← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to arch/x86/kernel/e820.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/x86/kernel/e820.c
 
1
/*
 
2
 * Handle the memory map.
 
3
 * The functions here do the job until bootmem takes over.
 
4
 *
 
5
 *  Getting sanitize_e820_map() in sync with i386 version by applying change:
 
6
 *  -  Provisions for empty E820 memory regions (reported by certain BIOSes).
 
7
 *     Alex Achenbach <xela@slit.de>, December 2002.
 
8
 *  Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
 
9
 *
 
10
 */
 
11
#include <linux/kernel.h>
 
12
#include <linux/types.h>
 
13
#include <linux/init.h>
 
14
#include <linux/crash_dump.h>
 
15
#include <linux/export.h>
 
16
#include <linux/bootmem.h>
 
17
#include <linux/pfn.h>
 
18
#include <linux/suspend.h>
 
19
#include <linux/acpi.h>
 
20
#include <linux/firmware-map.h>
 
21
#include <linux/memblock.h>
 
22
 
 
23
#include <asm/e820.h>
 
24
#include <asm/proto.h>
 
25
#include <asm/setup.h>
 
26
 
 
27
/*
 
28
 * The e820 map is the map that gets modified e.g. with command line parameters
 
29
 * and that is also registered with modifications in the kernel resource tree
 
30
 * with the iomem_resource as parent.
 
31
 *
 
32
 * The e820_saved is directly saved after the BIOS-provided memory map is
 
33
 * copied. It doesn't get modified afterwards. It's registered for the
 
34
 * /sys/firmware/memmap interface.
 
35
 *
 
36
 * That memory map is not modified and is used as base for kexec. The kexec'd
 
37
 * kernel should get the same memory map as the firmware provides. Then the
 
38
 * user can e.g. boot the original kernel with mem=1G while still booting the
 
39
 * next kernel with full memory.
 
40
 */
 
41
struct e820map e820;
 
42
struct e820map e820_saved;
 
43
 
 
44
/* For PCI or other memory-mapped resources */
 
45
unsigned long pci_mem_start = 0xaeedbabe;
 
46
#ifdef CONFIG_PCI
 
47
EXPORT_SYMBOL(pci_mem_start);
 
48
#endif
 
49
 
 
50
/*
 
51
 * This function checks if any part of the range <start,end> is mapped
 
52
 * with type.
 
53
 */
 
54
int
 
55
e820_any_mapped(u64 start, u64 end, unsigned type)
 
56
{
 
57
        int i;
 
58
 
 
59
        for (i = 0; i < e820.nr_map; i++) {
 
60
                struct e820entry *ei = &e820.map[i];
 
61
 
 
62
                if (type && ei->type != type)
 
63
                        continue;
 
64
                if (ei->addr >= end || ei->addr + ei->size <= start)
 
65
                        continue;
 
66
                return 1;
 
67
        }
 
68
        return 0;
 
69
}
 
70
EXPORT_SYMBOL_GPL(e820_any_mapped);
 
71
 
 
72
/*
 
73
 * This function checks if the entire range <start,end> is mapped with type.
 
74
 *
 
75
 * Note: this function only works correct if the e820 table is sorted and
 
76
 * not-overlapping, which is the case
 
77
 */
 
78
int __init e820_all_mapped(u64 start, u64 end, unsigned type)
 
79
{
 
80
        int i;
 
81
 
 
82
        for (i = 0; i < e820.nr_map; i++) {
 
83
                struct e820entry *ei = &e820.map[i];
 
84
 
 
85
                if (type && ei->type != type)
 
86
                        continue;
 
87
                /* is the region (part) in overlap with the current region ?*/
 
88
                if (ei->addr >= end || ei->addr + ei->size <= start)
 
89
                        continue;
 
90
 
 
91
                /* if the region is at the beginning of <start,end> we move
 
92
                 * start to the end of the region since it's ok until there
 
93
                 */
 
94
                if (ei->addr <= start)
 
95
                        start = ei->addr + ei->size;
 
96
                /*
 
97
                 * if start is now at or beyond end, we're done, full
 
98
                 * coverage
 
99
                 */
 
100
                if (start >= end)
 
101
                        return 1;
 
102
        }
 
103
        return 0;
 
104
}
 
105
 
 
106
/*
 
107
 * Add a memory region to the kernel e820 map.
 
108
 */
 
109
static void __init __e820_add_region(struct e820map *e820x, u64 start, u64 size,
 
110
                                         int type)
 
111
{
 
112
        int x = e820x->nr_map;
 
113
 
 
114
        if (x >= ARRAY_SIZE(e820x->map)) {
 
115
                printk(KERN_ERR "Ooops! Too many entries in the memory map!\n");
 
116
                return;
 
117
        }
 
118
 
 
119
        e820x->map[x].addr = start;
 
120
        e820x->map[x].size = size;
 
121
        e820x->map[x].type = type;
 
122
        e820x->nr_map++;
 
123
}
 
124
 
 
125
void __init e820_add_region(u64 start, u64 size, int type)
 
126
{
 
127
        __e820_add_region(&e820, start, size, type);
 
128
}
 
129
 
 
130
static void __init e820_print_type(u32 type)
 
131
{
 
132
        switch (type) {
 
133
        case E820_RAM:
 
134
        case E820_RESERVED_KERN:
 
135
                printk(KERN_CONT "(usable)");
 
136
                break;
 
137
        case E820_RESERVED:
 
138
                printk(KERN_CONT "(reserved)");
 
139
                break;
 
140
        case E820_ACPI:
 
141
                printk(KERN_CONT "(ACPI data)");
 
142
                break;
 
143
        case E820_NVS:
 
144
                printk(KERN_CONT "(ACPI NVS)");
 
145
                break;
 
146
        case E820_UNUSABLE:
 
147
                printk(KERN_CONT "(unusable)");
 
148
                break;
 
149
        default:
 
150
                printk(KERN_CONT "type %u", type);
 
151
                break;
 
152
        }
 
153
}
 
