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/ufs/ufs/ufs_vnops.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) 1982, 1986, 1989, 1993, 1995 3 * The Regents of the University of California. All rights reserved. 4 * (c) UNIX System Laboratories, Inc. 5 * All or some portions of this file are derived from material licensed 6 * to the University of California by American Telephone and Telegraph 7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 8 * the permission of UNIX System Laboratories, Inc. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 4. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * @(#)ufs_vnops.c 8.27 (Berkeley) 5/27/95 35 */ 36 37 #include <sys/cdefs.h> 38 __FBSDID("$FreeBSD: releng/8.2/sys/ufs/ufs/ufs_vnops.c 206809 2010-04-18 20:34:46Z trasz $"); 39 40 #include "opt_quota.h" 41 #include "opt_suiddir.h" 42 #include "opt_ufs.h" 43 #include "opt_ffs.h" 44 45 #include <sys/param.h> 46 #include <sys/systm.h> 47 #include <sys/malloc.h> 48 #include <sys/namei.h> 49 #include <sys/kernel.h> 50 #include <sys/fcntl.h> 51 #include <sys/stat.h> 52 #include <sys/bio.h> 53 #include <sys/buf.h> 54 #include <sys/mount.h> 55 #include <sys/priv.h> 56 #include <sys/refcount.h> 57 #include <sys/unistd.h> 58 #include <sys/vnode.h> 59 #include <sys/dirent.h> 60 #include <sys/lockf.h> 61 #include <sys/conf.h> 62 #include <sys/acl.h> 63 64 #include <machine/mutex.h> 65 66 #include <security/mac/mac_framework.h> 67 68 #include <sys/file.h> /* XXX */ 69 70 #include <vm/vm.h> 71 #include <vm/vm_extern.h> 72 73 #include <fs/fifofs/fifo.h> 74 75 #include <ufs/ufs/acl.h> 76 #include <ufs/ufs/extattr.h> 77 #include <ufs/ufs/quota.h> 78 #include <ufs/ufs/inode.h> 79 #include <ufs/ufs/dir.h> 80 #include <ufs/ufs/ufsmount.h> 81 #include <ufs/ufs/ufs_extern.h> 82 #ifdef UFS_DIRHASH 83 #include <ufs/ufs/dirhash.h> 84 #endif 85 #ifdef UFS_GJOURNAL 86 #include <ufs/ufs/gjournal.h> 87 #endif 88 89 #include <ufs/ffs/ffs_extern.h> 90 91 static vop_accessx_t ufs_accessx; 92 static int ufs_chmod(struct vnode *, int, struct ucred *, struct thread *); 93 static int ufs_chown(struct vnode *, uid_t, gid_t, struct ucred *, struct thread *); 94 static vop_close_t ufs_close; 95 static vop_create_t ufs_create; 96 static vop_getattr_t ufs_getattr; 97 static vop_link_t ufs_link; 98 static int ufs_makeinode(int mode, struct vnode *, struct vnode **, struct componentname *); 99 static vop_markatime_t ufs_markatime; 100 static vop_mkdir_t ufs_mkdir; 101 static vop_mknod_t ufs_mknod; 102 static vop_open_t ufs_open; 103 static vop_pathconf_t ufs_pathconf; 104 static vop_print_t ufs_print; 105 static vop_readlink_t ufs_readlink; 106 static vop_remove_t ufs_remove; 107 static vop_rename_t ufs_rename; 108 static vop_rmdir_t ufs_rmdir; 109 static vop_setattr_t ufs_setattr; 110 static vop_strategy_t ufs_strategy; 111 static vop_symlink_t ufs_symlink; 112 static vop_whiteout_t ufs_whiteout; 113 static vop_close_t ufsfifo_close; 114 static vop_kqfilter_t ufsfifo_kqfilter; 115 static vop_pathconf_t ufsfifo_pathconf; 116 117 /* 118 * A virgin directory (no blushing please). 119 */ 120 static struct dirtemplate mastertemplate = { 121 0, 12, DT_DIR, 1, ".", 122 0, DIRBLKSIZ - 12, DT_DIR, 2, ".." 123 }; 124 static struct odirtemplate omastertemplate = { 125 0, 12, 1, ".", 126 0, DIRBLKSIZ - 12, 2, ".." 127 }; 128 129 static void 130 ufs_itimes_locked(struct vnode *vp) 131 { 132 struct inode *ip; 133 struct timespec ts; 134 135 ASSERT_VI_LOCKED(vp, __func__); 136 137 ip = VTOI(vp); 138 if (UFS_RDONLY(ip)) 139 goto out; 140 if ((ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_UPDATE)) == 0) 141 return; 142 143 if ((vp->v_type == VBLK || vp->v_type == VCHR) && !DOINGSOFTDEP(vp)) 144 ip->i_flag |= IN_LAZYMOD; 145 else if (((vp->v_mount->mnt_kern_flag & 146 (MNTK_SUSPENDED | MNTK_SUSPEND)) == 0) || 147 (ip->i_flag & (IN_CHANGE | IN_UPDATE))) 148 ip->i_flag |= IN_MODIFIED; 149 else if (ip->i_flag & IN_ACCESS) 150 ip->i_flag |= IN_LAZYACCESS; 151 vfs_timestamp(&ts); 152 if (ip->i_flag & IN_ACCESS) { 153 DIP_SET(ip, i_atime, ts.tv_sec); 154 DIP_SET(ip, i_atimensec, ts.tv_nsec); 155 } 156 if (ip->i_flag & IN_UPDATE) { 157 DIP_SET(ip, i_mtime, ts.tv_sec); 158 DIP_SET(ip, i_mtimensec, ts.tv_nsec); 159 } 160 if (ip->i_flag & IN_CHANGE) { 161 DIP_SET(ip, i_ctime, ts.tv_sec); 162 DIP_SET(ip, i_ctimensec, ts.tv_nsec); 163 DIP_SET(ip, i_modrev, DIP(ip, i_modrev) + 1); 164 } 165 166 out: 167 ip->i_flag &= ~(IN_ACCESS | IN_CHANGE | IN_UPDATE); 168 } 169 170 void 171 ufs_itimes(struct vnode *vp) 172 { 173 174 VI_LOCK(vp); 175 ufs_itimes_locked(vp); 176 VI_UNLOCK(vp); 177 } 178 179 /* 180 * Create a regular file 181 */ 182 static int 183 ufs_create(ap) 184 struct vop_create_args /* { 185 struct vnode *a_dvp; 186 struct vnode **a_vpp; 187 struct componentname *a_cnp; 188 struct vattr *a_vap; 189 } */ *ap; 190 { 191 int error; 192 193 error = 194 ufs_makeinode(MAKEIMODE(ap->a_vap->va_type, ap->a_vap->va_mode), 195 ap->a_dvp, ap->a_vpp, ap->a_cnp); 196 if (error) 197 return (error); 198 return (0); 199 } 200 201 /* 202 * Mknod vnode call 203 */ 204 /* ARGSUSED */ 205 static int 206 ufs_mknod(ap) 207 struct vop_mknod_args /* { 208 struct vnode *a_dvp; 209 struct vnode **a_vpp; 210 struct componentname *a_cnp; 211 struct vattr *a_vap; 212 } */ *ap; 213 { 214 struct vattr *vap = ap->a_vap; 215 struct vnode **vpp = ap->a_vpp; 216 struct inode *ip; 217 ino_t ino; 218 int error; 219 220 error = ufs_makeinode(MAKEIMODE(vap->va_type, vap->va_mode), 221 ap->a_dvp, vpp, ap->a_cnp); 222 if (error) 223 return (error); 224 ip = VTOI(*vpp); 225 ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE; 226 if (vap->va_rdev != VNOVAL) { 227 /* 228 * Want to be able to use this to make badblock 229 * inodes, so don't truncate the dev number. 230 */ 231 DIP_SET(ip, i_rdev, vap->va_rdev); 232 } 233 /* 234 * Remove inode, then reload it through VFS_VGET so it is 235 * checked to see if it is an alias of an existing entry in 236 * the inode cache. XXX I don't believe this is necessary now. 237 */ 238 (*vpp)->v_type = VNON; 239 ino = ip->i_number; /* Save this before vgone() invalidates ip. */ 240 vgone(*vpp); 241 vput(*vpp); 242 error = VFS_VGET(ap->a_dvp->v_mount, ino, LK_EXCLUSIVE, vpp); 243 if (error) { 244 *vpp = NULL; 245 return (error); 246 } 247 return (0); 248 } 249 250 /* 251 * Open called. 252 */ 253 /* ARGSUSED */ 254 static int 255 ufs_open(struct vop_open_args *ap) 256 { 257 struct vnode *vp = ap->a_vp; 258 struct inode *ip; 259 260 if (vp->v_type == VCHR || vp->v_type == VBLK) 261 return (EOPNOTSUPP); 262 263 ip = VTOI(vp); 264 /* 265 * Files marked append-only must be opened for appending. 266 */ 267 if ((ip->i_flags & APPEND) && 268 (ap->a_mode & (FWRITE | O_APPEND)) == FWRITE) 269 return (EPERM); 270 vnode_create_vobject(vp, DIP(ip, i_size), ap->a_td); 271 return (0); 272 } 273 274 /* 275 * Close called. 276 * 277 * Update the times on the inode. 278 */ 279 /* ARGSUSED */ 280 static int 281 ufs_close(ap) 282 struct vop_close_args /* { 283 struct vnode *a_vp; 284 int a_fflag; 285 struct ucred *a_cred; 286 struct thread *a_td; 287 } */ *ap; 288 { 289 struct vnode *vp = ap->a_vp; 290 int usecount; 291 292 VI_LOCK(vp); 293 usecount = vp->v_usecount; 294 if (usecount > 1) 295 ufs_itimes_locked(vp); 296 VI_UNLOCK(vp); 297 return (0); 298 } 299 300 static int 301 ufs_accessx(ap) 302 struct vop_accessx_args /* { 303 struct vnode *a_vp; 304 accmode_t a_accmode; 305 struct ucred *a_cred; 306 struct thread *a_td; 307 } */ *ap; 308 { 309 struct vnode *vp = ap->a_vp; 310 struct inode *ip = VTOI(vp); 311 accmode_t accmode = ap->a_accmode; 312 int error; 313 #ifdef QUOTA 314 int relocked; 315 #endif 316 #ifdef UFS_ACL 317 struct acl *acl; 318 acl_type_t type; 319 #endif 320 321 /* 322 * Disallow write attempts on read-only filesystems; 323 * unless the file is a socket, fifo, or a block or 324 * character device resident on the filesystem. 325 */ 326 if (accmode & VMODIFY_PERMS) { 327 switch (vp->v_type) { 328 case VDIR: 329 case VLNK: 330 case VREG: 331 if (vp->v_mount->mnt_flag & MNT_RDONLY) 332 return (EROFS); 333 #ifdef QUOTA 334 /* 335 * Inode is accounted in the quotas only if struct 336 * dquot is attached to it. VOP_ACCESS() is called 337 * from vn_open_cred() and provides a convenient 338 * point to call getinoquota(). 339 */ 340 if (VOP_ISLOCKED(vp) != LK_EXCLUSIVE) { 341 342 /* 343 * Upgrade vnode lock, since getinoquota() 344 * requires exclusive lock to modify inode. 345 */ 346 relocked = 1; 347 vhold(vp); 348 vn_lock(vp, LK_UPGRADE | LK_RETRY); 349 VI_LOCK(vp); 350 if (vp->v_iflag & VI_DOOMED) { 351 vdropl(vp); 352 error = ENOENT; 353 goto relock; 354 } 355 vdropl(vp); 356 } else 357 relocked = 0; 358 error = getinoquota(ip); 359 relock: 360 if (relocked) 361 vn_lock(vp, LK_DOWNGRADE | LK_RETRY); 362 if (error != 0) 363 return (error); 364 #endif 365 break; 366 default: 367 break; 368 } 369 } 370 371 /* 372 * If immutable bit set, nobody gets to write it. "& ~VADMIN_PERMS" 373 * is here, because without it, * it would be impossible for the owner 374 * to remove the IMMUTABLE flag. 375 */ 376 if ((accmode & (VMODIFY_PERMS & ~VADMIN_PERMS)) && 377 (ip->i_flags & (IMMUTABLE | SF_SNAPSHOT))) 378 return (EPERM); 379 380 #ifdef UFS_ACL 381 if ((vp->v_mount->mnt_flag & (MNT_ACLS | MNT_NFS4ACLS)) != 0) { 382 if (vp->v_mount->mnt_flag & MNT_NFS4ACLS) 383 type = ACL_TYPE_NFS4; 384 else 385 type = ACL_TYPE_ACCESS; 386 387 acl = acl_alloc(M_WAITOK); 388 if (type == ACL_TYPE_NFS4) 389 error = ufs_getacl_nfs4_internal(vp, acl, ap->a_td); 390 else 391 error = VOP_GETACL(vp, type, acl, ap->a_cred, ap->a_td); 392 switch (error) { 393 case 0: 394 if (type == ACL_TYPE_NFS4) { 395 error = vaccess_acl_nfs4(vp->v_type, ip->i_uid, 396 ip->i_gid, acl, accmode, ap->a_cred, NULL); 397 } else { 398 error = vfs_unixify_accmode(&accmode); 399 if (error == 0) 400 error = vaccess_acl_posix1e(vp->v_type, ip->i_uid, 401 ip->i_gid, acl, accmode, ap->a_cred, NULL); 402 } 403 break; 404 default: 405 if (error != EOPNOTSUPP) 406 printf( 407 "ufs_accessx(): Error retrieving ACL on object (%d).\n", 408 error); 409 /* 410 * XXX: Fall back until debugged. Should 411 * eventually possibly log an error, and return 412 * EPERM for safety. 413 */ 414 error = vfs_unixify_accmode(&accmode); 415 if (error == 0) 416 error = vaccess(vp->v_type, ip->i_mode, ip->i_uid, 417 ip->i_gid, accmode, ap->a_cred, NULL); 418 } 419 acl_free(acl); 420 421 return (error); 422 } 423 #endif /* !UFS_ACL */ 424 error = vfs_unixify_accmode(&accmode); 425 if (error == 0) 426 error = vaccess(vp->v_type, ip->i_mode, ip->i_uid, ip->i_gid, 427 accmode, ap->a_cred, NULL); 428 return (error); 429 } 430 431 /* ARGSUSED */ 432 static int 433 ufs_getattr(ap) 434 struct vop_getattr_args /* { 435 struct vnode *a_vp; 436 struct vattr *a_vap; 437 struct ucred *a_cred; 438 } */ *ap; 439 { 440 struct vnode *vp = ap->a_vp; 441 struct inode *ip = VTOI(vp); 442 struct vattr *vap = ap->a_vap; 443 444 VI_LOCK(vp); 445 ufs_itimes_locked(vp); 446 if (ip->i_ump->um_fstype == UFS1) { 447 vap->va_atime.tv_sec = ip->i_din1->di_atime; 448 vap->va_atime.tv_nsec = ip->i_din1->di_atimensec; 449 } else { 450 vap->va_atime.tv_sec = ip->i_din2->di_atime; 451 vap->va_atime.tv_nsec = ip->i_din2->di_atimensec; 452 } 453 VI_UNLOCK(vp); 454 /* 455 * Copy from inode table 456 */ 457 vap->va_fsid = dev2udev(ip->i_dev); 458 vap->va_fileid = ip->i_number; 459 vap->va_mode = ip->i_mode & ~IFMT; 460 vap->va_nlink = ip->i_effnlink; 461 vap->va_uid = ip->i_uid; 462 vap->va_gid = ip->i_gid; 463 if (ip->i_ump->um_fstype == UFS1) { 464 vap->va_rdev = ip->i_din1->di_rdev; 465 vap->va_size = ip->i_din1->di_size; 466 vap->va_mtime.tv_sec = ip->i_din1->di_mtime; 467 vap->va_mtime.tv_nsec = ip->i_din1->di_mtimensec; 468 vap->va_ctime.tv_sec = ip->i_din1->di_ctime; 469 vap->va_ctime.tv_nsec = ip->i_din1->di_ctimensec; 470 vap->va_bytes = dbtob((u_quad_t)ip->i_din1->di_blocks); 471 vap->va_filerev = ip->i_din1->di_modrev; 472 } else { 473 vap->va_rdev = ip->i_din2->di_rdev; 474 vap->va_size = ip->i_din2->di_size; 475 vap->va_mtime.tv_sec = ip->i_din2->di_mtime; 476 vap->va_mtime.tv_nsec = ip->i_din2->di_mtimensec; 477 vap->va_ctime.tv_sec = ip->i_din2->di_ctime; 478 vap->va_ctime.tv_nsec = ip->i_din2->di_ctimensec; 479 vap->va_birthtime.tv_sec = ip->i_din2->di_birthtime; 480 vap->va_birthtime.tv_nsec = ip->i_din2->di_birthnsec; 481 vap->va_bytes = dbtob((u_quad_t)ip->i_din2->di_blocks); 482 vap->va_filerev = ip->i_din2->di_modrev; 483 } 484 vap->va_flags = ip->i_flags; 485 vap->va_gen = ip->i_gen; 486 vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize; 487 vap->va_type = IFTOVT(ip->i_mode); 488 return (0); 489 } 490 491 /* 492 * Set attribute vnode op. called from several syscalls 493 */ 494 static int 495 ufs_setattr(ap) 496 struct vop_setattr_args /* { 497 struct vnode *a_vp; 498 struct vattr *a_vap; 499 struct ucred *a_cred; 500 } */ *ap; 501 { 502 struct vattr *vap = ap->a_vap; 503 struct vnode *vp = ap->a_vp; 504 struct inode *ip = VTOI(vp); 505 struct ucred *cred = ap->a_cred; 506 struct thread *td = curthread; 507 int error; 508 509 /* 510 * Check for unsettable attributes. 511 */ 512 if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) || 513 (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) || 514 (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) || 515 ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) { 516 return (EINVAL); 517 } 518 if (vap->va_flags != VNOVAL) { 519 if (vp->v_mount->mnt_flag & MNT_RDONLY) 520 return (EROFS); 521 /* 522 * Callers may only modify the file flags on objects they 523 * have VADMIN rights for. 524 */ 525 if ((error = VOP_ACCESS(vp, VADMIN, cred, td))) 526 return (error); 527 /* 528 * Unprivileged processes are not permitted to unset system 529 * flags, or modify flags if any system flags are set. 530 * Privileged non-jail processes may not modify system flags 531 * if securelevel > 0 and any existing system flags are set. 532 * Privileged jail processes behave like privileged non-jail 533 * processes if the security.jail.chflags_allowed sysctl is 534 * is non-zero; otherwise, they behave like unprivileged 535 * processes. 536 */ 537 if (!priv_check_cred(cred, PRIV_VFS_SYSFLAGS, 0)) { 538 if (ip->i_flags 539 & (SF_NOUNLINK | SF_IMMUTABLE | SF_APPEND)) { 540 error = securelevel_gt(cred, 0); 541 if (error) 542 return (error); 543 } 544 /* Snapshot flag cannot be set or cleared */ 545 if (((vap->va_flags & SF_SNAPSHOT) != 0 && 546 (ip->i_flags & SF_SNAPSHOT) == 0) || 547 ((vap->va_flags & SF_SNAPSHOT) == 0 && 548 (ip->i_flags & SF_SNAPSHOT) != 0)) 549 return (EPERM); 550 ip->i_flags = vap->va_flags; 551 DIP_SET(ip, i_flags, vap->va_flags); 552 } else { 553 if (ip->i_flags 554 & (SF_NOUNLINK | SF_IMMUTABLE | SF_APPEND) || 555 (vap->va_flags & UF_SETTABLE) != vap->va_flags) 556 return (EPERM); 557 ip->i_flags &= SF_SETTABLE; 558 ip->i_flags |= (vap->va_flags & UF_SETTABLE); 559 DIP_SET(ip, i_flags, ip->i_flags); 560 } 561 ip->i_flag |= IN_CHANGE; 562 if (vap->va_flags & (IMMUTABLE | APPEND)) 563 return (0); 564 } 565 if (ip->i_flags & (IMMUTABLE | APPEND)) 566 return (EPERM); 567 /* 568 * Go through the fields and update iff not VNOVAL. 569 */ 570 if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) { 571 if (vp->v_mount->mnt_flag & MNT_RDONLY) 572 return (EROFS); 573 if ((error = ufs_chown(vp, vap->va_uid, vap->va_gid, cred, 574 td)) != 0) 575 return (error); 576 } 577 if (vap->va_size != VNOVAL) { 578 /* 579 * XXX most of the following special cases should be in 580 * callers instead of in N filesystems. The VDIR check 581 * mostly already is. 582 */ 583 switch (vp->v_type) { 584 case VDIR: 585 return (EISDIR); 586 case VLNK: 587 case VREG: 588 /* 589 * Truncation should have an effect in these cases. 590 * Disallow it if the filesystem is read-only or 591 * the file is being snapshotted. 592 */ 593 if (vp->v_mount->mnt_flag & MNT_RDONLY) 594 return (EROFS); 595 if ((ip->i_flags & SF_SNAPSHOT) != 0) 596 return (EPERM); 597 break; 598 default: 599 /* 600 * According to POSIX, the result is unspecified 601 * for file types other than regular files, 602 * directories and shared memory objects. We 603 * don't support shared memory objects in the file 604 * system, and have dubious support for truncating 605 * symlinks. Just ignore the request in other cases. 606 */ 607 return (0); 608 } 609 if ((error = UFS_TRUNCATE(vp, vap->va_size, IO_NORMAL, 610 cred, td)) != 0) 611 return (error); 612 } 613 if (vap->va_atime.tv_sec != VNOVAL || 614 vap->va_mtime.tv_sec != VNOVAL || 615 vap->va_birthtime.tv_sec != VNOVAL) { 616 if (vp->v_mount->mnt_flag & MNT_RDONLY) 617 return (EROFS); 618 if ((ip->i_flags & SF_SNAPSHOT) != 0) 619 return (EPERM); 620 /* 621 * From utimes(2): 622 * If times is NULL, ... The caller must be the owner of 623 * the file, have permission to write the file, or be the 624 * super-user. 625 * If times is non-NULL, ... The caller must be the owner of 626 * the file or be the super-user. 627 * 628 * Possibly for historical reasons, try to use VADMIN in 629 * preference to VWRITE for a NULL timestamp. This means we 630 * will return EACCES in preference to EPERM if neither 631 * check succeeds. 632 */ 633 if (vap->va_vaflags & VA_UTIMES_NULL) { 634 /* 635 * NFSv4.1, draft 21, 6.2.1.3.1, Discussion of Mask Attributes 636 * 637 * "A user having ACL_WRITE_DATA or ACL_WRITE_ATTRIBUTES 638 * will be allowed to set the times [..] to the current 639 * server time." 640 * 641 * XXX: Calling it four times seems a little excessive. 642 */ 643 error = VOP_ACCESSX(vp, VWRITE_ATTRIBUTES, cred, td); 644 if (error) 645 error = VOP_ACCESS(vp, VWRITE, cred, td); 646 } else 647 error = VOP_ACCESSX(vp, VWRITE_ATTRIBUTES, cred, td); 648 if (error) 649 return (error); 650 if (vap->va_atime.tv_sec != VNOVAL) 651 ip->i_flag |= IN_ACCESS; 652 if (vap->va_mtime.tv_sec != VNOVAL) 653 ip->i_flag |= IN_CHANGE | IN_UPDATE; 654 if (vap->va_birthtime.tv_sec != VNOVAL && 655 ip->i_ump->um_fstype == UFS2) 656 ip->i_flag |= IN_MODIFIED; 657 ufs_itimes(vp); 658 if (vap->va_atime.tv_sec != VNOVAL) { 659 DIP_SET(ip, i_atime, vap->va_atime.tv_sec); 660 DIP_SET(ip, i_atimensec, vap->va_atime.tv_nsec); 661 } 662 if (vap->va_mtime.tv_sec != VNOVAL) { 663 DIP_SET(ip, i_mtime, vap->va_mtime.tv_sec); 664 DIP_SET(ip, i_mtimensec, vap->va_mtime.tv_nsec); 665 } 666 if (vap->va_birthtime.tv_sec != VNOVAL && 667 ip->i_ump->um_fstype == UFS2) { 668 ip->i_din2->di_birthtime = vap->va_birthtime.tv_sec; 669 ip->i_din2->di_birthnsec = vap->va_birthtime.tv_nsec; 670 } 671 error = UFS_UPDATE(vp, 0); 672 if (error) 673 return (error); 674 } 675 error = 0; 676 if (vap->va_mode != (mode_t)VNOVAL) { 677 if (vp->v_mount->mnt_flag & MNT_RDONLY) 678 return (EROFS); 679 if ((ip->i_flags & SF_SNAPSHOT) != 0 && (vap->va_mode & 680 (S_IXUSR | S_IWUSR | S_IXGRP | S_IWGRP | S_IXOTH | S_IWOTH))) 681 return (EPERM); 682 error = ufs_chmod(vp, (int)vap->va_mode, cred, td); 683 } 684 return (error); 685 } 686 687 #ifdef UFS_ACL 688 static int 689 ufs_update_nfs4_acl_after_mode_change(struct vnode *vp, int mode, 690 int file_owner_id, struct ucred *cred, struct thread *td) 691 { 692 int error; 693 struct acl *aclp; 694 695 aclp = acl_alloc(M_WAITOK); 696 error = ufs_getacl_nfs4_internal(vp, aclp, td); 697 /* 698 * We don't have to handle EOPNOTSUPP here, as the filesystem claims 699 * it supports ACLs. 700 */ 701 if (error) 702 goto out; 703 704 acl_nfs4_sync_acl_from_mode(aclp, mode, file_owner_id); 705 error = ufs_setacl_nfs4_internal(vp, aclp, td); 706 707 out: 708 acl_free(aclp); 709 return (error); 710 } 711 #endif /* UFS_ACL */ 712 713 /* 714 * Mark this file's access time for update for vfs_mark_atime(). This 715 * is called from execve() and mmap(). 716 */ 717 static int 718 ufs_markatime(ap) 719 struct vop_markatime_args /* { 720 struct vnode *a_vp; 721 } */ *ap; 722 { 723 struct vnode *vp = ap->a_vp; 724 struct inode *ip = VTOI(vp); 725 726 VI_LOCK(vp); 727 ip->i_flag |= IN_ACCESS; 728 VI_UNLOCK(vp); 729 return (0); 730 } 731 732 /* 733 * Change the mode on a file. 734 * Inode must be locked before calling. 735 */ 736 static int 737 ufs_chmod(vp, mode, cred, td) 738 struct vnode *vp; 739 int mode; 740 struct ucred *cred; 741 struct thread *td; 742 { 743 struct inode *ip = VTOI(vp); 744 int error; 745 746 /* 747 * To modify the permissions on a file, must possess VADMIN 748 * for that file. 749 */ 750 if ((error = VOP_ACCESSX(vp, VWRITE_ACL, cred, td))) 751 return (error); 752 /* 753 * Privileged processes may set the sticky bit on non-directories, 754 * as well as set the setgid bit on a file with a group that the 755 * process is not a member of. Both of these are allowed in 756 * jail(8). 757 */ 758 if (vp->v_type != VDIR && (mode & S_ISTXT)) { 759 if (priv_check_cred(cred, PRIV_VFS_STICKYFILE, 0)) 760 return (EFTYPE); 761 } 762 if (!groupmember(ip->i_gid, cred) && (mode & ISGID)) { 763 error = priv_check_cred(cred, PRIV_VFS_SETGID, 0); 764 if (error) 765 return (error); 766 } 767 768 /* 769 * Deny setting setuid if we are not the file owner. 770 */ 771 if ((mode & ISUID) && ip->i_uid != cred->cr_uid) { 772 error = priv_check_cred(cred, PRIV_VFS_ADMIN, 0); 773 if (error) 774 return (error); 775 } 776 777 ip->i_mode &= ~ALLPERMS; 778 ip->i_mode |= (mode & ALLPERMS); 779 DIP_SET(ip, i_mode, ip->i_mode); 780 ip->i_flag |= IN_CHANGE; 781 #ifdef UFS_ACL 782 if ((vp->v_mount->mnt_flag & MNT_NFS4ACLS) != 0) 783 error = ufs_update_nfs4_acl_after_mode_change(vp, mode, ip->i_uid, cred, td); 784 #endif 785 return (error); 786 } 787 788 /* 789 * Perform chown operation on inode ip; 790 * inode must be locked prior to call. 791 */ 792 static int 793 ufs_chown(vp, uid, gid, cred, td) 794 struct vnode *vp; 795 uid_t uid; 796 gid_t gid; 797 struct ucred *cred; 798 struct thread *td; 799 { 800 struct inode *ip = VTOI(vp); 801 uid_t ouid; 802 gid_t ogid; 803 int error = 0; 804 #ifdef QUOTA 805 int i; 806 ufs2_daddr_t change; 807 #endif 808 809 if (uid == (uid_t)VNOVAL) 810 uid = ip->i_uid; 811 if (gid == (gid_t)VNOVAL) 812 gid = ip->i_gid; 813 /* 814 * To modify the ownership of a file, must possess VADMIN for that 815 * file. 816 */ 817 if ((error = VOP_ACCESSX(vp, VWRITE_OWNER, cred, td))) 818 return (error); 819 /* 820 * To change the owner of a file, or change the group of a file to a 821 * group of which we are not a member, the caller must have 822 * privilege. 823 */ 824 if (((uid != ip->i_uid && uid != cred->cr_uid) || 825 (gid != ip->i_gid && !groupmember(gid, cred))) && 826 (error = priv_check_cred(cred, PRIV_VFS_CHOWN, 0))) 827 return (error); 828 ogid = ip->i_gid; 829 ouid = ip->i_uid; 830 #ifdef QUOTA 831 if ((error = getinoquota(ip)) != 0) 832 return (error); 833 if (ouid == uid) { 834 dqrele(vp, ip->i_dquot[USRQUOTA]); 835 ip->i_dquot[USRQUOTA] = NODQUOT; 836 } 837 if (ogid == gid) { 838 dqrele(vp, ip->i_dquot[GRPQUOTA]); 839 ip->i_dquot[GRPQUOTA] = NODQUOT; 840 } 841 change = DIP(ip, i_blocks); 842 (void) chkdq(ip, -change, cred, CHOWN); 843 (void) chkiq(ip, -1, cred, CHOWN); 844 for (i = 0; i < MAXQUOTAS; i++) { 845 dqrele(vp, ip->i_dquot[i]); 846 ip->i_dquot[i] = NODQUOT; 847 } 848 #endif 849 ip->i_gid = gid; 850 DIP_SET(ip, i_gid, gid); 851 ip->i_uid = uid; 852 DIP_SET(ip, i_uid, uid); 853 #ifdef QUOTA 854 if ((error = getinoquota(ip)) == 0) { 855 if (ouid == uid) { 856 dqrele(vp, ip->i_dquot[USRQUOTA]); 857 ip->i_dquot[USRQUOTA] = NODQUOT; 858 } 859 if (ogid == gid) { 860 dqrele(vp, ip->i_dquot[GRPQUOTA]); 861 ip->i_dquot[GRPQUOTA] = NODQUOT; 862 } 863 if ((error = chkdq(ip, change, cred, CHOWN)) == 0) { 864 if ((error = chkiq(ip, 1, cred, CHOWN)) == 0) 865 goto good; 866 else 867 (void) chkdq(ip, -change, cred, CHOWN|FORCE); 868 } 869 for (i = 0; i < MAXQUOTAS; i++) { 870 dqrele(vp, ip->i_dquot[i]); 871 ip->i_dquot[i] = NODQUOT; 872 } 873 } 874 ip->i_gid = ogid; 875 DIP_SET(ip, i_gid, ogid); 876 ip->i_uid = ouid; 877 DIP_SET(ip, i_uid, ouid); 878 if (getinoquota(ip) == 0) { 879 if (ouid == uid) { 880 dqrele(vp, ip->i_dquot[USRQUOTA]); 881 ip->i_dquot[USRQUOTA] = NODQUOT; 882 } 883 if (ogid == gid) { 884 dqrele(vp, ip->i_dquot[GRPQUOTA]); 885 ip->i_dquot[GRPQUOTA] = NODQUOT; 886 } 887 (void) chkdq(ip, change, cred, FORCE|CHOWN); 888 (void) chkiq(ip, 1, cred, FORCE|CHOWN); 889 (void) getinoquota(ip); 890 } 891 return (error); 892 good: 893 if (getinoquota(ip)) 894 panic("ufs_chown: lost quota"); 895 #endif /* QUOTA */ 896 ip->i_flag |= IN_CHANGE; 897 if ((ip->i_mode & (ISUID | ISGID)) && (ouid != uid || ogid != gid)) { 898 if (priv_check_cred(cred, PRIV_VFS_RETAINSUGID, 0)) { 899 ip->i_mode &= ~(ISUID | ISGID); 900 DIP_SET(ip, i_mode, ip->i_mode); 901 } 902 } 903 return (0); 904 } 905 906 static int 907 ufs_remove(ap) 908 struct vop_remove_args /* { 909 struct vnode *a_dvp; 910 struct vnode *a_vp; 911 struct componentname *a_cnp; 912 } */ *ap; 913 { 914 struct inode *ip; 915 struct vnode *vp = ap->a_vp; 916 struct vnode *dvp = ap->a_dvp; 917 int error; 918 struct thread *td; 919 920 td = curthread; 921 ip = VTOI(vp); 922 if ((ip->i_flags & (NOUNLINK | IMMUTABLE | APPEND)) || 923 (VTOI(dvp)->i_flags & APPEND)) { 924 error = EPERM; 925 goto out; 926 } 927 #ifdef UFS_GJOURNAL 928 ufs_gjournal_orphan(vp); 929 #endif 930 error = ufs_dirremove(dvp, ip, ap->a_cnp->cn_flags, 0); 931 if (ip->i_nlink <= 0) 932 vp->v_vflag |= VV_NOSYNC; 933 if ((ip->i_flags & SF_SNAPSHOT) != 0) { 934 /* 935 * Avoid deadlock where another thread is trying to 936 * update the inodeblock for dvp and is waiting on 937 * snaplk. Temporary unlock the vnode lock for the 938 * unlinked file and sync the directory. This should 939 * allow vput() of the directory to not block later on 940 * while holding the snapshot vnode locked, assuming 941 * that the directory hasn't been unlinked too. 942 */ 943 VOP_UNLOCK(vp, 0); 944 (void) VOP_FSYNC(dvp, MNT_WAIT, td); 945 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 946 } 947 out: 948 return (error); 949 } 950 951 /* 952 * link vnode call 953 */ 954 static int 955 ufs_link(ap) 956 struct vop_link_args /* { 957 struct vnode *a_tdvp; 958 struct vnode *a_vp; 959 struct componentname *a_cnp; 960 } */ *ap; 961 { 962 struct vnode *vp = ap->a_vp; 963 struct vnode *tdvp = ap->a_tdvp; 964 struct componentname *cnp = ap->a_cnp; 965 struct inode *ip; 966 struct direct newdir; 967 int error; 968 969 #ifdef INVARIANTS 970 if ((cnp->cn_flags & HASBUF) == 0) 971 panic("ufs_link: no name"); 972 #endif 973 if (tdvp->v_mount != vp->v_mount) { 974 error = EXDEV; 975 goto out; 976 } 977 ip = VTOI(vp); 978 if ((nlink_t)ip->i_nlink >= LINK_MAX) { 979 error = EMLINK; 980 goto out; 981 } 982 if (ip->i_flags & (IMMUTABLE | APPEND)) { 983 error = EPERM; 984 goto out; 985 } 986 ip->i_effnlink++; 987 ip->i_nlink++; 988 DIP_SET(ip, i_nlink, ip->i_nlink); 989 ip->i_flag |= IN_CHANGE; 990 if (DOINGSOFTDEP(vp)) 991 softdep_change_linkcnt(ip); 992 error = UFS_UPDATE(vp, !(DOINGSOFTDEP(vp) | DOINGASYNC(vp))); 993 if (!error) { 994 ufs_makedirentry(ip, cnp, &newdir); 995 error = ufs_direnter(tdvp, vp, &newdir, cnp, NULL); 996 } 997 998 if (error) { 999 ip->i_effnlink--; 1000 ip->i_nlink--; 1001 DIP_SET(ip, i_nlink, ip->i_nlink); 1002 ip->i_flag |= IN_CHANGE; 1003 if (DOINGSOFTDEP(vp)) 1004 softdep_change_linkcnt(ip); 1005 } 1006 out: 1007 return (error); 1008 } 1009 1010 /* 1011 * whiteout vnode call 1012 */ 1013 static int 1014 ufs_whiteout(ap) 1015 struct vop_whiteout_args /* { 1016 struct vnode *a_dvp; 1017 struct componentname *a_cnp; 1018 int a_flags; 1019 } */ *ap; 1020 { 1021 struct vnode *dvp = ap->a_dvp; 1022 struct componentname *cnp = ap->a_cnp; 1023 struct direct newdir; 1024 int error = 0; 1025 1026 switch (ap->a_flags) { 1027 case LOOKUP: 1028 /* 4.4 format directories support whiteout operations */ 1029 if (dvp->v_mount->mnt_maxsymlinklen > 0) 1030 return (0); 1031 return (EOPNOTSUPP); 1032 1033 case CREATE: 1034 /* create a new directory whiteout */ 1035 #ifdef INVARIANTS 1036 if ((cnp->cn_flags & SAVENAME) == 0) 1037 panic("ufs_whiteout: missing name"); 1038 if (dvp->v_mount->mnt_maxsymlinklen <= 0) 1039 panic("ufs_whiteout: old format filesystem"); 1040 #endif 1041 1042 newdir.d_ino = WINO; 1043 newdir.d_namlen = cnp->cn_namelen; 1044 bcopy(cnp->cn_nameptr, newdir.d_name, (unsigned)cnp->cn_namelen + 1); 1045 newdir.d_type = DT_WHT; 1046 error = ufs_direnter(dvp, NULL, &newdir, cnp, NULL); 1047 break; 1048 1049 case DELETE: 1050 /* remove an existing directory whiteout */ 1051 #ifdef INVARIANTS 1052 if (dvp->v_mount->mnt_maxsymlinklen <= 0) 1053 panic("ufs_whiteout: old format filesystem"); 1054 #endif 1055 1056 cnp->cn_flags &= ~DOWHITEOUT; 1057 error = ufs_dirremove(dvp, NULL, cnp->cn_flags, 0); 1058 break; 1059 default: 1060 panic("ufs_whiteout: unknown op"); 1061 } 1062 return (error); 1063 } 1064 1065 /* 1066 * Rename system call. 1067 * rename("foo", "bar"); 1068 * is essentially 1069 * unlink("bar"); 1070 * link("foo", "bar"); 1071 * unlink("foo"); 1072 * but ``atomically''. Can't do full commit without saving state in the 1073 * inode on disk which isn't feasible at this time. Best we can do is 1074 * always guarantee the target exists. 1075 * 1076 * Basic algorithm is: 1077 * 1078 * 1) Bump link count on source while we're linking it to the 1079 * target. This also ensure the inode won't be deleted out 1080 * from underneath us while we work (it may be truncated by 1081 * a concurrent `trunc' or `open' for creation). 1082 * 2) Link source to destination. If destination already exists, 1083 * delete it first. 1084 * 3) Unlink source reference to inode if still around. If a 1085 * directory was moved and the parent of the destination 1086 * is different from the source, patch the ".." entry in the 1087 * directory. 1088 */ 1089 static int 1090 ufs_rename(ap) 1091 struct vop_rename_args /* { 1092 struct vnode *a_fdvp; 1093 struct vnode *a_fvp; 1094 struct componentname *a_fcnp; 1095 struct vnode *a_tdvp; 1096 struct vnode *a_tvp; 1097 struct componentname *a_tcnp; 1098 } */ *ap; 1099 { 1100 struct vnode *tvp = ap->a_tvp; 1101 struct vnode *tdvp = ap->a_tdvp; 1102 struct vnode *fvp = ap->a_fvp; 1103 struct vnode *fdvp = ap->a_fdvp; 1104 struct componentname *tcnp = ap->a_tcnp; 1105 struct componentname *fcnp = ap->a_fcnp; 1106 struct thread *td = fcnp->cn_thread; 1107 struct inode *ip, *xp, *dp; 1108 struct direct newdir; 1109 int doingdirectory = 0, oldparent = 0, newparent = 0; 1110 int error = 0, ioflag; 1111 ino_t fvp_ino; 1112 1113 #ifdef INVARIANTS 1114 if ((tcnp->cn_flags & HASBUF) == 0 || 1115 (fcnp->cn_flags & HASBUF) == 0) 1116 panic("ufs_rename: no name"); 1117 #endif 1118 /* 1119 * Check for cross-device rename. 1120 */ 1121 if ((fvp->v_mount != tdvp->v_mount) || 1122 (tvp && (fvp->v_mount != tvp->v_mount))) { 1123 error = EXDEV; 1124 abortit: 1125 if (tdvp == tvp) 1126 vrele(tdvp); 1127 else 1128 vput(tdvp); 1129 if (tvp) 1130 vput(tvp); 1131 vrele(fdvp); 1132 vrele(fvp); 1133 return (error); 1134 } 1135 1136 if (tvp && ((VTOI(tvp)->i_flags & (NOUNLINK | IMMUTABLE | APPEND)) || 1137 (VTOI(tdvp)->i_flags & APPEND))) { 1138 error = EPERM; 1139 goto abortit; 1140 } 1141 1142 /* 1143 * Renaming a file to itself has no effect. The upper layers should 1144 * not call us in that case. Temporarily just warn if they do. 1145 */ 1146 if (fvp == tvp) { 1147 printf("ufs_rename: fvp == tvp (can't happen)\n"); 1148 error = 0; 1149 goto abortit; 1150 } 1151 1152 if ((error = vn_lock(fvp, LK_EXCLUSIVE)) != 0) 1153 goto abortit; 1154 dp = VTOI(fdvp); 1155 ip = VTOI(fvp); 1156 if (ip->i_nlink >= LINK_MAX) { 1157 VOP_UNLOCK(fvp, 0); 1158 error = EMLINK; 1159 goto abortit; 1160 } 1161 if ((ip->i_flags & (NOUNLINK | IMMUTABLE | APPEND)) 1162 || (dp->i_flags & APPEND)) { 1163 VOP_UNLOCK(fvp, 0); 1164 error = EPERM; 1165 goto abortit; 1166 } 1167 if ((ip->i_mode & IFMT) == IFDIR) { 1168 /* 1169 * Avoid ".", "..", and aliases of "." for obvious reasons. 1170 */ 1171 if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.') || 1172 dp == ip || (fcnp->cn_flags | tcnp->cn_flags) & ISDOTDOT || 1173 (ip->i_flag & IN_RENAME)) { 1174 VOP_UNLOCK(fvp, 0); 1175 error = EINVAL; 1176 goto abortit; 1177 } 1178 ip->i_flag |= IN_RENAME; 1179 oldparent = dp->i_number; 1180 doingdirectory = 1; 1181 } 1182 vrele(fdvp); 1183 1184 /* 1185 * When the target exists, both the directory 1186 * and target vnodes are returned locked. 1187 */ 1188 dp = VTOI(tdvp); 1189 xp = NULL; 1190 if (tvp) 1191 xp = VTOI(tvp); 1192 1193 /* 1194 * 1) Bump link count while we're moving stuff 1195 * around. If we crash somewhere before 1196 * completing our work, the link count 1197 * may be wrong, but correctable. 1198 */ 1199 ip->i_effnlink++; 1200 ip->i_nlink++; 1201 DIP_SET(ip, i_nlink, ip->i_nlink); 1202 ip->i_flag |= IN_CHANGE; 1203 if (DOINGSOFTDEP(fvp)) 1204 softdep_change_linkcnt(ip); 1205 if ((error = UFS_UPDATE(fvp, !(DOINGSOFTDEP(fvp) | 1206 DOINGASYNC(fvp)))) != 0) { 1207 VOP_UNLOCK(fvp, 0); 1208 goto bad; 1209 } 1210 1211 /* 1212 * If ".." must be changed (ie the directory gets a new 1213 * parent) then the source directory must not be in the 1214 * directory hierarchy above the target, as this would 1215 * orphan everything below the source directory. Also 1216 * the user must have write permission in the source so 1217 * as to be able to change "..". We must repeat the call 1218 * to namei, as the parent directory is unlocked by the 1219 * call to checkpath(). 1220 */ 1221 error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_thread); 1222 fvp_ino = ip->i_number; 1223 VOP_UNLOCK(fvp, 0); 1224 if (oldparent != dp->i_number) 1225 newparent = dp->i_number; 1226 if (doingdirectory && newparent) { 1227 if (error) /* write access check above */ 1228 goto bad; 1229 if (xp != NULL) 1230 vput(tvp); 1231 error = ufs_checkpath(fvp_ino, dp, tcnp->cn_cred); 1232 if (error) 1233 goto out; 1234 if ((tcnp->cn_flags & SAVESTART) == 0) 1235 panic("ufs_rename: lost to startdir"); 1236 VREF(tdvp); 1237 error = relookup(tdvp, &tvp, tcnp); 1238 if (error) 1239 goto out; 1240 vrele(tdvp); 1241 dp = VTOI(tdvp); 1242 xp = NULL; 1243 if (tvp) 1244 xp = VTOI(tvp); 1245 } 1246 /* 1247 * 2) If target doesn't exist, link the target 1248 * to the source and unlink the source. 1249 * Otherwise, rewrite the target directory 1250 * entry to reference the source inode and 1251 * expunge the original entry's existence. 1252 */ 1253 if (xp == NULL) { 1254 if (dp->i_dev != ip->i_dev) 1255 panic("ufs_rename: EXDEV"); 1256 /* 1257 * Account for ".." in new directory. 1258 * When source and destination have the same 1259 * parent we don't fool with the link count. 1260 */ 1261 if (doingdirectory && newparent) { 1262 if ((nlink_t)dp->i_nlink >= LINK_MAX) { 1263 error = EMLINK; 1264 goto bad; 1265 } 1266 dp->i_effnlink++; 1267 dp->i_nlink++; 1268 DIP_SET(dp, i_nlink, dp->i_nlink); 1269 dp->i_flag |= IN_CHANGE; 1270 if (DOINGSOFTDEP(tdvp)) 1271 softdep_change_linkcnt(dp); 1272 error = UFS_UPDATE(tdvp, !(DOINGSOFTDEP(tdvp) | 1273 DOINGASYNC(tdvp))); 1274 if (error) 1275 goto bad; 1276 } 1277 ufs_makedirentry(ip, tcnp, &newdir); 1278 error = ufs_direnter(tdvp, NULL, &newdir, tcnp, NULL); 1279 if (error) { 1280 if (doingdirectory && newparent) { 1281 dp->i_effnlink--; 1282 dp->i_nlink--; 1283 DIP_SET(dp, i_nlink, dp->i_nlink); 1284 dp->i_flag |= IN_CHANGE; 1285 if (DOINGSOFTDEP(tdvp)) 1286 softdep_change_linkcnt(dp); 1287 (void)UFS_UPDATE(tdvp, 1); 1288 } 1289 goto bad; 1290 } 1291 vput(tdvp); 1292 } else { 1293 if (xp->i_dev != dp->i_dev || xp->i_dev != ip->i_dev) 1294 panic("ufs_rename: EXDEV"); 1295 /* 1296 * Short circuit rename(foo, foo). 1297 */ 1298 if (xp->i_number == ip->i_number) 1299 panic("ufs_rename: same file"); 1300 /* 1301 * If the parent directory is "sticky", then the caller 1302 * must possess VADMIN for the parent directory, or the 1303 * destination of the rename. This implements append-only 1304 * directories. 1305 */ 1306 if ((dp->i_mode & S_ISTXT) && 1307 VOP_ACCESS(tdvp, VADMIN, tcnp->cn_cred, td) && 1308 VOP_ACCESS(tvp, VADMIN, tcnp->cn_cred, td)) { 1309 error = EPERM; 1310 goto bad; 1311 } 1312 /* 1313 * Target must be empty if a directory and have no links 1314 * to it. Also, ensure source and target are compatible 1315 * (both directories, or both not directories). 1316 */ 1317 if ((xp->i_mode&IFMT) == IFDIR) { 1318 if ((xp->i_effnlink > 2) || 1319 !ufs_dirempty(xp, dp->i_number, tcnp->cn_cred)) { 1320 error = ENOTEMPTY; 1321 goto bad; 1322 } 1323 if (!doingdirectory) { 1324 error = ENOTDIR; 1325 goto bad; 1326 } 1327 cache_purge(tdvp); 1328 } else if (doingdirectory) { 1329 error = EISDIR; 1330 goto bad; 1331 } 1332 error = ufs_dirrewrite(dp, xp, ip->i_number, 1333 IFTODT(ip->i_mode), 1334 (doingdirectory && newparent) ? newparent : doingdirectory); 1335 if (error) 1336 goto bad; 1337 if (doingdirectory) { 1338 if (!newparent) { 1339 dp->i_effnlink--; 1340 if (DOINGSOFTDEP(tdvp)) 1341 softdep_change_linkcnt(dp); 1342 } 1343 xp->i_effnlink--; 1344 if (DOINGSOFTDEP(tvp)) 1345 softdep_change_linkcnt(xp); 1346 } 1347 if (doingdirectory && !DOINGSOFTDEP(tvp)) { 1348 /* 1349 * Truncate inode. The only stuff left in the directory 1350 * is "." and "..". The "." reference is inconsequential 1351 * since we are quashing it. We have removed the "." 1352 * reference and the reference in the parent directory, 1353 * but there may be other hard links. The soft 1354 * dependency code will arrange to do these operations 1355 * after the parent directory entry has been deleted on 1356 * disk, so when running with that code we avoid doing 1357 * them now. 1358 */ 1359 if (!newparent) { 1360 dp->i_nlink--; 1361 DIP_SET(dp, i_nlink, dp->i_nlink); 1362 dp->i_flag |= IN_CHANGE; 1363 } 1364 xp->i_nlink--; 1365 DIP_SET(xp, i_nlink, xp->i_nlink); 1366 xp->i_flag |= IN_CHANGE; 1367 ioflag = IO_NORMAL; 1368 if (!DOINGASYNC(tvp)) 1369 ioflag |= IO_SYNC; 1370 if ((error = UFS_TRUNCATE(tvp, (off_t)0, ioflag, 1371 tcnp->cn_cred, tcnp->cn_thread)) != 0) 1372 goto bad; 1373 } 1374 vput(tdvp); 1375 vput(tvp); 1376 xp = NULL; 1377 } 1378 1379 /* 1380 * 3) Unlink the source. 1381 */ 1382 fcnp->cn_flags &= ~MODMASK; 1383 fcnp->cn_flags |= LOCKPARENT | LOCKLEAF; 1384 if ((fcnp->cn_flags & SAVESTART) == 0) 1385 panic("ufs_rename: lost from startdir"); 1386 VREF(fdvp); 1387 error = relookup(fdvp, &fvp, fcnp); 1388 if (error == 0) 1389 vrele(fdvp); 1390 if (fvp != NULL) { 1391 xp = VTOI(fvp); 1392 dp = VTOI(fdvp); 1393 } else { 1394 /* 1395 * From name has disappeared. IN_RENAME is not sufficient 1396 * to protect against directory races due to timing windows, 1397 * so we have to remove the panic. XXX the only real way 1398 * to solve this issue is at a much higher level. By the 1399 * time we hit ufs_rename() it's too late. 1400 */ 1401 #if 0 1402 if (doingdirectory) 1403 panic("ufs_rename: lost dir entry"); 1404 #endif 1405 vrele(ap->a_fvp); 1406 return (0); 1407 } 1408 /* 1409 * Ensure that the directory entry still exists and has not 1410 * changed while the new name has been entered. If the source is 1411 * a file then the entry may have been unlinked or renamed. In 1412 * either case there is no further work to be done. If the source 1413 * is a directory then it cannot have been rmdir'ed; the IN_RENAME 1414 * flag ensures that it cannot be moved by another rename or removed 1415 * by a rmdir. 1416 */ 1417 if (xp != ip) { 1418 /* 1419 * From name resolves to a different inode. IN_RENAME is 1420 * not sufficient protection against timing window races 1421 * so we can't panic here. XXX the only real way 1422 * to solve this issue is at a much higher level. By the 1423 * time we hit ufs_rename() it's too late. 1424 */ 1425 #if 0 1426 if (doingdirectory) 1427 panic("ufs_rename: lost dir entry"); 1428 #endif 1429 } else { 1430 /* 1431 * If the source is a directory with a 1432 * new parent, the link count of the old 1433 * parent directory must be decremented 1434 * and ".." set to point to the new parent. 1435 */ 1436 if (doingdirectory && newparent) { 1437 xp->i_offset = mastertemplate.dot_reclen; 1438 ufs_dirrewrite(xp, dp, newparent, DT_DIR, 0); 1439 cache_purge(fdvp); 1440 } 1441 error = ufs_dirremove(fdvp, xp, fcnp->cn_flags, 0); 1442 xp->i_flag &= ~IN_RENAME; 1443 } 1444 if (dp) 1445 vput(fdvp); 1446 if (xp) 1447 vput(fvp); 1448 vrele(ap->a_fvp); 1449 return (error); 1450 1451 bad: 1452 if (xp) 1453 vput(ITOV(xp)); 1454 vput(ITOV(dp)); 1455 out: 1456 if (doingdirectory) 1457 ip->i_flag &= ~IN_RENAME; 1458 if (vn_lock(fvp, LK_EXCLUSIVE) == 0) { 1459 ip->i_effnlink--; 1460 ip->i_nlink--; 1461 DIP_SET(ip, i_nlink, ip->i_nlink); 1462 ip->i_flag |= IN_CHANGE; 1463 ip->i_flag &= ~IN_RENAME; 1464 if (DOINGSOFTDEP(fvp)) 1465 softdep_change_linkcnt(ip); 1466 vput(fvp); 1467 } else 1468 vrele(fvp); 1469 return (error); 1470 } 1471 1472 #ifdef UFS_ACL 1473 static int 1474 ufs_do_posix1e_acl_inheritance_dir(struct vnode *dvp, struct vnode *tvp, 1475 mode_t dmode, struct ucred *cred, struct thread *td) 1476 { 1477 int error; 1478 struct inode *ip = VTOI(tvp); 1479 struct acl *dacl, *acl; 1480 1481 acl = acl_alloc(M_WAITOK); 1482 dacl = acl_alloc(M_WAITOK); 1483 1484 /* 1485 * Retrieve default ACL from parent, if any. 1486 */ 1487 error = VOP_GETACL(dvp, ACL_TYPE_DEFAULT, acl, cred, td); 1488 switch (error) { 1489 case 0: 1490 /* 1491 * Retrieved a default ACL, so merge mode and ACL if 1492 * necessary. If the ACL is empty, fall through to 1493 * the "not defined or available" case. 1494 */ 1495 if (acl->acl_cnt != 0) { 1496 dmode = acl_posix1e_newfilemode(dmode, acl); 1497 ip->i_mode = dmode; 1498 DIP_SET(ip, i_mode, dmode); 1499 *dacl = *acl; 1500 ufs_sync_acl_from_inode(ip, acl); 1501 break; 1502 } 1503 /* FALLTHROUGH */ 1504 1505 case EOPNOTSUPP: 1506 /* 1507 * Just use the mode as-is. 1508 */ 1509 ip->i_mode = dmode; 1510 DIP_SET(ip, i_mode, dmode); 1511 error = 0; 1512 goto out; 1513 1514 default: 1515 goto out; 1516 } 1517 1518 /* 1519 * XXX: If we abort now, will Soft Updates notify the extattr 1520 * code that the EAs for the file need to be released? 1521 */ 1522 error = VOP_SETACL(tvp, ACL_TYPE_ACCESS, acl, cred, td); 1523 if (error == 0) 1524 error = VOP_SETACL(tvp, ACL_TYPE_DEFAULT, dacl, cred, td); 1525 switch (error) { 1526 case 0: 1527 break; 1528 1529 case EOPNOTSUPP: 1530 /* 1531 * XXX: This should not happen, as EOPNOTSUPP above 1532 * was supposed to free acl. 1533 */ 1534 printf("ufs_mkdir: VOP_GETACL() but no VOP_SETACL()\n"); 1535 /* 1536 panic("ufs_mkdir: VOP_GETACL() but no VOP_SETACL()"); 1537 */ 1538 break; 1539 1540 default: 1541 goto out; 1542 } 1543 1544 out: 1545 acl_free(acl); 1546 acl_free(dacl); 1547 1548 return (error); 1549 } 1550 1551 static int 1552 ufs_do_posix1e_acl_inheritance_file(struct vnode *dvp, struct vnode *tvp, 1553 mode_t mode, struct ucred *cred, struct thread *td) 1554 { 1555 int error; 1556 struct inode *ip = VTOI(tvp); 1557 struct acl *acl; 1558 1559 acl = acl_alloc(M_WAITOK); 1560 1561 /* 1562 * Retrieve default ACL for parent, if any. 1563 */ 1564 error = VOP_GETACL(dvp, ACL_TYPE_DEFAULT, acl, cred, td); 1565 switch (error) { 1566 case 0: 1567 /* 1568 * Retrieved a default ACL, so merge mode and ACL if 1569 * necessary. 1570 */ 1571 if (acl->acl_cnt != 0) { 1572 /* 1573 * Two possible ways for default ACL to not 1574 * be present. First, the EA can be 1575 * undefined, or second, the default ACL can 1576 * be blank. If it's blank, fall through to 1577 * the it's not defined case. 1578 */ 1579 mode = acl_posix1e_newfilemode(mode, acl); 1580 ip->i_mode = mode; 1581 DIP_SET(ip, i_mode, mode); 1582 ufs_sync_acl_from_inode(ip, acl); 1583 break; 1584 } 1585 /* FALLTHROUGH */ 1586 1587 case EOPNOTSUPP: 1588 /* 1589 * Just use the mode as-is. 1590 */ 1591 ip->i_mode = mode; 1592 DIP_SET(ip, i_mode, mode); 1593 error = 0; 1594 goto out; 1595 1596 default: 1597 goto out; 1598 } 1599 1600 /* 1601 * XXX: If we abort now, will Soft Updates notify the extattr 1602 * code that the EAs for the file need to be released? 1603 */ 1604 error = VOP_SETACL(tvp, ACL_TYPE_ACCESS, acl, cred, td); 1605 switch (error) { 1606 case 0: 1607 break; 1608 1609 case EOPNOTSUPP: 1610 /* 1611 * XXX: This should not happen, as EOPNOTSUPP above was 1612 * supposed to free acl. 1613 */ 1614 printf("ufs_makeinode: VOP_GETACL() but no " 1615 "VOP_SETACL()\n"); 1616 /* panic("ufs_makeinode: VOP_GETACL() but no " 1617 "VOP_SETACL()"); */ 1618 break; 1619 1620 default: 1621 goto out; 1622 } 1623 1624 out: 1625 acl_free(acl); 1626 1627 return (error); 1628 } 1629 1630 static int 1631 ufs_do_nfs4_acl_inheritance(struct vnode *dvp, struct vnode *tvp, 1632 mode_t child_mode, struct ucred *cred, struct thread *td) 1633 { 1634 int error; 1635 struct acl *parent_aclp, *child_aclp; 1636 1637 parent_aclp = acl_alloc(M_WAITOK); 1638 child_aclp = acl_alloc(M_WAITOK | M_ZERO); 1639 1640 error = ufs_getacl_nfs4_internal(dvp, parent_aclp, td); 1641 if (error) 1642 goto out; 1643 acl_nfs4_compute_inherited_acl(parent_aclp, child_aclp, 1644 child_mode, VTOI(tvp)->i_uid, tvp->v_type == VDIR); 1645 error = ufs_setacl_nfs4_internal(tvp, child_aclp, td); 1646 if (error) 1647 goto out; 1648 out: 1649 acl_free(parent_aclp); 1650 acl_free(child_aclp); 1651 1652 return (error); 1653 } 1654 #endif 1655 1656 /* 1657 * Mkdir system call 1658 */ 1659 static int 1660 ufs_mkdir(ap) 1661 struct vop_mkdir_args /* { 1662 struct vnode *a_dvp; 1663 struct vnode **a_vpp; 1664 struct componentname *a_cnp; 1665 struct vattr *a_vap; 1666 } */ *ap; 1667 { 1668 struct vnode *dvp = ap->a_dvp; 1669 struct vattr *vap = ap->a_vap; 1670 struct componentname *cnp = ap->a_cnp; 1671 struct inode *ip, *dp; 1672 struct vnode *tvp; 1673 struct buf *bp; 1674 struct dirtemplate dirtemplate, *dtp; 1675 struct direct newdir; 1676 int error, dmode; 1677 long blkoff; 1678 1679 #ifdef INVARIANTS 1680 if ((cnp->cn_flags & HASBUF) == 0) 1681 panic("ufs_mkdir: no name"); 1682 #endif 1683 dp = VTOI(dvp); 1684 if ((nlink_t)dp->i_nlink >= LINK_MAX) { 1685 error = EMLINK; 1686 goto out; 1687 } 1688 dmode = vap->va_mode & 0777; 1689 dmode |= IFDIR; 1690 /* 1691 * Must simulate part of ufs_makeinode here to acquire the inode, 1692 * but not have it entered in the parent directory. The entry is 1693 * made later after writing "." and ".." entries. 1694 */ 1695 error = UFS_VALLOC(dvp, dmode, cnp->cn_cred, &tvp); 1696 if (error) 1697 goto out; 1698 ip = VTOI(tvp); 1699 ip->i_gid = dp->i_gid; 1700 DIP_SET(ip, i_gid, dp->i_gid); 1701 #ifdef SUIDDIR 1702 { 1703 #ifdef QUOTA 1704 struct ucred ucred, *ucp; 1705 gid_t ucred_group; 1706 ucp = cnp->cn_cred; 1707 #endif 1708 /* 1709 * If we are hacking owners here, (only do this where told to) 1710 * and we are not giving it TO root, (would subvert quotas) 1711 * then go ahead and give it to the other user. 1712 * The new directory also inherits the SUID bit. 1713 * If user's UID and dir UID are the same, 1714 * 'give it away' so that the SUID is still forced on. 1715 */ 1716 if ((dvp->v_mount->mnt_flag & MNT_SUIDDIR) && 1717 (dp->i_mode & ISUID) && dp->i_uid) { 1718 dmode |= ISUID; 1719 ip->i_uid = dp->i_uid; 1720 DIP_SET(ip, i_uid, dp->i_uid); 1721 #ifdef QUOTA 1722 if (dp->i_uid != cnp->cn_cred->cr_uid) { 1723 /* 1724 * Make sure the correct user gets charged 1725 * for the space. 1726 * Make a dummy credential for the victim. 1727 * XXX This seems to never be accessed out of 1728 * our context so a stack variable is ok. 1729 */ 1730 refcount_init(&ucred.cr_ref, 1); 1731 ucred.cr_uid = ip->i_uid; 1732 ucred.cr_ngroups = 1; 1733 ucred.cr_groups = &ucred_group; 1734 ucred.cr_groups[0] = dp->i_gid; 1735 ucp = &ucred; 1736 } 1737 #endif 1738 } else { 1739 ip->i_uid = cnp->cn_cred->cr_uid; 1740 DIP_SET(ip, i_uid, ip->i_uid); 1741 } 1742 #ifdef QUOTA 1743 if ((error = getinoquota(ip)) || 1744 (error = chkiq(ip, 1, ucp, 0))) { 1745 UFS_VFREE(tvp, ip->i_number, dmode); 1746 vput(tvp); 1747 return (error); 1748 } 1749 #endif 1750 } 1751 #else /* !SUIDDIR */ 1752 ip->i_uid = cnp->cn_cred->cr_uid; 1753 DIP_SET(ip, i_uid, ip->i_uid); 1754 #ifdef QUOTA 1755 if ((error = getinoquota(ip)) || 1756 (error = chkiq(ip, 1, cnp->cn_cred, 0))) { 1757 UFS_VFREE(tvp, ip->i_number, dmode); 1758 vput(tvp); 1759 return (error); 1760 } 1761 #endif 1762 #endif /* !SUIDDIR */ 1763 ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE; 1764 ip->i_mode = dmode; 1765 DIP_SET(ip, i_mode, dmode); 1766 tvp->v_type = VDIR; /* Rest init'd in getnewvnode(). */ 1767 ip->i_effnlink = 2; 1768 ip->i_nlink = 2; 1769 DIP_SET(ip, i_nlink, 2); 1770 if (DOINGSOFTDEP(tvp)) 1771 softdep_change_linkcnt(ip); 1772 if (cnp->cn_flags & ISWHITEOUT) { 1773 ip->i_flags |= UF_OPAQUE; 1774 DIP_SET(ip, i_flags, ip->i_flags); 1775 } 1776 1777 /* 1778 * Bump link count in parent directory to reflect work done below. 1779 * Should be done before reference is created so cleanup is 1780 * possible if we crash. 1781 */ 1782 dp->i_effnlink++; 1783 dp->i_nlink++; 1784 DIP_SET(dp, i_nlink, dp->i_nlink); 1785 dp->i_flag |= IN_CHANGE; 1786 if (DOINGSOFTDEP(dvp)) 1787 softdep_change_linkcnt(dp); 1788 error = UFS_UPDATE(tvp, !(DOINGSOFTDEP(dvp) | DOINGASYNC(dvp))); 1789 if (error) 1790 goto bad; 1791 #ifdef MAC 1792 if (dvp->v_mount->mnt_flag & MNT_MULTILABEL) { 1793 error = mac_vnode_create_extattr(cnp->cn_cred, dvp->v_mount, 1794 dvp, tvp, cnp); 1795 if (error) 1796 goto bad; 1797 } 1798 #endif 1799 #ifdef UFS_ACL 1800 if (dvp->v_mount->mnt_flag & MNT_ACLS) { 1801 error = ufs_do_posix1e_acl_inheritance_dir(dvp, tvp, dmode, 1802 cnp->cn_cred, cnp->cn_thread); 1803 if (error) 1804 goto bad; 1805 } else if (dvp->v_mount->mnt_flag & MNT_NFS4ACLS) { 1806 error = ufs_do_nfs4_acl_inheritance(dvp, tvp, dmode, 1807 cnp->cn_cred, cnp->cn_thread); 1808 if (error) 1809 goto bad; 1810 } 1811 #endif /* !UFS_ACL */ 1812 1813 /* 1814 * Initialize directory with "." and ".." from static template. 1815 */ 1816 if (dvp->v_mount->mnt_maxsymlinklen > 0) 1817 dtp = &mastertemplate; 1818 else 1819 dtp = (struct dirtemplate *)&omastertemplate; 1820 dirtemplate = *dtp; 1821 dirtemplate.dot_ino = ip->i_number; 1822 dirtemplate.dotdot_ino = dp->i_number; 1823 if ((error = UFS_BALLOC(tvp, (off_t)0, DIRBLKSIZ, cnp->cn_cred, 1824 BA_CLRBUF, &bp)) != 0) 1825 goto bad; 1826 ip->i_size = DIRBLKSIZ; 1827 DIP_SET(ip, i_size, DIRBLKSIZ); 1828 ip->i_flag |= IN_CHANGE | IN_UPDATE; 1829 vnode_pager_setsize(tvp, (u_long)ip->i_size); 1830 bcopy((caddr_t)&dirtemplate, (caddr_t)bp->b_data, sizeof dirtemplate); 1831 if (DOINGSOFTDEP(tvp)) { 1832 /* 1833 * Ensure that the entire newly allocated block is a 1834 * valid directory so that future growth within the 1835 * block does not have to ensure that the block is 1836 * written before the inode. 1837 */ 1838 blkoff = DIRBLKSIZ; 1839 while (blkoff < bp->b_bcount) { 1840 ((struct direct *) 1841 (bp->b_data + blkoff))->d_reclen = DIRBLKSIZ; 1842 blkoff += DIRBLKSIZ; 1843 } 1844 } 1845 if ((error = UFS_UPDATE(tvp, !(DOINGSOFTDEP(tvp) | 1846 DOINGASYNC(tvp)))) != 0) { 1847 (void)bwrite(bp); 1848 goto bad; 1849 } 1850 /* 1851 * Directory set up, now install its entry in the parent directory. 1852 * 1853 * If we are not doing soft dependencies, then we must write out the 1854 * buffer containing the new directory body before entering the new 1855 * name in the parent. If we are doing soft dependencies, then the 1856 * buffer containing the new directory body will be passed to and 1857 * released in the soft dependency code after the code has attached 1858 * an appropriate ordering dependency to the buffer which ensures that 1859 * the buffer is written before the new name is written in the parent. 1860 */ 1861 if (DOINGASYNC(dvp)) 1862 bdwrite(bp); 1863 else if (!DOINGSOFTDEP(dvp) && ((error = bwrite(bp)))) 1864 goto bad; 1865 ufs_makedirentry(ip, cnp, &newdir); 1866 error = ufs_direnter(dvp, tvp, &newdir, cnp, bp); 1867 1868 bad: 1869 if (error == 0) { 1870 *ap->a_vpp = tvp; 1871 } else { 1872 dp->i_effnlink--; 1873 dp->i_nlink--; 1874 DIP_SET(dp, i_nlink, dp->i_nlink); 1875 dp->i_flag |= IN_CHANGE; 1876 if (DOINGSOFTDEP(dvp)) 1877 softdep_change_linkcnt(dp); 1878 /* 1879 * No need to do an explicit VOP_TRUNCATE here, vrele will 1880 * do this for us because we set the link count to 0. 1881 */ 1882 ip->i_effnlink = 0; 1883 ip->i_nlink = 0; 1884 DIP_SET(ip, i_nlink, 0); 1885 ip->i_flag |= IN_CHANGE; 1886 if (DOINGSOFTDEP(tvp)) 1887 softdep_change_linkcnt(ip); 1888 vput(tvp); 1889 } 1890 out: 1891 return (error); 1892 } 1893 1894 /* 1895 * Rmdir system call. 1896 */ 1897 static int 1898 ufs_rmdir(ap) 1899 struct vop_rmdir_args /* { 1900 struct vnode *a_dvp; 1901 struct vnode *a_vp; 1902 struct componentname *a_cnp; 1903 } */ *ap; 1904 { 1905 struct vnode *vp = ap->a_vp; 1906 struct vnode *dvp = ap->a_dvp; 1907 struct componentname *cnp = ap->a_cnp; 1908 struct inode *ip, *dp; 1909 int error, ioflag; 1910 1911 ip = VTOI(vp); 1912 dp = VTOI(dvp); 1913 1914 /* 1915 * Do not remove a directory that is in the process of being renamed. 1916 * Verify the directory is empty (and valid). Rmdir ".." will not be 1917 * valid since ".." will contain a reference to the current directory 1918 * and thus be non-empty. Do not allow the removal of mounted on 1919 * directories (this can happen when an NFS exported filesystem 1920 * tries to remove a locally mounted on directory). 1921 */ 1922 error = 0; 1923 if ((ip->i_flag & IN_RENAME) || ip->i_effnlink < 2) { 1924 error = EINVAL; 1925 goto out; 1926 } 1927 if (!ufs_dirempty(ip, dp->i_number, cnp->cn_cred)) { 1928 error = ENOTEMPTY; 1929 goto out; 1930 } 1931 if ((dp->i_flags & APPEND) 1932 || (ip->i_flags & (NOUNLINK | IMMUTABLE | APPEND))) { 1933 error = EPERM; 1934 goto out; 1935 } 1936 if (vp->v_mountedhere != 0) { 1937 error = EINVAL; 1938 goto out; 1939 } 1940 #ifdef UFS_GJOURNAL 1941 ufs_gjournal_orphan(vp); 1942 #endif 1943 /* 1944 * Delete reference to directory before purging 1945 * inode. If we crash in between, the directory 1946 * will be reattached to lost+found, 1947 */ 1948 dp->i_effnlink--; 1949 ip->i_effnlink--; 1950 if (DOINGSOFTDEP(vp)) { 1951 softdep_change_linkcnt(dp); 1952 softdep_change_linkcnt(ip); 1953 } 1954 error = ufs_dirremove(dvp, ip, cnp->cn_flags, 1); 1955 if (error) { 1956 dp->i_effnlink++; 1957 ip->i_effnlink++; 1958 if (DOINGSOFTDEP(vp)) { 1959 softdep_change_linkcnt(dp); 1960 softdep_change_linkcnt(ip); 1961 } 1962 goto out; 1963 } 1964 cache_purge(dvp); 1965 /* 1966 * Truncate inode. The only stuff left in the directory is "." and 1967 * "..". The "." reference is inconsequential since we are quashing 1968 * it. The soft dependency code will arrange to do these operations 1969 * after the parent directory entry has been deleted on disk, so 1970 * when running with that code we avoid doing them now. 1971 */ 1972 if (!DOINGSOFTDEP(vp)) { 1973 dp->i_nlink--; 1974 DIP_SET(dp, i_nlink, dp->i_nlink); 1975 dp->i_flag |= IN_CHANGE; 1976 ip->i_nlink--; 1977 DIP_SET(ip, i_nlink, ip->i_nlink); 1978 ip->i_flag |= IN_CHANGE; 1979 ioflag = IO_NORMAL; 1980 if (!DOINGASYNC(vp)) 1981 ioflag |= IO_SYNC; 1982 error = UFS_TRUNCATE(vp, (off_t)0, ioflag, cnp->cn_cred, 1983 cnp->cn_thread); 1984 } 1985 cache_purge(vp); 1986 #ifdef UFS_DIRHASH 1987 /* Kill any active hash; i_effnlink == 0, so it will not come back. */ 1988 if (ip->i_dirhash != NULL) 1989 ufsdirhash_free(ip); 1990 #endif 1991 out: 1992 return (error); 1993 } 1994 1995 /* 1996 * symlink -- make a symbolic link 1997 */ 1998 static int 1999 ufs_symlink(ap) 2000 struct vop_symlink_args /* { 2001 struct vnode *a_dvp; 2002 struct vnode **a_vpp; 2003 struct componentname *a_cnp; 2004 struct vattr *a_vap; 2005 char *a_target; 2006 } */ *ap; 2007 { 2008 struct vnode *vp, **vpp = ap->a_vpp; 2009 struct inode *ip; 2010 int len, error; 2011 2012 error = ufs_makeinode(IFLNK | ap->a_vap->va_mode, ap->a_dvp, 2013 vpp, ap->a_cnp); 2014 if (error) 2015 return (error); 2016 vp = *vpp; 2017 len = strlen(ap->a_target); 2018 if (len < vp->v_mount->mnt_maxsymlinklen) { 2019 ip = VTOI(vp); 2020 bcopy(ap->a_target, SHORTLINK(ip), len); 2021 ip->i_size = len; 2022 DIP_SET(ip, i_size, len); 2023 ip->i_flag |= IN_CHANGE | IN_UPDATE; 2024 } else 2025 error = vn_rdwr(UIO_WRITE, vp, ap->a_target, len, (off_t)0, 2026 UIO_SYSSPACE, IO_NODELOCKED | IO_NOMACCHECK, 2027 ap->a_cnp->cn_cred, NOCRED, NULL, NULL); 2028 if (error) 2029 vput(vp); 2030 return (error); 2031 } 2032 2033 /* 2034 * Vnode op for reading directories. 2035 * 2036 * The routine below assumes that the on-disk format of a directory 2037 * is the same as that defined by <sys/dirent.h>. If the on-disk 2038 * format changes, then it will be necessary to do a conversion 2039 * from the on-disk format that read returns to the format defined 2040 * by <sys/dirent.h>. 2041 */ 2042 int 2043 ufs_readdir(ap) 2044 struct vop_readdir_args /* { 2045 struct vnode *a_vp; 2046 struct uio *a_uio; 2047 struct ucred *a_cred; 2048 int *a_eofflag; 2049 int *a_ncookies; 2050 u_long **a_cookies; 2051 } */ *ap; 2052 { 2053 struct uio *uio = ap->a_uio; 2054 int error; 2055 size_t count, lost; 2056 off_t off; 2057 2058 if (ap->a_ncookies != NULL) 2059 /* 2060 * Ensure that the block is aligned. The caller can use 2061 * the cookies to determine where in the block to start. 2062 */ 2063 uio->uio_offset &= ~(DIRBLKSIZ - 1); 2064 off = uio->uio_offset; 2065 count = uio->uio_resid; 2066 /* Make sure we don't return partial entries. */ 2067 if (count <= ((uio->uio_offset + count) & (DIRBLKSIZ -1))) 2068 return (EINVAL); 2069 count -= (uio->uio_offset + count) & (DIRBLKSIZ -1); 2070 lost = uio->uio_resid - count; 2071 uio->uio_resid = count; 2072 uio->uio_iov->iov_len = count; 2073 # if (BYTE_ORDER == LITTLE_ENDIAN) 2074 if (ap->a_vp->v_mount->mnt_maxsymlinklen > 0) { 2075 error = VOP_READ(ap->a_vp, uio, 0, ap->a_cred); 2076 } else { 2077 struct dirent *dp, *edp; 2078 struct uio auio; 2079 struct iovec aiov; 2080 caddr_t dirbuf; 2081 int readcnt; 2082 u_char tmp; 2083 2084 auio = *uio; 2085 auio.uio_iov = &aiov; 2086 auio.uio_iovcnt = 1; 2087 auio.uio_segflg = UIO_SYSSPACE; 2088 aiov.iov_len = count; 2089 dirbuf = malloc(count, M_TEMP, M_WAITOK); 2090 aiov.iov_base = dirbuf; 2091 error = VOP_READ(ap->a_vp, &auio, 0, ap->a_cred); 2092 if (error == 0) { 2093 readcnt = count - auio.uio_resid; 2094 edp = (struct dirent *)&dirbuf[readcnt]; 2095 for (dp = (struct dirent *)dirbuf; dp < edp; ) { 2096 tmp = dp->d_namlen; 2097 dp->d_namlen = dp->d_type; 2098 dp->d_type = tmp; 2099 if (dp->d_reclen > 0) { 2100 dp = (struct dirent *) 2101 ((char *)dp + dp->d_reclen); 2102 } else { 2103 error = EIO; 2104 break; 2105 } 2106 } 2107 if (dp >= edp) 2108 error = uiomove(dirbuf, readcnt, uio); 2109 } 2110 free(dirbuf, M_TEMP); 2111 } 2112 # else 2113 error = VOP_READ(ap->a_vp, uio, 0, ap->a_cred); 2114 # endif 2115 if (!error && ap->a_ncookies != NULL) { 2116 struct dirent* dpStart; 2117 struct dirent* dpEnd; 2118 struct dirent* dp; 2119 int ncookies; 2120 u_long *cookies; 2121 u_long *cookiep; 2122 2123 if (uio->uio_segflg != UIO_SYSSPACE || uio->uio_iovcnt != 1) 2124 panic("ufs_readdir: unexpected uio from NFS server"); 2125 dpStart = (struct dirent *) 2126 ((char *)uio->uio_iov->iov_base - (uio->uio_offset - off)); 2127 dpEnd = (struct dirent *) uio->uio_iov->iov_base; 2128 for (dp = dpStart, ncookies = 0; 2129 dp < dpEnd; 2130 dp = (struct dirent *)((caddr_t) dp + dp->d_reclen)) 2131 ncookies++; 2132 cookies = malloc(ncookies * sizeof(u_long), M_TEMP, 2133 M_WAITOK); 2134 for (dp = dpStart, cookiep = cookies; 2135 dp < dpEnd; 2136 dp = (struct dirent *)((caddr_t) dp + dp->d_reclen)) { 2137 off += dp->d_reclen; 2138 *cookiep++ = (u_long) off; 2139 } 2140 *ap->a_ncookies = ncookies; 2141 *ap->a_cookies = cookies; 2142 } 2143 uio->uio_resid += lost; 2144 if (ap->a_eofflag) 2145 *ap->a_eofflag = VTOI(ap->a_vp)->i_size <= uio->uio_offset; 2146 return (error); 2147 } 2148 2149 /* 2150 * Return target name of a symbolic link 2151 */ 2152 static int 2153 ufs_readlink(ap) 2154 struct vop_readlink_args /* { 2155 struct vnode *a_vp; 2156 struct uio *a_uio; 2157 struct ucred *a_cred; 2158 } */ *ap; 2159 { 2160 struct vnode *vp = ap->a_vp; 2161 struct inode *ip = VTOI(vp); 2162 doff_t isize; 2163 2164 isize = ip->i_size; 2165 if ((isize < vp->v_mount->mnt_maxsymlinklen) || 2166 DIP(ip, i_blocks) == 0) { /* XXX - for old fastlink support */ 2167 return (uiomove(SHORTLINK(ip), isize, ap->a_uio)); 2168 } 2169 return (VOP_READ(vp, ap->a_uio, 0, ap->a_cred)); 2170 } 2171 2172 /* 2173 * Calculate the logical to physical mapping if not done already, 2174 * then call the device strategy routine. 2175 * 2176 * In order to be able to swap to a file, the ufs_bmaparray() operation may not 2177 * deadlock on memory. See ufs_bmap() for details. 2178 */ 2179 static int 2180 ufs_strategy(ap) 2181 struct vop_strategy_args /* { 2182 struct vnode *a_vp; 2183 struct buf *a_bp; 2184 } */ *ap; 2185 { 2186 struct buf *bp = ap->a_bp; 2187 struct vnode *vp = ap->a_vp; 2188 struct bufobj *bo; 2189 struct inode *ip; 2190 ufs2_daddr_t blkno; 2191 int error; 2192 2193 ip = VTOI(vp); 2194 if (bp->b_blkno == bp->b_lblkno) { 2195 error = ufs_bmaparray(vp, bp->b_lblkno, &blkno, bp, NULL, NULL); 2196 bp->b_blkno = blkno; 2197 if (error) { 2198 bp->b_error = error; 2199 bp->b_ioflags |= BIO_ERROR; 2200 bufdone(bp); 2201 return (0); 2202 } 2203 if ((long)bp->b_blkno == -1) 2204 vfs_bio_clrbuf(bp); 2205 } 2206 if ((long)bp->b_blkno == -1) { 2207 bufdone(bp); 2208 return (0); 2209 } 2210 bp->b_iooffset = dbtob(bp->b_blkno); 2211 bo = ip->i_umbufobj; 2212 BO_STRATEGY(bo, bp); 2213 return (0); 2214 } 2215 2216 /* 2217 * Print out the contents of an inode. 2218 */ 2219 static int 2220 ufs_print(ap) 2221 struct vop_print_args /* { 2222 struct vnode *a_vp; 2223 } */ *ap; 2224 { 2225 struct vnode *vp = ap->a_vp; 2226 struct inode *ip = VTOI(vp); 2227 2228 printf("\tino %lu, on dev %s", (u_long)ip->i_number, 2229 devtoname(ip->i_dev)); 2230 if (vp->v_type == VFIFO) 2231 fifo_printinfo(vp); 2232 printf("\n"); 2233 return (0); 2234 } 2235 2236 /* 2237 * Close wrapper for fifos. 2238 * 2239 * Update the times on the inode then do device close. 2240 */ 2241 static int 2242 ufsfifo_close(ap) 2243 struct vop_close_args /* { 2244 struct vnode *a_vp; 2245 int a_fflag; 2246 struct ucred *a_cred; 2247 struct thread *a_td; 2248 } */ *ap; 2249 { 2250 struct vnode *vp = ap->a_vp; 2251 int usecount; 2252 2253 VI_LOCK(vp); 2254 usecount = vp->v_usecount; 2255 if (usecount > 1) 2256 ufs_itimes_locked(vp); 2257 VI_UNLOCK(vp); 2258 return (fifo_specops.vop_close(ap)); 2259 } 2260 2261 /* 2262 * Kqfilter wrapper for fifos. 2263 * 2264 * Fall through to ufs kqfilter routines if needed 2265 */ 2266 static int 2267 ufsfifo_kqfilter(ap) 2268 struct vop_kqfilter_args *ap; 2269 { 2270 int error; 2271 2272 error = fifo_specops.vop_kqfilter(ap); 2273 if (error) 2274 error = vfs_kqfilter(ap); 2275 return (error); 2276 } 2277 2278 /* 2279 * Return POSIX pathconf information applicable to fifos. 2280 */ 2281 static int 2282 ufsfifo_pathconf(ap) 2283 struct vop_pathconf_args /* { 2284 struct vnode *a_vp; 2285 int a_name; 2286 int *a_retval; 2287 } */ *ap; 2288 { 2289 2290 switch (ap->a_name) { 2291 case _PC_ACL_EXTENDED: 2292 case _PC_ACL_NFS4: 2293 case _PC_ACL_PATH_MAX: 2294 case _PC_MAC_PRESENT: 2295 return (ufs_pathconf(ap)); 2296 default: 2297 return (fifo_specops.vop_pathconf(ap)); 2298 } 2299 /* NOTREACHED */ 2300 } 2301 2302 /* 2303 * Return POSIX pathconf information applicable to ufs filesystems. 2304 */ 2305 static int 2306 ufs_pathconf(ap) 2307 struct vop_pathconf_args /* { 2308 struct vnode *a_vp; 2309 int a_name; 2310 int *a_retval; 2311 } */ *ap; 2312 { 2313 int error; 2314 2315 error = 0; 2316 switch (ap->a_name) { 2317 case _PC_LINK_MAX: 2318 *ap->a_retval = LINK_MAX; 2319 break; 2320 case _PC_NAME_MAX: 2321 *ap->a_retval = NAME_MAX; 2322 break; 2323 case _PC_PATH_MAX: 2324 *ap->a_retval = PATH_MAX; 2325 break; 2326 case _PC_PIPE_BUF: 2327 *ap->a_retval = PIPE_BUF; 2328 break; 2329 case _PC_CHOWN_RESTRICTED: 2330 *ap->a_retval = 1; 2331 break; 2332 case _PC_NO_TRUNC: 2333 *ap->a_retval = 1; 2334 break; 2335 case _PC_ACL_EXTENDED: 2336 #ifdef UFS_ACL 2337 if (ap->a_vp->v_mount->mnt_flag & MNT_ACLS) 2338 *ap->a_retval = 1; 2339 else 2340 *ap->a_retval = 0; 2341 #else 2342 *ap->a_retval = 0; 2343 #endif 2344 break; 2345 2346 case _PC_ACL_NFS4: 2347 #ifdef UFS_ACL 2348 if (ap->a_vp->v_mount->mnt_flag & MNT_NFS4ACLS) 2349 *ap->a_retval = 1; 2350 else 2351 *ap->a_retval = 0; 2352 #else 2353 *ap->a_retval = 0; 2354 #endif 2355 break; 2356 2357 case _PC_ACL_PATH_MAX: 2358 #ifdef UFS_ACL 2359 if (ap->a_vp->v_mount->mnt_flag & (MNT_ACLS | MNT_NFS4ACLS)) 2360 *ap->a_retval = ACL_MAX_ENTRIES; 2361 else 2362 *ap->a_retval = 3; 2363 #else 2364 *ap->a_retval = 3; 2365 #endif 2366 break; 2367 case _PC_MAC_PRESENT: 2368 #ifdef MAC 2369 if (ap->a_vp->v_mount->mnt_flag & MNT_MULTILABEL) 2370 *ap->a_retval = 1; 2371 else 2372 *ap->a_retval = 0; 2373 #else 2374 *ap->a_retval = 0; 2375 #endif 2376 break; 2377 case _PC_ASYNC_IO: 2378 /* _PC_ASYNC_IO should have been handled by upper layers. */ 2379 KASSERT(0, ("_PC_ASYNC_IO should not get here")); 2380 error = EINVAL; 2381 break; 2382 case _PC_PRIO_IO: 2383 *ap->a_retval = 0; 2384 break; 2385 case _PC_SYNC_IO: 2386 *ap->a_retval = 0; 2387 break; 2388 case _PC_ALLOC_SIZE_MIN: 2389 *ap->a_retval = ap->a_vp->v_mount->mnt_stat.f_bsize; 2390 break; 2391 case _PC_FILESIZEBITS: 2392 *ap->a_retval = 64; 2393 break; 2394 case _PC_REC_INCR_XFER_SIZE: 2395 *ap->a_retval = ap->a_vp->v_mount->mnt_stat.f_iosize; 2396 break; 2397 case _PC_REC_MAX_XFER_SIZE: 2398 *ap->a_retval = -1; /* means ``unlimited'' */ 2399 break; 2400 case _PC_REC_MIN_XFER_SIZE: 2401 *ap->a_retval = ap->a_vp->v_mount->mnt_stat.f_iosize; 2402 break; 2403 case _PC_REC_XFER_ALIGN: 2404 *ap->a_retval = PAGE_SIZE; 2405 break; 2406 case _PC_SYMLINK_MAX: 2407 *ap->a_retval = MAXPATHLEN; 2408 break; 2409 2410 default: 2411 error = EINVAL; 2412 break; 2413 } 2414 return (error); 2415 } 2416 2417 /* 2418 * Initialize the vnode associated with a new inode, handle aliased 2419 * vnodes. 2420 */ 2421 int 2422 ufs_vinit(mntp, fifoops, vpp) 2423 struct mount *mntp; 2424 struct vop_vector *fifoops; 2425 struct vnode **vpp; 2426 { 2427 struct inode *ip; 2428 struct vnode *vp; 2429 2430 vp = *vpp; 2431 ip = VTOI(vp); 2432 vp->v_type = IFTOVT(ip->i_mode); 2433 if (vp->v_type == VFIFO) 2434 vp->v_op = fifoops; 2435 ASSERT_VOP_LOCKED(vp, "ufs_vinit"); 2436 if (ip->i_number == ROOTINO) 2437 vp->v_vflag |= VV_ROOT; 2438 *vpp = vp; 2439 return (0); 2440 } 2441 2442 /* 2443 * Allocate a new inode. 2444 * Vnode dvp must be locked. 2445 */ 2446 static int 2447 ufs_makeinode(mode, dvp, vpp, cnp) 2448 int mode; 2449 struct vnode *dvp; 2450 struct vnode **vpp; 2451 struct componentname *cnp; 2452 { 2453 struct inode *ip, *pdir; 2454 struct direct newdir; 2455 struct vnode *tvp; 2456 int error; 2457 2458 pdir = VTOI(dvp); 2459 #ifdef INVARIANTS 2460 if ((cnp->cn_flags & HASBUF) == 0) 2461 panic("ufs_makeinode: no name"); 2462 #endif 2463 *vpp = NULL; 2464 if ((mode & IFMT) == 0) 2465 mode |= IFREG; 2466 2467 error = UFS_VALLOC(dvp, mode, cnp->cn_cred, &tvp); 2468 if (error) 2469 return (error); 2470 ip = VTOI(tvp); 2471 ip->i_gid = pdir->i_gid; 2472 DIP_SET(ip, i_gid, pdir->i_gid); 2473 #ifdef SUIDDIR 2474 { 2475 #ifdef QUOTA 2476 struct ucred ucred, *ucp; 2477 gid_t ucred_group; 2478 ucp = cnp->cn_cred; 2479 #endif 2480 /* 2481 * If we are not the owner of the directory, 2482 * and we are hacking owners here, (only do this where told to) 2483 * and we are not giving it TO root, (would subvert quotas) 2484 * then go ahead and give it to the other user. 2485 * Note that this drops off the execute bits for security. 2486 */ 2487 if ((dvp->v_mount->mnt_flag & MNT_SUIDDIR) && 2488 (pdir->i_mode & ISUID) && 2489 (pdir->i_uid != cnp->cn_cred->cr_uid) && pdir->i_uid) { 2490 ip->i_uid = pdir->i_uid; 2491 DIP_SET(ip, i_uid, ip->i_uid); 2492 mode &= ~07111; 2493 #ifdef QUOTA 2494 /* 2495 * Make sure the correct user gets charged 2496 * for the space. 2497 * Quickly knock up a dummy credential for the victim. 2498 * XXX This seems to never be accessed out of our 2499 * context so a stack variable is ok. 2500 */ 2501 refcount_init(&ucred.cr_ref, 1); 2502 ucred.cr_uid = ip->i_uid; 2503 ucred.cr_ngroups = 1; 2504 ucred.cr_groups = &ucred_group; 2505 ucred.cr_groups[0] = pdir->i_gid; 2506 ucp = &ucred; 2507 #endif 2508 } else { 2509 ip->i_uid = cnp->cn_cred->cr_uid; 2510 DIP_SET(ip, i_uid, ip->i_uid); 2511 } 2512 2513 #ifdef QUOTA 2514 if ((error = getinoquota(ip)) || 2515 (error = chkiq(ip, 1, ucp, 0))) { 2516 UFS_VFREE(tvp, ip->i_number, mode); 2517 vput(tvp); 2518 return (error); 2519 } 2520 #endif 2521 } 2522 #else /* !SUIDDIR */ 2523 ip->i_uid = cnp->cn_cred->cr_uid; 2524 DIP_SET(ip, i_uid, ip->i_uid); 2525 #ifdef QUOTA 2526 if ((error = getinoquota(ip)) || 2527 (error = chkiq(ip, 1, cnp->cn_cred, 0))) { 2528 UFS_VFREE(tvp, ip->i_number, mode); 2529 vput(tvp); 2530 return (error); 2531 } 2532 #endif 2533 #endif /* !SUIDDIR */ 2534 ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE; 2535 ip->i_mode = mode; 2536 DIP_SET(ip, i_mode, mode); 2537 tvp->v_type = IFTOVT(mode); /* Rest init'd in getnewvnode(). */ 2538 ip->i_effnlink = 1; 2539 ip->i_nlink = 1; 2540 DIP_SET(ip, i_nlink, 1); 2541 if (DOINGSOFTDEP(tvp)) 2542 softdep_change_linkcnt(ip); 2543 if ((ip->i_mode & ISGID) && !groupmember(ip->i_gid, cnp->cn_cred) && 2544 priv_check_cred(cnp->cn_cred, PRIV_VFS_SETGID, 0)) { 2545 ip->i_mode &= ~ISGID; 2546 DIP_SET(ip, i_mode, ip->i_mode); 2547 } 2548 2549 if (cnp->cn_flags & ISWHITEOUT) { 2550 ip->i_flags |= UF_OPAQUE; 2551 DIP_SET(ip, i_flags, ip->i_flags); 2552 } 2553 2554 /* 2555 * Make sure inode goes to disk before directory entry. 2556 */ 2557 error = UFS_UPDATE(tvp, !(DOINGSOFTDEP(tvp) | DOINGASYNC(tvp))); 2558 if (error) 2559 goto bad; 2560 #ifdef MAC 2561 if (dvp->v_mount->mnt_flag & MNT_MULTILABEL) { 2562 error = mac_vnode_create_extattr(cnp->cn_cred, dvp->v_mount, 2563 dvp, tvp, cnp); 2564 if (error) 2565 goto bad; 2566 } 2567 #endif 2568 #ifdef UFS_ACL 2569 if (dvp->v_mount->mnt_flag & MNT_ACLS) { 2570 error = ufs_do_posix1e_acl_inheritance_file(dvp, tvp, mode, 2571 cnp->cn_cred, cnp->cn_thread); 2572 if (error) 2573 goto bad; 2574 } else if (dvp->v_mount->mnt_flag & MNT_NFS4ACLS) { 2575 error = ufs_do_nfs4_acl_inheritance(dvp, tvp, mode, 2576 cnp->cn_cred, cnp->cn_thread); 2577 if (error) 2578 goto bad; 2579 } 2580 #endif /* !UFS_ACL */ 2581 ufs_makedirentry(ip, cnp, &newdir); 2582 error = ufs_direnter(dvp, tvp, &newdir, cnp, NULL); 2583 if (error) 2584 goto bad; 2585 *vpp = tvp; 2586 return (0); 2587 2588 bad: 2589 /* 2590 * Write error occurred trying to update the inode 2591 * or the directory so must deallocate the inode. 2592 */ 2593 ip->i_effnlink = 0; 2594 ip->i_nlink = 0; 2595 DIP_SET(ip, i_nlink, 0); 2596 ip->i_flag |= IN_CHANGE; 2597 if (DOINGSOFTDEP(tvp)) 2598 softdep_change_linkcnt(ip); 2599 vput(tvp); 2600 return (error); 2601 } 2602 2603 /* Global vfs data structures for ufs. */ 2604 struct vop_vector ufs_vnodeops = { 2605 .vop_default = &default_vnodeops, 2606 .vop_fsync = VOP_PANIC, 2607 .vop_read = VOP_PANIC, 2608 .vop_reallocblks = VOP_PANIC, 2609 .vop_write = VOP_PANIC, 2610 .vop_accessx = ufs_accessx, 2611 .vop_bmap = ufs_bmap, 2612 .vop_cachedlookup = ufs_lookup, 2613 .vop_close = ufs_close, 2614 .vop_create = ufs_create, 2615 .vop_getattr = ufs_getattr, 2616 .vop_inactive = ufs_inactive, 2617 .vop_link = ufs_link, 2618 .vop_lookup = vfs_cache_lookup, 2619 .vop_markatime = ufs_markatime, 2620 .vop_mkdir = ufs_mkdir, 2621 .vop_mknod = ufs_mknod, 2622 .vop_open = ufs_open, 2623 .vop_pathconf = ufs_pathconf, 2624 .vop_poll = vop_stdpoll, 2625 .vop_print = ufs_print, 2626 .vop_readdir = ufs_readdir, 2627 .vop_readlink = ufs_readlink, 2628 .vop_reclaim = ufs_reclaim, 2629 .vop_remove = ufs_remove, 2630 .vop_rename = ufs_rename, 2631 .vop_rmdir = ufs_rmdir, 2632 .vop_setattr = ufs_setattr, 2633 #ifdef MAC 2634 .vop_setlabel = vop_stdsetlabel_ea, 2635 #endif 2636 .vop_strategy = ufs_strategy, 2637 .vop_symlink = ufs_symlink, 2638 .vop_whiteout = ufs_whiteout, 2639 #ifdef UFS_EXTATTR 2640 .vop_getextattr = ufs_getextattr, 2641 .vop_deleteextattr = ufs_deleteextattr, 2642 .vop_setextattr = ufs_setextattr, 2643 #endif 2644 #ifdef UFS_ACL 2645 .vop_getacl = ufs_getacl, 2646 .vop_setacl = ufs_setacl, 2647 .vop_aclcheck = ufs_aclcheck, 2648 #endif 2649 }; 2650 2651 struct vop_vector ufs_fifoops = { 2652 .vop_default = &fifo_specops, 2653 .vop_fsync = VOP_PANIC, 2654 .vop_accessx = ufs_accessx, 2655 .vop_close = ufsfifo_close, 2656 .vop_getattr = ufs_getattr, 2657 .vop_inactive = ufs_inactive, 2658 .vop_kqfilter = ufsfifo_kqfilter, 2659 .vop_markatime = ufs_markatime, 2660 .vop_pathconf = ufsfifo_pathconf, 2661 .vop_print = ufs_print, 2662 .vop_read = VOP_PANIC, 2663 .vop_reclaim = ufs_reclaim, 2664 .vop_setattr = ufs_setattr, 2665 #ifdef MAC 2666 .vop_setlabel = vop_stdsetlabel_ea, 2667 #endif 2668 .vop_write = VOP_PANIC, 2669 #ifdef UFS_EXTATTR 2670 .vop_getextattr = ufs_getextattr, 2671 .vop_deleteextattr = ufs_deleteextattr, 2672 .vop_setextattr = ufs_setextattr, 2673 #endif 2674 #ifdef UFS_ACL 2675 .vop_getacl = ufs_getacl, 2676 .vop_setacl = ufs_setacl, 2677 .vop_aclcheck = ufs_aclcheck, 2678 #endif 2679 };
Cache object: 3e8ab9ba343e134e862039232d82fee9
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]