Annotation of sys/nfs/nfs_vnops.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: nfs_vnops.c,v 1.75 2007/06/01 23:47:57 deraadt Exp $ */
! 2: /* $NetBSD: nfs_vnops.c,v 1.62.4.1 1996/07/08 20:26:52 jtc Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1989, 1993
! 6: * The Regents of the University of California. All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to Berkeley by
! 9: * Rick Macklem at The University of Guelph.
! 10: *
! 11: * Redistribution and use in source and binary forms, with or without
! 12: * modification, are permitted provided that the following conditions
! 13: * are met:
! 14: * 1. Redistributions of source code must retain the above copyright
! 15: * notice, this list of conditions and the following disclaimer.
! 16: * 2. Redistributions in binary form must reproduce the above copyright
! 17: * notice, this list of conditions and the following disclaimer in the
! 18: * documentation and/or other materials provided with the distribution.
! 19: * 3. Neither the name of the University nor the names of its contributors
! 20: * may be used to endorse or promote products derived from this software
! 21: * without specific prior written permission.
! 22: *
! 23: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 24: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 25: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 26: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 27: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 28: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 29: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 31: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 32: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 33: * SUCH DAMAGE.
! 34: *
! 35: * @(#)nfs_vnops.c 8.16 (Berkeley) 5/27/95
! 36: */
! 37:
! 38:
! 39: /*
! 40: * vnode op calls for Sun NFS version 2 and 3
! 41: */
! 42:
! 43: #include <sys/param.h>
! 44: #include <sys/proc.h>
! 45: #include <sys/kernel.h>
! 46: #include <sys/systm.h>
! 47: #include <sys/resourcevar.h>
! 48: #include <sys/poll.h>
! 49: #include <sys/proc.h>
! 50: #include <sys/mount.h>
! 51: #include <sys/buf.h>
! 52: #include <sys/malloc.h>
! 53: #include <sys/pool.h>
! 54: #include <sys/mbuf.h>
! 55: #include <sys/conf.h>
! 56: #include <sys/namei.h>
! 57: #include <sys/vnode.h>
! 58: #include <sys/dirent.h>
! 59: #include <sys/fcntl.h>
! 60: #include <sys/lockf.h>
! 61: #include <sys/hash.h>
! 62:
! 63: #include <uvm/uvm_extern.h>
! 64:
! 65: #include <miscfs/specfs/specdev.h>
! 66: #include <miscfs/fifofs/fifo.h>
! 67:
! 68: #include <nfs/rpcv2.h>
! 69: #include <nfs/nfsproto.h>
! 70: #include <nfs/nfs.h>
! 71: #include <nfs/nfsnode.h>
! 72: #include <nfs/nfsmount.h>
! 73: #include <nfs/xdr_subs.h>
! 74: #include <nfs/nfsm_subs.h>
! 75: #include <nfs/nfs_var.h>
! 76:
! 77: #include <net/if.h>
! 78: #include <netinet/in.h>
! 79: #include <netinet/in_var.h>
! 80:
! 81: /* Defs */
! 82: #define TRUE 1
! 83: #define FALSE 0
! 84:
! 85: /*
! 86: * Global vfs data structures for nfs
! 87: */
! 88: int (**nfsv2_vnodeop_p)(void *);
! 89: struct vnodeopv_entry_desc nfsv2_vnodeop_entries[] = {
! 90: { &vop_default_desc, vn_default_error },
! 91: { &vop_lookup_desc, nfs_lookup }, /* lookup */
! 92: { &vop_create_desc, nfs_create }, /* create */
! 93: { &vop_mknod_desc, nfs_mknod }, /* mknod */
! 94: { &vop_open_desc, nfs_open }, /* open */
! 95: { &vop_close_desc, nfs_close }, /* close */
! 96: { &vop_access_desc, nfs_access }, /* access */
! 97: { &vop_getattr_desc, nfs_getattr }, /* getattr */
! 98: { &vop_setattr_desc, nfs_setattr }, /* setattr */
! 99: { &vop_read_desc, nfs_read }, /* read */
! 100: { &vop_write_desc, nfs_write }, /* write */
! 101: { &vop_ioctl_desc, nfs_ioctl }, /* ioctl */
! 102: { &vop_poll_desc, nfs_poll }, /* poll */
! 103: { &vop_kqfilter_desc, nfs_kqfilter }, /* kqfilter */
! 104: { &vop_revoke_desc, nfs_revoke }, /* revoke */
! 105: { &vop_fsync_desc, nfs_fsync }, /* fsync */
! 106: { &vop_remove_desc, nfs_remove }, /* remove */
! 107: { &vop_link_desc, nfs_link }, /* link */
! 108: { &vop_rename_desc, nfs_rename }, /* rename */
! 109: { &vop_mkdir_desc, nfs_mkdir }, /* mkdir */
! 110: { &vop_rmdir_desc, nfs_rmdir }, /* rmdir */
! 111: { &vop_symlink_desc, nfs_symlink }, /* symlink */
! 112: { &vop_readdir_desc, nfs_readdir }, /* readdir */
! 113: { &vop_readlink_desc, nfs_readlink }, /* readlink */
! 114: { &vop_abortop_desc, vop_generic_abortop }, /* abortop */
! 115: { &vop_inactive_desc, nfs_inactive }, /* inactive */
! 116: { &vop_reclaim_desc, nfs_reclaim }, /* reclaim */
! 117: { &vop_lock_desc, nfs_lock }, /* lock */
! 118: { &vop_unlock_desc, nfs_unlock }, /* unlock */
! 119: { &vop_bmap_desc, nfs_bmap }, /* bmap */
! 120: { &vop_strategy_desc, nfs_strategy }, /* strategy */
! 121: { &vop_print_desc, nfs_print }, /* print */
! 122: { &vop_islocked_desc, nfs_islocked }, /* islocked */
! 123: { &vop_pathconf_desc, nfs_pathconf }, /* pathconf */
! 124: { &vop_advlock_desc, nfs_advlock }, /* advlock */
! 125: { &vop_bwrite_desc, nfs_bwrite },
! 126: { NULL, NULL }
! 127: };
! 128: struct vnodeopv_desc nfsv2_vnodeop_opv_desc =
! 129: { &nfsv2_vnodeop_p, nfsv2_vnodeop_entries };
! 130:
! 131: /*
! 132: * Special device vnode ops
! 133: */
! 134: int (**spec_nfsv2nodeop_p)(void *);
! 135: struct vnodeopv_entry_desc spec_nfsv2nodeop_entries[] = {
! 136: { &vop_default_desc, spec_vnoperate },
! 137: { &vop_close_desc, nfsspec_close }, /* close */
! 138: { &vop_access_desc, nfsspec_access }, /* access */
! 139: { &vop_getattr_desc, nfs_getattr }, /* getattr */
! 140: { &vop_setattr_desc, nfs_setattr }, /* setattr */
! 141: { &vop_read_desc, nfsspec_read }, /* read */
! 142: { &vop_write_desc, nfsspec_write }, /* write */
! 143: { &vop_fsync_desc, nfs_fsync }, /* fsync */
! 144: { &vop_inactive_desc, nfs_inactive }, /* inactive */
! 145: { &vop_reclaim_desc, nfs_reclaim }, /* reclaim */
! 146: { &vop_lock_desc, nfs_lock }, /* lock */
! 147: { &vop_unlock_desc, nfs_unlock }, /* unlock */
! 148: { &vop_print_desc, nfs_print }, /* print */
! 149: { &vop_islocked_desc, nfs_islocked }, /* islocked */
! 150: { NULL, NULL }
! 151: };
! 152: struct vnodeopv_desc spec_nfsv2nodeop_opv_desc =
! 153: { &spec_nfsv2nodeop_p, spec_nfsv2nodeop_entries };
! 154:
! 155: #ifdef FIFO
! 156: int (**fifo_nfsv2nodeop_p)(void *);
! 157: struct vnodeopv_entry_desc fifo_nfsv2nodeop_entries[] = {
! 158: { &vop_default_desc, fifo_vnoperate },
! 159: { &vop_close_desc, nfsfifo_close }, /* close */
! 160: { &vop_access_desc, nfsspec_access }, /* access */
! 161: { &vop_getattr_desc, nfs_getattr }, /* getattr */
! 162: { &vop_setattr_desc, nfs_setattr }, /* setattr */
! 163: { &vop_read_desc, nfsfifo_read }, /* read */
! 164: { &vop_write_desc, nfsfifo_write }, /* write */
! 165: { &vop_fsync_desc, nfs_fsync }, /* fsync */
! 166: { &vop_inactive_desc, nfs_inactive }, /* inactive */
! 167: { &vop_reclaim_desc, nfsfifo_reclaim }, /* reclaim */
! 168: { &vop_lock_desc, nfs_lock }, /* lock */
! 169: { &vop_unlock_desc, nfs_unlock }, /* unlock */
! 170: { &vop_print_desc, nfs_print }, /* print */
! 171: { &vop_islocked_desc, nfs_islocked }, /* islocked */
! 172: { &vop_bwrite_desc, vop_generic_bwrite },
! 173: { NULL, NULL }
! 174: };
! 175: struct vnodeopv_desc fifo_nfsv2nodeop_opv_desc =
! 176: { &fifo_nfsv2nodeop_p, fifo_nfsv2nodeop_entries };
! 177: #endif /* FIFO */
! 178:
! 179: /*
! 180: * Global variables
! 181: */
! 182: extern u_int32_t nfs_true, nfs_false;
! 183: extern u_int32_t nfs_xdrneg1;
! 184: extern struct nfsstats nfsstats;
! 185: extern nfstype nfsv3_type[9];
! 186: struct proc *nfs_iodwant[NFS_MAXASYNCDAEMON];
! 187: int nfs_numasync = 0;
! 188:
! 189: /*
! 190: * nfs null call from vfs.
! 191: */
! 192: int
! 193: nfs_null(vp, cred, procp)
! 194: struct vnode *vp;
! 195: struct ucred *cred;
! 196: struct proc *procp;
! 197: {
! 198: caddr_t bpos, dpos;
! 199: int error = 0;
! 200: struct mbuf *mreq, *mrep, *md, *mb;
! 201:
! 202: nfsm_reqhead(vp, NFSPROC_NULL, 0);
! 203: nfsm_request(vp, NFSPROC_NULL, procp, cred);
! 204: nfsm_reqdone;
! 205: return (error);
! 206: }
! 207:
! 208: /*
! 209: * nfs access vnode op.
! 210: * For nfs version 2, just return ok. File accesses may fail later.
! 211: * For nfs version 3, use the access rpc to check accessibility. If file modes
! 212: * are changed on the server, accesses might still fail later.
! 213: */
! 214: int
! 215: nfs_access(v)
! 216: void *v;
! 217: {
! 218: struct vop_access_args *ap = v;
! 219: struct vnode *vp = ap->a_vp;
! 220: u_int32_t *tl;
! 221: caddr_t cp;
! 222: int32_t t1, t2;
! 223: caddr_t bpos, dpos, cp2;
! 224: int error = 0, attrflag;
! 225: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 226: u_int32_t mode, rmode;
! 227: int v3 = NFS_ISV3(vp);
! 228:
! 229: /*
! 230: * Disallow write attempts on filesystems mounted read-only;
! 231: * unless the file is a socket, fifo, or a block or character
! 232: * device resident on the filesystem.
! 233: */
! 234: if ((ap->a_mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) {
! 235: switch (vp->v_type) {
! 236: case VREG:
! 237: case VDIR:
! 238: case VLNK:
! 239: return (EROFS);
! 240: default:
! 241: break;
! 242: }
! 243: }
! 244: /*
! 245: * For nfs v3, do an access rpc, otherwise you are stuck emulating
! 246: * ufs_access() locally using the vattr. This may not be correct,
! 247: * since the server may apply other access criteria such as
! 248: * client uid-->server uid mapping that we do not know about, but
! 249: * this is better than just returning anything that is lying about
! 250: * in the cache.
! 251: */
! 252: if (v3) {
! 253: nfsstats.rpccnt[NFSPROC_ACCESS]++;
! 254: nfsm_reqhead(vp, NFSPROC_ACCESS, NFSX_FH(v3) + NFSX_UNSIGNED);
! 255: nfsm_fhtom(vp, v3);
! 256: nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
! 257: if (ap->a_mode & VREAD)
! 258: mode = NFSV3ACCESS_READ;
! 259: else
! 260: mode = 0;
! 261: if (vp->v_type == VDIR) {
! 262: if (ap->a_mode & VWRITE)
! 263: mode |= (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND |
! 264: NFSV3ACCESS_DELETE);
! 265: if (ap->a_mode & VEXEC)
! 266: mode |= NFSV3ACCESS_LOOKUP;
! 267: } else {
! 268: if (ap->a_mode & VWRITE)
! 269: mode |= (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND);
! 270: if (ap->a_mode & VEXEC)
! 271: mode |= NFSV3ACCESS_EXECUTE;
! 272: }
! 273: *tl = txdr_unsigned(mode);
! 274: nfsm_request(vp, NFSPROC_ACCESS, ap->a_p, ap->a_cred);
! 275: nfsm_postop_attr(vp, attrflag);
! 276: if (!error) {
! 277: nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
! 278: rmode = fxdr_unsigned(u_int32_t, *tl);
! 279: /*
! 280: * The NFS V3 spec does not clarify whether or not
! 281: * the returned access bits can be a superset of
! 282: * the ones requested, so...
! 283: */
! 284: if ((rmode & mode) != mode)
! 285: error = EACCES;
! 286: }
! 287: nfsm_reqdone;
! 288: return (error);
! 289: } else
! 290: return (nfsspec_access(ap));
! 291: }
! 292:
! 293: /*
! 294: * nfs open vnode op
! 295: * Check to see if the type is ok
! 296: * and that deletion is not in progress.
! 297: * For paged in text files, you will need to flush the page cache
! 298: * if consistency is lost.
! 299: */
! 300: /* ARGSUSED */
! 301: int
! 302: nfs_open(v)
! 303: void *v;
! 304: {
! 305: struct vop_open_args *ap = v;
! 306: struct vnode *vp = ap->a_vp;
! 307: struct nfsnode *np = VTONFS(vp);
! 308: struct vattr vattr;
! 309: int error;
! 310:
! 311: if (vp->v_type != VREG && vp->v_type != VDIR && vp->v_type != VLNK) {
! 312: #ifdef DIAGNOSTIC
! 313: printf("open eacces vtyp=%d\n",vp->v_type);
! 314: #endif
! 315: return (EACCES);
! 316: }
! 317:
! 318: /*
! 319: * Initialize read and write creds here, for swapfiles
! 320: * and other paths that don't set the creds themselves.
! 321: */
! 322:
! 323: if (ap->a_mode & FREAD) {
! 324: if (np->n_rcred) {
! 325: crfree(np->n_rcred);
! 326: }
! 327: np->n_rcred = ap->a_cred;
! 328: crhold(np->n_rcred);
! 329: }
! 330: if (ap->a_mode & FWRITE) {
! 331: if (np->n_wcred) {
! 332: crfree(np->n_wcred);
! 333: }
! 334: np->n_wcred = ap->a_cred;
! 335: crhold(np->n_wcred);
! 336: }
! 337:
! 338: if (np->n_flag & NMODIFIED) {
! 339: if ((error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred,
! 340: ap->a_p, 1)) == EINTR)
! 341: return (error);
! 342: uvm_vnp_uncache(vp);
! 343: np->n_attrstamp = 0;
! 344: if (vp->v_type == VDIR)
! 345: np->n_direofoffset = 0;
! 346: error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_p);
! 347: if (error)
! 348: return (error);
! 349: np->n_mtime = vattr.va_mtime.tv_sec;
! 350: } else {
! 351: error = VOP_GETATTR(vp, &vattr, ap->a_cred, ap->a_p);
! 352: if (error)
! 353: return (error);
! 354: if (np->n_mtime != vattr.va_mtime.tv_sec) {
! 355: if (vp->v_type == VDIR)
! 356: np->n_direofoffset = 0;
! 357: if ((error = nfs_vinvalbuf(vp, V_SAVE,
! 358: ap->a_cred, ap->a_p, 1)) == EINTR)
! 359: return (error);
! 360: uvm_vnp_uncache(vp);
! 361: np->n_mtime = vattr.va_mtime.tv_sec;
! 362: }
! 363: }
! 364: np->n_attrstamp = 0; /* For Open/Close consistency */
! 365: return (0);
! 366: }
! 367:
! 368: /*
! 369: * nfs close vnode op
! 370: * What an NFS client should do upon close after writing is a debatable issue.
! 371: * Most NFS clients push delayed writes to the server upon close, basically for
! 372: * two reasons:
! 373: * 1 - So that any write errors may be reported back to the client process
! 374: * doing the close system call. By far the two most likely errors are
! 375: * NFSERR_NOSPC and NFSERR_DQUOT to indicate space allocation failure.
! 376: * 2 - To put a worst case upper bound on cache inconsistency between
! 377: * multiple clients for the file.
! 378: * There is also a consistency problem for Version 2 of the protocol w.r.t.
! 379: * not being able to tell if other clients are writing a file concurrently,
! 380: * since there is no way of knowing if the changed modify time in the reply
! 381: * is only due to the write for this client.
! 382: * (NFS Version 3 provides weak cache consistency data in the reply that
! 383: * should be sufficient to detect and handle this case.)
! 384: *
! 385: * The current code does the following:
! 386: * for NFS Version 2 - play it safe and flush/invalidate all dirty buffers
! 387: * for NFS Version 3 - flush dirty buffers to the server but don't invalidate
! 388: * or commit them (this satisfies 1 and 2 except for the
! 389: * case where the server crashes after this close but
! 390: * before the commit RPC, which is felt to be "good
! 391: * enough". Changing the last argument to nfs_flush() to
! 392: * a 1 would force a commit operation, if it is felt a
! 393: * commit is necessary now.
! 394: */
! 395: /* ARGSUSED */
! 396: int
! 397: nfs_close(v)
! 398: void *v;
! 399: {
! 400: struct vop_close_args *ap = v;
! 401: struct vnode *vp = ap->a_vp;
! 402: struct nfsnode *np = VTONFS(vp);
! 403: int error = 0;
! 404:
! 405: if (vp->v_type == VREG) {
! 406: if (np->n_flag & NMODIFIED) {
! 407: if (NFS_ISV3(vp)) {
! 408: error = nfs_flush(vp, ap->a_cred, MNT_WAIT, ap->a_p, 0);
! 409: np->n_flag &= ~NMODIFIED;
! 410: } else
! 411: error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_p, 1);
! 412: np->n_attrstamp = 0;
! 413: }
! 414: if (np->n_flag & NWRITEERR) {
! 415: np->n_flag &= ~NWRITEERR;
! 416: error = np->n_error;
! 417: }
! 418: }
! 419: return (error);
! 420: }
! 421:
! 422: /*
! 423: * nfs getattr call from vfs.
! 424: */
! 425: int
! 426: nfs_getattr(v)
! 427: void *v;
! 428: {
! 429: struct vop_getattr_args *ap = v;
! 430: struct vnode *vp = ap->a_vp;
! 431: struct nfsnode *np = VTONFS(vp);
! 432: caddr_t cp;
! 433: u_int32_t *tl;
! 434: int32_t t1, t2;
! 435: caddr_t bpos, dpos;
! 436: int error = 0;
! 437: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 438: int v3 = NFS_ISV3(vp);
! 439:
! 440: /*
! 441: * Update local times for special files.
! 442: */
! 443: if (np->n_flag & (NACC | NUPD))
! 444: np->n_flag |= NCHG;
! 445: /*
! 446: * First look in the cache.
! 447: */
! 448: if (nfs_getattrcache(vp, ap->a_vap) == 0)
! 449: return (0);
! 450: nfsstats.rpccnt[NFSPROC_GETATTR]++;
! 451: nfsm_reqhead(vp, NFSPROC_GETATTR, NFSX_FH(v3));
! 452: nfsm_fhtom(vp, v3);
! 453: nfsm_request(vp, NFSPROC_GETATTR, ap->a_p, ap->a_cred);
! 454: if (!error)
! 455: nfsm_loadattr(vp, ap->a_vap);
! 456: nfsm_reqdone;
! 457: return (error);
! 458: }
! 459:
! 460: /*
! 461: * nfs setattr call.
! 462: */
! 463: int
! 464: nfs_setattr(v)
! 465: void *v;
! 466: {
! 467: struct vop_setattr_args *ap = v;
! 468: struct vnode *vp = ap->a_vp;
! 469: struct nfsnode *np = VTONFS(vp);
! 470: struct vattr *vap = ap->a_vap;
! 471: int error = 0;
! 472: u_quad_t tsize = 0;
! 473:
! 474: /*
! 475: * Setting of flags is not supported.
! 476: */
! 477: if (vap->va_flags != VNOVAL)
! 478: return (EOPNOTSUPP);
! 479:
! 480: /*
! 481: * Disallow write attempts if the filesystem is mounted read-only.
! 482: */
! 483: if ((vap->va_uid != (uid_t)VNOVAL ||
! 484: vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL ||
! 485: vap->va_mtime.tv_sec != VNOVAL || vap->va_mode != (mode_t)VNOVAL) &&
! 486: (vp->v_mount->mnt_flag & MNT_RDONLY))
! 487: return (EROFS);
! 488: if (vap->va_size != VNOVAL) {
! 489: switch (vp->v_type) {
! 490: case VDIR:
! 491: return (EISDIR);
! 492: case VCHR:
! 493: case VBLK:
! 494: case VSOCK:
! 495: case VFIFO:
! 496: if (vap->va_mtime.tv_sec == VNOVAL &&
! 497: vap->va_atime.tv_sec == VNOVAL &&
! 498: vap->va_mode == (mode_t)VNOVAL &&
! 499: vap->va_uid == (uid_t)VNOVAL &&
! 500: vap->va_gid == (gid_t)VNOVAL)
! 501: return (0);
! 502: vap->va_size = VNOVAL;
! 503: break;
! 504: default:
! 505: /*
! 506: * Disallow write attempts if the filesystem is
! 507: * mounted read-only.
! 508: */
! 509: if (vp->v_mount->mnt_flag & MNT_RDONLY)
! 510: return (EROFS);
! 511: if (vap->va_size == 0)
! 512: error = nfs_vinvalbuf(vp, 0,
! 513: ap->a_cred, ap->a_p, 1);
! 514: else
! 515: error = nfs_vinvalbuf(vp, V_SAVE,
! 516: ap->a_cred, ap->a_p, 1);
! 517: if (error)
! 518: return (error);
! 519: tsize = np->n_size;
! 520: np->n_size = np->n_vattr.va_size = vap->va_size;
! 521: uvm_vnp_setsize(vp, np->n_size);
! 522: };
! 523: } else if ((vap->va_mtime.tv_sec != VNOVAL ||
! 524: vap->va_atime.tv_sec != VNOVAL) &&
! 525: vp->v_type == VREG &&
! 526: (error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred,
! 527: ap->a_p, 1)) == EINTR)
! 528: return (error);
! 529: error = nfs_setattrrpc(vp, vap, ap->a_cred, ap->a_p);
! 530: if (error && vap->va_size != VNOVAL) {
! 531: np->n_size = np->n_vattr.va_size = tsize;
! 532: uvm_vnp_setsize(vp, np->n_size);
! 533: }
! 534:
! 535: VN_KNOTE(vp, NOTE_ATTRIB); /* XXX setattrrpc? */
! 536:
! 537: return (error);
! 538: }
! 539:
! 540: /*
! 541: * Do an nfs setattr rpc.
! 542: */
! 543: int
! 544: nfs_setattrrpc(vp, vap, cred, procp)
! 545: struct vnode *vp;
! 546: struct vattr *vap;
! 547: struct ucred *cred;
! 548: struct proc *procp;
! 549: {
! 550: struct nfsv2_sattr *sp;
! 551: caddr_t cp;
! 552: int32_t t1, t2;
! 553: caddr_t bpos, dpos, cp2;
! 554: u_int32_t *tl;
! 555: int error = 0, wccflag = NFSV3_WCCRATTR;
! 556: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 557: int v3 = NFS_ISV3(vp);
! 558:
! 559: nfsstats.rpccnt[NFSPROC_SETATTR]++;
! 560: nfsm_reqhead(vp, NFSPROC_SETATTR, NFSX_FH(v3) + NFSX_SATTR(v3));
! 561: nfsm_fhtom(vp, v3);
! 562: if (v3) {
! 563: nfsm_v3attrbuild(vap, TRUE);
! 564: nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
! 565: *tl = nfs_false;
! 566: } else {
! 567: nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
! 568: if (vap->va_mode == (mode_t)VNOVAL)
! 569: sp->sa_mode = nfs_xdrneg1;
! 570: else
! 571: sp->sa_mode = vtonfsv2_mode(vp->v_type, vap->va_mode);
! 572: if (vap->va_uid == (uid_t)VNOVAL)
! 573: sp->sa_uid = nfs_xdrneg1;
! 574: else
! 575: sp->sa_uid = txdr_unsigned(vap->va_uid);
! 576: if (vap->va_gid == (gid_t)VNOVAL)
! 577: sp->sa_gid = nfs_xdrneg1;
! 578: else
! 579: sp->sa_gid = txdr_unsigned(vap->va_gid);
! 580: sp->sa_size = txdr_unsigned(vap->va_size);
! 581: txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
! 582: txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
! 583: }
! 584: nfsm_request(vp, NFSPROC_SETATTR, procp, cred);
! 585: if (v3) {
! 586: nfsm_wcc_data(vp, wccflag);
! 587: } else
! 588: nfsm_loadattr(vp, (struct vattr *)0);
! 589: nfsm_reqdone;
! 590: return (error);
! 591: }
! 592:
! 593: /*
! 594: * nfs lookup call, one step at a time...
! 595: * First look in cache
! 596: * If not found, unlock the directory nfsnode and do the rpc
! 597: */
! 598: int
! 599: nfs_lookup(v)
! 600: void *v;
! 601: {
! 602: struct vop_lookup_args *ap = v;
! 603: struct componentname *cnp = ap->a_cnp;
! 604: struct vnode *dvp = ap->a_dvp;
! 605: struct vnode **vpp = ap->a_vpp;
! 606: struct proc *p = cnp->cn_proc;
! 607: int flags;
! 608: struct vnode *newvp;
! 609: u_int32_t *tl;
! 610: caddr_t cp;
! 611: int32_t t1, t2;
! 612: struct nfsmount *nmp;
! 613: caddr_t bpos, dpos, cp2;
! 614: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 615: long len;
! 616: nfsfh_t *fhp;
! 617: struct nfsnode *np;
! 618: int lockparent, wantparent, error = 0, attrflag, fhsize;
! 619: int v3 = NFS_ISV3(dvp);
! 620:
! 621: cnp->cn_flags &= ~PDIRUNLOCK;
! 622: flags = cnp->cn_flags;
! 623:
! 624: *vpp = NULLVP;
! 625: if ((flags & ISLASTCN) && (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
! 626: (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
! 627: return (EROFS);
! 628: if (dvp->v_type != VDIR)
! 629: return (ENOTDIR);
! 630: lockparent = flags & LOCKPARENT;
! 631: wantparent = flags & (LOCKPARENT|WANTPARENT);
! 632: nmp = VFSTONFS(dvp->v_mount);
! 633: np = VTONFS(dvp);
! 634:
! 635: /*
! 636: * Before tediously performing a linear scan of the directory,
! 637: * check the name cache to see if the directory/name pair
! 638: * we are looking for is known already.
! 639: * If the directory/name pair is found in the name cache,
! 640: * we have to ensure the directory has not changed from
! 641: * the time the cache entry has been created. If it has,
! 642: * the cache entry has to be ignored.
! 643: */
! 644: if ((error = cache_lookup(dvp, vpp, cnp)) >= 0) {
! 645: struct vattr vattr;
! 646: int err2;
! 647:
! 648: if (error && error != ENOENT) {
! 649: *vpp = NULLVP;
! 650: return (error);
! 651: }
! 652:
! 653: if (cnp->cn_flags & PDIRUNLOCK) {
! 654: err2 = vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p);
! 655: if (err2 != 0) {
! 656: *vpp = NULLVP;
! 657: return (err2);
! 658: }
! 659: cnp->cn_flags &= ~PDIRUNLOCK;
! 660: }
! 661:
! 662: err2 = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, cnp->cn_proc);
! 663: if (err2 != 0) {
! 664: if (error == 0) {
! 665: if (*vpp != dvp)
! 666: vput(*vpp);
! 667: else
! 668: vrele(*vpp);
! 669: }
! 670: *vpp = NULLVP;
! 671: return (err2);
! 672: }
! 673:
! 674: if (error == ENOENT) {
! 675: if (!VOP_GETATTR(dvp, &vattr, cnp->cn_cred,
! 676: cnp->cn_proc) && vattr.va_mtime.tv_sec ==
! 677: VTONFS(dvp)->n_ctime)
! 678: return (ENOENT);
! 679: cache_purge(dvp);
! 680: np->n_ctime = 0;
! 681: goto dorpc;
! 682: }
! 683:
! 684: newvp = *vpp;
! 685: if (!VOP_GETATTR(newvp, &vattr, cnp->cn_cred, cnp->cn_proc)
! 686: && vattr.va_ctime.tv_sec == VTONFS(newvp)->n_ctime)
! 687: {
! 688: nfsstats.lookupcache_hits++;
! 689: if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
! 690: cnp->cn_flags |= SAVENAME;
! 691: if ((!lockparent || !(flags & ISLASTCN)) &&
! 692: newvp != dvp)
! 693: VOP_UNLOCK(dvp, 0, p);
! 694: return (0);
! 695: }
! 696: cache_purge(newvp);
! 697: if (newvp != dvp)
! 698: vput(newvp);
! 699: else
! 700: vrele(newvp);
! 701: *vpp = NULLVP;
! 702: }
! 703: dorpc:
! 704: error = 0;
! 705: newvp = NULLVP;
! 706: nfsstats.lookupcache_misses++;
! 707: nfsstats.rpccnt[NFSPROC_LOOKUP]++;
! 708: len = cnp->cn_namelen;
! 709: nfsm_reqhead(dvp, NFSPROC_LOOKUP,
! 710: NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len));
! 711: nfsm_fhtom(dvp, v3);
! 712: nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN);
! 713: nfsm_request(dvp, NFSPROC_LOOKUP, cnp->cn_proc, cnp->cn_cred);
! 714: if (error) {
! 715: nfsm_postop_attr(dvp, attrflag);
! 716: m_freem(mrep);
! 717: goto nfsmout;
! 718: }
! 719: nfsm_getfh(fhp, fhsize, v3);
! 720:
! 721: /*
! 722: * Handle RENAME case...
! 723: */
! 724: if (cnp->cn_nameiop == RENAME && wantparent && (flags & ISLASTCN)) {
! 725: if (NFS_CMPFH(np, fhp, fhsize)) {
! 726: m_freem(mrep);
! 727: return (EISDIR);
! 728: }
! 729: error = nfs_nget(dvp->v_mount, fhp, fhsize, &np);
! 730: if (error) {
! 731: m_freem(mrep);
! 732: return (error);
! 733: }
! 734: newvp = NFSTOV(np);
! 735: if (v3) {
! 736: nfsm_postop_attr(newvp, attrflag);
! 737: nfsm_postop_attr(dvp, attrflag);
! 738: } else
! 739: nfsm_loadattr(newvp, (struct vattr *)0);
! 740: *vpp = newvp;
! 741: m_freem(mrep);
! 742: cnp->cn_flags |= SAVENAME;
! 743: if (!lockparent) {
! 744: VOP_UNLOCK(dvp, 0, p);
! 745: cnp->cn_flags |= PDIRUNLOCK;
! 746: }
! 747: return (0);
! 748: }
! 749:
! 750: /*
! 751: * The postop attr handling is duplicated for each if case,
! 752: * because it should be done while dvp is locked (unlocking
! 753: * dvp is different for each case).
! 754: */
! 755:
! 756: if (NFS_CMPFH(np, fhp, fhsize)) {
! 757: VREF(dvp);
! 758: newvp = dvp;
! 759: if (v3) {
! 760: nfsm_postop_attr(newvp, attrflag);
! 761: nfsm_postop_attr(dvp, attrflag);
! 762: } else
! 763: nfsm_loadattr(newvp, (struct vattr *)0);
! 764: } else if (flags & ISDOTDOT) {
! 765: VOP_UNLOCK(dvp, 0, p);
! 766: cnp->cn_flags |= PDIRUNLOCK;
! 767:
! 768: error = nfs_nget(dvp->v_mount, fhp, fhsize, &np);
! 769: if (error) {
! 770: if (vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p) == 0)
! 771: cnp->cn_flags &= ~PDIRUNLOCK;
! 772: m_freem(mrep);
! 773: return (error);
! 774: }
! 775: newvp = NFSTOV(np);
! 776:
! 777: if (v3) {
! 778: nfsm_postop_attr(newvp, attrflag);
! 779: nfsm_postop_attr(dvp, attrflag);
! 780: } else
! 781: nfsm_loadattr(newvp, (struct vattr *)0);
! 782:
! 783: if (lockparent && (flags & ISLASTCN)) {
! 784: if ((error = vn_lock(dvp, LK_EXCLUSIVE, p))) {
! 785: m_freem(mrep);
! 786: vput(newvp);
! 787: return error;
! 788: }
! 789: cnp->cn_flags &= ~PDIRUNLOCK;
! 790: }
! 791:
! 792: } else {
! 793: error = nfs_nget(dvp->v_mount, fhp, fhsize, &np);
! 794: if (error) {
! 795: m_freem(mrep);
! 796: return error;
! 797: }
! 798: newvp = NFSTOV(np);
! 799: if (v3) {
! 800: nfsm_postop_attr(newvp, attrflag);
! 801: nfsm_postop_attr(dvp, attrflag);
! 802: } else
! 803: nfsm_loadattr(newvp, (struct vattr *)0);
! 804: if (!lockparent || !(flags & ISLASTCN)) {
! 805: VOP_UNLOCK(dvp, 0, p);
! 806: cnp->cn_flags |= PDIRUNLOCK;
! 807: }
! 808: }
! 809: if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
! 810: cnp->cn_flags |= SAVENAME;
! 811: if ((cnp->cn_flags & MAKEENTRY) &&
! 812: (cnp->cn_nameiop != DELETE || !(flags & ISLASTCN))) {
! 813: np->n_ctime = np->n_vattr.va_ctime.tv_sec;
! 814: cache_enter(dvp, newvp, cnp);
! 815: }
! 816: *vpp = newvp;
! 817: nfsm_reqdone;
! 818: if (error) {
! 819: /*
! 820: * We get here only because of errors returned by
! 821: * the RPC. Otherwise we'll have returned above
! 822: * (the nfsm_* macros will jump to nfsm_reqdone
! 823: * on error).
! 824: */
! 825: if (error == ENOENT && (cnp->cn_flags & MAKEENTRY) &&
! 826: cnp->cn_nameiop != CREATE) {
! 827: if (VTONFS(dvp)->n_ctime == 0)
! 828: VTONFS(dvp)->n_ctime =
! 829: VTONFS(dvp)->n_vattr.va_mtime.tv_sec;
! 830: cache_enter(dvp, NULL, cnp);
! 831: }
! 832: if (newvp != NULLVP) {
! 833: vrele(newvp);
! 834: if (newvp != dvp)
! 835: VOP_UNLOCK(newvp, 0, p);
! 836: }
! 837: if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME) &&
! 838: (flags & ISLASTCN) && error == ENOENT) {
! 839: if (dvp->v_mount->mnt_flag & MNT_RDONLY)
! 840: error = EROFS;
! 841: else
! 842: error = EJUSTRETURN;
! 843: }
! 844: if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
! 845: cnp->cn_flags |= SAVENAME;
! 846: *vpp = NULL;
! 847: }
! 848: return (error);
! 849: }
! 850:
! 851: /*
! 852: * nfs read call.
! 853: * Just call nfs_bioread() to do the work.
! 854: */
! 855: int
! 856: nfs_read(v)
! 857: void *v;
! 858: {
! 859: struct vop_read_args *ap = v;
! 860: struct vnode *vp = ap->a_vp;
! 861:
! 862: if (vp->v_type != VREG)
! 863: return (EPERM);
! 864: return (nfs_bioread(vp, ap->a_uio, ap->a_ioflag, ap->a_cred));
! 865: }
! 866:
! 867: /*
! 868: * nfs readlink call
! 869: */
! 870: int
! 871: nfs_readlink(v)
! 872: void *v;
! 873: {
! 874: struct vop_readlink_args *ap = v;
! 875: struct vnode *vp = ap->a_vp;
! 876:
! 877: if (vp->v_type != VLNK)
! 878: return (EPERM);
! 879: return (nfs_bioread(vp, ap->a_uio, 0, ap->a_cred));
! 880: }
! 881:
! 882: /*
! 883: * Do a readlink rpc.
! 884: * Called by nfs_doio() from below the buffer cache.
! 885: */
! 886: int
! 887: nfs_readlinkrpc(vp, uiop, cred)
! 888: struct vnode *vp;
! 889: struct uio *uiop;
! 890: struct ucred *cred;
! 891: {
! 892: u_int32_t *tl;
! 893: caddr_t cp;
! 894: int32_t t1, t2;
! 895: caddr_t bpos, dpos, cp2;
! 896: int error = 0, len, attrflag;
! 897: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 898: int v3 = NFS_ISV3(vp);
! 899:
! 900: nfsstats.rpccnt[NFSPROC_READLINK]++;
! 901: nfsm_reqhead(vp, NFSPROC_READLINK, NFSX_FH(v3));
! 902: nfsm_fhtom(vp, v3);
! 903: nfsm_request(vp, NFSPROC_READLINK, uiop->uio_procp, cred);
! 904: if (v3)
! 905: nfsm_postop_attr(vp, attrflag);
! 906: if (!error) {
! 907: nfsm_strsiz(len, NFS_MAXPATHLEN);
! 908: nfsm_mtouio(uiop, len);
! 909: }
! 910: nfsm_reqdone;
! 911: return (error);
! 912: }
! 913:
! 914: /*
! 915: * nfs read rpc call
! 916: * Ditto above
! 917: */
! 918: int
! 919: nfs_readrpc(vp, uiop)
! 920: struct vnode *vp;
! 921: struct uio *uiop;
! 922: {
! 923: u_int32_t *tl;
! 924: caddr_t cp;
! 925: int32_t t1, t2;
! 926: caddr_t bpos, dpos, cp2;
! 927: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 928: struct nfsmount *nmp;
! 929: int error = 0, len, retlen, tsiz, eof, attrflag;
! 930: int v3 = NFS_ISV3(vp);
! 931:
! 932: #ifndef nolint
! 933: eof = 0;
! 934: #endif
! 935: nmp = VFSTONFS(vp->v_mount);
! 936: tsiz = uiop->uio_resid;
! 937: if (uiop->uio_offset + tsiz > 0xffffffff && !v3)
! 938: return (EFBIG);
! 939: while (tsiz > 0) {
! 940: nfsstats.rpccnt[NFSPROC_READ]++;
! 941: len = (tsiz > nmp->nm_rsize) ? nmp->nm_rsize : tsiz;
! 942: nfsm_reqhead(vp, NFSPROC_READ, NFSX_FH(v3) + NFSX_UNSIGNED * 3);
! 943: nfsm_fhtom(vp, v3);
! 944: nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED * 3);
! 945: if (v3) {
! 946: txdr_hyper(uiop->uio_offset, tl);
! 947: *(tl + 2) = txdr_unsigned(len);
! 948: } else {
! 949: *tl++ = txdr_unsigned(uiop->uio_offset);
! 950: *tl++ = txdr_unsigned(len);
! 951: *tl = 0;
! 952: }
! 953: nfsm_request(vp, NFSPROC_READ, uiop->uio_procp,
! 954: VTONFS(vp)->n_rcred);
! 955: if (v3) {
! 956: nfsm_postop_attr(vp, attrflag);
! 957: if (error) {
! 958: m_freem(mrep);
! 959: goto nfsmout;
! 960: }
! 961: nfsm_dissect(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
! 962: eof = fxdr_unsigned(int, *(tl + 1));
! 963: } else
! 964: nfsm_loadattr(vp, (struct vattr *)0);
! 965: nfsm_strsiz(retlen, nmp->nm_rsize);
! 966: nfsm_mtouio(uiop, retlen);
! 967: m_freem(mrep);
! 968: tsiz -= retlen;
! 969: if (v3) {
! 970: if (eof || retlen == 0)
! 971: tsiz = 0;
! 972: } else if (retlen < len)
! 973: tsiz = 0;
! 974: }
! 975: nfsmout:
! 976: return (error);
! 977: }
! 978:
! 979: /*
! 980: * nfs write call
! 981: */
! 982: int
! 983: nfs_writerpc(vp, uiop, iomode, must_commit)
! 984: struct vnode *vp;
! 985: struct uio *uiop;
! 986: int *iomode, *must_commit;
! 987: {
! 988: u_int32_t *tl;
! 989: caddr_t cp;
! 990: int32_t t1, t2, backup;
! 991: caddr_t bpos, dpos, cp2;
! 992: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 993: struct nfsmount *nmp = VFSTONFS(vp->v_mount);
! 994: int error = 0, len, tsiz, wccflag = NFSV3_WCCRATTR, rlen, commit;
! 995: int v3 = NFS_ISV3(vp), committed = NFSV3WRITE_FILESYNC;
! 996:
! 997: #ifndef DIAGNOSTIC
! 998: if (uiop->uio_iovcnt != 1)
! 999: panic("nfs: writerpc iovcnt > 1");
! 1000: #endif
! 1001: *must_commit = 0;
! 1002: tsiz = uiop->uio_resid;
! 1003: if (uiop->uio_offset + tsiz > 0xffffffff && !v3)
! 1004: return (EFBIG);
! 1005: while (tsiz > 0) {
! 1006: nfsstats.rpccnt[NFSPROC_WRITE]++;
! 1007: len = (tsiz > nmp->nm_wsize) ? nmp->nm_wsize : tsiz;
! 1008: nfsm_reqhead(vp, NFSPROC_WRITE,
! 1009: NFSX_FH(v3) + 5 * NFSX_UNSIGNED + nfsm_rndup(len));
! 1010: nfsm_fhtom(vp, v3);
! 1011: if (v3) {
! 1012: nfsm_build(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
! 1013: txdr_hyper(uiop->uio_offset, tl);
! 1014: tl += 2;
! 1015: *tl++ = txdr_unsigned(len);
! 1016: *tl++ = txdr_unsigned(*iomode);
! 1017: *tl = txdr_unsigned(len);
! 1018: } else {
! 1019: u_int32_t x;
! 1020:
! 1021: nfsm_build(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
! 1022: /* Set both "begin" and "current" to non-garbage. */
! 1023: x = txdr_unsigned((u_int32_t)uiop->uio_offset);
! 1024: *tl++ = x; /* "begin offset" */
! 1025: *tl++ = x; /* "current offset" */
! 1026: x = txdr_unsigned(len);
! 1027: *tl++ = x; /* total to this offset */
! 1028: *tl = x; /* size of this write */
! 1029:
! 1030: }
! 1031: nfsm_uiotom(uiop, len);
! 1032: nfsm_request(vp, NFSPROC_WRITE, uiop->uio_procp,
! 1033: VTONFS(vp)->n_wcred);
! 1034: if (v3) {
! 1035: wccflag = NFSV3_WCCCHK;
! 1036: nfsm_wcc_data(vp, wccflag);
! 1037: if (!error) {
! 1038: nfsm_dissect(tl, u_int32_t *, 2 * NFSX_UNSIGNED
! 1039: + NFSX_V3WRITEVERF);
! 1040: rlen = fxdr_unsigned(int, *tl++);
! 1041: if (rlen == 0) {
! 1042: error = NFSERR_IO;
! 1043: break;
! 1044: } else if (rlen < len) {
! 1045: backup = len - rlen;
! 1046: (char *)uiop->uio_iov->iov_base -= backup;
! 1047: uiop->uio_iov->iov_len += backup;
! 1048: uiop->uio_offset -= backup;
! 1049: uiop->uio_resid += backup;
! 1050: len = rlen;
! 1051: }
! 1052: commit = fxdr_unsigned(int, *tl++);
! 1053:
! 1054: /*
! 1055: * Return the lowest committment level
! 1056: * obtained by any of the RPCs.
! 1057: */
! 1058: if (committed == NFSV3WRITE_FILESYNC)
! 1059: committed = commit;
! 1060: else if (committed == NFSV3WRITE_DATASYNC &&
! 1061: commit == NFSV3WRITE_UNSTABLE)
! 1062: committed = commit;
! 1063: if ((nmp->nm_flag & NFSMNT_HASWRITEVERF) == 0) {
! 1064: bcopy((caddr_t)tl, (caddr_t)nmp->nm_verf,
! 1065: NFSX_V3WRITEVERF);
! 1066: nmp->nm_flag |= NFSMNT_HASWRITEVERF;
! 1067: } else if (bcmp((caddr_t)tl,
! 1068: (caddr_t)nmp->nm_verf, NFSX_V3WRITEVERF)) {
! 1069: *must_commit = 1;
! 1070: bcopy((caddr_t)tl, (caddr_t)nmp->nm_verf,
! 1071: NFSX_V3WRITEVERF);
! 1072: }
! 1073: }
! 1074: } else
! 1075: nfsm_loadattr(vp, (struct vattr *)0);
! 1076: if (wccflag)
! 1077: VTONFS(vp)->n_mtime = VTONFS(vp)->n_vattr.va_mtime.tv_sec;
! 1078: m_freem(mrep);
! 1079: tsiz -= len;
! 1080: }
! 1081: nfsmout:
! 1082: *iomode = committed;
! 1083: if (error)
! 1084: uiop->uio_resid = tsiz;
! 1085: return (error);
! 1086: }
! 1087:
! 1088: /*
! 1089: * nfs mknod rpc
! 1090: * For NFS v2 this is a kludge. Use a create rpc but with the IFMT bits of the
! 1091: * mode set to specify the file type and the size field for rdev.
! 1092: */
! 1093: int
! 1094: nfs_mknodrpc(dvp, vpp, cnp, vap)
! 1095: struct vnode *dvp;
! 1096: struct vnode **vpp;
! 1097: struct componentname *cnp;
! 1098: struct vattr *vap;
! 1099: {
! 1100: struct nfsv2_sattr *sp;
! 1101: u_int32_t *tl;
! 1102: caddr_t cp;
! 1103: int32_t t1, t2;
! 1104: struct vnode *newvp = (struct vnode *)0;
! 1105: struct nfsnode *np;
! 1106: char *cp2;
! 1107: caddr_t bpos, dpos;
! 1108: int error = 0, wccflag = NFSV3_WCCRATTR, gotvp = 0;
! 1109: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 1110: u_int32_t rdev;
! 1111: int v3 = NFS_ISV3(dvp);
! 1112:
! 1113: if (vap->va_type == VCHR || vap->va_type == VBLK)
! 1114: rdev = txdr_unsigned(vap->va_rdev);
! 1115: else if (vap->va_type == VFIFO || vap->va_type == VSOCK)
! 1116: rdev = nfs_xdrneg1;
! 1117: else {
! 1118: VOP_ABORTOP(dvp, cnp);
! 1119: vput(dvp);
! 1120: return (EOPNOTSUPP);
! 1121: }
! 1122: nfsstats.rpccnt[NFSPROC_MKNOD]++;
! 1123: nfsm_reqhead(dvp, NFSPROC_MKNOD, NFSX_FH(v3) + 4 * NFSX_UNSIGNED +
! 1124: + nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(v3));
! 1125: nfsm_fhtom(dvp, v3);
! 1126: nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
! 1127: if (v3) {
! 1128: nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
! 1129: *tl++ = vtonfsv3_type(vap->va_type);
! 1130: nfsm_v3attrbuild(vap, FALSE);
! 1131: if (vap->va_type == VCHR || vap->va_type == VBLK) {
! 1132: nfsm_build(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
! 1133: *tl++ = txdr_unsigned(major(vap->va_rdev));
! 1134: *tl = txdr_unsigned(minor(vap->va_rdev));
! 1135: }
! 1136: } else {
! 1137: nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
! 1138: sp->sa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
! 1139: sp->sa_uid = nfs_xdrneg1;
! 1140: sp->sa_gid = nfs_xdrneg1;
! 1141: sp->sa_size = rdev;
! 1142: txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
! 1143: txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
! 1144: }
! 1145: nfsm_request(dvp, NFSPROC_MKNOD, cnp->cn_proc, cnp->cn_cred);
! 1146: if (!error) {
! 1147: nfsm_mtofh(dvp, newvp, v3, gotvp);
! 1148: if (!gotvp) {
! 1149: if (newvp) {
! 1150: vrele(newvp);
! 1151: newvp = (struct vnode *)0;
! 1152: }
! 1153: error = nfs_lookitup(dvp, cnp->cn_nameptr,
! 1154: cnp->cn_namelen, cnp->cn_cred, cnp->cn_proc, &np);
! 1155: if (!error)
! 1156: newvp = NFSTOV(np);
! 1157: }
! 1158: }
! 1159: if (v3)
! 1160: nfsm_wcc_data(dvp, wccflag);
! 1161: nfsm_reqdone;
! 1162: if (error) {
! 1163: if (newvp)
! 1164: vrele(newvp);
! 1165: } else {
! 1166: if (cnp->cn_flags & MAKEENTRY)
! 1167: cache_enter(dvp, newvp, cnp);
! 1168: *vpp = newvp;
! 1169: }
! 1170: pool_put(&namei_pool, cnp->cn_pnbuf);
! 1171: VTONFS(dvp)->n_flag |= NMODIFIED;
! 1172: if (!wccflag)
! 1173: VTONFS(dvp)->n_attrstamp = 0;
! 1174: vrele(dvp);
! 1175: return (error);
! 1176: }
! 1177:
! 1178: /*
! 1179: * nfs mknod vop
! 1180: * just call nfs_mknodrpc() to do the work.
! 1181: */
! 1182: /* ARGSUSED */
! 1183: int
! 1184: nfs_mknod(v)
! 1185: void *v;
! 1186: {
! 1187: struct vop_mknod_args *ap = v;
! 1188: struct vnode *newvp;
! 1189: int error;
! 1190:
! 1191: error = nfs_mknodrpc(ap->a_dvp, &newvp, ap->a_cnp, ap->a_vap);
! 1192: if (!error)
! 1193: vrele(newvp);
! 1194:
! 1195: VN_KNOTE(ap->a_dvp, NOTE_WRITE);
! 1196:
! 1197: return (error);
! 1198: }
! 1199:
! 1200: static u_long create_verf;
! 1201: /*
! 1202: * nfs file create call
! 1203: */
! 1204: int
! 1205: nfs_create(v)
! 1206: void *v;
! 1207: {
! 1208: struct vop_create_args *ap = v;
! 1209: struct vnode *dvp = ap->a_dvp;
! 1210: struct vattr *vap = ap->a_vap;
! 1211: struct componentname *cnp = ap->a_cnp;
! 1212: struct nfsv2_sattr *sp;
! 1213: u_int32_t *tl;
! 1214: caddr_t cp;
! 1215: int32_t t1, t2;
! 1216: struct nfsnode *np = (struct nfsnode *)0;
! 1217: struct vnode *newvp = (struct vnode *)0;
! 1218: caddr_t bpos, dpos, cp2;
! 1219: int error = 0, wccflag = NFSV3_WCCRATTR, gotvp = 0, fmode = 0;
! 1220: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 1221: int v3 = NFS_ISV3(dvp);
! 1222:
! 1223: /*
! 1224: * Oops, not for me..
! 1225: */
! 1226: if (vap->va_type == VSOCK)
! 1227: return (nfs_mknodrpc(dvp, ap->a_vpp, cnp, vap));
! 1228:
! 1229: #ifdef VA_EXCLUSIVE
! 1230: if (vap->va_vaflags & VA_EXCLUSIVE)
! 1231: fmode |= O_EXCL;
! 1232: #endif
! 1233: again:
! 1234: nfsstats.rpccnt[NFSPROC_CREATE]++;
! 1235: nfsm_reqhead(dvp, NFSPROC_CREATE, NFSX_FH(v3) + 2 * NFSX_UNSIGNED +
! 1236: nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(v3));
! 1237: nfsm_fhtom(dvp, v3);
! 1238: nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
! 1239: if (v3) {
! 1240: nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
! 1241: if (fmode & O_EXCL) {
! 1242: *tl = txdr_unsigned(NFSV3CREATE_EXCLUSIVE);
! 1243: nfsm_build(tl, u_int32_t *, NFSX_V3CREATEVERF);
! 1244: if (TAILQ_FIRST(&in_ifaddr))
! 1245: *tl++ = TAILQ_FIRST(&in_ifaddr)->ia_addr.sin_addr.s_addr;
! 1246: else
! 1247: *tl++ = create_verf;
! 1248: *tl = ++create_verf;
! 1249: } else {
! 1250: *tl = txdr_unsigned(NFSV3CREATE_UNCHECKED);
! 1251: nfsm_v3attrbuild(vap, FALSE);
! 1252: }
! 1253: } else {
! 1254: nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
! 1255: sp->sa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
! 1256: sp->sa_uid = nfs_xdrneg1;
! 1257: sp->sa_gid = nfs_xdrneg1;
! 1258: sp->sa_size = 0;
! 1259: txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
! 1260: txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
! 1261: }
! 1262: nfsm_request(dvp, NFSPROC_CREATE, cnp->cn_proc, cnp->cn_cred);
! 1263: if (!error) {
! 1264: nfsm_mtofh(dvp, newvp, v3, gotvp);
! 1265: if (!gotvp) {
! 1266: if (newvp) {
! 1267: vrele(newvp);
! 1268: newvp = (struct vnode *)0;
! 1269: }
! 1270: error = nfs_lookitup(dvp, cnp->cn_nameptr,
! 1271: cnp->cn_namelen, cnp->cn_cred, cnp->cn_proc, &np);
! 1272: if (!error)
! 1273: newvp = NFSTOV(np);
! 1274: }
! 1275: }
! 1276: if (v3)
! 1277: nfsm_wcc_data(dvp, wccflag);
! 1278: nfsm_reqdone;
! 1279: if (error) {
! 1280: if (v3 && (fmode & O_EXCL) && error == NFSERR_NOTSUPP) {
! 1281: fmode &= ~O_EXCL;
! 1282: goto again;
! 1283: }
! 1284: if (newvp)
! 1285: vrele(newvp);
! 1286: } else if (v3 && (fmode & O_EXCL))
! 1287: error = nfs_setattrrpc(newvp, vap, cnp->cn_cred, cnp->cn_proc);
! 1288: if (!error) {
! 1289: if (cnp->cn_flags & MAKEENTRY)
! 1290: cache_enter(dvp, newvp, cnp);
! 1291: *ap->a_vpp = newvp;
! 1292: }
! 1293: pool_put(&namei_pool, cnp->cn_pnbuf);
! 1294: VTONFS(dvp)->n_flag |= NMODIFIED;
! 1295: if (!wccflag)
! 1296: VTONFS(dvp)->n_attrstamp = 0;
! 1297: VN_KNOTE(ap->a_dvp, NOTE_WRITE);
! 1298: vrele(dvp);
! 1299: return (error);
! 1300: }
! 1301:
! 1302: /*
! 1303: * nfs file remove call
! 1304: * To try and make nfs semantics closer to ufs semantics, a file that has
! 1305: * other processes using the vnode is renamed instead of removed and then
! 1306: * removed later on the last close.
! 1307: * - If v_usecount > 1
! 1308: * If a rename is not already in the works
! 1309: * call nfs_sillyrename() to set it up
! 1310: * else
! 1311: * do the remove rpc
! 1312: */
! 1313: int
! 1314: nfs_remove(v)
! 1315: void *v;
! 1316: {
! 1317: struct vop_remove_args *ap = v;
! 1318: struct vnode *vp = ap->a_vp;
! 1319: struct vnode *dvp = ap->a_dvp;
! 1320: struct componentname *cnp = ap->a_cnp;
! 1321: struct nfsnode *np = VTONFS(vp);
! 1322: int error = 0;
! 1323: struct vattr vattr;
! 1324:
! 1325: #ifndef DIAGNOSTIC
! 1326: if ((cnp->cn_flags & HASBUF) == 0)
! 1327: panic("nfs_remove: no name");
! 1328: if (vp->v_usecount < 1)
! 1329: panic("nfs_remove: bad v_usecount");
! 1330: #endif
! 1331: if (vp->v_type == VDIR)
! 1332: error = EPERM;
! 1333: else if (vp->v_usecount == 1 || (np->n_sillyrename &&
! 1334: VOP_GETATTR(vp, &vattr, cnp->cn_cred, cnp->cn_proc) == 0 &&
! 1335: vattr.va_nlink > 1)) {
! 1336: /*
! 1337: * Purge the name cache so that the chance of a lookup for
! 1338: * the name succeeding while the remove is in progress is
! 1339: * minimized. Without node locking it can still happen, such
! 1340: * that an I/O op returns ESTALE, but since you get this if
! 1341: * another host removes the file..
! 1342: */
! 1343: cache_purge(vp);
! 1344: /*
! 1345: * throw away biocache buffers, mainly to avoid
! 1346: * unnecessary delayed writes later.
! 1347: */
! 1348: error = nfs_vinvalbuf(vp, 0, cnp->cn_cred, cnp->cn_proc, 1);
! 1349: /* Do the rpc */
! 1350: if (error != EINTR)
! 1351: error = nfs_removerpc(dvp, cnp->cn_nameptr,
! 1352: cnp->cn_namelen, cnp->cn_cred, cnp->cn_proc);
! 1353: /*
! 1354: * Kludge City: If the first reply to the remove rpc is lost..
! 1355: * the reply to the retransmitted request will be ENOENT
! 1356: * since the file was in fact removed
! 1357: * Therefore, we cheat and return success.
! 1358: */
! 1359: if (error == ENOENT)
! 1360: error = 0;
! 1361: } else if (!np->n_sillyrename)
! 1362: error = nfs_sillyrename(dvp, vp, cnp);
! 1363: pool_put(&namei_pool, cnp->cn_pnbuf);
! 1364: np->n_attrstamp = 0;
! 1365: vrele(dvp);
! 1366: vrele(vp);
! 1367:
! 1368: VN_KNOTE(vp, NOTE_DELETE);
! 1369: VN_KNOTE(dvp, NOTE_WRITE);
! 1370:
! 1371: return (error);
! 1372: }
! 1373:
! 1374: /*
! 1375: * nfs file remove rpc called from nfs_inactive
! 1376: */
! 1377: int
! 1378: nfs_removeit(sp)
! 1379: struct sillyrename *sp;
! 1380: {
! 1381:
! 1382: return (nfs_removerpc(sp->s_dvp, sp->s_name, sp->s_namlen, sp->s_cred,
! 1383: (struct proc *)0));
! 1384: }
! 1385:
! 1386: /*
! 1387: * Nfs remove rpc, called from nfs_remove() and nfs_removeit().
! 1388: */
! 1389: int
! 1390: nfs_removerpc(dvp, name, namelen, cred, proc)
! 1391: struct vnode *dvp;
! 1392: char *name;
! 1393: int namelen;
! 1394: struct ucred *cred;
! 1395: struct proc *proc;
! 1396: {
! 1397: u_int32_t *tl;
! 1398: caddr_t cp;
! 1399: int32_t t1, t2;
! 1400: caddr_t bpos, dpos, cp2;
! 1401: int error = 0, wccflag = NFSV3_WCCRATTR;
! 1402: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 1403: int v3 = NFS_ISV3(dvp);
! 1404:
! 1405: nfsstats.rpccnt[NFSPROC_REMOVE]++;
! 1406: nfsm_reqhead(dvp, NFSPROC_REMOVE,
! 1407: NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(namelen));
! 1408: nfsm_fhtom(dvp, v3);
! 1409: nfsm_strtom(name, namelen, NFS_MAXNAMLEN);
! 1410: nfsm_request(dvp, NFSPROC_REMOVE, proc, cred);
! 1411: if (v3)
! 1412: nfsm_wcc_data(dvp, wccflag);
! 1413: nfsm_reqdone;
! 1414: VTONFS(dvp)->n_flag |= NMODIFIED;
! 1415: if (!wccflag)
! 1416: VTONFS(dvp)->n_attrstamp = 0;
! 1417: return (error);
! 1418: }
! 1419:
! 1420: /*
! 1421: * nfs file rename call
! 1422: */
! 1423: int
! 1424: nfs_rename(v)
! 1425: void *v;
! 1426: {
! 1427: struct vop_rename_args *ap = v;
! 1428: struct vnode *fvp = ap->a_fvp;
! 1429: struct vnode *tvp = ap->a_tvp;
! 1430: struct vnode *fdvp = ap->a_fdvp;
! 1431: struct vnode *tdvp = ap->a_tdvp;
! 1432: struct componentname *tcnp = ap->a_tcnp;
! 1433: struct componentname *fcnp = ap->a_fcnp;
! 1434: int error;
! 1435:
! 1436: #ifndef DIAGNOSTIC
! 1437: if ((tcnp->cn_flags & HASBUF) == 0 ||
! 1438: (fcnp->cn_flags & HASBUF) == 0)
! 1439: panic("nfs_rename: no name");
! 1440: #endif
! 1441: /* Check for cross-device rename */
! 1442: if ((fvp->v_mount != tdvp->v_mount) ||
! 1443: (tvp && (fvp->v_mount != tvp->v_mount))) {
! 1444: error = EXDEV;
! 1445: goto out;
! 1446: }
! 1447:
! 1448: /*
! 1449: * If the tvp exists and is in use, sillyrename it before doing the
! 1450: * rename of the new file over it.
! 1451: */
! 1452: if (tvp && tvp->v_usecount > 1 && !VTONFS(tvp)->n_sillyrename &&
! 1453: tvp->v_type != VDIR && !nfs_sillyrename(tdvp, tvp, tcnp)) {
! 1454: VN_KNOTE(tvp, NOTE_DELETE);
! 1455: vrele(tvp);
! 1456: tvp = NULL;
! 1457: }
! 1458:
! 1459: error = nfs_renamerpc(fdvp, fcnp->cn_nameptr, fcnp->cn_namelen,
! 1460: tdvp, tcnp->cn_nameptr, tcnp->cn_namelen, tcnp->cn_cred,
! 1461: tcnp->cn_proc);
! 1462:
! 1463: VN_KNOTE(fdvp, NOTE_WRITE);
! 1464: VN_KNOTE(tdvp, NOTE_WRITE);
! 1465:
! 1466: if (fvp->v_type == VDIR) {
! 1467: if (tvp != NULL && tvp->v_type == VDIR)
! 1468: cache_purge(tdvp);
! 1469: cache_purge(fdvp);
! 1470: }
! 1471: out:
! 1472: if (tdvp == tvp)
! 1473: vrele(tdvp);
! 1474: else
! 1475: vput(tdvp);
! 1476: if (tvp)
! 1477: vput(tvp);
! 1478: vrele(fdvp);
! 1479: vrele(fvp);
! 1480: /*
! 1481: * Kludge: Map ENOENT => 0 assuming that it is a reply to a retry.
! 1482: */
! 1483: if (error == ENOENT)
! 1484: error = 0;
! 1485: return (error);
! 1486: }
! 1487:
! 1488: /*
! 1489: * nfs file rename rpc called from nfs_remove() above
! 1490: */
! 1491: int
! 1492: nfs_renameit(sdvp, scnp, sp)
! 1493: struct vnode *sdvp;
! 1494: struct componentname *scnp;
! 1495: struct sillyrename *sp;
! 1496: {
! 1497: return (nfs_renamerpc(sdvp, scnp->cn_nameptr, scnp->cn_namelen,
! 1498: sdvp, sp->s_name, sp->s_namlen, scnp->cn_cred, scnp->cn_proc));
! 1499: }
! 1500:
! 1501: /*
! 1502: * Do an nfs rename rpc. Called from nfs_rename() and nfs_renameit().
! 1503: */
! 1504: int
! 1505: nfs_renamerpc(fdvp, fnameptr, fnamelen, tdvp, tnameptr, tnamelen, cred, proc)
! 1506: struct vnode *fdvp;
! 1507: char *fnameptr;
! 1508: int fnamelen;
! 1509: struct vnode *tdvp;
! 1510: char *tnameptr;
! 1511: int tnamelen;
! 1512: struct ucred *cred;
! 1513: struct proc *proc;
! 1514: {
! 1515: u_int32_t *tl;
! 1516: caddr_t cp;
! 1517: int32_t t1, t2;
! 1518: caddr_t bpos, dpos, cp2;
! 1519: int error = 0, fwccflag = NFSV3_WCCRATTR, twccflag = NFSV3_WCCRATTR;
! 1520: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 1521: int v3 = NFS_ISV3(fdvp);
! 1522:
! 1523: nfsstats.rpccnt[NFSPROC_RENAME]++;
! 1524: nfsm_reqhead(fdvp, NFSPROC_RENAME,
! 1525: (NFSX_FH(v3) + NFSX_UNSIGNED)*2 + nfsm_rndup(fnamelen) +
! 1526: nfsm_rndup(tnamelen));
! 1527: nfsm_fhtom(fdvp, v3);
! 1528: nfsm_strtom(fnameptr, fnamelen, NFS_MAXNAMLEN);
! 1529: nfsm_fhtom(tdvp, v3);
! 1530: nfsm_strtom(tnameptr, tnamelen, NFS_MAXNAMLEN);
! 1531: nfsm_request(fdvp, NFSPROC_RENAME, proc, cred);
! 1532: if (v3) {
! 1533: nfsm_wcc_data(fdvp, fwccflag);
! 1534: nfsm_wcc_data(tdvp, twccflag);
! 1535: }
! 1536: nfsm_reqdone;
! 1537: VTONFS(fdvp)->n_flag |= NMODIFIED;
! 1538: VTONFS(tdvp)->n_flag |= NMODIFIED;
! 1539: if (!fwccflag)
! 1540: VTONFS(fdvp)->n_attrstamp = 0;
! 1541: if (!twccflag)
! 1542: VTONFS(tdvp)->n_attrstamp = 0;
! 1543: return (error);
! 1544: }
! 1545:
! 1546: /*
! 1547: * nfs hard link create call
! 1548: */
! 1549: int
! 1550: nfs_link(v)
! 1551: void *v;
! 1552: {
! 1553: struct vop_link_args *ap = v;
! 1554: struct vnode *vp = ap->a_vp;
! 1555: struct vnode *dvp = ap->a_dvp;
! 1556: struct componentname *cnp = ap->a_cnp;
! 1557: u_int32_t *tl;
! 1558: caddr_t cp;
! 1559: int32_t t1, t2;
! 1560: caddr_t bpos, dpos, cp2;
! 1561: int error = 0, wccflag = NFSV3_WCCRATTR, attrflag = 0;
! 1562: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 1563: int v3;
! 1564:
! 1565: if (dvp->v_mount != vp->v_mount) {
! 1566: pool_put(&namei_pool, cnp->cn_pnbuf);
! 1567: if (vp == dvp)
! 1568: vrele(dvp);
! 1569: else
! 1570: vput(dvp);
! 1571: return (EXDEV);
! 1572: }
! 1573:
! 1574: /*
! 1575: * Push all writes to the server, so that the attribute cache
! 1576: * doesn't get "out of sync" with the server.
! 1577: * XXX There should be a better way!
! 1578: */
! 1579: VOP_FSYNC(vp, cnp->cn_cred, MNT_WAIT, cnp->cn_proc);
! 1580:
! 1581: v3 = NFS_ISV3(vp);
! 1582: nfsstats.rpccnt[NFSPROC_LINK]++;
! 1583: nfsm_reqhead(vp, NFSPROC_LINK,
! 1584: NFSX_FH(v3)*2 + NFSX_UNSIGNED + nfsm_rndup(cnp->cn_namelen));
! 1585: nfsm_fhtom(vp, v3);
! 1586: nfsm_fhtom(dvp, v3);
! 1587: nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
! 1588: nfsm_request(vp, NFSPROC_LINK, cnp->cn_proc, cnp->cn_cred);
! 1589: if (v3) {
! 1590: nfsm_postop_attr(vp, attrflag);
! 1591: nfsm_wcc_data(dvp, wccflag);
! 1592: }
! 1593: nfsm_reqdone;
! 1594: pool_put(&namei_pool, cnp->cn_pnbuf);
! 1595: VTONFS(dvp)->n_flag |= NMODIFIED;
! 1596: if (!attrflag)
! 1597: VTONFS(vp)->n_attrstamp = 0;
! 1598: if (!wccflag)
! 1599: VTONFS(dvp)->n_attrstamp = 0;
! 1600:
! 1601: VN_KNOTE(vp, NOTE_LINK);
! 1602: VN_KNOTE(dvp, NOTE_WRITE);
! 1603: vput(dvp);
! 1604: /*
! 1605: * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
! 1606: */
! 1607: if (error == EEXIST)
! 1608: error = 0;
! 1609: return (error);
! 1610: }
! 1611:
! 1612: /*
! 1613: * nfs symbolic link create call
! 1614: */
! 1615: int
! 1616: nfs_symlink(v)
! 1617: void *v;
! 1618: {
! 1619: struct vop_symlink_args *ap = v;
! 1620: struct vnode *dvp = ap->a_dvp;
! 1621: struct vattr *vap = ap->a_vap;
! 1622: struct componentname *cnp = ap->a_cnp;
! 1623: struct nfsv2_sattr *sp;
! 1624: u_int32_t *tl;
! 1625: caddr_t cp;
! 1626: int32_t t1, t2;
! 1627: caddr_t bpos, dpos, cp2;
! 1628: int slen, error = 0, wccflag = NFSV3_WCCRATTR, gotvp;
! 1629: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 1630: struct vnode *newvp = (struct vnode *)0;
! 1631: int v3 = NFS_ISV3(dvp);
! 1632:
! 1633: nfsstats.rpccnt[NFSPROC_SYMLINK]++;
! 1634: slen = strlen(ap->a_target);
! 1635: nfsm_reqhead(dvp, NFSPROC_SYMLINK, NFSX_FH(v3) + 2*NFSX_UNSIGNED +
! 1636: nfsm_rndup(cnp->cn_namelen) + nfsm_rndup(slen) + NFSX_SATTR(v3));
! 1637: nfsm_fhtom(dvp, v3);
! 1638: nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
! 1639: if (v3)
! 1640: nfsm_v3attrbuild(vap, FALSE);
! 1641: nfsm_strtom(ap->a_target, slen, NFS_MAXPATHLEN);
! 1642: if (!v3) {
! 1643: nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
! 1644: sp->sa_mode = vtonfsv2_mode(VLNK, vap->va_mode);
! 1645: sp->sa_uid = nfs_xdrneg1;
! 1646: sp->sa_gid = nfs_xdrneg1;
! 1647: sp->sa_size = nfs_xdrneg1;
! 1648: txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
! 1649: txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
! 1650: }
! 1651: nfsm_request(dvp, NFSPROC_SYMLINK, cnp->cn_proc, cnp->cn_cred);
! 1652: if (v3) {
! 1653: if (!error)
! 1654: nfsm_mtofh(dvp, newvp, v3, gotvp);
! 1655: nfsm_wcc_data(dvp, wccflag);
! 1656: }
! 1657: nfsm_reqdone;
! 1658: if (newvp)
! 1659: vrele(newvp);
! 1660: pool_put(&namei_pool, cnp->cn_pnbuf);
! 1661: VTONFS(dvp)->n_flag |= NMODIFIED;
! 1662: if (!wccflag)
! 1663: VTONFS(dvp)->n_attrstamp = 0;
! 1664: VN_KNOTE(dvp, NOTE_WRITE);
! 1665: vrele(dvp);
! 1666: /*
! 1667: * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
! 1668: */
! 1669: if (error == EEXIST)
! 1670: error = 0;
! 1671: return (error);
! 1672: }
! 1673:
! 1674: /*
! 1675: * nfs make dir call
! 1676: */
! 1677: int
! 1678: nfs_mkdir(v)
! 1679: void *v;
! 1680: {
! 1681: struct vop_mkdir_args *ap = v;
! 1682: struct vnode *dvp = ap->a_dvp;
! 1683: struct vattr *vap = ap->a_vap;
! 1684: struct componentname *cnp = ap->a_cnp;
! 1685: struct nfsv2_sattr *sp;
! 1686: u_int32_t *tl;
! 1687: caddr_t cp;
! 1688: int32_t t1, t2;
! 1689: int len;
! 1690: struct nfsnode *np = (struct nfsnode *)0;
! 1691: struct vnode *newvp = (struct vnode *)0;
! 1692: caddr_t bpos, dpos, cp2;
! 1693: int error = 0, wccflag = NFSV3_WCCRATTR;
! 1694: int gotvp = 0;
! 1695: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 1696: int v3 = NFS_ISV3(dvp);
! 1697:
! 1698: len = cnp->cn_namelen;
! 1699: nfsstats.rpccnt[NFSPROC_MKDIR]++;
! 1700: nfsm_reqhead(dvp, NFSPROC_MKDIR,
! 1701: NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len) + NFSX_SATTR(v3));
! 1702: nfsm_fhtom(dvp, v3);
! 1703: nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN);
! 1704: if (v3) {
! 1705: nfsm_v3attrbuild(vap, FALSE);
! 1706: } else {
! 1707: nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
! 1708: sp->sa_mode = vtonfsv2_mode(VDIR, vap->va_mode);
! 1709: sp->sa_uid = nfs_xdrneg1;
! 1710: sp->sa_gid = nfs_xdrneg1;
! 1711: sp->sa_size = nfs_xdrneg1;
! 1712: txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
! 1713: txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
! 1714: }
! 1715: nfsm_request(dvp, NFSPROC_MKDIR, cnp->cn_proc, cnp->cn_cred);
! 1716: if (!error)
! 1717: nfsm_mtofh(dvp, newvp, v3, gotvp);
! 1718: if (v3)
! 1719: nfsm_wcc_data(dvp, wccflag);
! 1720: nfsm_reqdone;
! 1721: VTONFS(dvp)->n_flag |= NMODIFIED;
! 1722: if (!wccflag)
! 1723: VTONFS(dvp)->n_attrstamp = 0;
! 1724: /*
! 1725: * Kludge: Map EEXIST => 0 assuming that you have a reply to a retry
! 1726: * if we can succeed in looking up the directory.
! 1727: */
! 1728: if (error == EEXIST || (!error && !gotvp)) {
! 1729: if (newvp) {
! 1730: vrele(newvp);
! 1731: newvp = (struct vnode *)0;
! 1732: }
! 1733: error = nfs_lookitup(dvp, cnp->cn_nameptr, len, cnp->cn_cred,
! 1734: cnp->cn_proc, &np);
! 1735: if (!error) {
! 1736: newvp = NFSTOV(np);
! 1737: if (newvp->v_type != VDIR)
! 1738: error = EEXIST;
! 1739: }
! 1740: }
! 1741: if (error) {
! 1742: if (newvp)
! 1743: vrele(newvp);
! 1744: } else {
! 1745: VN_KNOTE(dvp, NOTE_WRITE|NOTE_LINK);
! 1746: *ap->a_vpp = newvp;
! 1747: }
! 1748: pool_put(&namei_pool, cnp->cn_pnbuf);
! 1749: vrele(dvp);
! 1750: return (error);
! 1751: }
! 1752:
! 1753: /*
! 1754: * nfs remove directory call
! 1755: */
! 1756: int
! 1757: nfs_rmdir(v)
! 1758: void *v;
! 1759: {
! 1760: struct vop_rmdir_args *ap = v;
! 1761: struct vnode *vp = ap->a_vp;
! 1762: struct vnode *dvp = ap->a_dvp;
! 1763: struct componentname *cnp = ap->a_cnp;
! 1764: u_int32_t *tl;
! 1765: caddr_t cp;
! 1766: int32_t t1, t2;
! 1767: caddr_t bpos, dpos, cp2;
! 1768: int error = 0, wccflag = NFSV3_WCCRATTR;
! 1769: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 1770: int v3 = NFS_ISV3(dvp);
! 1771:
! 1772: if (dvp == vp) {
! 1773: vrele(dvp);
! 1774: vrele(dvp);
! 1775: pool_put(&namei_pool, cnp->cn_pnbuf);
! 1776: return (EINVAL);
! 1777: }
! 1778: nfsstats.rpccnt[NFSPROC_RMDIR]++;
! 1779: nfsm_reqhead(dvp, NFSPROC_RMDIR,
! 1780: NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(cnp->cn_namelen));
! 1781: nfsm_fhtom(dvp, v3);
! 1782: nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
! 1783: nfsm_request(dvp, NFSPROC_RMDIR, cnp->cn_proc, cnp->cn_cred);
! 1784: if (v3)
! 1785: nfsm_wcc_data(dvp, wccflag);
! 1786: nfsm_reqdone;
! 1787: pool_put(&namei_pool, cnp->cn_pnbuf);
! 1788: VTONFS(dvp)->n_flag |= NMODIFIED;
! 1789: if (!wccflag)
! 1790: VTONFS(dvp)->n_attrstamp = 0;
! 1791:
! 1792: VN_KNOTE(dvp, NOTE_WRITE|NOTE_LINK);
! 1793: VN_KNOTE(vp, NOTE_DELETE);
! 1794:
! 1795: cache_purge(dvp);
! 1796: cache_purge(vp);
! 1797: vrele(vp);
! 1798: vrele(dvp);
! 1799: /*
! 1800: * Kludge: Map ENOENT => 0 assuming that you have a reply to a retry.
! 1801: */
! 1802: if (error == ENOENT)
! 1803: error = 0;
! 1804: return (error);
! 1805: }
! 1806:
! 1807:
! 1808: /*
! 1809: * The readdir logic below has a big design bug. It stores the NFS cookie in
! 1810: * the returned uio->uio_offset but does not store the verifier (it cannot).
! 1811: * Instead, the code stores the verifier in the nfsnode and applies that
! 1812: * verifies to all cookies, no matter what verifier was originally with
! 1813: * the cookie.
! 1814: *
! 1815: * From a practical standpoint, this is not a problem since almost all
! 1816: * NFS servers do not change the validity of cookies across deletes
! 1817: * and inserts.
! 1818: */
! 1819:
! 1820: struct nfs_dirent {
! 1821: u_int32_t cookie[2];
! 1822: struct dirent dirent;
! 1823: };
! 1824:
! 1825: #define NFS_DIRHDSIZ (sizeof (struct nfs_dirent) - (MAXNAMLEN + 1))
! 1826: #define NFS_DIRENT_OVERHEAD offsetof(struct nfs_dirent, dirent)
! 1827:
! 1828: /*
! 1829: * nfs readdir call
! 1830: */
! 1831: int
! 1832: nfs_readdir(v)
! 1833: void *v;
! 1834: {
! 1835: struct vop_readdir_args *ap = v;
! 1836: struct vnode *vp = ap->a_vp;
! 1837: struct nfsnode *np = VTONFS(vp);
! 1838: struct uio *uio = ap->a_uio;
! 1839: int tresid, error;
! 1840: struct vattr vattr;
! 1841: u_long *cookies = NULL;
! 1842: int ncookies = 0, cnt;
! 1843: u_int64_t newoff = uio->uio_offset;
! 1844: struct nfsmount *nmp = VFSTONFS(vp->v_mount);
! 1845: struct uio readdir_uio;
! 1846: struct iovec readdir_iovec;
! 1847: struct proc * p = uio->uio_procp;
! 1848: int done = 0, eof = 0;
! 1849: struct ucred *cred = ap->a_cred;
! 1850: void *data;
! 1851:
! 1852: if (vp->v_type != VDIR)
! 1853: return (EPERM);
! 1854: /*
! 1855: * First, check for hit on the EOF offset cache
! 1856: */
! 1857: if (np->n_direofoffset != 0 &&
! 1858: uio->uio_offset == np->n_direofoffset) {
! 1859: if (VOP_GETATTR(vp, &vattr, ap->a_cred, uio->uio_procp) == 0 &&
! 1860: np->n_mtime == vattr.va_mtime.tv_sec) {
! 1861: nfsstats.direofcache_hits++;
! 1862: *ap->a_eofflag = 1;
! 1863: return (0);
! 1864: }
! 1865: }
! 1866:
! 1867: if (uio->uio_resid < NFS_FABLKSIZE)
! 1868: return (EINVAL);
! 1869:
! 1870: tresid = uio->uio_resid;
! 1871:
! 1872: if (uio->uio_rw != UIO_READ)
! 1873: return (EINVAL);
! 1874:
! 1875: if (ap->a_cookies) {
! 1876: ncookies = uio->uio_resid / 20;
! 1877:
! 1878: MALLOC(cookies, u_long *, sizeof(*cookies) * ncookies,
! 1879: M_TEMP, M_WAITOK);
! 1880: *ap->a_ncookies = ncookies;
! 1881: *ap->a_cookies = cookies;
! 1882: }
! 1883:
! 1884: if ((nmp->nm_flag & (NFSMNT_NFSV3 | NFSMNT_GOTFSINFO)) == NFSMNT_NFSV3)
! 1885: (void)nfs_fsinfo(nmp, vp, cred, p);
! 1886:
! 1887: cnt = 5;
! 1888:
! 1889: MALLOC(data, void *, NFS_DIRBLKSIZ, M_TEMP,
! 1890: M_WAITOK);
! 1891:
! 1892: do {
! 1893: struct nfs_dirent *ndp = data;
! 1894:
! 1895: readdir_iovec.iov_len = NFS_DIRBLKSIZ;
! 1896: readdir_iovec.iov_base = data;
! 1897: readdir_uio.uio_offset = newoff;
! 1898: readdir_uio.uio_iov = &readdir_iovec;
! 1899: readdir_uio.uio_iovcnt = 1;
! 1900: readdir_uio.uio_segflg = UIO_SYSSPACE;
! 1901: readdir_uio.uio_rw = UIO_READ;
! 1902: readdir_uio.uio_resid = NFS_DIRBLKSIZ;
! 1903: readdir_uio.uio_procp = curproc;
! 1904:
! 1905: if (nmp->nm_flag & NFSMNT_RDIRPLUS) {
! 1906: error = nfs_readdirplusrpc(vp, &readdir_uio, cred,
! 1907: &eof);
! 1908: if (error == NFSERR_NOTSUPP)
! 1909: nmp->nm_flag &= ~NFSMNT_RDIRPLUS;
! 1910: }
! 1911: if ((nmp->nm_flag & NFSMNT_RDIRPLUS) == 0)
! 1912: error = nfs_readdirrpc(vp, &readdir_uio, cred, &eof);
! 1913:
! 1914: if (error == NFSERR_BAD_COOKIE)
! 1915: error = EINVAL;
! 1916:
! 1917: while (error == 0 &&
! 1918: (ap->a_cookies == NULL || ncookies != 0) &&
! 1919: ndp < (struct nfs_dirent *)readdir_iovec.iov_base) {
! 1920: struct dirent *dp = &ndp->dirent;
! 1921: int reclen = dp->d_reclen;
! 1922:
! 1923: dp->d_reclen -= NFS_DIRENT_OVERHEAD;
! 1924:
! 1925: if (uio->uio_resid < dp->d_reclen) {
! 1926: eof = 0;
! 1927: done = 1;
! 1928: break;
! 1929: }
! 1930:
! 1931: error = uiomove((caddr_t)dp, dp->d_reclen, uio);
! 1932: if (error)
! 1933: break;
! 1934:
! 1935: newoff = fxdr_hyper(&ndp->cookie[0]);
! 1936:
! 1937: if (ap->a_cookies != NULL) {
! 1938: *cookies = newoff;
! 1939: cookies++;
! 1940: ncookies--;
! 1941: }
! 1942:
! 1943: ndp = (struct nfs_dirent *)((u_int8_t *)ndp + reclen);
! 1944: }
! 1945: } while (!error && !done && !eof && cnt--);
! 1946:
! 1947: FREE(data, M_TEMP);
! 1948: data = NULL;
! 1949:
! 1950: if (ap->a_cookies) {
! 1951: if (error) {
! 1952: FREE(*ap->a_cookies, M_TEMP);
! 1953: *ap->a_cookies = NULL;
! 1954: *ap->a_ncookies = 0;
! 1955: } else {
! 1956: *ap->a_ncookies -= ncookies;
! 1957: }
! 1958: }
! 1959:
! 1960: if (!error)
! 1961: uio->uio_offset = newoff;
! 1962:
! 1963: if (!error && (eof || uio->uio_resid == tresid)) {
! 1964: nfsstats.direofcache_misses++;
! 1965: *ap->a_eofflag = 1;
! 1966: return (0);
! 1967: }
! 1968:
! 1969: *ap->a_eofflag = 0;
! 1970: return (error);
! 1971: }
! 1972:
! 1973:
! 1974: /*
! 1975: * The function below stuff the cookies in after the name
! 1976: */
! 1977:
! 1978: /*
! 1979: * Readdir rpc call.
! 1980: */
! 1981: int
! 1982: nfs_readdirrpc(struct vnode *vp,
! 1983: struct uio *uiop,
! 1984: struct ucred *cred,
! 1985: int *end_of_directory)
! 1986: {
! 1987: int len, left;
! 1988: struct nfs_dirent *ndp = NULL;
! 1989: struct dirent *dp = NULL;
! 1990: u_int32_t *tl;
! 1991: caddr_t cp;
! 1992: int32_t t1, t2;
! 1993: caddr_t bpos, dpos, cp2;
! 1994: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 1995: nfsuint64 cookie;
! 1996: struct nfsmount *nmp = VFSTONFS(vp->v_mount);
! 1997: struct nfsnode *dnp = VTONFS(vp);
! 1998: u_quad_t fileno;
! 1999: int error = 0, tlen, more_dirs = 1, blksiz = 0, bigenough = 1;
! 2000: int attrflag;
! 2001: int v3 = NFS_ISV3(vp);
! 2002:
! 2003: #ifndef DIAGNOSTIC
! 2004: if (uiop->uio_iovcnt != 1 ||
! 2005: (uiop->uio_resid & (NFS_DIRBLKSIZ - 1)))
! 2006: panic("nfs readdirrpc bad uio");
! 2007: #endif
! 2008:
! 2009: txdr_hyper(uiop->uio_offset, &cookie.nfsuquad[0]);
! 2010:
! 2011: /*
! 2012: * Loop around doing readdir rpc's of size nm_readdirsize
! 2013: * truncated to a multiple of NFS_READDIRBLKSIZ.
! 2014: * The stopping criteria is EOF or buffer full.
! 2015: */
! 2016: while (more_dirs && bigenough) {
! 2017: nfsstats.rpccnt[NFSPROC_READDIR]++;
! 2018: nfsm_reqhead(vp, NFSPROC_READDIR, NFSX_FH(v3) +
! 2019: NFSX_READDIR(v3));
! 2020: nfsm_fhtom(vp, v3);
! 2021: if (v3) {
! 2022: nfsm_build(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
! 2023: *tl++ = cookie.nfsuquad[0];
! 2024: *tl++ = cookie.nfsuquad[1];
! 2025: if (cookie.nfsuquad[0] == 0 &&
! 2026: cookie.nfsuquad[1] == 0) {
! 2027: *tl++ = 0;
! 2028: *tl++ = 0;
! 2029: } else {
! 2030: *tl++ = dnp->n_cookieverf.nfsuquad[0];
! 2031: *tl++ = dnp->n_cookieverf.nfsuquad[1];
! 2032: }
! 2033: } else {
! 2034: nfsm_build(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
! 2035: *tl++ = cookie.nfsuquad[1];
! 2036: }
! 2037: *tl = txdr_unsigned(nmp->nm_readdirsize);
! 2038: nfsm_request(vp, NFSPROC_READDIR, uiop->uio_procp, cred);
! 2039: if (v3) {
! 2040: nfsm_postop_attr(vp, attrflag);
! 2041: if (!error) {
! 2042: nfsm_dissect(tl, u_int32_t *,
! 2043: 2 * NFSX_UNSIGNED);
! 2044: dnp->n_cookieverf.nfsuquad[0] = *tl++;
! 2045: dnp->n_cookieverf.nfsuquad[1] = *tl;
! 2046: } else {
! 2047: m_freem(mrep);
! 2048: goto nfsmout;
! 2049: }
! 2050: }
! 2051: nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
! 2052: more_dirs = fxdr_unsigned(int, *tl);
! 2053:
! 2054: /* loop thru the dir entries, doctoring them to 4bsd form */
! 2055: while (more_dirs && bigenough) {
! 2056: if (v3) {
! 2057: nfsm_dissect(tl, u_int32_t *,
! 2058: 3 * NFSX_UNSIGNED);
! 2059: fileno = fxdr_hyper(tl);
! 2060: len = fxdr_unsigned(int, *(tl + 2));
! 2061: } else {
! 2062: nfsm_dissect(tl, u_int32_t *,
! 2063: 2 * NFSX_UNSIGNED);
! 2064: fileno = fxdr_unsigned(u_quad_t, *tl++);
! 2065: len = fxdr_unsigned(int, *tl);
! 2066: }
! 2067: if (len <= 0 || len > NFS_MAXNAMLEN) {
! 2068: error = EBADRPC;
! 2069: m_freem(mrep);
! 2070: goto nfsmout;
! 2071: }
! 2072: tlen = nfsm_rndup(len + 1);
! 2073: left = NFS_READDIRBLKSIZ - blksiz;
! 2074: if ((tlen + NFS_DIRHDSIZ) > left) {
! 2075: dp->d_reclen += left;
! 2076: uiop->uio_iov->iov_base += left;
! 2077: uiop->uio_iov->iov_len -= left;
! 2078: uiop->uio_resid -= left;
! 2079: blksiz = 0;
! 2080: }
! 2081: if ((tlen + NFS_DIRHDSIZ) > uiop->uio_resid)
! 2082: bigenough = 0;
! 2083: if (bigenough) {
! 2084: ndp = (struct nfs_dirent *)
! 2085: uiop->uio_iov->iov_base;
! 2086: dp = &ndp->dirent;
! 2087: dp->d_fileno = (int)fileno;
! 2088: dp->d_namlen = len;
! 2089: dp->d_reclen = tlen + NFS_DIRHDSIZ;
! 2090: dp->d_type = DT_UNKNOWN;
! 2091: blksiz += dp->d_reclen;
! 2092: if (blksiz == NFS_READDIRBLKSIZ)
! 2093: blksiz = 0;
! 2094: uiop->uio_resid -= NFS_DIRHDSIZ;
! 2095: (char *)uiop->uio_iov->iov_base += NFS_DIRHDSIZ;
! 2096: uiop->uio_iov->iov_len -= NFS_DIRHDSIZ;
! 2097: nfsm_mtouio(uiop, len);
! 2098: cp = uiop->uio_iov->iov_base;
! 2099: tlen -= len;
! 2100: *cp = '\0'; /* null terminate */
! 2101: uiop->uio_iov->iov_base += tlen;
! 2102: uiop->uio_iov->iov_len -= tlen;
! 2103: uiop->uio_resid -= tlen;
! 2104: } else
! 2105: nfsm_adv(nfsm_rndup(len));
! 2106: if (v3) {
! 2107: nfsm_dissect(tl, u_int32_t *,
! 2108: 3 * NFSX_UNSIGNED);
! 2109: } else {
! 2110: nfsm_dissect(tl, u_int32_t *,
! 2111: 2 * NFSX_UNSIGNED);
! 2112: }
! 2113: if (bigenough) {
! 2114: if (v3) {
! 2115: ndp->cookie[0] = cookie.nfsuquad[0] =
! 2116: *tl++;
! 2117: } else
! 2118: ndp->cookie[0] = 0;
! 2119:
! 2120: ndp->cookie[1] = cookie.nfsuquad[1] = *tl++;
! 2121: } else if (v3)
! 2122: tl += 2;
! 2123: else
! 2124: tl++;
! 2125: more_dirs = fxdr_unsigned(int, *tl);
! 2126: }
! 2127: /*
! 2128: * If at end of rpc data, get the eof boolean
! 2129: */
! 2130: if (!more_dirs) {
! 2131: nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
! 2132: more_dirs = (fxdr_unsigned(int, *tl) == 0);
! 2133: }
! 2134: m_freem(mrep);
! 2135: }
! 2136: /*
! 2137: * Fill last record, iff any, out to a multiple of NFS_READDIRBLKSIZ
! 2138: * by increasing d_reclen for the last record.
! 2139: */
! 2140: if (blksiz > 0) {
! 2141: left = NFS_READDIRBLKSIZ - blksiz;
! 2142: dp->d_reclen += left;
! 2143: (char *)uiop->uio_iov->iov_base += left;
! 2144: uiop->uio_iov->iov_len -= left;
! 2145: uiop->uio_resid -= left;
! 2146: }
! 2147:
! 2148: /*
! 2149: * We are now either at the end of the directory or have filled the
! 2150: * block.
! 2151: */
! 2152: if (bigenough) {
! 2153: dnp->n_direofoffset = fxdr_hyper(&cookie.nfsuquad[0]);
! 2154: if (end_of_directory) *end_of_directory = 1;
! 2155: } else {
! 2156: if (uiop->uio_resid > 0)
! 2157: printf("EEK! readdirrpc resid > 0\n");
! 2158: }
! 2159:
! 2160: nfsmout:
! 2161: return (error);
! 2162: }
! 2163:
! 2164: /*
! 2165: * NFS V3 readdir plus RPC. Used in place of nfs_readdirrpc().
! 2166: */
! 2167: int
! 2168: nfs_readdirplusrpc(struct vnode *vp, struct uio *uiop, struct ucred *cred,
! 2169: int *end_of_directory)
! 2170: {
! 2171: int len, left;
! 2172: struct nfs_dirent *ndirp = NULL;
! 2173: struct dirent *dp = NULL;
! 2174: u_int32_t *tl;
! 2175: caddr_t cp;
! 2176: int32_t t1, t2;
! 2177: struct vnode *newvp;
! 2178: caddr_t bpos, dpos, cp2, dpossav1, dpossav2;
! 2179: struct mbuf *mreq, *mrep, *md, *mb, *mb2, *mdsav1, *mdsav2;
! 2180: struct nameidata nami, *ndp = &nami;
! 2181: struct componentname *cnp = &ndp->ni_cnd;
! 2182: nfsuint64 cookie;
! 2183: struct nfsmount *nmp = VFSTONFS(vp->v_mount);
! 2184: struct nfsnode *dnp = VTONFS(vp), *np;
! 2185: nfsfh_t *fhp;
! 2186: u_quad_t fileno;
! 2187: int error = 0, tlen, more_dirs = 1, blksiz = 0, doit, bigenough = 1, i;
! 2188: int attrflag, fhsize;
! 2189:
! 2190: #ifndef DIAGNOSTIC
! 2191: if (uiop->uio_iovcnt != 1 ||
! 2192: (uiop->uio_resid & (NFS_DIRBLKSIZ - 1)))
! 2193: panic("nfs readdirplusrpc bad uio");
! 2194: #endif
! 2195: ndp->ni_dvp = vp;
! 2196: newvp = NULLVP;
! 2197:
! 2198: txdr_hyper(uiop->uio_offset, &cookie.nfsuquad[0]);
! 2199:
! 2200: /*
! 2201: * Loop around doing readdir rpc's of size nm_readdirsize
! 2202: * truncated to a multiple of NFS_READDIRBLKSIZ.
! 2203: * The stopping criteria is EOF or buffer full.
! 2204: */
! 2205: while (more_dirs && bigenough) {
! 2206: nfsstats.rpccnt[NFSPROC_READDIRPLUS]++;
! 2207: nfsm_reqhead(vp, NFSPROC_READDIRPLUS,
! 2208: NFSX_FH(1) + 6 * NFSX_UNSIGNED);
! 2209: nfsm_fhtom(vp, 1);
! 2210: nfsm_build(tl, u_int32_t *, 6 * NFSX_UNSIGNED);
! 2211: *tl++ = cookie.nfsuquad[0];
! 2212: *tl++ = cookie.nfsuquad[1];
! 2213: if (cookie.nfsuquad[0] == 0 &&
! 2214: cookie.nfsuquad[1] == 0) {
! 2215: *tl++ = 0;
! 2216: *tl++ = 0;
! 2217: } else {
! 2218: *tl++ = dnp->n_cookieverf.nfsuquad[0];
! 2219: *tl++ = dnp->n_cookieverf.nfsuquad[1];
! 2220: }
! 2221: *tl++ = txdr_unsigned(nmp->nm_readdirsize);
! 2222: *tl = txdr_unsigned(nmp->nm_rsize);
! 2223: nfsm_request(vp, NFSPROC_READDIRPLUS, uiop->uio_procp, cred);
! 2224: nfsm_postop_attr(vp, attrflag);
! 2225: if (error) {
! 2226: m_freem(mrep);
! 2227: goto nfsmout;
! 2228: }
! 2229: nfsm_dissect(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
! 2230: dnp->n_cookieverf.nfsuquad[0] = *tl++;
! 2231: dnp->n_cookieverf.nfsuquad[1] = *tl++;
! 2232: more_dirs = fxdr_unsigned(int, *tl);
! 2233:
! 2234: /* loop thru the dir entries, doctoring them to 4bsd form */
! 2235: while (more_dirs && bigenough) {
! 2236: nfsm_dissect(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
! 2237: fileno = fxdr_hyper(tl);
! 2238: len = fxdr_unsigned(int, *(tl + 2));
! 2239: if (len <= 0 || len > NFS_MAXNAMLEN) {
! 2240: error = EBADRPC;
! 2241: m_freem(mrep);
! 2242: goto nfsmout;
! 2243: }
! 2244: tlen = nfsm_rndup(len + 1);
! 2245: left = NFS_READDIRBLKSIZ - blksiz;
! 2246: if ((tlen + NFS_DIRHDSIZ) > left) {
! 2247: dp->d_reclen += left;
! 2248: (char *)uiop->uio_iov->iov_base += left;
! 2249: uiop->uio_iov->iov_len -= left;
! 2250: uiop->uio_resid -= left;
! 2251: blksiz = 0;
! 2252: }
! 2253: if ((tlen + NFS_DIRHDSIZ) > uiop->uio_resid)
! 2254: bigenough = 0;
! 2255: if (bigenough) {
! 2256: ndirp = (struct nfs_dirent *)
! 2257: uiop->uio_iov->iov_base;
! 2258: dp = &ndirp->dirent;
! 2259: dp->d_fileno = (int)fileno;
! 2260: dp->d_namlen = len;
! 2261: dp->d_reclen = tlen + NFS_DIRHDSIZ;
! 2262: dp->d_type = DT_UNKNOWN;
! 2263: blksiz += dp->d_reclen;
! 2264: if (blksiz == NFS_READDIRBLKSIZ)
! 2265: blksiz = 0;
! 2266: uiop->uio_resid -= NFS_DIRHDSIZ;
! 2267: (char *)uiop->uio_iov->iov_base += NFS_DIRHDSIZ;
! 2268: uiop->uio_iov->iov_len -= NFS_DIRHDSIZ;
! 2269: cnp->cn_nameptr = uiop->uio_iov->iov_base;
! 2270: cnp->cn_namelen = len;
! 2271: nfsm_mtouio(uiop, len);
! 2272: cp = uiop->uio_iov->iov_base;
! 2273: tlen -= len;
! 2274: *cp = '\0';
! 2275: uiop->uio_iov->iov_base += tlen;
! 2276: uiop->uio_iov->iov_len -= tlen;
! 2277: uiop->uio_resid -= tlen;
! 2278: } else
! 2279: nfsm_adv(nfsm_rndup(len));
! 2280: nfsm_dissect(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
! 2281: if (bigenough) {
! 2282: ndirp->cookie[0] = cookie.nfsuquad[0] = *tl++;
! 2283: ndirp->cookie[1] = cookie.nfsuquad[1] = *tl++;
! 2284: } else
! 2285: tl += 2;
! 2286:
! 2287: /*
! 2288: * Since the attributes are before the file handle
! 2289: * (sigh), we must skip over the attributes and then
! 2290: * come back and get them.
! 2291: */
! 2292: attrflag = fxdr_unsigned(int, *tl);
! 2293: if (attrflag) {
! 2294: dpossav1 = dpos;
! 2295: mdsav1 = md;
! 2296: nfsm_adv(NFSX_V3FATTR);
! 2297: nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
! 2298: doit = fxdr_unsigned(int, *tl);
! 2299: if (doit) {
! 2300: nfsm_getfh(fhp, fhsize, 1);
! 2301: if (NFS_CMPFH(dnp, fhp, fhsize)) {
! 2302: VREF(vp);
! 2303: newvp = vp;
! 2304: np = dnp;
! 2305: } else {
! 2306: error = nfs_nget(vp->v_mount, fhp,
! 2307: fhsize, &np);
! 2308: if (error)
! 2309: doit = 0;
! 2310: else
! 2311: newvp = NFSTOV(np);
! 2312: }
! 2313: }
! 2314: if (doit && bigenough) {
! 2315: dpossav2 = dpos;
! 2316: dpos = dpossav1;
! 2317: mdsav2 = md;
! 2318: md = mdsav1;
! 2319: nfsm_loadattr(newvp, (struct vattr *)0);
! 2320: dpos = dpossav2;
! 2321: md = mdsav2;
! 2322: dp->d_type =
! 2323: IFTODT(VTTOIF(np->n_vattr.va_type));
! 2324: if (cnp->cn_namelen <= NCHNAMLEN) {
! 2325: ndp->ni_vp = newvp;
! 2326: cnp->cn_hash =
! 2327: hash32_str(cnp->cn_nameptr,
! 2328: HASHINIT);
! 2329: cache_enter(ndp->ni_dvp, ndp->ni_vp,
! 2330: cnp);
! 2331: }
! 2332: }
! 2333: } else {
! 2334: /* Just skip over the file handle */
! 2335: nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
! 2336: i = fxdr_unsigned(int, *tl);
! 2337: nfsm_adv(nfsm_rndup(i));
! 2338: }
! 2339: if (newvp != NULLVP) {
! 2340: vrele(newvp);
! 2341: newvp = NULLVP;
! 2342: }
! 2343: nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
! 2344: more_dirs = fxdr_unsigned(int, *tl);
! 2345: }
! 2346: /*
! 2347: * If at end of rpc data, get the eof boolean
! 2348: */
! 2349: if (!more_dirs) {
! 2350: nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
! 2351: more_dirs = (fxdr_unsigned(int, *tl) == 0);
! 2352: }
! 2353: m_freem(mrep);
! 2354: }
! 2355: /*
! 2356: * Fill last record, iff any, out to a multiple of NFS_READDIRBLKSIZ
! 2357: * by increasing d_reclen for the last record.
! 2358: */
! 2359: if (blksiz > 0) {
! 2360: left = NFS_READDIRBLKSIZ - blksiz;
! 2361: dp->d_reclen += left;
! 2362: (char *)uiop->uio_iov->iov_base += left;
! 2363: uiop->uio_iov->iov_len -= left;
! 2364: uiop->uio_resid -= left;
! 2365: }
! 2366:
! 2367: /*
! 2368: * We are now either at the end of the directory or have filled the
! 2369: * block.
! 2370: */
! 2371: if (bigenough) {
! 2372: dnp->n_direofoffset = fxdr_hyper(&cookie.nfsuquad[0]);
! 2373: if (end_of_directory) *end_of_directory = 1;
! 2374: } else {
! 2375: if (uiop->uio_resid > 0)
! 2376: printf("EEK! readdirplusrpc resid > 0\n");
! 2377: }
! 2378:
! 2379: nfsmout:
! 2380: if (newvp != NULLVP)
! 2381: vrele(newvp);
! 2382: return (error);
! 2383: }
! 2384:
! 2385: /*
! 2386: * Silly rename. To make the NFS filesystem that is stateless look a little
! 2387: * more like the "ufs" a remove of an active vnode is translated to a rename
! 2388: * to a funny looking filename that is removed by nfs_inactive on the
! 2389: * nfsnode. There is the potential for another process on a different client
! 2390: * to create the same funny name between the nfs_lookitup() fails and the
! 2391: * nfs_rename() completes, but...
! 2392: */
! 2393: int
! 2394: nfs_sillyrename(dvp, vp, cnp)
! 2395: struct vnode *dvp, *vp;
! 2396: struct componentname *cnp;
! 2397: {
! 2398: struct sillyrename *sp;
! 2399: struct nfsnode *np;
! 2400: int error;
! 2401:
! 2402: cache_purge(dvp);
! 2403: np = VTONFS(vp);
! 2404: MALLOC(sp, struct sillyrename *, sizeof (struct sillyrename),
! 2405: M_NFSREQ, M_WAITOK);
! 2406: sp->s_cred = crdup(cnp->cn_cred);
! 2407: sp->s_dvp = dvp;
! 2408: VREF(dvp);
! 2409:
! 2410: if (vp->v_type == VDIR) {
! 2411: #ifdef DIAGNOSTIC
! 2412: printf("nfs: sillyrename dir\n");
! 2413: #endif
! 2414: error = EINVAL;
! 2415: goto bad;
! 2416: }
! 2417:
! 2418: /* Fudge together a funny name */
! 2419: sp->s_namlen = snprintf(sp->s_name, sizeof sp->s_name,
! 2420: ".nfsA%05x4.4", cnp->cn_proc->p_pid);
! 2421: if (sp->s_namlen > sizeof sp->s_name)
! 2422: sp->s_namlen = strlen(sp->s_name);
! 2423:
! 2424: /* Try lookitups until we get one that isn't there */
! 2425: while (nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,
! 2426: cnp->cn_proc, (struct nfsnode **)0) == 0) {
! 2427: sp->s_name[4]++;
! 2428: if (sp->s_name[4] > 'z') {
! 2429: error = EINVAL;
! 2430: goto bad;
! 2431: }
! 2432: }
! 2433: error = nfs_renameit(dvp, cnp, sp);
! 2434: if (error)
! 2435: goto bad;
! 2436: error = nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,
! 2437: cnp->cn_proc, &np);
! 2438: np->n_sillyrename = sp;
! 2439: return (0);
! 2440: bad:
! 2441: vrele(sp->s_dvp);
! 2442: crfree(sp->s_cred);
! 2443: FREE((caddr_t)sp, M_NFSREQ);
! 2444: return (error);
! 2445: }
! 2446:
! 2447: /*
! 2448: * Look up a file name and optionally either update the file handle or
! 2449: * allocate an nfsnode, depending on the value of npp.
! 2450: * npp == NULL --> just do the lookup
! 2451: * *npp == NULL --> allocate a new nfsnode and make sure attributes are
! 2452: * handled too
! 2453: * *npp != NULL --> update the file handle in the vnode
! 2454: */
! 2455: int
! 2456: nfs_lookitup(dvp, name, len, cred, procp, npp)
! 2457: struct vnode *dvp;
! 2458: char *name;
! 2459: int len;
! 2460: struct ucred *cred;
! 2461: struct proc *procp;
! 2462: struct nfsnode **npp;
! 2463: {
! 2464: u_int32_t *tl;
! 2465: caddr_t cp;
! 2466: int32_t t1, t2;
! 2467: struct vnode *newvp = (struct vnode *)0;
! 2468: struct nfsnode *np, *dnp = VTONFS(dvp);
! 2469: caddr_t bpos, dpos, cp2;
! 2470: int error = 0, fhlen, attrflag;
! 2471: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 2472: nfsfh_t *nfhp;
! 2473: int v3 = NFS_ISV3(dvp);
! 2474:
! 2475: nfsstats.rpccnt[NFSPROC_LOOKUP]++;
! 2476: nfsm_reqhead(dvp, NFSPROC_LOOKUP,
! 2477: NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len));
! 2478: nfsm_fhtom(dvp, v3);
! 2479: nfsm_strtom(name, len, NFS_MAXNAMLEN);
! 2480: nfsm_request(dvp, NFSPROC_LOOKUP, procp, cred);
! 2481: if (npp && !error) {
! 2482: nfsm_getfh(nfhp, fhlen, v3);
! 2483: if (*npp) {
! 2484: np = *npp;
! 2485: if (np->n_fhsize > NFS_SMALLFH && fhlen <= NFS_SMALLFH) {
! 2486: free((caddr_t)np->n_fhp, M_NFSBIGFH);
! 2487: np->n_fhp = &np->n_fh;
! 2488: } else if (np->n_fhsize <= NFS_SMALLFH && fhlen>NFS_SMALLFH)
! 2489: np->n_fhp =(nfsfh_t *)malloc(fhlen,M_NFSBIGFH,M_WAITOK);
! 2490: bcopy((caddr_t)nfhp, (caddr_t)np->n_fhp, fhlen);
! 2491: np->n_fhsize = fhlen;
! 2492: newvp = NFSTOV(np);
! 2493: } else if (NFS_CMPFH(dnp, nfhp, fhlen)) {
! 2494: VREF(dvp);
! 2495: newvp = dvp;
! 2496: } else {
! 2497: error = nfs_nget(dvp->v_mount, nfhp, fhlen, &np);
! 2498: if (error) {
! 2499: m_freem(mrep);
! 2500: return (error);
! 2501: }
! 2502: newvp = NFSTOV(np);
! 2503: }
! 2504: if (v3) {
! 2505: nfsm_postop_attr(newvp, attrflag);
! 2506: if (!attrflag && *npp == NULL) {
! 2507: m_freem(mrep);
! 2508: vrele(newvp);
! 2509: return (ENOENT);
! 2510: }
! 2511: } else
! 2512: nfsm_loadattr(newvp, (struct vattr *)0);
! 2513: }
! 2514: nfsm_reqdone;
! 2515: if (npp && *npp == NULL) {
! 2516: if (error) {
! 2517: if (newvp)
! 2518: vrele(newvp);
! 2519: } else
! 2520: *npp = np;
! 2521: }
! 2522: return (error);
! 2523: }
! 2524:
! 2525: /*
! 2526: * Nfs Version 3 commit rpc
! 2527: */
! 2528: int
! 2529: nfs_commit(vp, offset, cnt, procp)
! 2530: struct vnode *vp;
! 2531: u_quad_t offset;
! 2532: int cnt;
! 2533: struct proc *procp;
! 2534: {
! 2535: caddr_t cp;
! 2536: u_int32_t *tl;
! 2537: int32_t t1, t2;
! 2538: struct nfsmount *nmp = VFSTONFS(vp->v_mount);
! 2539: caddr_t bpos, dpos, cp2;
! 2540: int error = 0, wccflag = NFSV3_WCCRATTR;
! 2541: struct mbuf *mreq, *mrep, *md, *mb, *mb2;
! 2542:
! 2543: if ((nmp->nm_flag & NFSMNT_HASWRITEVERF) == 0)
! 2544: return (0);
! 2545: nfsstats.rpccnt[NFSPROC_COMMIT]++;
! 2546: nfsm_reqhead(vp, NFSPROC_COMMIT, NFSX_FH(1));
! 2547: nfsm_fhtom(vp, 1);
! 2548: nfsm_build(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
! 2549: txdr_hyper(offset, tl);
! 2550: tl += 2;
! 2551: *tl = txdr_unsigned(cnt);
! 2552: nfsm_request(vp, NFSPROC_COMMIT, procp, VTONFS(vp)->n_wcred);
! 2553: nfsm_wcc_data(vp, wccflag);
! 2554: if (!error) {
! 2555: nfsm_dissect(tl, u_int32_t *, NFSX_V3WRITEVERF);
! 2556: if (bcmp((caddr_t)nmp->nm_verf, (caddr_t)tl,
! 2557: NFSX_V3WRITEVERF)) {
! 2558: bcopy((caddr_t)tl, (caddr_t)nmp->nm_verf,
! 2559: NFSX_V3WRITEVERF);
! 2560: error = NFSERR_STALEWRITEVERF;
! 2561: }
! 2562: }
! 2563: nfsm_reqdone;
! 2564: return (error);
! 2565: }
! 2566:
! 2567: /*
! 2568: * Kludge City..
! 2569: * - make nfs_bmap() essentially a no-op that does no translation
! 2570: * - do nfs_strategy() by doing I/O with nfs_readrpc/nfs_writerpc
! 2571: * (Maybe I could use the process's page mapping, but I was concerned that
! 2572: * Kernel Write might not be enabled and also figured copyout() would do
! 2573: * a lot more work than bcopy() and also it currently happens in the
! 2574: * context of the swapper process (2).
! 2575: */
! 2576: int
! 2577: nfs_bmap(v)
! 2578: void *v;
! 2579: {
! 2580: struct vop_bmap_args *ap = v;
! 2581: struct vnode *vp = ap->a_vp;
! 2582:
! 2583: if (ap->a_vpp != NULL)
! 2584: *ap->a_vpp = vp;
! 2585: if (ap->a_bnp != NULL)
! 2586: *ap->a_bnp = ap->a_bn * btodb(vp->v_mount->mnt_stat.f_iosize);
! 2587: return (0);
! 2588: }
! 2589:
! 2590: /*
! 2591: * Strategy routine.
! 2592: * For async requests when nfsiod(s) are running, queue the request by
! 2593: * calling nfs_asyncio(), otherwise just all nfs_doio() to do the
! 2594: * request.
! 2595: */
! 2596: int
! 2597: nfs_strategy(v)
! 2598: void *v;
! 2599: {
! 2600: struct vop_strategy_args *ap = v;
! 2601: struct buf *bp = ap->a_bp;
! 2602: struct proc *p;
! 2603: int error = 0;
! 2604:
! 2605: if ((bp->b_flags & (B_PHYS|B_ASYNC)) == (B_PHYS|B_ASYNC))
! 2606: panic("nfs physio/async");
! 2607: if (bp->b_flags & B_ASYNC)
! 2608: p = NULL;
! 2609: else
! 2610: p = curproc; /* XXX */
! 2611: /*
! 2612: * If the op is asynchronous and an i/o daemon is waiting
! 2613: * queue the request, wake it up and wait for completion
! 2614: * otherwise just do it ourselves.
! 2615: */
! 2616: if ((bp->b_flags & B_ASYNC) == 0 || nfs_asyncio(bp))
! 2617: error = nfs_doio(bp, p);
! 2618: return (error);
! 2619: }
! 2620:
! 2621: /*
! 2622: * fsync vnode op. Just call nfs_flush() with commit == 1.
! 2623: */
! 2624: /* ARGSUSED */
! 2625: int
! 2626: nfs_fsync(v)
! 2627: void *v;
! 2628: {
! 2629: struct vop_fsync_args *ap = v;
! 2630:
! 2631: return (nfs_flush(ap->a_vp, ap->a_cred, ap->a_waitfor, ap->a_p, 1));
! 2632: }
! 2633:
! 2634: /*
! 2635: * Flush all the blocks associated with a vnode.
! 2636: * Walk through the buffer pool and push any dirty pages
! 2637: * associated with the vnode.
! 2638: */
! 2639: int
! 2640: nfs_flush(vp, cred, waitfor, p, commit)
! 2641: struct vnode *vp;
! 2642: struct ucred *cred;
! 2643: int waitfor;
! 2644: struct proc *p;
! 2645: int commit;
! 2646: {
! 2647: struct nfsnode *np = VTONFS(vp);
! 2648: struct buf *bp;
! 2649: int i;
! 2650: struct buf *nbp;
! 2651: struct nfsmount *nmp = VFSTONFS(vp->v_mount);
! 2652: int s, error = 0, slptimeo = 0, slpflag = 0, retv, bvecpos;
! 2653: int passone = 1;
! 2654: u_quad_t off = (u_quad_t)-1, endoff = 0, toff;
! 2655: #ifndef NFS_COMMITBVECSIZ
! 2656: #define NFS_COMMITBVECSIZ 20
! 2657: #endif
! 2658: struct buf *bvec[NFS_COMMITBVECSIZ];
! 2659:
! 2660: if (nmp->nm_flag & NFSMNT_INT)
! 2661: slpflag = PCATCH;
! 2662: if (!commit)
! 2663: passone = 0;
! 2664: /*
! 2665: * A b_flags == (B_DELWRI | B_NEEDCOMMIT) block has been written to the
! 2666: * server, but nas not been committed to stable storage on the server
! 2667: * yet. On the first pass, the byte range is worked out and the commit
! 2668: * rpc is done. On the second pass, nfs_writebp() is called to do the
! 2669: * job.
! 2670: */
! 2671: again:
! 2672: bvecpos = 0;
! 2673: if (NFS_ISV3(vp) && commit) {
! 2674: s = splbio();
! 2675: for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp != NULL; bp = nbp) {
! 2676: nbp = LIST_NEXT(bp, b_vnbufs);
! 2677: if (bvecpos >= NFS_COMMITBVECSIZ)
! 2678: break;
! 2679: if ((bp->b_flags & (B_BUSY | B_DELWRI | B_NEEDCOMMIT))
! 2680: != (B_DELWRI | B_NEEDCOMMIT))
! 2681: continue;
! 2682: bremfree(bp);
! 2683: bp->b_flags |= (B_BUSY | B_WRITEINPROG);
! 2684: /*
! 2685: * A list of these buffers is kept so that the
! 2686: * second loop knows which buffers have actually
! 2687: * been committed. This is necessary, since there
! 2688: * may be a race between the commit rpc and new
! 2689: * uncommitted writes on the file.
! 2690: */
! 2691: bvec[bvecpos++] = bp;
! 2692: toff = ((u_quad_t)bp->b_blkno) * DEV_BSIZE +
! 2693: bp->b_dirtyoff;
! 2694: if (toff < off)
! 2695: off = toff;
! 2696: toff += (u_quad_t)(bp->b_dirtyend - bp->b_dirtyoff);
! 2697: if (toff > endoff)
! 2698: endoff = toff;
! 2699: }
! 2700: splx(s);
! 2701: }
! 2702: if (bvecpos > 0) {
! 2703: /*
! 2704: * Commit data on the server, as required.
! 2705: */
! 2706: retv = nfs_commit(vp, off, (int)(endoff - off), p);
! 2707: if (retv == NFSERR_STALEWRITEVERF)
! 2708: nfs_clearcommit(vp->v_mount);
! 2709: /*
! 2710: * Now, either mark the blocks I/O done or mark the
! 2711: * blocks dirty, depending on whether the commit
! 2712: * succeeded.
! 2713: */
! 2714: for (i = 0; i < bvecpos; i++) {
! 2715: bp = bvec[i];
! 2716: bp->b_flags &= ~(B_NEEDCOMMIT | B_WRITEINPROG);
! 2717: if (retv)
! 2718: brelse(bp);
! 2719: else {
! 2720: s = splbio();
! 2721: buf_undirty(bp);
! 2722: vp->v_numoutput++;
! 2723: bp->b_flags |= B_ASYNC;
! 2724: bp->b_flags &= ~(B_READ|B_DONE|B_ERROR);
! 2725: bp->b_dirtyoff = bp->b_dirtyend = 0;
! 2726: biodone(bp);
! 2727: splx(s);
! 2728: }
! 2729: }
! 2730: }
! 2731:
! 2732: /*
! 2733: * Start/do any write(s) that are required.
! 2734: */
! 2735: loop:
! 2736: s = splbio();
! 2737: for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp != NULL; bp = nbp) {
! 2738: nbp = LIST_NEXT(bp, b_vnbufs);
! 2739: if (bp->b_flags & B_BUSY) {
! 2740: if (waitfor != MNT_WAIT || passone)
! 2741: continue;
! 2742: bp->b_flags |= B_WANTED;
! 2743: error = tsleep((caddr_t)bp, slpflag | (PRIBIO + 1),
! 2744: "nfsfsync", slptimeo);
! 2745: splx(s);
! 2746: if (error) {
! 2747: if (nfs_sigintr(nmp, (struct nfsreq *)0, p))
! 2748: return (EINTR);
! 2749: if (slpflag == PCATCH) {
! 2750: slpflag = 0;
! 2751: slptimeo = 2 * hz;
! 2752: }
! 2753: }
! 2754: goto loop;
! 2755: }
! 2756: if ((bp->b_flags & B_DELWRI) == 0)
! 2757: panic("nfs_fsync: not dirty");
! 2758: if ((passone || !commit) && (bp->b_flags & B_NEEDCOMMIT))
! 2759: continue;
! 2760: bremfree(bp);
! 2761: if (passone || !commit)
! 2762: bp->b_flags |= (B_BUSY|B_ASYNC);
! 2763: else
! 2764: bp->b_flags |= (B_BUSY|B_ASYNC|B_WRITEINPROG|B_NEEDCOMMIT);
! 2765: splx(s);
! 2766: VOP_BWRITE(bp);
! 2767: goto loop;
! 2768: }
! 2769: splx(s);
! 2770: if (passone) {
! 2771: passone = 0;
! 2772: goto again;
! 2773: }
! 2774: if (waitfor == MNT_WAIT) {
! 2775: loop2:
! 2776: s = splbio();
! 2777: error = vwaitforio(vp, slpflag, "nfs_fsync", slptimeo);
! 2778: splx(s);
! 2779: if (error) {
! 2780: if (nfs_sigintr(nmp, (struct nfsreq *)0, p))
! 2781: return (EINTR);
! 2782: if (slpflag == PCATCH) {
! 2783: slpflag = 0;
! 2784: slptimeo = 2 * hz;
! 2785: }
! 2786: goto loop2;
! 2787: }
! 2788:
! 2789: if (LIST_FIRST(&vp->v_dirtyblkhd) && commit) {
! 2790: #if 0
! 2791: vprint("nfs_fsync: dirty", vp);
! 2792: #endif
! 2793: goto loop;
! 2794: }
! 2795: }
! 2796: if (np->n_flag & NWRITEERR) {
! 2797: error = np->n_error;
! 2798: np->n_flag &= ~NWRITEERR;
! 2799: }
! 2800: return (error);
! 2801: }
! 2802:
! 2803: /*
! 2804: * Return POSIX pathconf information applicable to nfs.
! 2805: *
! 2806: * The NFS V2 protocol doesn't support this, so just return EINVAL
! 2807: * for V2.
! 2808: */
! 2809: /* ARGSUSED */
! 2810: int
! 2811: nfs_pathconf(v)
! 2812: void *v;
! 2813: {
! 2814: #if 0
! 2815: struct vop_pathconf_args *ap = v;
! 2816: #endif
! 2817:
! 2818: return (EINVAL);
! 2819: }
! 2820:
! 2821: /*
! 2822: * NFS advisory byte-level locks.
! 2823: */
! 2824: int
! 2825: nfs_advlock(v)
! 2826: void *v;
! 2827: {
! 2828: struct vop_advlock_args *ap = v;
! 2829: struct nfsnode *np = VTONFS(ap->a_vp);
! 2830:
! 2831: return (lf_advlock(&np->n_lockf, np->n_size, ap->a_id, ap->a_op,
! 2832: ap->a_fl, ap->a_flags));
! 2833: }
! 2834:
! 2835: /*
! 2836: * Print out the contents of an nfsnode.
! 2837: */
! 2838: int
! 2839: nfs_print(v)
! 2840: void *v;
! 2841: {
! 2842: struct vop_print_args *ap = v;
! 2843: struct vnode *vp = ap->a_vp;
! 2844: struct nfsnode *np = VTONFS(vp);
! 2845:
! 2846: printf("tag VT_NFS, fileid %ld fsid 0x%lx",
! 2847: np->n_vattr.va_fileid, np->n_vattr.va_fsid);
! 2848: #ifdef FIFO
! 2849: if (vp->v_type == VFIFO)
! 2850: fifo_printinfo(vp);
! 2851: #endif
! 2852: printf("\n");
! 2853: return (0);
! 2854: }
! 2855:
! 2856: /*
! 2857: * Just call nfs_writebp() with the force argument set to 1.
! 2858: */
! 2859: int
! 2860: nfs_bwrite(v)
! 2861: void *v;
! 2862: {
! 2863: struct vop_bwrite_args *ap = v;
! 2864:
! 2865: return (nfs_writebp(ap->a_bp, 1));
! 2866: }
! 2867:
! 2868: /*
! 2869: * This is a clone of vop_generic_bwrite(), except that B_WRITEINPROG isn't set unless
! 2870: * the force flag is one and it also handles the B_NEEDCOMMIT flag.
! 2871: */
! 2872: int
! 2873: nfs_writebp(bp, force)
! 2874: struct buf *bp;
! 2875: int force;
! 2876: {
! 2877: int oldflags = bp->b_flags, retv = 1;
! 2878: struct proc *p = curproc; /* XXX */
! 2879: off_t off;
! 2880: size_t cnt;
! 2881: int s;
! 2882: struct vnode *vp;
! 2883: struct nfsnode *np;
! 2884:
! 2885: if(!(bp->b_flags & B_BUSY))
! 2886: panic("bwrite: buffer is not busy???");
! 2887:
! 2888: vp = bp->b_vp;
! 2889: np = VTONFS(vp);
! 2890:
! 2891: bp->b_flags &= ~(B_READ|B_DONE|B_ERROR);
! 2892:
! 2893: s = splbio();
! 2894: buf_undirty(bp);
! 2895:
! 2896: if ((oldflags & B_ASYNC) && !(oldflags & B_DELWRI) && p)
! 2897: ++p->p_stats->p_ru.ru_oublock;
! 2898:
! 2899: bp->b_vp->v_numoutput++;
! 2900: splx(s);
! 2901:
! 2902: /*
! 2903: * If B_NEEDCOMMIT is set, a commit rpc may do the trick. If not
! 2904: * an actual write will have to be scheduled via. VOP_STRATEGY().
! 2905: * If B_WRITEINPROG is already set, then push it with a write anyhow.
! 2906: */
! 2907: if ((oldflags & (B_NEEDCOMMIT | B_WRITEINPROG)) == B_NEEDCOMMIT) {
! 2908: off = ((u_quad_t)bp->b_blkno) * DEV_BSIZE + bp->b_dirtyoff;
! 2909: cnt = bp->b_dirtyend - bp->b_dirtyoff;
! 2910:
! 2911: rw_enter_write(&np->n_commitlock);
! 2912: if (!(bp->b_flags & B_NEEDCOMMIT)) {
! 2913: rw_exit_write(&np->n_commitlock);
! 2914: return (0);
! 2915: }
! 2916:
! 2917: /*
! 2918: * If it's already been commited by somebody else,
! 2919: * bail.
! 2920: */
! 2921: if (!nfs_in_committed_range(vp, bp)) {
! 2922: int pushedrange = 0;
! 2923: /*
! 2924: * Since we're going to do this, push as much
! 2925: * as we can.
! 2926: */
! 2927:
! 2928: if (nfs_in_tobecommitted_range(vp, bp)) {
! 2929: pushedrange = 1;
! 2930: off = np->n_pushlo;
! 2931: cnt = np->n_pushhi - np->n_pushlo;
! 2932: }
! 2933:
! 2934: bp->b_flags |= B_WRITEINPROG;
! 2935: retv = nfs_commit(bp->b_vp, off, cnt, bp->b_proc);
! 2936: bp->b_flags &= ~B_WRITEINPROG;
! 2937:
! 2938: if (retv == 0) {
! 2939: if (pushedrange)
! 2940: nfs_merge_commit_ranges(vp);
! 2941: else
! 2942: nfs_add_committed_range(vp, bp);
! 2943: }
! 2944: } else
! 2945: retv = 0; /* It has already been commited. */
! 2946:
! 2947: rw_exit_write(&np->n_commitlock);
! 2948: if (!retv) {
! 2949: bp->b_dirtyoff = bp->b_dirtyend = 0;
! 2950: bp->b_flags &= ~B_NEEDCOMMIT;
! 2951: s = splbio();
! 2952: biodone(bp);
! 2953: splx(s);
! 2954: } else if (retv == NFSERR_STALEWRITEVERF)
! 2955: nfs_clearcommit(bp->b_vp->v_mount);
! 2956: }
! 2957: if (retv) {
! 2958: if (force)
! 2959: bp->b_flags |= B_WRITEINPROG;
! 2960: VOP_STRATEGY(bp);
! 2961: }
! 2962:
! 2963: if( (oldflags & B_ASYNC) == 0) {
! 2964: int rtval = biowait(bp);
! 2965: if (!(oldflags & B_DELWRI) && p) {
! 2966: ++p->p_stats->p_ru.ru_oublock;
! 2967: }
! 2968: brelse(bp);
! 2969: return (rtval);
! 2970: }
! 2971:
! 2972: return (0);
! 2973: }
! 2974:
! 2975: /*
! 2976: * nfs special file access vnode op.
! 2977: * Essentially just get vattr and then imitate iaccess() since the device is
! 2978: * local to the client.
! 2979: */
! 2980: int
! 2981: nfsspec_access(v)
! 2982: void *v;
! 2983: {
! 2984: struct vop_access_args *ap = v;
! 2985: struct vattr va;
! 2986: struct vnode *vp = ap->a_vp;
! 2987: int error;
! 2988:
! 2989: /*
! 2990: * Disallow write attempts on filesystems mounted read-only;
! 2991: * unless the file is a socket, fifo, or a block or character
! 2992: * device resident on the filesystem.
! 2993: */
! 2994: if ((ap->a_mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) {
! 2995: switch (vp->v_type) {
! 2996: case VREG:
! 2997: case VDIR:
! 2998: case VLNK:
! 2999: return (EROFS);
! 3000: default:
! 3001: break;
! 3002: }
! 3003: }
! 3004:
! 3005: error = VOP_GETATTR(vp, &va, ap->a_cred, ap->a_p);
! 3006: if (error)
! 3007: return (error);
! 3008:
! 3009: return (vaccess(va.va_mode, va.va_uid, va.va_gid, ap->a_mode,
! 3010: ap->a_cred));
! 3011: }
! 3012:
! 3013: /* ARGSUSED */
! 3014: int
! 3015: nfs_poll(v)
! 3016: void *v;
! 3017: {
! 3018: struct vop_poll_args *ap = v;
! 3019:
! 3020: /*
! 3021: * We should really check to see if I/O is possible.
! 3022: */
! 3023: return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
! 3024: }
! 3025:
! 3026: /*
! 3027: * Read wrapper for special devices.
! 3028: */
! 3029: int
! 3030: nfsspec_read(v)
! 3031: void *v;
! 3032: {
! 3033: struct vop_read_args *ap = v;
! 3034: struct nfsnode *np = VTONFS(ap->a_vp);
! 3035:
! 3036: /*
! 3037: * Set access flag.
! 3038: */
! 3039: np->n_flag |= NACC;
! 3040: getnanotime(&np->n_atim);
! 3041: return (VOCALL(spec_vnodeop_p, VOFFSET(vop_read), ap));
! 3042: }
! 3043:
! 3044: /*
! 3045: * Write wrapper for special devices.
! 3046: */
! 3047: int
! 3048: nfsspec_write(v)
! 3049: void *v;
! 3050: {
! 3051: struct vop_write_args *ap = v;
! 3052: struct nfsnode *np = VTONFS(ap->a_vp);
! 3053:
! 3054: /*
! 3055: * Set update flag.
! 3056: */
! 3057: np->n_flag |= NUPD;
! 3058: getnanotime(&np->n_mtim);
! 3059: return (VOCALL(spec_vnodeop_p, VOFFSET(vop_write), ap));
! 3060: }
! 3061:
! 3062: /*
! 3063: * Close wrapper for special devices.
! 3064: *
! 3065: * Update the times on the nfsnode then do device close.
! 3066: */
! 3067: int
! 3068: nfsspec_close(v)
! 3069: void *v;
! 3070: {
! 3071: struct vop_close_args *ap = v;
! 3072: struct vnode *vp = ap->a_vp;
! 3073: struct nfsnode *np = VTONFS(vp);
! 3074: struct vattr vattr;
! 3075:
! 3076: if (np->n_flag & (NACC | NUPD)) {
! 3077: np->n_flag |= NCHG;
! 3078: if (vp->v_usecount == 1 &&
! 3079: (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
! 3080: VATTR_NULL(&vattr);
! 3081: if (np->n_flag & NACC)
! 3082: vattr.va_atime = np->n_atim;
! 3083: if (np->n_flag & NUPD)
! 3084: vattr.va_mtime = np->n_mtim;
! 3085: (void)VOP_SETATTR(vp, &vattr, ap->a_cred, ap->a_p);
! 3086: }
! 3087: }
! 3088: return (VOCALL(spec_vnodeop_p, VOFFSET(vop_close), ap));
! 3089: }
! 3090:
! 3091: #ifdef FIFO
! 3092: /*
! 3093: * Read wrapper for fifos.
! 3094: */
! 3095: int
! 3096: nfsfifo_read(v)
! 3097: void *v;
! 3098: {
! 3099: struct vop_read_args *ap = v;
! 3100: extern int (**fifo_vnodeop_p)(void *);
! 3101: struct nfsnode *np = VTONFS(ap->a_vp);
! 3102:
! 3103: /*
! 3104: * Set access flag.
! 3105: */
! 3106: np->n_flag |= NACC;
! 3107: getnanotime(&np->n_atim);
! 3108: return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_read), ap));
! 3109: }
! 3110:
! 3111: /*
! 3112: * Write wrapper for fifos.
! 3113: */
! 3114: int
! 3115: nfsfifo_write(v)
! 3116: void *v;
! 3117: {
! 3118: struct vop_write_args *ap = v;
! 3119: extern int (**fifo_vnodeop_p)(void *);
! 3120: struct nfsnode *np = VTONFS(ap->a_vp);
! 3121:
! 3122: /*
! 3123: * Set update flag.
! 3124: */
! 3125: np->n_flag |= NUPD;
! 3126: getnanotime(&np->n_mtim);
! 3127: return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_write), ap));
! 3128: }
! 3129:
! 3130: /*
! 3131: * Close wrapper for fifos.
! 3132: *
! 3133: * Update the times on the nfsnode then do fifo close.
! 3134: */
! 3135: int
! 3136: nfsfifo_close(v)
! 3137: void *v;
! 3138: {
! 3139: struct vop_close_args *ap = v;
! 3140: struct vnode *vp = ap->a_vp;
! 3141: struct nfsnode *np = VTONFS(vp);
! 3142: struct vattr vattr;
! 3143: extern int (**fifo_vnodeop_p)(void *);
! 3144:
! 3145: if (np->n_flag & (NACC | NUPD)) {
! 3146: if (np->n_flag & NACC) {
! 3147: getnanotime(&np->n_atim);
! 3148: }
! 3149: if (np->n_flag & NUPD) {
! 3150: getnanotime(&np->n_mtim);
! 3151: }
! 3152: np->n_flag |= NCHG;
! 3153: if (vp->v_usecount == 1 &&
! 3154: (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
! 3155: VATTR_NULL(&vattr);
! 3156: if (np->n_flag & NACC)
! 3157: vattr.va_atime = np->n_atim;
! 3158: if (np->n_flag & NUPD)
! 3159: vattr.va_mtime = np->n_mtim;
! 3160: (void)VOP_SETATTR(vp, &vattr, ap->a_cred, ap->a_p);
! 3161: }
! 3162: }
! 3163: return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_close), ap));
! 3164: }
! 3165:
! 3166: int
! 3167: nfsfifo_reclaim(void *v)
! 3168: {
! 3169: fifo_reclaim(v);
! 3170: return (nfs_reclaim(v));
! 3171: }
! 3172: #endif /* ! FIFO */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to nfs_vnops.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / nfs