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