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/mempart.h>
  10
  11 #include <usr/lunaix/mann_flags.h>
  12
  13 // any size beyond this is bullshit
  14 #define BS_SIZE (KERNEL_EXEC - 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_EXEC;
  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 = PG_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     int proct = param->proct;
 220     int attr = PG_ALLOW_USER;
 221     if ((proct & REGION_WRITE)) {
 222         attr |= PG_WRITE;
 223     }
 224     if ((proct & REGION_KERNEL)) {
 225         attr &= ~PG_ALLOW_USER;
 226     }
 227
 228     for (size_t i = 0; i < param->mlen; i += PG_SIZE) {
 229         vmm_set_mapping(param->vms_mnt, found_loc + i, 0, attr, 0);
 230     }
 231
 232     if (file) {
 233         vfs_ref_file(file);
 234     }
 235
 236     if (addr_out) {
 237         *addr_out = (void*)found_loc;
 238     }
 239     if (created) {
 240         *created = region;
 241     }
 242     return 0;
 243 }
 244
 245 int
 246 mem_remap(void** addr_out,
 247           struct mm_region** remapped,
 248           void* addr,
 249           struct v_file* file,
 250           struct mmap_param* param)
 251 {
 252     // TODO
 253
 254     return EINVAL;
 255 }
 256
 257 void
 258 mem_sync_pages(ptr_t mnt,
 259                struct mm_region* region,
 260                ptr_t start,
 261                ptr_t length,
 262                int options)
 263 {
 264     if (!region->mfile || !(region->attr & REGION_WSHARED)) {
 265         return;
 266     }
 267
 268     v_mapping mapping;
 269     for (size_t i = 0; i < length; i += PG_SIZE) {
 270         if (!vmm_lookupat(mnt, start + i, &mapping)) {
 271             continue;
 272         }
 273
 274         if (PG_IS_DIRTY(*mapping.pte)) {
 275             size_t offset = mapping.va - region->start + region->foff;
 276             struct v_inode* inode = region->mfile->inode;
 277
 278             region->mfile->ops->write_page(inode, (void*)mapping.va, offset);
 279
 280             *mapping.pte &= ~PG_DIRTY;
 281
 282             cpu_flush_page((ptr_t)mapping.pte);
 283         } else if ((options & MS_INVALIDATE)) {
 284             goto invalidate;
 285         }
 286
 287         if (options & MS_INVALIDATE_ALL) {
 288             goto invalidate;
 289         }
 290
 291         continue;
 292
 293     invalidate:
 294         *mapping.pte &= ~PG_PRESENT;
 295         pmm_free_page(mapping.pa);
 296         cpu_flush_page((ptr_t)mapping.pte);
 297     }
 298 }
 299
 300 int
 301 mem_msync(ptr_t mnt,
 302           vm_regions_t* regions,
 303           ptr_t addr,
 304           size_t length,
 305           int options)
 306 {
 307     struct mm_region* pos = list_entry(regions->next, struct mm_region, head);
 308     while (length && (ptr_t)&pos->head != (ptr_t)regions) {
 309         if (pos->end >= addr && pos->start <= addr) {
 310             size_t l = MIN(length, pos->end - addr);
 311             mem_sync_pages(mnt, pos, addr, l, options);
 312
 313             addr += l;
 314             length -= l;
 315         }
 316         pos = list_entry(pos->head.next, struct mm_region, head);
 317     }
 318
 319     if (length) {
 320         return ENOMEM;
 321     }
 322
 323     return 0;
 324 }
 325
 326 void
 327 mem_unmap_region(ptr_t mnt, struct mm_region* region)
 328 {
 329     if (!region) {
 330         return;
 331     }
 332
 333     valloc_ensure_valid(region);
 334
 335     size_t len = ROUNDUP(region->end - region->start, PG_SIZE);
 336     mem_sync_pages(mnt, region, region->start, len, 0);
 337
 338     for (size_t i = region->start; i <= region->end; i += PG_SIZE) {
 339         ptr_t pa = vmm_del_mapping(mnt, i);
 340         if (pa) {
 341             pmm_free_page(pa);
 342         }
 343     }
 344
 345     llist_delete(&region->head);
 346     region_release(region);
 347 }
 348
 349 // Case: head inseted, tail inseted
 350 #define CASE_HITI(vmr, addr, len)                                              \
 351     ((vmr)->start <= (addr) && ((addr) + (len)) <= (vmr)->end)
 352
 353 // Case: head inseted, tail extruded
 354 #define CASE_HITE(vmr, addr, len)                                              \
 355     ((vmr)->start <= (addr) && ((addr) + (len)) > (vmr)->end)
 356
 357 // Case: head extruded, tail inseted
 358 #define CASE_HETI(vmr, addr, len)                                              \
 359     ((vmr)->start > (addr) && ((addr) + (len)) <= (vmr)->end)
 360
 361 // Case: head extruded, tail extruded
 362 #define CASE_HETE(vmr, addr, len)                                              \
 363     ((vmr)->start > (addr) && ((addr) + (len)) > (vmr)->end)
 364
 365 static void
 366 __unmap_overlapped_cases(ptr_t mnt,
 367                          struct mm_region* vmr,
 368                          ptr_t* addr,
 369                          size_t* length)
 370 {
 371     // seg start, umapped segement start
 372     ptr_t seg_start = *addr, umps_start = 0;
 373
 374     // seg len, umapped segement len
 375     size_t seg_len = *length, umps_len = 0;
 376
 377     size_t displ = 0, shrink = 0;
 378
 379     if (CASE_HITI(vmr, seg_start, seg_len)) {
 380         size_t new_start = seg_start + seg_len;
 381
 382         // Require a split
 383         if (new_start < vmr->end) {
 384             struct mm_region* region = region_dup(vmr);
 385             if (region->mfile) {
 386                 size_t f_shifted = new_start - region->start;
 387                 region->foff += f_shifted;
 388             }
 389             region->start = new_start;
 390             llist_insert_after(&vmr->head, &region->head);
 391         }
 392
 393         shrink = vmr->end - seg_start;
 394         umps_len = shrink;
 395         umps_start = seg_start;
 396     } else if (CASE_HITE(vmr, seg_start, seg_len)) {
 397         shrink = vmr->end - seg_start;
 398         umps_len = shrink;
 399         umps_start = seg_start;
 400     } else if (CASE_HETI(vmr, seg_start, seg_len)) {
 401         displ = seg_len - (vmr->start - seg_start);
 402         umps_len = displ;
 403         umps_start = vmr->start;
 404     } else if (CASE_HETE(vmr, seg_start, seg_len)) {
 405         shrink = vmr->end - vmr->start;
 406         umps_len = shrink;
 407         umps_start = vmr->start;
 408     }
 409
 410     mem_sync_pages(mnt, vmr, vmr->start, umps_len, 0);
 411     for (size_t i = 0; i < umps_len; i += PG_SIZE) {
 412         ptr_t pa = vmm_del_mapping(mnt, vmr->start + i);
 413         if (pa) {
 414             pmm_free_page(pa);
 415         }
 416     }
 417
 418     vmr->start += displ;
 419     vmr->end -= shrink;
 420
 421     if (vmr->start >= vmr->end) {
 422         llist_delete(&vmr->head);
 423         region_release(vmr);
 424     } else if (vmr->mfile) {
 425         vmr->foff += displ;
 426     }
 427
 428     *addr = umps_start + umps_len;
 429
 430     size_t ump_len = *addr - seg_start;
 431     *length = MAX(seg_len, ump_len) - ump_len;
 432 }
 433
 434 int
 435 mem_unmap(ptr_t mnt, vm_regions_t* regions, ptr_t addr, size_t length)
 436 {
 437     length = ROUNDUP(length, PG_SIZE);
 438     ptr_t cur_addr = PG_ALIGN(addr);
 439     struct mm_region *pos, *n;
 440
 441     llist_for_each(pos, n, regions, head)
 442     {
 443         u32_t l = pos->start - cur_addr;
 444         if ((pos->start <= cur_addr && cur_addr < pos->end) || l <= length) {
 445             break;
 446         }
 447     }
 448
 449     while (&pos->head != regions && length) {
 450         n = container_of(pos->head.next, typeof(*pos), head);
 451         __unmap_overlapped_cases(mnt, pos, &cur_addr, &length);
 452
 453         pos = n;
 454     }
 455
 456     return 0;
 457 }
 458
 459 __DEFINE_LXSYSCALL3(void*, sys_mmap, void*, addr, size_t, length, va_list, lst)
 460 {
 461     int proct = va_arg(lst, int);
 462     int fd = va_arg(lst, u32_t);
 463     off_t offset = va_arg(lst, off_t);
 464     int options = va_arg(lst, int);
 465     int errno = 0;
 466     void* result = (void*)-1;
 467
 468     ptr_t addr_ptr = (ptr_t)addr;
 469
 470     if (!length || length > BS_SIZE || !PG_ALIGNED(addr_ptr)) {
 471         errno = EINVAL;
 472         goto done;
 473     }
 474
 475     if (!addr_ptr) {
 476         addr_ptr = USR_MMAP;
 477     } else if (addr_ptr < USR_MMAP || addr_ptr + length >= USR_MMAP_END) {
 478         if (!(options & (MAP_FIXED | MAP_FIXED_NOREPLACE))) {
 479             errno = ENOMEM;
 480             goto done;
 481         }
 482     }
 483
 484     struct v_file* file = NULL;
 485
 486     if (!(options & MAP_ANON)) {
 487         struct v_fd* vfd;
 488         if ((errno = vfs_getfd(fd, &vfd))) {
 489             goto done;
 490         }
 491
 492         file = vfd->file;
 493         if (!file->ops->read_page) {
 494             errno = ENODEV;
 495             goto done;
 496         }
 497     }
 498
 499     struct mmap_param param = { .flags = options,
 500                                 .mlen = ROUNDUP(length, PG_SIZE),
 501                                 .offset = offset,
 502                                 .type = REGION_TYPE_GENERAL,
 503                                 .proct = proct,
 504                                 .pvms = vmspace(__current),
 505                                 .vms_mnt = VMS_SELF };
 506
 507     errno = mmap_user(&result, NULL, addr_ptr, file, &param);
 508
 509 done:
 510     syscall_result(errno);
 511     return result;
 512 }
 513
 514 __DEFINE_LXSYSCALL2(int, munmap, void*, addr, size_t, length)
 515 {
 516     return mem_unmap(
 517       VMS_SELF, vmregions(__current), (ptr_t)addr, length);
 518 }
 519
 520 __DEFINE_LXSYSCALL3(int, msync, void*, addr, size_t, length, int, flags)
 521 {
 522     if (!PG_ALIGNED(addr) || ((flags & MS_ASYNC) && (flags & MS_SYNC))) {
 523         return DO_STATUS(EINVAL);
 524     }
 525
 526     int status = mem_msync(VMS_SELF,
 527                            vmregions(__current),
 528                            (ptr_t)addr,
 529                            length,
 530                            flags);
 531
 532     return DO_STATUS(status);
 533 }