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 56 static const struct cred *id_resolver_cache; 57 static struct key_type key_type_id_resolver_legacy; 58 59 struct 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 66 struct 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 */ 79 void 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 87 static 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 93 static 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 99 static 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 113 static 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 */ 131 void 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 */ 147 void 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 155 int 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 } 169 EXPORT_SYMBOL_GPL(nfs_map_string_to_numeric); 170 171 static int nfs_map_numeric_to_string(__u32 id, char *buf, size_t buflen) 172 { 173 return snprintf(buf, buflen, "%u", id); 174 } 175 176 static 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 187 static int nfs_idmap_init_keyring(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); 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 224 failed_reg_legacy: 225 unregister_key_type(&key_type_id_resolver); 226 failed_put_key: 227 key_put(keyring); 228 failed_put_cred: 229 put_cred(cred); 230 return ret; 231 } 232 233 static void nfs_idmap_quit_keyring(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 */ 248 static 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 269 static 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 294 static 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 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 = rcu_dereference(rkey->payload.rcudata); 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 331 out_up: 332 rcu_read_unlock(); 333 key_put(rkey); 334 out: 335 return ret; 336 } 337 338 /* ID -> Name */ 339 static 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 = snprintf(id_str, sizeof(id_str), "%u", id); 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 */ 354 static 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 *id = (__u32)id_long; 368 } 369 return ret; 370 } 371 372 /* idmap classic begins here */ 373 374 enum { 375 Opt_find_uid, Opt_find_gid, Opt_find_user, Opt_find_group, Opt_find_err 376 }; 377 378 static const match_table_t nfs_idmap_tokens = { 379 { Opt_find_uid, "uid:%s" }, 380 { Opt_find_gid, "gid:%s" }, 381 { Opt_find_user, "user:%s" }, 382 { Opt_find_group, "group:%s" }, 383 { Opt_find_err, NULL } 384 }; 385 386 static int nfs_idmap_legacy_upcall(struct key_construction *, const char *, void *); 387 static ssize_t idmap_pipe_downcall(struct file *, const char __user *, 388 size_t); 389 static void idmap_release_pipe(struct inode *); 390 static void idmap_pipe_destroy_msg(struct rpc_pipe_msg *); 391 392 static const struct rpc_pipe_ops idmap_upcall_ops = { 393 .upcall = rpc_pipe_generic_upcall, 394 .downcall = idmap_pipe_downcall, 395 .release_pipe = idmap_release_pipe, 396 .destroy_msg = idmap_pipe_destroy_msg, 397 }; 398 399 static struct key_type key_type_id_resolver_legacy = { 400 .name = "id_legacy", 401 .preparse = user_preparse, 402 .free_preparse = user_free_preparse, 403 .instantiate = generic_key_instantiate, 404 .revoke = user_revoke, 405 .destroy = user_destroy, 406 .describe = user_describe, 407 .read = user_read, 408 .request_key = nfs_idmap_legacy_upcall, 409 }; 410 411 static void nfs_idmap_pipe_destroy(struct dentry *dir, 412 struct rpc_pipe_dir_object *pdo) 413 { 414 struct idmap *idmap = pdo->pdo_data; 415 struct rpc_pipe *pipe = idmap->idmap_pipe; 416 417 if (pipe->dentry) { 418 rpc_unlink(pipe->dentry); 419 pipe->dentry = NULL; 420 } 421 } 422 423 static int nfs_idmap_pipe_create(struct dentry *dir, 424 struct rpc_pipe_dir_object *pdo) 425 { 426 struct idmap *idmap = pdo->pdo_data; 427 struct rpc_pipe *pipe = idmap->idmap_pipe; 428 struct dentry *dentry; 429 430 dentry = rpc_mkpipe_dentry(dir, "idmap", idmap, pipe); 431 if (IS_ERR(dentry)) 432 return PTR_ERR(dentry); 433 pipe->dentry = dentry; 434 return 0; 435 } 436 437 static const struct rpc_pipe_dir_object_ops nfs_idmap_pipe_dir_object_ops = { 438 .create = nfs_idmap_pipe_create, 439 .destroy = nfs_idmap_pipe_destroy, 440 }; 441 442 int 443 nfs_idmap_new(struct nfs_client *clp) 444 { 445 struct idmap *idmap; 446 struct rpc_pipe *pipe; 447 int error; 448 449 idmap = kzalloc(sizeof(*idmap), GFP_KERNEL); 450 if (idmap == NULL) 451 return -ENOMEM; 452 453 rpc_init_pipe_dir_object(&idmap->idmap_pdo, 454 &nfs_idmap_pipe_dir_object_ops, 455 idmap); 456 457 pipe = rpc_mkpipe_data(&idmap_upcall_ops, 0); 458 if (IS_ERR(pipe)) { 459 error = PTR_ERR(pipe); 460 goto err; 461 } 462 idmap->idmap_pipe = pipe; 463 mutex_init(&idmap->idmap_mutex); 464 465 error = rpc_add_pipe_dir_object(clp->cl_net, 466 &clp->cl_rpcclient->cl_pipedir_objects, 467 &idmap->idmap_pdo); 468 if (error) 469 goto err_destroy_pipe; 470 471 clp->cl_idmap = idmap; 472 return 0; 473 err_destroy_pipe: 474 rpc_destroy_pipe_data(idmap->idmap_pipe); 475 err: 476 kfree(idmap); 477 return error; 478 } 479 480 void 481 nfs_idmap_delete(struct nfs_client *clp) 482 { 483 struct idmap *idmap = clp->cl_idmap; 484 485 if (!idmap) 486 return; 487 clp->cl_idmap = NULL; 488 rpc_remove_pipe_dir_object(clp->cl_net, 489 &clp->cl_rpcclient->cl_pipedir_objects, 490 &idmap->idmap_pdo); 491 rpc_destroy_pipe_data(idmap->idmap_pipe); 492 kfree(idmap); 493 } 494 495 int nfs_idmap_init(void) 496 { 497 return nfs_idmap_init_keyring(); 498 } 499 500 void nfs_idmap_quit(void) 501 { 502 nfs_idmap_quit_keyring(); 503 } 504 505 static int nfs_idmap_prepare_message(char *desc, struct idmap *idmap, 506 struct idmap_msg *im, 507 struct rpc_pipe_msg *msg) 508 { 509 substring_t substr; 510 int token, ret; 511 512 im->im_type = IDMAP_TYPE_GROUP; 513 token = match_token(desc, nfs_idmap_tokens, &substr); 514 515 switch (token) { 516 case Opt_find_uid: 517 im->im_type = IDMAP_TYPE_USER; 518 case Opt_find_gid: 519 im->im_conv = IDMAP_CONV_NAMETOID; 520 ret = match_strlcpy(im->im_name, &substr, IDMAP_NAMESZ); 521 break; 522 523 case Opt_find_user: 524 im->im_type = IDMAP_TYPE_USER; 525 case Opt_find_group: 526 im->im_conv = IDMAP_CONV_IDTONAME; 527 ret = match_int(&substr, &im->im_id); 528 break; 529 530 default: 531 ret = -EINVAL; 532 goto out; 533 } 534 535 msg->data = im; 536 msg->len = sizeof(struct idmap_msg); 537 538 out: 539 return ret; 540 } 541 542 static bool 543 nfs_idmap_prepare_pipe_upcall(struct idmap *idmap, 544 struct idmap_legacy_upcalldata *data) 545 { 546 if (idmap->idmap_upcall_data != NULL) { 547 WARN_ON_ONCE(1); 548 return false; 549 } 550 idmap->idmap_upcall_data = data; 551 return true; 552 } 553 554 static void 555 nfs_idmap_complete_pipe_upcall_locked(struct idmap *idmap, int ret) 556 { 557 struct key_construction *cons = idmap->idmap_upcall_data->key_cons; 558 559 kfree(idmap->idmap_upcall_data); 560 idmap->idmap_upcall_data = NULL; 561 complete_request_key(cons, ret); 562 } 563 564 static void 565 nfs_idmap_abort_pipe_upcall(struct idmap *idmap, int ret) 566 { 567 if (idmap->idmap_upcall_data != NULL) 568 nfs_idmap_complete_pipe_upcall_locked(idmap, ret); 569 } 570 571 static int nfs_idmap_legacy_upcall(struct key_construction *cons, 572 const char *op, 573 void *aux) 574 { 575 struct idmap_legacy_upcalldata *data; 576 struct rpc_pipe_msg *msg; 577 struct idmap_msg *im; 578 struct idmap *idmap = (struct idmap *)aux; 579 struct key *key = cons->key; 580 int ret = -ENOMEM; 581 582 /* msg and im are freed in idmap_pipe_destroy_msg */ 583 data = kzalloc(sizeof(*data), GFP_KERNEL); 584 if (!data) 585 goto out1; 586 587 msg = &data->pipe_msg; 588 im = &data->idmap_msg; 589 data->idmap = idmap; 590 data->key_cons = cons; 591 592 ret = nfs_idmap_prepare_message(key->description, idmap, im, msg); 593 if (ret < 0) 594 goto out2; 595 596 ret = -EAGAIN; 597 if (!nfs_idmap_prepare_pipe_upcall(idmap, data)) 598 goto out2; 599 600 ret = rpc_queue_upcall(idmap->idmap_pipe, msg); 601 if (ret < 0) 602 nfs_idmap_abort_pipe_upcall(idmap, ret); 603 604 return ret; 605 out2: 606 kfree(data); 607 out1: 608 complete_request_key(cons, ret); 609 return ret; 610 } 611 612 static int nfs_idmap_instantiate(struct key *key, struct key *authkey, char *data, size_t datalen) 613 { 614 return key_instantiate_and_link(key, data, datalen, 615 id_resolver_cache->thread_keyring, 616 authkey); 617 } 618 619 static int nfs_idmap_read_and_verify_message(struct idmap_msg *im, 620 struct idmap_msg *upcall, 621 struct key *key, struct key *authkey) 622 { 623 char id_str[NFS_UINT_MAXLEN]; 624 size_t len; 625 int ret = -ENOKEY; 626 627 /* ret = -ENOKEY */ 628 if (upcall->im_type != im->im_type || upcall->im_conv != im->im_conv) 629 goto out; 630 switch (im->im_conv) { 631 case IDMAP_CONV_NAMETOID: 632 if (strcmp(upcall->im_name, im->im_name) != 0) 633 break; 634 /* Note: here we store the NUL terminator too */ 635 len = sprintf(id_str, "%d", im->im_id) + 1; 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 } 647 out: 648 return ret; 649 } 650 651 static ssize_t 652 idmap_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 699 out: 700 nfs_idmap_complete_pipe_upcall_locked(idmap, ret); 701 out_noupcall: 702 return ret; 703 } 704 705 static void 706 idmap_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 717 static void 718 idmap_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 726 int 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 743 int 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 760 int 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 } 774 int 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