154
 
 
155
void __init e820_print_map(char *who)
 
156
{
 
157
        int i;
 
158
 
 
159
        for (i = 0; i < e820.nr_map; i++) {
 
160
                printk(KERN_INFO " %s: %016Lx - %016Lx ", who,
 
161
                       (unsigned long long) e820.map[i].addr,
 
162
                       (unsigned long long)
 
163
                       (e820.map[i].addr + e820.map[i].size));
 
164
                e820_print_type(e820.map[i].type);
 
165
                printk(KERN_CONT "\n");
 
166
        }
 
167
}
 
168
 
 
169
/*
 
170
 * Sanitize the BIOS e820 map.
 
171
 *
 
172
 * Some e820 responses include overlapping entries. The following
 
173
 * replaces the original e820 map with a new one, removing overlaps,
 
174
 * and resolving conflicting memory types in favor of highest
 
175
 * numbered type.
 
176
 *
 
177
 * The input parameter biosmap points to an array of 'struct
 
178
 * e820entry' which on entry has elements in the range [0, *pnr_map)
 
179
 * valid, and which has space for up to max_nr_map entries.
 
180
 * On return, the resulting sanitized e820 map entries will be in
 
181
 * overwritten in the same location, starting at biosmap.
 
182
 *
 
183
 * The integer pointed to by pnr_map must be valid on entry (the
 
184
 * current number of valid entries located at biosmap) and will
 
185
 * be updated on return, with the new number of valid entries
 
186
 * (something no more than max_nr_map.)
 
187
 *
 
188
 * The return value from sanitize_e820_map() is zero if it
 
189
 * successfully 'sanitized' the map entries passed in, and is -1
 
190
 * if it did nothing, which can happen if either of (1) it was
 
191
 * only passed one map entry, or (2) any of the input map entries
 
192
 * were invalid (start + size < start, meaning that the size was
 
193
 * so big the described memory range wrapped around through zero.)
 
194
 *
 
195
 *      Visually we're performing the following
 
196
 *      (1,2,3,4 = memory types)...
 
197
 *
 
198
 *      Sample memory map (w/overlaps):
 
199
 *         ____22__________________
 
200
 *         ______________________4_
 
201
 *         ____1111________________
 
202
 *         _44_____________________
 
203
 *         11111111________________
 
204
 *         ____________________33__
 
205
 *         ___________44___________
 
206
 *         __________33333_________
 
207
 *         ______________22________
 
208
 *         ___________________2222_
 
209
 *         _________111111111______
 
210
 *         _____________________11_
 
211
 *         _________________4______
 
212
 *
 
213
 *      Sanitized equivalent (no overlap):
 
214
 *         1_______________________
 
215
 *         _44_____________________
 
216
 *         ___1____________________
 
217
 *         ____22__________________
 
218
 *         ______11________________
 
219
 *         _________1______________
 
220
 *         __________3_____________
 
221
 *         ___________44___________
 
222
 *         _____________33_________
 
223
 *         _______________2________
 
224
 *         ________________1_______
 
225
 *         _________________4______
 
226
 *         ___________________2____
 
227
 *         ____________________33__
 
228
 *         ______________________4_
 
229
 */
 
230
 
 
231
int __init sanitize_e820_map(struct e820entry *biosmap, int max_nr_map,
 
232
                             u32 *pnr_map)
 
233
{
 
234
        struct change_member {
 
235
                struct e820entry *pbios; /* pointer to original bios entry */
 
236
                unsigned long long addr; /* address for this change point */
 
237
        };
 
238
        static struct change_member change_point_list[2*E820_X_MAX] __initdata;
 
239
        static struct change_member *change_point[2*E820_X_MAX] __initdata;
 
240
        static struct e820entry *overlap_list[E820_X_MAX] __initdata;
 
241
        static struct e820entry new_bios[E820_X_MAX] __initdata;
 
242
        struct change_member *change_tmp;
 
243
        unsigned long current_type, last_type;
 
244
        unsigned long long last_addr;
 
245
        int chgidx, still_changing;
 
246
        int overlap_entries;
 
247
        int new_bios_entry;
 
248
        int old_nr, new_nr, chg_nr;
 
249
        int i;
 
250
 
 
251
        /* if there's only one memory region, don't bother */
 
252
        if (*pnr_map < 2)
 
253
                return -1;
 
254
 
 
255
        old_nr = *pnr_map;
 
256
        BUG_ON(old_nr > max_nr_map);
 
257
 
 
258
        /* bail out if we find any unreasonable addresses in bios map */
 
259
        for (i = 0; i < old_nr; i++)
 
260
                if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr)
 
261
                        return -1;
 
262
 
 
263
        /* create pointers for initial change-point information (for sorting) */
 
264
        for (i = 0; i < 2 * old_nr; i++)
 
265
                change_point[i] = &change_point_list[i];
 
266
 
 
267
        /* record all known change-points (starting and ending addresses),
 
268
           omitting those that are for empty memory regions */
 
269
        chgidx = 0;
 
270
        for (i = 0; i < old_nr; i++)    {
 
271
                if (biosmap[i].size != 0) {
 
272
                        change_point[chgidx]->addr = biosmap[i].addr;
 
273
                        change_point[chgidx++]->pbios = &biosmap[i];
 
274
                        change_point[chgidx]->addr = biosmap[i].addr +
 
275
                                biosmap[i].size;
 
276
                        change_point[chgidx++]->pbios = &biosmap[i];
 
277
                }
 
278
        }
 
279
        chg_nr = chgidx;
 
