idmap.c 19.6 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
/*
 * fs/nfs/idmap.c
 *
 *  UID and GID to name mapping for clients.
 *
 *  Copyright (c) 2002 The Regents of the University of Michigan.
 *  All rights reserved.
 *
 *  Marius Aamodt Eriksen <marius@umich.edu>
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the University nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
36
#include <linux/types.h>
37 38
#include <linux/parser.h>
#include <linux/fs.h>
39
#include <linux/nfs_idmap.h>
40 41
#include <net/net_namespace.h>
#include <linux/sunrpc/rpc_pipe_fs.h>
42
#include <linux/nfs_fs.h>
43
#include <linux/nfs_fs_sb.h>
44
#include <linux/key.h>
45 46 47 48
#include <linux/keyctl.h>
#include <linux/key-type.h>
#include <keys/user-type.h>
#include <linux/module.h>
49

50
#include "internal.h"
51
#include "netns.h"
52 53 54 55

#define NFS_UINT_MAXLEN 11

/* Default cache timeout is 10 minutes */
56
unsigned int nfs_idmap_cache_timeout = 600;
57 58
static const struct cred *id_resolver_cache;
static struct key_type key_type_id_resolver_legacy;
59

60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141

/**
 * nfs_fattr_init_names - initialise the nfs_fattr owner_name/group_name fields
 * @fattr: fully initialised struct nfs_fattr
 * @owner_name: owner name string cache
 * @group_name: group name string cache
 */
void nfs_fattr_init_names(struct nfs_fattr *fattr,
		struct nfs4_string *owner_name,
		struct nfs4_string *group_name)
{
	fattr->owner_name = owner_name;
	fattr->group_name = group_name;
}

static void nfs_fattr_free_owner_name(struct nfs_fattr *fattr)
{
	fattr->valid &= ~NFS_ATTR_FATTR_OWNER_NAME;
	kfree(fattr->owner_name->data);
}

static void nfs_fattr_free_group_name(struct nfs_fattr *fattr)
{
	fattr->valid &= ~NFS_ATTR_FATTR_GROUP_NAME;
	kfree(fattr->group_name->data);
}

static bool nfs_fattr_map_owner_name(struct nfs_server *server, struct nfs_fattr *fattr)
{
	struct nfs4_string *owner = fattr->owner_name;
	__u32 uid;

	if (!(fattr->valid & NFS_ATTR_FATTR_OWNER_NAME))
		return false;
	if (nfs_map_name_to_uid(server, owner->data, owner->len, &uid) == 0) {
		fattr->uid = uid;
		fattr->valid |= NFS_ATTR_FATTR_OWNER;
	}
	return true;
}

static bool nfs_fattr_map_group_name(struct nfs_server *server, struct nfs_fattr *fattr)
{
	struct nfs4_string *group = fattr->group_name;
	__u32 gid;

	if (!(fattr->valid & NFS_ATTR_FATTR_GROUP_NAME))
		return false;
	if (nfs_map_group_to_gid(server, group->data, group->len, &gid) == 0) {
		fattr->gid = gid;
		fattr->valid |= NFS_ATTR_FATTR_GROUP;
	}
	return true;
}

/**
 * nfs_fattr_free_names - free up the NFSv4 owner and group strings
 * @fattr: a fully initialised nfs_fattr structure
 */
void nfs_fattr_free_names(struct nfs_fattr *fattr)
{
	if (fattr->valid & NFS_ATTR_FATTR_OWNER_NAME)
		nfs_fattr_free_owner_name(fattr);
	if (fattr->valid & NFS_ATTR_FATTR_GROUP_NAME)
		nfs_fattr_free_group_name(fattr);
}

/**
 * nfs_fattr_map_and_free_names - map owner/group strings into uid/gid and free
 * @server: pointer to the filesystem nfs_server structure
 * @fattr: a fully initialised nfs_fattr structure
 *
 * This helper maps the cached NFSv4 owner/group strings in fattr into
 * their numeric uid/gid equivalents, and then frees the cached strings.
 */
