Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 | */ | |
5cf36cfd | 36 | #include <linux/types.h> |
57e62324 BS |
37 | #include <linux/parser.h> |
38 | #include <linux/fs.h> | |
e44ba033 | 39 | #include <linux/nfs_idmap.h> |
57e62324 BS |
40 | #include <net/net_namespace.h> |
41 | #include <linux/sunrpc/rpc_pipe_fs.h> | |
6926afd1 | 42 | #include <linux/nfs_fs.h> |
3cd0f37a | 43 | #include <linux/nfs_fs_sb.h> |
57e62324 | 44 | #include <linux/key.h> |
3cd0f37a BS |
45 | #include <linux/keyctl.h> |
46 | #include <linux/key-type.h> | |
3cd0f37a | 47 | #include <keys/user-type.h> |
3cd0f37a | 48 | #include <linux/module.h> |
57e62324 | 49 | |
3cd0f37a | 50 | #include "internal.h" |
17347d03 | 51 | #include "netns.h" |
1f2d30b5 | 52 | #include "nfs4trace.h" |
3cd0f37a BS |
53 | |
54 | #define NFS_UINT_MAXLEN 11 | |
3cd0f37a | 55 | |
17280175 TM |
56 | static const struct cred *id_resolver_cache; |
57 | static struct key_type key_type_id_resolver_legacy; | |
3cd0f37a | 58 | |
c5066945 BS |
59 | struct idmap_legacy_upcalldata { |
60 | struct rpc_pipe_msg pipe_msg; | |
61 | struct idmap_msg idmap_msg; | |
0cac1202 | 62 | struct key_construction *key_cons; |
c5066945 BS |
63 | struct idmap *idmap; |
64 | }; | |
65 | ||
0cac1202 TM |
66 | struct idmap { |
67 | struct rpc_pipe *idmap_pipe; | |
68 | struct idmap_legacy_upcalldata *idmap_upcall_data; | |
69 | struct mutex idmap_mutex; | |
70 | }; | |
71 | ||
6926afd1 TM |
72 | /** |
73 | * nfs_fattr_init_names - initialise the nfs_fattr owner_name/group_name fields | |
74 | * @fattr: fully initialised struct nfs_fattr | |
75 | * @owner_name: owner name string cache | |
76 | * @group_name: group name string cache | |
77 | */ | |
78 | void nfs_fattr_init_names(struct nfs_fattr *fattr, | |
79 | struct nfs4_string *owner_name, | |
80 | struct nfs4_string *group_name) | |
81 | { | |
82 | fattr->owner_name = owner_name; | |
83 | fattr->group_name = group_name; | |
84 | } | |
85 | ||
86 | static void nfs_fattr_free_owner_name(struct nfs_fattr *fattr) | |
87 | { | |
88 | fattr->valid &= ~NFS_ATTR_FATTR_OWNER_NAME; | |
89 | kfree(fattr->owner_name->data); | |
90 | } | |
91 | ||
92 | static void nfs_fattr_free_group_name(struct nfs_fattr *fattr) | |
93 | { | |
94 | fattr->valid &= ~NFS_ATTR_FATTR_GROUP_NAME; | |
95 | kfree(fattr->group_name->data); | |
96 | } | |
97 | ||
98 | static bool nfs_fattr_map_owner_name(struct nfs_server *server, struct nfs_fattr *fattr) | |
99 | { | |
100 | struct nfs4_string *owner = fattr->owner_name; | |
9f309c86 | 101 | kuid_t uid; |
6926afd1 TM |
102 | |
103 | if (!(fattr->valid & NFS_ATTR_FATTR_OWNER_NAME)) | |
104 | return false; | |
105 | if (nfs_map_name_to_uid(server, owner->data, owner->len, &uid) == 0) { | |
106 | fattr->uid = uid; | |
107 | fattr->valid |= NFS_ATTR_FATTR_OWNER; | |
108 | } | |
109 | return true; | |
110 | } | |
111 | ||
112 | static bool nfs_fattr_map_group_name(struct nfs_server *server, struct nfs_fattr *fattr) | |
113 | { | |
114 | struct nfs4_string *group = fattr->group_name; | |
9f309c86 | 115 | kgid_t gid; |
6926afd1 TM |
116 | |
117 | if (!(fattr->valid & NFS_ATTR_FATTR_GROUP_NAME)) | |
118 | return false; | |
119 | if (nfs_map_group_to_gid(server, group->data, group->len, &gid) == 0) { | |
120 | fattr->gid = gid; | |
121 | fattr->valid |= NFS_ATTR_FATTR_GROUP; | |
122 | } | |
123 | return true; | |
124 | } | |
125 | ||
126 | /** | |
127 | * nfs_fattr_free_names - free up the NFSv4 owner and group strings | |
128 | * @fattr: a fully initialised nfs_fattr structure | |
129 | */ | |
130 | void nfs_fattr_free_names(struct nfs_fattr *fattr) | |
131 | { | |
132 | if (fattr->valid & NFS_ATTR_FATTR_OWNER_NAME) | |
133 | nfs_fattr_free_owner_name(fattr); | |
134 | if (fattr->valid & NFS_ATTR_FATTR_GROUP_NAME) | |
135 | nfs_fattr_free_group_name(fattr); | |
136 | } | |
137 | ||
138 | /** | |
139 | * nfs_fattr_map_and_free_names - map owner/group strings into uid/gid and free | |
140 | * @server: pointer to the filesystem nfs_server structure | |
141 | * @fattr: a fully initialised nfs_fattr structure | |
142 | * | |
143 | * This helper maps the cached NFSv4 owner/group strings in fattr into | |
144 | * their numeric uid/gid equivalents, and then frees the cached strings. | |
145 | */ | |
146 | void nfs_fattr_map_and_free_names(struct nfs_server *server, struct nfs_fattr *fattr) | |
147 | { | |
148 | if (nfs_fattr_map_owner_name(server, fattr)) | |
149 | nfs_fattr_free_owner_name(fattr); | |
150 | if (nfs_fattr_map_group_name(server, fattr)) | |
151 | nfs_fattr_free_group_name(fattr); | |
152 | } | |
5cf36cfd TM |
153 | |
154 | static int nfs_map_string_to_numeric(const char *name, size_t namelen, __u32 *res) | |
155 | { | |
156 | unsigned long val; | |
157 | char buf[16]; | |
158 | ||
159 | if (memchr(name, '@', namelen) != NULL || namelen >= sizeof(buf)) | |
160 | return 0; | |
161 | memcpy(buf, name, namelen); | |
162 | buf[namelen] = '\0'; | |
7297cb68 | 163 | if (kstrtoul(buf, 0, &val) != 0) |
5cf36cfd TM |
164 | return 0; |
165 | *res = val; | |
166 | return 1; | |
167 | } | |
1da177e4 | 168 | |
f0b85168 TM |
169 | static int nfs_map_numeric_to_string(__u32 id, char *buf, size_t buflen) |
170 | { | |
171 | return snprintf(buf, buflen, "%u", id); | |
172 | } | |
173 | ||
17280175 | 174 | static struct key_type key_type_id_resolver = { |
955a857e BS |
175 | .name = "id_resolver", |
176 | .instantiate = user_instantiate, | |
177 | .match = user_match, | |
178 | .revoke = user_revoke, | |
179 | .destroy = user_destroy, | |
180 | .describe = user_describe, | |
181 | .read = user_read, | |
182 | }; | |
183 | ||
e6499c6f | 184 | static int nfs_idmap_init_keyring(void) |
955a857e BS |
185 | { |
186 | struct cred *cred; | |
187 | struct key *keyring; | |
188 | int ret = 0; | |
189 | ||
f9fd2d9c WAA |
190 | printk(KERN_NOTICE "NFS: Registering the %s key type\n", |
191 | key_type_id_resolver.name); | |
955a857e BS |
192 | |
193 | cred = prepare_kernel_cred(NULL); | |
194 | if (!cred) | |
195 | return -ENOMEM; | |
196 | ||
4e963d4f EB |
197 | keyring = keyring_alloc(".id_resolver", |
198 | GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred, | |
f8aa23a5 DH |
199 | (KEY_POS_ALL & ~KEY_POS_SETATTR) | |
200 | KEY_USR_VIEW | KEY_USR_READ, | |
201 | KEY_ALLOC_NOT_IN_QUOTA, NULL); | |
955a857e BS |
202 | if (IS_ERR(keyring)) { |
203 | ret = PTR_ERR(keyring); | |
204 | goto failed_put_cred; | |
205 | } | |
206 | ||
955a857e BS |
207 | ret = register_key_type(&key_type_id_resolver); |
208 | if (ret < 0) | |
209 | goto failed_put_key; | |
210 | ||
a427b9ec DH |
211 | ret = register_key_type(&key_type_id_resolver_legacy); |
212 | if (ret < 0) | |
213 | goto failed_reg_legacy; | |
214 | ||
700920eb | 215 | set_bit(KEY_FLAG_ROOT_CAN_CLEAR, &keyring->flags); |
955a857e BS |
216 | cred->thread_keyring = keyring; |
217 | cred->jit_keyring = KEY_REQKEY_DEFL_THREAD_KEYRING; | |
218 | id_resolver_cache = cred; | |
219 | return 0; | |
220 | ||
a427b9ec DH |
221 | failed_reg_legacy: |
222 | unregister_key_type(&key_type_id_resolver); | |
955a857e BS |
223 | failed_put_key: |
224 | key_put(keyring); | |
225 | failed_put_cred: | |
226 | put_cred(cred); | |
227 | return ret; | |
228 | } | |
229 | ||
e6499c6f | 230 | static void nfs_idmap_quit_keyring(void) |
955a857e BS |
231 | { |
232 | key_revoke(id_resolver_cache->thread_keyring); | |
233 | unregister_key_type(&key_type_id_resolver); | |
a427b9ec | 234 | unregister_key_type(&key_type_id_resolver_legacy); |
955a857e BS |
235 | put_cred(id_resolver_cache); |
236 | } | |
237 | ||
238 | /* | |
239 | * Assemble the description to pass to request_key() | |
240 | * This function will allocate a new string and update dest to point | |
241 | * at it. The caller is responsible for freeing dest. | |
242 | * | |
243 | * On error 0 is returned. Otherwise, the length of dest is returned. | |
244 | */ | |
245 | static ssize_t nfs_idmap_get_desc(const char *name, size_t namelen, | |
246 | const char *type, size_t typelen, char **desc) | |
247 | { | |
248 | char *cp; | |
249 | size_t desclen = typelen + namelen + 2; | |
250 | ||
251 | *desc = kmalloc(desclen, GFP_KERNEL); | |
8f0d97b4 | 252 | if (!*desc) |
955a857e BS |
253 | return -ENOMEM; |
254 | ||
255 | cp = *desc; | |
256 | memcpy(cp, type, typelen); | |
257 | cp += typelen; | |
258 | *cp++ = ':'; | |
259 | ||
260 | memcpy(cp, name, namelen); | |
261 | cp += namelen; | |
262 | *cp = '\0'; | |
263 | return desclen; | |
264 | } | |
265 | ||
ffa57b9e BS |
266 | static struct key *nfs_idmap_request_key(const char *name, size_t namelen, |
267 | const char *type, struct idmap *idmap) | |
955a857e | 268 | { |
955a857e | 269 | char *desc; |
ffa57b9e | 270 | struct key *rkey; |
955a857e BS |
271 | ssize_t ret; |
272 | ||
273 | ret = nfs_idmap_get_desc(name, namelen, type, strlen(type), &desc); | |
274 | if (ret <= 0) | |
ffa57b9e BS |
275 | return ERR_PTR(ret); |
276 | ||
277 | rkey = request_key(&key_type_id_resolver, desc, ""); | |
278 | if (IS_ERR(rkey)) { | |
279 | mutex_lock(&idmap->idmap_mutex); | |
280 | rkey = request_key_with_auxdata(&key_type_id_resolver_legacy, | |
281 | desc, "", 0, idmap); | |
282 | mutex_unlock(&idmap->idmap_mutex); | |
283 | } | |
284 | ||
285 | kfree(desc); | |
286 | return rkey; | |
287 | } | |
288 | ||
289 | static ssize_t nfs_idmap_get_key(const char *name, size_t namelen, | |
290 | const char *type, void *data, | |
291 | size_t data_size, struct idmap *idmap) | |
292 | { | |
293 | const struct cred *saved_cred; | |
294 | struct key *rkey; | |
295 | struct user_key_payload *payload; | |
296 | ssize_t ret; | |
955a857e BS |
297 | |
298 | saved_cred = override_creds(id_resolver_cache); | |
ffa57b9e | 299 | rkey = nfs_idmap_request_key(name, namelen, type, idmap); |
955a857e | 300 | revert_creds(saved_cred); |
57e62324 | 301 | |
955a857e BS |
302 | if (IS_ERR(rkey)) { |
303 | ret = PTR_ERR(rkey); | |
304 | goto out; | |
305 | } | |
306 | ||
307 | rcu_read_lock(); | |
308 | rkey->perm |= KEY_USR_VIEW; | |
309 | ||
310 | ret = key_validate(rkey); | |
311 | if (ret < 0) | |
312 | goto out_up; | |
313 | ||
393faffe | 314 | payload = rcu_dereference(rkey->payload.rcudata); |
955a857e BS |
315 | if (IS_ERR_OR_NULL(payload)) { |
316 | ret = PTR_ERR(payload); | |
317 | goto out_up; | |
318 | } | |
319 | ||
320 | ret = payload->datalen; | |
321 | if (ret > 0 && ret <= data_size) | |
322 | memcpy(data, payload->data, ret); | |
323 | else | |
324 | ret = -EINVAL; | |
325 | ||
326 | out_up: | |
327 | rcu_read_unlock(); | |
328 | key_put(rkey); | |
329 | out: | |
330 | return ret; | |
331 | } | |
332 | ||
955a857e | 333 | /* ID -> Name */ |
57e62324 BS |
334 | static ssize_t nfs_idmap_lookup_name(__u32 id, const char *type, char *buf, |
335 | size_t buflen, struct idmap *idmap) | |
955a857e BS |
336 | { |
337 | char id_str[NFS_UINT_MAXLEN]; | |
338 | int id_len; | |
339 | ssize_t ret; | |
340 | ||
341 | id_len = snprintf(id_str, sizeof(id_str), "%u", id); | |
57e62324 | 342 | ret = nfs_idmap_get_key(id_str, id_len, type, buf, buflen, idmap); |
955a857e BS |
343 | if (ret < 0) |
344 | return -EINVAL; | |
345 | return ret; | |
346 | } | |
347 | ||
348 | /* Name -> ID */ | |
57e62324 BS |
349 | static int nfs_idmap_lookup_id(const char *name, size_t namelen, const char *type, |
350 | __u32 *id, struct idmap *idmap) | |
955a857e BS |
351 | { |
352 | char id_str[NFS_UINT_MAXLEN]; | |
353 | long id_long; | |
354 | ssize_t data_size; | |
355 | int ret = 0; | |
356 | ||
57e62324 | 357 | data_size = nfs_idmap_get_key(name, namelen, type, id_str, NFS_UINT_MAXLEN, idmap); |
955a857e BS |
358 | if (data_size <= 0) { |
359 | ret = -EINVAL; | |
360 | } else { | |
7297cb68 | 361 | ret = kstrtol(id_str, 10, &id_long); |
955a857e BS |
362 | *id = (__u32)id_long; |
363 | } | |
364 | return ret; | |
365 | } | |
366 | ||
e6499c6f | 367 | /* idmap classic begins here */ |
f0b85168 | 368 | |
57e62324 BS |
369 | enum { |
370 | Opt_find_uid, Opt_find_gid, Opt_find_user, Opt_find_group, Opt_find_err | |
1da177e4 LT |
371 | }; |
372 | ||
57e62324 BS |
373 | static const match_table_t nfs_idmap_tokens = { |
374 | { Opt_find_uid, "uid:%s" }, | |
375 | { Opt_find_gid, "gid:%s" }, | |
376 | { Opt_find_user, "user:%s" }, | |
377 | { Opt_find_group, "group:%s" }, | |
378 | { Opt_find_err, NULL } | |
1da177e4 LT |
379 | }; |
380 | ||
57e62324 | 381 | static int nfs_idmap_legacy_upcall(struct key_construction *, const char *, void *); |
369af0f1 CL |
382 | static ssize_t idmap_pipe_downcall(struct file *, const char __user *, |
383 | size_t); | |
c5066945 | 384 | static void idmap_release_pipe(struct inode *); |
369af0f1 | 385 | static void idmap_pipe_destroy_msg(struct rpc_pipe_msg *); |
1da177e4 | 386 | |
b693ba4a | 387 | static const struct rpc_pipe_ops idmap_upcall_ops = { |
c1225158 | 388 | .upcall = rpc_pipe_generic_upcall, |
369af0f1 | 389 | .downcall = idmap_pipe_downcall, |
c5066945 | 390 | .release_pipe = idmap_release_pipe, |
369af0f1 | 391 | .destroy_msg = idmap_pipe_destroy_msg, |
1da177e4 LT |
392 | }; |
393 | ||
17280175 | 394 | static struct key_type key_type_id_resolver_legacy = { |
a427b9ec | 395 | .name = "id_legacy", |
57e62324 BS |
396 | .instantiate = user_instantiate, |
397 | .match = user_match, | |
398 | .revoke = user_revoke, | |
399 | .destroy = user_destroy, | |
400 | .describe = user_describe, | |
401 | .read = user_read, | |
402 | .request_key = nfs_idmap_legacy_upcall, | |
403 | }; | |
404 | ||
4929d1d3 SK |
405 | static void __nfs_idmap_unregister(struct rpc_pipe *pipe) |
406 | { | |
d7631250 | 407 | if (pipe->dentry) { |
4929d1d3 | 408 | rpc_unlink(pipe->dentry); |
d7631250 TM |
409 | pipe->dentry = NULL; |
410 | } | |
4929d1d3 SK |
411 | } |
412 | ||
413 | static int __nfs_idmap_register(struct dentry *dir, | |
414 | struct idmap *idmap, | |
415 | struct rpc_pipe *pipe) | |
416 | { | |
417 | struct dentry *dentry; | |
418 | ||
419 | dentry = rpc_mkpipe_dentry(dir, "idmap", idmap, pipe); | |
420 | if (IS_ERR(dentry)) | |
421 | return PTR_ERR(dentry); | |
422 | pipe->dentry = dentry; | |
423 | return 0; | |
424 | } | |
425 | ||
426 | static void nfs_idmap_unregister(struct nfs_client *clp, | |
427 | struct rpc_pipe *pipe) | |
428 | { | |
73ea666c | 429 | struct net *net = clp->cl_net; |
4929d1d3 SK |
430 | struct super_block *pipefs_sb; |
431 | ||
432 | pipefs_sb = rpc_get_sb_net(net); | |
433 | if (pipefs_sb) { | |
434 | __nfs_idmap_unregister(pipe); | |
435 | rpc_put_sb_net(net); | |
436 | } | |
437 | } | |
438 | ||
439 | static int nfs_idmap_register(struct nfs_client *clp, | |
440 | struct idmap *idmap, | |
441 | struct rpc_pipe *pipe) | |
442 | { | |
73ea666c | 443 | struct net *net = clp->cl_net; |
4929d1d3 SK |
444 | struct super_block *pipefs_sb; |
445 | int err = 0; | |
446 | ||
447 | pipefs_sb = rpc_get_sb_net(net); | |
448 | if (pipefs_sb) { | |
449 | if (clp->cl_rpcclient->cl_dentry) | |
450 | err = __nfs_idmap_register(clp->cl_rpcclient->cl_dentry, | |
451 | idmap, pipe); | |
452 | rpc_put_sb_net(net); | |
453 | } | |
454 | return err; | |
455 | } | |
456 | ||
b7162792 | 457 | int |
adfa6f98 | 458 | nfs_idmap_new(struct nfs_client *clp) |
1da177e4 LT |
459 | { |
460 | struct idmap *idmap; | |
c239d83b | 461 | struct rpc_pipe *pipe; |
b7162792 | 462 | int error; |
1da177e4 | 463 | |
369af0f1 CL |
464 | idmap = kzalloc(sizeof(*idmap), GFP_KERNEL); |
465 | if (idmap == NULL) | |
466 | return -ENOMEM; | |
1da177e4 | 467 | |
c239d83b SK |
468 | pipe = rpc_mkpipe_data(&idmap_upcall_ops, 0); |
469 | if (IS_ERR(pipe)) { | |
470 | error = PTR_ERR(pipe); | |
1da177e4 | 471 | kfree(idmap); |
b7162792 | 472 | return error; |
1da177e4 | 473 | } |
4929d1d3 SK |
474 | error = nfs_idmap_register(clp, idmap, pipe); |
475 | if (error) { | |
c239d83b SK |
476 | rpc_destroy_pipe_data(pipe); |
477 | kfree(idmap); | |
478 | return error; | |
479 | } | |
480 | idmap->idmap_pipe = pipe; | |
b1027439 | 481 | mutex_init(&idmap->idmap_mutex); |
1da177e4 LT |
482 | |
483 | clp->cl_idmap = idmap; | |
b7162792 | 484 | return 0; |
1da177e4 LT |
485 | } |
486 | ||
487 | void | |
adfa6f98 | 488 | nfs_idmap_delete(struct nfs_client *clp) |
1da177e4 LT |
489 | { |
490 | struct idmap *idmap = clp->cl_idmap; | |
491 | ||
492 | if (!idmap) | |
493 | return; | |
4929d1d3 | 494 | nfs_idmap_unregister(clp, idmap->idmap_pipe); |
c239d83b | 495 | rpc_destroy_pipe_data(idmap->idmap_pipe); |
1da177e4 LT |
496 | clp->cl_idmap = NULL; |
497 | kfree(idmap); | |
498 | } | |
499 | ||
eee17325 SK |
500 | static int __rpc_pipefs_event(struct nfs_client *clp, unsigned long event, |
501 | struct super_block *sb) | |
1da177e4 | 502 | { |
eee17325 | 503 | int err = 0; |
1da177e4 | 504 | |
eee17325 SK |
505 | switch (event) { |
506 | case RPC_PIPEFS_MOUNT: | |
eee17325 SK |
507 | err = __nfs_idmap_register(clp->cl_rpcclient->cl_dentry, |
508 | clp->cl_idmap, | |
509 | clp->cl_idmap->idmap_pipe); | |
510 | break; | |
511 | case RPC_PIPEFS_UMOUNT: | |
512 | if (clp->cl_idmap->idmap_pipe) { | |
513 | struct dentry *parent; | |
514 | ||
515 | parent = clp->cl_idmap->idmap_pipe->dentry->d_parent; | |
516 | __nfs_idmap_unregister(clp->cl_idmap->idmap_pipe); | |
517 | /* | |
518 | * Note: This is a dirty hack. SUNRPC hook has been | |
519 | * called already but simple_rmdir() call for the | |
520 | * directory returned with error because of idmap pipe | |
521 | * inside. Thus now we have to remove this directory | |
522 | * here. | |
523 | */ | |
524 | if (rpc_rmdir(parent)) | |
a030889a WAA |
525 | printk(KERN_ERR "NFS: %s: failed to remove " |
526 | "clnt dir!\n", __func__); | |
eee17325 SK |
527 | } |
528 | break; | |
529 | default: | |
a030889a WAA |
530 | printk(KERN_ERR "NFS: %s: unknown event: %ld\n", __func__, |
531 | event); | |
eee17325 SK |
532 | return -ENOTSUPP; |
533 | } | |
534 | return err; | |
535 | } | |
536 | ||
e9dbca8d | 537 | static struct nfs_client *nfs_get_client_for_event(struct net *net, int event) |
eee17325 | 538 | { |
e9dbca8d SK |
539 | struct nfs_net *nn = net_generic(net, nfs_net_id); |
540 | struct dentry *cl_dentry; | |
eee17325 | 541 | struct nfs_client *clp; |
4697bd5e | 542 | int err; |
eee17325 | 543 | |
4697bd5e | 544 | restart: |
dc030858 | 545 | spin_lock(&nn->nfs_client_lock); |
6b13168b | 546 | list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) { |
4697bd5e TM |
547 | /* Wait for initialisation to finish */ |
548 | if (clp->cl_cons_state == NFS_CS_INITING) { | |
549 | atomic_inc(&clp->cl_count); | |
550 | spin_unlock(&nn->nfs_client_lock); | |
551 | err = nfs_wait_client_init_complete(clp); | |
552 | nfs_put_client(clp); | |
553 | if (err) | |
554 | return NULL; | |
555 | goto restart; | |
556 | } | |
557 | /* Skip nfs_clients that failed to initialise */ | |
558 | if (clp->cl_cons_state < 0) | |
559 | continue; | |
54ac471c | 560 | smp_rmb(); |
eee17325 SK |
561 | if (clp->rpc_ops != &nfs_v4_clientops) |
562 | continue; | |
e9dbca8d SK |
563 | cl_dentry = clp->cl_idmap->idmap_pipe->dentry; |
564 | if (((event == RPC_PIPEFS_MOUNT) && cl_dentry) || | |
565 | ((event == RPC_PIPEFS_UMOUNT) && !cl_dentry)) | |
566 | continue; | |
567 | atomic_inc(&clp->cl_count); | |
568 | spin_unlock(&nn->nfs_client_lock); | |
569 | return clp; | |
570 | } | |
571 | spin_unlock(&nn->nfs_client_lock); | |
572 | return NULL; | |
1da177e4 LT |
573 | } |
574 | ||
e9dbca8d SK |
575 | static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event, |
576 | void *ptr) | |
1da177e4 | 577 | { |
e9dbca8d SK |
578 | struct super_block *sb = ptr; |
579 | struct nfs_client *clp; | |
580 | int error = 0; | |
1da177e4 | 581 | |
71dfc5fa SK |
582 | if (!try_module_get(THIS_MODULE)) |
583 | return 0; | |
584 | ||
e9dbca8d | 585 | while ((clp = nfs_get_client_for_event(sb->s_fs_info, event))) { |
eee17325 | 586 | error = __rpc_pipefs_event(clp, event, sb); |
e9dbca8d | 587 | nfs_put_client(clp); |
eee17325 SK |
588 | if (error) |
589 | break; | |
590 | } | |
71dfc5fa | 591 | module_put(THIS_MODULE); |
eee17325 | 592 | return error; |
1da177e4 LT |
593 | } |
594 | ||
eee17325 SK |
595 | #define PIPEFS_NFS_PRIO 1 |
596 | ||
597 | static struct notifier_block nfs_idmap_block = { | |
598 | .notifier_call = rpc_pipefs_event, | |
599 | .priority = SUNRPC_PIPEFS_NFS_PRIO, | |
600 | }; | |
1da177e4 | 601 | |
eee17325 | 602 | int nfs_idmap_init(void) |
1da177e4 | 603 | { |
e6499c6f BS |
604 | int ret; |
605 | ret = nfs_idmap_init_keyring(); | |
606 | if (ret != 0) | |
607 | goto out; | |
608 | ret = rpc_pipefs_notifier_register(&nfs_idmap_block); | |
609 | if (ret != 0) | |
610 | nfs_idmap_quit_keyring(); | |
611 | out: | |
612 | return ret; | |
1da177e4 LT |
613 | } |
614 | ||
eee17325 | 615 | void nfs_idmap_quit(void) |
1da177e4 | 616 | { |
eee17325 | 617 | rpc_pipefs_notifier_unregister(&nfs_idmap_block); |
e6499c6f | 618 | nfs_idmap_quit_keyring(); |
1da177e4 LT |
619 | } |
620 | ||
c5066945 BS |
621 | static int nfs_idmap_prepare_message(char *desc, struct idmap *idmap, |
622 | struct idmap_msg *im, | |
57e62324 | 623 | struct rpc_pipe_msg *msg) |
1da177e4 | 624 | { |
57e62324 BS |
625 | substring_t substr; |
626 | int token, ret; | |
1da177e4 | 627 | |
57e62324 BS |
628 | im->im_type = IDMAP_TYPE_GROUP; |
629 | token = match_token(desc, nfs_idmap_tokens, &substr); | |
1da177e4 | 630 | |
57e62324 BS |
631 | switch (token) { |
632 | case Opt_find_uid: | |
633 | im->im_type = IDMAP_TYPE_USER; | |
634 | case Opt_find_gid: | |
635 | im->im_conv = IDMAP_CONV_NAMETOID; | |
636 | ret = match_strlcpy(im->im_name, &substr, IDMAP_NAMESZ); | |
637 | break; | |
1da177e4 | 638 | |
57e62324 BS |
639 | case Opt_find_user: |
640 | im->im_type = IDMAP_TYPE_USER; | |
641 | case Opt_find_group: | |
642 | im->im_conv = IDMAP_CONV_IDTONAME; | |
643 | ret = match_int(&substr, &im->im_id); | |
644 | break; | |
1da177e4 | 645 | |
57e62324 BS |
646 | default: |
647 | ret = -EINVAL; | |
1da177e4 LT |
648 | goto out; |
649 | } | |
650 | ||
57e62324 BS |
651 | msg->data = im; |
652 | msg->len = sizeof(struct idmap_msg); | |
1da177e4 | 653 | |
57e62324 | 654 | out: |
369af0f1 | 655 | return ret; |
1da177e4 LT |
656 | } |
657 | ||
e9ab41b6 TM |
658 | static bool |
659 | nfs_idmap_prepare_pipe_upcall(struct idmap *idmap, | |
0cac1202 | 660 | struct idmap_legacy_upcalldata *data) |
e9ab41b6 | 661 | { |
0cac1202 | 662 | if (idmap->idmap_upcall_data != NULL) { |
e9ab41b6 TM |
663 | WARN_ON_ONCE(1); |
664 | return false; | |
665 | } | |
0cac1202 | 666 | idmap->idmap_upcall_data = data; |
e9ab41b6 TM |
667 | return true; |
668 | } | |
669 | ||
670 | static void | |
671 | nfs_idmap_complete_pipe_upcall_locked(struct idmap *idmap, int ret) | |
672 | { | |
0cac1202 | 673 | struct key_construction *cons = idmap->idmap_upcall_data->key_cons; |
e9ab41b6 | 674 | |
0cac1202 TM |
675 | kfree(idmap->idmap_upcall_data); |
676 | idmap->idmap_upcall_data = NULL; | |
e9ab41b6 TM |
677 | complete_request_key(cons, ret); |
678 | } | |
679 | ||
680 | static void | |
681 | nfs_idmap_abort_pipe_upcall(struct idmap *idmap, int ret) | |
682 | { | |
0cac1202 | 683 | if (idmap->idmap_upcall_data != NULL) |
e9ab41b6 TM |
684 | nfs_idmap_complete_pipe_upcall_locked(idmap, ret); |
685 | } | |
686 | ||
57e62324 BS |
687 | static int nfs_idmap_legacy_upcall(struct key_construction *cons, |
688 | const char *op, | |
689 | void *aux) | |
1da177e4 | 690 | { |
c5066945 | 691 | struct idmap_legacy_upcalldata *data; |
57e62324 | 692 | struct rpc_pipe_msg *msg; |
1da177e4 | 693 | struct idmap_msg *im; |
57e62324 BS |
694 | struct idmap *idmap = (struct idmap *)aux; |
695 | struct key *key = cons->key; | |
5abc03cd | 696 | int ret = -ENOMEM; |
1da177e4 | 697 | |
57e62324 | 698 | /* msg and im are freed in idmap_pipe_destroy_msg */ |
57a51048 | 699 | data = kzalloc(sizeof(*data), GFP_KERNEL); |
c5066945 | 700 | if (!data) |
57e62324 | 701 | goto out1; |
1da177e4 | 702 | |
c5066945 BS |
703 | msg = &data->pipe_msg; |
704 | im = &data->idmap_msg; | |
705 | data->idmap = idmap; | |
ddfc4e17 | 706 | data->key_cons = cons; |
c5066945 BS |
707 | |
708 | ret = nfs_idmap_prepare_message(key->description, idmap, im, msg); | |
57e62324 BS |
709 | if (ret < 0) |
710 | goto out2; | |
1da177e4 | 711 | |
e9ab41b6 | 712 | ret = -EAGAIN; |
0cac1202 | 713 | if (!nfs_idmap_prepare_pipe_upcall(idmap, data)) |
0e24d849 | 714 | goto out2; |
1da177e4 | 715 | |
11588f49 BS |
716 | ret = rpc_queue_upcall(idmap->idmap_pipe, msg); |
717 | if (ret < 0) | |
e9ab41b6 | 718 | nfs_idmap_abort_pipe_upcall(idmap, ret); |
1da177e4 | 719 | |
11588f49 | 720 | return ret; |
57e62324 | 721 | out2: |
c5066945 | 722 | kfree(data); |
57e62324 | 723 | out1: |
a427b9ec | 724 | complete_request_key(cons, ret); |
369af0f1 | 725 | return ret; |
1da177e4 LT |
726 | } |
727 | ||
cf4ab538 | 728 | static int nfs_idmap_instantiate(struct key *key, struct key *authkey, char *data, size_t datalen) |
1da177e4 | 729 | { |
cf4ab538 | 730 | return key_instantiate_and_link(key, data, datalen, |
57e62324 BS |
731 | id_resolver_cache->thread_keyring, |
732 | authkey); | |
733 | } | |
1da177e4 | 734 | |
0cac1202 TM |
735 | static int nfs_idmap_read_and_verify_message(struct idmap_msg *im, |
736 | struct idmap_msg *upcall, | |
737 | struct key *key, struct key *authkey) | |
57e62324 BS |
738 | { |
739 | char id_str[NFS_UINT_MAXLEN]; | |
cf4ab538 | 740 | size_t len; |
0cac1202 | 741 | int ret = -ENOKEY; |
1da177e4 | 742 | |
0cac1202 TM |
743 | /* ret = -ENOKEY */ |
744 | if (upcall->im_type != im->im_type || upcall->im_conv != im->im_conv) | |
745 | goto out; | |
57e62324 BS |
746 | switch (im->im_conv) { |
747 | case IDMAP_CONV_NAMETOID: | |
0cac1202 TM |
748 | if (strcmp(upcall->im_name, im->im_name) != 0) |
749 | break; | |
cf4ab538 TM |
750 | /* Note: here we store the NUL terminator too */ |
751 | len = sprintf(id_str, "%d", im->im_id) + 1; | |
752 | ret = nfs_idmap_instantiate(key, authkey, id_str, len); | |
57e62324 BS |
753 | break; |
754 | case IDMAP_CONV_IDTONAME: | |
0cac1202 TM |
755 | if (upcall->im_id != im->im_id) |
756 | break; | |
cf4ab538 TM |
757 | len = strlen(im->im_name); |
758 | ret = nfs_idmap_instantiate(key, authkey, im->im_name, len); | |
57e62324 | 759 | break; |
0cac1202 TM |
760 | default: |
761 | ret = -EINVAL; | |
1da177e4 | 762 | } |
0cac1202 | 763 | out: |
1da177e4 LT |
764 | return ret; |
765 | } | |
766 | ||
1da177e4 LT |
767 | static ssize_t |
768 | idmap_pipe_downcall(struct file *filp, const char __user *src, size_t mlen) | |
769 | { | |
496ad9aa | 770 | struct rpc_inode *rpci = RPC_I(file_inode(filp)); |
1da177e4 | 771 | struct idmap *idmap = (struct idmap *)rpci->private; |
a427b9ec | 772 | struct key_construction *cons; |
57e62324 | 773 | struct idmap_msg im; |
d24aae41 | 774 | size_t namelen_in; |
e9ab41b6 | 775 | int ret = -ENOKEY; |
1da177e4 | 776 | |
a427b9ec DH |
777 | /* If instantiation is successful, anyone waiting for key construction |
778 | * will have been woken up and someone else may now have used | |
779 | * idmap_key_cons - so after this point we may no longer touch it. | |
780 | */ | |
0cac1202 | 781 | if (idmap->idmap_upcall_data == NULL) |
e9ab41b6 | 782 | goto out_noupcall; |
a427b9ec | 783 | |
0cac1202 | 784 | cons = idmap->idmap_upcall_data->key_cons; |
a427b9ec | 785 | |
57e62324 BS |
786 | if (mlen != sizeof(im)) { |
787 | ret = -ENOSPC; | |
1da177e4 LT |
788 | goto out; |
789 | } | |
790 | ||
57e62324 BS |
791 | if (copy_from_user(&im, src, mlen) != 0) { |
792 | ret = -EFAULT; | |
1da177e4 | 793 | goto out; |
57e62324 | 794 | } |
1da177e4 | 795 | |
57e62324 | 796 | if (!(im.im_status & IDMAP_STATUS_SUCCESS)) { |
12dfd080 BS |
797 | ret = -ENOKEY; |
798 | goto out; | |
1da177e4 LT |
799 | } |
800 | ||
57e62324 BS |
801 | namelen_in = strnlen(im.im_name, IDMAP_NAMESZ); |
802 | if (namelen_in == 0 || namelen_in == IDMAP_NAMESZ) { | |
803 | ret = -EINVAL; | |
1da177e4 | 804 | goto out; |
0cac1202 | 805 | } |
1da177e4 | 806 | |
0cac1202 TM |
807 | ret = nfs_idmap_read_and_verify_message(&im, |
808 | &idmap->idmap_upcall_data->idmap_msg, | |
809 | cons->key, cons->authkey); | |
57e62324 BS |
810 | if (ret >= 0) { |
811 | key_set_timeout(cons->key, nfs_idmap_cache_timeout); | |
812 | ret = mlen; | |
813 | } | |
814 | ||
1da177e4 | 815 | out: |
e9ab41b6 TM |
816 | nfs_idmap_complete_pipe_upcall_locked(idmap, ret); |
817 | out_noupcall: | |
1da177e4 LT |
818 | return ret; |
819 | } | |
820 | ||
75c96f85 | 821 | static void |
1da177e4 LT |
822 | idmap_pipe_destroy_msg(struct rpc_pipe_msg *msg) |
823 | { | |
c5066945 BS |
824 | struct idmap_legacy_upcalldata *data = container_of(msg, |
825 | struct idmap_legacy_upcalldata, | |
826 | pipe_msg); | |
827 | struct idmap *idmap = data->idmap; | |
e9ab41b6 TM |
828 | |
829 | if (msg->errno) | |
830 | nfs_idmap_abort_pipe_upcall(idmap, msg->errno); | |
c5066945 BS |
831 | } |
832 | ||
833 | static void | |
834 | idmap_release_pipe(struct inode *inode) | |
835 | { | |
836 | struct rpc_inode *rpci = RPC_I(inode); | |
837 | struct idmap *idmap = (struct idmap *)rpci->private; | |
e9ab41b6 TM |
838 | |
839 | nfs_idmap_abort_pipe_upcall(idmap, -EPIPE); | |
1da177e4 LT |
840 | } |
841 | ||
9f309c86 | 842 | int nfs_map_name_to_uid(const struct nfs_server *server, const char *name, size_t namelen, kuid_t *uid) |
1da177e4 | 843 | { |
e4fd72a1 | 844 | struct idmap *idmap = server->nfs_client->cl_idmap; |
9f309c86 EB |
845 | __u32 id = -1; |
846 | int ret = 0; | |
1da177e4 | 847 | |
9f309c86 EB |
848 | if (!nfs_map_string_to_numeric(name, namelen, &id)) |
849 | ret = nfs_idmap_lookup_id(name, namelen, "uid", &id, idmap); | |
850 | if (ret == 0) { | |
851 | *uid = make_kuid(&init_user_ns, id); | |
852 | if (!uid_valid(*uid)) | |
853 | ret = -ERANGE; | |
854 | } | |
1f2d30b5 | 855 | trace_nfs4_map_name_to_uid(name, namelen, id, ret); |
9f309c86 | 856 | return ret; |
1da177e4 LT |
857 | } |
858 | ||
9f309c86 | 859 | int nfs_map_group_to_gid(const struct nfs_server *server, const char *name, size_t namelen, kgid_t *gid) |
1da177e4 | 860 | { |
e4fd72a1 | 861 | struct idmap *idmap = server->nfs_client->cl_idmap; |
9f309c86 EB |
862 | __u32 id = -1; |
863 | int ret = 0; | |
1da177e4 | 864 | |
9f309c86 EB |
865 | if (!nfs_map_string_to_numeric(name, namelen, &id)) |
866 | ret = nfs_idmap_lookup_id(name, namelen, "gid", &id, idmap); | |
867 | if (ret == 0) { | |
868 | *gid = make_kgid(&init_user_ns, id); | |
869 | if (!gid_valid(*gid)) | |
870 | ret = -ERANGE; | |
871 | } | |
1f2d30b5 | 872 | trace_nfs4_map_group_to_gid(name, namelen, id, ret); |
9f309c86 | 873 | return ret; |
1da177e4 LT |
874 | } |
875 | ||
9f309c86 | 876 | int nfs_map_uid_to_name(const struct nfs_server *server, kuid_t uid, char *buf, size_t buflen) |
1da177e4 | 877 | { |
e4fd72a1 | 878 | struct idmap *idmap = server->nfs_client->cl_idmap; |
b064eca2 | 879 | int ret = -EINVAL; |
9f309c86 | 880 | __u32 id; |
1da177e4 | 881 | |
9f309c86 | 882 | id = from_kuid(&init_user_ns, uid); |
b064eca2 | 883 | if (!(server->caps & NFS_CAP_UIDGID_NOMAP)) |
9f309c86 | 884 | ret = nfs_idmap_lookup_name(id, "user", buf, buflen, idmap); |
f0b85168 | 885 | if (ret < 0) |
9f309c86 | 886 | ret = nfs_map_numeric_to_string(id, buf, buflen); |
1f2d30b5 | 887 | trace_nfs4_map_uid_to_name(buf, ret, id, ret); |
f0b85168 | 888 | return ret; |
1da177e4 | 889 | } |
9f309c86 | 890 | int nfs_map_gid_to_group(const struct nfs_server *server, kgid_t gid, char *buf, size_t buflen) |
1da177e4 | 891 | { |
e4fd72a1 | 892 | struct idmap *idmap = server->nfs_client->cl_idmap; |
b064eca2 | 893 | int ret = -EINVAL; |
9f309c86 | 894 | __u32 id; |
1da177e4 | 895 | |
9f309c86 | 896 | id = from_kgid(&init_user_ns, gid); |
b064eca2 | 897 | if (!(server->caps & NFS_CAP_UIDGID_NOMAP)) |
9f309c86 | 898 | ret = nfs_idmap_lookup_name(id, "group", buf, buflen, idmap); |
f0b85168 | 899 | if (ret < 0) |
9f309c86 | 900 | ret = nfs_map_numeric_to_string(id, buf, buflen); |
1f2d30b5 | 901 | trace_nfs4_map_gid_to_group(buf, ret, id, ret); |
f0b85168 | 902 | return ret; |
1da177e4 | 903 | } |