nfs_vnops.c revision 1.30
1 /* 2 * Copyright (c) 1989 The Regents of the University of California. 3 * All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Rick Macklem at The University of Guelph. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by the University of 19 * California, Berkeley and its contributors. 20 * 4. Neither the name of the University nor the names of its contributors 21 * may be used to endorse or promote products derived from this software 22 * without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 * 36 * from: @(#)nfs_vnops.c 7.60 (Berkeley) 5/24/91 37 * $Id: nfs_vnops.c,v 1.30 1994/04/25 03:50:21 cgd Exp $ 38 */ 39 40 /* 41 * vnode op calls for sun nfs version 2 42 */ 43 44 #include <sys/param.h> 45 #include <sys/proc.h> 46 #include <sys/kernel.h> 47 #include <sys/systm.h> 48 #include <sys/mount.h> 49 #include <sys/buf.h> 50 #include <sys/malloc.h> 51 #include <sys/mbuf.h> 52 #include <sys/conf.h> 53 #include <sys/namei.h> 54 #include <sys/vnode.h> 55 #include <sys/dir.h> 56 #include <sys/lockf.h> 57 #include <miscfs/specfs/specdev.h> /* XXX */ 58 #include <miscfs/fifofs/fifo.h> /* XXX */ 59 60 #include <nfs/nfsv2.h> 61 #include <nfs/nfs.h> 62 #include <nfs/nfsnode.h> 63 #include <nfs/nfsmount.h> 64 #include <nfs/xdr_subs.h> 65 #include <nfs/nfsm_subs.h> 66 #include <nfs/nfsiom.h> 67 68 #include <ufs/quota.h> 69 #include <ufs/inode.h> /* for IFTOVT */ 70 71 /* Defs */ 72 #define TRUE 1 73 #define FALSE 0 74 75 /* 76 * Global vfs data structures for nfs 77 */ 78 struct vnodeops nfsv2_vnodeops = { 79 nfs_lookup, /* lookup */ 80 nfs_create, /* create */ 81 nfs_mknod, /* mknod */ 82 nfs_open, /* open */ 83 nfs_close, /* close */ 84 nfs_access, /* access */ 85 nfs_getattr, /* getattr */ 86 nfs_setattr, /* setattr */ 87 nfs_read, /* read */ 88 nfs_write, /* write */ 89 nfs_ioctl, /* ioctl */ 90 nfs_select, /* select */ 91 nfs_mmap, /* mmap */ 92 nfs_fsync, /* fsync */ 93 nfs_seek, /* seek */ 94 nfs_remove, /* remove */ 95 nfs_link, /* link */ 96 nfs_rename, /* rename */ 97 nfs_mkdir, /* mkdir */ 98 nfs_rmdir, /* rmdir */ 99 nfs_symlink, /* symlink */ 100 nfs_readdir, /* readdir */ 101 nfs_readlink, /* readlink */ 102 nfs_abortop, /* abortop */ 103 nfs_inactive, /* inactive */ 104 nfs_reclaim, /* reclaim */ 105 nfs_lock, /* lock */ 106 nfs_unlock, /* unlock */ 107 nfs_bmap, /* bmap */ 108 nfs_strategy, /* strategy */ 109 nfs_print, /* print */ 110 nfs_islocked, /* islocked */ 111 nfs_advlock, /* advlock */ 112 }; 113 114 /* 115 * Special device vnode ops 116 */ 117 struct vnodeops spec_nfsv2nodeops = { 118 spec_lookup, /* lookup */ 119 spec_create, /* create */ 120 spec_mknod, /* mknod */ 121 spec_open, /* open */ 122 nfsspec_close, /* close */ 123 nfs_access, /* access */ 124 nfs_getattr, /* getattr */ 125 nfs_setattr, /* setattr */ 126 nfsspec_read, /* read */ 127 nfsspec_write, /* write */ 128 spec_ioctl, /* ioctl */ 129 spec_select, /* select */ 130 spec_mmap, /* mmap */ 131 spec_fsync, /* fsync */ 132 spec_seek, /* seek */ 133 spec_remove, /* remove */ 134 spec_link, /* link */ 135 spec_rename, /* rename */ 136 spec_mkdir, /* mkdir */ 137 spec_rmdir, /* rmdir */ 138 spec_symlink, /* symlink */ 139 spec_readdir, /* readdir */ 140 spec_readlink, /* readlink */ 141 spec_abortop, /* abortop */ 142 nfs_inactive, /* inactive */ 143 nfs_reclaim, /* reclaim */ 144 nfs_lock, /* lock */ 145 nfs_unlock, /* unlock */ 146 spec_bmap, /* bmap */ 147 spec_strategy, /* strategy */ 148 nfs_print, /* print */ 149 nfs_islocked, /* islocked */ 150 spec_advlock, /* advlock */ 151 }; 152 153 #ifdef FIFO 154 struct vnodeops fifo_nfsv2nodeops = { 155 fifo_lookup, /* lookup */ 156 fifo_create, /* create */ 157 fifo_mknod, /* mknod */ 158 fifo_open, /* open */ 159 nfsfifo_close, /* close */ 160 nfs_access, /* access */ 161 nfs_getattr, /* getattr */ 162 nfs_setattr, /* setattr */ 163 nfsfifo_read, /* read */ 164 nfsfifo_write, /* write */ 165 fifo_ioctl, /* ioctl */ 166 fifo_select, /* select */ 167 fifo_mmap, /* mmap */ 168 fifo_fsync, /* fsync */ 169 fifo_seek, /* seek */ 170 fifo_remove, /* remove */ 171 fifo_link, /* link */ 172 fifo_rename, /* rename */ 173 fifo_mkdir, /* mkdir */ 174 fifo_rmdir, /* rmdir */ 175 fifo_symlink, /* symlink */ 176 fifo_readdir, /* readdir */ 177 fifo_readlink, /* readlink */ 178 fifo_abortop, /* abortop */ 179 nfs_inactive, /* inactive */ 180 nfs_reclaim, /* reclaim */ 181 nfs_lock, /* lock */ 182 nfs_unlock, /* unlock */ 183 fifo_bmap, /* bmap */ 184 fifo_badop, /* strategy */ 185 nfs_print, /* print */ 186 nfs_islocked, /* islocked */ 187 fifo_advlock, /* advlock */ 188 }; 189 #endif /* FIFO */ 190 191 /* 192 * Global vars 193 */ 194 extern u_long nfs_procids[NFS_NPROCS]; 195 extern u_long nfs_prog, nfs_vers; 196 extern char nfsiobuf[MAXPHYS+NBPG]; 197 struct buf nfs_bqueue; /* Queue head for nfsiod's */ 198 struct proc *nfs_iodwant[NFS_MAXASYNCDAEMON]; 199 enum vtype ntov_type[7] = { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VNON }; 200 int nfs_numasync = 0; 201 202 /* 203 * nfs null call from vfs. 204 */ 205 nfs_null(vp, cred, p) 206 struct vnode *vp; 207 struct ucred *cred; 208 struct proc *p; 209 { 210 caddr_t bpos, dpos; 211 u_long xid; 212 int error = 0; 213 struct mbuf *mreq, *mrep, *md, *mb; 214 215 nfsm_reqhead(nfs_procids[NFSPROC_NULL], cred, 0); 216 nfsm_request(vp, NFSPROC_NULL, p, 0); 217 nfsm_reqdone; 218 return (error); 219 } 220 221 /* 222 * nfs access vnode op. 223 * Essentially just get vattr and then imitate iaccess() 224 */ 225 nfs_access(vp, mode, cred, p) 226 struct vnode *vp; 227 int mode; 228 register struct ucred *cred; 229 struct proc *p; 230 { 231 register struct vattr *vap; 232 register gid_t *gp; 233 struct vattr vattr; 234 register int i; 235 int error; 236 237 /* 238 * If you're the super-user, 239 * you always get access. 240 */ 241 if (cred->cr_uid == 0) 242 return (0); 243 vap = &vattr; 244 if (error = nfs_dogetattr(vp, vap, cred, 0, p)) 245 return (error); 246 /* 247 * Access check is based on only one of owner, group, public. 248 * If not owner, then check group. If not a member of the 249 * group, then check public access. 250 */ 251 if (cred->cr_uid != vap->va_uid) { 252 mode >>= 3; 253 gp = cred->cr_groups; 254 for (i = 0; i < cred->cr_ngroups; i++, gp++) 255 if (vap->va_gid == *gp) 256 goto found; 257 mode >>= 3; 258 found: 259 ; 260 } 261 return ((vap->va_mode & mode) == mode ? 0 : EACCES); 262 } 263 264 /* 265 * nfs open vnode op 266 * Just check to see if the type is ok 267 */ 268 /* ARGSUSED */ 269 nfs_open(vp, mode, cred, p) 270 struct vnode *vp; 271 int mode; 272 struct ucred *cred; 273 struct proc *p; 274 { 275 register enum vtype vtyp; 276 277 vtyp = vp->v_type; 278 if (vtyp == VREG || vtyp == VDIR || vtyp == VLNK) 279 return (0); 280 else 281 return (EACCES); 282 } 283 284 /* 285 * nfs close vnode op 286 * For reg files, invalidate any buffer cache entries. 287 */ 288 /* ARGSUSED */ 289 nfs_close(vp, fflags, cred, p) 290 register struct vnode *vp; 291 int fflags; 292 struct ucred *cred; 293 struct proc *p; 294 { 295 register struct nfsnode *np = VTONFS(vp); 296 int error = 0; 297 298 if (vp->v_type == VREG && (np->n_flag & NMODIFIED)) { 299 nfs_lock(vp); 300 np->n_flag &= ~NMODIFIED; 301 vinvalbuf(vp, TRUE); 302 np->n_attrstamp = 0; 303 if (np->n_flag & NWRITEERR) { 304 np->n_flag &= ~NWRITEERR; 305 error = np->n_error; 306 } 307 nfs_unlock(vp); 308 } 309 return (error); 310 } 311 312 /* 313 * nfs getattr call from vfs. 314 */ 315 nfs_getattr(vp, vap, cred, p) 316 register struct vnode *vp; 317 struct vattr *vap; 318 struct ucred *cred; 319 struct proc *p; 320 { 321 return (nfs_dogetattr(vp, vap, cred, 0, p)); 322 } 323 324 nfs_dogetattr(vp, vap, cred, tryhard, p) 325 register struct vnode *vp; 326 struct vattr *vap; 327 struct ucred *cred; 328 int tryhard; 329 struct proc *p; 330 { 331 register caddr_t cp; 332 register long t1; 333 caddr_t bpos, dpos; 334 u_long xid; 335 int error = 0; 336 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 337 struct nfsnode *np; 338 339 /* First look in the cache.. */ 340 /* cred == NOCRED when we are called by mountroot */ 341 if (cred != NOCRED && nfs_getattrcache(vp, vap) == 0) 342 return (0); 343 344 np = VTONFS(vp); 345 if (np->n_delayed_atime.ts_sec != VNOVAL || 346 np->n_delayed_mtime.ts_sec != VNOVAL) { 347 VATTR_NULL(vap); 348 error = nfs_setattr(vp, vap, cred, p); 349 bcopy((caddr_t)&np->n_vattr, (caddr_t)vap, sizeof(*vap)); 350 if ((np->n_flag & NMODIFIED) && (np->n_size > vap->va_size)) 351 vap->va_size = np->n_size; 352 return error; 353 } 354 nfsstats.rpccnt[NFSPROC_GETATTR]++; 355 nfsm_reqhead(nfs_procids[NFSPROC_GETATTR], cred, NFSX_FH); 356 nfsm_fhtom(vp); 357 nfsm_request(vp, NFSPROC_GETATTR, p, tryhard); 358 nfsm_loadattr(vp, vap); 359 nfsm_reqdone; 360 return (error); 361 } 362 363 /* 364 * nfs setattr call. 365 */ 366 nfs_setattr(vp, vap, cred, p) 367 register struct vnode *vp; 368 register struct vattr *vap; 369 struct ucred *cred; 370 struct proc *p; 371 { 372 register struct nfsv2_sattr *sp; 373 register caddr_t cp; 374 register long t1; 375 caddr_t bpos, dpos; 376 u_long xid; 377 int error = 0; 378 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 379 struct nfsnode *np = VTONFS(vp); 380 381 nfsstats.rpccnt[NFSPROC_SETATTR]++; 382 nfsm_reqhead(nfs_procids[NFSPROC_SETATTR], cred, NFSX_FH+NFSX_SATTR); 383 nfsm_fhtom(vp); 384 nfsm_build(sp, struct nfsv2_sattr *, NFSX_SATTR); 385 if (vap->va_mode == (u_short)VNOVAL) 386 sp->sa_mode = VNOVAL; 387 else 388 sp->sa_mode = vtonfs_mode(vp->v_type, vap->va_mode); 389 if (vap->va_uid == VNOVAL) 390 sp->sa_uid = VNOVAL; 391 else 392 sp->sa_uid = txdr_unsigned(vap->va_uid); 393 if (vap->va_gid == VNOVAL) 394 sp->sa_gid = VNOVAL; 395 else 396 sp->sa_gid = txdr_unsigned(vap->va_gid); 397 sp->sa_size = txdr_unsigned(vap->va_size); 398 /* jfw (at) ksr.com 6/2/93 */ 399 #if 0 /* bad assumption; Suns (at least) make full use of usec field */ 400 sp->sa_atime.tv_sec = txdr_unsigned(vap->va_atime.tv_sec); 401 sp->sa_atime.tv_usec = txdr_unsigned(vap->va_flags); 402 #else 403 if (vap->va_atime.ts_sec == VNOVAL && 404 np->n_delayed_atime.ts_sec != VNOVAL) { 405 txdr_time(&np->n_delayed_atime, &sp->sa_atime); 406 } else { 407 txdr_time(&vap->va_atime, &sp->sa_atime); 408 } 409 #endif 410 if (vap->va_mtime.ts_sec == VNOVAL && 411 np->n_delayed_mtime.ts_sec != VNOVAL) { 412 txdr_time(&np->n_delayed_mtime, &sp->sa_mtime); 413 } else { 414 txdr_time(&vap->va_mtime, &sp->sa_mtime); 415 } 416 np->n_delayed_atime.ts_sec = VNOVAL; 417 np->n_delayed_mtime.ts_sec = VNOVAL; 418 419 if (vap->va_size != VNOVAL || vap->va_mtime.ts_sec != VNOVAL || 420 vap->va_atime.ts_sec != VNOVAL) { 421 if (np->n_flag & NMODIFIED) { 422 np->n_flag &= ~NMODIFIED; 423 if (vap->va_size == 0) 424 vinvalbuf(vp, FALSE); 425 else 426 vinvalbuf(vp, TRUE); 427 np->n_attrstamp = 0; 428 } 429 } 430 nfsm_request(vp, NFSPROC_SETATTR, p, 1); 431 nfsm_loadattr(vp, (struct vattr *)0); 432 /* should we fill in any vap fields ?? */ 433 nfsm_reqdone; 434 return (error); 435 } 436 437 /* 438 * nfs lookup call, one step at a time... 439 * First look in cache 440 * If not found, unlock the directory nfsnode and do the rpc 441 */ 442 nfs_lookup(vp, ndp, p) 443 register struct vnode *vp; 444 register struct nameidata *ndp; 445 struct proc *p; 446 { 447 register struct vnode *vdp; 448 register u_long *tl; 449 register caddr_t cp; 450 register long t1, t2; 451 caddr_t bpos, dpos, cp2; 452 u_long xid; 453 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 454 struct vnode *newvp; 455 long len; 456 nfsv2fh_t *fhp; 457 struct nfsnode *np; 458 int lockparent, wantparent, flag, error = 0; 459 460 ndp->ni_dvp = vp; 461 ndp->ni_vp = NULL; 462 if (vp->v_type != VDIR) 463 return (ENOTDIR); 464 lockparent = ndp->ni_nameiop & LOCKPARENT; 465 flag = ndp->ni_nameiop & OPMASK; 466 wantparent = ndp->ni_nameiop & (LOCKPARENT|WANTPARENT); 467 if ((error = cache_lookup(ndp)) && error != ENOENT) { 468 struct vattr vattr; 469 int vpid; 470 471 vdp = ndp->ni_vp; 472 vpid = vdp->v_id; 473 /* 474 * See the comment starting `Step through' in ufs/ufs_lookup.c 475 * for an explanation of the locking protocol 476 */ 477 if (vp == vdp) { 478 VREF(vdp); 479 error = 0; 480 } else if (ndp->ni_isdotdot) { 481 nfs_unlock(vp); 482 error = vget(vdp, 1); 483 if (!error && lockparent && *ndp->ni_next == '\0') 484 nfs_lock(vp); 485 } else { 486 error = vget(vdp, 1); 487 if (!lockparent || error || *ndp->ni_next != '\0') 488 nfs_unlock(vp); 489 } 490 if (!error) { 491 if (vpid == vdp->v_id) { 492 if (!nfs_dogetattr(vdp, &vattr, ndp->ni_cred, 0, p)&& 493 vattr.va_ctime.ts_sec == VTONFS(vdp)->n_ctime) { 494 nfsstats.lookupcache_hits++; 495 if (flag != LOOKUP && *ndp->ni_next == 0) 496 ndp->ni_nameiop |= SAVENAME; 497 return (0); 498 } 499 cache_purge(vdp); 500 } 501 nfs_nput(vdp); 502 if (lockparent && vdp != vp && *ndp->ni_next == '\0') 503 nfs_unlock(vp); 504 } 505 ndp->ni_vp = NULLVP; 506 } else 507 nfs_unlock(vp); 508 error = 0; 509 nfsstats.lookupcache_misses++; 510 nfsstats.rpccnt[NFSPROC_LOOKUP]++; 511 len = ndp->ni_namelen; 512 nfsm_reqhead(nfs_procids[NFSPROC_LOOKUP], ndp->ni_cred, NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(len)); 513 nfsm_fhtom(vp); 514 nfsm_strtom(ndp->ni_ptr, len, NFS_MAXNAMLEN); 515 nfsm_request(vp, NFSPROC_LOOKUP, p, 0); 516 nfsmout: 517 if (error) { 518 if ((flag == CREATE || flag == RENAME) && 519 *ndp->ni_next == '\0' && error == ENOENT) 520 error = EJUSTRETURN; 521 if (lockparent || (flag != CREATE && flag != RENAME) || 522 *ndp->ni_next != 0) 523 nfs_lock(vp); 524 if (flag != LOOKUP && *ndp->ni_next == 0) 525 ndp->ni_nameiop |= SAVENAME; 526 return (error); 527 } 528 nfsm_disect(fhp,nfsv2fh_t *,NFSX_FH); 529 530 /* 531 * Handle DELETE and RENAME cases... 532 */ 533 if (flag == DELETE && *ndp->ni_next == 0) { 534 if (!bcmp(VTONFS(vp)->n_fh.fh_bytes, (caddr_t)fhp, NFSX_FH)) { 535 VREF(vp); 536 newvp = vp; 537 np = VTONFS(vp); 538 } else { 539 if (error = nfs_nget(vp->v_mount, fhp, &np)) { 540 nfs_lock(vp); 541 m_freem(mrep); 542 return (error); 543 } 544 newvp = NFSTOV(np); 545 } 546 if (error = 547 nfs_loadattrcache(&newvp, &md, &dpos, (struct vattr *)0)) { 548 nfs_lock(vp); 549 if (newvp != vp) 550 nfs_nput(newvp); 551 else 552 vrele(vp); 553 m_freem(mrep); 554 return (error); 555 } 556 ndp->ni_vp = newvp; 557 if (lockparent || vp == newvp) 558 nfs_lock(vp); 559 m_freem(mrep); 560 ndp->ni_nameiop |= SAVENAME; 561 return (0); 562 } 563 564 if (flag == RENAME && wantparent && *ndp->ni_next == 0) { 565 if (!bcmp(VTONFS(vp)->n_fh.fh_bytes, (caddr_t)fhp, NFSX_FH)) { 566 nfs_lock(vp); 567 m_freem(mrep); 568 return (EISDIR); 569 } 570 if (error = nfs_nget(vp->v_mount, fhp, &np)) { 571 nfs_lock(vp); 572 m_freem(mrep); 573 return (error); 574 } 575 newvp = NFSTOV(np); 576 if (error = 577 nfs_loadattrcache(&newvp, &md, &dpos, (struct vattr *)0)) { 578 nfs_lock(vp); 579 nfs_nput(newvp); 580 m_freem(mrep); 581 return (error); 582 } 583 ndp->ni_vp = newvp; 584 if (lockparent) 585 nfs_lock(vp); 586 m_freem(mrep); 587 ndp->ni_nameiop |= SAVENAME; 588 return (0); 589 } 590 591 if (!bcmp(VTONFS(vp)->n_fh.fh_bytes, (caddr_t)fhp, NFSX_FH)) { 592 VREF(vp); 593 newvp = vp; 594 np = VTONFS(vp); 595 } else if (ndp->ni_isdotdot) { 596 if (error = nfs_nget(vp->v_mount, fhp, &np)) { 597 nfs_lock(vp); 598 m_freem(mrep); 599 return (error); 600 } 601 newvp = NFSTOV(np); 602 } else { 603 if (error = nfs_nget(vp->v_mount, fhp, &np)) { 604 nfs_lock(vp); 605 m_freem(mrep); 606 return (error); 607 } 608 newvp = NFSTOV(np); 609 } 610 if (error = nfs_loadattrcache(&newvp, &md, &dpos, (struct vattr *)0)) { 611 nfs_lock(vp); 612 if (newvp != vp) 613 nfs_nput(newvp); 614 else 615 vrele(vp); 616 m_freem(mrep); 617 return (error); 618 } 619 m_freem(mrep); 620 621 if (vp == newvp || (lockparent && *ndp->ni_next == '\0')) 622 nfs_lock(vp); 623 ndp->ni_vp = newvp; 624 if (flag != LOOKUP && *ndp->ni_next == 0) 625 ndp->ni_nameiop |= SAVENAME; 626 if (error == 0 && ndp->ni_makeentry) { 627 np->n_ctime = np->n_vattr.va_ctime.ts_sec; 628 cache_enter(ndp); 629 } 630 return (error); 631 } 632 633 /* 634 * nfs read call. 635 * Just call nfs_bioread() to do the work. 636 */ 637 nfs_read(vp, uiop, ioflag, cred) 638 register struct vnode *vp; 639 struct uio *uiop; 640 int ioflag; 641 struct ucred *cred; 642 { 643 if (vp->v_type != VREG) 644 return (EPERM); 645 return (nfs_bioread(vp, uiop, ioflag, cred)); 646 } 647 648 /* 649 * nfs readlink call 650 */ 651 nfs_readlink(vp, uiop, cred) 652 struct vnode *vp; 653 struct uio *uiop; 654 struct ucred *cred; 655 { 656 if (vp->v_type != VLNK) 657 return (EPERM); 658 return (nfs_bioread(vp, uiop, 0, cred)); 659 } 660 661 /* 662 * Do a readlink rpc. 663 * Called by nfs_doio() from below the buffer cache. 664 */ 665 nfs_readlinkrpc(vp, uiop, cred) 666 register struct vnode *vp; 667 struct uio *uiop; 668 struct ucred *cred; 669 { 670 register u_long *tl; 671 register caddr_t cp; 672 register long t1; 673 caddr_t bpos, dpos, cp2; 674 u_long xid; 675 int error = 0; 676 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 677 long len; 678 679 nfsstats.rpccnt[NFSPROC_READLINK]++; 680 nfsm_reqhead(nfs_procids[NFSPROC_READLINK], cred, NFSX_FH); 681 nfsm_fhtom(vp); 682 nfsm_request(vp, NFSPROC_READLINK, uiop->uio_procp, 0); 683 nfsm_strsiz(len, NFS_MAXPATHLEN); 684 nfsm_mtouio(uiop, len); 685 nfsm_reqdone; 686 return (error); 687 } 688 689 /* 690 * nfs read rpc call 691 * Ditto above 692 */ 693 nfs_readrpc(vp, uiop, cred) 694 register struct vnode *vp; 695 struct uio *uiop; 696 struct ucred *cred; 697 { 698 register u_long *tl; 699 register caddr_t cp; 700 register long t1; 701 caddr_t bpos, dpos, cp2; 702 u_long xid; 703 int error = 0; 704 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 705 struct nfsmount *nmp; 706 long len, retlen, tsiz; 707 708 nmp = VFSTONFS(vp->v_mount); 709 tsiz = uiop->uio_resid; 710 while (tsiz > 0) { 711 nfsstats.rpccnt[NFSPROC_READ]++; 712 len = (tsiz > nmp->nm_rsize) ? nmp->nm_rsize : tsiz; 713 nfsm_reqhead(nfs_procids[NFSPROC_READ], cred, NFSX_FH+NFSX_UNSIGNED*3); 714 nfsm_fhtom(vp); 715 nfsm_build(tl, u_long *, NFSX_UNSIGNED*3); 716 *tl++ = txdr_unsigned(uiop->uio_offset); 717 *tl++ = txdr_unsigned(len); 718 *tl = 0; 719 nfsm_request(vp, NFSPROC_READ, uiop->uio_procp, 1); 720 nfsm_loadattr(vp, (struct vattr *)0); 721 nfsm_strsiz(retlen, nmp->nm_rsize); 722 nfsm_mtouio(uiop, retlen); 723 m_freem(mrep); 724 if (retlen < len) 725 tsiz = 0; 726 else 727 tsiz -= len; 728 } 729 nfsmout: 730 return (error); 731 } 732 733 /* 734 * nfs write call 735 */ 736 nfs_writerpc(vp, uiop, cred) 737 register struct vnode *vp; 738 struct uio *uiop; 739 struct ucred *cred; 740 { 741 register u_long *tl; 742 register caddr_t cp; 743 register long t1; 744 caddr_t bpos, dpos; 745 u_long xid; 746 int error = 0; 747 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 748 struct nfsmount *nmp; 749 long len, tsiz; 750 751 nmp = VFSTONFS(vp->v_mount); 752 tsiz = uiop->uio_resid; 753 while (tsiz > 0) { 754 nfsstats.rpccnt[NFSPROC_WRITE]++; 755 len = (tsiz > nmp->nm_wsize) ? nmp->nm_wsize : tsiz; 756 nfsm_reqhead(nfs_procids[NFSPROC_WRITE], cred, 757 NFSX_FH+NFSX_UNSIGNED*4); 758 nfsm_fhtom(vp); 759 nfsm_build(tl, u_long *, NFSX_UNSIGNED*4); 760 *(tl+1) = txdr_unsigned(uiop->uio_offset); 761 *(tl+3) = txdr_unsigned(len); 762 nfsm_uiotom(uiop, len); 763 nfsm_request(vp, NFSPROC_WRITE, uiop->uio_procp, 1); 764 nfsm_loadattr(vp, (struct vattr *)0); 765 m_freem(mrep); 766 tsiz -= len; 767 } 768 nfsmout: 769 return (error); 770 } 771 772 /* 773 * nfs mknod call 774 * This is a kludge. Use a create rpc but with the IFMT bits of the mode 775 * set to specify the file type and the size field for rdev. 776 */ 777 /* ARGSUSED */ 778 nfs_mknod(ndp, vap, cred, p) 779 struct nameidata *ndp; 780 struct ucred *cred; 781 register struct vattr *vap; 782 struct proc *p; 783 { 784 register struct nfsv2_sattr *sp; 785 register u_long *tl; 786 register caddr_t cp; 787 register long t1, t2; 788 caddr_t bpos, dpos; 789 u_long xid; 790 int error = 0; 791 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 792 u_long rdev; 793 794 if (vap->va_type == VCHR || vap->va_type == VBLK) 795 rdev = txdr_unsigned(vap->va_rdev); 796 #ifdef FIFO 797 else if (vap->va_type == VFIFO) 798 rdev = 0xffffffff; 799 #endif /* FIFO */ 800 else { 801 VOP_ABORTOP(ndp); 802 vput(ndp->ni_dvp); 803 return (EOPNOTSUPP); 804 } 805 nfsstats.rpccnt[NFSPROC_CREATE]++; 806 nfsm_reqhead(nfs_procids[NFSPROC_CREATE], ndp->ni_cred, 807 NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(ndp->ni_namelen)+NFSX_SATTR); 808 nfsm_fhtom(ndp->ni_dvp); 809 nfsm_strtom(ndp->ni_ptr, ndp->ni_namelen, NFS_MAXNAMLEN); 810 nfsm_build(sp, struct nfsv2_sattr *, NFSX_SATTR); 811 sp->sa_mode = vtonfs_mode(vap->va_type, vap->va_mode); 812 sp->sa_uid = txdr_unsigned(ndp->ni_cred->cr_uid); 813 sp->sa_gid = txdr_unsigned(ndp->ni_cred->cr_gid); 814 sp->sa_size = rdev; 815 /* or should these be VNOVAL ?? */ 816 txdr_time(&vap->va_atime, &sp->sa_atime); 817 txdr_time(&vap->va_mtime, &sp->sa_mtime); 818 nfsm_request(ndp->ni_dvp, NFSPROC_CREATE, p, 1); 819 nfsm_reqdone; 820 FREE(ndp->ni_pnbuf, M_NAMEI); 821 VTONFS(ndp->ni_dvp)->n_flag |= NMODIFIED; 822 nfs_nput(ndp->ni_dvp); 823 return (error); 824 } 825 826 /* 827 * nfs file create call 828 */ 829 nfs_create(ndp, vap, p) 830 register struct nameidata *ndp; 831 register struct vattr *vap; 832 struct proc *p; 833 { 834 register struct nfsv2_sattr *sp; 835 register u_long *tl; 836 register caddr_t cp; 837 register long t1, t2; 838 caddr_t bpos, dpos, cp2; 839 u_long xid; 840 int error = 0; 841 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 842 843 nfsstats.rpccnt[NFSPROC_CREATE]++; 844 nfsm_reqhead(nfs_procids[NFSPROC_CREATE], ndp->ni_cred, 845 NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(ndp->ni_namelen)+NFSX_SATTR); 846 nfsm_fhtom(ndp->ni_dvp); 847 nfsm_strtom(ndp->ni_ptr, ndp->ni_namelen, NFS_MAXNAMLEN); 848 nfsm_build(sp, struct nfsv2_sattr *, NFSX_SATTR); 849 sp->sa_mode = vtonfs_mode(vap->va_type, vap->va_mode); 850 sp->sa_uid = txdr_unsigned(ndp->ni_cred->cr_uid); 851 sp->sa_gid = txdr_unsigned(ndp->ni_cred->cr_gid); 852 sp->sa_size = txdr_unsigned(0); 853 /* or should these be VNOVAL ?? */ 854 txdr_time(&vap->va_atime, &sp->sa_atime); 855 txdr_time(&vap->va_mtime, &sp->sa_mtime); 856 nfsm_request(ndp->ni_dvp, NFSPROC_CREATE, p, 1); 857 nfsm_mtofh(ndp->ni_dvp, ndp->ni_vp); 858 nfsm_reqdone; 859 FREE(ndp->ni_pnbuf, M_NAMEI); 860 VTONFS(ndp->ni_dvp)->n_flag |= NMODIFIED; 861 nfs_nput(ndp->ni_dvp); 862 return (error); 863 } 864 865 /* 866 * nfs file remove call 867 * To try and make nfs semantics closer to ufs semantics, a file that has 868 * other processes using the vnode is renamed instead of removed and then 869 * removed later on the last close. 870 * - If v_usecount > 1 871 * If a rename is not already in the works 872 * call nfs_sillyrename() to set it up 873 * else 874 * If link_count > 0 875 * do the remove rpc 876 * else 877 * do the remove rpc 878 */ 879 nfs_remove(ndp, p) 880 register struct nameidata *ndp; 881 struct proc *p; 882 { 883 register struct vnode *vp = ndp->ni_vp; 884 register struct nfsnode *np = VTONFS(ndp->ni_vp); 885 register u_long *tl; 886 register caddr_t cp; 887 register long t1, t2; 888 caddr_t bpos, dpos; 889 u_long xid; 890 int error = 0; 891 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 892 893 if (vp->v_usecount > 1) { 894 struct vattr va; 895 if (!np->n_sillyrename) 896 error = nfs_sillyrename(ndp, p); 897 else if (nfs_getattr(vp, &va, ndp->ni_cred, p) == 0 && 898 va.va_nlink > 1) 899 goto do_nfsremove; 900 } else { 901 do_nfsremove: 902 nfsstats.rpccnt[NFSPROC_REMOVE]++; 903 nfsm_reqhead(nfs_procids[NFSPROC_REMOVE], ndp->ni_cred, 904 NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(ndp->ni_namelen)); 905 nfsm_fhtom(ndp->ni_dvp); 906 nfsm_strtom(ndp->ni_ptr, ndp->ni_namelen, NFS_MAXNAMLEN); 907 nfsm_request(ndp->ni_dvp, NFSPROC_REMOVE, p, 1); 908 nfsm_reqdone; 909 FREE(ndp->ni_pnbuf, M_NAMEI); 910 VTONFS(ndp->ni_dvp)->n_flag |= NMODIFIED; 911 /* 912 * Kludge City: If the first reply to the remove rpc is lost.. 913 * the reply to the retransmitted request will be ENOENT 914 * since the file was in fact removed 915 * Therefore, we cheat and return success. 916 */ 917 if (error == ENOENT) 918 error = 0; 919 } 920 np->n_attrstamp = 0; 921 if (ndp->ni_dvp == vp) 922 vrele(vp); 923 else 924 nfs_nput(ndp->ni_dvp); 925 nfs_nput(vp); 926 return (error); 927 } 928 929 /* 930 * nfs file remove rpc called from nfs_inactive 931 */ 932 nfs_removeit(sp, p) 933 register struct sillyrename *sp; 934 struct proc *p; 935 { 936 register u_long *tl; 937 register caddr_t cp; 938 register long t1, t2; 939 caddr_t bpos, dpos; 940 u_long xid; 941 int error = 0; 942 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 943 944 nfsstats.rpccnt[NFSPROC_REMOVE]++; 945 nfsm_reqhead(nfs_procids[NFSPROC_REMOVE], sp->s_cred, 946 NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(sp->s_namlen)); 947 nfsm_fhtom(sp->s_dvp); 948 nfsm_strtom(sp->s_name, sp->s_namlen, NFS_MAXNAMLEN); 949 nfsm_request(sp->s_dvp, NFSPROC_REMOVE, p, 1); 950 nfsm_reqdone; 951 VTONFS(sp->s_dvp)->n_flag |= NMODIFIED; 952 return (error); 953 } 954 955 /* 956 * nfs file rename call 957 */ 958 nfs_rename(sndp, tndp, p) 959 register struct nameidata *sndp, *tndp; 960 struct proc *p; 961 { 962 register u_long *tl; 963 register caddr_t cp; 964 register long t1, t2; 965 caddr_t bpos, dpos; 966 u_long xid; 967 int error = 0; 968 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 969 struct vnode *fvp, *tdvp, *tvp; 970 971 /* Check for cross-device rename */ 972 fvp = sndp->ni_vp; 973 tdvp = tndp->ni_dvp; 974 tvp = tndp->ni_vp; 975 if ((fvp->v_mount != tdvp->v_mount) || 976 (tvp && (fvp->v_mount != tvp->v_mount))) { 977 error = EXDEV; 978 goto out; 979 } 980 981 nfsstats.rpccnt[NFSPROC_RENAME]++; 982 nfsm_reqhead(nfs_procids[NFSPROC_RENAME], tndp->ni_cred, 983 (NFSX_FH+NFSX_UNSIGNED)*2+nfsm_rndup(sndp->ni_namelen) + 984 nfsm_rndup(tndp->ni_namelen)); /* or sndp->ni_cred?*/ 985 nfsm_fhtom(sndp->ni_dvp); 986 nfsm_strtom(sndp->ni_ptr, sndp->ni_namelen, NFS_MAXNAMLEN); 987 nfsm_fhtom(tndp->ni_dvp); 988 nfsm_strtom(tndp->ni_ptr, tndp->ni_namelen, NFS_MAXNAMLEN); 989 nfsm_request(sndp->ni_dvp, NFSPROC_RENAME, p, 1); 990 nfsm_reqdone; 991 VTONFS(sndp->ni_dvp)->n_flag |= NMODIFIED; 992 VTONFS(tndp->ni_dvp)->n_flag |= NMODIFIED; 993 if (sndp->ni_vp->v_type == VDIR) { 994 if (tndp->ni_vp != NULL && tndp->ni_vp->v_type == VDIR) 995 cache_purge(tndp->ni_dvp); 996 cache_purge(sndp->ni_dvp); 997 } 998 999 out: 1000 if (tndp->ni_dvp == tndp->ni_vp) 1001 vrele(tndp->ni_dvp); 1002 else 1003 vput(tndp->ni_dvp); 1004 if (tndp->ni_vp) 1005 vput(tndp->ni_vp); 1006 vrele(sndp->ni_dvp); 1007 vrele(sndp->ni_vp); 1008 /* 1009 * Kludge: Map ENOENT => 0 assuming that it is a reply to a retry. 1010 */ 1011 if (error == ENOENT) 1012 error = 0; 1013 return (error); 1014 } 1015 1016 /* 1017 * nfs file rename rpc called from nfs_remove() above 1018 */ 1019 nfs_renameit(sndp, sp, p) 1020 register struct nameidata *sndp; 1021 register struct sillyrename *sp; 1022 struct proc *p; 1023 { 1024 register u_long *tl; 1025 register caddr_t cp; 1026 register long t1, t2; 1027 caddr_t bpos, dpos; 1028 u_long xid; 1029 int error = 0; 1030 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 1031 1032 nfsstats.rpccnt[NFSPROC_RENAME]++; 1033 nfsm_reqhead(nfs_procids[NFSPROC_RENAME], sp->s_cred, 1034 (NFSX_FH+NFSX_UNSIGNED)*2+nfsm_rndup(sndp->ni_namelen) + 1035 nfsm_rndup(sp->s_namlen)); /* or sndp->ni_cred?*/ 1036 nfsm_fhtom(sndp->ni_dvp); 1037 nfsm_strtom(sndp->ni_ptr, sndp->ni_namelen, NFS_MAXNAMLEN); 1038 nfsm_fhtom(sp->s_dvp); 1039 nfsm_strtom(sp->s_name, sp->s_namlen, NFS_MAXNAMLEN); 1040 nfsm_request(sndp->ni_dvp, NFSPROC_RENAME, p, 1); 1041 nfsm_reqdone; 1042 FREE(sndp->ni_pnbuf, M_NAMEI); 1043 VTONFS(sndp->ni_dvp)->n_flag |= NMODIFIED; 1044 VTONFS(sp->s_dvp)->n_flag |= NMODIFIED; 1045 return (error); 1046 } 1047 1048 /* 1049 * nfs hard link create call 1050 */ 1051 nfs_link(vp, ndp, p) 1052 register struct vnode *vp; 1053 register struct nameidata *ndp; 1054 struct proc *p; 1055 { 1056 register u_long *tl; 1057 register caddr_t cp; 1058 register long t1, t2; 1059 caddr_t bpos, dpos; 1060 u_long xid; 1061 int error = 0; 1062 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 1063 1064 if (vp->v_mount != ndp->ni_dvp->v_mount) { 1065 VOP_ABORTOP(ndp); 1066 if (ndp->ni_dvp == ndp->ni_vp) 1067 vrele(ndp->ni_dvp); 1068 else 1069 vput(ndp->ni_dvp); 1070 if (ndp->ni_vp) 1071 vrele(ndp->ni_vp); 1072 return (EXDEV); 1073 } 1074 if (ndp->ni_dvp != vp) 1075 nfs_lock(vp); 1076 nfsstats.rpccnt[NFSPROC_LINK]++; 1077 nfsm_reqhead(nfs_procids[NFSPROC_LINK], ndp->ni_cred, 1078 NFSX_FH*2+NFSX_UNSIGNED+nfsm_rndup(ndp->ni_namelen)); 1079 nfsm_fhtom(vp); 1080 nfsm_fhtom(ndp->ni_dvp); 1081 nfsm_strtom(ndp->ni_ptr, ndp->ni_namelen, NFS_MAXNAMLEN); 1082 nfsm_request(vp, NFSPROC_LINK, p, 1); 1083 nfsm_reqdone; 1084 FREE(ndp->ni_pnbuf, M_NAMEI); 1085 VTONFS(vp)->n_attrstamp = 0; 1086 VTONFS(ndp->ni_dvp)->n_flag |= NMODIFIED; 1087 if (ndp->ni_dvp != vp) 1088 nfs_unlock(vp); 1089 nfs_nput(ndp->ni_dvp); 1090 /* 1091 * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry. 1092 */ 1093 if (error == EEXIST) 1094 error = 0; 1095 return (error); 1096 } 1097 1098 /* 1099 * nfs symbolic link create call 1100 */ 1101 nfs_symlink(ndp, vap, nm, p) 1102 struct nameidata *ndp; 1103 struct vattr *vap; 1104 char *nm; /* is this the path ?? */ 1105 struct proc *p; 1106 { 1107 register struct nfsv2_sattr *sp; 1108 register u_long *tl; 1109 register caddr_t cp; 1110 register long t1, t2; 1111 caddr_t bpos, dpos; 1112 u_long xid; 1113 int error = 0; 1114 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 1115 1116 nfsstats.rpccnt[NFSPROC_SYMLINK]++; 1117 nfsm_reqhead(nfs_procids[NFSPROC_SYMLINK], ndp->ni_cred, 1118 NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(ndp->ni_namelen)+NFSX_UNSIGNED); 1119 nfsm_fhtom(ndp->ni_dvp); 1120 nfsm_strtom(ndp->ni_ptr, ndp->ni_namelen, NFS_MAXNAMLEN); 1121 nfsm_strtom(nm, strlen(nm), NFS_MAXPATHLEN); 1122 nfsm_build(sp, struct nfsv2_sattr *, NFSX_SATTR); 1123 sp->sa_mode = vtonfs_mode(VLNK, vap->va_mode); 1124 sp->sa_uid = txdr_unsigned(ndp->ni_cred->cr_uid); 1125 sp->sa_gid = txdr_unsigned(ndp->ni_cred->cr_gid); 1126 sp->sa_size = txdr_unsigned(VNOVAL); 1127 txdr_time(&vap->va_atime, &sp->sa_atime); /* or VNOVAL ?? */ 1128 txdr_time(&vap->va_mtime, &sp->sa_mtime); /* or VNOVAL ?? */ 1129 nfsm_request(ndp->ni_dvp, NFSPROC_SYMLINK, p, 1); 1130 nfsm_reqdone; 1131 FREE(ndp->ni_pnbuf, M_NAMEI); 1132 VTONFS(ndp->ni_dvp)->n_flag |= NMODIFIED; 1133 nfs_nput(ndp->ni_dvp); 1134 /* 1135 * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry. 1136 */ 1137 if (error == EEXIST) 1138 error = 0; 1139 return (error); 1140 } 1141 1142 /* 1143 * nfs make dir call 1144 */ 1145 nfs_mkdir(ndp, vap, p) 1146 register struct nameidata *ndp; 1147 struct vattr *vap; 1148 struct proc *p; 1149 { 1150 register struct nfsv2_sattr *sp; 1151 register u_long *tl; 1152 register caddr_t cp; 1153 register long t1, t2; 1154 register int len; 1155 caddr_t bpos, dpos, cp2; 1156 u_long xid; 1157 int error = 0, firsttry = 1; 1158 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 1159 1160 len = ndp->ni_namelen; 1161 nfsstats.rpccnt[NFSPROC_MKDIR]++; 1162 nfsm_reqhead(nfs_procids[NFSPROC_MKDIR], ndp->ni_cred, 1163 NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(len)+NFSX_SATTR); 1164 nfsm_fhtom(ndp->ni_dvp); 1165 nfsm_strtom(ndp->ni_ptr, len, NFS_MAXNAMLEN); 1166 nfsm_build(sp, struct nfsv2_sattr *, NFSX_SATTR); 1167 sp->sa_mode = vtonfs_mode(VDIR, vap->va_mode); 1168 sp->sa_uid = txdr_unsigned(ndp->ni_cred->cr_uid); 1169 sp->sa_gid = txdr_unsigned(ndp->ni_cred->cr_gid); 1170 sp->sa_size = txdr_unsigned(VNOVAL); 1171 txdr_time(&vap->va_atime, &sp->sa_atime); /* or VNOVAL ?? */ 1172 txdr_time(&vap->va_mtime, &sp->sa_mtime); /* or VNOVAL ?? */ 1173 nfsm_request(ndp->ni_dvp, NFSPROC_MKDIR, p, 1); 1174 nfsm_mtofh(ndp->ni_dvp, ndp->ni_vp); 1175 nfsm_reqdone; 1176 VTONFS(ndp->ni_dvp)->n_flag |= NMODIFIED; 1177 /* 1178 * Kludge: Map EEXIST => 0 assuming that you have a reply to a retry 1179 * if we can succeed in looking up the directory. 1180 * "firsttry" is necessary since the macros may "goto nfsmout" which 1181 * is above the if on errors. (Ugh) 1182 */ 1183 if (error == EEXIST && firsttry) { 1184 firsttry = 0; 1185 error = 0; 1186 nfsstats.rpccnt[NFSPROC_LOOKUP]++; 1187 ndp->ni_vp = NULL; 1188 nfsm_reqhead(nfs_procids[NFSPROC_LOOKUP], ndp->ni_cred, 1189 NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(len)); 1190 nfsm_fhtom(ndp->ni_dvp); 1191 nfsm_strtom(ndp->ni_ptr, len, NFS_MAXNAMLEN); 1192 nfsm_request(ndp->ni_dvp, NFSPROC_LOOKUP, p, 1); 1193 nfsm_mtofh(ndp->ni_dvp, ndp->ni_vp); 1194 if (ndp->ni_vp->v_type != VDIR) { 1195 vput(ndp->ni_vp); 1196 error = EEXIST; 1197 } 1198 m_freem(mrep); 1199 } 1200 FREE(ndp->ni_pnbuf, M_NAMEI); 1201 nfs_nput(ndp->ni_dvp); 1202 return (error); 1203 } 1204 1205 /* 1206 * nfs remove directory call 1207 */ 1208 nfs_rmdir(ndp, p) 1209 register struct nameidata *ndp; 1210 struct proc *p; 1211 { 1212 register u_long *tl; 1213 register caddr_t cp; 1214 register long t1, t2; 1215 caddr_t bpos, dpos; 1216 u_long xid; 1217 int error = 0; 1218 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 1219 1220 if (ndp->ni_dvp == ndp->ni_vp) { 1221 vrele(ndp->ni_dvp); 1222 nfs_nput(ndp->ni_dvp); 1223 return (EINVAL); 1224 } 1225 nfsstats.rpccnt[NFSPROC_RMDIR]++; 1226 nfsm_reqhead(nfs_procids[NFSPROC_RMDIR], ndp->ni_cred, 1227 NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(ndp->ni_namelen)); 1228 nfsm_fhtom(ndp->ni_dvp); 1229 nfsm_strtom(ndp->ni_ptr, ndp->ni_namelen, NFS_MAXNAMLEN); 1230 nfsm_request(ndp->ni_dvp, NFSPROC_RMDIR, p, 1); 1231 nfsm_reqdone; 1232 FREE(ndp->ni_pnbuf, M_NAMEI); 1233 VTONFS(ndp->ni_dvp)->n_flag |= NMODIFIED; 1234 cache_purge(ndp->ni_dvp); 1235 cache_purge(ndp->ni_vp); 1236 nfs_nput(ndp->ni_vp); 1237 nfs_nput(ndp->ni_dvp); 1238 /* 1239 * Kludge: Map ENOENT => 0 assuming that you have a reply to a retry. 1240 */ 1241 if (error == ENOENT) 1242 error = 0; 1243 return (error); 1244 } 1245 1246 /* 1247 * nfs readdir call 1248 * Although cookie is defined as opaque, I translate it to/from net byte 1249 * order so that it looks more sensible. This appears consistent with the 1250 * Ultrix implementation of NFS. 1251 */ 1252 nfs_readdir(vp, uiop, cred, eofflagp, cookies, ncookies) 1253 register struct vnode *vp; 1254 struct uio *uiop; 1255 struct ucred *cred; 1256 int *eofflagp; 1257 u_int *cookies; 1258 int ncookies; 1259 { 1260 register struct nfsnode *np = VTONFS(vp); 1261 int tresid, error; 1262 struct vattr vattr; 1263 1264 /* 1265 * Since NFS mounting isn't propagated, 1266 * we don't need to handle cookies here! 1267 */ 1268 if (cookies) 1269 panic("nfs_readdir"); 1270 1271 if (vp->v_type != VDIR) 1272 return (EPERM); 1273 /* 1274 * First, check for hit on the EOF offset cache 1275 */ 1276 if (uiop->uio_offset != 0 && uiop->uio_offset == np->n_direofoffset && 1277 (np->n_flag & NMODIFIED) == 0 && 1278 nfs_dogetattr(vp, &vattr, cred, 0, uiop->uio_procp) == 0 && 1279 np->n_mtime == vattr.va_mtime.ts_sec) { 1280 *eofflagp = 1; 1281 nfsstats.direofcache_hits++; 1282 return (0); 1283 } 1284 1285 /* 1286 * Call nfs_bioread() to do the real work. 1287 */ 1288 tresid = uiop->uio_resid; 1289 error = nfs_bioread(vp, uiop, 0, cred); 1290 1291 if (!error && uiop->uio_resid == tresid) { 1292 *eofflagp = 1; 1293 nfsstats.direofcache_misses++; 1294 } else 1295 *eofflagp = 0; 1296 return (error); 1297 } 1298 1299 /* 1300 * Readdir rpc call. 1301 * Called from below the buffer cache by nfs_doio(). 1302 */ 1303 nfs_readdirrpc(vp, uiop, cred) 1304 register struct vnode *vp; 1305 struct uio *uiop; 1306 struct ucred *cred; 1307 { 1308 register long len; 1309 register struct dirent *dp; 1310 register u_long *tl; 1311 register caddr_t cp; 1312 register long t1; 1313 long tlen, lastlen; 1314 caddr_t bpos, dpos, cp2; 1315 u_long xid; 1316 int error = 0; 1317 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 1318 struct mbuf *md2; 1319 caddr_t dpos2; 1320 int siz; 1321 int more_dirs = 1; 1322 off_t off, savoff; 1323 struct dirent *savdp; 1324 struct nfsmount *nmp; 1325 struct nfsnode *np = VTONFS(vp); 1326 long tresid; 1327 1328 nmp = VFSTONFS(vp->v_mount); 1329 tresid = uiop->uio_resid; 1330 /* 1331 * Loop around doing readdir rpc's of size uio_resid or nm_rsize, 1332 * whichever is smaller, truncated to a multiple of NFS_DIRBLKSIZ. 1333 * The stopping criteria is EOF or buffer full. 1334 */ 1335 while (more_dirs && uiop->uio_resid >= NFS_DIRBLKSIZ) { 1336 nfsstats.rpccnt[NFSPROC_READDIR]++; 1337 nfsm_reqhead(nfs_procids[NFSPROC_READDIR], cred, xid); 1338 nfsm_fhtom(vp); 1339 nfsm_build(tl, u_long *, 2*NFSX_UNSIGNED); 1340 *tl++ = txdr_unsigned(uiop->uio_offset); 1341 *tl = txdr_unsigned(((uiop->uio_resid > nmp->nm_rsize) ? 1342 nmp->nm_rsize : uiop->uio_resid) & ~(NFS_DIRBLKSIZ-1)); 1343 nfsm_request(vp, NFSPROC_READDIR, uiop->uio_procp, 0); 1344 siz = 0; 1345 nfsm_disect(tl, u_long *, NFSX_UNSIGNED); 1346 more_dirs = fxdr_unsigned(int, *tl); 1347 1348 /* Save the position so that we can do nfsm_mtouio() later */ 1349 dpos2 = dpos; 1350 md2 = md; 1351 1352 /* loop thru the dir entries, doctoring them to 4bsd form */ 1353 off = uiop->uio_offset; 1354 #ifdef lint 1355 dp = (struct dirent *)0; 1356 #endif /* lint */ 1357 while (more_dirs && siz < uiop->uio_resid) { 1358 savoff = off; /* Hold onto offset and dp */ 1359 savdp = dp; 1360 nfsm_disecton(tl, u_long *, 2*NFSX_UNSIGNED); 1361 dp = (struct dirent *)tl; 1362 dp->d_fileno = fxdr_unsigned(u_long, *tl++); 1363 len = fxdr_unsigned(int, *tl); 1364 if (len <= 0 || len > NFS_MAXNAMLEN) { 1365 error = EBADRPC; 1366 m_freem(mrep); 1367 goto nfsmout; 1368 } 1369 dp->d_namlen = (u_short)len; 1370 nfsm_adv(len); /* Point past name */ 1371 tlen = nfsm_rndup(len); 1372 /* 1373 * This should not be necessary, but some servers have 1374 * broken XDR such that these bytes are not null filled. 1375 */ 1376 if (tlen != len) { 1377 *dpos = '\0'; /* Null-terminate */ 1378 nfsm_adv(tlen - len); 1379 len = tlen; 1380 } 1381 nfsm_disecton(tl, u_long *, 2*NFSX_UNSIGNED); 1382 off = fxdr_unsigned(off_t, *tl); 1383 *tl++ = 0; /* Ensures null termination of name */ 1384 more_dirs = fxdr_unsigned(int, *tl); 1385 dp->d_reclen = len+4*NFSX_UNSIGNED; 1386 siz += dp->d_reclen; 1387 } 1388 /* 1389 * If at end of rpc data, get the eof boolean 1390 */ 1391 if (!more_dirs) { 1392 nfsm_disecton(tl, u_long *, NFSX_UNSIGNED); 1393 more_dirs = (fxdr_unsigned(int, *tl) == 0); 1394 1395 /* 1396 * If at EOF, cache directory offset 1397 */ 1398 if (!more_dirs) 1399 np->n_direofoffset = off; 1400 } 1401 /* 1402 * If there is too much to fit in the data buffer, use savoff and 1403 * savdp to trim off the last record. 1404 * --> we are not at eof 1405 */ 1406 if (siz > uiop->uio_resid) { 1407 off = savoff; 1408 siz -= dp->d_reclen; 1409 dp = savdp; 1410 more_dirs = 0; /* Paranoia */ 1411 } 1412 if (siz > 0) { 1413 lastlen = dp->d_reclen; 1414 md = md2; 1415 dpos = dpos2; 1416 nfsm_mtouio(uiop, siz); 1417 uiop->uio_offset = off; 1418 } else 1419 more_dirs = 0; /* Ugh, never happens, but in case.. */ 1420 m_freem(mrep); 1421 } 1422 /* 1423 * Fill last record, iff any, out to a multiple of NFS_DIRBLKSIZ 1424 * by increasing d_reclen for the last record. 1425 */ 1426 if (uiop->uio_resid < tresid) { 1427 len = uiop->uio_resid & (NFS_DIRBLKSIZ - 1); 1428 if (len > 0) { 1429 dp = (struct dirent *) 1430 (uiop->uio_iov->iov_base - lastlen); 1431 dp->d_reclen += len; 1432 uiop->uio_iov->iov_base += len; 1433 uiop->uio_iov->iov_len -= len; 1434 uiop->uio_resid -= len; 1435 } 1436 } 1437 nfsmout: 1438 return (error); 1439 } 1440 1441 static char hextoasc[] = "0123456789abcdef"; 1442 1443 /* 1444 * Silly rename. To make the NFS filesystem that is stateless look a little 1445 * more like the "ufs" a remove of an active vnode is translated to a rename 1446 * to a funny looking filename that is removed by nfs_inactive on the 1447 * nfsnode. There is the potential for another process on a different client 1448 * to create the same funny name between the nfs_lookitup() fails and the 1449 * nfs_rename() completes, but... 1450 */ 1451 nfs_sillyrename(ndp, p) 1452 register struct nameidata *ndp; 1453 struct proc *p; 1454 { 1455 register struct nfsnode *np; 1456 register struct sillyrename *sp; 1457 int error; 1458 short pid; 1459 1460 np = VTONFS(ndp->ni_dvp); 1461 cache_purge(ndp->ni_dvp); 1462 MALLOC(sp, struct sillyrename *, sizeof (struct sillyrename), 1463 M_NFSREQ, M_WAITOK); 1464 bcopy((caddr_t)&np->n_fh, (caddr_t)&sp->s_fh, NFSX_FH); 1465 np = VTONFS(ndp->ni_vp); 1466 sp->s_cred = crdup(ndp->ni_cred); 1467 sp->s_dvp = ndp->ni_dvp; 1468 VREF(sp->s_dvp); 1469 1470 /* Fudge together a funny name */ 1471 pid = p->p_pid; 1472 bcopy(".nfsAxxxx4.4", sp->s_name, 13); 1473 sp->s_namlen = 12; 1474 sp->s_name[8] = hextoasc[pid & 0xf]; 1475 sp->s_name[7] = hextoasc[(pid >> 4) & 0xf]; 1476 sp->s_name[6] = hextoasc[(pid >> 8) & 0xf]; 1477 sp->s_name[5] = hextoasc[(pid >> 12) & 0xf]; 1478 1479 /* Try lookitups until we get one that isn't there */ 1480 while (nfs_lookitup(sp, (nfsv2fh_t *)0, p) == 0) { 1481 sp->s_name[4]++; 1482 if (sp->s_name[4] > 'z') { 1483 error = EINVAL; 1484 goto bad; 1485 } 1486 } 1487 if (error = nfs_renameit(ndp, sp, p)) 1488 goto bad; 1489 nfs_lookitup(sp, &np->n_fh, p); 1490 np->n_sillyrename = sp; 1491 return (0); 1492 bad: 1493 vrele(sp->s_dvp); 1494 crfree(sp->s_cred); 1495 free((caddr_t)sp, M_NFSREQ); 1496 return (error); 1497 } 1498 1499 /* 1500 * Look up a file name for silly rename stuff. 1501 * Just like nfs_lookup() except that it doesn't load returned values 1502 * into the nfsnode table. 1503 * If fhp != NULL it copies the returned file handle out 1504 */ 1505 nfs_lookitup(sp, fhp, p) 1506 register struct sillyrename *sp; 1507 nfsv2fh_t *fhp; 1508 struct proc *p; 1509 { 1510 register struct vnode *vp = sp->s_dvp; 1511 register u_long *tl; 1512 register caddr_t cp; 1513 register long t1, t2; 1514 caddr_t bpos, dpos, cp2; 1515 u_long xid; 1516 int error = 0; 1517 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 1518 long len; 1519 1520 nfsstats.rpccnt[NFSPROC_LOOKUP]++; 1521 len = sp->s_namlen; 1522 nfsm_reqhead(nfs_procids[NFSPROC_LOOKUP], sp->s_cred, NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(len)); 1523 nfsm_fhtom(vp); 1524 nfsm_strtom(sp->s_name, len, NFS_MAXNAMLEN); 1525 nfsm_request(vp, NFSPROC_LOOKUP, p, 1); 1526 if (fhp != NULL) { 1527 nfsm_disect(cp, caddr_t, NFSX_FH); 1528 bcopy(cp, (caddr_t)fhp, NFSX_FH); 1529 } 1530 nfsm_reqdone; 1531 return (error); 1532 } 1533 1534 /* 1535 * Kludge City.. 1536 * - make nfs_bmap() essentially a no-op that does no translation 1537 * - do nfs_strategy() by faking physical I/O with nfs_readrpc/nfs_writerpc 1538 * after mapping the physical addresses into Kernel Virtual space in the 1539 * nfsiobuf area. 1540 * (Maybe I could use the process's page mapping, but I was concerned that 1541 * Kernel Write might not be enabled and also figured copyout() would do 1542 * a lot more work than bcopy() and also it currently happens in the 1543 * context of the swapper process (2). 1544 */ 1545 nfs_bmap(vp, bn, vpp, bnp) 1546 struct vnode *vp; 1547 daddr_t bn; 1548 struct vnode **vpp; 1549 daddr_t *bnp; 1550 { 1551 if (vpp != NULL) 1552 *vpp = vp; 1553 if (bnp != NULL) 1554 *bnp = bn * btodb(vp->v_mount->mnt_stat.f_iosize); 1555 return (0); 1556 } 1557 1558 /* 1559 * Strategy routine for phys. i/o 1560 * If the biod's are running, queue a request 1561 * otherwise just call nfs_doio() to get it done 1562 */ 1563 nfs_strategy(bp) 1564 register struct buf *bp; 1565 { 1566 register struct buf *dp; 1567 register int i; 1568 int error = 0; 1569 int fnd = 0; 1570 1571 /* 1572 * Set b_proc. It seems a bit silly to do it here, but since bread() 1573 * doesn't set it, I will. 1574 * Set b_proc == NULL for asynchronous ops, since these may still 1575 * be hanging about after the process terminates. 1576 */ 1577 if ((bp->b_flags & B_PHYS) == 0) { 1578 if (bp->b_flags & B_ASYNC) 1579 bp->b_proc = (struct proc *)0; 1580 else 1581 bp->b_proc = curproc; 1582 } 1583 /* 1584 * If the op is asynchronous and an i/o daemon is waiting 1585 * queue the request, wake it up and wait for completion 1586 * otherwise just do it ourselves. 1587 */ 1588 if ((bp->b_flags & B_ASYNC) == 0 || nfs_numasync == 0) 1589 return (nfs_doio(bp)); 1590 for (i = 0; i < NFS_MAXASYNCDAEMON; i++) { 1591 if (nfs_iodwant[i]) { 1592 dp = &nfs_bqueue; 1593 bp->b_actf = NULL; 1594 bp->b_actb = dp->b_actb; 1595 *dp->b_actb = bp; 1596 dp->b_actb = &bp->b_actf; 1597 fnd++; 1598 wakeup((caddr_t)&nfs_iodwant[i]); 1599 break; 1600 } 1601 } 1602 if (!fnd) 1603 error = nfs_doio(bp); 1604 return (error); 1605 } 1606 1607 /* 1608 * Fun and games with i/o 1609 * 1610 * If the nfsiod's are not running, this is just called from nfs_strategy(), 1611 * otherwise it is called by the nfsiods to do what would normally be 1612 * partially disk interrupt driven. 1613 */ 1614 nfs_doio(bp) 1615 register struct buf *bp; 1616 { 1617 register struct uio *uiop; 1618 register struct vnode *vp; 1619 struct nfsnode *np; 1620 struct ucred *cr; 1621 int error; 1622 struct uio uio; 1623 struct iovec io; 1624 1625 vp = bp->b_vp; 1626 np = VTONFS(vp); 1627 uiop = &uio; 1628 uiop->uio_iov = &io; 1629 uiop->uio_iovcnt = 1; 1630 uiop->uio_segflg = UIO_SYSSPACE; 1631 /* 1632 * Not to worry, `b_proc' will have been set to NULL 1633 * for asynchronous IO. 1634 */ 1635 uiop->uio_procp = bp->b_proc; 1636 1637 /* 1638 * Always use credentials passed in the buffer header. 1639 */ 1640 if (bp->b_flags & B_PHYS) { 1641 #if 0 1642 /* 1643 * This cannot happen in the current (12/16/93) NetBSD kernel 1644 * Is this an artifact of the pager implementation in 1645 * previous incarnations of BSD ?? 1646 */ 1647 if (bp->b_flags & B_DIRTY) 1648 uiop->uio_procp = pageproc; 1649 #endif 1650 1651 /* mapping was already done by vmapbuf */ 1652 io.iov_base = bp->b_un.b_addr; 1653 io.iov_len = uiop->uio_resid = bp->b_bcount; 1654 uiop->uio_offset = bp->b_blkno * DEV_BSIZE; 1655 if (bp->b_flags & B_READ) { 1656 uiop->uio_rw = UIO_READ; 1657 nfsstats.read_physios++; 1658 bp->b_error = error = nfs_readrpc(vp, uiop, bp->b_rcred); 1659 } else { 1660 (void) vnode_pager_uncache(vp); 1661 uiop->uio_rw = UIO_WRITE; 1662 nfsstats.write_physios++; 1663 bp->b_error = error = nfs_writerpc(vp, uiop, bp->b_wcred); 1664 } 1665 1666 } else { 1667 if (bp->b_flags & B_READ) { 1668 io.iov_len = uiop->uio_resid = bp->b_bcount; 1669 io.iov_base = bp->b_un.b_addr; 1670 uiop->uio_rw = UIO_READ; 1671 switch (vp->v_type) { 1672 case VREG: 1673 uiop->uio_offset = bp->b_blkno * DEV_BSIZE; 1674 nfsstats.read_bios++; 1675 error = nfs_readrpc(vp, uiop, bp->b_rcred); 1676 break; 1677 case VLNK: 1678 uiop->uio_offset = 0; 1679 nfsstats.readlink_bios++; 1680 error = nfs_readlinkrpc(vp, uiop, bp->b_rcred); 1681 break; 1682 case VDIR: 1683 uiop->uio_offset = bp->b_lblkno; 1684 nfsstats.readdir_bios++; 1685 error = nfs_readdirrpc(vp, uiop, bp->b_rcred); 1686 /* 1687 * Save offset cookie in b_blkno. 1688 */ 1689 bp->b_blkno = uiop->uio_offset; 1690 break; 1691 }; 1692 bp->b_error = error; 1693 } else { 1694 io.iov_len = uiop->uio_resid = bp->b_dirtyend 1695 - bp->b_dirtyoff; 1696 uiop->uio_offset = (bp->b_blkno * DEV_BSIZE) 1697 + bp->b_dirtyoff; 1698 io.iov_base = bp->b_un.b_addr + bp->b_dirtyoff; 1699 uiop->uio_rw = UIO_WRITE; 1700 nfsstats.write_bios++; 1701 bp->b_error = error = nfs_writerpc(vp, uiop, 1702 bp->b_wcred); 1703 if (error) { 1704 np->n_error = error; 1705 np->n_flag |= NWRITEERR; 1706 } 1707 bp->b_dirtyoff = bp->b_dirtyend = 0; 1708 } 1709 } 1710 if (error) 1711 bp->b_flags |= B_ERROR; 1712 bp->b_resid = uiop->uio_resid; 1713 biodone(bp); 1714 return (error); 1715 } 1716 1717 /* 1718 * Mmap a file 1719 * 1720 * NB Currently unsupported. 1721 */ 1722 /* ARGSUSED */ 1723 nfs_mmap(vp, fflags, cred, p) 1724 struct vnode *vp; 1725 int fflags; 1726 struct ucred *cred; 1727 struct proc *p; 1728 { 1729 1730 return (EINVAL); 1731 } 1732 1733 /* 1734 * Flush all the blocks associated with a vnode. 1735 * Walk through the buffer pool and push any dirty pages 1736 * associated with the vnode. 1737 */ 1738 /* ARGSUSED */ 1739 nfs_fsync(vp, fflags, cred, waitfor, p) 1740 register struct vnode *vp; 1741 int fflags; 1742 struct ucred *cred; 1743 int waitfor; 1744 struct proc *p; 1745 { 1746 register struct nfsnode *np = VTONFS(vp); 1747 int error = 0; 1748 1749 if (np->n_flag & NMODIFIED) { 1750 np->n_flag &= ~NMODIFIED; 1751 vflushbuf(vp, waitfor == MNT_WAIT ? B_SYNC : 0); 1752 } 1753 if (!error && (np->n_flag & NWRITEERR)) 1754 error = np->n_error; 1755 return (error); 1756 } 1757 1758 /* 1759 * NFS advisory byte-level locks. 1760 * Currently unsupported. 1761 */ 1762 nfs_advlock(vp, id, op, fl, flags) 1763 struct vnode *vp; 1764 caddr_t id; 1765 int op; 1766 struct flock *fl; 1767 int flags; 1768 { 1769 register struct nfsnode *np = VTONFS(vp); 1770 1771 return (lf_advlock(&(np->n_lockf), np->n_size, id, op, fl, flags)); 1772 } 1773 1774 /* 1775 * Print out the contents of an nfsnode. 1776 */ 1777 int 1778 nfs_print(vp) 1779 struct vnode *vp; 1780 { 1781 register struct nfsnode *np = VTONFS(vp); 1782 1783 printf("tag VT_NFS, fileid %d fsid 0x%x", 1784 np->n_vattr.va_fileid, np->n_vattr.va_fsid); 1785 #ifdef FIFO 1786 if (vp->v_type == VFIFO) 1787 fifo_printinfo(vp); 1788 #endif /* FIFO */ 1789 printf("\n"); 1790 return (0); 1791 } 1792 1793 /* 1794 * Attribute cache routines. 1795 * nfs_loadattrcache() - loads or updates the cache contents from attributes 1796 * that are on the mbuf list 1797 * nfs_getattrcache() - returns valid attributes if found in cache, returns 1798 * error otherwise 1799 */ 1800 1801 /* 1802 * Load the attribute cache (that lives in the nfsnode entry) with 1803 * the values on the mbuf list and 1804 * Iff vap not NULL 1805 * copy the attributes to *vaper 1806 */ 1807 nfs_loadattrcache(vpp, mdp, dposp, vaper) 1808 struct vnode **vpp; 1809 struct mbuf **mdp; 1810 caddr_t *dposp; 1811 struct vattr *vaper; 1812 { 1813 register struct vnode *vp = *vpp; 1814 register struct vattr *vap; 1815 register struct nfsv2_fattr *fp; 1816 extern struct vnodeops spec_nfsv2nodeops; 1817 register struct nfsnode *np; 1818 register long t1; 1819 caddr_t dpos, cp2; 1820 int error = 0; 1821 struct mbuf *md; 1822 enum vtype type; 1823 u_short mode; 1824 long rdev; 1825 struct timespec mtime; 1826 struct vnode *nvp; 1827 1828 md = *mdp; 1829 dpos = *dposp; 1830 t1 = (mtod(md, caddr_t)+md->m_len)-dpos; 1831 if (error = nfsm_disct(&md, &dpos, NFSX_FATTR, t1, TRUE, &cp2)) 1832 return (error); 1833 fp = (struct nfsv2_fattr *)cp2; 1834 type = nfstov_type(fp->fa_type); 1835 mode = fxdr_unsigned(u_short, fp->fa_mode); 1836 if (type == VNON) 1837 type = IFTOVT(mode); 1838 rdev = fxdr_unsigned(long, fp->fa_rdev); 1839 fxdr_time(&fp->fa_mtime, &mtime); 1840 /* 1841 * If v_type == VNON it is a new node, so fill in the v_type, 1842 * n_mtime fields. Check to see if it represents a special 1843 * device, and if so, check for a possible alias. Once the 1844 * correct vnode has been obtained, fill in the rest of the 1845 * information. 1846 */ 1847 np = VTONFS(vp); 1848 if (vp->v_type == VNON) { 1849 if (type == VCHR && rdev == 0xffffffff) 1850 vp->v_type = type = VFIFO; 1851 else 1852 vp->v_type = type; 1853 if (vp->v_type == VFIFO) { 1854 #ifdef FIFO 1855 extern struct vnodeops fifo_nfsv2nodeops; 1856 vp->v_op = &fifo_nfsv2nodeops; 1857 #else 1858 return (EOPNOTSUPP); 1859 #endif /* FIFO */ 1860 } 1861 if (vp->v_type == VCHR || vp->v_type == VBLK) { 1862 vp->v_op = &spec_nfsv2nodeops; 1863 if (nvp = checkalias(vp, (dev_t)rdev, vp->v_mount)) { 1864 /* 1865 * Reinitialize aliased node. 1866 */ 1867 np = VTONFS(nvp); 1868 np->n_vnode = nvp; 1869 np->n_flag = 0; 1870 nfs_lock(nvp); 1871 bcopy((caddr_t)&VTONFS(vp)->n_fh, 1872 (caddr_t)&np->n_fh, NFSX_FH); 1873 insque(np, nfs_hash(&np->n_fh)); 1874 np->n_attrstamp = 0; 1875 np->n_sillyrename = (struct sillyrename *)0; 1876 /* 1877 * Discard unneeded vnode and update actual one 1878 */ 1879 vput(vp); 1880 *vpp = vp = nvp; 1881 } 1882 } 1883 np->n_mtime = mtime.ts_sec; 1884 } 1885 vap = &np->n_vattr; 1886 vap->va_type = type; 1887 vap->va_mode = (mode & 07777); 1888 vap->va_nlink = fxdr_unsigned(u_short, fp->fa_nlink); 1889 vap->va_uid = fxdr_unsigned(uid_t, fp->fa_uid); 1890 vap->va_gid = fxdr_unsigned(gid_t, fp->fa_gid); 1891 vap->va_size = fxdr_unsigned(u_long, fp->fa_size); 1892 if ((np->n_flag & NMODIFIED) == 0 || vap->va_size > np->n_size) { 1893 np->n_size = vap->va_size; 1894 vnode_pager_setsize(vp, np->n_size); 1895 } 1896 vap->va_blocksize = fxdr_unsigned(long, fp->fa_blocksize); 1897 vap->va_rdev = (dev_t)rdev; 1898 vap->va_bytes = fxdr_unsigned(long, fp->fa_blocks) * NFS_FABLKSIZE; 1899 vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0]; 1900 vap->va_fileid = fxdr_unsigned(long, fp->fa_fileid); 1901 /* jfw (at) ksr.com 6/2/93 */ 1902 #if 0 /* bad assumption; Suns make full (and obvious) use of .usec fields */ 1903 vap->va_atime.tv_sec = fxdr_unsigned(long, fp->fa_atime.tv_sec); 1904 vap->va_atime.tv_usec = 0; 1905 vap->va_flags = fxdr_unsigned(u_long, fp->fa_atime.tv_usec); 1906 vap->va_mtime = mtime; 1907 vap->va_ctime.tv_sec = fxdr_unsigned(long, fp->fa_ctime.tv_sec); 1908 vap->va_ctime.tv_usec = 0; 1909 vap->va_gen = fxdr_unsigned(u_long, fp->fa_ctime.tv_usec); 1910 #else 1911 fxdr_time(&fp->fa_atime, &vap->va_atime); 1912 vap->va_mtime = mtime; 1913 fxdr_time(&fp->fa_ctime, &vap->va_ctime); 1914 vap->va_gen = 0; /* can reliably learn nothing about this via NFS. */ 1915 vap->va_flags = 0; /* can reliably learn nothing about this via NFS. */ 1916 #endif 1917 np->n_attrstamp = time.tv_sec; 1918 *dposp = dpos; 1919 *mdp = md; 1920 if (vaper != NULL) { 1921 bcopy((caddr_t)vap, (caddr_t)vaper, sizeof(*vap)); 1922 if ((np->n_flag & NMODIFIED) && (np->n_size > vap->va_size)) 1923 vaper->va_size = np->n_size; 1924 } 1925 return (0); 1926 } 1927 1928 /* 1929 * Check the time stamp 1930 * If the cache is valid, copy contents to *vap and return 0 1931 * otherwise return an error 1932 */ 1933 nfs_getattrcache(vp, vap) 1934 register struct vnode *vp; 1935 struct vattr *vap; 1936 { 1937 register struct nfsnode *np; 1938 1939 np = VTONFS(vp); 1940 if ((time.tv_sec-np->n_attrstamp) < NFS_ATTRTIMEO) { 1941 nfsstats.attrcache_hits++; 1942 bcopy((caddr_t)&np->n_vattr,(caddr_t)vap,sizeof(struct vattr)); 1943 if ((np->n_flag & NMODIFIED) == 0) { 1944 np->n_size = vap->va_size; 1945 vnode_pager_setsize(vp, np->n_size); 1946 } else if (np->n_size > vap->va_size) 1947 vap->va_size = np->n_size; 1948 if (np->n_delayed_atime.ts_sec != VNOVAL) 1949 vap->va_atime = np->n_delayed_atime; 1950 if (np->n_delayed_mtime.ts_sec != VNOVAL) 1951 vap->va_mtime = np->n_delayed_mtime; 1952 return (0); 1953 } else { 1954 nfsstats.attrcache_misses++; 1955 return (ENOENT); 1956 } 1957 } 1958 1959 /* 1960 * Read wrapper for special devices. 1961 */ 1962 nfsspec_read(vp, uio, ioflag, cred) 1963 struct vnode *vp; 1964 struct uio *uio; 1965 int ioflag; 1966 struct ucred *cred; 1967 { 1968 /* 1969 * Set access time. 1970 */ 1971 TIMEVAL_TO_TIMESPEC(&time, &(VTONFS(vp)->n_delayed_atime)); 1972 return (spec_read(vp, uio, ioflag, cred)); 1973 } 1974 1975 /* 1976 * Write wrapper for special devices. 1977 */ 1978 nfsspec_write(vp, uio, ioflag, cred) 1979 struct vnode *vp; 1980 struct uio *uio; 1981 int ioflag; 1982 struct ucred *cred; 1983 { 1984 /* 1985 * Set change time. 1986 */ 1987 TIMEVAL_TO_TIMESPEC(&time, &(VTONFS(vp)->n_delayed_mtime)); 1988 return (spec_write(vp, uio, ioflag, cred)); 1989 } 1990 1991 /* 1992 * Close wrapper for special devices. 1993 * 1994 * Update the times then do device close. 1995 */ 1996 nfsspec_close(vp, fflag, cred, p) 1997 struct vnode *vp; 1998 int fflag; 1999 struct ucred *cred; 2000 struct proc *p; 2001 { 2002 if (VTONFS(vp)->n_delayed_mtime.ts_sec != VNOVAL || 2003 VTONFS(vp)->n_delayed_atime.ts_sec != VNOVAL) { 2004 struct vattr va; 2005 VATTR_NULL(&va); 2006 nfs_setattr(vp, &va, cred, p); 2007 } 2008 return (spec_close(vp, fflag, cred, p)); 2009 } 2010 2011 #ifdef FIFO 2012 /* 2013 * Read wrapper for special devices. 2014 */ 2015 nfsfifo_read(vp, uio, ioflag, cred) 2016 struct vnode *vp; 2017 struct uio *uio; 2018 int ioflag; 2019 struct ucred *cred; 2020 { 2021 /* 2022 * Set access time. 2023 */ 2024 TIMEVAL_TO_TIMESPEC(&time, &(VTONFS(vp)->n_delayed_atime)); 2025 return (fifo_read(vp, uio, ioflag, cred)); 2026 } 2027 2028 /* 2029 * Write wrapper for special devices. 2030 */ 2031 nfsfifo_write(vp, uio, ioflag, cred) 2032 struct vnode *vp; 2033 struct uio *uio; 2034 int ioflag; 2035 struct ucred *cred; 2036 { 2037 /* 2038 * Set change time. 2039 */ 2040 TIMEVAL_TO_TIMESPEC(&time, &(VTONFS(vp)->n_delayed_mtime)); 2041 return (fifo_write(vp, uio, ioflag, cred)); 2042 } 2043 2044 /* 2045 * Close wrapper for special devices. 2046 * 2047 * Update the times then do device close. 2048 */ 2049 nfsfifo_close(vp, fflag, cred, p) 2050 struct vnode *vp; 2051 int fflag; 2052 struct ucred *cred; 2053 struct proc *p; 2054 { 2055 if (VTONFS(vp)->n_delayed_mtime.ts_sec != VNOVAL || 2056 VTONFS(vp)->n_delayed_atime.ts_sec != VNOVAL) { 2057 struct vattr va; 2058 VATTR_NULL(&va); 2059 nfs_setattr(vp, &va, cred, p); 2060 } 2061 return (fifo_close(vp, fflag, cred, p)); 2062 } 2063 #endif /* FIFO */ 2064
Indexes created Tue Sep 23 14:10:03 GMT 2025