void nfs_fattr_map_and_free_names(struct nfs_server *server, struct nfs_fattr *fattr)
{
	if (nfs_fattr_map_owner_name(server, fattr))
		nfs_fattr_free_owner_name(fattr);
	if (nfs_fattr_map_group_name(server, fattr))
		nfs_fattr_free_group_name(fattr);
}
142 143 144 145 146 147 148 149 150 151 152 153 154 155 156

static int nfs_map_string_to_numeric(const char *name, size_t namelen, __u32 *res)
{
	unsigned long val;
	char buf[16];

	if (memchr(name, '@', namelen) != NULL || namelen >= sizeof(buf))
		return 0;
	memcpy(buf, name, namelen);
	buf[namelen] = '\0';
	if (strict_strtoul(buf, 0, &val) != 0)
		return 0;
	*res = val;
	return 1;
}
L
Linus Torvalds 已提交
157

158 159 160 161 162
static int nfs_map_numeric_to_string(__u32 id, char *buf, size_t buflen)
{
	return snprintf(buf, buflen, "%u", id);
}

163
static struct key_type key_type_id_resolver = {
B
Bryan Schumaker 已提交
164 165 166 167 168 169 170 171 172
	.name		= "id_resolver",
	.instantiate	= user_instantiate,
	.match		= user_match,
	.revoke		= user_revoke,
	.destroy	= user_destroy,
	.describe	= user_describe,
	.read		= user_read,
};

173
static int nfs_idmap_init_keyring(void)
B
Bryan Schumaker 已提交
174 175 176 177 178
{
	struct cred *cred;
	struct key *keyring;
	int ret = 0;

179 180
	printk(KERN_NOTICE "NFS: Registering the %s key type\n",
		key_type_id_resolver.name);
B
Bryan Schumaker 已提交
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202

	cred = prepare_kernel_cred(NULL);
	if (!cred)
		return -ENOMEM;

	keyring = key_alloc(&key_type_keyring, ".id_resolver", 0, 0, cred,
			     (KEY_POS_ALL & ~KEY_POS_SETATTR) |
			     KEY_USR_VIEW | KEY_USR_READ,
			     KEY_ALLOC_NOT_IN_QUOTA);
	if (IS_ERR(keyring)) {
		ret = PTR_ERR(keyring);
		goto failed_put_cred;
	}

	ret = key_instantiate_and_link(keyring, NULL, 0, NULL, NULL);
	if (ret < 0)
		goto failed_put_key;

	ret = register_key_type(&key_type_id_resolver);
	if (ret < 0)
		goto failed_put_key;

203
	set_bit(KEY_FLAG_ROOT_CAN_CLEAR, &keyring->flags);
B
Bryan Schumaker 已提交
204 205 206 207 208 209 210 211 212 213 214 215
	cred->thread_keyring = keyring;
	cred->jit_keyring = KEY_REQKEY_DEFL_THREAD_KEYRING;
	id_resolver_cache = cred;
	return 0;

failed_put_key:
	key_put(keyring);
failed_put_cred:
	put_cred(cred);
	return ret;
}

216
static void nfs_idmap_quit_keyring(void)
B
Bryan Schumaker 已提交
217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
{
	key_revoke(id_resolver_cache->thread_keyring);
	unregister_key_type(&key_type_id_resolver);
	put_cred(id_resolver_cache);
}

/*
 * Assemble the description to pass to request_key()
 * This function will allocate a new string and update dest to point
 * at it.  The caller is responsible for freeing dest.
 *
 * On error 0 is returned.  Otherwise, the length of dest is returned.
 */