280
 
 
281
        /* sort change-point list by memory addresses (low -> high) */
 
282
        still_changing = 1;
 
283
        while (still_changing)  {
 
284
                still_changing = 0;
 
285
                for (i = 1; i < chg_nr; i++)  {
 
286
                        unsigned long long curaddr, lastaddr;
 
287
                        unsigned long long curpbaddr, lastpbaddr;
 
288
 
 
289
                        curaddr = change_point[i]->addr;
 
290
                        lastaddr = change_point[i - 1]->addr;
 
291
                        curpbaddr = change_point[i]->pbios->addr;
 
292
                        lastpbaddr = change_point[i - 1]->pbios->addr;
 
293
 
 
294
                        /*
 
295
                         * swap entries, when:
 
296
                         *
 
297
                         * curaddr > lastaddr or
 
298
                         * curaddr == lastaddr and curaddr == curpbaddr and
 
299
                         * lastaddr != lastpbaddr
 
300
                         */
 
301
                        if (curaddr < lastaddr ||
 
302
                            (curaddr == lastaddr && curaddr == curpbaddr &&
 
303
                             lastaddr != lastpbaddr)) {
 
304
                                change_tmp = change_point[i];
 
305
                                change_point[i] = change_point[i-1];
 
306
                                change_point[i-1] = change_tmp;
 
307
                                still_changing = 1;
 
308
                        }
 
309
                }
 
310
        }
 
311
 
 
312
        /* create a new bios memory map, removing overlaps */
 
313
        overlap_entries = 0;     /* number of entries in the overlap table */
 
314
        new_bios_entry = 0;      /* index for creating new bios map entries */
 
315
        last_type = 0;           /* start with undefined memory type */
 
316
        last_addr = 0;           /* start with 0 as last starting address */
 
317
 
 
318
        /* loop through change-points, determining affect on the new bios map */
 
319
        for (chgidx = 0; chgidx < chg_nr; chgidx++) {
 
320
                /* keep track of all overlapping bios entries */
 
321
                if (change_point[chgidx]->addr ==
 
322
                    change_point[chgidx]->pbios->addr) {
 
323
                        /*
 
324
                         * add map entry to overlap list (> 1 entry
 
325
                         * implies an overlap)
 
326
                         */
 
327
                        overlap_list[overlap_entries++] =
 
328
                                change_point[chgidx]->pbios;
 
329
                } else {
 
330
                        /*
 
331
                         * remove entry from list (order independent,
 
332
                         * so swap with last)
 
333
                         */
 
334
                        for (i = 0; i < overlap_entries; i++) {
 
335
                                if (overlap_list[i] ==
 
336
                                    change_point[chgidx]->pbios)
 
337
                                        overlap_list[i] =
 
338
                                                overlap_list[overlap_entries-1];
 
339
                        }
 
340
                        overlap_entries--;
 
341
                }
 
342
                /*
 
343
                 * if there are overlapping entries, decide which
 
344
                 * "type" to use (larger value takes precedence --
 
345
                 * 1=usable, 2,3,4,4+=unusable)
 
346
                 */
 
347
                current_type = 0;
 
348
                for (i = 0; i < overlap_entries; i++)
 
349
                        if (overlap_list[i]->type > current_type)
 
350
                                current_type = overlap_list[i]->type;
 
351
                /*
 
352
                 * continue building up new bios map based on this
 
353
                 * information
 
354
                 */
 
355
                if (current_type != last_type)  {
 
356
                        if (last_type != 0)      {
 
357
                                new_bios[new_bios_entry].size =
 
358
                                        change_point[chgidx]->addr - last_addr;
 
359
                                /*
 
360
                                 * move forward only if the new size
 
361
                                 * was non-zero
 
362
                                 */
 
363
                                if (new_bios[new_bios_entry].size != 0)
 
364
                                        /*
 
365
                                         * no more space left for new
 
366
                                         * bios entries ?
 
367
                                         */
 
368
                                        if (++new_bios_entry >= max_nr_map)
 
369
                                                break;
 
370
                        }
 
371
                        if (current_type != 0)  {
 
372
                                new_bios[new_bios_entry].addr =
 
373
                                        change_point[chgidx]->addr;
 
374
                                new_bios[new_bios_entry].type = current_type;
 
375
                                last_addr = change_point[chgidx]->addr;
 
376
                        }
 
377
                        last_type = current_type;
 
378
                }
 
379
        }
 
380
        /* retain count for new bios entries */
 
381
        new_nr = new_bios_entry;
 
382
 
 
383
        /* copy new bios mapping into original location */
 
384
        memcpy(biosmap, new_bios, new_nr * sizeof(struct e820entry));
 
385
        *pnr_map = new_nr;
 
386
 
 
387
        return 0;
 
388
}
 
389
 
 
390
static int __init __append_e820_map(struct e820entry *biosmap, int nr_map)
 
391
{
 
392
        while (nr_map) {
 
393
                u64 start = biosmap->addr;
 
394
                u64 size = biosmap->size;
 
395
                u64 end = start + size;
 
396
                u32 type = biosmap->type;
 
397
 
 
398
                /* Overflow in 64 bits? Ignore the memory map. */
 
399
                if (start > end)
 
400
                        return -1;
 
401
 
 
402
                e820_add_region(start, size, type);
 
403
 
 
404
                biosmap++;
 
405
                nr_map--;
 
406
        }
 
407
        return 0;
 
408
}
 
409
 
 
410
/*
 
411
 * Copy the BIOS e820 map into a safe place.
 
412
 *
 
413
 * Sanity-check it while we're at it..
 
414
 *
 
415
 * If we're lucky and live on a modern system, the setup code
 
416
 * will have given us a memory map that we can use to properly
 
417
 * set up memory.  If we aren't, we'll fake a memory map.
 
418
 */
 
