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