static ssize_t nfs_idmap_get_desc(const char *name, size_t namelen,
				const char *type, size_t typelen, char **desc)
{
	char *cp;
	size_t desclen = typelen + namelen + 2;

	*desc = kmalloc(desclen, GFP_KERNEL);
D
Dan Carpenter 已提交
237
	if (!*desc)
B
Bryan Schumaker 已提交
238 239 240 241 242 243 244 245 246 247 248 249 250
		return -ENOMEM;

	cp = *desc;
	memcpy(cp, type, typelen);
	cp += typelen;
	*cp++ = ':';

	memcpy(cp, name, namelen);
	cp += namelen;
	*cp = '\0';
	return desclen;
}

251 252 253 254
static ssize_t nfs_idmap_request_key(struct key_type *key_type,
				     const char *name, size_t namelen,
				     const char *type, void *data,
				     size_t data_size, struct idmap *idmap)
B
Bryan Schumaker 已提交
255 256 257 258 259 260 261 262 263 264 265 266
{
	const struct cred *saved_cred;
	struct key *rkey;
	char *desc;
	struct user_key_payload *payload;
	ssize_t ret;

	ret = nfs_idmap_get_desc(name, namelen, type, strlen(type), &desc);
	if (ret <= 0)
		goto out;

	saved_cred = override_creds(id_resolver_cache);
267 268 269 270
	if (idmap)
		rkey = request_key_with_auxdata(key_type, desc, "", 0, idmap);
	else
		rkey = request_key(&key_type_id_resolver, desc, "");
B
Bryan Schumaker 已提交
271
	revert_creds(saved_cred);
272

B
Bryan Schumaker 已提交
273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
	kfree(desc);
	if (IS_ERR(rkey)) {
		ret = PTR_ERR(rkey);
		goto out;
	}

	rcu_read_lock();
	rkey->perm |= KEY_USR_VIEW;

	ret = key_validate(rkey);
	if (ret < 0)
		goto out_up;

	payload = rcu_dereference(rkey->payload.data);
	if (IS_ERR_OR_NULL(payload)) {
		ret = PTR_ERR(payload);
		goto out_up;
	}

	ret = payload->datalen;
	if (ret > 0 && ret <= data_size)
		memcpy(data, payload->data, ret);
	else
		ret = -EINVAL;

out_up:
	rcu_read_unlock();
	key_put(rkey);
out:
	return ret;
}

305 306 307 308 309 310 311 312 313 314 315 316 317 318
static ssize_t nfs_idmap_get_key(const char *name, size_t namelen,
				 const char *type, void *data,
				 size_t data_size, struct idmap *idmap)
{
	ssize_t ret = nfs_idmap_request_key(&key_type_id_resolver,
					    name, namelen, type, data,
					    data_size, NULL);
	if (ret < 0) {
		ret = nfs_idmap_request_key(&key_type_id_resolver_legacy,
					    name, namelen, type, data,
					    data_size, idmap);
	}
	return ret;
}
B
Bryan Schumaker 已提交
319 320

/* ID -> Name */
321 322
static ssize_t nfs_idmap_lookup_name(__u32 id, const char *type, char *buf,
				     size_t buflen, struct idmap *idmap)
B
Bryan Schumaker 已提交
323 324 325 326 327 328
{
	char id_str[NFS_UINT_MAXLEN];
	int id_len;
	ssize_t ret;

	id_len = snprintf(id_str, sizeof(id_str), "%u", id);
329
	ret = nfs_idmap_get_key(id_str, id_len, type, buf, buflen, idmap);
B
Bryan Schumaker 已提交
330 331 332 333 334 335
	if (ret < 0)
		return -EINVAL;
	return ret;
}

/* Name -> ID */
336 337
static int nfs_idmap_lookup_id(const char *name, size_t namelen, const char *type,
			       __u32 *id, struct idmap *idmap)