419
static int __init append_e820_map(struct e820entry *biosmap, int nr_map)
 
420
{
 
421
        /* Only one memory region (or negative)? Ignore it */
 
422
        if (nr_map < 2)
 
423
                return -1;
 
424
 
 
425
        return __append_e820_map(biosmap, nr_map);
 
426
}
 
427
 
 
428
static u64 __init __e820_update_range(struct e820map *e820x, u64 start,
 
429
                                        u64 size, unsigned old_type,
 
430
                                        unsigned new_type)
 
431
{
 
432
        u64 end;
 
433
        unsigned int i;
 
434
        u64 real_updated_size = 0;
 
435
 
 
436
        BUG_ON(old_type == new_type);
 
437
 
 
438
        if (size > (ULLONG_MAX - start))
 
439
                size = ULLONG_MAX - start;
 
440
 
 
441
        end = start + size;
 
442
        printk(KERN_DEBUG "e820 update range: %016Lx - %016Lx ",
 
443
                       (unsigned long long) start,
 
444
                       (unsigned long long) end);
 
445
        e820_print_type(old_type);
 
446
        printk(KERN_CONT " ==> ");
 
447
        e820_print_type(new_type);
 
448
        printk(KERN_CONT "\n");
 
449
 
 
450
        for (i = 0; i < e820x->nr_map; i++) {
 
451
                struct e820entry *ei = &e820x->map[i];
 
452
                u64 final_start, final_end;
 
453
                u64 ei_end;
 
454
 
 
455
                if (ei->type != old_type)
 
456
                        continue;
 
457
 
 
458
                ei_end = ei->addr + ei->size;
 
459
                /* totally covered by new range? */
 
460
                if (ei->addr >= start && ei_end <= end) {
 
461
                        ei->type = new_type;
 
462
                        real_updated_size += ei->size;
 
463
                        continue;
 
464
                }
 
465
 
 
466
                /* new range is totally covered? */
 
467
                if (ei->addr < start && ei_end > end) {
 
468
                        __e820_add_region(e820x, start, size, new_type);
 
469
                        __e820_add_region(e820x, end, ei_end - end, ei->type);
 
470
                        ei->size = start - ei->addr;
 
471
                        real_updated_size += size;
 
472
                        continue;
 
473
                }
 
474
 
 
475
                /* partially covered */
 
476
                final_start = max(start, ei->addr);
 
477
                final_end = min(end, ei_end);
 
478
                if (final_start >= final_end)
 
479
                        continue;
 
480
 
 
481
                __e820_add_region(e820x, final_start, final_end - final_start,
 
482
                                  new_type);
 
483
 
 
484
                real_updated_size += final_end - final_start;
 
485
 
 
486
                /*
 
487
                 * left range could be head or tail, so need to update
 
488
                 * size at first.
 
489
                 */
 
490
                ei->size -= final_end - final_start;
 
491
                if (ei->addr < final_start)
 
492
                        continue;
 
493
                ei->addr = final_end;
 
494
        }
 
495
        return real_updated_size;
 
496
}
 
497
 
 
498
u64 __init e820_update_range(u64 start, u64 size, unsigned old_type,
 
499
                             unsigned new_type)
 
500
{
 
501
        return __e820_update_range(&e820, start, size, old_type, new_type);
 
502
}
 
503
 
 
504
static u64 __init e820_update_range_saved(u64 start, u64 size,
 
505
                                          unsigned old_type, unsigned new_type)
 
506
{
 
507
        return __e820_update_range(&e820_saved, start, size, old_type,
 
508
                                     new_type);
 
509
}
 
510
 
 
511
/* make e820 not cover the range */
 
512
u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type,
 
513
                             int checktype)
 
514
{
 
515
        int i;
 
516
        u64 end;
 
517
        u64 real_removed_size = 0;
 
518
 
 
519
        if (size > (ULLONG_MAX - start))
 
520
                size = ULLONG_MAX - start;
 
521
 
 
522
        end = start + size;
 
523
        printk(KERN_DEBUG "e820 remove range: %016Lx - %016Lx ",
 
524
                       (unsigned long long) start,
 
525
                       (unsigned long long) end);
 
526
        if (checktype)
 
527
                e820_print_type(old_type);
 
528
        printk(KERN_CONT "\n");
 
529
 
 
530
        for (i = 0; i < e820.nr_map; i++) {
 
531
                struct e820entry *ei = &e820.map[i];
 
532
                u64 final_start, final_end;
 
533
                u64 ei_end;
 
534
 
 
535
                if (checktype && ei->type != old_type)
 
536
                        continue;
 
537
 
 
538
                ei_end = ei->addr + ei->size;
 
539
                /* totally covered? */
 
540
                if (ei->addr >= start && ei_end <= end) {
 
541
                        real_removed_size += ei->size;
 
542
                        memset(ei, 0, sizeof(struct e820entry));
 
543
                        continue;
 
544
                }
 
545
 
 
546
                /* new range is totally covered? */
 
547
                if (ei->addr < start && ei_end > end) {
 
548
                        e820_add_region(end, ei_end - end, ei->type);
 
549
                        ei->size = start - ei->addr;
 
550
                        real_removed_size += size;
 
551
                        continue;
 
552
                }
 
553
 
 
554
                /* partially covered */
 
555
                final_start = max(start, ei->addr);
 
556
                final_end = min(end, ei_end);
 
557
                if (final_start >= final_end)
 
558
                        continue;
 
559
                real_removed_size += final_end - final_start;
 
560
 
 
561
                /*
 
562
                 * left range could be head or tail, so need to update
 
563
                 * size at first.
 
564
                 */
 
565
                ei->size -= final_end - final_start;
 
566
                if (ei->addr < final_start)
 
567
                        continue;
 
568
                ei->addr = final_end;
 
569
        }
 
570
        return real_removed_size;
 
571
}
 
