aboutsummaryrefslogtreecommitdiff
path: root/sys/fs
diff options
context:
space:
mode:
authorRick Macklem <rmacklem@FreeBSD.org>2026-05-02 21:36:43 +0000
committerRick Macklem <rmacklem@FreeBSD.org>2026-05-02 21:36:43 +0000
commit821976facf746ef241e1524b44bb1de0af98fdc0 (patch)
tree6d6efd1bb157874ec82301da600c27459fc80213 /sys/fs
parent050b3ff753e04ce142ac751a0d76b5ee3beda9c5 (diff)
Diffstat (limited to 'sys/fs')
-rw-r--r--sys/fs/nfs/nfs_commonport.c294
-rw-r--r--sys/fs/nfs/nfs_commonsubs.c294
-rw-r--r--sys/fs/nfs/nfsdport.h2
-rw-r--r--sys/fs/nfs/nfsport.h14
-rw-r--r--sys/fs/nfs/nfsrvstate.h12
-rw-r--r--sys/fs/nfsclient/nfs_clport.c4
-rw-r--r--sys/fs/nfsserver/nfs_fha_new.c84
-rw-r--r--sys/fs/nfsserver/nfs_nfsdcache.c134
-rw-r--r--sys/fs/nfsserver/nfs_nfsdkrpc.c82
-rw-r--r--sys/fs/nfsserver/nfs_nfsdport.c178
-rw-r--r--sys/fs/nfsserver/nfs_nfsdsocket.c66
-rw-r--r--sys/fs/nfsserver/nfs_nfsdstate.c160
-rw-r--r--sys/fs/nfsserver/nfs_nfsdsubs.c32
13 files changed, 671 insertions, 685 deletions
diff --git a/sys/fs/nfs/nfs_commonport.c b/sys/fs/nfs/nfs_commonport.c
index 91d9188d30c5..03c6688b1406 100644
--- a/sys/fs/nfs/nfs_commonport.c
+++ b/sys/fs/nfs/nfs_commonport.c
@@ -71,10 +71,10 @@ vop_advlock_t *nfs_advlock_p = NULL;
vop_reclaim_t *nfs_reclaim_p = NULL;
uint32_t nfs_srvmaxio = NFS_SRVMAXIO;
-NFSD_VNET_DEFINE(struct nfsstatsv1 *, nfsstatsv1_p);
+VNET_DEFINE(struct nfsstatsv1 *, nfsstatsv1_p);
-NFSD_VNET_DECLARE(struct nfssockreq, nfsrv_nfsuserdsock);
-NFSD_VNET_DECLARE(nfsuserd_state, nfsrv_nfsuserd);
+VNET_DECLARE(struct nfssockreq, nfsrv_nfsuserdsock);
+VNET_DECLARE(nfsuserd_state, nfsrv_nfsuserd);
int nfs_pnfsio(task_fn_t *, void *);
@@ -428,9 +428,9 @@ nfssvc_nfscommon(struct thread *td, struct nfssvc_args *uap)
{
int error;
- NFSD_CURVNET_SET(NFSD_TD_TO_VNET(td));
+ CURVNET_SET(TD_TO_VNET(td));
error = nfssvc_call(td, uap, td->td_ucred);
- NFSD_CURVNET_RESTORE();
+ CURVNET_RESTORE();
NFSEXITCODE(error);
return (error);
}
@@ -470,105 +470,105 @@ nfssvc_call(struct thread *p, struct nfssvc_args *uap, struct ucred *cred)
if ((uap->flag & NFSSVC_NEWSTRUCT) == 0) {
/* Copy fields to the old ext_nfsstat structure. */
oldnfsstats.attrcache_hits =
- NFSD_VNET(nfsstatsv1_p)->attrcache_hits;
+ VNET(nfsstatsv1_p)->attrcache_hits;
oldnfsstats.attrcache_misses =
- NFSD_VNET(nfsstatsv1_p)->attrcache_misses;
+ VNET(nfsstatsv1_p)->attrcache_misses;
oldnfsstats.lookupcache_hits =
- NFSD_VNET(nfsstatsv1_p)->lookupcache_hits;
+ VNET(nfsstatsv1_p)->lookupcache_hits;
oldnfsstats.lookupcache_misses =
- NFSD_VNET(nfsstatsv1_p)->lookupcache_misses;
+ VNET(nfsstatsv1_p)->lookupcache_misses;
oldnfsstats.direofcache_hits =
- NFSD_VNET(nfsstatsv1_p)->direofcache_hits;
+ VNET(nfsstatsv1_p)->direofcache_hits;
oldnfsstats.direofcache_misses =
- NFSD_VNET(nfsstatsv1_p)->direofcache_misses;
+ VNET(nfsstatsv1_p)->direofcache_misses;
oldnfsstats.accesscache_hits =
- NFSD_VNET(nfsstatsv1_p)->accesscache_hits;
+ VNET(nfsstatsv1_p)->accesscache_hits;
oldnfsstats.accesscache_misses =
- NFSD_VNET(nfsstatsv1_p)->accesscache_misses;
+ VNET(nfsstatsv1_p)->accesscache_misses;
oldnfsstats.biocache_reads =
- NFSD_VNET(nfsstatsv1_p)->biocache_reads;
+ VNET(nfsstatsv1_p)->biocache_reads;
oldnfsstats.read_bios =
- NFSD_VNET(nfsstatsv1_p)->read_bios;
+ VNET(nfsstatsv1_p)->read_bios;
oldnfsstats.read_physios =
- NFSD_VNET(nfsstatsv1_p)->read_physios;
+ VNET(nfsstatsv1_p)->read_physios;
oldnfsstats.biocache_writes =
- NFSD_VNET(nfsstatsv1_p)->biocache_writes;
+ VNET(nfsstatsv1_p)->biocache_writes;
oldnfsstats.write_bios =
- NFSD_VNET(nfsstatsv1_p)->write_bios;
+ VNET(nfsstatsv1_p)->write_bios;
oldnfsstats.write_physios =
- NFSD_VNET(nfsstatsv1_p)->write_physios;
+ VNET(nfsstatsv1_p)->write_physios;
oldnfsstats.biocache_readlinks =
- NFSD_VNET(nfsstatsv1_p)->biocache_readlinks;
+ VNET(nfsstatsv1_p)->biocache_readlinks;
oldnfsstats.readlink_bios =
- NFSD_VNET(nfsstatsv1_p)->readlink_bios;
+ VNET(nfsstatsv1_p)->readlink_bios;
oldnfsstats.biocache_readdirs =
- NFSD_VNET(nfsstatsv1_p)->biocache_readdirs;
+ VNET(nfsstatsv1_p)->biocache_readdirs;
oldnfsstats.readdir_bios =
- NFSD_VNET(nfsstatsv1_p)->readdir_bios;
+ VNET(nfsstatsv1_p)->readdir_bios;
for (i = 0; i < NFSV4_NPROCS; i++)
oldnfsstats.rpccnt[i] =
- NFSD_VNET(nfsstatsv1_p)->rpccnt[i];
+ VNET(nfsstatsv1_p)->rpccnt[i];
oldnfsstats.rpcretries =
- NFSD_VNET(nfsstatsv1_p)->rpcretries;
+ VNET(nfsstatsv1_p)->rpcretries;
for (i = 0; i < NFSV4OP_NOPS; i++)
oldnfsstats.srvrpccnt[i] =
- NFSD_VNET(nfsstatsv1_p)->srvrpccnt[i];
+ VNET(nfsstatsv1_p)->srvrpccnt[i];
for (i = NFSV42_NOPS, j = NFSV4OP_NOPS;
i < NFSV42_NOPS + NFSV4OP_FAKENOPS; i++, j++)
oldnfsstats.srvrpccnt[j] =
- NFSD_VNET(nfsstatsv1_p)->srvrpccnt[i];
+ VNET(nfsstatsv1_p)->srvrpccnt[i];
oldnfsstats.reserved_0 = 0;
oldnfsstats.reserved_1 = 0;
oldnfsstats.rpcrequests =
- NFSD_VNET(nfsstatsv1_p)->rpcrequests;
+ VNET(nfsstatsv1_p)->rpcrequests;
oldnfsstats.rpctimeouts =
- NFSD_VNET(nfsstatsv1_p)->rpctimeouts;
+ VNET(nfsstatsv1_p)->rpctimeouts;
oldnfsstats.rpcunexpected =
- NFSD_VNET(nfsstatsv1_p)->rpcunexpected;
+ VNET(nfsstatsv1_p)->rpcunexpected;
oldnfsstats.rpcinvalid =
- NFSD_VNET(nfsstatsv1_p)->rpcinvalid;
+ VNET(nfsstatsv1_p)->rpcinvalid;
oldnfsstats.srvcache_inproghits =
- NFSD_VNET(nfsstatsv1_p)->srvcache_inproghits;
+ VNET(nfsstatsv1_p)->srvcache_inproghits;
oldnfsstats.reserved_2 = 0;
oldnfsstats.srvcache_nonidemdonehits =
- NFSD_VNET(nfsstatsv1_p)->srvcache_nonidemdonehits;
+ VNET(nfsstatsv1_p)->srvcache_nonidemdonehits;
oldnfsstats.srvcache_misses =
- NFSD_VNET(nfsstatsv1_p)->srvcache_misses;
+ VNET(nfsstatsv1_p)->srvcache_misses;
oldnfsstats.srvcache_tcppeak =
- NFSD_VNET(nfsstatsv1_p)->srvcache_tcppeak;
+ VNET(nfsstatsv1_p)->srvcache_tcppeak;
oldnfsstats.srvcache_size =
- NFSD_VNET(nfsstatsv1_p)->srvcache_size;
+ VNET(nfsstatsv1_p)->srvcache_size;
oldnfsstats.srvclients =
- NFSD_VNET(nfsstatsv1_p)->srvclients;
+ VNET(nfsstatsv1_p)->srvclients;
oldnfsstats.srvopenowners =
- NFSD_VNET(nfsstatsv1_p)->srvopenowners;
+ VNET(nfsstatsv1_p)->srvopenowners;
oldnfsstats.srvopens =
- NFSD_VNET(nfsstatsv1_p)->srvopens;
+ VNET(nfsstatsv1_p)->srvopens;
oldnfsstats.srvlockowners =
- NFSD_VNET(nfsstatsv1_p)->srvlockowners;
+ VNET(nfsstatsv1_p)->srvlockowners;
oldnfsstats.srvlocks =
- NFSD_VNET(nfsstatsv1_p)->srvlocks;
+ VNET(nfsstatsv1_p)->srvlocks;
oldnfsstats.srvdelegates =
- NFSD_VNET(nfsstatsv1_p)->srvdelegates;
+ VNET(nfsstatsv1_p)->srvdelegates;
for (i = 0; i < NFSV4OP_CBNOPS; i++)
oldnfsstats.cbrpccnt[i] =
- NFSD_VNET(nfsstatsv1_p)->cbrpccnt[i];
+ VNET(nfsstatsv1_p)->cbrpccnt[i];
oldnfsstats.clopenowners =
- NFSD_VNET(nfsstatsv1_p)->clopenowners;
- oldnfsstats.clopens = NFSD_VNET(nfsstatsv1_p)->clopens;
+ VNET(nfsstatsv1_p)->clopenowners;
+ oldnfsstats.clopens = VNET(nfsstatsv1_p)->clopens;
oldnfsstats.cllockowners =
- NFSD_VNET(nfsstatsv1_p)->cllockowners;
- oldnfsstats.cllocks = NFSD_VNET(nfsstatsv1_p)->cllocks;
+ VNET(nfsstatsv1_p)->cllockowners;
+ oldnfsstats.cllocks = VNET(nfsstatsv1_p)->cllocks;
oldnfsstats.cldelegates =
- NFSD_VNET(nfsstatsv1_p)->cldelegates;
+ VNET(nfsstatsv1_p)->cldelegates;
oldnfsstats.cllocalopenowners =
- NFSD_VNET(nfsstatsv1_p)->cllocalopenowners;
+ VNET(nfsstatsv1_p)->cllocalopenowners;
oldnfsstats.cllocalopens =
- NFSD_VNET(nfsstatsv1_p)->cllocalopens;
+ VNET(nfsstatsv1_p)->cllocalopens;
oldnfsstats.cllocallockowners =
- NFSD_VNET(nfsstatsv1_p)->cllocallockowners;
+ VNET(nfsstatsv1_p)->cllocallockowners;
oldnfsstats.cllocallocks =
- NFSD_VNET(nfsstatsv1_p)->cllocallocks;
+ VNET(nfsstatsv1_p)->cllocallocks;
error = copyout(&oldnfsstats, uap->argp,
sizeof (oldnfsstats));
} else {
@@ -578,174 +578,174 @@ nfssvc_call(struct thread *p, struct nfssvc_args *uap, struct ucred *cred)
if (nfsstatver.vers == NFSSTATS_OV1) {
/* Copy nfsstatsv1 to nfsstatsov1. */
nfsstatsov1.attrcache_hits =
- NFSD_VNET(nfsstatsv1_p)->attrcache_hits;
+ VNET(nfsstatsv1_p)->attrcache_hits;
nfsstatsov1.attrcache_misses =
- NFSD_VNET(nfsstatsv1_p)->attrcache_misses;
+ VNET(nfsstatsv1_p)->attrcache_misses;
nfsstatsov1.lookupcache_hits =
- NFSD_VNET(nfsstatsv1_p)->lookupcache_hits;
+ VNET(nfsstatsv1_p)->lookupcache_hits;
nfsstatsov1.lookupcache_misses =
- NFSD_VNET(nfsstatsv1_p)->lookupcache_misses;
+ VNET(nfsstatsv1_p)->lookupcache_misses;
nfsstatsov1.direofcache_hits =
- NFSD_VNET(nfsstatsv1_p)->direofcache_hits;
+ VNET(nfsstatsv1_p)->direofcache_hits;
nfsstatsov1.direofcache_misses =
- NFSD_VNET(nfsstatsv1_p)->direofcache_misses;
+ VNET(nfsstatsv1_p)->direofcache_misses;
nfsstatsov1.accesscache_hits =
- NFSD_VNET(nfsstatsv1_p)->accesscache_hits;
+ VNET(nfsstatsv1_p)->accesscache_hits;
nfsstatsov1.accesscache_misses =
- NFSD_VNET(nfsstatsv1_p)->accesscache_misses;
+ VNET(nfsstatsv1_p)->accesscache_misses;
nfsstatsov1.biocache_reads =
- NFSD_VNET(nfsstatsv1_p)->biocache_reads;
+ VNET(nfsstatsv1_p)->biocache_reads;
nfsstatsov1.read_bios =
- NFSD_VNET(nfsstatsv1_p)->read_bios;
+ VNET(nfsstatsv1_p)->read_bios;
nfsstatsov1.read_physios =
- NFSD_VNET(nfsstatsv1_p)->read_physios;
+ VNET(nfsstatsv1_p)->read_physios;
nfsstatsov1.biocache_writes =
- NFSD_VNET(nfsstatsv1_p)->biocache_writes;
+ VNET(nfsstatsv1_p)->biocache_writes;
nfsstatsov1.write_bios =
- NFSD_VNET(nfsstatsv1_p)->write_bios;
+ VNET(nfsstatsv1_p)->write_bios;
nfsstatsov1.write_physios =
- NFSD_VNET(nfsstatsv1_p)->write_physios;
+ VNET(nfsstatsv1_p)->write_physios;
nfsstatsov1.biocache_readlinks =
- NFSD_VNET(nfsstatsv1_p)->biocache_readlinks;
+ VNET(nfsstatsv1_p)->biocache_readlinks;
nfsstatsov1.readlink_bios =
- NFSD_VNET(nfsstatsv1_p)->readlink_bios;
+ VNET(nfsstatsv1_p)->readlink_bios;
nfsstatsov1.biocache_readdirs =
- NFSD_VNET(nfsstatsv1_p)->biocache_readdirs;
+ VNET(nfsstatsv1_p)->biocache_readdirs;
nfsstatsov1.readdir_bios =
- NFSD_VNET(nfsstatsv1_p)->readdir_bios;
+ VNET(nfsstatsv1_p)->readdir_bios;
for (i = 0; i < NFSV42_OLDNPROCS; i++)
nfsstatsov1.rpccnt[i] =
- NFSD_VNET(nfsstatsv1_p)->rpccnt[i];
+ VNET(nfsstatsv1_p)->rpccnt[i];
nfsstatsov1.rpcretries =
- NFSD_VNET(nfsstatsv1_p)->rpcretries;
+ VNET(nfsstatsv1_p)->rpcretries;
for (i = 0; i < NFSV42_PURENOPS; i++)
nfsstatsov1.srvrpccnt[i] =
- NFSD_VNET(nfsstatsv1_p)->srvrpccnt[i];
+ VNET(nfsstatsv1_p)->srvrpccnt[i];
for (i = NFSV42_NOPS,
j = NFSV42_PURENOPS;
i < NFSV42_NOPS + NFSV4OP_FAKENOPS;
i++, j++)
nfsstatsov1.srvrpccnt[j] =
- NFSD_VNET(nfsstatsv1_p)->srvrpccnt[i];
+ VNET(nfsstatsv1_p)->srvrpccnt[i];
nfsstatsov1.reserved_0 = 0;
nfsstatsov1.reserved_1 = 0;
nfsstatsov1.rpcrequests =
- NFSD_VNET(nfsstatsv1_p)->rpcrequests;
+ VNET(nfsstatsv1_p)->rpcrequests;
nfsstatsov1.rpctimeouts =
- NFSD_VNET(nfsstatsv1_p)->rpctimeouts;
+ VNET(nfsstatsv1_p)->rpctimeouts;
nfsstatsov1.rpcunexpected =
- NFSD_VNET(nfsstatsv1_p)->rpcunexpected;
+ VNET(nfsstatsv1_p)->rpcunexpected;
nfsstatsov1.rpcinvalid =
- NFSD_VNET(nfsstatsv1_p)->rpcinvalid;
+ VNET(nfsstatsv1_p)->rpcinvalid;
nfsstatsov1.srvcache_inproghits =
- NFSD_VNET(nfsstatsv1_p)->srvcache_inproghits;
+ VNET(nfsstatsv1_p)->srvcache_inproghits;
nfsstatsov1.reserved_2 = 0;
nfsstatsov1.srvcache_nonidemdonehits =
- NFSD_VNET(nfsstatsv1_p)->srvcache_nonidemdonehits;
+ VNET(nfsstatsv1_p)->srvcache_nonidemdonehits;
nfsstatsov1.srvcache_misses =
- NFSD_VNET(nfsstatsv1_p)->srvcache_misses;
+ VNET(nfsstatsv1_p)->srvcache_misses;
nfsstatsov1.srvcache_tcppeak =
- NFSD_VNET(nfsstatsv1_p)->srvcache_tcppeak;
+ VNET(nfsstatsv1_p)->srvcache_tcppeak;
nfsstatsov1.srvcache_size =
- NFSD_VNET(nfsstatsv1_p)->srvcache_size;
+ VNET(nfsstatsv1_p)->srvcache_size;
nfsstatsov1.srvclients =
- NFSD_VNET(nfsstatsv1_p)->srvclients;
+ VNET(nfsstatsv1_p)->srvclients;
nfsstatsov1.srvopenowners =
- NFSD_VNET(nfsstatsv1_p)->srvopenowners;
+ VNET(nfsstatsv1_p)->srvopenowners;
nfsstatsov1.srvopens =
- NFSD_VNET(nfsstatsv1_p)->srvopens;
+ VNET(nfsstatsv1_p)->srvopens;
nfsstatsov1.srvlockowners =
- NFSD_VNET(nfsstatsv1_p)->srvlockowners;
+ VNET(nfsstatsv1_p)->srvlockowners;
nfsstatsov1.srvlocks =
- NFSD_VNET(nfsstatsv1_p)->srvlocks;
+ VNET(nfsstatsv1_p)->srvlocks;
nfsstatsov1.srvdelegates =
- NFSD_VNET(nfsstatsv1_p)->srvdelegates;
+ VNET(nfsstatsv1_p)->srvdelegates;
for (i = 0; i < NFSV42_CBNOPS; i++)
nfsstatsov1.cbrpccnt[i] =
- NFSD_VNET(nfsstatsv1_p)->cbrpccnt[i];
+ VNET(nfsstatsv1_p)->cbrpccnt[i];
nfsstatsov1.clopenowners =
- NFSD_VNET(nfsstatsv1_p)->clopenowners;
+ VNET(nfsstatsv1_p)->clopenowners;
nfsstatsov1.clopens =
- NFSD_VNET(nfsstatsv1_p)->clopens;
+ VNET(nfsstatsv1_p)->clopens;
nfsstatsov1.cllockowners =
- NFSD_VNET(nfsstatsv1_p)->cllockowners;
+ VNET(nfsstatsv1_p)->cllockowners;
nfsstatsov1.cllocks =
- NFSD_VNET(nfsstatsv1_p)->cllocks;
+ VNET(nfsstatsv1_p)->cllocks;
nfsstatsov1.cldelegates =
- NFSD_VNET(nfsstatsv1_p)->cldelegates;
+ VNET(nfsstatsv1_p)->cldelegates;
nfsstatsov1.cllocalopenowners =
- NFSD_VNET(nfsstatsv1_p)->cllocalopenowners;
+ VNET(nfsstatsv1_p)->cllocalopenowners;
nfsstatsov1.cllocalopens =
- NFSD_VNET(nfsstatsv1_p)->cllocalopens;
+ VNET(nfsstatsv1_p)->cllocalopens;
nfsstatsov1.cllocallockowners =
- NFSD_VNET(nfsstatsv1_p)->cllocallockowners;
+ VNET(nfsstatsv1_p)->cllocallockowners;
nfsstatsov1.cllocallocks =
- NFSD_VNET(nfsstatsv1_p)->cllocallocks;
+ VNET(nfsstatsv1_p)->cllocallocks;
nfsstatsov1.srvstartcnt =
- NFSD_VNET(nfsstatsv1_p)->srvstartcnt;
+ VNET(nfsstatsv1_p)->srvstartcnt;
nfsstatsov1.srvdonecnt =
- NFSD_VNET(nfsstatsv1_p)->srvdonecnt;
+ VNET(nfsstatsv1_p)->srvdonecnt;
for (i = NFSV42_NOPS,
j = NFSV42_PURENOPS;
i < NFSV42_NOPS + NFSV4OP_FAKENOPS;
i++, j++) {
nfsstatsov1.srvbytes[j] =
- NFSD_VNET(nfsstatsv1_p)->srvbytes[i];
+ VNET(nfsstatsv1_p)->srvbytes[i];
nfsstatsov1.srvops[j] =
- NFSD_VNET(nfsstatsv1_p)->srvops[i];
+ VNET(nfsstatsv1_p)->srvops[i];
nfsstatsov1.srvduration[j] =
- NFSD_VNET(nfsstatsv1_p)->srvduration[i];
+ VNET(nfsstatsv1_p)->srvduration[i];
}
nfsstatsov1.busyfrom =
- NFSD_VNET(nfsstatsv1_p)->busyfrom;
+ VNET(nfsstatsv1_p)->busyfrom;
nfsstatsov1.busyfrom =
- NFSD_VNET(nfsstatsv1_p)->busyfrom;
+ VNET(nfsstatsv1_p)->busyfrom;
error = copyout(&nfsstatsov1, uap->argp,
sizeof(nfsstatsov1));
} else if (nfsstatver.vers != NFSSTATS_V1)
error = EPERM;
else
- error = copyout(NFSD_VNET(nfsstatsv1_p),
+ error = copyout(VNET(nfsstatsv1_p),
uap->argp, sizeof(nfsstatsv1));
}
}
if (error == 0) {
if ((uap->flag & NFSSVC_ZEROCLTSTATS) != 0) {
- NFSD_VNET(nfsstatsv1_p)->attrcache_hits = 0;
- NFSD_VNET(nfsstatsv1_p)->attrcache_misses = 0;
- NFSD_VNET(nfsstatsv1_p)->lookupcache_hits = 0;
- NFSD_VNET(nfsstatsv1_p)->lookupcache_misses = 0;
- NFSD_VNET(nfsstatsv1_p)->direofcache_hits = 0;
- NFSD_VNET(nfsstatsv1_p)->direofcache_misses = 0;
- NFSD_VNET(nfsstatsv1_p)->accesscache_hits = 0;
- NFSD_VNET(nfsstatsv1_p)->accesscache_misses = 0;
- NFSD_VNET(nfsstatsv1_p)->biocache_reads = 0;
- NFSD_VNET(nfsstatsv1_p)->read_bios = 0;
- NFSD_VNET(nfsstatsv1_p)->read_physios = 0;
- NFSD_VNET(nfsstatsv1_p)->biocache_writes = 0;
- NFSD_VNET(nfsstatsv1_p)->write_bios = 0;
- NFSD_VNET(nfsstatsv1_p)->write_physios = 0;
- NFSD_VNET(nfsstatsv1_p)->biocache_readlinks = 0;
- NFSD_VNET(nfsstatsv1_p)->readlink_bios = 0;
- NFSD_VNET(nfsstatsv1_p)->biocache_readdirs = 0;
- NFSD_VNET(nfsstatsv1_p)->readdir_bios = 0;
- NFSD_VNET(nfsstatsv1_p)->rpcretries = 0;
- NFSD_VNET(nfsstatsv1_p)->rpcrequests = 0;
- NFSD_VNET(nfsstatsv1_p)->rpctimeouts = 0;
- NFSD_VNET(nfsstatsv1_p)->rpcunexpected = 0;
- NFSD_VNET(nfsstatsv1_p)->rpcinvalid = 0;
- bzero(NFSD_VNET(nfsstatsv1_p)->rpccnt,
- sizeof(NFSD_VNET(nfsstatsv1_p)->rpccnt));
+ VNET(nfsstatsv1_p)->attrcache_hits = 0;
+ VNET(nfsstatsv1_p)->attrcache_misses = 0;
+ VNET(nfsstatsv1_p)->lookupcache_hits = 0;
+ VNET(nfsstatsv1_p)->lookupcache_misses = 0;
+ VNET(nfsstatsv1_p)->direofcache_hits = 0;
+ VNET(nfsstatsv1_p)->direofcache_misses = 0;
+ VNET(nfsstatsv1_p)->accesscache_hits = 0;
+ VNET(nfsstatsv1_p)->accesscache_misses = 0;
+ VNET(nfsstatsv1_p)->biocache_reads = 0;
+ VNET(nfsstatsv1_p)->read_bios = 0;
+ VNET(nfsstatsv1_p)->read_physios = 0;
+ VNET(nfsstatsv1_p)->biocache_writes = 0;
+ VNET(nfsstatsv1_p)->write_bios = 0;
+ VNET(nfsstatsv1_p)->write_physios = 0;
+ VNET(nfsstatsv1_p)->biocache_readlinks = 0;
+ VNET(nfsstatsv1_p)->readlink_bios = 0;
+ VNET(nfsstatsv1_p)->biocache_readdirs = 0;
+ VNET(nfsstatsv1_p)->readdir_bios = 0;
+ VNET(nfsstatsv1_p)->rpcretries = 0;
+ VNET(nfsstatsv1_p)->rpcrequests = 0;
+ VNET(nfsstatsv1_p)->rpctimeouts = 0;
+ VNET(nfsstatsv1_p)->rpcunexpected = 0;
+ VNET(nfsstatsv1_p)->rpcinvalid = 0;
+ bzero(VNET(nfsstatsv1_p)->rpccnt,
+ sizeof(VNET(nfsstatsv1_p)->rpccnt));
}
if ((uap->flag & NFSSVC_ZEROSRVSTATS) != 0) {
- NFSD_VNET(nfsstatsv1_p)->srvcache_inproghits = 0;
- NFSD_VNET(nfsstatsv1_p)->srvcache_nonidemdonehits = 0;
- NFSD_VNET(nfsstatsv1_p)->srvcache_misses = 0;
- NFSD_VNET(nfsstatsv1_p)->srvcache_tcppeak = 0;
- bzero(NFSD_VNET(nfsstatsv1_p)->srvrpccnt,
- sizeof(NFSD_VNET(nfsstatsv1_p)->srvrpccnt));
- bzero(NFSD_VNET(nfsstatsv1_p)->cbrpccnt,
- sizeof(NFSD_VNET(nfsstatsv1_p)->cbrpccnt));
+ VNET(nfsstatsv1_p)->srvcache_inproghits = 0;
+ VNET(nfsstatsv1_p)->srvcache_nonidemdonehits = 0;
+ VNET(nfsstatsv1_p)->srvcache_misses = 0;
+ VNET(nfsstatsv1_p)->srvcache_tcppeak = 0;
+ bzero(VNET(nfsstatsv1_p)->srvrpccnt,
+ sizeof(VNET(nfsstatsv1_p)->srvrpccnt));
+ bzero(VNET(nfsstatsv1_p)->cbrpccnt,
+ sizeof(VNET(nfsstatsv1_p)->cbrpccnt));
}
}
goto out;
@@ -891,11 +891,11 @@ nfs_vnetinit(const void *unused __unused)
{
if (IS_DEFAULT_VNET(curvnet))
- NFSD_VNET(nfsstatsv1_p) = &nfsstatsv1;
+ VNET(nfsstatsv1_p) = &nfsstatsv1;
else
- NFSD_VNET(nfsstatsv1_p) = malloc(sizeof(struct nfsstatsv1),
+ VNET(nfsstatsv1_p) = malloc(sizeof(struct nfsstatsv1),
M_TEMP, M_WAITOK | M_ZERO);
- mtx_init(&NFSD_VNET(nfsrv_nfsuserdsock).nr_mtx, "nfsuserd",
+ mtx_init(&VNET(nfsrv_nfsuserdsock).nr_mtx, "nfsuserd",
NULL, MTX_DEF);
}
VNET_SYSINIT(nfs_vnetinit, SI_SUB_VNET_DONE, SI_ORDER_FIRST,
@@ -905,10 +905,10 @@ static void
nfs_cleanup(void *unused __unused)
{
- mtx_destroy(&NFSD_VNET(nfsrv_nfsuserdsock).nr_mtx);
+ mtx_destroy(&VNET(nfsrv_nfsuserdsock).nr_mtx);
if (!IS_DEFAULT_VNET(curvnet)) {
- free(NFSD_VNET(nfsstatsv1_p), M_TEMP);
- NFSD_VNET(nfsstatsv1_p) = NULL;
+ free(VNET(nfsstatsv1_p), M_TEMP);
+ VNET(nfsstatsv1_p) = NULL;
}
/* Clean out the name<-->id cache. */
nfsrv_cleanusergroup();
@@ -945,7 +945,7 @@ nfscommon_modevent(module_t mod, int type, void *data)
case MOD_UNLOAD:
if (newnfs_numnfsd != 0 ||
- NFSD_VNET(nfsrv_nfsuserd) != NOTRUNNING ||
+ VNET(nfsrv_nfsuserd) != NOTRUNNING ||
nfs_numnfscbd != 0) {
error = EBUSY;
break;
diff --git a/sys/fs/nfs/nfs_commonsubs.c b/sys/fs/nfs/nfs_commonsubs.c
index 0b7c15a0b54e..b5f83a98b307 100644
--- a/sys/fs/nfs/nfs_commonsubs.c
+++ b/sys/fs/nfs/nfs_commonsubs.c
@@ -96,19 +96,19 @@ struct nfs_prime_userd nfs_prime_userd[] = {
{ 0, 0, 0, NULL },
};
-NFSD_VNET_DEFINE(int, nfsd_enable_stringtouid) = 0;
-NFSD_VNET_DEFINE(struct nfssockreq, nfsrv_nfsuserdsock);
-NFSD_VNET_DEFINE(nfsuserd_state, nfsrv_nfsuserd) = NOTRUNNING;
-NFSD_VNET_DEFINE(uid_t, nfsrv_defaultuid) = UID_NOBODY;
-NFSD_VNET_DEFINE(gid_t, nfsrv_defaultgid) = GID_NOGROUP;
+VNET_DEFINE(int, nfsd_enable_stringtouid) = 0;
+VNET_DEFINE(struct nfssockreq, nfsrv_nfsuserdsock);
+VNET_DEFINE(nfsuserd_state, nfsrv_nfsuserd) = NOTRUNNING;
+VNET_DEFINE(uid_t, nfsrv_defaultuid) = UID_NOBODY;
+VNET_DEFINE(gid_t, nfsrv_defaultgid) = GID_NOGROUP;
-NFSD_VNET_DEFINE_STATIC(int, nfsrv_userdupcalls) = 0;
+VNET_DEFINE_STATIC(int, nfsrv_userdupcalls) = 0;
SYSCTL_DECL(_vfs_nfs);
-NFSD_VNET_DEFINE_STATIC(int, nfs_enable_uidtostring) = 0;
+VNET_DEFINE_STATIC(int, nfs_enable_uidtostring) = 0;
SYSCTL_INT(_vfs_nfs, OID_AUTO, enable_uidtostring,
- CTLFLAG_NFSD_VNET | CTLFLAG_RW, &NFSD_VNET_NAME(nfs_enable_uidtostring), 0,
+ CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(nfs_enable_uidtostring), 0,
"Make nfs always send numeric owner_names");
int nfsrv_maxpnfsmirror = 1;
@@ -216,14 +216,14 @@ struct nfsrv_lughash {
struct nfsuserhashhead lughead;
};
-NFSD_VNET_DEFINE_STATIC(int, nfsrv_usercnt) = 0;
-NFSD_VNET_DEFINE_STATIC(int, nfsrv_dnsnamelen) = 0;
-NFSD_VNET_DEFINE_STATIC(int, nfsrv_usermax) = 999999999;
-NFSD_VNET_DEFINE_STATIC(struct nfsrv_lughash *, nfsuserhash) = NULL;
-NFSD_VNET_DEFINE_STATIC(struct nfsrv_lughash *, nfsusernamehash) = NULL;
-NFSD_VNET_DEFINE_STATIC(struct nfsrv_lughash *, nfsgrouphash) = NULL;
-NFSD_VNET_DEFINE_STATIC(struct nfsrv_lughash *, nfsgroupnamehash) = NULL;
-NFSD_VNET_DEFINE_STATIC(u_char *, nfsrv_dnsname) = NULL;
+VNET_DEFINE_STATIC(int, nfsrv_usercnt) = 0;
+VNET_DEFINE_STATIC(int, nfsrv_dnsnamelen) = 0;
+VNET_DEFINE_STATIC(int, nfsrv_usermax) = 999999999;
+VNET_DEFINE_STATIC(struct nfsrv_lughash *, nfsuserhash) = NULL;
+VNET_DEFINE_STATIC(struct nfsrv_lughash *, nfsusernamehash) = NULL;
+VNET_DEFINE_STATIC(struct nfsrv_lughash *, nfsgrouphash) = NULL;
+VNET_DEFINE_STATIC(struct nfsrv_lughash *, nfsgroupnamehash) = NULL;
+VNET_DEFINE_STATIC(u_char *, nfsrv_dnsname) = NULL;
/*
* This static array indicates whether or not the RPC generates a large
@@ -1369,7 +1369,7 @@ nfsv4_loadattr(struct nfsrv_descript *nd, vnode_t vp,
#endif
CTASSERT(sizeof(ino_t) == sizeof(uint64_t));
- NFSD_CURVNET_SET_QUIET(NFSD_TD_TO_VNET(curthread));
+ CURVNET_SET_QUIET(TD_TO_VNET(curthread));
if (compare) {
retnotsup = 0;
error = nfsrv_getattrbits(nd, &attrbits, NULL, &retnotsup);
@@ -2064,7 +2064,7 @@ nfsv4_loadattr(struct nfsrv_descript *nd, vnode_t vp,
} else if (nap != NULL) {
if (nfsv4_strtouid(nd, cp, j, &uid))
nap->na_uid =
- NFSD_VNET(nfsrv_defaultuid);
+ VNET(nfsrv_defaultuid);
else
nap->na_uid = uid;
}
@@ -2098,7 +2098,7 @@ nfsv4_loadattr(struct nfsrv_descript *nd, vnode_t vp,
} else if (nap != NULL) {
if (nfsv4_strtogid(nd, cp, j, &gid))
nap->na_gid =
- NFSD_VNET(nfsrv_defaultgid);
+ VNET(nfsrv_defaultgid);
else
nap->na_gid = gid;
}
@@ -2602,7 +2602,7 @@ nfsv4_loadattr(struct nfsrv_descript *nd, vnode_t vp,
error = nfsm_advance(nd, attrsize - attrsum, -1);
}
nfsmout:
- NFSD_CURVNET_RESTORE();
+ CURVNET_RESTORE();
NFSEXITCODE2(error, nd);
return (error);
}
@@ -3652,16 +3652,16 @@ nfsv4_uidtostr(uid_t uid, u_char **cpp, int *retlenp)
int cnt, hasampersand, len = NFSV4_SMALLSTR, ret;
struct nfsrv_lughash *hp;
- NFSD_CURVNET_SET_QUIET(NFSD_TD_TO_VNET(curthread));
+ CURVNET_SET_QUIET(TD_TO_VNET(curthread));
cnt = 0;
tryagain:
- if (NFSD_VNET(nfsrv_dnsnamelen) > 0 &&
- !NFSD_VNET(nfs_enable_uidtostring)) {
+ if (VNET(nfsrv_dnsnamelen) > 0 &&
+ !VNET(nfs_enable_uidtostring)) {
/*
* Always map nfsrv_defaultuid to "nobody".
*/
- if (uid == NFSD_VNET(nfsrv_defaultuid)) {
- i = NFSD_VNET(nfsrv_dnsnamelen) + 7;
+ if (uid == VNET(nfsrv_defaultuid)) {
+ i = VNET(nfsrv_dnsnamelen) + 7;
if (i > len) {
if (len > NFSV4_SMALLSTR)
free(cp, M_NFSSTRING);
@@ -3673,9 +3673,9 @@ tryagain:
*retlenp = i;
NFSBCOPY("nobody@", cp, 7);
cp += 7;
- NFSBCOPY(NFSD_VNET(nfsrv_dnsname), cp,
- NFSD_VNET(nfsrv_dnsnamelen));
- NFSD_CURVNET_RESTORE();
+ NFSBCOPY(VNET(nfsrv_dnsname), cp,
+ VNET(nfsrv_dnsnamelen));
+ CURVNET_RESTORE();
return;
}
hasampersand = 0;
@@ -3700,7 +3700,7 @@ tryagain:
i = usrp->lug_namelen;
else
i = usrp->lug_namelen +
- NFSD_VNET(nfsrv_dnsnamelen) + 1;
+ VNET(nfsrv_dnsnamelen) + 1;
if (i > len) {
mtx_unlock(&hp->mtx);
if (len > NFSV4_SMALLSTR)
@@ -3715,14 +3715,14 @@ tryagain:
if (!hasampersand) {
cp += usrp->lug_namelen;
*cp++ = '@';
- NFSBCOPY(NFSD_VNET(nfsrv_dnsname), cp,
- NFSD_VNET(nfsrv_dnsnamelen));
+ NFSBCOPY(VNET(nfsrv_dnsname), cp,
+ VNET(nfsrv_dnsnamelen));
}
TAILQ_REMOVE(&hp->lughead, usrp, lug_numhash);
TAILQ_INSERT_TAIL(&hp->lughead, usrp,
lug_numhash);
mtx_unlock(&hp->mtx);
- NFSD_CURVNET_RESTORE();
+ CURVNET_RESTORE();
return;
}
}
@@ -3750,7 +3750,7 @@ tryagain:
*cp-- = '0' + (tmp % 10);
tmp /= 10;
}
- NFSD_CURVNET_RESTORE();
+ CURVNET_RESTORE();
return;
}
@@ -3771,7 +3771,7 @@ nfsrv_getgrpscred(struct ucred *oldcred)
cnt = 0;
uid = oldcred->cr_uid;
tryagain:
- if (NFSD_VNET(nfsrv_dnsnamelen) > 0) {
+ if (VNET(nfsrv_dnsnamelen) > 0) {
hp = NFSUSERHASH(uid);
mtx_lock(&hp->mtx);
TAILQ_FOREACH(usrp, &hp->lughead, lug_numhash) {
@@ -3819,7 +3819,7 @@ nfsv4_strtouid(struct nfsrv_descript *nd, u_char *str, int len, uid_t *uidp)
uid_t tuid;
struct nfsrv_lughash *hp, *hp2;
- NFSD_CURVNET_SET_QUIET(NFSD_TD_TO_VNET(curthread));
+ CURVNET_SET_QUIET(TD_TO_VNET(curthread));
if (len == 0) {
error = NFSERR_BADOWNER;
goto out;
@@ -3831,7 +3831,7 @@ nfsv4_strtouid(struct nfsrv_descript *nd, u_char *str, int len, uid_t *uidp)
/* A numeric string. */
if ((nd->nd_flag & ND_KERBV) == 0 &&
((nd->nd_flag & ND_NFSCL) != 0 ||
- NFSD_VNET(nfsd_enable_stringtouid) != 0))
+ VNET(nfsd_enable_stringtouid) != 0))
*uidp = tuid;
else
error = NFSERR_BADOWNER;
@@ -3848,7 +3848,7 @@ nfsv4_strtouid(struct nfsrv_descript *nd, u_char *str, int len, uid_t *uidp)
cnt = 0;
tryagain:
- if (NFSD_VNET(nfsrv_dnsnamelen) > 0) {
+ if (VNET(nfsrv_dnsnamelen) > 0) {
/*
* If an '@' is found and the domain name matches, search for
* the name with dns stripped off.
@@ -3856,10 +3856,10 @@ tryagain:
* since RFC8881 defines this string as a DNS domain name.
*/
if (cnt == 0 && i < len && i > 0 &&
- (len - 1 - i) == NFSD_VNET(nfsrv_dnsnamelen) &&
- strncasecmp(cp, NFSD_VNET(nfsrv_dnsname),
- NFSD_VNET(nfsrv_dnsnamelen)) == 0) {
- len -= (NFSD_VNET(nfsrv_dnsnamelen) + 1);
+ (len - 1 - i) == VNET(nfsrv_dnsnamelen) &&
+ strncasecmp(cp, VNET(nfsrv_dnsname),
+ VNET(nfsrv_dnsnamelen)) == 0) {
+ len -= (VNET(nfsrv_dnsnamelen) + 1);
*(cp - 1) = '\0';
}
@@ -3867,7 +3867,7 @@ tryagain:
* Check for the special case of "nobody".
*/
if (len == 6 && !NFSBCMP(str, "nobody", 6)) {
- *uidp = NFSD_VNET(nfsrv_defaultuid);
+ *uidp = VNET(nfsrv_defaultuid);
error = 0;
goto out;
}
@@ -3902,7 +3902,7 @@ tryagain:
error = NFSERR_BADOWNER;
out:
- NFSD_CURVNET_RESTORE();
+ CURVNET_RESTORE();
NFSEXITCODE(error);
return (error);
}
@@ -3924,16 +3924,16 @@ nfsv4_gidtostr(gid_t gid, u_char **cpp, int *retlenp)
int cnt, hasampersand, len = NFSV4_SMALLSTR, ret;
struct nfsrv_lughash *hp;
- NFSD_CURVNET_SET_QUIET(NFSD_TD_TO_VNET(curthread));
+ CURVNET_SET_QUIET(TD_TO_VNET(curthread));
cnt = 0;
tryagain:
- if (NFSD_VNET(nfsrv_dnsnamelen) > 0 &&
- !NFSD_VNET(nfs_enable_uidtostring)) {
+ if (VNET(nfsrv_dnsnamelen) > 0 &&
+ !VNET(nfs_enable_uidtostring)) {
/*
* Always map nfsrv_defaultgid to "nogroup".
*/
- if (gid == NFSD_VNET(nfsrv_defaultgid)) {
- i = NFSD_VNET(nfsrv_dnsnamelen) + 8;
+ if (gid == VNET(nfsrv_defaultgid)) {
+ i = VNET(nfsrv_dnsnamelen) + 8;
if (i > len) {
if (len > NFSV4_SMALLSTR)
free(cp, M_NFSSTRING);
@@ -3945,9 +3945,9 @@ tryagain:
*retlenp = i;
NFSBCOPY("nogroup@", cp, 8);
cp += 8;
- NFSBCOPY(NFSD_VNET(nfsrv_dnsname), cp,
- NFSD_VNET(nfsrv_dnsnamelen));
- NFSD_CURVNET_RESTORE();
+ NFSBCOPY(VNET(nfsrv_dnsname), cp,
+ VNET(nfsrv_dnsnamelen));
+ CURVNET_RESTORE();
return;
}
hasampersand = 0;
@@ -3972,7 +3972,7 @@ tryagain:
i = usrp->lug_namelen;
else
i = usrp->lug_namelen +
- NFSD_VNET(nfsrv_dnsnamelen) + 1;
+ VNET(nfsrv_dnsnamelen) + 1;
if (i > len) {
mtx_unlock(&hp->mtx);
if (len > NFSV4_SMALLSTR)
@@ -3987,14 +3987,14 @@ tryagain:
if (!hasampersand) {
cp += usrp->lug_namelen;
*cp++ = '@';
- NFSBCOPY(NFSD_VNET(nfsrv_dnsname), cp,
- NFSD_VNET(nfsrv_dnsnamelen));
+ NFSBCOPY(VNET(nfsrv_dnsname), cp,
+ VNET(nfsrv_dnsnamelen));
}
TAILQ_REMOVE(&hp->lughead, usrp, lug_numhash);
TAILQ_INSERT_TAIL(&hp->lughead, usrp,
lug_numhash);
mtx_unlock(&hp->mtx);
- NFSD_CURVNET_RESTORE();
+ CURVNET_RESTORE();
return;
}
}
@@ -4022,7 +4022,7 @@ tryagain:
*cp-- = '0' + (tmp % 10);
tmp /= 10;
}
- NFSD_CURVNET_RESTORE();
+ CURVNET_RESTORE();
return;
}
@@ -4045,7 +4045,7 @@ nfsv4_strtogid(struct nfsrv_descript *nd, u_char *str, int len, gid_t *gidp)
gid_t tgid;
struct nfsrv_lughash *hp, *hp2;
- NFSD_CURVNET_SET_QUIET(NFSD_TD_TO_VNET(curthread));
+ CURVNET_SET_QUIET(TD_TO_VNET(curthread));
if (len == 0) {
error = NFSERR_BADOWNER;
goto out;
@@ -4057,7 +4057,7 @@ nfsv4_strtogid(struct nfsrv_descript *nd, u_char *str, int len, gid_t *gidp)
/* A numeric string. */
if ((nd->nd_flag & ND_KERBV) == 0 &&
((nd->nd_flag & ND_NFSCL) != 0 ||
- NFSD_VNET(nfsd_enable_stringtouid) != 0))
+ VNET(nfsd_enable_stringtouid) != 0))
*gidp = tgid;
else
error = NFSERR_BADOWNER;
@@ -4074,16 +4074,16 @@ nfsv4_strtogid(struct nfsrv_descript *nd, u_char *str, int len, gid_t *gidp)
cnt = 0;
tryagain:
- if (NFSD_VNET(nfsrv_dnsnamelen) > 0) {
+ if (VNET(nfsrv_dnsnamelen) > 0) {
/*
* If an '@' is found and the dns name matches, search for the
* name with the dns stripped off.
*/
if (cnt == 0 && i < len && i > 0 &&
- (len - 1 - i) == NFSD_VNET(nfsrv_dnsnamelen) &&
- strncasecmp(cp, NFSD_VNET(nfsrv_dnsname),
- NFSD_VNET(nfsrv_dnsnamelen)) == 0) {
- len -= (NFSD_VNET(nfsrv_dnsnamelen) + 1);
+ (len - 1 - i) == VNET(nfsrv_dnsnamelen) &&
+ strncasecmp(cp, VNET(nfsrv_dnsname),
+ VNET(nfsrv_dnsnamelen)) == 0) {
+ len -= (VNET(nfsrv_dnsnamelen) + 1);
*(cp - 1) = '\0';
}
@@ -4091,7 +4091,7 @@ tryagain:
* Check for the special case of "nogroup".
*/
if (len == 7 && !NFSBCMP(str, "nogroup", 7)) {
- *gidp = NFSD_VNET(nfsrv_defaultgid);
+ *gidp = VNET(nfsrv_defaultgid);
error = 0;
goto out;
}
@@ -4126,7 +4126,7 @@ tryagain:
error = NFSERR_BADOWNER;
out:
- NFSD_CURVNET_RESTORE();
+ CURVNET_RESTORE();
NFSEXITCODE(error);
return (error);
}
@@ -4148,12 +4148,12 @@ nfsrv_nfsuserdport(struct nfsuserd_args *nargs, NFSPROC_T *p)
int error;
NFSLOCKNAMEID();
- if (NFSD_VNET(nfsrv_nfsuserd) != NOTRUNNING) {
+ if (VNET(nfsrv_nfsuserd) != NOTRUNNING) {
NFSUNLOCKNAMEID();
error = EPERM;
goto out;
}
- NFSD_VNET(nfsrv_nfsuserd) = STARTSTOP;
+ VNET(nfsrv_nfsuserd) = STARTSTOP;
/*
* Set up the socket record and connect.
* Set nr_client NULL before unlocking, just to ensure that no other
@@ -4161,7 +4161,7 @@ nfsrv_nfsuserdport(struct nfsuserd_args *nargs, NFSPROC_T *p)
* occur if the use of the nameid lock to protect nfsrv_nfsuserd is
* broken.
*/
- rp = &NFSD_VNET(nfsrv_nfsuserdsock);
+ rp = &VNET(nfsrv_nfsuserdsock);
rp->nr_client = NULL;
NFSUNLOCKNAMEID();
rp->nr_sotype = SOCK_DGRAM;
@@ -4202,12 +4202,12 @@ nfsrv_nfsuserdport(struct nfsuserd_args *nargs, NFSPROC_T *p)
&rp->nr_client);
if (error == 0) {
NFSLOCKNAMEID();
- NFSD_VNET(nfsrv_nfsuserd) = RUNNING;
+ VNET(nfsrv_nfsuserd) = RUNNING;
NFSUNLOCKNAMEID();
} else {
free(rp->nr_nam, M_SONAME);
NFSLOCKNAMEID();
- NFSD_VNET(nfsrv_nfsuserd) = NOTRUNNING;
+ VNET(nfsrv_nfsuserd) = NOTRUNNING;
NFSUNLOCKNAMEID();
}
out:
@@ -4223,21 +4223,21 @@ nfsrv_nfsuserddelport(void)
{
NFSLOCKNAMEID();
- if (NFSD_VNET(nfsrv_nfsuserd) != RUNNING) {
+ if (VNET(nfsrv_nfsuserd) != RUNNING) {
NFSUNLOCKNAMEID();
return;
}
- NFSD_VNET(nfsrv_nfsuserd) = STARTSTOP;
+ VNET(nfsrv_nfsuserd) = STARTSTOP;
/* Wait for all upcalls to complete. */
- while (NFSD_VNET(nfsrv_userdupcalls) > 0)
- msleep(&NFSD_VNET(nfsrv_userdupcalls), NFSNAMEIDMUTEXPTR, PVFS,
+ while (VNET(nfsrv_userdupcalls) > 0)
+ msleep(&VNET(nfsrv_userdupcalls), NFSNAMEIDMUTEXPTR, PVFS,
"nfsupcalls", 0);
NFSUNLOCKNAMEID();
- newnfs_disconnect(NULL, &NFSD_VNET(nfsrv_nfsuserdsock));
- free(NFSD_VNET(nfsrv_nfsuserdsock).nr_nam, M_SONAME);
+ newnfs_disconnect(NULL, &VNET(nfsrv_nfsuserdsock));
+ free(VNET(nfsrv_nfsuserdsock).nr_nam, M_SONAME);
crfree(VNET(nfsrv_nfsuserdsock).nr_cred);
NFSLOCKNAMEID();
- NFSD_VNET(nfsrv_nfsuserd) = NOTRUNNING;
+ VNET(nfsrv_nfsuserd) = NOTRUNNING;
NFSUNLOCKNAMEID();
}
@@ -4257,7 +4257,7 @@ nfsrv_getuser(int procnum, uid_t uid, gid_t gid, char *name)
int error;
NFSLOCKNAMEID();
- if (NFSD_VNET(nfsrv_nfsuserd) != RUNNING) {
+ if (VNET(nfsrv_nfsuserd) != RUNNING) {
NFSUNLOCKNAMEID();
error = EPERM;
goto out;
@@ -4266,9 +4266,9 @@ nfsrv_getuser(int procnum, uid_t uid, gid_t gid, char *name)
* Maintain a count of upcalls in progress, so that nfsrv_X()
* can wait until no upcalls are in progress.
*/
- NFSD_VNET(nfsrv_userdupcalls)++;
+ VNET(nfsrv_userdupcalls)++;
NFSUNLOCKNAMEID();
- KASSERT(NFSD_VNET(nfsrv_userdupcalls) > 0,
+ KASSERT(VNET(nfsrv_userdupcalls) > 0,
("nfsrv_getuser: non-positive upcalls"));
nd = &nfsd;
cred = newnfs_getcred();
@@ -4286,13 +4286,13 @@ nfsrv_getuser(int procnum, uid_t uid, gid_t gid, char *name)
len = strlen(name);
(void) nfsm_strtom(nd, name, len);
}
- error = newnfs_request(nd, NULL, NULL, &NFSD_VNET(nfsrv_nfsuserdsock),
+ error = newnfs_request(nd, NULL, NULL, &VNET(nfsrv_nfsuserdsock),
NULL, NULL, cred, RPCPROG_NFSUSERD, RPCNFSUSERD_VERS, NULL, 0,
NULL, NULL);
NFSLOCKNAMEID();
- if (--NFSD_VNET(nfsrv_userdupcalls) == 0 &&
- NFSD_VNET(nfsrv_nfsuserd) == STARTSTOP)
- wakeup(&NFSD_VNET(nfsrv_userdupcalls));
+ if (--VNET(nfsrv_userdupcalls) == 0 &&
+ VNET(nfsrv_nfsuserd) == STARTSTOP)
+ wakeup(&VNET(nfsrv_userdupcalls));
NFSUNLOCKNAMEID();
NFSFREECRED(cred);
if (!error) {
@@ -4353,7 +4353,7 @@ nfssvc_idname(struct nfsd_idargs *nidp)
free(cp, M_NFSSTRING);
goto out;
}
- if (atomic_cmpset_acq_int(&NFSD_VNET(nfsrv_dnsnamelen), 0, 0) ==
+ if (atomic_cmpset_acq_int(&VNET(nfsrv_dnsnamelen), 0, 0) ==
0) {
/*
* Free up all the old stuff and reinitialize hash
@@ -4362,80 +4362,80 @@ nfssvc_idname(struct nfsd_idargs *nidp)
* ones, to avoid a LOR.
*/
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_lock(&NFSD_VNET(nfsusernamehash)[i].mtx);
+ mtx_lock(&VNET(nfsusernamehash)[i].mtx);
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_lock(&NFSD_VNET(nfsuserhash)[i].mtx);
+ mtx_lock(&VNET(nfsuserhash)[i].mtx);
for (i = 0; i < nfsrv_lughashsize; i++)
TAILQ_FOREACH_SAFE(usrp,
- &NFSD_VNET(nfsuserhash)[i].lughead, lug_numhash, nusrp)
+ &VNET(nfsuserhash)[i].lughead, lug_numhash, nusrp)
nfsrv_removeuser(usrp, 1);
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_unlock(&NFSD_VNET(nfsuserhash)[i].mtx);
+ mtx_unlock(&VNET(nfsuserhash)[i].mtx);
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_unlock(&NFSD_VNET(nfsusernamehash)[i].mtx);
+ mtx_unlock(&VNET(nfsusernamehash)[i].mtx);
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_lock(&NFSD_VNET(nfsgroupnamehash)[i].mtx);
+ mtx_lock(&VNET(nfsgroupnamehash)[i].mtx);
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_lock(&NFSD_VNET(nfsgrouphash)[i].mtx);
+ mtx_lock(&VNET(nfsgrouphash)[i].mtx);
for (i = 0; i < nfsrv_lughashsize; i++)
TAILQ_FOREACH_SAFE(usrp,
- &NFSD_VNET(nfsgrouphash)[i].lughead, lug_numhash,
+ &VNET(nfsgrouphash)[i].lughead, lug_numhash,
nusrp)
nfsrv_removeuser(usrp, 0);
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_unlock(&NFSD_VNET(nfsgrouphash)[i].mtx);
+ mtx_unlock(&VNET(nfsgrouphash)[i].mtx);
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_unlock(&NFSD_VNET(nfsgroupnamehash)[i].mtx);
- free(NFSD_VNET(nfsrv_dnsname), M_NFSSTRING);
- NFSD_VNET(nfsrv_dnsname) = NULL;
+ mtx_unlock(&VNET(nfsgroupnamehash)[i].mtx);
+ free(VNET(nfsrv_dnsname), M_NFSSTRING);
+ VNET(nfsrv_dnsname) = NULL;
}
- if (NFSD_VNET(nfsuserhash) == NULL) {
+ if (VNET(nfsuserhash) == NULL) {
/* Allocate the hash tables. */
- NFSD_VNET(nfsuserhash) = malloc(sizeof(struct nfsrv_lughash) *
+ VNET(nfsuserhash) = malloc(sizeof(struct nfsrv_lughash) *
nfsrv_lughashsize, M_NFSUSERGROUP, M_WAITOK |
M_ZERO);
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_init(&NFSD_VNET(nfsuserhash)[i].mtx, "nfsuidhash",
+ mtx_init(&VNET(nfsuserhash)[i].mtx, "nfsuidhash",
NULL, MTX_DEF | MTX_DUPOK);
- NFSD_VNET(nfsusernamehash) = malloc(sizeof(struct nfsrv_lughash) *
+ VNET(nfsusernamehash) = malloc(sizeof(struct nfsrv_lughash) *
nfsrv_lughashsize, M_NFSUSERGROUP, M_WAITOK |
M_ZERO);
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_init(&NFSD_VNET(nfsusernamehash)[i].mtx,
+ mtx_init(&VNET(nfsusernamehash)[i].mtx,
"nfsusrhash", NULL, MTX_DEF |
MTX_DUPOK);
- NFSD_VNET(nfsgrouphash) = malloc(sizeof(struct nfsrv_lughash) *
+ VNET(nfsgrouphash) = malloc(sizeof(struct nfsrv_lughash) *
nfsrv_lughashsize, M_NFSUSERGROUP, M_WAITOK |
M_ZERO);
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_init(&NFSD_VNET(nfsgrouphash)[i].mtx, "nfsgidhash",
+ mtx_init(&VNET(nfsgrouphash)[i].mtx, "nfsgidhash",
NULL, MTX_DEF | MTX_DUPOK);
- NFSD_VNET(nfsgroupnamehash) = malloc(sizeof(struct nfsrv_lughash) *
+ VNET(nfsgroupnamehash) = malloc(sizeof(struct nfsrv_lughash) *
nfsrv_lughashsize, M_NFSUSERGROUP, M_WAITOK |
M_ZERO);
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_init(&NFSD_VNET(nfsgroupnamehash)[i].mtx,
+ mtx_init(&VNET(nfsgroupnamehash)[i].mtx,
"nfsgrphash", NULL, MTX_DEF | MTX_DUPOK);
}
/* (Re)initialize the list heads. */
for (i = 0; i < nfsrv_lughashsize; i++)
- TAILQ_INIT(&NFSD_VNET(nfsuserhash)[i].lughead);
+ TAILQ_INIT(&VNET(nfsuserhash)[i].lughead);
for (i = 0; i < nfsrv_lughashsize; i++)
- TAILQ_INIT(&NFSD_VNET(nfsusernamehash)[i].lughead);
+ TAILQ_INIT(&VNET(nfsusernamehash)[i].lughead);
for (i = 0; i < nfsrv_lughashsize; i++)
- TAILQ_INIT(&NFSD_VNET(nfsgrouphash)[i].lughead);
+ TAILQ_INIT(&VNET(nfsgrouphash)[i].lughead);
for (i = 0; i < nfsrv_lughashsize; i++)
- TAILQ_INIT(&NFSD_VNET(nfsgroupnamehash)[i].lughead);
+ TAILQ_INIT(&VNET(nfsgroupnamehash)[i].lughead);
/*
* Put name in "DNS" string.
*/
- NFSD_VNET(nfsrv_dnsname) = cp;
- NFSD_VNET(nfsrv_defaultuid) = nidp->nid_uid;
- NFSD_VNET(nfsrv_defaultgid) = nidp->nid_gid;
- NFSD_VNET(nfsrv_usercnt) = 0;
- NFSD_VNET(nfsrv_usermax) = nidp->nid_usermax;
- atomic_store_rel_int(&NFSD_VNET(nfsrv_dnsnamelen),
+ VNET(nfsrv_dnsname) = cp;
+ VNET(nfsrv_defaultuid) = nidp->nid_uid;
+ VNET(nfsrv_defaultgid) = nidp->nid_gid;
+ VNET(nfsrv_usercnt) = 0;
+ VNET(nfsrv_usermax) = nidp->nid_usermax;
+ atomic_store_rel_int(&VNET(nfsrv_dnsnamelen),
nidp->nid_namelen);
goto out;
}
@@ -4505,7 +4505,7 @@ nfssvc_idname(struct nfsd_idargs *nidp)
if (nidp->nid_flag & (NFSID_DELUID | NFSID_ADDUID)) {
/* Must lock all username hash lists first, to avoid a LOR. */
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_lock(&NFSD_VNET(nfsusernamehash)[i].mtx);
+ mtx_lock(&VNET(nfsusernamehash)[i].mtx);
username_locked = 1;
hp_idnum = NFSUSERHASH(nidp->nid_uid);
mtx_lock(&hp_idnum->mtx);
@@ -4534,7 +4534,7 @@ nfssvc_idname(struct nfsd_idargs *nidp)
} else if (nidp->nid_flag & (NFSID_DELGID | NFSID_ADDGID)) {
/* Must lock all groupname hash lists first, to avoid a LOR. */
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_lock(&NFSD_VNET(nfsgroupnamehash)[i].mtx);
+ mtx_lock(&VNET(nfsgroupnamehash)[i].mtx);
groupname_locked = 1;
hp_idnum = NFSGROUPHASH(nidp->nid_gid);
mtx_lock(&hp_idnum->mtx);
@@ -4581,7 +4581,7 @@ nfssvc_idname(struct nfsd_idargs *nidp)
thp = NFSUSERNAMEHASH(newusrp->lug_name, newusrp->lug_namelen);
mtx_assert(&thp->mtx, MA_OWNED);
TAILQ_INSERT_TAIL(&thp->lughead, newusrp, lug_namehash);
- atomic_add_int(&NFSD_VNET(nfsrv_usercnt), 1);
+ atomic_add_int(&VNET(nfsrv_usercnt), 1);
} else if (nidp->nid_flag & (NFSID_ADDGID | NFSID_ADDGROUPNAME)) {
if (nfs_nfsv4root && nfs_in_prime(NFSID_ADDGID, nidp->nid_uid,
nidp->nid_gid))
@@ -4593,7 +4593,7 @@ nfssvc_idname(struct nfsd_idargs *nidp)
thp = NFSGROUPNAMEHASH(newusrp->lug_name, newusrp->lug_namelen);
mtx_assert(&thp->mtx, MA_OWNED);
TAILQ_INSERT_TAIL(&thp->lughead, newusrp, lug_namehash);
- atomic_add_int(&NFSD_VNET(nfsrv_usercnt), 1);
+ atomic_add_int(&VNET(nfsrv_usercnt), 1);
} else {
if (newusrp->lug_cred != NULL)
crfree(newusrp->lug_cred);
@@ -4622,17 +4622,17 @@ nfssvc_idname(struct nfsd_idargs *nidp)
NFSID_DELUSERNAME | NFSID_ADDUSERNAME)) != 0) {
if (username_locked == 0) {
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_lock(&NFSD_VNET(nfsusernamehash)[i].mtx);
+ mtx_lock(&VNET(nfsusernamehash)[i].mtx);
username_locked = 1;
}
KASSERT(user_locked == 0,
("nfssvc_idname: user_locked"));
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_lock(&NFSD_VNET(nfsuserhash)[i].mtx);
+ mtx_lock(&VNET(nfsuserhash)[i].mtx);
user_locked = 1;
for (i = 0; i < nfsrv_lughashsize; i++) {
TAILQ_FOREACH_SAFE(usrp,
- &NFSD_VNET(nfsuserhash)[i].lughead, lug_numhash,
+ &VNET(nfsuserhash)[i].lughead, lug_numhash,
nusrp)
if (!usrp->lug_wired &&
usrp->lug_expiry < NFSD_MONOSEC)
@@ -4644,26 +4644,26 @@ nfssvc_idname(struct nfsd_idargs *nidp)
* algorithm. This code deletes the least
* recently used entry on each hash list.
*/
- if (NFSD_VNET(nfsrv_usercnt) <= NFSD_VNET(nfsrv_usermax))
+ if (VNET(nfsrv_usercnt) <= VNET(nfsrv_usermax))
break;
- usrp = TAILQ_FIRST(&NFSD_VNET(nfsuserhash)[i].lughead);
+ usrp = TAILQ_FIRST(&VNET(nfsuserhash)[i].lughead);
if (usrp != NULL)
nfsrv_removeuser(usrp, 1);
}
} else {
if (groupname_locked == 0) {
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_lock(&NFSD_VNET(nfsgroupnamehash)[i].mtx);
+ mtx_lock(&VNET(nfsgroupnamehash)[i].mtx);
groupname_locked = 1;
}
KASSERT(group_locked == 0,
("nfssvc_idname: group_locked"));
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_lock(&NFSD_VNET(nfsgrouphash)[i].mtx);
+ mtx_lock(&VNET(nfsgrouphash)[i].mtx);
group_locked = 1;
for (i = 0; i < nfsrv_lughashsize; i++) {
TAILQ_FOREACH_SAFE(usrp,
- &NFSD_VNET(nfsgrouphash)[i].lughead, lug_numhash,
+ &VNET(nfsgrouphash)[i].lughead, lug_numhash,
nusrp)
if (!usrp->lug_wired &&
usrp->lug_expiry < NFSD_MONOSEC)
@@ -4675,9 +4675,9 @@ nfssvc_idname(struct nfsd_idargs *nidp)
* algorithm. This code deletes the least
* recently user entry on each hash list.
*/
- if (NFSD_VNET(nfsrv_usercnt) <= NFSD_VNET(nfsrv_usermax))
+ if (VNET(nfsrv_usercnt) <= VNET(nfsrv_usermax))
break;
- usrp = TAILQ_FIRST(&NFSD_VNET(nfsgrouphash)[i].lughead);
+ usrp = TAILQ_FIRST(&VNET(nfsgrouphash)[i].lughead);
if (usrp != NULL)
nfsrv_removeuser(usrp, 0);
}
@@ -4693,16 +4693,16 @@ nfssvc_idname(struct nfsd_idargs *nidp)
mtx_unlock(&hp_name->mtx);
if (user_locked != 0)
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_unlock(&NFSD_VNET(nfsuserhash)[i].mtx);
+ mtx_unlock(&VNET(nfsuserhash)[i].mtx);
if (username_locked != 0)
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_unlock(&NFSD_VNET(nfsusernamehash)[i].mtx);
+ mtx_unlock(&VNET(nfsusernamehash)[i].mtx);
if (group_locked != 0)
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_unlock(&NFSD_VNET(nfsgrouphash)[i].mtx);
+ mtx_unlock(&VNET(nfsgrouphash)[i].mtx);
if (groupname_locked != 0)
for (i = 0; i < nfsrv_lughashsize; i++)
- mtx_unlock(&NFSD_VNET(nfsgroupnamehash)[i].mtx);
+ mtx_unlock(&VNET(nfsgroupnamehash)[i].mtx);
out:
NFSEXITCODE(error);
return (error);
@@ -4731,7 +4731,7 @@ nfsrv_removeuser(struct nfsusrgrp *usrp, int isuser)
mtx_assert(&hp->mtx, MA_OWNED);
TAILQ_REMOVE(&hp->lughead, usrp, lug_namehash);
}
- atomic_add_int(&NFSD_VNET(nfsrv_usercnt), -1);
+ atomic_add_int(&VNET(nfsrv_usercnt), -1);
if (usrp->lug_cred != NULL)
crfree(usrp->lug_cred);
free(usrp, M_NFSUSERGROUP);
@@ -4750,11 +4750,11 @@ nfsrv_cleanusergroup(void)
struct nfsusrgrp *nusrp, *usrp;
int i;
- if (NFSD_VNET(nfsuserhash) == NULL)
+ if (VNET(nfsuserhash) == NULL)
return;
for (i = 0; i < nfsrv_lughashsize; i++) {
- hp = &NFSD_VNET(nfsuserhash)[i];
+ hp = &VNET(nfsuserhash)[i];
TAILQ_FOREACH_SAFE(usrp, &hp->lughead, lug_numhash, nusrp) {
TAILQ_REMOVE(&hp->lughead, usrp, lug_numhash);
hp2 = NFSUSERNAMEHASH(usrp->lug_name,
@@ -4764,7 +4764,7 @@ nfsrv_cleanusergroup(void)
crfree(usrp->lug_cred);
free(usrp, M_NFSUSERGROUP);
}
- hp = &NFSD_VNET(nfsgrouphash)[i];
+ hp = &VNET(nfsgrouphash)[i];
TAILQ_FOREACH_SAFE(usrp, &hp->lughead, lug_numhash, nusrp) {
TAILQ_REMOVE(&hp->lughead, usrp, lug_numhash);
hp2 = NFSGROUPNAMEHASH(usrp->lug_name,
@@ -4774,16 +4774,16 @@ nfsrv_cleanusergroup(void)
crfree(usrp->lug_cred);
free(usrp, M_NFSUSERGROUP);
}
- mtx_destroy(&NFSD_VNET(nfsuserhash)[i].mtx);
- mtx_destroy(&NFSD_VNET(nfsusernamehash)[i].mtx);
- mtx_destroy(&NFSD_VNET(nfsgroupnamehash)[i].mtx);
- mtx_destroy(&NFSD_VNET(nfsgrouphash)[i].mtx);
+ mtx_destroy(&VNET(nfsuserhash)[i].mtx);
+ mtx_destroy(&VNET(nfsusernamehash)[i].mtx);
+ mtx_destroy(&VNET(nfsgroupnamehash)[i].mtx);
+ mtx_destroy(&VNET(nfsgrouphash)[i].mtx);
}
- free(NFSD_VNET(nfsuserhash), M_NFSUSERGROUP);
- free(NFSD_VNET(nfsusernamehash), M_NFSUSERGROUP);
- free(NFSD_VNET(nfsgrouphash), M_NFSUSERGROUP);
- free(NFSD_VNET(nfsgroupnamehash), M_NFSUSERGROUP);
- free(NFSD_VNET(nfsrv_dnsname), M_NFSSTRING);
+ free(VNET(nfsuserhash), M_NFSUSERGROUP);
+ free(VNET(nfsusernamehash), M_NFSUSERGROUP);
+ free(VNET(nfsgrouphash), M_NFSUSERGROUP);
+ free(VNET(nfsgroupnamehash), M_NFSUSERGROUP);
+ free(VNET(nfsrv_dnsname), M_NFSSTRING);
}
/*
diff --git a/sys/fs/nfs/nfsdport.h b/sys/fs/nfs/nfsdport.h
index 6439ef921d29..33190274eb86 100644
--- a/sys/fs/nfs/nfsdport.h
+++ b/sys/fs/nfs/nfsdport.h
@@ -92,7 +92,7 @@ struct nfsexstuff {
bcmp(&(f1)->fh_fid, &(f2)->fh_fid, sizeof(struct fid)) == 0)
#define NFSLOCKHASH(f) \
- (&NFSD_VNET(nfslockhash)[nfsrv_hashfh(f) % nfsrv_lockhashsize])
+ (&VNET(nfslockhash)[nfsrv_hashfh(f) % nfsrv_lockhashsize])
#define NFSFPVNODE(f) ((f)->f_vnode)
#define NFSFPCRED(f) ((f)->f_cred)
diff --git a/sys/fs/nfs/nfsport.h b/sys/fs/nfs/nfsport.h
index f6b6cfb22908..91345bde3441 100644
--- a/sys/fs/nfs/nfsport.h
+++ b/sys/fs/nfs/nfsport.h
@@ -179,20 +179,6 @@
*/
#define NFSMUTEX_T struct mtx
-/* Just define the NFSD_VNETxxx() macros as VNETxxx() macros. */
-#define NFSD_VNET_NAME(n) VNET_NAME(n)
-#define NFSD_VNET_DECLARE(t, n) VNET_DECLARE(t, n)
-#define NFSD_VNET_DEFINE(t, n) VNET_DEFINE(t, n)
-#define NFSD_VNET_DEFINE_STATIC(t, n) VNET_DEFINE_STATIC(t, n)
-#define NFSD_VNET(n) VNET(n)
-
-#define CTLFLAG_NFSD_VNET CTLFLAG_VNET
-
-#define NFSD_CURVNET_SET(n) CURVNET_SET(n)
-#define NFSD_CURVNET_SET_QUIET(n) CURVNET_SET_QUIET(n)
-#define NFSD_CURVNET_RESTORE() CURVNET_RESTORE()
-#define NFSD_TD_TO_VNET(n) TD_TO_VNET(n)
-
#endif /* _KERNEL */
/*
diff --git a/sys/fs/nfs/nfsrvstate.h b/sys/fs/nfs/nfsrvstate.h
index 858c52ec6218..0e93f87234b2 100644
--- a/sys/fs/nfs/nfsrvstate.h
+++ b/sys/fs/nfs/nfsrvstate.h
@@ -56,18 +56,18 @@ LIST_HEAD(nfsdontlisthead, nfsdontlist);
TAILQ_HEAD(nfsuserhashhead, nfsusrgrp);
#define NFSCLIENTHASH(id) \
- (&NFSD_VNET(nfsclienthash)[(id).lval[1] % nfsrv_clienthashsize])
+ (&VNET(nfsclienthash)[(id).lval[1] % nfsrv_clienthashsize])
#define NFSSTATEHASH(clp, id) \
(&((clp)->lc_stateid[(id).other[2] % nfsrv_statehashsize]))
#define NFSUSERHASH(id) \
- (&NFSD_VNET(nfsuserhash)[(id) % nfsrv_lughashsize])
+ (&VNET(nfsuserhash)[(id) % nfsrv_lughashsize])
#define NFSUSERNAMEHASH(p, l) \
- (&NFSD_VNET(nfsusernamehash)[((l)>=4?(*(p)+*((p)+1)+*((p)+2)+*((p)+3)):*(p)) \
+ (&VNET(nfsusernamehash)[((l)>=4?(*(p)+*((p)+1)+*((p)+2)+*((p)+3)):*(p)) \
% nfsrv_lughashsize])
#define NFSGROUPHASH(id) \
- (&NFSD_VNET(nfsgrouphash)[(id) % nfsrv_lughashsize])
+ (&VNET(nfsgrouphash)[(id) % nfsrv_lughashsize])
#define NFSGROUPNAMEHASH(p, l) \
- (&NFSD_VNET(nfsgroupnamehash)[((l)>=4?(*(p)+*((p)+1)+*((p)+2)+*((p)+3)):*(p)) \
+ (&VNET(nfsgroupnamehash)[((l)>=4?(*(p)+*((p)+1)+*((p)+2)+*((p)+3)):*(p)) \
% nfsrv_lughashsize])
struct nfssessionhash {
@@ -75,7 +75,7 @@ struct nfssessionhash {
struct nfssessionhashhead list;
};
#define NFSSESSIONHASH(f) \
- (&NFSD_VNET(nfssessionhash)[nfsrv_hashsessionid(f) % \
+ (&VNET(nfssessionhash)[nfsrv_hashsessionid(f) % \
nfsrv_sessionhashsize])
struct nfslayouthash {
diff --git a/sys/fs/nfsclient/nfs_clport.c b/sys/fs/nfsclient/nfs_clport.c
index bc5f74b79749..6573144fc8d3 100644
--- a/sys/fs/nfsclient/nfs_clport.c
+++ b/sys/fs/nfsclient/nfs_clport.c
@@ -1254,7 +1254,7 @@ nfssvc_nfscl(struct thread *td, struct nfssvc_args *uap)
struct mount *mp;
struct nfsmount *nmp;
- NFSD_CURVNET_SET(NFSD_TD_TO_VNET(td));
+ CURVNET_SET(TD_TO_VNET(td));
if (uap->flag & NFSSVC_CBADDSOCK) {
error = copyin(uap->argp, (caddr_t)&nfscbdarg, sizeof(nfscbdarg));
if (error)
@@ -1374,7 +1374,7 @@ nfssvc_nfscl(struct thread *td, struct nfssvc_args *uap)
error = EINVAL;
}
out:
- NFSD_CURVNET_RESTORE();
+ CURVNET_RESTORE();
return (error);
}
diff --git a/sys/fs/nfsserver/nfs_fha_new.c b/sys/fs/nfsserver/nfs_fha_new.c
index e3f70490b818..dc22cfc418e5 100644
--- a/sys/fs/nfsserver/nfs_fha_new.c
+++ b/sys/fs/nfsserver/nfs_fha_new.c
@@ -53,42 +53,42 @@ static int fhenew_stats_sysctl(SYSCTL_HANDLER_ARGS);
static void fha_extract_info(struct svc_req *req,
struct fha_info *i);
-NFSD_VNET_DEFINE_STATIC(struct fha_params *, fhanew_softc);
-NFSD_VNET_DEFINE_STATIC(struct fha_ctls, nfsfha_ctls);
+VNET_DEFINE_STATIC(struct fha_params *, fhanew_softc);
+VNET_DEFINE_STATIC(struct fha_ctls, nfsfha_ctls);
SYSCTL_DECL(_vfs_nfsd);
SYSCTL_NODE(_vfs_nfsd, OID_AUTO, fha, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
"NFS File Handle Affinity (FHA)");
SYSCTL_UINT(_vfs_nfsd_fha,
- OID_AUTO, enable, CTLFLAG_NFSD_VNET | CTLFLAG_RWTUN,
- &NFSD_VNET_NAME(nfsfha_ctls).enable, 0,
+ OID_AUTO, enable, CTLFLAG_VNET | CTLFLAG_RWTUN,
+ &VNET_NAME(nfsfha_ctls).enable, 0,
"Enable NFS File Handle Affinity (FHA)");
SYSCTL_UINT(_vfs_nfsd_fha,
- OID_AUTO, read, CTLFLAG_NFSD_VNET | CTLFLAG_RWTUN,
- &NFSD_VNET_NAME(nfsfha_ctls).read, 0,
+ OID_AUTO, read, CTLFLAG_VNET | CTLFLAG_RWTUN,
+ &VNET_NAME(nfsfha_ctls).read, 0,
"Enable NFS FHA read locality");
SYSCTL_UINT(_vfs_nfsd_fha,
- OID_AUTO, write, CTLFLAG_NFSD_VNET | CTLFLAG_RWTUN,
- &NFSD_VNET_NAME(nfsfha_ctls).write, 0,
+ OID_AUTO, write, CTLFLAG_VNET | CTLFLAG_RWTUN,
+ &VNET_NAME(nfsfha_ctls).write, 0,
"Enable NFS FHA write locality");
SYSCTL_UINT(_vfs_nfsd_fha,
- OID_AUTO, bin_shift, CTLFLAG_NFSD_VNET | CTLFLAG_RWTUN,
- &NFSD_VNET_NAME(nfsfha_ctls).bin_shift, 0,
+ OID_AUTO, bin_shift, CTLFLAG_VNET | CTLFLAG_RWTUN,
+ &VNET_NAME(nfsfha_ctls).bin_shift, 0,
"Maximum locality distance 2^(bin_shift) bytes");
SYSCTL_UINT(_vfs_nfsd_fha,
- OID_AUTO, max_nfsds_per_fh, CTLFLAG_NFSD_VNET | CTLFLAG_RWTUN,
- &NFSD_VNET_NAME(nfsfha_ctls).max_nfsds_per_fh, 0,
+ OID_AUTO, max_nfsds_per_fh, CTLFLAG_VNET | CTLFLAG_RWTUN,
+ &VNET_NAME(nfsfha_ctls).max_nfsds_per_fh, 0,
"Maximum nfsd threads that "
"should be working on requests for the same file handle");
SYSCTL_UINT(_vfs_nfsd_fha,
- OID_AUTO, max_reqs_per_nfsd, CTLFLAG_NFSD_VNET | CTLFLAG_RWTUN,
- &NFSD_VNET_NAME(nfsfha_ctls).max_reqs_per_nfsd, 0, "Maximum requests that "
+ OID_AUTO, max_reqs_per_nfsd, CTLFLAG_VNET | CTLFLAG_RWTUN,
+ &VNET_NAME(nfsfha_ctls).max_reqs_per_nfsd, 0, "Maximum requests that "
"single nfsd thread should be working on at any time");
SYSCTL_PROC(_vfs_nfsd_fha, OID_AUTO, fhe_stats,
@@ -106,9 +106,9 @@ fhanew_init(void *foo)
struct fha_params *softc;
int i;
- NFSD_VNET(fhanew_softc) = malloc(sizeof(struct fha_params), M_TEMP,
+ VNET(fhanew_softc) = malloc(sizeof(struct fha_params), M_TEMP,
M_WAITOK | M_ZERO);
- softc = NFSD_VNET(fhanew_softc);
+ softc = VNET(fhanew_softc);
snprintf(softc->server_name, sizeof(softc->server_name),
FHANEW_SERVER_NAME);
@@ -119,12 +119,12 @@ fhanew_init(void *foo)
/*
* Set the default tuning parameters.
*/
- NFSD_VNET(nfsfha_ctls).enable = FHA_DEF_ENABLE;
- NFSD_VNET(nfsfha_ctls).read = FHA_DEF_READ;
- NFSD_VNET(nfsfha_ctls).write = FHA_DEF_WRITE;
- NFSD_VNET(nfsfha_ctls).bin_shift = FHA_DEF_BIN_SHIFT;
- NFSD_VNET(nfsfha_ctls).max_nfsds_per_fh = FHA_DEF_MAX_NFSDS_PER_FH;
- NFSD_VNET(nfsfha_ctls).max_reqs_per_nfsd = FHA_DEF_MAX_REQS_PER_NFSD;
+ VNET(nfsfha_ctls).enable = FHA_DEF_ENABLE;
+ VNET(nfsfha_ctls).read = FHA_DEF_READ;
+ VNET(nfsfha_ctls).write = FHA_DEF_WRITE;
+ VNET(nfsfha_ctls).bin_shift = FHA_DEF_BIN_SHIFT;
+ VNET(nfsfha_ctls).max_nfsds_per_fh = FHA_DEF_MAX_NFSDS_PER_FH;
+ VNET(nfsfha_ctls).max_reqs_per_nfsd = FHA_DEF_MAX_REQS_PER_NFSD;
}
@@ -134,7 +134,7 @@ fhanew_uninit(void *foo)
struct fha_params *softc;
int i;
- softc = NFSD_VNET(fhanew_softc);
+ softc = VNET(fhanew_softc);
for (i = 0; i < FHA_HASH_SIZE; i++)
mtx_destroy(&softc->fha_hash[i].mtx);
@@ -474,8 +474,8 @@ fha_hash_entry_choose_thread(struct fha_params *softc,
}
/* Check whether we should consider locality. */
- if ((i->read && !NFSD_VNET(nfsfha_ctls).read) ||
- (i->write && !NFSD_VNET(nfsfha_ctls).write))
+ if ((i->read && !VNET(nfsfha_ctls).read) ||
+ (i->write && !VNET(nfsfha_ctls).write))
goto noloc;
/*
@@ -486,11 +486,11 @@ fha_hash_entry_choose_thread(struct fha_params *softc,
offset2 = thread->st_p3;
if (((offset1 >= offset2)
- && ((offset1 - offset2) < (1 << NFSD_VNET(nfsfha_ctls).bin_shift)))
+ && ((offset1 - offset2) < (1 << VNET(nfsfha_ctls).bin_shift)))
|| ((offset2 > offset1)
- && ((offset2 - offset1) < (1 << NFSD_VNET(nfsfha_ctls).bin_shift)))) {
- if ((NFSD_VNET(nfsfha_ctls).max_reqs_per_nfsd == 0) ||
- (req_count < NFSD_VNET(nfsfha_ctls).max_reqs_per_nfsd)) {
+ && ((offset2 - offset1) < (1 << VNET(nfsfha_ctls).bin_shift)))) {
+ if ((VNET(nfsfha_ctls).max_reqs_per_nfsd == 0) ||
+ (req_count < VNET(nfsfha_ctls).max_reqs_per_nfsd)) {
#if 0
ITRACE_CURPROC(ITRACE_NFS, ITRACE_INFO,
"fha: %p(%d)r", thread, req_count);
@@ -520,8 +520,8 @@ noloc:
* We didn't find a good match yet. See if we can add
* a new thread to this file handle entry's thread list.
*/
- if ((NFSD_VNET(nfsfha_ctls).max_nfsds_per_fh == 0) ||
- (fhe->num_threads < NFSD_VNET(nfsfha_ctls).max_nfsds_per_fh)) {
+ if ((VNET(nfsfha_ctls).max_nfsds_per_fh == 0) ||
+ (fhe->num_threads < VNET(nfsfha_ctls).max_nfsds_per_fh)) {
thread = this_thread;
#if 0
ITRACE_CURPROC(ITRACE_NFS, ITRACE_INFO,
@@ -551,10 +551,10 @@ fhanew_assign(SVCTHREAD *this_thread, struct svc_req *req)
struct fha_info i;
struct fha_hash_entry *fhe;
- NFSD_CURVNET_SET(NFSD_TD_TO_VNET(curthread));
- softc = NFSD_VNET(fhanew_softc);
+ CURVNET_SET(TD_TO_VNET(curthread));
+ softc = VNET(fhanew_softc);
/* Check to see whether we're enabled. */
- if (NFSD_VNET(nfsfha_ctls).enable == 0)
+ if (VNET(nfsfha_ctls).enable == 0)
goto thist;
/*
@@ -594,11 +594,11 @@ fhanew_assign(SVCTHREAD *this_thread, struct svc_req *req)
mtx_lock(&thread->st_lock);
mtx_unlock(fhe->mtx);
- NFSD_CURVNET_RESTORE();
+ CURVNET_RESTORE();
return (thread);
thist:
req->rq_p1 = NULL;
- NFSD_CURVNET_RESTORE();
+ CURVNET_RESTORE();
mtx_lock(&this_thread->st_lock);
return (this_thread);
}
@@ -613,13 +613,13 @@ fhanew_nd_complete(SVCTHREAD *thread, struct svc_req *req)
struct fha_hash_entry *fhe = req->rq_p1;
struct mtx *mtx;
- NFSD_CURVNET_SET(NFSD_TD_TO_VNET(curthread));
+ CURVNET_SET(TD_TO_VNET(curthread));
/*
* This may be called for reqs that didn't go through
* fha_assign (e.g. extra NULL ops used for RPCSEC_GSS.
*/
if (!fhe) {
- NFSD_CURVNET_RESTORE();
+ CURVNET_RESTORE();
return;
}
@@ -635,7 +635,7 @@ fhanew_nd_complete(SVCTHREAD *thread, struct svc_req *req)
fha_hash_entry_remove(fhe);
}
mtx_unlock(mtx);
- NFSD_CURVNET_RESTORE();
+ CURVNET_RESTORE();
}
static int
@@ -650,8 +650,8 @@ fhenew_stats_sysctl(SYSCTL_HANDLER_ARGS)
sbuf_new(&sb, NULL, 65536, SBUF_FIXEDLEN);
- NFSD_CURVNET_SET(NFSD_TD_TO_VNET(curthread));
- softc = NFSD_VNET(fhanew_softc);
+ CURVNET_SET(TD_TO_VNET(curthread));
+ softc = VNET(fhanew_softc);
for (i = 0; i < FHA_HASH_SIZE; i++)
if (!LIST_EMPTY(&softc->fha_hash[i].list))
break;
@@ -694,7 +694,7 @@ fhenew_stats_sysctl(SYSCTL_HANDLER_ARGS)
}
out:
- NFSD_CURVNET_RESTORE();
+ CURVNET_RESTORE();
sbuf_trim(&sb);
sbuf_finish(&sb);
error = sysctl_handle_string(oidp, sbuf_data(&sb), sbuf_len(&sb), req);
diff --git a/sys/fs/nfsserver/nfs_nfsdcache.c b/sys/fs/nfsserver/nfs_nfsdcache.c
index de72187bbb91..9f2732fd005b 100644
--- a/sys/fs/nfsserver/nfs_nfsdcache.c
+++ b/sys/fs/nfsserver/nfs_nfsdcache.c
@@ -160,13 +160,13 @@
extern struct mtx nfsrc_udpmtx;
-NFSD_VNET_DECLARE(struct nfsrvhashhead *, nfsrvudphashtbl);
-NFSD_VNET_DECLARE(struct nfsrchash_bucket *, nfsrchash_table);
-NFSD_VNET_DECLARE(struct nfsrchash_bucket *, nfsrcahash_table);
-NFSD_VNET_DECLARE(struct nfsstatsv1 *, nfsstatsv1_p);
+VNET_DECLARE(struct nfsrvhashhead *, nfsrvudphashtbl);
+VNET_DECLARE(struct nfsrchash_bucket *, nfsrchash_table);
+VNET_DECLARE(struct nfsrchash_bucket *, nfsrcahash_table);
+VNET_DECLARE(struct nfsstatsv1 *, nfsstatsv1_p);
-NFSD_VNET_DEFINE(int, nfsrc_floodlevel) = NFSRVCACHE_FLOODLEVEL;
-NFSD_VNET_DEFINE(int, nfsrc_tcpsavedreplies) = 0;
+VNET_DEFINE(int, nfsrc_floodlevel) = NFSRVCACHE_FLOODLEVEL;
+VNET_DEFINE(int, nfsrc_tcpsavedreplies) = 0;
SYSCTL_DECL(_vfs_nfsd);
@@ -182,8 +182,8 @@ sysctl_tcphighwater(SYSCTL_HANDLER_ARGS)
return (error);
if (newhighwater < 0)
return (EINVAL);
- if (newhighwater >= NFSD_VNET(nfsrc_floodlevel))
- NFSD_VNET(nfsrc_floodlevel) = newhighwater + newhighwater / 5;
+ if (newhighwater >= VNET(nfsrc_floodlevel))
+ VNET(nfsrc_floodlevel) = newhighwater + newhighwater / 5;
nfsrc_tcphighwater = newhighwater;
return (0);
}
@@ -204,8 +204,8 @@ SYSCTL_UINT(_vfs_nfsd, OID_AUTO, cachetcp, CTLFLAG_RW,
&nfsrc_tcpnonidempotent, 0,
"Enable the DRC for NFS over TCP");
-NFSD_VNET_DEFINE_STATIC(int, nfsrc_udpcachesize) = 0;
-NFSD_VNET_DEFINE_STATIC(TAILQ_HEAD(, nfsrvcache), nfsrvudplru);
+VNET_DEFINE_STATIC(int, nfsrc_udpcachesize) = 0;
+VNET_DEFINE_STATIC(TAILQ_HEAD(, nfsrvcache), nfsrvudplru);
/*
* and the reverse mapping from generic to Version 2 procedure numbers
@@ -237,10 +237,10 @@ static int newnfsv2_procid[NFS_V3NPROCS] = {
#define nfsrc_hash(xid) (((xid) + ((xid) >> 24)) % NFSRVCACHE_HASHSIZE)
#define NFSRCUDPHASH(xid) \
- (&NFSD_VNET(nfsrvudphashtbl)[nfsrc_hash(xid)])
+ (&VNET(nfsrvudphashtbl)[nfsrc_hash(xid)])
#define NFSRCHASH(xid) \
- (&NFSD_VNET(nfsrchash_table)[nfsrc_hash(xid)].tbl)
-#define NFSRCAHASH(xid) (&NFSD_VNET(nfsrcahash_table)[nfsrc_hash(xid)])
+ (&VNET(nfsrchash_table)[nfsrc_hash(xid)].tbl)
+#define NFSRCAHASH(xid) (&VNET(nfsrcahash_table)[nfsrc_hash(xid)])
#define TRUE 1
#define FALSE 0
#define NFSRVCACHE_CHECKLEN 100
@@ -296,7 +296,7 @@ nfsrc_cachemutex(struct nfsrvcache *rp)
if ((rp->rc_flag & RC_UDP) != 0)
return (&nfsrc_udpmtx);
- return (&NFSD_VNET(nfsrchash_table)[nfsrc_hash(rp->rc_xid)].mtx);
+ return (&VNET(nfsrchash_table)[nfsrc_hash(rp->rc_xid)].mtx);
}
/*
@@ -307,26 +307,26 @@ nfsrvd_initcache(void)
{
int i;
- NFSD_VNET(nfsrvudphashtbl) = malloc(sizeof(struct nfsrvhashhead) *
+ VNET(nfsrvudphashtbl) = malloc(sizeof(struct nfsrvhashhead) *
NFSRVCACHE_HASHSIZE, M_NFSRVCACHE, M_WAITOK | M_ZERO);
- NFSD_VNET(nfsrchash_table) = malloc(sizeof(struct nfsrchash_bucket) *
+ VNET(nfsrchash_table) = malloc(sizeof(struct nfsrchash_bucket) *
NFSRVCACHE_HASHSIZE, M_NFSRVCACHE, M_WAITOK | M_ZERO);
- NFSD_VNET(nfsrcahash_table) = malloc(sizeof(struct nfsrchash_bucket) *
+ VNET(nfsrcahash_table) = malloc(sizeof(struct nfsrchash_bucket) *
NFSRVCACHE_HASHSIZE, M_NFSRVCACHE, M_WAITOK | M_ZERO);
for (i = 0; i < NFSRVCACHE_HASHSIZE; i++) {
- mtx_init(&NFSD_VNET(nfsrchash_table)[i].mtx, "nfsrtc", NULL,
+ mtx_init(&VNET(nfsrchash_table)[i].mtx, "nfsrtc", NULL,
MTX_DEF);
- mtx_init(&NFSD_VNET(nfsrcahash_table)[i].mtx, "nfsrtca", NULL,
+ mtx_init(&VNET(nfsrcahash_table)[i].mtx, "nfsrtca", NULL,
MTX_DEF);
}
for (i = 0; i < NFSRVCACHE_HASHSIZE; i++) {
- LIST_INIT(&NFSD_VNET(nfsrvudphashtbl)[i]);
- LIST_INIT(&NFSD_VNET(nfsrchash_table)[i].tbl);
- LIST_INIT(&NFSD_VNET(nfsrcahash_table)[i].tbl);
+ LIST_INIT(&VNET(nfsrvudphashtbl)[i]);
+ LIST_INIT(&VNET(nfsrchash_table)[i].tbl);
+ LIST_INIT(&VNET(nfsrcahash_table)[i].tbl);
}
- TAILQ_INIT(&NFSD_VNET(nfsrvudplru));
- NFSD_VNET(nfsrc_tcpsavedreplies) = 0;
- NFSD_VNET(nfsrc_udpcachesize) = 0;
+ TAILQ_INIT(&VNET(nfsrvudplru));
+ VNET(nfsrc_tcpsavedreplies) = 0;
+ VNET(nfsrc_udpcachesize) = 0;
}
/*
@@ -399,17 +399,17 @@ loop:
if (rp->rc_flag == 0)
panic("nfs udp cache0");
rp->rc_flag |= RC_LOCKED;
- TAILQ_REMOVE(&NFSD_VNET(nfsrvudplru), rp, rc_lru);
- TAILQ_INSERT_TAIL(&NFSD_VNET(nfsrvudplru), rp, rc_lru);
+ TAILQ_REMOVE(&VNET(nfsrvudplru), rp, rc_lru);
+ TAILQ_INSERT_TAIL(&VNET(nfsrvudplru), rp, rc_lru);
if (rp->rc_flag & RC_INPROG) {
- NFSD_VNET(nfsstatsv1_p)->srvcache_inproghits++;
+ VNET(nfsstatsv1_p)->srvcache_inproghits++;
mtx_unlock(mutex);
ret = RC_DROPIT;
} else if (rp->rc_flag & RC_REPSTATUS) {
/*
* V2 only.
*/
- NFSD_VNET(nfsstatsv1_p)->srvcache_nonidemdonehits++;
+ VNET(nfsstatsv1_p)->srvcache_nonidemdonehits++;
mtx_unlock(mutex);
nfsrvd_rephead(nd);
*(nd->nd_errp) = rp->rc_status;
@@ -417,7 +417,7 @@ loop:
rp->rc_timestamp = NFSD_MONOSEC +
NFSRVCACHE_UDPTIMEOUT;
} else if (rp->rc_flag & RC_REPMBUF) {
- NFSD_VNET(nfsstatsv1_p)->srvcache_nonidemdonehits++;
+ VNET(nfsstatsv1_p)->srvcache_nonidemdonehits++;
mtx_unlock(mutex);
nd->nd_mreq = m_copym(rp->rc_reply, 0,
M_COPYALL, M_WAITOK);
@@ -432,9 +432,9 @@ loop:
goto out;
}
}
- NFSD_VNET(nfsstatsv1_p)->srvcache_misses++;
- atomic_add_int(&NFSD_VNET(nfsstatsv1_p)->srvcache_size, 1);
- NFSD_VNET(nfsrc_udpcachesize)++;
+ VNET(nfsstatsv1_p)->srvcache_misses++;
+ atomic_add_int(&VNET(nfsstatsv1_p)->srvcache_size, 1);
+ VNET(nfsrc_udpcachesize)++;
newrp->rc_flag |= RC_INPROG;
saddr = NFSSOCKADDR(nd->nd_nam, struct sockaddr_in *);
@@ -447,7 +447,7 @@ loop:
newrp->rc_flag |= RC_INETIPV6;
}
LIST_INSERT_HEAD(hp, newrp, rc_hash);
- TAILQ_INSERT_TAIL(&NFSD_VNET(nfsrvudplru), newrp, rc_lru);
+ TAILQ_INSERT_TAIL(&VNET(nfsrvudplru), newrp, rc_lru);
mtx_unlock(mutex);
nd->nd_rp = newrp;
ret = RC_DOIT;
@@ -479,15 +479,15 @@ nfsrvd_updatecache(struct nfsrv_descript *nd)
panic("nfsrvd_updatecache not inprog");
rp->rc_flag &= ~RC_INPROG;
if (rp->rc_flag & RC_UDP) {
- TAILQ_REMOVE(&NFSD_VNET(nfsrvudplru), rp, rc_lru);
- TAILQ_INSERT_TAIL(&NFSD_VNET(nfsrvudplru), rp, rc_lru);
+ TAILQ_REMOVE(&VNET(nfsrvudplru), rp, rc_lru);
+ TAILQ_INSERT_TAIL(&VNET(nfsrvudplru), rp, rc_lru);
}
/*
* Reply from cache is a special case returned by nfsrv_checkseqid().
*/
if (nd->nd_repstat == NFSERR_REPLYFROMCACHE) {
- NFSD_VNET(nfsstatsv1_p)->srvcache_nonidemdonehits++;
+ VNET(nfsstatsv1_p)->srvcache_nonidemdonehits++;
mtx_unlock(mutex);
nd->nd_repstat = 0;
if (nd->nd_mreq)
@@ -510,7 +510,7 @@ nfsrvd_updatecache(struct nfsrv_descript *nd)
(rp->rc_refcnt > 0 ||
((nd->nd_flag & ND_SAVEREPLY) && (rp->rc_flag & RC_UDP)) ||
((nd->nd_flag & ND_SAVEREPLY) && !(rp->rc_flag & RC_UDP) &&
- NFSD_VNET(nfsrc_tcpsavedreplies) <= NFSD_VNET(nfsrc_floodlevel) &&
+ VNET(nfsrc_tcpsavedreplies) <= VNET(nfsrc_floodlevel) &&
nfsrc_tcpnonidempotent))) {
if (rp->rc_refcnt > 0) {
if (!(rp->rc_flag & RC_NFSV4))
@@ -524,12 +524,12 @@ nfsrvd_updatecache(struct nfsrv_descript *nd)
mtx_unlock(mutex);
} else {
if (!(rp->rc_flag & RC_UDP)) {
- atomic_add_int(&NFSD_VNET(nfsrc_tcpsavedreplies),
+ atomic_add_int(&VNET(nfsrc_tcpsavedreplies),
1);
- if (NFSD_VNET(nfsrc_tcpsavedreplies) >
- NFSD_VNET(nfsstatsv1_p)->srvcache_tcppeak)
- NFSD_VNET(nfsstatsv1_p)->srvcache_tcppeak =
- NFSD_VNET(nfsrc_tcpsavedreplies);
+ if (VNET(nfsrc_tcpsavedreplies) >
+ VNET(nfsstatsv1_p)->srvcache_tcppeak)
+ VNET(nfsstatsv1_p)->srvcache_tcppeak =
+ VNET(nfsrc_tcpsavedreplies);
}
mtx_unlock(mutex);
m = m_copym(nd->nd_mreq, 0, M_COPYALL, M_WAITOK);
@@ -686,7 +686,7 @@ tryagain:
panic("nfs tcp cache0");
rp->rc_flag |= RC_LOCKED;
if (rp->rc_flag & RC_INPROG) {
- NFSD_VNET(nfsstatsv1_p)->srvcache_inproghits++;
+ VNET(nfsstatsv1_p)->srvcache_inproghits++;
mtx_unlock(mutex);
if (newrp->rc_sockref == rp->rc_sockref)
nfsrc_marksametcpconn(rp->rc_sockref);
@@ -695,7 +695,7 @@ tryagain:
/*
* V2 only.
*/
- NFSD_VNET(nfsstatsv1_p)->srvcache_nonidemdonehits++;
+ VNET(nfsstatsv1_p)->srvcache_nonidemdonehits++;
mtx_unlock(mutex);
if (newrp->rc_sockref == rp->rc_sockref)
nfsrc_marksametcpconn(rp->rc_sockref);
@@ -704,7 +704,7 @@ tryagain:
*(nd->nd_errp) = rp->rc_status;
rp->rc_timestamp = NFSD_MONOSEC + nfsrc_tcptimeout;
} else if (rp->rc_flag & RC_REPMBUF) {
- NFSD_VNET(nfsstatsv1_p)->srvcache_nonidemdonehits++;
+ VNET(nfsstatsv1_p)->srvcache_nonidemdonehits++;
mtx_unlock(mutex);
if (newrp->rc_sockref == rp->rc_sockref)
nfsrc_marksametcpconn(rp->rc_sockref);
@@ -719,8 +719,8 @@ tryagain:
free(newrp, M_NFSRVCACHE);
goto out;
}
- NFSD_VNET(nfsstatsv1_p)->srvcache_misses++;
- atomic_add_int(&NFSD_VNET(nfsstatsv1_p)->srvcache_size, 1);
+ VNET(nfsstatsv1_p)->srvcache_misses++;
+ atomic_add_int(&VNET(nfsstatsv1_p)->srvcache_size, 1);
/*
* For TCP, multiple entries for a key are allowed, so don't
@@ -793,8 +793,8 @@ nfsrc_freecache(struct nfsrvcache *rp)
LIST_REMOVE(rp, rc_hash);
if (rp->rc_flag & RC_UDP) {
- TAILQ_REMOVE(&NFSD_VNET(nfsrvudplru), rp, rc_lru);
- NFSD_VNET(nfsrc_udpcachesize)--;
+ TAILQ_REMOVE(&VNET(nfsrvudplru), rp, rc_lru);
+ VNET(nfsrc_udpcachesize)--;
} else if (rp->rc_acked != RC_NO_SEQ) {
hbp = NFSRCAHASH(rp->rc_sockref);
mtx_lock(&hbp->mtx);
@@ -806,10 +806,10 @@ nfsrc_freecache(struct nfsrvcache *rp)
if (rp->rc_flag & RC_REPMBUF) {
m_freem(rp->rc_reply);
if (!(rp->rc_flag & RC_UDP))
- atomic_add_int(&NFSD_VNET(nfsrc_tcpsavedreplies), -1);
+ atomic_add_int(&VNET(nfsrc_tcpsavedreplies), -1);
}
free(rp, M_NFSRVCACHE);
- atomic_add_int(&NFSD_VNET(nfsstatsv1_p)->srvcache_size, -1);
+ atomic_add_int(&VNET(nfsstatsv1_p)->srvcache_size, -1);
}
/*
@@ -822,18 +822,18 @@ nfsrvd_cleancache(void)
int i;
for (i = 0; i < NFSRVCACHE_HASHSIZE; i++) {
- LIST_FOREACH_SAFE(rp, &NFSD_VNET(nfsrchash_table)[i].tbl,
+ LIST_FOREACH_SAFE(rp, &VNET(nfsrchash_table)[i].tbl,
rc_hash, nextrp)
nfsrc_freecache(rp);
}
for (i = 0; i < NFSRVCACHE_HASHSIZE; i++) {
- LIST_FOREACH_SAFE(rp, &NFSD_VNET(nfsrvudphashtbl)[i], rc_hash,
+ LIST_FOREACH_SAFE(rp, &VNET(nfsrvudphashtbl)[i], rc_hash,
nextrp) {
nfsrc_freecache(rp);
}
}
- NFSD_VNET(nfsstatsv1_p)->srvcache_size = 0;
- NFSD_VNET(nfsrc_tcpsavedreplies) = 0;
+ VNET(nfsstatsv1_p)->srvcache_size = 0;
+ VNET(nfsrc_tcpsavedreplies) = 0;
}
#define HISTSIZE 16
@@ -870,27 +870,27 @@ nfsrc_trimcache(u_int64_t sockref, uint32_t snd_una, int final)
if (atomic_cmpset_acq_int(&onethread, 0, 1) == 0)
return;
if (NFSD_MONOSEC != udp_lasttrim ||
- NFSD_VNET(nfsrc_udpcachesize) >= (nfsrc_udphighwater +
+ VNET(nfsrc_udpcachesize) >= (nfsrc_udphighwater +
nfsrc_udphighwater / 2)) {
mtx_lock(&nfsrc_udpmtx);
udp_lasttrim = NFSD_MONOSEC;
- TAILQ_FOREACH_SAFE(rp, &NFSD_VNET(nfsrvudplru), rc_lru,
+ TAILQ_FOREACH_SAFE(rp, &VNET(nfsrvudplru), rc_lru,
nextrp) {
if (!(rp->rc_flag & (RC_INPROG|RC_LOCKED|RC_WANTED))
&& rp->rc_refcnt == 0
&& ((rp->rc_flag & RC_REFCNT) ||
udp_lasttrim > rp->rc_timestamp ||
- NFSD_VNET(nfsrc_udpcachesize) >
+ VNET(nfsrc_udpcachesize) >
nfsrc_udphighwater))
nfsrc_freecache(rp);
}
mtx_unlock(&nfsrc_udpmtx);
}
if (NFSD_MONOSEC != tcp_lasttrim ||
- NFSD_VNET(nfsrc_tcpsavedreplies) >= nfsrc_tcphighwater) {
+ VNET(nfsrc_tcpsavedreplies) >= nfsrc_tcphighwater) {
force = nfsrc_tcphighwater / 4;
if (force > 0 &&
- NFSD_VNET(nfsrc_tcpsavedreplies) + force >=
+ VNET(nfsrc_tcpsavedreplies) + force >=
nfsrc_tcphighwater) {
for (i = 0; i < HISTSIZE; i++)
time_histo[i] = 0;
@@ -910,9 +910,9 @@ nfsrc_trimcache(u_int64_t sockref, uint32_t snd_una, int final)
tto = nfsrc_tcptimeout;
tcp_lasttrim = NFSD_MONOSEC;
for (; i <= lastslot; i++) {
- mtx_lock(&NFSD_VNET(nfsrchash_table)[i].mtx);
+ mtx_lock(&VNET(nfsrchash_table)[i].mtx);
LIST_FOREACH_SAFE(rp,
- &NFSD_VNET(nfsrchash_table)[i].tbl, rc_hash,
+ &VNET(nfsrchash_table)[i].tbl, rc_hash,
nextrp) {
if (!(rp->rc_flag &
(RC_INPROG|RC_LOCKED|RC_WANTED))
@@ -942,7 +942,7 @@ nfsrc_trimcache(u_int64_t sockref, uint32_t snd_una, int final)
time_histo[j]++;
}
}
- mtx_unlock(&NFSD_VNET(nfsrchash_table)[i].mtx);
+ mtx_unlock(&VNET(nfsrchash_table)[i].mtx);
}
if (force) {
/*
@@ -961,9 +961,9 @@ nfsrc_trimcache(u_int64_t sockref, uint32_t snd_una, int final)
k = 1;
thisstamp = tcp_lasttrim + k;
for (i = 0; i < NFSRVCACHE_HASHSIZE; i++) {
- mtx_lock(&NFSD_VNET(nfsrchash_table)[i].mtx);
+ mtx_lock(&VNET(nfsrchash_table)[i].mtx);
LIST_FOREACH_SAFE(rp,
- &NFSD_VNET(nfsrchash_table)[i].tbl,
+ &VNET(nfsrchash_table)[i].tbl,
rc_hash, nextrp) {
if (!(rp->rc_flag &
(RC_INPROG|RC_LOCKED|RC_WANTED))
@@ -973,7 +973,7 @@ nfsrc_trimcache(u_int64_t sockref, uint32_t snd_una, int final)
rp->rc_acked == RC_ACK))
nfsrc_freecache(rp);
}
- mtx_unlock(&NFSD_VNET(nfsrchash_table)[i].mtx);
+ mtx_unlock(&VNET(nfsrchash_table)[i].mtx);
}
}
}
diff --git a/sys/fs/nfsserver/nfs_nfsdkrpc.c b/sys/fs/nfsserver/nfs_nfsdkrpc.c
index ce1189d40425..8c557143efbd 100644
--- a/sys/fs/nfsserver/nfs_nfsdkrpc.c
+++ b/sys/fs/nfsserver/nfs_nfsdkrpc.c
@@ -82,19 +82,19 @@ int newnfs_nfsv3_procid[NFS_V3NPROCS] = {
SYSCTL_DECL(_vfs_nfsd);
-NFSD_VNET_DEFINE_STATIC(int, nfs_privport) = 1;
-SYSCTL_INT(_vfs_nfsd, OID_AUTO, nfs_privport, CTLFLAG_NFSD_VNET | CTLFLAG_RWTUN,
- &NFSD_VNET_NAME(nfs_privport), 0,
+VNET_DEFINE_STATIC(int, nfs_privport) = 1;
+SYSCTL_INT(_vfs_nfsd, OID_AUTO, nfs_privport, CTLFLAG_VNET | CTLFLAG_RWTUN,
+ &VNET_NAME(nfs_privport), 0,
"Only allow clients using a privileged port for NFSv2, 3 and 4");
-NFSD_VNET_DEFINE_STATIC(int, nfs_minvers) = NFS_VER2;
+VNET_DEFINE_STATIC(int, nfs_minvers) = NFS_VER2;
SYSCTL_INT(_vfs_nfsd, OID_AUTO, server_min_nfsvers,
- CTLFLAG_NFSD_VNET | CTLFLAG_RWTUN, &NFSD_VNET_NAME(nfs_minvers), 0,
+ CTLFLAG_VNET | CTLFLAG_RWTUN, &VNET_NAME(nfs_minvers), 0,
"The lowest version of NFS handled by the server");
-NFSD_VNET_DEFINE_STATIC(int, nfs_maxvers) = NFS_VER4;
+VNET_DEFINE_STATIC(int, nfs_maxvers) = NFS_VER4;
SYSCTL_INT(_vfs_nfsd, OID_AUTO, server_max_nfsvers,
- CTLFLAG_NFSD_VNET | CTLFLAG_RWTUN, &NFSD_VNET_NAME(nfs_maxvers), 0,
+ CTLFLAG_VNET | CTLFLAG_RWTUN, &VNET_NAME(nfs_maxvers), 0,
"The highest version of NFS handled by the server");
static int nfs_proc(struct nfsrv_descript *, u_int32_t, SVCXPRT *xprt,
@@ -108,13 +108,13 @@ extern volatile int nfsrv_devidcnt;
extern struct nfsv4_opflag nfsv4_opflag[NFSV42_NOPS];
extern int nfsd_debuglevel;
-NFSD_VNET_DECLARE(struct proc *, nfsd_master_proc);
+VNET_DECLARE(struct proc *, nfsd_master_proc);
-NFSD_VNET_DEFINE(SVCPOOL *, nfsrvd_pool);
-NFSD_VNET_DEFINE(int, nfsrv_numnfsd) = 0;
-NFSD_VNET_DEFINE(struct nfsv4lock, nfsd_suspend_lock);
+VNET_DEFINE(SVCPOOL *, nfsrvd_pool);
+VNET_DEFINE(int, nfsrv_numnfsd) = 0;
+VNET_DEFINE(struct nfsv4lock, nfsd_suspend_lock);
-NFSD_VNET_DEFINE_STATIC(bool, nfsrvd_inited) = false;
+VNET_DEFINE_STATIC(bool, nfsrvd_inited) = false;
/*
* NFS server system calls
@@ -132,7 +132,7 @@ nfssvc_program(struct svc_req *rqst, SVCXPRT *xprt)
u_int maxlen;
#endif
- NFSD_CURVNET_SET_QUIET(NFSD_TD_TO_VNET(curthread));
+ CURVNET_SET_QUIET(TD_TO_VNET(curthread));
memset(&nd, 0, sizeof(nd));
if (rqst->rq_vers == NFS_VER2) {
if (rqst->rq_proc > NFSV2PROC_STATFS ||
@@ -177,7 +177,7 @@ nfssvc_program(struct svc_req *rqst, SVCXPRT *xprt)
nd.nd_mreq = NULL;
nd.nd_cred = NULL;
- if (NFSD_VNET(nfs_privport) != 0) {
+ if (VNET(nfs_privport) != 0) {
/* Check if source port is privileged */
u_short port;
struct sockaddr *nam = nd.nd_nam;
@@ -331,9 +331,9 @@ nfssvc_program(struct svc_req *rqst, SVCXPRT *xprt)
* nfsv4root exports by nfsvno_v4rootexport().
*/
NFSLOCKV4ROOTMUTEX();
- nfsv4_lock(&NFSD_VNET(nfsd_suspend_lock), 0, NULL,
+ nfsv4_lock(&VNET(nfsd_suspend_lock), 0, NULL,
NFSV4ROOTLOCKMUTEXPTR, NULL);
- nfsv4_getref(&NFSD_VNET(nfsd_suspend_lock), NULL,
+ nfsv4_getref(&VNET(nfsd_suspend_lock), NULL,
NFSV4ROOTLOCKMUTEXPTR, NULL);
NFSUNLOCKV4ROOTMUTEX();
@@ -341,7 +341,7 @@ nfssvc_program(struct svc_req *rqst, SVCXPRT *xprt)
nd.nd_repstat = nfsvno_v4rootexport(&nd);
if (nd.nd_repstat != 0) {
NFSLOCKV4ROOTMUTEX();
- nfsv4_relref(&NFSD_VNET(nfsd_suspend_lock));
+ nfsv4_relref(&VNET(nfsd_suspend_lock));
NFSUNLOCKV4ROOTMUTEX();
svcerr_weakauth(rqst);
svc_freereq(rqst);
@@ -357,7 +357,7 @@ nfssvc_program(struct svc_req *rqst, SVCXPRT *xprt)
#endif
cacherep = nfs_proc(&nd, rqst->rq_xid, xprt, &rp);
NFSLOCKV4ROOTMUTEX();
- nfsv4_relref(&NFSD_VNET(nfsd_suspend_lock));
+ nfsv4_relref(&VNET(nfsd_suspend_lock));
NFSUNLOCKV4ROOTMUTEX();
} else {
NFSMGET(nd.nd_mreq);
@@ -398,7 +398,7 @@ nfssvc_program(struct svc_req *rqst, SVCXPRT *xprt)
out:
free(nd.nd_principal, M_TEMP);
- NFSD_CURVNET_RESTORE();
+ CURVNET_RESTORE();
ast_kclear(curthread);
NFSEXITCODE(0);
}
@@ -512,9 +512,9 @@ nfssvc_loss(SVCXPRT *xprt)
ack = 0;
SVC_ACK(xprt, &ack);
- NFSD_CURVNET_SET(NFSD_TD_TO_VNET(curthread));
+ CURVNET_SET(TD_TO_VNET(curthread));
nfsrc_trimcache(xprt->xp_sockref, ack, 1);
- NFSD_CURVNET_RESTORE();
+ CURVNET_RESTORE();
}
/*
@@ -541,21 +541,21 @@ nfsrvd_addsock(struct file *fp)
* unexpectedly.
*/
if (so->so_type == SOCK_DGRAM)
- xprt = svc_dg_create(NFSD_VNET(nfsrvd_pool), so, 0, 0);
+ xprt = svc_dg_create(VNET(nfsrvd_pool), so, 0, 0);
else
- xprt = svc_vc_create(NFSD_VNET(nfsrvd_pool), so, 0, 0);
+ xprt = svc_vc_create(VNET(nfsrvd_pool), so, 0, 0);
if (xprt) {
fp->f_ops = &badfileops;
fp->f_data = NULL;
xprt->xp_sockref = ++sockref;
- if (NFSD_VNET(nfs_minvers) == NFS_VER2)
+ if (VNET(nfs_minvers) == NFS_VER2)
svc_reg(xprt, NFS_PROG, NFS_VER2, nfssvc_program,
NULL);
- if (NFSD_VNET(nfs_minvers) <= NFS_VER3 &&
- NFSD_VNET(nfs_maxvers) >= NFS_VER3)
+ if (VNET(nfs_minvers) <= NFS_VER3 &&
+ VNET(nfs_maxvers) >= NFS_VER3)
svc_reg(xprt, NFS_PROG, NFS_VER3, nfssvc_program,
NULL);
- if (NFSD_VNET(nfs_maxvers) >= NFS_VER4)
+ if (VNET(nfs_maxvers) >= NFS_VER4)
svc_reg(xprt, NFS_PROG, NFS_VER4, nfssvc_program,
NULL);
if (so->so_type == SOCK_STREAM)
@@ -594,14 +594,14 @@ nfsrvd_nfsd(struct thread *td, struct nfsd_nfsd_args *args)
* use.
*/
NFSD_LOCK();
- if (NFSD_VNET(nfsrv_numnfsd) == 0) {
+ if (VNET(nfsrv_numnfsd) == 0) {
nfsdev_time = time_second;
p = td->td_proc;
PROC_LOCK(p);
p->p_flag2 |= P2_AST_SU;
PROC_UNLOCK(p);
newnfs_numnfsd++; /* Total num for all vnets. */
- NFSD_VNET(nfsrv_numnfsd)++; /* Num for this vnet. */
+ VNET(nfsrv_numnfsd)++; /* Num for this vnet. */
NFSD_UNLOCK();
error = nfsrv_createdevids(args, td);
@@ -624,9 +624,9 @@ nfsrvd_nfsd(struct thread *td, struct nfsd_nfsd_args *args)
td->td_ucred->cr_prison->pr_id);
}
- NFSD_VNET(nfsrvd_pool)->sp_minthreads =
+ VNET(nfsrvd_pool)->sp_minthreads =
args->minthreads;
- NFSD_VNET(nfsrvd_pool)->sp_maxthreads =
+ VNET(nfsrvd_pool)->sp_maxthreads =
args->maxthreads;
/*
@@ -638,7 +638,7 @@ nfsrvd_nfsd(struct thread *td, struct nfsd_nfsd_args *args)
nfsv4_opflag[NFSV4OP_GETATTR].modifyfs = 1;
}
- svc_run(NFSD_VNET(nfsrvd_pool));
+ svc_run(VNET(nfsrvd_pool));
/* Reset Getattr to not do a vn_start_write(). */
nfsrv_writerpc[NFSPROC_GETATTR] = 0;
@@ -652,7 +652,7 @@ nfsrvd_nfsd(struct thread *td, struct nfsd_nfsd_args *args)
}
NFSD_LOCK();
newnfs_numnfsd--;
- NFSD_VNET(nfsrv_numnfsd)--;
+ VNET(nfsrv_numnfsd)--;
nfsrvd_init(1);
PROC_LOCK(p);
p->p_flag2 &= ~P2_AST_SU;
@@ -677,25 +677,25 @@ nfsrvd_init(int terminating)
NFSD_LOCK_ASSERT();
if (terminating) {
- NFSD_VNET(nfsd_master_proc) = NULL;
+ VNET(nfsd_master_proc) = NULL;
NFSD_UNLOCK();
nfsrv_freealllayoutsanddevids();
nfsrv_freeallbackchannel_xprts();
- svcpool_close(NFSD_VNET(nfsrvd_pool));
+ svcpool_close(VNET(nfsrvd_pool));
free(nfsrv_zeropnfsdat, M_TEMP);
nfsrv_zeropnfsdat = NULL;
NFSD_LOCK();
} else {
/* Initialize per-vnet globals once per vnet. */
- if (NFSD_VNET(nfsrvd_inited))
+ if (VNET(nfsrvd_inited))
return;
- NFSD_VNET(nfsrvd_inited) = true;
+ VNET(nfsrvd_inited) = true;
NFSD_UNLOCK();
- NFSD_VNET(nfsrvd_pool) = svcpool_create("nfsd",
+ VNET(nfsrvd_pool) = svcpool_create("nfsd",
SYSCTL_STATIC_CHILDREN(_vfs_nfsd));
- NFSD_VNET(nfsrvd_pool)->sp_rcache = NULL;
- NFSD_VNET(nfsrvd_pool)->sp_assign = fhanew_assign;
- NFSD_VNET(nfsrvd_pool)->sp_done = fhanew_nd_complete;
+ VNET(nfsrvd_pool)->sp_rcache = NULL;
+ VNET(nfsrvd_pool)->sp_assign = fhanew_assign;
+ VNET(nfsrvd_pool)->sp_done = fhanew_nd_complete;
NFSD_LOCK();
}
}
diff --git a/sys/fs/nfsserver/nfs_nfsdport.c b/sys/fs/nfsserver/nfs_nfsdport.c
index 13133e6fd165..e42d5ca1e0a3 100644
--- a/sys/fs/nfsserver/nfs_nfsdport.c
+++ b/sys/fs/nfsserver/nfs_nfsdport.c
@@ -71,14 +71,14 @@ extern int nfs_bufpackets;
extern u_long sb_max_adj;
extern struct nfsv4lock nfsv4rootfs_lock;
-NFSD_VNET_DECLARE(int, nfsrv_numnfsd);
-NFSD_VNET_DECLARE(struct nfsrv_stablefirst, nfsrv_stablefirst);
-NFSD_VNET_DECLARE(SVCPOOL *, nfsrvd_pool);
-NFSD_VNET_DECLARE(struct nfsclienthashhead *, nfsclienthash);
-NFSD_VNET_DECLARE(struct nfslockhashhead *, nfslockhash);
-NFSD_VNET_DECLARE(struct nfssessionhash *, nfssessionhash);
-NFSD_VNET_DECLARE(struct nfsv4lock, nfsd_suspend_lock);
-NFSD_VNET_DECLARE(struct nfsstatsv1 *, nfsstatsv1_p);
+VNET_DECLARE(int, nfsrv_numnfsd);
+VNET_DECLARE(struct nfsrv_stablefirst, nfsrv_stablefirst);
+VNET_DECLARE(SVCPOOL *, nfsrvd_pool);
+VNET_DECLARE(struct nfsclienthashhead *, nfsclienthash);
+VNET_DECLARE(struct nfslockhashhead *, nfslockhash);
+VNET_DECLARE(struct nfssessionhash *, nfssessionhash);
+VNET_DECLARE(struct nfsv4lock, nfsd_suspend_lock);
+VNET_DECLARE(struct nfsstatsv1 *, nfsstatsv1_p);
NFSDLOCKMUTEX;
NFSSTATESPINLOCK;
@@ -95,18 +95,18 @@ static struct timeval nfsd_master_start;
static uint32_t nfsv4_sysid = 0;
static fhandle_t zerofh;
-NFSD_VNET_DEFINE(struct proc *, nfsd_master_proc) = NULL;
-NFSD_VNET_DEFINE(struct nfsrvhashhead *, nfsrvudphashtbl);
-NFSD_VNET_DEFINE(struct nfsrchash_bucket *, nfsrchash_table);
-NFSD_VNET_DEFINE(struct nfsrchash_bucket *, nfsrcahash_table);
-NFSD_VNET_DEFINE(struct nfsrvfh, nfs_rootfh);
-NFSD_VNET_DEFINE(int, nfs_rootfhset) = 0;
-NFSD_VNET_DEFINE(struct callout, nfsd_callout);
-NFSD_VNET_DEFINE_STATIC(struct mount *, nfsv4root_mnt);
-NFSD_VNET_DEFINE_STATIC(struct vfsoptlist, nfsv4root_opt);
-NFSD_VNET_DEFINE_STATIC(struct vfsoptlist, nfsv4root_newopt);
-NFSD_VNET_DEFINE_STATIC(bool, nfsrv_suspend_nfsd) = false;
-NFSD_VNET_DEFINE_STATIC(bool, nfsrv_mntinited) = false;
+VNET_DEFINE(struct proc *, nfsd_master_proc) = NULL;
+VNET_DEFINE(struct nfsrvhashhead *, nfsrvudphashtbl);
+VNET_DEFINE(struct nfsrchash_bucket *, nfsrchash_table);
+VNET_DEFINE(struct nfsrchash_bucket *, nfsrcahash_table);
+VNET_DEFINE(struct nfsrvfh, nfs_rootfh);
+VNET_DEFINE(int, nfs_rootfhset) = 0;
+VNET_DEFINE(struct callout, nfsd_callout);
+VNET_DEFINE_STATIC(struct mount *, nfsv4root_mnt);
+VNET_DEFINE_STATIC(struct vfsoptlist, nfsv4root_opt);
+VNET_DEFINE_STATIC(struct vfsoptlist, nfsv4root_newopt);
+VNET_DEFINE_STATIC(bool, nfsrv_suspend_nfsd) = false;
+VNET_DEFINE_STATIC(bool, nfsrv_mntinited) = false;
static int nfssvc_srvcall(struct thread *, struct nfssvc_args *,
struct ucred *);
@@ -181,9 +181,9 @@ SYSCTL_INT(_vfs_nfsd, OID_AUTO, issue_delegations, CTLFLAG_RW,
&nfsrv_issuedelegs, 0, "Enable nfsd to issue delegations");
SYSCTL_INT(_vfs_nfsd, OID_AUTO, debuglevel, CTLFLAG_RW, &nfsd_debuglevel,
0, "Debug level for NFS server");
-NFSD_VNET_DECLARE(int, nfsd_enable_stringtouid);
+VNET_DECLARE(int, nfsd_enable_stringtouid);
SYSCTL_INT(_vfs_nfsd, OID_AUTO, enable_stringtouid,
- CTLFLAG_NFSD_VNET | CTLFLAG_RW, &NFSD_VNET_NAME(nfsd_enable_stringtouid),
+ CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(nfsd_enable_stringtouid),
0, "Enable nfsd to accept numeric owner_names");
static int nfsrv_pnfsgetdsattr = 1;
SYSCTL_INT(_vfs_nfsd, OID_AUTO, pnfsgetdsattr, CTLFLAG_RW,
@@ -1073,7 +1073,7 @@ nfsvno_read(struct vnode *vp, off_t off, int cnt, struct ucred *cred,
nh = nfsrv_sequential_heuristic(uiop, vp);
ioflag |= nh->nh_seqcount << IO_SEQSHIFT;
/* XXX KDM make this more systematic? */
- NFSD_VNET(nfsstatsv1_p)->srvbytes[NFSV4OP_READ] += uiop->uio_resid;
+ VNET(nfsstatsv1_p)->srvbytes[NFSV4OP_READ] += uiop->uio_resid;
error = VOP_READ(vp, uiop, IO_NODELOCKED | ioflag, cred);
free(iv, M_TEMP);
if (error) {
@@ -1198,7 +1198,7 @@ nfsvno_write(struct vnode *vp, off_t off, int retlen, int *stable,
nh = nfsrv_sequential_heuristic(uiop, vp);
ioflags |= nh->nh_seqcount << IO_SEQSHIFT;
/* XXX KDM make this more systematic? */
- NFSD_VNET(nfsstatsv1_p)->srvbytes[NFSV4OP_WRITE] += uiop->uio_resid;
+ VNET(nfsstatsv1_p)->srvbytes[NFSV4OP_WRITE] += uiop->uio_resid;
error = VOP_WRITE(vp, uiop, ioflags, cred);
if (error == 0)
nh->nh_nextoff = uiop->uio_offset;
@@ -3603,7 +3603,7 @@ nfsvno_checkexp(struct mount *mp, struct sockaddr *nam, struct nfsexstuff *exp,
error = VFS_CHECKEXP(mp, nam, &exp->nes_exflag, credp,
&exp->nes_numsecflavor, exp->nes_secflavors);
if (error) {
- if (NFSD_VNET(nfs_rootfhset)) {
+ if (VNET(nfs_rootfhset)) {
exp->nes_exflag = 0;
exp->nes_numsecflavor = 0;
error = 0;
@@ -3644,7 +3644,7 @@ nfsvno_fhtovp(struct mount *mp, fhandle_t *fhp, struct sockaddr *nam,
error = VFS_CHECKEXP(mp, nam, &exp->nes_exflag, credp,
&exp->nes_numsecflavor, exp->nes_secflavors);
if (error) {
- if (NFSD_VNET(nfs_rootfhset)) {
+ if (VNET(nfs_rootfhset)) {
exp->nes_exflag = 0;
exp->nes_numsecflavor = 0;
error = 0;
@@ -3821,9 +3821,9 @@ nfsrv_v4rootexport(void *argp, struct ucred *cred, struct thread *p)
struct nameidata nd;
fhandle_t fh;
- error = vfs_export(NFSD_VNET(nfsv4root_mnt), &nfsexargp->export, false);
+ error = vfs_export(VNET(nfsv4root_mnt), &nfsexargp->export, false);
if ((nfsexargp->export.ex_flags & MNT_DELEXPORT) != 0)
- NFSD_VNET(nfs_rootfhset) = 0;
+ VNET(nfs_rootfhset) = 0;
else if (error == 0) {
if (nfsexargp->fspec == NULL) {
error = EPERM;
@@ -3839,11 +3839,11 @@ nfsrv_v4rootexport(void *argp, struct ucred *cred, struct thread *p)
error = nfsvno_getfh(nd.ni_vp, &fh, p);
vrele(nd.ni_vp);
if (!error) {
- NFSD_VNET(nfs_rootfh).nfsrvfh_len = NFSX_MYFH;
+ VNET(nfs_rootfh).nfsrvfh_len = NFSX_MYFH;
NFSBCOPY((caddr_t)&fh,
- NFSD_VNET(nfs_rootfh).nfsrvfh_data,
+ VNET(nfs_rootfh).nfsrvfh_data,
sizeof (fhandle_t));
- NFSD_VNET(nfs_rootfhset) = 1;
+ VNET(nfs_rootfhset) = 1;
}
}
@@ -3881,29 +3881,29 @@ nfsd_mntinit(void)
{
NFSD_LOCK();
- if (NFSD_VNET(nfsrv_mntinited)) {
+ if (VNET(nfsrv_mntinited)) {
NFSD_UNLOCK();
return;
}
- NFSD_VNET(nfsrv_mntinited) = true;
+ VNET(nfsrv_mntinited) = true;
nfsrvd_init(0);
NFSD_UNLOCK();
- NFSD_VNET(nfsv4root_mnt) = malloc(sizeof(struct mount), M_TEMP,
+ VNET(nfsv4root_mnt) = malloc(sizeof(struct mount), M_TEMP,
M_WAITOK | M_ZERO);
- NFSD_VNET(nfsv4root_mnt)->mnt_flag = (MNT_RDONLY | MNT_EXPORTED);
- mtx_init(&NFSD_VNET(nfsv4root_mnt)->mnt_mtx, "nfs4mnt", NULL, MTX_DEF);
- lockinit(&NFSD_VNET(nfsv4root_mnt)->mnt_explock, PVFS, "explock", 0, 0);
- TAILQ_INIT(&NFSD_VNET(nfsv4root_mnt)->mnt_nvnodelist);
- TAILQ_INIT(&NFSD_VNET(nfsv4root_mnt)->mnt_lazyvnodelist);
- NFSD_VNET(nfsv4root_mnt)->mnt_export = NULL;
- TAILQ_INIT(&NFSD_VNET(nfsv4root_opt));
- TAILQ_INIT(&NFSD_VNET(nfsv4root_newopt));
- NFSD_VNET(nfsv4root_mnt)->mnt_opt = &NFSD_VNET(nfsv4root_opt);
- NFSD_VNET(nfsv4root_mnt)->mnt_optnew = &NFSD_VNET(nfsv4root_newopt);
- NFSD_VNET(nfsv4root_mnt)->mnt_nvnodelistsize = 0;
- NFSD_VNET(nfsv4root_mnt)->mnt_lazyvnodelistsize = 0;
- callout_init(&NFSD_VNET(nfsd_callout), 1);
+ VNET(nfsv4root_mnt)->mnt_flag = (MNT_RDONLY | MNT_EXPORTED);
+ mtx_init(&VNET(nfsv4root_mnt)->mnt_mtx, "nfs4mnt", NULL, MTX_DEF);
+ lockinit(&VNET(nfsv4root_mnt)->mnt_explock, PVFS, "explock", 0, 0);
+ TAILQ_INIT(&VNET(nfsv4root_mnt)->mnt_nvnodelist);
+ TAILQ_INIT(&VNET(nfsv4root_mnt)->mnt_lazyvnodelist);
+ VNET(nfsv4root_mnt)->mnt_export = NULL;
+ TAILQ_INIT(&VNET(nfsv4root_opt));
+ TAILQ_INIT(&VNET(nfsv4root_newopt));
+ VNET(nfsv4root_mnt)->mnt_opt = &VNET(nfsv4root_opt);
+ VNET(nfsv4root_mnt)->mnt_optnew = &VNET(nfsv4root_newopt);
+ VNET(nfsv4root_mnt)->mnt_nvnodelistsize = 0;
+ VNET(nfsv4root_mnt)->mnt_lazyvnodelistsize = 0;
+ callout_init(&VNET(nfsd_callout), 1);
nfsrvd_initcache();
nfsd_init();
@@ -3915,11 +3915,11 @@ nfsd_timer(void *arg)
struct vnet *vnetp;
vnetp = (struct vnet *)arg;
- NFSD_CURVNET_SET_QUIET(vnetp);
+ CURVNET_SET_QUIET(vnetp);
nfsrv_servertimer(vnetp);
- callout_reset_sbt(&NFSD_VNET(nfsd_callout), SBT_1S, SBT_1S, nfsd_timer,
+ callout_reset_sbt(&VNET(nfsd_callout), SBT_1S, SBT_1S, nfsd_timer,
arg, 0);
- NFSD_CURVNET_RESTORE();
+ CURVNET_RESTORE();
}
/*
@@ -4001,7 +4001,7 @@ nfsvno_v4rootexport(struct nfsrv_descript *nd)
int error = 0, numsecflavor, secflavors[MAXSECFLAVORS], i;
uint64_t exflags;
- error = vfs_stdcheckexp(NFSD_VNET(nfsv4root_mnt), nd->nd_nam, &exflags,
+ error = vfs_stdcheckexp(VNET(nfsv4root_mnt), nd->nd_nam, &exflags,
&credanon, &numsecflavor, secflavors);
if (error) {
error = NFSERR_PROGUNAVAIL;
@@ -4056,7 +4056,7 @@ nfssvc_nfsd(struct thread *td, struct nfssvc_args *uap)
char *buf, *cp, *cp2, *cp3;
char fname[PNFS_FILENAME_LEN + 1];
- NFSD_CURVNET_SET(NFSD_TD_TO_VNET(td));
+ CURVNET_SET(TD_TO_VNET(td));
if (uap->flag & NFSSVC_NFSDADDSOCK) {
error = copyin(uap->argp, (caddr_t)&sockarg, sizeof (sockarg));
if (error)
@@ -4164,9 +4164,9 @@ nfssvc_nfsd(struct thread *td, struct nfssvc_args *uap)
nfsdarg.mdspathlen = 0;
nfsdarg.mirrorcnt = 1;
}
- nfsd_timer(NFSD_TD_TO_VNET(td));
+ nfsd_timer(TD_TO_VNET(td));
error = nfsrvd_nfsd(td, &nfsdarg);
- callout_drain(&NFSD_VNET(nfsd_callout));
+ callout_drain(&VNET(nfsd_callout));
free(nfsdarg.addr, M_TEMP);
free(nfsdarg.dnshost, M_TEMP);
free(nfsdarg.dspath, M_TEMP);
@@ -4244,7 +4244,7 @@ nfssvc_nfsd(struct thread *td, struct nfssvc_args *uap)
}
out:
- NFSD_CURVNET_RESTORE();
+ CURVNET_RESTORE();
NFSEXITCODE(error);
return (error);
}
@@ -4349,10 +4349,10 @@ nfssvc_srvcall(struct thread *p, struct nfssvc_args *uap, struct ucred *cred)
error = fp_getfvp(p, stablefd, &fp, &vp);
if (!error && (NFSFPFLAG(fp) & (FREAD | FWRITE)) != (FREAD | FWRITE))
error = EBADF;
- if (!error && NFSD_VNET(nfsrv_numnfsd) != 0)
+ if (!error && VNET(nfsrv_numnfsd) != 0)
error = ENXIO;
if (!error) {
- NFSD_VNET(nfsrv_stablefirst).nsf_fp = fp;
+ VNET(nfsrv_stablefirst).nsf_fp = fp;
nfsrv_setupstable(p);
}
} else if (uap->flag & NFSSVC_ADMINREVOKE) {
@@ -4399,27 +4399,27 @@ nfssvc_srvcall(struct thread *p, struct nfssvc_args *uap, struct ucred *cred)
nfsd_master_pid = procp->p_pid;
bcopy(procp->p_comm, nfsd_master_comm, MAXCOMLEN + 1);
nfsd_master_start = procp->p_stats->p_start;
- NFSD_VNET(nfsd_master_proc) = procp;
+ VNET(nfsd_master_proc) = procp;
PROC_UNLOCK(procp);
} else if ((uap->flag & NFSSVC_SUSPENDNFSD) != 0) {
NFSLOCKV4ROOTMUTEX();
- if (!NFSD_VNET(nfsrv_suspend_nfsd)) {
+ if (!VNET(nfsrv_suspend_nfsd)) {
/* Lock out all nfsd threads */
do {
igotlock = nfsv4_lock(
- &NFSD_VNET(nfsd_suspend_lock), 1, NULL,
+ &VNET(nfsd_suspend_lock), 1, NULL,
NFSV4ROOTLOCKMUTEXPTR, NULL);
} while (igotlock == 0 &&
- !NFSD_VNET(nfsrv_suspend_nfsd));
- NFSD_VNET(nfsrv_suspend_nfsd) = true;
+ !VNET(nfsrv_suspend_nfsd));
+ VNET(nfsrv_suspend_nfsd) = true;
}
NFSUNLOCKV4ROOTMUTEX();
error = 0;
} else if ((uap->flag & NFSSVC_RESUMENFSD) != 0) {
NFSLOCKV4ROOTMUTEX();
- if (NFSD_VNET(nfsrv_suspend_nfsd)) {
- nfsv4_unlock(&NFSD_VNET(nfsd_suspend_lock), 0);
- NFSD_VNET(nfsrv_suspend_nfsd) = false;
+ if (VNET(nfsrv_suspend_nfsd)) {
+ nfsv4_unlock(&VNET(nfsd_suspend_lock), 0);
+ VNET(nfsrv_suspend_nfsd) = false;
}
NFSUNLOCKV4ROOTMUTEX();
error = 0;
@@ -4527,10 +4527,10 @@ nfsrv_backupstable(void)
{
struct proc *procp;
- if (NFSD_VNET(nfsd_master_proc) != NULL) {
+ if (VNET(nfsd_master_proc) != NULL) {
procp = pfind(nfsd_master_pid);
/* Try to make sure it is the correct process. */
- if (procp == NFSD_VNET(nfsd_master_proc) &&
+ if (procp == VNET(nfsd_master_proc) &&
procp->p_stats->p_start.tv_sec ==
nfsd_master_start.tv_sec &&
procp->p_stats->p_start.tv_usec ==
@@ -4538,7 +4538,7 @@ nfsrv_backupstable(void)
strcmp(procp->p_comm, nfsd_master_comm) == 0)
kern_psignal(procp, SIGUSR2);
else
- NFSD_VNET(nfsd_master_proc) = NULL;
+ VNET(nfsd_master_proc) = NULL;
if (procp != NULL)
PROC_UNLOCK(procp);
@@ -7502,11 +7502,11 @@ nfsrv_cleanup(const void *unused __unused)
int i;
NFSD_LOCK();
- if (!NFSD_VNET(nfsrv_mntinited)) {
+ if (!VNET(nfsrv_mntinited)) {
NFSD_UNLOCK();
return;
}
- NFSD_VNET(nfsrv_mntinited) = false;
+ VNET(nfsrv_mntinited) = false;
NFSD_UNLOCK();
/* Clean out all NFSv4 state. */
@@ -7516,33 +7516,33 @@ nfsrv_cleanup(const void *unused __unused)
nfsrvd_cleancache();
/* Clean out v4root exports. */
- if (NFSD_VNET(nfsv4root_mnt)->mnt_export != NULL) {
- vfs_free_addrlist(NFSD_VNET(nfsv4root_mnt)->mnt_export);
- free(NFSD_VNET(nfsv4root_mnt)->mnt_export, M_MOUNT);
- NFSD_VNET(nfsv4root_mnt)->mnt_export = NULL;
+ if (VNET(nfsv4root_mnt)->mnt_export != NULL) {
+ vfs_free_addrlist(VNET(nfsv4root_mnt)->mnt_export);
+ free(VNET(nfsv4root_mnt)->mnt_export, M_MOUNT);
+ VNET(nfsv4root_mnt)->mnt_export = NULL;
}
/* Free up the krpc server pool. */
- if (NFSD_VNET(nfsrvd_pool) != NULL)
- svcpool_destroy(NFSD_VNET(nfsrvd_pool));
+ if (VNET(nfsrvd_pool) != NULL)
+ svcpool_destroy(VNET(nfsrvd_pool));
/* and get rid of the locks */
for (i = 0; i < NFSRVCACHE_HASHSIZE; i++) {
- mtx_destroy(&NFSD_VNET(nfsrchash_table)[i].mtx);
- mtx_destroy(&NFSD_VNET(nfsrcahash_table)[i].mtx);
+ mtx_destroy(&VNET(nfsrchash_table)[i].mtx);
+ mtx_destroy(&VNET(nfsrcahash_table)[i].mtx);
}
- mtx_destroy(&NFSD_VNET(nfsv4root_mnt)->mnt_mtx);
+ mtx_destroy(&VNET(nfsv4root_mnt)->mnt_mtx);
for (i = 0; i < nfsrv_sessionhashsize; i++)
- mtx_destroy(&NFSD_VNET(nfssessionhash)[i].mtx);
- lockdestroy(&NFSD_VNET(nfsv4root_mnt)->mnt_explock);
- free(NFSD_VNET(nfsrvudphashtbl), M_NFSRVCACHE);
- free(NFSD_VNET(nfsrchash_table), M_NFSRVCACHE);
- free(NFSD_VNET(nfsrcahash_table), M_NFSRVCACHE);
- free(NFSD_VNET(nfsclienthash), M_NFSDCLIENT);
- free(NFSD_VNET(nfslockhash), M_NFSDLOCKFILE);
- free(NFSD_VNET(nfssessionhash), M_NFSDSESSION);
- free(NFSD_VNET(nfsv4root_mnt), M_TEMP);
- NFSD_VNET(nfsv4root_mnt) = NULL;
+ mtx_destroy(&VNET(nfssessionhash)[i].mtx);
+ lockdestroy(&VNET(nfsv4root_mnt)->mnt_explock);
+ free(VNET(nfsrvudphashtbl), M_NFSRVCACHE);
+ free(VNET(nfsrchash_table), M_NFSRVCACHE);
+ free(VNET(nfsrcahash_table), M_NFSRVCACHE);
+ free(VNET(nfsclienthash), M_NFSDCLIENT);
+ free(VNET(nfslockhash), M_NFSDLOCKFILE);
+ free(VNET(nfssessionhash), M_NFSDSESSION);
+ free(VNET(nfsv4root_mnt), M_TEMP);
+ VNET(nfsv4root_mnt) = NULL;
}
VNET_SYSUNINIT(nfsrv_cleanup, SI_SUB_VNET_DONE, SI_ORDER_ANY,
nfsrv_cleanup, NULL);
diff --git a/sys/fs/nfsserver/nfs_nfsdsocket.c b/sys/fs/nfsserver/nfs_nfsdsocket.c
index efa7906dffc7..36996425ae95 100644
--- a/sys/fs/nfsserver/nfs_nfsdsocket.c
+++ b/sys/fs/nfsserver/nfs_nfsdsocket.c
@@ -52,13 +52,13 @@ extern volatile int nfsrv_layoutcnt;
NFSV4ROOTLOCKMUTEX;
NFSSTATESPINLOCK;
-NFSD_VNET_DECLARE(struct nfsrv_stablefirst, nfsrv_stablefirst);
-NFSD_VNET_DECLARE(struct nfsclienthashhead *, nfsclienthash);
-NFSD_VNET_DECLARE(int, nfsrc_floodlevel);
-NFSD_VNET_DECLARE(int, nfsrc_tcpsavedreplies);
-NFSD_VNET_DECLARE(struct nfsrvfh, nfs_rootfh);
-NFSD_VNET_DECLARE(int, nfs_rootfhset);
-NFSD_VNET_DECLARE(struct nfsstatsv1 *, nfsstatsv1_p);
+VNET_DECLARE(struct nfsrv_stablefirst, nfsrv_stablefirst);
+VNET_DECLARE(struct nfsclienthashhead *, nfsclienthash);
+VNET_DECLARE(int, nfsrc_floodlevel);
+VNET_DECLARE(int, nfsrc_tcpsavedreplies);
+VNET_DECLARE(struct nfsrvfh, nfs_rootfh);
+VNET_DECLARE(int, nfs_rootfhset);
+VNET_DECLARE(struct nfsstatsv1 *, nfsstatsv1_p);
int (*nfsrv3_procs0[NFS_V3NPROCS])(struct nfsrv_descript *,
int, vnode_t , struct nfsexstuff *) = {
@@ -477,16 +477,16 @@ nfsrvd_statstart(int op, struct bintime *now)
}
mtx_lock(&nfsrvd_statmtx);
- if (NFSD_VNET(nfsstatsv1_p)->srvstartcnt ==
- NFSD_VNET(nfsstatsv1_p)->srvdonecnt) {
+ if (VNET(nfsstatsv1_p)->srvstartcnt ==
+ VNET(nfsstatsv1_p)->srvdonecnt) {
if (now != NULL)
- NFSD_VNET(nfsstatsv1_p)->busyfrom = *now;
+ VNET(nfsstatsv1_p)->busyfrom = *now;
else
- binuptime(&NFSD_VNET(nfsstatsv1_p)->busyfrom);
+ binuptime(&VNET(nfsstatsv1_p)->busyfrom);
}
- NFSD_VNET(nfsstatsv1_p)->srvrpccnt[op]++;
- NFSD_VNET(nfsstatsv1_p)->srvstartcnt++;
+ VNET(nfsstatsv1_p)->srvrpccnt[op]++;
+ VNET(nfsstatsv1_p)->srvstartcnt++;
mtx_unlock(&nfsrvd_statmtx);
}
@@ -509,21 +509,21 @@ nfsrvd_statend(int op, uint64_t bytes, struct bintime *now,
mtx_lock(&nfsrvd_statmtx);
- NFSD_VNET(nfsstatsv1_p)->srvbytes[op] += bytes;
- NFSD_VNET(nfsstatsv1_p)->srvops[op]++;
+ VNET(nfsstatsv1_p)->srvbytes[op] += bytes;
+ VNET(nfsstatsv1_p)->srvops[op]++;
if (then != NULL) {
dt = *now;
bintime_sub(&dt, then);
- bintime_add(&NFSD_VNET(nfsstatsv1_p)->srvduration[op], &dt);
+ bintime_add(&VNET(nfsstatsv1_p)->srvduration[op], &dt);
}
dt = *now;
- bintime_sub(&dt, &NFSD_VNET(nfsstatsv1_p)->busyfrom);
- bintime_add(&NFSD_VNET(nfsstatsv1_p)->busytime, &dt);
- NFSD_VNET(nfsstatsv1_p)->busyfrom = *now;
+ bintime_sub(&dt, &VNET(nfsstatsv1_p)->busyfrom);
+ bintime_add(&VNET(nfsstatsv1_p)->busytime, &dt);
+ VNET(nfsstatsv1_p)->busyfrom = *now;
- NFSD_VNET(nfsstatsv1_p)->srvdonecnt++;
+ VNET(nfsstatsv1_p)->srvdonecnt++;
mtx_unlock(&nfsrvd_statmtx);
}
@@ -761,7 +761,7 @@ nfsrvd_compound(struct nfsrv_descript *nd, int isdgram, u_char *tag,
*/
igotlock = 0;
NFSLOCKV4ROOTMUTEX();
- if (NFSD_VNET(nfsrv_stablefirst).nsf_flags & NFSNSF_NEEDLOCK)
+ if (VNET(nfsrv_stablefirst).nsf_flags & NFSNSF_NEEDLOCK)
igotlock = nfsv4_lock(&nfsv4rootfs_lock, 1, NULL,
NFSV4ROOTLOCKMUTEXPTR, NULL);
else
@@ -774,8 +774,8 @@ nfsrvd_compound(struct nfsrv_descript *nd, int isdgram, u_char *tag,
* Done when the grace period is over or a client has long
* since expired.
*/
- NFSD_VNET(nfsrv_stablefirst).nsf_flags &= ~NFSNSF_NEEDLOCK;
- if ((NFSD_VNET(nfsrv_stablefirst).nsf_flags &
+ VNET(nfsrv_stablefirst).nsf_flags &= ~NFSNSF_NEEDLOCK;
+ if ((VNET(nfsrv_stablefirst).nsf_flags &
(NFSNSF_GRACEOVER | NFSNSF_UPDATEDONE)) == NFSNSF_GRACEOVER)
nfsrv_updatestable(p);
@@ -785,12 +785,12 @@ nfsrvd_compound(struct nfsrv_descript *nd, int isdgram, u_char *tag,
* stable storage file and then remove them from the client
* list.
*/
- if (NFSD_VNET(nfsrv_stablefirst).nsf_flags &
+ if (VNET(nfsrv_stablefirst).nsf_flags &
NFSNSF_EXPIREDCLIENT) {
- NFSD_VNET(nfsrv_stablefirst).nsf_flags &=
+ VNET(nfsrv_stablefirst).nsf_flags &=
~NFSNSF_EXPIREDCLIENT;
for (i = 0; i < nfsrv_clienthashsize; i++) {
- LIST_FOREACH_SAFE(clp, &NFSD_VNET(nfsclienthash)[i],
+ LIST_FOREACH_SAFE(clp, &VNET(nfsclienthash)[i],
lc_hash, nclp) {
if (clp->lc_flags & LCL_EXPIREIT) {
if (!LIST_EMPTY(&clp->lc_open) ||
@@ -824,7 +824,7 @@ nfsrvd_compound(struct nfsrv_descript *nd, int isdgram, u_char *tag,
* If flagged, search for open owners that haven't had any opens
* for a long time.
*/
- if (NFSD_VNET(nfsrv_stablefirst).nsf_flags & NFSNSF_NOOPENS) {
+ if (VNET(nfsrv_stablefirst).nsf_flags & NFSNSF_NOOPENS) {
nfsrv_throwawayopens(p);
}
@@ -951,10 +951,10 @@ nfsrvd_compound(struct nfsrv_descript *nd, int isdgram, u_char *tag,
if (i == 0 && (nd->nd_rp == NULL ||
nd->nd_rp->rc_refcnt == 0) &&
(nfsrv_mallocmget_limit() ||
- NFSD_VNET(nfsrc_tcpsavedreplies) >
- NFSD_VNET(nfsrc_floodlevel))) {
- if (NFSD_VNET(nfsrc_tcpsavedreplies) >
- NFSD_VNET(nfsrc_floodlevel))
+ VNET(nfsrc_tcpsavedreplies) >
+ VNET(nfsrc_floodlevel))) {
+ if (VNET(nfsrc_tcpsavedreplies) >
+ VNET(nfsrc_floodlevel))
printf("nfsd server cache flooded, try "
"increasing vfs.nfsd.tcphighwater\n");
nd->nd_repstat = NFSERR_RESOURCE;
@@ -1069,7 +1069,7 @@ nfsrvd_compound(struct nfsrv_descript *nd, int isdgram, u_char *tag,
}
break;
case NFSV4OP_PUTROOTFH:
- if (NFSD_VNET(nfs_rootfhset)) {
+ if (VNET(nfs_rootfhset)) {
if ((nd->nd_flag & ND_LASTOP) == 0) {
/*
* Pre-parse the next op#. If it is
@@ -1090,7 +1090,7 @@ nfsrvd_compound(struct nfsrv_descript *nd, int isdgram, u_char *tag,
} while (nextop == NFSV4OP_SAVEFH &&
i < numops - 1);
}
- nfsd_fhtovp(nd, &NFSD_VNET(nfs_rootfh),
+ nfsd_fhtovp(nd, &VNET(nfs_rootfh),
LK_SHARED, &nvp, &nes, NULL, 0, nextop);
if (!nd->nd_repstat) {
if (vp)
diff --git a/sys/fs/nfsserver/nfs_nfsdstate.c b/sys/fs/nfsserver/nfs_nfsdstate.c
index 18967a00583a..4f4aff342872 100644
--- a/sys/fs/nfsserver/nfs_nfsdstate.c
+++ b/sys/fs/nfsserver/nfs_nfsdstate.c
@@ -40,10 +40,10 @@ time_t nfsdev_time = 0;
int nfsrv_layouthashsize;
volatile int nfsrv_layoutcnt = 0;
-NFSD_VNET_DEFINE(struct nfsrv_stablefirst, nfsrv_stablefirst);
+VNET_DEFINE(struct nfsrv_stablefirst, nfsrv_stablefirst);
-NFSD_VNET_DECLARE(int, nfsrv_numnfsd);
-NFSD_VNET_DECLARE(struct nfsstatsv1 *, nfsstatsv1_p);
+VNET_DECLARE(int, nfsrv_numnfsd);
+VNET_DECLARE(struct nfsstatsv1 *, nfsstatsv1_p);
extern uint32_t nfs_srvmaxio;
extern int nfsrv_lease;
@@ -115,17 +115,17 @@ SYSCTL_INT(_vfs_nfsd, OID_AUTO, flexlinuxhack, CTLFLAG_RW,
&nfsrv_flexlinuxhack, 0,
"For Linux clients, hack around Flex File Layout bug");
-NFSD_VNET_DEFINE_STATIC(bool, nfsd_disable_grace) = false;
+VNET_DEFINE_STATIC(bool, nfsd_disable_grace) = false;
SYSCTL_BOOL(_vfs_nfsd, OID_AUTO, testing_disable_grace,
- CTLFLAG_NFSD_VNET | CTLFLAG_RW, &NFSD_VNET_NAME(nfsd_disable_grace),
+ CTLFLAG_VNET | CTLFLAG_RW, &VNET_NAME(nfsd_disable_grace),
0, "Disable grace for testing");
/*
* Hash lists for nfs V4.
*/
-NFSD_VNET_DEFINE(struct nfsclienthashhead *, nfsclienthash);
-NFSD_VNET_DEFINE(struct nfslockhashhead *, nfslockhash);
-NFSD_VNET_DEFINE(struct nfssessionhash *, nfssessionhash);
+VNET_DEFINE(struct nfsclienthashhead *, nfsclienthash);
+VNET_DEFINE(struct nfslockhashhead *, nfslockhash);
+VNET_DEFINE(struct nfssessionhash *, nfssessionhash);
struct nfslayouthash *nfslayouthash;
volatile int nfsrv_dontlistlen = 0;
@@ -137,7 +137,7 @@ static int nfsrv_nogsscallback = 0;
static volatile int nfsrv_writedelegcnt = 0;
static int nfsrv_faildscnt;
-NFSD_VNET_DEFINE_STATIC(time_t, nfsrvboottime);
+VNET_DEFINE_STATIC(time_t, nfsrvboottime);
/* local functions */
static void nfsrv_dumpaclient(struct nfsclient *clp,
@@ -352,7 +352,7 @@ nfsrv_setclient(struct nfsrv_descript *nd, struct nfsclient **new_clpp,
*/
gotit = i = 0;
while (i < nfsrv_clienthashsize && !gotit) {
- LIST_FOREACH(clp, &NFSD_VNET(nfsclienthash)[i], lc_hash) {
+ LIST_FOREACH(clp, &VNET(nfsclienthash)[i], lc_hash) {
if (new_clp->lc_idlen == clp->lc_idlen &&
!NFSBCMP(new_clp->lc_id, clp->lc_id, clp->lc_idlen)) {
gotit = 1;
@@ -399,7 +399,7 @@ nfsrv_setclient(struct nfsrv_descript *nd, struct nfsclient **new_clpp,
confirmp->qval = new_clp->lc_confirm.qval =
++confirm_index;
clientidp->lval[0] = new_clp->lc_clientid.lval[0] =
- NFSD_VNET(nfsrvboottime);
+ VNET(nfsrvboottime);
clientidp->lval[1] = new_clp->lc_clientid.lval[1] =
nfsrv_nextclientindex();
new_clp->lc_stateindex = 0;
@@ -415,7 +415,7 @@ nfsrv_setclient(struct nfsrv_descript *nd, struct nfsclient **new_clpp,
LIST_INIT(&new_clp->lc_stateid[i]);
LIST_INSERT_HEAD(NFSCLIENTHASH(new_clp->lc_clientid), new_clp,
lc_hash);
- NFSD_VNET(nfsstatsv1_p)->srvclients++;
+ VNET(nfsstatsv1_p)->srvclients++;
nfsrv_openpluslock++;
nfsrv_clients++;
nfsrv_clientunlock(mlocked);
@@ -512,7 +512,7 @@ nfsrv_setclient(struct nfsrv_descript *nd, struct nfsclient **new_clpp,
confirmp->qval = new_clp->lc_confirm.qval =
++confirm_index;
clientidp->lval[0] = new_clp->lc_clientid.lval[0] =
- NFSD_VNET(nfsrvboottime);
+ VNET(nfsrvboottime);
clientidp->lval[1] = new_clp->lc_clientid.lval[1] =
nfsrv_nextclientindex();
new_clp->lc_stateindex = 0;
@@ -543,7 +543,7 @@ nfsrv_setclient(struct nfsrv_descript *nd, struct nfsclient **new_clpp,
LIST_INIT(&new_clp->lc_session);
LIST_INSERT_HEAD(NFSCLIENTHASH(new_clp->lc_clientid), new_clp,
lc_hash);
- NFSD_VNET(nfsstatsv1_p)->srvclients++;
+ VNET(nfsstatsv1_p)->srvclients++;
nfsrv_openpluslock++;
nfsrv_clients++;
if (!mlocked) {
@@ -618,7 +618,7 @@ nfsrv_setclient(struct nfsrv_descript *nd, struct nfsclient **new_clpp,
LIST_INIT(&new_clp->lc_session);
LIST_INSERT_HEAD(NFSCLIENTHASH(new_clp->lc_clientid), new_clp,
lc_hash);
- NFSD_VNET(nfsstatsv1_p)->srvclients++;
+ VNET(nfsstatsv1_p)->srvclients++;
nfsrv_openpluslock++;
nfsrv_clients++;
}
@@ -678,7 +678,7 @@ nfsrv_getclient(nfsquad_t clientid, int opflags, struct nfsclient **clpp,
if (clpp)
*clpp = NULL;
if ((nd == NULL || (nd->nd_flag & ND_NFSV41) == 0 ||
- opflags != CLOPS_RENEW) && NFSD_VNET(nfsrvboottime) !=
+ opflags != CLOPS_RENEW) && VNET(nfsrvboottime) !=
clientid.lval[0]) {
error = NFSERR_STALECLIENTID;
goto out;
@@ -920,7 +920,7 @@ nfsrv_destroyclient(struct nfsrv_descript *nd, nfsquad_t clientid, NFSPROC_T *p)
int error = 0, i;
bool mlocked;
- if (NFSD_VNET(nfsrvboottime) != clientid.lval[0]) {
+ if (VNET(nfsrvboottime) != clientid.lval[0]) {
error = NFSERR_STALECLIENTID;
goto out;
}
@@ -1014,7 +1014,7 @@ nfsrv_adminrevoke(struct nfsd_clid *revokep, NFSPROC_T *p)
*/
gotit = i = 0;
while (i < nfsrv_clienthashsize && !gotit) {
- LIST_FOREACH(clp, &NFSD_VNET(nfsclienthash)[i], lc_hash) {
+ LIST_FOREACH(clp, &VNET(nfsclienthash)[i], lc_hash) {
if (revokep->nclid_idlen == clp->lc_idlen &&
!NFSBCMP(revokep->nclid_id, clp->lc_id, clp->lc_idlen)) {
gotit = 1;
@@ -1076,8 +1076,8 @@ nfsrv_dumpclients(struct nfsd_dumpclients *dumpp, int maxcnt)
* Rattle through the client lists until done.
*/
while (i < nfsrv_clienthashsize && cnt < maxcnt) {
- clp = LIST_FIRST(&NFSD_VNET(nfsclienthash)[i]);
- while (clp != LIST_END(&NFSD_VNET(nfsclienthash)[i]) && cnt <
+ clp = LIST_FIRST(&VNET(nfsclienthash)[i]);
+ while (clp != LIST_END(&VNET(nfsclienthash)[i]) && cnt <
maxcnt) {
nfsrv_dumpaclient(clp, &dumpp[cnt]);
cnt++;
@@ -1354,15 +1354,15 @@ nfsrv_servertimer(void *arg __unused)
* If server hasn't started yet, just return.
*/
NFSLOCKSTATE();
- if (NFSD_VNET(nfsrv_stablefirst).nsf_eograce == 0) {
+ if (VNET(nfsrv_stablefirst).nsf_eograce == 0) {
NFSUNLOCKSTATE();
return;
}
- if (!(NFSD_VNET(nfsrv_stablefirst).nsf_flags & NFSNSF_UPDATEDONE)) {
- if (!(NFSD_VNET(nfsrv_stablefirst).nsf_flags &
+ if (!(VNET(nfsrv_stablefirst).nsf_flags & NFSNSF_UPDATEDONE)) {
+ if (!(VNET(nfsrv_stablefirst).nsf_flags &
NFSNSF_GRACEOVER) &&
- NFSD_MONOSEC > NFSD_VNET(nfsrv_stablefirst).nsf_eograce)
- NFSD_VNET(nfsrv_stablefirst).nsf_flags |=
+ NFSD_MONOSEC > VNET(nfsrv_stablefirst).nsf_eograce)
+ VNET(nfsrv_stablefirst).nsf_flags |=
(NFSNSF_GRACEOVER | NFSNSF_NEEDLOCK);
NFSUNLOCKSTATE();
return;
@@ -1385,8 +1385,8 @@ nfsrv_servertimer(void *arg __unused)
* For each client...
*/
for (i = 0; i < nfsrv_clienthashsize; i++) {
- clp = LIST_FIRST(&NFSD_VNET(nfsclienthash)[i]);
- while (clp != LIST_END(&NFSD_VNET(nfsclienthash)[i])) {
+ clp = LIST_FIRST(&VNET(nfsclienthash)[i]);
+ while (clp != LIST_END(&VNET(nfsclienthash)[i])) {
nclp = LIST_NEXT(clp, lc_hash);
if (!(clp->lc_flags & LCL_EXPIREIT)) {
if (((clp->lc_expiry + NFSRV_STALELEASE) < NFSD_MONOSEC
@@ -1417,7 +1417,7 @@ nfsrv_servertimer(void *arg __unused)
* by an nfsd sometime soon.
*/
clp->lc_flags |= LCL_EXPIREIT;
- NFSD_VNET(nfsrv_stablefirst).nsf_flags |=
+ VNET(nfsrv_stablefirst).nsf_flags |=
(NFSNSF_NEEDLOCK | NFSNSF_EXPIREDCLIENT);
} else {
/*
@@ -1435,7 +1435,7 @@ nfsrv_servertimer(void *arg __unused)
if (stp->ls_noopens > NFSNOOPEN ||
(nfsrv_openpluslock * 2) >
nfsrv_v4statelimit)
- NFSD_VNET(nfsrv_stablefirst).nsf_flags |=
+ VNET(nfsrv_stablefirst).nsf_flags |=
NFSNSF_NOOPENS;
} else {
stp->ls_noopens = 0;
@@ -1508,7 +1508,7 @@ nfsrv_zapclient(struct nfsclient *clp, NFSPROC_T *p)
free(clp->lc_stateid, M_NFSDCLIENT);
free(clp, M_NFSDCLIENT);
NFSLOCKSTATE();
- NFSD_VNET(nfsstatsv1_p)->srvclients--;
+ VNET(nfsstatsv1_p)->srvclients--;
nfsrv_openpluslock--;
nfsrv_clients--;
NFSUNLOCKSTATE();
@@ -1551,7 +1551,7 @@ nfsrv_freedeleg(struct nfsstate *stp)
nfsv4_testlock(&lfp->lf_locallock_lck) == 0)
nfsrv_freenfslockfile(lfp);
free(stp, M_NFSDSTATE);
- NFSD_VNET(nfsstatsv1_p)->srvdelegates--;
+ VNET(nfsstatsv1_p)->srvdelegates--;
nfsrv_openpluslock--;
nfsrv_delegatecnt--;
}
@@ -1577,7 +1577,7 @@ nfsrv_freeopenowner(struct nfsstate *stp, int cansleep, NFSPROC_T *p)
if (stp->ls_op)
nfsrvd_derefcache(stp->ls_op);
free(stp, M_NFSDSTATE);
- NFSD_VNET(nfsstatsv1_p)->srvopenowners--;
+ VNET(nfsstatsv1_p)->srvopenowners--;
nfsrv_openpluslock--;
}
@@ -1638,7 +1638,7 @@ nfsrv_freeopen(struct nfsstate *stp, vnode_t vp, int cansleep, NFSPROC_T *p)
nfsv4_testlock(&lfp->lf_locallock_lck) == 0)
nfsrv_freenfslockfile(lfp);
free(stp, M_NFSDSTATE);
- NFSD_VNET(nfsstatsv1_p)->srvopens--;
+ VNET(nfsstatsv1_p)->srvopens--;
nfsrv_openpluslock--;
}
@@ -1657,7 +1657,7 @@ nfsrv_freelockowner(struct nfsstate *stp, vnode_t vp, int cansleep,
if (stp->ls_op)
nfsrvd_derefcache(stp->ls_op);
free(stp, M_NFSDSTATE);
- NFSD_VNET(nfsstatsv1_p)->srvlockowners--;
+ VNET(nfsstatsv1_p)->srvlockowners--;
nfsrv_openpluslock--;
}
@@ -1733,7 +1733,7 @@ nfsrv_freenfslock(struct nfslock *lop)
if (lop->lo_lckfile.le_prev != NULL) {
LIST_REMOVE(lop, lo_lckfile);
- NFSD_VNET(nfsstatsv1_p)->srvlocks--;
+ VNET(nfsstatsv1_p)->srvlocks--;
nfsrv_openpluslock--;
}
LIST_REMOVE(lop, lo_lckowner);
@@ -2524,7 +2524,7 @@ tryagain:
LIST_INSERT_HEAD(&stp->ls_open, new_stp, ls_list);
*new_lopp = NULL;
*new_stpp = NULL;
- NFSD_VNET(nfsstatsv1_p)->srvlockowners++;
+ VNET(nfsstatsv1_p)->srvlockowners++;
nfsrv_openpluslock++;
}
if (filestruct_locked != 0) {
@@ -3184,12 +3184,12 @@ tryagain:
LIST_INSERT_HEAD(&new_stp->ls_open, new_open, ls_list);
LIST_INSERT_HEAD(&clp->lc_open, new_stp, ls_list);
*new_stpp = NULL;
- NFSD_VNET(nfsstatsv1_p)->srvopenowners++;
+ VNET(nfsstatsv1_p)->srvopenowners++;
nfsrv_openpluslock++;
}
openstp = new_open;
new_open = NULL;
- NFSD_VNET(nfsstatsv1_p)->srvopens++;
+ VNET(nfsstatsv1_p)->srvopens++;
nfsrv_openpluslock++;
break;
}
@@ -3250,7 +3250,7 @@ tryagain:
NFSRV_V4DELEGLIMIT(nfsrv_delegatecnt) ||
!NFSVNO_DELEGOK(vp))
*rflagsp |= NFSV4OPEN_RECALL;
- NFSD_VNET(nfsstatsv1_p)->srvdelegates++;
+ VNET(nfsstatsv1_p)->srvdelegates++;
nfsrv_openpluslock++;
nfsrv_delegatecnt++;
@@ -3290,12 +3290,12 @@ tryagain:
LIST_INSERT_HEAD(&new_stp->ls_open, new_open, ls_list);
LIST_INSERT_HEAD(&clp->lc_open, new_stp, ls_list);
*new_stpp = NULL;
- NFSD_VNET(nfsstatsv1_p)->srvopenowners++;
+ VNET(nfsstatsv1_p)->srvopenowners++;
nfsrv_openpluslock++;
}
openstp = new_open;
new_open = NULL;
- NFSD_VNET(nfsstatsv1_p)->srvopens++;
+ VNET(nfsstatsv1_p)->srvopens++;
nfsrv_openpluslock++;
} else {
error = NFSERR_RECLAIMCONFLICT;
@@ -3351,7 +3351,7 @@ tryagain:
new_open, ls_hash);
openstp = new_open;
new_open = NULL;
- NFSD_VNET(nfsstatsv1_p)->srvopens++;
+ VNET(nfsstatsv1_p)->srvopens++;
nfsrv_openpluslock++;
/*
@@ -3415,9 +3415,9 @@ tryagain:
openstp = new_open;
new_open = NULL;
*new_stpp = NULL;
- NFSD_VNET(nfsstatsv1_p)->srvopens++;
+ VNET(nfsstatsv1_p)->srvopens++;
nfsrv_openpluslock++;
- NFSD_VNET(nfsstatsv1_p)->srvopenowners++;
+ VNET(nfsstatsv1_p)->srvopenowners++;
nfsrv_openpluslock++;
}
if (!error) {
@@ -3880,7 +3880,7 @@ nfsrv_insertlock(struct nfslock *new_lop, struct nfslock *insert_lop,
else
LIST_INSERT_AFTER(insert_lop, new_lop, lo_lckowner);
if (stp != NULL) {
- NFSD_VNET(nfsstatsv1_p)->srvlocks++;
+ VNET(nfsstatsv1_p)->srvlocks++;
nfsrv_openpluslock++;
}
}
@@ -4367,11 +4367,11 @@ nfsrv_checkrestart(nfsquad_t clientid, u_int32_t flags,
*/
if (flags &
(NFSLCK_OPEN | NFSLCK_TEST | NFSLCK_RELEASE | NFSLCK_DELEGPURGE)) {
- if (clientid.lval[0] != NFSD_VNET(nfsrvboottime)) {
+ if (clientid.lval[0] != VNET(nfsrvboottime)) {
ret = NFSERR_STALECLIENTID;
goto out;
}
- } else if (stateidp->other[0] != NFSD_VNET(nfsrvboottime) &&
+ } else if (stateidp->other[0] != VNET(nfsrvboottime) &&
specialid == 0) {
ret = NFSERR_STALESTATEID;
goto out;
@@ -4404,15 +4404,15 @@ nfsrv_checkgrace(struct nfsrv_descript *nd, struct nfsclient *clp,
int error = 0, notreclaimed;
struct nfsrv_stable *sp;
- if ((NFSD_VNET(nfsrv_stablefirst).nsf_flags & (NFSNSF_UPDATEDONE |
+ if ((VNET(nfsrv_stablefirst).nsf_flags & (NFSNSF_UPDATEDONE |
NFSNSF_GRACEOVER)) == 0) {
/*
* First, check to see if all of the clients have done a
* ReclaimComplete. If so, grace can end now.
*/
notreclaimed = 0;
- if (!NFSD_VNET(nfsd_disable_grace)) {
- LIST_FOREACH(sp, &NFSD_VNET(nfsrv_stablefirst).nsf_head,
+ if (!VNET(nfsd_disable_grace)) {
+ LIST_FOREACH(sp, &VNET(nfsrv_stablefirst).nsf_head,
nst_list) {
if ((sp->nst_flag & NFSNST_RECLAIMED) == 0) {
notreclaimed = 1;
@@ -4421,11 +4421,11 @@ nfsrv_checkgrace(struct nfsrv_descript *nd, struct nfsclient *clp,
}
}
if (notreclaimed == 0)
- NFSD_VNET(nfsrv_stablefirst).nsf_flags |=
+ VNET(nfsrv_stablefirst).nsf_flags |=
(NFSNSF_GRACEOVER | NFSNSF_NEEDLOCK);
}
- if ((NFSD_VNET(nfsrv_stablefirst).nsf_flags & NFSNSF_GRACEOVER) != 0) {
+ if ((VNET(nfsrv_stablefirst).nsf_flags & NFSNSF_GRACEOVER) != 0) {
if (flags & NFSLCK_RECLAIM) {
error = NFSERR_NOGRACE;
goto out;
@@ -4447,8 +4447,8 @@ nfsrv_checkgrace(struct nfsrv_descript *nd, struct nfsclient *clp,
* extend grace a bit.
*/
if ((NFSD_MONOSEC + NFSRV_LEASEDELTA) >
- NFSD_VNET(nfsrv_stablefirst).nsf_eograce)
- NFSD_VNET(nfsrv_stablefirst).nsf_eograce =
+ VNET(nfsrv_stablefirst).nsf_eograce)
+ VNET(nfsrv_stablefirst).nsf_eograce =
NFSD_MONOSEC + NFSRV_LEASEDELTA;
}
@@ -4883,7 +4883,7 @@ tryagain:
void
nfsrv_setupstable(NFSPROC_T *p)
{
- struct nfsrv_stablefirst *sf = &NFSD_VNET(nfsrv_stablefirst);
+ struct nfsrv_stablefirst *sf = &VNET(nfsrv_stablefirst);
struct nfsrv_stable *sp, *nsp;
struct nfst_rec *tsp;
int error, i, tryagain;
@@ -4899,7 +4899,7 @@ nfsrv_setupstable(NFSPROC_T *p)
/*
* Set Grace over just until the file reads successfully.
*/
- NFSD_VNET(nfsrvboottime) = time_second;
+ VNET(nfsrvboottime) = time_second;
LIST_INIT(&sf->nsf_head);
sf->nsf_flags = (NFSNSF_GRACEOVER | NFSNSF_NEEDLOCK);
sf->nsf_eograce = NFSD_MONOSEC + NFSRV_LEASEDELTA;
@@ -4934,8 +4934,8 @@ nfsrv_setupstable(NFSPROC_T *p)
do {
tryagain = 0;
for (i = 0; i < sf->nsf_numboots; i++) {
- if (NFSD_VNET(nfsrvboottime) == sf->nsf_bootvals[i]) {
- NFSD_VNET(nfsrvboottime)++;
+ if (VNET(nfsrvboottime) == sf->nsf_bootvals[i]) {
+ VNET(nfsrvboottime)++;
tryagain = 1;
break;
}
@@ -5018,7 +5018,7 @@ nfsrv_setupstable(NFSPROC_T *p)
void
nfsrv_updatestable(NFSPROC_T *p)
{
- struct nfsrv_stablefirst *sf = &NFSD_VNET(nfsrv_stablefirst);
+ struct nfsrv_stablefirst *sf = &VNET(nfsrv_stablefirst);
struct nfsrv_stable *sp, *nsp;
int i;
struct nfsvattr nva;
@@ -5047,7 +5047,7 @@ nfsrv_updatestable(NFSPROC_T *p)
sf->nsf_bootvals = (time_t *)malloc(sizeof(time_t),
M_TEMP, M_WAITOK);
}
- sf->nsf_bootvals[0] = NFSD_VNET(nfsrvboottime);
+ sf->nsf_bootvals[0] = VNET(nfsrvboottime);
sf->nsf_lease = nfsrv_lease;
NFSVNO_ATTRINIT(&nva);
NFSVNO_SETATTRVAL(&nva, size, 0);
@@ -5101,7 +5101,7 @@ nfsrv_updatestable(NFSPROC_T *p)
void
nfsrv_writestable(u_char *client, int len, int flag, NFSPROC_T *p)
{
- struct nfsrv_stablefirst *sf = &NFSD_VNET(nfsrv_stablefirst);
+ struct nfsrv_stablefirst *sf = &VNET(nfsrv_stablefirst);
struct nfst_rec *sp;
int error;
@@ -5134,12 +5134,12 @@ nfsrv_markstable(struct nfsclient *clp)
/*
* First find the client structure.
*/
- LIST_FOREACH(sp, &NFSD_VNET(nfsrv_stablefirst).nsf_head, nst_list) {
+ LIST_FOREACH(sp, &VNET(nfsrv_stablefirst).nsf_head, nst_list) {
if (sp->nst_len == clp->lc_idlen &&
!NFSBCMP(sp->nst_client, clp->lc_id, sp->nst_len))
break;
}
- if (sp == LIST_END(&NFSD_VNET(nfsrv_stablefirst).nsf_head))
+ if (sp == LIST_END(&VNET(nfsrv_stablefirst).nsf_head))
return;
/*
@@ -5161,12 +5161,12 @@ nfsrv_markreclaim(struct nfsclient *clp)
/*
* First find the client structure.
*/
- LIST_FOREACH(sp, &NFSD_VNET(nfsrv_stablefirst).nsf_head, nst_list) {
+ LIST_FOREACH(sp, &VNET(nfsrv_stablefirst).nsf_head, nst_list) {
if (sp->nst_len == clp->lc_idlen &&
!NFSBCMP(sp->nst_client, clp->lc_id, sp->nst_len))
break;
}
- if (sp == LIST_END(&NFSD_VNET(nfsrv_stablefirst).nsf_head))
+ if (sp == LIST_END(&VNET(nfsrv_stablefirst).nsf_head))
return;
/*
@@ -5192,7 +5192,7 @@ nfsrv_checkstable(struct nfsclient *clp)
/*
* First, find the entry for the client.
*/
- LIST_FOREACH(sp, &NFSD_VNET(nfsrv_stablefirst).nsf_head, nst_list) {
+ LIST_FOREACH(sp, &VNET(nfsrv_stablefirst).nsf_head, nst_list) {
if (sp->nst_len == clp->lc_idlen &&
!NFSBCMP(sp->nst_client, clp->lc_id, sp->nst_len))
break;
@@ -5202,9 +5202,9 @@ nfsrv_checkstable(struct nfsclient *clp)
* If not in the list, state was revoked or no state was issued
* since the previous reboot, a reclaim is denied.
*/
- if (sp == LIST_END(&NFSD_VNET(nfsrv_stablefirst).nsf_head) ||
+ if (sp == LIST_END(&VNET(nfsrv_stablefirst).nsf_head) ||
(sp->nst_flag & NFSNST_REVOKE) ||
- !(NFSD_VNET(nfsrv_stablefirst).nsf_flags & NFSNSF_OK))
+ !(VNET(nfsrv_stablefirst).nsf_flags & NFSNSF_OK))
return (1);
return (0);
}
@@ -5232,7 +5232,7 @@ nfsrv_clientconflict(struct nfsclient *clp, int *haslockp, vnode_t vp,
* If lease hasn't expired, we can't fix it.
*/
if (clp->lc_expiry >= NFSD_MONOSEC ||
- !(NFSD_VNET(nfsrv_stablefirst).nsf_flags & NFSNSF_UPDATEDONE))
+ !(VNET(nfsrv_stablefirst).nsf_flags & NFSNSF_UPDATEDONE))
return (0);
if (*haslockp == 0) {
NFSUNLOCKSTATE();
@@ -5631,7 +5631,7 @@ nfsd_recalldelegation(vnode_t vp, NFSPROC_T *p)
* First, check to see if the server is currently running and it has
* been called for a regular file when issuing delegations.
*/
- if (NFSD_VNET(nfsrv_numnfsd) == 0 || vp->v_type != VREG ||
+ if (VNET(nfsrv_numnfsd) == 0 || vp->v_type != VREG ||
nfsrv_issuedelegs == 0)
return;
@@ -5865,12 +5865,12 @@ nfsrv_throwawayopens(NFSPROC_T *p)
int i;
NFSLOCKSTATE();
- NFSD_VNET(nfsrv_stablefirst).nsf_flags &= ~NFSNSF_NOOPENS;
+ VNET(nfsrv_stablefirst).nsf_flags &= ~NFSNSF_NOOPENS;
/*
* For each client...
*/
for (i = 0; i < nfsrv_clienthashsize; i++) {
- LIST_FOREACH_SAFE(clp, &NFSD_VNET(nfsclienthash)[i], lc_hash,
+ LIST_FOREACH_SAFE(clp, &VNET(nfsclienthash)[i], lc_hash,
nclp) {
LIST_FOREACH_SAFE(stp, &clp->lc_open, ls_list, nstp) {
if (LIST_EMPTY(&stp->ls_open) &&
@@ -5938,7 +5938,7 @@ static time_t
nfsrv_leaseexpiry(void)
{
- if (NFSD_VNET(nfsrv_stablefirst).nsf_eograce > NFSD_MONOSEC)
+ if (VNET(nfsrv_stablefirst).nsf_eograce > NFSD_MONOSEC)
return (NFSD_MONOSEC + 2 * (nfsrv_lease + NFSRV_LEASEDELTA));
return (NFSD_MONOSEC + nfsrv_lease + NFSRV_LEASEDELTA);
}
@@ -6259,7 +6259,7 @@ nfsrv_throwawayallstate(NFSPROC_T *p)
* For each client, clean out the state and then free the structure.
*/
for (i = 0; i < nfsrv_clienthashsize; i++) {
- LIST_FOREACH_SAFE(clp, &NFSD_VNET(nfsclienthash)[i], lc_hash,
+ LIST_FOREACH_SAFE(clp, &VNET(nfsclienthash)[i], lc_hash,
nclp) {
nfsrv_cleanclient(clp, p, false, NULL);
nfsrv_freedeleglist(&clp->lc_deleg);
@@ -6273,7 +6273,7 @@ nfsrv_throwawayallstate(NFSPROC_T *p)
* Also, free up any remaining lock file structures.
*/
for (i = 0; i < nfsrv_lockhashsize; i++) {
- LIST_FOREACH_SAFE(lfp, &NFSD_VNET(nfslockhash)[i], lf_hash,
+ LIST_FOREACH_SAFE(lfp, &VNET(nfslockhash)[i], lf_hash,
nlfp) {
printf("nfsd unload: fnd a lock file struct\n");
nfsrv_freenfslockfile(lfp);
@@ -6402,7 +6402,7 @@ nfsrv_cache_session(struct nfsrv_descript *nd, struct mbuf **m)
sep = nfsrv_findsession(nd->nd_sessionid);
if (sep == NULL) {
NFSUNLOCKSESSION(shp);
- if ((NFSD_VNET(nfsrv_stablefirst).nsf_flags &
+ if ((VNET(nfsrv_stablefirst).nsf_flags &
NFSNSF_GRACEOVER) != 0) {
buf = malloc(INET6_ADDRSTRLEN, M_TEMP, M_WAITOK);
switch (nd->nd_nam->sa_family) {
@@ -6787,7 +6787,7 @@ nfsrv_freeallbackchannel_xprts(void)
int i;
for (i = 0; i < nfsrv_clienthashsize; i++) {
- LIST_FOREACH(clp, &NFSD_VNET(nfsclienthash)[i], lc_hash) {
+ LIST_FOREACH(clp, &VNET(nfsclienthash)[i], lc_hash) {
LIST_FOREACH(sep, &clp->lc_session, sess_list) {
xprt = sep->sess_cbsess.nfsess_xprt;
sep->sess_cbsess.nfsess_xprt = NULL;
@@ -7503,7 +7503,7 @@ nfsrv_addlayout(struct nfsrv_descript *nd, struct nfslayout **lypp,
/* Insert the new layout in the lists. */
*lypp = NULL;
atomic_add_int(&nfsrv_layoutcnt, 1);
- NFSD_VNET(nfsstatsv1_p)->srvlayouts++;
+ VNET(nfsstatsv1_p)->srvlayouts++;
NFSBCOPY(lyp->lay_xdr, layp, lyp->lay_layoutlen);
*layoutlenp = lyp->lay_layoutlen;
TAILQ_INSERT_HEAD(&lhyp->list, lyp, lay_list);
@@ -7596,7 +7596,7 @@ nfsrv_freelayout(struct nfslayouthead *lhp, struct nfslayout *lyp)
NFSD_DEBUG(4, "Freelayout=%p\n", lyp);
atomic_add_int(&nfsrv_layoutcnt, -1);
- NFSD_VNET(nfsstatsv1_p)->srvlayouts--;
+ VNET(nfsstatsv1_p)->srvlayouts--;
TAILQ_REMOVE(lhp, lyp, lay_list);
free(lyp, M_NFSDSTATE);
}
@@ -9035,7 +9035,7 @@ nfsrv_issuedelegation(struct vnode *vp, struct nfsclient *clp,
new_deleg, ls_hash);
LIST_INSERT_HEAD(&clp->lc_deleg, new_deleg, ls_list);
*new_delegp = NULL;
- NFSD_VNET(nfsstatsv1_p)->srvdelegates++;
+ VNET(nfsstatsv1_p)->srvdelegates++;
nfsrv_openpluslock++;
nfsrv_delegatecnt++;
}
diff --git a/sys/fs/nfsserver/nfs_nfsdsubs.c b/sys/fs/nfsserver/nfs_nfsdsubs.c
index f4a934edede3..f7fd81ef4e1e 100644
--- a/sys/fs/nfsserver/nfs_nfsdsubs.c
+++ b/sys/fs/nfsserver/nfs_nfsdsubs.c
@@ -50,12 +50,12 @@ extern int nfsrv_useacl;
extern uid_t nfsrv_defaultuid;
extern gid_t nfsrv_defaultgid;
-NFSD_VNET_DECLARE(struct nfsclienthashhead *, nfsclienthash);
-NFSD_VNET_DECLARE(struct nfslockhashhead *, nfslockhash);
-NFSD_VNET_DECLARE(struct nfssessionhash *, nfssessionhash);
-NFSD_VNET_DECLARE(int, nfs_rootfhset);
-NFSD_VNET_DECLARE(uid_t, nfsrv_defaultuid);
-NFSD_VNET_DECLARE(gid_t, nfsrv_defaultgid);
+VNET_DECLARE(struct nfsclienthashhead *, nfsclienthash);
+VNET_DECLARE(struct nfslockhashhead *, nfslockhash);
+VNET_DECLARE(struct nfssessionhash *, nfssessionhash);
+VNET_DECLARE(int, nfs_rootfhset);
+VNET_DECLARE(uid_t, nfsrv_defaultuid);
+VNET_DECLARE(gid_t, nfsrv_defaultgid);
char nfs_v2pubfh[NFSX_V2FH];
struct nfsdontlisthead nfsrv_dontlisthead;
@@ -1618,10 +1618,10 @@ nfsrv_checkuidgid(struct nfsrv_descript *nd, struct nfsvattr *nvap)
if (NFSVNO_NOTSETUID(nvap) && NFSVNO_NOTSETGID(nvap))
goto out;
if ((NFSVNO_ISSETUID(nvap) &&
- nvap->na_uid == NFSD_VNET(nfsrv_defaultuid) &&
+ nvap->na_uid == VNET(nfsrv_defaultuid) &&
enable_nobodycheck == 1) ||
(NFSVNO_ISSETGID(nvap) &&
- nvap->na_gid == NFSD_VNET(nfsrv_defaultgid) &&
+ nvap->na_gid == VNET(nfsrv_defaultgid) &&
enable_nogroupcheck == 1)) {
error = NFSERR_BADOWNER;
goto out;
@@ -2153,20 +2153,20 @@ nfsd_init(void)
* Initialize client queues. Don't free/reinitialize
* them when nfsds are restarted.
*/
- NFSD_VNET(nfsclienthash) = malloc(sizeof(struct nfsclienthashhead) *
+ VNET(nfsclienthash) = malloc(sizeof(struct nfsclienthashhead) *
nfsrv_clienthashsize, M_NFSDCLIENT, M_WAITOK | M_ZERO);
for (i = 0; i < nfsrv_clienthashsize; i++)
- LIST_INIT(&NFSD_VNET(nfsclienthash)[i]);
- NFSD_VNET(nfslockhash) = malloc(sizeof(struct nfslockhashhead) *
+ LIST_INIT(&VNET(nfsclienthash)[i]);
+ VNET(nfslockhash) = malloc(sizeof(struct nfslockhashhead) *
nfsrv_lockhashsize, M_NFSDLOCKFILE, M_WAITOK | M_ZERO);
for (i = 0; i < nfsrv_lockhashsize; i++)
- LIST_INIT(&NFSD_VNET(nfslockhash)[i]);
- NFSD_VNET(nfssessionhash) = malloc(sizeof(struct nfssessionhash) *
+ LIST_INIT(&VNET(nfslockhash)[i]);
+ VNET(nfssessionhash) = malloc(sizeof(struct nfssessionhash) *
nfsrv_sessionhashsize, M_NFSDSESSION, M_WAITOK | M_ZERO);
for (i = 0; i < nfsrv_sessionhashsize; i++) {
- mtx_init(&NFSD_VNET(nfssessionhash)[i].mtx, "nfssm", NULL,
+ mtx_init(&VNET(nfssessionhash)[i].mtx, "nfssm", NULL,
MTX_DEF);
- LIST_INIT(&NFSD_VNET(nfssessionhash)[i].list);
+ LIST_INIT(&VNET(nfssessionhash)[i].list);
}
LIST_INIT(&nfsrv_dontlisthead);
TAILQ_INIT(&nfsrv_recalllisthead);
@@ -2183,7 +2183,7 @@ int
nfsd_checkrootexp(struct nfsrv_descript *nd)
{
- if (NFSD_VNET(nfs_rootfhset) == 0)
+ if (VNET(nfs_rootfhset) == 0)
return (NFSERR_AUTHERR | AUTH_FAILED);
/*
* For NFSv4.1/4.2, if the client specifies SP4_NONE, then these
generated by cgit v1.3 (git 2.53.0) at 2026-05-14 05:05:12 +0000