B
Bryan Schumaker 已提交
338 339 340 341 342 343
{
	char id_str[NFS_UINT_MAXLEN];
	long id_long;
	ssize_t data_size;
	int ret = 0;

344
	data_size = nfs_idmap_get_key(name, namelen, type, id_str, NFS_UINT_MAXLEN, idmap);
B
Bryan Schumaker 已提交
345 346 347 348 349 350 351 352 353
	if (data_size <= 0) {
		ret = -EINVAL;
	} else {
		ret = strict_strtol(id_str, 10, &id_long);
		*id = (__u32)id_long;
	}
	return ret;
}

354
/* idmap classic begins here */
355
module_param(nfs_idmap_cache_timeout, int, 0644);
356

357 358 359
struct idmap {
	struct rpc_pipe		*idmap_pipe;
	struct key_construction	*idmap_key_cons;
L
Linus Torvalds 已提交
360 361
};

362 363
enum {
	Opt_find_uid, Opt_find_gid, Opt_find_user, Opt_find_group, Opt_find_err
L
Linus Torvalds 已提交
364 365
};

366 367 368 369 370 371
static const match_table_t nfs_idmap_tokens = {
	{ Opt_find_uid, "uid:%s" },
	{ Opt_find_gid, "gid:%s" },
	{ Opt_find_user, "user:%s" },
	{ Opt_find_group, "group:%s" },
	{ Opt_find_err, NULL }
L
Linus Torvalds 已提交
372 373
};

374
static int nfs_idmap_legacy_upcall(struct key_construction *, const char *, void *);
C
Chuck Lever 已提交
375 376 377
static ssize_t idmap_pipe_downcall(struct file *, const char __user *,
				   size_t);
static void idmap_pipe_destroy_msg(struct rpc_pipe_msg *);
L
Linus Torvalds 已提交
378

379
static const struct rpc_pipe_ops idmap_upcall_ops = {
380
	.upcall		= rpc_pipe_generic_upcall,
C
Chuck Lever 已提交
381 382
	.downcall	= idmap_pipe_downcall,
	.destroy_msg	= idmap_pipe_destroy_msg,
L
Linus Torvalds 已提交
383 384
};

385
static struct key_type key_type_id_resolver_legacy = {
386 387 388 389 390 391 392 393 394 395
	.name		= "id_resolver",
	.instantiate	= user_instantiate,
	.match		= user_match,
	.revoke		= user_revoke,
	.destroy	= user_destroy,
	.describe	= user_describe,
	.read		= user_read,
	.request_key	= nfs_idmap_legacy_upcall,
};

396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417
static void __nfs_idmap_unregister(struct rpc_pipe *pipe)
{
	if (pipe->dentry)
		rpc_unlink(pipe->dentry);
}

static int __nfs_idmap_register(struct dentry *dir,
				     struct idmap *idmap,
				     struct rpc_pipe *pipe)
{
	struct dentry *dentry;

	dentry = rpc_mkpipe_dentry(dir, "idmap", idmap, pipe);
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);
	pipe->dentry = dentry;
	return 0;
}

static void nfs_idmap_unregister(struct nfs_client *clp,
				      struct rpc_pipe *pipe)
{
418
	struct net *net = clp->cl_net;
419 420 421 422 423 424 425 426 427 428 429 430 431
	struct super_block *pipefs_sb;

	pipefs_sb = rpc_get_sb_net(net);
	if (pipefs_sb) {
		__nfs_idmap_unregister(pipe);
		rpc_put_sb_net(net);
	}
}

static int nfs_idmap_register(struct nfs_client *clp,
				   struct idmap *idmap,
				   struct rpc_pipe *pipe)
{
432
	struct net *net = clp->cl_net;
433 434 435 436 437 438 439 440 441 442 443 444 445
	struct super_block *pipefs_sb;
	int err = 0;

	pipefs_sb = rpc_get_sb_net(net);
	if (pipefs_sb) {
		if (clp->cl_rpcclient->cl_dentry)
			err = __nfs_idmap_register(clp->cl_rpcclient->cl_dentry,
						   idmap, pipe);
		rpc_put_sb_net(net);
	}
	return err;
}

