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