138414Smckusick /* 238414Smckusick * Copyright (c) 1989 The Regents of the University of California. 338414Smckusick * All rights reserved. 438414Smckusick * 538414Smckusick * This code is derived from software contributed to Berkeley by 638414Smckusick * Rick Macklem at The University of Guelph. 738414Smckusick * 838414Smckusick * Redistribution and use in source and binary forms are permitted 938414Smckusick * provided that the above copyright notice and this paragraph are 1038414Smckusick * duplicated in all such forms and that any documentation, 1138414Smckusick * advertising materials, and other materials related to such 1238414Smckusick * distribution and use acknowledge that the software was developed 1338414Smckusick * by the University of California, Berkeley. The name of the 1438414Smckusick * University may not be used to endorse or promote products derived 1538414Smckusick * from this software without specific prior written permission. 1638414Smckusick * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR 1738414Smckusick * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED 1838414Smckusick * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. 1938414Smckusick * 20*40833Smckusick * @(#)nfs_vnops.c 7.35 (Berkeley) 04/07/90 2138414Smckusick */ 2238414Smckusick 2338414Smckusick /* 2438414Smckusick * vnode op calls for sun nfs version 2 2538414Smckusick */ 2638414Smckusick 2738414Smckusick #include "machine/pte.h" 2838414Smckusick #include "machine/mtpr.h" 2938414Smckusick #include "param.h" 3038414Smckusick #include "user.h" 3138414Smckusick #include "proc.h" 3240296Smckusick #include "kernel.h" 3338414Smckusick #include "mount.h" 3438414Smckusick #include "buf.h" 3538414Smckusick #include "vm.h" 3638414Smckusick #include "malloc.h" 3738414Smckusick #include "mbuf.h" 3838414Smckusick #include "errno.h" 3938414Smckusick #include "file.h" 4038414Smckusick #include "conf.h" 4138414Smckusick #include "vnode.h" 4240251Smckusick #include "text.h" 4338884Smacklem #include "map.h" 4438414Smckusick #include "nfsv2.h" 4538414Smckusick #include "nfs.h" 4638414Smckusick #include "nfsnode.h" 4738414Smckusick #include "nfsmount.h" 4838414Smckusick #include "xdr_subs.h" 4938414Smckusick #include "nfsm_subs.h" 5038884Smacklem #include "nfsiom.h" 5138414Smckusick 5238414Smckusick /* Defs */ 5338414Smckusick #define TRUE 1 5438414Smckusick #define FALSE 0 5538414Smckusick 5638414Smckusick /* Global vars */ 5738414Smckusick int nfs_lookup(), 5838414Smckusick nfs_create(), 5939459Smckusick nfs_mknod(), 6038414Smckusick nfs_open(), 6138414Smckusick nfs_close(), 6238414Smckusick nfs_access(), 6338414Smckusick nfs_getattr(), 6438414Smckusick nfs_setattr(), 6538414Smckusick nfs_read(), 6638414Smckusick nfs_write(), 6738414Smckusick vfs_noop(), 6838414Smckusick vfs_nullop(), 6938414Smckusick nfs_remove(), 7038414Smckusick nfs_link(), 7138414Smckusick nfs_rename(), 7238414Smckusick nfs_mkdir(), 7338414Smckusick nfs_rmdir(), 7438414Smckusick nfs_symlink(), 7538414Smckusick nfs_readdir(), 7638414Smckusick nfs_readlink(), 7738414Smckusick nfs_abortop(), 7838414Smckusick nfs_lock(), 7938414Smckusick nfs_unlock(), 8038414Smckusick nfs_bmap(), 8138414Smckusick nfs_strategy(), 8238884Smacklem nfs_fsync(), 8339394Smckusick nfs_inactive(), 8439672Smckusick nfs_reclaim(), 8539906Smckusick nfs_print(), 8639906Smckusick nfs_islocked(); 8738414Smckusick 8838414Smckusick struct vnodeops nfsv2_vnodeops = { 8939672Smckusick nfs_lookup, /* lookup */ 9039672Smckusick nfs_create, /* create */ 9139672Smckusick nfs_mknod, /* mknod */ 9239672Smckusick nfs_open, /* open */ 9339672Smckusick nfs_close, /* close */ 9439672Smckusick nfs_access, /* access */ 9539672Smckusick nfs_getattr, /* getattr */ 9639672Smckusick nfs_setattr, /* setattr */ 9739672Smckusick nfs_read, /* read */ 9839672Smckusick nfs_write, /* write */ 9939672Smckusick vfs_noop, /* ioctl */ 10039672Smckusick vfs_noop, /* select */ 10139672Smckusick vfs_noop, /* mmap */ 10239672Smckusick nfs_fsync, /* fsync */ 10339672Smckusick vfs_nullop, /* seek */ 10439672Smckusick nfs_remove, /* remove */ 10539672Smckusick nfs_link, /* link */ 10639672Smckusick nfs_rename, /* rename */ 10739672Smckusick nfs_mkdir, /* mkdir */ 10839672Smckusick nfs_rmdir, /* rmdir */ 10939672Smckusick nfs_symlink, /* symlink */ 11039672Smckusick nfs_readdir, /* readdir */ 11139672Smckusick nfs_readlink, /* readlink */ 11239672Smckusick nfs_abortop, /* abortop */ 11339672Smckusick nfs_inactive, /* inactive */ 11439672Smckusick nfs_reclaim, /* reclaim */ 11539672Smckusick nfs_lock, /* lock */ 11639672Smckusick nfs_unlock, /* unlock */ 11739672Smckusick nfs_bmap, /* bmap */ 11839672Smckusick nfs_strategy, /* strategy */ 11939672Smckusick nfs_print, /* print */ 12039906Smckusick nfs_islocked, /* islocked */ 12138414Smckusick }; 12238414Smckusick 12338414Smckusick /* Special device vnode ops */ 12439441Smckusick int spec_lookup(), 12539441Smckusick spec_open(), 12639441Smckusick spec_read(), 12739441Smckusick spec_write(), 12839441Smckusick spec_strategy(), 12939672Smckusick spec_bmap(), 13039441Smckusick spec_ioctl(), 13139441Smckusick spec_select(), 13239441Smckusick spec_close(), 13339441Smckusick spec_badop(), 13439441Smckusick spec_nullop(); 13538414Smckusick 13639441Smckusick struct vnodeops spec_nfsv2nodeops = { 13739599Smckusick spec_lookup, /* lookup */ 13839599Smckusick spec_badop, /* create */ 13939599Smckusick spec_badop, /* mknod */ 14039599Smckusick spec_open, /* open */ 14139599Smckusick spec_close, /* close */ 14239599Smckusick nfs_access, /* access */ 14339599Smckusick nfs_getattr, /* getattr */ 14439599Smckusick nfs_setattr, /* setattr */ 14539599Smckusick spec_read, /* read */ 14639599Smckusick spec_write, /* write */ 14739599Smckusick spec_ioctl, /* ioctl */ 14839599Smckusick spec_select, /* select */ 14939599Smckusick spec_badop, /* mmap */ 15039599Smckusick spec_nullop, /* fsync */ 15139599Smckusick spec_badop, /* seek */ 15239599Smckusick spec_badop, /* remove */ 15339599Smckusick spec_badop, /* link */ 15439599Smckusick spec_badop, /* rename */ 15539599Smckusick spec_badop, /* mkdir */ 15639599Smckusick spec_badop, /* rmdir */ 15739599Smckusick spec_badop, /* symlink */ 15839599Smckusick spec_badop, /* readdir */ 15939599Smckusick spec_badop, /* readlink */ 16039599Smckusick spec_badop, /* abortop */ 16139599Smckusick nfs_inactive, /* inactive */ 16239599Smckusick nfs_reclaim, /* reclaim */ 16339599Smckusick nfs_lock, /* lock */ 16439599Smckusick nfs_unlock, /* unlock */ 16539672Smckusick spec_bmap, /* bmap */ 16639599Smckusick spec_strategy, /* strategy */ 16739672Smckusick nfs_print, /* print */ 16839906Smckusick nfs_islocked, /* islocked */ 16938414Smckusick }; 17038414Smckusick 17140294Smckusick #ifdef FIFO 17240294Smckusick int fifo_lookup(), 17340294Smckusick fifo_open(), 17440294Smckusick fifo_read(), 17540294Smckusick fifo_write(), 17640294Smckusick fifo_bmap(), 17740294Smckusick fifo_ioctl(), 17840294Smckusick fifo_select(), 17940294Smckusick fifo_close(), 18040294Smckusick fifo_print(), 18140294Smckusick fifo_badop(), 18240294Smckusick fifo_nullop(); 18340294Smckusick 18440294Smckusick struct vnodeops fifo_nfsv2nodeops = { 18540294Smckusick fifo_lookup, /* lookup */ 18640294Smckusick fifo_badop, /* create */ 18740294Smckusick fifo_badop, /* mknod */ 18840294Smckusick fifo_open, /* open */ 18940294Smckusick fifo_close, /* close */ 19040294Smckusick nfs_access, /* access */ 19140294Smckusick nfs_getattr, /* getattr */ 19240294Smckusick nfs_setattr, /* setattr */ 19340294Smckusick fifo_read, /* read */ 19440294Smckusick fifo_write, /* write */ 19540294Smckusick fifo_ioctl, /* ioctl */ 19640294Smckusick fifo_select, /* select */ 19740294Smckusick fifo_badop, /* mmap */ 19840294Smckusick fifo_nullop, /* fsync */ 19940294Smckusick fifo_badop, /* seek */ 20040294Smckusick fifo_badop, /* remove */ 20140294Smckusick fifo_badop, /* link */ 20240294Smckusick fifo_badop, /* rename */ 20340294Smckusick fifo_badop, /* mkdir */ 20440294Smckusick fifo_badop, /* rmdir */ 20540294Smckusick fifo_badop, /* symlink */ 20640294Smckusick fifo_badop, /* readdir */ 20740294Smckusick fifo_badop, /* readlink */ 20840294Smckusick fifo_badop, /* abortop */ 20940294Smckusick nfs_inactive, /* inactive */ 21040294Smckusick nfs_reclaim, /* reclaim */ 21140294Smckusick nfs_lock, /* lock */ 21240294Smckusick nfs_unlock, /* unlock */ 21340294Smckusick fifo_bmap, /* bmap */ 21440294Smckusick fifo_badop, /* strategy */ 21540294Smckusick nfs_print, /* print */ 21640294Smckusick nfs_islocked, /* islocked */ 21740294Smckusick }; 21840294Smckusick #endif /* FIFO */ 21940294Smckusick 22038414Smckusick extern u_long nfs_procids[NFS_NPROCS]; 22138414Smckusick extern u_long nfs_prog, nfs_vers; 22238414Smckusick extern char nfsiobuf[MAXPHYS+NBPG]; 22340112Smckusick extern int nonidempotent[NFS_NPROCS]; 22438884Smacklem struct map nfsmap[NFS_MSIZ]; 22538414Smckusick enum vtype v_type[NFLNK+1]; 22638884Smacklem struct buf nfs_bqueue; /* Queue head for nfsiod's */ 22739341Smckusick int nfs_asyncdaemons = 0; 22839341Smckusick struct proc *nfs_iodwant[MAX_ASYNCDAEMON]; 22938884Smacklem static int nfsmap_want = 0; 23038414Smckusick 23138414Smckusick /* 23238414Smckusick * nfs null call from vfs. 23338414Smckusick */ 23438414Smckusick nfs_null(vp, cred) 23538414Smckusick struct vnode *vp; 23638414Smckusick struct ucred *cred; 23738414Smckusick { 23839488Smckusick caddr_t bpos, dpos; 23939488Smckusick u_long xid; 24039488Smckusick int error = 0; 24139488Smckusick struct mbuf *mreq, *mrep, *md, *mb; 24238414Smckusick 24338414Smckusick nfsm_reqhead(nfs_procids[NFSPROC_NULL], cred, 0); 24440112Smckusick nfsm_request(vp, nonidempotent[NFSPROC_NULL]); 24538414Smckusick nfsm_reqdone; 24638414Smckusick return (error); 24738414Smckusick } 24838414Smckusick 24938414Smckusick /* 25038414Smckusick * nfs access vnode op. 25138414Smckusick * Essentially just get vattr and then imitate iaccess() 25238414Smckusick */ 25338414Smckusick nfs_access(vp, mode, cred) 25438414Smckusick struct vnode *vp; 25538414Smckusick int mode; 25638414Smckusick register struct ucred *cred; 25738414Smckusick { 25838414Smckusick register struct vattr *vap; 25938414Smckusick register gid_t *gp; 26038414Smckusick struct vattr vattr; 26138414Smckusick register int i; 26238414Smckusick int error; 26338414Smckusick 26438414Smckusick /* 26538414Smckusick * If you're the super-user, 26638414Smckusick * you always get access. 26738414Smckusick */ 26838414Smckusick if (cred->cr_uid == 0) 26938414Smckusick return (0); 27038414Smckusick vap = &vattr; 27138884Smacklem if (error = nfs_getattr(vp, vap, cred)) 27238884Smacklem return (error); 27338414Smckusick /* 27438414Smckusick * Access check is based on only one of owner, group, public. 27538414Smckusick * If not owner, then check group. If not a member of the 27638414Smckusick * group, then check public access. 27738414Smckusick */ 27838414Smckusick if (cred->cr_uid != vap->va_uid) { 27938414Smckusick mode >>= 3; 28038414Smckusick gp = cred->cr_groups; 28138414Smckusick for (i = 0; i < cred->cr_ngroups; i++, gp++) 28238414Smckusick if (vap->va_gid == *gp) 28338414Smckusick goto found; 28438414Smckusick mode >>= 3; 28538414Smckusick found: 28638414Smckusick ; 28738414Smckusick } 28838414Smckusick if ((vap->va_mode & mode) != 0) 28938414Smckusick return (0); 29038414Smckusick return (EACCES); 29138414Smckusick } 29238414Smckusick 29338414Smckusick /* 29438414Smckusick * nfs open vnode op 29538414Smckusick * Just check to see if the type is ok 29638414Smckusick */ 29739488Smckusick /* ARGSUSED */ 29838414Smckusick nfs_open(vp, mode, cred) 29938414Smckusick struct vnode *vp; 30038414Smckusick int mode; 30138414Smckusick struct ucred *cred; 30238414Smckusick { 30338414Smckusick register enum vtype vtyp; 30438414Smckusick 30538414Smckusick vtyp = vp->v_type; 30638414Smckusick if (vtyp == VREG || vtyp == VDIR || vtyp == VLNK) 30738414Smckusick return (0); 30838414Smckusick else 30938414Smckusick return (EACCES); 31038414Smckusick } 31138414Smckusick 31238414Smckusick /* 31338414Smckusick * nfs close vnode op 31438884Smacklem * For reg files, invalidate any buffer cache entries. 31538414Smckusick */ 31639488Smckusick /* ARGSUSED */ 31738414Smckusick nfs_close(vp, fflags, cred) 31838414Smckusick register struct vnode *vp; 31938414Smckusick int fflags; 32038414Smckusick struct ucred *cred; 32138414Smckusick { 32239488Smckusick register struct nfsnode *np = VTONFS(vp); 32339341Smckusick int error = 0; 32438414Smckusick 32539874Smckusick if (vp->v_type == VREG && ((np->n_flag & NMODIFIED) || 32639341Smckusick ((np->n_flag & NBUFFERED) && np->n_sillyrename))) { 32739441Smckusick nfs_lock(vp); 32839341Smckusick np->n_flag &= ~(NMODIFIED|NBUFFERED); 32939751Smckusick vinvalbuf(vp, TRUE); 33039341Smckusick if (np->n_flag & NWRITEERR) { 33139341Smckusick np->n_flag &= ~NWRITEERR; 33239751Smckusick error = np->n_error; 33339341Smckusick } 33439441Smckusick nfs_unlock(vp); 33538884Smacklem } 33638414Smckusick return (error); 33738414Smckusick } 33838414Smckusick 33938414Smckusick /* 34038414Smckusick * nfs getattr call from vfs. 34138414Smckusick */ 34238414Smckusick nfs_getattr(vp, vap, cred) 34339488Smckusick register struct vnode *vp; 34439488Smckusick struct vattr *vap; 34538414Smckusick struct ucred *cred; 34638414Smckusick { 34739488Smckusick register caddr_t cp; 34839488Smckusick register long t1; 34939488Smckusick caddr_t bpos, dpos; 35039488Smckusick u_long xid; 35139488Smckusick int error = 0; 35239488Smckusick struct mbuf *mreq, *mrep, *md, *mb, *mb2; 35338414Smckusick 35438414Smckusick /* First look in the cache.. */ 35538414Smckusick if (nfs_getattrcache(vp, vap) == 0) 35638414Smckusick return (0); 35738414Smckusick nfsstats.rpccnt[NFSPROC_GETATTR]++; 35838414Smckusick nfsm_reqhead(nfs_procids[NFSPROC_GETATTR], cred, NFSX_FH); 35938414Smckusick nfsm_fhtom(vp); 36040112Smckusick nfsm_request(vp, nonidempotent[NFSPROC_GETATTR]); 36138414Smckusick nfsm_loadattr(vp, vap); 36238414Smckusick nfsm_reqdone; 36338414Smckusick return (error); 36438414Smckusick } 36538414Smckusick 36638414Smckusick /* 36738414Smckusick * nfs setattr call. 36838414Smckusick */ 36938414Smckusick nfs_setattr(vp, vap, cred) 37039488Smckusick register struct vnode *vp; 37138414Smckusick register struct vattr *vap; 37238414Smckusick struct ucred *cred; 37338414Smckusick { 37438884Smacklem register struct nfsv2_sattr *sp; 37539488Smckusick register caddr_t cp; 37639488Smckusick register long t1; 37739488Smckusick caddr_t bpos, dpos; 37839488Smckusick u_long xid; 37939488Smckusick int error = 0; 38039488Smckusick struct mbuf *mreq, *mrep, *md, *mb, *mb2; 38139359Smckusick struct nfsnode *np; 38238414Smckusick 38338414Smckusick nfsstats.rpccnt[NFSPROC_SETATTR]++; 38438414Smckusick nfsm_reqhead(nfs_procids[NFSPROC_SETATTR], cred, NFSX_FH+NFSX_SATTR); 38538414Smckusick nfsm_fhtom(vp); 38638884Smacklem nfsm_build(sp, struct nfsv2_sattr *, NFSX_SATTR); 38738414Smckusick if (vap->va_mode == 0xffff) 38838884Smacklem sp->sa_mode = VNOVAL; 38938414Smckusick else 39038884Smacklem sp->sa_mode = vtonfs_mode(vp->v_type, vap->va_mode); 39138414Smckusick if (vap->va_uid == 0xffff) 39238884Smacklem sp->sa_uid = VNOVAL; 39338414Smckusick else 39438884Smacklem sp->sa_uid = txdr_unsigned(vap->va_uid); 39538414Smckusick if (vap->va_gid == 0xffff) 39638884Smacklem sp->sa_gid = VNOVAL; 39738414Smckusick else 39838884Smacklem sp->sa_gid = txdr_unsigned(vap->va_gid); 39938884Smacklem sp->sa_size = txdr_unsigned(vap->va_size); 40039359Smckusick if (vap->va_size != VNOVAL) { 40139359Smckusick np = VTONFS(vp); 40239359Smckusick if (np->n_flag & NMODIFIED) { 40339359Smckusick np->n_flag &= ~NMODIFIED; 40439874Smckusick vinvalbuf(vp, TRUE); 40539359Smckusick } 40639359Smckusick } 40739751Smckusick sp->sa_atime.tv_sec = txdr_unsigned(vap->va_atime.tv_sec); 40839751Smckusick sp->sa_atime.tv_usec = txdr_unsigned(vap->va_flags); 40938884Smacklem txdr_time(&vap->va_mtime, &sp->sa_mtime); 41040112Smckusick nfsm_request(vp, nonidempotent[NFSPROC_SETATTR]); 41138414Smckusick nfsm_loadattr(vp, (struct vattr *)0); 41238414Smckusick /* should we fill in any vap fields ?? */ 41338414Smckusick nfsm_reqdone; 41438414Smckusick return (error); 41538414Smckusick } 41638414Smckusick 41738414Smckusick /* 41838414Smckusick * nfs lookup call, one step at a time... 41938414Smckusick * First look in cache 42038414Smckusick * If not found, unlock the directory nfsnode and do the rpc 42138414Smckusick */ 42238414Smckusick nfs_lookup(vp, ndp) 42338414Smckusick register struct vnode *vp; 42438414Smckusick register struct nameidata *ndp; 42538414Smckusick { 42638414Smckusick register struct vnode *vdp; 42739488Smckusick register u_long *p; 42839488Smckusick register caddr_t cp; 42939488Smckusick register long t1, t2; 43039488Smckusick caddr_t bpos, dpos, cp2; 43139488Smckusick u_long xid; 43239488Smckusick struct mbuf *mreq, *mrep, *md, *mb, *mb2; 43338414Smckusick struct vnode *newvp; 43438414Smckusick long len; 43538414Smckusick nfsv2fh_t *fhp; 43638414Smckusick struct nfsnode *np; 43739488Smckusick int lockparent, wantparent, flag, error = 0; 43838414Smckusick 43938414Smckusick ndp->ni_dvp = vp; 44038414Smckusick ndp->ni_vp = NULL; 44138414Smckusick if (vp->v_type != VDIR) 44238414Smckusick return (ENOTDIR); 44338414Smckusick lockparent = ndp->ni_nameiop & LOCKPARENT; 44438414Smckusick flag = ndp->ni_nameiop & OPFLAG; 44538414Smckusick wantparent = ndp->ni_nameiop & (LOCKPARENT|WANTPARENT); 44639341Smckusick if ((error = cache_lookup(ndp)) && error != ENOENT) { 44738884Smacklem struct vattr vattr; 44838884Smacklem int vpid; 44938884Smacklem 45039441Smckusick if (vp == ndp->ni_rdir && ndp->ni_isdotdot) 45139441Smckusick panic("nfs_lookup: .. through root"); 45239441Smckusick vdp = ndp->ni_vp; 45338884Smacklem vpid = vdp->v_id; 45438414Smckusick /* 45538884Smacklem * See the comment starting `Step through' in ufs/ufs_lookup.c 45638884Smacklem * for an explanation of the locking protocol 45738414Smckusick */ 45838414Smckusick if (vp == vdp) { 45938425Smckusick VREF(vdp); 46039441Smckusick error = 0; 46138414Smckusick } else if (ndp->ni_isdotdot) { 46238414Smckusick nfs_unlock(vp); 46339441Smckusick error = vget(vdp); 46438414Smckusick } else { 46539441Smckusick error = vget(vdp); 46638414Smckusick nfs_unlock(vp); 46738414Smckusick } 46839441Smckusick if (!error) { 46940251Smckusick if (vpid == vdp->v_id) { 47040251Smckusick if (!nfs_getattr(vdp, &vattr, ndp->ni_cred) && 47140251Smckusick vattr.va_ctime.tv_sec == VTONFS(vdp)->n_ctime) { 47239441Smckusick nfsstats.lookupcache_hits++; 47339441Smckusick return (0); 47440251Smckusick } else { 47540251Smckusick cache_purge(vdp); 47640251Smckusick nfs_nput(vdp); 47740251Smckusick } 47839441Smckusick } else { 47939441Smckusick nfs_nput(vdp); 48039441Smckusick } 48138884Smacklem } 48238884Smacklem ndp->ni_vp = (struct vnode *)0; 48339751Smckusick } else 48439751Smckusick nfs_unlock(vp); 48539341Smckusick error = 0; 48638414Smckusick nfsstats.lookupcache_misses++; 48738414Smckusick nfsstats.rpccnt[NFSPROC_LOOKUP]++; 48838414Smckusick len = ndp->ni_namelen; 48938414Smckusick nfsm_reqhead(nfs_procids[NFSPROC_LOOKUP], ndp->ni_cred, NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(len)); 49038414Smckusick nfsm_fhtom(vp); 49138414Smckusick nfsm_strtom(ndp->ni_ptr, len, NFS_MAXNAMLEN); 49240112Smckusick nfsm_request(vp, nonidempotent[NFSPROC_LOOKUP]); 49338414Smckusick nfsmout: 49438414Smckusick if (error) { 49539751Smckusick if (lockparent || (flag != CREATE && flag != RENAME) || 49639751Smckusick *ndp->ni_next != 0) 49739751Smckusick nfs_lock(vp); 49840483Smckusick return (error); 49938414Smckusick } 50038414Smckusick nfsm_disect(fhp,nfsv2fh_t *,NFSX_FH); 50138414Smckusick 50238414Smckusick /* 50338414Smckusick * Handle DELETE and RENAME cases... 50438414Smckusick */ 50538414Smckusick if (flag == DELETE && *ndp->ni_next == 0) { 50638414Smckusick if (!bcmp(VTONFS(vp)->n_fh.fh_bytes, (caddr_t)fhp, NFSX_FH)) { 50738425Smckusick VREF(vp); 50838414Smckusick newvp = vp; 50938414Smckusick np = VTONFS(vp); 51038414Smckusick } else { 51138414Smckusick if (error = nfs_nget(vp->v_mount, fhp, &np)) { 51239751Smckusick nfs_lock(vp); 51338414Smckusick m_freem(mrep); 51438414Smckusick return (error); 51538414Smckusick } 51638414Smckusick newvp = NFSTOV(np); 51738414Smckusick } 51839459Smckusick if (error = 51939459Smckusick nfs_loadattrcache(&newvp, &md, &dpos, (struct vattr *)0)) { 52039751Smckusick nfs_lock(vp); 52138414Smckusick if (newvp != vp) 52238414Smckusick nfs_nput(newvp); 52338414Smckusick else 52438425Smckusick vrele(vp); 52538414Smckusick m_freem(mrep); 52638414Smckusick return (error); 52738414Smckusick } 52838414Smckusick ndp->ni_vp = newvp; 52939751Smckusick if (lockparent || vp == newvp) 53039751Smckusick nfs_lock(vp); 53138414Smckusick m_freem(mrep); 53238414Smckusick return (0); 53338414Smckusick } 53438414Smckusick 53538414Smckusick if (flag == RENAME && wantparent && *ndp->ni_next == 0) { 53638414Smckusick if (!bcmp(VTONFS(vp)->n_fh.fh_bytes, (caddr_t)fhp, NFSX_FH)) { 53739751Smckusick nfs_lock(vp); 53838414Smckusick m_freem(mrep); 53938414Smckusick return (EISDIR); 54038414Smckusick } 54138414Smckusick if (error = nfs_nget(vp->v_mount, fhp, &np)) { 54239751Smckusick nfs_lock(vp); 54338414Smckusick m_freem(mrep); 54438414Smckusick return (error); 54538414Smckusick } 54638414Smckusick newvp = NFSTOV(np); 54739459Smckusick if (error = 54839459Smckusick nfs_loadattrcache(&newvp, &md, &dpos, (struct vattr *)0)) { 54939751Smckusick nfs_lock(vp); 55038425Smckusick nfs_nput(newvp); 55138414Smckusick m_freem(mrep); 55238414Smckusick return (error); 55338414Smckusick } 55438414Smckusick ndp->ni_vp = newvp; 55539751Smckusick if (lockparent) 55639751Smckusick nfs_lock(vp); 55738414Smckusick return (0); 55838414Smckusick } 55938414Smckusick 56038414Smckusick if (!bcmp(VTONFS(vp)->n_fh.fh_bytes, (caddr_t)fhp, NFSX_FH)) { 56138425Smckusick VREF(vp); 56238414Smckusick newvp = vp; 56338414Smckusick np = VTONFS(vp); 56438414Smckusick } else if (ndp->ni_isdotdot) { 56538414Smckusick if (error = nfs_nget(vp->v_mount, fhp, &np)) { 56638414Smckusick nfs_lock(vp); 56738414Smckusick m_freem(mrep); 56838414Smckusick return (error); 56938414Smckusick } 57038414Smckusick newvp = NFSTOV(np); 57138414Smckusick } else { 57238414Smckusick if (error = nfs_nget(vp->v_mount, fhp, &np)) { 57339751Smckusick nfs_lock(vp); 57438414Smckusick m_freem(mrep); 57538414Smckusick return (error); 57638414Smckusick } 57738414Smckusick newvp = NFSTOV(np); 57838414Smckusick } 57939459Smckusick if (error = nfs_loadattrcache(&newvp, &md, &dpos, (struct vattr *)0)) { 58039751Smckusick nfs_lock(vp); 58138414Smckusick if (newvp != vp) 58238414Smckusick nfs_nput(newvp); 58338414Smckusick else 58438425Smckusick vrele(vp); 58538414Smckusick m_freem(mrep); 58638414Smckusick return (error); 58738414Smckusick } 58838414Smckusick m_freem(mrep); 58938414Smckusick 59039751Smckusick if (vp == newvp || (lockparent && *ndp->ni_next == '\0')) 59139751Smckusick nfs_lock(vp); 59238414Smckusick ndp->ni_vp = newvp; 59340251Smckusick if (error == 0 && ndp->ni_makeentry) { 59440251Smckusick np->n_ctime = np->n_vattr.va_ctime.tv_sec; 59538414Smckusick cache_enter(ndp); 59640251Smckusick } 59738414Smckusick return (error); 59838414Smckusick } 59938414Smckusick 60038414Smckusick /* 60138414Smckusick * nfs readlink call 60238414Smckusick */ 60338414Smckusick nfs_readlink(vp, uiop, cred) 60439488Smckusick register struct vnode *vp; 60538414Smckusick struct uio *uiop; 60638414Smckusick struct ucred *cred; 60738414Smckusick { 60839488Smckusick register u_long *p; 60939488Smckusick register caddr_t cp; 61039488Smckusick register long t1; 61139488Smckusick caddr_t bpos, dpos, cp2; 61239488Smckusick u_long xid; 61339488Smckusick int error = 0; 61439488Smckusick struct mbuf *mreq, *mrep, *md, *mb, *mb2; 61538414Smckusick long len; 61638414Smckusick 61738414Smckusick nfsstats.rpccnt[NFSPROC_READLINK]++; 61838414Smckusick nfsm_reqhead(nfs_procids[NFSPROC_READLINK], cred, NFSX_FH); 61938414Smckusick nfsm_fhtom(vp); 62040112Smckusick nfsm_request(vp, nonidempotent[NFSPROC_READLINK]); 62138414Smckusick nfsm_strsiz(len, NFS_MAXPATHLEN); 62238414Smckusick nfsm_mtouio(uiop, len); 62338414Smckusick nfsm_reqdone; 62438414Smckusick return (error); 62538414Smckusick } 62638414Smckusick 62738414Smckusick /* 62838414Smckusick * nfs read call 62938414Smckusick */ 63039587Smckusick nfs_readrpc(vp, uiop, cred) 63139488Smckusick register struct vnode *vp; 63238414Smckusick struct uio *uiop; 63338414Smckusick struct ucred *cred; 63438414Smckusick { 63539488Smckusick register u_long *p; 63639488Smckusick register caddr_t cp; 63739488Smckusick register long t1; 63839488Smckusick caddr_t bpos, dpos, cp2; 63939488Smckusick u_long xid; 64039488Smckusick int error = 0; 64139488Smckusick struct mbuf *mreq, *mrep, *md, *mb, *mb2; 64238414Smckusick struct nfsmount *nmp; 64338414Smckusick long len, retlen, tsiz; 64438414Smckusick 64538414Smckusick nmp = vfs_to_nfs(vp->v_mount); 64638414Smckusick tsiz = uiop->uio_resid; 64738414Smckusick while (tsiz > 0) { 64838414Smckusick nfsstats.rpccnt[NFSPROC_READ]++; 64938414Smckusick len = (tsiz > nmp->nm_rsize) ? nmp->nm_rsize : tsiz; 65038414Smckusick nfsm_reqhead(nfs_procids[NFSPROC_READ], cred, NFSX_FH+NFSX_UNSIGNED*3); 65138414Smckusick nfsm_fhtom(vp); 65238414Smckusick nfsm_build(p, u_long *, NFSX_UNSIGNED*3); 65339587Smckusick *p++ = txdr_unsigned(uiop->uio_offset); 65438414Smckusick *p++ = txdr_unsigned(len); 65538414Smckusick *p = 0; 65640112Smckusick nfsm_request(vp, nonidempotent[NFSPROC_READ]); 65738414Smckusick nfsm_loadattr(vp, (struct vattr *)0); 65838414Smckusick nfsm_strsiz(retlen, nmp->nm_rsize); 65938414Smckusick nfsm_mtouio(uiop, retlen); 66038414Smckusick m_freem(mrep); 66138414Smckusick if (retlen < len) 66238414Smckusick tsiz = 0; 66338414Smckusick else 66438414Smckusick tsiz -= len; 66538414Smckusick } 66638414Smckusick nfsmout: 66738414Smckusick return (error); 66838414Smckusick } 66938414Smckusick 67038414Smckusick /* 67138414Smckusick * nfs write call 67238414Smckusick */ 67339587Smckusick nfs_writerpc(vp, uiop, cred) 67439488Smckusick register struct vnode *vp; 67538414Smckusick struct uio *uiop; 67638414Smckusick struct ucred *cred; 67738414Smckusick { 67839488Smckusick register u_long *p; 67939488Smckusick register caddr_t cp; 68039488Smckusick register long t1; 68139488Smckusick caddr_t bpos, dpos; 68239488Smckusick u_long xid; 68339488Smckusick int error = 0; 68439488Smckusick struct mbuf *mreq, *mrep, *md, *mb, *mb2; 68538414Smckusick struct nfsmount *nmp; 68638414Smckusick long len, tsiz; 68738414Smckusick 68838414Smckusick nmp = vfs_to_nfs(vp->v_mount); 68938414Smckusick tsiz = uiop->uio_resid; 69038414Smckusick while (tsiz > 0) { 69138414Smckusick nfsstats.rpccnt[NFSPROC_WRITE]++; 69238414Smckusick len = (tsiz > nmp->nm_wsize) ? nmp->nm_wsize : tsiz; 69338414Smckusick nfsm_reqhead(nfs_procids[NFSPROC_WRITE], cred, 69438414Smckusick NFSX_FH+NFSX_UNSIGNED*4); 69538414Smckusick nfsm_fhtom(vp); 69638414Smckusick nfsm_build(p, u_long *, NFSX_UNSIGNED*4); 69739587Smckusick *(p+1) = txdr_unsigned(uiop->uio_offset); 69838414Smckusick *(p+3) = txdr_unsigned(len); 69938414Smckusick nfsm_uiotom(uiop, len); 70040112Smckusick nfsm_request(vp, nonidempotent[NFSPROC_WRITE]); 70138414Smckusick nfsm_loadattr(vp, (struct vattr *)0); 70238414Smckusick m_freem(mrep); 70338414Smckusick tsiz -= len; 70438414Smckusick } 70538414Smckusick nfsmout: 70638414Smckusick return (error); 70738414Smckusick } 70838414Smckusick 70938414Smckusick /* 71039459Smckusick * nfs mknod call 71139459Smckusick * This call is currently not supported. 71239459Smckusick */ 71339459Smckusick /* ARGSUSED */ 71439459Smckusick nfs_mknod(ndp, vap, cred) 71539459Smckusick struct nameidata *ndp; 71639459Smckusick struct ucred *cred; 71739459Smckusick struct vattr *vap; 71839459Smckusick { 71939459Smckusick 72039459Smckusick nfs_abortop(ndp); 72139459Smckusick return (EOPNOTSUPP); 72239459Smckusick } 72339459Smckusick 72439459Smckusick /* 72538414Smckusick * nfs file create call 72638414Smckusick */ 72738414Smckusick nfs_create(ndp, vap) 72838414Smckusick register struct nameidata *ndp; 72938414Smckusick register struct vattr *vap; 73038414Smckusick { 73138884Smacklem register struct nfsv2_sattr *sp; 73239488Smckusick register u_long *p; 73339488Smckusick register caddr_t cp; 73439488Smckusick register long t1, t2; 73539488Smckusick caddr_t bpos, dpos, cp2; 73639488Smckusick u_long xid; 73739488Smckusick int error = 0; 73839488Smckusick struct mbuf *mreq, *mrep, *md, *mb, *mb2; 73938414Smckusick 74038414Smckusick nfsstats.rpccnt[NFSPROC_CREATE]++; 74138414Smckusick nfsm_reqhead(nfs_procids[NFSPROC_CREATE], ndp->ni_cred, 74238414Smckusick NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(ndp->ni_dent.d_namlen)+NFSX_SATTR); 74338414Smckusick nfsm_fhtom(ndp->ni_dvp); 74438414Smckusick nfsm_strtom(ndp->ni_dent.d_name, ndp->ni_dent.d_namlen, NFS_MAXNAMLEN); 74538884Smacklem nfsm_build(sp, struct nfsv2_sattr *, NFSX_SATTR); 74638884Smacklem sp->sa_mode = vtonfs_mode(VREG, vap->va_mode); 74738884Smacklem sp->sa_uid = txdr_unsigned(ndp->ni_cred->cr_uid); 74838884Smacklem sp->sa_gid = txdr_unsigned(ndp->ni_cred->cr_gid); 74938884Smacklem sp->sa_size = txdr_unsigned(0); 75038414Smckusick /* or should these be VNOVAL ?? */ 75138884Smacklem txdr_time(&vap->va_atime, &sp->sa_atime); 75238884Smacklem txdr_time(&vap->va_mtime, &sp->sa_mtime); 75340112Smckusick nfsm_request(ndp->ni_dvp, nonidempotent[NFSPROC_CREATE]); 75438414Smckusick nfsm_mtofh(ndp->ni_dvp, ndp->ni_vp); 75538414Smckusick nfsm_reqdone; 75640296Smckusick VTONFS(ndp->ni_dvp)->n_direofstamp = 0; 75738414Smckusick nfs_nput(ndp->ni_dvp); 75838414Smckusick return (error); 75938414Smckusick } 76038414Smckusick 76138414Smckusick /* 76238414Smckusick * nfs file remove call 76339341Smckusick * To try and make nfs semantics closer to vfs semantics, a file that has 76439341Smckusick * other references to the vnode is renamed instead of removed and then 76539341Smckusick * removed later on the last close. 76639341Smckusick * Unfortunately you must flush the buffer cache and cmap to get rid of 76739341Smckusick * all extraneous vnode references before you check the reference cnt. 76839341Smckusick * 1 - If the file could have blocks in the buffer cache 76939341Smckusick * flush them out and invalidate them 77039341Smckusick * mpurge the vnode to flush out cmap references 77139341Smckusick * (This is necessary to update the vnode ref cnt as well as sensible 77239341Smckusick * for actual removes, to free up the buffers) 77339810Smckusick * 2 - If v_usecount > 1 77439341Smckusick * If a rename is not already in the works 77539341Smckusick * call nfs_sillyrename() to set it up 77639341Smckusick * else 77739341Smckusick * do the remove rpc 77838414Smckusick */ 77938414Smckusick nfs_remove(ndp) 78038414Smckusick register struct nameidata *ndp; 78138414Smckusick { 78239341Smckusick register struct vnode *vp = ndp->ni_vp; 78339341Smckusick register struct nfsnode *np = VTONFS(ndp->ni_vp); 78439488Smckusick register u_long *p; 78539488Smckusick register caddr_t cp; 78639488Smckusick register long t1, t2; 78739488Smckusick caddr_t bpos, dpos; 78839488Smckusick u_long xid; 78939488Smckusick int error = 0; 79039488Smckusick struct mbuf *mreq, *mrep, *md, *mb, *mb2; 79138414Smckusick 79239341Smckusick if (vp->v_type == VREG) { 79339341Smckusick if (np->n_flag & (NMODIFIED|NBUFFERED)) { 79439341Smckusick np->n_flag &= ~(NMODIFIED|NBUFFERED); 79539874Smckusick vinvalbuf(vp, TRUE); 79639341Smckusick } 79739751Smckusick if (np->n_flag & NPAGEDON) { 79839751Smckusick np->n_flag &= ~NPAGEDON; 79939341Smckusick mpurge(vp); /* In case cmap entries still ref it */ 80039751Smckusick } 80139341Smckusick } 80239810Smckusick if (vp->v_usecount > 1) { 80339341Smckusick if (!np->n_sillyrename) 80439341Smckusick error = nfs_sillyrename(ndp, REMOVE); 80539341Smckusick } else { 80638414Smckusick nfsstats.rpccnt[NFSPROC_REMOVE]++; 80738414Smckusick nfsm_reqhead(nfs_procids[NFSPROC_REMOVE], ndp->ni_cred, 80838414Smckusick NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(ndp->ni_dent.d_namlen)); 80938414Smckusick nfsm_fhtom(ndp->ni_dvp); 81038414Smckusick nfsm_strtom(ndp->ni_dent.d_name, ndp->ni_dent.d_namlen, NFS_MAXNAMLEN); 81140112Smckusick nfsm_request(ndp->ni_dvp, nonidempotent[NFSPROC_REMOVE]); 81238414Smckusick nfsm_reqdone; 81340296Smckusick VTONFS(ndp->ni_dvp)->n_direofstamp = 0; 81439751Smckusick /* 81539751Smckusick * Kludge City: If the first reply to the remove rpc is lost.. 81639751Smckusick * the reply to the retransmitted request will be ENOENT 81739751Smckusick * since the file was in fact removed 81839751Smckusick * Therefore, we cheat and return success. 81939751Smckusick */ 82039751Smckusick if (error == ENOENT) 82139751Smckusick error = 0; 82238414Smckusick } 82340042Smckusick np->n_attrstamp = 0; 82440112Smckusick if (ndp->ni_dvp == vp) 82540112Smckusick vrele(vp); 82638414Smckusick else 82740112Smckusick nfs_nput(ndp->ni_dvp); 82840112Smckusick nfs_nput(vp); 82938414Smckusick return (error); 83038414Smckusick } 83138414Smckusick 83238414Smckusick /* 83338414Smckusick * nfs file remove rpc called from nfs_inactive 83438414Smckusick */ 83538414Smckusick nfs_removeit(ndp) 83638414Smckusick register struct nameidata *ndp; 83738414Smckusick { 83839488Smckusick register u_long *p; 83939488Smckusick register caddr_t cp; 84039488Smckusick register long t1, t2; 84139488Smckusick caddr_t bpos, dpos; 84239488Smckusick u_long xid; 84339488Smckusick int error = 0; 84439488Smckusick struct mbuf *mreq, *mrep, *md, *mb, *mb2; 84538414Smckusick 84638414Smckusick nfsstats.rpccnt[NFSPROC_REMOVE]++; 84738414Smckusick nfsm_reqhead(nfs_procids[NFSPROC_REMOVE], ndp->ni_cred, 84838414Smckusick NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(ndp->ni_dent.d_namlen)); 84938414Smckusick nfsm_fhtom(ndp->ni_dvp); 85038414Smckusick nfsm_strtom(ndp->ni_dent.d_name, ndp->ni_dent.d_namlen, NFS_MAXNAMLEN); 85140112Smckusick nfsm_request(ndp->ni_dvp, nonidempotent[NFSPROC_REMOVE]); 85238414Smckusick nfsm_reqdone; 85340296Smckusick VTONFS(ndp->ni_dvp)->n_direofstamp = 0; 85438414Smckusick return (error); 85538414Smckusick } 85638414Smckusick 85738414Smckusick /* 85838414Smckusick * nfs file rename call 85938414Smckusick */ 86038414Smckusick nfs_rename(sndp, tndp) 86138414Smckusick register struct nameidata *sndp, *tndp; 86238414Smckusick { 86339488Smckusick register u_long *p; 86439488Smckusick register caddr_t cp; 86539488Smckusick register long t1, t2; 86639488Smckusick caddr_t bpos, dpos; 86739488Smckusick u_long xid; 86839488Smckusick int error = 0; 86939488Smckusick struct mbuf *mreq, *mrep, *md, *mb, *mb2; 87038414Smckusick 87138414Smckusick nfsstats.rpccnt[NFSPROC_RENAME]++; 87238414Smckusick nfsm_reqhead(nfs_procids[NFSPROC_RENAME], tndp->ni_cred, 87338414Smckusick (NFSX_FH+NFSX_UNSIGNED)*2+nfsm_rndup(sndp->ni_dent.d_namlen)+ 87438414Smckusick nfsm_rndup(tndp->ni_dent.d_namlen)); /* or sndp->ni_cred?*/ 87538414Smckusick nfsm_fhtom(sndp->ni_dvp); 87638414Smckusick nfsm_strtom(sndp->ni_dent.d_name,sndp->ni_dent.d_namlen,NFS_MAXNAMLEN); 87738414Smckusick nfsm_fhtom(tndp->ni_dvp); 87838414Smckusick nfsm_strtom(tndp->ni_dent.d_name,tndp->ni_dent.d_namlen,NFS_MAXNAMLEN); 87940112Smckusick nfsm_request(sndp->ni_dvp, nonidempotent[NFSPROC_RENAME]); 88038414Smckusick nfsm_reqdone; 88140296Smckusick VTONFS(sndp->ni_dvp)->n_direofstamp = 0; 88240296Smckusick VTONFS(tndp->ni_dvp)->n_direofstamp = 0; 88338414Smckusick if (sndp->ni_vp->v_type == VDIR) { 88438414Smckusick if (tndp->ni_vp != NULL && tndp->ni_vp->v_type == VDIR) 88538414Smckusick cache_purge(tndp->ni_dvp); 88638414Smckusick cache_purge(sndp->ni_dvp); 88738414Smckusick } 88838414Smckusick nfs_abortop(sndp); 88938414Smckusick nfs_abortop(tndp); 89040112Smckusick /* 89140112Smckusick * Kludge: Map ENOENT => 0 assuming that it is a reply to a retry. 89240112Smckusick */ 89340112Smckusick if (error == ENOENT) 89440112Smckusick error = 0; 89538414Smckusick return (error); 89638414Smckusick } 89738414Smckusick 89838414Smckusick /* 89938414Smckusick * nfs file rename rpc called from above 90038414Smckusick */ 90138414Smckusick nfs_renameit(sndp, tndp) 90238414Smckusick register struct nameidata *sndp, *tndp; 90338414Smckusick { 90439488Smckusick register u_long *p; 90539488Smckusick register caddr_t cp; 90639488Smckusick register long t1, t2; 90739488Smckusick caddr_t bpos, dpos; 90839488Smckusick u_long xid; 90939488Smckusick int error = 0; 91039488Smckusick struct mbuf *mreq, *mrep, *md, *mb, *mb2; 91138414Smckusick 91238414Smckusick nfsstats.rpccnt[NFSPROC_RENAME]++; 91338414Smckusick nfsm_reqhead(nfs_procids[NFSPROC_RENAME], tndp->ni_cred, 91438414Smckusick (NFSX_FH+NFSX_UNSIGNED)*2+nfsm_rndup(sndp->ni_dent.d_namlen)+ 91538414Smckusick nfsm_rndup(tndp->ni_dent.d_namlen)); /* or sndp->ni_cred?*/ 91638414Smckusick nfsm_fhtom(sndp->ni_dvp); 91738414Smckusick nfsm_strtom(sndp->ni_dent.d_name,sndp->ni_dent.d_namlen,NFS_MAXNAMLEN); 91838414Smckusick nfsm_fhtom(tndp->ni_dvp); 91938414Smckusick nfsm_strtom(tndp->ni_dent.d_name,tndp->ni_dent.d_namlen,NFS_MAXNAMLEN); 92040112Smckusick nfsm_request(sndp->ni_dvp, nonidempotent[NFSPROC_RENAME]); 92138414Smckusick nfsm_reqdone; 92240296Smckusick VTONFS(sndp->ni_dvp)->n_direofstamp = 0; 92340296Smckusick VTONFS(tndp->ni_dvp)->n_direofstamp = 0; 92438414Smckusick return (error); 92538414Smckusick } 92638414Smckusick 92738414Smckusick /* 92838414Smckusick * nfs hard link create call 92938414Smckusick */ 93038414Smckusick nfs_link(vp, ndp) 93139488Smckusick register struct vnode *vp; 93238414Smckusick register struct nameidata *ndp; 93338414Smckusick { 93439488Smckusick register u_long *p; 93539488Smckusick register caddr_t cp; 93639488Smckusick register long t1, t2; 93739488Smckusick caddr_t bpos, dpos; 93839488Smckusick u_long xid; 93939488Smckusick int error = 0; 94039488Smckusick struct mbuf *mreq, *mrep, *md, *mb, *mb2; 94138414Smckusick 94238425Smckusick if (ndp->ni_dvp != vp) 94338425Smckusick nfs_lock(vp); 94438414Smckusick nfsstats.rpccnt[NFSPROC_LINK]++; 94538414Smckusick nfsm_reqhead(nfs_procids[NFSPROC_LINK], ndp->ni_cred, 94638414Smckusick NFSX_FH*2+NFSX_UNSIGNED+nfsm_rndup(ndp->ni_dent.d_namlen)); 94738414Smckusick nfsm_fhtom(vp); 94838414Smckusick nfsm_fhtom(ndp->ni_dvp); 94938414Smckusick nfsm_strtom(ndp->ni_dent.d_name, ndp->ni_dent.d_namlen, NFS_MAXNAMLEN); 95040112Smckusick nfsm_request(vp, nonidempotent[NFSPROC_LINK]); 95138414Smckusick nfsm_reqdone; 95240042Smckusick VTONFS(vp)->n_attrstamp = 0; 95340296Smckusick VTONFS(ndp->ni_dvp)->n_direofstamp = 0; 95438425Smckusick if (ndp->ni_dvp != vp) 95538425Smckusick nfs_unlock(vp); 95638414Smckusick nfs_nput(ndp->ni_dvp); 95740112Smckusick /* 95840112Smckusick * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry. 95940112Smckusick */ 96040112Smckusick if (error == EEXIST) 96140112Smckusick error = 0; 96238414Smckusick return (error); 96338414Smckusick } 96438414Smckusick 96538414Smckusick /* 96638414Smckusick * nfs symbolic link create call 96738414Smckusick */ 96838414Smckusick nfs_symlink(ndp, vap, nm) 96938414Smckusick struct nameidata *ndp; 97038414Smckusick struct vattr *vap; 97138414Smckusick char *nm; /* is this the path ?? */ 97238414Smckusick { 97338884Smacklem register struct nfsv2_sattr *sp; 97439488Smckusick register u_long *p; 97539488Smckusick register caddr_t cp; 97639488Smckusick register long t1, t2; 97739488Smckusick caddr_t bpos, dpos; 97839488Smckusick u_long xid; 97939488Smckusick int error = 0; 98039488Smckusick struct mbuf *mreq, *mrep, *md, *mb, *mb2; 98138414Smckusick 98238414Smckusick nfsstats.rpccnt[NFSPROC_SYMLINK]++; 98338414Smckusick nfsm_reqhead(nfs_procids[NFSPROC_SYMLINK], ndp->ni_cred, 98438414Smckusick NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(ndp->ni_dent.d_namlen)+NFSX_UNSIGNED); 98538414Smckusick nfsm_fhtom(ndp->ni_dvp); 98638414Smckusick nfsm_strtom(ndp->ni_dent.d_name, ndp->ni_dent.d_namlen, NFS_MAXNAMLEN); 98738414Smckusick nfsm_strtom(nm, strlen(nm), NFS_MAXPATHLEN); 98838884Smacklem nfsm_build(sp, struct nfsv2_sattr *, NFSX_SATTR); 98938884Smacklem sp->sa_mode = vtonfs_mode(VLNK, vap->va_mode); 99038884Smacklem sp->sa_uid = txdr_unsigned(ndp->ni_cred->cr_uid); 99138884Smacklem sp->sa_gid = txdr_unsigned(ndp->ni_cred->cr_gid); 99238884Smacklem sp->sa_size = txdr_unsigned(VNOVAL); 99340112Smckusick txdr_time(&vap->va_atime, &sp->sa_atime); /* or VNOVAL ?? */ 99438884Smacklem txdr_time(&vap->va_mtime, &sp->sa_mtime); /* or VNOVAL ?? */ 99540112Smckusick nfsm_request(ndp->ni_dvp, nonidempotent[NFSPROC_SYMLINK]); 99638414Smckusick nfsm_reqdone; 99740296Smckusick VTONFS(ndp->ni_dvp)->n_direofstamp = 0; 99838414Smckusick nfs_nput(ndp->ni_dvp); 99940112Smckusick /* 100040112Smckusick * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry. 100140112Smckusick */ 100240112Smckusick if (error == EEXIST) 100340112Smckusick error = 0; 100438414Smckusick return (error); 100538414Smckusick } 100638414Smckusick 100738414Smckusick /* 100838414Smckusick * nfs make dir call 100938414Smckusick */ 101038414Smckusick nfs_mkdir(ndp, vap) 101139488Smckusick register struct nameidata *ndp; 101238414Smckusick struct vattr *vap; 101338414Smckusick { 101438884Smacklem register struct nfsv2_sattr *sp; 101539488Smckusick register u_long *p; 101639488Smckusick register caddr_t cp; 101739488Smckusick register long t1, t2; 101839488Smckusick caddr_t bpos, dpos, cp2; 101939488Smckusick u_long xid; 102039488Smckusick int error = 0; 102139488Smckusick struct mbuf *mreq, *mrep, *md, *mb, *mb2; 102238414Smckusick 102338414Smckusick nfsstats.rpccnt[NFSPROC_MKDIR]++; 102438414Smckusick nfsm_reqhead(nfs_procids[NFSPROC_MKDIR], ndp->ni_cred, 102538414Smckusick NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(ndp->ni_dent.d_namlen)+NFSX_SATTR); 102638414Smckusick nfsm_fhtom(ndp->ni_dvp); 102738414Smckusick nfsm_strtom(ndp->ni_dent.d_name, ndp->ni_dent.d_namlen, NFS_MAXNAMLEN); 102838884Smacklem nfsm_build(sp, struct nfsv2_sattr *, NFSX_SATTR); 102938884Smacklem sp->sa_mode = vtonfs_mode(VDIR, vap->va_mode); 103038884Smacklem sp->sa_uid = txdr_unsigned(ndp->ni_cred->cr_uid); 103138884Smacklem sp->sa_gid = txdr_unsigned(ndp->ni_cred->cr_gid); 103238884Smacklem sp->sa_size = txdr_unsigned(VNOVAL); 103340112Smckusick txdr_time(&vap->va_atime, &sp->sa_atime); /* or VNOVAL ?? */ 103438884Smacklem txdr_time(&vap->va_mtime, &sp->sa_mtime); /* or VNOVAL ?? */ 103540112Smckusick nfsm_request(ndp->ni_dvp, nonidempotent[NFSPROC_MKDIR]); 103638414Smckusick nfsm_mtofh(ndp->ni_dvp, ndp->ni_vp); 103738414Smckusick nfsm_reqdone; 103840296Smckusick VTONFS(ndp->ni_dvp)->n_direofstamp = 0; 103938414Smckusick nfs_nput(ndp->ni_dvp); 104040112Smckusick /* 104140112Smckusick * Kludge: Map EEXIST => 0 assuming that you have a reply to a retry. 104240112Smckusick */ 104340112Smckusick if (error == EEXIST) 104440112Smckusick error = 0; 104538414Smckusick return (error); 104638414Smckusick } 104738414Smckusick 104838414Smckusick /* 104938414Smckusick * nfs remove directory call 105038414Smckusick */ 105138414Smckusick nfs_rmdir(ndp) 105238414Smckusick register struct nameidata *ndp; 105338414Smckusick { 105439488Smckusick register u_long *p; 105539488Smckusick register caddr_t cp; 105639488Smckusick register long t1, t2; 105739488Smckusick caddr_t bpos, dpos; 105839488Smckusick u_long xid; 105939488Smckusick int error = 0; 106039488Smckusick struct mbuf *mreq, *mrep, *md, *mb, *mb2; 106138414Smckusick 106238414Smckusick if (ndp->ni_dvp == ndp->ni_vp) { 106338414Smckusick vrele(ndp->ni_dvp); 106438414Smckusick nfs_nput(ndp->ni_dvp); 106538414Smckusick return (EINVAL); 106638414Smckusick } 106738414Smckusick nfsstats.rpccnt[NFSPROC_RMDIR]++; 106838414Smckusick nfsm_reqhead(nfs_procids[NFSPROC_RMDIR], ndp->ni_cred, 106938414Smckusick NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(ndp->ni_dent.d_namlen)); 107038414Smckusick nfsm_fhtom(ndp->ni_dvp); 107138414Smckusick nfsm_strtom(ndp->ni_dent.d_name, ndp->ni_dent.d_namlen, NFS_MAXNAMLEN); 107240112Smckusick nfsm_request(ndp->ni_dvp, nonidempotent[NFSPROC_RMDIR]); 107338414Smckusick nfsm_reqdone; 107440296Smckusick VTONFS(ndp->ni_dvp)->n_direofstamp = 0; 107538884Smacklem cache_purge(ndp->ni_dvp); 107638884Smacklem cache_purge(ndp->ni_vp); 107738884Smacklem nfs_nput(ndp->ni_vp); 107838884Smacklem nfs_nput(ndp->ni_dvp); 107940112Smckusick /* 108040112Smckusick * Kludge: Map ENOENT => 0 assuming that you have a reply to a retry. 108140112Smckusick */ 108240112Smckusick if (error == ENOENT) 108340112Smckusick error = 0; 108438414Smckusick return (error); 108538414Smckusick } 108638414Smckusick 108738414Smckusick /* 108838414Smckusick * nfs readdir call 108938414Smckusick * Although cookie is defined as opaque, I translate it to/from net byte 109038414Smckusick * order so that it looks more sensible. This appears consistent with the 109138414Smckusick * Ultrix implementation of NFS. 109238414Smckusick */ 1093*40833Smckusick int direof = 0; 109440296Smckusick nfs_readdir(vp, uiop, cred, eofflagp) 109539488Smckusick register struct vnode *vp; 109638414Smckusick struct uio *uiop; 109738414Smckusick struct ucred *cred; 109840296Smckusick int *eofflagp; 109938414Smckusick { 110038414Smckusick register long len; 110138414Smckusick register struct direct *dp; 110239488Smckusick register u_long *p; 110339488Smckusick register caddr_t cp; 110439488Smckusick register long t1; 110540113Smckusick long tlen; 110639488Smckusick caddr_t bpos, dpos, cp2; 110739488Smckusick u_long xid; 110839488Smckusick int error = 0; 110939488Smckusick struct mbuf *mreq, *mrep, *md, *mb, *mb2; 111038414Smckusick struct mbuf *md2; 111138414Smckusick caddr_t dpos2; 111238414Smckusick int siz; 111340296Smckusick int more_dirs = 1; 111438414Smckusick off_t off, savoff; 111538414Smckusick struct direct *savdp; 111640296Smckusick struct nfsmount *nmp; 111740296Smckusick struct nfsnode *np = VTONFS(vp); 111840296Smckusick long tresid; 111938414Smckusick 112040296Smckusick /* 112140296Smckusick * First, check for hit on the EOF offset cache 112240296Smckusick */ 1123*40833Smckusick if (direof) 112440296Smckusick if (uiop->uio_offset != 0 && uiop->uio_offset == np->n_direofoffset && 112540296Smckusick (time.tv_sec - np->n_direofstamp) < NFS_ATTRTIMEO) { 112640296Smckusick *eofflagp = 1; 112740296Smckusick nfsstats.direofcache_hits++; 112840296Smckusick return (0); 112940296Smckusick } 113038414Smckusick 113140296Smckusick nmp = vfs_to_nfs(vp->v_mount); 113240296Smckusick tresid = uiop->uio_resid; 113340296Smckusick /* 113440296Smckusick * Loop around doing readdir rpc's of size uio_resid or nm_rsize, 113540296Smckusick * whichever is smaller, truncated to a multiple of DIRBLKSIZ. 113640296Smckusick * The stopping criteria is EOF or less than DIRBLKSIZ of the 113740296Smckusick * request left. 113840296Smckusick */ 113940296Smckusick while (more_dirs && uiop->uio_resid >= DIRBLKSIZ) { 114040296Smckusick nfsstats.rpccnt[NFSPROC_READDIR]++; 114140296Smckusick nfsm_reqhead(nfs_procids[NFSPROC_READDIR], cred, xid); 114240296Smckusick nfsm_fhtom(vp); 114340296Smckusick nfsm_build(p, u_long *, 2*NFSX_UNSIGNED); 114440296Smckusick *p++ = txdr_unsigned(uiop->uio_offset); 114540296Smckusick *p = txdr_unsigned(((uiop->uio_resid > nmp->nm_rsize) ? 114640296Smckusick nmp->nm_rsize : uiop->uio_resid) & ~(DIRBLKSIZ-1)); 114740296Smckusick nfsm_request(vp, nonidempotent[NFSPROC_READDIR]); 114840296Smckusick siz = 0; 114940296Smckusick nfsm_disect(p, u_long *, NFSX_UNSIGNED); 115040296Smckusick more_dirs = fxdr_unsigned(int, *p); 115140296Smckusick 115240296Smckusick /* Save the position so that we can do nfsm_mtouio() later */ 115340296Smckusick dpos2 = dpos; 115440296Smckusick md2 = md; 115540296Smckusick 115640296Smckusick /* loop thru the dir entries, doctoring them to 4bsd form */ 115740296Smckusick savoff = off = 0; 115840296Smckusick savdp = dp = NULL; 115940296Smckusick while (more_dirs && siz < uiop->uio_resid) { 116040296Smckusick savoff = off; /* Hold onto offset and dp */ 116140296Smckusick savdp = dp; 116240296Smckusick nfsm_disecton(p, u_long *, 2*NFSX_UNSIGNED); 116340296Smckusick dp = (struct direct *)p; 116440296Smckusick dp->d_ino = fxdr_unsigned(u_long, *p++); 116540296Smckusick len = fxdr_unsigned(int, *p); 116640296Smckusick if (len <= 0 || len > NFS_MAXNAMLEN) { 116740296Smckusick error = EBADRPC; 116840296Smckusick m_freem(mrep); 116940296Smckusick goto nfsmout; 117040296Smckusick } 117140296Smckusick dp->d_namlen = (u_short)len; 117240296Smckusick nfsm_adv(len); /* Point past name */ 117340296Smckusick tlen = nfsm_rndup(len); 117440296Smckusick /* 117540296Smckusick * This should not be necessary, but some servers have 117640296Smckusick * broken XDR such that these bytes are not null filled. 117740296Smckusick */ 117840296Smckusick if (tlen != len) { 117940296Smckusick *dpos = '\0'; /* Null-terminate */ 118040296Smckusick nfsm_adv(tlen - len); 118140296Smckusick len = tlen; 118240296Smckusick } 118340296Smckusick nfsm_disecton(p, u_long *, 2*NFSX_UNSIGNED); 118440296Smckusick off = fxdr_unsigned(off_t, *p); 118540296Smckusick *p++ = 0; /* Ensures null termination of name */ 118640296Smckusick more_dirs = fxdr_unsigned(int, *p); 118740296Smckusick dp->d_reclen = len+4*NFSX_UNSIGNED; 118840296Smckusick siz += dp->d_reclen; 118940296Smckusick } 119040296Smckusick /* 119140296Smckusick * If at end of rpc data, get the eof boolean 119240296Smckusick */ 119340296Smckusick if (!more_dirs) { 119440296Smckusick nfsm_disecton(p, u_long *, NFSX_UNSIGNED); 119540296Smckusick more_dirs = (fxdr_unsigned(int, *p) == 0); 119638414Smckusick 119740296Smckusick /* 119840296Smckusick * If at EOF, cache directory offset 119940296Smckusick */ 120040296Smckusick if (!more_dirs) { 120140296Smckusick np->n_direofoffset = off; 120240296Smckusick np->n_direofstamp = time.tv_sec; 120340296Smckusick } 120438414Smckusick } 120540296Smckusick /* 120640296Smckusick * If there is too much to fit in the data buffer, use savoff and 120740296Smckusick * savdp to trim off the last record. 120840296Smckusick * --> we are not at eof 120940296Smckusick */ 121040296Smckusick if (siz > uiop->uio_resid) { 121140296Smckusick off = savoff; 121240296Smckusick siz -= dp->d_reclen; 121340296Smckusick dp = savdp; 121440296Smckusick more_dirs = 0; /* Paranoia */ 121540113Smckusick } 121640296Smckusick if (siz > 0) { 121740296Smckusick md = md2; 121840296Smckusick dpos = dpos2; 121940296Smckusick nfsm_mtouio(uiop, siz); 122040296Smckusick uiop->uio_offset = off; 122140296Smckusick } else 122240296Smckusick more_dirs = 0; /* Ugh, never happens, but in case.. */ 122340296Smckusick m_freem(mrep); 122438414Smckusick } 122540296Smckusick nfsmout: 122640296Smckusick if (tresid == uiop->uio_resid) { 122740296Smckusick *eofflagp = 1; 122840296Smckusick nfsstats.direofcache_misses++; 122940296Smckusick } else { 123040296Smckusick *eofflagp = 0; 123138414Smckusick } 123238414Smckusick return (error); 123338414Smckusick } 123438414Smckusick 123538414Smckusick /* 123638414Smckusick * nfs statfs call 123738414Smckusick * (Actually a vfsop, not a vnode op) 123838414Smckusick */ 123938414Smckusick nfs_statfs(mp, sbp) 124038414Smckusick struct mount *mp; 124138414Smckusick register struct statfs *sbp; 124238414Smckusick { 124339488Smckusick register struct vnode *vp; 124438884Smacklem register struct nfsv2_statfs *sfp; 124539488Smckusick register caddr_t cp; 124639488Smckusick register long t1; 124739488Smckusick caddr_t bpos, dpos, cp2; 124839488Smckusick u_long xid; 124939488Smckusick int error = 0; 125039488Smckusick struct mbuf *mreq, *mrep, *md, *mb, *mb2; 125138884Smacklem struct nfsmount *nmp; 125238414Smckusick struct ucred *cred; 125338414Smckusick struct nfsnode *np; 125438414Smckusick 125538414Smckusick nmp = vfs_to_nfs(mp); 125638414Smckusick if (error = nfs_nget(mp, &nmp->nm_fh, &np)) 125738414Smckusick return (error); 125838414Smckusick vp = NFSTOV(np); 125938414Smckusick nfsstats.rpccnt[NFSPROC_STATFS]++; 126038414Smckusick cred = crget(); 126138414Smckusick cred->cr_ngroups = 1; 126238414Smckusick nfsm_reqhead(nfs_procids[NFSPROC_STATFS], cred, NFSX_FH); 126338414Smckusick nfsm_fhtom(vp); 126440112Smckusick nfsm_request(vp, nonidempotent[NFSPROC_STATFS]); 126538884Smacklem nfsm_disect(sfp, struct nfsv2_statfs *, NFSX_STATFS); 126638414Smckusick sbp->f_type = MOUNT_NFS; 126739751Smckusick sbp->f_flags = nmp->nm_flag; 126838884Smacklem sbp->f_bsize = fxdr_unsigned(long, sfp->sf_tsize); 126938884Smacklem sbp->f_fsize = fxdr_unsigned(long, sfp->sf_bsize); 127038884Smacklem sbp->f_blocks = fxdr_unsigned(long, sfp->sf_blocks); 127138884Smacklem sbp->f_bfree = fxdr_unsigned(long, sfp->sf_bfree); 127238884Smacklem sbp->f_bavail = fxdr_unsigned(long, sfp->sf_bavail); 127338739Smckusick sbp->f_files = 0; 127438739Smckusick sbp->f_ffree = 0; 127540349Smckusick if (sbp != &mp->m_stat) { 127640349Smckusick bcopy(mp->m_stat.f_mntonname, sbp->f_mntonname, MNAMELEN); 127740349Smckusick bcopy(mp->m_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN); 127840349Smckusick } 127938414Smckusick nfsm_reqdone; 128038414Smckusick nfs_nput(vp); 128138414Smckusick crfree(cred); 128238414Smckusick return (error); 128338414Smckusick } 128438414Smckusick 128539488Smckusick static char hextoasc[] = "0123456789abcdef"; 128638414Smckusick 128738414Smckusick /* 128838414Smckusick * Silly rename. To make the NFS filesystem that is stateless look a little 128938414Smckusick * more like the "ufs" a remove of an active vnode is translated to a rename 129038414Smckusick * to a funny looking filename that is removed by nfs_inactive on the 129138414Smckusick * nfsnode. There is the potential for another process on a different client 129238414Smckusick * to create the same funny name between the nfs_lookitup() fails and the 129338414Smckusick * nfs_rename() completes, but... 129438414Smckusick */ 129538414Smckusick nfs_sillyrename(ndp, flag) 129639488Smckusick register struct nameidata *ndp; 129738414Smckusick int flag; 129838414Smckusick { 129938414Smckusick register struct nfsnode *np; 130038414Smckusick register struct sillyrename *sp; 130138414Smckusick register struct nameidata *tndp; 130238414Smckusick int error; 130338414Smckusick short pid; 130438414Smckusick 130538414Smckusick np = VTONFS(ndp->ni_dvp); 130639341Smckusick cache_purge(ndp->ni_dvp); 130738414Smckusick MALLOC(sp, struct sillyrename *, sizeof (struct sillyrename), 130838884Smacklem M_TEMP, M_WAITOK); 130938414Smckusick sp->s_flag = flag; 131038414Smckusick bcopy((caddr_t)&np->n_fh, (caddr_t)&sp->s_fh, NFSX_FH); 131138414Smckusick np = VTONFS(ndp->ni_vp); 131238414Smckusick tndp = &sp->s_namei; 131338414Smckusick tndp->ni_cred = crdup(ndp->ni_cred); 131438414Smckusick 131538414Smckusick /* Fudge together a funny name */ 131638414Smckusick pid = u.u_procp->p_pid; 131738414Smckusick bcopy(".nfsAxxxx4.4", tndp->ni_dent.d_name, 13); 131838414Smckusick tndp->ni_dent.d_namlen = 12; 131939488Smckusick tndp->ni_dent.d_name[8] = hextoasc[pid & 0xf]; 132039488Smckusick tndp->ni_dent.d_name[7] = hextoasc[(pid >> 4) & 0xf]; 132139488Smckusick tndp->ni_dent.d_name[6] = hextoasc[(pid >> 8) & 0xf]; 132239488Smckusick tndp->ni_dent.d_name[5] = hextoasc[(pid >> 12) & 0xf]; 132338414Smckusick 132438414Smckusick /* Try lookitups until we get one that isn't there */ 132538414Smckusick while (nfs_lookitup(ndp->ni_dvp, tndp, (nfsv2fh_t *)0) == 0) { 132638414Smckusick tndp->ni_dent.d_name[4]++; 132738414Smckusick if (tndp->ni_dent.d_name[4] > 'z') { 132838414Smckusick error = EINVAL; 132938414Smckusick goto bad; 133038414Smckusick } 133138414Smckusick } 133238414Smckusick if (error = nfs_renameit(ndp, tndp)) 133338414Smckusick goto bad; 133438414Smckusick nfs_lookitup(ndp->ni_dvp, tndp, &np->n_fh); 133538414Smckusick np->n_sillyrename = sp; 133638414Smckusick return (0); 133738414Smckusick bad: 133838884Smacklem crfree(tndp->ni_cred); 133938414Smckusick free((caddr_t)sp, M_TEMP); 134038414Smckusick return (error); 134138414Smckusick } 134238414Smckusick 134338414Smckusick /* 134438414Smckusick * Look up a file name for silly rename stuff. 134538414Smckusick * Just like nfs_lookup() except that it doesn't load returned values 134638414Smckusick * into the nfsnode table. 134738414Smckusick * If fhp != NULL it copies the returned file handle out 134838414Smckusick */ 134938414Smckusick nfs_lookitup(vp, ndp, fhp) 135038414Smckusick register struct vnode *vp; 135138414Smckusick register struct nameidata *ndp; 135238414Smckusick nfsv2fh_t *fhp; 135338414Smckusick { 135439488Smckusick register u_long *p; 135539488Smckusick register caddr_t cp; 135639488Smckusick register long t1, t2; 135739488Smckusick caddr_t bpos, dpos, cp2; 135839488Smckusick u_long xid; 135939488Smckusick int error = 0; 136039488Smckusick struct mbuf *mreq, *mrep, *md, *mb, *mb2; 136138414Smckusick long len; 136238414Smckusick 136338414Smckusick nfsstats.rpccnt[NFSPROC_LOOKUP]++; 136438414Smckusick ndp->ni_dvp = vp; 136538414Smckusick ndp->ni_vp = NULL; 136638414Smckusick len = ndp->ni_dent.d_namlen; 136738414Smckusick nfsm_reqhead(nfs_procids[NFSPROC_LOOKUP], ndp->ni_cred, NFSX_FH+NFSX_UNSIGNED+nfsm_rndup(len)); 136838414Smckusick nfsm_fhtom(vp); 136938414Smckusick nfsm_strtom(ndp->ni_dent.d_name, len, NFS_MAXNAMLEN); 137040112Smckusick nfsm_request(vp, nonidempotent[NFSPROC_LOOKUP]); 137138414Smckusick if (fhp != NULL) { 137238414Smckusick nfsm_disect(cp, caddr_t, NFSX_FH); 137338414Smckusick bcopy(cp, (caddr_t)fhp, NFSX_FH); 137438414Smckusick } 137538414Smckusick nfsm_reqdone; 137638414Smckusick return (error); 137738414Smckusick } 137838414Smckusick 137938414Smckusick /* 138038414Smckusick * Kludge City.. 138138414Smckusick * - make nfs_bmap() essentially a no-op that does no translation 138238414Smckusick * - do nfs_strategy() by faking physical I/O with nfs_readit/nfs_writeit 138338414Smckusick * after mapping the physical addresses into Kernel Virtual space in the 138438414Smckusick * nfsiobuf area. 138538414Smckusick * (Maybe I could use the process's page mapping, but I was concerned that 138638414Smckusick * Kernel Write might not be enabled and also figured copyout() would do 138738414Smckusick * a lot more work than bcopy() and also it currently happens in the 138838414Smckusick * context of the swapper process (2). 138938414Smckusick */ 139038414Smckusick nfs_bmap(vp, bn, vpp, bnp) 139138414Smckusick struct vnode *vp; 139238414Smckusick daddr_t bn; 139338414Smckusick struct vnode **vpp; 139438414Smckusick daddr_t *bnp; 139538414Smckusick { 139638414Smckusick if (vpp != NULL) 139738414Smckusick *vpp = vp; 139838414Smckusick if (bnp != NULL) 139940349Smckusick *bnp = bn * btodb(vp->v_mount->m_stat.f_bsize); 140038414Smckusick return (0); 140138414Smckusick } 140238414Smckusick 140338414Smckusick /* 140438884Smacklem * Strategy routine for phys. i/o 140538884Smacklem * If the biod's are running, queue a request 140638884Smacklem * otherwise just call nfs_doio() to get it done 140738414Smckusick */ 140838414Smckusick nfs_strategy(bp) 140938414Smckusick register struct buf *bp; 141038414Smckusick { 141138884Smacklem register struct buf *dp; 141239341Smckusick register int i; 141338884Smacklem struct proc *rp; 141438884Smacklem int error = 0; 141539341Smckusick int fnd = 0; 141638884Smacklem 141738884Smacklem /* 141838884Smacklem * If an i/o daemon is waiting 141938884Smacklem * queue the request, wake it up and wait for completion 142038884Smacklem * otherwise just do it ourselves 142138884Smacklem */ 142239341Smckusick for (i = 0; i < nfs_asyncdaemons; i++) { 142339341Smckusick if (rp = nfs_iodwant[i]) { 142439341Smckusick /* 142539341Smckusick * Ensure that the async_daemon is still waiting here 142639341Smckusick */ 142739341Smckusick if (rp->p_stat != SSLEEP || 142839341Smckusick rp->p_wchan != ((caddr_t)&nfs_iodwant[i])) { 142939341Smckusick nfs_iodwant[i] = (struct proc *)0; 143039341Smckusick continue; 143139341Smckusick } 143239341Smckusick dp = &nfs_bqueue; 143339341Smckusick if (dp->b_actf == NULL) { 143439341Smckusick dp->b_actl = bp; 143539341Smckusick bp->b_actf = dp; 143639341Smckusick } else { 143739341Smckusick dp->b_actf->b_actl = bp; 143839341Smckusick bp->b_actf = dp->b_actf; 143939341Smckusick } 144039341Smckusick dp->b_actf = bp; 144139341Smckusick bp->b_actl = dp; 144239341Smckusick fnd++; 144339341Smckusick nfs_iodwant[i] = (struct proc *)0; 144439341Smckusick wakeup((caddr_t)&nfs_iodwant[i]); 144539341Smckusick break; 144638884Smacklem } 144739341Smckusick } 144839341Smckusick if (!fnd) 144938884Smacklem error = nfs_doio(bp); 145038884Smacklem return (error); 145138884Smacklem } 145238884Smacklem 145338884Smacklem /* 145438884Smacklem * Fun and games with i/o 145538884Smacklem * Essentially play ubasetup() and disk interrupt service routine by 145638884Smacklem * mapping the data buffer into kernel virtual space and doing the 145738884Smacklem * nfs read or write rpc's from it. 145838884Smacklem * If the biod's are not running, this is just called from nfs_strategy(), 145938884Smacklem * otherwise it is called by the biod's to do what would normally be 146038884Smacklem * partially disk interrupt driven. 146138884Smacklem */ 146238884Smacklem nfs_doio(bp) 146338884Smacklem register struct buf *bp; 146438884Smacklem { 146538414Smckusick register struct pte *pte, *ppte; 146638414Smckusick register caddr_t vaddr; 146738414Smckusick register struct uio *uiop; 146838414Smckusick register struct vnode *vp; 146939341Smckusick struct nfsnode *np; 147038884Smacklem struct ucred *cr; 147138884Smacklem int npf, npf2; 147238884Smacklem int reg; 147338884Smacklem caddr_t vbase; 147438414Smckusick unsigned v; 147538414Smckusick struct proc *rp; 147638414Smckusick int o, error; 147738414Smckusick struct uio uio; 147838414Smckusick struct iovec io; 147938414Smckusick 148038414Smckusick vp = bp->b_vp; 148140251Smckusick np = VTONFS(vp); 148238414Smckusick uiop = &uio; 148338414Smckusick uiop->uio_iov = &io; 148438414Smckusick uiop->uio_iovcnt = 1; 148538414Smckusick uiop->uio_segflg = UIO_SYSSPACE; 148639751Smckusick 148738414Smckusick /* 148838884Smacklem * For phys i/o, map the b_addr into kernel virtual space using 148938884Smacklem * the Nfsiomap pte's 149038884Smacklem * Also, add a temporary b_rcred for reading using the process's uid 149138884Smacklem * and a guess at a group 149238414Smckusick */ 149338884Smacklem if (bp->b_flags & B_PHYS) { 149440251Smckusick np->n_flag |= NPAGEDON; 149538884Smacklem bp->b_rcred = cr = crget(); 149638884Smacklem rp = (bp->b_flags & B_DIRTY) ? &proc[2] : bp->b_proc; 149738884Smacklem cr->cr_uid = rp->p_uid; 149838884Smacklem cr->cr_gid = 0; /* Anything ?? */ 149938884Smacklem cr->cr_ngroups = 1; 150039751Smckusick o = (int)bp->b_un.b_addr & PGOFSET; 150139751Smckusick npf2 = npf = btoc(bp->b_bcount + o); 150239751Smckusick 150338884Smacklem /* 150438884Smacklem * Get some mapping page table entries 150538884Smacklem */ 150638884Smacklem while ((reg = rmalloc(nfsmap, (long)npf)) == 0) { 150738884Smacklem nfsmap_want++; 150838884Smacklem sleep((caddr_t)&nfsmap_want, PZERO-1); 150938884Smacklem } 151038884Smacklem reg--; 151139751Smckusick if (bp->b_flags & B_PAGET) 151239751Smckusick pte = &Usrptmap[btokmx((struct pte *)bp->b_un.b_addr)]; 151338884Smacklem else { 151439751Smckusick v = btop(bp->b_un.b_addr); 151538884Smacklem if (bp->b_flags & B_UAREA) 151638884Smacklem pte = &rp->p_addr[v]; 151738884Smacklem else 151838884Smacklem pte = vtopte(rp, v); 151938884Smacklem } 152039751Smckusick 152138884Smacklem /* 152238884Smacklem * Play vmaccess() but with the Nfsiomap page table 152338884Smacklem */ 152438884Smacklem ppte = &Nfsiomap[reg]; 152538884Smacklem vbase = vaddr = &nfsiobuf[reg*NBPG]; 152638884Smacklem while (npf != 0) { 152738884Smacklem mapin(ppte, (u_int)vaddr, pte->pg_pfnum, (int)(PG_V|PG_KW)); 152838414Smckusick #if defined(tahoe) 152938884Smacklem mtpr(P1DC, vaddr); 153038414Smckusick #endif 153138884Smacklem ppte++; 153238884Smacklem pte++; 153338884Smacklem vaddr += NBPG; 153438884Smacklem --npf; 153538884Smacklem } 153639751Smckusick 153739751Smckusick /* 153839751Smckusick * And do the i/o rpc 153939751Smckusick */ 154038884Smacklem io.iov_base = vbase+o; 154139751Smckusick io.iov_len = uiop->uio_resid = bp->b_bcount; 154239823Smckusick uiop->uio_offset = bp->b_blkno * DEV_BSIZE; 154339751Smckusick if (bp->b_flags & B_READ) { 154439751Smckusick uiop->uio_rw = UIO_READ; 154539751Smckusick nfsstats.read_physios++; 154639751Smckusick bp->b_error = error = nfs_readrpc(vp, uiop, bp->b_rcred); 154740251Smckusick /* 154840251Smckusick * If a text file has been modified since it was exec'd 154940251Smckusick * blow the process' out of the water. This is the 155040251Smckusick * closest we can come to "Text File Busy" in good old 155140251Smckusick * stateless nfs. 155240251Smckusick */ 155340251Smckusick if ((vp->v_flag & VTEXT) && 155440251Smckusick (vp->v_text->x_mtime != np->n_vattr.va_mtime.tv_sec)) 155540251Smckusick xinval(vp); 155639751Smckusick } else { 155739751Smckusick uiop->uio_rw = UIO_WRITE; 155839751Smckusick nfsstats.write_physios++; 155939751Smckusick bp->b_error = error = nfs_writerpc(vp, uiop, bp->b_wcred); 156039341Smckusick } 156139751Smckusick 156239751Smckusick /* 156339751Smckusick * Finally, release pte's used by physical i/o 156439751Smckusick */ 156538884Smacklem crfree(cr); 156638884Smacklem rmfree(nfsmap, (long)npf2, (long)++reg); 156738884Smacklem if (nfsmap_want) { 156838884Smacklem nfsmap_want = 0; 156938884Smacklem wakeup((caddr_t)&nfsmap_want); 157038884Smacklem } 157139751Smckusick } else { 157239751Smckusick if (bp->b_flags & B_READ) { 157339751Smckusick io.iov_len = uiop->uio_resid = bp->b_bcount; 157439823Smckusick uiop->uio_offset = bp->b_blkno * DEV_BSIZE; 157539751Smckusick io.iov_base = bp->b_un.b_addr; 157639751Smckusick uiop->uio_rw = UIO_READ; 157739751Smckusick nfsstats.read_bios++; 157839751Smckusick bp->b_error = error = nfs_readrpc(vp, uiop, bp->b_rcred); 157939751Smckusick } else { 158039751Smckusick io.iov_len = uiop->uio_resid = bp->b_dirtyend 158139751Smckusick - bp->b_dirtyoff; 158239823Smckusick uiop->uio_offset = (bp->b_blkno * DEV_BSIZE) 158339751Smckusick + bp->b_dirtyoff; 158439751Smckusick io.iov_base = bp->b_un.b_addr + bp->b_dirtyoff; 158539751Smckusick uiop->uio_rw = UIO_WRITE; 158639751Smckusick nfsstats.write_bios++; 158739751Smckusick bp->b_error = error = nfs_writerpc(vp, uiop, bp->b_wcred); 158839751Smckusick if (error) { 158939751Smckusick np->n_error = error; 159039751Smckusick np->n_flag |= NWRITEERR; 159139751Smckusick } 159239751Smckusick bp->b_dirtyoff = bp->b_dirtyend = 0; 159339751Smckusick } 159438884Smacklem } 159539751Smckusick if (error) 159639751Smckusick bp->b_flags |= B_ERROR; 159739751Smckusick bp->b_resid = uiop->uio_resid; 159838414Smckusick biodone(bp); 159938414Smckusick return (error); 160038414Smckusick } 160138884Smacklem 160238884Smacklem /* 160338884Smacklem * Flush all the blocks associated with a vnode. 160438884Smacklem * Walk through the buffer pool and push any dirty pages 160538884Smacklem * associated with the vnode. 160638884Smacklem */ 160739488Smckusick /* ARGSUSED */ 160839587Smckusick nfs_fsync(vp, fflags, cred, waitfor) 160938884Smacklem register struct vnode *vp; 161038884Smacklem int fflags; 161138884Smacklem struct ucred *cred; 161239587Smckusick int waitfor; 161338884Smacklem { 161438884Smacklem register struct nfsnode *np = VTONFS(vp); 161539751Smckusick int error = 0; 161638884Smacklem 161738884Smacklem if (np->n_flag & NMODIFIED) { 161838884Smacklem np->n_flag &= ~NMODIFIED; 161939751Smckusick vflushbuf(vp, waitfor == MNT_WAIT ? B_SYNC : 0); 162038884Smacklem } 162139751Smckusick if (!error && (np->n_flag & NWRITEERR)) 162239751Smckusick error = np->n_error; 162338884Smacklem return (error); 162438884Smacklem } 162539672Smckusick 162639672Smckusick /* 162739672Smckusick * Print out the contents of an nfsnode. 162839672Smckusick */ 162939672Smckusick nfs_print(vp) 163039672Smckusick struct vnode *vp; 163139672Smckusick { 163239672Smckusick register struct nfsnode *np = VTONFS(vp); 163339672Smckusick 163440294Smckusick printf("tag VT_NFS, fileid %d fsid 0x%x", 163540294Smckusick np->n_vattr.va_fileid, np->n_vattr.va_fsid); 163640294Smckusick #ifdef FIFO 163740294Smckusick if (vp->v_type == VFIFO) 163840294Smckusick fifo_printinfo(vp); 163940294Smckusick #endif /* FIFO */ 164040294Smckusick printf("%s\n", (np->n_flag & NLOCKED) ? " (LOCKED)" : ""); 164139914Smckusick if (np->n_lockholder == 0) 164239914Smckusick return; 164339914Smckusick printf("\towner pid %d", np->n_lockholder); 164439914Smckusick if (np->n_lockwaiter) 164539914Smckusick printf(" waiting pid %d", np->n_lockwaiter); 164639914Smckusick printf("\n"); 164739672Smckusick } 1648