kgss: remove KGSS_VNET_* macros family

The original idea was that something else than VNET(9) might be used for
kgss in jails, but that is very unlikely to happen.

Mechanical change done with sed+grep.  No functional change.

Reviewed by:		rmacklem
Differential Revision:	https://reviews.freebsd.org/D56560

sys/kgssapi/gss_delete_sec_context.c

@@ -52,12 +52,12 @@ gss_delete_sec_context(OM_uint32 *minor_status, gss_ctx_id_t *context_handle,
 
 	*minor_status = 0;
 
-	KGSS_CURVNET_SET_QUIET(KGSS_TD_TO_VNET(curthread));
+	CURVNET_SET_QUIET(TD_TO_VNET(curthread));
-	if (!KGSS_VNET(kgss_gssd_handle)) {
+	if (!VNET(kgss_gssd_handle)) {
-		KGSS_CURVNET_RESTORE();
+		CURVNET_RESTORE();
 		return (GSS_S_FAILURE);
 	}
-	KGSS_CURVNET_RESTORE();
+	CURVNET_RESTORE();
 
 	if (*context_handle) {
 		ctx = *context_handle;

sys/kgssapi/gss_impl.c

@@ -52,7 +52,7 @@ MALLOC_DEFINE(M_GSSAPI, "GSS-API", "GSS-API");
 struct kgss_mech_list kgss_mechs;
 struct mtx kgss_gssd_lock;
 
-KGSS_VNET_DEFINE(CLIENT *, kgss_gssd_handle) = NULL;
+VNET_DEFINE(CLIENT *, kgss_gssd_handle) = NULL;
 
 static int
 kgss_load(void)
@@ -79,11 +79,11 @@ kgss_load(void)
 	 */
 	clnt_control(cl, CLSET_WAITCHAN, "gssd");
 
-	KGSS_CURVNET_SET_QUIET(KGSS_TD_TO_VNET(curthread));
+	CURVNET_SET_QUIET(TD_TO_VNET(curthread));
 	mtx_lock(&kgss_gssd_lock);
-	KGSS_VNET(kgss_gssd_handle) = cl;
+	VNET(kgss_gssd_handle) = cl;
 	mtx_unlock(&kgss_gssd_lock);
-	KGSS_CURVNET_RESTORE();
+	CURVNET_RESTORE();
 
 	return (0);
 }
@@ -93,9 +93,9 @@ static void
 kgss_unload(void)
 {
 
-	KGSS_CURVNET_SET_QUIET(KGSS_TD_TO_VNET(curthread));
+	CURVNET_SET_QUIET(TD_TO_VNET(curthread));
-	clnt_destroy(KGSS_VNET(kgss_gssd_handle));
+	clnt_destroy(VNET(kgss_gssd_handle));
-	KGSS_CURVNET_RESTORE();
+	CURVNET_RESTORE();
 }
 #endif
 
@@ -207,16 +207,16 @@ kgss_transfer_context(gss_ctx_id_t ctx, void *lctx)
 		return (maj_stat);
 	}
 
-	KGSS_CURVNET_SET_QUIET(KGSS_TD_TO_VNET(curthread));
+	CURVNET_SET_QUIET(TD_TO_VNET(curthread));
-	if (!KGSS_VNET(kgss_gssd_handle)) {
+	if (!VNET(kgss_gssd_handle)) {
-		KGSS_CURVNET_RESTORE();
+		CURVNET_RESTORE();
 		return (GSS_S_FAILURE);
 	}
 
 	args.ctx = ctx->handle;
 	bzero(&res, sizeof(res));
-	stat = gssd_export_sec_context_1(&args, &res, KGSS_VNET(kgss_gssd_handle));
+	stat = gssd_export_sec_context_1(&args, &res, VNET(kgss_gssd_handle));
-	KGSS_CURVNET_RESTORE();
+	CURVNET_RESTORE();
 	if (stat != RPC_SUCCESS) {
 		return (GSS_S_FAILURE);
 	}
@@ -250,13 +250,13 @@ kgss_gssd_client(void)
 {
 	CLIENT *cl;
 
-	KGSS_CURVNET_SET_QUIET(KGSS_TD_TO_VNET(curthread));
+	CURVNET_SET_QUIET(TD_TO_VNET(curthread));
 	mtx_lock(&kgss_gssd_lock);
-	cl = KGSS_VNET(kgss_gssd_handle);
+	cl = VNET(kgss_gssd_handle);
 	if (cl != NULL)
 		CLNT_ACQUIRE(cl);
 	mtx_unlock(&kgss_gssd_lock);
-	KGSS_CURVNET_RESTORE();
+	CURVNET_RESTORE();
 	return (cl);
 }
 

sys/kgssapi/gss_release_cred.c

@@ -50,12 +50,12 @@ gss_release_cred(OM_uint32 *minor_status, gss_cred_id_t *cred_handle)
 
 	*minor_status = 0;
 
-	KGSS_CURVNET_SET_QUIET(KGSS_TD_TO_VNET(curthread));
+	CURVNET_SET_QUIET(TD_TO_VNET(curthread));
-	if (!KGSS_VNET(kgss_gssd_handle)) {
+	if (!VNET(kgss_gssd_handle)) {
-		KGSS_CURVNET_RESTORE();
+		CURVNET_RESTORE();
 		return (GSS_S_FAILURE);
 	}
-	KGSS_CURVNET_RESTORE();
+	CURVNET_RESTORE();
 
 	if (*cred_handle) {
 		args.cred = (*cred_handle)->handle;

sys/kgssapi/gss_release_name.c

@@ -51,12 +51,12 @@ gss_release_name(OM_uint32 *minor_status, gss_name_t *input_name)
 
 	*minor_status = 0;
 
-	KGSS_CURVNET_SET_QUIET(KGSS_TD_TO_VNET(curthread));
+	CURVNET_SET_QUIET(TD_TO_VNET(curthread));
-	if (!KGSS_VNET(kgss_gssd_handle)) {
+	if (!VNET(kgss_gssd_handle)) {
-		KGSS_CURVNET_RESTORE();
+		CURVNET_RESTORE();
 		return (GSS_S_FAILURE);
 	}
-	KGSS_CURVNET_RESTORE();
+	CURVNET_RESTORE();
 
 	if (*input_name) {
 		name = *input_name;

sys/kgssapi/gssapi_impl.h

@@ -52,22 +52,10 @@ struct kgss_mech {
 };
 LIST_HEAD(kgss_mech_list, kgss_mech);
 
-/* Macros for VIMAGE. */
-/* Just define the KGSS_VNETxxx() macros as VNETxxx() macros. */
-#define	KGSS_VNET_DEFINE(t, n)		VNET_DEFINE(t, n)
-#define	KGSS_VNET_DEFINE_STATIC(t, n)	VNET_DEFINE_STATIC(t, n)
-#define	KGSS_VNET_DECLARE(t, n)		VNET_DECLARE(t, n)
-#define	KGSS_VNET(n)			VNET(n)
-
-#define	KGSS_CURVNET_SET(n)		CURVNET_SET(n)
-#define	KGSS_CURVNET_SET_QUIET(n)	CURVNET_SET_QUIET(n)
-#define	KGSS_CURVNET_RESTORE()		CURVNET_RESTORE()
-#define	KGSS_TD_TO_VNET(n)		TD_TO_VNET(n)
-
 extern struct mtx kgss_gssd_lock;
 extern struct kgss_mech_list kgss_mechs;
 
-KGSS_VNET_DECLARE(CLIENT *, kgss_gssd_handle);
+VNET_DECLARE(CLIENT *, kgss_gssd_handle);
 
 CLIENT *kgss_gssd_client(void);
 int kgss_oid_equal(const gss_OID oid1, const gss_OID oid2);

sys/rpc/rpcsec_gss/rpcsec_gss.c

@@ -783,7 +783,7 @@ rpc_gss_init(AUTH *auth, rpc_gss_options_ret_t *options_ret)
 	 * only option.  This is broken if NFS mounts are enabled
 	 * within vnet prisons.
 	 */
-	KGSS_CURVNET_SET_QUIET(vnet0);
+	CURVNET_SET_QUIET(vnet0);
 	/*
 	 * For KerberosV, if there is a client principal name, that implies
 	 * that this is a host based initiator credential in the default
@@ -1030,14 +1030,14 @@ rpc_gss_init(AUTH *auth, rpc_gss_options_ret_t *options_ret)
 			gss_delete_sec_context(&min_stat, &gd->gd_ctx,
 				GSS_C_NO_BUFFER);
 		}
-		KGSS_CURVNET_RESTORE();
+		CURVNET_RESTORE();
 		mtx_lock(&gd->gd_lock);
 		gd->gd_state = RPCSEC_GSS_START;
 		wakeup(gd);
 		mtx_unlock(&gd->gd_lock);
 		return (FALSE);
 	}
-	KGSS_CURVNET_RESTORE();
+	CURVNET_RESTORE();
 	
 	mtx_lock(&gd->gd_lock);
 	gd->gd_state = RPCSEC_GSS_ESTABLISHED;

sys/rpc/rpcsec_gss/svc_rpcsec_gss.c

@@ -100,7 +100,7 @@ struct svc_rpc_gss_callback {
 	rpc_gss_callback_t	cb_callback;
 };
 SLIST_HEAD(svc_rpc_gss_callback_list, svc_rpc_gss_callback);
-KGSS_VNET_DEFINE_STATIC(struct svc_rpc_gss_callback_list,
+VNET_DEFINE_STATIC(struct svc_rpc_gss_callback_list,
     svc_rpc_gss_callbacks) = SLIST_HEAD_INITIALIZER(svc_rpc_gss_callbacks);
 
 struct svc_rpc_gss_svc_name {
@@ -113,7 +113,7 @@ struct svc_rpc_gss_svc_name {
 	u_int			sn_version;
 };
 SLIST_HEAD(svc_rpc_gss_svc_name_list, svc_rpc_gss_svc_name);
-KGSS_VNET_DEFINE_STATIC(struct svc_rpc_gss_svc_name_list,
+VNET_DEFINE_STATIC(struct svc_rpc_gss_svc_name_list,
     svc_rpc_gss_svc_names) = SLIST_HEAD_INITIALIZER(svc_rpc_gss_svc_names);
 
 enum svc_rpc_gss_client_state {
@@ -195,9 +195,9 @@ SYSCTL_UINT(_kern_rpc_gss, OID_AUTO, client_count, CTLFLAG_RD,
     &svc_rpc_gss_client_count, 0,
     "Number of rpc-gss clients");
 
-KGSS_VNET_DEFINE(struct svc_rpc_gss_client_list *, svc_rpc_gss_client_hash);
+VNET_DEFINE(struct svc_rpc_gss_client_list *, svc_rpc_gss_client_hash);
-KGSS_VNET_DEFINE(struct svc_rpc_gss_client_list, svc_rpc_gss_clients);
+VNET_DEFINE(struct svc_rpc_gss_client_list, svc_rpc_gss_clients);
-KGSS_VNET_DEFINE_STATIC(uint32_t, svc_rpc_gss_next_clientid) = 1;
+VNET_DEFINE_STATIC(uint32_t, svc_rpc_gss_next_clientid) = 1;
 
 static void
 svc_rpc_gss_init(void *unused __unused)
@@ -223,12 +223,12 @@ svc_rpc_gss_vnetinit(void *unused __unused)
 {
 	int i;
 
-	KGSS_VNET(svc_rpc_gss_client_hash) = mem_alloc(
+	VNET(svc_rpc_gss_client_hash) = mem_alloc(
 	    sizeof(struct svc_rpc_gss_client_list) *
 	    svc_rpc_gss_client_hash_size);
 	for (i = 0; i < svc_rpc_gss_client_hash_size; i++)
-		TAILQ_INIT(&KGSS_VNET(svc_rpc_gss_client_hash)[i]);
+		TAILQ_INIT(&VNET(svc_rpc_gss_client_hash)[i]);
-	TAILQ_INIT(&KGSS_VNET(svc_rpc_gss_clients));
+	TAILQ_INIT(&VNET(svc_rpc_gss_clients));
 }
 VNET_SYSINIT(svc_rpc_gss_vnetinit, SI_SUB_VNET_DONE, SI_ORDER_ANY,
     svc_rpc_gss_vnetinit, NULL);
@@ -237,7 +237,7 @@ static void
 svc_rpc_gss_vnet_cleanup(void *unused __unused)
 {
 
-	mem_free(KGSS_VNET(svc_rpc_gss_client_hash),
+	mem_free(VNET(svc_rpc_gss_client_hash),
 	    sizeof(struct svc_rpc_gss_client_list) *
 	    svc_rpc_gss_client_hash_size);
 }
@@ -256,7 +256,7 @@ rpc_gss_set_callback(rpc_gss_callback_t *cb)
 	}
 	scb->cb_callback = *cb;
 	sx_xlock(&svc_rpc_gss_lock);
-	SLIST_INSERT_HEAD(&KGSS_VNET(svc_rpc_gss_callbacks), scb, cb_link);
+	SLIST_INSERT_HEAD(&VNET(svc_rpc_gss_callbacks), scb, cb_link);
 	sx_xunlock(&svc_rpc_gss_lock);
 
 	return (TRUE);
@@ -268,11 +268,11 @@ rpc_gss_clear_callback(rpc_gss_callback_t *cb)
 	struct svc_rpc_gss_callback *scb;
 
 	sx_xlock(&svc_rpc_gss_lock);
-	SLIST_FOREACH(scb, &KGSS_VNET(svc_rpc_gss_callbacks), cb_link) {
+	SLIST_FOREACH(scb, &VNET(svc_rpc_gss_callbacks), cb_link) {
 		if (scb->cb_callback.program == cb->program
 		    && scb->cb_callback.version == cb->version
 		    && scb->cb_callback.callback == cb->callback) {
-			SLIST_REMOVE(&KGSS_VNET(svc_rpc_gss_callbacks), scb,
+			SLIST_REMOVE(&VNET(svc_rpc_gss_callbacks), scb,
 			    svc_rpc_gss_callback, cb_link);
 			sx_xunlock(&svc_rpc_gss_lock);
 			mem_free(scb, sizeof(*scb));
@@ -343,7 +343,7 @@ rpc_gss_set_svc_name(const char *principal, const char *mechanism,
 	}
 
 	sx_xlock(&svc_rpc_gss_lock);
-	SLIST_INSERT_HEAD(&KGSS_VNET(svc_rpc_gss_svc_names), sname, sn_link);
+	SLIST_INSERT_HEAD(&VNET(svc_rpc_gss_svc_names), sname, sn_link);
 	sx_xunlock(&svc_rpc_gss_lock);
 
 	return (TRUE);
@@ -356,10 +356,10 @@ rpc_gss_clear_svc_name(u_int program, u_int version)
 	struct svc_rpc_gss_svc_name *sname;
 
 	sx_xlock(&svc_rpc_gss_lock);
-	SLIST_FOREACH(sname, &KGSS_VNET(svc_rpc_gss_svc_names), sn_link) {
+	SLIST_FOREACH(sname, &VNET(svc_rpc_gss_svc_names), sn_link) {
 		if (sname->sn_program == program
 		    && sname->sn_version == version) {
-			SLIST_REMOVE(&KGSS_VNET(svc_rpc_gss_svc_names), sname,
+			SLIST_REMOVE(&VNET(svc_rpc_gss_svc_names), sname,
 			    svc_rpc_gss_svc_name, sn_link);
 			sx_xunlock(&svc_rpc_gss_lock);
 			gss_release_cred(&min_stat, &sname->sn_cred);
@@ -603,7 +603,7 @@ svc_rpc_gss_find_client(struct svc_rpc_gss_clientid *id)
 	if (id->ci_hostid != hostid || id->ci_boottime != boottime.tv_sec)
 		return (NULL);
 
-	list = &KGSS_VNET(svc_rpc_gss_client_hash)
+	list = &VNET(svc_rpc_gss_client_hash)
 	    [id->ci_id % svc_rpc_gss_client_hash_size];
 	sx_xlock(&svc_rpc_gss_lock);
 	TAILQ_FOREACH(client, list, cl_link) {
@@ -612,9 +612,9 @@ svc_rpc_gss_find_client(struct svc_rpc_gss_clientid *id)
 			 * Move this client to the front of the LRU
 			 * list.
 			 */
-			TAILQ_REMOVE(&KGSS_VNET(svc_rpc_gss_clients), client,
+			TAILQ_REMOVE(&VNET(svc_rpc_gss_clients), client,
 			    cl_alllink);
-			TAILQ_INSERT_HEAD(&KGSS_VNET(svc_rpc_gss_clients),
+			TAILQ_INSERT_HEAD(&VNET(svc_rpc_gss_clients),
 			    client, cl_alllink);
 			refcount_acquire(&client->cl_refs);
 			break;
@@ -648,7 +648,7 @@ svc_rpc_gss_create_client(void)
 	client->cl_id.ci_hostid = hostid;
 	getboottime(&boottime);
 	client->cl_id.ci_boottime = boottime.tv_sec;
-	client->cl_id.ci_id = KGSS_VNET(svc_rpc_gss_next_clientid)++;
+	client->cl_id.ci_id = VNET(svc_rpc_gss_next_clientid)++;
 
 	/*
 	 * Start the client off with a short expiration time. We will
@@ -658,11 +658,11 @@ svc_rpc_gss_create_client(void)
 	client->cl_locked = FALSE;
 	client->cl_expiration = time_uptime + 5*60;
 
-	list = &KGSS_VNET(svc_rpc_gss_client_hash)
+	list = &VNET(svc_rpc_gss_client_hash)
 	    [client->cl_id.ci_id % svc_rpc_gss_client_hash_size];
 	sx_xlock(&svc_rpc_gss_lock);
 	TAILQ_INSERT_HEAD(list, client, cl_link);
-	TAILQ_INSERT_HEAD(&KGSS_VNET(svc_rpc_gss_clients), client, cl_alllink);
+	TAILQ_INSERT_HEAD(&VNET(svc_rpc_gss_clients), client, cl_alllink);
 	svc_rpc_gss_client_count++;
 	sx_xunlock(&svc_rpc_gss_lock);
 	return (client);
@@ -716,10 +716,10 @@ svc_rpc_gss_forget_client_locked(struct svc_rpc_gss_client *client)
 	struct svc_rpc_gss_client_list *list;
 
 	sx_assert(&svc_rpc_gss_lock, SX_XLOCKED);
-	list = &KGSS_VNET(svc_rpc_gss_client_hash)
+	list = &VNET(svc_rpc_gss_client_hash)
 	    [client->cl_id.ci_id % svc_rpc_gss_client_hash_size];
 	TAILQ_REMOVE(list, client, cl_link);
-	TAILQ_REMOVE(&KGSS_VNET(svc_rpc_gss_clients), client, cl_alllink);
+	TAILQ_REMOVE(&VNET(svc_rpc_gss_clients), client, cl_alllink);
 	svc_rpc_gss_client_count--;
 }
 
@@ -732,7 +732,7 @@ svc_rpc_gss_forget_client(struct svc_rpc_gss_client *client)
 	struct svc_rpc_gss_client_list *list;
 	struct svc_rpc_gss_client *tclient;
 
-	list = &KGSS_VNET(svc_rpc_gss_client_hash)
+	list = &VNET(svc_rpc_gss_client_hash)
 	    [client->cl_id.ci_id % svc_rpc_gss_client_hash_size];
 	sx_xlock(&svc_rpc_gss_lock);
 	TAILQ_FOREACH(tclient, list, cl_link) {
@@ -764,18 +764,18 @@ svc_rpc_gss_timeout_clients(void)
 	 * svc_rpc_gss_clients in LRU order.
 	 */
 	sx_xlock(&svc_rpc_gss_lock);
-	client = TAILQ_LAST(&KGSS_VNET(svc_rpc_gss_clients),
+	client = TAILQ_LAST(&VNET(svc_rpc_gss_clients),
 	    svc_rpc_gss_client_list);
 	while (svc_rpc_gss_client_count > svc_rpc_gss_client_max && client != NULL) {
 		svc_rpc_gss_forget_client_locked(client);
 		sx_xunlock(&svc_rpc_gss_lock);
 		svc_rpc_gss_release_client(client);
 		sx_xlock(&svc_rpc_gss_lock);
-		client = TAILQ_LAST(&KGSS_VNET(svc_rpc_gss_clients),
+		client = TAILQ_LAST(&VNET(svc_rpc_gss_clients),
 		    svc_rpc_gss_client_list);
 	}
 again:
-	TAILQ_FOREACH(client, &KGSS_VNET(svc_rpc_gss_clients), cl_alllink) {
+	TAILQ_FOREACH(client, &VNET(svc_rpc_gss_clients), cl_alllink) {
 		if (client->cl_state == CLIENT_STALE
 		    || now > client->cl_expiration) {
 			svc_rpc_gss_forget_client_locked(client);
@@ -964,7 +964,7 @@ svc_rpc_gss_accept_sec_context(struct svc_rpc_gss_client *client,
 	 */
 	sx_xlock(&svc_rpc_gss_lock);
 	if (!client->cl_sname) {
-		SLIST_FOREACH(sname, &KGSS_VNET(svc_rpc_gss_svc_names),
+		SLIST_FOREACH(sname, &VNET(svc_rpc_gss_svc_names),
 		    sn_link) {
 			if (sname->sn_program == rqst->rq_prog
 			    && sname->sn_version == rqst->rq_vers) {
@@ -1271,7 +1271,7 @@ svc_rpc_gss_callback(struct svc_rpc_gss_client *client, struct svc_req *rqst)
 	 * See if we have a callback for this guy.
 	 */
 	result = TRUE;
-	SLIST_FOREACH(scb, &KGSS_VNET(svc_rpc_gss_callbacks), cb_link) {
+	SLIST_FOREACH(scb, &VNET(svc_rpc_gss_callbacks), cb_link) {
 		if (scb->cb_callback.program == rqst->rq_prog
 		    && scb->cb_callback.version == rqst->rq_vers) {
 			/*
@@ -1407,7 +1407,7 @@ svc_rpc_gss(struct svc_req *rqst, struct rpc_msg *msg)
 	int			 call_stat;
 	enum auth_stat		 result;
 	
-	KGSS_CURVNET_SET_QUIET(KGSS_TD_TO_VNET(curthread));
+	CURVNET_SET_QUIET(TD_TO_VNET(curthread));
 	rpc_gss_log_debug("in svc_rpc_gss()");
 	
 	/* Garbage collect old clients. */
@@ -1418,7 +1418,7 @@ svc_rpc_gss(struct svc_req *rqst, struct rpc_msg *msg)
 
 	/* Deserialize client credentials. */
 	if (rqst->rq_cred.oa_length <= 0) {
-		KGSS_CURVNET_RESTORE();
+		CURVNET_RESTORE();
 		return (AUTH_BADCRED);
 	}
 	
@@ -1429,7 +1429,7 @@ svc_rpc_gss(struct svc_req *rqst, struct rpc_msg *msg)
 	
 	if (!xdr_rpc_gss_cred(&xdrs, &gc)) {
 		XDR_DESTROY(&xdrs);
-		KGSS_CURVNET_RESTORE();
+		CURVNET_RESTORE();
 		return (AUTH_BADCRED);
 	}
 	XDR_DESTROY(&xdrs);
@@ -1665,7 +1665,7 @@ svc_rpc_gss(struct svc_req *rqst, struct rpc_msg *msg)
 		svc_rpc_gss_release_client(client);
 
 	xdr_free((xdrproc_t) xdr_rpc_gss_cred, (char *) &gc);
-	KGSS_CURVNET_RESTORE();
+	CURVNET_RESTORE();
 	return (result);
 }