aboutsummaryrefslogtreecommitdiff
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
parent050b3ff753e04ce142ac751a0d76b5ee3beda9c5 (diff)
nfsd: Get rid of NFSD_VNET macros
When the nfsd was vnet'd, the VNET macros were hidden behind macros that had the NFSD_ prefix on them. This was done because, at the time, it was thought that something other than vnet might be used for this. That has not happened and probably will not happen, so this patch replaces these obscuring macros with the regular vnet ones. There should be no semantics change caused by this commit. Discussed with: bz, glebius MFC after: 1 month
Diffstat
-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.2.3 (git 2.25.1) at 2026-05-19 03:15:13 +0000