572
 
 
573
void __init update_e820(void)
 
574
{
 
575
        u32 nr_map;
 
576
 
 
577
        nr_map = e820.nr_map;
 
578
        if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &nr_map))
 
579
                return;
 
580
        e820.nr_map = nr_map;
 
581
        printk(KERN_INFO "modified physical RAM map:\n");
 
582
        e820_print_map("modified");
 
583
}
 
584
static void __init update_e820_saved(void)
 
585
{
 
586
        u32 nr_map;
 
587
 
 
588
        nr_map = e820_saved.nr_map;
 
589
        if (sanitize_e820_map(e820_saved.map, ARRAY_SIZE(e820_saved.map), &nr_map))
 
590
                return;
 
591
        e820_saved.nr_map = nr_map;
 
592
}
 
593
#define MAX_GAP_END 0x100000000ull
 
594
/*
 
595
 * Search for a gap in the e820 memory space from start_addr to end_addr.
 
596
 */
 
597
__init int e820_search_gap(unsigned long *gapstart, unsigned long *gapsize,
 
598
                unsigned long start_addr, unsigned long long end_addr)
 
599
{
 
600
        unsigned long long last;
 
601
        int i = e820.nr_map;
 
602
        int found = 0;
 
603
 
 
604
        last = (end_addr && end_addr < MAX_GAP_END) ? end_addr : MAX_GAP_END;
 
605
 
 
606
        while (--i >= 0) {
 
607
                unsigned long long start = e820.map[i].addr;
 
608
                unsigned long long end = start + e820.map[i].size;
 
609
 
 
610
                if (end < start_addr)
 
611
                        continue;
 
612
 
 
613
                /*
 
614
                 * Since "last" is at most 4GB, we know we'll
 
615
                 * fit in 32 bits if this condition is true
 
616
                 */
 
617
                if (last > end) {
 
618
                        unsigned long gap = last - end;
 
619
 
 
620
                        if (gap >= *gapsize) {
 
621
                                *gapsize = gap;
 
622
                                *gapstart = end;
 
623
                                found = 1;
 
624
                        }
 
625
                }
 
626
                if (start < last)
 
627
                        last = start;
 
628
        }
 
629
        return found;
 
630
}
 
631
 
 
632
/*
 
633
 * Search for the biggest gap in the low 32 bits of the e820
 
634
 * memory space.  We pass this space to PCI to assign MMIO resources
 
635
 * for hotplug or unconfigured devices in.
 
636
 * Hopefully the BIOS let enough space left.
 
637
 */
 
638
__init void e820_setup_gap(void)
 
639
{
 
640
        unsigned long gapstart, gapsize;
 
641
        int found;
 
642
 
 
643
        gapstart = 0x10000000;
 
644
        gapsize = 0x400000;
 
645
        found  = e820_search_gap(&gapstart, &gapsize, 0, MAX_GAP_END);
 
646
 
 
647
#ifdef CONFIG_X86_64
 
648
        if (!found) {
 
649
                gapstart = (max_pfn << PAGE_SHIFT) + 1024*1024;
 
650
                printk(KERN_ERR
 
651
        "PCI: Warning: Cannot find a gap in the 32bit address range\n"
 
652
        "PCI: Unassigned devices with 32bit resource registers may break!\n");
 
653
        }
 
654
#endif
 
655
 
 
656
        /*
 
657
         * e820_reserve_resources_late protect stolen RAM already
 
658
         */
 
659
        pci_mem_start = gapstart;
 
660
 
 
661
        printk(KERN_INFO
 
662
               "Allocating PCI resources starting at %lx (gap: %lx:%lx)\n",
 
663
               pci_mem_start, gapstart, gapsize);
 
664
}
 
665
 
 
666
/**
 
667
 * Because of the size limitation of struct boot_params, only first
 
668
 * 128 E820 memory entries are passed to kernel via
 
669
 * boot_params.e820_map, others are passed via SETUP_E820_EXT node of
 
670
 * linked list of struct setup_data, which is parsed here.
 
671
 */
 
672
void __init parse_e820_ext(struct setup_data *sdata)
 
673
{
 
674
        int entries;
 
675
        struct e820entry *extmap;
 
676
 
 
677
        entries = sdata->len / sizeof(struct e820entry);
 
678
        extmap = (struct e820entry *)(sdata->data);
 
679
        __append_e820_map(extmap, entries);
 
680
        sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
 
681
        printk(KERN_INFO "extended physical RAM map:\n");
 
682
        e820_print_map("extended");
 
683
}
 
684
 
 
685
#if defined(CONFIG_X86_64) || \
 
686
        (defined(CONFIG_X86_32) && defined(CONFIG_HIBERNATION))
 
687
/**
 
688
 * Find the ranges of physical addresses that do not correspond to
 
689
 * e820 RAM areas and mark the corresponding pages as nosave for
 
690
 * hibernation (32 bit) or software suspend and suspend to RAM (64 bit).
 
691
 *
 
692
 * This function requires the e820 map to be sorted and without any
 
693
 * overlapping entries and assumes the first e820 area to be RAM.
 
694
 */
 
695
void __init e820_mark_nosave_regions(unsigned long limit_pfn)
 
696
{
 
697
        int i;
 
698
        unsigned long pfn;
 
699
 
 
700
        pfn = PFN_DOWN(e820.map[0].addr + e820.map[0].size);
 
701
        for (i = 1; i < e820.nr_map; i++) {
 
702
                struct e820entry *ei = &e820.map[i];
 
703
 
 
704
                if (pfn < PFN_UP(ei->addr))
 
705
                        register_nosave_region(pfn, PFN_UP(ei->addr));
 
706
 
 
707
                pfn = PFN_DOWN(ei->addr + ei->size);
 
708
                if (ei->type != E820_RAM && ei->type != E820_RESERVED_KERN)
 
709
                        register_nosave_region(PFN_UP(ei->addr), pfn);
 
710
 
 
711
                if (pfn >= limit_pfn)
 
712
                        break;
 
713
        }
 
714
}
 
