lunaix-os/kernel/mm/pmm.c

   1 #include <lunaix/mm/page.h>
   2 #include <lunaix/mm/pmm.h>
   3 #include <lunaix/status.h>
   4
   5 // This is a very large array...
   6 static struct pp_struct pm_table[PM_BMP_MAX_SIZE];
   7
   8 static uintptr_t max_pg;
   9
  10 void
  11 pmm_mark_page_free(uintptr_t ppn)
  12 {
  13     pm_table[ppn].ref_counts = 0;
  14 }
  15
  16 void
  17 pmm_mark_page_occupied(pid_t owner, uintptr_t ppn, pp_attr_t attr)
  18 {
  19     pm_table[ppn] = (struct pp_struct) {
  20         .owner = owner,
  21         .ref_counts = 1,
  22         .attr = attr
  23     };
  24 }
  25
  26 void
  27 pmm_mark_chunk_free(uintptr_t start_ppn, size_t page_count)
  28 {
  29     for (size_t i = start_ppn; i < start_ppn + page_count && i < max_pg; i++)
  30     {
  31         pm_table[i].ref_counts = 0;
  32     }
  33 }
  34
  35 void
  36 pmm_mark_chunk_occupied(pid_t owner, uint32_t start_ppn, size_t page_count, pp_attr_t attr)
  37 {
  38     for (size_t i = start_ppn; i < start_ppn + page_count && i < max_pg; i++)
  39     {
  40         pm_table[i] = (struct pp_struct) {
  41             .owner = owner,
  42             .ref_counts = 1,
  43             .attr = attr
  44         };
  45     }
  46 }
  47
  48 // 我们跳过位于0x0的页。我们不希望空指针是指向一个有效的内存空间。
  49 #define LOOKUP_START 1
  50
  51 size_t pg_lookup_ptr;
  52
  53 void
  54 pmm_init(uintptr_t mem_upper_lim)
  55 {
  56     max_pg = (PG_ALIGN(mem_upper_lim) >> 12);
  57
  58     pg_lookup_ptr = LOOKUP_START;
  59
  60     // mark all as occupied
  61     for (size_t i = 0; i < PM_BMP_MAX_SIZE; i++) {
  62         pm_table[i] = (struct pp_struct) {
  63             .owner = 0,
  64             .attr = 0,
  65             .ref_counts = 1
  66         };
  67     }
  68 }
  69
  70 void*
  71 pmm_alloc_cpage(pid_t owner, size_t num_pages, pp_attr_t attr) {
  72     size_t p1 = 0;
  73     size_t p2 = 0;
  74
  75     while (p2 < max_pg && p2 - p1 < num_pages)
  76     {
  77         (!(&pm_table[p2])->ref_counts) ? (p2++) : (p1 = p2);
  78     }
  79
  80     if (p2 < max_pg) {
  81         return NULL;
  82     }
  83
  84     pmm_mark_chunk_occupied(owner, p1, num_pages, attr);
  85
  86     return p1 << 12;
  87 }
  88
  89 void*
  90 pmm_alloc_page(pid_t owner, pp_attr_t attr)
  91 {
  92     // Next fit approach. Maximize the throughput!
  93     uintptr_t good_page_found = (uintptr_t)NULL;
  94     size_t old_pg_ptr = pg_lookup_ptr;
  95     size_t upper_lim = max_pg;
  96     struct pp_struct* pm;
  97     while (!good_page_found && pg_lookup_ptr < upper_lim) {
  98         pm = &pm_table[pg_lookup_ptr];
  99
 100         // skip the fully occupied chunk, reduce # of iterations
 101         if (!pm->ref_counts) {
 102             *pm = (struct pp_struct) {
 103                 .attr = attr,
 104                 .owner = owner,
 105                 .ref_counts = 1
 106             };
 107             good_page_found = pg_lookup_ptr << 12;
 108         } else {
 109             pg_lookup_ptr++;
 110
 111             // We've searched the interval [old_pg_ptr, max_pg) but failed
 112             //   may be chances in [1, old_pg_ptr) ?
 113             // Let's find out!
 114             if (pg_lookup_ptr >= upper_lim && old_pg_ptr != LOOKUP_START) {
 115                 upper_lim = old_pg_ptr;
 116                 pg_lookup_ptr = LOOKUP_START;
 117                 old_pg_ptr = LOOKUP_START;
 118             }
 119         }
 120     }
 121     if (!good_page_found) {
 122         __current->k_status = LXOUTOFMEM;
 123     }
 124     return (void*)good_page_found;
 125 }
 126
 127 int
 128 pmm_free_page(pid_t owner, void* page)
 129 {
 130     struct pp_struct* pm = &pm_table[(intptr_t)page >> 12];
 131
 132     // Oops, double free!
 133     if (!(pm->ref_counts)) {
 134         return 0;
 135     }
 136
 137     // 检查权限，保证：1) 用户只能释放用户页； 2) 内核可释放所有页。
 138     if ((pm->owner & owner) == pm->owner) {
 139         pm->ref_counts--;
 140         return 1;
 141     }
 142     return 0;
 143 }
 144
 145 int pmm_ref_page(pid_t owner, void* page) {
 146     (void*) owner;      // TODO: do smth with owner
 147
 148     uint32_t ppn = (uintptr_t)page >> 12;
 149
 150     if (ppn >= PM_BMP_MAX_SIZE) {
 151         return 0;
 152     }
 153
 154     struct pp_struct* pm = &pm_table[ppn];
 155     if (!pm->ref_counts) {
 156         return 0;
 157     }
 158
 159     pm->ref_counts++;
 160     return 1;
 161 }
 162
 163 struct pp_struct* pmm_query(void* pa) {
 164     uint32_t ppn = (uintptr_t)pa >> 12;
 165
 166     if (ppn >= PM_BMP_MAX_SIZE) {
 167         return NULL;
 168     }
 169
 170     return &pm_table[ppn];
 171 }