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