446
int
447
nfs_idmap_new(struct nfs_client *clp)
L
Linus Torvalds 已提交
448 449
{
	struct idmap *idmap;
450
	struct rpc_pipe *pipe;
451
	int error;
L
Linus Torvalds 已提交
452

453
	BUG_ON(clp->cl_idmap != NULL);
454

C
Chuck Lever 已提交
455 456 457
	idmap = kzalloc(sizeof(*idmap), GFP_KERNEL);
	if (idmap == NULL)
		return -ENOMEM;
L
Linus Torvalds 已提交
458

459 460 461
	pipe = rpc_mkpipe_data(&idmap_upcall_ops, 0);
	if (IS_ERR(pipe)) {
		error = PTR_ERR(pipe);
L
Linus Torvalds 已提交
462
		kfree(idmap);
463
		return error;
L
Linus Torvalds 已提交
464
	}
465 466
	error = nfs_idmap_register(clp, idmap, pipe);
	if (error) {
467 468 469 470 471
		rpc_destroy_pipe_data(pipe);
		kfree(idmap);
		return error;
	}
	idmap->idmap_pipe = pipe;
L
Linus Torvalds 已提交
472 473

	clp->cl_idmap = idmap;
474
	return 0;
L
Linus Torvalds 已提交
475 476 477
}

void
478
nfs_idmap_delete(struct nfs_client *clp)
L
Linus Torvalds 已提交
479 480 481 482 483
{
	struct idmap *idmap = clp->cl_idmap;

	if (!idmap)
		return;
484
	nfs_idmap_unregister(clp, idmap->idmap_pipe);
485
	rpc_destroy_pipe_data(idmap->idmap_pipe);
L
Linus Torvalds 已提交
486 487 488 489
	clp->cl_idmap = NULL;
	kfree(idmap);
}

490 491
static int __rpc_pipefs_event(struct nfs_client *clp, unsigned long event,
			      struct super_block *sb)
L
Linus Torvalds 已提交
492
{
493
	int err = 0;
L
Linus Torvalds 已提交
494

495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
	switch (event) {
	case RPC_PIPEFS_MOUNT:
		BUG_ON(clp->cl_rpcclient->cl_dentry == NULL);
		err = __nfs_idmap_register(clp->cl_rpcclient->cl_dentry,
						clp->cl_idmap,
						clp->cl_idmap->idmap_pipe);
		break;
	case RPC_PIPEFS_UMOUNT:
		if (clp->cl_idmap->idmap_pipe) {
			struct dentry *parent;

			parent = clp->cl_idmap->idmap_pipe->dentry->d_parent;
			__nfs_idmap_unregister(clp->cl_idmap->idmap_pipe);
			/*
			 * Note: This is a dirty hack. SUNRPC hook has been
			 * called already but simple_rmdir() call for the
			 * directory returned with error because of idmap pipe
			 * inside. Thus now we have to remove this directory
			 * here.
			 */
			if (rpc_rmdir(parent))
516 517
				printk(KERN_ERR "NFS: %s: failed to remove "
					"clnt dir!\n", __func__);
518 519 520
		}
		break;
	default:
521 522
		printk(KERN_ERR "NFS: %s: unknown event: %ld\n", __func__,
			event);
523 524 525 526 527
		return -ENOTSUPP;
	}
	return err;
}

