Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * fs/nfs/idmap.c |
| 3 | * |
| 4 | * UID and GID to name mapping for clients. |
| 5 | * |
| 6 | * Copyright (c) 2002 The Regents of the University of Michigan. |
| 7 | * All rights reserved. |
| 8 | * |
| 9 | * Marius Aamodt Eriksen <marius@umich.edu> |
| 10 | * |
| 11 | * Redistribution and use in source and binary forms, with or without |
| 12 | * modification, are permitted provided that the following conditions |
| 13 | * are met: |
| 14 | * |
| 15 | * 1. Redistributions of source code must retain the above copyright |
| 16 | * notice, this list of conditions and the following disclaimer. |
| 17 | * 2. Redistributions in binary form must reproduce the above copyright |
| 18 | * notice, this list of conditions and the following disclaimer in the |
| 19 | * documentation and/or other materials provided with the distribution. |
| 20 | * 3. Neither the name of the University nor the names of its |
| 21 | * contributors may be used to endorse or promote products derived |
| 22 | * from this software without specific prior written permission. |
| 23 | * |
| 24 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED |
| 25 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| 26 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| 27 | * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
| 28 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| 29 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| 30 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| 31 | * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
| 32 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
| 33 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| 34 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 35 | */ |
Trond Myklebust | 5cf36cf | 2011-02-22 15:44:31 -0800 | [diff] [blame] | 36 | #include <linux/types.h> |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 37 | #include <linux/parser.h> |
| 38 | #include <linux/fs.h> |
Vitaliy Ivanov | e44ba03 | 2011-06-20 16:08:07 +0200 | [diff] [blame] | 39 | #include <linux/nfs_idmap.h> |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 40 | #include <net/net_namespace.h> |
Bryan Schumaker | 3cd0f37 | 2012-01-26 16:54:24 -0500 | [diff] [blame] | 41 | #include <linux/sunrpc/rpc_pipe_fs.h> |
Trond Myklebust | 6926afd | 2012-01-07 13:22:46 -0500 | [diff] [blame] | 42 | #include <linux/nfs_fs.h> |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 43 | #include <linux/nfs_fs_sb.h> |
| 44 | #include <linux/key.h> |
| 45 | #include <linux/keyctl.h> |
| 46 | #include <linux/key-type.h> |
| 47 | #include <keys/user-type.h> |
| 48 | #include <linux/module.h> |
| 49 | |
Bryan Schumaker | 3cd0f37 | 2012-01-26 16:54:24 -0500 | [diff] [blame] | 50 | #include "internal.h" |
Stanislav Kinsbursky | 17347d0 | 2012-01-26 15:11:41 +0400 | [diff] [blame] | 51 | #include "netns.h" |
Bryan Schumaker | 3cd0f37 | 2012-01-26 16:54:24 -0500 | [diff] [blame] | 52 | |
| 53 | #define NFS_UINT_MAXLEN 11 |
Bryan Schumaker | 3cd0f37 | 2012-01-26 16:54:24 -0500 | [diff] [blame] | 54 | |
Trond Myklebust | 1728017 | 2012-03-11 13:11:00 -0400 | [diff] [blame] | 55 | static const struct cred *id_resolver_cache; |
| 56 | static struct key_type key_type_id_resolver_legacy; |
Bryan Schumaker | 3cd0f37 | 2012-01-26 16:54:24 -0500 | [diff] [blame] | 57 | |
Bryan Schumaker | c506694 | 2012-08-09 14:05:49 -0400 | [diff] [blame] | 58 | struct idmap_legacy_upcalldata { |
| 59 | struct rpc_pipe_msg pipe_msg; |
| 60 | struct idmap_msg idmap_msg; |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 61 | struct key_construction *key_cons; |
Bryan Schumaker | c506694 | 2012-08-09 14:05:49 -0400 | [diff] [blame] | 62 | struct idmap *idmap; |
| 63 | }; |
| 64 | |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 65 | struct idmap { |
| 66 | struct rpc_pipe *idmap_pipe; |
| 67 | struct idmap_legacy_upcalldata *idmap_upcall_data; |
| 68 | struct mutex idmap_mutex; |
| 69 | }; |
| 70 | |
Trond Myklebust | 6926afd | 2012-01-07 13:22:46 -0500 | [diff] [blame] | 71 | /** |
| 72 | * nfs_fattr_init_names - initialise the nfs_fattr owner_name/group_name fields |
| 73 | * @fattr: fully initialised struct nfs_fattr |
| 74 | * @owner_name: owner name string cache |
| 75 | * @group_name: group name string cache |
| 76 | */ |
| 77 | void nfs_fattr_init_names(struct nfs_fattr *fattr, |
| 78 | struct nfs4_string *owner_name, |
| 79 | struct nfs4_string *group_name) |
| 80 | { |
| 81 | fattr->owner_name = owner_name; |
| 82 | fattr->group_name = group_name; |
| 83 | } |
| 84 | |
| 85 | static void nfs_fattr_free_owner_name(struct nfs_fattr *fattr) |
| 86 | { |
| 87 | fattr->valid &= ~NFS_ATTR_FATTR_OWNER_NAME; |
| 88 | kfree(fattr->owner_name->data); |
| 89 | } |
| 90 | |
| 91 | static void nfs_fattr_free_group_name(struct nfs_fattr *fattr) |
| 92 | { |
| 93 | fattr->valid &= ~NFS_ATTR_FATTR_GROUP_NAME; |
| 94 | kfree(fattr->group_name->data); |
| 95 | } |
| 96 | |
| 97 | static bool nfs_fattr_map_owner_name(struct nfs_server *server, struct nfs_fattr *fattr) |
| 98 | { |
| 99 | struct nfs4_string *owner = fattr->owner_name; |
Eric W. Biederman | 9f309c8 | 2013-02-01 03:21:47 -0800 | [diff] [blame] | 100 | kuid_t uid; |
Trond Myklebust | 6926afd | 2012-01-07 13:22:46 -0500 | [diff] [blame] | 101 | |
| 102 | if (!(fattr->valid & NFS_ATTR_FATTR_OWNER_NAME)) |
| 103 | return false; |
| 104 | if (nfs_map_name_to_uid(server, owner->data, owner->len, &uid) == 0) { |
| 105 | fattr->uid = uid; |
| 106 | fattr->valid |= NFS_ATTR_FATTR_OWNER; |
| 107 | } |
| 108 | return true; |
| 109 | } |
| 110 | |
| 111 | static bool nfs_fattr_map_group_name(struct nfs_server *server, struct nfs_fattr *fattr) |
| 112 | { |
| 113 | struct nfs4_string *group = fattr->group_name; |
Eric W. Biederman | 9f309c8 | 2013-02-01 03:21:47 -0800 | [diff] [blame] | 114 | kgid_t gid; |
Trond Myklebust | 6926afd | 2012-01-07 13:22:46 -0500 | [diff] [blame] | 115 | |
| 116 | if (!(fattr->valid & NFS_ATTR_FATTR_GROUP_NAME)) |
| 117 | return false; |
| 118 | if (nfs_map_group_to_gid(server, group->data, group->len, &gid) == 0) { |
| 119 | fattr->gid = gid; |
| 120 | fattr->valid |= NFS_ATTR_FATTR_GROUP; |
| 121 | } |
| 122 | return true; |
| 123 | } |
| 124 | |
| 125 | /** |
| 126 | * nfs_fattr_free_names - free up the NFSv4 owner and group strings |
| 127 | * @fattr: a fully initialised nfs_fattr structure |
| 128 | */ |
| 129 | void nfs_fattr_free_names(struct nfs_fattr *fattr) |
| 130 | { |
| 131 | if (fattr->valid & NFS_ATTR_FATTR_OWNER_NAME) |
| 132 | nfs_fattr_free_owner_name(fattr); |
| 133 | if (fattr->valid & NFS_ATTR_FATTR_GROUP_NAME) |
| 134 | nfs_fattr_free_group_name(fattr); |
| 135 | } |
| 136 | |
| 137 | /** |
| 138 | * nfs_fattr_map_and_free_names - map owner/group strings into uid/gid and free |
| 139 | * @server: pointer to the filesystem nfs_server structure |
| 140 | * @fattr: a fully initialised nfs_fattr structure |
| 141 | * |
| 142 | * This helper maps the cached NFSv4 owner/group strings in fattr into |
| 143 | * their numeric uid/gid equivalents, and then frees the cached strings. |
| 144 | */ |
| 145 | void nfs_fattr_map_and_free_names(struct nfs_server *server, struct nfs_fattr *fattr) |
| 146 | { |
| 147 | if (nfs_fattr_map_owner_name(server, fattr)) |
| 148 | nfs_fattr_free_owner_name(fattr); |
| 149 | if (nfs_fattr_map_group_name(server, fattr)) |
| 150 | nfs_fattr_free_group_name(fattr); |
| 151 | } |
Trond Myklebust | 5cf36cf | 2011-02-22 15:44:31 -0800 | [diff] [blame] | 152 | |
| 153 | static int nfs_map_string_to_numeric(const char *name, size_t namelen, __u32 *res) |
| 154 | { |
| 155 | unsigned long val; |
| 156 | char buf[16]; |
| 157 | |
| 158 | if (memchr(name, '@', namelen) != NULL || namelen >= sizeof(buf)) |
| 159 | return 0; |
| 160 | memcpy(buf, name, namelen); |
| 161 | buf[namelen] = '\0'; |
Daniel Walter | 7297cb6 | 2012-09-26 21:51:46 +0200 | [diff] [blame] | 162 | if (kstrtoul(buf, 0, &val) != 0) |
Trond Myklebust | 5cf36cf | 2011-02-22 15:44:31 -0800 | [diff] [blame] | 163 | return 0; |
| 164 | *res = val; |
| 165 | return 1; |
| 166 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 167 | |
Trond Myklebust | f0b8516 | 2011-02-22 15:44:31 -0800 | [diff] [blame] | 168 | static int nfs_map_numeric_to_string(__u32 id, char *buf, size_t buflen) |
| 169 | { |
| 170 | return snprintf(buf, buflen, "%u", id); |
| 171 | } |
| 172 | |
Trond Myklebust | 1728017 | 2012-03-11 13:11:00 -0400 | [diff] [blame] | 173 | static struct key_type key_type_id_resolver = { |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 174 | .name = "id_resolver", |
| 175 | .instantiate = user_instantiate, |
| 176 | .match = user_match, |
| 177 | .revoke = user_revoke, |
| 178 | .destroy = user_destroy, |
| 179 | .describe = user_describe, |
| 180 | .read = user_read, |
| 181 | }; |
| 182 | |
Bryan Schumaker | e6499c6 | 2012-01-26 16:54:23 -0500 | [diff] [blame] | 183 | static int nfs_idmap_init_keyring(void) |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 184 | { |
| 185 | struct cred *cred; |
| 186 | struct key *keyring; |
| 187 | int ret = 0; |
| 188 | |
Weston Andros Adamson | f9fd2d9 | 2012-01-26 13:32:22 -0500 | [diff] [blame] | 189 | printk(KERN_NOTICE "NFS: Registering the %s key type\n", |
| 190 | key_type_id_resolver.name); |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 191 | |
| 192 | cred = prepare_kernel_cred(NULL); |
| 193 | if (!cred) |
| 194 | return -ENOMEM; |
| 195 | |
Eric W. Biederman | 4e963d4 | 2013-02-01 03:03:16 -0800 | [diff] [blame] | 196 | keyring = keyring_alloc(".id_resolver", |
| 197 | GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred, |
David Howells | f8aa23a | 2012-10-02 19:24:56 +0100 | [diff] [blame] | 198 | (KEY_POS_ALL & ~KEY_POS_SETATTR) | |
| 199 | KEY_USR_VIEW | KEY_USR_READ, |
| 200 | KEY_ALLOC_NOT_IN_QUOTA, NULL); |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 201 | if (IS_ERR(keyring)) { |
| 202 | ret = PTR_ERR(keyring); |
| 203 | goto failed_put_cred; |
| 204 | } |
| 205 | |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 206 | ret = register_key_type(&key_type_id_resolver); |
| 207 | if (ret < 0) |
| 208 | goto failed_put_key; |
| 209 | |
David Howells | a427b9e | 2012-07-25 16:53:36 +0100 | [diff] [blame] | 210 | ret = register_key_type(&key_type_id_resolver_legacy); |
| 211 | if (ret < 0) |
| 212 | goto failed_reg_legacy; |
| 213 | |
David Howells | 700920e | 2012-01-18 15:31:45 +0000 | [diff] [blame] | 214 | set_bit(KEY_FLAG_ROOT_CAN_CLEAR, &keyring->flags); |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 215 | cred->thread_keyring = keyring; |
| 216 | cred->jit_keyring = KEY_REQKEY_DEFL_THREAD_KEYRING; |
| 217 | id_resolver_cache = cred; |
| 218 | return 0; |
| 219 | |
David Howells | a427b9e | 2012-07-25 16:53:36 +0100 | [diff] [blame] | 220 | failed_reg_legacy: |
| 221 | unregister_key_type(&key_type_id_resolver); |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 222 | failed_put_key: |
| 223 | key_put(keyring); |
| 224 | failed_put_cred: |
| 225 | put_cred(cred); |
| 226 | return ret; |
| 227 | } |
| 228 | |
Bryan Schumaker | e6499c6 | 2012-01-26 16:54:23 -0500 | [diff] [blame] | 229 | static void nfs_idmap_quit_keyring(void) |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 230 | { |
| 231 | key_revoke(id_resolver_cache->thread_keyring); |
| 232 | unregister_key_type(&key_type_id_resolver); |
David Howells | a427b9e | 2012-07-25 16:53:36 +0100 | [diff] [blame] | 233 | unregister_key_type(&key_type_id_resolver_legacy); |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 234 | put_cred(id_resolver_cache); |
| 235 | } |
| 236 | |
| 237 | /* |
| 238 | * Assemble the description to pass to request_key() |
| 239 | * This function will allocate a new string and update dest to point |
| 240 | * at it. The caller is responsible for freeing dest. |
| 241 | * |
| 242 | * On error 0 is returned. Otherwise, the length of dest is returned. |
| 243 | */ |
| 244 | static ssize_t nfs_idmap_get_desc(const char *name, size_t namelen, |
| 245 | const char *type, size_t typelen, char **desc) |
| 246 | { |
| 247 | char *cp; |
| 248 | size_t desclen = typelen + namelen + 2; |
| 249 | |
| 250 | *desc = kmalloc(desclen, GFP_KERNEL); |
Dan Carpenter | 8f0d97b | 2010-10-28 08:05:57 +0200 | [diff] [blame] | 251 | if (!*desc) |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 252 | return -ENOMEM; |
| 253 | |
| 254 | cp = *desc; |
| 255 | memcpy(cp, type, typelen); |
| 256 | cp += typelen; |
| 257 | *cp++ = ':'; |
| 258 | |
| 259 | memcpy(cp, name, namelen); |
| 260 | cp += namelen; |
| 261 | *cp = '\0'; |
| 262 | return desclen; |
| 263 | } |
| 264 | |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 265 | static ssize_t nfs_idmap_request_key(struct key_type *key_type, |
| 266 | const char *name, size_t namelen, |
| 267 | const char *type, void *data, |
| 268 | size_t data_size, struct idmap *idmap) |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 269 | { |
| 270 | const struct cred *saved_cred; |
| 271 | struct key *rkey; |
| 272 | char *desc; |
| 273 | struct user_key_payload *payload; |
| 274 | ssize_t ret; |
| 275 | |
| 276 | ret = nfs_idmap_get_desc(name, namelen, type, strlen(type), &desc); |
| 277 | if (ret <= 0) |
| 278 | goto out; |
| 279 | |
| 280 | saved_cred = override_creds(id_resolver_cache); |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 281 | if (idmap) |
| 282 | rkey = request_key_with_auxdata(key_type, desc, "", 0, idmap); |
| 283 | else |
| 284 | rkey = request_key(&key_type_id_resolver, desc, ""); |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 285 | revert_creds(saved_cred); |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 286 | |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 287 | kfree(desc); |
| 288 | if (IS_ERR(rkey)) { |
| 289 | ret = PTR_ERR(rkey); |
| 290 | goto out; |
| 291 | } |
| 292 | |
| 293 | rcu_read_lock(); |
| 294 | rkey->perm |= KEY_USR_VIEW; |
| 295 | |
| 296 | ret = key_validate(rkey); |
| 297 | if (ret < 0) |
| 298 | goto out_up; |
| 299 | |
| 300 | payload = rcu_dereference(rkey->payload.data); |
| 301 | if (IS_ERR_OR_NULL(payload)) { |
| 302 | ret = PTR_ERR(payload); |
| 303 | goto out_up; |
| 304 | } |
| 305 | |
| 306 | ret = payload->datalen; |
| 307 | if (ret > 0 && ret <= data_size) |
| 308 | memcpy(data, payload->data, ret); |
| 309 | else |
| 310 | ret = -EINVAL; |
| 311 | |
| 312 | out_up: |
| 313 | rcu_read_unlock(); |
| 314 | key_put(rkey); |
| 315 | out: |
| 316 | return ret; |
| 317 | } |
| 318 | |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 319 | static ssize_t nfs_idmap_get_key(const char *name, size_t namelen, |
| 320 | const char *type, void *data, |
| 321 | size_t data_size, struct idmap *idmap) |
| 322 | { |
| 323 | ssize_t ret = nfs_idmap_request_key(&key_type_id_resolver, |
| 324 | name, namelen, type, data, |
| 325 | data_size, NULL); |
| 326 | if (ret < 0) { |
Bryan Schumaker | b102743 | 2012-06-20 14:35:28 -0400 | [diff] [blame] | 327 | mutex_lock(&idmap->idmap_mutex); |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 328 | ret = nfs_idmap_request_key(&key_type_id_resolver_legacy, |
| 329 | name, namelen, type, data, |
| 330 | data_size, idmap); |
Bryan Schumaker | b102743 | 2012-06-20 14:35:28 -0400 | [diff] [blame] | 331 | mutex_unlock(&idmap->idmap_mutex); |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 332 | } |
| 333 | return ret; |
| 334 | } |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 335 | |
| 336 | /* ID -> Name */ |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 337 | static ssize_t nfs_idmap_lookup_name(__u32 id, const char *type, char *buf, |
| 338 | size_t buflen, struct idmap *idmap) |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 339 | { |
| 340 | char id_str[NFS_UINT_MAXLEN]; |
| 341 | int id_len; |
| 342 | ssize_t ret; |
| 343 | |
| 344 | id_len = snprintf(id_str, sizeof(id_str), "%u", id); |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 345 | ret = nfs_idmap_get_key(id_str, id_len, type, buf, buflen, idmap); |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 346 | if (ret < 0) |
| 347 | return -EINVAL; |
| 348 | return ret; |
| 349 | } |
| 350 | |
| 351 | /* Name -> ID */ |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 352 | static int nfs_idmap_lookup_id(const char *name, size_t namelen, const char *type, |
| 353 | __u32 *id, struct idmap *idmap) |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 354 | { |
| 355 | char id_str[NFS_UINT_MAXLEN]; |
| 356 | long id_long; |
| 357 | ssize_t data_size; |
| 358 | int ret = 0; |
| 359 | |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 360 | data_size = nfs_idmap_get_key(name, namelen, type, id_str, NFS_UINT_MAXLEN, idmap); |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 361 | if (data_size <= 0) { |
| 362 | ret = -EINVAL; |
| 363 | } else { |
Daniel Walter | 7297cb6 | 2012-09-26 21:51:46 +0200 | [diff] [blame] | 364 | ret = kstrtol(id_str, 10, &id_long); |
Bryan Schumaker | 955a857 | 2010-09-29 15:41:49 -0400 | [diff] [blame] | 365 | *id = (__u32)id_long; |
| 366 | } |
| 367 | return ret; |
| 368 | } |
| 369 | |
Bryan Schumaker | e6499c6 | 2012-01-26 16:54:23 -0500 | [diff] [blame] | 370 | /* idmap classic begins here */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 371 | |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 372 | enum { |
| 373 | Opt_find_uid, Opt_find_gid, Opt_find_user, Opt_find_group, Opt_find_err |
| 374 | }; |
| 375 | |
| 376 | static const match_table_t nfs_idmap_tokens = { |
| 377 | { Opt_find_uid, "uid:%s" }, |
| 378 | { Opt_find_gid, "gid:%s" }, |
| 379 | { Opt_find_user, "user:%s" }, |
| 380 | { Opt_find_group, "group:%s" }, |
| 381 | { Opt_find_err, NULL } |
| 382 | }; |
| 383 | |
| 384 | static int nfs_idmap_legacy_upcall(struct key_construction *, const char *, void *); |
Chuck Lever | 369af0f | 2007-12-20 14:54:35 -0500 | [diff] [blame] | 385 | static ssize_t idmap_pipe_downcall(struct file *, const char __user *, |
| 386 | size_t); |
Bryan Schumaker | c506694 | 2012-08-09 14:05:49 -0400 | [diff] [blame] | 387 | static void idmap_release_pipe(struct inode *); |
Chuck Lever | 369af0f | 2007-12-20 14:54:35 -0500 | [diff] [blame] | 388 | static void idmap_pipe_destroy_msg(struct rpc_pipe_msg *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 389 | |
Trond Myklebust | b693ba4 | 2009-08-09 15:14:15 -0400 | [diff] [blame] | 390 | static const struct rpc_pipe_ops idmap_upcall_ops = { |
Peng Tao | c122515 | 2011-09-22 21:50:10 -0400 | [diff] [blame] | 391 | .upcall = rpc_pipe_generic_upcall, |
Chuck Lever | 369af0f | 2007-12-20 14:54:35 -0500 | [diff] [blame] | 392 | .downcall = idmap_pipe_downcall, |
Bryan Schumaker | c506694 | 2012-08-09 14:05:49 -0400 | [diff] [blame] | 393 | .release_pipe = idmap_release_pipe, |
Chuck Lever | 369af0f | 2007-12-20 14:54:35 -0500 | [diff] [blame] | 394 | .destroy_msg = idmap_pipe_destroy_msg, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 395 | }; |
| 396 | |
Trond Myklebust | 1728017 | 2012-03-11 13:11:00 -0400 | [diff] [blame] | 397 | static struct key_type key_type_id_resolver_legacy = { |
David Howells | a427b9e | 2012-07-25 16:53:36 +0100 | [diff] [blame] | 398 | .name = "id_legacy", |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 399 | .instantiate = user_instantiate, |
| 400 | .match = user_match, |
| 401 | .revoke = user_revoke, |
| 402 | .destroy = user_destroy, |
| 403 | .describe = user_describe, |
| 404 | .read = user_read, |
| 405 | .request_key = nfs_idmap_legacy_upcall, |
| 406 | }; |
| 407 | |
Stanislav Kinsbursky | 4929d1d | 2012-01-10 16:13:11 +0400 | [diff] [blame] | 408 | static void __nfs_idmap_unregister(struct rpc_pipe *pipe) |
| 409 | { |
| 410 | if (pipe->dentry) |
| 411 | rpc_unlink(pipe->dentry); |
| 412 | } |
| 413 | |
| 414 | static int __nfs_idmap_register(struct dentry *dir, |
| 415 | struct idmap *idmap, |
| 416 | struct rpc_pipe *pipe) |
| 417 | { |
| 418 | struct dentry *dentry; |
| 419 | |
| 420 | dentry = rpc_mkpipe_dentry(dir, "idmap", idmap, pipe); |
| 421 | if (IS_ERR(dentry)) |
| 422 | return PTR_ERR(dentry); |
| 423 | pipe->dentry = dentry; |
| 424 | return 0; |
| 425 | } |
| 426 | |
| 427 | static void nfs_idmap_unregister(struct nfs_client *clp, |
| 428 | struct rpc_pipe *pipe) |
| 429 | { |
Chuck Lever | 73ea666 | 2012-05-21 22:44:50 -0400 | [diff] [blame] | 430 | struct net *net = clp->cl_net; |
Stanislav Kinsbursky | 4929d1d | 2012-01-10 16:13:11 +0400 | [diff] [blame] | 431 | struct super_block *pipefs_sb; |
| 432 | |
| 433 | pipefs_sb = rpc_get_sb_net(net); |
| 434 | if (pipefs_sb) { |
| 435 | __nfs_idmap_unregister(pipe); |
| 436 | rpc_put_sb_net(net); |
| 437 | } |
| 438 | } |
| 439 | |
| 440 | static int nfs_idmap_register(struct nfs_client *clp, |
| 441 | struct idmap *idmap, |
| 442 | struct rpc_pipe *pipe) |
| 443 | { |
Chuck Lever | 73ea666 | 2012-05-21 22:44:50 -0400 | [diff] [blame] | 444 | struct net *net = clp->cl_net; |
Stanislav Kinsbursky | 4929d1d | 2012-01-10 16:13:11 +0400 | [diff] [blame] | 445 | struct super_block *pipefs_sb; |
| 446 | int err = 0; |
| 447 | |
| 448 | pipefs_sb = rpc_get_sb_net(net); |
| 449 | if (pipefs_sb) { |
| 450 | if (clp->cl_rpcclient->cl_dentry) |
| 451 | err = __nfs_idmap_register(clp->cl_rpcclient->cl_dentry, |
| 452 | idmap, pipe); |
| 453 | rpc_put_sb_net(net); |
| 454 | } |
| 455 | return err; |
| 456 | } |
| 457 | |
David Howells | b716279 | 2006-08-22 20:06:09 -0400 | [diff] [blame] | 458 | int |
David Howells | adfa6f9 | 2006-08-22 20:06:08 -0400 | [diff] [blame] | 459 | nfs_idmap_new(struct nfs_client *clp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 460 | { |
| 461 | struct idmap *idmap; |
Stanislav Kinsbursky | c239d83 | 2011-12-26 15:44:06 +0300 | [diff] [blame] | 462 | struct rpc_pipe *pipe; |
David Howells | b716279 | 2006-08-22 20:06:09 -0400 | [diff] [blame] | 463 | int error; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 464 | |
Chuck Lever | 369af0f | 2007-12-20 14:54:35 -0500 | [diff] [blame] | 465 | idmap = kzalloc(sizeof(*idmap), GFP_KERNEL); |
| 466 | if (idmap == NULL) |
| 467 | return -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 468 | |
Stanislav Kinsbursky | c239d83 | 2011-12-26 15:44:06 +0300 | [diff] [blame] | 469 | pipe = rpc_mkpipe_data(&idmap_upcall_ops, 0); |
| 470 | if (IS_ERR(pipe)) { |
| 471 | error = PTR_ERR(pipe); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 472 | kfree(idmap); |
David Howells | b716279 | 2006-08-22 20:06:09 -0400 | [diff] [blame] | 473 | return error; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 474 | } |
Stanislav Kinsbursky | 4929d1d | 2012-01-10 16:13:11 +0400 | [diff] [blame] | 475 | error = nfs_idmap_register(clp, idmap, pipe); |
| 476 | if (error) { |
Stanislav Kinsbursky | c239d83 | 2011-12-26 15:44:06 +0300 | [diff] [blame] | 477 | rpc_destroy_pipe_data(pipe); |
| 478 | kfree(idmap); |
| 479 | return error; |
| 480 | } |
| 481 | idmap->idmap_pipe = pipe; |
Bryan Schumaker | b102743 | 2012-06-20 14:35:28 -0400 | [diff] [blame] | 482 | mutex_init(&idmap->idmap_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 483 | |
| 484 | clp->cl_idmap = idmap; |
David Howells | b716279 | 2006-08-22 20:06:09 -0400 | [diff] [blame] | 485 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 486 | } |
| 487 | |
| 488 | void |
David Howells | adfa6f9 | 2006-08-22 20:06:08 -0400 | [diff] [blame] | 489 | nfs_idmap_delete(struct nfs_client *clp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 490 | { |
| 491 | struct idmap *idmap = clp->cl_idmap; |
| 492 | |
| 493 | if (!idmap) |
| 494 | return; |
Stanislav Kinsbursky | 4929d1d | 2012-01-10 16:13:11 +0400 | [diff] [blame] | 495 | nfs_idmap_unregister(clp, idmap->idmap_pipe); |
Stanislav Kinsbursky | c239d83 | 2011-12-26 15:44:06 +0300 | [diff] [blame] | 496 | rpc_destroy_pipe_data(idmap->idmap_pipe); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 497 | clp->cl_idmap = NULL; |
| 498 | kfree(idmap); |
| 499 | } |
| 500 | |
Stanislav Kinsbursky | eee1732 | 2012-01-10 16:13:19 +0400 | [diff] [blame] | 501 | static int __rpc_pipefs_event(struct nfs_client *clp, unsigned long event, |
| 502 | struct super_block *sb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 503 | { |
Stanislav Kinsbursky | eee1732 | 2012-01-10 16:13:19 +0400 | [diff] [blame] | 504 | int err = 0; |
| 505 | |
| 506 | switch (event) { |
| 507 | case RPC_PIPEFS_MOUNT: |
Stanislav Kinsbursky | eee1732 | 2012-01-10 16:13:19 +0400 | [diff] [blame] | 508 | err = __nfs_idmap_register(clp->cl_rpcclient->cl_dentry, |
| 509 | clp->cl_idmap, |
| 510 | clp->cl_idmap->idmap_pipe); |
| 511 | break; |
| 512 | case RPC_PIPEFS_UMOUNT: |
| 513 | if (clp->cl_idmap->idmap_pipe) { |
| 514 | struct dentry *parent; |
| 515 | |
| 516 | parent = clp->cl_idmap->idmap_pipe->dentry->d_parent; |
| 517 | __nfs_idmap_unregister(clp->cl_idmap->idmap_pipe); |
| 518 | /* |
| 519 | * Note: This is a dirty hack. SUNRPC hook has been |
| 520 | * called already but simple_rmdir() call for the |
| 521 | * directory returned with error because of idmap pipe |
| 522 | * inside. Thus now we have to remove this directory |
| 523 | * here. |
| 524 | */ |
| 525 | if (rpc_rmdir(parent)) |
Weston Andros Adamson | a030889 | 2012-01-26 13:32:23 -0500 | [diff] [blame] | 526 | printk(KERN_ERR "NFS: %s: failed to remove " |
| 527 | "clnt dir!\n", __func__); |
Stanislav Kinsbursky | eee1732 | 2012-01-10 16:13:19 +0400 | [diff] [blame] | 528 | } |
| 529 | break; |
| 530 | default: |
Weston Andros Adamson | a030889 | 2012-01-26 13:32:23 -0500 | [diff] [blame] | 531 | printk(KERN_ERR "NFS: %s: unknown event: %ld\n", __func__, |
| 532 | event); |
Stanislav Kinsbursky | eee1732 | 2012-01-10 16:13:19 +0400 | [diff] [blame] | 533 | return -ENOTSUPP; |
| 534 | } |
| 535 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 536 | } |
| 537 | |
Stanislav Kinsbursky | e9dbca8 | 2012-02-27 22:05:37 +0400 | [diff] [blame] | 538 | static struct nfs_client *nfs_get_client_for_event(struct net *net, int event) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 539 | { |
Stanislav Kinsbursky | e9dbca8 | 2012-02-27 22:05:37 +0400 | [diff] [blame] | 540 | struct nfs_net *nn = net_generic(net, nfs_net_id); |
| 541 | struct dentry *cl_dentry; |
Stanislav Kinsbursky | eee1732 | 2012-01-10 16:13:19 +0400 | [diff] [blame] | 542 | struct nfs_client *clp; |
Trond Myklebust | 4697bd5 | 2012-05-23 13:24:36 -0400 | [diff] [blame] | 543 | int err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 544 | |
Trond Myklebust | 4697bd5 | 2012-05-23 13:24:36 -0400 | [diff] [blame] | 545 | restart: |
Stanislav Kinsbursky | dc03085 | 2012-01-23 17:26:31 +0000 | [diff] [blame] | 546 | spin_lock(&nn->nfs_client_lock); |
Stanislav Kinsbursky | 6b13168 | 2012-01-23 17:26:05 +0000 | [diff] [blame] | 547 | list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) { |
Trond Myklebust | 4697bd5 | 2012-05-23 13:24:36 -0400 | [diff] [blame] | 548 | /* Wait for initialisation to finish */ |
| 549 | if (clp->cl_cons_state == NFS_CS_INITING) { |
| 550 | atomic_inc(&clp->cl_count); |
| 551 | spin_unlock(&nn->nfs_client_lock); |
| 552 | err = nfs_wait_client_init_complete(clp); |
| 553 | nfs_put_client(clp); |
| 554 | if (err) |
| 555 | return NULL; |
| 556 | goto restart; |
| 557 | } |
| 558 | /* Skip nfs_clients that failed to initialise */ |
| 559 | if (clp->cl_cons_state < 0) |
| 560 | continue; |
Trond Myklebust | 54ac471 | 2012-05-23 13:26:10 -0400 | [diff] [blame] | 561 | smp_rmb(); |
Stanislav Kinsbursky | eee1732 | 2012-01-10 16:13:19 +0400 | [diff] [blame] | 562 | if (clp->rpc_ops != &nfs_v4_clientops) |
| 563 | continue; |
Stanislav Kinsbursky | e9dbca8 | 2012-02-27 22:05:37 +0400 | [diff] [blame] | 564 | cl_dentry = clp->cl_idmap->idmap_pipe->dentry; |
| 565 | if (((event == RPC_PIPEFS_MOUNT) && cl_dentry) || |
| 566 | ((event == RPC_PIPEFS_UMOUNT) && !cl_dentry)) |
| 567 | continue; |
| 568 | atomic_inc(&clp->cl_count); |
| 569 | spin_unlock(&nn->nfs_client_lock); |
| 570 | return clp; |
| 571 | } |
| 572 | spin_unlock(&nn->nfs_client_lock); |
| 573 | return NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 574 | } |
| 575 | |
Stanislav Kinsbursky | e9dbca8 | 2012-02-27 22:05:37 +0400 | [diff] [blame] | 576 | static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event, |
| 577 | void *ptr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 578 | { |
Stanislav Kinsbursky | e9dbca8 | 2012-02-27 22:05:37 +0400 | [diff] [blame] | 579 | struct super_block *sb = ptr; |
| 580 | struct nfs_client *clp; |
| 581 | int error = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 582 | |
Stanislav Kinsbursky | 71dfc5f | 2012-04-28 19:32:21 +0400 | [diff] [blame] | 583 | if (!try_module_get(THIS_MODULE)) |
| 584 | return 0; |
| 585 | |
Stanislav Kinsbursky | e9dbca8 | 2012-02-27 22:05:37 +0400 | [diff] [blame] | 586 | while ((clp = nfs_get_client_for_event(sb->s_fs_info, event))) { |
Stanislav Kinsbursky | eee1732 | 2012-01-10 16:13:19 +0400 | [diff] [blame] | 587 | error = __rpc_pipefs_event(clp, event, sb); |
Stanislav Kinsbursky | e9dbca8 | 2012-02-27 22:05:37 +0400 | [diff] [blame] | 588 | nfs_put_client(clp); |
Stanislav Kinsbursky | eee1732 | 2012-01-10 16:13:19 +0400 | [diff] [blame] | 589 | if (error) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 590 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 591 | } |
Stanislav Kinsbursky | 71dfc5f | 2012-04-28 19:32:21 +0400 | [diff] [blame] | 592 | module_put(THIS_MODULE); |
Stanislav Kinsbursky | eee1732 | 2012-01-10 16:13:19 +0400 | [diff] [blame] | 593 | return error; |
| 594 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 595 | |
Stanislav Kinsbursky | eee1732 | 2012-01-10 16:13:19 +0400 | [diff] [blame] | 596 | #define PIPEFS_NFS_PRIO 1 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 597 | |
Stanislav Kinsbursky | eee1732 | 2012-01-10 16:13:19 +0400 | [diff] [blame] | 598 | static struct notifier_block nfs_idmap_block = { |
| 599 | .notifier_call = rpc_pipefs_event, |
| 600 | .priority = SUNRPC_PIPEFS_NFS_PRIO, |
| 601 | }; |
| 602 | |
| 603 | int nfs_idmap_init(void) |
| 604 | { |
Bryan Schumaker | e6499c6 | 2012-01-26 16:54:23 -0500 | [diff] [blame] | 605 | int ret; |
| 606 | ret = nfs_idmap_init_keyring(); |
| 607 | if (ret != 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 608 | goto out; |
Bryan Schumaker | e6499c6 | 2012-01-26 16:54:23 -0500 | [diff] [blame] | 609 | ret = rpc_pipefs_notifier_register(&nfs_idmap_block); |
| 610 | if (ret != 0) |
| 611 | nfs_idmap_quit_keyring(); |
| 612 | out: |
Chuck Lever | 369af0f | 2007-12-20 14:54:35 -0500 | [diff] [blame] | 613 | return ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 614 | } |
| 615 | |
Stanislav Kinsbursky | eee1732 | 2012-01-10 16:13:19 +0400 | [diff] [blame] | 616 | void nfs_idmap_quit(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 617 | { |
Stanislav Kinsbursky | eee1732 | 2012-01-10 16:13:19 +0400 | [diff] [blame] | 618 | rpc_pipefs_notifier_unregister(&nfs_idmap_block); |
Bryan Schumaker | e6499c6 | 2012-01-26 16:54:23 -0500 | [diff] [blame] | 619 | nfs_idmap_quit_keyring(); |
Stanislav Kinsbursky | eee1732 | 2012-01-10 16:13:19 +0400 | [diff] [blame] | 620 | } |
| 621 | |
Bryan Schumaker | c506694 | 2012-08-09 14:05:49 -0400 | [diff] [blame] | 622 | static int nfs_idmap_prepare_message(char *desc, struct idmap *idmap, |
| 623 | struct idmap_msg *im, |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 624 | struct rpc_pipe_msg *msg) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 625 | { |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 626 | substring_t substr; |
| 627 | int token, ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 628 | |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 629 | im->im_type = IDMAP_TYPE_GROUP; |
| 630 | token = match_token(desc, nfs_idmap_tokens, &substr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 631 | |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 632 | switch (token) { |
| 633 | case Opt_find_uid: |
| 634 | im->im_type = IDMAP_TYPE_USER; |
| 635 | case Opt_find_gid: |
| 636 | im->im_conv = IDMAP_CONV_NAMETOID; |
| 637 | ret = match_strlcpy(im->im_name, &substr, IDMAP_NAMESZ); |
| 638 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 639 | |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 640 | case Opt_find_user: |
| 641 | im->im_type = IDMAP_TYPE_USER; |
| 642 | case Opt_find_group: |
| 643 | im->im_conv = IDMAP_CONV_IDTONAME; |
| 644 | ret = match_int(&substr, &im->im_id); |
| 645 | break; |
Trond Myklebust | 685f50f | 2012-02-08 13:39:15 -0500 | [diff] [blame] | 646 | |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 647 | default: |
| 648 | ret = -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 649 | goto out; |
| 650 | } |
| 651 | |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 652 | msg->data = im; |
| 653 | msg->len = sizeof(struct idmap_msg); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 654 | |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 655 | out: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 656 | return ret; |
| 657 | } |
| 658 | |
Trond Myklebust | e9ab41b6 | 2012-09-27 15:44:19 -0400 | [diff] [blame] | 659 | static bool |
| 660 | nfs_idmap_prepare_pipe_upcall(struct idmap *idmap, |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 661 | struct idmap_legacy_upcalldata *data) |
Trond Myklebust | e9ab41b6 | 2012-09-27 15:44:19 -0400 | [diff] [blame] | 662 | { |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 663 | if (idmap->idmap_upcall_data != NULL) { |
Trond Myklebust | e9ab41b6 | 2012-09-27 15:44:19 -0400 | [diff] [blame] | 664 | WARN_ON_ONCE(1); |
| 665 | return false; |
| 666 | } |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 667 | idmap->idmap_upcall_data = data; |
Trond Myklebust | e9ab41b6 | 2012-09-27 15:44:19 -0400 | [diff] [blame] | 668 | return true; |
| 669 | } |
| 670 | |
| 671 | static void |
| 672 | nfs_idmap_complete_pipe_upcall_locked(struct idmap *idmap, int ret) |
| 673 | { |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 674 | struct key_construction *cons = idmap->idmap_upcall_data->key_cons; |
Trond Myklebust | e9ab41b6 | 2012-09-27 15:44:19 -0400 | [diff] [blame] | 675 | |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 676 | kfree(idmap->idmap_upcall_data); |
| 677 | idmap->idmap_upcall_data = NULL; |
Trond Myklebust | e9ab41b6 | 2012-09-27 15:44:19 -0400 | [diff] [blame] | 678 | complete_request_key(cons, ret); |
| 679 | } |
| 680 | |
| 681 | static void |
| 682 | nfs_idmap_abort_pipe_upcall(struct idmap *idmap, int ret) |
| 683 | { |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 684 | if (idmap->idmap_upcall_data != NULL) |
Trond Myklebust | e9ab41b6 | 2012-09-27 15:44:19 -0400 | [diff] [blame] | 685 | nfs_idmap_complete_pipe_upcall_locked(idmap, ret); |
| 686 | } |
| 687 | |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 688 | static int nfs_idmap_legacy_upcall(struct key_construction *cons, |
| 689 | const char *op, |
| 690 | void *aux) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 691 | { |
Bryan Schumaker | c506694 | 2012-08-09 14:05:49 -0400 | [diff] [blame] | 692 | struct idmap_legacy_upcalldata *data; |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 693 | struct rpc_pipe_msg *msg; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 694 | struct idmap_msg *im; |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 695 | struct idmap *idmap = (struct idmap *)aux; |
| 696 | struct key *key = cons->key; |
Dan Carpenter | 5abc03c | 2012-05-14 22:45:28 +0300 | [diff] [blame] | 697 | int ret = -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 698 | |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 699 | /* msg and im are freed in idmap_pipe_destroy_msg */ |
Bryan Schumaker | 57a5104 | 2012-08-09 14:05:51 -0400 | [diff] [blame] | 700 | data = kzalloc(sizeof(*data), GFP_KERNEL); |
Bryan Schumaker | c506694 | 2012-08-09 14:05:49 -0400 | [diff] [blame] | 701 | if (!data) |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 702 | goto out1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 703 | |
Bryan Schumaker | c506694 | 2012-08-09 14:05:49 -0400 | [diff] [blame] | 704 | msg = &data->pipe_msg; |
| 705 | im = &data->idmap_msg; |
| 706 | data->idmap = idmap; |
Bryan Schumaker | ddfc4e1 | 2012-10-02 16:01:38 -0400 | [diff] [blame] | 707 | data->key_cons = cons; |
Bryan Schumaker | c506694 | 2012-08-09 14:05:49 -0400 | [diff] [blame] | 708 | |
| 709 | ret = nfs_idmap_prepare_message(key->description, idmap, im, msg); |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 710 | if (ret < 0) |
| 711 | goto out2; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 712 | |
Trond Myklebust | e9ab41b6 | 2012-09-27 15:44:19 -0400 | [diff] [blame] | 713 | ret = -EAGAIN; |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 714 | if (!nfs_idmap_prepare_pipe_upcall(idmap, data)) |
Trond Myklebust | 0e24d84 | 2012-09-28 12:03:09 -0400 | [diff] [blame] | 715 | goto out2; |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 716 | |
Bryan Schumaker | 11588f4 | 2012-03-12 11:33:00 -0400 | [diff] [blame] | 717 | ret = rpc_queue_upcall(idmap->idmap_pipe, msg); |
| 718 | if (ret < 0) |
Trond Myklebust | e9ab41b6 | 2012-09-27 15:44:19 -0400 | [diff] [blame] | 719 | nfs_idmap_abort_pipe_upcall(idmap, ret); |
Bryan Schumaker | 11588f4 | 2012-03-12 11:33:00 -0400 | [diff] [blame] | 720 | |
| 721 | return ret; |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 722 | out2: |
Bryan Schumaker | c506694 | 2012-08-09 14:05:49 -0400 | [diff] [blame] | 723 | kfree(data); |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 724 | out1: |
David Howells | a427b9e | 2012-07-25 16:53:36 +0100 | [diff] [blame] | 725 | complete_request_key(cons, ret); |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 726 | return ret; |
| 727 | } |
| 728 | |
| 729 | static int nfs_idmap_instantiate(struct key *key, struct key *authkey, char *data) |
| 730 | { |
| 731 | return key_instantiate_and_link(key, data, strlen(data) + 1, |
| 732 | id_resolver_cache->thread_keyring, |
| 733 | authkey); |
| 734 | } |
| 735 | |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 736 | static int nfs_idmap_read_and_verify_message(struct idmap_msg *im, |
| 737 | struct idmap_msg *upcall, |
| 738 | struct key *key, struct key *authkey) |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 739 | { |
| 740 | char id_str[NFS_UINT_MAXLEN]; |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 741 | int ret = -ENOKEY; |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 742 | |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 743 | /* ret = -ENOKEY */ |
| 744 | if (upcall->im_type != im->im_type || upcall->im_conv != im->im_conv) |
| 745 | goto out; |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 746 | switch (im->im_conv) { |
| 747 | case IDMAP_CONV_NAMETOID: |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 748 | if (strcmp(upcall->im_name, im->im_name) != 0) |
| 749 | break; |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 750 | sprintf(id_str, "%d", im->im_id); |
| 751 | ret = nfs_idmap_instantiate(key, authkey, id_str); |
| 752 | break; |
| 753 | case IDMAP_CONV_IDTONAME: |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 754 | if (upcall->im_id != im->im_id) |
| 755 | break; |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 756 | ret = nfs_idmap_instantiate(key, authkey, im->im_name); |
| 757 | break; |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 758 | default: |
| 759 | ret = -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 760 | } |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 761 | out: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 762 | return ret; |
| 763 | } |
| 764 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 765 | static ssize_t |
| 766 | idmap_pipe_downcall(struct file *filp, const char __user *src, size_t mlen) |
| 767 | { |
Al Viro | 496ad9a | 2013-01-23 17:07:38 -0500 | [diff] [blame] | 768 | struct rpc_inode *rpci = RPC_I(file_inode(filp)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 769 | struct idmap *idmap = (struct idmap *)rpci->private; |
David Howells | a427b9e | 2012-07-25 16:53:36 +0100 | [diff] [blame] | 770 | struct key_construction *cons; |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 771 | struct idmap_msg im; |
Chuck Lever | d24aae4 | 2007-12-20 14:54:49 -0500 | [diff] [blame] | 772 | size_t namelen_in; |
Trond Myklebust | e9ab41b6 | 2012-09-27 15:44:19 -0400 | [diff] [blame] | 773 | int ret = -ENOKEY; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 774 | |
David Howells | a427b9e | 2012-07-25 16:53:36 +0100 | [diff] [blame] | 775 | /* If instantiation is successful, anyone waiting for key construction |
| 776 | * will have been woken up and someone else may now have used |
| 777 | * idmap_key_cons - so after this point we may no longer touch it. |
| 778 | */ |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 779 | if (idmap->idmap_upcall_data == NULL) |
Trond Myklebust | e9ab41b6 | 2012-09-27 15:44:19 -0400 | [diff] [blame] | 780 | goto out_noupcall; |
David Howells | a427b9e | 2012-07-25 16:53:36 +0100 | [diff] [blame] | 781 | |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 782 | cons = idmap->idmap_upcall_data->key_cons; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 783 | |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 784 | if (mlen != sizeof(im)) { |
| 785 | ret = -ENOSPC; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 786 | goto out; |
| 787 | } |
| 788 | |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 789 | if (copy_from_user(&im, src, mlen) != 0) { |
| 790 | ret = -EFAULT; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 791 | goto out; |
| 792 | } |
| 793 | |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 794 | if (!(im.im_status & IDMAP_STATUS_SUCCESS)) { |
Bryan Schumaker | 12dfd08 | 2012-08-09 14:05:50 -0400 | [diff] [blame] | 795 | ret = -ENOKEY; |
| 796 | goto out; |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 797 | } |
| 798 | |
| 799 | namelen_in = strnlen(im.im_name, IDMAP_NAMESZ); |
| 800 | if (namelen_in == 0 || namelen_in == IDMAP_NAMESZ) { |
| 801 | ret = -EINVAL; |
| 802 | goto out; |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 803 | } |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 804 | |
Trond Myklebust | 0cac120 | 2012-09-27 16:15:00 -0400 | [diff] [blame] | 805 | ret = nfs_idmap_read_and_verify_message(&im, |
| 806 | &idmap->idmap_upcall_data->idmap_msg, |
| 807 | cons->key, cons->authkey); |
Bryan Schumaker | 57e6232 | 2012-02-24 14:14:51 -0500 | [diff] [blame] | 808 | if (ret >= 0) { |
| 809 | key_set_timeout(cons->key, nfs_idmap_cache_timeout); |
| 810 | ret = mlen; |
| 811 | } |
| 812 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 813 | out: |
Trond Myklebust | e9ab41b6 | 2012-09-27 15:44:19 -0400 | [diff] [blame] | 814 | nfs_idmap_complete_pipe_upcall_locked(idmap, ret); |
| 815 | out_noupcall: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 816 | return ret; |
| 817 | } |
| 818 | |
Adrian Bunk | 75c96f8 | 2005-05-05 16:16:09 -0700 | [diff] [blame] | 819 | static void |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 820 | idmap_pipe_destroy_msg(struct rpc_pipe_msg *msg) |
| 821 | { |
Bryan Schumaker | c506694 | 2012-08-09 14:05:49 -0400 | [diff] [blame] | 822 | struct idmap_legacy_upcalldata *data = container_of(msg, |
| 823 | struct idmap_legacy_upcalldata, |
| 824 | pipe_msg); |
| 825 | struct idmap *idmap = data->idmap; |
Trond Myklebust | e9ab41b6 | 2012-09-27 15:44:19 -0400 | [diff] [blame] | 826 | |
| 827 | if (msg->errno) |
| 828 | nfs_idmap_abort_pipe_upcall(idmap, msg->errno); |
Bryan Schumaker | c506694 | 2012-08-09 14:05:49 -0400 | [diff] [blame] | 829 | } |
| 830 | |
| 831 | static void |
| 832 | idmap_release_pipe(struct inode *inode) |
| 833 | { |
| 834 | struct rpc_inode *rpci = RPC_I(inode); |
| 835 | struct idmap *idmap = (struct idmap *)rpci->private; |
Trond Myklebust | e9ab41b6 | 2012-09-27 15:44:19 -0400 | [diff] [blame] | 836 | |
| 837 | nfs_idmap_abort_pipe_upcall(idmap, -EPIPE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 838 | } |
| 839 | |
Eric W. Biederman | 9f309c8 | 2013-02-01 03:21:47 -0800 | [diff] [blame] | 840 | int nfs_map_name_to_uid(const struct nfs_server *server, const char *name, size_t namelen, kuid_t *uid) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 841 | { |
Trond Myklebust | e4fd72a | 2011-02-22 15:44:31 -0800 | [diff] [blame] | 842 | struct idmap *idmap = server->nfs_client->cl_idmap; |
Eric W. Biederman | 9f309c8 | 2013-02-01 03:21:47 -0800 | [diff] [blame] | 843 | __u32 id = -1; |
| 844 | int ret = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 845 | |
Eric W. Biederman | 9f309c8 | 2013-02-01 03:21:47 -0800 | [diff] [blame] | 846 | if (!nfs_map_string_to_numeric(name, namelen, &id)) |
| 847 | ret = nfs_idmap_lookup_id(name, namelen, "uid", &id, idmap); |
| 848 | if (ret == 0) { |
| 849 | *uid = make_kuid(&init_user_ns, id); |
| 850 | if (!uid_valid(*uid)) |
| 851 | ret = -ERANGE; |
| 852 | } |
Trond Myklebust | f0b8516 | 2011-02-22 15:44:31 -0800 | [diff] [blame] | 853 | return ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 854 | } |
Eric W. Biederman | 9f309c8 | 2013-02-01 03:21:47 -0800 | [diff] [blame] | 855 | |
| 856 | int nfs_map_group_to_gid(const struct nfs_server *server, const char *name, size_t namelen, kgid_t *gid) |
| 857 | { |
| 858 | struct idmap *idmap = server->nfs_client->cl_idmap; |
| 859 | __u32 id = -1; |
| 860 | int ret = 0; |
| 861 | |
| 862 | if (!nfs_map_string_to_numeric(name, namelen, &id)) |
| 863 | ret = nfs_idmap_lookup_id(name, namelen, "gid", &id, idmap); |
| 864 | if (ret == 0) { |
| 865 | *gid = make_kgid(&init_user_ns, id); |
| 866 | if (!gid_valid(*gid)) |
| 867 | ret = -ERANGE; |
| 868 | } |
| 869 | return ret; |
| 870 | } |
| 871 | |
| 872 | int nfs_map_uid_to_name(const struct nfs_server *server, kuid_t uid, char *buf, size_t buflen) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 873 | { |
Trond Myklebust | e4fd72a | 2011-02-22 15:44:31 -0800 | [diff] [blame] | 874 | struct idmap *idmap = server->nfs_client->cl_idmap; |
Trond Myklebust | b064eca2 | 2011-02-22 15:44:32 -0800 | [diff] [blame] | 875 | int ret = -EINVAL; |
Eric W. Biederman | 9f309c8 | 2013-02-01 03:21:47 -0800 | [diff] [blame] | 876 | __u32 id; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 877 | |
Eric W. Biederman | 9f309c8 | 2013-02-01 03:21:47 -0800 | [diff] [blame] | 878 | id = from_kuid(&init_user_ns, uid); |
Trond Myklebust | b064eca2 | 2011-02-22 15:44:32 -0800 | [diff] [blame] | 879 | if (!(server->caps & NFS_CAP_UIDGID_NOMAP)) |
Eric W. Biederman | 9f309c8 | 2013-02-01 03:21:47 -0800 | [diff] [blame] | 880 | ret = nfs_idmap_lookup_name(id, "user", buf, buflen, idmap); |
Trond Myklebust | f0b8516 | 2011-02-22 15:44:31 -0800 | [diff] [blame] | 881 | if (ret < 0) |
Eric W. Biederman | 9f309c8 | 2013-02-01 03:21:47 -0800 | [diff] [blame] | 882 | ret = nfs_map_numeric_to_string(id, buf, buflen); |
| 883 | return ret; |
| 884 | } |
| 885 | int nfs_map_gid_to_group(const struct nfs_server *server, kgid_t gid, char *buf, size_t buflen) |
| 886 | { |
| 887 | struct idmap *idmap = server->nfs_client->cl_idmap; |
| 888 | int ret = -EINVAL; |
| 889 | __u32 id; |
| 890 | |
| 891 | id = from_kgid(&init_user_ns, gid); |
| 892 | if (!(server->caps & NFS_CAP_UIDGID_NOMAP)) |
| 893 | ret = nfs_idmap_lookup_name(id, "group", buf, buflen, idmap); |
| 894 | if (ret < 0) |
| 895 | ret = nfs_map_numeric_to_string(id, buf, buflen); |
Trond Myklebust | f0b8516 | 2011-02-22 15:44:31 -0800 | [diff] [blame] | 896 | return ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 897 | } |