mm.c 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243
  1. /* Physical memory manager: parse the E820 map and hand out 4 KB pages. */
  2. #include "mm.h"
  3. #include "serial.h"
  4. /* One bit per 4 KB page; bit set = in use. */
  5. #define MM_BITMAP_BITS (MM_MAX_PHYS / PAGE_SIZE)
  6. #define MM_BITMAP_WORDS (MM_BITMAP_BITS / 32)
  7. static unsigned int bitmap[MM_BITMAP_WORDS];
  8. static unsigned int free_pages;
  9. static unsigned int total_ram_kb;
  10. /* ---- bitmap helpers ---- */
  11. static inline void bit_set(unsigned int idx)
  12. {
  13. bitmap[idx / 32] |= (1u << (idx % 32));
  14. }
  15. static inline void bit_clear(unsigned int idx)
  16. {
  17. bitmap[idx / 32] &= ~(1u << (idx % 32));
  18. }
  19. static inline int bit_test(unsigned int idx)
  20. {
  21. return (bitmap[idx / 32] >> (idx % 32)) & 1;
  22. }
  23. /* ---- interrupt flag save/restore (allocator is not IRQ-safe) ---- */
  24. static inline unsigned int irq_disable_save(void)
  25. {
  26. unsigned int flags;
  27. __asm__ volatile ("pushfl; popl %0; cli" : "=r"(flags));
  28. return flags;
  29. }
  30. static inline void irq_restore(unsigned int flags)
  31. {
  32. __asm__ volatile ("pushl %0; popfl" : : "r"(flags));
  33. }
  34. /* Mark a physical byte range [base, base+len) as used in the bitmap. */
  35. static void mark_used(unsigned long long base, unsigned long long len)
  36. {
  37. unsigned long long end = base + len;
  38. unsigned int p0, p1, p;
  39. if (base >= MM_MAX_PHYS)
  40. return;
  41. if (end > MM_MAX_PHYS)
  42. end = MM_MAX_PHYS;
  43. p0 = (unsigned int)(base >> 12);
  44. p1 = (unsigned int)((end + PAGE_SIZE - 1) >> 12);
  45. for (p = p0; p < p1; p++)
  46. bit_set(p);
  47. }
  48. /* Mark a physical byte range [base, base+len) as free (usable RAM). */
  49. static void mark_free(unsigned long long base, unsigned long long len)
  50. {
  51. unsigned long long end = base + len;
  52. unsigned int p0, p1, p;
  53. if (base >= MM_MAX_PHYS)
  54. return;
  55. if (end > MM_MAX_PHYS)
  56. end = MM_MAX_PHYS;
  57. p0 = (unsigned int)(base >> 12);
  58. p1 = (unsigned int)(end >> 12);
  59. for (p = p0; p < p1; p++)
  60. bit_clear(p);
  61. }
  62. /* Mark the whole bitmap as used, then walk the E820 map and free RAM. */
  63. void mm_init(void)
  64. {
  65. const struct e820_map *map = (const struct e820_map *)E820_MAP_ADDR;
  66. unsigned int i, n;
  67. /* Everything starts in-use. */
  68. for (i = 0; i < MM_BITMAP_WORDS; i++)
  69. bitmap[i] = 0xFFFFFFFFu;
  70. total_ram_kb = 0;
  71. if (map->magic == E820_MAGIC && map->count <= E820_MAX_ENTRIES) {
  72. n = map->count;
  73. for (i = 0; i < n; i++) {
  74. const struct e820_entry *e = &map->entry[i];
  75. if (e->type == E820_RAM && e->length != 0) {
  76. mark_free(e->base, e->length);
  77. total_ram_kb += (unsigned int)(e->length >> 10);
  78. }
  79. }
  80. } else {
  81. /* No E820 map (very old BIOS, or first kexec onto an old build):
  82. * assume 16 MB of RAM from 1 MB up. The process-stack fallback
  83. * pool keeps the system bootable if this guess is wrong. */
  84. mark_free(0x100000ULL, 0x1000000ULL - 0x100000ULL);
  85. total_ram_kb = (0x1000000ULL - 0x100000ULL) >> 10; /* 15 MB */
  86. }
  87. /* Re-reserve what the kernel already owns. */
  88. mark_used(0, MM_RESERVE_LOW);
  89. mark_used(MM_SHADOW_BASE, MM_SHADOW_RESERVE);
  90. /* Count free pages. */
  91. free_pages = 0;
  92. for (i = 0; i < MM_BITMAP_BITS; i++) {
  93. if (!bit_test(i))
  94. free_pages++;
  95. }
  96. }
  97. unsigned int mm_alloc_page(void)
  98. {
  99. unsigned int i, w;
  100. unsigned int flags = irq_disable_save();
  101. for (w = 0; w < MM_BITMAP_WORDS; w++) {
  102. if (bitmap[w] != 0xFFFFFFFFu) {
  103. unsigned int word = bitmap[w];
  104. for (i = 0; i < 32; i++) {
  105. if (!(word & (1u << i))) {
  106. unsigned int idx = w * 32 + i;
  107. bitmap[w] |= (1u << i);
  108. free_pages--;
  109. irq_restore(flags);
  110. return idx * PAGE_SIZE;
  111. }
  112. }
  113. }
  114. }
  115. irq_restore(flags);
  116. return 0;
  117. }
  118. unsigned int mm_alloc_pages(unsigned int n)
  119. {
  120. unsigned int start = 0, run = 0;
  121. unsigned int p;
  122. unsigned int flags;
  123. if (n == 0)
  124. return 0;
  125. flags = irq_disable_save();
  126. for (p = 0; p < MM_BITMAP_BITS; p++) {
  127. if (!bit_test(p)) {
  128. if (run == 0)
  129. start = p;
  130. run++;
  131. if (run == n) {
  132. unsigned int i;
  133. for (i = start; i < start + n; i++)
  134. bit_set(i);
  135. free_pages -= n;
  136. irq_restore(flags);
  137. return start * PAGE_SIZE;
  138. }
  139. } else {
  140. run = 0;
  141. }
  142. }
  143. irq_restore(flags);
  144. return 0;
  145. }
  146. void mm_free_page(unsigned int addr)
  147. {
  148. unsigned int idx = addr / PAGE_SIZE;
  149. unsigned int flags;
  150. if (addr == 0 || idx >= MM_BITMAP_BITS)
  151. return;
  152. flags = irq_disable_save();
  153. if (bit_test(idx)) {
  154. bit_clear(idx);
  155. free_pages++;
  156. }
  157. irq_restore(flags);
  158. }
  159. unsigned int mm_free_pages(void)
  160. {
  161. return free_pages;
  162. }
  163. unsigned int mm_total_ram_kb(void)
  164. {
  165. return total_ram_kb;
  166. }
  167. unsigned int mm_e820_count(void)
  168. {
  169. const struct e820_map *map = (const struct e820_map *)E820_MAP_ADDR;
  170. if (map->magic == E820_MAGIC && map->count <= E820_MAX_ENTRIES)
  171. return map->count;
  172. return 0;
  173. }
  174. const struct e820_entry *mm_e820_entry(unsigned int i)
  175. {
  176. const struct e820_map *map = (const struct e820_map *)E820_MAP_ADDR;
  177. if (map->magic == E820_MAGIC && map->count <= E820_MAX_ENTRIES &&
  178. i < map->count)
  179. return &map->entry[i];
  180. return 0;
  181. }
  182. void mm_dump(void)
  183. {
  184. const struct e820_map *map = (const struct e820_map *)E820_MAP_ADDR;
  185. unsigned int i;
  186. serial_puts(SERIAL_COM1, "mm: E820 ");
  187. if (map->magic == E820_MAGIC && map->count <= E820_MAX_ENTRIES) {
  188. serial_putdec(SERIAL_COM1, map->count);
  189. serial_puts(SERIAL_COM1, " entries, ");
  190. for (i = 0; i < map->count; i++) {
  191. serial_puts(SERIAL_COM1, "\n [");
  192. serial_puthex(SERIAL_COM1, (unsigned int)map->entry[i].base);
  193. serial_puts(SERIAL_COM1, " +");
  194. serial_puthex(SERIAL_COM1, (unsigned int)map->entry[i].length);
  195. serial_puts(SERIAL_COM1, "] type ");
  196. serial_putdec(SERIAL_COM1, map->entry[i].type);
  197. }
  198. } else {
  199. serial_puts(SERIAL_COM1, "unavailable (fallback 16 MB)");
  200. }
  201. serial_puts(SERIAL_COM1, "\nmm: total ");
  202. serial_putdec(SERIAL_COM1, total_ram_kb);
  203. serial_puts(SERIAL_COM1, " KB, free ");
  204. serial_putdec(SERIAL_COM1, free_pages * (PAGE_SIZE / 1024));
  205. serial_puts(SERIAL_COM1, " KB\n");
  206. }