fs/nfs/idmap.c

   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
  37 #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
  52 const struct cred *id_resolver_cache;
  53
  54 struct 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
  64 int 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
  98 failed_put_key:
  99         key_put(keyring);
 100 failed_put_cred:
 101         put_cred(cred);
 102         return ret;
 103 }
 104
 105 void 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  */
 119 static 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);
 126         if (!desc)
 127                 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
 140 static 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
 181 out_up:
 182         rcu_read_unlock();
 183         key_put(rkey);
 184 out:
 185         return ret;
 186 }
 187
 188
 189 /* ID -> Name */
 190 static 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 */
 204 static 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
 222 int 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
 227 int 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
 232 int 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 }
 236 int 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
 243 #include <linux/module.h>
 244 #include <linux/mutex.h>
 245 #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
 256 #include <linux/nfs_fs.h>
 257
 258 #include <linux/nfs_idmap.h>
 259 #include "nfs4_fs.h"
 260
 261 #define IDMAP_HASH_SZ          128
 262
 263 /* Default cache timeout is 10 minutes */
 264 unsigned int nfs_idmap_cache_timeout = 600 * HZ;
 265
 266 static 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
 277 module_param_call(idmap_cache_timeout, param_set_idmap_timeout, param_get_int,
 278                  &nfs_idmap_cache_timeout, 0644);
 279
 280 struct idmap_hashent {
 281         unsigned long           ih_expires;
 282         __u32                   ih_id;
 283         size_t                  ih_namelen;
 284         char                    ih_name[IDMAP_NAMESZ];
 285 };
 286
 287 struct idmap_hashtable {
 288         __u8                    h_type;
 289         struct idmap_hashent    h_entries[IDMAP_HASH_SZ];
 290 };
 291
 292 struct idmap {
 293         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;
 300 };
 301
 302 static ssize_t idmap_pipe_upcall(struct file *, struct rpc_pipe_msg *,
 303                                  char __user *, size_t);
 304 static ssize_t idmap_pipe_downcall(struct file *, const char __user *,
 305                                    size_t);
 306 static void idmap_pipe_destroy_msg(struct rpc_pipe_msg *);
 307
 308 static unsigned int fnvhash32(const void *, size_t);
 309
 310 static const struct rpc_pipe_ops idmap_upcall_ops = {
 311         .upcall         = idmap_pipe_upcall,
 312         .downcall       = idmap_pipe_downcall,
 313         .destroy_msg    = idmap_pipe_destroy_msg,
 314 };
 315
 316 int
 317 nfs_idmap_new(struct nfs_client *clp)
 318 {
 319         struct idmap *idmap;
 320         int error;
 321
 322         BUG_ON(clp->cl_idmap != NULL);
 323
 324         idmap = kzalloc(sizeof(*idmap), GFP_KERNEL);
 325         if (idmap == NULL)
 326                 return -ENOMEM;
 327
 328         idmap->idmap_dentry = rpc_mkpipe(clp->cl_rpcclient->cl_path.dentry,
 329                         "idmap", idmap, &idmap_upcall_ops, 0);
 330         if (IS_ERR(idmap->idmap_dentry)) {
 331                 error = PTR_ERR(idmap->idmap_dentry);
 332                 kfree(idmap);
 333                 return error;
 334         }
 335
 336         mutex_init(&idmap->idmap_lock);
 337         mutex_init(&idmap->idmap_im_lock);
 338         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;
 343         return 0;
 344 }
 345
 346 void
 347 nfs_idmap_delete(struct nfs_client *clp)
 348 {
 349         struct idmap *idmap = clp->cl_idmap;
 350
 351         if (!idmap)
 352                 return;
 353         rpc_unlink(idmap->idmap_dentry);
 354         clp->cl_idmap = NULL;
 355         kfree(idmap);
 356 }
 357
 358 /*
 359  * Helper routines for manipulating the hashtable
 360  */
 361 static inline struct idmap_hashent *
 362 idmap_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
 367 static struct idmap_hashent *
 368 idmap_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;
 374         if (time_after(jiffies, he->ih_expires))
 375                 return NULL;
 376         return he;
 377 }
 378
 379 static inline struct idmap_hashent *
 380 idmap_id_hash(struct idmap_hashtable* h, __u32 id)
 381 {
 382         return &h->h_entries[fnvhash32(&id, sizeof(id)) % IDMAP_HASH_SZ];
 383 }
 384
 385 static struct idmap_hashent *
 386 idmap_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;
 391         if (time_after(jiffies, he->ih_expires))
 392                 return NULL;
 393         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  */
 401 static inline struct idmap_hashent *
 402 idmap_alloc_name(struct idmap_hashtable *h, char *name, size_t len)
 403 {
 404         return idmap_name_hash(h, name, len);
 405 }
 406
 407 static inline struct idmap_hashent *
 408 idmap_alloc_id(struct idmap_hashtable *h, __u32 id)
 409 {
 410         return idmap_id_hash(h, id);
 411 }
 412
 413 static void
 414 idmap_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;
 421         he->ih_expires = jiffies + nfs_idmap_cache_timeout;
 422 }
 423
 424 /*
 425  * Name -> ID
 426  */
 427 static int
 428 nfs_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
 453         mutex_lock(&idmap->idmap_lock);
 454         mutex_lock(&idmap->idmap_im_lock);
 455
 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);
 480         mutex_unlock(&idmap->idmap_im_lock);
 481         schedule();
 482         __set_current_state(TASK_RUNNING);
 483         remove_wait_queue(&idmap->idmap_wq, &wq);
 484         mutex_lock(&idmap->idmap_im_lock);
 485
 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));
 493         mutex_unlock(&idmap->idmap_im_lock);
 494         mutex_unlock(&idmap->idmap_lock);
 495         return ret;
 496 }
 497
 498 /*
 499  * ID -> Name
 500  */
 501 static int
 502 nfs_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
 514         mutex_lock(&idmap->idmap_lock);
 515         mutex_lock(&idmap->idmap_im_lock);
 516
 517         he = idmap_lookup_id(h, id);
 518         if (he) {
 519                 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);
 541         mutex_unlock(&idmap->idmap_im_lock);
 542         schedule();
 543         __set_current_state(TASK_RUNNING);
 544         remove_wait_queue(&idmap->idmap_wq, &wq);
 545         mutex_lock(&idmap->idmap_im_lock);
 546
 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));
 556         mutex_unlock(&idmap->idmap_im_lock);
 557         mutex_unlock(&idmap->idmap_lock);
 558         return ret;
 559 }
 560
 561 /* RPC pipefs upcall/downcall routines */
 562 static ssize_t
 563 idmap_pipe_upcall(struct file *filp, struct rpc_pipe_msg *msg,
 564                   char __user *dst, size_t buflen)
 565 {
 566         char *data = (char *)msg->data + msg->copied;
 567         size_t mlen = min(msg->len, buflen);
 568         unsigned long left;
 569
 570         left = copy_to_user(dst, data, mlen);
 571         if (left == mlen) {
 572                 msg->errno = -EFAULT;
 573                 return -EFAULT;
 574         }
 575
 576         mlen -= left;
 577         msg->copied += mlen;
 578         msg->errno = 0;
 579         return mlen;
 580 }
 581
 582 static ssize_t
 583 idmap_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
 584 {
 585         struct rpc_inode *rpci = RPC_I(filp->f_path.dentry->d_inode);
 586         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;
 590         size_t namelen_in;
 591         int ret;
 592
 593         if (mlen != sizeof(im_in))
 594                 return -ENOSPC;
 595
 596         if (copy_from_user(&im_in, src, mlen) != 0)
 597                 return -EFAULT;
 598
 599         mutex_lock(&idmap->idmap_im_lock);
 600
 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;
 658 out:
 659         mutex_unlock(&idmap->idmap_im_lock);
 660         return ret;
 661 }
 662
 663 static void
 664 idmap_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;
 671         mutex_lock(&idmap->idmap_im_lock);
 672         im->im_status = IDMAP_STATUS_LOOKUPFAIL;
 673         wake_up(&idmap->idmap_wq);
 674         mutex_unlock(&idmap->idmap_im_lock);
 675 }
 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
 685 static 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
 695         return hash;
 696 }
 697
 698 int nfs_map_name_to_uid(struct nfs_client *clp, const char *name, size_t namelen, __u32 *uid)
 699 {
 700         struct idmap *idmap = clp->cl_idmap;
 701
 702         return nfs_idmap_id(idmap, &idmap->idmap_user_hash, name, namelen, uid);
 703 }
 704
 705 int nfs_map_group_to_gid(struct nfs_client *clp, const char *name, size_t namelen, __u32 *uid)
 706 {
 707         struct idmap *idmap = clp->cl_idmap;
 708
 709         return nfs_idmap_id(idmap, &idmap->idmap_group_hash, name, namelen, uid);
 710 }
 711
 712 int nfs_map_uid_to_name(struct nfs_client *clp, __u32 uid, char *buf, size_t buflen)
 713 {
 714         struct idmap *idmap = clp->cl_idmap;
 715
 716         return nfs_idmap_name(idmap, &idmap->idmap_user_hash, uid, buf);
 717 }
 718 int nfs_map_gid_to_group(struct nfs_client *clp, __u32 uid, char *buf, size_t buflen)
 719 {
 720         struct idmap *idmap = clp->cl_idmap;
 721
 722         return nfs_idmap_name(idmap, &idmap->idmap_group_hash, uid, buf);
 723 }
 724
 725 #endif /* CONFIG_NFS_USE_NEW_IDMAPPER */