715
#endif
 
716
 
 
717
#ifdef CONFIG_HIBERNATION
 
718
/**
 
719
 * Mark ACPI NVS memory region, so that we can save/restore it during
 
720
 * hibernation and the subsequent resume.
 
721
 */
 
722
static int __init e820_mark_nvs_memory(void)
 
723
{
 
724
        int i;
 
725
 
 
726
        for (i = 0; i < e820.nr_map; i++) {
 
727
                struct e820entry *ei = &e820.map[i];
 
728
 
 
729
                if (ei->type == E820_NVS)
 
730
                        suspend_nvs_register(ei->addr, ei->size);
 
731
        }
 
732
 
 
733
        return 0;
 
734
}
 
735
core_initcall(e820_mark_nvs_memory);
 
736
#endif
 
737
 
 
738
/*
 
739
 * pre allocated 4k and reserved it in memblock and e820_saved
 
740
 */
 
741
u64 __init early_reserve_e820(u64 startt, u64 sizet, u64 align)
 
742
{
 
743
        u64 size = 0;
 
744
        u64 addr;
 
745
        u64 start;
 
746
 
 
747
        for (start = startt; ; start += size) {
 
748
                start = memblock_x86_find_in_range_size(start, &size, align);
 
749
                if (start == MEMBLOCK_ERROR)
 
750
                        return 0;
 
751
                if (size >= sizet)
 
752
                        break;
 
753
        }
 
754
 
 
755
#ifdef CONFIG_X86_32
 
756
        if (start >= MAXMEM)
 
757
                return 0;
 
758
        if (start + size > MAXMEM)
 
759
                size = MAXMEM - start;
 
760
#endif
 
761
 
 
762
        addr = round_down(start + size - sizet, align);
 
763
        if (addr < start)
 
764
                return 0;
 
765
        memblock_x86_reserve_range(addr, addr + sizet, "new next");
 
766
        e820_update_range_saved(addr, sizet, E820_RAM, E820_RESERVED);
 
767
        printk(KERN_INFO "update e820_saved for early_reserve_e820\n");
 
768
        update_e820_saved();
 
769
 
 
770
        return addr;
 
771
}
 
772
 
 
773
#ifdef CONFIG_X86_32
 
774
# ifdef CONFIG_X86_PAE
 
775
#  define MAX_ARCH_PFN          (1ULL<<(36-PAGE_SHIFT))
 
776
# else
 
777
#  define MAX_ARCH_PFN          (1ULL<<(32-PAGE_SHIFT))
 
778
# endif
 
779
#else /* CONFIG_X86_32 */
 
780
# define MAX_ARCH_PFN MAXMEM>>PAGE_SHIFT
 
781
#endif
 
782
 
 
783
/*
 
784
 * Find the highest page frame number we have available
 
785
 */
 
786
static unsigned long __init e820_end_pfn(unsigned long limit_pfn, unsigned type)
 
787
{
 
788
        int i;
 
789
        unsigned long last_pfn = 0;
 
790
        unsigned long max_arch_pfn = MAX_ARCH_PFN;
 
791
 
 
792
        for (i = 0; i < e820.nr_map; i++) {
 
793
                struct e820entry *ei = &e820.map[i];
 
794
                unsigned long start_pfn;
 
795
                unsigned long end_pfn;
 
796
 
 
797
                if (ei->type != type)
 
798
                        continue;
 
799
 
 
800
                start_pfn = ei->addr >> PAGE_SHIFT;
 
801
                end_pfn = (ei->addr + ei->size) >> PAGE_SHIFT;
 
802
 
 
803
                if (start_pfn >= limit_pfn)
 
804
                        continue;
 
805
                if (end_pfn > limit_pfn) {
 
806
                        last_pfn = limit_pfn;
 
807
                        break;
 
808
                }
 
809
                if (end_pfn > last_pfn)
 
810
                        last_pfn = end_pfn;
 
811
        }
 
812
 
 
813
        if (last_pfn > max_arch_pfn)
 
814
                last_pfn = max_arch_pfn;
 
815
 
 
816
        printk(KERN_INFO "last_pfn = %#lx max_arch_pfn = %#lx\n",
 
817
                         last_pfn, max_arch_pfn);
 
818
        return last_pfn;
 
819
}
 
820
unsigned long __init e820_end_of_ram_pfn(void)
 
821
{
 
822
        return e820_end_pfn(MAX_ARCH_PFN, E820_RAM);
 
823
}
 
824
 
 
825
unsigned long __init e820_end_of_low_ram_pfn(void)
 
826
{
 
827
        return e820_end_pfn(1UL<<(32 - PAGE_SHIFT), E820_RAM);
 
828
}
 
829
 
 
830
static void early_panic(char *msg)
 
831
{
 
832
        early_printk(msg);
 
833
        panic(msg);
 
834
}
 
835
 
 
836
static int userdef __initdata;
 
837
 
 
838
/* "mem=nopentium" disables the 4MB page tables. */
 
839
static int __init parse_memopt(char *p)
 
