blob: 4e2d9b6b1380394cdeca41f0d632eff513b241b8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 */
36
Bryan Schumaker955a8572010-09-29 15:41:49 -040037#ifdef CONFIG_NFS_USE_NEW_IDMAPPER
38
39#include <linux/slab.h>
40#include <linux/cred.h>
41#include <linux/nfs_idmap.h>
42#include <linux/keyctl.h>
43#include <linux/key-type.h>
44#include <linux/rcupdate.h>
45#include <linux/kernel.h>
46#include <linux/err.h>
47
48#include <keys/user-type.h>
49
50#define NFS_UINT_MAXLEN 11
51
52const struct cred *id_resolver_cache;
53
54struct key_type key_type_id_resolver = {
55 .name = "id_resolver",
56 .instantiate = user_instantiate,
57 .match = user_match,
58 .revoke = user_revoke,
59 .destroy = user_destroy,
60 .describe = user_describe,
61 .read = user_read,
62};
63
64int nfs_idmap_init(void)
65{
66 struct cred *cred;
67 struct key *keyring;
68 int ret = 0;
69
70 printk(KERN_NOTICE "Registering the %s key type\n", key_type_id_resolver.name);
71
72 cred = prepare_kernel_cred(NULL);
73 if (!cred)
74 return -ENOMEM;
75
76 keyring = key_alloc(&key_type_keyring, ".id_resolver", 0, 0, cred,
77 (KEY_POS_ALL & ~KEY_POS_SETATTR) |
78 KEY_USR_VIEW | KEY_USR_READ,
79 KEY_ALLOC_NOT_IN_QUOTA);
80 if (IS_ERR(keyring)) {
81 ret = PTR_ERR(keyring);
82 goto failed_put_cred;
83 }
84
85 ret = key_instantiate_and_link(keyring, NULL, 0, NULL, NULL);
86 if (ret < 0)
87 goto failed_put_key;
88
89 ret = register_key_type(&key_type_id_resolver);
90 if (ret < 0)
91 goto failed_put_key;
92
93 cred->thread_keyring = keyring;
94 cred->jit_keyring = KEY_REQKEY_DEFL_THREAD_KEYRING;
95 id_resolver_cache = cred;
96 return 0;
97
98failed_put_key:
99 key_put(keyring);
100failed_put_cred:
101 put_cred(cred);
102 return ret;
103}
104
105void nfs_idmap_quit(void)
106{
107 key_revoke(id_resolver_cache->thread_keyring);
108 unregister_key_type(&key_type_id_resolver);
109 put_cred(id_resolver_cache);
110}
111
112/*
113 * Assemble the description to pass to request_key()
114 * This function will allocate a new string and update dest to point
115 * at it. The caller is responsible for freeing dest.
116 *
117 * On error 0 is returned. Otherwise, the length of dest is returned.
118 */
119static ssize_t nfs_idmap_get_desc(const char *name, size_t namelen,
120 const char *type, size_t typelen, char **desc)
121{
122 char *cp;
123 size_t desclen = typelen + namelen + 2;
124
125 *desc = kmalloc(desclen, GFP_KERNEL);
Dan Carpenter8f0d97b2010-10-28 08:05:57 +0200126 if (!*desc)
Bryan Schumaker955a8572010-09-29 15:41:49 -0400127 return -ENOMEM;
128
129 cp = *desc;
130 memcpy(cp, type, typelen);
131 cp += typelen;
132 *cp++ = ':';
133
134 memcpy(cp, name, namelen);
135 cp += namelen;
136 *cp = '\0';
137 return desclen;
138}
139
140static ssize_t nfs_idmap_request_key(const char *name, size_t namelen,
141 const char *type, void *data, size_t data_size)
142{
143 const struct cred *saved_cred;
144 struct key *rkey;
145 char *desc;
146 struct user_key_payload *payload;
147 ssize_t ret;
148
149 ret = nfs_idmap_get_desc(name, namelen, type, strlen(type), &desc);
150 if (ret <= 0)
151 goto out;
152
153 saved_cred = override_creds(id_resolver_cache);
154 rkey = request_key(&key_type_id_resolver, desc, "");
155 revert_creds(saved_cred);
156 kfree(desc);
157 if (IS_ERR(rkey)) {
158 ret = PTR_ERR(rkey);
159 goto out;
160 }
161
162 rcu_read_lock();
163 rkey->perm |= KEY_USR_VIEW;
164
165 ret = key_validate(rkey);
166 if (ret < 0)
167 goto out_up;
168
169 payload = rcu_dereference(rkey->payload.data);
170 if (IS_ERR_OR_NULL(payload)) {
171 ret = PTR_ERR(payload);
172 goto out_up;
173 }
174
175 ret = payload->datalen;
176 if (ret > 0 && ret <= data_size)
177 memcpy(data, payload->data, ret);
178 else
179 ret = -EINVAL;
180
181out_up:
182 rcu_read_unlock();
183 key_put(rkey);
184out:
185 return ret;
186}
187
188
189/* ID -> Name */
190static ssize_t nfs_idmap_lookup_name(__u32 id, const char *type, char *buf, size_t buflen)
191{
192 char id_str[NFS_UINT_MAXLEN];
193 int id_len;
194 ssize_t ret;
195
196 id_len = snprintf(id_str, sizeof(id_str), "%u", id);
197 ret = nfs_idmap_request_key(id_str, id_len, type, buf, buflen);
198 if (ret < 0)
199 return -EINVAL;
200 return ret;
201}
202
203/* Name -> ID */
204static int nfs_idmap_lookup_id(const char *name, size_t namelen,
205 const char *type, __u32 *id)
206{
207 char id_str[NFS_UINT_MAXLEN];
208 long id_long;
209 ssize_t data_size;
210 int ret = 0;
211
212 data_size = nfs_idmap_request_key(name, namelen, type, id_str, NFS_UINT_MAXLEN);
213 if (data_size <= 0) {
214 ret = -EINVAL;
215 } else {
216 ret = strict_strtol(id_str, 10, &id_long);
217 *id = (__u32)id_long;
218 }
219 return ret;
220}
221
222int nfs_map_name_to_uid(struct nfs_client *clp, const char *name, size_t namelen, __u32 *uid)
223{
224 return nfs_idmap_lookup_id(name, namelen, "uid", uid);
225}
226
227int nfs_map_group_to_gid(struct nfs_client *clp, const char *name, size_t namelen, __u32 *gid)
228{
229 return nfs_idmap_lookup_id(name, namelen, "gid", gid);
230}
231
232int nfs_map_uid_to_name(struct nfs_client *clp, __u32 uid, char *buf, size_t buflen)
233{
234 return nfs_idmap_lookup_name(uid, "user", buf, buflen);
235}
236int nfs_map_gid_to_group(struct nfs_client *clp, __u32 gid, char *buf, size_t buflen)
237{
238 return nfs_idmap_lookup_name(gid, "group", buf, buflen);
239}
240
241#else /* CONFIG_NFS_USE_IDMAPPER not defined */
242
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243#include <linux/module.h>
Ingo Molnarc9d51282006-03-20 13:44:11 -0500244#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245#include <linux/init.h>
246#include <linux/types.h>
247#include <linux/slab.h>
248#include <linux/socket.h>
249#include <linux/in.h>
250#include <linux/sched.h>
251
252#include <linux/sunrpc/clnt.h>
253#include <linux/workqueue.h>
254#include <linux/sunrpc/rpc_pipe_fs.h>
255
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256#include <linux/nfs_fs.h>
257
258#include <linux/nfs_idmap.h>
Trond Myklebust4ce79712005-06-22 17:16:21 +0000259#include "nfs4_fs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
261#define IDMAP_HASH_SZ 128
262
Trond Myklebust58df0952006-01-03 09:55:57 +0100263/* Default cache timeout is 10 minutes */
264unsigned int nfs_idmap_cache_timeout = 600 * HZ;
265
David Howells7d4e2742006-08-22 20:06:07 -0400266static int param_set_idmap_timeout(const char *val, struct kernel_param *kp)
267{
268 char *endp;
269 int num = simple_strtol(val, &endp, 0);
270 int jif = num * HZ;
271 if (endp == val || *endp || num < 0 || jif < num)
272 return -EINVAL;
273 *((int *)kp->arg) = jif;
274 return 0;
275}
276
277module_param_call(idmap_cache_timeout, param_set_idmap_timeout, param_get_int,
278 &nfs_idmap_cache_timeout, 0644);
279
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280struct idmap_hashent {
Chuck Lever369af0f2007-12-20 14:54:35 -0500281 unsigned long ih_expires;
282 __u32 ih_id;
Chuck Leverd24aae42007-12-20 14:54:49 -0500283 size_t ih_namelen;
Chuck Lever369af0f2007-12-20 14:54:35 -0500284 char ih_name[IDMAP_NAMESZ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285};
286
287struct idmap_hashtable {
Chuck Lever369af0f2007-12-20 14:54:35 -0500288 __u8 h_type;
289 struct idmap_hashent h_entries[IDMAP_HASH_SZ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290};
291
292struct idmap {
Chuck Lever369af0f2007-12-20 14:54:35 -0500293 struct dentry *idmap_dentry;
294 wait_queue_head_t idmap_wq;
295 struct idmap_msg idmap_im;
296 struct mutex idmap_lock; /* Serializes upcalls */
297 struct mutex idmap_im_lock; /* Protects the hashtable */
298 struct idmap_hashtable idmap_user_hash;
299 struct idmap_hashtable idmap_group_hash;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300};
301
Chuck Lever369af0f2007-12-20 14:54:35 -0500302static ssize_t idmap_pipe_upcall(struct file *, struct rpc_pipe_msg *,
303 char __user *, size_t);
304static ssize_t idmap_pipe_downcall(struct file *, const char __user *,
305 size_t);
306static void idmap_pipe_destroy_msg(struct rpc_pipe_msg *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
308static unsigned int fnvhash32(const void *, size_t);
309
Trond Myklebustb693ba42009-08-09 15:14:15 -0400310static const struct rpc_pipe_ops idmap_upcall_ops = {
Chuck Lever369af0f2007-12-20 14:54:35 -0500311 .upcall = idmap_pipe_upcall,
312 .downcall = idmap_pipe_downcall,
313 .destroy_msg = idmap_pipe_destroy_msg,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314};
315
David Howellsb7162792006-08-22 20:06:09 -0400316int
David Howellsadfa6f92006-08-22 20:06:08 -0400317nfs_idmap_new(struct nfs_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318{
319 struct idmap *idmap;
David Howellsb7162792006-08-22 20:06:09 -0400320 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
David Howells54ceac42006-08-22 20:06:13 -0400322 BUG_ON(clp->cl_idmap != NULL);
David Howellsb7162792006-08-22 20:06:09 -0400323
Chuck Lever369af0f2007-12-20 14:54:35 -0500324 idmap = kzalloc(sizeof(*idmap), GFP_KERNEL);
325 if (idmap == NULL)
326 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
Trond Myklebust7d217ca2009-08-09 15:14:24 -0400328 idmap->idmap_dentry = rpc_mkpipe(clp->cl_rpcclient->cl_path.dentry,
329 "idmap", idmap, &idmap_upcall_ops, 0);
Chuck Lever369af0f2007-12-20 14:54:35 -0500330 if (IS_ERR(idmap->idmap_dentry)) {
David Howellsb7162792006-08-22 20:06:09 -0400331 error = PTR_ERR(idmap->idmap_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 kfree(idmap);
David Howellsb7162792006-08-22 20:06:09 -0400333 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 }
335
Chuck Lever369af0f2007-12-20 14:54:35 -0500336 mutex_init(&idmap->idmap_lock);
337 mutex_init(&idmap->idmap_im_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 init_waitqueue_head(&idmap->idmap_wq);
339 idmap->idmap_user_hash.h_type = IDMAP_TYPE_USER;
340 idmap->idmap_group_hash.h_type = IDMAP_TYPE_GROUP;
341
342 clp->cl_idmap = idmap;
David Howellsb7162792006-08-22 20:06:09 -0400343 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344}
345
346void
David Howellsadfa6f92006-08-22 20:06:08 -0400347nfs_idmap_delete(struct nfs_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348{
349 struct idmap *idmap = clp->cl_idmap;
350
351 if (!idmap)
352 return;
Trond Myklebust5d674762006-07-31 14:11:48 -0700353 rpc_unlink(idmap->idmap_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 clp->cl_idmap = NULL;
355 kfree(idmap);
356}
357
358/*
359 * Helper routines for manipulating the hashtable
360 */
361static inline struct idmap_hashent *
362idmap_name_hash(struct idmap_hashtable* h, const char *name, size_t len)
363{
364 return &h->h_entries[fnvhash32(name, len) % IDMAP_HASH_SZ];
365}
366
367static struct idmap_hashent *
368idmap_lookup_name(struct idmap_hashtable *h, const char *name, size_t len)
369{
370 struct idmap_hashent *he = idmap_name_hash(h, name, len);
371
372 if (he->ih_namelen != len || memcmp(he->ih_name, name, len) != 0)
373 return NULL;
Trond Myklebust58df0952006-01-03 09:55:57 +0100374 if (time_after(jiffies, he->ih_expires))
375 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 return he;
377}
378
379static inline struct idmap_hashent *
380idmap_id_hash(struct idmap_hashtable* h, __u32 id)
381{
382 return &h->h_entries[fnvhash32(&id, sizeof(id)) % IDMAP_HASH_SZ];
383}
384
385static struct idmap_hashent *
386idmap_lookup_id(struct idmap_hashtable *h, __u32 id)
387{
388 struct idmap_hashent *he = idmap_id_hash(h, id);
389 if (he->ih_id != id || he->ih_namelen == 0)
390 return NULL;
Trond Myklebust58df0952006-01-03 09:55:57 +0100391 if (time_after(jiffies, he->ih_expires))
392 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 return he;
394}
395
396/*
397 * Routines for allocating new entries in the hashtable.
398 * For now, we just have 1 entry per bucket, so it's all
399 * pretty trivial.
400 */
401static inline struct idmap_hashent *
Chuck Leverd24aae42007-12-20 14:54:49 -0500402idmap_alloc_name(struct idmap_hashtable *h, char *name, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403{
404 return idmap_name_hash(h, name, len);
405}
406
407static inline struct idmap_hashent *
408idmap_alloc_id(struct idmap_hashtable *h, __u32 id)
409{
410 return idmap_id_hash(h, id);
411}
412
413static void
414idmap_update_entry(struct idmap_hashent *he, const char *name,
415 size_t namelen, __u32 id)
416{
417 he->ih_id = id;
418 memcpy(he->ih_name, name, namelen);
419 he->ih_name[namelen] = '\0';
420 he->ih_namelen = namelen;
Trond Myklebust58df0952006-01-03 09:55:57 +0100421 he->ih_expires = jiffies + nfs_idmap_cache_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422}
423
424/*
425 * Name -> ID
426 */
427static int
428nfs_idmap_id(struct idmap *idmap, struct idmap_hashtable *h,
429 const char *name, size_t namelen, __u32 *id)
430{
431 struct rpc_pipe_msg msg;
432 struct idmap_msg *im;
433 struct idmap_hashent *he;
434 DECLARE_WAITQUEUE(wq, current);
435 int ret = -EIO;
436
437 im = &idmap->idmap_im;
438
439 /*
440 * String sanity checks
441 * Note that the userland daemon expects NUL terminated strings
442 */
443 for (;;) {
444 if (namelen == 0)
445 return -EINVAL;
446 if (name[namelen-1] != '\0')
447 break;
448 namelen--;
449 }
450 if (namelen >= IDMAP_NAMESZ)
451 return -EINVAL;
452
Ingo Molnarc9d51282006-03-20 13:44:11 -0500453 mutex_lock(&idmap->idmap_lock);
454 mutex_lock(&idmap->idmap_im_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
456 he = idmap_lookup_name(h, name, namelen);
457 if (he != NULL) {
458 *id = he->ih_id;
459 ret = 0;
460 goto out;
461 }
462
463 memset(im, 0, sizeof(*im));
464 memcpy(im->im_name, name, namelen);
465
466 im->im_type = h->h_type;
467 im->im_conv = IDMAP_CONV_NAMETOID;
468
469 memset(&msg, 0, sizeof(msg));
470 msg.data = im;
471 msg.len = sizeof(*im);
472
473 add_wait_queue(&idmap->idmap_wq, &wq);
474 if (rpc_queue_upcall(idmap->idmap_dentry->d_inode, &msg) < 0) {
475 remove_wait_queue(&idmap->idmap_wq, &wq);
476 goto out;
477 }
478
479 set_current_state(TASK_UNINTERRUPTIBLE);
Ingo Molnarc9d51282006-03-20 13:44:11 -0500480 mutex_unlock(&idmap->idmap_im_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 schedule();
Milind Arun Choudharyfee7f232007-04-26 00:29:03 -0700482 __set_current_state(TASK_RUNNING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 remove_wait_queue(&idmap->idmap_wq, &wq);
Ingo Molnarc9d51282006-03-20 13:44:11 -0500484 mutex_lock(&idmap->idmap_im_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
486 if (im->im_status & IDMAP_STATUS_SUCCESS) {
487 *id = im->im_id;
488 ret = 0;
489 }
490
491 out:
492 memset(im, 0, sizeof(*im));
Ingo Molnarc9d51282006-03-20 13:44:11 -0500493 mutex_unlock(&idmap->idmap_im_lock);
494 mutex_unlock(&idmap->idmap_lock);
Chuck Lever369af0f2007-12-20 14:54:35 -0500495 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496}
497
498/*
499 * ID -> Name
500 */
501static int
502nfs_idmap_name(struct idmap *idmap, struct idmap_hashtable *h,
503 __u32 id, char *name)
504{
505 struct rpc_pipe_msg msg;
506 struct idmap_msg *im;
507 struct idmap_hashent *he;
508 DECLARE_WAITQUEUE(wq, current);
509 int ret = -EIO;
510 unsigned int len;
511
512 im = &idmap->idmap_im;
513
Ingo Molnarc9d51282006-03-20 13:44:11 -0500514 mutex_lock(&idmap->idmap_lock);
515 mutex_lock(&idmap->idmap_im_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516
517 he = idmap_lookup_id(h, id);
Harvey Harrison90dc7d22008-02-20 13:03:05 -0800518 if (he) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 memcpy(name, he->ih_name, he->ih_namelen);
520 ret = he->ih_namelen;
521 goto out;
522 }
523
524 memset(im, 0, sizeof(*im));
525 im->im_type = h->h_type;
526 im->im_conv = IDMAP_CONV_IDTONAME;
527 im->im_id = id;
528
529 memset(&msg, 0, sizeof(msg));
530 msg.data = im;
531 msg.len = sizeof(*im);
532
533 add_wait_queue(&idmap->idmap_wq, &wq);
534
535 if (rpc_queue_upcall(idmap->idmap_dentry->d_inode, &msg) < 0) {
536 remove_wait_queue(&idmap->idmap_wq, &wq);
537 goto out;
538 }
539
540 set_current_state(TASK_UNINTERRUPTIBLE);
Ingo Molnarc9d51282006-03-20 13:44:11 -0500541 mutex_unlock(&idmap->idmap_im_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 schedule();
Milind Arun Choudharyfee7f232007-04-26 00:29:03 -0700543 __set_current_state(TASK_RUNNING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 remove_wait_queue(&idmap->idmap_wq, &wq);
Ingo Molnarc9d51282006-03-20 13:44:11 -0500545 mutex_lock(&idmap->idmap_im_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546
547 if (im->im_status & IDMAP_STATUS_SUCCESS) {
548 if ((len = strnlen(im->im_name, IDMAP_NAMESZ)) == 0)
549 goto out;
550 memcpy(name, im->im_name, len);
551 ret = len;
552 }
553
554 out:
555 memset(im, 0, sizeof(*im));
Ingo Molnarc9d51282006-03-20 13:44:11 -0500556 mutex_unlock(&idmap->idmap_im_lock);
557 mutex_unlock(&idmap->idmap_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 return ret;
559}
560
561/* RPC pipefs upcall/downcall routines */
562static ssize_t
563idmap_pipe_upcall(struct file *filp, struct rpc_pipe_msg *msg,
Chuck Lever369af0f2007-12-20 14:54:35 -0500564 char __user *dst, size_t buflen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565{
Chuck Lever369af0f2007-12-20 14:54:35 -0500566 char *data = (char *)msg->data + msg->copied;
Chuck Levera661b772007-12-20 14:54:42 -0500567 size_t mlen = min(msg->len, buflen);
568 unsigned long left;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
Chuck Lever369af0f2007-12-20 14:54:35 -0500570 left = copy_to_user(dst, data, mlen);
Chuck Levera661b772007-12-20 14:54:42 -0500571 if (left == mlen) {
572 msg->errno = -EFAULT;
573 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 }
Chuck Levera661b772007-12-20 14:54:42 -0500575
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 mlen -= left;
577 msg->copied += mlen;
578 msg->errno = 0;
Chuck Lever369af0f2007-12-20 14:54:35 -0500579 return mlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580}
581
582static ssize_t
583idmap_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
584{
Chuck Lever369af0f2007-12-20 14:54:35 -0500585 struct rpc_inode *rpci = RPC_I(filp->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 struct idmap *idmap = (struct idmap *)rpci->private;
587 struct idmap_msg im_in, *im = &idmap->idmap_im;
588 struct idmap_hashtable *h;
589 struct idmap_hashent *he = NULL;
Chuck Leverd24aae42007-12-20 14:54:49 -0500590 size_t namelen_in;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 int ret;
592
Chuck Lever369af0f2007-12-20 14:54:35 -0500593 if (mlen != sizeof(im_in))
594 return -ENOSPC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
Chuck Lever369af0f2007-12-20 14:54:35 -0500596 if (copy_from_user(&im_in, src, mlen) != 0)
597 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598
Ingo Molnarc9d51282006-03-20 13:44:11 -0500599 mutex_lock(&idmap->idmap_im_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
601 ret = mlen;
602 im->im_status = im_in.im_status;
603 /* If we got an error, terminate now, and wake up pending upcalls */
604 if (!(im_in.im_status & IDMAP_STATUS_SUCCESS)) {
605 wake_up(&idmap->idmap_wq);
606 goto out;
607 }
608
609 /* Sanity checking of strings */
610 ret = -EINVAL;
611 namelen_in = strnlen(im_in.im_name, IDMAP_NAMESZ);
612 if (namelen_in == 0 || namelen_in == IDMAP_NAMESZ)
613 goto out;
614
615 switch (im_in.im_type) {
616 case IDMAP_TYPE_USER:
617 h = &idmap->idmap_user_hash;
618 break;
619 case IDMAP_TYPE_GROUP:
620 h = &idmap->idmap_group_hash;
621 break;
622 default:
623 goto out;
624 }
625
626 switch (im_in.im_conv) {
627 case IDMAP_CONV_IDTONAME:
628 /* Did we match the current upcall? */
629 if (im->im_conv == IDMAP_CONV_IDTONAME
630 && im->im_type == im_in.im_type
631 && im->im_id == im_in.im_id) {
632 /* Yes: copy string, including the terminating '\0' */
633 memcpy(im->im_name, im_in.im_name, namelen_in);
634 im->im_name[namelen_in] = '\0';
635 wake_up(&idmap->idmap_wq);
636 }
637 he = idmap_alloc_id(h, im_in.im_id);
638 break;
639 case IDMAP_CONV_NAMETOID:
640 /* Did we match the current upcall? */
641 if (im->im_conv == IDMAP_CONV_NAMETOID
642 && im->im_type == im_in.im_type
643 && strnlen(im->im_name, IDMAP_NAMESZ) == namelen_in
644 && memcmp(im->im_name, im_in.im_name, namelen_in) == 0) {
645 im->im_id = im_in.im_id;
646 wake_up(&idmap->idmap_wq);
647 }
648 he = idmap_alloc_name(h, im_in.im_name, namelen_in);
649 break;
650 default:
651 goto out;
652 }
653
654 /* If the entry is valid, also copy it to the cache */
655 if (he != NULL)
656 idmap_update_entry(he, im_in.im_name, namelen_in, im_in.im_id);
657 ret = mlen;
658out:
Ingo Molnarc9d51282006-03-20 13:44:11 -0500659 mutex_unlock(&idmap->idmap_im_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 return ret;
661}
662
Adrian Bunk75c96f82005-05-05 16:16:09 -0700663static void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664idmap_pipe_destroy_msg(struct rpc_pipe_msg *msg)
665{
666 struct idmap_msg *im = msg->data;
667 struct idmap *idmap = container_of(im, struct idmap, idmap_im);
668
669 if (msg->errno >= 0)
670 return;
Ingo Molnarc9d51282006-03-20 13:44:11 -0500671 mutex_lock(&idmap->idmap_im_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 im->im_status = IDMAP_STATUS_LOOKUPFAIL;
673 wake_up(&idmap->idmap_wq);
Ingo Molnarc9d51282006-03-20 13:44:11 -0500674 mutex_unlock(&idmap->idmap_im_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675}
676
677/*
678 * Fowler/Noll/Vo hash
679 * http://www.isthe.com/chongo/tech/comp/fnv/
680 */
681
682#define FNV_P_32 ((unsigned int)0x01000193) /* 16777619 */
683#define FNV_1_32 ((unsigned int)0x811c9dc5) /* 2166136261 */
684
685static unsigned int fnvhash32(const void *buf, size_t buflen)
686{
687 const unsigned char *p, *end = (const unsigned char *)buf + buflen;
688 unsigned int hash = FNV_1_32;
689
690 for (p = buf; p < end; p++) {
691 hash *= FNV_P_32;
692 hash ^= (unsigned int)*p;
693 }
694
Chuck Lever369af0f2007-12-20 14:54:35 -0500695 return hash;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696}
697
David Howellsadfa6f92006-08-22 20:06:08 -0400698int nfs_map_name_to_uid(struct nfs_client *clp, const char *name, size_t namelen, __u32 *uid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699{
700 struct idmap *idmap = clp->cl_idmap;
701
702 return nfs_idmap_id(idmap, &idmap->idmap_user_hash, name, namelen, uid);
703}
704
David Howellsadfa6f92006-08-22 20:06:08 -0400705int nfs_map_group_to_gid(struct nfs_client *clp, const char *name, size_t namelen, __u32 *uid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706{
707 struct idmap *idmap = clp->cl_idmap;
708
709 return nfs_idmap_id(idmap, &idmap->idmap_group_hash, name, namelen, uid);
710}
711
Bryan Schumaker955a8572010-09-29 15:41:49 -0400712int nfs_map_uid_to_name(struct nfs_client *clp, __u32 uid, char *buf, size_t buflen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713{
714 struct idmap *idmap = clp->cl_idmap;
715
716 return nfs_idmap_name(idmap, &idmap->idmap_user_hash, uid, buf);
717}
Bryan Schumaker955a8572010-09-29 15:41:49 -0400718int nfs_map_gid_to_group(struct nfs_client *clp, __u32 uid, char *buf, size_t buflen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719{
720 struct idmap *idmap = clp->cl_idmap;
721
722 return nfs_idmap_name(idmap, &idmap->idmap_group_hash, uid, buf);
723}
724
Bryan Schumaker955a8572010-09-29 15:41:49 -0400725#endif /* CONFIG_NFS_USE_NEW_IDMAPPER */