528
static struct nfs_client *nfs_get_client_for_event(struct net *net, int event)
529
{
530 531
	struct nfs_net *nn = net_generic(net, nfs_net_id);
	struct dentry *cl_dentry;
532
	struct nfs_client *clp;
533
	int err;
534

535
restart:
536
	spin_lock(&nn->nfs_client_lock);
537
	list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) {
538 539 540 541 542 543 544 545 546 547 548 549 550
		/* Wait for initialisation to finish */
		if (clp->cl_cons_state == NFS_CS_INITING) {
			atomic_inc(&clp->cl_count);
			spin_unlock(&nn->nfs_client_lock);
			err = nfs_wait_client_init_complete(clp);
			nfs_put_client(clp);
			if (err)
				return NULL;
			goto restart;
		}
		/* Skip nfs_clients that failed to initialise */
		if (clp->cl_cons_state < 0)
			continue;
551 552
		if (clp->rpc_ops != &nfs_v4_clientops)
			continue;
553 554 555 556 557 558 559 560 561 562
		cl_dentry = clp->cl_idmap->idmap_pipe->dentry;
		if (((event == RPC_PIPEFS_MOUNT) && cl_dentry) ||
		    ((event == RPC_PIPEFS_UMOUNT) && !cl_dentry))
			continue;
		atomic_inc(&clp->cl_count);
		spin_unlock(&nn->nfs_client_lock);
		return clp;
	}
	spin_unlock(&nn->nfs_client_lock);
	return NULL;
L
Linus Torvalds 已提交
563 564
}

565 566
static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event,
			    void *ptr)
L
Linus Torvalds 已提交
567
{
568 569 570
	struct super_block *sb = ptr;
	struct nfs_client *clp;
	int error = 0;
L
Linus Torvalds 已提交
571

572 573 574
	if (!try_module_get(THIS_MODULE))
		return 0;

575
	while ((clp = nfs_get_client_for_event(sb->s_fs_info, event))) {
576
		error = __rpc_pipefs_event(clp, event, sb);
577
		nfs_put_client(clp);
578 579 580
		if (error)
			break;
	}
581
	module_put(THIS_MODULE);
582
	return error;
L
Linus Torvalds 已提交
583 584
}

585 586 587 588 589 590
#define PIPEFS_NFS_PRIO		1

static struct notifier_block nfs_idmap_block = {
	.notifier_call	= rpc_pipefs_event,
	.priority	= SUNRPC_PIPEFS_NFS_PRIO,
};
L
Linus Torvalds 已提交
591

592
int nfs_idmap_init(void)
L
Linus Torvalds 已提交
593
{
594 595 596 597 598 599 600 601 602
	int ret;
	ret = nfs_idmap_init_keyring();
	if (ret != 0)
		goto out;
	ret = rpc_pipefs_notifier_register(&nfs_idmap_block);
	if (ret != 0)
		nfs_idmap_quit_keyring();
out:
	return ret;
L
Linus Torvalds 已提交
603 604
}

605
void nfs_idmap_quit(void)
L
Linus Torvalds 已提交
606
{
607
	rpc_pipefs_notifier_unregister(&nfs_idmap_block);
608
	nfs_idmap_quit_keyring();
L
Linus Torvalds 已提交
609 610
}

611 612
static int nfs_idmap_prepare_message(char *desc, struct idmap_msg *im,
				     struct rpc_pipe_msg *msg)
L
Linus Torvalds 已提交
613
{
614 615
	substring_t substr;
	int token, ret;
L
Linus Torvalds 已提交
616

617 618
	memset(im,  0, sizeof(*im));
	memset(msg, 0, sizeof(*msg));
L
Linus Torvalds 已提交
619

620 621
	im->im_type = IDMAP_TYPE_GROUP;
	token = match_token(desc, nfs_idmap_tokens, &substr);
L
Linus Torvalds 已提交
622

623 624 625 626 627 628 629
	switch (token) {
	case Opt_find_uid:
		im->im_type = IDMAP_TYPE_USER;
	case Opt_find_gid:
		im->im_conv = IDMAP_CONV_NAMETOID;
		ret = match_strlcpy(im->im_name, &substr, IDMAP_NAMESZ);
		break;
L
Linus Torvalds 已提交
630

631 632 633 634 635 636
	case Opt_find_user:
		im->im_type = IDMAP_TYPE_USER;
	case Opt_find_group:
		im->im_conv = IDMAP_CONV_IDTONAME;
		ret = match_int(&substr, &im->im_id);
		break;
L
Linus Torvalds 已提交
637

638 639
	default:
		ret = -EINVAL;
L
Linus Torvalds 已提交
640 641 642
		goto out;
	}

643 644
	msg->data = im;
	msg->len  = sizeof(struct idmap_msg);
L
Linus Torvalds 已提交
645

646
out:
C
Chuck Lever 已提交
647
	return ret;
L
Linus Torvalds 已提交
648 649
}

