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