1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
4 */
5
6#include <linux/module.h>
7#include <linux/memblock.h>
8#include <linux/mm.h>
9#include <linux/pfn.h>
10#include <asm/page.h>
11#include <asm/sections.h>
12#include <as-layout.h>
13#include <init.h>
14#include <kern.h>
15#include <mem_user.h>
16#include <os.h>
17
18static int physmem_fd = -1;
19
20/* Changed during early boot */
21unsigned long high_physmem;
22EXPORT_SYMBOL(high_physmem);
23
24extern unsigned long long physmem_size;
25
26void __init mem_total_pages(unsigned long physmem, unsigned long iomem,
27		     unsigned long highmem)
28{
29	unsigned long phys_pages, highmem_pages;
30	unsigned long iomem_pages, total_pages;
31
32	phys_pages    = physmem >> PAGE_SHIFT;
33	iomem_pages   = iomem   >> PAGE_SHIFT;
34	highmem_pages = highmem >> PAGE_SHIFT;
35
36	total_pages   = phys_pages + iomem_pages + highmem_pages;
37
38	max_mapnr = total_pages;
39}
40
41void map_memory(unsigned long virt, unsigned long phys, unsigned long len,
42		int r, int w, int x)
43{
44	__u64 offset;
45	int fd, err;
46
47	fd = phys_mapping(phys, &offset);
48	err = os_map_memory((void *) virt, fd, offset, len, r, w, x);
49	if (err) {
50		if (err == -ENOMEM)
51			printk(KERN_ERR "try increasing the host's "
52			       "/proc/sys/vm/max_map_count to <physical "
53			       "memory size>/4096\n");
54		panic("map_memory(0x%lx, %d, 0x%llx, %ld, %d, %d, %d) failed, "
55		      "err = %d\n", virt, fd, offset, len, r, w, x, err);
56	}
57}
58
59/**
60 * setup_physmem() - Setup physical memory for UML
61 * @start:	Start address of the physical kernel memory,
62 *		i.e start address of the executable image.
63 * @reserve_end:	end address of the physical kernel memory.
64 * @len:	Length of total physical memory that should be mapped/made
65 *		available, in bytes.
66 * @highmem:	Number of highmem bytes that should be mapped/made available.
67 *
68 * Creates an unlinked temporary file of size (len + highmem) and memory maps
69 * it on the last executable image address (uml_reserved).
70 *
71 * The offset is needed as the length of the total physical memory
72 * (len + highmem) includes the size of the memory used be the executable image,
73 * but the mapped-to address is the last address of the executable image
74 * (uml_reserved == end address of executable image).
75 *
76 * The memory mapped memory of the temporary file is used as backing memory
77 * of all user space processes/kernel tasks.
78 */
79void __init setup_physmem(unsigned long start, unsigned long reserve_end,
80			  unsigned long len, unsigned long long highmem)
81{
82	unsigned long reserve = reserve_end - start;
83	long map_size = len - reserve;
84	int err;
85
86	if(map_size <= 0) {
87		os_warn("Too few physical memory! Needed=%lu, given=%lu\n",
88			reserve, len);
89		exit(1);
90	}
91
92	physmem_fd = create_mem_file(len + highmem);
93
94	err = os_map_memory((void *) reserve_end, physmem_fd, reserve,
95			    map_size, 1, 1, 1);
96	if (err < 0) {
97		os_warn("setup_physmem - mapping %ld bytes of memory at 0x%p "
98			"failed - errno = %d\n", map_size,
99			(void *) reserve_end, err);
100		exit(1);
101	}
102
103	/*
104	 * Special kludge - This page will be mapped in to userspace processes
105	 * from physmem_fd, so it needs to be written out there.
106	 */
107	os_seek_file(physmem_fd, __pa(__syscall_stub_start));
108	os_write_file(physmem_fd, __syscall_stub_start, PAGE_SIZE);
109	os_fsync_file(physmem_fd);
110
111	memblock_add(__pa(start), len + highmem);
112	memblock_reserve(__pa(start), reserve);
113
114	min_low_pfn = PFN_UP(__pa(reserve_end));
115	max_low_pfn = min_low_pfn + (map_size >> PAGE_SHIFT);
116}
117
118int phys_mapping(unsigned long phys, unsigned long long *offset_out)
119{
120	int fd = -1;
121
122	if (phys < physmem_size) {
123		fd = physmem_fd;
124		*offset_out = phys;
125	}
126	else if (phys < __pa(end_iomem)) {
127		struct iomem_region *region = iomem_regions;
128
129		while (region != NULL) {
130			if ((phys >= region->phys) &&
131			    (phys < region->phys + region->size)) {
132				fd = region->fd;
133				*offset_out = phys - region->phys;
134				break;
135			}
136			region = region->next;
137		}
138	}
139	else if (phys < __pa(end_iomem) + highmem) {
140		fd = physmem_fd;
141		*offset_out = phys - iomem_size;
142	}
143
144	return fd;
145}
146EXPORT_SYMBOL(phys_mapping);
147
148static int __init uml_mem_setup(char *line, int *add)
149{
150	char *retptr;
151	physmem_size = memparse(line,&retptr);
152	return 0;
153}
154__uml_setup("mem=", uml_mem_setup,
155"mem=<Amount of desired ram>\n"
156"    This controls how much \"physical\" memory the kernel allocates\n"
157"    for the system. The size is specified as a number followed by\n"
158"    one of 'k', 'K', 'm', 'M', which have the obvious meanings.\n"
159"    This is not related to the amount of memory in the host.  It can\n"
160"    be more, and the excess, if it's ever used, will just be swapped out.\n"
161"	Example: mem=64M\n\n"
162);
163
164extern int __init parse_iomem(char *str, int *add);
165
166__uml_setup("iomem=", parse_iomem,
167"iomem=<name>,<file>\n"
168"    Configure <file> as an IO memory region named <name>.\n\n"
169);
170
171/*
172 * This list is constructed in parse_iomem and addresses filled in
173 * setup_iomem, both of which run during early boot.  Afterwards, it's
174 * unchanged.
175 */
176struct iomem_region *iomem_regions;
177
178/* Initialized in parse_iomem and unchanged thereafter */
179int iomem_size;
180
181unsigned long find_iomem(char *driver, unsigned long *len_out)
182{
183	struct iomem_region *region = iomem_regions;
184
185	while (region != NULL) {
186		if (!strcmp(region->driver, driver)) {
187			*len_out = region->size;
188			return region->virt;
189		}
190
191		region = region->next;
192	}
193
194	return 0;
195}
196EXPORT_SYMBOL(find_iomem);
197
198static int setup_iomem(void)
199{
200	struct iomem_region *region = iomem_regions;
201	unsigned long iomem_start = high_physmem + PAGE_SIZE;
202	int err;
203
204	while (region != NULL) {
205		err = os_map_memory((void *) iomem_start, region->fd, 0,
206				    region->size, 1, 1, 0);
207		if (err)
208			printk(KERN_ERR "Mapping iomem region for driver '%s' "
209			       "failed, errno = %d\n", region->driver, -err);
210		else {
211			region->virt = iomem_start;
212			region->phys = __pa(region->virt);
213		}
214
215		iomem_start += region->size + PAGE_SIZE;
216		region = region->next;
217	}
218
219	return 0;
220}
221
222__initcall(setup_iomem);
223