开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
e820.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：15k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

e820.c：源码内容
  1. /* 
  2.  * Handle the memory map.
  3.  * The functions here do the job until bootmem takes over.
  4.  * $Id: e820.c,v 1.4 2002/09/19 19:25:32 ak Exp $
  5.  */
  6. #include <linux/config.h>
  7. #include <linux/kernel.h>
  8. #include <linux/types.h>
  9. #include <linux/init.h>
  10. #include <linux/bootmem.h>
  11. #include <linux/ioport.h>
  12. #include <asm/page.h>
  13. #include <asm/e820.h>
  14. #include <asm/proto.h>
  15. #include <asm/bootsetup.h>
  17. extern unsigned long table_start, table_end;
  18. extern char _end[];
  20. extern struct resource code_resource, data_resource, vram_resource;
  22. /* Check for some hardcoded bad areas that early boot is not allowed to touch */ 
  23. static inline int bad_addr(unsigned long *addrp, unsigned long size)
  24. { 
  25. unsigned long addr = *addrp, last = addr + size; 
  27. /* various gunk below that needed for SMP startup */
  28. if (addr < 7*PAGE_SIZE) { 
  29. *addrp = 7*PAGE_SIZE; 
  30. return 1; 
  31. }
  32. /* direct mapping tables of the kernel */
  33. if (last >= table_start<<PAGE_SHIFT && addr < table_end<<PAGE_SHIFT) { 
  34. *addrp = table_end << PAGE_SHIFT; 
  35. return 1;
  36. } 
  37. /* initrd */ 
  38. #ifdef CONFIG_BLK_DEV_INITRD
  39. if (LOADER_TYPE && INITRD_START && last >= INITRD_START && 
  40.     addr < INITRD_START+INITRD_SIZE) { 
  41. *addrp = INITRD_START + INITRD_SIZE; 
  42. return 1;
  43. } 
  44. #endif
  45. /* kernel code + 640k memory hole (later should not be needed, but 
  46.    be paranoid for now) */
  47. if (last >= 640*1024 && addr < __pa_symbol(&_end)) { 
  48. *addrp = __pa_symbol(&_end);
  49. return 1;
  50. }
  51. /* XXX ramdisk image here? */ 
  52. return 0;
  53. } 
  55. int __init e820_mapped(unsigned long start, unsigned long end, int type) 
  56. { 
  57. int i;
  58. for (i = 0; i < e820.nr_map; i++) { 
  59. struct e820entry *ei = &e820.map[i]; 
  60. if (type && ei->type != type) 
  61. continue;
  62. if (ei->addr >= end || ei->addr + ei->size < start) 
  63. continue; 
  64. return 1; 
  65. } 
  66. return 0;
  67. }
  69. /* 
  70.  * Find a free area in a specific range. 
  71.  */ 
  72. unsigned long __init find_e820_area(unsigned long start, unsigned long end, unsigned size) 
  73. { 
  74. int i; 
  75. for (i = 0; i < e820.nr_map; i++) { 
  76. struct e820entry *ei = &e820.map[i]; 
  77. unsigned long addr = ei->addr, last; 
  78. if (ei->type != E820_RAM) 
  79. continue; 
  80. if (addr < start) 
  81. addr = start;
  82. if (addr > ei->addr + ei->size) 
  83. continue; 
  84. while (bad_addr(&addr, size) && addr+size < ei->addr + ei->size)
  85. ;
  86. last = addr + size;
  87. if (last > ei->addr + ei->size)
  88. continue;
  89. if (last > end) 
  90. continue;
  91. return addr; 
  92. } 
  93. return -1UL;
  94. } 
  96. /* 
  97.  * Free bootmem based on the e820 table for a node.
  98.  */
  99. void __init e820_bootmem_free(pg_data_t *pgdat, unsigned long start,unsigned long end)
  100. {
  101. int i;
  102. for (i = 0; i < e820.nr_map; i++) {
  103. struct e820entry *ei = &e820.map[i]; 
  104. unsigned long last, addr;
  106. if (ei->type != E820_RAM || 
  107.     ei->addr+ei->size <= start || 
  108.     ei->addr > end)
  109. continue;
  111. addr = round_up(ei->addr, PAGE_SIZE);
  112. if (addr < start) 
  113. addr = start;
  115. last = round_down(ei->addr + ei->size, PAGE_SIZE); 
  116. if (last >= end)
  117. last = end; 
  119. if (last > addr && last-addr >= PAGE_SIZE)
  120. free_bootmem_node(pgdat, addr, last-addr);
  121. }
  122. }
  124. /*
  125.  * Find the highest page frame number we have available
  126.  */
  127. void __init e820_end_of_ram(void)
  128. {
  129. int i;
  130. end_pfn = 0;
  131. for (i = 0; i < e820.nr_map; i++) {
  132. struct e820entry *ei = &e820.map[i]; 
  133. unsigned long start, end;
  135. /* count all types of areas for now to map ACPI easily */
  136. start = round_up(ei->addr, PAGE_SIZE); 
  137. end = round_down(ei->addr + ei->size, PAGE_SIZE); 
  138. if (start >= end)
  139. continue;
  140. if (end > end_pfn<<PAGE_SHIFT)
  141. end_pfn = end>>PAGE_SHIFT;
  142. }
  144. if (end_pfn > MAXMEM >> PAGE_SHIFT)
  145. end_pfn = MAXMEM >> PAGE_SHIFT;
  146. }
  148. /* 
  149.  * Mark e820 reserved areas as busy for the resource manager.
  150.  */
  151. void __init e820_reserve_resources(void)
  152. {
  153. int i;
  154. for (i = 0; i < e820.nr_map; i++) {
  155. struct resource *res;
  156. if (e820.map[i].addr + e820.map[i].size > 0x100000000ULL)
  157. continue;
  158. res = alloc_bootmem_low(sizeof(struct resource));
  159. switch (e820.map[i].type) {
  160. case E820_RAM: res->name = "System RAM"; break;
  161. case E820_ACPI: res->name = "ACPI Tables"; break;
  162. case E820_NVS: res->name = "ACPI Non-volatile Storage"; break;
  163. default: res->name = "reserved";
  164. }
  165. res->start = e820.map[i].addr;
  166. res->end = res->start + e820.map[i].size - 1;
  167. res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
  168. request_resource(&iomem_resource, res);
  169. if (e820.map[i].type == E820_RAM) {
  170. /*
  171.  *  We dont't know which RAM region contains kernel data,
  172.  *  so we try it repeatedly and let the resource manager
  173.  *  test it.
  174.  */
  175. request_resource(res, &code_resource);
  176. request_resource(res, &data_resource);
  177. }
  178. }
  179. }
  181. /* 
  182.  * Add a memory region to the kernel e820 map.
  183.  */ 
  184. void __init add_memory_region(unsigned long start, unsigned long size, int type)
  185. {
  186. int x = e820.nr_map;
  188. if (x == E820MAX) {
  189. printk(KERN_ERR "Ooops! Too many entries in the memory map!n");
  190. return;
  191. }
  193. e820.map[x].addr = start;
  194. e820.map[x].size = size;
  195. e820.map[x].type = type;
  196. e820.nr_map++;
  197. }
  199. void __init e820_print_map(char *who)
  200. {
  201. int i;
  203. for (i = 0; i < e820.nr_map; i++) {
  204. printk(" %s: %016Lx - %016Lx ", who,
  205. (unsigned long long) e820.map[i].addr,
  206. (unsigned long long) (e820.map[i].addr + e820.map[i].size));
  207. switch (e820.map[i].type) {
  208. case E820_RAM: printk("(usable)n");
  209. break;
  210. case E820_RESERVED:
  211. printk("(reserved)n");
  212. break;
  213. case E820_ACPI:
  214. printk("(ACPI data)n");
  215. break;
  216. case E820_NVS:
  217. printk("(ACPI NVS)n");
  218. break;
  219. default: printk("type %un", e820.map[i].type);
  220. break;
  221. }
  222. }
  223. }
  225. /*
  226.  * Sanitize the BIOS e820 map.
  227.  *
  228.  * Some e820 responses include overlapping entries.  The following 
  229.  * replaces the original e820 map with a new one, removing overlaps.
  230.  *
  231.  */
  232. static int __init sanitize_e820_map(struct e820entry * biosmap, char * 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*E820MAX] __initdata;
  239. static struct change_member *change_point[2*E820MAX] __initdata;
  240. static struct e820entry *overlap_list[E820MAX] __initdata;
  241. static struct e820entry new_bios[E820MAX] __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;
  249. int i;
  251. /*
  252. Visually we're performing the following (1,2,3,4 = memory types)...
  254. Sample memory map (w/overlaps):
  255.    ____22__________________
  256.    ______________________4_
  257.    ____1111________________
  258.    _44_____________________
  259.    11111111________________
  260.    ____________________33__
  261.    ___________44___________
  262.    __________33333_________
  263.    ______________22________
  264.    ___________________2222_
  265.    _________111111111______
  266.    _____________________11_
  267.    _________________4______
  269. Sanitized equivalent (no overlap):
  270.    1_______________________
  271.    _44_____________________
  272.    ___1____________________
  273.    ____22__________________
  274.    ______11________________
  275.    _________1______________
  276.    __________3_____________
  277.    ___________44___________
  278.    _____________33_________
  279.    _______________2________
  280.    ________________1_______
  281.    _________________4______
  282.    ___________________2____
  283.    ____________________33__
  284.    ______________________4_
  285. */
  287. /* if there's only one memory region, don't bother */
  288. if (*pnr_map < 2)
  289. return -1;
  291. old_nr = *pnr_map;
  293. /* bail out if we find any unreasonable addresses in bios map */
  294. for (i=0; i<old_nr; i++)
  295. if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr)
  296. return -1;
  298. /* create pointers for initial change-point information (for sorting) */
  299. for (i=0; i < 2*old_nr; i++)
  300. change_point[i] = &change_point_list[i];
  302. /* record all known change-points (starting and ending addresses) */
  303. chgidx = 0;
  304. for (i=0; i < old_nr; i++) {
  305. change_point[chgidx]->addr = biosmap[i].addr;
  306. change_point[chgidx++]->pbios = &biosmap[i];
  307. change_point[chgidx]->addr = biosmap[i].addr + biosmap[i].size;
  308. change_point[chgidx++]->pbios = &biosmap[i];
  309. }
  311. /* sort change-point list by memory addresses (low -> high) */
  312. still_changing = 1;
  313. while (still_changing) {
  314. still_changing = 0;
  315. for (i=1; i < 2*old_nr; i++)  {
  316. /* if <current_addr> > <last_addr>, swap */
  317. /* or, if current=<start_addr> & last=<end_addr>, swap */
  318. if ((change_point[i]->addr < change_point[i-1]->addr) ||
  319. ((change_point[i]->addr == change_point[i-1]->addr) &&
  320.  (change_point[i]->addr == change_point[i]->pbios->addr) &&
  321.  (change_point[i-1]->addr != change_point[i-1]->pbios->addr))
  322.    )
  323. {
  324. change_tmp = change_point[i];
  325. change_point[i] = change_point[i-1];
  326. change_point[i-1] = change_tmp;
  327. still_changing=1;
  328. }
  329. }
  330. }
  332. /* create a new bios memory map, removing overlaps */
  333. overlap_entries=0;  /* number of entries in the overlap table */
  334. new_bios_entry=0;  /* index for creating new bios map entries */
  335. last_type = 0;  /* start with undefined memory type */
  336. last_addr = 0;  /* start with 0 as last starting address */
  337. /* loop through change-points, determining affect on the new bios map */
  338. for (chgidx=0; chgidx < 2*old_nr; chgidx++)
  339. {
  340. /* keep track of all overlapping bios entries */
  341. if (change_point[chgidx]->addr == change_point[chgidx]->pbios->addr)
  342. {
  343. /* add map entry to overlap list (> 1 entry implies an overlap) */
  344. overlap_list[overlap_entries++]=change_point[chgidx]->pbios;
  345. }
  346. else
  347. {
  348. /* remove entry from list (order independent, so swap with last) */
  349. for (i=0; i<overlap_entries; i++)
  350. {
  351. if (overlap_list[i] == change_point[chgidx]->pbios)
  352. overlap_list[i] = overlap_list[overlap_entries-1];
  353. }
  354. overlap_entries--;
  355. }
  356. /* if there are overlapping entries, decide which "type" to use */
  357. /* (larger value takes precedence -- 1=usable, 2,3,4,4+=unusable) */
  358. current_type = 0;
  359. for (i=0; i<overlap_entries; i++)
  360. if (overlap_list[i]->type > current_type)
  361. current_type = overlap_list[i]->type;
  362. /* continue building up new bios map based on this information */
  363. if (current_type != last_type) {
  364. if (last_type != 0)  {
  365. new_bios[new_bios_entry].size =
  366. change_point[chgidx]->addr - last_addr;
  367. /* move forward only if the new size was non-zero */
  368. if (new_bios[new_bios_entry].size != 0)
  369. if (++new_bios_entry >= E820MAX)
  370. break;  /* no more space left for new bios entries */
  371. }
  372. if (current_type != 0) {
  373. new_bios[new_bios_entry].addr = 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. new_nr = new_bios_entry;   /* retain count for new bios entries */
  382. /* copy new bios mapping into original location */
  383. memcpy(biosmap, new_bios, new_nr*sizeof(struct e820entry));
  384. *pnr_map = new_nr;
  386. return 0;
  387. }
  389. /*
  390.  * Copy the BIOS e820 map into a safe place.
  391.  *
  392.  * Sanity-check it while we're at it..
  393.  *
  394.  * If we're lucky and live on a modern system, the setup code
  395.  * will have given us a memory map that we can use to properly
  396.  * set up memory.  If we aren't, we'll fake a memory map.
  397.  *
  398.  * We check to see that the memory map contains at least 2 elements
  399.  * before we'll use it, because the detection code in setup.S may
  400.  * not be perfect and most every PC known to man has two memory
  401.  * regions: one from 0 to 640k, and one from 1mb up.  (The IBM
  402.  * thinkpad 560x, for example, does not cooperate with the memory
  403.  * detection code.)
  404.  */
  405. static int __init copy_e820_map(struct e820entry * biosmap, int nr_map)
  406. {
  407. /* Only one memory region (or negative)? Ignore it */
  408. if (nr_map < 2)
  409. return -1;
  411. do {
  412. unsigned long start = biosmap->addr;
  413. unsigned long size = biosmap->size;
  414. unsigned long end = start + size;
  415. unsigned long type = biosmap->type;
  417. /* Overflow in 64 bits? Ignore the memory map. */
  418. if (start > end)
  419. return -1;
  421. /*
  422.  * Some BIOSes claim RAM in the 640k - 1M region.
  423.  * Not right. Fix it up.
  424.  * 
  425.  * This should be removed on Hammer which is supposed to not
  426.  * have non e820 covered ISA mappings there, but I had some strange
  427.  * problems so it stays for now.  -AK
  428.  */
  429. if (type == E820_RAM) {
  430. if (start < 0x100000ULL && end > 0xA0000ULL) {
  431. if (start < 0xA0000ULL)
  432. add_memory_region(start, 0xA0000ULL-start, type);
  433. if (end <= 0x100000ULL)
  434. continue;
  435. start = 0x100000ULL;
  436. size = end - start;
  437. }
  438. }
  440. add_memory_region(start, size, type);
  441. } while (biosmap++,--nr_map);
  442. return 0;
  443. }
  445. void __init setup_memory_region(void)
  446. {
  447. char *who = "BIOS-e820";
  449. /*
  450.  * Try to copy the BIOS-supplied E820-map.
  451.  *
  452.  * Otherwise fake a memory map; one section from 0k->640k,
  453.  * the next section from 1mb->appropriate_mem_k
  454.  */
  455. sanitize_e820_map(E820_MAP, &E820_MAP_NR);
  456. if (copy_e820_map(E820_MAP, E820_MAP_NR) < 0) {
  457. unsigned long mem_size;
  459. /* compare results from other methods and take the greater */
  460. if (ALT_MEM_K < EXT_MEM_K) {
  461. mem_size = EXT_MEM_K;
  462. who = "BIOS-88";
  463. } else {
  464. mem_size = ALT_MEM_K;
  465. who = "BIOS-e801";
  466. }
  468. e820.nr_map = 0;
  469. add_memory_region(0, LOWMEMSIZE(), E820_RAM);
  470. add_memory_region(HIGH_MEMORY, mem_size << 10, E820_RAM);
  471.    }
  472. printk(KERN_INFO "BIOS-provided physical RAM map:n");
  473. e820_print_map(who);
  474. }
  476. extern char command_line[], saved_command_line[];
  477. extern int fallback_aper_order;
  478. extern int iommu_setup(char *opt);
  480. void __init parse_mem_cmdline (char ** cmdline_p)
  481. {
  482. char c = ' ', *to = command_line, *from = COMMAND_LINE;
  483. int len = 0;
  484. int usermem = 0;
  486. /* Save unparsed command line copy for /proc/cmdline */
  487. memcpy(saved_command_line, COMMAND_LINE, COMMAND_LINE_SIZE);
  488. saved_command_line[COMMAND_LINE_SIZE-1] = '';
  490. for (;;) {
  491. if (c != ' ') 
  492. goto next;
  494. /*
  495.  * "mem=XXX[kKmM]" defines a memory region from HIGH_MEM
  496.  * to <mem>, overriding the bios size.
  497.  * "mem=XXX[KkmM]@XXX[KkmM]" defines a memory region from
  498.  * <start> to <start>+<mem>, overriding the bios size.
  499.  */
  500. if (!memcmp(from, "mem=", 4)) {
  501. if (to != command_line)
  502. to--;
  503. else if (!memcmp(from+4, "exactmap", 8)) {
  504. from += 8+4;
  505. e820.nr_map = 0;
  506. usermem = 1;
  507. } else {
  508. /* If the user specifies memory size, we
  509.  * blow away any automatically generated
  510.  * size
  511.  */
  512. unsigned long long start_at, mem_size;
  513.  
  514. if (usermem == 0) {
  515. /* first time in: zap the whitelist
  516.  * and reinitialize it with the
  517.  * standard low-memory region.
  518.  */
  519. e820.nr_map = 0;
  520. usermem = 1;
  521. add_memory_region(0, LOWMEMSIZE(), E820_RAM);
  522. }
  523. mem_size = memparse(from+4, &from);
  524. if (*from == '@')
  525. start_at = memparse(from+1, &from);
  526. else {
  527. start_at = HIGH_MEMORY;
  528. mem_size -= HIGH_MEMORY;
  529. usermem=0;
  530. }
  531. add_memory_region(start_at, mem_size, E820_RAM);
  532. }
  533. }
  534. #ifdef CONFIG_GART_IOMMU 
  535. else if (!memcmp(from,"iommu=",6)) { 
  536. iommu_setup(from+6); 
  537. } 
  539. #endif
  540. next:
  541. c = *(from++);
  542. if (!c)
  543. break;
  544. if (COMMAND_LINE_SIZE <= ++len)
  545. break;
  546. *(to++) = c;
  547. }
  548. *to = '';
  549. *cmdline_p = command_line;
  550. if (usermem) {
  551. printk(KERN_INFO "user-defined physical RAM map:n");
  552. e820_print_map("user");
  553. }
  554. }