mm.c 7.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298
  1. /* Physical memory manager: parse the E820 map and hand out 4 KB pages. */
  2. #include "mm.h"
  3. #include "bootinfo.h"
  4. #include "serial.h"
  5. #include "vga.h"
  6. /* One bit per 4 KB page; bit set = in use. */
  7. #define MM_BITMAP_BITS (MM_MAX_PHYS / PAGE_SIZE)
  8. #define MM_BITMAP_WORDS (MM_BITMAP_BITS / 32)
  9. static unsigned int bitmap[MM_BITMAP_WORDS];
  10. static unsigned int free_pages;
  11. static unsigned int total_ram_kb;
  12. /* ---- bitmap helpers ---- */
  13. static inline void bit_set(unsigned int idx)
  14. {
  15. bitmap[idx / 32] |= (1u << (idx % 32));
  16. }
  17. static inline void bit_clear(unsigned int idx)
  18. {
  19. bitmap[idx / 32] &= ~(1u << (idx % 32));
  20. }
  21. static inline int bit_test(unsigned int idx)
  22. {
  23. return (bitmap[idx / 32] >> (idx % 32)) & 1;
  24. }
  25. /* ---- interrupt flag save/restore (allocator is not IRQ-safe) ---- */
  26. static inline unsigned int irq_disable_save(void)
  27. {
  28. unsigned int flags;
  29. __asm__ volatile ("pushfl; popl %0; cli" : "=r"(flags));
  30. return flags;
  31. }
  32. static inline void irq_restore(unsigned int flags)
  33. {
  34. __asm__ volatile ("pushl %0; popfl" : : "r"(flags));
  35. }
  36. /* Mark a physical byte range [base, base+len) as used in the bitmap. */
  37. static void mark_used(unsigned long long base, unsigned long long len)
  38. {
  39. unsigned long long end = base + len;
  40. unsigned int p0, p1, p;
  41. if (base >= MM_MAX_PHYS)
  42. return;
  43. if (end > MM_MAX_PHYS)
  44. end = MM_MAX_PHYS;
  45. p0 = (unsigned int)(base >> 12);
  46. p1 = (unsigned int)((end + PAGE_SIZE - 1) >> 12);
  47. for (p = p0; p < p1; p++)
  48. bit_set(p);
  49. }
  50. /* Mark a physical byte range [base, base+len) as free (usable RAM). */
  51. static void mark_free(unsigned long long base, unsigned long long len)
  52. {
  53. unsigned long long end = base + len;
  54. unsigned int p0, p1, p;
  55. if (base >= MM_MAX_PHYS)
  56. return;
  57. if (end > MM_MAX_PHYS)
  58. end = MM_MAX_PHYS;
  59. p0 = (unsigned int)(base >> 12);
  60. p1 = (unsigned int)(end >> 12);
  61. for (p = p0; p < p1; p++)
  62. bit_clear(p);
  63. }
  64. /* Mark the whole bitmap as used, then walk the E820 map and free RAM. */
  65. void mm_init(void)
  66. {
  67. const struct e820_map *map = (const struct e820_map *)E820_MAP_ADDR;
  68. unsigned int i, n;
  69. /* Everything starts in-use. */
  70. for (i = 0; i < MM_BITMAP_WORDS; i++)
  71. bitmap[i] = 0xFFFFFFFFu;
  72. total_ram_kb = 0;
  73. if (map->magic == E820_MAGIC && map->count <= E820_MAX_ENTRIES) {
  74. n = map->count;
  75. for (i = 0; i < n; i++) {
  76. const struct e820_entry *e = &map->entry[i];
  77. if (e->type == E820_RAM && e->length != 0) {
  78. unsigned long long end = e->base + e->length;
  79. mark_free(e->base, e->length);
  80. if (end > MM_MAX_PHYS)
  81. end = MM_MAX_PHYS;
  82. if (end > e->base)
  83. total_ram_kb +=
  84. (unsigned int)((end - e->base) >> 10);
  85. }
  86. }
  87. } else {
  88. /* No E820 map (very old BIOS, or first kexec onto an old build):
  89. * assume 16 MB of RAM from 1 MB up. The process-stack fallback
  90. * pool keeps the system bootable if this guess is wrong. */
  91. mark_free(0x100000ULL, 0x1000000ULL - 0x100000ULL);
  92. total_ram_kb = (0x1000000ULL - 0x100000ULL) >> 10; /* 15 MB */
  93. }
  94. /* Re-reserve what the kernel already owns. */
  95. mark_used(0, MM_RESERVE_LOW);
  96. mark_used(MM_SHADOW_BASE, MM_SHADOW_RESERVE);
  97. /* The VBE LFB is normally high MMIO, but a BIOS may place it inside
  98. * low RAM. Never hand framebuffer pages to the allocator: the boot
  99. * console draws into the LFB, so an allocated page directory there
  100. * would be overwritten by its own progress line. */
  101. {
  102. const volatile struct vga_boot_fb_info *fb = VGA_BOOT_FB;
  103. unsigned int sz;
  104. __asm__ volatile ("" : "+r"(fb));
  105. sz = (unsigned int)fb->pitch * fb->height;
  106. if (!sz)
  107. sz = 0x1000000;
  108. if (fb->valid && fb->lfb_base && fb->lfb_base < MM_MAX_PHYS)
  109. mark_used(fb->lfb_base, sz);
  110. }
  111. /* The boot path copied the command-pack rootfs into high RAM before
  112. * the kernel ran. Keep it away from the allocator until ramfs_init()
  113. * has taken its own copy. */
  114. {
  115. unsigned int pa = bootinfo_pack_addr();
  116. unsigned int ps = bootinfo_pack_size();
  117. if (pa >= MM_RESERVE_LOW && pa < MM_MAX_PHYS && ps != 0 &&
  118. ps <= MM_MAX_PHYS && pa + ps > pa &&
  119. pa + ps <= MM_MAX_PHYS)
  120. mark_used(pa, ps);
  121. }
  122. /* Count free pages. */
  123. free_pages = 0;
  124. for (i = 0; i < MM_BITMAP_BITS; i++) {
  125. if (!bit_test(i))
  126. free_pages++;
  127. }
  128. }
  129. unsigned int mm_alloc_page(void)
  130. {
  131. unsigned int i, w;
  132. unsigned int flags = irq_disable_save();
  133. for (w = 0; w < MM_BITMAP_WORDS; w++) {
  134. if (bitmap[w] != 0xFFFFFFFFu) {
  135. unsigned int word = bitmap[w];
  136. for (i = 0; i < 32; i++) {
  137. if (!(word & (1u << i))) {
  138. unsigned int idx = w * 32 + i;
  139. bitmap[w] |= (1u << i);
  140. free_pages--;
  141. irq_restore(flags);
  142. return idx * PAGE_SIZE;
  143. }
  144. }
  145. }
  146. }
  147. irq_restore(flags);
  148. return 0;
  149. }
  150. unsigned int mm_alloc_pages(unsigned int n)
  151. {
  152. unsigned int start = 0, run = 0;
  153. unsigned int p;
  154. unsigned int flags;
  155. if (n == 0)
  156. return 0;
  157. flags = irq_disable_save();
  158. for (p = 0; p < MM_BITMAP_BITS; p++) {
  159. if (!bit_test(p)) {
  160. if (run == 0)
  161. start = p;
  162. run++;
  163. if (run == n) {
  164. unsigned int i;
  165. for (i = start; i < start + n; i++)
  166. bit_set(i);
  167. free_pages -= n;
  168. irq_restore(flags);
  169. return start * PAGE_SIZE;
  170. }
  171. } else {
  172. run = 0;
  173. }
  174. }
  175. irq_restore(flags);
  176. return 0;
  177. }
  178. void mm_free_page(unsigned int addr)
  179. {
  180. unsigned int idx = addr / PAGE_SIZE;
  181. unsigned int flags;
  182. if (addr == 0 || idx >= MM_BITMAP_BITS)
  183. return;
  184. flags = irq_disable_save();
  185. if (bit_test(idx)) {
  186. bit_clear(idx);
  187. free_pages++;
  188. }
  189. irq_restore(flags);
  190. }
  191. /* Return a boot-time reservation (the rootfs pack region) to the allocator.
  192. * Low memory and the VGA shadow reserve always stay reserved. */
  193. void mm_free_range(unsigned int base, unsigned int size)
  194. {
  195. unsigned int end, p;
  196. if (base == 0 || size == 0)
  197. return;
  198. base &= ~(PAGE_SIZE - 1u);
  199. if (base + size < base)
  200. return;
  201. end = (base + size + PAGE_SIZE - 1u) & ~(PAGE_SIZE - 1u);
  202. if (base < MM_SHADOW_BASE + MM_SHADOW_RESERVE)
  203. return;
  204. for (p = base; p < end; p += PAGE_SIZE)
  205. mm_free_page(p);
  206. }
  207. unsigned int mm_free_pages(void)
  208. {
  209. return free_pages;
  210. }
  211. unsigned int mm_total_ram_kb(void)
  212. {
  213. return total_ram_kb;
  214. }
  215. unsigned int mm_e820_count(void)
  216. {
  217. const struct e820_map *map = (const struct e820_map *)E820_MAP_ADDR;
  218. if (map->magic == E820_MAGIC && map->count <= E820_MAX_ENTRIES)
  219. return map->count;
  220. return 0;
  221. }
  222. const struct e820_entry *mm_e820_entry(unsigned int i)
  223. {
  224. const struct e820_map *map = (const struct e820_map *)E820_MAP_ADDR;
  225. if (map->magic == E820_MAGIC && map->count <= E820_MAX_ENTRIES &&
  226. i < map->count)
  227. return &map->entry[i];
  228. return 0;
  229. }
  230. void mm_dump(void)
  231. {
  232. const struct e820_map *map = (const struct e820_map *)E820_MAP_ADDR;
  233. unsigned int i;
  234. serial_puts(SERIAL_COM1, "mm: E820 ");
  235. if (map->magic == E820_MAGIC && map->count <= E820_MAX_ENTRIES) {
  236. serial_putdec(SERIAL_COM1, map->count);
  237. serial_puts(SERIAL_COM1, " entries, ");
  238. for (i = 0; i < map->count; i++) {
  239. serial_puts(SERIAL_COM1, "\n [");
  240. serial_puthex(SERIAL_COM1, (unsigned int)map->entry[i].base);
  241. serial_puts(SERIAL_COM1, " +");
  242. serial_puthex(SERIAL_COM1, (unsigned int)map->entry[i].length);
  243. serial_puts(SERIAL_COM1, "] type ");
  244. serial_putdec(SERIAL_COM1, map->entry[i].type);
  245. }
  246. } else {
  247. serial_puts(SERIAL_COM1, "unavailable (fallback 16 MB)");
  248. }
  249. serial_puts(SERIAL_COM1, "\nmm: total ");
  250. serial_putdec(SERIAL_COM1, total_ram_kb);
  251. serial_puts(SERIAL_COM1, " KB, free ");
  252. serial_putdec(SERIAL_COM1, free_pages * (PAGE_SIZE / 1024));
  253. serial_puts(SERIAL_COM1, " KB\n");
  254. }