840
{
 
841
        u64 mem_size;
 
842
 
 
843
        if (!p)
 
844
                return -EINVAL;
 
845
 
 
846
        if (!strcmp(p, "nopentium")) {
 
847
#ifdef CONFIG_X86_32
 
848
                setup_clear_cpu_cap(X86_FEATURE_PSE);
 
849
                return 0;
 
850
#else
 
851
                printk(KERN_WARNING "mem=nopentium ignored! (only supported on x86_32)\n");
 
852
                return -EINVAL;
 
853
#endif
 
854
        }
 
855
 
 
856
        userdef = 1;
 
857
        mem_size = memparse(p, &p);
 
858
        /* don't remove all of memory when handling "mem={invalid}" param */
 
859
        if (mem_size == 0)
 
860
                return -EINVAL;
 
861
        e820_remove_range(mem_size, ULLONG_MAX - mem_size, E820_RAM, 1);
 
862
 
 
863
        return 0;
 
864
}
 
865
early_param("mem", parse_memopt);
 
866
 
 
867
static int __init parse_memmap_opt(char *p)
 
868
{
 
869
        char *oldp;
 
870
        u64 start_at, mem_size;
 
871
 
 
872
        if (!p)
 
873
                return -EINVAL;
 
874
 
 
875
        if (!strncmp(p, "exactmap", 8)) {
 
876
#ifdef CONFIG_CRASH_DUMP
 
877
                /*
 
878
                 * If we are doing a crash dump, we still need to know
 
879
                 * the real mem size before original memory map is
 
880
                 * reset.
 
881
                 */
 
882
                saved_max_pfn = e820_end_of_ram_pfn();
 
883
#endif
 
884
                e820.nr_map = 0;
 
885
                userdef = 1;
 
886
                return 0;
 
887
        }
 
888
 
 
889
        oldp = p;
 
890
        mem_size = memparse(p, &p);
 
891
        if (p == oldp)
 
892
                return -EINVAL;
 
893
 
 
894
        userdef = 1;
 
895
        if (*p == '@') {
 
896
                start_at = memparse(p+1, &p);
 
897
                e820_add_region(start_at, mem_size, E820_RAM);
 
898
        } else if (*p == '#') {
 
899
                start_at = memparse(p+1, &p);
 
900
                e820_add_region(start_at, mem_size, E820_ACPI);
 
901
        } else if (*p == '$') {
 
902
                start_at = memparse(p+1, &p);
 
903
                e820_add_region(start_at, mem_size, E820_RESERVED);
 
904
        } else
 
905
                e820_remove_range(mem_size, ULLONG_MAX - mem_size, E820_RAM, 1);
 
906
 
 
907
        return *p == '\0' ? 0 : -EINVAL;
 
908
}
 
909
early_param("memmap", parse_memmap_opt);
 
910
 
 
911
void __init finish_e820_parsing(void)
 
912
{
 
913
        if (userdef) {
 
914
                u32 nr = e820.nr_map;
 
915
 
 
916
                if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &nr) < 0)
 
917
                        early_panic("Invalid user supplied memory map");
 
918
                e820.nr_map = nr;
 
919
 
 
920
                printk(KERN_INFO "user-defined physical RAM map:\n");
 
921
                e820_print_map("user");
 
922
        }
 
923
}
 
924
 
 
925
static inline const char *e820_type_to_string(int e820_type)
 
926
{
 
927
        switch (e820_type) {
 
928
        case E820_RESERVED_KERN:
 
929
        case E820_RAM:  return "System RAM";
 
930
        case E820_ACPI: return "ACPI Tables";
 
931
        case E820_NVS:  return "ACPI Non-volatile Storage";
 
932
        case E820_UNUSABLE:     return "Unusable memory";
 
933
        default:        return "reserved";
 
934
        }
 
935
}
 
936
 
 
937
/*
 
938
 * Mark e820 reserved areas as busy for the resource manager.
 
939
 */
 
940
static struct resource __initdata *e820_res;
 
941
void __init e820_reserve_resources(void)
 
942
{
 
943
        int i;
 
944
        struct resource *res;
 
945
        u64 end;
 
946
 
 
947
        res = alloc_bootmem(sizeof(struct resource) * e820.nr_map);
 
948
        e820_res = res;
 
949
        for (i = 0; i < e820.nr_map; i++) {
 
950
                end = e820.map[i].addr + e820.map[i].size - 1;
 
951
                if (end != (resource_size_t)end) {
 
952
                        res++;
 
953
                        continue;
 
954
                }
 
955
                res->name = e820_type_to_string(e820.map[i].type);
 
956
                res->start = e820.map[i].addr;
 
957
                res->end = end;
 
958
 
 
959
                res->flags = IORESOURCE_MEM;
 
960
 
 
961
                /*
 
962
                 * don't register the region that could be conflicted with
 
963
                 * pci device BAR resource and insert them later in
 
964
                 * pcibios_resource_survey()
 
965
                 */
 
966
                if (e820.map[i].type != E820_RESERVED || res->start < (1ULL<<20)) {
 
967
                        res->flags |= IORESOURCE_BUSY;
 
968
                        insert_resource(&iomem_resource, res);
 
969
                }
 
970
                res++;
 
971
        }
 
972
 
 
973
        for (i = 0; i < e820_saved.nr_map; i++) {
 
974
                struct e820entry *entry = &e820_saved.map[i];
 
975
                firmware_map_add_early(entry->addr,
 
976
                        entry->addr + entry->size - 1,
 
977
                        e820_type_to_string(entry->type));
 
978
        }
 
979
}
 
980
 
 
981
/* How much should we pad RAM ending depending on where it is? */
 
982
static unsigned long ram_alignment(resource_size_t pos)
 
983
{
 
984
        unsigned long mb = pos >> 20;
 
985
 
 
986
        /* To 64kB in the first megabyte */
 
987
        if (!mb)
 
988
                return 64*1024;
 
989
 
 
990
        /* To 1MB in the first 16MB */
 
991
        if (mb < 16)
 
992
                return 1024*1024;
 
993
 
 
994
        /* To 64MB for anything above that */
 
995
        return 64*1024*1024;
 
996
}
 
