1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include <linux/bootmem.h>
18#include <linux/efi.h>
19#include <linux/memblock.h>
20#include <linux/mm.h>
21#include <linux/nmi.h>
22#include <linux/swap.h>
23
24#include <asm/meminit.h>
25#include <asm/pgalloc.h>
26#include <asm/pgtable.h>
27#include <asm/sections.h>
28#include <asm/mca.h>
29
30#ifdef CONFIG_VIRTUAL_MEM_MAP
31static unsigned long max_gap;
32#endif
33
34
35unsigned long bootmap_start;
36
37
38
39
40
41
42
43
44
45
46static int __init
47find_bootmap_location (u64 start, u64 end, void *arg)
48{
49 u64 needed = *(unsigned long *)arg;
50 u64 range_start, range_end, free_start;
51 int i;
52
53#if IGNORE_PFN0
54 if (start == PAGE_OFFSET) {
55 start += PAGE_SIZE;
56 if (start >= end)
57 return 0;
58 }
59#endif
60
61 free_start = PAGE_OFFSET;
62
63 for (i = 0; i < num_rsvd_regions; i++) {
64 range_start = max(start, free_start);
65 range_end = min(end, rsvd_region[i].start & PAGE_MASK);
66
67 free_start = PAGE_ALIGN(rsvd_region[i].end);
68
69 if (range_end <= range_start)
70 continue;
71
72 if (range_end - range_start >= needed) {
73 bootmap_start = __pa(range_start);
74 return -1;
75 }
76
77
78 if (range_end == end)
79 return 0;
80 }
81 return 0;
82}
83
84#ifdef CONFIG_SMP
85static void *cpu_data;
86
87
88
89
90
91void *per_cpu_init(void)
92{
93 static bool first_time = true;
94 void *cpu0_data = __cpu0_per_cpu;
95 unsigned int cpu;
96
97 if (!first_time)
98 goto skip;
99 first_time = false;
100
101
102
103
104
105
106 for_each_possible_cpu(cpu) {
107 void *src = cpu == 0 ? cpu0_data : __phys_per_cpu_start;
108
109 memcpy(cpu_data, src, __per_cpu_end - __per_cpu_start);
110 __per_cpu_offset[cpu] = (char *)cpu_data - __per_cpu_start;
111 per_cpu(local_per_cpu_offset, cpu) = __per_cpu_offset[cpu];
112
113
114
115
116
117
118
119
120
121
122 if (cpu == 0)
123 ia64_set_kr(IA64_KR_PER_CPU_DATA, __pa(cpu_data) -
124 (unsigned long)__per_cpu_start);
125
126 cpu_data += PERCPU_PAGE_SIZE;
127 }
128skip:
129 return __per_cpu_start + __per_cpu_offset[smp_processor_id()];
130}
131
132static inline void
133alloc_per_cpu_data(void)
134{
135 cpu_data = __alloc_bootmem(PERCPU_PAGE_SIZE * num_possible_cpus(),
136 PERCPU_PAGE_SIZE, __pa(MAX_DMA_ADDRESS));
137}
138
139
140
141
142
143
144
145
146
147void __init
148setup_per_cpu_areas(void)
149{
150 struct pcpu_alloc_info *ai;
151 struct pcpu_group_info *gi;
152 unsigned int cpu;
153 ssize_t static_size, reserved_size, dyn_size;
154 int rc;
155
156 ai = pcpu_alloc_alloc_info(1, num_possible_cpus());
157 if (!ai)
158 panic("failed to allocate pcpu_alloc_info");
159 gi = &ai->groups[0];
160
161
162 for_each_possible_cpu(cpu)
163 gi->cpu_map[gi->nr_units++] = cpu;
164
165
166 static_size = __per_cpu_end - __per_cpu_start;
167 reserved_size = PERCPU_MODULE_RESERVE;
168 dyn_size = PERCPU_PAGE_SIZE - static_size - reserved_size;
169 if (dyn_size < 0)
170 panic("percpu area overflow static=%zd reserved=%zd\n",
171 static_size, reserved_size);
172
173 ai->static_size = static_size;
174 ai->reserved_size = reserved_size;
175 ai->dyn_size = dyn_size;
176 ai->unit_size = PERCPU_PAGE_SIZE;
177 ai->atom_size = PAGE_SIZE;
178 ai->alloc_size = PERCPU_PAGE_SIZE;
179
180 rc = pcpu_setup_first_chunk(ai, __per_cpu_start + __per_cpu_offset[0]);
181 if (rc)
182 panic("failed to setup percpu area (err=%d)", rc);
183
184 pcpu_free_alloc_info(ai);
185}
186#else
187#define alloc_per_cpu_data() do { } while (0)
188#endif
189
190
191
192
193
194
195
196void __init
197find_memory (void)
198{
199 unsigned long bootmap_size;
200
201 reserve_memory();
202
203
204 min_low_pfn = ~0UL;
205 max_low_pfn = 0;
206 efi_memmap_walk(find_max_min_low_pfn, NULL);
207 max_pfn = max_low_pfn;
208
209 bootmap_size = bootmem_bootmap_pages(max_pfn) << PAGE_SHIFT;
210
211
212 bootmap_start = ~0UL;
213 efi_memmap_walk(find_bootmap_location, &bootmap_size);
214 if (bootmap_start == ~0UL)
215 panic("Cannot find %ld bytes for bootmap\n", bootmap_size);
216
217 bootmap_size = init_bootmem_node(NODE_DATA(0),
218 (bootmap_start >> PAGE_SHIFT), 0, max_pfn);
219
220
221 efi_memmap_walk(filter_rsvd_memory, free_bootmem);
222 reserve_bootmem(bootmap_start, bootmap_size, BOOTMEM_DEFAULT);
223
224 find_initrd();
225
226 alloc_per_cpu_data();
227}
228
229
230
231
232
233void __init
234paging_init (void)
235{
236 unsigned long max_dma;
237 unsigned long max_zone_pfns[MAX_NR_ZONES];
238
239 memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
240#ifdef CONFIG_ZONE_DMA
241 max_dma = virt_to_phys((void *) MAX_DMA_ADDRESS) >> PAGE_SHIFT;
242 max_zone_pfns[ZONE_DMA] = max_dma;
243#endif
244 max_zone_pfns[ZONE_NORMAL] = max_low_pfn;
245
246#ifdef CONFIG_VIRTUAL_MEM_MAP
247 efi_memmap_walk(filter_memory, register_active_ranges);
248 efi_memmap_walk(find_largest_hole, (u64 *)&max_gap);
249 if (max_gap < LARGE_GAP) {
250 vmem_map = (struct page *) 0;
251 free_area_init_nodes(max_zone_pfns);
252 } else {
253 unsigned long map_size;
254
255
256
257 map_size = PAGE_ALIGN(ALIGN(max_low_pfn, MAX_ORDER_NR_PAGES) *
258 sizeof(struct page));
259 VMALLOC_END -= map_size;
260 vmem_map = (struct page *) VMALLOC_END;
261 efi_memmap_walk(create_mem_map_page_table, NULL);
262
263
264
265
266
267 NODE_DATA(0)->node_mem_map = vmem_map +
268 find_min_pfn_with_active_regions();
269 free_area_init_nodes(max_zone_pfns);
270
271 printk("Virtual mem_map starts at 0x%p\n", mem_map);
272 }
273#else
274 memblock_add_node(0, PFN_PHYS(max_low_pfn), 0);
275 free_area_init_nodes(max_zone_pfns);
276#endif
277 zero_page_memmap_ptr = virt_to_page(ia64_imva(empty_zero_page));
278}
279