650 651 652
static int nfs_idmap_legacy_upcall(struct key_construction *cons,
				   const char *op,
				   void *aux)
L
Linus Torvalds 已提交
653
{
654
	struct rpc_pipe_msg *msg;
L
Linus Torvalds 已提交
655
	struct idmap_msg *im;
656 657
	struct idmap *idmap = (struct idmap *)aux;
	struct key *key = cons->key;
658
	int ret = -ENOMEM;
L
Linus Torvalds 已提交
659

660 661
	/* msg and im are freed in idmap_pipe_destroy_msg */
	msg = kmalloc(sizeof(*msg), GFP_KERNEL);
662
	if (!msg)
663
		goto out0;
L
Linus Torvalds 已提交
664

665
	im = kmalloc(sizeof(*im), GFP_KERNEL);
666
	if (!im)
667
		goto out1;
L
Linus Torvalds 已提交
668

669 670 671
	ret = nfs_idmap_prepare_message(key->description, im, msg);
	if (ret < 0)
		goto out2;
L
Linus Torvalds 已提交
672

673
	idmap->idmap_key_cons = cons;
L
Linus Torvalds 已提交
674

675 676 677
	ret = rpc_queue_upcall(idmap->idmap_pipe, msg);
	if (ret < 0)
		goto out2;
L
Linus Torvalds 已提交
678

679
	return ret;
680 681 682 683 684 685

out2:
	kfree(im);
out1:
	kfree(msg);
out0:
686 687
	key_revoke(cons->key);
	key_revoke(cons->authkey);
C
Chuck Lever 已提交
688
	return ret;
L
Linus Torvalds 已提交
689 690
}

691
static int nfs_idmap_instantiate(struct key *key, struct key *authkey, char *data)
L
Linus Torvalds 已提交
692
{
693 694 695 696
	return key_instantiate_and_link(key, data, strlen(data) + 1,
					id_resolver_cache->thread_keyring,
					authkey);
}
L
Linus Torvalds 已提交
697

698 699 700 701
static int nfs_idmap_read_message(struct idmap_msg *im, struct key *key, struct key *authkey)
{
	char id_str[NFS_UINT_MAXLEN];
	int ret = -EINVAL;
L
Linus Torvalds 已提交
702

703 704 705 706 707 708 709 710
	switch (im->im_conv) {
	case IDMAP_CONV_NAMETOID:
		sprintf(id_str, "%d", im->im_id);
		ret = nfs_idmap_instantiate(key, authkey, id_str);
		break;
	case IDMAP_CONV_IDTONAME:
		ret = nfs_idmap_instantiate(key, authkey, im->im_name);
		break;
L
Linus Torvalds 已提交
711 712 713 714 715 716 717 718
	}

	return ret;
}

