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 */
 36#include <linux/types.h>
 37#include <linux/string.h>
 38#include <linux/kernel.h>
 39#include <linux/slab.h>
 40#include <linux/nfs_idmap.h>
 41
 42static int nfs_map_string_to_numeric(const char *name, size_t namelen, __u32 *res)
 43{
 44	unsigned long val;
 45	char buf[16];
 46
 47	if (memchr(name, '@', namelen) != NULL || namelen >= sizeof(buf))
 48		return 0;
 49	memcpy(buf, name, namelen);
 50	buf[namelen] = '\0';
 51	if (strict_strtoul(buf, 0, &val) != 0)
 52		return 0;
 53	*res = val;
 54	return 1;
 55}
 56
 57static int nfs_map_numeric_to_string(__u32 id, char *buf, size_t buflen)
 58{
 59	return snprintf(buf, buflen, "%u", id);
 60}
 61
 62#ifdef CONFIG_NFS_USE_NEW_IDMAPPER
 63
 64#include <linux/cred.h>
 65#include <linux/sunrpc/sched.h>
 66#include <linux/nfs4.h>
 67#include <linux/nfs_fs_sb.h>
 68#include <linux/keyctl.h>
 69#include <linux/key-type.h>
 70#include <linux/rcupdate.h>
 71#include <linux/err.h>
 72
 73#include <keys/user-type.h>
 74
 75#define NFS_UINT_MAXLEN 11
 76
 77const struct cred *id_resolver_cache;
 78
 79struct key_type key_type_id_resolver = {
 80	.name		= "id_resolver",
 81	.instantiate	= user_instantiate,
 82	.match		= user_match,
 83	.revoke		= user_revoke,
 84	.destroy	= user_destroy,
 85	.describe	= user_describe,
 86	.read		= user_read,
 87};
 88
 89int nfs_idmap_init(void)
 90{
 91	struct cred *cred;
 92	struct key *keyring;
 93	int ret = 0;
 94
 95	printk(KERN_NOTICE "Registering the %s key type\n", key_type_id_resolver.name);
 96
 97	cred = prepare_kernel_cred(NULL);
 98	if (!cred)
 99		return -ENOMEM;
100
101	keyring = key_alloc(&key_type_keyring, ".id_resolver", 0, 0, cred,
102			     (KEY_POS_ALL & ~KEY_POS_SETATTR) |
103			     KEY_USR_VIEW | KEY_USR_READ,
104			     KEY_ALLOC_NOT_IN_QUOTA);
105	if (IS_ERR(keyring)) {
106		ret = PTR_ERR(keyring);
107		goto failed_put_cred;
108	}
109
110	ret = key_instantiate_and_link(keyring, NULL, 0, NULL, NULL);
111	if (ret < 0)
112		goto failed_put_key;
113
114	ret = register_key_type(&key_type_id_resolver);
115	if (ret < 0)
116		goto failed_put_key;
117
118	cred->thread_keyring = keyring;
119	cred->jit_keyring = KEY_REQKEY_DEFL_THREAD_KEYRING;
120	id_resolver_cache = cred;
121	return 0;
122
123failed_put_key:
124	key_put(keyring);
125failed_put_cred:
126	put_cred(cred);
127	return ret;
128}
129
130void nfs_idmap_quit(void)
131{
132	key_revoke(id_resolver_cache->thread_keyring);
133	unregister_key_type(&key_type_id_resolver);
134	put_cred(id_resolver_cache);
135}
136
137/*
138 * Assemble the description to pass to request_key()
139 * This function will allocate a new string and update dest to point
140 * at it.  The caller is responsible for freeing dest.
141 *
142 * On error 0 is returned.  Otherwise, the length of dest is returned.
143 */
144static ssize_t nfs_idmap_get_desc(const char *name, size_t namelen,
145				const char *type, size_t typelen, char **desc)
146{
147	char *cp;
148	size_t desclen = typelen + namelen + 2;
149
150	*desc = kmalloc(desclen, GFP_KERNEL);
151	if (!*desc)
152		return -ENOMEM;
153
154	cp = *desc;
155	memcpy(cp, type, typelen);
156	cp += typelen;
157	*cp++ = ':';
158
159	memcpy(cp, name, namelen);
160	cp += namelen;
161	*cp = '\0';
162	return desclen;
163}
164
165static ssize_t nfs_idmap_request_key(const char *name, size_t namelen,
166		const char *type, void *data, size_t data_size)
167{
168	const struct cred *saved_cred;
169	struct key *rkey;
170	char *desc;
171	struct user_key_payload *payload;
172	ssize_t ret;
173
174	ret = nfs_idmap_get_desc(name, namelen, type, strlen(type), &desc);
175	if (ret <= 0)
176		goto out;
177
178	saved_cred = override_creds(id_resolver_cache);
179	rkey = request_key(&key_type_id_resolver, desc, "");
180	revert_creds(saved_cred);
181	kfree(desc);
182	if (IS_ERR(rkey)) {
183		ret = PTR_ERR(rkey);
184		goto out;
185	}
186
187	rcu_read_lock();
188	rkey->perm |= KEY_USR_VIEW;
189
190	ret = key_validate(rkey);
191	if (ret < 0)
192		goto out_up;
193
194	payload = rcu_dereference(rkey->payload.data);
195	if (IS_ERR_OR_NULL(payload)) {
196		ret = PTR_ERR(payload);
197		goto out_up;
198	}
199
200	ret = payload->datalen;
201	if (ret > 0 && ret <= data_size)
202		memcpy(data, payload->data, ret);
203	else
204		ret = -EINVAL;
205
206out_up:
207	rcu_read_unlock();
208	key_put(rkey);
209out:
210	return ret;
211}
212
213
214/* ID -> Name */
215static ssize_t nfs_idmap_lookup_name(__u32 id, const char *type, char *buf, size_t buflen)
216{
217	char id_str[NFS_UINT_MAXLEN];
218	int id_len;
219	ssize_t ret;
220
221	id_len = snprintf(id_str, sizeof(id_str), "%u", id);
222	ret = nfs_idmap_request_key(id_str, id_len, type, buf, buflen);
223	if (ret < 0)
224		return -EINVAL;
225	return ret;
226}
227
228/* Name -> ID */
229static int nfs_idmap_lookup_id(const char *name, size_t namelen,
230				const char *type, __u32 *id)
231{
232	char id_str[NFS_UINT_MAXLEN];
233	long id_long;
234	ssize_t data_size;
235	int ret = 0;
236
237	data_size = nfs_idmap_request_key(name, namelen, type, id_str, NFS_UINT_MAXLEN);
238	if (data_size <= 0) {
239		ret = -EINVAL;
240	} else {
241		ret = strict_strtol(id_str, 10, &id_long);
242		*id = (__u32)id_long;
243	}
244	return ret;
245}
246
247int nfs_map_name_to_uid(const struct nfs_server *server, const char *name, size_t namelen, __u32 *uid)
248{
249	if (nfs_map_string_to_numeric(name, namelen, uid))
250		return 0;
251	return nfs_idmap_lookup_id(name, namelen, "uid", uid);
252}
253
254int nfs_map_group_to_gid(const struct nfs_server *server, const char *name, size_t namelen, __u32 *gid)
255{
256	if (nfs_map_string_to_numeric(name, namelen, gid))
257		return 0;
258	return nfs_idmap_lookup_id(name, namelen, "gid", gid);
259}
260
261int nfs_map_uid_to_name(const struct nfs_server *server, __u32 uid, char *buf, size_t buflen)
262{
263	int ret = -EINVAL;
264
265	if (!(server->caps & NFS_CAP_UIDGID_NOMAP))
266		ret = nfs_idmap_lookup_name(uid, "user", buf, buflen);
267	if (ret < 0)
268		ret = nfs_map_numeric_to_string(uid, buf, buflen);
269	return ret;
270}
271int nfs_map_gid_to_group(const struct nfs_server *server, __u32 gid, char *buf, size_t buflen)
272{
273	int ret = -EINVAL;
274
275	if (!(server->caps & NFS_CAP_UIDGID_NOMAP))
276		ret = nfs_idmap_lookup_name(gid, "group", buf, buflen);
277	if (ret < 0)
278		ret = nfs_map_numeric_to_string(gid, buf, buflen);
279	return ret;
280}
281
282#else  /* CONFIG_NFS_USE_NEW_IDMAPPER not defined */
283
284#include <linux/module.h>
285#include <linux/mutex.h>
286#include <linux/init.h>
287#include <linux/socket.h>
288#include <linux/in.h>
289#include <linux/sched.h>
290#include <linux/sunrpc/clnt.h>
291#include <linux/workqueue.h>
292#include <linux/sunrpc/rpc_pipe_fs.h>
293
294#include <linux/nfs_fs.h>
295
296#include "nfs4_fs.h"
297
298#define IDMAP_HASH_SZ          128
299
300/* Default cache timeout is 10 minutes */
301unsigned int nfs_idmap_cache_timeout = 600 * HZ;
302
303static int param_set_idmap_timeout(const char *val, struct kernel_param *kp)
304{
305	char *endp;
306	int num = simple_strtol(val, &endp, 0);
307	int jif = num * HZ;
308	if (endp == val || *endp || num < 0 || jif < num)
309		return -EINVAL;
310	*((int *)kp->arg) = jif;
311	return 0;
312}
313
314module_param_call(idmap_cache_timeout, param_set_idmap_timeout, param_get_int,
315		 &nfs_idmap_cache_timeout, 0644);
316
317struct idmap_hashent {
318	unsigned long		ih_expires;
319	__u32			ih_id;
320	size_t			ih_namelen;
321	char			ih_name[IDMAP_NAMESZ];
322};
323
324struct idmap_hashtable {
325	__u8			h_type;
326	struct idmap_hashent	h_entries[IDMAP_HASH_SZ];
327};
328
329struct idmap {
330	struct dentry		*idmap_dentry;
331	wait_queue_head_t	idmap_wq;
332	struct idmap_msg	idmap_im;
333	struct mutex		idmap_lock;	/* Serializes upcalls */
334	struct mutex		idmap_im_lock;	/* Protects the hashtable */
335	struct idmap_hashtable	idmap_user_hash;
336	struct idmap_hashtable	idmap_group_hash;
337};
338
339static ssize_t idmap_pipe_upcall(struct file *, struct rpc_pipe_msg *,
340				 char __user *, size_t);
341static ssize_t idmap_pipe_downcall(struct file *, const char __user *,
342				   size_t);
343static void idmap_pipe_destroy_msg(struct rpc_pipe_msg *);
344
345static unsigned int fnvhash32(const void *, size_t);
346
347static const struct rpc_pipe_ops idmap_upcall_ops = {
348	.upcall		= idmap_pipe_upcall,
349	.downcall	= idmap_pipe_downcall,
350	.destroy_msg	= idmap_pipe_destroy_msg,
351};
352
353int
354nfs_idmap_new(struct nfs_client *clp)
355{
356	struct idmap *idmap;
357	int error;
358
359	BUG_ON(clp->cl_idmap != NULL);
360
361	idmap = kzalloc(sizeof(*idmap), GFP_KERNEL);
362	if (idmap == NULL)
363		return -ENOMEM;
364
365	idmap->idmap_dentry = rpc_mkpipe(clp->cl_rpcclient->cl_path.dentry,
366			"idmap", idmap, &idmap_upcall_ops, 0);
367	if (IS_ERR(idmap->idmap_dentry)) {
368		error = PTR_ERR(idmap->idmap_dentry);
369		kfree(idmap);
370		return error;
371	}
372
373	mutex_init(&idmap->idmap_lock);
374	mutex_init(&idmap->idmap_im_lock);
375	init_waitqueue_head(&idmap->idmap_wq);
376	idmap->idmap_user_hash.h_type = IDMAP_TYPE_USER;
377	idmap->idmap_group_hash.h_type = IDMAP_TYPE_GROUP;
378
379	clp->cl_idmap = idmap;
380	return 0;
381}
382
383void
384nfs_idmap_delete(struct nfs_client *clp)
385{
386	struct idmap *idmap = clp->cl_idmap;
387
388	if (!idmap)
389		return;
390	rpc_unlink(idmap->idmap_dentry);
391	clp->cl_idmap = NULL;
392	kfree(idmap);
393}
394
395/*
396 * Helper routines for manipulating the hashtable
397 */
398static inline struct idmap_hashent *
399idmap_name_hash(struct idmap_hashtable* h, const char *name, size_t len)
400{
401	return &h->h_entries[fnvhash32(name, len) % IDMAP_HASH_SZ];
402}
403
404static struct idmap_hashent *
405idmap_lookup_name(struct idmap_hashtable *h, const char *name, size_t len)
406{
407	struct idmap_hashent *he = idmap_name_hash(h, name, len);
408
409	if (he->ih_namelen != len || memcmp(he->ih_name, name, len) != 0)
410		return NULL;
411	if (time_after(jiffies, he->ih_expires))
412		return NULL;
413	return he;
414}
415
416static inline struct idmap_hashent *
417idmap_id_hash(struct idmap_hashtable* h, __u32 id)
418{
419	return &h->h_entries[fnvhash32(&id, sizeof(id)) % IDMAP_HASH_SZ];
420}
421
422static struct idmap_hashent *
423idmap_lookup_id(struct idmap_hashtable *h, __u32 id)
424{
425	struct idmap_hashent *he = idmap_id_hash(h, id);
426	if (he->ih_id != id || he->ih_namelen == 0)
427		return NULL;
428	if (time_after(jiffies, he->ih_expires))
429		return NULL;
430	return he;
431}
432
433/*
434 * Routines for allocating new entries in the hashtable.
435 * For now, we just have 1 entry per bucket, so it's all
436 * pretty trivial.
437 */
438static inline struct idmap_hashent *
439idmap_alloc_name(struct idmap_hashtable *h, char *name, size_t len)
440{
441	return idmap_name_hash(h, name, len);
442}
443
444static inline struct idmap_hashent *
445idmap_alloc_id(struct idmap_hashtable *h, __u32 id)
446{
447	return idmap_id_hash(h, id);
448}
449
450static void
451idmap_update_entry(struct idmap_hashent *he, const char *name,
452		size_t namelen, __u32 id)
453{
454	he->ih_id = id;
455	memcpy(he->ih_name, name, namelen);
456	he->ih_name[namelen] = '\0';
457	he->ih_namelen = namelen;
458	he->ih_expires = jiffies + nfs_idmap_cache_timeout;
459}
460
461/*
462 * Name -> ID
463 */
464static int
465nfs_idmap_id(struct idmap *idmap, struct idmap_hashtable *h,
466		const char *name, size_t namelen, __u32 *id)
467{
468	struct rpc_pipe_msg msg;
469	struct idmap_msg *im;
470	struct idmap_hashent *he;
471	DECLARE_WAITQUEUE(wq, current);
472	int ret = -EIO;
473
474	im = &idmap->idmap_im;
475
476	/*
477	 * String sanity checks
478	 * Note that the userland daemon expects NUL terminated strings
479	 */
480	for (;;) {
481		if (namelen == 0)
482			return -EINVAL;
483		if (name[namelen-1] != '\0')
484			break;
485		namelen--;
486	}
487	if (namelen >= IDMAP_NAMESZ)
488		return -EINVAL;
489
490	mutex_lock(&idmap->idmap_lock);
491	mutex_lock(&idmap->idmap_im_lock);
492
493	he = idmap_lookup_name(h, name, namelen);
494	if (he != NULL) {
495		*id = he->ih_id;
496		ret = 0;
497		goto out;
498	}
499
500	memset(im, 0, sizeof(*im));
501	memcpy(im->im_name, name, namelen);
502
503	im->im_type = h->h_type;
504	im->im_conv = IDMAP_CONV_NAMETOID;
505
506	memset(&msg, 0, sizeof(msg));
507	msg.data = im;
508	msg.len = sizeof(*im);
509
510	add_wait_queue(&idmap->idmap_wq, &wq);
511	if (rpc_queue_upcall(idmap->idmap_dentry->d_inode, &msg) < 0) {
512		remove_wait_queue(&idmap->idmap_wq, &wq);
513		goto out;
514	}
515
516	set_current_state(TASK_UNINTERRUPTIBLE);
517	mutex_unlock(&idmap->idmap_im_lock);
518	schedule();
519	__set_current_state(TASK_RUNNING);
520	remove_wait_queue(&idmap->idmap_wq, &wq);
521	mutex_lock(&idmap->idmap_im_lock);
522
523	if (im->im_status & IDMAP_STATUS_SUCCESS) {
524		*id = im->im_id;
525		ret = 0;
526	}
527
528 out:
529	memset(im, 0, sizeof(*im));
530	mutex_unlock(&idmap->idmap_im_lock);
531	mutex_unlock(&idmap->idmap_lock);
532	return ret;
533}
534
535/*
536 * ID -> Name
537 */
538static int
539nfs_idmap_name(struct idmap *idmap, struct idmap_hashtable *h,
540		__u32 id, char *name)
541{
542	struct rpc_pipe_msg msg;
543	struct idmap_msg *im;
544	struct idmap_hashent *he;
545	DECLARE_WAITQUEUE(wq, current);
546	int ret = -EIO;
547	unsigned int len;
548
549	im = &idmap->idmap_im;
550
551	mutex_lock(&idmap->idmap_lock);
552	mutex_lock(&idmap->idmap_im_lock);
553
554	he = idmap_lookup_id(h, id);
555	if (he) {
556		memcpy(name, he->ih_name, he->ih_namelen);
557		ret = he->ih_namelen;
558		goto out;
559	}
560
561	memset(im, 0, sizeof(*im));
562	im->im_type = h->h_type;
563	im->im_conv = IDMAP_CONV_IDTONAME;
564	im->im_id = id;
565
566	memset(&msg, 0, sizeof(msg));
567	msg.data = im;
568	msg.len = sizeof(*im);
569
570	add_wait_queue(&idmap->idmap_wq, &wq);
571
572	if (rpc_queue_upcall(idmap->idmap_dentry->d_inode, &msg) < 0) {
573		remove_wait_queue(&idmap->idmap_wq, &wq);
574		goto out;
575	}
576
577	set_current_state(TASK_UNINTERRUPTIBLE);
578	mutex_unlock(&idmap->idmap_im_lock);
579	schedule();
580	__set_current_state(TASK_RUNNING);
581	remove_wait_queue(&idmap->idmap_wq, &wq);
582	mutex_lock(&idmap->idmap_im_lock);
583
584	if (im->im_status & IDMAP_STATUS_SUCCESS) {
585		if ((len = strnlen(im->im_name, IDMAP_NAMESZ)) == 0)
586			goto out;
587		memcpy(name, im->im_name, len);
588		ret = len;
589	}
590
591 out:
592	memset(im, 0, sizeof(*im));
593	mutex_unlock(&idmap->idmap_im_lock);
594	mutex_unlock(&idmap->idmap_lock);
595	return ret;
596}
597
598/* RPC pipefs upcall/downcall routines */
599static ssize_t
600idmap_pipe_upcall(struct file *filp, struct rpc_pipe_msg *msg,
601		  char __user *dst, size_t buflen)
602{
603	char *data = (char *)msg->data + msg->copied;
604	size_t mlen = min(msg->len, buflen);
605	unsigned long left;
606
607	left = copy_to_user(dst, data, mlen);
608	if (left == mlen) {
609		msg->errno = -EFAULT;
610		return -EFAULT;
611	}
612
613	mlen -= left;
614	msg->copied += mlen;
615	msg->errno = 0;
616	return mlen;
617}
618
619static ssize_t
620idmap_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
621{
622	struct rpc_inode *rpci = RPC_I(filp->f_path.dentry->d_inode);
623	struct idmap *idmap = (struct idmap *)rpci->private;
624	struct idmap_msg im_in, *im = &idmap->idmap_im;
625	struct idmap_hashtable *h;
626	struct idmap_hashent *he = NULL;
627	size_t namelen_in;
628	int ret;
629
630	if (mlen != sizeof(im_in))
631		return -ENOSPC;
632
633	if (copy_from_user(&im_in, src, mlen) != 0)
634		return -EFAULT;
635
636	mutex_lock(&idmap->idmap_im_lock);
637
638	ret = mlen;
639	im->im_status = im_in.im_status;
640	/* If we got an error, terminate now, and wake up pending upcalls */
641	if (!(im_in.im_status & IDMAP_STATUS_SUCCESS)) {
642		wake_up(&idmap->idmap_wq);
643		goto out;
644	}
645
646	/* Sanity checking of strings */
647	ret = -EINVAL;
648	namelen_in = strnlen(im_in.im_name, IDMAP_NAMESZ);
649	if (namelen_in == 0 || namelen_in == IDMAP_NAMESZ)
650		goto out;
651
652	switch (im_in.im_type) {
653		case IDMAP_TYPE_USER:
654			h = &idmap->idmap_user_hash;
655			break;
656		case IDMAP_TYPE_GROUP:
657			h = &idmap->idmap_group_hash;
658			break;
659		default:
660			goto out;
661	}
662
663	switch (im_in.im_conv) {
664	case IDMAP_CONV_IDTONAME:
665		/* Did we match the current upcall? */
666		if (im->im_conv == IDMAP_CONV_IDTONAME
667				&& im->im_type == im_in.im_type
668				&& im->im_id == im_in.im_id) {
669			/* Yes: copy string, including the terminating '\0'  */
670			memcpy(im->im_name, im_in.im_name, namelen_in);
671			im->im_name[namelen_in] = '\0';
672			wake_up(&idmap->idmap_wq);
673		}
674		he = idmap_alloc_id(h, im_in.im_id);
675		break;
676	case IDMAP_CONV_NAMETOID:
677		/* Did we match the current upcall? */
678		if (im->im_conv == IDMAP_CONV_NAMETOID
679				&& im->im_type == im_in.im_type
680				&& strnlen(im->im_name, IDMAP_NAMESZ) == namelen_in
681				&& memcmp(im->im_name, im_in.im_name, namelen_in) == 0) {
682			im->im_id = im_in.im_id;
683			wake_up(&idmap->idmap_wq);
684		}
685		he = idmap_alloc_name(h, im_in.im_name, namelen_in);
686		break;
687	default:
688		goto out;
689	}
690
691	/* If the entry is valid, also copy it to the cache */
692	if (he != NULL)
693		idmap_update_entry(he, im_in.im_name, namelen_in, im_in.im_id);
694	ret = mlen;
695out:
696	mutex_unlock(&idmap->idmap_im_lock);
697	return ret;
698}
699
700static void
701idmap_pipe_destroy_msg(struct rpc_pipe_msg *msg)
702{
703	struct idmap_msg *im = msg->data;
704	struct idmap *idmap = container_of(im, struct idmap, idmap_im); 
705
706	if (msg->errno >= 0)
707		return;
708	mutex_lock(&idmap->idmap_im_lock);
709	im->im_status = IDMAP_STATUS_LOOKUPFAIL;
710	wake_up(&idmap->idmap_wq);
711	mutex_unlock(&idmap->idmap_im_lock);
712}
713
714/* 
715 * Fowler/Noll/Vo hash
716 *    http://www.isthe.com/chongo/tech/comp/fnv/
717 */
718
719#define FNV_P_32 ((unsigned int)0x01000193) /* 16777619 */
720#define FNV_1_32 ((unsigned int)0x811c9dc5) /* 2166136261 */
721
722static unsigned int fnvhash32(const void *buf, size_t buflen)
723{
724	const unsigned char *p, *end = (const unsigned char *)buf + buflen;
725	unsigned int hash = FNV_1_32;
726
727	for (p = buf; p < end; p++) {
728		hash *= FNV_P_32;
729		hash ^= (unsigned int)*p;
730	}
731
732	return hash;
733}
734
735int nfs_map_name_to_uid(const struct nfs_server *server, const char *name, size_t namelen, __u32 *uid)
736{
737	struct idmap *idmap = server->nfs_client->cl_idmap;
738
739	if (nfs_map_string_to_numeric(name, namelen, uid))
740		return 0;
741	return nfs_idmap_id(idmap, &idmap->idmap_user_hash, name, namelen, uid);
742}
743
744int nfs_map_group_to_gid(const struct nfs_server *server, const char *name, size_t namelen, __u32 *uid)
745{
746	struct idmap *idmap = server->nfs_client->cl_idmap;
747
748	if (nfs_map_string_to_numeric(name, namelen, uid))
749		return 0;
750	return nfs_idmap_id(idmap, &idmap->idmap_group_hash, name, namelen, uid);
751}
752
753int nfs_map_uid_to_name(const struct nfs_server *server, __u32 uid, char *buf, size_t buflen)
754{
755	struct idmap *idmap = server->nfs_client->cl_idmap;
756	int ret = -EINVAL;
757
758	if (!(server->caps & NFS_CAP_UIDGID_NOMAP))
759		ret = nfs_idmap_name(idmap, &idmap->idmap_user_hash, uid, buf);
760	if (ret < 0)
761		ret = nfs_map_numeric_to_string(uid, buf, buflen);
762	return ret;
763}
764int nfs_map_gid_to_group(const struct nfs_server *server, __u32 uid, char *buf, size_t buflen)
765{
766	struct idmap *idmap = server->nfs_client->cl_idmap;
767	int ret = -EINVAL;
768
769	if (!(server->caps & NFS_CAP_UIDGID_NOMAP))
770		ret = nfs_idmap_name(idmap, &idmap->idmap_group_hash, uid, buf);
771	if (ret < 0)
772		ret = nfs_map_numeric_to_string(uid, buf, buflen);
773	return ret;
774}
775
776#endif /* CONFIG_NFS_USE_NEW_IDMAPPER */