997
 
 
998
#define MAX_RESOURCE_SIZE ((resource_size_t)-1)
 
999
 
 
1000
void __init e820_reserve_resources_late(void)
 
1001
{
 
1002
        int i;
 
1003
        struct resource *res;
 
1004
 
 
1005
        res = e820_res;
 
1006
        for (i = 0; i < e820.nr_map; i++) {
 
1007
                if (!res->parent && res->end)
 
1008
                        insert_resource_expand_to_fit(&iomem_resource, res);
 
1009
                res++;
 
1010
        }
 
1011
 
 
1012
        /*
 
1013
         * Try to bump up RAM regions to reasonable boundaries to
 
1014
         * avoid stolen RAM:
 
1015
         */
 
1016
        for (i = 0; i < e820.nr_map; i++) {
 
1017
                struct e820entry *entry = &e820.map[i];
 
1018
                u64 start, end;
 
1019
 
 
1020
                if (entry->type != E820_RAM)
 
1021
                        continue;
 
1022
                start = entry->addr + entry->size;
 
1023
                end = round_up(start, ram_alignment(start)) - 1;
 
1024
                if (end > MAX_RESOURCE_SIZE)
 
1025
                        end = MAX_RESOURCE_SIZE;
 
1026
                if (start >= end)
 
1027
                        continue;
 
1028
                printk(KERN_DEBUG "reserve RAM buffer: %016llx - %016llx ",
 
1029
                               start, end);
 
1030
                reserve_region_with_split(&iomem_resource, start, end,
 
1031
                                          "RAM buffer");
 
1032
        }
 
1033
}
 
1034
 
 
1035
char *__init default_machine_specific_memory_setup(void)
 
1036
{
 
1037
        char *who = "BIOS-e820";
 
1038
        u32 new_nr;
 
1039
        /*
 
1040
         * Try to copy the BIOS-supplied E820-map.
 
1041
         *
 
1042
         * Otherwise fake a memory map; one section from 0k->640k,
 
1043
         * the next section from 1mb->appropriate_mem_k
 
1044
         */
 
1045
        new_nr = boot_params.e820_entries;
 
1046
        sanitize_e820_map(boot_params.e820_map,
 
1047
                        ARRAY_SIZE(boot_params.e820_map),
 
1048
                        &new_nr);
 
1049
        boot_params.e820_entries = new_nr;
 
1050
        if (append_e820_map(boot_params.e820_map, boot_params.e820_entries)
 
1051
          < 0) {
 
1052
                u64 mem_size;
 
1053
 
 
1054
                /* compare results from other methods and take the greater */
 
1055
                if (boot_params.alt_mem_k
 
1056
                    < boot_params.screen_info.ext_mem_k) {
 
1057
                        mem_size = boot_params.screen_info.ext_mem_k;
 
1058
                        who = "BIOS-88";
 
1059
                } else {
 
1060
                        mem_size = boot_params.alt_mem_k;
 
1061
                        who = "BIOS-e801";
 
1062
                }
 
1063
 
 
1064
                e820.nr_map = 0;
 
1065
                e820_add_region(0, LOWMEMSIZE(), E820_RAM);
 
1066
                e820_add_region(HIGH_MEMORY, mem_size << 10, E820_RAM);
 
1067
        }
 
1068
 
 
1069
        /* In case someone cares... */
 
1070
        return who;
 
1071
}
 
1072
 
 
1073
void __init setup_memory_map(void)
 
1074
{
 
1075
        char *who;
 
1076
 
 
1077
        who = x86_init.resources.memory_setup();
 
1078
        memcpy(&e820_saved, &e820, sizeof(struct e820map));
 
1079
        printk(KERN_INFO "BIOS-provided physical RAM map:\n");
 
1080
        e820_print_map(who);
 
1081
}
 
1082
 
 
1083
void __init memblock_x86_fill(void)
 
1084
{
 
1085
        int i;
 
1086
        u64 end;
 
1087
 
 
1088
        /*
 
1089
         * EFI may have more than 128 entries
 
1090
         * We are safe to enable resizing, beause memblock_x86_fill()
 
1091
         * is rather later for x86
 
1092
         */
 
1093
        memblock_can_resize = 1;
 
1094
 
 
1095
        for (i = 0; i < e820.nr_map; i++) {
 
1096
                struct e820entry *ei = &e820.map[i];
 
1097
 
 
1098
                end = ei->addr + ei->size;
 
1099
                if (end != (resource_size_t)end)
 
1100
                        continue;
 
1101
 
 
1102
                if (ei->type != E820_RAM && ei->type != E820_RESERVED_KERN)
 
1103
                        continue;
 
1104
 
 
1105
                memblock_add(ei->addr, ei->size);
 
1106
        }
 
1107
 
 
1108
        memblock_analyze();
 
1109
        memblock_dump_all();
 
1110
}
 
1111
 
 
1112
void __init memblock_find_dma_reserve(void)
 
1113
{
 
1114
#ifdef CONFIG_X86_64
 
1115
        u64 free_size_pfn;
 
1116
        u64 mem_size_pfn;
 
1117
        /*
 
1118
         * need to find out used area below MAX_DMA_PFN
 
1119
         * need to use memblock to get free size in [0, MAX_DMA_PFN]
 
1120
         * at first, and assume boot_mem will not take below MAX_DMA_PFN
 
1121
         */
 
1122
        mem_size_pfn = memblock_x86_memory_in_range(0, MAX_DMA_PFN << PAGE_SHIFT) >> PAGE_SHIFT;
 
1123
        free_size_pfn = memblock_x86_free_memory_in_range(0, MAX_DMA_PFN << PAGE_SHIFT) >> PAGE_SHIFT;
 
1124
        set_dma_reserve(mem_size_pfn - free_size_pfn);
 
1125
#endif
 
1126
}