1 /* 2 * Copyright (c) 1982, 1986, 1989 Regents of the University of California. 3 * All rights reserved. 4 * 5 * %sccs.include.redist.c% 6 * 7 * @(#)ffs_vnops.c 7.50 (Berkeley) 02/01/91 8 */ 9 10 #include "param.h" 11 #include "systm.h" 12 #include "user.h" 13 #include "kernel.h" 14 #include "file.h" 15 #include "stat.h" 16 #include "buf.h" 17 #include "proc.h" 18 #include "socket.h" 19 #include "socketvar.h" 20 #include "conf.h" 21 #include "mount.h" 22 #include "vnode.h" 23 #include "specdev.h" 24 #include "fcntl.h" 25 #include "malloc.h" 26 #include "../ufs/lockf.h" 27 #include "../ufs/quota.h" 28 #include "../ufs/inode.h" 29 #include "../ufs/fs.h" 30 31 /* 32 * Global vfs data structures for ufs 33 */ 34 35 int ufs_lookup(), 36 ufs_create(), 37 ufs_mknod(), 38 ufs_open(), 39 ufs_close(), 40 ufs_access(), 41 ufs_getattr(), 42 ufs_setattr(), 43 ufs_read(), 44 ufs_write(), 45 ufs_ioctl(), 46 ufs_select(), 47 ufs_mmap(), 48 ufs_fsync(), 49 ufs_seek(), 50 ufs_remove(), 51 ufs_link(), 52 ufs_rename(), 53 ufs_mkdir(), 54 ufs_rmdir(), 55 ufs_symlink(), 56 ufs_readdir(), 57 ufs_readlink(), 58 ufs_abortop(), 59 ufs_inactive(), 60 ufs_reclaim(), 61 ufs_lock(), 62 ufs_unlock(), 63 ufs_bmap(), 64 ufs_strategy(), 65 ufs_print(), 66 ufs_islocked(), 67 ufs_advlock(); 68 69 struct vnodeops ufs_vnodeops = { 70 ufs_lookup, /* lookup */ 71 ufs_create, /* create */ 72 ufs_mknod, /* mknod */ 73 ufs_open, /* open */ 74 ufs_close, /* close */ 75 ufs_access, /* access */ 76 ufs_getattr, /* getattr */ 77 ufs_setattr, /* setattr */ 78 ufs_read, /* read */ 79 ufs_write, /* write */ 80 ufs_ioctl, /* ioctl */ 81 ufs_select, /* select */ 82 ufs_mmap, /* mmap */ 83 ufs_fsync, /* fsync */ 84 ufs_seek, /* seek */ 85 ufs_remove, /* remove */ 86 ufs_link, /* link */ 87 ufs_rename, /* rename */ 88 ufs_mkdir, /* mkdir */ 89 ufs_rmdir, /* rmdir */ 90 ufs_symlink, /* symlink */ 91 ufs_readdir, /* readdir */ 92 ufs_readlink, /* readlink */ 93 ufs_abortop, /* abortop */ 94 ufs_inactive, /* inactive */ 95 ufs_reclaim, /* reclaim */ 96 ufs_lock, /* lock */ 97 ufs_unlock, /* unlock */ 98 ufs_bmap, /* bmap */ 99 ufs_strategy, /* strategy */ 100 ufs_print, /* print */ 101 ufs_islocked, /* islocked */ 102 ufs_advlock, /* advlock */ 103 }; 104 105 int spec_lookup(), 106 spec_open(), 107 ufsspec_read(), 108 ufsspec_write(), 109 spec_strategy(), 110 spec_bmap(), 111 spec_ioctl(), 112 spec_select(), 113 ufsspec_close(), 114 spec_advlock(), 115 spec_badop(), 116 spec_nullop(); 117 118 struct vnodeops spec_inodeops = { 119 spec_lookup, /* lookup */ 120 spec_badop, /* create */ 121 spec_badop, /* mknod */ 122 spec_open, /* open */ 123 ufsspec_close, /* close */ 124 ufs_access, /* access */ 125 ufs_getattr, /* getattr */ 126 ufs_setattr, /* setattr */ 127 ufsspec_read, /* read */ 128 ufsspec_write, /* write */ 129 spec_ioctl, /* ioctl */ 130 spec_select, /* select */ 131 spec_badop, /* mmap */ 132 spec_nullop, /* fsync */ 133 spec_badop, /* seek */ 134 spec_badop, /* remove */ 135 spec_badop, /* link */ 136 spec_badop, /* rename */ 137 spec_badop, /* mkdir */ 138 spec_badop, /* rmdir */ 139 spec_badop, /* symlink */ 140 spec_badop, /* readdir */ 141 spec_badop, /* readlink */ 142 spec_badop, /* abortop */ 143 ufs_inactive, /* inactive */ 144 ufs_reclaim, /* reclaim */ 145 ufs_lock, /* lock */ 146 ufs_unlock, /* unlock */ 147 spec_bmap, /* bmap */ 148 spec_strategy, /* strategy */ 149 ufs_print, /* print */ 150 ufs_islocked, /* islocked */ 151 spec_advlock, /* advlock */ 152 }; 153 154 #ifdef FIFO 155 int fifo_lookup(), 156 fifo_open(), 157 ufsfifo_read(), 158 ufsfifo_write(), 159 fifo_bmap(), 160 fifo_ioctl(), 161 fifo_select(), 162 ufsfifo_close(), 163 fifo_print(), 164 fifo_advlock(), 165 fifo_badop(), 166 fifo_nullop(); 167 168 struct vnodeops fifo_inodeops = { 169 fifo_lookup, /* lookup */ 170 fifo_badop, /* create */ 171 fifo_badop, /* mknod */ 172 fifo_open, /* open */ 173 ufsfifo_close, /* close */ 174 ufs_access, /* access */ 175 ufs_getattr, /* getattr */ 176 ufs_setattr, /* setattr */ 177 ufsfifo_read, /* read */ 178 ufsfifo_write, /* write */ 179 fifo_ioctl, /* ioctl */ 180 fifo_select, /* select */ 181 fifo_badop, /* mmap */ 182 fifo_nullop, /* fsync */ 183 fifo_badop, /* seek */ 184 fifo_badop, /* remove */ 185 fifo_badop, /* link */ 186 fifo_badop, /* rename */ 187 fifo_badop, /* mkdir */ 188 fifo_badop, /* rmdir */ 189 fifo_badop, /* symlink */ 190 fifo_badop, /* readdir */ 191 fifo_badop, /* readlink */ 192 fifo_badop, /* abortop */ 193 ufs_inactive, /* inactive */ 194 ufs_reclaim, /* reclaim */ 195 ufs_lock, /* lock */ 196 ufs_unlock, /* unlock */ 197 fifo_bmap, /* bmap */ 198 fifo_badop, /* strategy */ 199 ufs_print, /* print */ 200 ufs_islocked, /* islocked */ 201 fifo_advlock, /* advlock */ 202 }; 203 #endif /* FIFO */ 204 205 enum vtype iftovt_tab[16] = { 206 VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON, 207 VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD, 208 }; 209 int vttoif_tab[9] = { 210 0, IFREG, IFDIR, IFBLK, IFCHR, IFLNK, IFSOCK, IFIFO, IFMT, 211 }; 212 213 /* 214 * Create a regular file 215 */ 216 ufs_create(ndp, vap) 217 struct nameidata *ndp; 218 struct vattr *vap; 219 { 220 struct inode *ip; 221 int error; 222 223 if (error = maknode(MAKEIMODE(vap->va_type, vap->va_mode), ndp, &ip)) 224 return (error); 225 ndp->ni_vp = ITOV(ip); 226 return (0); 227 } 228 229 /* 230 * Mknod vnode call 231 */ 232 /* ARGSUSED */ 233 ufs_mknod(ndp, vap, cred) 234 struct nameidata *ndp; 235 struct ucred *cred; 236 struct vattr *vap; 237 { 238 register struct vnode *vp; 239 struct inode *ip; 240 int error; 241 242 if (error = maknode(MAKEIMODE(vap->va_type, vap->va_mode), ndp, &ip)) 243 return (error); 244 ip->i_flag |= IACC|IUPD|ICHG; 245 if (vap->va_rdev != VNOVAL) { 246 /* 247 * Want to be able to use this to make badblock 248 * inodes, so don't truncate the dev number. 249 */ 250 ip->i_rdev = vap->va_rdev; 251 } 252 /* 253 * Remove inode so that it will be reloaded by iget and 254 * checked to see if it is an alias of an existing entry 255 * in the inode cache. 256 */ 257 vp = ITOV(ip); 258 vput(vp); 259 vp->v_type = VNON; 260 vgone(vp); 261 return (0); 262 } 263 264 /* 265 * Open called. 266 * 267 * Nothing to do. 268 */ 269 /* ARGSUSED */ 270 ufs_open(vp, mode, cred) 271 struct vnode *vp; 272 int mode; 273 struct ucred *cred; 274 { 275 276 return (0); 277 } 278 279 /* 280 * Close called 281 * 282 * Update the times on the inode. 283 */ 284 /* ARGSUSED */ 285 ufs_close(vp, fflag, cred) 286 struct vnode *vp; 287 int fflag; 288 struct ucred *cred; 289 { 290 register struct inode *ip = VTOI(vp); 291 292 if (vp->v_usecount > 1 && !(ip->i_flag & ILOCKED)) 293 ITIMES(ip, &time, &time); 294 return (0); 295 } 296 297 /* 298 * Check mode permission on inode pointer. Mode is READ, WRITE or EXEC. 299 * The mode is shifted to select the owner/group/other fields. The 300 * super user is granted all permissions. 301 */ 302 ufs_access(vp, mode, cred) 303 struct vnode *vp; 304 register int mode; 305 struct ucred *cred; 306 { 307 register struct inode *ip = VTOI(vp); 308 register gid_t *gp; 309 int i, error; 310 311 #ifdef DIAGNOSTIC 312 if (!VOP_ISLOCKED(vp)) { 313 vprint("ufs_access: not locked", vp); 314 panic("ufs_access: not locked"); 315 } 316 #endif 317 #ifdef QUOTA 318 if (mode & VWRITE) { 319 switch (vp->v_type) { 320 case VREG: case VDIR: case VLNK: 321 if (error = getinoquota(ip)) 322 return (error); 323 } 324 } 325 #endif /* QUOTA */ 326 /* 327 * If you're the super-user, you always get access. 328 */ 329 if (cred->cr_uid == 0) 330 return (0); 331 /* 332 * Access check is based on only one of owner, group, public. 333 * If not owner, then check group. If not a member of the 334 * group, then check public access. 335 */ 336 if (cred->cr_uid != ip->i_uid) { 337 mode >>= 3; 338 gp = cred->cr_groups; 339 for (i = 0; i < cred->cr_ngroups; i++, gp++) 340 if (ip->i_gid == *gp) 341 goto found; 342 mode >>= 3; 343 found: 344 ; 345 } 346 if ((ip->i_mode & mode) != 0) 347 return (0); 348 return (EACCES); 349 } 350 351 /* ARGSUSED */ 352 ufs_getattr(vp, vap, cred) 353 struct vnode *vp; 354 register struct vattr *vap; 355 struct ucred *cred; 356 { 357 register struct inode *ip = VTOI(vp); 358 359 ITIMES(ip, &time, &time); 360 /* 361 * Copy from inode table 362 */ 363 vap->va_fsid = ip->i_dev; 364 vap->va_fileid = ip->i_number; 365 vap->va_mode = ip->i_mode & ~IFMT; 366 vap->va_nlink = ip->i_nlink; 367 vap->va_uid = ip->i_uid; 368 vap->va_gid = ip->i_gid; 369 vap->va_rdev = (dev_t)ip->i_rdev; 370 #ifdef tahoe 371 vap->va_size = ip->i_size; 372 vap->va_size_rsv = 0; 373 #else 374 vap->va_qsize = ip->i_din.di_qsize; 375 #endif 376 vap->va_atime.tv_sec = ip->i_atime; 377 vap->va_atime.tv_usec = 0; 378 vap->va_mtime.tv_sec = ip->i_mtime; 379 vap->va_mtime.tv_usec = 0; 380 vap->va_ctime.tv_sec = ip->i_ctime; 381 vap->va_ctime.tv_usec = 0; 382 vap->va_flags = ip->i_flags; 383 vap->va_gen = ip->i_gen; 384 /* this doesn't belong here */ 385 if (vp->v_type == VBLK) 386 vap->va_blocksize = BLKDEV_IOSIZE; 387 else if (vp->v_type == VCHR) 388 vap->va_blocksize = MAXBSIZE; 389 else 390 vap->va_blocksize = ip->i_fs->fs_bsize; 391 vap->va_bytes = dbtob(ip->i_blocks); 392 vap->va_bytes_rsv = 0; 393 vap->va_type = vp->v_type; 394 return (0); 395 } 396 397 /* 398 * Set attribute vnode op. called from several syscalls 399 */ 400 ufs_setattr(vp, vap, cred) 401 register struct vnode *vp; 402 register struct vattr *vap; 403 register struct ucred *cred; 404 { 405 register struct inode *ip = VTOI(vp); 406 int error = 0; 407 408 /* 409 * Check for unsetable attributes. 410 */ 411 if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) || 412 (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) || 413 (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) || 414 ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) { 415 return (EINVAL); 416 } 417 /* 418 * Go through the fields and update iff not VNOVAL. 419 */ 420 if (vap->va_uid != (u_short)VNOVAL || vap->va_gid != (u_short)VNOVAL) 421 if (error = chown1(vp, vap->va_uid, vap->va_gid, cred)) 422 return (error); 423 if (vap->va_size != VNOVAL) { 424 if (vp->v_type == VDIR) 425 return (EISDIR); 426 if (error = itrunc(ip, vap->va_size, 0)) /* XXX IO_SYNC? */ 427 return (error); 428 } 429 if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) { 430 if (cred->cr_uid != ip->i_uid && 431 (error = suser(cred, &u.u_acflag))) 432 return (error); 433 if (vap->va_atime.tv_sec != VNOVAL) 434 ip->i_flag |= IACC; 435 if (vap->va_mtime.tv_sec != VNOVAL) 436 ip->i_flag |= IUPD; 437 ip->i_flag |= ICHG; 438 if (error = iupdat(ip, &vap->va_atime, &vap->va_mtime, 1)) 439 return (error); 440 } 441 if (vap->va_mode != (u_short)VNOVAL) 442 error = chmod1(vp, (int)vap->va_mode, cred); 443 if (vap->va_flags != VNOVAL) { 444 if (cred->cr_uid != ip->i_uid && 445 (error = suser(cred, &u.u_acflag))) 446 return (error); 447 if (cred->cr_uid == 0) { 448 ip->i_flags = vap->va_flags; 449 } else { 450 ip->i_flags &= 0xffff0000; 451 ip->i_flags |= (vap->va_flags & 0xffff); 452 } 453 ip->i_flag |= ICHG; 454 } 455 return (error); 456 } 457 458 /* 459 * Change the mode on a file. 460 * Inode must be locked before calling. 461 */ 462 chmod1(vp, mode, cred) 463 register struct vnode *vp; 464 register int mode; 465 struct ucred *cred; 466 { 467 register struct inode *ip = VTOI(vp); 468 int error; 469 470 if (cred->cr_uid != ip->i_uid && 471 (error = suser(cred, &u.u_acflag))) 472 return (error); 473 if (cred->cr_uid) { 474 if (vp->v_type != VDIR && (mode & ISVTX)) 475 return (EFTYPE); 476 if (!groupmember(ip->i_gid, cred) && (mode & ISGID)) 477 return (EPERM); 478 } 479 ip->i_mode &= ~07777; 480 ip->i_mode |= mode & 07777; 481 ip->i_flag |= ICHG; 482 if ((vp->v_flag & VTEXT) && (ip->i_mode & ISVTX) == 0) 483 (void) vnode_pager_uncache(vp); 484 return (0); 485 } 486 487 /* 488 * Perform chown operation on inode ip; 489 * inode must be locked prior to call. 490 */ 491 chown1(vp, uid, gid, cred) 492 register struct vnode *vp; 493 uid_t uid; 494 gid_t gid; 495 struct ucred *cred; 496 { 497 register struct inode *ip = VTOI(vp); 498 uid_t ouid; 499 gid_t ogid; 500 int error = 0; 501 #ifdef QUOTA 502 register int i; 503 long change; 504 #endif 505 506 if (uid == (u_short)VNOVAL) 507 uid = ip->i_uid; 508 if (gid == (u_short)VNOVAL) 509 gid = ip->i_gid; 510 /* 511 * If we don't own the file, are trying to change the owner 512 * of the file, or are not a member of the target group, 513 * the caller must be superuser or the call fails. 514 */ 515 if ((cred->cr_uid != ip->i_uid || uid != ip->i_uid || 516 !groupmember((gid_t)gid, cred)) && 517 (error = suser(cred, &u.u_acflag))) 518 return (error); 519 ouid = ip->i_uid; 520 ogid = ip->i_gid; 521 #ifdef QUOTA 522 if (error = getinoquota(ip)) 523 return (error); 524 if (ouid == uid) { 525 dqrele(vp, ip->i_dquot[USRQUOTA]); 526 ip->i_dquot[USRQUOTA] = NODQUOT; 527 } 528 if (ogid == gid) { 529 dqrele(vp, ip->i_dquot[GRPQUOTA]); 530 ip->i_dquot[GRPQUOTA] = NODQUOT; 531 } 532 change = ip->i_blocks; 533 (void) chkdq(ip, -change, cred, CHOWN); 534 (void) chkiq(ip, -1, cred, CHOWN); 535 for (i = 0; i < MAXQUOTAS; i++) { 536 dqrele(vp, ip->i_dquot[i]); 537 ip->i_dquot[i] = NODQUOT; 538 } 539 #endif 540 ip->i_uid = uid; 541 ip->i_gid = gid; 542 #ifdef QUOTA 543 if ((error = getinoquota(ip)) == 0) { 544 if (ouid == uid) { 545 dqrele(vp, ip->i_dquot[USRQUOTA]); 546 ip->i_dquot[USRQUOTA] = NODQUOT; 547 } 548 if (ogid == gid) { 549 dqrele(vp, ip->i_dquot[GRPQUOTA]); 550 ip->i_dquot[GRPQUOTA] = NODQUOT; 551 } 552 if ((error = chkdq(ip, change, cred, CHOWN)) == 0) { 553 if ((error = chkiq(ip, 1, cred, CHOWN)) == 0) 554 goto good; 555 else 556 (void) chkdq(ip, -change, cred, CHOWN|FORCE); 557 } 558 for (i = 0; i < MAXQUOTAS; i++) { 559 dqrele(vp, ip->i_dquot[i]); 560 ip->i_dquot[i] = NODQUOT; 561 } 562 } 563 ip->i_uid = ouid; 564 ip->i_gid = ogid; 565 if (getinoquota(ip) == 0) { 566 if (ouid == uid) { 567 dqrele(vp, ip->i_dquot[USRQUOTA]); 568 ip->i_dquot[USRQUOTA] = NODQUOT; 569 } 570 if (ogid == gid) { 571 dqrele(vp, ip->i_dquot[GRPQUOTA]); 572 ip->i_dquot[GRPQUOTA] = NODQUOT; 573 } 574 (void) chkdq(ip, change, cred, FORCE|CHOWN); 575 (void) chkiq(ip, 1, cred, FORCE|CHOWN); 576 (void) getinoquota(ip); 577 } 578 return (error); 579 good: 580 if (getinoquota(ip)) 581 panic("chown: lost quota"); 582 #endif /* QUOTA */ 583 if (ouid != uid || ogid != gid) 584 ip->i_flag |= ICHG; 585 if (ouid != uid && cred->cr_uid != 0) 586 ip->i_mode &= ~ISUID; 587 if (ogid != gid && cred->cr_uid != 0) 588 ip->i_mode &= ~ISGID; 589 return (0); 590 } 591 592 /* 593 * Vnode op for reading. 594 */ 595 /* ARGSUSED */ 596 ufs_read(vp, uio, ioflag, cred) 597 struct vnode *vp; 598 register struct uio *uio; 599 int ioflag; 600 struct ucred *cred; 601 { 602 register struct inode *ip = VTOI(vp); 603 register struct fs *fs; 604 struct buf *bp; 605 daddr_t lbn, bn, rablock; 606 int size, diff, error = 0; 607 long n, on, type; 608 609 if (uio->uio_rw != UIO_READ) 610 panic("ufs_read mode"); 611 type = ip->i_mode & IFMT; 612 if (type != IFDIR && type != IFREG && type != IFLNK) 613 panic("ufs_read type"); 614 if (uio->uio_resid == 0) 615 return (0); 616 if (uio->uio_offset < 0) 617 return (EINVAL); 618 ip->i_flag |= IACC; 619 fs = ip->i_fs; 620 do { 621 lbn = lblkno(fs, uio->uio_offset); 622 on = blkoff(fs, uio->uio_offset); 623 n = MIN((unsigned)(fs->fs_bsize - on), uio->uio_resid); 624 diff = ip->i_size - uio->uio_offset; 625 if (diff <= 0) 626 return (0); 627 if (diff < n) 628 n = diff; 629 size = blksize(fs, ip, lbn); 630 rablock = lbn + 1; 631 if (vp->v_lastr + 1 == lbn && 632 lblktosize(fs, rablock) < ip->i_size) 633 error = breada(ITOV(ip), lbn, size, rablock, 634 blksize(fs, ip, rablock), NOCRED, &bp); 635 else 636 error = bread(ITOV(ip), lbn, size, NOCRED, &bp); 637 vp->v_lastr = lbn; 638 n = MIN(n, size - bp->b_resid); 639 if (error) { 640 brelse(bp); 641 return (error); 642 } 643 error = uiomove(bp->b_un.b_addr + on, (int)n, uio); 644 if (n + on == fs->fs_bsize || uio->uio_offset == ip->i_size) 645 bp->b_flags |= B_AGE; 646 brelse(bp); 647 } while (error == 0 && uio->uio_resid > 0 && n != 0); 648 return (error); 649 } 650 651 /* 652 * Vnode op for writing. 653 */ 654 ufs_write(vp, uio, ioflag, cred) 655 register struct vnode *vp; 656 struct uio *uio; 657 int ioflag; 658 struct ucred *cred; 659 { 660 register struct inode *ip = VTOI(vp); 661 register struct fs *fs; 662 struct buf *bp; 663 daddr_t lbn, bn; 664 u_long osize; 665 int n, on, flags; 666 int size, resid, error = 0; 667 668 if (uio->uio_rw != UIO_WRITE) 669 panic("ufs_write mode"); 670 switch (vp->v_type) { 671 case VREG: 672 if (ioflag & IO_APPEND) 673 uio->uio_offset = ip->i_size; 674 /* fall through */ 675 case VLNK: 676 break; 677 678 case VDIR: 679 if ((ioflag & IO_SYNC) == 0) 680 panic("ufs_write nonsync dir write"); 681 break; 682 683 default: 684 panic("ufs_write type"); 685 } 686 if (uio->uio_offset < 0) 687 return (EINVAL); 688 if (uio->uio_resid == 0) 689 return (0); 690 /* 691 * Maybe this should be above the vnode op call, but so long as 692 * file servers have no limits, i don't think it matters 693 */ 694 if (vp->v_type == VREG && 695 uio->uio_offset + uio->uio_resid > 696 u.u_rlimit[RLIMIT_FSIZE].rlim_cur) { 697 psignal(u.u_procp, SIGXFSZ); 698 return (EFBIG); 699 } 700 resid = uio->uio_resid; 701 osize = ip->i_size; 702 fs = ip->i_fs; 703 flags = 0; 704 if (ioflag & IO_SYNC) 705 flags = B_SYNC; 706 do { 707 lbn = lblkno(fs, uio->uio_offset); 708 on = blkoff(fs, uio->uio_offset); 709 n = MIN((unsigned)(fs->fs_bsize - on), uio->uio_resid); 710 if (n < fs->fs_bsize) 711 flags |= B_CLRBUF; 712 else 713 flags &= ~B_CLRBUF; 714 if (error = balloc(ip, lbn, (int)(on + n), &bp, flags)) 715 break; 716 bn = bp->b_blkno; 717 if (uio->uio_offset + n > ip->i_size) { 718 ip->i_size = uio->uio_offset + n; 719 vnode_pager_setsize(vp, ip->i_size); 720 } 721 size = blksize(fs, ip, lbn); 722 (void) vnode_pager_uncache(vp); 723 n = MIN(n, size - bp->b_resid); 724 error = uiomove(bp->b_un.b_addr + on, n, uio); 725 if (ioflag & IO_SYNC) 726 (void) bwrite(bp); 727 else if (n + on == fs->fs_bsize) { 728 bp->b_flags |= B_AGE; 729 bawrite(bp); 730 } else 731 bdwrite(bp); 732 ip->i_flag |= IUPD|ICHG; 733 if (cred->cr_uid != 0) 734 ip->i_mode &= ~(ISUID|ISGID); 735 } while (error == 0 && uio->uio_resid > 0 && n != 0); 736 if (error && (ioflag & IO_UNIT)) { 737 (void) itrunc(ip, osize, ioflag & IO_SYNC); 738 uio->uio_offset -= resid - uio->uio_resid; 739 uio->uio_resid = resid; 740 } 741 if (!error && (ioflag & IO_SYNC)) 742 error = iupdat(ip, &time, &time, 1); 743 return (error); 744 } 745 746 /* ARGSUSED */ 747 ufs_ioctl(vp, com, data, fflag, cred) 748 struct vnode *vp; 749 int com; 750 caddr_t data; 751 int fflag; 752 struct ucred *cred; 753 { 754 755 return (ENOTTY); 756 } 757 758 /* ARGSUSED */ 759 ufs_select(vp, which, fflags, cred) 760 struct vnode *vp; 761 int which, fflags; 762 struct ucred *cred; 763 { 764 765 return (1); /* XXX */ 766 } 767 768 /* 769 * Mmap a file 770 * 771 * NB Currently unsupported. 772 */ 773 /* ARGSUSED */ 774 ufs_mmap(vp, fflags, cred) 775 struct vnode *vp; 776 int fflags; 777 struct ucred *cred; 778 { 779 780 return (EINVAL); 781 } 782 783 /* 784 * Synch an open file. 785 */ 786 /* ARGSUSED */ 787 ufs_fsync(vp, fflags, cred, waitfor) 788 struct vnode *vp; 789 int fflags; 790 struct ucred *cred; 791 int waitfor; 792 { 793 struct inode *ip = VTOI(vp); 794 795 if (fflags&FWRITE) 796 ip->i_flag |= ICHG; 797 vflushbuf(vp, waitfor == MNT_WAIT ? B_SYNC : 0); 798 return (iupdat(ip, &time, &time, waitfor == MNT_WAIT)); 799 } 800 801 /* 802 * Seek on a file 803 * 804 * Nothing to do, so just return. 805 */ 806 /* ARGSUSED */ 807 ufs_seek(vp, oldoff, newoff, cred) 808 struct vnode *vp; 809 off_t oldoff, newoff; 810 struct ucred *cred; 811 { 812 813 return (0); 814 } 815 816 /* 817 * ufs remove 818 * Hard to avoid races here, especially 819 * in unlinking directories. 820 */ 821 ufs_remove(ndp) 822 struct nameidata *ndp; 823 { 824 register struct inode *ip, *dp; 825 int error; 826 827 ip = VTOI(ndp->ni_vp); 828 dp = VTOI(ndp->ni_dvp); 829 error = dirremove(ndp); 830 if (!error) { 831 ip->i_nlink--; 832 ip->i_flag |= ICHG; 833 } 834 if (dp == ip) 835 vrele(ITOV(ip)); 836 else 837 iput(ip); 838 iput(dp); 839 return (error); 840 } 841 842 /* 843 * link vnode call 844 */ 845 ufs_link(vp, ndp) 846 register struct vnode *vp; 847 register struct nameidata *ndp; 848 { 849 register struct inode *ip = VTOI(vp); 850 int error; 851 852 if (ndp->ni_dvp != vp) 853 ILOCK(ip); 854 if (ip->i_nlink == LINK_MAX - 1) { 855 error = EMLINK; 856 goto out; 857 } 858 ip->i_nlink++; 859 ip->i_flag |= ICHG; 860 error = iupdat(ip, &time, &time, 1); 861 if (!error) 862 error = direnter(ip, ndp); 863 out: 864 if (ndp->ni_dvp != vp) 865 IUNLOCK(ip); 866 if (error) { 867 ip->i_nlink--; 868 ip->i_flag |= ICHG; 869 } 870 return (error); 871 } 872 873 /* 874 * Rename system call. 875 * rename("foo", "bar"); 876 * is essentially 877 * unlink("bar"); 878 * link("foo", "bar"); 879 * unlink("foo"); 880 * but ``atomically''. Can't do full commit without saving state in the 881 * inode on disk which isn't feasible at this time. Best we can do is 882 * always guarantee the target exists. 883 * 884 * Basic algorithm is: 885 * 886 * 1) Bump link count on source while we're linking it to the 887 * target. This also ensure the inode won't be deleted out 888 * from underneath us while we work (it may be truncated by 889 * a concurrent `trunc' or `open' for creation). 890 * 2) Link source to destination. If destination already exists, 891 * delete it first. 892 * 3) Unlink source reference to inode if still around. If a 893 * directory was moved and the parent of the destination 894 * is different from the source, patch the ".." entry in the 895 * directory. 896 */ 897 ufs_rename(fndp, tndp) 898 register struct nameidata *fndp, *tndp; 899 { 900 register struct inode *ip, *xp, *dp; 901 struct dirtemplate dirbuf; 902 int doingdirectory = 0, oldparent = 0, newparent = 0; 903 int error = 0; 904 905 dp = VTOI(fndp->ni_dvp); 906 ip = VTOI(fndp->ni_vp); 907 ILOCK(ip); 908 if ((ip->i_mode&IFMT) == IFDIR) { 909 register struct direct *d = &fndp->ni_dent; 910 911 /* 912 * Avoid ".", "..", and aliases of "." for obvious reasons. 913 */ 914 if ((d->d_namlen == 1 && d->d_name[0] == '.') || dp == ip || 915 fndp->ni_isdotdot || (ip->i_flag & IRENAME)) { 916 VOP_ABORTOP(tndp); 917 vput(tndp->ni_dvp); 918 if (tndp->ni_vp) 919 vput(tndp->ni_vp); 920 VOP_ABORTOP(fndp); 921 vrele(fndp->ni_dvp); 922 vput(fndp->ni_vp); 923 return (EINVAL); 924 } 925 ip->i_flag |= IRENAME; 926 oldparent = dp->i_number; 927 doingdirectory++; 928 } 929 vrele(fndp->ni_dvp); 930 931 /* 932 * 1) Bump link count while we're moving stuff 933 * around. If we crash somewhere before 934 * completing our work, the link count 935 * may be wrong, but correctable. 936 */ 937 ip->i_nlink++; 938 ip->i_flag |= ICHG; 939 error = iupdat(ip, &time, &time, 1); 940 IUNLOCK(ip); 941 942 /* 943 * When the target exists, both the directory 944 * and target vnodes are returned locked. 945 */ 946 dp = VTOI(tndp->ni_dvp); 947 xp = NULL; 948 if (tndp->ni_vp) 949 xp = VTOI(tndp->ni_vp); 950 /* 951 * If ".." must be changed (ie the directory gets a new 952 * parent) then the source directory must not be in the 953 * directory heirarchy above the target, as this would 954 * orphan everything below the source directory. Also 955 * the user must have write permission in the source so 956 * as to be able to change "..". We must repeat the call 957 * to namei, as the parent directory is unlocked by the 958 * call to checkpath(). 959 */ 960 if (oldparent != dp->i_number) 961 newparent = dp->i_number; 962 if (doingdirectory && newparent) { 963 VOP_LOCK(fndp->ni_vp); 964 error = ufs_access(fndp->ni_vp, VWRITE, tndp->ni_cred); 965 VOP_UNLOCK(fndp->ni_vp); 966 if (error) 967 goto bad; 968 tndp->ni_nameiop = RENAME | LOCKPARENT | LOCKLEAF | NOCACHE; 969 do { 970 dp = VTOI(tndp->ni_dvp); 971 if (xp != NULL) 972 iput(xp); 973 if (error = checkpath(ip, dp, tndp->ni_cred)) 974 goto out; 975 if (error = namei(tndp)) 976 goto out; 977 xp = NULL; 978 if (tndp->ni_vp) 979 xp = VTOI(tndp->ni_vp); 980 } while (dp != VTOI(tndp->ni_dvp)); 981 } 982 /* 983 * 2) If target doesn't exist, link the target 984 * to the source and unlink the source. 985 * Otherwise, rewrite the target directory 986 * entry to reference the source inode and 987 * expunge the original entry's existence. 988 */ 989 if (xp == NULL) { 990 if (dp->i_dev != ip->i_dev) 991 panic("rename: EXDEV"); 992 /* 993 * Account for ".." in new directory. 994 * When source and destination have the same 995 * parent we don't fool with the link count. 996 */ 997 if (doingdirectory && newparent) { 998 dp->i_nlink++; 999 dp->i_flag |= ICHG; 1000 error = iupdat(dp, &time, &time, 1); 1001 } 1002 if (error = direnter(ip, tndp)) 1003 goto out; 1004 } else { 1005 if (xp->i_dev != dp->i_dev || xp->i_dev != ip->i_dev) 1006 panic("rename: EXDEV"); 1007 /* 1008 * Short circuit rename(foo, foo). 1009 */ 1010 if (xp->i_number == ip->i_number) 1011 panic("rename: same file"); 1012 /* 1013 * If the parent directory is "sticky", then the user must 1014 * own the parent directory, or the destination of the rename, 1015 * otherwise the destination may not be changed (except by 1016 * root). This implements append-only directories. 1017 */ 1018 if ((dp->i_mode & ISVTX) && tndp->ni_cred->cr_uid != 0 && 1019 tndp->ni_cred->cr_uid != dp->i_uid && 1020 xp->i_uid != tndp->ni_cred->cr_uid) { 1021 error = EPERM; 1022 goto bad; 1023 } 1024 /* 1025 * Target must be empty if a directory 1026 * and have no links to it. 1027 * Also, insure source and target are 1028 * compatible (both directories, or both 1029 * not directories). 1030 */ 1031 if ((xp->i_mode&IFMT) == IFDIR) { 1032 if (!dirempty(xp, dp->i_number, tndp->ni_cred) || 1033 xp->i_nlink > 2) { 1034 error = ENOTEMPTY; 1035 goto bad; 1036 } 1037 if (!doingdirectory) { 1038 error = ENOTDIR; 1039 goto bad; 1040 } 1041 cache_purge(ITOV(dp)); 1042 } else if (doingdirectory) { 1043 error = EISDIR; 1044 goto bad; 1045 } 1046 if (error = dirrewrite(dp, ip, tndp)) 1047 goto bad; 1048 /* 1049 * If the target directory is in the same 1050 * directory as the source directory, 1051 * decrement the link count on the parent 1052 * of the target directory. 1053 */ 1054 if (doingdirectory && !newparent) { 1055 dp->i_nlink--; 1056 dp->i_flag |= ICHG; 1057 } 1058 vput(ITOV(dp)); 1059 /* 1060 * Adjust the link count of the target to 1061 * reflect the dirrewrite above. If this is 1062 * a directory it is empty and there are 1063 * no links to it, so we can squash the inode and 1064 * any space associated with it. We disallowed 1065 * renaming over top of a directory with links to 1066 * it above, as the remaining link would point to 1067 * a directory without "." or ".." entries. 1068 */ 1069 xp->i_nlink--; 1070 if (doingdirectory) { 1071 if (--xp->i_nlink != 0) 1072 panic("rename: linked directory"); 1073 error = itrunc(xp, (u_long)0, IO_SYNC); 1074 } 1075 xp->i_flag |= ICHG; 1076 iput(xp); 1077 xp = NULL; 1078 } 1079 1080 /* 1081 * 3) Unlink the source. 1082 */ 1083 fndp->ni_nameiop = DELETE | LOCKPARENT | LOCKLEAF; 1084 (void)namei(fndp); 1085 if (fndp->ni_vp != NULL) { 1086 xp = VTOI(fndp->ni_vp); 1087 dp = VTOI(fndp->ni_dvp); 1088 } else { 1089 if (fndp->ni_dvp != NULL) 1090 vput(fndp->ni_dvp); 1091 xp = NULL; 1092 dp = NULL; 1093 } 1094 /* 1095 * Ensure that the directory entry still exists and has not 1096 * changed while the new name has been entered. If the source is 1097 * a file then the entry may have been unlinked or renamed. In 1098 * either case there is no further work to be done. If the source 1099 * is a directory then it cannot have been rmdir'ed; its link 1100 * count of three would cause a rmdir to fail with ENOTEMPTY. 1101 * The IRENAME flag ensures that it cannot be moved by another 1102 * rename. 1103 */ 1104 if (xp != ip) { 1105 if (doingdirectory) 1106 panic("rename: lost dir entry"); 1107 } else { 1108 /* 1109 * If the source is a directory with a 1110 * new parent, the link count of the old 1111 * parent directory must be decremented 1112 * and ".." set to point to the new parent. 1113 */ 1114 if (doingdirectory && newparent) { 1115 dp->i_nlink--; 1116 dp->i_flag |= ICHG; 1117 error = vn_rdwr(UIO_READ, ITOV(xp), (caddr_t)&dirbuf, 1118 sizeof (struct dirtemplate), (off_t)0, 1119 UIO_SYSSPACE, IO_NODELOCKED, 1120 tndp->ni_cred, (int *)0); 1121 if (error == 0) { 1122 if (dirbuf.dotdot_namlen != 2 || 1123 dirbuf.dotdot_name[0] != '.' || 1124 dirbuf.dotdot_name[1] != '.') { 1125 dirbad(xp, 12, "rename: mangled dir"); 1126 } else { 1127 dirbuf.dotdot_ino = newparent; 1128 (void) vn_rdwr(UIO_WRITE, ITOV(xp), 1129 (caddr_t)&dirbuf, 1130 sizeof (struct dirtemplate), 1131 (off_t)0, UIO_SYSSPACE, 1132 IO_NODELOCKED|IO_SYNC, 1133 tndp->ni_cred, (int *)0); 1134 cache_purge(ITOV(dp)); 1135 } 1136 } 1137 } 1138 error = dirremove(fndp); 1139 if (!error) { 1140 xp->i_nlink--; 1141 xp->i_flag |= ICHG; 1142 } 1143 xp->i_flag &= ~IRENAME; 1144 } 1145 if (dp) 1146 vput(ITOV(dp)); 1147 if (xp) 1148 vput(ITOV(xp)); 1149 vrele(ITOV(ip)); 1150 return (error); 1151 1152 bad: 1153 if (xp) 1154 vput(ITOV(xp)); 1155 vput(ITOV(dp)); 1156 out: 1157 ip->i_nlink--; 1158 ip->i_flag |= ICHG; 1159 vrele(ITOV(ip)); 1160 return (error); 1161 } 1162 1163 /* 1164 * A virgin directory (no blushing please). 1165 */ 1166 struct dirtemplate mastertemplate = { 1167 0, 12, 1, ".", 1168 0, DIRBLKSIZ - 12, 2, ".." 1169 }; 1170 1171 /* 1172 * Mkdir system call 1173 */ 1174 ufs_mkdir(ndp, vap) 1175 struct nameidata *ndp; 1176 struct vattr *vap; 1177 { 1178 register struct inode *ip, *dp; 1179 struct inode *tip; 1180 struct vnode *dvp; 1181 struct dirtemplate dirtemplate; 1182 int error; 1183 int dmode; 1184 1185 dvp = ndp->ni_dvp; 1186 dp = VTOI(dvp); 1187 dmode = vap->va_mode&0777; 1188 dmode |= IFDIR; 1189 /* 1190 * Must simulate part of maknode here 1191 * in order to acquire the inode, but 1192 * not have it entered in the parent 1193 * directory. The entry is made later 1194 * after writing "." and ".." entries out. 1195 */ 1196 if (error = ialloc(dp, dirpref(dp->i_fs), dmode, ndp->ni_cred, &tip)) { 1197 iput(dp); 1198 return (error); 1199 } 1200 ip = tip; 1201 ip->i_uid = ndp->ni_cred->cr_uid; 1202 ip->i_gid = dp->i_gid; 1203 #ifdef QUOTA 1204 if ((error = getinoquota(ip)) || 1205 (error = chkiq(ip, 1, ndp->ni_cred, 0))) { 1206 ifree(ip, ip->i_number, dmode); 1207 iput(ip); 1208 iput(dp); 1209 return (error); 1210 } 1211 #endif 1212 ip->i_flag |= IACC|IUPD|ICHG; 1213 ip->i_mode = dmode; 1214 ITOV(ip)->v_type = VDIR; /* Rest init'd in iget() */ 1215 ip->i_nlink = 2; 1216 error = iupdat(ip, &time, &time, 1); 1217 1218 /* 1219 * Bump link count in parent directory 1220 * to reflect work done below. Should 1221 * be done before reference is created 1222 * so reparation is possible if we crash. 1223 */ 1224 dp->i_nlink++; 1225 dp->i_flag |= ICHG; 1226 error = iupdat(dp, &time, &time, 1); 1227 1228 /* 1229 * Initialize directory with "." 1230 * and ".." from static template. 1231 */ 1232 dirtemplate = mastertemplate; 1233 dirtemplate.dot_ino = ip->i_number; 1234 dirtemplate.dotdot_ino = dp->i_number; 1235 error = vn_rdwr(UIO_WRITE, ITOV(ip), (caddr_t)&dirtemplate, 1236 sizeof (dirtemplate), (off_t)0, UIO_SYSSPACE, 1237 IO_NODELOCKED|IO_SYNC, ndp->ni_cred, (int *)0); 1238 if (error) { 1239 dp->i_nlink--; 1240 dp->i_flag |= ICHG; 1241 goto bad; 1242 } 1243 if (DIRBLKSIZ > dp->i_fs->fs_fsize) { 1244 panic("mkdir: blksize"); /* XXX - should grow w/balloc() */ 1245 } else { 1246 ip->i_size = DIRBLKSIZ; 1247 ip->i_flag |= ICHG; 1248 } 1249 /* 1250 * Directory all set up, now 1251 * install the entry for it in 1252 * the parent directory. 1253 */ 1254 error = direnter(ip, ndp); 1255 dp = NULL; 1256 if (error) { 1257 ndp->ni_nameiop = LOOKUP | NOCACHE; 1258 error = namei(ndp); 1259 if (!error) { 1260 dp = VTOI(ndp->ni_vp); 1261 dp->i_nlink--; 1262 dp->i_flag |= ICHG; 1263 } 1264 } 1265 bad: 1266 /* 1267 * No need to do an explicit itrunc here, 1268 * vrele will do this for us because we set 1269 * the link count to 0. 1270 */ 1271 if (error) { 1272 ip->i_nlink = 0; 1273 ip->i_flag |= ICHG; 1274 iput(ip); 1275 } else 1276 ndp->ni_vp = ITOV(ip); 1277 if (dp) 1278 iput(dp); 1279 return (error); 1280 } 1281 1282 /* 1283 * Rmdir system call. 1284 */ 1285 ufs_rmdir(ndp) 1286 register struct nameidata *ndp; 1287 { 1288 register struct inode *ip, *dp; 1289 int error = 0; 1290 1291 ip = VTOI(ndp->ni_vp); 1292 dp = VTOI(ndp->ni_dvp); 1293 /* 1294 * No rmdir "." please. 1295 */ 1296 if (dp == ip) { 1297 vrele(ITOV(dp)); 1298 iput(ip); 1299 return (EINVAL); 1300 } 1301 /* 1302 * Verify the directory is empty (and valid). 1303 * (Rmdir ".." won't be valid since 1304 * ".." will contain a reference to 1305 * the current directory and thus be 1306 * non-empty.) 1307 */ 1308 if (ip->i_nlink != 2 || !dirempty(ip, dp->i_number, ndp->ni_cred)) { 1309 error = ENOTEMPTY; 1310 goto out; 1311 } 1312 /* 1313 * Delete reference to directory before purging 1314 * inode. If we crash in between, the directory 1315 * will be reattached to lost+found, 1316 */ 1317 if (error = dirremove(ndp)) 1318 goto out; 1319 dp->i_nlink--; 1320 dp->i_flag |= ICHG; 1321 cache_purge(ITOV(dp)); 1322 iput(dp); 1323 ndp->ni_dvp = NULL; 1324 /* 1325 * Truncate inode. The only stuff left 1326 * in the directory is "." and "..". The 1327 * "." reference is inconsequential since 1328 * we're quashing it. The ".." reference 1329 * has already been adjusted above. We've 1330 * removed the "." reference and the reference 1331 * in the parent directory, but there may be 1332 * other hard links so decrement by 2 and 1333 * worry about them later. 1334 */ 1335 ip->i_nlink -= 2; 1336 error = itrunc(ip, (u_long)0, IO_SYNC); 1337 cache_purge(ITOV(ip)); 1338 out: 1339 if (ndp->ni_dvp) 1340 iput(dp); 1341 iput(ip); 1342 return (error); 1343 } 1344 1345 /* 1346 * symlink -- make a symbolic link 1347 */ 1348 ufs_symlink(ndp, vap, target) 1349 struct nameidata *ndp; 1350 struct vattr *vap; 1351 char *target; 1352 { 1353 struct inode *ip; 1354 int error; 1355 1356 error = maknode(IFLNK | vap->va_mode, ndp, &ip); 1357 if (error) 1358 return (error); 1359 error = vn_rdwr(UIO_WRITE, ITOV(ip), target, strlen(target), (off_t)0, 1360 UIO_SYSSPACE, IO_NODELOCKED, ndp->ni_cred, (int *)0); 1361 iput(ip); 1362 return (error); 1363 } 1364 1365 /* 1366 * Vnode op for read and write 1367 */ 1368 ufs_readdir(vp, uio, cred, eofflagp) 1369 struct vnode *vp; 1370 register struct uio *uio; 1371 struct ucred *cred; 1372 int *eofflagp; 1373 { 1374 int count, lost, error; 1375 1376 count = uio->uio_resid; 1377 count &= ~(DIRBLKSIZ - 1); 1378 lost = uio->uio_resid - count; 1379 if (count < DIRBLKSIZ || (uio->uio_offset & (DIRBLKSIZ -1))) 1380 return (EINVAL); 1381 uio->uio_resid = count; 1382 uio->uio_iov->iov_len = count; 1383 error = ufs_read(vp, uio, 0, cred); 1384 uio->uio_resid += lost; 1385 if ((VTOI(vp)->i_size - uio->uio_offset) <= 0) 1386 *eofflagp = 1; 1387 else 1388 *eofflagp = 0; 1389 return (error); 1390 } 1391 1392 /* 1393 * Return target name of a symbolic link 1394 */ 1395 ufs_readlink(vp, uiop, cred) 1396 struct vnode *vp; 1397 struct uio *uiop; 1398 struct ucred *cred; 1399 { 1400 1401 return (ufs_read(vp, uiop, 0, cred)); 1402 } 1403 1404 /* 1405 * Ufs abort op, called after namei() when a CREATE/DELETE isn't actually 1406 * done. Nothing to do at the moment. 1407 */ 1408 /* ARGSUSED */ 1409 ufs_abortop(ndp) 1410 struct nameidata *ndp; 1411 { 1412 1413 return (0); 1414 } 1415 1416 /* 1417 * Lock an inode. 1418 */ 1419 ufs_lock(vp) 1420 struct vnode *vp; 1421 { 1422 register struct inode *ip = VTOI(vp); 1423 1424 ILOCK(ip); 1425 return (0); 1426 } 1427 1428 /* 1429 * Unlock an inode. 1430 */ 1431 ufs_unlock(vp) 1432 struct vnode *vp; 1433 { 1434 register struct inode *ip = VTOI(vp); 1435 1436 if (!(ip->i_flag & ILOCKED)) 1437 panic("ufs_unlock NOT LOCKED"); 1438 IUNLOCK(ip); 1439 return (0); 1440 } 1441 1442 /* 1443 * Check for a locked inode. 1444 */ 1445 ufs_islocked(vp) 1446 struct vnode *vp; 1447 { 1448 1449 if (VTOI(vp)->i_flag & ILOCKED) 1450 return (1); 1451 return (0); 1452 } 1453 1454 /* 1455 * Get access to bmap 1456 */ 1457 ufs_bmap(vp, bn, vpp, bnp) 1458 struct vnode *vp; 1459 daddr_t bn; 1460 struct vnode **vpp; 1461 daddr_t *bnp; 1462 { 1463 struct inode *ip = VTOI(vp); 1464 1465 if (vpp != NULL) 1466 *vpp = ip->i_devvp; 1467 if (bnp == NULL) 1468 return (0); 1469 return (bmap(ip, bn, bnp)); 1470 } 1471 1472 /* 1473 * Calculate the logical to physical mapping if not done already, 1474 * then call the device strategy routine. 1475 */ 1476 int checkoverlap = 0; 1477 1478 ufs_strategy(bp) 1479 register struct buf *bp; 1480 { 1481 register struct inode *ip = VTOI(bp->b_vp); 1482 struct vnode *vp; 1483 int error; 1484 1485 if (bp->b_vp->v_type == VBLK || bp->b_vp->v_type == VCHR) 1486 panic("ufs_strategy: spec"); 1487 if (bp->b_blkno == bp->b_lblkno) { 1488 if (error = bmap(ip, bp->b_lblkno, &bp->b_blkno)) 1489 return (error); 1490 if ((long)bp->b_blkno == -1) 1491 clrbuf(bp); 1492 } 1493 if ((long)bp->b_blkno == -1) { 1494 biodone(bp); 1495 return (0); 1496 } 1497 #ifdef DIAGNOSTIC 1498 if (checkoverlap) { 1499 register struct buf *ep; 1500 struct buf *ebp; 1501 daddr_t start, last; 1502 1503 ebp = &buf[nbuf]; 1504 start = bp->b_blkno; 1505 last = start + btodb(bp->b_bcount) - 1; 1506 for (ep = buf; ep < ebp; ep++) { 1507 if (ep == bp || (ep->b_flags & B_INVAL) || 1508 ep->b_vp == NULLVP) 1509 continue; 1510 if (VOP_BMAP(ep->b_vp, (daddr_t)0, &vp, (daddr_t)0)) 1511 continue; 1512 if (vp != ip->i_devvp) 1513 continue; 1514 /* look for overlap */ 1515 if (ep->b_bcount == 0 || ep->b_blkno > last || 1516 ep->b_blkno + btodb(ep->b_bcount) <= start) 1517 continue; 1518 vprint("Disk overlap", vp); 1519 printf("\tstart %d, end %d overlap start %d, end %d\n", 1520 start, last, ep->b_blkno, 1521 ep->b_blkno + btodb(ep->b_bcount) - 1); 1522 panic("Disk buffer overlap"); 1523 } 1524 } 1525 #endif /* DIAGNOSTIC */ 1526 vp = ip->i_devvp; 1527 bp->b_dev = vp->v_rdev; 1528 (*(vp->v_op->vn_strategy))(bp); 1529 return (0); 1530 } 1531 1532 /* 1533 * Print out the contents of an inode. 1534 */ 1535 ufs_print(vp) 1536 struct vnode *vp; 1537 { 1538 register struct inode *ip = VTOI(vp); 1539 1540 printf("tag VT_UFS, ino %d, on dev %d, %d", ip->i_number, 1541 major(ip->i_dev), minor(ip->i_dev)); 1542 #ifdef FIFO 1543 if (vp->v_type == VFIFO) 1544 fifo_printinfo(vp); 1545 #endif /* FIFO */ 1546 printf("%s\n", (ip->i_flag & ILOCKED) ? " (LOCKED)" : ""); 1547 if (ip->i_spare0 == 0) 1548 return; 1549 printf("\towner pid %d", ip->i_spare0); 1550 if (ip->i_spare1) 1551 printf(" waiting pid %d", ip->i_spare1); 1552 printf("\n"); 1553 } 1554 1555 /* 1556 * Read wrapper for special devices. 1557 */ 1558 ufsspec_read(vp, uio, ioflag, cred) 1559 struct vnode *vp; 1560 struct uio *uio; 1561 int ioflag; 1562 struct ucred *cred; 1563 { 1564 1565 /* 1566 * Set access flag. 1567 */ 1568 VTOI(vp)->i_flag |= IACC; 1569 return (spec_read(vp, uio, ioflag, cred)); 1570 } 1571 1572 /* 1573 * Write wrapper for special devices. 1574 */ 1575 ufsspec_write(vp, uio, ioflag, cred) 1576 struct vnode *vp; 1577 struct uio *uio; 1578 int ioflag; 1579 struct ucred *cred; 1580 { 1581 1582 /* 1583 * Set update and change flags. 1584 */ 1585 VTOI(vp)->i_flag |= IUPD|ICHG; 1586 return (spec_write(vp, uio, ioflag, cred)); 1587 } 1588 1589 /* 1590 * Close wrapper for special devices. 1591 * 1592 * Update the times on the inode then do device close. 1593 */ 1594 ufsspec_close(vp, fflag, cred) 1595 struct vnode *vp; 1596 int fflag; 1597 struct ucred *cred; 1598 { 1599 register struct inode *ip = VTOI(vp); 1600 1601 if (vp->v_usecount > 1 && !(ip->i_flag & ILOCKED)) 1602 ITIMES(ip, &time, &time); 1603 return (spec_close(vp, fflag, cred)); 1604 } 1605 1606 #ifdef FIFO 1607 /* 1608 * Read wrapper for fifo's 1609 */ 1610 ufsfifo_read(vp, uio, ioflag, cred) 1611 struct vnode *vp; 1612 struct uio *uio; 1613 int ioflag; 1614 struct ucred *cred; 1615 { 1616 1617 /* 1618 * Set access flag. 1619 */ 1620 VTOI(vp)->i_flag |= IACC; 1621 return (fifo_read(vp, uio, ioflag, cred)); 1622 } 1623 1624 /* 1625 * Write wrapper for fifo's. 1626 */ 1627 ufsfifo_write(vp, uio, ioflag, cred) 1628 struct vnode *vp; 1629 struct uio *uio; 1630 int ioflag; 1631 struct ucred *cred; 1632 { 1633 1634 /* 1635 * Set update and change flags. 1636 */ 1637 VTOI(vp)->i_flag |= IUPD|ICHG; 1638 return (fifo_write(vp, uio, ioflag, cred)); 1639 } 1640 1641 /* 1642 * Close wrapper for fifo's. 1643 * 1644 * Update the times on the inode then do device close. 1645 */ 1646 ufsfifo_close(vp, fflag, cred) 1647 struct vnode *vp; 1648 int fflag; 1649 struct ucred *cred; 1650 { 1651 register struct inode *ip = VTOI(vp); 1652 1653 if (vp->v_usecount > 1 && !(ip->i_flag & ILOCKED)) 1654 ITIMES(ip, &time, &time); 1655 return (fifo_close(vp, fflag, cred)); 1656 } 1657 #endif /* FIFO */ 1658 1659 /* 1660 * Make a new file. 1661 */ 1662 maknode(mode, ndp, ipp) 1663 int mode; 1664 register struct nameidata *ndp; 1665 struct inode **ipp; 1666 { 1667 register struct inode *ip; 1668 struct inode *tip; 1669 register struct inode *pdir = VTOI(ndp->ni_dvp); 1670 ino_t ipref; 1671 int error; 1672 1673 *ipp = 0; 1674 if ((mode & IFMT) == 0) 1675 mode |= IFREG; 1676 if ((mode & IFMT) == IFDIR) 1677 ipref = dirpref(pdir->i_fs); 1678 else 1679 ipref = pdir->i_number; 1680 if (error = ialloc(pdir, ipref, mode, ndp->ni_cred, &tip)) { 1681 iput(pdir); 1682 return (error); 1683 } 1684 ip = tip; 1685 ip->i_uid = ndp->ni_cred->cr_uid; 1686 ip->i_gid = pdir->i_gid; 1687 #ifdef QUOTA 1688 if ((error = getinoquota(ip)) || 1689 (error = chkiq(ip, 1, ndp->ni_cred, 0))) { 1690 ifree(ip, ip->i_number, mode); 1691 iput(ip); 1692 iput(pdir); 1693 return (error); 1694 } 1695 #endif 1696 ip->i_flag |= IACC|IUPD|ICHG; 1697 ip->i_mode = mode; 1698 ITOV(ip)->v_type = IFTOVT(mode); /* Rest init'd in iget() */ 1699 ip->i_nlink = 1; 1700 if ((ip->i_mode & ISGID) && !groupmember(ip->i_gid, ndp->ni_cred) && 1701 suser(ndp->ni_cred, NULL)) 1702 ip->i_mode &= ~ISGID; 1703 1704 /* 1705 * Make sure inode goes to disk before directory entry. 1706 */ 1707 if (error = iupdat(ip, &time, &time, 1)) 1708 goto bad; 1709 if (error = direnter(ip, ndp)) { 1710 pdir = NULL; 1711 goto bad; 1712 } 1713 *ipp = ip; 1714 return (0); 1715 1716 bad: 1717 /* 1718 * Write error occurred trying to update the inode 1719 * or the directory so must deallocate the inode. 1720 */ 1721 if (pdir) 1722 iput(pdir); 1723 ip->i_nlink = 0; 1724 ip->i_flag |= ICHG; 1725 iput(ip); 1726 return (error); 1727 } 1728 1729 /* 1730 * Advisory record locking support 1731 */ 1732 ufs_advlock(vp, id, op, fl, flags) 1733 struct vnode *vp; 1734 caddr_t id; 1735 int op; 1736 register struct flock *fl; 1737 int flags; 1738 { 1739 register struct inode *ip = VTOI(vp); 1740 register struct lockf *lock; 1741 off_t start, end; 1742 int error; 1743 1744 /* 1745 * Avoid the common case of unlocking when inode has no locks. 1746 */ 1747 if (ip->i_lockf == (struct lockf *)0) { 1748 if (op != F_SETLK) { 1749 fl->l_type = F_UNLCK; 1750 return (0); 1751 } 1752 } 1753 /* 1754 * Convert the flock structure into a start and end. 1755 */ 1756 switch (fl->l_whence) { 1757 1758 case SEEK_SET: 1759 case SEEK_CUR: 1760 /* 1761 * Caller is responsible for adding any necessary offset 1762 * when SEEK_CUR is used. 1763 */ 1764 start = fl->l_start; 1765 break; 1766 1767 case SEEK_END: 1768 start = ip->i_size + fl->l_start; 1769 break; 1770 1771 default: 1772 return (EINVAL); 1773 } 1774 if (start < 0) 1775 return (EINVAL); 1776 if (fl->l_len == 0) 1777 end = -1; 1778 else 1779 end = start + fl->l_len; 1780 /* 1781 * Create the lockf structure 1782 */ 1783 MALLOC(lock, struct lockf *, sizeof *lock, M_LOCKF, M_WAITOK); 1784 lock->lf_start = start; 1785 lock->lf_end = end; 1786 lock->lf_id = id; 1787 lock->lf_inode = ip; 1788 lock->lf_type = fl->l_type; 1789 lock->lf_next = (struct lockf *)0; 1790 lock->lf_block = (struct lockf *)0; 1791 lock->lf_flags = flags; 1792 /* 1793 * Do the requested operation. 1794 */ 1795 switch(op) { 1796 case F_SETLK: 1797 return (ufs_setlock(lock)); 1798 1799 case F_UNLCK: 1800 return (ufs_advunlock(lock)); 1801 1802 case F_GETLK: 1803 return (ufs_advgetlock(lock, fl)); 1804 1805 default: 1806 free(lock, M_LOCKF); 1807 return (EINVAL); 1808 } 1809 /* NOTREACHED */ 1810 } 1811 1812 /* 1813 * This variable controls the maximum number of processes that will 1814 * be checked in doing deadlock detection. 1815 */ 1816 int maxlockdepth = MAXDEPTH; 1817 1818 /* 1819 * Set a byte-range lock. 1820 */ 1821 ufs_setlock(lock) 1822 register struct lockf *lock; 1823 { 1824 register struct inode *ip = lock->lf_inode; 1825 register struct lockf *block; 1826 static char lockstr[] = "lockf"; 1827 int priority, error; 1828 1829 #ifdef LOCKF_DEBUG 1830 if (lockf_debug & 4) 1831 lf_print("ufs_setlock", lock); 1832 #endif /* LOCKF_DEBUG */ 1833 1834 /* 1835 * Set the priority 1836 */ 1837 priority = PLOCK; 1838 if ((lock->lf_type & F_WRLCK) == 0) 1839 priority += 4; 1840 priority |= PCATCH; 1841 /* 1842 * Scan lock list for this file looking for locks that would block us. 1843 */ 1844 while (block = lf_getblock(lock)) { 1845 /* 1846 * Free the structure and return if nonblocking. 1847 */ 1848 if ((lock->lf_flags & F_WAIT) == 0) { 1849 free(lock, M_LOCKF); 1850 return (EAGAIN); 1851 } 1852 /* 1853 * We are blocked. Since flock style locks cover 1854 * the whole file, there is no chance for deadlock. 1855 * For byte-range locks we must check for deadlock. 1856 * 1857 * Deadlock detection is done by looking through the 1858 * wait channels to see if there are any cycles that 1859 * involve us. MAXDEPTH is set just to make sure we 1860 * do not go off into neverland. 1861 */ 1862 if ((lock->lf_flags & F_POSIX) && 1863 (block->lf_flags & F_POSIX)) { 1864 register struct proc *wproc; 1865 register struct lockf *waitblock; 1866 int i = 0; 1867 1868 /* The block is waiting on something */ 1869 wproc = (struct proc *)block->lf_id; 1870 while (wproc->p_wchan && 1871 (wproc->p_wmesg == lockstr) && 1872 (i++ < maxlockdepth)) { 1873 waitblock = (struct lockf *)wproc->p_wchan; 1874 /* Get the owner of the blocking lock */ 1875 waitblock = waitblock->lf_next; 1876 if ((waitblock->lf_flags & F_POSIX) == 0) 1877 break; 1878 wproc = (struct proc *)waitblock->lf_id; 1879 if (wproc == (struct proc *)lock->lf_id) { 1880 free(lock, M_LOCKF); 1881 return (EDEADLK); 1882 } 1883 } 1884 } 1885 /* 1886 * Add our lock to the blocked 1887 * list and sleep until we're free. 1888 */ 1889 #ifdef LOCKF_DEBUG 1890 if (lockf_debug & 4) 1891 lf_print("ufs_advlock: blocking on", block); 1892 #endif /* LOCKF_DEBUG */ 1893 /* 1894 * Remember who blocked us (for deadlock detection) 1895 */ 1896 lock->lf_next = block; 1897 lf_addblock(block, lock); 1898 if (error = tsleep((caddr_t *)lock, priority, lockstr, 0)) { 1899 free(lock, M_LOCKF); 1900 return (error); 1901 } 1902 } 1903 /* 1904 * No blocks!! Add the lock. Note that addlock will 1905 * downgrade or upgrade any overlapping locks this 1906 * process already owns. 1907 */ 1908 #ifdef LOCKF_DEBUG 1909 if (lockf_debug & 4) 1910 lf_print("ufs_advlock: got the lock", lock); 1911 #endif /* LOCKF_DEBUG */ 1912 lf_addlock(lock); 1913 return (0); 1914 } 1915 1916 /* 1917 * Remove a byte-range lock on an inode. 1918 */ 1919 ufs_advunlock(lock) 1920 struct lockf *lock; 1921 { 1922 struct lockf *blocklist; 1923 1924 if (lock->lf_inode->i_lockf == (struct lockf *)0) 1925 return (0); 1926 #ifdef LOCKF_DEBUG 1927 if (lockf_debug & 4) 1928 lf_print("ufs_advunlock", lock); 1929 #endif /* LOCKF_DEBUG */ 1930 /* 1931 * Generally, find the lock (or an overlap to that lock) 1932 * and remove it (or shrink it), then wakeup anyone we can. 1933 */ 1934 blocklist = lf_remove(lock); 1935 FREE(lock, M_LOCKF); 1936 lf_wakelock(blocklist); 1937 return (0); 1938 } 1939 1940 /* 1941 * Return the blocking pid 1942 */ 1943 ufs_advgetlock(lock, fl) 1944 register struct lockf *lock; 1945 register struct flock *fl; 1946 { 1947 register struct lockf *block; 1948 off_t start, end; 1949 1950 #ifdef LOCKF_DEBUG 1951 if (lockf_debug & 4) 1952 lf_print("ufs_advgetlock", lock); 1953 #endif /* LOCKF_DEBUG */ 1954 1955 if (block = lf_getblock(lock)) { 1956 fl->l_type = block->lf_type; 1957 fl->l_whence = SEEK_SET; 1958 fl->l_start = block->lf_start; 1959 if (block->lf_end == -1) 1960 fl->l_len = 0; 1961 else 1962 fl->l_len = block->lf_end - block->lf_start; 1963 if (block->lf_flags & F_POSIX) 1964 fl->l_pid = ((struct proc *)(block->lf_id))->p_pid; 1965 else 1966 fl->l_pid = -1; 1967 } 1968 FREE(lock, M_LOCKF); 1969 return (0); 1970 } 1971