static ssize_t
idmap_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
{
C
Chuck Lever 已提交
719
	struct rpc_inode *rpci = RPC_I(filp->f_path.dentry->d_inode);
L
Linus Torvalds 已提交
720
	struct idmap *idmap = (struct idmap *)rpci->private;
721 722
	struct key_construction *cons = idmap->idmap_key_cons;
	struct idmap_msg im;
723
	size_t namelen_in;
L
Linus Torvalds 已提交
724 725
	int ret;

726 727
	if (mlen != sizeof(im)) {
		ret = -ENOSPC;
L
Linus Torvalds 已提交
728 729 730
		goto out;
	}

731 732
	if (copy_from_user(&im, src, mlen) != 0) {
		ret = -EFAULT;
L
Linus Torvalds 已提交
733
		goto out;
734
	}
L
Linus Torvalds 已提交
735

736 737 738 739
	if (!(im.im_status & IDMAP_STATUS_SUCCESS)) {
		ret = mlen;
		complete_request_key(idmap->idmap_key_cons, -ENOKEY);
		goto out_incomplete;
L
Linus Torvalds 已提交
740 741
	}

742 743 744
	namelen_in = strnlen(im.im_name, IDMAP_NAMESZ);
	if (namelen_in == 0 || namelen_in == IDMAP_NAMESZ) {
		ret = -EINVAL;
L
Linus Torvalds 已提交
745 746 747
		goto out;
	}

748 749 750 751 752 753
	ret = nfs_idmap_read_message(&im, cons->key, cons->authkey);
	if (ret >= 0) {
		key_set_timeout(cons->key, nfs_idmap_cache_timeout);
		ret = mlen;
	}

L
Linus Torvalds 已提交
754
out:
755 756
	complete_request_key(idmap->idmap_key_cons, ret);
out_incomplete:
L
Linus Torvalds 已提交
757 758 759
	return ret;
}

A
Adrian Bunk 已提交
760
static void
L
Linus Torvalds 已提交
761 762
idmap_pipe_destroy_msg(struct rpc_pipe_msg *msg)
{
763 764 765
	/* Free memory allocated in nfs_idmap_legacy_upcall() */
	kfree(msg->data);
	kfree(msg);
L
Linus Torvalds 已提交
766 767
}

768
int nfs_map_name_to_uid(const struct nfs_server *server, const char *name, size_t namelen, __u32 *uid)
L
Linus Torvalds 已提交
769
{
770
	struct idmap *idmap = server->nfs_client->cl_idmap;
L
Linus Torvalds 已提交
771

772 773
	if (nfs_map_string_to_numeric(name, namelen, uid))
		return 0;
774
	return nfs_idmap_lookup_id(name, namelen, "uid", uid, idmap);
L
Linus Torvalds 已提交
775 776
}

777
int nfs_map_group_to_gid(const struct nfs_server *server, const char *name, size_t namelen, __u32 *gid)
L
Linus Torvalds 已提交
778
{
779
	struct idmap *idmap = server->nfs_client->cl_idmap;
L
Linus Torvalds 已提交
780

781
	if (nfs_map_string_to_numeric(name, namelen, gid))
782
		return 0;
783
	return nfs_idmap_lookup_id(name, namelen, "gid", gid, idmap);
L
Linus Torvalds 已提交
784 785
}

786
int nfs_map_uid_to_name(const struct nfs_server *server, __u32 uid, char *buf, size_t buflen)
L
Linus Torvalds 已提交
787
{
788
	struct idmap *idmap = server->nfs_client->cl_idmap;
789
	int ret = -EINVAL;
L
Linus Torvalds 已提交
790

791
	if (!(server->caps & NFS_CAP_UIDGID_NOMAP))
792
		ret = nfs_idmap_lookup_name(uid, "user", buf, buflen, idmap);
793 794 795
	if (ret < 0)
		ret = nfs_map_numeric_to_string(uid, buf, buflen);
	return ret;
L
Linus Torvalds 已提交
796
}
797
int nfs_map_gid_to_group(const struct nfs_server *server, __u32 gid, char *buf, size_t buflen)
L
Linus Torvalds 已提交
798
{
799
	struct idmap *idmap = server->nfs_client->cl_idmap;
800
	int ret = -EINVAL;
L
Linus Torvalds 已提交
801

802
	if (!(server->caps & NFS_CAP_UIDGID_NOMAP))
803
		ret = nfs_idmap_lookup_name(gid, "group", buf, buflen, idmap);
804
	if (ret < 0)
805
		ret = nfs_map_numeric_to_string(gid, buf, buflen);
806
	return ret;
L
Linus Torvalds 已提交
807
}