lunaix-os/kernel/mm/mmap.c

   1 #include <lunaix/mm/mmap.h>
   2 #include <lunaix/mm/pmm.h>
   3 #include <lunaix/mm/valloc.h>
   4 #include <lunaix/mm/vmm.h>
   5 #include <lunaix/spike.h>
   6 #include <lunaix/syscall.h>
   7 #include <lunaix/syscall_utils.h>
   8
   9 #include <sys/mm/mm_defs.h>
  10
  11 #include <usr/lunaix/mann_flags.h>
  12
  13 // any size beyond this is bullshit
  14 #define BS_SIZE (KERNEL_RESIDENT - USR_MMAP)
  15
  16 int
  17 mem_has_overlap(vm_regions_t* regions, ptr_t start, ptr_t end)
  18 {
  19     struct mm_region *pos, *n;
  20     llist_for_each(pos, n, regions, head)
  21     {
  22         if (pos->end >= start && pos->start < start) {
  23             return 1;
  24         }
  25
  26         if (pos->end <= end && pos->start >= start) {
  27             return 1;
  28         }
  29
  30         if (pos->end >= end && pos->start < end) {
  31             return 1;
  32         }
  33     }
  34
  35     return 0;
  36 }
  37
  38 int
  39 mem_adjust_inplace(vm_regions_t* regions,
  40                    struct mm_region* region,
  41                    ptr_t newend)
  42 {
  43     ssize_t len = newend - region->start;
  44     if (len == 0) {
  45         return 0;
  46     }
  47
  48     if (len < 0) {
  49         return EINVAL;
  50     }
  51
  52     if (mem_has_overlap(regions, region->start, newend)) {
  53         return ENOMEM;
  54     }
  55
  56     region->end = newend;
  57
  58     return 0;
  59 }
  60
  61 int
  62 mmap_user(void** addr_out,
  63         struct mm_region** created,
  64         ptr_t addr,
  65         struct v_file* file,
  66         struct mmap_param* param)
  67 {
  68     param->range_end = KERNEL_RESIDENT;
  69     param->range_start = USR_EXEC;
  70
  71     return mem_map(addr_out, created, addr, file, param);
  72 }
  73
  74 static ptr_t
  75 __mem_find_slot_backward(struct mm_region* lead, struct mmap_param* param, struct mm_region* anchor)
  76 {
  77     ptr_t size = param->mlen;
  78     struct mm_region *pos = anchor,
  79                      *n = next_region(pos);
  80     while (pos != lead)
  81     {
  82         if (pos == lead) {
  83             break;
  84         }
  85
  86         ptr_t end = n->start;
  87         if (n == lead) {
  88             end = param->range_end;
  89         }
  90
  91         if (end - pos->end >= size) {
  92             return pos->end;
  93         }
  94
  95         pos = n;
  96         n = next_region(pos);
  97     }
  98
  99     return 0;
 100 }
 101
 102 static ptr_t
 103 __mem_find_slot_forward(struct mm_region* lead, struct mmap_param* param, struct mm_region* anchor)
 104 {
 105     ptr_t size = param->mlen;
 106     struct mm_region *pos = anchor,
 107                      *prev = prev_region(pos);
 108     while (lead != pos)
 109     {
 110         ptr_t end = prev->end;
 111         if (prev == lead) {
 112             end = param->range_start;
 113         }
 114
 115         if (pos->start - end >= size) {
 116             return pos->start - size;
 117         }
 118
 119         pos = prev;
 120         prev = prev_region(pos);
 121     }
 122
 123     return 0;
 124 }
 125
 126 static ptr_t
 127 __mem_find_slot(vm_regions_t* lead, struct mmap_param* param, struct mm_region* anchor)
 128 {
 129     ptr_t result = 0;
 130     struct mm_region* _lead = get_region(lead);
 131     if ((result = __mem_find_slot_backward(_lead, param, anchor))) {
 132         return result;
 133     }
 134
 135     return __mem_find_slot_forward(_lead, param, anchor);
 136 }
 137
 138 static struct mm_region*
 139 __mem_find_nearest(vm_regions_t* lead, ptr_t addr)
 140 {
 141     ptr_t min_dist = (ptr_t)-1;
 142     struct mm_region *pos, *n, *min = NULL;
 143     llist_for_each(pos, n, lead, head) {
 144         if (region_contains(pos, addr)) {
 145             return pos;
 146         }
 147
 148         ptr_t dist = addr - pos->end;
 149         if (addr < pos->start) {
 150             dist = pos->start - addr;
 151         }
 152
 153         if (dist < min_dist) {
 154             min_dist = dist;
 155             min = pos;
 156         }
 157     }
 158
 159     return min;
 160 }
 161
 162 int
 163 mem_map(void** addr_out,
 164         struct mm_region** created,
 165         ptr_t addr,
 166         struct v_file* file,
 167         struct mmap_param* param)
 168 {
 169     assert_msg(addr, "addr can not be NULL");
 170
 171     ptr_t last_end = USR_EXEC, found_loc = va_align(addr);
 172     struct mm_region *pos, *n;
 173
 174     vm_regions_t* vm_regions = &param->pvms->regions;
 175
 176     if ((param->flags & MAP_FIXED_NOREPLACE)) {
 177         if (mem_has_overlap(vm_regions, found_loc, param->mlen + found_loc)) {
 178             return EEXIST;
 179         }
 180         goto found;
 181     }
 182
 183     if ((param->flags & MAP_FIXED)) {
 184         int status =
 185           mem_unmap(param->vms_mnt, vm_regions, found_loc, param->mlen);
 186         if (status) {
 187             return status;
 188         }
 189         goto found;
 190     }
 191
 192     if (llist_empty(vm_regions)) {
 193         goto found;
 194     }
 195
 196     struct mm_region* anchor = __mem_find_nearest(vm_regions, found_loc);
 197     if ((found_loc = __mem_find_slot(vm_regions, param, anchor))) {
 198         goto found;
 199     }
 200
 201     return ENOMEM;
 202
 203 found:
 204     if (found_loc >= param->range_end || found_loc < param->range_start) {
 205         return ENOMEM;
 206     }
 207
 208     struct mm_region* region = region_create_range(
 209       found_loc,
 210       param->mlen,
 211       ((param->proct | param->flags) & 0x3f) | (param->type & ~0xffff));
 212
 213     region->mfile = file;
 214     region->foff = param->offset;
 215     region->proc_vms = param->pvms;
 216
 217     region_add(vm_regions, region);
 218
 219     if (file) {
 220         vfs_ref_file(file);
 221     }
 222
 223     if (addr_out) {
 224         *addr_out = (void*)found_loc;
 225     }
 226     if (created) {
 227         *created = region;
 228     }
 229     return 0;
 230 }
 231
 232 int
 233 mem_remap(void** addr_out,
 234           struct mm_region** remapped,
 235           void* addr,
 236           struct v_file* file,
 237           struct mmap_param* param)
 238 {
 239     // TODO
 240
 241     return EINVAL;
 242 }
 243
 244 void
 245 mem_sync_pages(ptr_t mnt,
 246                struct mm_region* region,
 247                ptr_t start,
 248                ptr_t length,
 249                int options)
 250 {
 251     if (!region->mfile || !(region->attr & REGION_WSHARED)) {
 252         return;
 253     }
 254
 255     pte_t* ptep = mkptep_va(mnt, start);
 256     ptr_t va    = va_align(start);
 257
 258     for (; va < start + length; va += PAGE_SIZE, ptep++) {
 259         pte_t pte = vmm_tryptep(ptep, LFT_SIZE);
 260         if (pte_isnull(pte)) {
 261             continue;
 262         }
 263
 264         if (pte_dirty(pte)) {
 265             size_t offset = va - region->start + region->foff;
 266             struct v_inode* inode = region->mfile->inode;
 267
 268             region->mfile->ops->write_page(inode, (void*)va, offset);
 269
 270             set_pte(ptep, pte_mkclean(pte));
 271             cpu_flush_page(va);
 272         } else if ((options & MS_INVALIDATE)) {
 273             goto invalidate;
 274         }
 275
 276         if (options & MS_INVALIDATE_ALL) {
 277             goto invalidate;
 278         }
 279
 280         continue;
 281
 282     invalidate:
 283         set_pte(ptep, null_pte);
 284         pmm_free_page(pte_paddr(pte));
 285         cpu_flush_page(va);
 286     }
 287 }
 288
 289 int
 290 mem_msync(ptr_t mnt,
 291           vm_regions_t* regions,
 292           ptr_t addr,
 293           size_t length,
 294           int options)
 295 {
 296     struct mm_region* pos = list_entry(regions->next, struct mm_region, head);
 297     while (length && (ptr_t)&pos->head != (ptr_t)regions) {
 298         if (pos->end >= addr && pos->start <= addr) {
 299             size_t l = MIN(length, pos->end - addr);
 300             mem_sync_pages(mnt, pos, addr, l, options);
 301
 302             addr += l;
 303             length -= l;
 304         }
 305         pos = list_entry(pos->head.next, struct mm_region, head);
 306     }
 307
 308     if (length) {
 309         return ENOMEM;
 310     }
 311
 312     return 0;
 313 }
 314
 315 void
 316 mem_unmap_region(ptr_t mnt, struct mm_region* region)
 317 {
 318     if (!region) {
 319         return;
 320     }
 321
 322     valloc_ensure_valid(region);
 323
 324     pfn_t pglen = leaf_count(region->end - region->start);
 325     mem_sync_pages(mnt, region, region->start, pglen * PAGE_SIZE, 0);
 326
 327     pte_t* ptep = mkptep_va(mnt, region->start);
 328     for (size_t i = 0; i < pglen; i++, ptep++) {
 329         pte_t pte = pte_at(ptep);
 330         ptr_t pa  = pte_paddr(pte);
 331
 332         set_pte(ptep, null_pte);
 333         if (pte_isloaded(pte)) {
 334             pmm_free_page(pte_paddr(pte));
 335         }
 336     }
 337
 338     llist_delete(&region->head);
 339     region_release(region);
 340 }
 341
 342 // Case: head inseted, tail inseted
 343 #define CASE_HITI(vmr, addr, len)                                              \
 344     ((vmr)->start <= (addr) && ((addr) + (len)) <= (vmr)->end)
 345
 346 // Case: head inseted, tail extruded
 347 #define CASE_HITE(vmr, addr, len)                                              \
 348     ((vmr)->start <= (addr) && ((addr) + (len)) > (vmr)->end)
 349
 350 // Case: head extruded, tail inseted
 351 #define CASE_HETI(vmr, addr, len)                                              \
 352     ((vmr)->start > (addr) && ((addr) + (len)) <= (vmr)->end)
 353
 354 // Case: head extruded, tail extruded
 355 #define CASE_HETE(vmr, addr, len)                                              \
 356     ((vmr)->start > (addr) && ((addr) + (len)) > (vmr)->end)
 357
 358 static void
 359 __unmap_overlapped_cases(ptr_t mnt,
 360                          struct mm_region* vmr,
 361                          ptr_t* addr,
 362                          size_t* length)
 363 {
 364     // seg start, umapped segement start
 365     ptr_t seg_start = *addr, umps_start = 0;
 366
 367     // seg len, umapped segement len
 368     size_t seg_len = *length, umps_len = 0;
 369
 370     size_t displ = 0, shrink = 0;
 371
 372     if (CASE_HITI(vmr, seg_start, seg_len)) {
 373         size_t new_start = seg_start + seg_len;
 374
 375         // Require a split
 376         if (new_start < vmr->end) {
 377             struct mm_region* region = region_dup(vmr);
 378             if (region->mfile) {
 379                 size_t f_shifted = new_start - region->start;
 380                 region->foff += f_shifted;
 381             }
 382             region->start = new_start;
 383             llist_insert_after(&vmr->head, &region->head);
 384         }
 385
 386         shrink = vmr->end - seg_start;
 387         umps_len = shrink;
 388         umps_start = seg_start;
 389     }
 390     else if (CASE_HITE(vmr, seg_start, seg_len)) {
 391         shrink = vmr->end - seg_start;
 392         umps_len = shrink;
 393         umps_start = seg_start;
 394     }
 395     else if (CASE_HETI(vmr, seg_start, seg_len)) {
 396         displ = seg_len - (vmr->start - seg_start);
 397         umps_len = displ;
 398         umps_start = vmr->start;
 399     }
 400     else if (CASE_HETE(vmr, seg_start, seg_len)) {
 401         shrink = vmr->end - vmr->start;
 402         umps_len = shrink;
 403         umps_start = vmr->start;
 404     }
 405
 406     mem_sync_pages(mnt, vmr, vmr->start, umps_len, 0);
 407     for (size_t i = 0; i < umps_len; i += PAGE_SIZE) {
 408         ptr_t pa = vmm_del_mapping(mnt, vmr->start + i);
 409         if (pa) {
 410             pmm_free_page(pa);
 411         }
 412     }
 413
 414     vmr->start += displ;
 415     vmr->end -= shrink;
 416
 417     if (vmr->start >= vmr->end) {
 418         llist_delete(&vmr->head);
 419         region_release(vmr);
 420     } else if (vmr->mfile) {
 421         vmr->foff += displ;
 422     }
 423
 424     *addr = umps_start + umps_len;
 425
 426     size_t ump_len = *addr - seg_start;
 427     *length = MAX(seg_len, ump_len) - ump_len;
 428 }
 429
 430 int
 431 mem_unmap(ptr_t mnt, vm_regions_t* regions, ptr_t addr, size_t length)
 432 {
 433     length = ROUNDUP(length, PAGE_SIZE);
 434     ptr_t cur_addr = va_align(addr);
 435     struct mm_region *pos, *n;
 436
 437     llist_for_each(pos, n, regions, head)
 438     {
 439         u32_t l = pos->start - cur_addr;
 440         if ((pos->start <= cur_addr && cur_addr < pos->end) || l <= length) {
 441             break;
 442         }
 443     }
 444
 445     while (&pos->head != regions && length) {
 446         n = container_of(pos->head.next, typeof(*pos), head);
 447         __unmap_overlapped_cases(mnt, pos, &cur_addr, &length);
 448
 449         pos = n;
 450     }
 451
 452     return 0;
 453 }
 454
 455 __DEFINE_LXSYSCALL3(void*, sys_mmap, void*, addr, size_t, length, va_list, lst)
 456 {
 457     int proct = va_arg(lst, int);
 458     int fd = va_arg(lst, u32_t);
 459     off_t offset = va_arg(lst, off_t);
 460     int options = va_arg(lst, int);
 461     int errno = 0;
 462     void* result = (void*)-1;
 463
 464     ptr_t addr_ptr = (ptr_t)addr;
 465
 466     if (!length || length > BS_SIZE || va_offset(addr_ptr)) {
 467         errno = EINVAL;
 468         goto done;
 469     }
 470
 471     if (!addr_ptr) {
 472         addr_ptr = USR_MMAP;
 473     } else if (addr_ptr < USR_MMAP || addr_ptr + length >= USR_MMAP_END) {
 474         if (!(options & (MAP_FIXED | MAP_FIXED_NOREPLACE))) {
 475             errno = ENOMEM;
 476             goto done;
 477         }
 478     }
 479
 480     struct v_file* file = NULL;
 481
 482     if (!(options & MAP_ANON)) {
 483         struct v_fd* vfd;
 484         if ((errno = vfs_getfd(fd, &vfd))) {
 485             goto done;
 486         }
 487
 488         file = vfd->file;
 489         if (!file->ops->read_page) {
 490             errno = ENODEV;
 491             goto done;
 492         }
 493     }
 494
 495     struct mmap_param param = { .flags = options,
 496                                 .mlen = ROUNDUP(length, PAGE_SIZE),
 497                                 .offset = offset,
 498                                 .type = REGION_TYPE_GENERAL,
 499                                 .proct = proct,
 500                                 .pvms = vmspace(__current),
 501                                 .vms_mnt = VMS_SELF };
 502
 503     errno = mmap_user(&result, NULL, addr_ptr, file, &param);
 504
 505 done:
 506     syscall_result(errno);
 507     return result;
 508 }
 509
 510 __DEFINE_LXSYSCALL2(int, munmap, void*, addr, size_t, length)
 511 {
 512     return mem_unmap(
 513       VMS_SELF, vmregions(__current), (ptr_t)addr, length);
 514 }
 515
 516 __DEFINE_LXSYSCALL3(int, msync, void*, addr, size_t, length, int, flags)
 517 {
 518     if (va_offset((ptr_t)addr) || ((flags & MS_ASYNC) && (flags & MS_SYNC))) {
 519         return DO_STATUS(EINVAL);
 520     }
 521
 522     int status = mem_msync(VMS_SELF,
 523                            vmregions(__current),
 524                            (ptr_t)addr,
 525                            length,
 526                            flags);
 527
 528     return DO_STATUS(status);
 529 }