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 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the University of 21 * California, Berkeley and its contributors. 22 * 4. Neither the name of the University nor the names of its contributors 23 * may be used to endorse or promote products derived from this software 24 * without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 36 * SUCH DAMAGE. 37 * 38 * @(#)ufs_vnops.c 8.27 (Berkeley) 5/27/95 39 * $FreeBSD: src/sys/ufs/ufs/ufs_vnops.c,v 1.131.2.8 2003/01/02 17:26:19 bde Exp $ 40 * $DragonFly: src/sys/vfs/ufs/ufs_vnops.c,v 1.20 2004/08/28 19:02:30 dillon Exp $ 41 */ 42 43 #include "opt_quota.h" 44 #include "opt_suiddir.h" 45 #include "opt_ufs.h" 46 47 #include <sys/param.h> 48 #include <sys/systm.h> 49 #include <sys/kernel.h> 50 #include <sys/fcntl.h> 51 #include <sys/stat.h> 52 #include <sys/buf.h> 53 #include <sys/proc.h> 54 #include <sys/namei.h> 55 #include <sys/mount.h> 56 #include <sys/unistd.h> 57 #include <sys/vnode.h> 58 #include <sys/malloc.h> 59 #include <sys/dirent.h> 60 #include <sys/lockf.h> 61 #include <sys/event.h> 62 #include <sys/conf.h> 63 64 #include <sys/file.h> /* XXX */ 65 66 #include <vm/vm.h> 67 #include <vm/vm_extern.h> 68 69 #include <vfs/fifofs/fifo.h> 70 71 #include "quota.h" 72 #include "inode.h" 73 #include "dir.h" 74 #include "ufsmount.h" 75 #include "ufs_extern.h" 76 #ifdef UFS_DIRHASH 77 #include "dirhash.h" 78 #endif 79 80 static int ufs_access (struct vop_access_args *); 81 static int ufs_advlock (struct vop_advlock_args *); 82 static int ufs_chmod (struct vnode *, int, struct ucred *, struct thread *); 83 static int ufs_chown (struct vnode *, uid_t, gid_t, struct ucred *, struct thread *); 84 static int ufs_close (struct vop_close_args *); 85 static int ufs_create (struct vop_create_args *); 86 static int ufs_getattr (struct vop_getattr_args *); 87 static int ufs_link (struct vop_link_args *); 88 static int ufs_makeinode (int mode, struct vnode *, struct vnode **, struct componentname *); 89 static int ufs_missingop (struct vop_generic_args *ap); 90 static int ufs_mkdir (struct vop_mkdir_args *); 91 static int ufs_mknod (struct vop_mknod_args *); 92 static int ufs_mmap (struct vop_mmap_args *); 93 static int ufs_open (struct vop_open_args *); 94 static int ufs_pathconf (struct vop_pathconf_args *); 95 static int ufs_print (struct vop_print_args *); 96 static int ufs_readdir (struct vop_readdir_args *); 97 static int ufs_readlink (struct vop_readlink_args *); 98 static int ufs_remove (struct vop_remove_args *); 99 static int ufs_rename (struct vop_rename_args *); 100 static int ufs_rmdir (struct vop_rmdir_args *); 101 static int ufs_setattr (struct vop_setattr_args *); 102 static int ufs_strategy (struct vop_strategy_args *); 103 static int ufs_symlink (struct vop_symlink_args *); 104 static int ufs_whiteout (struct vop_whiteout_args *); 105 static int ufsfifo_close (struct vop_close_args *); 106 static int ufsfifo_kqfilter (struct vop_kqfilter_args *); 107 static int ufsfifo_read (struct vop_read_args *); 108 static int ufsfifo_write (struct vop_write_args *); 109 static int ufsspec_close (struct vop_close_args *); 110 static int ufsspec_read (struct vop_read_args *); 111 static int ufsspec_write (struct vop_write_args *); 112 static int filt_ufsread (struct knote *kn, long hint); 113 static int filt_ufswrite (struct knote *kn, long hint); 114 static int filt_ufsvnode (struct knote *kn, long hint); 115 static void filt_ufsdetach (struct knote *kn); 116 static int ufs_kqfilter (struct vop_kqfilter_args *ap); 117 118 union _qcvt { 119 int64_t qcvt; 120 int32_t val[2]; 121 }; 122 #define SETHIGH(q, h) { \ 123 union _qcvt tmp; \ 124 tmp.qcvt = (q); \ 125 tmp.val[_QUAD_HIGHWORD] = (h); \ 126 (q) = tmp.qcvt; \ 127 } 128 #define SETLOW(q, l) { \ 129 union _qcvt tmp; \ 130 tmp.qcvt = (q); \ 131 tmp.val[_QUAD_LOWWORD] = (l); \ 132 (q) = tmp.qcvt; \ 133 } 134 #define VN_KNOTE(vp, b) \ 135 KNOTE(&vp->v_pollinfo.vpi_selinfo.si_note, (b)) 136 137 /* 138 * A virgin directory (no blushing please). 139 */ 140 static struct dirtemplate mastertemplate = { 141 0, 12, DT_DIR, 1, ".", 142 0, DIRBLKSIZ - 12, DT_DIR, 2, ".." 143 }; 144 static struct odirtemplate omastertemplate = { 145 0, 12, 1, ".", 146 0, DIRBLKSIZ - 12, 2, ".." 147 }; 148 149 void 150 ufs_itimes(struct vnode *vp) 151 { 152 struct inode *ip; 153 struct timespec ts; 154 155 ip = VTOI(vp); 156 if ((ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_UPDATE)) == 0) 157 return; 158 if ((vp->v_type == VBLK || vp->v_type == VCHR) && !DOINGSOFTDEP(vp)) 159 ip->i_flag |= IN_LAZYMOD; 160 else 161 ip->i_flag |= IN_MODIFIED; 162 if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) { 163 vfs_timestamp(&ts); 164 if (ip->i_flag & IN_ACCESS) { 165 ip->i_atime = ts.tv_sec; 166 ip->i_atimensec = ts.tv_nsec; 167 } 168 if (ip->i_flag & IN_UPDATE) { 169 ip->i_mtime = ts.tv_sec; 170 ip->i_mtimensec = ts.tv_nsec; 171 ip->i_modrev++; 172 } 173 if (ip->i_flag & IN_CHANGE) { 174 ip->i_ctime = ts.tv_sec; 175 ip->i_ctimensec = ts.tv_nsec; 176 } 177 } 178 ip->i_flag &= ~(IN_ACCESS | IN_CHANGE | IN_UPDATE); 179 } 180 181 /* 182 * Create a regular file 183 * 184 * ufs_create(struct vnode *a_dvp, struct vnode **a_vpp, 185 * struct componentname *a_cnp, struct vattr *a_vap) 186 */ 187 static 188 int 189 ufs_create(struct vop_create_args *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 VN_KNOTE(ap->a_dvp, NOTE_WRITE); 199 return (0); 200 } 201 202 /* 203 * Mknod vnode call 204 * 205 * ufs_mknod(struct vnode *a_dvp, struct vnode **a_vpp, 206 * struct componentname *a_cnp, struct vattr *a_vap) 207 */ 208 /* ARGSUSED */ 209 static 210 int 211 ufs_mknod(struct vop_mknod_args *ap) 212 { 213 struct vattr *vap = ap->a_vap; 214 struct vnode **vpp = ap->a_vpp; 215 struct inode *ip; 216 ino_t ino; 217 int error; 218 219 error = ufs_makeinode(MAKEIMODE(vap->va_type, vap->va_mode), 220 ap->a_dvp, vpp, ap->a_cnp); 221 if (error) 222 return (error); 223 VN_KNOTE(ap->a_dvp, NOTE_WRITE); 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 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. 237 */ 238 vput(*vpp); 239 (*vpp)->v_type = VNON; 240 ino = ip->i_number; /* Save this before vgone() invalidates ip. */ 241 vgone(*vpp); 242 error = VFS_VGET(ap->a_dvp->v_mount, ino, vpp); 243 if (error) { 244 *vpp = NULL; 245 return (error); 246 } 247 return (0); 248 } 249 250 /* 251 * Open called. 252 * 253 * Nothing to do. 254 * 255 * ufs_open(struct vnode *a_vp, int a_mode, struct ucred *a_cred, 256 * struct thread *a_td) 257 */ 258 /* ARGSUSED */ 259 static 260 int 261 ufs_open(struct vop_open_args *ap) 262 { 263 /* 264 * Files marked append-only must be opened for appending. 265 */ 266 if ((VTOI(ap->a_vp)->i_flags & APPEND) && 267 (ap->a_mode & (FWRITE | O_APPEND)) == FWRITE) 268 return (EPERM); 269 return (0); 270 } 271 272 /* 273 * Close called. 274 * 275 * Update the times on the inode. 276 * 277 * ufs_close(struct vnode *a_vp, int a_fflag, struct ucred *a_cred, 278 * struct thread *a_td) 279 */ 280 /* ARGSUSED */ 281 static 282 int 283 ufs_close(struct vop_close_args *ap) 284 { 285 struct vnode *vp = ap->a_vp; 286 lwkt_tokref vlock; 287 288 lwkt_gettoken(&vlock, vp->v_interlock); 289 if (vp->v_usecount > 1) 290 ufs_itimes(vp); 291 lwkt_reltoken(&vlock); 292 return (0); 293 } 294 295 /* 296 * ufs_access(struct vnode *a_vp, int a_mode, struct ucred *a_cred, 297 * struct thread *a_td) 298 */ 299 static 300 int 301 ufs_access(struct vop_access_args *ap) 302 { 303 struct vnode *vp = ap->a_vp; 304 struct inode *ip = VTOI(vp); 305 struct ucred *cred = ap->a_cred; 306 mode_t mask, mode = ap->a_mode; 307 gid_t *gp; 308 int i; 309 #ifdef QUOTA 310 int error; 311 #endif 312 313 /* 314 * Disallow write attempts on read-only filesystems; 315 * unless the file is a socket, fifo, or a block or 316 * character device resident on the filesystem. 317 */ 318 if (mode & VWRITE) { 319 switch (vp->v_type) { 320 case VDIR: 321 case VLNK: 322 case VREG: 323 if (vp->v_mount->mnt_flag & MNT_RDONLY) 324 return (EROFS); 325 #ifdef QUOTA 326 if ((error = getinoquota(ip)) != 0) 327 return (error); 328 #endif 329 break; 330 default: 331 break; 332 } 333 } 334 335 /* If immutable bit set, nobody gets to write it. */ 336 if ((mode & VWRITE) && (ip->i_flags & IMMUTABLE)) 337 return (EPERM); 338 339 /* Otherwise, user id 0 always gets access. */ 340 if (cred->cr_uid == 0) 341 return (0); 342 343 mask = 0; 344 345 /* Otherwise, check the owner. */ 346 if (cred->cr_uid == ip->i_uid) { 347 if (mode & VEXEC) 348 mask |= S_IXUSR; 349 if (mode & VREAD) 350 mask |= S_IRUSR; 351 if (mode & VWRITE) 352 mask |= S_IWUSR; 353 return ((ip->i_mode & mask) == mask ? 0 : EACCES); 354 } 355 356 /* Otherwise, check the groups. */ 357 for (i = 0, gp = cred->cr_groups; i < cred->cr_ngroups; i++, gp++) 358 if (ip->i_gid == *gp) { 359 if (mode & VEXEC) 360 mask |= S_IXGRP; 361 if (mode & VREAD) 362 mask |= S_IRGRP; 363 if (mode & VWRITE) 364 mask |= S_IWGRP; 365 return ((ip->i_mode & mask) == mask ? 0 : EACCES); 366 } 367 368 /* Otherwise, check everyone else. */ 369 if (mode & VEXEC) 370 mask |= S_IXOTH; 371 if (mode & VREAD) 372 mask |= S_IROTH; 373 if (mode & VWRITE) 374 mask |= S_IWOTH; 375 return ((ip->i_mode & mask) == mask ? 0 : EACCES); 376 } 377 378 /* 379 * ufs_getattr(struct vnode *a_vp, struct vattr *a_vap, 380 * struct thread *a_td) 381 */ 382 /* ARGSUSED */ 383 static 384 int 385 ufs_getattr(struct vop_getattr_args *ap) 386 { 387 struct vnode *vp = ap->a_vp; 388 struct inode *ip = VTOI(vp); 389 struct vattr *vap = ap->a_vap; 390 391 ufs_itimes(vp); 392 /* 393 * Copy from inode table 394 */ 395 vap->va_fsid = dev2udev(ip->i_dev); 396 vap->va_fileid = ip->i_number; 397 vap->va_mode = ip->i_mode & ~IFMT; 398 vap->va_nlink = VFSTOUFS(vp->v_mount)->um_i_effnlink_valid ? 399 ip->i_effnlink : ip->i_nlink; 400 vap->va_uid = ip->i_uid; 401 vap->va_gid = ip->i_gid; 402 vap->va_rdev = ip->i_rdev; 403 vap->va_size = ip->i_din.di_size; 404 vap->va_atime.tv_sec = ip->i_atime; 405 vap->va_atime.tv_nsec = ip->i_atimensec; 406 vap->va_mtime.tv_sec = ip->i_mtime; 407 vap->va_mtime.tv_nsec = ip->i_mtimensec; 408 vap->va_ctime.tv_sec = ip->i_ctime; 409 vap->va_ctime.tv_nsec = ip->i_ctimensec; 410 vap->va_flags = ip->i_flags; 411 vap->va_gen = ip->i_gen; 412 vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize; 413 vap->va_bytes = dbtob((u_quad_t)ip->i_blocks); 414 vap->va_type = IFTOVT(ip->i_mode); 415 vap->va_filerev = ip->i_modrev; 416 return (0); 417 } 418 419 /* 420 * Set attribute vnode op. called from several syscalls 421 * 422 * ufs_setattr(struct vnode *a_vp, struct vattr *a_vap, 423 * struct ucred *a_cred, struct thread *a_td) 424 */ 425 static 426 int 427 ufs_setattr(struct vop_setattr_args *ap) 428 { 429 struct vattr *vap = ap->a_vap; 430 struct vnode *vp = ap->a_vp; 431 struct inode *ip = VTOI(vp); 432 struct ucred *cred = ap->a_cred; 433 int error; 434 435 /* 436 * Check for unsettable attributes. 437 */ 438 if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) || 439 (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) || 440 (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) || 441 ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) { 442 return (EINVAL); 443 } 444 if (vap->va_flags != VNOVAL) { 445 if (vp->v_mount->mnt_flag & MNT_RDONLY) 446 return (EROFS); 447 if (cred->cr_uid != ip->i_uid && 448 (error = suser_cred(cred, PRISON_ROOT))) 449 return (error); 450 if ((cred->cr_uid == 0) && (cred->cr_prison == NULL)) { 451 if ((ip->i_flags 452 & (SF_NOUNLINK | SF_IMMUTABLE | SF_APPEND)) && 453 securelevel > 0) 454 return (EPERM); 455 ip->i_flags = vap->va_flags; 456 } else { 457 if (ip->i_flags 458 & (SF_NOUNLINK | SF_IMMUTABLE | SF_APPEND) || 459 (vap->va_flags & UF_SETTABLE) != vap->va_flags) 460 return (EPERM); 461 ip->i_flags &= SF_SETTABLE; 462 ip->i_flags |= (vap->va_flags & UF_SETTABLE); 463 } 464 ip->i_flag |= IN_CHANGE; 465 if (vap->va_flags & (IMMUTABLE | APPEND)) 466 return (0); 467 } 468 if (ip->i_flags & (IMMUTABLE | APPEND)) 469 return (EPERM); 470 /* 471 * Go through the fields and update iff not VNOVAL. 472 */ 473 if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) { 474 if (vp->v_mount->mnt_flag & MNT_RDONLY) 475 return (EROFS); 476 if ((error = ufs_chown(vp, vap->va_uid, vap->va_gid, cred, ap->a_td)) != 0) 477 return (error); 478 } 479 if (vap->va_size != VNOVAL) { 480 /* 481 * Disallow write attempts on read-only filesystems; 482 * unless the file is a socket, fifo, or a block or 483 * character device resident on the filesystem. 484 */ 485 switch (vp->v_type) { 486 case VDIR: 487 return (EISDIR); 488 case VLNK: 489 case VREG: 490 if (vp->v_mount->mnt_flag & MNT_RDONLY) 491 return (EROFS); 492 break; 493 default: 494 break; 495 } 496 if ((error = UFS_TRUNCATE(vp, vap->va_size, 0, cred, ap->a_td)) != 0) 497 return (error); 498 } 499 ip = VTOI(vp); 500 if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) { 501 if (vp->v_mount->mnt_flag & MNT_RDONLY) 502 return (EROFS); 503 if (cred->cr_uid != ip->i_uid && 504 (error = suser_cred(cred, PRISON_ROOT)) && 505 ((vap->va_vaflags & VA_UTIMES_NULL) == 0 || 506 (error = VOP_ACCESS(vp, VWRITE, cred, ap->a_td)))) 507 return (error); 508 if (vap->va_atime.tv_sec != VNOVAL) 509 ip->i_flag |= IN_ACCESS; 510 if (vap->va_mtime.tv_sec != VNOVAL) 511 ip->i_flag |= IN_CHANGE | IN_UPDATE; 512 ufs_itimes(vp); 513 if (vap->va_atime.tv_sec != VNOVAL) { 514 ip->i_atime = vap->va_atime.tv_sec; 515 ip->i_atimensec = vap->va_atime.tv_nsec; 516 } 517 if (vap->va_mtime.tv_sec != VNOVAL) { 518 ip->i_mtime = vap->va_mtime.tv_sec; 519 ip->i_mtimensec = vap->va_mtime.tv_nsec; 520 } 521 error = UFS_UPDATE(vp, 0); 522 if (error) 523 return (error); 524 } 525 error = 0; 526 if (vap->va_mode != (mode_t)VNOVAL) { 527 if (vp->v_mount->mnt_flag & MNT_RDONLY) 528 return (EROFS); 529 error = ufs_chmod(vp, (int)vap->va_mode, cred, ap->a_td); 530 } 531 VN_KNOTE(vp, NOTE_ATTRIB); 532 return (error); 533 } 534 535 /* 536 * Change the mode on a file. 537 * Inode must be locked before calling. 538 */ 539 static int 540 ufs_chmod(struct vnode *vp, int mode, struct ucred *cred, struct thread *td) 541 { 542 struct inode *ip = VTOI(vp); 543 int error; 544 545 if (cred->cr_uid != ip->i_uid) { 546 error = suser_cred(cred, PRISON_ROOT); 547 if (error) 548 return (error); 549 } 550 if (cred->cr_uid) { 551 if (vp->v_type != VDIR && (mode & S_ISTXT)) 552 return (EFTYPE); 553 if (!groupmember(ip->i_gid, cred) && (mode & ISGID)) 554 return (EPERM); 555 } 556 ip->i_mode &= ~ALLPERMS; 557 ip->i_mode |= (mode & ALLPERMS); 558 ip->i_flag |= IN_CHANGE; 559 return (0); 560 } 561 562 /* 563 * Perform chown operation on inode ip; 564 * inode must be locked prior to call. 565 */ 566 static int 567 ufs_chown(struct vnode *vp, uid_t uid, gid_t gid, struct ucred *cred, 568 struct thread *td) 569 { 570 struct inode *ip = VTOI(vp); 571 uid_t ouid; 572 gid_t ogid; 573 int error = 0; 574 #ifdef QUOTA 575 int i; 576 long change; 577 #endif 578 579 if (uid == (uid_t)VNOVAL) 580 uid = ip->i_uid; 581 if (gid == (gid_t)VNOVAL) 582 gid = ip->i_gid; 583 /* 584 * If we don't own the file, are trying to change the owner 585 * of the file, or are not a member of the target group, 586 * the caller must be superuser or the call fails. 587 */ 588 if ((cred->cr_uid != ip->i_uid || uid != ip->i_uid || 589 (gid != ip->i_gid && !(cred->cr_gid == gid || 590 groupmember((gid_t)gid, cred)))) && 591 (error = suser_cred(cred, PRISON_ROOT))) 592 return (error); 593 ogid = ip->i_gid; 594 ouid = ip->i_uid; 595 #ifdef QUOTA 596 if ((error = getinoquota(ip)) != 0) 597 return (error); 598 if (ouid == uid) { 599 dqrele(vp, ip->i_dquot[USRQUOTA]); 600 ip->i_dquot[USRQUOTA] = NODQUOT; 601 } 602 if (ogid == gid) { 603 dqrele(vp, ip->i_dquot[GRPQUOTA]); 604 ip->i_dquot[GRPQUOTA] = NODQUOT; 605 } 606 change = ip->i_blocks; 607 (void) chkdq(ip, -change, cred, CHOWN); 608 (void) chkiq(ip, -1, cred, CHOWN); 609 for (i = 0; i < MAXQUOTAS; i++) { 610 dqrele(vp, ip->i_dquot[i]); 611 ip->i_dquot[i] = NODQUOT; 612 } 613 #endif 614 ip->i_gid = gid; 615 ip->i_uid = uid; 616 #ifdef QUOTA 617 if ((error = getinoquota(ip)) == 0) { 618 if (ouid == uid) { 619 dqrele(vp, ip->i_dquot[USRQUOTA]); 620 ip->i_dquot[USRQUOTA] = NODQUOT; 621 } 622 if (ogid == gid) { 623 dqrele(vp, ip->i_dquot[GRPQUOTA]); 624 ip->i_dquot[GRPQUOTA] = NODQUOT; 625 } 626 if ((error = chkdq(ip, change, cred, CHOWN)) == 0) { 627 if ((error = chkiq(ip, 1, cred, CHOWN)) == 0) 628 goto good; 629 else 630 (void) chkdq(ip, -change, cred, CHOWN|FORCE); 631 } 632 for (i = 0; i < MAXQUOTAS; i++) { 633 dqrele(vp, ip->i_dquot[i]); 634 ip->i_dquot[i] = NODQUOT; 635 } 636 } 637 ip->i_gid = ogid; 638 ip->i_uid = ouid; 639 if (getinoquota(ip) == 0) { 640 if (ouid == uid) { 641 dqrele(vp, ip->i_dquot[USRQUOTA]); 642 ip->i_dquot[USRQUOTA] = NODQUOT; 643 } 644 if (ogid == gid) { 645 dqrele(vp, ip->i_dquot[GRPQUOTA]); 646 ip->i_dquot[GRPQUOTA] = NODQUOT; 647 } 648 (void) chkdq(ip, change, cred, FORCE|CHOWN); 649 (void) chkiq(ip, 1, cred, FORCE|CHOWN); 650 (void) getinoquota(ip); 651 } 652 return (error); 653 good: 654 if (getinoquota(ip)) 655 panic("ufs_chown: lost quota"); 656 #endif /* QUOTA */ 657 ip->i_flag |= IN_CHANGE; 658 if (cred->cr_uid != 0 && (ouid != uid || ogid != gid)) 659 ip->i_mode &= ~(ISUID | ISGID); 660 return (0); 661 } 662 663 /* 664 * Mmap a file 665 * 666 * NB Currently unsupported. 667 * 668 * ufs_mmap(struct vnode *a_vp, int a_fflags, struct ucred *a_cred, 669 * struct thread *a_td) 670 */ 671 /* ARGSUSED */ 672 static 673 int 674 ufs_mmap(struct vop_mmap_args *ap) 675 { 676 return (EINVAL); 677 } 678 679 /* 680 * ufs_remove(struct vnode *a_dvp, struct vnode *a_vp, 681 * struct componentname *a_cnp) 682 */ 683 static 684 int 685 ufs_remove(struct vop_remove_args *ap) 686 { 687 struct inode *ip; 688 struct vnode *vp = ap->a_vp; 689 struct vnode *dvp = ap->a_dvp; 690 int error; 691 692 ip = VTOI(vp); 693 if ((ip->i_flags & (NOUNLINK | IMMUTABLE | APPEND)) || 694 (VTOI(dvp)->i_flags & APPEND)) { 695 error = EPERM; 696 goto out; 697 } 698 error = ufs_dirremove(dvp, ip, ap->a_cnp->cn_flags, 0); 699 VN_KNOTE(vp, NOTE_DELETE); 700 VN_KNOTE(dvp, NOTE_WRITE); 701 out: 702 return (error); 703 } 704 705 /* 706 * link vnode call 707 * 708 * ufs_link(struct vnode *a_tdvp, struct vnode *a_vp, 709 * struct componentname *a_cnp) 710 */ 711 static 712 int 713 ufs_link(struct vop_link_args *ap) 714 { 715 struct vnode *vp = ap->a_vp; 716 struct vnode *tdvp = ap->a_tdvp; 717 struct componentname *cnp = ap->a_cnp; 718 struct thread *td = cnp->cn_td; 719 struct inode *ip; 720 struct direct newdir; 721 int error; 722 723 #ifdef DIAGNOSTIC 724 if ((cnp->cn_flags & CNP_HASBUF) == 0) 725 panic("ufs_link: no name"); 726 #endif 727 if (tdvp->v_mount != vp->v_mount) { 728 error = EXDEV; 729 goto out2; 730 } 731 if (tdvp != vp && (error = vn_lock(vp, NULL, LK_EXCLUSIVE, td))) { 732 goto out2; 733 } 734 ip = VTOI(vp); 735 if ((nlink_t)ip->i_nlink >= LINK_MAX) { 736 error = EMLINK; 737 goto out1; 738 } 739 if (ip->i_flags & (IMMUTABLE | APPEND)) { 740 error = EPERM; 741 goto out1; 742 } 743 ip->i_effnlink++; 744 ip->i_nlink++; 745 ip->i_flag |= IN_CHANGE; 746 if (DOINGSOFTDEP(vp)) 747 softdep_change_linkcnt(ip); 748 error = UFS_UPDATE(vp, !(DOINGSOFTDEP(vp) | DOINGASYNC(vp))); 749 if (!error) { 750 ufs_makedirentry(ip, cnp, &newdir); 751 error = ufs_direnter(tdvp, vp, &newdir, cnp, NULL); 752 } 753 754 if (error) { 755 ip->i_effnlink--; 756 ip->i_nlink--; 757 ip->i_flag |= IN_CHANGE; 758 if (DOINGSOFTDEP(vp)) 759 softdep_change_linkcnt(ip); 760 } 761 out1: 762 if (tdvp != vp) 763 VOP_UNLOCK(vp, NULL, 0, td); 764 out2: 765 VN_KNOTE(vp, NOTE_LINK); 766 VN_KNOTE(tdvp, NOTE_WRITE); 767 return (error); 768 } 769 770 /* 771 * whiteout vnode call 772 * 773 * ufs_whiteout(struct vnode *a_dvp, struct componentname *a_cnp, int a_flags) 774 */ 775 static 776 int 777 ufs_whiteout(struct vop_whiteout_args *ap) 778 { 779 struct vnode *dvp = ap->a_dvp; 780 struct componentname *cnp = ap->a_cnp; 781 struct direct newdir; 782 int error = 0; 783 784 switch (ap->a_flags) { 785 case NAMEI_LOOKUP: 786 /* 4.4 format directories support whiteout operations */ 787 if (dvp->v_mount->mnt_maxsymlinklen > 0) 788 return (0); 789 return (EOPNOTSUPP); 790 791 case NAMEI_CREATE: 792 /* create a new directory whiteout */ 793 #ifdef DIAGNOSTIC 794 if ((cnp->cn_flags & CNP_SAVENAME) == 0) 795 panic("ufs_whiteout: missing name"); 796 if (dvp->v_mount->mnt_maxsymlinklen <= 0) 797 panic("ufs_whiteout: old format filesystem"); 798 #endif 799 800 newdir.d_ino = WINO; 801 newdir.d_namlen = cnp->cn_namelen; 802 bcopy(cnp->cn_nameptr, newdir.d_name, (unsigned)cnp->cn_namelen + 1); 803 newdir.d_type = DT_WHT; 804 error = ufs_direnter(dvp, NULL, &newdir, cnp, NULL); 805 break; 806 807 case NAMEI_DELETE: 808 /* remove an existing directory whiteout */ 809 #ifdef DIAGNOSTIC 810 if (dvp->v_mount->mnt_maxsymlinklen <= 0) 811 panic("ufs_whiteout: old format filesystem"); 812 #endif 813 814 cnp->cn_flags &= ~CNP_DOWHITEOUT; 815 error = ufs_dirremove(dvp, NULL, cnp->cn_flags, 0); 816 break; 817 default: 818 panic("ufs_whiteout: unknown op"); 819 } 820 return (error); 821 } 822 823 /* 824 * Rename system call. 825 * rename("foo", "bar"); 826 * is essentially 827 * unlink("bar"); 828 * link("foo", "bar"); 829 * unlink("foo"); 830 * but ``atomically''. Can't do full commit without saving state in the 831 * inode on disk which isn't feasible at this time. Best we can do is 832 * always guarantee the target exists. 833 * 834 * Basic algorithm is: 835 * 836 * 1) Bump link count on source while we're linking it to the 837 * target. This also ensure the inode won't be deleted out 838 * from underneath us while we work (it may be truncated by 839 * a concurrent `trunc' or `open' for creation). 840 * 2) Link source to destination. If destination already exists, 841 * delete it first. 842 * 3) Unlink source reference to inode if still around. If a 843 * directory was moved and the parent of the destination 844 * is different from the source, patch the ".." entry in the 845 * directory. 846 * 847 * ufs_rename(struct vnode *a_fdvp, struct vnode *a_fvp, 848 * struct componentname *a_fcnp, struct vnode *a_tdvp, 849 * struct vnode *a_tvp, struct componentname *a_tcnp) 850 */ 851 static 852 int 853 ufs_rename(struct vop_rename_args *ap) 854 { 855 struct vnode *tvp = ap->a_tvp; 856 struct vnode *tdvp = ap->a_tdvp; 857 struct vnode *fvp = ap->a_fvp; 858 struct vnode *fdvp = ap->a_fdvp; 859 struct componentname *tcnp = ap->a_tcnp; 860 struct componentname *fcnp = ap->a_fcnp; 861 struct thread *td = fcnp->cn_td; 862 struct inode *ip, *xp, *dp; 863 struct direct newdir; 864 ino_t oldparent = 0, newparent = 0; 865 int doingdirectory = 0; 866 int error = 0, ioflag; 867 868 #ifdef DIAGNOSTIC 869 if ((tcnp->cn_flags & CNP_HASBUF) == 0 || 870 (fcnp->cn_flags & CNP_HASBUF) == 0) 871 panic("ufs_rename: no name"); 872 #endif /* DIAGNOSTIC */ 873 /* 874 * Check for cross-device rename. 875 */ 876 if ((fvp->v_mount != tdvp->v_mount) || 877 (tvp && (fvp->v_mount != tvp->v_mount))) { 878 error = EXDEV; 879 abortit: 880 if (tdvp == tvp) 881 vrele(tdvp); 882 else 883 vput(tdvp); 884 if (tvp) 885 vput(tvp); 886 vrele(fdvp); 887 vrele(fvp); 888 return (error); 889 } 890 891 if (tvp && ((VTOI(tvp)->i_flags & (NOUNLINK | IMMUTABLE | APPEND)) || 892 (VTOI(tdvp)->i_flags & APPEND))) { 893 error = EPERM; 894 goto abortit; 895 } 896 897 /* 898 * Renaming a file to itself has no effect. The upper layers should 899 * not call us in that case. Temporarily just warn if they do. 900 */ 901 if (fvp == tvp) { 902 printf("ufs_rename: fvp == tvp (can't happen)\n"); 903 error = 0; 904 goto abortit; 905 } 906 907 if ((error = vn_lock(fvp, NULL, LK_EXCLUSIVE, td)) != 0) 908 goto abortit; 909 dp = VTOI(fdvp); 910 ip = VTOI(fvp); 911 if (ip->i_nlink >= LINK_MAX) { 912 VOP_UNLOCK(fvp, NULL, 0, td); 913 error = EMLINK; 914 goto abortit; 915 } 916 if ((ip->i_flags & (NOUNLINK | IMMUTABLE | APPEND)) 917 || (dp->i_flags & APPEND)) { 918 VOP_UNLOCK(fvp, NULL, 0, td); 919 error = EPERM; 920 goto abortit; 921 } 922 if ((ip->i_mode & IFMT) == IFDIR) { 923 /* 924 * Avoid ".", "..", and aliases of "." for obvious reasons. 925 */ 926 if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.') || 927 dp == ip || (fcnp->cn_flags | tcnp->cn_flags) & CNP_ISDOTDOT || 928 (ip->i_flag & IN_RENAME)) { 929 VOP_UNLOCK(fvp, NULL, 0, td); 930 error = EINVAL; 931 goto abortit; 932 } 933 ip->i_flag |= IN_RENAME; 934 oldparent = dp->i_number; 935 doingdirectory = 1; 936 } 937 VN_KNOTE(fdvp, NOTE_WRITE); /* XXX right place? */ 938 vrele(fdvp); 939 940 /* 941 * When the target exists, both the directory 942 * and target vnodes are returned locked. 943 */ 944 dp = VTOI(tdvp); 945 xp = NULL; 946 if (tvp) 947 xp = VTOI(tvp); 948 949 /* 950 * 1) Bump link count while we're moving stuff 951 * around. If we crash somewhere before 952 * completing our work, the link count 953 * may be wrong, but correctable. 954 */ 955 ip->i_effnlink++; 956 ip->i_nlink++; 957 ip->i_flag |= IN_CHANGE; 958 if (DOINGSOFTDEP(fvp)) 959 softdep_change_linkcnt(ip); 960 if ((error = UFS_UPDATE(fvp, !(DOINGSOFTDEP(fvp) | 961 DOINGASYNC(fvp)))) != 0) { 962 VOP_UNLOCK(fvp, NULL, 0, td); 963 goto bad; 964 } 965 966 /* 967 * If ".." must be changed (ie the directory gets a new 968 * parent) then the source directory must not be in the 969 * directory heirarchy above the target, as this would 970 * orphan everything below the source directory. Also 971 * the user must have write permission in the source so 972 * as to be able to change "..". We must repeat the call 973 * to namei, as the parent directory is unlocked by the 974 * call to checkpath(). 975 */ 976 error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_td); 977 VOP_UNLOCK(fvp, NULL, 0, td); 978 if (oldparent != dp->i_number) 979 newparent = dp->i_number; 980 if (doingdirectory && newparent) { 981 if (error) /* write access check above */ 982 goto bad; 983 if (xp != NULL) 984 vput(tvp); 985 error = ufs_checkpath(ip, dp, tcnp->cn_cred); 986 if (error) 987 goto out; 988 if ((tcnp->cn_flags & CNP_SAVESTART) == 0) 989 panic("ufs_rename: lost to startdir"); 990 vref(tdvp); 991 error = relookup(tdvp, &tvp, tcnp); 992 if (error) 993 goto out; 994 vrele(tdvp); 995 dp = VTOI(tdvp); 996 xp = NULL; 997 if (tvp) 998 xp = VTOI(tvp); 999 } 1000 /* 1001 * 2) If target doesn't exist, link the target 1002 * to the source and unlink the source. 1003 * Otherwise, rewrite the target directory 1004 * entry to reference the source inode and 1005 * expunge the original entry's existence. 1006 */ 1007 if (xp == NULL) { 1008 if (dp->i_dev != ip->i_dev) 1009 panic("ufs_rename: EXDEV"); 1010 /* 1011 * Account for ".." in new directory. 1012 * When source and destination have the same 1013 * parent we don't fool with the link count. 1014 */ 1015 if (doingdirectory && newparent) { 1016 if ((nlink_t)dp->i_nlink >= LINK_MAX) { 1017 error = EMLINK; 1018 goto bad; 1019 } 1020 dp->i_effnlink++; 1021 dp->i_nlink++; 1022 dp->i_flag |= IN_CHANGE; 1023 if (DOINGSOFTDEP(tdvp)) 1024 softdep_change_linkcnt(dp); 1025 error = UFS_UPDATE(tdvp, !(DOINGSOFTDEP(tdvp) | 1026 DOINGASYNC(tdvp))); 1027 if (error) 1028 goto bad; 1029 } 1030 ufs_makedirentry(ip, tcnp, &newdir); 1031 error = ufs_direnter(tdvp, NULL, &newdir, tcnp, NULL); 1032 if (error) { 1033 if (doingdirectory && newparent) { 1034 dp->i_effnlink--; 1035 dp->i_nlink--; 1036 dp->i_flag |= IN_CHANGE; 1037 if (DOINGSOFTDEP(tdvp)) 1038 softdep_change_linkcnt(dp); 1039 (void)UFS_UPDATE(tdvp, 1); 1040 } 1041 goto bad; 1042 } 1043 VN_KNOTE(tdvp, NOTE_WRITE); 1044 vput(tdvp); 1045 } else { 1046 if (xp->i_dev != dp->i_dev || xp->i_dev != ip->i_dev) 1047 panic("ufs_rename: EXDEV"); 1048 /* 1049 * Short circuit rename(foo, foo). 1050 */ 1051 if (xp->i_number == ip->i_number) 1052 panic("ufs_rename: same file"); 1053 /* 1054 * If the parent directory is "sticky", then the user must 1055 * own the parent directory, or the destination of the rename, 1056 * otherwise the destination may not be changed (except by 1057 * root). This implements append-only directories. 1058 */ 1059 if ((dp->i_mode & S_ISTXT) && tcnp->cn_cred->cr_uid != 0 && 1060 tcnp->cn_cred->cr_uid != dp->i_uid && 1061 xp->i_uid != tcnp->cn_cred->cr_uid) { 1062 error = EPERM; 1063 goto bad; 1064 } 1065 /* 1066 * Target must be empty if a directory and have no links 1067 * to it. Also, ensure source and target are compatible 1068 * (both directories, or both not directories). 1069 */ 1070 if ((xp->i_mode&IFMT) == IFDIR) { 1071 if ((xp->i_effnlink > 2) || 1072 !ufs_dirempty(xp, dp->i_number, tcnp->cn_cred)) { 1073 error = ENOTEMPTY; 1074 goto bad; 1075 } 1076 if (!doingdirectory) { 1077 error = ENOTDIR; 1078 goto bad; 1079 } 1080 cache_purge(tdvp); 1081 } else if (doingdirectory) { 1082 error = EISDIR; 1083 goto bad; 1084 } 1085 /* 1086 * note: inode passed to ufs_dirrewrite() is 0 for a 1087 * non-directory file rename, 1 for a directory rename 1088 * in the same directory, and > 1 for an inode representing 1089 * the new directory. 1090 */ 1091 error = ufs_dirrewrite(dp, xp, ip->i_number, 1092 IFTODT(ip->i_mode), 1093 (doingdirectory && newparent) ? 1094 newparent : (ino_t)doingdirectory); 1095 if (error) 1096 goto bad; 1097 if (doingdirectory) { 1098 if (!newparent) { 1099 dp->i_effnlink--; 1100 if (DOINGSOFTDEP(tdvp)) 1101 softdep_change_linkcnt(dp); 1102 } 1103 xp->i_effnlink--; 1104 if (DOINGSOFTDEP(tvp)) 1105 softdep_change_linkcnt(xp); 1106 } 1107 if (doingdirectory && !DOINGSOFTDEP(tvp)) { 1108 /* 1109 * Truncate inode. The only stuff left in the directory 1110 * is "." and "..". The "." reference is inconsequential 1111 * since we are quashing it. We have removed the "." 1112 * reference and the reference in the parent directory, 1113 * but there may be other hard links. The soft 1114 * dependency code will arrange to do these operations 1115 * after the parent directory entry has been deleted on 1116 * disk, so when running with that code we avoid doing 1117 * them now. 1118 */ 1119 if (!newparent) { 1120 dp->i_nlink--; 1121 dp->i_flag |= IN_CHANGE; 1122 } 1123 xp->i_nlink--; 1124 xp->i_flag |= IN_CHANGE; 1125 ioflag = DOINGASYNC(tvp) ? 0 : IO_SYNC; 1126 if ((error = UFS_TRUNCATE(tvp, (off_t)0, ioflag, 1127 tcnp->cn_cred, tcnp->cn_td)) != 0) 1128 goto bad; 1129 } 1130 VN_KNOTE(tdvp, NOTE_WRITE); 1131 vput(tdvp); 1132 VN_KNOTE(tvp, NOTE_DELETE); 1133 vput(tvp); 1134 xp = NULL; 1135 } 1136 1137 /* 1138 * 3) Unlink the source. 1139 */ 1140 fcnp->cn_flags &= ~CNP_MODMASK; 1141 fcnp->cn_flags |= CNP_LOCKPARENT | CNP_LOCKLEAF; 1142 if ((fcnp->cn_flags & CNP_SAVESTART) == 0) 1143 panic("ufs_rename: lost from startdir"); 1144 vref(fdvp); 1145 error = relookup(fdvp, &fvp, fcnp); 1146 if (error == 0) 1147 vrele(fdvp); 1148 if (fvp != NULL) { 1149 xp = VTOI(fvp); 1150 dp = VTOI(fdvp); 1151 } else { 1152 /* 1153 * From name has disappeared. 1154 */ 1155 if (doingdirectory) 1156 panic("ufs_rename: lost dir entry"); 1157 vrele(ap->a_fvp); 1158 return (0); 1159 } 1160 /* 1161 * Ensure that the directory entry still exists and has not 1162 * changed while the new name has been entered. If the source is 1163 * a file then the entry may have been unlinked or renamed. In 1164 * either case there is no further work to be done. If the source 1165 * is a directory then it cannot have been rmdir'ed; the IN_RENAME 1166 * flag ensures that it cannot be moved by another rename or removed 1167 * by a rmdir. 1168 */ 1169 if (xp != ip) { 1170 if (doingdirectory) 1171 panic("ufs_rename: lost dir entry"); 1172 } else { 1173 /* 1174 * If the source is a directory with a 1175 * new parent, the link count of the old 1176 * parent directory must be decremented 1177 * and ".." set to point to the new parent. 1178 */ 1179 if (doingdirectory && newparent) { 1180 xp->i_offset = mastertemplate.dot_reclen; 1181 ufs_dirrewrite(xp, dp, newparent, DT_DIR, 0); 1182 cache_purge(fdvp); 1183 } 1184 error = ufs_dirremove(fdvp, xp, fcnp->cn_flags, 0); 1185 xp->i_flag &= ~IN_RENAME; 1186 } 1187 VN_KNOTE(fvp, NOTE_RENAME); 1188 if (dp) 1189 vput(fdvp); 1190 if (xp) 1191 vput(fvp); 1192 vrele(ap->a_fvp); 1193 return (error); 1194 1195 bad: 1196 if (xp) 1197 vput(ITOV(xp)); 1198 vput(ITOV(dp)); 1199 out: 1200 if (doingdirectory) 1201 ip->i_flag &= ~IN_RENAME; 1202 if (vn_lock(fvp, NULL, LK_EXCLUSIVE, td) == 0) { 1203 ip->i_effnlink--; 1204 ip->i_nlink--; 1205 ip->i_flag |= IN_CHANGE; 1206 ip->i_flag &= ~IN_RENAME; 1207 if (DOINGSOFTDEP(fvp)) 1208 softdep_change_linkcnt(ip); 1209 vput(fvp); 1210 } else 1211 vrele(fvp); 1212 return (error); 1213 } 1214 1215 /* 1216 * Mkdir system call 1217 * 1218 * ufs_mkdir(struct vnode *a_dvp, struct vnode **a_vpp, 1219 * struct componentname *a_cnp, struct vattr *a_vap) 1220 */ 1221 static 1222 int 1223 ufs_mkdir(struct vop_mkdir_args *ap) 1224 { 1225 struct vnode *dvp = ap->a_dvp; 1226 struct vattr *vap = ap->a_vap; 1227 struct componentname *cnp = ap->a_cnp; 1228 struct inode *ip, *dp; 1229 struct vnode *tvp; 1230 struct buf *bp; 1231 struct dirtemplate dirtemplate, *dtp; 1232 struct direct newdir; 1233 int error, dmode; 1234 long blkoff; 1235 1236 #ifdef DIAGNOSTIC 1237 if ((cnp->cn_flags & CNP_HASBUF) == 0) 1238 panic("ufs_mkdir: no name"); 1239 #endif 1240 dp = VTOI(dvp); 1241 if ((nlink_t)dp->i_nlink >= LINK_MAX) { 1242 error = EMLINK; 1243 goto out; 1244 } 1245 dmode = vap->va_mode & 0777; 1246 dmode |= IFDIR; 1247 /* 1248 * Must simulate part of ufs_makeinode here to acquire the inode, 1249 * but not have it entered in the parent directory. The entry is 1250 * made later after writing "." and ".." entries. 1251 */ 1252 error = UFS_VALLOC(dvp, dmode, cnp->cn_cred, &tvp); 1253 if (error) 1254 goto out; 1255 ip = VTOI(tvp); 1256 ip->i_gid = dp->i_gid; 1257 #ifdef SUIDDIR 1258 { 1259 #ifdef QUOTA 1260 struct ucred ucred, *ucp; 1261 ucp = cnp->cn_cred; 1262 #endif 1263 /* 1264 * If we are hacking owners here, (only do this where told to) 1265 * and we are not giving it TO root, (would subvert quotas) 1266 * then go ahead and give it to the other user. 1267 * The new directory also inherits the SUID bit. 1268 * If user's UID and dir UID are the same, 1269 * 'give it away' so that the SUID is still forced on. 1270 */ 1271 if ((dvp->v_mount->mnt_flag & MNT_SUIDDIR) && 1272 (dp->i_mode & ISUID) && dp->i_uid) { 1273 dmode |= ISUID; 1274 ip->i_uid = dp->i_uid; 1275 #ifdef QUOTA 1276 if (dp->i_uid != cnp->cn_cred->cr_uid) { 1277 /* 1278 * Make sure the correct user gets charged 1279 * for the space. 1280 * Make a dummy credential for the victim. 1281 * XXX This seems to never be accessed out of 1282 * our context so a stack variable is ok. 1283 */ 1284 ucred.cr_ref = 1; 1285 ucred.cr_uid = ip->i_uid; 1286 ucred.cr_ngroups = 1; 1287 ucred.cr_groups[0] = dp->i_gid; 1288 ucp = &ucred; 1289 } 1290 #endif 1291 } else 1292 ip->i_uid = cnp->cn_cred->cr_uid; 1293 #ifdef QUOTA 1294 if ((error = getinoquota(ip)) || 1295 (error = chkiq(ip, 1, ucp, 0))) { 1296 UFS_VFREE(tvp, ip->i_number, dmode); 1297 vput(tvp); 1298 return (error); 1299 } 1300 #endif 1301 } 1302 #else /* !SUIDDIR */ 1303 ip->i_uid = cnp->cn_cred->cr_uid; 1304 #ifdef QUOTA 1305 if ((error = getinoquota(ip)) || 1306 (error = chkiq(ip, 1, cnp->cn_cred, 0))) { 1307 UFS_VFREE(tvp, ip->i_number, dmode); 1308 vput(tvp); 1309 return (error); 1310 } 1311 #endif 1312 #endif /* !SUIDDIR */ 1313 ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE; 1314 ip->i_mode = dmode; 1315 tvp->v_type = VDIR; /* Rest init'd in getnewvnode(). */ 1316 ip->i_effnlink = 2; 1317 ip->i_nlink = 2; 1318 if (DOINGSOFTDEP(tvp)) 1319 softdep_change_linkcnt(ip); 1320 if (cnp->cn_flags & CNP_ISWHITEOUT) 1321 ip->i_flags |= UF_OPAQUE; 1322 1323 /* 1324 * Bump link count in parent directory to reflect work done below. 1325 * Should be done before reference is created so cleanup is 1326 * possible if we crash. 1327 */ 1328 dp->i_effnlink++; 1329 dp->i_nlink++; 1330 dp->i_flag |= IN_CHANGE; 1331 if (DOINGSOFTDEP(dvp)) 1332 softdep_change_linkcnt(dp); 1333 error = UFS_UPDATE(tvp, !(DOINGSOFTDEP(dvp) | DOINGASYNC(dvp))); 1334 if (error) 1335 goto bad; 1336 1337 /* 1338 * Initialize directory with "." and ".." from static template. 1339 */ 1340 if (dvp->v_mount->mnt_maxsymlinklen > 0 1341 ) 1342 dtp = &mastertemplate; 1343 else 1344 dtp = (struct dirtemplate *)&omastertemplate; 1345 dirtemplate = *dtp; 1346 dirtemplate.dot_ino = ip->i_number; 1347 dirtemplate.dotdot_ino = dp->i_number; 1348 if ((error = VOP_BALLOC(tvp, (off_t)0, DIRBLKSIZ, cnp->cn_cred, 1349 B_CLRBUF, &bp)) != 0) 1350 goto bad; 1351 ip->i_size = DIRBLKSIZ; 1352 ip->i_flag |= IN_CHANGE | IN_UPDATE; 1353 vnode_pager_setsize(tvp, (u_long)ip->i_size); 1354 bcopy((caddr_t)&dirtemplate, (caddr_t)bp->b_data, sizeof dirtemplate); 1355 if (DOINGSOFTDEP(tvp)) { 1356 /* 1357 * Ensure that the entire newly allocated block is a 1358 * valid directory so that future growth within the 1359 * block does not have to ensure that the block is 1360 * written before the inode. 1361 */ 1362 blkoff = DIRBLKSIZ; 1363 while (blkoff < bp->b_bcount) { 1364 ((struct direct *) 1365 (bp->b_data + blkoff))->d_reclen = DIRBLKSIZ; 1366 blkoff += DIRBLKSIZ; 1367 } 1368 } 1369 if ((error = UFS_UPDATE(tvp, !(DOINGSOFTDEP(tvp) | 1370 DOINGASYNC(tvp)))) != 0) { 1371 (void)VOP_BWRITE(bp->b_vp, bp); 1372 goto bad; 1373 } 1374 /* 1375 * Directory set up, now install its entry in the parent directory. 1376 * 1377 * If we are not doing soft dependencies, then we must write out the 1378 * buffer containing the new directory body before entering the new 1379 * name in the parent. If we are doing soft dependencies, then the 1380 * buffer containing the new directory body will be passed to and 1381 * released in the soft dependency code after the code has attached 1382 * an appropriate ordering dependency to the buffer which ensures that 1383 * the buffer is written before the new name is written in the parent. 1384 */ 1385 if (DOINGASYNC(dvp)) 1386 bdwrite(bp); 1387 else if (!DOINGSOFTDEP(dvp) && ((error = VOP_BWRITE(bp->b_vp, bp)))) 1388 goto bad; 1389 ufs_makedirentry(ip, cnp, &newdir); 1390 error = ufs_direnter(dvp, tvp, &newdir, cnp, bp); 1391 1392 bad: 1393 if (error == 0) { 1394 VN_KNOTE(dvp, NOTE_WRITE | NOTE_LINK); 1395 *ap->a_vpp = tvp; 1396 } else { 1397 dp->i_effnlink--; 1398 dp->i_nlink--; 1399 dp->i_flag |= IN_CHANGE; 1400 if (DOINGSOFTDEP(dvp)) 1401 softdep_change_linkcnt(dp); 1402 /* 1403 * No need to do an explicit VOP_TRUNCATE here, vrele will 1404 * do this for us because we set the link count to 0. 1405 */ 1406 ip->i_effnlink = 0; 1407 ip->i_nlink = 0; 1408 ip->i_flag |= IN_CHANGE; 1409 if (DOINGSOFTDEP(tvp)) 1410 softdep_change_linkcnt(ip); 1411 vput(tvp); 1412 } 1413 out: 1414 return (error); 1415 } 1416 1417 /* 1418 * Rmdir system call. 1419 * 1420 * ufs_rmdir(struct vnode *a_dvp, struct vnode *a_vp, 1421 * struct componentname *a_cnp) 1422 */ 1423 static 1424 int 1425 ufs_rmdir(struct vop_rmdir_args *ap) 1426 { 1427 struct vnode *vp = ap->a_vp; 1428 struct vnode *dvp = ap->a_dvp; 1429 struct componentname *cnp = ap->a_cnp; 1430 struct inode *ip, *dp; 1431 int error, ioflag; 1432 1433 ip = VTOI(vp); 1434 dp = VTOI(dvp); 1435 1436 /* 1437 * Do not remove a directory that is in the process of being renamed. 1438 * Verify the directory is empty (and valid). Rmdir ".." will not be 1439 * valid since ".." will contain a reference to the current directory 1440 * and thus be non-empty. Do not allow the removal of mounted on 1441 * directories (this can happen when an NFS exported filesystem 1442 * tries to remove a locally mounted on directory). 1443 */ 1444 error = 0; 1445 if (ip->i_flag & IN_RENAME) { 1446 error = EINVAL; 1447 goto out; 1448 } 1449 if (ip->i_effnlink != 2 || 1450 !ufs_dirempty(ip, dp->i_number, cnp->cn_cred)) { 1451 error = ENOTEMPTY; 1452 goto out; 1453 } 1454 if ((dp->i_flags & APPEND) 1455 || (ip->i_flags & (NOUNLINK | IMMUTABLE | APPEND))) { 1456 error = EPERM; 1457 goto out; 1458 } 1459 if (vp->v_mountedhere != 0) { 1460 error = EINVAL; 1461 goto out; 1462 } 1463 /* 1464 * Delete reference to directory before purging 1465 * inode. If we crash in between, the directory 1466 * will be reattached to lost+found, 1467 */ 1468 dp->i_effnlink--; 1469 ip->i_effnlink--; 1470 if (DOINGSOFTDEP(vp)) { 1471 softdep_change_linkcnt(dp); 1472 softdep_change_linkcnt(ip); 1473 } 1474 error = ufs_dirremove(dvp, ip, cnp->cn_flags, 1); 1475 if (error) { 1476 dp->i_effnlink++; 1477 ip->i_effnlink++; 1478 if (DOINGSOFTDEP(vp)) { 1479 softdep_change_linkcnt(dp); 1480 softdep_change_linkcnt(ip); 1481 } 1482 goto out; 1483 } 1484 VN_KNOTE(dvp, NOTE_WRITE | NOTE_LINK); 1485 cache_purge(dvp); 1486 /* 1487 * Truncate inode. The only stuff left in the directory is "." and 1488 * "..". The "." reference is inconsequential since we are quashing 1489 * it. The soft dependency code will arrange to do these operations 1490 * after the parent directory entry has been deleted on disk, so 1491 * when running with that code we avoid doing them now. 1492 */ 1493 if (!DOINGSOFTDEP(vp)) { 1494 dp->i_nlink--; 1495 dp->i_flag |= IN_CHANGE; 1496 ip->i_nlink--; 1497 ip->i_flag |= IN_CHANGE; 1498 ioflag = DOINGASYNC(vp) ? 0 : IO_SYNC; 1499 error = UFS_TRUNCATE(vp, (off_t)0, ioflag, cnp->cn_cred, 1500 cnp->cn_td); 1501 } 1502 cache_purge(vp); 1503 #ifdef UFS_DIRHASH 1504 /* Kill any active hash; i_effnlink == 0, so it will not come back. */ 1505 if (ip->i_dirhash != NULL) 1506 ufsdirhash_free(ip); 1507 #endif 1508 out: 1509 VN_KNOTE(vp, NOTE_DELETE); 1510 return (error); 1511 } 1512 1513 /* 1514 * symlink -- make a symbolic link 1515 * 1516 * ufs_symlink(struct vnode *a_dvp, struct vnode **a_vpp, 1517 * struct componentname *a_cnp, struct vattr *a_vap, 1518 * char *a_target) 1519 */ 1520 static 1521 int 1522 ufs_symlink(struct vop_symlink_args *ap) 1523 { 1524 struct vnode *vp, **vpp = ap->a_vpp; 1525 struct inode *ip; 1526 int len, error; 1527 1528 error = ufs_makeinode(IFLNK | ap->a_vap->va_mode, ap->a_dvp, 1529 vpp, ap->a_cnp); 1530 if (error) 1531 return (error); 1532 VN_KNOTE(ap->a_dvp, NOTE_WRITE); 1533 vp = *vpp; 1534 len = strlen(ap->a_target); 1535 if (len < vp->v_mount->mnt_maxsymlinklen) { 1536 ip = VTOI(vp); 1537 bcopy(ap->a_target, (char *)ip->i_shortlink, len); 1538 ip->i_size = len; 1539 ip->i_flag |= IN_CHANGE | IN_UPDATE; 1540 } else 1541 error = vn_rdwr(UIO_WRITE, vp, ap->a_target, len, (off_t)0, 1542 UIO_SYSSPACE, IO_NODELOCKED, ap->a_cnp->cn_cred, 1543 (int *)0, NULL); 1544 if (error) 1545 vput(vp); 1546 return (error); 1547 } 1548 1549 /* 1550 * Vnode op for reading directories. 1551 * 1552 * The routine below assumes that the on-disk format of a directory 1553 * is the same as that defined by <sys/dirent.h>. If the on-disk 1554 * format changes, then it will be necessary to do a conversion 1555 * from the on-disk format that read returns to the format defined 1556 * by <sys/dirent.h>. 1557 * 1558 * ufs_readdir(struct vnode *a_vp, struct uio *a_uio, struct ucred *a_cred, 1559 * int *a_eofflag, int *ncookies, u_long **a_cookies) 1560 */ 1561 static 1562 int 1563 ufs_readdir(struct vop_readdir_args *ap) 1564 { 1565 struct uio *uio = ap->a_uio; 1566 int error; 1567 size_t count, lost; 1568 off_t off; 1569 1570 if (ap->a_ncookies != NULL) 1571 /* 1572 * Ensure that the block is aligned. The caller can use 1573 * the cookies to determine where in the block to start. 1574 */ 1575 uio->uio_offset &= ~(DIRBLKSIZ - 1); 1576 off = uio->uio_offset; 1577 count = uio->uio_resid; 1578 /* Make sure we don't return partial entries. */ 1579 if (count <= ((uio->uio_offset + count) & (DIRBLKSIZ -1))) 1580 return (EINVAL); 1581 count -= (uio->uio_offset + count) & (DIRBLKSIZ -1); 1582 lost = uio->uio_resid - count; 1583 uio->uio_resid = count; 1584 uio->uio_iov->iov_len = count; 1585 # if (BYTE_ORDER == LITTLE_ENDIAN) 1586 if (ap->a_vp->v_mount->mnt_maxsymlinklen > 0) { 1587 error = VOP_READ(ap->a_vp, uio, 0, ap->a_cred); 1588 } else { 1589 struct dirent *dp, *edp; 1590 struct uio auio; 1591 struct iovec aiov; 1592 caddr_t dirbuf; 1593 int readcnt; 1594 u_char tmp; 1595 1596 auio = *uio; 1597 auio.uio_iov = &aiov; 1598 auio.uio_iovcnt = 1; 1599 auio.uio_segflg = UIO_SYSSPACE; 1600 aiov.iov_len = count; 1601 MALLOC(dirbuf, caddr_t, count, M_TEMP, M_WAITOK); 1602 aiov.iov_base = dirbuf; 1603 error = VOP_READ(ap->a_vp, &auio, 0, ap->a_cred); 1604 if (error == 0) { 1605 readcnt = count - auio.uio_resid; 1606 edp = (struct dirent *)&dirbuf[readcnt]; 1607 for (dp = (struct dirent *)dirbuf; dp < edp; ) { 1608 tmp = dp->d_namlen; 1609 dp->d_namlen = dp->d_type; 1610 dp->d_type = tmp; 1611 if (dp->d_reclen > 0) { 1612 dp = (struct dirent *) 1613 ((char *)dp + dp->d_reclen); 1614 } else { 1615 error = EIO; 1616 break; 1617 } 1618 } 1619 if (dp >= edp) 1620 error = uiomove(dirbuf, readcnt, uio); 1621 } 1622 FREE(dirbuf, M_TEMP); 1623 } 1624 # else 1625 error = VOP_READ(ap->a_vp, uio, 0, ap->a_cred); 1626 # endif 1627 if (!error && ap->a_ncookies != NULL) { 1628 struct dirent* dpStart; 1629 struct dirent* dpEnd; 1630 struct dirent* dp; 1631 int ncookies; 1632 u_long *cookies; 1633 u_long *cookiep; 1634 1635 if (uio->uio_segflg != UIO_SYSSPACE || uio->uio_iovcnt != 1) 1636 panic("ufs_readdir: unexpected uio from NFS server"); 1637 dpStart = (struct dirent *) 1638 (uio->uio_iov->iov_base - (uio->uio_offset - off)); 1639 dpEnd = (struct dirent *) uio->uio_iov->iov_base; 1640 for (dp = dpStart, ncookies = 0; 1641 dp < dpEnd; 1642 dp = (struct dirent *)((caddr_t) dp + dp->d_reclen)) 1643 ncookies++; 1644 MALLOC(cookies, u_long *, ncookies * sizeof(u_long), M_TEMP, 1645 M_WAITOK); 1646 for (dp = dpStart, cookiep = cookies; 1647 dp < dpEnd; 1648 dp = (struct dirent *)((caddr_t) dp + dp->d_reclen)) { 1649 off += dp->d_reclen; 1650 *cookiep++ = (u_long) off; 1651 } 1652 *ap->a_ncookies = ncookies; 1653 *ap->a_cookies = cookies; 1654 } 1655 uio->uio_resid += lost; 1656 if (ap->a_eofflag) 1657 *ap->a_eofflag = VTOI(ap->a_vp)->i_size <= uio->uio_offset; 1658 return (error); 1659 } 1660 1661 /* 1662 * Return target name of a symbolic link 1663 * 1664 * ufs_readlink(struct vnode *a_vp, struct uio *a_uio, struct ucred *a_cred) 1665 */ 1666 static 1667 int 1668 ufs_readlink(struct vop_readlink_args *ap) 1669 { 1670 struct vnode *vp = ap->a_vp; 1671 struct inode *ip = VTOI(vp); 1672 int isize; 1673 1674 isize = ip->i_size; 1675 if ((isize < vp->v_mount->mnt_maxsymlinklen) || 1676 (ip->i_din.di_blocks == 0)) { /* XXX - for old fastlink support */ 1677 uiomove((char *)ip->i_shortlink, isize, ap->a_uio); 1678 return (0); 1679 } 1680 return (VOP_READ(vp, ap->a_uio, 0, ap->a_cred)); 1681 } 1682 1683 /* 1684 * Calculate the logical to physical mapping if not done already, 1685 * then call the device strategy routine. 1686 * 1687 * In order to be able to swap to a file, the VOP_BMAP operation may not 1688 * deadlock on memory. See ufs_bmap() for details. 1689 * 1690 * ufs_strategy(struct vnode *a_vp, struct buf *a_bp) 1691 */ 1692 static 1693 int 1694 ufs_strategy(struct vop_strategy_args *ap) 1695 { 1696 struct buf *bp = ap->a_bp; 1697 struct vnode *vp = ap->a_vp; 1698 struct inode *ip; 1699 int error; 1700 1701 ip = VTOI(vp); 1702 if (vp->v_type == VBLK || vp->v_type == VCHR) 1703 panic("ufs_strategy: spec"); 1704 if (bp->b_blkno == bp->b_lblkno) { 1705 error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, NULL, NULL); 1706 if (error) { 1707 bp->b_error = error; 1708 bp->b_flags |= B_ERROR; 1709 biodone(bp); 1710 return (error); 1711 } 1712 if (bp->b_blkno == (daddr_t)-1) 1713 vfs_bio_clrbuf(bp); 1714 } 1715 if (bp->b_blkno == (daddr_t)-1) { 1716 biodone(bp); 1717 return (0); 1718 } 1719 vp = ip->i_devvp; 1720 bp->b_dev = vp->v_rdev; 1721 VOP_STRATEGY(vp, bp); 1722 return (0); 1723 } 1724 1725 /* 1726 * Print out the contents of an inode. 1727 * 1728 * ufs_print(struct vnode *a_vp) 1729 */ 1730 static 1731 int 1732 ufs_print(struct vop_print_args *ap) 1733 { 1734 struct vnode *vp = ap->a_vp; 1735 struct inode *ip = VTOI(vp); 1736 1737 printf("tag VT_UFS, ino %lu, on dev %s (%d, %d)", 1738 (u_long)ip->i_number, devtoname(ip->i_dev), major(ip->i_dev), 1739 minor(ip->i_dev)); 1740 if (vp->v_type == VFIFO) 1741 fifo_printinfo(vp); 1742 lockmgr_printinfo(&vp->v_lock); 1743 printf("\n"); 1744 return (0); 1745 } 1746 1747 /* 1748 * Read wrapper for special devices. 1749 * 1750 * ufsspec_read(struct vnode *a_vp, struct uio *a_uio, int a_ioflag, 1751 * struct ucred *a_cred) 1752 */ 1753 static 1754 int 1755 ufsspec_read(struct vop_read_args *ap) 1756 { 1757 int error, resid; 1758 struct inode *ip; 1759 struct uio *uio; 1760 1761 uio = ap->a_uio; 1762 resid = uio->uio_resid; 1763 error = VOCALL(spec_vnode_vops, &ap->a_head); 1764 /* 1765 * The inode may have been revoked during the call, so it must not 1766 * be accessed blindly here or in the other wrapper functions. 1767 */ 1768 ip = VTOI(ap->a_vp); 1769 if (ip != NULL && (uio->uio_resid != resid || (error == 0 && resid != 0))) 1770 ip->i_flag |= IN_ACCESS; 1771 return (error); 1772 } 1773 1774 /* 1775 * Write wrapper for special devices. 1776 * 1777 * ufsspec_write(struct vnode *a_vp, struct uio *a_uio, int a_ioflag, 1778 * struct ucred *a_cred) 1779 */ 1780 static 1781 int 1782 ufsspec_write(struct vop_write_args *ap) 1783 { 1784 int error, resid; 1785 struct inode *ip; 1786 struct uio *uio; 1787 1788 uio = ap->a_uio; 1789 resid = uio->uio_resid; 1790 error = VOCALL(spec_vnode_vops, &ap->a_head); 1791 ip = VTOI(ap->a_vp); 1792 if (ip != NULL && (uio->uio_resid != resid || (error == 0 && resid != 0))) 1793 VTOI(ap->a_vp)->i_flag |= IN_CHANGE | IN_UPDATE; 1794 return (error); 1795 } 1796 1797 /* 1798 * Close wrapper for special devices. 1799 * 1800 * Update the times on the inode then do device close. 1801 * 1802 * ufsspec_close(struct vnode *a_vp, int a_fflag, struct ucred *a_cred, 1803 * struct thread *a_td) 1804 */ 1805 static 1806 int 1807 ufsspec_close(struct vop_close_args *ap) 1808 { 1809 struct vnode *vp = ap->a_vp; 1810 lwkt_tokref vlock; 1811 1812 lwkt_gettoken(&vlock, vp->v_interlock); 1813 if (vp->v_usecount > 1) 1814 ufs_itimes(vp); 1815 lwkt_reltoken(&vlock); 1816 return (VOCALL(spec_vnode_vops, &ap->a_head)); 1817 } 1818 1819 /* 1820 * Read wrapper for fifos. 1821 * 1822 * ufsfifo_read(struct vnode *a_vp, struct uio *a_uio, int a_ioflag, 1823 * struct ucred *a_cred) 1824 */ 1825 static 1826 int 1827 ufsfifo_read(struct vop_read_args *ap) 1828 { 1829 int error, resid; 1830 struct inode *ip; 1831 struct uio *uio; 1832 1833 uio = ap->a_uio; 1834 resid = uio->uio_resid; 1835 error = VOCALL(fifo_vnode_vops, &ap->a_head); 1836 ip = VTOI(ap->a_vp); 1837 if ((ap->a_vp->v_mount->mnt_flag & MNT_NOATIME) == 0 && ip != NULL && 1838 (uio->uio_resid != resid || (error == 0 && resid != 0))) 1839 VTOI(ap->a_vp)->i_flag |= IN_ACCESS; 1840 return (error); 1841 } 1842 1843 /* 1844 * Write wrapper for fifos. 1845 * 1846 * ufsfifo_write(struct vnode *a_vp, struct uio *a_uio, int a_ioflag, 1847 * struct ucred *a_cred) 1848 */ 1849 static 1850 int 1851 ufsfifo_write(struct vop_write_args *ap) 1852 { 1853 int error, resid; 1854 struct inode *ip; 1855 struct uio *uio; 1856 1857 uio = ap->a_uio; 1858 resid = uio->uio_resid; 1859 error = VOCALL(fifo_vnode_vops, &ap->a_head); 1860 ip = VTOI(ap->a_vp); 1861 if (ip != NULL && (uio->uio_resid != resid || (error == 0 && resid != 0))) 1862 VTOI(ap->a_vp)->i_flag |= IN_CHANGE | IN_UPDATE; 1863 return (error); 1864 } 1865 1866 /* 1867 * Close wrapper for fifos. 1868 * 1869 * Update the times on the inode then do device close. 1870 * 1871 * ufsfifo_close(struct vnode *a_vp, int a_fflag, struct ucred *a_cred, 1872 * struct thread *a_td) 1873 */ 1874 static 1875 int 1876 ufsfifo_close(struct vop_close_args *ap) 1877 { 1878 struct vnode *vp = ap->a_vp; 1879 lwkt_tokref vlock; 1880 1881 lwkt_gettoken(&vlock, vp->v_interlock); 1882 if (vp->v_usecount > 1) 1883 ufs_itimes(vp); 1884 lwkt_reltoken(&vlock); 1885 return (VOCALL(fifo_vnode_vops, &ap->a_head)); 1886 } 1887 1888 /* 1889 * Kqfilter wrapper for fifos. 1890 * 1891 * Fall through to ufs kqfilter routines if needed 1892 */ 1893 static 1894 int 1895 ufsfifo_kqfilter(struct vop_kqfilter_args *ap) 1896 { 1897 int error; 1898 1899 error = VOCALL(fifo_vnode_vops, &ap->a_head); 1900 if (error) 1901 error = ufs_kqfilter(ap); 1902 return (error); 1903 } 1904 1905 /* 1906 * Return POSIX pathconf information applicable to ufs filesystems. 1907 * 1908 * ufs_pathconf(struct vnode *a_vp, int a_name, int *a_retval) 1909 */ 1910 static 1911 int 1912 ufs_pathconf(struct vop_pathconf_args *ap) 1913 { 1914 switch (ap->a_name) { 1915 case _PC_LINK_MAX: 1916 *ap->a_retval = LINK_MAX; 1917 return (0); 1918 case _PC_NAME_MAX: 1919 *ap->a_retval = NAME_MAX; 1920 return (0); 1921 case _PC_PATH_MAX: 1922 *ap->a_retval = PATH_MAX; 1923 return (0); 1924 case _PC_PIPE_BUF: 1925 *ap->a_retval = PIPE_BUF; 1926 return (0); 1927 case _PC_CHOWN_RESTRICTED: 1928 *ap->a_retval = 1; 1929 return (0); 1930 case _PC_NO_TRUNC: 1931 *ap->a_retval = 1; 1932 return (0); 1933 default: 1934 return (EINVAL); 1935 } 1936 /* NOTREACHED */ 1937 } 1938 1939 /* 1940 * Advisory record locking support 1941 * 1942 * ufs_advlock(struct vnode *a_vp, caddr_t a_id, int a_op, struct flock *a_fl, 1943 * int a_flags) 1944 */ 1945 static 1946 int 1947 ufs_advlock(struct vop_advlock_args *ap) 1948 { 1949 struct inode *ip = VTOI(ap->a_vp); 1950 1951 return (lf_advlock(ap, &(ip->i_lockf), ip->i_size)); 1952 } 1953 1954 /* 1955 * Initialize the vnode associated with a new inode, handle aliased 1956 * vnodes. 1957 */ 1958 int 1959 ufs_vinit(struct mount *mntp, struct vnode **vpp) 1960 { 1961 struct inode *ip; 1962 struct vnode *vp; 1963 struct timeval tv; 1964 1965 vp = *vpp; 1966 ip = VTOI(vp); 1967 switch(vp->v_type = IFTOVT(ip->i_mode)) { 1968 case VCHR: 1969 case VBLK: 1970 vp->v_ops = mntp->mnt_vn_spec_ops; 1971 addaliasu(vp, ip->i_rdev); 1972 break; 1973 case VFIFO: 1974 vp->v_ops = mntp->mnt_vn_fifo_ops; 1975 break; 1976 default: 1977 break; 1978 1979 } 1980 if (ip->i_number == ROOTINO) 1981 vp->v_flag |= VROOT; 1982 /* 1983 * Initialize modrev times 1984 */ 1985 getmicrouptime(&tv); 1986 SETHIGH(ip->i_modrev, tv.tv_sec); 1987 SETLOW(ip->i_modrev, tv.tv_usec * 4294); 1988 *vpp = vp; 1989 return (0); 1990 } 1991 1992 /* 1993 * Allocate a new inode. 1994 */ 1995 static 1996 int 1997 ufs_makeinode(int mode, struct vnode *dvp, struct vnode **vpp, 1998 struct componentname *cnp) 1999 { 2000 struct inode *ip, *pdir; 2001 struct direct newdir; 2002 struct vnode *tvp; 2003 int error; 2004 2005 pdir = VTOI(dvp); 2006 #ifdef DIAGNOSTIC 2007 if ((cnp->cn_flags & CNP_HASBUF) == 0) 2008 panic("ufs_makeinode: no name"); 2009 #endif 2010 *vpp = NULL; 2011 if ((mode & IFMT) == 0) 2012 mode |= IFREG; 2013 2014 error = UFS_VALLOC(dvp, mode, cnp->cn_cred, &tvp); 2015 if (error) 2016 return (error); 2017 ip = VTOI(tvp); 2018 ip->i_gid = pdir->i_gid; 2019 #ifdef SUIDDIR 2020 { 2021 #ifdef QUOTA 2022 struct ucred ucred, *ucp; 2023 ucp = cnp->cn_cred; 2024 #endif 2025 /* 2026 * If we are not the owner of the directory, 2027 * and we are hacking owners here, (only do this where told to) 2028 * and we are not giving it TO root, (would subvert quotas) 2029 * then go ahead and give it to the other user. 2030 * Note that this drops off the execute bits for security. 2031 */ 2032 if ((dvp->v_mount->mnt_flag & MNT_SUIDDIR) && 2033 (pdir->i_mode & ISUID) && 2034 (pdir->i_uid != cnp->cn_cred->cr_uid) && pdir->i_uid) { 2035 ip->i_uid = pdir->i_uid; 2036 mode &= ~07111; 2037 #ifdef QUOTA 2038 /* 2039 * Make sure the correct user gets charged 2040 * for the space. 2041 * Quickly knock up a dummy credential for the victim. 2042 * XXX This seems to never be accessed out of our 2043 * context so a stack variable is ok. 2044 */ 2045 ucred.cr_ref = 1; 2046 ucred.cr_uid = ip->i_uid; 2047 ucred.cr_ngroups = 1; 2048 ucred.cr_groups[0] = pdir->i_gid; 2049 ucp = &ucred; 2050 #endif 2051 } else 2052 ip->i_uid = cnp->cn_cred->cr_uid; 2053 2054 #ifdef QUOTA 2055 if ((error = getinoquota(ip)) || 2056 (error = chkiq(ip, 1, ucp, 0))) { 2057 UFS_VFREE(tvp, ip->i_number, mode); 2058 vput(tvp); 2059 return (error); 2060 } 2061 #endif 2062 } 2063 #else /* !SUIDDIR */ 2064 ip->i_uid = cnp->cn_cred->cr_uid; 2065 #ifdef QUOTA 2066 if ((error = getinoquota(ip)) || 2067 (error = chkiq(ip, 1, cnp->cn_cred, 0))) { 2068 UFS_VFREE(tvp, ip->i_number, mode); 2069 vput(tvp); 2070 return (error); 2071 } 2072 #endif 2073 #endif /* !SUIDDIR */ 2074 ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE; 2075 ip->i_mode = mode; 2076 tvp->v_type = IFTOVT(mode); /* Rest init'd in getnewvnode(). */ 2077 ip->i_effnlink = 1; 2078 ip->i_nlink = 1; 2079 if (DOINGSOFTDEP(tvp)) 2080 softdep_change_linkcnt(ip); 2081 if ((ip->i_mode & ISGID) && !groupmember(ip->i_gid, cnp->cn_cred) && 2082 suser_cred(cnp->cn_cred, 0)) { 2083 ip->i_mode &= ~ISGID; 2084 } 2085 2086 if (cnp->cn_flags & CNP_ISWHITEOUT) 2087 ip->i_flags |= UF_OPAQUE; 2088 2089 /* 2090 * Make sure inode goes to disk before directory entry. 2091 */ 2092 error = UFS_UPDATE(tvp, !(DOINGSOFTDEP(tvp) | DOINGASYNC(tvp))); 2093 if (error) 2094 goto bad; 2095 ufs_makedirentry(ip, cnp, &newdir); 2096 error = ufs_direnter(dvp, tvp, &newdir, cnp, NULL); 2097 if (error) 2098 goto bad; 2099 *vpp = tvp; 2100 return (0); 2101 2102 bad: 2103 /* 2104 * Write error occurred trying to update the inode 2105 * or the directory so must deallocate the inode. 2106 */ 2107 ip->i_effnlink = 0; 2108 ip->i_nlink = 0; 2109 ip->i_flag |= IN_CHANGE; 2110 if (DOINGSOFTDEP(tvp)) 2111 softdep_change_linkcnt(ip); 2112 vput(tvp); 2113 return (error); 2114 } 2115 2116 static int 2117 ufs_missingop(struct vop_generic_args *ap) 2118 { 2119 panic("no vop function for %s in ufs child", ap->a_desc->vdesc_name); 2120 return (EOPNOTSUPP); 2121 } 2122 2123 static struct filterops ufsread_filtops = 2124 { 1, NULL, filt_ufsdetach, filt_ufsread }; 2125 static struct filterops ufswrite_filtops = 2126 { 1, NULL, filt_ufsdetach, filt_ufswrite }; 2127 static struct filterops ufsvnode_filtops = 2128 { 1, NULL, filt_ufsdetach, filt_ufsvnode }; 2129 2130 /* 2131 * ufs_kqfilter(struct vnode *a_vp, struct knote *a_kn) 2132 */ 2133 static int 2134 ufs_kqfilter(struct vop_kqfilter_args *ap) 2135 { 2136 struct vnode *vp = ap->a_vp; 2137 struct knote *kn = ap->a_kn; 2138 lwkt_tokref ilock; 2139 2140 switch (kn->kn_filter) { 2141 case EVFILT_READ: 2142 kn->kn_fop = &ufsread_filtops; 2143 break; 2144 case EVFILT_WRITE: 2145 kn->kn_fop = &ufswrite_filtops; 2146 break; 2147 case EVFILT_VNODE: 2148 kn->kn_fop = &ufsvnode_filtops; 2149 break; 2150 default: 2151 return (1); 2152 } 2153 2154 kn->kn_hook = (caddr_t)vp; 2155 2156 lwkt_gettoken(&ilock, &vp->v_pollinfo.vpi_token); 2157 SLIST_INSERT_HEAD(&vp->v_pollinfo.vpi_selinfo.si_note, kn, kn_selnext); 2158 lwkt_reltoken(&ilock); 2159 2160 return (0); 2161 } 2162 2163 static void 2164 filt_ufsdetach(struct knote *kn) 2165 { 2166 struct vnode *vp = (struct vnode *)kn->kn_hook; 2167 lwkt_tokref ilock; 2168 2169 lwkt_gettoken(&ilock, &vp->v_pollinfo.vpi_token); 2170 SLIST_REMOVE(&vp->v_pollinfo.vpi_selinfo.si_note, 2171 kn, knote, kn_selnext); 2172 lwkt_reltoken(&ilock); 2173 } 2174 2175 /*ARGSUSED*/ 2176 static int 2177 filt_ufsread(struct knote *kn, long hint) 2178 { 2179 struct vnode *vp = (struct vnode *)kn->kn_hook; 2180 struct inode *ip = VTOI(vp); 2181 2182 /* 2183 * filesystem is gone, so set the EOF flag and schedule 2184 * the knote for deletion. 2185 */ 2186 if (hint == NOTE_REVOKE) { 2187 kn->kn_flags |= (EV_EOF | EV_ONESHOT); 2188 return (1); 2189 } 2190 2191 kn->kn_data = ip->i_size - kn->kn_fp->f_offset; 2192 return (kn->kn_data != 0); 2193 } 2194 2195 /*ARGSUSED*/ 2196 static int 2197 filt_ufswrite(struct knote *kn, long hint) 2198 { 2199 /* 2200 * filesystem is gone, so set the EOF flag and schedule 2201 * the knote for deletion. 2202 */ 2203 if (hint == NOTE_REVOKE) 2204 kn->kn_flags |= (EV_EOF | EV_ONESHOT); 2205 2206 kn->kn_data = 0; 2207 return (1); 2208 } 2209 2210 static int 2211 filt_ufsvnode(struct knote *kn, long hint) 2212 { 2213 if (kn->kn_sfflags & hint) 2214 kn->kn_fflags |= hint; 2215 if (hint == NOTE_REVOKE) { 2216 kn->kn_flags |= EV_EOF; 2217 return (1); 2218 } 2219 return (kn->kn_fflags != 0); 2220 } 2221 2222 /* Global vfs data structures for ufs. */ 2223 static struct vop_ops *ufs_vnode_vops; 2224 static struct vnodeopv_entry_desc ufs_vnodeop_entries[] = { 2225 { &vop_default_desc, vop_defaultop }, 2226 { &vop_fsync_desc, (void *) ufs_missingop }, 2227 { &vop_read_desc, (void *) ufs_missingop }, 2228 { &vop_reallocblks_desc, (void *) ufs_missingop }, 2229 { &vop_write_desc, (void *) ufs_missingop }, 2230 { &vop_access_desc, (void *) ufs_access }, 2231 { &vop_advlock_desc, (void *) ufs_advlock }, 2232 { &vop_bmap_desc, (void *) ufs_bmap }, 2233 { &vop_cachedlookup_desc, (void *) ufs_lookup }, 2234 { &vop_close_desc, (void *) ufs_close }, 2235 { &vop_create_desc, (void *) ufs_create }, 2236 { &vop_getattr_desc, (void *) ufs_getattr }, 2237 { &vop_inactive_desc, (void *) ufs_inactive }, 2238 { &vop_islocked_desc, (void *) vop_stdislocked }, 2239 { &vop_link_desc, (void *) ufs_link }, 2240 { &vop_lock_desc, (void *) vop_stdlock }, 2241 { &vop_lookup_desc, (void *) vfs_cache_lookup }, 2242 { &vop_mkdir_desc, (void *) ufs_mkdir }, 2243 { &vop_mknod_desc, (void *) ufs_mknod }, 2244 { &vop_mmap_desc, (void *) ufs_mmap }, 2245 { &vop_open_desc, (void *) ufs_open }, 2246 { &vop_pathconf_desc, (void *) ufs_pathconf }, 2247 { &vop_poll_desc, (void *) vop_stdpoll }, 2248 { &vop_kqfilter_desc, (void *) ufs_kqfilter }, 2249 { &vop_print_desc, (void *) ufs_print }, 2250 { &vop_readdir_desc, (void *) ufs_readdir }, 2251 { &vop_readlink_desc, (void *) ufs_readlink }, 2252 { &vop_reclaim_desc, (void *) ufs_reclaim }, 2253 { &vop_remove_desc, (void *) ufs_remove }, 2254 { &vop_rename_desc, (void *) ufs_rename }, 2255 { &vop_rmdir_desc, (void *) ufs_rmdir }, 2256 { &vop_setattr_desc, (void *) ufs_setattr }, 2257 { &vop_strategy_desc, (void *) ufs_strategy }, 2258 { &vop_symlink_desc, (void *) ufs_symlink }, 2259 { &vop_unlock_desc, (void *) vop_stdunlock }, 2260 { &vop_whiteout_desc, (void *) ufs_whiteout }, 2261 { NULL, NULL } 2262 }; 2263 static struct vnodeopv_desc ufs_vnodeop_opv_desc = 2264 { &ufs_vnode_vops, ufs_vnodeop_entries }; 2265 2266 static struct vop_ops *ufs_spec_vops; 2267 static struct vnodeopv_entry_desc ufs_specop_entries[] = { 2268 { &vop_default_desc, (void *) spec_vnoperate }, 2269 { &vop_fsync_desc, (void *) ufs_missingop }, 2270 { &vop_access_desc, (void *) ufs_access }, 2271 { &vop_close_desc, (void *) ufsspec_close }, 2272 { &vop_getattr_desc, (void *) ufs_getattr }, 2273 { &vop_inactive_desc, (void *) ufs_inactive }, 2274 { &vop_islocked_desc, (void *) vop_stdislocked }, 2275 { &vop_lock_desc, (void *) vop_stdlock }, 2276 { &vop_print_desc, (void *) ufs_print }, 2277 { &vop_read_desc, (void *) ufsspec_read }, 2278 { &vop_reclaim_desc, (void *) ufs_reclaim }, 2279 { &vop_setattr_desc, (void *) ufs_setattr }, 2280 { &vop_unlock_desc, (void *) vop_stdunlock }, 2281 { &vop_write_desc, (void *) ufsspec_write }, 2282 { NULL, NULL } 2283 }; 2284 static struct vnodeopv_desc ufs_specop_opv_desc = 2285 { &ufs_spec_vops, ufs_specop_entries }; 2286 2287 static struct vop_ops *ufs_fifo_vops; 2288 static struct vnodeopv_entry_desc ufs_fifoop_entries[] = { 2289 { &vop_default_desc, (void *) fifo_vnoperate }, 2290 { &vop_fsync_desc, (void *) ufs_missingop }, 2291 { &vop_access_desc, (void *) ufs_access }, 2292 { &vop_close_desc, (void *) ufsfifo_close }, 2293 { &vop_getattr_desc, (void *) ufs_getattr }, 2294 { &vop_inactive_desc, (void *) ufs_inactive }, 2295 { &vop_islocked_desc, (void *) vop_stdislocked }, 2296 { &vop_kqfilter_desc, (void *) ufsfifo_kqfilter }, 2297 { &vop_lock_desc, (void *) vop_stdlock }, 2298 { &vop_print_desc, (void *) ufs_print }, 2299 { &vop_read_desc, (void *) ufsfifo_read }, 2300 { &vop_reclaim_desc, (void *) ufs_reclaim }, 2301 { &vop_setattr_desc, (void *) ufs_setattr }, 2302 { &vop_unlock_desc, (void *) vop_stdunlock }, 2303 { &vop_write_desc, (void *) ufsfifo_write }, 2304 { NULL, NULL } 2305 }; 2306 static struct vnodeopv_desc ufs_fifoop_opv_desc = 2307 { &ufs_fifo_vops, ufs_fifoop_entries }; 2308 2309 VNODEOP_SET(ufs_vnodeop_opv_desc); 2310 VNODEOP_SET(ufs_specop_opv_desc); 2311 VNODEOP_SET(ufs_fifoop_opv_desc); 2312 2313 /* 2314 * ufs_vnoperate(struct vnodeop_desc *a_desc) 2315 */ 2316 int 2317 ufs_vnoperate(struct vop_generic_args *ap) 2318 { 2319 return (VOCALL(ufs_vnode_vops, ap)); 2320 } 2321 2322 /* 2323 * ufs_vnoperatefifo(struct vnodeop_desc *a_desc) 2324 */ 2325 int 2326 ufs_vnoperatefifo(struct vop_generic_args *ap) 2327 { 2328 return (VOCALL(ufs_fifo_vops, ap)); 2329 } 2330 2331 /* 2332 * ufs_vnoperatespec(struct vnodeop_desc *a_desc) 2333 */ 2334 int 2335 ufs_vnoperatespec(struct vop_generic_args *ap) 2336 { 2337 return (VOCALL(ufs_spec_vops, ap)); 2338 } 2339