*
* @(#)nfs_serv.c 8.8 (Berkeley) 7/31/95
* $FreeBSD: src/sys/nfs/nfs_serv.c,v 1.93.2.6 2002/12/29 18:19:53 dillon Exp $
- * $DragonFly: src/sys/vfs/nfs/nfs_serv.c,v 1.4 2003/06/23 17:55:48 dillon Exp $
+ * $DragonFly: src/sys/vfs/nfs/nfs_serv.c,v 1.5 2003/06/25 03:56:07 dillon Exp $
*/
/*
SYSCTL_INT(_vfs_nfs, OID_AUTO, commit_miss, CTLFLAG_RW, &nfs_commit_miss, 0, "");
static int nfsrv_access __P((struct vnode *,int,struct ucred *,int,
- struct proc *, int));
+ struct thread *, int));
static void nfsrvw_coalesce __P((struct nfsrv_descript *,
struct nfsrv_descript *));
* nfs v3 access service
*/
int
-nfsrv3_access(nfsd, slp, procp, mrq)
- struct nfsrv_descript *nfsd;
- struct nfssvc_sock *slp;
- struct proc *procp;
- struct mbuf **mrq;
+nfsrv3_access(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
+ struct thread *td, struct mbuf **mrq)
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
struct sockaddr *nam = nfsd->nd_nam;
struct vnode *vp = NULL;
nfsfh_t nfh;
fhandle_t *fhp;
- register u_int32_t *tl;
- register int32_t t1;
+ u_int32_t *tl;
+ int32_t t1;
caddr_t bpos;
int error = 0, rdonly, cache, getret;
char *cp2;
}
nfsmode = fxdr_unsigned(u_int32_t, *tl);
if ((nfsmode & NFSV3ACCESS_READ) &&
- nfsrv_access(vp, VREAD, cred, rdonly, procp, 0))
+ nfsrv_access(vp, VREAD, cred, rdonly, td, 0))
nfsmode &= ~NFSV3ACCESS_READ;
if (vp->v_type == VDIR)
testmode = (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND |
else
testmode = (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND);
if ((nfsmode & testmode) &&
- nfsrv_access(vp, VWRITE, cred, rdonly, procp, 0))
+ nfsrv_access(vp, VWRITE, cred, rdonly, td, 0))
nfsmode &= ~testmode;
if (vp->v_type == VDIR)
testmode = NFSV3ACCESS_LOOKUP;
else
testmode = NFSV3ACCESS_EXECUTE;
if ((nfsmode & testmode) &&
- nfsrv_access(vp, VEXEC, cred, rdonly, procp, 0))
+ nfsrv_access(vp, VEXEC, cred, rdonly, td, 0))
nfsmode &= ~testmode;
- getret = VOP_GETATTR(vp, vap, cred, procp);
+ getret = VOP_GETATTR(vp, vap, cred, td);
vput(vp);
vp = NULL;
nfsm_reply(NFSX_POSTOPATTR(1) + NFSX_UNSIGNED);
* nfs getattr service
*/
int
-nfsrv_getattr(nfsd, slp, procp, mrq)
+nfsrv_getattr(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
struct sockaddr *nam = nfsd->nd_nam;
caddr_t dpos = nfsd->nd_dpos;
struct ucred *cred = &nfsd->nd_cr;
- register struct nfs_fattr *fp;
+ struct nfs_fattr *fp;
struct vattr va;
- register struct vattr *vap = &va;
+ struct vattr *vap = &va;
struct vnode *vp = NULL;
nfsfh_t nfh;
fhandle_t *fhp;
- register u_int32_t *tl;
- register int32_t t1;
+ u_int32_t *tl;
+ int32_t t1;
caddr_t bpos;
int error = 0, rdonly, cache;
char *cp2;
goto nfsmout;
}
nqsrv_getl(vp, ND_READ);
- error = VOP_GETATTR(vp, vap, cred, procp);
+ error = VOP_GETATTR(vp, vap, cred, td);
vput(vp);
vp = NULL;
nfsm_reply(NFSX_FATTR(nfsd->nd_flag & ND_NFSV3));
* nfs setattr service
*/
int
-nfsrv_setattr(nfsd, slp, procp, mrq)
+nfsrv_setattr(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
caddr_t dpos = nfsd->nd_dpos;
struct ucred *cred = &nfsd->nd_cr;
struct vattr va, preat;
- register struct vattr *vap = &va;
- register struct nfsv2_sattr *sp;
- register struct nfs_fattr *fp;
+ struct vattr *vap = &va;
+ struct nfsv2_sattr *sp;
+ struct nfs_fattr *fp;
struct vnode *vp = NULL;
nfsfh_t nfh;
fhandle_t *fhp;
- register u_int32_t *tl;
- register int32_t t1;
+ u_int32_t *tl;
+ int32_t t1;
caddr_t bpos;
int error = 0, rdonly, cache, preat_ret = 1, postat_ret = 1;
int v3 = (nfsd->nd_flag & ND_NFSV3), gcheck = 0;
nqsrv_getl(vp, ND_WRITE);
if (v3) {
- error = preat_ret = VOP_GETATTR(vp, &preat, cred, procp);
+ error = preat_ret = VOP_GETATTR(vp, &preat, cred, td);
if (!error && gcheck &&
(preat.va_ctime.tv_sec != guard.tv_sec ||
preat.va_ctime.tv_nsec != guard.tv_nsec))
error = EISDIR;
goto out;
} else if ((error = nfsrv_access(vp, VWRITE, cred, rdonly,
- procp, 0)) != 0)
+ td, 0)) != 0){
goto out;
+ }
}
- error = VOP_SETATTR(vp, vap, cred, procp);
- postat_ret = VOP_GETATTR(vp, vap, cred, procp);
+ error = VOP_SETATTR(vp, vap, cred, td);
+ postat_ret = VOP_GETATTR(vp, vap, cred, td);
if (!error)
error = postat_ret;
out:
* nfs lookup rpc
*/
int
-nfsrv_lookup(nfsd, slp, procp, mrq)
+nfsrv_lookup(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
struct sockaddr *nam = nfsd->nd_nam;
caddr_t dpos = nfsd->nd_dpos;
struct ucred *cred = &nfsd->nd_cr;
- register struct nfs_fattr *fp;
+ struct nfs_fattr *fp;
struct nameidata nd, ind, *ndp = &nd;
struct vnode *vp, *dirp = NULL;
nfsfh_t nfh;
fhandle_t *fhp;
- register caddr_t cp;
- register u_int32_t *tl;
- register int32_t t1;
+ caddr_t cp;
+ u_int32_t *tl;
+ int32_t t1;
caddr_t bpos;
int error = 0, cache, len, dirattr_ret = 1;
int v3 = (nfsd->nd_flag & ND_NFSV3), pubflag;
nd.ni_cnd.cn_nameiop = LOOKUP;
nd.ni_cnd.cn_flags = LOCKLEAF | SAVESTART;
error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
- &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), pubflag);
+ &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), pubflag);
/*
* namei failure, only dirp to cleanup. Clear out garbarge from
if (dirp) {
if (v3)
dirattr_ret = VOP_GETATTR(dirp, &dirattr, cred,
- procp);
+ td);
vrele(dirp);
dirp = NULL;
}
* via the original nd. Confused? You aren't alone!
*/
ind = nd;
- VOP_UNLOCK(nd.ni_vp, 0, procp);
+ VOP_UNLOCK(nd.ni_vp, 0, td);
ind.ni_pathlen = strlen(nfs_pub.np_index);
ind.ni_cnd.cn_nameptr = ind.ni_cnd.cn_pnbuf =
nfs_pub.np_index;
if (dirp) {
if (v3)
dirattr_ret = VOP_GETATTR(dirp, &dirattr, cred,
- procp);
+ td);
vrele(dirp);
dirp = NULL;
}
fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid;
error = VFS_VPTOFH(vp, &fhp->fh_fid);
if (!error)
- error = VOP_GETATTR(vp, vap, cred, procp);
+ error = VOP_GETATTR(vp, vap, cred, td);
vput(vp);
ndp->ni_vp = NULL;
* nfs readlink service
*/
int
-nfsrv_readlink(nfsd, slp, procp, mrq)
+nfsrv_readlink(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
caddr_t dpos = nfsd->nd_dpos;
struct ucred *cred = &nfsd->nd_cr;
struct iovec iv[(NFS_MAXPATHLEN+MLEN-1)/MLEN];
- register struct iovec *ivp = iv;
- register struct mbuf *mp;
- register u_int32_t *tl;
- register int32_t t1;
+ struct iovec *ivp = iv;
+ struct mbuf *mp;
+ u_int32_t *tl;
+ int32_t t1;
caddr_t bpos;
int error = 0, rdonly, cache, i, tlen, len, getret;
int v3 = (nfsd->nd_flag & ND_NFSV3);
uiop->uio_resid = len;
uiop->uio_rw = UIO_READ;
uiop->uio_segflg = UIO_SYSSPACE;
- uiop->uio_procp = (struct proc *)0;
+ uiop->uio_td = NULL;
error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
&rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE);
if (error) {
nqsrv_getl(vp, ND_READ);
error = VOP_READLINK(vp, uiop, cred);
out:
- getret = VOP_GETATTR(vp, &attr, cred, procp);
+ getret = VOP_GETATTR(vp, &attr, cred, td);
vput(vp);
vp = NULL;
nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_UNSIGNED);
* nfs read service
*/
int
-nfsrv_read(nfsd, slp, procp, mrq)
+nfsrv_read(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
struct sockaddr *nam = nfsd->nd_nam;
caddr_t dpos = nfsd->nd_dpos;
struct ucred *cred = &nfsd->nd_cr;
- register struct iovec *iv;
+ struct iovec *iv;
struct iovec *iv2;
- register struct mbuf *m;
- register struct nfs_fattr *fp;
- register u_int32_t *tl;
- register int32_t t1;
- register int i;
+ struct mbuf *m;
+ struct nfs_fattr *fp;
+ u_int32_t *tl;
+ int32_t t1;
+ int i;
caddr_t bpos;
int error = 0, rdonly, cache, cnt, len, left, siz, tlen, getret;
int v3 = (nfsd->nd_flag & ND_NFSV3), reqlen;
}
if (!error) {
nqsrv_getl(vp, ND_READ);
- if ((error = nfsrv_access(vp, VREAD, cred, rdonly, procp, 1)) != 0)
- error = nfsrv_access(vp, VEXEC, cred, rdonly, procp, 1);
+ if ((error = nfsrv_access(vp, VREAD, cred, rdonly, td, 1)) != 0)
+ error = nfsrv_access(vp, VEXEC, cred, rdonly, td, 1);
}
- getret = VOP_GETATTR(vp, vap, cred, procp);
+ getret = VOP_GETATTR(vp, vap, cred, td);
if (!error)
error = getret;
if (error) {
off = uiop->uio_offset;
nh->nh_nextr = off;
FREE((caddr_t)iv2, M_TEMP);
- if (error || (getret = VOP_GETATTR(vp, vap, cred, procp))) {
+ if (error || (getret = VOP_GETATTR(vp, vap, cred, td))) {
if (!error)
error = getret;
m_freem(mreq);
* nfs write service
*/
int
-nfsrv_write(nfsd, slp, procp, mrq)
+nfsrv_write(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
struct sockaddr *nam = nfsd->nd_nam;
caddr_t dpos = nfsd->nd_dpos;
struct ucred *cred = &nfsd->nd_cr;
- register struct iovec *ivp;
- register int i, cnt;
- register struct mbuf *mp;
- register struct nfs_fattr *fp;
+ struct iovec *ivp;
+ int i, cnt;
+ struct mbuf *mp;
+ struct nfs_fattr *fp;
struct iovec *iv;
struct vattr va, forat;
- register struct vattr *vap = &va;
- register u_int32_t *tl;
- register int32_t t1;
+ struct vattr *vap = &va;
+ u_int32_t *tl;
+ int32_t t1;
caddr_t bpos;
int error = 0, rdonly, cache, len, forat_ret = 1;
int ioflags, aftat_ret = 1, retlen, zeroing, adjust;
goto nfsmout;
}
if (v3)
- forat_ret = VOP_GETATTR(vp, &forat, cred, procp);
+ forat_ret = VOP_GETATTR(vp, &forat, cred, td);
if (vp->v_type != VREG) {
if (v3)
error = EINVAL;
}
if (!error) {
nqsrv_getl(vp, ND_WRITE);
- error = nfsrv_access(vp, VWRITE, cred, rdonly, procp, 1);
+ error = nfsrv_access(vp, VWRITE, cred, rdonly, td, 1);
}
if (error) {
vput(vp);
uiop->uio_resid = len;
uiop->uio_rw = UIO_WRITE;
uiop->uio_segflg = UIO_SYSSPACE;
- uiop->uio_procp = (struct proc *)0;
+ uiop->uio_td = NULL;
uiop->uio_offset = off;
error = VOP_WRITE(vp, uiop, ioflags, cred);
nfsstats.srvvop_writes++;
FREE((caddr_t)iv, M_TEMP);
}
- aftat_ret = VOP_GETATTR(vp, vap, cred, procp);
+ aftat_ret = VOP_GETATTR(vp, vap, cred, td);
vput(vp);
vp = NULL;
if (!error)
* Jan. 1994.
*/
int
-nfsrv_writegather(ndp, slp, procp, mrq)
+nfsrv_writegather(ndp, slp, td, mrq)
struct nfsrv_descript **ndp;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
- register struct iovec *ivp;
- register struct mbuf *mp;
- register struct nfsrv_descript *wp, *nfsd, *owp, *swp;
- register struct nfs_fattr *fp;
- register int i;
+ struct iovec *ivp;
+ struct mbuf *mp;
+ struct nfsrv_descript *wp, *nfsd, *owp, *swp;
+ struct nfs_fattr *fp;
+ int i;
struct iovec *iov;
struct nfsrvw_delayhash *wpp;
struct ucred *cred;
struct vattr va, forat;
- register u_int32_t *tl;
- register int32_t t1;
+ u_int32_t *tl;
+ int32_t t1;
caddr_t bpos, dpos;
int error = 0, rdonly, cache, len, forat_ret = 1;
int ioflags, aftat_ret = 1, s, adjust, v3, zeroing;
nfsd->nd_nam, &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE);
if (!error) {
if (v3)
- forat_ret = VOP_GETATTR(vp, &forat, cred, procp);
+ forat_ret = VOP_GETATTR(vp, &forat, cred, td);
if (vp->v_type != VREG) {
if (v3)
error = EINVAL;
}
if (!error) {
nqsrv_getl(vp, ND_WRITE);
- error = nfsrv_access(vp, VWRITE, cred, rdonly, procp, 1);
+ error = nfsrv_access(vp, VWRITE, cred, rdonly, td, 1);
}
if (nfsd->nd_stable == NFSV3WRITE_UNSTABLE)
ioflags = (IO_METASYNC | IO_SYNC | IO_NODELOCKED);
uiop->uio_rw = UIO_WRITE;
uiop->uio_segflg = UIO_SYSSPACE;
- uiop->uio_procp = (struct proc *)0;
+ uiop->uio_td = NULL;
uiop->uio_offset = nfsd->nd_off;
uiop->uio_resid = nfsd->nd_eoff - nfsd->nd_off;
if (uiop->uio_resid > 0) {
}
m_freem(mrep);
if (vp) {
- aftat_ret = VOP_GETATTR(vp, &va, cred, procp);
+ aftat_ret = VOP_GETATTR(vp, &va, cred, td);
vput(vp);
vp = NULL;
}
* NB: Must be called at splsoftclock().
*/
static void
-nfsrvw_coalesce(owp, nfsd)
- register struct nfsrv_descript *owp;
- register struct nfsrv_descript *nfsd;
+nfsrvw_coalesce(struct nfsrv_descript *owp, struct nfsrv_descript *nfsd)
{
- register int overlap;
- register struct mbuf *mp;
+ int overlap;
+ struct mbuf *mp;
struct nfsrv_descript *p;
NFS_DPF(WG, ("C%03x-%03x",
* now does a truncate to 0 length via. setattr if it already exists
*/
int
-nfsrv_create(nfsd, slp, procp, mrq)
+nfsrv_create(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
struct sockaddr *nam = nfsd->nd_nam;
caddr_t dpos = nfsd->nd_dpos;
struct ucred *cred = &nfsd->nd_cr;
- register struct nfs_fattr *fp;
+ struct nfs_fattr *fp;
struct vattr va, dirfor, diraft;
- register struct vattr *vap = &va;
- register struct nfsv2_sattr *sp;
- register u_int32_t *tl;
+ struct vattr *vap = &va;
+ struct nfsv2_sattr *sp;
+ u_int32_t *tl;
struct nameidata nd;
- register int32_t t1;
+ int32_t t1;
caddr_t bpos;
int error = 0, rdev, cache, len, tsize, dirfor_ret = 1, diraft_ret = 1;
int v3 = (nfsd->nd_flag & ND_NFSV3), how, exclusive_flag = 0;
* prior to calling nfsm_reply ( which might goto nfsmout ).
*/
error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
- &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
+ &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
if (dirp) {
if (v3) {
dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
- procp);
+ td);
} else {
vrele(dirp);
dirp = NULL;
bcopy(cverf, (caddr_t)&vap->va_atime,
NFSX_V3CREATEVERF);
error = VOP_SETATTR(nd.ni_vp, vap, cred,
- procp);
+ td);
}
}
} else if (
if (vap->va_type == VCHR && rdev == 0xffffffff)
vap->va_type = VFIFO;
if (vap->va_type != VFIFO &&
- (error = suser_xxx(cred, 0))) {
+ (error = suser_cred(cred, 0))) {
goto nfsmreply0;
}
vap->va_rdev = rdev;
*/
nd.ni_cnd.cn_nameiop = LOOKUP;
nd.ni_cnd.cn_flags &= ~(LOCKPARENT);
- nd.ni_cnd.cn_proc = procp;
+ nd.ni_cnd.cn_td = td;
nd.ni_cnd.cn_cred = cred;
error = lookup(&nd);
} else {
if (vap->va_size != -1) {
error = nfsrv_access(nd.ni_vp, VWRITE, cred,
- (nd.ni_cnd.cn_flags & RDONLY), procp, 0);
+ (nd.ni_cnd.cn_flags & RDONLY), td, 0);
if (!error) {
nqsrv_getl(nd.ni_vp, ND_WRITE);
tempsize = vap->va_size;
VATTR_NULL(vap);
vap->va_size = tempsize;
- error = VOP_SETATTR(nd.ni_vp, vap, cred,
- procp);
+ error = VOP_SETATTR(nd.ni_vp, vap, cred, td);
}
}
}
fhp->fh_fsid = nd.ni_vp->v_mount->mnt_stat.f_fsid;
error = VFS_VPTOFH(nd.ni_vp, &fhp->fh_fid);
if (!error)
- error = VOP_GETATTR(nd.ni_vp, vap, cred, procp);
+ error = VOP_GETATTR(nd.ni_vp, vap, cred, td);
}
if (v3) {
if (exclusive_flag && !error &&
bcmp(cverf, (caddr_t)&vap->va_atime, NFSX_V3CREATEVERF))
error = EEXIST;
- diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp);
+ diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td);
vrele(dirp);
dirp = NULL;
}
* nfs v3 mknod service
*/
int
-nfsrv_mknod(nfsd, slp, procp, mrq)
+nfsrv_mknod(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
caddr_t dpos = nfsd->nd_dpos;
struct ucred *cred = &nfsd->nd_cr;
struct vattr va, dirfor, diraft;
- register struct vattr *vap = &va;
- register u_int32_t *tl;
+ struct vattr *vap = &va;
+ u_int32_t *tl;
struct nameidata nd;
- register int32_t t1;
+ int32_t t1;
caddr_t bpos;
int error = 0, cache, len, dirfor_ret = 1, diraft_ret = 1;
u_int32_t major, minor;
*/
error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
- &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
+ &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
if (dirp)
- dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, procp);
+ dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, td);
if (error) {
nfsm_reply(NFSX_WCCDATA(1));
nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
if (error)
NDFREE(&nd, NDF_ONLY_PNBUF);
} else {
- if (vtyp != VFIFO && (error = suser_xxx(cred, 0)))
+ if (vtyp != VFIFO && (error = suser_cred(cred, 0)))
goto out;
nqsrv_getl(nd.ni_dvp, ND_WRITE);
vput(nd.ni_dvp);
nd.ni_dvp = NULL;
+ KKASSERT(td->td_proc);
nd.ni_cnd.cn_nameiop = LOOKUP;
nd.ni_cnd.cn_flags &= ~(LOCKPARENT);
- nd.ni_cnd.cn_proc = procp;
- nd.ni_cnd.cn_cred = procp->p_ucred;
+ nd.ni_cnd.cn_td = td;
+ nd.ni_cnd.cn_cred = td->td_proc->p_ucred;
error = lookup(&nd);
nd.ni_dvp = NULL;
fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid;
error = VFS_VPTOFH(vp, &fhp->fh_fid);
if (!error)
- error = VOP_GETATTR(vp, vap, cred, procp);
+ error = VOP_GETATTR(vp, vap, cred, td);
}
if (vp) {
vput(vp);
vp = NULL;
nd.ni_vp = NULL;
}
- diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp);
+ diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td);
if (dirp) {
vrele(dirp);
dirp = NULL;
* nfs remove service
*/
int
-nfsrv_remove(nfsd, slp, procp, mrq)
+nfsrv_remove(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
caddr_t dpos = nfsd->nd_dpos;
struct ucred *cred = &nfsd->nd_cr;
struct nameidata nd;
- register u_int32_t *tl;
- register int32_t t1;
+ u_int32_t *tl;
+ int32_t t1;
caddr_t bpos;
int error = 0, cache, len, dirfor_ret = 1, diraft_ret = 1;
int v3 = (nfsd->nd_flag & ND_NFSV3);
nd.ni_cnd.cn_nameiop = DELETE;
nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF;
error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
- &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
+ &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
if (dirp) {
if (v3) {
- dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
- procp);
+ dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, td);
} else {
vrele(dirp);
dirp = NULL;
}
}
if (dirp && v3) {
- diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp);
+ diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td);
vrele(dirp);
dirp = NULL;
}
* nfs rename service
*/
int
-nfsrv_rename(nfsd, slp, procp, mrq)
+nfsrv_rename(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
struct sockaddr *nam = nfsd->nd_nam;
caddr_t dpos = nfsd->nd_dpos;
struct ucred *cred = &nfsd->nd_cr;
- register u_int32_t *tl;
- register int32_t t1;
+ u_int32_t *tl;
+ int32_t t1;
caddr_t bpos;
int error = 0, cache, len, len2, fdirfor_ret = 1, fdiraft_ret = 1;
int tdirfor_ret = 1, tdiraft_ret = 1;
fromnd.ni_cnd.cn_nameiop = DELETE;
fromnd.ni_cnd.cn_flags = WANTPARENT | SAVESTART;
error = nfs_namei(&fromnd, ffhp, len, slp, nam, &md,
- &dpos, &fdirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
+ &dpos, &fdirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
if (fdirp) {
if (v3) {
- fdirfor_ret = VOP_GETATTR(fdirp, &fdirfor, cred,
- procp);
+ fdirfor_ret = VOP_GETATTR(fdirp, &fdirfor, cred, td);
} else {
vrele(fdirp);
fdirp = NULL;
tond.ni_cnd.cn_nameiop = RENAME;
tond.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART;
error = nfs_namei(&tond, tfhp, len2, slp, nam, &md,
- &dpos, &tdirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
+ &dpos, &tdirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
if (tdirp) {
if (v3) {
- tdirfor_ret = VOP_GETATTR(tdirp, &tdirfor, cred,
- procp);
+ tdirfor_ret = VOP_GETATTR(tdirp, &tdirfor, cred, td);
} else {
vrele(tdirp);
tdirp = NULL;
out1:
if (fdirp)
- fdiraft_ret = VOP_GETATTR(fdirp, &fdiraft, cred, procp);
+ fdiraft_ret = VOP_GETATTR(fdirp, &fdiraft, cred, td);
if (tdirp)
- tdiraft_ret = VOP_GETATTR(tdirp, &tdiraft, cred, procp);
+ tdiraft_ret = VOP_GETATTR(tdirp, &tdiraft, cred, td);
nfsm_reply(2 * NFSX_WCCDATA(v3));
if (v3) {
nfsm_srvwcc_data(fdirfor_ret, &fdirfor, fdiraft_ret, &fdiraft);
* nfs link service
*/
int
-nfsrv_link(nfsd, slp, procp, mrq)
+nfsrv_link(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
caddr_t dpos = nfsd->nd_dpos;
struct ucred *cred = &nfsd->nd_cr;
struct nameidata nd;
- register u_int32_t *tl;
- register int32_t t1;
+ u_int32_t *tl;
+ int32_t t1;
caddr_t bpos;
int error = 0, rdonly, cache, len, dirfor_ret = 1, diraft_ret = 1;
int getret = 1, v3 = (nfsd->nd_flag & ND_NFSV3);
nd.ni_cnd.cn_nameiop = CREATE;
nd.ni_cnd.cn_flags = LOCKPARENT;
error = nfs_namei(&nd, dfhp, len, slp, nam, &md, &dpos,
- &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
+ &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
if (dirp) {
if (v3) {
- dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
- procp);
+ dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, td);
} else {
vrele(dirp);
dirp = NULL;
out1:
if (v3)
- getret = VOP_GETATTR(vp, &at, cred, procp);
+ getret = VOP_GETATTR(vp, &at, cred, td);
if (dirp)
- diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp);
+ diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td);
nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_WCCDATA(v3));
if (v3) {
nfsm_srvpostop_attr(getret, &at);
* nfs symbolic link service
*/
int
-nfsrv_symlink(nfsd, slp, procp, mrq)
+nfsrv_symlink(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
struct ucred *cred = &nfsd->nd_cr;
struct vattr va, dirfor, diraft;
struct nameidata nd;
- register struct vattr *vap = &va;
- register u_int32_t *tl;
- register int32_t t1;
+ struct vattr *vap = &va;
+ u_int32_t *tl;
+ int32_t t1;
struct nfsv2_sattr *sp;
char *bpos, *pathcp = (char *)0, *cp2;
struct uio io;
nd.ni_cnd.cn_nameiop = CREATE;
nd.ni_cnd.cn_flags = LOCKPARENT | SAVESTART;
error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
- &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
+ &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
if (dirp) {
if (v3) {
- dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
- procp);
+ dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, td);
} else {
vrele(dirp);
dirp = NULL;
io.uio_iovcnt = 1;
io.uio_segflg = UIO_SYSSPACE;
io.uio_rw = UIO_READ;
- io.uio_procp = (struct proc *)0;
+ io.uio_td = NULL;
nfsm_mtouio(&io, len2);
if (!v3) {
nfsm_dissect(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
nd.ni_cnd.cn_nameiop = LOOKUP;
nd.ni_cnd.cn_flags &= ~(LOCKPARENT | FOLLOW);
nd.ni_cnd.cn_flags |= (NOFOLLOW | LOCKLEAF);
- nd.ni_cnd.cn_proc = procp;
+ nd.ni_cnd.cn_td = td;
nd.ni_cnd.cn_cred = cred;
error = lookup(&nd);
fhp->fh_fsid = nd.ni_vp->v_mount->mnt_stat.f_fsid;
error = VFS_VPTOFH(nd.ni_vp, &fhp->fh_fid);
if (!error)
- error = VOP_GETATTR(nd.ni_vp, vap, cred,
- procp);
+ error = VOP_GETATTR(nd.ni_vp, vap, cred, td);
vput(nd.ni_vp);
nd.ni_vp = NULL;
}
pathcp = NULL;
}
if (dirp) {
- diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp);
+ diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td);
vrele(dirp);
dirp = NULL;
}
* nfs mkdir service
*/
int
-nfsrv_mkdir(nfsd, slp, procp, mrq)
+nfsrv_mkdir(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
caddr_t dpos = nfsd->nd_dpos;
struct ucred *cred = &nfsd->nd_cr;
struct vattr va, dirfor, diraft;
- register struct vattr *vap = &va;
- register struct nfs_fattr *fp;
+ struct vattr *vap = &va;
+ struct nfs_fattr *fp;
struct nameidata nd;
- register caddr_t cp;
- register u_int32_t *tl;
- register int32_t t1;
+ caddr_t cp;
+ u_int32_t *tl;
+ int32_t t1;
caddr_t bpos;
int error = 0, cache, len, dirfor_ret = 1, diraft_ret = 1;
int v3 = (nfsd->nd_flag & ND_NFSV3);
nd.ni_cnd.cn_flags = LOCKPARENT;
error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
- &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
+ &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
if (dirp) {
if (v3) {
- dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
- procp);
+ dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, td);
} else {
vrele(dirp);
dirp = NULL;
fhp->fh_fsid = nd.ni_vp->v_mount->mnt_stat.f_fsid;
error = VFS_VPTOFH(nd.ni_vp, &fhp->fh_fid);
if (!error)
- error = VOP_GETATTR(nd.ni_vp, vap, cred, procp);
+ error = VOP_GETATTR(nd.ni_vp, vap, cred, td);
}
out:
if (dirp)
- diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp);
+ diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td);
nfsm_reply(NFSX_SRVFH(v3) + NFSX_POSTOPATTR(v3) + NFSX_WCCDATA(v3));
if (v3) {
if (!error) {
* nfs rmdir service
*/
int
-nfsrv_rmdir(nfsd, slp, procp, mrq)
+nfsrv_rmdir(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
struct sockaddr *nam = nfsd->nd_nam;
caddr_t dpos = nfsd->nd_dpos;
struct ucred *cred = &nfsd->nd_cr;
- register u_int32_t *tl;
- register int32_t t1;
+ u_int32_t *tl;
+ int32_t t1;
caddr_t bpos;
int error = 0, cache, len, dirfor_ret = 1, diraft_ret = 1;
int v3 = (nfsd->nd_flag & ND_NFSV3);
nd.ni_cnd.cn_nameiop = DELETE;
nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF;
error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
- &dirp, procp, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
+ &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), FALSE);
if (dirp) {
if (v3) {
- dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
- procp);
+ dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, td);
} else {
vrele(dirp);
dirp = NULL;
NDFREE(&nd, NDF_ONLY_PNBUF);
if (dirp)
- diraft_ret = VOP_GETATTR(dirp, &diraft, cred, procp);
+ diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td);
nfsm_reply(NFSX_WCCDATA(v3));
if (v3) {
nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
};
int
-nfsrv_readdir(nfsd, slp, procp, mrq)
+nfsrv_readdir(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
struct sockaddr *nam = nfsd->nd_nam;
caddr_t dpos = nfsd->nd_dpos;
struct ucred *cred = &nfsd->nd_cr;
- register char *bp, *be;
- register struct mbuf *mp;
- register struct dirent *dp;
- register caddr_t cp;
- register u_int32_t *tl;
- register int32_t t1;
+ char *bp, *be;
+ struct mbuf *mp;
+ struct dirent *dp;
+ caddr_t cp;
+ u_int32_t *tl;
+ int32_t t1;
caddr_t bpos;
struct mbuf *mb, *mb2, *mreq, *mp2;
char *cpos, *cend, *cp2, *rbuf;
nqsrv_getl(vp, ND_READ);
if (v3) {
- error = getret = VOP_GETATTR(vp, &at, cred, procp);
+ error = getret = VOP_GETATTR(vp, &at, cred, td);
#if 0
/*
* XXX This check may be too strict for Solaris 2.5 clients.
#endif
}
if (!error)
- error = nfsrv_access(vp, VEXEC, cred, rdonly, procp, 0);
+ error = nfsrv_access(vp, VEXEC, cred, rdonly, td, 0);
if (error) {
vput(vp);
vp = NULL;
error = 0;
goto nfsmout;
}
- VOP_UNLOCK(vp, 0, procp);
+ VOP_UNLOCK(vp, 0, td);
/*
* end section. Allocate rbuf and continue
io.uio_resid = fullsiz;
io.uio_segflg = UIO_SYSSPACE;
io.uio_rw = UIO_READ;
- io.uio_procp = (struct proc *)0;
+ io.uio_td = NULL;
eofflag = 0;
- vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, procp);
+ vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
if (cookies) {
free((caddr_t)cookies, M_TEMP);
cookies = NULL;
if (!cookies && !error)
error = NFSERR_PERM;
if (v3) {
- getret = VOP_GETATTR(vp, &at, cred, procp);
+ getret = VOP_GETATTR(vp, &at, cred, td);
if (!error)
error = getret;
}
- VOP_UNLOCK(vp, 0, procp);
+ VOP_UNLOCK(vp, 0, td);
if (error) {
vrele(vp);
vp = NULL;
}
int
-nfsrv_readdirplus(nfsd, slp, procp, mrq)
+nfsrv_readdirplus(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
struct sockaddr *nam = nfsd->nd_nam;
caddr_t dpos = nfsd->nd_dpos;
struct ucred *cred = &nfsd->nd_cr;
- register char *bp, *be;
- register struct mbuf *mp;
- register struct dirent *dp;
- register caddr_t cp;
- register u_int32_t *tl;
- register int32_t t1;
+ char *bp, *be;
+ struct mbuf *mp;
+ struct dirent *dp;
+ caddr_t cp;
+ u_int32_t *tl;
+ int32_t t1;
caddr_t bpos;
struct mbuf *mb, *mb2, *mreq, *mp2;
char *cpos, *cend, *cp2, *rbuf;
error = 0;
goto nfsmout;
}
- error = getret = VOP_GETATTR(vp, &at, cred, procp);
+ error = getret = VOP_GETATTR(vp, &at, cred, td);
#if 0
/*
* XXX This check may be too strict for Solaris 2.5 clients.
#endif
if (!error) {
nqsrv_getl(vp, ND_READ);
- error = nfsrv_access(vp, VEXEC, cred, rdonly, procp, 0);
+ error = nfsrv_access(vp, VEXEC, cred, rdonly, td, 0);
}
if (error) {
vput(vp);
error = 0;
goto nfsmout;
}
- VOP_UNLOCK(vp, 0, procp);
+ VOP_UNLOCK(vp, 0, td);
MALLOC(rbuf, caddr_t, siz, M_TEMP, M_WAITOK);
again:
iv.iov_base = rbuf;
io.uio_resid = fullsiz;
io.uio_segflg = UIO_SYSSPACE;
io.uio_rw = UIO_READ;
- io.uio_procp = (struct proc *)0;
+ io.uio_td = NULL;
eofflag = 0;
- vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, procp);
+ vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
if (cookies) {
free((caddr_t)cookies, M_TEMP);
cookies = NULL;
}
error = VOP_READDIR(vp, &io, cred, &eofflag, &ncookies, &cookies);
off = (u_quad_t)io.uio_offset;
- getret = VOP_GETATTR(vp, &at, cred, procp);
- VOP_UNLOCK(vp, 0, procp);
+ getret = VOP_GETATTR(vp, &at, cred, td);
+ VOP_UNLOCK(vp, 0, td);
if (!cookies && !error)
error = NFSERR_PERM;
if (!error)
nvp = NULL;
goto invalid;
}
- if (VOP_GETATTR(nvp, vap, cred, procp)) {
+ if (VOP_GETATTR(nvp, vap, cred, td)) {
vput(nvp);
nvp = NULL;
goto invalid;
* nfs commit service
*/
int
-nfsrv_commit(nfsd, slp, procp, mrq)
+nfsrv_commit(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
struct vnode *vp = NULL;
nfsfh_t nfh;
fhandle_t *fhp;
- register u_int32_t *tl;
- register int32_t t1;
+ u_int32_t *tl;
+ int32_t t1;
caddr_t bpos;
int error = 0, rdonly, for_ret = 1, aft_ret = 1, cnt, cache;
char *cp2;
error = 0;
goto nfsmout;
}
- for_ret = VOP_GETATTR(vp, &bfor, cred, procp);
+ for_ret = VOP_GETATTR(vp, &bfor, cred, td);
if (cnt > MAX_COMMIT_COUNT) {
/*
(vp->v_object->flags & OBJ_MIGHTBEDIRTY)) {
vm_object_page_clean(vp->v_object, 0, 0, OBJPC_SYNC);
}
- error = VOP_FSYNC(vp, cred, MNT_WAIT, procp);
+ error = VOP_FSYNC(vp, cred, MNT_WAIT, td);
} else {
/*
* Locate and synchronously write any buffers that fall
splx(s);
}
- aft_ret = VOP_GETATTR(vp, &aft, cred, procp);
+ aft_ret = VOP_GETATTR(vp, &aft, cred, td);
vput(vp);
vp = NULL;
nfsm_reply(NFSX_V3WCCDATA + NFSX_V3WRITEVERF);
* nfs statfs service
*/
int
-nfsrv_statfs(nfsd, slp, procp, mrq)
+nfsrv_statfs(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
struct sockaddr *nam = nfsd->nd_nam;
caddr_t dpos = nfsd->nd_dpos;
struct ucred *cred = &nfsd->nd_cr;
- register struct statfs *sf;
- register struct nfs_statfs *sfp;
- register u_int32_t *tl;
- register int32_t t1;
+ struct statfs *sf;
+ struct nfs_statfs *sfp;
+ u_int32_t *tl;
+ int32_t t1;
caddr_t bpos;
int error = 0, rdonly, cache, getret = 1;
int v3 = (nfsd->nd_flag & ND_NFSV3);
goto nfsmout;
}
sf = &statfs;
- error = VFS_STATFS(vp->v_mount, sf, procp);
- getret = VOP_GETATTR(vp, &at, cred, procp);
+ error = VFS_STATFS(vp->v_mount, sf, td);
+ getret = VOP_GETATTR(vp, &at, cred, td);
vput(vp);
vp = NULL;
nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_STATFS(v3));
* nfs fsinfo service
*/
int
-nfsrv_fsinfo(nfsd, slp, procp, mrq)
+nfsrv_fsinfo(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
struct sockaddr *nam = nfsd->nd_nam;
caddr_t dpos = nfsd->nd_dpos;
struct ucred *cred = &nfsd->nd_cr;
- register u_int32_t *tl;
- register struct nfsv3_fsinfo *sip;
- register int32_t t1;
+ u_int32_t *tl;
+ struct nfsv3_fsinfo *sip;
+ int32_t t1;
caddr_t bpos;
int error = 0, rdonly, cache, getret = 1, pref;
char *cp2;
}
/* XXX Try to make a guess on the max file size. */
- VFS_STATFS(vp->v_mount, &sb, procp);
+ VFS_STATFS(vp->v_mount, &sb, td);
maxfsize = (u_quad_t)0x80000000 * sb.f_bsize - 1;
- getret = VOP_GETATTR(vp, &at, cred, procp);
+ getret = VOP_GETATTR(vp, &at, cred, td);
vput(vp);
vp = NULL;
nfsm_reply(NFSX_V3POSTOPATTR + NFSX_V3FSINFO);
* nfs pathconf service
*/
int
-nfsrv_pathconf(nfsd, slp, procp, mrq)
+nfsrv_pathconf(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
struct sockaddr *nam = nfsd->nd_nam;
caddr_t dpos = nfsd->nd_dpos;
struct ucred *cred = &nfsd->nd_cr;
- register u_int32_t *tl;
- register struct nfsv3_pathconf *pc;
- register int32_t t1;
+ u_int32_t *tl;
+ struct nfsv3_pathconf *pc;
+ int32_t t1;
caddr_t bpos;
int error = 0, rdonly, cache, getret = 1;
register_t linkmax, namemax, chownres, notrunc;
error = VOP_PATHCONF(vp, _PC_CHOWN_RESTRICTED, &chownres);
if (!error)
error = VOP_PATHCONF(vp, _PC_NO_TRUNC, ¬runc);
- getret = VOP_GETATTR(vp, &at, cred, procp);
+ getret = VOP_GETATTR(vp, &at, cred, td);
vput(vp);
vp = NULL;
nfsm_reply(NFSX_V3POSTOPATTR + NFSX_V3PATHCONF);
*/
/* ARGSUSED */
int
-nfsrv_null(nfsd, slp, procp, mrq)
+nfsrv_null(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep;
*/
/* ARGSUSED */
int
-nfsrv_noop(nfsd, slp, procp, mrq)
+nfsrv_noop(nfsd, slp, td, mrq)
struct nfsrv_descript *nfsd;
struct nfssvc_sock *slp;
- struct proc *procp;
+ struct thread *td;
struct mbuf **mrq;
{
struct mbuf *mrep = nfsd->nd_mrep;
* will return EPERM instead of EACCESS. EPERM is always an error.
*/
static int
-nfsrv_access(vp, flags, cred, rdonly, p, override)
- register struct vnode *vp;
- int flags;
- register struct ucred *cred;
- int rdonly;
- struct proc *p;
- int override;
+nfsrv_access(struct vnode *vp, int flags, struct ucred *cred,
+ int rdonly, struct thread *td, int override)
{
struct vattr vattr;
int error;
if (vp->v_flag & VTEXT)
return (ETXTBSY);
}
- error = VOP_GETATTR(vp, &vattr, cred, p);
+ error = VOP_GETATTR(vp, &vattr, cred, td);
if (error)
return (error);
- error = VOP_ACCESS(vp, flags, cred, p);
+ error = VOP_ACCESS(vp, flags, cred, td);
/*
* Allow certain operations for the owner (reads and writes
* on files that are already open).
projects / dragonfly.git / blobdiff