1 /* $NetBSD: tmpfs_vnops.c,v 1.110 2013/12/24 09:23:33 hannken Exp $ */ 2 3 /* 4 * Copyright (c) 2005, 2006, 2007 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Julio M. Merino Vidal, developed as part of Google's Summer of Code 9 * 2005 program. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 /* 34 * tmpfs vnode interface. 35 */ 36 37 #include <sys/cdefs.h> 38 __KERNEL_RCSID(0, "$NetBSD: tmpfs_vnops.c,v 1.110 2013/12/24 09:23:33 hannken Exp $"); 39 40 #include <sys/param.h> 41 #include <sys/dirent.h> 42 #include <sys/fcntl.h> 43 #include <sys/event.h> 44 #include <sys/malloc.h> 45 #include <sys/namei.h> 46 #include <sys/stat.h> 47 #include <sys/uio.h> 48 #include <sys/unistd.h> 49 #include <sys/vnode.h> 50 #include <sys/lockf.h> 51 #include <sys/kauth.h> 52 53 #include <uvm/uvm.h> 54 55 #include <miscfs/fifofs/fifo.h> 56 #include <miscfs/genfs/genfs.h> 57 #include <fs/tmpfs/tmpfs_vnops.h> 58 #include <fs/tmpfs/tmpfs.h> 59 60 /* 61 * vnode operations vector used for files stored in a tmpfs file system. 62 */ 63 int (**tmpfs_vnodeop_p)(void *); 64 const struct vnodeopv_entry_desc tmpfs_vnodeop_entries[] = { 65 { &vop_default_desc, vn_default_error }, 66 { &vop_lookup_desc, tmpfs_lookup }, 67 { &vop_create_desc, tmpfs_create }, 68 { &vop_mknod_desc, tmpfs_mknod }, 69 { &vop_open_desc, tmpfs_open }, 70 { &vop_close_desc, tmpfs_close }, 71 { &vop_access_desc, tmpfs_access }, 72 { &vop_getattr_desc, tmpfs_getattr }, 73 { &vop_setattr_desc, tmpfs_setattr }, 74 { &vop_read_desc, tmpfs_read }, 75 { &vop_write_desc, tmpfs_write }, 76 { &vop_ioctl_desc, tmpfs_ioctl }, 77 { &vop_fcntl_desc, tmpfs_fcntl }, 78 { &vop_poll_desc, tmpfs_poll }, 79 { &vop_kqfilter_desc, tmpfs_kqfilter }, 80 { &vop_revoke_desc, tmpfs_revoke }, 81 { &vop_mmap_desc, tmpfs_mmap }, 82 { &vop_fsync_desc, tmpfs_fsync }, 83 { &vop_seek_desc, tmpfs_seek }, 84 { &vop_remove_desc, tmpfs_remove }, 85 { &vop_link_desc, tmpfs_link }, 86 { &vop_rename_desc, tmpfs_rename }, 87 { &vop_mkdir_desc, tmpfs_mkdir }, 88 { &vop_rmdir_desc, tmpfs_rmdir }, 89 { &vop_symlink_desc, tmpfs_symlink }, 90 { &vop_readdir_desc, tmpfs_readdir }, 91 { &vop_readlink_desc, tmpfs_readlink }, 92 { &vop_abortop_desc, tmpfs_abortop }, 93 { &vop_inactive_desc, tmpfs_inactive }, 94 { &vop_reclaim_desc, tmpfs_reclaim }, 95 { &vop_lock_desc, tmpfs_lock }, 96 { &vop_unlock_desc, tmpfs_unlock }, 97 { &vop_bmap_desc, tmpfs_bmap }, 98 { &vop_strategy_desc, tmpfs_strategy }, 99 { &vop_print_desc, tmpfs_print }, 100 { &vop_pathconf_desc, tmpfs_pathconf }, 101 { &vop_islocked_desc, tmpfs_islocked }, 102 { &vop_advlock_desc, tmpfs_advlock }, 103 { &vop_bwrite_desc, tmpfs_bwrite }, 104 { &vop_getpages_desc, tmpfs_getpages }, 105 { &vop_putpages_desc, tmpfs_putpages }, 106 { &vop_whiteout_desc, tmpfs_whiteout }, 107 { NULL, NULL } 108 }; 109 110 const struct vnodeopv_desc tmpfs_vnodeop_opv_desc = { 111 &tmpfs_vnodeop_p, tmpfs_vnodeop_entries 112 }; 113 114 /* 115 * tmpfs_lookup: path name traversal routine. 116 * 117 * Arguments: dvp (directory being searched), vpp (result), 118 * cnp (component name - path). 119 * 120 * => Caller holds a reference and lock on dvp. 121 * => We return looked-up vnode (vpp) locked, with a reference held. 122 */ 123 int 124 tmpfs_lookup(void *v) 125 { 126 struct vop_lookup_args /* { 127 struct vnode *a_dvp; 128 struct vnode **a_vpp; 129 struct componentname *a_cnp; 130 } */ *ap = v; 131 vnode_t *dvp = ap->a_dvp, **vpp = ap->a_vpp; 132 struct componentname *cnp = ap->a_cnp; 133 const bool lastcn = (cnp->cn_flags & ISLASTCN) != 0; 134 tmpfs_node_t *dnode, *tnode; 135 tmpfs_dirent_t *de; 136 int cachefound, iswhiteout; 137 int error; 138 139 KASSERT(VOP_ISLOCKED(dvp)); 140 141 dnode = VP_TO_TMPFS_DIR(dvp); 142 *vpp = NULL; 143 144 /* Check accessibility of directory. */ 145 error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred); 146 if (error) { 147 goto out; 148 } 149 150 /* 151 * If requesting the last path component on a read-only file system 152 * with a write operation, deny it. 153 */ 154 if (lastcn && (dvp->v_mount->mnt_flag & MNT_RDONLY) != 0 && 155 (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) { 156 error = EROFS; 157 goto out; 158 } 159 160 /* 161 * Avoid doing a linear scan of the directory if the requested 162 * directory/name couple is already in the cache. 163 */ 164 cachefound = cache_lookup(dvp, cnp->cn_nameptr, cnp->cn_namelen, 165 cnp->cn_nameiop, cnp->cn_flags, 166 &iswhiteout, vpp); 167 if (iswhiteout) { 168 cnp->cn_flags |= ISWHITEOUT; 169 } 170 if (cachefound && *vpp == NULLVP) { 171 /* Negative cache hit. */ 172 error = ENOENT; 173 goto out; 174 } else if (cachefound) { 175 error = 0; 176 goto out; 177 } 178 179 /* 180 * Treat an unlinked directory as empty (no "." or "..") 181 */ 182 if (dnode->tn_links == 0) { 183 KASSERT(dnode->tn_size == 0); 184 error = ENOENT; 185 goto out; 186 } 187 188 if (cnp->cn_flags & ISDOTDOT) { 189 tmpfs_node_t *pnode; 190 191 /* 192 * Lookup of ".." case. 193 */ 194 if (lastcn && cnp->cn_nameiop == RENAME) { 195 error = EINVAL; 196 goto out; 197 } 198 KASSERT(dnode->tn_type == VDIR); 199 pnode = dnode->tn_spec.tn_dir.tn_parent; 200 if (pnode == NULL) { 201 error = ENOENT; 202 goto out; 203 } 204 205 /* 206 * Lock the parent tn_vlock before releasing the vnode lock, 207 * and thus prevent parent from disappearing. 208 */ 209 mutex_enter(&pnode->tn_vlock); 210 VOP_UNLOCK(dvp); 211 212 /* 213 * Get a vnode of the '..' entry and re-acquire the lock. 214 * Release the tn_vlock. 215 */ 216 error = tmpfs_vnode_get(dvp->v_mount, pnode, vpp); 217 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY); 218 goto out; 219 220 } else if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') { 221 /* 222 * Lookup of "." case. 223 */ 224 if (lastcn && cnp->cn_nameiop == RENAME) { 225 error = EISDIR; 226 goto out; 227 } 228 vref(dvp); 229 *vpp = dvp; 230 error = 0; 231 goto done; 232 } 233 234 /* 235 * Other lookup cases: perform directory scan. 236 */ 237 de = tmpfs_dir_lookup(dnode, cnp); 238 if (de == NULL || de->td_node == TMPFS_NODE_WHITEOUT) { 239 /* 240 * The entry was not found in the directory. This is valid 241 * if we are creating or renaming an entry and are working 242 * on the last component of the path name. 243 */ 244 if (lastcn && (cnp->cn_nameiop == CREATE || 245 cnp->cn_nameiop == RENAME)) { 246 error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred); 247 if (error) { 248 goto out; 249 } 250 error = EJUSTRETURN; 251 } else { 252 error = ENOENT; 253 } 254 if (de) { 255 KASSERT(de->td_node == TMPFS_NODE_WHITEOUT); 256 cnp->cn_flags |= ISWHITEOUT; 257 } 258 goto done; 259 } 260 261 tnode = de->td_node; 262 263 /* 264 * If it is not the last path component and found a non-directory 265 * or non-link entry (which may itself be pointing to a directory), 266 * raise an error. 267 */ 268 if (!lastcn && tnode->tn_type != VDIR && tnode->tn_type != VLNK) { 269 error = ENOTDIR; 270 goto out; 271 } 272 273 /* Check the permissions. */ 274 if (lastcn && (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) { 275 error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred); 276 if (error) 277 goto out; 278 279 if ((dnode->tn_mode & S_ISTXT) != 0) { 280 error = kauth_authorize_vnode(cnp->cn_cred, 281 KAUTH_VNODE_DELETE, tnode->tn_vnode, 282 dnode->tn_vnode, genfs_can_sticky(cnp->cn_cred, 283 dnode->tn_uid, tnode->tn_uid)); 284 if (error) { 285 error = EPERM; 286 goto out; 287 } 288 } 289 } 290 291 /* Get a vnode for the matching entry. */ 292 mutex_enter(&tnode->tn_vlock); 293 error = tmpfs_vnode_get(dvp->v_mount, tnode, vpp); 294 done: 295 /* 296 * Cache the result, unless request was for creation (as it does 297 * not improve the performance). 298 */ 299 if (cnp->cn_nameiop != CREATE) { 300 cache_enter(dvp, *vpp, cnp->cn_nameptr, cnp->cn_namelen, 301 cnp->cn_flags); 302 } 303 out: 304 KASSERT((*vpp && VOP_ISLOCKED(*vpp)) || error); 305 KASSERT(VOP_ISLOCKED(dvp)); 306 307 return error; 308 } 309 310 int 311 tmpfs_create(void *v) 312 { 313 struct vop_create_args /* { 314 struct vnode *a_dvp; 315 struct vnode **a_vpp; 316 struct componentname *a_cnp; 317 struct vattr *a_vap; 318 } */ *ap = v; 319 vnode_t *dvp = ap->a_dvp, **vpp = ap->a_vpp; 320 struct componentname *cnp = ap->a_cnp; 321 struct vattr *vap = ap->a_vap; 322 323 KASSERT(VOP_ISLOCKED(dvp)); 324 KASSERT(vap->va_type == VREG || vap->va_type == VSOCK); 325 return tmpfs_construct_node(dvp, vpp, vap, cnp, NULL); 326 } 327 328 int 329 tmpfs_mknod(void *v) 330 { 331 struct vop_mknod_args /* { 332 struct vnode *a_dvp; 333 struct vnode **a_vpp; 334 struct componentname *a_cnp; 335 struct vattr *a_vap; 336 } */ *ap = v; 337 vnode_t *dvp = ap->a_dvp, **vpp = ap->a_vpp; 338 struct componentname *cnp = ap->a_cnp; 339 struct vattr *vap = ap->a_vap; 340 enum vtype vt = vap->va_type; 341 342 if (vt != VBLK && vt != VCHR && vt != VFIFO) { 343 vput(dvp); 344 return EINVAL; 345 } 346 return tmpfs_construct_node(dvp, vpp, vap, cnp, NULL); 347 } 348 349 int 350 tmpfs_open(void *v) 351 { 352 struct vop_open_args /* { 353 struct vnode *a_vp; 354 int a_mode; 355 kauth_cred_t a_cred; 356 } */ *ap = v; 357 vnode_t *vp = ap->a_vp; 358 mode_t mode = ap->a_mode; 359 tmpfs_node_t *node; 360 361 KASSERT(VOP_ISLOCKED(vp)); 362 363 node = VP_TO_TMPFS_NODE(vp); 364 365 /* If the file is marked append-only, deny write requests. */ 366 if ((node->tn_flags & APPEND) != 0 && 367 (mode & (FWRITE | O_APPEND)) == FWRITE) { 368 return EPERM; 369 } 370 return 0; 371 } 372 373 int 374 tmpfs_close(void *v) 375 { 376 struct vop_close_args /* { 377 struct vnode *a_vp; 378 int a_fflag; 379 kauth_cred_t a_cred; 380 } */ *ap = v; 381 vnode_t *vp __diagused = ap->a_vp; 382 383 KASSERT(VOP_ISLOCKED(vp)); 384 return 0; 385 } 386 387 int 388 tmpfs_access(void *v) 389 { 390 struct vop_access_args /* { 391 struct vnode *a_vp; 392 int a_mode; 393 kauth_cred_t a_cred; 394 } */ *ap = v; 395 vnode_t *vp = ap->a_vp; 396 mode_t mode = ap->a_mode; 397 kauth_cred_t cred = ap->a_cred; 398 tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); 399 const bool writing = (mode & VWRITE) != 0; 400 401 KASSERT(VOP_ISLOCKED(vp)); 402 403 /* Possible? */ 404 switch (vp->v_type) { 405 case VDIR: 406 case VLNK: 407 case VREG: 408 if (writing && (vp->v_mount->mnt_flag & MNT_RDONLY) != 0) { 409 return EROFS; 410 } 411 break; 412 case VBLK: 413 case VCHR: 414 case VSOCK: 415 case VFIFO: 416 break; 417 default: 418 return EINVAL; 419 } 420 if (writing && (node->tn_flags & IMMUTABLE) != 0) { 421 return EPERM; 422 } 423 424 return kauth_authorize_vnode(cred, KAUTH_ACCESS_ACTION(mode, 425 vp->v_type, node->tn_mode), vp, NULL, genfs_can_access(vp->v_type, 426 node->tn_mode, node->tn_uid, node->tn_gid, mode, cred)); 427 } 428 429 int 430 tmpfs_getattr(void *v) 431 { 432 struct vop_getattr_args /* { 433 struct vnode *a_vp; 434 struct vattr *a_vap; 435 kauth_cred_t a_cred; 436 } */ *ap = v; 437 vnode_t *vp = ap->a_vp; 438 struct vattr *vap = ap->a_vap; 439 tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); 440 441 vattr_null(vap); 442 443 vap->va_type = vp->v_type; 444 vap->va_mode = node->tn_mode; 445 vap->va_nlink = node->tn_links; 446 vap->va_uid = node->tn_uid; 447 vap->va_gid = node->tn_gid; 448 vap->va_fsid = vp->v_mount->mnt_stat.f_fsidx.__fsid_val[0]; 449 vap->va_fileid = node->tn_id; 450 vap->va_size = node->tn_size; 451 vap->va_blocksize = PAGE_SIZE; 452 vap->va_atime = node->tn_atime; 453 vap->va_mtime = node->tn_mtime; 454 vap->va_ctime = node->tn_ctime; 455 vap->va_birthtime = node->tn_birthtime; 456 vap->va_gen = TMPFS_NODE_GEN(node); 457 vap->va_flags = node->tn_flags; 458 vap->va_rdev = (vp->v_type == VBLK || vp->v_type == VCHR) ? 459 node->tn_spec.tn_dev.tn_rdev : VNOVAL; 460 vap->va_bytes = round_page(node->tn_size); 461 vap->va_filerev = VNOVAL; 462 vap->va_vaflags = 0; 463 vap->va_spare = VNOVAL; /* XXX */ 464 465 return 0; 466 } 467 468 int 469 tmpfs_setattr(void *v) 470 { 471 struct vop_setattr_args /* { 472 struct vnode *a_vp; 473 struct vattr *a_vap; 474 kauth_cred_t a_cred; 475 } */ *ap = v; 476 vnode_t *vp = ap->a_vp; 477 struct vattr *vap = ap->a_vap; 478 kauth_cred_t cred = ap->a_cred; 479 lwp_t *l = curlwp; 480 int error = 0; 481 482 KASSERT(VOP_ISLOCKED(vp)); 483 484 /* Abort if any unsettable attribute is given. */ 485 if (vap->va_type != VNON || vap->va_nlink != VNOVAL || 486 vap->va_fsid != VNOVAL || vap->va_fileid != VNOVAL || 487 vap->va_blocksize != VNOVAL || vap->va_ctime.tv_sec != VNOVAL || 488 vap->va_gen != VNOVAL || vap->va_rdev != VNOVAL || 489 vap->va_bytes != VNOVAL) { 490 return EINVAL; 491 } 492 493 if (error == 0 && vap->va_flags != VNOVAL) 494 error = tmpfs_chflags(vp, vap->va_flags, cred, l); 495 496 if (error == 0 && vap->va_size != VNOVAL) 497 error = tmpfs_chsize(vp, vap->va_size, cred, l); 498 499 if (error == 0 && (vap->va_uid != VNOVAL || vap->va_gid != VNOVAL)) 500 error = tmpfs_chown(vp, vap->va_uid, vap->va_gid, cred, l); 501 502 if (error == 0 && vap->va_mode != VNOVAL) 503 error = tmpfs_chmod(vp, vap->va_mode, cred, l); 504 505 const bool chsometime = 506 vap->va_atime.tv_sec != VNOVAL || 507 vap->va_mtime.tv_sec != VNOVAL || 508 vap->va_birthtime.tv_sec != VNOVAL; 509 if (error == 0 && chsometime) { 510 error = tmpfs_chtimes(vp, &vap->va_atime, &vap->va_mtime, 511 &vap->va_birthtime, vap->va_vaflags, cred, l); 512 } 513 return error; 514 } 515 516 int 517 tmpfs_read(void *v) 518 { 519 struct vop_read_args /* { 520 struct vnode *a_vp; 521 struct uio *a_uio; 522 int a_ioflag; 523 kauth_cred_t a_cred; 524 } */ *ap = v; 525 vnode_t *vp = ap->a_vp; 526 struct uio *uio = ap->a_uio; 527 const int ioflag = ap->a_ioflag; 528 tmpfs_node_t *node; 529 struct uvm_object *uobj; 530 int error; 531 532 KASSERT(VOP_ISLOCKED(vp)); 533 534 if (vp->v_type != VREG) { 535 return EISDIR; 536 } 537 if (uio->uio_offset < 0) { 538 return EINVAL; 539 } 540 541 /* Note: reading zero bytes should not update atime. */ 542 if (uio->uio_resid == 0) { 543 return 0; 544 } 545 546 node = VP_TO_TMPFS_NODE(vp); 547 uobj = node->tn_spec.tn_reg.tn_aobj; 548 error = 0; 549 550 while (error == 0 && uio->uio_resid > 0) { 551 vsize_t len; 552 553 if (node->tn_size <= uio->uio_offset) { 554 break; 555 } 556 len = MIN(node->tn_size - uio->uio_offset, uio->uio_resid); 557 if (len == 0) { 558 break; 559 } 560 error = ubc_uiomove(uobj, uio, len, IO_ADV_DECODE(ioflag), 561 UBC_READ | UBC_PARTIALOK | UBC_UNMAP_FLAG(vp)); 562 } 563 564 tmpfs_update(vp, TMPFS_UPDATE_ATIME); 565 return error; 566 } 567 568 int 569 tmpfs_write(void *v) 570 { 571 struct vop_write_args /* { 572 struct vnode *a_vp; 573 struct uio *a_uio; 574 int a_ioflag; 575 kauth_cred_t a_cred; 576 } */ *ap = v; 577 vnode_t *vp = ap->a_vp; 578 struct uio *uio = ap->a_uio; 579 const int ioflag = ap->a_ioflag; 580 tmpfs_node_t *node; 581 struct uvm_object *uobj; 582 off_t oldsize; 583 int error; 584 585 KASSERT(VOP_ISLOCKED(vp)); 586 587 node = VP_TO_TMPFS_NODE(vp); 588 oldsize = node->tn_size; 589 590 if (uio->uio_offset < 0 || vp->v_type != VREG) { 591 error = EINVAL; 592 goto out; 593 } 594 if (uio->uio_resid == 0) { 595 error = 0; 596 goto out; 597 } 598 if (ioflag & IO_APPEND) { 599 uio->uio_offset = node->tn_size; 600 } 601 602 if (uio->uio_offset + uio->uio_resid > node->tn_size) { 603 error = tmpfs_reg_resize(vp, uio->uio_offset + uio->uio_resid); 604 if (error) 605 goto out; 606 } 607 608 uobj = node->tn_spec.tn_reg.tn_aobj; 609 error = 0; 610 while (error == 0 && uio->uio_resid > 0) { 611 vsize_t len; 612 613 len = MIN(node->tn_size - uio->uio_offset, uio->uio_resid); 614 if (len == 0) { 615 break; 616 } 617 error = ubc_uiomove(uobj, uio, len, IO_ADV_DECODE(ioflag), 618 UBC_WRITE | UBC_UNMAP_FLAG(vp)); 619 } 620 if (error) { 621 (void)tmpfs_reg_resize(vp, oldsize); 622 } 623 624 tmpfs_update(vp, TMPFS_UPDATE_MTIME | TMPFS_UPDATE_CTIME); 625 VN_KNOTE(vp, NOTE_WRITE); 626 out: 627 if (error) { 628 KASSERT(oldsize == node->tn_size); 629 } else { 630 KASSERT(uio->uio_resid == 0); 631 } 632 return error; 633 } 634 635 int 636 tmpfs_fsync(void *v) 637 { 638 struct vop_fsync_args /* { 639 struct vnode *a_vp; 640 kauth_cred_t a_cred; 641 int a_flags; 642 off_t a_offlo; 643 off_t a_offhi; 644 struct lwp *a_l; 645 } */ *ap = v; 646 vnode_t *vp __diagused = ap->a_vp; 647 648 /* Nothing to do. Should be up to date. */ 649 KASSERT(VOP_ISLOCKED(vp)); 650 return 0; 651 } 652 653 /* 654 * tmpfs_remove: unlink a file. 655 * 656 * => Both directory (dvp) and file (vp) are locked. 657 * => We unlock and drop the reference on both. 658 */ 659 int 660 tmpfs_remove(void *v) 661 { 662 struct vop_remove_args /* { 663 struct vnode *a_dvp; 664 struct vnode *a_vp; 665 struct componentname *a_cnp; 666 } */ *ap = v; 667 vnode_t *dvp = ap->a_dvp, *vp = ap->a_vp; 668 tmpfs_node_t *dnode, *node; 669 tmpfs_dirent_t *de; 670 int error; 671 672 KASSERT(VOP_ISLOCKED(dvp)); 673 KASSERT(VOP_ISLOCKED(vp)); 674 675 if (vp->v_type == VDIR) { 676 error = EPERM; 677 goto out; 678 } 679 dnode = VP_TO_TMPFS_DIR(dvp); 680 node = VP_TO_TMPFS_NODE(vp); 681 682 /* 683 * Files marked as immutable or append-only cannot be deleted. 684 * Likewise, files residing on directories marked as append-only 685 * cannot be deleted. 686 */ 687 if (node->tn_flags & (IMMUTABLE | APPEND)) { 688 error = EPERM; 689 goto out; 690 } 691 if (dnode->tn_flags & APPEND) { 692 error = EPERM; 693 goto out; 694 } 695 696 /* Lookup the directory entry (check the cached hint first). */ 697 de = tmpfs_dir_cached(node); 698 if (de == NULL) { 699 struct componentname *cnp = ap->a_cnp; 700 de = tmpfs_dir_lookup(dnode, cnp); 701 } 702 KASSERT(de && de->td_node == node); 703 704 /* 705 * Remove the entry from the directory (drops the link count) and 706 * destroy it or replace with a whiteout. 707 * 708 * Note: the inode referred by it will not be destroyed until the 709 * vnode is reclaimed/recycled. 710 */ 711 712 tmpfs_dir_detach(dnode, de); 713 714 if (ap->a_cnp->cn_flags & DOWHITEOUT) 715 tmpfs_dir_attach(dnode, de, TMPFS_NODE_WHITEOUT); 716 else 717 tmpfs_free_dirent(VFS_TO_TMPFS(vp->v_mount), de); 718 719 if (node->tn_links > 0) { 720 /* We removed a hard link. */ 721 tmpfs_update(vp, TMPFS_UPDATE_CTIME); 722 } 723 tmpfs_update(dvp, TMPFS_UPDATE_MTIME | TMPFS_UPDATE_CTIME); 724 error = 0; 725 out: 726 /* Drop the references and unlock the vnodes. */ 727 vput(vp); 728 if (dvp == vp) { 729 vrele(dvp); 730 } else { 731 vput(dvp); 732 } 733 return error; 734 } 735 736 /* 737 * tmpfs_link: create a hard link. 738 */ 739 int 740 tmpfs_link(void *v) 741 { 742 struct vop_link_args /* { 743 struct vnode *a_dvp; 744 struct vnode *a_vp; 745 struct componentname *a_cnp; 746 } */ *ap = v; 747 vnode_t *dvp = ap->a_dvp; 748 vnode_t *vp = ap->a_vp; 749 struct componentname *cnp = ap->a_cnp; 750 tmpfs_node_t *dnode, *node; 751 tmpfs_dirent_t *de; 752 int error; 753 754 KASSERT(dvp != vp); 755 KASSERT(VOP_ISLOCKED(dvp)); 756 KASSERT(vp->v_type != VDIR); 757 KASSERT(dvp->v_mount == vp->v_mount); 758 759 dnode = VP_TO_TMPFS_DIR(dvp); 760 node = VP_TO_TMPFS_NODE(vp); 761 762 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 763 764 /* Check for maximum number of links limit. */ 765 if (node->tn_links == LINK_MAX) { 766 error = EMLINK; 767 goto out; 768 } 769 KASSERT(node->tn_links < LINK_MAX); 770 771 /* We cannot create links of files marked immutable or append-only. */ 772 if (node->tn_flags & (IMMUTABLE | APPEND)) { 773 error = EPERM; 774 goto out; 775 } 776 777 /* Allocate a new directory entry to represent the inode. */ 778 error = tmpfs_alloc_dirent(VFS_TO_TMPFS(vp->v_mount), 779 cnp->cn_nameptr, cnp->cn_namelen, &de); 780 if (error) { 781 goto out; 782 } 783 784 /* 785 * Insert the entry into the directory. 786 * It will increase the inode link count. 787 */ 788 tmpfs_dir_attach(dnode, de, node); 789 tmpfs_update(dvp, TMPFS_UPDATE_MTIME | TMPFS_UPDATE_CTIME); 790 791 /* Update the timestamps and trigger the event. */ 792 if (node->tn_vnode) { 793 VN_KNOTE(node->tn_vnode, NOTE_LINK); 794 } 795 tmpfs_update(vp, TMPFS_UPDATE_CTIME); 796 error = 0; 797 out: 798 VOP_UNLOCK(vp); 799 vput(dvp); 800 return error; 801 } 802 803 int 804 tmpfs_mkdir(void *v) 805 { 806 struct vop_mkdir_args /* { 807 struct vnode *a_dvp; 808 struct vnode **a_vpp; 809 struct componentname *a_cnp; 810 struct vattr *a_vap; 811 } */ *ap = v; 812 vnode_t *dvp = ap->a_dvp; 813 vnode_t **vpp = ap->a_vpp; 814 struct componentname *cnp = ap->a_cnp; 815 struct vattr *vap = ap->a_vap; 816 817 KASSERT(vap->va_type == VDIR); 818 return tmpfs_construct_node(dvp, vpp, vap, cnp, NULL); 819 } 820 821 int 822 tmpfs_rmdir(void *v) 823 { 824 struct vop_rmdir_args /* { 825 struct vnode *a_dvp; 826 struct vnode *a_vp; 827 struct componentname *a_cnp; 828 } */ *ap = v; 829 vnode_t *dvp = ap->a_dvp; 830 vnode_t *vp = ap->a_vp; 831 tmpfs_mount_t *tmp = VFS_TO_TMPFS(dvp->v_mount); 832 tmpfs_node_t *dnode = VP_TO_TMPFS_DIR(dvp); 833 tmpfs_node_t *node = VP_TO_TMPFS_DIR(vp); 834 tmpfs_dirent_t *de; 835 int error = 0; 836 837 KASSERT(VOP_ISLOCKED(dvp)); 838 KASSERT(VOP_ISLOCKED(vp)); 839 KASSERT(node->tn_spec.tn_dir.tn_parent == dnode); 840 841 /* 842 * Directories with more than two entries ('.' and '..') cannot be 843 * removed. There may be whiteout entries, which we will destroy. 844 */ 845 if (node->tn_size > 0) { 846 /* 847 * If never had whiteout entries, the directory is certainly 848 * not empty. Otherwise, scan for any non-whiteout entry. 849 */ 850 if ((node->tn_gen & TMPFS_WHITEOUT_BIT) == 0) { 851 error = ENOTEMPTY; 852 goto out; 853 } 854 TAILQ_FOREACH(de, &node->tn_spec.tn_dir.tn_dir, td_entries) { 855 if (de->td_node != TMPFS_NODE_WHITEOUT) { 856 error = ENOTEMPTY; 857 goto out; 858 } 859 } 860 KASSERT(error == 0); 861 } 862 863 /* Lookup the directory entry (check the cached hint first). */ 864 de = tmpfs_dir_cached(node); 865 if (de == NULL) { 866 struct componentname *cnp = ap->a_cnp; 867 de = tmpfs_dir_lookup(dnode, cnp); 868 } 869 KASSERT(de && de->td_node == node); 870 871 /* Check flags to see if we are allowed to remove the directory. */ 872 if (dnode->tn_flags & APPEND || node->tn_flags & (IMMUTABLE | APPEND)) { 873 error = EPERM; 874 goto out; 875 } 876 877 /* Decrement the link count for the virtual '.' entry. */ 878 node->tn_links--; 879 880 /* Detach the directory entry from the directory. */ 881 tmpfs_dir_detach(dnode, de); 882 883 /* Purge the cache for parent. */ 884 cache_purge(dvp); 885 886 /* 887 * Destroy the directory entry or replace it with a whiteout. 888 * 889 * Note: the inode referred by it will not be destroyed until the 890 * vnode is reclaimed. 891 */ 892 if (ap->a_cnp->cn_flags & DOWHITEOUT) 893 tmpfs_dir_attach(dnode, de, TMPFS_NODE_WHITEOUT); 894 else 895 tmpfs_free_dirent(tmp, de); 896 897 /* Destroy the whiteout entries from the node. */ 898 while ((de = TAILQ_FIRST(&node->tn_spec.tn_dir.tn_dir)) != NULL) { 899 KASSERT(de->td_node == TMPFS_NODE_WHITEOUT); 900 tmpfs_dir_detach(node, de); 901 tmpfs_free_dirent(tmp, de); 902 } 903 tmpfs_update(dvp, TMPFS_UPDATE_MTIME | TMPFS_UPDATE_CTIME); 904 905 KASSERT(node->tn_size == 0); 906 KASSERT(node->tn_links == 0); 907 out: 908 /* Release the nodes. */ 909 vput(dvp); 910 vput(vp); 911 return error; 912 } 913 914 int 915 tmpfs_symlink(void *v) 916 { 917 struct vop_symlink_args /* { 918 struct vnode *a_dvp; 919 struct vnode **a_vpp; 920 struct componentname *a_cnp; 921 struct vattr *a_vap; 922 char *a_target; 923 } */ *ap = v; 924 vnode_t *dvp = ap->a_dvp; 925 vnode_t **vpp = ap->a_vpp; 926 struct componentname *cnp = ap->a_cnp; 927 struct vattr *vap = ap->a_vap; 928 char *target = ap->a_target; 929 930 KASSERT(vap->va_type == VLNK); 931 return tmpfs_construct_node(dvp, vpp, vap, cnp, target); 932 } 933 934 int 935 tmpfs_readdir(void *v) 936 { 937 struct vop_readdir_args /* { 938 struct vnode *a_vp; 939 struct uio *a_uio; 940 kauth_cred_t a_cred; 941 int *a_eofflag; 942 off_t **a_cookies; 943 int *ncookies; 944 } */ *ap = v; 945 vnode_t *vp = ap->a_vp; 946 struct uio *uio = ap->a_uio; 947 int *eofflag = ap->a_eofflag; 948 off_t **cookies = ap->a_cookies; 949 int *ncookies = ap->a_ncookies; 950 off_t startoff, cnt; 951 tmpfs_node_t *node; 952 int error; 953 954 KASSERT(VOP_ISLOCKED(vp)); 955 956 /* This operation only makes sense on directory nodes. */ 957 if (vp->v_type != VDIR) { 958 return ENOTDIR; 959 } 960 node = VP_TO_TMPFS_DIR(vp); 961 startoff = uio->uio_offset; 962 cnt = 0; 963 964 /* 965 * Retrieve the directory entries, unless it is being destroyed. 966 */ 967 if (node->tn_links) { 968 error = tmpfs_dir_getdents(node, uio, &cnt); 969 } else { 970 error = 0; 971 } 972 973 if (eofflag != NULL) { 974 *eofflag = !error && uio->uio_offset == TMPFS_DIRSEQ_EOF; 975 } 976 if (error || cookies == NULL || ncookies == NULL) { 977 return error; 978 } 979 980 /* Update NFS-related variables, if any. */ 981 tmpfs_dirent_t *de = NULL; 982 off_t i, off = startoff; 983 984 *cookies = malloc(cnt * sizeof(off_t), M_TEMP, M_WAITOK); 985 *ncookies = cnt; 986 987 for (i = 0; i < cnt; i++) { 988 KASSERT(off != TMPFS_DIRSEQ_EOF); 989 if (off != TMPFS_DIRSEQ_DOT) { 990 if (off == TMPFS_DIRSEQ_DOTDOT) { 991 de = TAILQ_FIRST(&node->tn_spec.tn_dir.tn_dir); 992 } else if (de != NULL) { 993 de = TAILQ_NEXT(de, td_entries); 994 } else { 995 de = tmpfs_dir_lookupbyseq(node, off); 996 KASSERT(de != NULL); 997 de = TAILQ_NEXT(de, td_entries); 998 } 999 if (de == NULL) { 1000 off = TMPFS_DIRSEQ_EOF; 1001 } else { 1002 off = tmpfs_dir_getseq(node, de); 1003 } 1004 } else { 1005 off = TMPFS_DIRSEQ_DOTDOT; 1006 } 1007 (*cookies)[i] = off; 1008 } 1009 KASSERT(uio->uio_offset == off); 1010 return error; 1011 } 1012 1013 int 1014 tmpfs_readlink(void *v) 1015 { 1016 struct vop_readlink_args /* { 1017 struct vnode *a_vp; 1018 struct uio *a_uio; 1019 kauth_cred_t a_cred; 1020 } */ *ap = v; 1021 vnode_t *vp = ap->a_vp; 1022 struct uio *uio = ap->a_uio; 1023 tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); 1024 int error; 1025 1026 KASSERT(VOP_ISLOCKED(vp)); 1027 KASSERT(uio->uio_offset == 0); 1028 KASSERT(vp->v_type == VLNK); 1029 1030 /* Note: readlink(2) returns the path without NUL terminator. */ 1031 if (node->tn_size > 0) { 1032 error = uiomove(node->tn_spec.tn_lnk.tn_link, 1033 MIN(node->tn_size - 1, uio->uio_resid), uio); 1034 } else { 1035 error = 0; 1036 } 1037 tmpfs_update(vp, TMPFS_UPDATE_ATIME); 1038 1039 return error; 1040 } 1041 1042 int 1043 tmpfs_inactive(void *v) 1044 { 1045 struct vop_inactive_args /* { 1046 struct vnode *a_vp; 1047 bool *a_recycle; 1048 } */ *ap = v; 1049 vnode_t *vp = ap->a_vp; 1050 tmpfs_node_t *node; 1051 1052 KASSERT(VOP_ISLOCKED(vp)); 1053 1054 node = VP_TO_TMPFS_NODE(vp); 1055 *ap->a_recycle = (node->tn_links == 0); 1056 VOP_UNLOCK(vp); 1057 1058 return 0; 1059 } 1060 1061 int 1062 tmpfs_reclaim(void *v) 1063 { 1064 struct vop_reclaim_args /* { 1065 struct vnode *a_vp; 1066 } */ *ap = v; 1067 vnode_t *vp = ap->a_vp; 1068 tmpfs_mount_t *tmp = VFS_TO_TMPFS(vp->v_mount); 1069 tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); 1070 bool recycle; 1071 1072 mutex_enter(&node->tn_vlock); 1073 VOP_LOCK(vp, LK_EXCLUSIVE); 1074 1075 /* Disassociate inode from vnode. */ 1076 node->tn_vnode = NULL; 1077 vp->v_data = NULL; 1078 1079 /* If inode is not referenced, i.e. no links, then destroy it. */ 1080 recycle = node->tn_links == 0 && TMPFS_NODE_RECLAIMING(node) == 0; 1081 1082 VOP_UNLOCK(vp); 1083 mutex_exit(&node->tn_vlock); 1084 1085 if (recycle) { 1086 tmpfs_free_node(tmp, node); 1087 } 1088 return 0; 1089 } 1090 1091 int 1092 tmpfs_pathconf(void *v) 1093 { 1094 struct vop_pathconf_args /* { 1095 struct vnode *a_vp; 1096 int a_name; 1097 register_t *a_retval; 1098 } */ *ap = v; 1099 const int name = ap->a_name; 1100 register_t *retval = ap->a_retval; 1101 int error = 0; 1102 1103 switch (name) { 1104 case _PC_LINK_MAX: 1105 *retval = LINK_MAX; 1106 break; 1107 case _PC_NAME_MAX: 1108 *retval = TMPFS_MAXNAMLEN; 1109 break; 1110 case _PC_PATH_MAX: 1111 *retval = PATH_MAX; 1112 break; 1113 case _PC_PIPE_BUF: 1114 *retval = PIPE_BUF; 1115 break; 1116 case _PC_CHOWN_RESTRICTED: 1117 *retval = 1; 1118 break; 1119 case _PC_NO_TRUNC: 1120 *retval = 1; 1121 break; 1122 case _PC_SYNC_IO: 1123 *retval = 1; 1124 break; 1125 case _PC_FILESIZEBITS: 1126 *retval = sizeof(off_t) * CHAR_BIT; 1127 break; 1128 default: 1129 error = EINVAL; 1130 } 1131 return error; 1132 } 1133 1134 int 1135 tmpfs_advlock(void *v) 1136 { 1137 struct vop_advlock_args /* { 1138 struct vnode *a_vp; 1139 void * a_id; 1140 int a_op; 1141 struct flock *a_fl; 1142 int a_flags; 1143 } */ *ap = v; 1144 vnode_t *vp = ap->a_vp; 1145 tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); 1146 1147 return lf_advlock(v, &node->tn_lockf, node->tn_size); 1148 } 1149 1150 int 1151 tmpfs_getpages(void *v) 1152 { 1153 struct vop_getpages_args /* { 1154 struct vnode *a_vp; 1155 voff_t a_offset; 1156 struct vm_page **a_m; 1157 int *a_count; 1158 int a_centeridx; 1159 vm_prot_t a_access_type; 1160 int a_advice; 1161 int a_flags; 1162 } */ * const ap = v; 1163 vnode_t *vp = ap->a_vp; 1164 const voff_t offset = ap->a_offset; 1165 struct vm_page **pgs = ap->a_m; 1166 const int centeridx = ap->a_centeridx; 1167 const vm_prot_t access_type = ap->a_access_type; 1168 const int advice = ap->a_advice; 1169 const int flags = ap->a_flags; 1170 int error, npages = *ap->a_count; 1171 tmpfs_node_t *node; 1172 struct uvm_object *uobj; 1173 1174 KASSERT(vp->v_type == VREG); 1175 KASSERT(mutex_owned(vp->v_interlock)); 1176 1177 node = VP_TO_TMPFS_NODE(vp); 1178 uobj = node->tn_spec.tn_reg.tn_aobj; 1179 1180 /* 1181 * Currently, PGO_PASTEOF is not supported. 1182 */ 1183 if (vp->v_size <= offset + (centeridx << PAGE_SHIFT)) { 1184 if ((flags & PGO_LOCKED) == 0) 1185 mutex_exit(vp->v_interlock); 1186 return EINVAL; 1187 } 1188 1189 if (vp->v_size < offset + (npages << PAGE_SHIFT)) { 1190 npages = (round_page(vp->v_size) - offset) >> PAGE_SHIFT; 1191 } 1192 1193 if ((flags & PGO_LOCKED) != 0) 1194 return EBUSY; 1195 1196 if ((flags & PGO_NOTIMESTAMP) == 0) { 1197 u_int tflags = 0; 1198 1199 if ((vp->v_mount->mnt_flag & MNT_NOATIME) == 0) 1200 tflags |= TMPFS_UPDATE_ATIME; 1201 1202 if ((access_type & VM_PROT_WRITE) != 0) { 1203 tflags |= TMPFS_UPDATE_MTIME; 1204 if (vp->v_mount->mnt_flag & MNT_RELATIME) 1205 tflags |= TMPFS_UPDATE_ATIME; 1206 } 1207 tmpfs_update(vp, tflags); 1208 } 1209 1210 /* 1211 * Invoke the pager. 1212 * 1213 * Clean the array of pages before. XXX: PR/32166 1214 * Note that vnode lock is shared with underlying UVM object. 1215 */ 1216 if (pgs) { 1217 memset(pgs, 0, sizeof(struct vm_pages *) * npages); 1218 } 1219 KASSERT(vp->v_interlock == uobj->vmobjlock); 1220 1221 error = (*uobj->pgops->pgo_get)(uobj, offset, pgs, &npages, centeridx, 1222 access_type, advice, flags | PGO_ALLPAGES); 1223 1224 #if defined(DEBUG) 1225 if (!error && pgs) { 1226 for (int i = 0; i < npages; i++) { 1227 KASSERT(pgs[i] != NULL); 1228 } 1229 } 1230 #endif 1231 return error; 1232 } 1233 1234 int 1235 tmpfs_putpages(void *v) 1236 { 1237 struct vop_putpages_args /* { 1238 struct vnode *a_vp; 1239 voff_t a_offlo; 1240 voff_t a_offhi; 1241 int a_flags; 1242 } */ * const ap = v; 1243 vnode_t *vp = ap->a_vp; 1244 const voff_t offlo = ap->a_offlo; 1245 const voff_t offhi = ap->a_offhi; 1246 const int flags = ap->a_flags; 1247 tmpfs_node_t *node; 1248 struct uvm_object *uobj; 1249 int error; 1250 1251 KASSERT(mutex_owned(vp->v_interlock)); 1252 1253 if (vp->v_type != VREG) { 1254 mutex_exit(vp->v_interlock); 1255 return 0; 1256 } 1257 1258 node = VP_TO_TMPFS_NODE(vp); 1259 uobj = node->tn_spec.tn_reg.tn_aobj; 1260 1261 KASSERT(vp->v_interlock == uobj->vmobjlock); 1262 error = (*uobj->pgops->pgo_put)(uobj, offlo, offhi, flags); 1263 1264 /* XXX mtime */ 1265 1266 return error; 1267 } 1268 1269 int 1270 tmpfs_whiteout(void *v) 1271 { 1272 struct vop_whiteout_args /* { 1273 struct vnode *a_dvp; 1274 struct componentname *a_cnp; 1275 int a_flags; 1276 } */ *ap = v; 1277 vnode_t *dvp = ap->a_dvp; 1278 struct componentname *cnp = ap->a_cnp; 1279 const int flags = ap->a_flags; 1280 tmpfs_mount_t *tmp = VFS_TO_TMPFS(dvp->v_mount); 1281 tmpfs_node_t *dnode = VP_TO_TMPFS_DIR(dvp); 1282 tmpfs_dirent_t *de; 1283 int error; 1284 1285 switch (flags) { 1286 case LOOKUP: 1287 break; 1288 case CREATE: 1289 error = tmpfs_alloc_dirent(tmp, cnp->cn_nameptr, 1290 cnp->cn_namelen, &de); 1291 if (error) 1292 return error; 1293 tmpfs_dir_attach(dnode, de, TMPFS_NODE_WHITEOUT); 1294 break; 1295 case DELETE: 1296 cnp->cn_flags &= ~DOWHITEOUT; /* when in doubt, cargo cult */ 1297 de = tmpfs_dir_lookup(dnode, cnp); 1298 if (de == NULL) 1299 return ENOENT; 1300 tmpfs_dir_detach(dnode, de); 1301 tmpfs_free_dirent(tmp, de); 1302 break; 1303 } 1304 tmpfs_update(dvp, TMPFS_UPDATE_MTIME | TMPFS_UPDATE_CTIME); 1305 return 0; 1306 } 1307 1308 int 1309 tmpfs_print(void *v) 1310 { 1311 struct vop_print_args /* { 1312 struct vnode *a_vp; 1313 } */ *ap = v; 1314 vnode_t *vp = ap->a_vp; 1315 tmpfs_node_t *node = VP_TO_TMPFS_NODE(vp); 1316 1317 printf("tag VT_TMPFS, tmpfs_node %p, flags 0x%x, links %d\n" 1318 "\tmode 0%o, owner %d, group %d, size %" PRIdMAX, 1319 node, node->tn_flags, node->tn_links, node->tn_mode, node->tn_uid, 1320 node->tn_gid, (uintmax_t)node->tn_size); 1321 if (vp->v_type == VFIFO) { 1322 VOCALL(fifo_vnodeop_p, VOFFSET(vop_print), v); 1323 } 1324 printf("\n"); 1325 return 0; 1326 } 1327