1 /* $OpenBSD: uvm_mmap.c,v 1.185 2024/01/19 21:20:35 deraadt Exp $ */ 2 /* $NetBSD: uvm_mmap.c,v 1.49 2001/02/18 21:19:08 chs Exp $ */ 3 4 /* 5 * Copyright (c) 1997 Charles D. Cranor and Washington University. 6 * Copyright (c) 1991, 1993 The Regents of the University of California. 7 * Copyright (c) 1988 University of Utah. 8 * 9 * All rights reserved. 10 * 11 * This code is derived from software contributed to Berkeley by 12 * the Systems Programming Group of the University of Utah Computer 13 * Science Department. 14 * 15 * Redistribution and use in source and binary forms, with or without 16 * modification, are permitted provided that the following conditions 17 * are met: 18 * 1. Redistributions of source code must retain the above copyright 19 * notice, this list of conditions and the following disclaimer. 20 * 2. Redistributions in binary form must reproduce the above copyright 21 * notice, this list of conditions and the following disclaimer in the 22 * documentation and/or other materials provided with the distribution. 23 * 3. Neither the name of the University nor the names of its contributors 24 * may be used to endorse or promote products derived from this software 25 * without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 28 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 30 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 31 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 37 * SUCH DAMAGE. 38 * 39 * from: Utah $Hdr: vm_mmap.c 1.6 91/10/21$ 40 * @(#)vm_mmap.c 8.5 (Berkeley) 5/19/94 41 * from: Id: uvm_mmap.c,v 1.1.2.14 1998/01/05 21:04:26 chuck Exp 42 */ 43 44 /* 45 * uvm_mmap.c: system call interface into VM system, plus kernel vm_mmap 46 * function. 47 */ 48 #include <sys/param.h> 49 #include <sys/systm.h> 50 #include <sys/fcntl.h> 51 #include <sys/file.h> 52 #include <sys/filedesc.h> 53 #include <sys/resourcevar.h> 54 #include <sys/mman.h> 55 #include <sys/mount.h> 56 #include <sys/proc.h> 57 #include <sys/malloc.h> 58 #include <sys/vnode.h> 59 #include <sys/conf.h> 60 #include <sys/signalvar.h> 61 #include <sys/syslog.h> 62 #include <sys/stat.h> 63 #include <sys/specdev.h> 64 #include <sys/stdint.h> 65 #include <sys/pledge.h> 66 #include <sys/unistd.h> /* for KBIND* */ 67 #include <sys/user.h> 68 69 #include <machine/exec.h> /* for __LDPGSZ */ 70 71 #include <sys/syscall.h> 72 #include <sys/syscallargs.h> 73 74 #include <uvm/uvm.h> 75 #include <uvm/uvm_device.h> 76 #include <uvm/uvm_vnode.h> 77 78 int uvm_mmapanon(vm_map_t, vaddr_t *, vsize_t, vm_prot_t, vm_prot_t, int, 79 vsize_t, struct proc *); 80 int uvm_mmapfile(vm_map_t, vaddr_t *, vsize_t, vm_prot_t, vm_prot_t, int, 81 struct vnode *, voff_t, vsize_t, struct proc *); 82 83 84 /* 85 * Page align addr and size, returning EINVAL on wraparound. 86 */ 87 #define ALIGN_ADDR(addr, size, pageoff) do { \ 88 pageoff = (addr & PAGE_MASK); \ 89 if (pageoff != 0) { \ 90 if (size > SIZE_MAX - pageoff) \ 91 return EINVAL; /* wraparound */ \ 92 addr -= pageoff; \ 93 size += pageoff; \ 94 } \ 95 if (size != 0) { \ 96 size = (vsize_t)round_page(size); \ 97 if (size == 0) \ 98 return EINVAL; /* wraparound */ \ 99 } \ 100 } while (0) 101 102 /* 103 * sys_mquery: provide mapping hints to applications that do fixed mappings 104 * 105 * flags: 0 or MAP_FIXED (MAP_FIXED - means that we insist on this addr and 106 * don't care about PMAP_PREFER or such) 107 * addr: hint where we'd like to place the mapping. 108 * size: size of the mapping 109 * fd: fd of the file we want to map 110 * off: offset within the file 111 */ 112 int 113 sys_mquery(struct proc *p, void *v, register_t *retval) 114 { 115 struct sys_mquery_args /* { 116 syscallarg(void *) addr; 117 syscallarg(size_t) len; 118 syscallarg(int) prot; 119 syscallarg(int) flags; 120 syscallarg(int) fd; 121 syscallarg(off_t) pos; 122 } */ *uap = v; 123 struct file *fp; 124 voff_t uoff; 125 int error; 126 vaddr_t vaddr; 127 int flags = 0; 128 vsize_t size; 129 vm_prot_t prot; 130 int fd; 131 132 vaddr = (vaddr_t) SCARG(uap, addr); 133 prot = SCARG(uap, prot); 134 size = (vsize_t) SCARG(uap, len); 135 fd = SCARG(uap, fd); 136 137 if ((prot & PROT_MASK) != prot) 138 return EINVAL; 139 140 if (SCARG(uap, flags) & MAP_FIXED) 141 flags |= UVM_FLAG_FIXED; 142 143 if (fd >= 0) { 144 if ((error = getvnode(p, fd, &fp)) != 0) 145 return error; 146 uoff = SCARG(uap, pos); 147 } else { 148 fp = NULL; 149 uoff = UVM_UNKNOWN_OFFSET; 150 } 151 152 if (vaddr == 0) 153 vaddr = uvm_map_hint(p->p_vmspace, prot, VM_MIN_ADDRESS, 154 VM_MAXUSER_ADDRESS); 155 156 error = uvm_map_mquery(&p->p_vmspace->vm_map, &vaddr, size, uoff, 157 flags); 158 if (error == 0) 159 *retval = (register_t)(vaddr); 160 161 if (fp != NULL) 162 FRELE(fp, p); 163 return error; 164 } 165 166 int uvm_wxabort; 167 168 /* 169 * W^X violations are only allowed on permitted filesystems. 170 */ 171 static inline int 172 uvm_wxcheck(struct proc *p, char *call) 173 { 174 struct process *pr = p->p_p; 175 int wxallowed = (pr->ps_textvp->v_mount && 176 (pr->ps_textvp->v_mount->mnt_flag & MNT_WXALLOWED)); 177 178 if (wxallowed && (pr->ps_flags & PS_WXNEEDED)) 179 return 0; 180 181 if (uvm_wxabort) { 182 KERNEL_LOCK(); 183 /* Report W^X failures */ 184 if (pr->ps_wxcounter++ == 0) 185 log(LOG_NOTICE, "%s(%d): %s W^X violation\n", 186 pr->ps_comm, pr->ps_pid, call); 187 /* Send uncatchable SIGABRT for coredump */ 188 sigexit(p, SIGABRT); 189 KERNEL_UNLOCK(); 190 } 191 192 return ENOTSUP; 193 } 194 195 /* 196 * sys_mmap: mmap system call. 197 * 198 * => file offset and address may not be page aligned 199 * - if MAP_FIXED, offset and address must have remainder mod PAGE_SIZE 200 * - if address isn't page aligned the mapping starts at trunc_page(addr) 201 * and the return value is adjusted up by the page offset. 202 */ 203 int 204 sys_mmap(struct proc *p, void *v, register_t *retval) 205 { 206 struct sys_mmap_args /* { 207 syscallarg(void *) addr; 208 syscallarg(size_t) len; 209 syscallarg(int) prot; 210 syscallarg(int) flags; 211 syscallarg(int) fd; 212 syscallarg(off_t) pos; 213 } */ *uap = v; 214 vaddr_t addr; 215 struct vattr va; 216 off_t pos; 217 vsize_t limit, pageoff, size; 218 vm_prot_t prot, maxprot; 219 int flags, fd; 220 vaddr_t vm_min_address = VM_MIN_ADDRESS; 221 struct filedesc *fdp = p->p_fd; 222 struct file *fp = NULL; 223 struct vnode *vp; 224 int error; 225 226 /* first, extract syscall args from the uap. */ 227 addr = (vaddr_t) SCARG(uap, addr); 228 size = (vsize_t) SCARG(uap, len); 229 prot = SCARG(uap, prot); 230 flags = SCARG(uap, flags); 231 fd = SCARG(uap, fd); 232 pos = SCARG(uap, pos); 233 234 /* 235 * Validate the flags. 236 */ 237 if ((prot & PROT_MASK) != prot) 238 return EINVAL; 239 if ((prot & (PROT_WRITE | PROT_EXEC)) == (PROT_WRITE | PROT_EXEC) && 240 (error = uvm_wxcheck(p, "mmap"))) 241 return error; 242 243 if ((flags & MAP_FLAGMASK) != flags) 244 return EINVAL; 245 if ((flags & (MAP_SHARED|MAP_PRIVATE)) == (MAP_SHARED|MAP_PRIVATE)) 246 return EINVAL; 247 if ((flags & (MAP_FIXED|__MAP_NOREPLACE)) == __MAP_NOREPLACE) 248 return EINVAL; 249 if (flags & MAP_STACK) { 250 if ((flags & (MAP_ANON|MAP_PRIVATE)) != (MAP_ANON|MAP_PRIVATE)) 251 return EINVAL; 252 if (flags & ~(MAP_STACK|MAP_FIXED|MAP_ANON|MAP_PRIVATE)) 253 return EINVAL; 254 if (pos != 0) 255 return EINVAL; 256 if ((prot & (PROT_READ|PROT_WRITE)) != (PROT_READ|PROT_WRITE)) 257 return EINVAL; 258 } 259 if (size == 0) 260 return EINVAL; 261 262 error = pledge_protexec(p, prot); 263 if (error) 264 return error; 265 266 /* align file position and save offset. adjust size. */ 267 ALIGN_ADDR(pos, size, pageoff); 268 269 /* now check (MAP_FIXED) or get (!MAP_FIXED) the "addr" */ 270 if (flags & MAP_FIXED) { 271 /* adjust address by the same amount as we did the offset */ 272 addr -= pageoff; 273 if (addr & PAGE_MASK) 274 return EINVAL; /* not page aligned */ 275 276 if (addr > SIZE_MAX - size) 277 return EINVAL; /* no wrapping! */ 278 if (VM_MAXUSER_ADDRESS > 0 && 279 (addr + size) > VM_MAXUSER_ADDRESS) 280 return EINVAL; 281 if (vm_min_address > 0 && addr < vm_min_address) 282 return EINVAL; 283 } 284 285 /* check for file mappings (i.e. not anonymous) and verify file. */ 286 if ((flags & MAP_ANON) == 0) { 287 KERNEL_LOCK(); 288 if ((fp = fd_getfile(fdp, fd)) == NULL) { 289 error = EBADF; 290 goto out; 291 } 292 293 if (fp->f_type != DTYPE_VNODE) { 294 error = ENODEV; /* only mmap vnodes! */ 295 goto out; 296 } 297 vp = (struct vnode *)fp->f_data; /* convert to vnode */ 298 299 if (vp->v_type != VREG && vp->v_type != VCHR && 300 vp->v_type != VBLK) { 301 error = ENODEV; /* only REG/CHR/BLK support mmap */ 302 goto out; 303 } 304 305 if (vp->v_type == VREG && (pos + size) < pos) { 306 error = EINVAL; /* no offset wrapping */ 307 goto out; 308 } 309 310 /* special case: catch SunOS style /dev/zero */ 311 if (vp->v_type == VCHR && iszerodev(vp->v_rdev)) { 312 flags |= MAP_ANON; 313 FRELE(fp, p); 314 fp = NULL; 315 KERNEL_UNLOCK(); 316 goto is_anon; 317 } 318 319 /* 320 * Old programs may not select a specific sharing type, so 321 * default to an appropriate one. 322 */ 323 if ((flags & (MAP_SHARED|MAP_PRIVATE)) == 0) { 324 #if defined(DEBUG) 325 printf("WARNING: defaulted mmap() share type to" 326 " %s (pid %d comm %s)\n", 327 vp->v_type == VCHR ? "MAP_SHARED" : "MAP_PRIVATE", 328 p->p_p->ps_pid, p->p_p->ps_comm); 329 #endif 330 if (vp->v_type == VCHR) 331 flags |= MAP_SHARED; /* for a device */ 332 else 333 flags |= MAP_PRIVATE; /* for a file */ 334 } 335 336 /* 337 * MAP_PRIVATE device mappings don't make sense (and aren't 338 * supported anyway). However, some programs rely on this, 339 * so just change it to MAP_SHARED. 340 */ 341 if (vp->v_type == VCHR && (flags & MAP_PRIVATE) != 0) { 342 flags = (flags & ~MAP_PRIVATE) | MAP_SHARED; 343 } 344 345 /* now check protection */ 346 maxprot = PROT_EXEC; 347 348 /* check read access */ 349 if (fp->f_flag & FREAD) 350 maxprot |= PROT_READ; 351 else if (prot & PROT_READ) { 352 error = EACCES; 353 goto out; 354 } 355 356 /* check write access, shared case first */ 357 if (flags & MAP_SHARED) { 358 /* 359 * if the file is writable, only add PROT_WRITE to 360 * maxprot if the file is not immutable, append-only. 361 * otherwise, if we have asked for PROT_WRITE, return 362 * EPERM. 363 */ 364 if (fp->f_flag & FWRITE) { 365 error = VOP_GETATTR(vp, &va, p->p_ucred, p); 366 if (error) 367 goto out; 368 if ((va.va_flags & (IMMUTABLE|APPEND)) == 0) 369 maxprot |= PROT_WRITE; 370 else if (prot & PROT_WRITE) { 371 error = EPERM; 372 goto out; 373 } 374 } else if (prot & PROT_WRITE) { 375 error = EACCES; 376 goto out; 377 } 378 } else { 379 /* MAP_PRIVATE mappings can always write to */ 380 maxprot |= PROT_WRITE; 381 } 382 if ((flags & __MAP_NOFAULT) != 0 || 383 ((flags & MAP_PRIVATE) != 0 && (prot & PROT_WRITE) != 0)) { 384 limit = lim_cur(RLIMIT_DATA); 385 if (limit < size || 386 limit - size < ptoa(p->p_vmspace->vm_dused)) { 387 error = ENOMEM; 388 goto out; 389 } 390 } 391 error = uvm_mmapfile(&p->p_vmspace->vm_map, &addr, size, prot, 392 maxprot, flags, vp, pos, lim_cur(RLIMIT_MEMLOCK), p); 393 FRELE(fp, p); 394 KERNEL_UNLOCK(); 395 } else { /* MAP_ANON case */ 396 if (fd != -1) 397 return EINVAL; 398 399 is_anon: /* label for SunOS style /dev/zero */ 400 401 /* __MAP_NOFAULT only makes sense with a backing object */ 402 if ((flags & __MAP_NOFAULT) != 0) 403 return EINVAL; 404 405 if (prot != PROT_NONE || (flags & MAP_SHARED)) { 406 limit = lim_cur(RLIMIT_DATA); 407 if (limit < size || 408 limit - size < ptoa(p->p_vmspace->vm_dused)) { 409 return ENOMEM; 410 } 411 } 412 413 /* 414 * We've been treating (MAP_SHARED|MAP_PRIVATE) == 0 as 415 * MAP_PRIVATE, so make that clear. 416 */ 417 if ((flags & MAP_SHARED) == 0) 418 flags |= MAP_PRIVATE; 419 420 maxprot = PROT_MASK; 421 error = uvm_mmapanon(&p->p_vmspace->vm_map, &addr, size, prot, 422 maxprot, flags, lim_cur(RLIMIT_MEMLOCK), p); 423 } 424 425 if (error == 0) 426 /* remember to add offset */ 427 *retval = (register_t)(addr + pageoff); 428 429 return error; 430 431 out: 432 KERNEL_UNLOCK(); 433 if (fp) 434 FRELE(fp, p); 435 return error; 436 } 437 438 /* 439 * sys_msync: the msync system call (a front-end for flush) 440 */ 441 442 int 443 sys_msync(struct proc *p, void *v, register_t *retval) 444 { 445 struct sys_msync_args /* { 446 syscallarg(void *) addr; 447 syscallarg(size_t) len; 448 syscallarg(int) flags; 449 } */ *uap = v; 450 vaddr_t addr; 451 vsize_t size, pageoff; 452 int flags, uvmflags; 453 454 /* extract syscall args from the uap */ 455 addr = (vaddr_t)SCARG(uap, addr); 456 size = (vsize_t)SCARG(uap, len); 457 flags = SCARG(uap, flags); 458 459 /* sanity check flags */ 460 if ((flags & ~(MS_ASYNC | MS_SYNC | MS_INVALIDATE)) != 0 || 461 (flags & (MS_ASYNC | MS_SYNC | MS_INVALIDATE)) == 0 || 462 (flags & (MS_ASYNC | MS_SYNC)) == (MS_ASYNC | MS_SYNC)) 463 return EINVAL; 464 if ((flags & (MS_ASYNC | MS_SYNC)) == 0) 465 flags |= MS_SYNC; 466 467 /* align the address to a page boundary, and adjust the size accordingly */ 468 ALIGN_ADDR(addr, size, pageoff); 469 if (addr > SIZE_MAX - size) 470 return EINVAL; /* disallow wrap-around. */ 471 472 /* translate MS_ flags into PGO_ flags */ 473 uvmflags = PGO_CLEANIT; 474 if (flags & MS_INVALIDATE) 475 uvmflags |= PGO_FREE; 476 if (flags & MS_SYNC) 477 uvmflags |= PGO_SYNCIO; 478 else 479 uvmflags |= PGO_SYNCIO; /* XXXCDC: force sync for now! */ 480 481 return uvm_map_clean(&p->p_vmspace->vm_map, addr, addr+size, uvmflags); 482 } 483 484 /* 485 * sys_munmap: unmap a users memory 486 */ 487 int 488 sys_munmap(struct proc *p, void *v, register_t *retval) 489 { 490 struct sys_munmap_args /* { 491 syscallarg(void *) addr; 492 syscallarg(size_t) len; 493 } */ *uap = v; 494 vaddr_t addr; 495 vsize_t size, pageoff; 496 vm_map_t map; 497 vaddr_t vm_min_address = VM_MIN_ADDRESS; 498 struct uvm_map_deadq dead_entries; 499 500 /* get syscall args... */ 501 addr = (vaddr_t) SCARG(uap, addr); 502 size = (vsize_t) SCARG(uap, len); 503 504 /* align address to a page boundary, and adjust size accordingly */ 505 ALIGN_ADDR(addr, size, pageoff); 506 507 /* 508 * Check for illegal addresses. Watch out for address wrap... 509 * Note that VM_*_ADDRESS are not constants due to casts (argh). 510 */ 511 if (addr > SIZE_MAX - size) 512 return EINVAL; 513 if (VM_MAXUSER_ADDRESS > 0 && addr + size > VM_MAXUSER_ADDRESS) 514 return EINVAL; 515 if (vm_min_address > 0 && addr < vm_min_address) 516 return EINVAL; 517 map = &p->p_vmspace->vm_map; 518 519 520 vm_map_lock(map); /* lock map so we can checkprot */ 521 522 /* 523 * interesting system call semantic: make sure entire range is 524 * allocated before allowing an unmap. 525 */ 526 if (!uvm_map_checkprot(map, addr, addr + size, PROT_NONE)) { 527 vm_map_unlock(map); 528 return EINVAL; 529 } 530 531 TAILQ_INIT(&dead_entries); 532 if (uvm_unmap_remove(map, addr, addr + size, &dead_entries, 533 FALSE, TRUE, TRUE) != 0) { 534 vm_map_unlock(map); 535 return EPERM; /* immutable entries found */ 536 } 537 vm_map_unlock(map); /* and unlock */ 538 539 uvm_unmap_detach(&dead_entries, 0); 540 541 return 0; 542 } 543 544 /* 545 * sys_mprotect: the mprotect system call 546 */ 547 int 548 sys_mprotect(struct proc *p, void *v, register_t *retval) 549 { 550 struct sys_mprotect_args /* { 551 syscallarg(void *) addr; 552 syscallarg(size_t) len; 553 syscallarg(int) prot; 554 } */ *uap = v; 555 vaddr_t addr; 556 vsize_t size, pageoff; 557 vm_prot_t prot; 558 int error; 559 560 /* 561 * extract syscall args from uap 562 */ 563 564 addr = (vaddr_t)SCARG(uap, addr); 565 size = (vsize_t)SCARG(uap, len); 566 prot = SCARG(uap, prot); 567 568 if ((prot & PROT_MASK) != prot) 569 return EINVAL; 570 if ((prot & (PROT_WRITE | PROT_EXEC)) == (PROT_WRITE | PROT_EXEC) && 571 (error = uvm_wxcheck(p, "mprotect"))) 572 return error; 573 574 error = pledge_protexec(p, prot); 575 if (error) 576 return error; 577 578 /* 579 * align the address to a page boundary, and adjust the size accordingly 580 */ 581 ALIGN_ADDR(addr, size, pageoff); 582 if (addr > SIZE_MAX - size) 583 return EINVAL; /* disallow wrap-around. */ 584 585 return (uvm_map_protect(&p->p_vmspace->vm_map, addr, addr+size, 586 prot, 0, FALSE, TRUE)); 587 } 588 589 /* 590 * sys_msyscall: the msyscall system call 591 */ 592 int 593 sys_msyscall(struct proc *p, void *v, register_t *retval) 594 { 595 struct sys_msyscall_args /* { 596 syscallarg(void *) addr; 597 syscallarg(size_t) len; 598 } */ *uap = v; 599 vaddr_t addr; 600 vsize_t size, pageoff; 601 602 addr = (vaddr_t)SCARG(uap, addr); 603 size = (vsize_t)SCARG(uap, len); 604 605 /* 606 * align the address to a page boundary, and adjust the size accordingly 607 */ 608 ALIGN_ADDR(addr, size, pageoff); 609 if (addr > SIZE_MAX - size) 610 return EINVAL; /* disallow wrap-around. */ 611 612 return uvm_map_syscall(&p->p_vmspace->vm_map, addr, addr+size); 613 } 614 615 /* 616 * sys_pinsyscall 617 */ 618 int 619 sys_pinsyscall(struct proc *p, void *v, register_t *retval) 620 { 621 return (0); 622 } 623 624 /* 625 * sys_pinsyscalls. The caller is required to normalize base,len 626 * to the minimum .text region, and adjust pintable offsets relative 627 * to that base. 628 */ 629 int 630 sys_pinsyscalls(struct proc *p, void *v, register_t *retval) 631 { 632 struct sys_pinsyscalls_args /* { 633 syscallarg(void *) base; 634 syscallarg(size_t) len; 635 syscallarg(u_int *) pins; 636 syscallarg(int) npins; 637 } */ *uap = v; 638 struct process *pr = p->p_p; 639 int npins, error = 0, i; 640 vaddr_t base; 641 size_t len; 642 u_int *pins; 643 644 if (pr->ps_libcpin.pn_start || 645 (pr->ps_vmspace->vm_map.flags & VM_MAP_PINSYSCALL_ONCE)) 646 return (EPERM); 647 base = (vaddr_t)SCARG(uap, base); 648 len = (vsize_t)SCARG(uap, len); 649 if (base > SIZE_MAX - len) 650 return (EINVAL); /* disallow wrap-around. */ 651 652 /* XXX MP unlock */ 653 654 npins = SCARG(uap, npins); 655 if (npins < 1 || npins > SYS_MAXSYSCALL) 656 return (E2BIG); 657 pins = malloc(npins * sizeof(u_int), M_PINSYSCALL, M_WAITOK|M_ZERO); 658 if (pins == NULL) 659 return (ENOMEM); 660 error = copyin(SCARG(uap, pins), pins, npins * sizeof(u_int)); 661 if (error) 662 goto err; 663 664 /* Range-check pintable offsets */ 665 for (i = 0; i < npins; i++) { 666 if (pins[i] == (u_int)-1 || pins[i] == 0) 667 continue; 668 if (pins[i] > SCARG(uap, len)) { 669 error = ERANGE; 670 break; 671 } 672 } 673 if (error) { 674 err: 675 free(pins, M_PINSYSCALL, npins * sizeof(u_int)); 676 return (error); 677 } 678 pr->ps_libcpin.pn_start = base; 679 pr->ps_libcpin.pn_end = base + len; 680 pr->ps_libcpin.pn_pins = pins; 681 pr->ps_libcpin.pn_npins = npins; 682 pr->ps_flags |= PS_LIBCPIN; 683 return (0); 684 } 685 686 /* 687 * sys_mimmutable: the mimmutable system call 688 */ 689 int 690 sys_mimmutable(struct proc *p, void *v, register_t *retval) 691 { 692 struct sys_mimmutable_args /* { 693 immutablearg(void *) addr; 694 immutablearg(size_t) len; 695 } */ *uap = v; 696 vaddr_t addr; 697 vsize_t size, pageoff; 698 699 addr = (vaddr_t)SCARG(uap, addr); 700 size = (vsize_t)SCARG(uap, len); 701 702 /* 703 * align the address to a page boundary, and adjust the size accordingly 704 */ 705 ALIGN_ADDR(addr, size, pageoff); 706 if (addr > SIZE_MAX - size) 707 return EINVAL; /* disallow wrap-around. */ 708 709 return uvm_map_immutable(&p->p_vmspace->vm_map, addr, addr+size, 1); 710 } 711 712 /* 713 * sys_minherit: the minherit system call 714 */ 715 int 716 sys_minherit(struct proc *p, void *v, register_t *retval) 717 { 718 struct sys_minherit_args /* { 719 syscallarg(void *) addr; 720 syscallarg(size_t) len; 721 syscallarg(int) inherit; 722 } */ *uap = v; 723 vaddr_t addr; 724 vsize_t size, pageoff; 725 vm_inherit_t inherit; 726 727 addr = (vaddr_t)SCARG(uap, addr); 728 size = (vsize_t)SCARG(uap, len); 729 inherit = SCARG(uap, inherit); 730 731 /* 732 * align the address to a page boundary, and adjust the size accordingly 733 */ 734 ALIGN_ADDR(addr, size, pageoff); 735 if (addr > SIZE_MAX - size) 736 return EINVAL; /* disallow wrap-around. */ 737 738 return (uvm_map_inherit(&p->p_vmspace->vm_map, addr, addr+size, 739 inherit)); 740 } 741 742 /* 743 * sys_madvise: give advice about memory usage. 744 */ 745 int 746 sys_madvise(struct proc *p, void *v, register_t *retval) 747 { 748 struct sys_madvise_args /* { 749 syscallarg(void *) addr; 750 syscallarg(size_t) len; 751 syscallarg(int) behav; 752 } */ *uap = v; 753 vaddr_t addr; 754 vsize_t size, pageoff; 755 int advice, error; 756 757 addr = (vaddr_t)SCARG(uap, addr); 758 size = (vsize_t)SCARG(uap, len); 759 advice = SCARG(uap, behav); 760 761 /* 762 * align the address to a page boundary, and adjust the size accordingly 763 */ 764 ALIGN_ADDR(addr, size, pageoff); 765 if (addr > SIZE_MAX - size) 766 return EINVAL; /* disallow wrap-around. */ 767 768 switch (advice) { 769 case MADV_NORMAL: 770 case MADV_RANDOM: 771 case MADV_SEQUENTIAL: 772 error = uvm_map_advice(&p->p_vmspace->vm_map, addr, 773 addr + size, advice); 774 break; 775 776 case MADV_WILLNEED: 777 /* 778 * Activate all these pages, pre-faulting them in if 779 * necessary. 780 */ 781 /* 782 * XXX IMPLEMENT ME. 783 * Should invent a "weak" mode for uvm_fault() 784 * which would only do the PGO_LOCKED pgo_get(). 785 */ 786 return 0; 787 788 case MADV_DONTNEED: 789 /* 790 * Deactivate all these pages. We don't need them 791 * any more. We don't, however, toss the data in 792 * the pages. 793 */ 794 error = uvm_map_clean(&p->p_vmspace->vm_map, addr, addr + size, 795 PGO_DEACTIVATE); 796 break; 797 798 case MADV_FREE: 799 /* 800 * These pages contain no valid data, and may be 801 * garbage-collected. Toss all resources, including 802 * any swap space in use. 803 */ 804 error = uvm_map_clean(&p->p_vmspace->vm_map, addr, addr + size, 805 PGO_FREE); 806 break; 807 808 case MADV_SPACEAVAIL: 809 /* 810 * XXXMRG What is this? I think it's: 811 * 812 * Ensure that we have allocated backing-store 813 * for these pages. 814 * 815 * This is going to require changes to the page daemon, 816 * as it will free swap space allocated to pages in core. 817 * There's also what to do for device/file/anonymous memory. 818 */ 819 return EINVAL; 820 821 default: 822 return EINVAL; 823 } 824 825 return error; 826 } 827 828 /* 829 * sys_mlock: memory lock 830 */ 831 832 int 833 sys_mlock(struct proc *p, void *v, register_t *retval) 834 { 835 struct sys_mlock_args /* { 836 syscallarg(const void *) addr; 837 syscallarg(size_t) len; 838 } */ *uap = v; 839 vaddr_t addr; 840 vsize_t size, pageoff; 841 int error; 842 843 /* extract syscall args from uap */ 844 addr = (vaddr_t)SCARG(uap, addr); 845 size = (vsize_t)SCARG(uap, len); 846 847 /* align address to a page boundary and adjust size accordingly */ 848 ALIGN_ADDR(addr, size, pageoff); 849 if (addr > SIZE_MAX - size) 850 return EINVAL; /* disallow wrap-around. */ 851 852 if (atop(size) + uvmexp.wired > uvmexp.wiredmax) 853 return EAGAIN; 854 855 #ifdef pmap_wired_count 856 if (size + ptoa(pmap_wired_count(vm_map_pmap(&p->p_vmspace->vm_map))) > 857 lim_cur(RLIMIT_MEMLOCK)) 858 return EAGAIN; 859 #else 860 if ((error = suser(p)) != 0) 861 return error; 862 #endif 863 864 error = uvm_map_pageable(&p->p_vmspace->vm_map, addr, addr+size, FALSE, 865 0); 866 return error == 0 ? 0 : ENOMEM; 867 } 868 869 /* 870 * sys_munlock: unlock wired pages 871 */ 872 873 int 874 sys_munlock(struct proc *p, void *v, register_t *retval) 875 { 876 struct sys_munlock_args /* { 877 syscallarg(const void *) addr; 878 syscallarg(size_t) len; 879 } */ *uap = v; 880 vaddr_t addr; 881 vsize_t size, pageoff; 882 int error; 883 884 /* extract syscall args from uap */ 885 addr = (vaddr_t)SCARG(uap, addr); 886 size = (vsize_t)SCARG(uap, len); 887 888 /* align address to a page boundary, and adjust size accordingly */ 889 ALIGN_ADDR(addr, size, pageoff); 890 if (addr > SIZE_MAX - size) 891 return EINVAL; /* disallow wrap-around. */ 892 893 #ifndef pmap_wired_count 894 if ((error = suser(p)) != 0) 895 return error; 896 #endif 897 898 error = uvm_map_pageable(&p->p_vmspace->vm_map, addr, addr+size, TRUE, 899 0); 900 return error == 0 ? 0 : ENOMEM; 901 } 902 903 /* 904 * sys_mlockall: lock all pages mapped into an address space. 905 */ 906 int 907 sys_mlockall(struct proc *p, void *v, register_t *retval) 908 { 909 struct sys_mlockall_args /* { 910 syscallarg(int) flags; 911 } */ *uap = v; 912 int error, flags; 913 914 flags = SCARG(uap, flags); 915 916 if (flags == 0 || 917 (flags & ~(MCL_CURRENT|MCL_FUTURE)) != 0) 918 return EINVAL; 919 920 #ifndef pmap_wired_count 921 if ((error = suser(p)) != 0) 922 return error; 923 #endif 924 925 error = uvm_map_pageable_all(&p->p_vmspace->vm_map, flags, 926 lim_cur(RLIMIT_MEMLOCK)); 927 if (error != 0 && error != ENOMEM) 928 return EAGAIN; 929 return error; 930 } 931 932 /* 933 * sys_munlockall: unlock all pages mapped into an address space. 934 */ 935 int 936 sys_munlockall(struct proc *p, void *v, register_t *retval) 937 { 938 939 (void) uvm_map_pageable_all(&p->p_vmspace->vm_map, 0, 0); 940 return 0; 941 } 942 943 /* 944 * common code for mmapanon and mmapfile to lock a mmaping 945 */ 946 int 947 uvm_mmaplock(vm_map_t map, vaddr_t *addr, vsize_t size, vm_prot_t prot, 948 vsize_t locklimit) 949 { 950 int error; 951 952 /* 953 * POSIX 1003.1b -- if our address space was configured 954 * to lock all future mappings, wire the one we just made. 955 */ 956 if (prot == PROT_NONE) { 957 /* 958 * No more work to do in this case. 959 */ 960 return 0; 961 } 962 963 vm_map_lock(map); 964 if (map->flags & VM_MAP_WIREFUTURE) { 965 KERNEL_LOCK(); 966 if ((atop(size) + uvmexp.wired) > uvmexp.wiredmax 967 #ifdef pmap_wired_count 968 || (locklimit != 0 && (size + 969 ptoa(pmap_wired_count(vm_map_pmap(map)))) > 970 locklimit) 971 #endif 972 ) { 973 error = ENOMEM; 974 vm_map_unlock(map); 975 /* unmap the region! */ 976 uvm_unmap(map, *addr, *addr + size); 977 KERNEL_UNLOCK(); 978 return error; 979 } 980 /* 981 * uvm_map_pageable() always returns the map 982 * unlocked. 983 */ 984 error = uvm_map_pageable(map, *addr, *addr + size, 985 FALSE, UVM_LK_ENTER); 986 if (error != 0) { 987 /* unmap the region! */ 988 uvm_unmap(map, *addr, *addr + size); 989 KERNEL_UNLOCK(); 990 return error; 991 } 992 KERNEL_UNLOCK(); 993 return 0; 994 } 995 vm_map_unlock(map); 996 return 0; 997 } 998 999 /* 1000 * uvm_mmapanon: internal version of mmap for anons 1001 * 1002 * - used by sys_mmap 1003 */ 1004 int 1005 uvm_mmapanon(vm_map_t map, vaddr_t *addr, vsize_t size, vm_prot_t prot, 1006 vm_prot_t maxprot, int flags, vsize_t locklimit, struct proc *p) 1007 { 1008 int error; 1009 int advice = MADV_NORMAL; 1010 unsigned int uvmflag = 0; 1011 vsize_t align = 0; /* userland page size */ 1012 1013 /* 1014 * for non-fixed mappings, round off the suggested address. 1015 * for fixed mappings, check alignment and zap old mappings. 1016 */ 1017 if ((flags & MAP_FIXED) == 0) { 1018 *addr = round_page(*addr); /* round */ 1019 } else { 1020 if (*addr & PAGE_MASK) 1021 return EINVAL; 1022 1023 uvmflag |= UVM_FLAG_FIXED; 1024 if ((flags & __MAP_NOREPLACE) == 0) 1025 uvmflag |= UVM_FLAG_UNMAP; 1026 } 1027 1028 if ((flags & MAP_FIXED) == 0 && size >= __LDPGSZ) 1029 align = __LDPGSZ; 1030 if ((flags & MAP_SHARED) == 0) 1031 /* XXX: defer amap create */ 1032 uvmflag |= UVM_FLAG_COPYONW; 1033 else 1034 /* shared: create amap now */ 1035 uvmflag |= UVM_FLAG_OVERLAY; 1036 if (flags & MAP_STACK) 1037 uvmflag |= UVM_FLAG_STACK; 1038 if (flags & MAP_CONCEAL) 1039 uvmflag |= UVM_FLAG_CONCEAL; 1040 1041 /* set up mapping flags */ 1042 uvmflag = UVM_MAPFLAG(prot, maxprot, 1043 (flags & MAP_SHARED) ? MAP_INHERIT_SHARE : MAP_INHERIT_COPY, 1044 advice, uvmflag); 1045 1046 error = uvm_mapanon(map, addr, size, align, uvmflag); 1047 1048 if (error == 0) 1049 error = uvm_mmaplock(map, addr, size, prot, locklimit); 1050 return error; 1051 } 1052 1053 /* 1054 * uvm_mmapfile: internal version of mmap for non-anons 1055 * 1056 * - used by sys_mmap 1057 * - caller must page-align the file offset 1058 */ 1059 int 1060 uvm_mmapfile(vm_map_t map, vaddr_t *addr, vsize_t size, vm_prot_t prot, 1061 vm_prot_t maxprot, int flags, struct vnode *vp, voff_t foff, 1062 vsize_t locklimit, struct proc *p) 1063 { 1064 struct uvm_object *uobj; 1065 int error; 1066 int advice = MADV_NORMAL; 1067 unsigned int uvmflag = 0; 1068 vsize_t align = 0; /* userland page size */ 1069 1070 /* 1071 * for non-fixed mappings, round off the suggested address. 1072 * for fixed mappings, check alignment and zap old mappings. 1073 */ 1074 if ((flags & MAP_FIXED) == 0) { 1075 *addr = round_page(*addr); /* round */ 1076 } else { 1077 if (*addr & PAGE_MASK) 1078 return EINVAL; 1079 1080 uvmflag |= UVM_FLAG_FIXED; 1081 if ((flags & __MAP_NOREPLACE) == 0) 1082 uvmflag |= UVM_FLAG_UNMAP; 1083 } 1084 1085 /* 1086 * attach to underlying vm object. 1087 */ 1088 if (vp->v_type != VCHR) { 1089 uobj = uvn_attach(vp, (flags & MAP_SHARED) ? 1090 maxprot : (maxprot & ~PROT_WRITE)); 1091 1092 /* 1093 * XXXCDC: hack from old code 1094 * don't allow vnodes which have been mapped 1095 * shared-writeable to persist [forces them to be 1096 * flushed out when last reference goes]. 1097 * XXXCDC: interesting side effect: avoids a bug. 1098 * note that in WRITE [ufs_readwrite.c] that we 1099 * allocate buffer, uncache, and then do the write. 1100 * the problem with this is that if the uncache causes 1101 * VM data to be flushed to the same area of the file 1102 * we are writing to... in that case we've got the 1103 * buffer locked and our process goes to sleep forever. 1104 * 1105 * XXXCDC: checking maxprot protects us from the 1106 * "persistbug" program but this is not a long term 1107 * solution. 1108 * 1109 * XXXCDC: we don't bother calling uncache with the vp 1110 * VOP_LOCKed since we know that we are already 1111 * holding a valid reference to the uvn (from the 1112 * uvn_attach above), and thus it is impossible for 1113 * the uncache to kill the uvn and trigger I/O. 1114 */ 1115 if (flags & MAP_SHARED) { 1116 if ((prot & PROT_WRITE) || 1117 (maxprot & PROT_WRITE)) { 1118 uvm_vnp_uncache(vp); 1119 } 1120 } 1121 } else { 1122 uobj = udv_attach(vp->v_rdev, 1123 (flags & MAP_SHARED) ? maxprot : 1124 (maxprot & ~PROT_WRITE), foff, size); 1125 /* 1126 * XXX Some devices don't like to be mapped with 1127 * XXX PROT_EXEC, but we don't really have a 1128 * XXX better way of handling this, right now 1129 */ 1130 if (uobj == NULL && (prot & PROT_EXEC) == 0) { 1131 maxprot &= ~PROT_EXEC; 1132 uobj = udv_attach(vp->v_rdev, 1133 (flags & MAP_SHARED) ? maxprot : 1134 (maxprot & ~PROT_WRITE), foff, size); 1135 } 1136 advice = MADV_RANDOM; 1137 } 1138 1139 if (uobj == NULL) 1140 return vp->v_type == VREG ? ENOMEM : EINVAL; 1141 1142 if ((flags & MAP_SHARED) == 0) 1143 uvmflag |= UVM_FLAG_COPYONW; 1144 if (flags & __MAP_NOFAULT) 1145 uvmflag |= (UVM_FLAG_NOFAULT | UVM_FLAG_OVERLAY); 1146 if (flags & MAP_STACK) 1147 uvmflag |= UVM_FLAG_STACK; 1148 if (flags & MAP_CONCEAL) 1149 uvmflag |= UVM_FLAG_CONCEAL; 1150 1151 /* set up mapping flags */ 1152 uvmflag = UVM_MAPFLAG(prot, maxprot, 1153 (flags & MAP_SHARED) ? MAP_INHERIT_SHARE : MAP_INHERIT_COPY, 1154 advice, uvmflag); 1155 1156 error = uvm_map(map, addr, size, uobj, foff, align, uvmflag); 1157 1158 if (error == 0) 1159 return uvm_mmaplock(map, addr, size, prot, locklimit); 1160 1161 /* errors: first detach from the uobj, if any. */ 1162 if (uobj) 1163 uobj->pgops->pgo_detach(uobj); 1164 1165 return error; 1166 } 1167 1168 int 1169 sys_kbind(struct proc *p, void *v, register_t *retval) 1170 { 1171 struct sys_kbind_args /* { 1172 syscallarg(const struct __kbind *) param; 1173 syscallarg(size_t) psize; 1174 syscallarg(uint64_t) proc_cookie; 1175 } */ *uap = v; 1176 const struct __kbind *paramp; 1177 union { 1178 struct __kbind uk[KBIND_BLOCK_MAX]; 1179 char upad[KBIND_BLOCK_MAX * sizeof(*paramp) + KBIND_DATA_MAX]; 1180 } param; 1181 struct uvm_map_deadq dead_entries; 1182 struct process *pr = p->p_p; 1183 const char *data; 1184 vaddr_t baseva, last_baseva, endva, pageoffset, kva; 1185 size_t psize, s; 1186 u_long pc; 1187 int count, i, extra; 1188 int error, sigill = 0; 1189 1190 /* 1191 * extract syscall args from uap 1192 */ 1193 paramp = SCARG(uap, param); 1194 psize = SCARG(uap, psize); 1195 1196 /* 1197 * If paramp is NULL and we're uninitialized, disable the syscall 1198 * for the process. Raise SIGILL if paramp is NULL and we're 1199 * already initialized. 1200 * 1201 * If paramp is non-NULL and we're uninitialized, do initialization. 1202 * Otherwise, do security checks and raise SIGILL on failure. 1203 */ 1204 pc = PROC_PC(p); 1205 mtx_enter(&pr->ps_mtx); 1206 if (paramp == NULL) { 1207 /* ld.so disables kbind() when lazy binding is disabled */ 1208 if (pr->ps_kbind_addr == 0) 1209 pr->ps_kbind_addr = BOGO_PC; 1210 /* pre-7.3 static binaries disable kbind */ 1211 /* XXX delete check in 2026 */ 1212 else if (pr->ps_kbind_addr != BOGO_PC) 1213 sigill = 1; 1214 } else if (pr->ps_kbind_addr == 0) { 1215 pr->ps_kbind_addr = pc; 1216 pr->ps_kbind_cookie = SCARG(uap, proc_cookie); 1217 } else if (pc != pr->ps_kbind_addr || pc == BOGO_PC || 1218 pr->ps_kbind_cookie != SCARG(uap, proc_cookie)) { 1219 sigill = 1; 1220 } 1221 mtx_leave(&pr->ps_mtx); 1222 1223 /* Raise SIGILL if something is off. */ 1224 if (sigill) { 1225 KERNEL_LOCK(); 1226 sigexit(p, SIGILL); 1227 /* NOTREACHED */ 1228 KERNEL_UNLOCK(); 1229 } 1230 1231 /* We're done if we were disabling the syscall. */ 1232 if (paramp == NULL) 1233 return 0; 1234 1235 if (psize < sizeof(struct __kbind) || psize > sizeof(param)) 1236 return EINVAL; 1237 if ((error = copyin(paramp, ¶m, psize))) 1238 return error; 1239 1240 /* 1241 * The param argument points to an array of __kbind structures 1242 * followed by the corresponding new data areas for them. Verify 1243 * that the sizes in the __kbind structures add up to the total 1244 * size and find the start of the new area. 1245 */ 1246 paramp = ¶m.uk[0]; 1247 s = psize; 1248 for (count = 0; s > 0 && count < KBIND_BLOCK_MAX; count++) { 1249 if (s < sizeof(*paramp)) 1250 return EINVAL; 1251 s -= sizeof(*paramp); 1252 1253 baseva = (vaddr_t)paramp[count].kb_addr; 1254 endva = baseva + paramp[count].kb_size - 1; 1255 if (paramp[count].kb_addr == NULL || 1256 paramp[count].kb_size == 0 || 1257 paramp[count].kb_size > KBIND_DATA_MAX || 1258 baseva >= VM_MAXUSER_ADDRESS || 1259 endva >= VM_MAXUSER_ADDRESS || 1260 s < paramp[count].kb_size) 1261 return EINVAL; 1262 1263 s -= paramp[count].kb_size; 1264 } 1265 if (s > 0) 1266 return EINVAL; 1267 data = (const char *)¶mp[count]; 1268 1269 /* all looks good, so do the bindings */ 1270 last_baseva = VM_MAXUSER_ADDRESS; 1271 kva = 0; 1272 TAILQ_INIT(&dead_entries); 1273 KERNEL_LOCK(); 1274 for (i = 0; i < count; i++) { 1275 baseva = (vaddr_t)paramp[i].kb_addr; 1276 s = paramp[i].kb_size; 1277 pageoffset = baseva & PAGE_MASK; 1278 baseva = trunc_page(baseva); 1279 1280 /* hppa at least runs PLT entries over page edge */ 1281 extra = (pageoffset + s) & PAGE_MASK; 1282 if (extra > pageoffset) 1283 extra = 0; 1284 else 1285 s -= extra; 1286 redo: 1287 /* make sure the desired page is mapped into kernel_map */ 1288 if (baseva != last_baseva) { 1289 if (kva != 0) { 1290 vm_map_lock(kernel_map); 1291 uvm_unmap_remove(kernel_map, kva, 1292 kva+PAGE_SIZE, &dead_entries, 1293 FALSE, TRUE, FALSE); /* XXX */ 1294 vm_map_unlock(kernel_map); 1295 kva = 0; 1296 } 1297 if ((error = uvm_map_extract(&p->p_vmspace->vm_map, 1298 baseva, PAGE_SIZE, &kva, UVM_EXTRACT_FIXPROT))) 1299 break; 1300 last_baseva = baseva; 1301 } 1302 1303 /* do the update */ 1304 if ((error = kcopy(data, (char *)kva + pageoffset, s))) 1305 break; 1306 data += s; 1307 1308 if (extra > 0) { 1309 baseva += PAGE_SIZE; 1310 s = extra; 1311 pageoffset = 0; 1312 extra = 0; 1313 goto redo; 1314 } 1315 } 1316 1317 if (kva != 0) { 1318 vm_map_lock(kernel_map); 1319 uvm_unmap_remove(kernel_map, kva, kva+PAGE_SIZE, 1320 &dead_entries, FALSE, TRUE, FALSE); /* XXX */ 1321 vm_map_unlock(kernel_map); 1322 } 1323 uvm_unmap_detach(&dead_entries, AMAP_REFALL); 1324 KERNEL_UNLOCK(); 1325 1326 return error; 1327 } 1328