Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/kern/uipc_shm.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Copyright (c) 2006, 2011 Robert N. M. Watson 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 /* 28 * Support for shared swap-backed anonymous memory objects via 29 * shm_open(2) and shm_unlink(2). While most of the implementation is 30 * here, vm_mmap.c contains mapping logic changes. 31 * 32 * TODO: 33 * 34 * (1) Need to export data to a userland tool via a sysctl. Should ipcs(1) 35 * and ipcrm(1) be expanded or should new tools to manage both POSIX 36 * kernel semaphores and POSIX shared memory be written? 37 * 38 * (2) Add support for this file type to fstat(1). 39 * 40 * (3) Resource limits? Does this need its own resource limits or are the 41 * existing limits in mmap(2) sufficient? 42 */ 43 44 #include <sys/cdefs.h> 45 __FBSDID("$FreeBSD$"); 46 47 #include "opt_capsicum.h" 48 49 #include <sys/param.h> 50 #include <sys/capability.h> 51 #include <sys/conf.h> 52 #include <sys/fcntl.h> 53 #include <sys/file.h> 54 #include <sys/filedesc.h> 55 #include <sys/fnv_hash.h> 56 #include <sys/kernel.h> 57 #include <sys/lock.h> 58 #include <sys/malloc.h> 59 #include <sys/mman.h> 60 #include <sys/mutex.h> 61 #include <sys/priv.h> 62 #include <sys/proc.h> 63 #include <sys/refcount.h> 64 #include <sys/resourcevar.h> 65 #include <sys/stat.h> 66 #include <sys/sysctl.h> 67 #include <sys/sysproto.h> 68 #include <sys/systm.h> 69 #include <sys/sx.h> 70 #include <sys/time.h> 71 #include <sys/vnode.h> 72 73 #include <security/mac/mac_framework.h> 74 75 #include <vm/vm.h> 76 #include <vm/vm_param.h> 77 #include <vm/pmap.h> 78 #include <vm/vm_extern.h> 79 #include <vm/vm_map.h> 80 #include <vm/vm_kern.h> 81 #include <vm/vm_object.h> 82 #include <vm/vm_page.h> 83 #include <vm/vm_pageout.h> 84 #include <vm/vm_pager.h> 85 #include <vm/swap_pager.h> 86 87 struct shm_mapping { 88 char *sm_path; 89 Fnv32_t sm_fnv; 90 struct shmfd *sm_shmfd; 91 LIST_ENTRY(shm_mapping) sm_link; 92 }; 93 94 static MALLOC_DEFINE(M_SHMFD, "shmfd", "shared memory file descriptor"); 95 static LIST_HEAD(, shm_mapping) *shm_dictionary; 96 static struct sx shm_dict_lock; 97 static struct mtx shm_timestamp_lock; 98 static u_long shm_hash; 99 static struct unrhdr *shm_ino_unr; 100 static dev_t shm_dev_ino; 101 102 #define SHM_HASH(fnv) (&shm_dictionary[(fnv) & shm_hash]) 103 104 static int shm_access(struct shmfd *shmfd, struct ucred *ucred, int flags); 105 static struct shmfd *shm_alloc(struct ucred *ucred, mode_t mode); 106 static void shm_init(void *arg); 107 static void shm_drop(struct shmfd *shmfd); 108 static struct shmfd *shm_hold(struct shmfd *shmfd); 109 static void shm_insert(char *path, Fnv32_t fnv, struct shmfd *shmfd); 110 static struct shmfd *shm_lookup(char *path, Fnv32_t fnv); 111 static int shm_remove(char *path, Fnv32_t fnv, struct ucred *ucred); 112 static int shm_dotruncate(struct shmfd *shmfd, off_t length); 113 114 static fo_rdwr_t shm_read; 115 static fo_rdwr_t shm_write; 116 static fo_truncate_t shm_truncate; 117 static fo_ioctl_t shm_ioctl; 118 static fo_poll_t shm_poll; 119 static fo_kqfilter_t shm_kqfilter; 120 static fo_stat_t shm_stat; 121 static fo_close_t shm_close; 122 static fo_chmod_t shm_chmod; 123 static fo_chown_t shm_chown; 124 125 /* File descriptor operations. */ 126 static struct fileops shm_ops = { 127 .fo_read = shm_read, 128 .fo_write = shm_write, 129 .fo_truncate = shm_truncate, 130 .fo_ioctl = shm_ioctl, 131 .fo_poll = shm_poll, 132 .fo_kqfilter = shm_kqfilter, 133 .fo_stat = shm_stat, 134 .fo_close = shm_close, 135 .fo_chmod = shm_chmod, 136 .fo_chown = shm_chown, 137 .fo_flags = DFLAG_PASSABLE 138 }; 139 140 FEATURE(posix_shm, "POSIX shared memory"); 141 142 static int 143 shm_read(struct file *fp, struct uio *uio, struct ucred *active_cred, 144 int flags, struct thread *td) 145 { 146 147 return (EOPNOTSUPP); 148 } 149 150 static int 151 shm_write(struct file *fp, struct uio *uio, struct ucred *active_cred, 152 int flags, struct thread *td) 153 { 154 155 return (EOPNOTSUPP); 156 } 157 158 static int 159 shm_truncate(struct file *fp, off_t length, struct ucred *active_cred, 160 struct thread *td) 161 { 162 struct shmfd *shmfd; 163 #ifdef MAC 164 int error; 165 #endif 166 167 shmfd = fp->f_data; 168 #ifdef MAC 169 error = mac_posixshm_check_truncate(active_cred, fp->f_cred, shmfd); 170 if (error) 171 return (error); 172 #endif 173 return (shm_dotruncate(shmfd, length)); 174 } 175 176 static int 177 shm_ioctl(struct file *fp, u_long com, void *data, 178 struct ucred *active_cred, struct thread *td) 179 { 180 181 return (EOPNOTSUPP); 182 } 183 184 static int 185 shm_poll(struct file *fp, int events, struct ucred *active_cred, 186 struct thread *td) 187 { 188 189 return (EOPNOTSUPP); 190 } 191 192 static int 193 shm_kqfilter(struct file *fp, struct knote *kn) 194 { 195 196 return (EOPNOTSUPP); 197 } 198 199 static int 200 shm_stat(struct file *fp, struct stat *sb, struct ucred *active_cred, 201 struct thread *td) 202 { 203 struct shmfd *shmfd; 204 #ifdef MAC 205 int error; 206 #endif 207 208 shmfd = fp->f_data; 209 210 #ifdef MAC 211 error = mac_posixshm_check_stat(active_cred, fp->f_cred, shmfd); 212 if (error) 213 return (error); 214 #endif 215 216 /* 217 * Attempt to return sanish values for fstat() on a memory file 218 * descriptor. 219 */ 220 bzero(sb, sizeof(*sb)); 221 sb->st_blksize = PAGE_SIZE; 222 sb->st_size = shmfd->shm_size; 223 sb->st_blocks = (sb->st_size + sb->st_blksize - 1) / sb->st_blksize; 224 mtx_lock(&shm_timestamp_lock); 225 sb->st_atim = shmfd->shm_atime; 226 sb->st_ctim = shmfd->shm_ctime; 227 sb->st_mtim = shmfd->shm_mtime; 228 sb->st_birthtim = shmfd->shm_birthtime; 229 sb->st_mode = S_IFREG | shmfd->shm_mode; /* XXX */ 230 sb->st_uid = shmfd->shm_uid; 231 sb->st_gid = shmfd->shm_gid; 232 mtx_unlock(&shm_timestamp_lock); 233 sb->st_dev = shm_dev_ino; 234 sb->st_ino = shmfd->shm_ino; 235 236 return (0); 237 } 238 239 static int 240 shm_close(struct file *fp, struct thread *td) 241 { 242 struct shmfd *shmfd; 243 244 shmfd = fp->f_data; 245 fp->f_data = NULL; 246 shm_drop(shmfd); 247 248 return (0); 249 } 250 251 static int 252 shm_dotruncate(struct shmfd *shmfd, off_t length) 253 { 254 vm_object_t object; 255 vm_page_t m, ma[1]; 256 vm_pindex_t idx, nobjsize; 257 vm_ooffset_t delta; 258 int base, rv; 259 260 object = shmfd->shm_object; 261 VM_OBJECT_LOCK(object); 262 if (length == shmfd->shm_size) { 263 VM_OBJECT_UNLOCK(object); 264 return (0); 265 } 266 nobjsize = OFF_TO_IDX(length + PAGE_MASK); 267 268 /* Are we shrinking? If so, trim the end. */ 269 if (length < shmfd->shm_size) { 270 /* 271 * Disallow any requests to shrink the size if this 272 * object is mapped into the kernel. 273 */ 274 if (shmfd->shm_kmappings > 0) { 275 VM_OBJECT_UNLOCK(object); 276 return (EBUSY); 277 } 278 279 /* 280 * Zero the truncated part of the last page. 281 */ 282 base = length & PAGE_MASK; 283 if (base != 0) { 284 idx = OFF_TO_IDX(length); 285 retry: 286 m = vm_page_lookup(object, idx); 287 if (m != NULL) { 288 if ((m->oflags & VPO_BUSY) != 0 || 289 m->busy != 0) { 290 vm_page_sleep(m, "shmtrc"); 291 goto retry; 292 } 293 } else if (vm_pager_has_page(object, idx, NULL, NULL)) { 294 m = vm_page_alloc(object, idx, VM_ALLOC_NORMAL); 295 if (m == NULL) { 296 VM_OBJECT_UNLOCK(object); 297 VM_WAIT; 298 VM_OBJECT_LOCK(object); 299 goto retry; 300 } else if (m->valid != VM_PAGE_BITS_ALL) { 301 ma[0] = m; 302 rv = vm_pager_get_pages(object, ma, 1, 303 0); 304 m = vm_page_lookup(object, idx); 305 } else 306 /* A cached page was reactivated. */ 307 rv = VM_PAGER_OK; 308 vm_page_lock(m); 309 if (rv == VM_PAGER_OK) { 310 vm_page_deactivate(m); 311 vm_page_unlock(m); 312 vm_page_wakeup(m); 313 } else { 314 vm_page_free(m); 315 vm_page_unlock(m); 316 VM_OBJECT_UNLOCK(object); 317 return (EIO); 318 } 319 } 320 if (m != NULL) { 321 pmap_zero_page_area(m, base, PAGE_SIZE - base); 322 KASSERT(m->valid == VM_PAGE_BITS_ALL, 323 ("shm_dotruncate: page %p is invalid", m)); 324 vm_page_dirty(m); 325 vm_pager_page_unswapped(m); 326 } 327 } 328 delta = ptoa(object->size - nobjsize); 329 330 /* Toss in memory pages. */ 331 if (nobjsize < object->size) 332 vm_object_page_remove(object, nobjsize, object->size, 333 0); 334 335 /* Toss pages from swap. */ 336 if (object->type == OBJT_SWAP) 337 swap_pager_freespace(object, nobjsize, delta); 338 339 /* Free the swap accounted for shm */ 340 swap_release_by_cred(delta, object->cred); 341 object->charge -= delta; 342 } else { 343 /* Attempt to reserve the swap */ 344 delta = ptoa(nobjsize - object->size); 345 if (!swap_reserve_by_cred(delta, object->cred)) { 346 VM_OBJECT_UNLOCK(object); 347 return (ENOMEM); 348 } 349 object->charge += delta; 350 } 351 shmfd->shm_size = length; 352 mtx_lock(&shm_timestamp_lock); 353 vfs_timestamp(&shmfd->shm_ctime); 354 shmfd->shm_mtime = shmfd->shm_ctime; 355 mtx_unlock(&shm_timestamp_lock); 356 object->size = nobjsize; 357 VM_OBJECT_UNLOCK(object); 358 return (0); 359 } 360 361 /* 362 * shmfd object management including creation and reference counting 363 * routines. 364 */ 365 static struct shmfd * 366 shm_alloc(struct ucred *ucred, mode_t mode) 367 { 368 struct shmfd *shmfd; 369 int ino; 370 371 shmfd = malloc(sizeof(*shmfd), M_SHMFD, M_WAITOK | M_ZERO); 372 shmfd->shm_size = 0; 373 shmfd->shm_uid = ucred->cr_uid; 374 shmfd->shm_gid = ucred->cr_gid; 375 shmfd->shm_mode = mode; 376 shmfd->shm_object = vm_pager_allocate(OBJT_DEFAULT, NULL, 377 shmfd->shm_size, VM_PROT_DEFAULT, 0, ucred); 378 KASSERT(shmfd->shm_object != NULL, ("shm_create: vm_pager_allocate")); 379 VM_OBJECT_LOCK(shmfd->shm_object); 380 vm_object_clear_flag(shmfd->shm_object, OBJ_ONEMAPPING); 381 vm_object_set_flag(shmfd->shm_object, OBJ_NOSPLIT); 382 VM_OBJECT_UNLOCK(shmfd->shm_object); 383 vfs_timestamp(&shmfd->shm_birthtime); 384 shmfd->shm_atime = shmfd->shm_mtime = shmfd->shm_ctime = 385 shmfd->shm_birthtime; 386 ino = alloc_unr(shm_ino_unr); 387 if (ino == -1) 388 shmfd->shm_ino = 0; 389 else 390 shmfd->shm_ino = ino; 391 refcount_init(&shmfd->shm_refs, 1); 392 #ifdef MAC 393 mac_posixshm_init(shmfd); 394 mac_posixshm_create(ucred, shmfd); 395 #endif 396 397 return (shmfd); 398 } 399 400 static struct shmfd * 401 shm_hold(struct shmfd *shmfd) 402 { 403 404 refcount_acquire(&shmfd->shm_refs); 405 return (shmfd); 406 } 407 408 static void 409 shm_drop(struct shmfd *shmfd) 410 { 411 412 if (refcount_release(&shmfd->shm_refs)) { 413 #ifdef MAC 414 mac_posixshm_destroy(shmfd); 415 #endif 416 vm_object_deallocate(shmfd->shm_object); 417 if (shmfd->shm_ino != 0) 418 free_unr(shm_ino_unr, shmfd->shm_ino); 419 free(shmfd, M_SHMFD); 420 } 421 } 422 423 /* 424 * Determine if the credentials have sufficient permissions for a 425 * specified combination of FREAD and FWRITE. 426 */ 427 static int 428 shm_access(struct shmfd *shmfd, struct ucred *ucred, int flags) 429 { 430 accmode_t accmode; 431 int error; 432 433 accmode = 0; 434 if (flags & FREAD) 435 accmode |= VREAD; 436 if (flags & FWRITE) 437 accmode |= VWRITE; 438 mtx_lock(&shm_timestamp_lock); 439 error = vaccess(VREG, shmfd->shm_mode, shmfd->shm_uid, shmfd->shm_gid, 440 accmode, ucred, NULL); 441 mtx_unlock(&shm_timestamp_lock); 442 return (error); 443 } 444 445 /* 446 * Dictionary management. We maintain an in-kernel dictionary to map 447 * paths to shmfd objects. We use the FNV hash on the path to store 448 * the mappings in a hash table. 449 */ 450 static void 451 shm_init(void *arg) 452 { 453 454 mtx_init(&shm_timestamp_lock, "shm timestamps", NULL, MTX_DEF); 455 sx_init(&shm_dict_lock, "shm dictionary"); 456 shm_dictionary = hashinit(1024, M_SHMFD, &shm_hash); 457 shm_ino_unr = new_unrhdr(1, INT32_MAX, NULL); 458 KASSERT(shm_ino_unr != NULL, ("shm fake inodes not initialized")); 459 shm_dev_ino = devfs_alloc_cdp_inode(); 460 KASSERT(shm_dev_ino > 0, ("shm dev inode not initialized")); 461 } 462 SYSINIT(shm_init, SI_SUB_SYSV_SHM, SI_ORDER_ANY, shm_init, NULL); 463 464 static struct shmfd * 465 shm_lookup(char *path, Fnv32_t fnv) 466 { 467 struct shm_mapping *map; 468 469 LIST_FOREACH(map, SHM_HASH(fnv), sm_link) { 470 if (map->sm_fnv != fnv) 471 continue; 472 if (strcmp(map->sm_path, path) == 0) 473 return (map->sm_shmfd); 474 } 475 476 return (NULL); 477 } 478 479 static void 480 shm_insert(char *path, Fnv32_t fnv, struct shmfd *shmfd) 481 { 482 struct shm_mapping *map; 483 484 map = malloc(sizeof(struct shm_mapping), M_SHMFD, M_WAITOK); 485 map->sm_path = path; 486 map->sm_fnv = fnv; 487 map->sm_shmfd = shm_hold(shmfd); 488 shmfd->shm_path = path; 489 LIST_INSERT_HEAD(SHM_HASH(fnv), map, sm_link); 490 } 491 492 static int 493 shm_remove(char *path, Fnv32_t fnv, struct ucred *ucred) 494 { 495 struct shm_mapping *map; 496 int error; 497 498 LIST_FOREACH(map, SHM_HASH(fnv), sm_link) { 499 if (map->sm_fnv != fnv) 500 continue; 501 if (strcmp(map->sm_path, path) == 0) { 502 #ifdef MAC 503 error = mac_posixshm_check_unlink(ucred, map->sm_shmfd); 504 if (error) 505 return (error); 506 #endif 507 error = shm_access(map->sm_shmfd, ucred, 508 FREAD | FWRITE); 509 if (error) 510 return (error); 511 map->sm_shmfd->shm_path = NULL; 512 LIST_REMOVE(map, sm_link); 513 shm_drop(map->sm_shmfd); 514 free(map->sm_path, M_SHMFD); 515 free(map, M_SHMFD); 516 return (0); 517 } 518 } 519 520 return (ENOENT); 521 } 522 523 /* System calls. */ 524 int 525 sys_shm_open(struct thread *td, struct shm_open_args *uap) 526 { 527 struct filedesc *fdp; 528 struct shmfd *shmfd; 529 struct file *fp; 530 char *path; 531 Fnv32_t fnv; 532 mode_t cmode; 533 int fd, error; 534 535 #ifdef CAPABILITY_MODE 536 /* 537 * shm_open(2) is only allowed for anonymous objects. 538 */ 539 if (IN_CAPABILITY_MODE(td) && (uap->path != SHM_ANON)) 540 return (ECAPMODE); 541 #endif 542 543 if ((uap->flags & O_ACCMODE) != O_RDONLY && 544 (uap->flags & O_ACCMODE) != O_RDWR) 545 return (EINVAL); 546 547 if ((uap->flags & ~(O_ACCMODE | O_CREAT | O_EXCL | O_TRUNC)) != 0) 548 return (EINVAL); 549 550 fdp = td->td_proc->p_fd; 551 cmode = (uap->mode & ~fdp->fd_cmask) & ACCESSPERMS; 552 553 error = falloc(td, &fp, &fd, O_CLOEXEC); 554 if (error) 555 return (error); 556 557 /* A SHM_ANON path pointer creates an anonymous object. */ 558 if (uap->path == SHM_ANON) { 559 /* A read-only anonymous object is pointless. */ 560 if ((uap->flags & O_ACCMODE) == O_RDONLY) { 561 fdclose(fdp, fp, fd, td); 562 fdrop(fp, td); 563 return (EINVAL); 564 } 565 shmfd = shm_alloc(td->td_ucred, cmode); 566 } else { 567 path = malloc(MAXPATHLEN, M_SHMFD, M_WAITOK); 568 error = copyinstr(uap->path, path, MAXPATHLEN, NULL); 569 570 /* Require paths to start with a '/' character. */ 571 if (error == 0 && path[0] != '/') 572 error = EINVAL; 573 if (error) { 574 fdclose(fdp, fp, fd, td); 575 fdrop(fp, td); 576 free(path, M_SHMFD); 577 return (error); 578 } 579 580 fnv = fnv_32_str(path, FNV1_32_INIT); 581 sx_xlock(&shm_dict_lock); 582 shmfd = shm_lookup(path, fnv); 583 if (shmfd == NULL) { 584 /* Object does not yet exist, create it if requested. */ 585 if (uap->flags & O_CREAT) { 586 #ifdef MAC 587 error = mac_posixshm_check_create(td->td_ucred, 588 path); 589 if (error == 0) { 590 #endif 591 shmfd = shm_alloc(td->td_ucred, cmode); 592 shm_insert(path, fnv, shmfd); 593 #ifdef MAC 594 } 595 #endif 596 } else { 597 free(path, M_SHMFD); 598 error = ENOENT; 599 } 600 } else { 601 /* 602 * Object already exists, obtain a new 603 * reference if requested and permitted. 604 */ 605 free(path, M_SHMFD); 606 if ((uap->flags & (O_CREAT | O_EXCL)) == 607 (O_CREAT | O_EXCL)) 608 error = EEXIST; 609 else { 610 #ifdef MAC 611 error = mac_posixshm_check_open(td->td_ucred, 612 shmfd, FFLAGS(uap->flags & O_ACCMODE)); 613 if (error == 0) 614 #endif 615 error = shm_access(shmfd, td->td_ucred, 616 FFLAGS(uap->flags & O_ACCMODE)); 617 } 618 619 /* 620 * Truncate the file back to zero length if 621 * O_TRUNC was specified and the object was 622 * opened with read/write. 623 */ 624 if (error == 0 && 625 (uap->flags & (O_ACCMODE | O_TRUNC)) == 626 (O_RDWR | O_TRUNC)) { 627 #ifdef MAC 628 error = mac_posixshm_check_truncate( 629 td->td_ucred, fp->f_cred, shmfd); 630 if (error == 0) 631 #endif 632 shm_dotruncate(shmfd, 0); 633 } 634 if (error == 0) 635 shm_hold(shmfd); 636 } 637 sx_xunlock(&shm_dict_lock); 638 639 if (error) { 640 fdclose(fdp, fp, fd, td); 641 fdrop(fp, td); 642 return (error); 643 } 644 } 645 646 finit(fp, FFLAGS(uap->flags & O_ACCMODE), DTYPE_SHM, shmfd, &shm_ops); 647 648 td->td_retval[0] = fd; 649 fdrop(fp, td); 650 651 return (0); 652 } 653 654 int 655 sys_shm_unlink(struct thread *td, struct shm_unlink_args *uap) 656 { 657 char *path; 658 Fnv32_t fnv; 659 int error; 660 661 path = malloc(MAXPATHLEN, M_TEMP, M_WAITOK); 662 error = copyinstr(uap->path, path, MAXPATHLEN, NULL); 663 if (error) { 664 free(path, M_TEMP); 665 return (error); 666 } 667 668 fnv = fnv_32_str(path, FNV1_32_INIT); 669 sx_xlock(&shm_dict_lock); 670 error = shm_remove(path, fnv, td->td_ucred); 671 sx_xunlock(&shm_dict_lock); 672 free(path, M_TEMP); 673 674 return (error); 675 } 676 677 /* 678 * mmap() helper to validate mmap() requests against shm object state 679 * and give mmap() the vm_object to use for the mapping. 680 */ 681 int 682 shm_mmap(struct shmfd *shmfd, vm_size_t objsize, vm_ooffset_t foff, 683 vm_object_t *obj) 684 { 685 686 /* 687 * XXXRW: This validation is probably insufficient, and subject to 688 * sign errors. It should be fixed. 689 */ 690 if (foff >= shmfd->shm_size || 691 foff + objsize > round_page(shmfd->shm_size)) 692 return (EINVAL); 693 694 mtx_lock(&shm_timestamp_lock); 695 vfs_timestamp(&shmfd->shm_atime); 696 mtx_unlock(&shm_timestamp_lock); 697 vm_object_reference(shmfd->shm_object); 698 *obj = shmfd->shm_object; 699 return (0); 700 } 701 702 static int 703 shm_chmod(struct file *fp, mode_t mode, struct ucred *active_cred, 704 struct thread *td) 705 { 706 struct shmfd *shmfd; 707 int error; 708 709 error = 0; 710 shmfd = fp->f_data; 711 mtx_lock(&shm_timestamp_lock); 712 /* 713 * SUSv4 says that x bits of permission need not be affected. 714 * Be consistent with our shm_open there. 715 */ 716 #ifdef MAC 717 error = mac_posixshm_check_setmode(active_cred, shmfd, mode); 718 if (error != 0) 719 goto out; 720 #endif 721 error = vaccess(VREG, shmfd->shm_mode, shmfd->shm_uid, 722 shmfd->shm_gid, VADMIN, active_cred, NULL); 723 if (error != 0) 724 goto out; 725 shmfd->shm_mode = mode & ACCESSPERMS; 726 out: 727 mtx_unlock(&shm_timestamp_lock); 728 return (error); 729 } 730 731 static int 732 shm_chown(struct file *fp, uid_t uid, gid_t gid, struct ucred *active_cred, 733 struct thread *td) 734 { 735 struct shmfd *shmfd; 736 int error; 737 738 error = 0; 739 shmfd = fp->f_data; 740 mtx_lock(&shm_timestamp_lock); 741 #ifdef MAC 742 error = mac_posixshm_check_setowner(active_cred, shmfd, uid, gid); 743 if (error != 0) 744 goto out; 745 #endif 746 if (uid == (uid_t)-1) 747 uid = shmfd->shm_uid; 748 if (gid == (gid_t)-1) 749 gid = shmfd->shm_gid; 750 if (((uid != shmfd->shm_uid && uid != active_cred->cr_uid) || 751 (gid != shmfd->shm_gid && !groupmember(gid, active_cred))) && 752 (error = priv_check_cred(active_cred, PRIV_VFS_CHOWN, 0))) 753 goto out; 754 shmfd->shm_uid = uid; 755 shmfd->shm_gid = gid; 756 out: 757 mtx_unlock(&shm_timestamp_lock); 758 return (error); 759 } 760 761 /* 762 * Helper routines to allow the backing object of a shared memory file 763 * descriptor to be mapped in the kernel. 764 */ 765 int 766 shm_map(struct file *fp, size_t size, off_t offset, void **memp) 767 { 768 struct shmfd *shmfd; 769 vm_offset_t kva, ofs; 770 vm_object_t obj; 771 int rv; 772 773 if (fp->f_type != DTYPE_SHM) 774 return (EINVAL); 775 shmfd = fp->f_data; 776 obj = shmfd->shm_object; 777 VM_OBJECT_LOCK(obj); 778 /* 779 * XXXRW: This validation is probably insufficient, and subject to 780 * sign errors. It should be fixed. 781 */ 782 if (offset >= shmfd->shm_size || 783 offset + size > round_page(shmfd->shm_size)) { 784 VM_OBJECT_UNLOCK(obj); 785 return (EINVAL); 786 } 787 788 shmfd->shm_kmappings++; 789 vm_object_reference_locked(obj); 790 VM_OBJECT_UNLOCK(obj); 791 792 /* Map the object into the kernel_map and wire it. */ 793 kva = vm_map_min(kernel_map); 794 ofs = offset & PAGE_MASK; 795 offset = trunc_page(offset); 796 size = round_page(size + ofs); 797 rv = vm_map_find(kernel_map, obj, offset, &kva, size, 798 VMFS_OPTIMAL_SPACE, VM_PROT_READ | VM_PROT_WRITE, 799 VM_PROT_READ | VM_PROT_WRITE, 0); 800 if (rv == KERN_SUCCESS) { 801 rv = vm_map_wire(kernel_map, kva, kva + size, 802 VM_MAP_WIRE_SYSTEM | VM_MAP_WIRE_NOHOLES); 803 if (rv == KERN_SUCCESS) { 804 *memp = (void *)(kva + ofs); 805 return (0); 806 } 807 vm_map_remove(kernel_map, kva, kva + size); 808 } else 809 vm_object_deallocate(obj); 810 811 /* On failure, drop our mapping reference. */ 812 VM_OBJECT_LOCK(obj); 813 shmfd->shm_kmappings--; 814 VM_OBJECT_UNLOCK(obj); 815 816 return (vm_mmap_to_errno(rv)); 817 } 818 819 /* 820 * We require the caller to unmap the entire entry. This allows us to 821 * safely decrement shm_kmappings when a mapping is removed. 822 */ 823 int 824 shm_unmap(struct file *fp, void *mem, size_t size) 825 { 826 struct shmfd *shmfd; 827 vm_map_entry_t entry; 828 vm_offset_t kva, ofs; 829 vm_object_t obj; 830 vm_pindex_t pindex; 831 vm_prot_t prot; 832 boolean_t wired; 833 vm_map_t map; 834 int rv; 835 836 if (fp->f_type != DTYPE_SHM) 837 return (EINVAL); 838 shmfd = fp->f_data; 839 kva = (vm_offset_t)mem; 840 ofs = kva & PAGE_MASK; 841 kva = trunc_page(kva); 842 size = round_page(size + ofs); 843 map = kernel_map; 844 rv = vm_map_lookup(&map, kva, VM_PROT_READ | VM_PROT_WRITE, &entry, 845 &obj, &pindex, &prot, &wired); 846 if (rv != KERN_SUCCESS) 847 return (EINVAL); 848 if (entry->start != kva || entry->end != kva + size) { 849 vm_map_lookup_done(map, entry); 850 return (EINVAL); 851 } 852 vm_map_lookup_done(map, entry); 853 if (obj != shmfd->shm_object) 854 return (EINVAL); 855 vm_map_remove(map, kva, kva + size); 856 VM_OBJECT_LOCK(obj); 857 KASSERT(shmfd->shm_kmappings > 0, ("shm_unmap: object not mapped")); 858 shmfd->shm_kmappings--; 859 VM_OBJECT_UNLOCK(obj); 860 return (0); 861 } 862 863 void 864 shm_path(struct shmfd *shmfd, char *path, size_t size) 865 { 866 867 if (shmfd->shm_path == NULL) 868 return; 869 sx_slock(&shm_dict_lock); 870 if (shmfd->shm_path != NULL) 871 strlcpy(path, shmfd->shm_path, size); 872 sx_sunlock(&shm_dict_lock); 873 }
Cache object: edec0574288a1b63b3cc76a3ea2f40ff
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]