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 #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 #include <linux/nfs_fs.h>
  42
  43 /**
  44  * nfs_fattr_init_names - initialise the nfs_fattr owner_name/group_name fields
  45  * @fattr: fully initialised struct nfs_fattr
  46  * @owner_name: owner name string cache
  47  * @group_name: group name string cache
  48  */
  49 void nfs_fattr_init_names(struct nfs_fattr *fattr,
  50                 struct nfs4_string *owner_name,
  51                 struct nfs4_string *group_name)
  52 {
  53         fattr->owner_name = owner_name;
  54         fattr->group_name = group_name;
  55 }
  56
  57 static void nfs_fattr_free_owner_name(struct nfs_fattr *fattr)
  58 {
  59         fattr->valid &= ~NFS_ATTR_FATTR_OWNER_NAME;
  60         kfree(fattr->owner_name->data);
  61 }
  62
  63 static void nfs_fattr_free_group_name(struct nfs_fattr *fattr)
  64 {
  65         fattr->valid &= ~NFS_ATTR_FATTR_GROUP_NAME;
  66         kfree(fattr->group_name->data);
  67 }
  68
  69 static bool nfs_fattr_map_owner_name(struct nfs_server *server, struct nfs_fattr *fattr)
  70 {
  71         struct nfs4_string *owner = fattr->owner_name;
  72         __u32 uid;
  73
  74         if (!(fattr->valid & NFS_ATTR_FATTR_OWNER_NAME))
  75                 return false;
  76         if (nfs_map_name_to_uid(server, owner->data, owner->len, &uid) == 0) {
  77                 fattr->uid = uid;
  78                 fattr->valid |= NFS_ATTR_FATTR_OWNER;
  79         }
  80         return true;
  81 }
  82
  83 static bool nfs_fattr_map_group_name(struct nfs_server *server, struct nfs_fattr *fattr)
  84 {
  85         struct nfs4_string *group = fattr->group_name;
  86         __u32 gid;
  87
  88         if (!(fattr->valid & NFS_ATTR_FATTR_GROUP_NAME))
  89                 return false;
  90         if (nfs_map_group_to_gid(server, group->data, group->len, &gid) == 0) {
  91                 fattr->gid = gid;
  92                 fattr->valid |= NFS_ATTR_FATTR_GROUP;
  93         }
  94         return true;
  95 }
  96
  97 /**
  98  * nfs_fattr_free_names - free up the NFSv4 owner and group strings
  99  * @fattr: a fully initialised nfs_fattr structure
 100  */
 101 void nfs_fattr_free_names(struct nfs_fattr *fattr)
 102 {
 103         if (fattr->valid & NFS_ATTR_FATTR_OWNER_NAME)
 104                 nfs_fattr_free_owner_name(fattr);
 105         if (fattr->valid & NFS_ATTR_FATTR_GROUP_NAME)
 106                 nfs_fattr_free_group_name(fattr);
 107 }
 108
 109 /**
 110  * nfs_fattr_map_and_free_names - map owner/group strings into uid/gid and free
 111  * @server: pointer to the filesystem nfs_server structure
 112  * @fattr: a fully initialised nfs_fattr structure
 113  *
 114  * This helper maps the cached NFSv4 owner/group strings in fattr into
 115  * their numeric uid/gid equivalents, and then frees the cached strings.
 116  */
 117 void nfs_fattr_map_and_free_names(struct nfs_server *server, struct nfs_fattr *fattr)
 118 {
 119         if (nfs_fattr_map_owner_name(server, fattr))
 120                 nfs_fattr_free_owner_name(fattr);
 121         if (nfs_fattr_map_group_name(server, fattr))
 122                 nfs_fattr_free_group_name(fattr);
 123 }
 124
 125 static int nfs_map_string_to_numeric(const char *name, size_t namelen, __u32 *res)
 126 {
 127         unsigned long val;
 128         char buf[16];
 129
 130         if (memchr(name, '@', namelen) != NULL || namelen >= sizeof(buf))
 131                 return 0;
 132         memcpy(buf, name, namelen);
 133         buf[namelen] = '\0';
 134         if (strict_strtoul(buf, 0, &val) != 0)
 135                 return 0;
 136         *res = val;
 137         return 1;
 138 }
 139
 140 static int nfs_map_numeric_to_string(__u32 id, char *buf, size_t buflen)
 141 {
 142         return snprintf(buf, buflen, "%u", id);
 143 }
 144
 145 #ifdef CONFIG_NFS_USE_NEW_IDMAPPER
 146
 147 #include <linux/cred.h>
 148 #include <linux/sunrpc/sched.h>
 149 #include <linux/nfs4.h>
 150 #include <linux/nfs_fs_sb.h>
 151 #include <linux/keyctl.h>
 152 #include <linux/key-type.h>
 153 #include <linux/rcupdate.h>
 154 #include <linux/err.h>
 155
 156 #include <keys/user-type.h>
 157
 158 #define NFS_UINT_MAXLEN 11
 159
 160 const struct cred *id_resolver_cache;
 161
 162 struct key_type key_type_id_resolver = {
 163         .name           = "id_resolver",
 164         .instantiate    = user_instantiate,
 165         .match          = user_match,
 166         .revoke         = user_revoke,
 167         .destroy        = user_destroy,
 168         .describe       = user_describe,
 169         .read           = user_read,
 170 };
 171
 172 int nfs_idmap_init(void)
 173 {
 174         struct cred *cred;
 175         struct key *keyring;
 176         int ret = 0;
 177
 178         printk(KERN_NOTICE "NFS: Registering the %s key type\n",
 179                 key_type_id_resolver.name);
 180
 181         cred = prepare_kernel_cred(NULL);
 182         if (!cred)
 183                 return -ENOMEM;
 184
 185         keyring = key_alloc(&key_type_keyring, ".id_resolver", 0, 0, cred,
 186                              (KEY_POS_ALL & ~KEY_POS_SETATTR) |
 187                              KEY_USR_VIEW | KEY_USR_READ,
 188                              KEY_ALLOC_NOT_IN_QUOTA);
 189         if (IS_ERR(keyring)) {
 190                 ret = PTR_ERR(keyring);
 191                 goto failed_put_cred;
 192         }
 193
 194         ret = key_instantiate_and_link(keyring, NULL, 0, NULL, NULL);
 195         if (ret < 0)
 196                 goto failed_put_key;
 197
 198         ret = register_key_type(&key_type_id_resolver);
 199         if (ret < 0)
 200                 goto failed_put_key;
 201
 202         cred->thread_keyring = keyring;
 203         cred->jit_keyring = KEY_REQKEY_DEFL_THREAD_KEYRING;
 204         id_resolver_cache = cred;
 205         return 0;
 206
 207 failed_put_key:
 208         key_put(keyring);
 209 failed_put_cred:
 210         put_cred(cred);
 211         return ret;
 212 }
 213
 214 void nfs_idmap_quit(void)
 215 {
 216         key_revoke(id_resolver_cache->thread_keyring);
 217         unregister_key_type(&key_type_id_resolver);
 218         put_cred(id_resolver_cache);
 219 }
 220
 221 /*
 222  * Assemble the description to pass to request_key()
 223  * This function will allocate a new string and update dest to point
 224  * at it.  The caller is responsible for freeing dest.
 225  *
 226  * On error 0 is returned.  Otherwise, the length of dest is returned.
 227  */
 228 static ssize_t nfs_idmap_get_desc(const char *name, size_t namelen,
 229                                 const char *type, size_t typelen, char **desc)
 230 {
 231         char *cp;
 232         size_t desclen = typelen + namelen + 2;
 233
 234         *desc = kmalloc(desclen, GFP_KERNEL);
 235         if (!*desc)
 236                 return -ENOMEM;
 237
 238         cp = *desc;
 239         memcpy(cp, type, typelen);
 240         cp += typelen;
 241         *cp++ = ':';
 242
 243         memcpy(cp, name, namelen);
 244         cp += namelen;
 245         *cp = '\0';
 246         return desclen;
 247 }
 248
 249 static ssize_t nfs_idmap_request_key(const char *name, size_t namelen,
 250                 const char *type, void *data, size_t data_size)
 251 {
 252         const struct cred *saved_cred;
 253         struct key *rkey;
 254         char *desc;
 255         struct user_key_payload *payload;
 256         ssize_t ret;
 257
 258         ret = nfs_idmap_get_desc(name, namelen, type, strlen(type), &desc);
 259         if (ret <= 0)
 260                 goto out;
 261
 262         saved_cred = override_creds(id_resolver_cache);
 263         rkey = request_key(&key_type_id_resolver, desc, "");
 264         revert_creds(saved_cred);
 265         kfree(desc);
 266         if (IS_ERR(rkey)) {
 267                 ret = PTR_ERR(rkey);
 268                 goto out;
 269         }
 270
 271         rcu_read_lock();
 272         rkey->perm |= KEY_USR_VIEW;
 273
 274         ret = key_validate(rkey);
 275         if (ret < 0)
 276                 goto out_up;
 277
 278         payload = rcu_dereference(rkey->payload.data);
 279         if (IS_ERR_OR_NULL(payload)) {
 280                 ret = PTR_ERR(payload);
 281                 goto out_up;
 282         }
 283
 284         ret = payload->datalen;
 285         if (ret > 0 && ret <= data_size)
 286                 memcpy(data, payload->data, ret);
 287         else
 288                 ret = -EINVAL;
 289
 290 out_up:
 291         rcu_read_unlock();
 292         key_put(rkey);
 293 out:
 294         return ret;
 295 }
 296
 297
 298 /* ID -> Name */
 299 static ssize_t nfs_idmap_lookup_name(__u32 id, const char *type, char *buf, size_t buflen)
 300 {
 301         char id_str[NFS_UINT_MAXLEN];
 302         int id_len;
 303         ssize_t ret;
 304
 305         id_len = snprintf(id_str, sizeof(id_str), "%u", id);
 306         ret = nfs_idmap_request_key(id_str, id_len, type, buf, buflen);
 307         if (ret < 0)
 308                 return -EINVAL;
 309         return ret;
 310 }
 311
 312 /* Name -> ID */
 313 static int nfs_idmap_lookup_id(const char *name, size_t namelen,
 314                                 const char *type, __u32 *id)
 315 {
 316         char id_str[NFS_UINT_MAXLEN];
 317         long id_long;
 318         ssize_t data_size;
 319         int ret = 0;
 320
 321         data_size = nfs_idmap_request_key(name, namelen, type, id_str, NFS_UINT_MAXLEN);
 322         if (data_size <= 0) {
 323                 ret = -EINVAL;
 324         } else {
 325                 ret = strict_strtol(id_str, 10, &id_long);
 326                 *id = (__u32)id_long;
 327         }
 328         return ret;
 329 }
 330
 331 int nfs_map_name_to_uid(const struct nfs_server *server, const char *name, size_t namelen, __u32 *uid)
 332 {
 333         if (nfs_map_string_to_numeric(name, namelen, uid))
 334                 return 0;
 335         return nfs_idmap_lookup_id(name, namelen, "uid", uid);
 336 }
 337
 338 int nfs_map_group_to_gid(const struct nfs_server *server, const char *name, size_t namelen, __u32 *gid)
 339 {
 340         if (nfs_map_string_to_numeric(name, namelen, gid))
 341                 return 0;
 342         return nfs_idmap_lookup_id(name, namelen, "gid", gid);
 343 }
 344
 345 int nfs_map_uid_to_name(const struct nfs_server *server, __u32 uid, char *buf, size_t buflen)
 346 {
 347         int ret = -EINVAL;
 348
 349         if (!(server->caps & NFS_CAP_UIDGID_NOMAP))
 350                 ret = nfs_idmap_lookup_name(uid, "user", buf, buflen);
 351         if (ret < 0)
 352                 ret = nfs_map_numeric_to_string(uid, buf, buflen);
 353         return ret;
 354 }
 355 int nfs_map_gid_to_group(const struct nfs_server *server, __u32 gid, char *buf, size_t buflen)
 356 {
 357         int ret = -EINVAL;
 358
 359         if (!(server->caps & NFS_CAP_UIDGID_NOMAP))
 360                 ret = nfs_idmap_lookup_name(gid, "group", buf, buflen);
 361         if (ret < 0)
 362                 ret = nfs_map_numeric_to_string(gid, buf, buflen);
 363         return ret;
 364 }
 365
 366 #else  /* CONFIG_NFS_USE_NEW_IDMAPPER not defined */
 367
 368 #include <linux/module.h>
 369 #include <linux/mutex.h>
 370 #include <linux/init.h>
 371 #include <linux/socket.h>
 372 #include <linux/in.h>
 373 #include <linux/sched.h>
 374 #include <linux/sunrpc/clnt.h>
 375 #include <linux/workqueue.h>
 376 #include <linux/sunrpc/rpc_pipe_fs.h>
 377
 378 #include <linux/nfs_fs.h>
 379
 380 #include "nfs4_fs.h"
 381 #include "internal.h"
 382
 383 #define IDMAP_HASH_SZ          128
 384
 385 /* Default cache timeout is 10 minutes */
 386 unsigned int nfs_idmap_cache_timeout = 600 * HZ;
 387
 388 static int param_set_idmap_timeout(const char *val, struct kernel_param *kp)
 389 {
 390         char *endp;
 391         int num = simple_strtol(val, &endp, 0);
 392         int jif = num * HZ;
 393         if (endp == val || *endp || num < 0 || jif < num)
 394                 return -EINVAL;
 395         *((int *)kp->arg) = jif;
 396         return 0;
 397 }
 398
 399 module_param_call(idmap_cache_timeout, param_set_idmap_timeout, param_get_int,
 400                  &nfs_idmap_cache_timeout, 0644);
 401
 402 struct idmap_hashent {
 403         unsigned long           ih_expires;
 404         __u32                   ih_id;
 405         size_t                  ih_namelen;
 406         char                    ih_name[IDMAP_NAMESZ];
 407 };
 408
 409 struct idmap_hashtable {
 410         __u8                    h_type;
 411         struct idmap_hashent    h_entries[IDMAP_HASH_SZ];
 412 };
 413
 414 struct idmap {
 415         struct rpc_pipe         *idmap_pipe;
 416         wait_queue_head_t       idmap_wq;
 417         struct idmap_msg        idmap_im;
 418         struct mutex            idmap_lock;     /* Serializes upcalls */
 419         struct mutex            idmap_im_lock;  /* Protects the hashtable */
 420         struct idmap_hashtable  idmap_user_hash;
 421         struct idmap_hashtable  idmap_group_hash;
 422 };
 423
 424 static ssize_t idmap_pipe_downcall(struct file *, const char __user *,
 425                                    size_t);
 426 static void idmap_pipe_destroy_msg(struct rpc_pipe_msg *);
 427
 428 static unsigned int fnvhash32(const void *, size_t);
 429
 430 static const struct rpc_pipe_ops idmap_upcall_ops = {
 431         .upcall         = rpc_pipe_generic_upcall,
 432         .downcall       = idmap_pipe_downcall,
 433         .destroy_msg    = idmap_pipe_destroy_msg,
 434 };
 435
 436 static void __nfs_idmap_unregister(struct rpc_pipe *pipe)
 437 {
 438         if (pipe->dentry)
 439                 rpc_unlink(pipe->dentry);
 440 }
 441
 442 static int __nfs_idmap_register(struct dentry *dir,
 443                                      struct idmap *idmap,
 444                                      struct rpc_pipe *pipe)
 445 {
 446         struct dentry *dentry;
 447
 448         dentry = rpc_mkpipe_dentry(dir, "idmap", idmap, pipe);
 449         if (IS_ERR(dentry))
 450                 return PTR_ERR(dentry);
 451         pipe->dentry = dentry;
 452         return 0;
 453 }
 454
 455 static void nfs_idmap_unregister(struct nfs_client *clp,
 456                                       struct rpc_pipe *pipe)
 457 {
 458         struct net *net = clp->net;
 459         struct super_block *pipefs_sb;
 460
 461         pipefs_sb = rpc_get_sb_net(net);
 462         if (pipefs_sb) {
 463                 __nfs_idmap_unregister(pipe);
 464                 rpc_put_sb_net(net);
 465         }
 466 }
 467
 468 static int nfs_idmap_register(struct nfs_client *clp,
 469                                    struct idmap *idmap,
 470                                    struct rpc_pipe *pipe)
 471 {
 472         struct net *net = clp->net;
 473         struct super_block *pipefs_sb;
 474         int err = 0;
 475
 476         pipefs_sb = rpc_get_sb_net(net);
 477         if (pipefs_sb) {
 478                 if (clp->cl_rpcclient->cl_dentry)
 479                         err = __nfs_idmap_register(clp->cl_rpcclient->cl_dentry,
 480                                                    idmap, pipe);
 481                 rpc_put_sb_net(net);
 482         }
 483         return err;
 484 }
 485
 486 int
 487 nfs_idmap_new(struct nfs_client *clp)
 488 {
 489         struct idmap *idmap;
 490         struct rpc_pipe *pipe;
 491         int error;
 492
 493         BUG_ON(clp->cl_idmap != NULL);
 494
 495         idmap = kzalloc(sizeof(*idmap), GFP_KERNEL);
 496         if (idmap == NULL)
 497                 return -ENOMEM;
 498
 499         pipe = rpc_mkpipe_data(&idmap_upcall_ops, 0);
 500         if (IS_ERR(pipe)) {
 501                 error = PTR_ERR(pipe);
 502                 kfree(idmap);
 503                 return error;
 504         }
 505         error = nfs_idmap_register(clp, idmap, pipe);
 506         if (error) {
 507                 rpc_destroy_pipe_data(pipe);
 508                 kfree(idmap);
 509                 return error;
 510         }
 511         idmap->idmap_pipe = pipe;
 512         mutex_init(&idmap->idmap_lock);
 513         mutex_init(&idmap->idmap_im_lock);
 514         init_waitqueue_head(&idmap->idmap_wq);
 515         idmap->idmap_user_hash.h_type = IDMAP_TYPE_USER;
 516         idmap->idmap_group_hash.h_type = IDMAP_TYPE_GROUP;
 517
 518         clp->cl_idmap = idmap;
 519         return 0;
 520 }
 521
 522 void
 523 nfs_idmap_delete(struct nfs_client *clp)
 524 {
 525         struct idmap *idmap = clp->cl_idmap;
 526
 527         if (!idmap)
 528                 return;
 529         nfs_idmap_unregister(clp, idmap->idmap_pipe);
 530         rpc_destroy_pipe_data(idmap->idmap_pipe);
 531         clp->cl_idmap = NULL;
 532         kfree(idmap);
 533 }
 534
 535 static int __rpc_pipefs_event(struct nfs_client *clp, unsigned long event,
 536                               struct super_block *sb)
 537 {
 538         int err = 0;
 539
 540         switch (event) {
 541         case RPC_PIPEFS_MOUNT:
 542                 BUG_ON(clp->cl_rpcclient->cl_dentry == NULL);
 543                 err = __nfs_idmap_register(clp->cl_rpcclient->cl_dentry,
 544                                                 clp->cl_idmap,
 545                                                 clp->cl_idmap->idmap_pipe);
 546                 break;
 547         case RPC_PIPEFS_UMOUNT:
 548                 if (clp->cl_idmap->idmap_pipe) {
 549                         struct dentry *parent;
 550
 551                         parent = clp->cl_idmap->idmap_pipe->dentry->d_parent;
 552                         __nfs_idmap_unregister(clp->cl_idmap->idmap_pipe);
 553                         /*
 554                          * Note: This is a dirty hack. SUNRPC hook has been
 555                          * called already but simple_rmdir() call for the
 556                          * directory returned with error because of idmap pipe
 557                          * inside. Thus now we have to remove this directory
 558                          * here.
 559                          */
 560                         if (rpc_rmdir(parent))
 561                                 printk(KERN_ERR "NFS: %s: failed to remove "
 562                                         "clnt dir!\n", __func__);
 563                 }
 564                 break;
 565         default:
 566                 printk(KERN_ERR "NFS: %s: unknown event: %ld\n", __func__,
 567                         event);
 568                 return -ENOTSUPP;
 569         }
 570         return err;
 571 }
 572
 573 static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event,
 574                             void *ptr)
 575 {
 576         struct super_block *sb = ptr;
 577         struct nfs_client *clp;
 578         int error = 0;
 579
 580         spin_lock(&nfs_client_lock);
 581         list_for_each_entry(clp, &nfs_client_list, cl_share_link) {
 582                 if (clp->net != sb->s_fs_info)
 583                         continue;
 584                 if (clp->rpc_ops != &nfs_v4_clientops)
 585                         continue;
 586                 error = __rpc_pipefs_event(clp, event, sb);
 587                 if (error)
 588                         break;
 589         }
 590         spin_unlock(&nfs_client_lock);
 591         return error;
 592 }
 593
 594 #define PIPEFS_NFS_PRIO         1
 595
 596 static struct notifier_block nfs_idmap_block = {
 597         .notifier_call  = rpc_pipefs_event,
 598         .priority       = SUNRPC_PIPEFS_NFS_PRIO,
 599 };
 600
 601 int nfs_idmap_init(void)
 602 {
 603         return rpc_pipefs_notifier_register(&nfs_idmap_block);
 604 }
 605
 606 void nfs_idmap_quit(void)
 607 {
 608         rpc_pipefs_notifier_unregister(&nfs_idmap_block);
 609 }
 610
 611 /*
 612  * Helper routines for manipulating the hashtable
 613  */
 614 static inline struct idmap_hashent *
 615 idmap_name_hash(struct idmap_hashtable* h, const char *name, size_t len)
 616 {
 617         return &h->h_entries[fnvhash32(name, len) % IDMAP_HASH_SZ];
 618 }
 619
 620 static struct idmap_hashent *
 621 idmap_lookup_name(struct idmap_hashtable *h, const char *name, size_t len)
 622 {
 623         struct idmap_hashent *he = idmap_name_hash(h, name, len);
 624
 625         if (he->ih_namelen != len || memcmp(he->ih_name, name, len) != 0)
 626                 return NULL;
 627         if (time_after(jiffies, he->ih_expires))
 628                 return NULL;
 629         return he;
 630 }
 631
 632 static inline struct idmap_hashent *
 633 idmap_id_hash(struct idmap_hashtable* h, __u32 id)
 634 {
 635         return &h->h_entries[fnvhash32(&id, sizeof(id)) % IDMAP_HASH_SZ];
 636 }
 637
 638 static struct idmap_hashent *
 639 idmap_lookup_id(struct idmap_hashtable *h, __u32 id)
 640 {
 641         struct idmap_hashent *he = idmap_id_hash(h, id);
 642         if (he->ih_id != id || he->ih_namelen == 0)
 643                 return NULL;
 644         if (time_after(jiffies, he->ih_expires))
 645                 return NULL;
 646         return he;
 647 }
 648
 649 /*
 650  * Routines for allocating new entries in the hashtable.
 651  * For now, we just have 1 entry per bucket, so it's all
 652  * pretty trivial.
 653  */
 654 static inline struct idmap_hashent *
 655 idmap_alloc_name(struct idmap_hashtable *h, char *name, size_t len)
 656 {
 657         return idmap_name_hash(h, name, len);
 658 }
 659
 660 static inline struct idmap_hashent *
 661 idmap_alloc_id(struct idmap_hashtable *h, __u32 id)
 662 {
 663         return idmap_id_hash(h, id);
 664 }
 665
 666 static void
 667 idmap_update_entry(struct idmap_hashent *he, const char *name,
 668                 size_t namelen, __u32 id)
 669 {
 670         he->ih_id = id;
 671         memcpy(he->ih_name, name, namelen);
 672         he->ih_name[namelen] = '\0';
 673         he->ih_namelen = namelen;
 674         he->ih_expires = jiffies + nfs_idmap_cache_timeout;
 675 }
 676
 677 /*
 678  * Name -> ID
 679  */
 680 static int
 681 nfs_idmap_id(struct idmap *idmap, struct idmap_hashtable *h,
 682                 const char *name, size_t namelen, __u32 *id)
 683 {
 684         struct rpc_pipe_msg msg;
 685         struct idmap_msg *im;
 686         struct idmap_hashent *he;
 687         DECLARE_WAITQUEUE(wq, current);
 688         int ret = -EIO;
 689
 690         im = &idmap->idmap_im;
 691
 692         /*
 693          * String sanity checks
 694          * Note that the userland daemon expects NUL terminated strings
 695          */
 696         for (;;) {
 697                 if (namelen == 0)
 698                         return -EINVAL;
 699                 if (name[namelen-1] != '\0')
 700                         break;
 701                 namelen--;
 702         }
 703         if (namelen >= IDMAP_NAMESZ)
 704                 return -EINVAL;
 705
 706         mutex_lock(&idmap->idmap_lock);
 707         mutex_lock(&idmap->idmap_im_lock);
 708
 709         he = idmap_lookup_name(h, name, namelen);
 710         if (he != NULL) {
 711                 *id = he->ih_id;
 712                 ret = 0;
 713                 goto out;
 714         }
 715
 716         memset(im, 0, sizeof(*im));
 717         memcpy(im->im_name, name, namelen);
 718
 719         im->im_type = h->h_type;
 720         im->im_conv = IDMAP_CONV_NAMETOID;
 721
 722         memset(&msg, 0, sizeof(msg));
 723         msg.data = im;
 724         msg.len = sizeof(*im);
 725
 726         add_wait_queue(&idmap->idmap_wq, &wq);
 727         if (rpc_queue_upcall(idmap->idmap_pipe, &msg) < 0) {
 728                 remove_wait_queue(&idmap->idmap_wq, &wq);
 729                 goto out;
 730         }
 731
 732         set_current_state(TASK_UNINTERRUPTIBLE);
 733         mutex_unlock(&idmap->idmap_im_lock);
 734         schedule();
 735         __set_current_state(TASK_RUNNING);
 736         remove_wait_queue(&idmap->idmap_wq, &wq);
 737         mutex_lock(&idmap->idmap_im_lock);
 738
 739         if (im->im_status & IDMAP_STATUS_SUCCESS) {
 740                 *id = im->im_id;
 741                 ret = 0;
 742         }
 743
 744  out:
 745         memset(im, 0, sizeof(*im));
 746         mutex_unlock(&idmap->idmap_im_lock);
 747         mutex_unlock(&idmap->idmap_lock);
 748         return ret;
 749 }
 750
 751 /*
 752  * ID -> Name
 753  */
 754 static int
 755 nfs_idmap_name(struct idmap *idmap, struct idmap_hashtable *h,
 756                 __u32 id, char *name)
 757 {
 758         struct rpc_pipe_msg msg;
 759         struct idmap_msg *im;
 760         struct idmap_hashent *he;
 761         DECLARE_WAITQUEUE(wq, current);
 762         int ret = -EIO;
 763         unsigned int len;
 764
 765         im = &idmap->idmap_im;
 766
 767         mutex_lock(&idmap->idmap_lock);
 768         mutex_lock(&idmap->idmap_im_lock);
 769
 770         he = idmap_lookup_id(h, id);
 771         if (he) {
 772                 memcpy(name, he->ih_name, he->ih_namelen);
 773                 ret = he->ih_namelen;
 774                 goto out;
 775         }
 776
 777         memset(im, 0, sizeof(*im));
 778         im->im_type = h->h_type;
 779         im->im_conv = IDMAP_CONV_IDTONAME;
 780         im->im_id = id;
 781
 782         memset(&msg, 0, sizeof(msg));
 783         msg.data = im;
 784         msg.len = sizeof(*im);
 785
 786         add_wait_queue(&idmap->idmap_wq, &wq);
 787
 788         if (rpc_queue_upcall(idmap->idmap_pipe, &msg) < 0) {
 789                 remove_wait_queue(&idmap->idmap_wq, &wq);
 790                 goto out;
 791         }
 792
 793         set_current_state(TASK_UNINTERRUPTIBLE);
 794         mutex_unlock(&idmap->idmap_im_lock);
 795         schedule();
 796         __set_current_state(TASK_RUNNING);
 797         remove_wait_queue(&idmap->idmap_wq, &wq);
 798         mutex_lock(&idmap->idmap_im_lock);
 799
 800         if (im->im_status & IDMAP_STATUS_SUCCESS) {
 801                 if ((len = strnlen(im->im_name, IDMAP_NAMESZ)) == 0)
 802                         goto out;
 803                 memcpy(name, im->im_name, len);
 804                 ret = len;
 805         }
 806
 807  out:
 808         memset(im, 0, sizeof(*im));
 809         mutex_unlock(&idmap->idmap_im_lock);
 810         mutex_unlock(&idmap->idmap_lock);
 811         return ret;
 812 }
 813
 814 static ssize_t
 815 idmap_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
 816 {
 817         struct rpc_inode *rpci = RPC_I(filp->f_path.dentry->d_inode);
 818         struct idmap *idmap = (struct idmap *)rpci->private;
 819         struct idmap_msg im_in, *im = &idmap->idmap_im;
 820         struct idmap_hashtable *h;
 821         struct idmap_hashent *he = NULL;
 822         size_t namelen_in;
 823         int ret;
 824
 825         if (mlen != sizeof(im_in))
 826                 return -ENOSPC;
 827
 828         if (copy_from_user(&im_in, src, mlen) != 0)
 829                 return -EFAULT;
 830
 831         mutex_lock(&idmap->idmap_im_lock);
 832
 833         ret = mlen;
 834         im->im_status = im_in.im_status;
 835         /* If we got an error, terminate now, and wake up pending upcalls */
 836         if (!(im_in.im_status & IDMAP_STATUS_SUCCESS)) {
 837                 wake_up(&idmap->idmap_wq);
 838                 goto out;
 839         }
 840
 841         /* Sanity checking of strings */
 842         ret = -EINVAL;
 843         namelen_in = strnlen(im_in.im_name, IDMAP_NAMESZ);
 844         if (namelen_in == 0 || namelen_in == IDMAP_NAMESZ)
 845                 goto out;
 846
 847         switch (im_in.im_type) {
 848                 case IDMAP_TYPE_USER:
 849                         h = &idmap->idmap_user_hash;
 850                         break;
 851                 case IDMAP_TYPE_GROUP:
 852                         h = &idmap->idmap_group_hash;
 853                         break;
 854                 default:
 855                         goto out;
 856         }
 857
 858         switch (im_in.im_conv) {
 859         case IDMAP_CONV_IDTONAME:
 860                 /* Did we match the current upcall? */
 861                 if (im->im_conv == IDMAP_CONV_IDTONAME
 862                                 && im->im_type == im_in.im_type
 863                                 && im->im_id == im_in.im_id) {
 864                         /* Yes: copy string, including the terminating '\0'  */
 865                         memcpy(im->im_name, im_in.im_name, namelen_in);
 866                         im->im_name[namelen_in] = '\0';
 867                         wake_up(&idmap->idmap_wq);
 868                 }
 869                 he = idmap_alloc_id(h, im_in.im_id);
 870                 break;
 871         case IDMAP_CONV_NAMETOID:
 872                 /* Did we match the current upcall? */
 873                 if (im->im_conv == IDMAP_CONV_NAMETOID
 874                                 && im->im_type == im_in.im_type
 875                                 && strnlen(im->im_name, IDMAP_NAMESZ) == namelen_in
 876                                 && memcmp(im->im_name, im_in.im_name, namelen_in) == 0) {
 877                         im->im_id = im_in.im_id;
 878                         wake_up(&idmap->idmap_wq);
 879                 }
 880                 he = idmap_alloc_name(h, im_in.im_name, namelen_in);
 881                 break;
 882         default:
 883                 goto out;
 884         }
 885
 886         /* If the entry is valid, also copy it to the cache */
 887         if (he != NULL)
 888                 idmap_update_entry(he, im_in.im_name, namelen_in, im_in.im_id);
 889         ret = mlen;
 890 out:
 891         mutex_unlock(&idmap->idmap_im_lock);
 892         return ret;
 893 }
 894
 895 static void
 896 idmap_pipe_destroy_msg(struct rpc_pipe_msg *msg)
 897 {
 898         struct idmap_msg *im = msg->data;
 899         struct idmap *idmap = container_of(im, struct idmap, idmap_im);
 900
 901         if (msg->errno >= 0)
 902                 return;
 903         mutex_lock(&idmap->idmap_im_lock);
 904         im->im_status = IDMAP_STATUS_LOOKUPFAIL;
 905         wake_up(&idmap->idmap_wq);
 906         mutex_unlock(&idmap->idmap_im_lock);
 907 }
 908
 909 /*
 910  * Fowler/Noll/Vo hash
 911  *    http://www.isthe.com/chongo/tech/comp/fnv/
 912  */
 913
 914 #define FNV_P_32 ((unsigned int)0x01000193) /* 16777619 */
 915 #define FNV_1_32 ((unsigned int)0x811c9dc5) /* 2166136261 */
 916
 917 static unsigned int fnvhash32(const void *buf, size_t buflen)
 918 {
 919         const unsigned char *p, *end = (const unsigned char *)buf + buflen;
 920         unsigned int hash = FNV_1_32;
 921
 922         for (p = buf; p < end; p++) {
 923                 hash *= FNV_P_32;
 924                 hash ^= (unsigned int)*p;
 925         }
 926
 927         return hash;
 928 }
 929
 930 int nfs_map_name_to_uid(const struct nfs_server *server, const char *name, size_t namelen, __u32 *uid)
 931 {
 932         struct idmap *idmap = server->nfs_client->cl_idmap;
 933
 934         if (nfs_map_string_to_numeric(name, namelen, uid))
 935                 return 0;
 936         return nfs_idmap_id(idmap, &idmap->idmap_user_hash, name, namelen, uid);
 937 }
 938
 939 int nfs_map_group_to_gid(const struct nfs_server *server, const char *name, size_t namelen, __u32 *uid)
 940 {
 941         struct idmap *idmap = server->nfs_client->cl_idmap;
 942
 943         if (nfs_map_string_to_numeric(name, namelen, uid))
 944                 return 0;
 945         return nfs_idmap_id(idmap, &idmap->idmap_group_hash, name, namelen, uid);
 946 }
 947
 948 int nfs_map_uid_to_name(const struct nfs_server *server, __u32 uid, char *buf, size_t buflen)
 949 {
 950         struct idmap *idmap = server->nfs_client->cl_idmap;
 951         int ret = -EINVAL;
 952
 953         if (!(server->caps & NFS_CAP_UIDGID_NOMAP))
 954                 ret = nfs_idmap_name(idmap, &idmap->idmap_user_hash, uid, buf);
 955         if (ret < 0)
 956                 ret = nfs_map_numeric_to_string(uid, buf, buflen);
 957         return ret;
 958 }
 959 int nfs_map_gid_to_group(const struct nfs_server *server, __u32 uid, char *buf, size_t buflen)
 960 {
 961         struct idmap *idmap = server->nfs_client->cl_idmap;
 962         int ret = -EINVAL;
 963
 964         if (!(server->caps & NFS_CAP_UIDGID_NOMAP))
 965                 ret = nfs_idmap_name(idmap, &idmap->idmap_group_hash, uid, buf);
 966         if (ret < 0)
 967                 ret = nfs_map_numeric_to_string(uid, buf, buflen);
 968         return ret;
 969 }
 970
 971 #endif /* CONFIG_NFS_USE_NEW_IDMAPPER */