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