Thomas Gleixner | 457c899 | 2019-05-19 13:08:55 +0100 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0-only |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | /* |
| 3 | * linux/net/sunrpc/auth.c |
| 4 | * |
| 5 | * Generic RPC client authentication API. |
| 6 | * |
| 7 | * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de> |
| 8 | */ |
| 9 | |
| 10 | #include <linux/types.h> |
| 11 | #include <linux/sched.h> |
Ingo Molnar | 5b825c3 | 2017-02-02 17:54:15 +0100 | [diff] [blame] | 12 | #include <linux/cred.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | #include <linux/module.h> |
| 14 | #include <linux/slab.h> |
| 15 | #include <linux/errno.h> |
Trond Myklebust | 25337fd | 2008-03-12 14:40:14 -0400 | [diff] [blame] | 16 | #include <linux/hash.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | #include <linux/sunrpc/clnt.h> |
Chuck Lever | 6a1a1e3 | 2012-07-11 16:31:08 -0400 | [diff] [blame] | 18 | #include <linux/sunrpc/gss_api.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | #include <linux/spinlock.h> |
| 20 | |
Chuck Lever | a0584ee | 2019-02-11 11:24:58 -0500 | [diff] [blame] | 21 | #include <trace/events/sunrpc.h> |
| 22 | |
Trond Myklebust | 241269b | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 23 | #define RPC_CREDCACHE_DEFAULT_HASHBITS (4) |
| 24 | struct rpc_cred_cache { |
| 25 | struct hlist_head *hashtable; |
| 26 | unsigned int hashbits; |
| 27 | spinlock_t lock; |
| 28 | }; |
| 29 | |
| 30 | static unsigned int auth_hashbits = RPC_CREDCACHE_DEFAULT_HASHBITS; |
| 31 | |
Trond Myklebust | 4e4c3be | 2018-09-27 13:12:44 -0400 | [diff] [blame] | 32 | static const struct rpc_authops __rcu *auth_flavors[RPC_AUTH_MAXFLAVOR] = { |
| 33 | [RPC_AUTH_NULL] = (const struct rpc_authops __force __rcu *)&authnull_ops, |
| 34 | [RPC_AUTH_UNIX] = (const struct rpc_authops __force __rcu *)&authunix_ops, |
Chuck Lever | 1207265 | 2023-06-07 09:58:04 -0400 | [diff] [blame] | 35 | [RPC_AUTH_TLS] = (const struct rpc_authops __force __rcu *)&authtls_ops, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 36 | }; |
| 37 | |
Trond Myklebust | e092bdc | 2007-06-23 19:45:36 -0400 | [diff] [blame] | 38 | static LIST_HEAD(cred_unused); |
Trond Myklebust | f5c2187 | 2007-06-25 17:11:20 -0400 | [diff] [blame] | 39 | static unsigned long number_cred_unused; |
Trond Myklebust | e092bdc | 2007-06-23 19:45:36 -0400 | [diff] [blame] | 40 | |
NeilBrown | a52458b | 2018-12-03 11:30:31 +1100 | [diff] [blame] | 41 | static struct cred machine_cred = { |
| 42 | .usage = ATOMIC_INIT(1), |
NeilBrown | 5e16923 | 2018-12-03 11:30:30 +1100 | [diff] [blame] | 43 | }; |
| 44 | |
| 45 | /* |
| 46 | * Return the machine_cred pointer to be used whenever |
| 47 | * the a generic machine credential is needed. |
| 48 | */ |
NeilBrown | a52458b | 2018-12-03 11:30:31 +1100 | [diff] [blame] | 49 | const struct cred *rpc_machine_cred(void) |
NeilBrown | 5e16923 | 2018-12-03 11:30:30 +1100 | [diff] [blame] | 50 | { |
| 51 | return &machine_cred; |
| 52 | } |
| 53 | EXPORT_SYMBOL_GPL(rpc_machine_cred); |
| 54 | |
Miquel van Smoorenburg | db5fe26 | 2010-09-12 19:55:26 -0400 | [diff] [blame] | 55 | #define MAX_HASHTABLE_BITS (14) |
Stephen Rothwell | 8e4e15d | 2010-08-04 12:11:22 +1000 | [diff] [blame] | 56 | static int param_set_hashtbl_sz(const char *val, const struct kernel_param *kp) |
Trond Myklebust | 241269b | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 57 | { |
| 58 | unsigned long num; |
| 59 | unsigned int nbits; |
| 60 | int ret; |
| 61 | |
| 62 | if (!val) |
| 63 | goto out_inval; |
Daniel Walter | 00cfaa9 | 2014-06-21 13:06:38 +0100 | [diff] [blame] | 64 | ret = kstrtoul(val, 0, &num); |
Dan Carpenter | 1a54c0c | 2018-07-12 15:30:08 +0300 | [diff] [blame] | 65 | if (ret) |
Trond Myklebust | 241269b | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 66 | goto out_inval; |
Frank Sorenson | 34ae685 | 2016-06-27 15:17:19 -0400 | [diff] [blame] | 67 | nbits = fls(num - 1); |
Trond Myklebust | 241269b | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 68 | if (nbits > MAX_HASHTABLE_BITS || nbits < 2) |
| 69 | goto out_inval; |
| 70 | *(unsigned int *)kp->arg = nbits; |
| 71 | return 0; |
| 72 | out_inval: |
| 73 | return -EINVAL; |
| 74 | } |
| 75 | |
Stephen Rothwell | 8e4e15d | 2010-08-04 12:11:22 +1000 | [diff] [blame] | 76 | static int param_get_hashtbl_sz(char *buffer, const struct kernel_param *kp) |
Trond Myklebust | 241269b | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 77 | { |
| 78 | unsigned int nbits; |
| 79 | |
| 80 | nbits = *(unsigned int *)kp->arg; |
Xiongfeng Wang | 2ac3ddc | 2020-05-08 09:33:00 +0800 | [diff] [blame] | 81 | return sprintf(buffer, "%u\n", 1U << nbits); |
Trond Myklebust | 241269b | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 82 | } |
| 83 | |
| 84 | #define param_check_hashtbl_sz(name, p) __param_check(name, p, unsigned int); |
| 85 | |
Luis R. Rodriguez | 9c27847 | 2015-05-27 11:09:38 +0930 | [diff] [blame] | 86 | static const struct kernel_param_ops param_ops_hashtbl_sz = { |
Stephen Rothwell | 8e4e15d | 2010-08-04 12:11:22 +1000 | [diff] [blame] | 87 | .set = param_set_hashtbl_sz, |
| 88 | .get = param_get_hashtbl_sz, |
| 89 | }; |
| 90 | |
Trond Myklebust | 241269b | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 91 | module_param_named(auth_hashtable_size, auth_hashbits, hashtbl_sz, 0644); |
| 92 | MODULE_PARM_DESC(auth_hashtable_size, "RPC credential cache hashtable size"); |
| 93 | |
Trond Myklebust | bae6746 | 2014-07-21 13:32:42 -0400 | [diff] [blame] | 94 | static unsigned long auth_max_cred_cachesize = ULONG_MAX; |
| 95 | module_param(auth_max_cred_cachesize, ulong, 0644); |
| 96 | MODULE_PARM_DESC(auth_max_cred_cachesize, "RPC credential maximum total cache size"); |
| 97 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | static u32 |
| 99 | pseudoflavor_to_flavor(u32 flavor) { |
Chuck Lever | 1c74a24 | 2013-03-22 12:53:08 -0400 | [diff] [blame] | 100 | if (flavor > RPC_AUTH_MAXFLAVOR) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | return RPC_AUTH_GSS; |
| 102 | return flavor; |
| 103 | } |
| 104 | |
| 105 | int |
Trond Myklebust | f1c0a861 | 2007-06-23 20:17:58 -0400 | [diff] [blame] | 106 | rpcauth_register(const struct rpc_authops *ops) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | { |
Trond Myklebust | 4e4c3be | 2018-09-27 13:12:44 -0400 | [diff] [blame] | 108 | const struct rpc_authops *old; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | rpc_authflavor_t flavor; |
| 110 | |
| 111 | if ((flavor = ops->au_flavor) >= RPC_AUTH_MAXFLAVOR) |
| 112 | return -EINVAL; |
Trond Myklebust | 4e4c3be | 2018-09-27 13:12:44 -0400 | [diff] [blame] | 113 | old = cmpxchg((const struct rpc_authops ** __force)&auth_flavors[flavor], NULL, ops); |
| 114 | if (old == NULL || old == ops) |
| 115 | return 0; |
| 116 | return -EPERM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | } |
Trond Myklebust | e8914c6 | 2007-07-14 15:39:59 -0400 | [diff] [blame] | 118 | EXPORT_SYMBOL_GPL(rpcauth_register); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 119 | |
| 120 | int |
Trond Myklebust | f1c0a861 | 2007-06-23 20:17:58 -0400 | [diff] [blame] | 121 | rpcauth_unregister(const struct rpc_authops *ops) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 122 | { |
Trond Myklebust | 4e4c3be | 2018-09-27 13:12:44 -0400 | [diff] [blame] | 123 | const struct rpc_authops *old; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 124 | rpc_authflavor_t flavor; |
| 125 | |
| 126 | if ((flavor = ops->au_flavor) >= RPC_AUTH_MAXFLAVOR) |
| 127 | return -EINVAL; |
Trond Myklebust | 4e4c3be | 2018-09-27 13:12:44 -0400 | [diff] [blame] | 128 | |
| 129 | old = cmpxchg((const struct rpc_authops ** __force)&auth_flavors[flavor], ops, NULL); |
| 130 | if (old == ops || old == NULL) |
| 131 | return 0; |
| 132 | return -EPERM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 133 | } |
Trond Myklebust | e8914c6 | 2007-07-14 15:39:59 -0400 | [diff] [blame] | 134 | EXPORT_SYMBOL_GPL(rpcauth_unregister); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 135 | |
Trond Myklebust | 4e4c3be | 2018-09-27 13:12:44 -0400 | [diff] [blame] | 136 | static const struct rpc_authops * |
| 137 | rpcauth_get_authops(rpc_authflavor_t flavor) |
| 138 | { |
| 139 | const struct rpc_authops *ops; |
| 140 | |
| 141 | if (flavor >= RPC_AUTH_MAXFLAVOR) |
| 142 | return NULL; |
| 143 | |
| 144 | rcu_read_lock(); |
| 145 | ops = rcu_dereference(auth_flavors[flavor]); |
| 146 | if (ops == NULL) { |
| 147 | rcu_read_unlock(); |
| 148 | request_module("rpc-auth-%u", flavor); |
| 149 | rcu_read_lock(); |
| 150 | ops = rcu_dereference(auth_flavors[flavor]); |
| 151 | if (ops == NULL) |
| 152 | goto out; |
| 153 | } |
| 154 | if (!try_module_get(ops->owner)) |
| 155 | ops = NULL; |
| 156 | out: |
| 157 | rcu_read_unlock(); |
| 158 | return ops; |
| 159 | } |
| 160 | |
| 161 | static void |
| 162 | rpcauth_put_authops(const struct rpc_authops *ops) |
| 163 | { |
| 164 | module_put(ops->owner); |
| 165 | } |
| 166 | |
Chuck Lever | 6a1a1e3 | 2012-07-11 16:31:08 -0400 | [diff] [blame] | 167 | /** |
Chuck Lever | 9568c5e | 2013-03-16 15:54:43 -0400 | [diff] [blame] | 168 | * rpcauth_get_pseudoflavor - check if security flavor is supported |
| 169 | * @flavor: a security flavor |
| 170 | * @info: a GSS mech OID, quality of protection, and service value |
| 171 | * |
| 172 | * Verifies that an appropriate kernel module is available or already loaded. |
| 173 | * Returns an equivalent pseudoflavor, or RPC_AUTH_MAXFLAVOR if "flavor" is |
| 174 | * not supported locally. |
| 175 | */ |
| 176 | rpc_authflavor_t |
| 177 | rpcauth_get_pseudoflavor(rpc_authflavor_t flavor, struct rpcsec_gss_info *info) |
| 178 | { |
Trond Myklebust | 4e4c3be | 2018-09-27 13:12:44 -0400 | [diff] [blame] | 179 | const struct rpc_authops *ops = rpcauth_get_authops(flavor); |
Chuck Lever | 9568c5e | 2013-03-16 15:54:43 -0400 | [diff] [blame] | 180 | rpc_authflavor_t pseudoflavor; |
| 181 | |
Trond Myklebust | 4e4c3be | 2018-09-27 13:12:44 -0400 | [diff] [blame] | 182 | if (!ops) |
Chuck Lever | 9568c5e | 2013-03-16 15:54:43 -0400 | [diff] [blame] | 183 | return RPC_AUTH_MAXFLAVOR; |
Chuck Lever | 9568c5e | 2013-03-16 15:54:43 -0400 | [diff] [blame] | 184 | pseudoflavor = flavor; |
| 185 | if (ops->info2flavor != NULL) |
| 186 | pseudoflavor = ops->info2flavor(info); |
| 187 | |
Trond Myklebust | 4e4c3be | 2018-09-27 13:12:44 -0400 | [diff] [blame] | 188 | rpcauth_put_authops(ops); |
Chuck Lever | 9568c5e | 2013-03-16 15:54:43 -0400 | [diff] [blame] | 189 | return pseudoflavor; |
| 190 | } |
| 191 | EXPORT_SYMBOL_GPL(rpcauth_get_pseudoflavor); |
| 192 | |
| 193 | /** |
Chuck Lever | a77c806 | 2013-03-16 15:55:10 -0400 | [diff] [blame] | 194 | * rpcauth_get_gssinfo - find GSS tuple matching a GSS pseudoflavor |
| 195 | * @pseudoflavor: GSS pseudoflavor to match |
| 196 | * @info: rpcsec_gss_info structure to fill in |
| 197 | * |
| 198 | * Returns zero and fills in "info" if pseudoflavor matches a |
| 199 | * supported mechanism. |
| 200 | */ |
| 201 | int |
| 202 | rpcauth_get_gssinfo(rpc_authflavor_t pseudoflavor, struct rpcsec_gss_info *info) |
| 203 | { |
| 204 | rpc_authflavor_t flavor = pseudoflavor_to_flavor(pseudoflavor); |
| 205 | const struct rpc_authops *ops; |
| 206 | int result; |
| 207 | |
Trond Myklebust | 4e4c3be | 2018-09-27 13:12:44 -0400 | [diff] [blame] | 208 | ops = rpcauth_get_authops(flavor); |
Chuck Lever | a77c806 | 2013-03-16 15:55:10 -0400 | [diff] [blame] | 209 | if (ops == NULL) |
Chuck Lever | a77c806 | 2013-03-16 15:55:10 -0400 | [diff] [blame] | 210 | return -ENOENT; |
Chuck Lever | a77c806 | 2013-03-16 15:55:10 -0400 | [diff] [blame] | 211 | |
| 212 | result = -ENOENT; |
| 213 | if (ops->flavor2info != NULL) |
| 214 | result = ops->flavor2info(pseudoflavor, info); |
| 215 | |
Trond Myklebust | 4e4c3be | 2018-09-27 13:12:44 -0400 | [diff] [blame] | 216 | rpcauth_put_authops(ops); |
Chuck Lever | a77c806 | 2013-03-16 15:55:10 -0400 | [diff] [blame] | 217 | return result; |
| 218 | } |
| 219 | EXPORT_SYMBOL_GPL(rpcauth_get_gssinfo); |
| 220 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 221 | struct rpc_auth * |
Sargun Dhillon | 82b98ca | 2018-07-05 16:48:50 +0000 | [diff] [blame] | 222 | rpcauth_create(const struct rpc_auth_create_args *args, struct rpc_clnt *clnt) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 223 | { |
Trond Myklebust | 4e4c3be | 2018-09-27 13:12:44 -0400 | [diff] [blame] | 224 | struct rpc_auth *auth = ERR_PTR(-EINVAL); |
Trond Myklebust | f1c0a861 | 2007-06-23 20:17:58 -0400 | [diff] [blame] | 225 | const struct rpc_authops *ops; |
Trond Myklebust | 4e4c3be | 2018-09-27 13:12:44 -0400 | [diff] [blame] | 226 | u32 flavor = pseudoflavor_to_flavor(args->pseudoflavor); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 227 | |
Trond Myklebust | 4e4c3be | 2018-09-27 13:12:44 -0400 | [diff] [blame] | 228 | ops = rpcauth_get_authops(flavor); |
| 229 | if (ops == NULL) |
Olaf Kirch | f344f6d | 2006-03-20 13:44:08 -0500 | [diff] [blame] | 230 | goto out; |
| 231 | |
Trond Myklebust | c219066 | 2013-08-26 19:23:04 -0400 | [diff] [blame] | 232 | auth = ops->create(args, clnt); |
Trond Myklebust | 4e4c3be | 2018-09-27 13:12:44 -0400 | [diff] [blame] | 233 | |
| 234 | rpcauth_put_authops(ops); |
J. Bruce Fields | 6a19275 | 2005-06-22 17:16:23 +0000 | [diff] [blame] | 235 | if (IS_ERR(auth)) |
| 236 | return auth; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 237 | if (clnt->cl_auth) |
Trond Myklebust | de7a8ce | 2007-06-23 10:46:47 -0400 | [diff] [blame] | 238 | rpcauth_release(clnt->cl_auth); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 239 | clnt->cl_auth = auth; |
Olaf Kirch | f344f6d | 2006-03-20 13:44:08 -0500 | [diff] [blame] | 240 | |
| 241 | out: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 242 | return auth; |
| 243 | } |
Trond Myklebust | e8914c6 | 2007-07-14 15:39:59 -0400 | [diff] [blame] | 244 | EXPORT_SYMBOL_GPL(rpcauth_create); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 245 | |
| 246 | void |
Trond Myklebust | de7a8ce | 2007-06-23 10:46:47 -0400 | [diff] [blame] | 247 | rpcauth_release(struct rpc_auth *auth) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 248 | { |
Trond Myklebust | 331bc71 | 2018-10-14 10:40:29 -0400 | [diff] [blame] | 249 | if (!refcount_dec_and_test(&auth->au_count)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 250 | return; |
| 251 | auth->au_ops->destroy(auth); |
| 252 | } |
| 253 | |
| 254 | static DEFINE_SPINLOCK(rpc_credcache_lock); |
| 255 | |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 256 | /* |
| 257 | * On success, the caller is responsible for freeing the reference |
| 258 | * held by the hashtable |
| 259 | */ |
| 260 | static bool |
Trond Myklebust | 31be5bf | 2007-06-24 15:55:26 -0400 | [diff] [blame] | 261 | rpcauth_unhash_cred_locked(struct rpc_cred *cred) |
| 262 | { |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 263 | if (!test_and_clear_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags)) |
| 264 | return false; |
Trond Myklebust | 31be5bf | 2007-06-24 15:55:26 -0400 | [diff] [blame] | 265 | hlist_del_rcu(&cred->cr_hash); |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 266 | return true; |
Trond Myklebust | 31be5bf | 2007-06-24 15:55:26 -0400 | [diff] [blame] | 267 | } |
| 268 | |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 269 | static bool |
Trond Myklebust | 9499b43 | 2007-06-24 15:57:57 -0400 | [diff] [blame] | 270 | rpcauth_unhash_cred(struct rpc_cred *cred) |
| 271 | { |
| 272 | spinlock_t *cache_lock; |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 273 | bool ret; |
Trond Myklebust | 9499b43 | 2007-06-24 15:57:57 -0400 | [diff] [blame] | 274 | |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 275 | if (!test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags)) |
| 276 | return false; |
Trond Myklebust | 9499b43 | 2007-06-24 15:57:57 -0400 | [diff] [blame] | 277 | cache_lock = &cred->cr_auth->au_credcache->lock; |
| 278 | spin_lock(cache_lock); |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 279 | ret = rpcauth_unhash_cred_locked(cred); |
Trond Myklebust | 9499b43 | 2007-06-24 15:57:57 -0400 | [diff] [blame] | 280 | spin_unlock(cache_lock); |
Trond Myklebust | f0380f3 | 2009-12-03 08:10:17 -0500 | [diff] [blame] | 281 | return ret; |
Trond Myklebust | 9499b43 | 2007-06-24 15:57:57 -0400 | [diff] [blame] | 282 | } |
| 283 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 284 | /* |
| 285 | * Initialize RPC credential cache |
| 286 | */ |
| 287 | int |
Trond Myklebust | f5c2187 | 2007-06-25 17:11:20 -0400 | [diff] [blame] | 288 | rpcauth_init_credcache(struct rpc_auth *auth) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 289 | { |
| 290 | struct rpc_cred_cache *new; |
Trond Myklebust | 988664a | 2010-07-31 14:29:07 -0400 | [diff] [blame] | 291 | unsigned int hashsize; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 292 | |
Kris Katterjohn | 8b3a700 | 2006-01-11 15:56:43 -0800 | [diff] [blame] | 293 | new = kmalloc(sizeof(*new), GFP_KERNEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 294 | if (!new) |
Trond Myklebust | 241269b | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 295 | goto out_nocache; |
| 296 | new->hashbits = auth_hashbits; |
Trond Myklebust | 988664a | 2010-07-31 14:29:07 -0400 | [diff] [blame] | 297 | hashsize = 1U << new->hashbits; |
Trond Myklebust | 241269b | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 298 | new->hashtable = kcalloc(hashsize, sizeof(new->hashtable[0]), GFP_KERNEL); |
| 299 | if (!new->hashtable) |
| 300 | goto out_nohashtbl; |
Trond Myklebust | 9499b43 | 2007-06-24 15:57:57 -0400 | [diff] [blame] | 301 | spin_lock_init(&new->lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 302 | auth->au_credcache = new; |
| 303 | return 0; |
Trond Myklebust | 241269b | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 304 | out_nohashtbl: |
| 305 | kfree(new); |
| 306 | out_nocache: |
| 307 | return -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 308 | } |
Trond Myklebust | e8914c6 | 2007-07-14 15:39:59 -0400 | [diff] [blame] | 309 | EXPORT_SYMBOL_GPL(rpcauth_init_credcache); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 310 | |
Jeff Layton | a0337d1 | 2014-06-21 20:52:16 -0400 | [diff] [blame] | 311 | char * |
| 312 | rpcauth_stringify_acceptor(struct rpc_cred *cred) |
| 313 | { |
| 314 | if (!cred->cr_ops->crstringify_acceptor) |
| 315 | return NULL; |
| 316 | return cred->cr_ops->crstringify_acceptor(cred); |
| 317 | } |
| 318 | EXPORT_SYMBOL_GPL(rpcauth_stringify_acceptor); |
| 319 | |
Andy Adamson | 4de6caa | 2013-08-14 11:59:15 -0400 | [diff] [blame] | 320 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 321 | * Destroy a list of credentials |
| 322 | */ |
| 323 | static inline |
Trond Myklebust | e092bdc | 2007-06-23 19:45:36 -0400 | [diff] [blame] | 324 | void rpcauth_destroy_credlist(struct list_head *head) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 325 | { |
| 326 | struct rpc_cred *cred; |
| 327 | |
Trond Myklebust | e092bdc | 2007-06-23 19:45:36 -0400 | [diff] [blame] | 328 | while (!list_empty(head)) { |
| 329 | cred = list_entry(head->next, struct rpc_cred, cr_lru); |
| 330 | list_del_init(&cred->cr_lru); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 331 | put_rpccred(cred); |
| 332 | } |
| 333 | } |
| 334 | |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 335 | static void |
| 336 | rpcauth_lru_add_locked(struct rpc_cred *cred) |
| 337 | { |
| 338 | if (!list_empty(&cred->cr_lru)) |
| 339 | return; |
| 340 | number_cred_unused++; |
| 341 | list_add_tail(&cred->cr_lru, &cred_unused); |
| 342 | } |
| 343 | |
| 344 | static void |
| 345 | rpcauth_lru_add(struct rpc_cred *cred) |
| 346 | { |
| 347 | if (!list_empty(&cred->cr_lru)) |
| 348 | return; |
| 349 | spin_lock(&rpc_credcache_lock); |
| 350 | rpcauth_lru_add_locked(cred); |
| 351 | spin_unlock(&rpc_credcache_lock); |
| 352 | } |
| 353 | |
| 354 | static void |
| 355 | rpcauth_lru_remove_locked(struct rpc_cred *cred) |
| 356 | { |
| 357 | if (list_empty(&cred->cr_lru)) |
| 358 | return; |
| 359 | number_cred_unused--; |
| 360 | list_del_init(&cred->cr_lru); |
| 361 | } |
| 362 | |
| 363 | static void |
| 364 | rpcauth_lru_remove(struct rpc_cred *cred) |
| 365 | { |
| 366 | if (list_empty(&cred->cr_lru)) |
| 367 | return; |
| 368 | spin_lock(&rpc_credcache_lock); |
| 369 | rpcauth_lru_remove_locked(cred); |
| 370 | spin_unlock(&rpc_credcache_lock); |
| 371 | } |
| 372 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 373 | /* |
| 374 | * Clear the RPC credential cache, and delete those credentials |
| 375 | * that are not referenced. |
| 376 | */ |
| 377 | void |
Trond Myklebust | 3ab9bb7 | 2007-06-09 15:41:42 -0400 | [diff] [blame] | 378 | rpcauth_clear_credcache(struct rpc_cred_cache *cache) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 379 | { |
Trond Myklebust | e092bdc | 2007-06-23 19:45:36 -0400 | [diff] [blame] | 380 | LIST_HEAD(free); |
| 381 | struct hlist_head *head; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 382 | struct rpc_cred *cred; |
Trond Myklebust | 988664a | 2010-07-31 14:29:07 -0400 | [diff] [blame] | 383 | unsigned int hashsize = 1U << cache->hashbits; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 384 | int i; |
| 385 | |
| 386 | spin_lock(&rpc_credcache_lock); |
Trond Myklebust | 9499b43 | 2007-06-24 15:57:57 -0400 | [diff] [blame] | 387 | spin_lock(&cache->lock); |
Trond Myklebust | 988664a | 2010-07-31 14:29:07 -0400 | [diff] [blame] | 388 | for (i = 0; i < hashsize; i++) { |
Trond Myklebust | e092bdc | 2007-06-23 19:45:36 -0400 | [diff] [blame] | 389 | head = &cache->hashtable[i]; |
| 390 | while (!hlist_empty(head)) { |
| 391 | cred = hlist_entry(head->first, struct rpc_cred, cr_hash); |
Trond Myklebust | 31be5bf | 2007-06-24 15:55:26 -0400 | [diff] [blame] | 392 | rpcauth_unhash_cred_locked(cred); |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 393 | /* Note: We now hold a reference to cred */ |
| 394 | rpcauth_lru_remove_locked(cred); |
| 395 | list_add_tail(&cred->cr_lru, &free); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 396 | } |
| 397 | } |
Trond Myklebust | 9499b43 | 2007-06-24 15:57:57 -0400 | [diff] [blame] | 398 | spin_unlock(&cache->lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 399 | spin_unlock(&rpc_credcache_lock); |
| 400 | rpcauth_destroy_credlist(&free); |
| 401 | } |
| 402 | |
Trond Myklebust | 3ab9bb7 | 2007-06-09 15:41:42 -0400 | [diff] [blame] | 403 | /* |
| 404 | * Destroy the RPC credential cache |
| 405 | */ |
| 406 | void |
| 407 | rpcauth_destroy_credcache(struct rpc_auth *auth) |
| 408 | { |
| 409 | struct rpc_cred_cache *cache = auth->au_credcache; |
| 410 | |
| 411 | if (cache) { |
| 412 | auth->au_credcache = NULL; |
| 413 | rpcauth_clear_credcache(cache); |
Trond Myklebust | 241269b | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 414 | kfree(cache->hashtable); |
Trond Myklebust | 3ab9bb7 | 2007-06-09 15:41:42 -0400 | [diff] [blame] | 415 | kfree(cache); |
| 416 | } |
| 417 | } |
Trond Myklebust | e8914c6 | 2007-07-14 15:39:59 -0400 | [diff] [blame] | 418 | EXPORT_SYMBOL_GPL(rpcauth_destroy_credcache); |
Trond Myklebust | 3ab9bb7 | 2007-06-09 15:41:42 -0400 | [diff] [blame] | 419 | |
Trond Myklebust | d2b8314 | 2008-04-14 18:13:37 -0400 | [diff] [blame] | 420 | |
| 421 | #define RPC_AUTH_EXPIRY_MORATORIUM (60 * HZ) |
| 422 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 423 | /* |
| 424 | * Remove stale credentials. Avoid sleeping inside the loop. |
| 425 | */ |
Dave Chinner | 70534a7 | 2013-08-28 10:18:14 +1000 | [diff] [blame] | 426 | static long |
Trond Myklebust | f5c2187 | 2007-06-25 17:11:20 -0400 | [diff] [blame] | 427 | rpcauth_prune_expired(struct list_head *free, int nr_to_scan) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 428 | { |
Trond Myklebust | eac0d18 | 2008-10-28 15:21:41 -0400 | [diff] [blame] | 429 | struct rpc_cred *cred, *next; |
Trond Myklebust | d2b8314 | 2008-04-14 18:13:37 -0400 | [diff] [blame] | 430 | unsigned long expired = jiffies - RPC_AUTH_EXPIRY_MORATORIUM; |
Dave Chinner | 70534a7 | 2013-08-28 10:18:14 +1000 | [diff] [blame] | 431 | long freed = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 432 | |
Trond Myklebust | eac0d18 | 2008-10-28 15:21:41 -0400 | [diff] [blame] | 433 | list_for_each_entry_safe(cred, next, &cred_unused, cr_lru) { |
| 434 | |
Trond Myklebust | 2067340 | 2010-05-13 12:51:06 -0400 | [diff] [blame] | 435 | if (nr_to_scan-- == 0) |
| 436 | break; |
Trond Myklebust | 79b1818 | 2018-10-14 10:34:31 -0400 | [diff] [blame] | 437 | if (refcount_read(&cred->cr_count) > 1) { |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 438 | rpcauth_lru_remove_locked(cred); |
| 439 | continue; |
| 440 | } |
Trond Myklebust | 93a05e6 | 2010-05-13 12:51:06 -0400 | [diff] [blame] | 441 | /* |
| 442 | * Enforce a 60 second garbage collection moratorium |
| 443 | * Note that the cred_unused list must be time-ordered. |
| 444 | */ |
Dan Aloni | f1bafa7 | 2022-07-04 15:56:57 +0300 | [diff] [blame] | 445 | if (time_in_range(cred->cr_expire, expired, jiffies)) |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 446 | continue; |
| 447 | if (!rpcauth_unhash_cred(cred)) |
Trond Myklebust | e092bdc | 2007-06-23 19:45:36 -0400 | [diff] [blame] | 448 | continue; |
Trond Myklebust | eac0d18 | 2008-10-28 15:21:41 -0400 | [diff] [blame] | 449 | |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 450 | rpcauth_lru_remove_locked(cred); |
| 451 | freed++; |
| 452 | list_add_tail(&cred->cr_lru, free); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 453 | } |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 454 | return freed ? freed : SHRINK_STOP; |
Trond Myklebust | e092bdc | 2007-06-23 19:45:36 -0400 | [diff] [blame] | 455 | } |
| 456 | |
Trond Myklebust | bae6746 | 2014-07-21 13:32:42 -0400 | [diff] [blame] | 457 | static unsigned long |
| 458 | rpcauth_cache_do_shrink(int nr_to_scan) |
| 459 | { |
| 460 | LIST_HEAD(free); |
| 461 | unsigned long freed; |
| 462 | |
| 463 | spin_lock(&rpc_credcache_lock); |
| 464 | freed = rpcauth_prune_expired(&free, nr_to_scan); |
| 465 | spin_unlock(&rpc_credcache_lock); |
| 466 | rpcauth_destroy_credlist(&free); |
| 467 | |
| 468 | return freed; |
| 469 | } |
| 470 | |
Trond Myklebust | e092bdc | 2007-06-23 19:45:36 -0400 | [diff] [blame] | 471 | /* |
Trond Myklebust | f5c2187 | 2007-06-25 17:11:20 -0400 | [diff] [blame] | 472 | * Run memory cache shrinker. |
Trond Myklebust | e092bdc | 2007-06-23 19:45:36 -0400 | [diff] [blame] | 473 | */ |
Dave Chinner | 70534a7 | 2013-08-28 10:18:14 +1000 | [diff] [blame] | 474 | static unsigned long |
| 475 | rpcauth_cache_shrink_scan(struct shrinker *shrink, struct shrink_control *sc) |
| 476 | |
Trond Myklebust | e092bdc | 2007-06-23 19:45:36 -0400 | [diff] [blame] | 477 | { |
Dave Chinner | 70534a7 | 2013-08-28 10:18:14 +1000 | [diff] [blame] | 478 | if ((sc->gfp_mask & GFP_KERNEL) != GFP_KERNEL) |
| 479 | return SHRINK_STOP; |
| 480 | |
| 481 | /* nothing left, don't come back */ |
Trond Myklebust | f5c2187 | 2007-06-25 17:11:20 -0400 | [diff] [blame] | 482 | if (list_empty(&cred_unused)) |
Dave Chinner | 70534a7 | 2013-08-28 10:18:14 +1000 | [diff] [blame] | 483 | return SHRINK_STOP; |
| 484 | |
Trond Myklebust | bae6746 | 2014-07-21 13:32:42 -0400 | [diff] [blame] | 485 | return rpcauth_cache_do_shrink(sc->nr_to_scan); |
Dave Chinner | 70534a7 | 2013-08-28 10:18:14 +1000 | [diff] [blame] | 486 | } |
| 487 | |
| 488 | static unsigned long |
| 489 | rpcauth_cache_shrink_count(struct shrinker *shrink, struct shrink_control *sc) |
| 490 | |
| 491 | { |
NeilBrown | 4c3ffd0 | 2017-01-06 14:19:58 +1100 | [diff] [blame] | 492 | return number_cred_unused * sysctl_vfs_cache_pressure / 100; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 493 | } |
| 494 | |
Trond Myklebust | bae6746 | 2014-07-21 13:32:42 -0400 | [diff] [blame] | 495 | static void |
| 496 | rpcauth_cache_enforce_limit(void) |
| 497 | { |
| 498 | unsigned long diff; |
| 499 | unsigned int nr_to_scan; |
| 500 | |
| 501 | if (number_cred_unused <= auth_max_cred_cachesize) |
| 502 | return; |
| 503 | diff = number_cred_unused - auth_max_cred_cachesize; |
| 504 | nr_to_scan = 100; |
| 505 | if (diff < nr_to_scan) |
| 506 | nr_to_scan = diff; |
| 507 | rpcauth_cache_do_shrink(nr_to_scan); |
| 508 | } |
| 509 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 510 | /* |
| 511 | * Look up a process' credentials in the authentication cache |
| 512 | */ |
| 513 | struct rpc_cred * |
| 514 | rpcauth_lookup_credcache(struct rpc_auth *auth, struct auth_cred * acred, |
Jeff Layton | 3c6e0bc | 2016-04-21 20:51:54 -0400 | [diff] [blame] | 515 | int flags, gfp_t gfp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 516 | { |
Trond Myklebust | e092bdc | 2007-06-23 19:45:36 -0400 | [diff] [blame] | 517 | LIST_HEAD(free); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 518 | struct rpc_cred_cache *cache = auth->au_credcache; |
Trond Myklebust | 31be5bf | 2007-06-24 15:55:26 -0400 | [diff] [blame] | 519 | struct rpc_cred *cred = NULL, |
| 520 | *entry, *new; |
Trond Myklebust | 25337fd | 2008-03-12 14:40:14 -0400 | [diff] [blame] | 521 | unsigned int nr; |
| 522 | |
Frank Sorenson | 66cbd4b | 2016-09-29 10:44:41 -0500 | [diff] [blame] | 523 | nr = auth->au_ops->hash_cred(acred, cache->hashbits); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 524 | |
Trond Myklebust | 31be5bf | 2007-06-24 15:55:26 -0400 | [diff] [blame] | 525 | rcu_read_lock(); |
Sasha Levin | b67bfe0 | 2013-02-27 17:06:00 -0800 | [diff] [blame] | 526 | hlist_for_each_entry_rcu(entry, &cache->hashtable[nr], cr_hash) { |
Trond Myklebust | 31be5bf | 2007-06-24 15:55:26 -0400 | [diff] [blame] | 527 | if (!entry->cr_ops->crmatch(acred, entry, flags)) |
| 528 | continue; |
Trond Myklebust | 31be5bf | 2007-06-24 15:55:26 -0400 | [diff] [blame] | 529 | cred = get_rpccred(entry); |
Trond Myklebust | 07d02a6 | 2018-10-12 13:28:26 -0400 | [diff] [blame] | 530 | if (cred) |
| 531 | break; |
Trond Myklebust | 31be5bf | 2007-06-24 15:55:26 -0400 | [diff] [blame] | 532 | } |
| 533 | rcu_read_unlock(); |
| 534 | |
Trond Myklebust | 9499b43 | 2007-06-24 15:57:57 -0400 | [diff] [blame] | 535 | if (cred != NULL) |
Trond Myklebust | 31be5bf | 2007-06-24 15:55:26 -0400 | [diff] [blame] | 536 | goto found; |
Trond Myklebust | 31be5bf | 2007-06-24 15:55:26 -0400 | [diff] [blame] | 537 | |
Jeff Layton | 3c6e0bc | 2016-04-21 20:51:54 -0400 | [diff] [blame] | 538 | new = auth->au_ops->crcreate(auth, acred, flags, gfp); |
Trond Myklebust | 31be5bf | 2007-06-24 15:55:26 -0400 | [diff] [blame] | 539 | if (IS_ERR(new)) { |
| 540 | cred = new; |
| 541 | goto out; |
| 542 | } |
| 543 | |
Trond Myklebust | 9499b43 | 2007-06-24 15:57:57 -0400 | [diff] [blame] | 544 | spin_lock(&cache->lock); |
Sasha Levin | b67bfe0 | 2013-02-27 17:06:00 -0800 | [diff] [blame] | 545 | hlist_for_each_entry(entry, &cache->hashtable[nr], cr_hash) { |
Trond Myklebust | e092bdc | 2007-06-23 19:45:36 -0400 | [diff] [blame] | 546 | if (!entry->cr_ops->crmatch(acred, entry, flags)) |
| 547 | continue; |
| 548 | cred = get_rpccred(entry); |
Trond Myklebust | 07d02a6 | 2018-10-12 13:28:26 -0400 | [diff] [blame] | 549 | if (cred) |
| 550 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 551 | } |
Trond Myklebust | 31be5bf | 2007-06-24 15:55:26 -0400 | [diff] [blame] | 552 | if (cred == NULL) { |
Trond Myklebust | 5fe4755 | 2007-06-23 19:55:31 -0400 | [diff] [blame] | 553 | cred = new; |
Trond Myklebust | 31be5bf | 2007-06-24 15:55:26 -0400 | [diff] [blame] | 554 | set_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags); |
Trond Myklebust | 79b1818 | 2018-10-14 10:34:31 -0400 | [diff] [blame] | 555 | refcount_inc(&cred->cr_count); |
Trond Myklebust | 31be5bf | 2007-06-24 15:55:26 -0400 | [diff] [blame] | 556 | hlist_add_head_rcu(&cred->cr_hash, &cache->hashtable[nr]); |
| 557 | } else |
| 558 | list_add_tail(&new->cr_lru, &free); |
Trond Myklebust | 9499b43 | 2007-06-24 15:57:57 -0400 | [diff] [blame] | 559 | spin_unlock(&cache->lock); |
Trond Myklebust | bae6746 | 2014-07-21 13:32:42 -0400 | [diff] [blame] | 560 | rpcauth_cache_enforce_limit(); |
Trond Myklebust | 31be5bf | 2007-06-24 15:55:26 -0400 | [diff] [blame] | 561 | found: |
Joe Perches | f64f9e7 | 2009-11-29 16:55:45 -0800 | [diff] [blame] | 562 | if (test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags) && |
| 563 | cred->cr_ops->cr_init != NULL && |
| 564 | !(flags & RPCAUTH_LOOKUP_NEW)) { |
Trond Myklebust | fba3bad | 2006-02-01 12:19:27 -0500 | [diff] [blame] | 565 | int res = cred->cr_ops->cr_init(auth, cred); |
| 566 | if (res < 0) { |
| 567 | put_rpccred(cred); |
| 568 | cred = ERR_PTR(res); |
| 569 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 570 | } |
Trond Myklebust | 31be5bf | 2007-06-24 15:55:26 -0400 | [diff] [blame] | 571 | rpcauth_destroy_credlist(&free); |
| 572 | out: |
| 573 | return cred; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 574 | } |
Trond Myklebust | e8914c6 | 2007-07-14 15:39:59 -0400 | [diff] [blame] | 575 | EXPORT_SYMBOL_GPL(rpcauth_lookup_credcache); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 576 | |
| 577 | struct rpc_cred * |
Trond Myklebust | 8a31776 | 2006-02-01 12:18:36 -0500 | [diff] [blame] | 578 | rpcauth_lookupcred(struct rpc_auth *auth, int flags) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 579 | { |
David Howells | 86a264a | 2008-11-14 10:39:18 +1100 | [diff] [blame] | 580 | struct auth_cred acred; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 581 | struct rpc_cred *ret; |
David Howells | 86a264a | 2008-11-14 10:39:18 +1100 | [diff] [blame] | 582 | const struct cred *cred = current_cred(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 583 | |
David Howells | 86a264a | 2008-11-14 10:39:18 +1100 | [diff] [blame] | 584 | memset(&acred, 0, sizeof(acred)); |
NeilBrown | 97f68c6b | 2018-12-03 11:30:30 +1100 | [diff] [blame] | 585 | acred.cred = cred; |
Trond Myklebust | 8a31776 | 2006-02-01 12:18:36 -0500 | [diff] [blame] | 586 | ret = auth->au_ops->lookup_cred(auth, &acred, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 587 | return ret; |
| 588 | } |
Andy Adamson | 66b0686 | 2014-06-12 15:02:32 -0400 | [diff] [blame] | 589 | EXPORT_SYMBOL_GPL(rpcauth_lookupcred); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 590 | |
Trond Myklebust | 5fe4755 | 2007-06-23 19:55:31 -0400 | [diff] [blame] | 591 | void |
| 592 | rpcauth_init_cred(struct rpc_cred *cred, const struct auth_cred *acred, |
| 593 | struct rpc_auth *auth, const struct rpc_credops *ops) |
| 594 | { |
| 595 | INIT_HLIST_NODE(&cred->cr_hash); |
Trond Myklebust | e092bdc | 2007-06-23 19:45:36 -0400 | [diff] [blame] | 596 | INIT_LIST_HEAD(&cred->cr_lru); |
Trond Myklebust | 79b1818 | 2018-10-14 10:34:31 -0400 | [diff] [blame] | 597 | refcount_set(&cred->cr_count, 1); |
Trond Myklebust | 5fe4755 | 2007-06-23 19:55:31 -0400 | [diff] [blame] | 598 | cred->cr_auth = auth; |
NeilBrown | 2edd8d7 | 2018-12-03 11:30:31 +1100 | [diff] [blame] | 599 | cred->cr_flags = 0; |
Trond Myklebust | 5fe4755 | 2007-06-23 19:55:31 -0400 | [diff] [blame] | 600 | cred->cr_ops = ops; |
| 601 | cred->cr_expire = jiffies; |
NeilBrown | 97f68c6b | 2018-12-03 11:30:30 +1100 | [diff] [blame] | 602 | cred->cr_cred = get_cred(acred->cred); |
Trond Myklebust | 5fe4755 | 2007-06-23 19:55:31 -0400 | [diff] [blame] | 603 | } |
Trond Myklebust | e8914c6 | 2007-07-14 15:39:59 -0400 | [diff] [blame] | 604 | EXPORT_SYMBOL_GPL(rpcauth_init_cred); |
Trond Myklebust | 5fe4755 | 2007-06-23 19:55:31 -0400 | [diff] [blame] | 605 | |
Trond Myklebust | 8572b8e | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 606 | static struct rpc_cred * |
Trond Myklebust | 5d35175 | 2009-09-15 13:32:13 -0400 | [diff] [blame] | 607 | rpcauth_bind_root_cred(struct rpc_task *task, int lookupflags) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 608 | { |
Trond Myklebust | 1be27f3 | 2007-06-27 14:29:04 -0400 | [diff] [blame] | 609 | struct rpc_auth *auth = task->tk_client->cl_auth; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 610 | struct auth_cred acred = { |
NeilBrown | 97f68c6b | 2018-12-03 11:30:30 +1100 | [diff] [blame] | 611 | .cred = get_task_cred(&init_task), |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 612 | }; |
NeilBrown | 97f68c6b | 2018-12-03 11:30:30 +1100 | [diff] [blame] | 613 | struct rpc_cred *ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 614 | |
NeilBrown | a41b05e | 2022-03-07 10:41:44 +1100 | [diff] [blame] | 615 | if (RPC_IS_ASYNC(task)) |
| 616 | lookupflags |= RPCAUTH_LOOKUP_ASYNC; |
NeilBrown | 97f68c6b | 2018-12-03 11:30:30 +1100 | [diff] [blame] | 617 | ret = auth->au_ops->lookup_cred(auth, &acred, lookupflags); |
| 618 | put_cred(acred.cred); |
| 619 | return ret; |
Trond Myklebust | af09383 | 2008-03-12 12:12:16 -0400 | [diff] [blame] | 620 | } |
| 621 | |
Trond Myklebust | 8572b8e | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 622 | static struct rpc_cred * |
NeilBrown | 5e16923 | 2018-12-03 11:30:30 +1100 | [diff] [blame] | 623 | rpcauth_bind_machine_cred(struct rpc_task *task, int lookupflags) |
| 624 | { |
| 625 | struct rpc_auth *auth = task->tk_client->cl_auth; |
| 626 | struct auth_cred acred = { |
| 627 | .principal = task->tk_client->cl_principal, |
| 628 | .cred = init_task.cred, |
| 629 | }; |
| 630 | |
| 631 | if (!acred.principal) |
| 632 | return NULL; |
NeilBrown | a41b05e | 2022-03-07 10:41:44 +1100 | [diff] [blame] | 633 | if (RPC_IS_ASYNC(task)) |
| 634 | lookupflags |= RPCAUTH_LOOKUP_ASYNC; |
NeilBrown | 5e16923 | 2018-12-03 11:30:30 +1100 | [diff] [blame] | 635 | return auth->au_ops->lookup_cred(auth, &acred, lookupflags); |
| 636 | } |
| 637 | |
| 638 | static struct rpc_cred * |
Trond Myklebust | 5d35175 | 2009-09-15 13:32:13 -0400 | [diff] [blame] | 639 | rpcauth_bind_new_cred(struct rpc_task *task, int lookupflags) |
Trond Myklebust | af09383 | 2008-03-12 12:12:16 -0400 | [diff] [blame] | 640 | { |
| 641 | struct rpc_auth *auth = task->tk_client->cl_auth; |
Trond Myklebust | af09383 | 2008-03-12 12:12:16 -0400 | [diff] [blame] | 642 | |
Trond Myklebust | 8572b8e | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 643 | return rpcauth_lookupcred(auth, lookupflags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 644 | } |
| 645 | |
Trond Myklebust | a17c215 | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 646 | static int |
NeilBrown | a52458b | 2018-12-03 11:30:31 +1100 | [diff] [blame] | 647 | rpcauth_bindcred(struct rpc_task *task, const struct cred *cred, int flags) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 648 | { |
Trond Myklebust | a17c215 | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 649 | struct rpc_rqst *req = task->tk_rqstp; |
NeilBrown | 5e16923 | 2018-12-03 11:30:30 +1100 | [diff] [blame] | 650 | struct rpc_cred *new = NULL; |
Trond Myklebust | 5d35175 | 2009-09-15 13:32:13 -0400 | [diff] [blame] | 651 | int lookupflags = 0; |
NeilBrown | a52458b | 2018-12-03 11:30:31 +1100 | [diff] [blame] | 652 | struct rpc_auth *auth = task->tk_client->cl_auth; |
| 653 | struct auth_cred acred = { |
| 654 | .cred = cred, |
| 655 | }; |
Trond Myklebust | 5d35175 | 2009-09-15 13:32:13 -0400 | [diff] [blame] | 656 | |
| 657 | if (flags & RPC_TASK_ASYNC) |
NeilBrown | a41b05e | 2022-03-07 10:41:44 +1100 | [diff] [blame] | 658 | lookupflags |= RPCAUTH_LOOKUP_NEW | RPCAUTH_LOOKUP_ASYNC; |
NeilBrown | 1de7eea | 2018-12-03 11:30:30 +1100 | [diff] [blame] | 659 | if (task->tk_op_cred) |
| 660 | /* Task must use exactly this rpc_cred */ |
NeilBrown | d6efccd | 2018-12-03 11:30:31 +1100 | [diff] [blame] | 661 | new = get_rpccred(task->tk_op_cred); |
NeilBrown | 1de7eea | 2018-12-03 11:30:30 +1100 | [diff] [blame] | 662 | else if (cred != NULL && cred != &machine_cred) |
NeilBrown | a52458b | 2018-12-03 11:30:31 +1100 | [diff] [blame] | 663 | new = auth->au_ops->lookup_cred(auth, &acred, lookupflags); |
NeilBrown | 5e16923 | 2018-12-03 11:30:30 +1100 | [diff] [blame] | 664 | else if (cred == &machine_cred) |
| 665 | new = rpcauth_bind_machine_cred(task, lookupflags); |
| 666 | |
| 667 | /* If machine cred couldn't be bound, try a root cred */ |
| 668 | if (new) |
| 669 | ; |
NeilBrown | 89c2be8 | 2022-03-07 10:41:44 +1100 | [diff] [blame] | 670 | else if (cred == &machine_cred) |
Trond Myklebust | 8572b8e | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 671 | new = rpcauth_bind_root_cred(task, lookupflags); |
NeilBrown | a68a72e | 2018-12-03 11:30:30 +1100 | [diff] [blame] | 672 | else if (flags & RPC_TASK_NULLCREDS) |
| 673 | new = authnull_ops.lookup_cred(NULL, NULL, 0); |
Trond Myklebust | 4ccda2c | 2008-03-12 16:20:55 -0400 | [diff] [blame] | 674 | else |
Trond Myklebust | 8572b8e | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 675 | new = rpcauth_bind_new_cred(task, lookupflags); |
| 676 | if (IS_ERR(new)) |
| 677 | return PTR_ERR(new); |
Trond Myklebust | 9a8f6b5 | 2016-05-16 17:42:42 -0400 | [diff] [blame] | 678 | put_rpccred(req->rq_cred); |
Trond Myklebust | a17c215 | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 679 | req->rq_cred = new; |
Trond Myklebust | 8572b8e | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 680 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 681 | } |
| 682 | |
| 683 | void |
| 684 | put_rpccred(struct rpc_cred *cred) |
| 685 | { |
Trond Myklebust | 9a8f6b5 | 2016-05-16 17:42:42 -0400 | [diff] [blame] | 686 | if (cred == NULL) |
| 687 | return; |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 688 | rcu_read_lock(); |
Trond Myklebust | 79b1818 | 2018-10-14 10:34:31 -0400 | [diff] [blame] | 689 | if (refcount_dec_and_test(&cred->cr_count)) |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 690 | goto destroy; |
Trond Myklebust | 79b1818 | 2018-10-14 10:34:31 -0400 | [diff] [blame] | 691 | if (refcount_read(&cred->cr_count) != 1 || |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 692 | !test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags)) |
| 693 | goto out; |
| 694 | if (test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) != 0) { |
| 695 | cred->cr_expire = jiffies; |
| 696 | rpcauth_lru_add(cred); |
| 697 | /* Race breaker */ |
| 698 | if (unlikely(!test_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags))) |
| 699 | rpcauth_lru_remove(cred); |
| 700 | } else if (rpcauth_unhash_cred(cred)) { |
| 701 | rpcauth_lru_remove(cred); |
Trond Myklebust | 79b1818 | 2018-10-14 10:34:31 -0400 | [diff] [blame] | 702 | if (refcount_dec_and_test(&cred->cr_count)) |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 703 | goto destroy; |
Trond Myklebust | f0380f3 | 2009-12-03 08:10:17 -0500 | [diff] [blame] | 704 | } |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 705 | out: |
| 706 | rcu_read_unlock(); |
Trond Myklebust | f0380f3 | 2009-12-03 08:10:17 -0500 | [diff] [blame] | 707 | return; |
Trond Myklebust | 95cd623 | 2018-10-11 16:11:09 -0400 | [diff] [blame] | 708 | destroy: |
| 709 | rcu_read_unlock(); |
| 710 | cred->cr_ops->crdestroy(cred); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 711 | } |
Trond Myklebust | e8914c6 | 2007-07-14 15:39:59 -0400 | [diff] [blame] | 712 | EXPORT_SYMBOL_GPL(put_rpccred); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 713 | |
Chuck Lever | e8680a2 | 2019-02-11 11:24:48 -0500 | [diff] [blame] | 714 | /** |
| 715 | * rpcauth_marshcred - Append RPC credential to end of @xdr |
| 716 | * @task: controlling RPC task |
| 717 | * @xdr: xdr_stream containing initial portion of RPC Call header |
| 718 | * |
| 719 | * On success, an appropriate verifier is added to @xdr, @xdr is |
| 720 | * updated to point past the verifier, and zero is returned. |
| 721 | * Otherwise, @xdr is in an undefined state and a negative errno |
| 722 | * is returned. |
| 723 | */ |
| 724 | int rpcauth_marshcred(struct rpc_task *task, struct xdr_stream *xdr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 725 | { |
Chuck Lever | e8680a2 | 2019-02-11 11:24:48 -0500 | [diff] [blame] | 726 | const struct rpc_credops *ops = task->tk_rqstp->rq_cred->cr_ops; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 727 | |
Chuck Lever | e8680a2 | 2019-02-11 11:24:48 -0500 | [diff] [blame] | 728 | return ops->crmarshal(task, xdr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 729 | } |
| 730 | |
Chuck Lever | e8680a2 | 2019-02-11 11:24:48 -0500 | [diff] [blame] | 731 | /** |
| 732 | * rpcauth_wrap_req_encode - XDR encode the RPC procedure |
| 733 | * @task: controlling RPC task |
| 734 | * @xdr: stream where on-the-wire bytes are to be marshalled |
| 735 | * |
| 736 | * On success, @xdr contains the encoded and wrapped message. |
| 737 | * Otherwise, @xdr is in an undefined state. |
| 738 | */ |
| 739 | int rpcauth_wrap_req_encode(struct rpc_task *task, struct xdr_stream *xdr) |
Chuck Lever | 9f06c71 | 2010-12-14 14:59:18 +0000 | [diff] [blame] | 740 | { |
Chuck Lever | e8680a2 | 2019-02-11 11:24:48 -0500 | [diff] [blame] | 741 | kxdreproc_t encode = task->tk_msg.rpc_proc->p_encode; |
Chuck Lever | 9f06c71 | 2010-12-14 14:59:18 +0000 | [diff] [blame] | 742 | |
Chuck Lever | e8680a2 | 2019-02-11 11:24:48 -0500 | [diff] [blame] | 743 | encode(task->tk_rqstp, xdr, task->tk_msg.rpc_argp); |
Chuck Lever | 9f06c71 | 2010-12-14 14:59:18 +0000 | [diff] [blame] | 744 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 745 | } |
Chuck Lever | e8680a2 | 2019-02-11 11:24:48 -0500 | [diff] [blame] | 746 | EXPORT_SYMBOL_GPL(rpcauth_wrap_req_encode); |
| 747 | |
| 748 | /** |
| 749 | * rpcauth_wrap_req - XDR encode and wrap the RPC procedure |
| 750 | * @task: controlling RPC task |
| 751 | * @xdr: stream where on-the-wire bytes are to be marshalled |
| 752 | * |
| 753 | * On success, @xdr contains the encoded and wrapped message, |
| 754 | * and zero is returned. Otherwise, @xdr is in an undefined |
| 755 | * state and a negative errno is returned. |
| 756 | */ |
| 757 | int rpcauth_wrap_req(struct rpc_task *task, struct xdr_stream *xdr) |
| 758 | { |
| 759 | const struct rpc_credops *ops = task->tk_rqstp->rq_cred->cr_ops; |
| 760 | |
| 761 | return ops->crwrap_req(task, xdr); |
| 762 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 763 | |
Chuck Lever | a0584ee | 2019-02-11 11:24:58 -0500 | [diff] [blame] | 764 | /** |
| 765 | * rpcauth_checkverf - Validate verifier in RPC Reply header |
| 766 | * @task: controlling RPC task |
| 767 | * @xdr: xdr_stream containing RPC Reply header |
| 768 | * |
Chuck Lever | 5623ecf | 2023-09-06 16:05:26 -0400 | [diff] [blame] | 769 | * Return values: |
| 770 | * %0: Verifier is valid. @xdr now points past the verifier. |
| 771 | * %-EIO: Verifier is corrupted or message ended early. |
| 772 | * %-EACCES: Verifier is intact but not valid. |
| 773 | * %-EPROTONOSUPPORT: Server does not support the requested auth type. |
| 774 | * |
| 775 | * When a negative errno is returned, @xdr is left in an undefined |
| 776 | * state. |
Chuck Lever | a0584ee | 2019-02-11 11:24:58 -0500 | [diff] [blame] | 777 | */ |
| 778 | int |
| 779 | rpcauth_checkverf(struct rpc_task *task, struct xdr_stream *xdr) |
Chuck Lever | bf26955 | 2010-12-14 14:59:29 +0000 | [diff] [blame] | 780 | { |
Chuck Lever | a0584ee | 2019-02-11 11:24:58 -0500 | [diff] [blame] | 781 | const struct rpc_credops *ops = task->tk_rqstp->rq_cred->cr_ops; |
Chuck Lever | bf26955 | 2010-12-14 14:59:29 +0000 | [diff] [blame] | 782 | |
Chuck Lever | a0584ee | 2019-02-11 11:24:58 -0500 | [diff] [blame] | 783 | return ops->crvalidate(task, xdr); |
Chuck Lever | bf26955 | 2010-12-14 14:59:29 +0000 | [diff] [blame] | 784 | } |
| 785 | |
Chuck Lever | a0584ee | 2019-02-11 11:24:58 -0500 | [diff] [blame] | 786 | /** |
| 787 | * rpcauth_unwrap_resp_decode - Invoke XDR decode function |
| 788 | * @task: controlling RPC task |
| 789 | * @xdr: stream where the Reply message resides |
| 790 | * |
| 791 | * Returns zero on success; otherwise a negative errno is returned. |
| 792 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 793 | int |
Chuck Lever | a0584ee | 2019-02-11 11:24:58 -0500 | [diff] [blame] | 794 | rpcauth_unwrap_resp_decode(struct rpc_task *task, struct xdr_stream *xdr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 795 | { |
Chuck Lever | a0584ee | 2019-02-11 11:24:58 -0500 | [diff] [blame] | 796 | kxdrdproc_t decode = task->tk_msg.rpc_proc->p_decode; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 797 | |
Chuck Lever | a0584ee | 2019-02-11 11:24:58 -0500 | [diff] [blame] | 798 | return decode(task->tk_rqstp, xdr, task->tk_msg.rpc_resp); |
| 799 | } |
| 800 | EXPORT_SYMBOL_GPL(rpcauth_unwrap_resp_decode); |
| 801 | |
| 802 | /** |
| 803 | * rpcauth_unwrap_resp - Invoke unwrap and decode function for the cred |
| 804 | * @task: controlling RPC task |
| 805 | * @xdr: stream where the Reply message resides |
| 806 | * |
| 807 | * Returns zero on success; otherwise a negative errno is returned. |
| 808 | */ |
| 809 | int |
| 810 | rpcauth_unwrap_resp(struct rpc_task *task, struct xdr_stream *xdr) |
| 811 | { |
| 812 | const struct rpc_credops *ops = task->tk_rqstp->rq_cred->cr_ops; |
| 813 | |
| 814 | return ops->crunwrap_resp(task, xdr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 815 | } |
| 816 | |
Trond Myklebust | 3021a5bb | 2018-08-14 13:50:21 -0400 | [diff] [blame] | 817 | bool |
| 818 | rpcauth_xmit_need_reencode(struct rpc_task *task) |
| 819 | { |
| 820 | struct rpc_cred *cred = task->tk_rqstp->rq_cred; |
| 821 | |
| 822 | if (!cred || !cred->cr_ops->crneed_reencode) |
| 823 | return false; |
| 824 | return cred->cr_ops->crneed_reencode(task); |
| 825 | } |
| 826 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 827 | int |
| 828 | rpcauth_refreshcred(struct rpc_task *task) |
| 829 | { |
Trond Myklebust | 9a84d38 | 2010-10-24 18:00:46 -0400 | [diff] [blame] | 830 | struct rpc_cred *cred; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 831 | int err; |
| 832 | |
Trond Myklebust | a17c215 | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 833 | cred = task->tk_rqstp->rq_cred; |
| 834 | if (cred == NULL) { |
| 835 | err = rpcauth_bindcred(task, task->tk_msg.rpc_cred, task->tk_flags); |
| 836 | if (err < 0) |
| 837 | goto out; |
| 838 | cred = task->tk_rqstp->rq_cred; |
Joe Perches | f81c622 | 2011-06-03 11:51:19 +0000 | [diff] [blame] | 839 | } |
Chuck Lever | 0bbacc4 | 2005-11-01 16:53:32 -0500 | [diff] [blame] | 840 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 841 | err = cred->cr_ops->crrefresh(task); |
Trond Myklebust | a17c215 | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 842 | out: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 843 | if (err < 0) |
| 844 | task->tk_status = err; |
| 845 | return err; |
| 846 | } |
| 847 | |
| 848 | void |
| 849 | rpcauth_invalcred(struct rpc_task *task) |
| 850 | { |
Trond Myklebust | a17c215 | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 851 | struct rpc_cred *cred = task->tk_rqstp->rq_cred; |
Trond Myklebust | fc432dd | 2007-06-25 10:15:15 -0400 | [diff] [blame] | 852 | |
Trond Myklebust | fc432dd | 2007-06-25 10:15:15 -0400 | [diff] [blame] | 853 | if (cred) |
| 854 | clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 855 | } |
| 856 | |
| 857 | int |
| 858 | rpcauth_uptodatecred(struct rpc_task *task) |
| 859 | { |
Trond Myklebust | a17c215 | 2010-07-31 14:29:08 -0400 | [diff] [blame] | 860 | struct rpc_cred *cred = task->tk_rqstp->rq_cred; |
Trond Myklebust | fc432dd | 2007-06-25 10:15:15 -0400 | [diff] [blame] | 861 | |
| 862 | return cred == NULL || |
| 863 | test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) != 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 864 | } |
Trond Myklebust | f5c2187 | 2007-06-25 17:11:20 -0400 | [diff] [blame] | 865 | |
Qi Zheng | abe0c26 | 2023-09-11 17:44:17 +0800 | [diff] [blame] | 866 | static struct shrinker *rpc_cred_shrinker; |
Trond Myklebust | f5c2187 | 2007-06-25 17:11:20 -0400 | [diff] [blame] | 867 | |
Trond Myklebust | 5d8d9a4 | 2010-07-31 14:29:07 -0400 | [diff] [blame] | 868 | int __init rpcauth_init_module(void) |
Trond Myklebust | f5c2187 | 2007-06-25 17:11:20 -0400 | [diff] [blame] | 869 | { |
Trond Myklebust | 5d8d9a4 | 2010-07-31 14:29:07 -0400 | [diff] [blame] | 870 | int err; |
| 871 | |
| 872 | err = rpc_init_authunix(); |
| 873 | if (err < 0) |
| 874 | goto out1; |
Qi Zheng | abe0c26 | 2023-09-11 17:44:17 +0800 | [diff] [blame] | 875 | rpc_cred_shrinker = shrinker_alloc(0, "sunrpc_cred"); |
| 876 | if (!rpc_cred_shrinker) { |
| 877 | err = -ENOMEM; |
NeilBrown | 89a4f75 | 2018-12-03 11:30:31 +1100 | [diff] [blame] | 878 | goto out2; |
Qi Zheng | abe0c26 | 2023-09-11 17:44:17 +0800 | [diff] [blame] | 879 | } |
| 880 | |
| 881 | rpc_cred_shrinker->count_objects = rpcauth_cache_shrink_count; |
| 882 | rpc_cred_shrinker->scan_objects = rpcauth_cache_shrink_scan; |
| 883 | |
| 884 | shrinker_register(rpc_cred_shrinker); |
| 885 | |
Trond Myklebust | 5d8d9a4 | 2010-07-31 14:29:07 -0400 | [diff] [blame] | 886 | return 0; |
| 887 | out2: |
| 888 | rpc_destroy_authunix(); |
| 889 | out1: |
| 890 | return err; |
Trond Myklebust | f5c2187 | 2007-06-25 17:11:20 -0400 | [diff] [blame] | 891 | } |
| 892 | |
Stephen Rothwell | c135e84 | 2010-09-29 14:16:57 +1000 | [diff] [blame] | 893 | void rpcauth_remove_module(void) |
Trond Myklebust | f5c2187 | 2007-06-25 17:11:20 -0400 | [diff] [blame] | 894 | { |
Trond Myklebust | 5d8d9a4 | 2010-07-31 14:29:07 -0400 | [diff] [blame] | 895 | rpc_destroy_authunix(); |
Qi Zheng | abe0c26 | 2023-09-11 17:44:17 +0800 | [diff] [blame] | 896 | shrinker_free(rpc_cred_shrinker); |
Trond Myklebust | f5c2187 | 2007-06-25 17:11:20 -0400 | [diff] [blame] | 897 | } |