idmap.c 21.8 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

#define NFS_UINT_MAXLEN 11

55 56
static const struct cred *id_resolver_cache;
static struct key_type key_type_id_resolver_legacy;
57

58 59 60
struct idmap_legacy_upcalldata {
	struct rpc_pipe_msg pipe_msg;
	struct idmap_msg idmap_msg;
61
	struct key_construction	*key_cons;
62 63 64
	struct idmap *idmap;
};

65 66 67 68 69 70
struct idmap {
	struct rpc_pipe		*idmap_pipe;
	struct idmap_legacy_upcalldata *idmap_upcall_data;
	struct mutex		idmap_mutex;
};

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
/**
 * 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;
100
	kuid_t uid;
101 102 103 104 105 106 107 108 109 110 111 112 113

	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;
114
	kgid_t gid;
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 142 143 144 145 146 147 148 149 150 151

	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);
}
152 153 154 155 156 157 158 159 160 161

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';
162
	if (kstrtoul(buf, 0, &val) != 0)
163 164 165 166
		return 0;
	*res = val;
	return 1;
}
L
Linus Torvalds 已提交
167

168 169 170 171 172
static int nfs_map_numeric_to_string(__u32 id, char *buf, size_t buflen)
{
	return snprintf(buf, buflen, "%u", id);
}

173
static struct key_type key_type_id_resolver = {
B
Bryan Schumaker 已提交
174 175 176 177 178 179 180 181 182
	.name		= "id_resolver",
	.instantiate	= user_instantiate,
	.match		= user_match,
	.revoke		= user_revoke,
	.destroy	= user_destroy,
	.describe	= user_describe,
	.read		= user_read,
};

183
static int nfs_idmap_init_keyring(void)
B
Bryan Schumaker 已提交
184 185 186 187 188
{
	struct cred *cred;
	struct key *keyring;
	int ret = 0;

189 190
	printk(KERN_NOTICE "NFS: Registering the %s key type\n",
		key_type_id_resolver.name);
B
Bryan Schumaker 已提交
191 192 193 194 195

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

196 197
	keyring = keyring_alloc(".id_resolver",
				GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred,
198 199 200
				(KEY_POS_ALL & ~KEY_POS_SETATTR) |
				KEY_USR_VIEW | KEY_USR_READ,
				KEY_ALLOC_NOT_IN_QUOTA, NULL);
B
Bryan Schumaker 已提交
201 202 203 204 205 206 207 208 209
	if (IS_ERR(keyring)) {
		ret = PTR_ERR(keyring);
		goto failed_put_cred;
	}

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

210 211 212 213
	ret = register_key_type(&key_type_id_resolver_legacy);
	if (ret < 0)
		goto failed_reg_legacy;

214
	set_bit(KEY_FLAG_ROOT_CAN_CLEAR, &keyring->flags);
B
Bryan Schumaker 已提交
215 216 217 218 219
	cred->thread_keyring = keyring;
	cred->jit_keyring = KEY_REQKEY_DEFL_THREAD_KEYRING;
	id_resolver_cache = cred;
	return 0;

220 221
failed_reg_legacy:
	unregister_key_type(&key_type_id_resolver);
B
Bryan Schumaker 已提交
222 223 224 225 226 227 228
failed_put_key:
	key_put(keyring);
failed_put_cred:
	put_cred(cred);
	return ret;
}

229
static void nfs_idmap_quit_keyring(void)
B
Bryan Schumaker 已提交
230 231 232
{
	key_revoke(id_resolver_cache->thread_keyring);
	unregister_key_type(&key_type_id_resolver);
233
	unregister_key_type(&key_type_id_resolver_legacy);
B
Bryan Schumaker 已提交
234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
	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 已提交
251
	if (!*desc)
B
Bryan Schumaker 已提交
252 253 254 255 256 257 258 259 260 261 262 263 264
		return -ENOMEM;

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

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

265 266 267 268
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 已提交
269 270 271 272 273 274 275 276 277 278 279 280
{
	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);
281 282 283 284
	if (idmap)
		rkey = request_key_with_auxdata(key_type, desc, "", 0, idmap);
	else
		rkey = request_key(&key_type_id_resolver, desc, "");
B
Bryan Schumaker 已提交
285
	revert_creds(saved_cred);
286

B
Bryan Schumaker 已提交
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318
	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;
}

319 320 321 322 323 324 325 326
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) {
327
		mutex_lock(&idmap->idmap_mutex);
328 329 330
		ret = nfs_idmap_request_key(&key_type_id_resolver_legacy,
					    name, namelen, type, data,
					    data_size, idmap);
331
		mutex_unlock(&idmap->idmap_mutex);
332 333 334
	}
	return ret;
}
B
Bryan Schumaker 已提交
335 336

/* ID -> Name */
337 338
static ssize_t nfs_idmap_lookup_name(__u32 id, const char *type, char *buf,
				     size_t buflen, struct idmap *idmap)
B
Bryan Schumaker 已提交
339 340 341 342 343 344
{
	char id_str[NFS_UINT_MAXLEN];
	int id_len;
	ssize_t ret;

	id_len = snprintf(id_str, sizeof(id_str), "%u", id);
345
	ret = nfs_idmap_get_key(id_str, id_len, type, buf, buflen, idmap);
B
Bryan Schumaker 已提交
346 347 348 349 350 351
	if (ret < 0)
		return -EINVAL;
	return ret;
}

/* Name -> ID */
352 353
static int nfs_idmap_lookup_id(const char *name, size_t namelen, const char *type,
			       __u32 *id, struct idmap *idmap)
B
Bryan Schumaker 已提交
354 355 356 357 358 359
{
	char id_str[NFS_UINT_MAXLEN];
	long id_long;
	ssize_t data_size;
	int ret = 0;

360
	data_size = nfs_idmap_get_key(name, namelen, type, id_str, NFS_UINT_MAXLEN, idmap);
B
Bryan Schumaker 已提交
361 362 363
	if (data_size <= 0) {
		ret = -EINVAL;
	} else {
364
		ret = kstrtol(id_str, 10, &id_long);
B
Bryan Schumaker 已提交
365 366 367 368 369
		*id = (__u32)id_long;
	}
	return ret;
}

370
/* idmap classic begins here */
371

372 373
enum {
	Opt_find_uid, Opt_find_gid, Opt_find_user, Opt_find_group, Opt_find_err
L
Linus Torvalds 已提交
374 375
};

376 377 378 379 380 381
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 已提交
382 383
};

384
static int nfs_idmap_legacy_upcall(struct key_construction *, const char *, void *);
C
Chuck Lever 已提交
385 386
static ssize_t idmap_pipe_downcall(struct file *, const char __user *,
				   size_t);
387
static void idmap_release_pipe(struct inode *);
C
Chuck Lever 已提交
388
static void idmap_pipe_destroy_msg(struct rpc_pipe_msg *);
L
Linus Torvalds 已提交
389

390
static const struct rpc_pipe_ops idmap_upcall_ops = {
391
	.upcall		= rpc_pipe_generic_upcall,
C
Chuck Lever 已提交
392
	.downcall	= idmap_pipe_downcall,
393
	.release_pipe	= idmap_release_pipe,
C
Chuck Lever 已提交
394
	.destroy_msg	= idmap_pipe_destroy_msg,
L
Linus Torvalds 已提交
395 396
};

397
static struct key_type key_type_id_resolver_legacy = {
398
	.name		= "id_legacy",
399 400 401 402 403 404 405 406 407
	.instantiate	= user_instantiate,
	.match		= user_match,
	.revoke		= user_revoke,
	.destroy	= user_destroy,
	.describe	= user_describe,
	.read		= user_read,
	.request_key	= nfs_idmap_legacy_upcall,
};

408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
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)
{
430
	struct net *net = clp->cl_net;
431 432 433 434 435 436 437 438 439 440 441 442 443
	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)
{
444
	struct net *net = clp->cl_net;
445 446 447 448 449 450 451 452 453 454 455 456 457
	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;
}

458
int
459
nfs_idmap_new(struct nfs_client *clp)
L
Linus Torvalds 已提交
460 461
{
	struct idmap *idmap;
462
	struct rpc_pipe *pipe;
463
	int error;
L
Linus Torvalds 已提交
464

C
Chuck Lever 已提交
465 466 467
	idmap = kzalloc(sizeof(*idmap), GFP_KERNEL);
	if (idmap == NULL)
		return -ENOMEM;
L
Linus Torvalds 已提交
468

469 470 471
	pipe = rpc_mkpipe_data(&idmap_upcall_ops, 0);
	if (IS_ERR(pipe)) {
		error = PTR_ERR(pipe);
L
Linus Torvalds 已提交
472
		kfree(idmap);
473
		return error;
L
Linus Torvalds 已提交
474
	}
475 476
	error = nfs_idmap_register(clp, idmap, pipe);
	if (error) {
477 478 479 480 481
		rpc_destroy_pipe_data(pipe);
		kfree(idmap);
		return error;
	}
	idmap->idmap_pipe = pipe;
482
	mutex_init(&idmap->idmap_mutex);
L
Linus Torvalds 已提交
483 484

	clp->cl_idmap = idmap;
485
	return 0;
L
Linus Torvalds 已提交
486 487 488
}

void
489
nfs_idmap_delete(struct nfs_client *clp)
L
Linus Torvalds 已提交
490 491 492 493 494
{
	struct idmap *idmap = clp->cl_idmap;

	if (!idmap)
		return;
495
	nfs_idmap_unregister(clp, idmap->idmap_pipe);
496
	rpc_destroy_pipe_data(idmap->idmap_pipe);
L
Linus Torvalds 已提交
497 498 499 500
	clp->cl_idmap = NULL;
	kfree(idmap);
}

501 502
static int __rpc_pipefs_event(struct nfs_client *clp, unsigned long event,
			      struct super_block *sb)
L
Linus Torvalds 已提交
503
{
504
	int err = 0;
L
Linus Torvalds 已提交
505

506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525
	switch (event) {
	case RPC_PIPEFS_MOUNT:
		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))
526 527
				printk(KERN_ERR "NFS: %s: failed to remove "
					"clnt dir!\n", __func__);
528 529 530
		}
		break;
	default:
531 532
		printk(KERN_ERR "NFS: %s: unknown event: %ld\n", __func__,
			event);
533 534 535 536 537
		return -ENOTSUPP;
	}
	return err;
}

538
static struct nfs_client *nfs_get_client_for_event(struct net *net, int event)
539
{
540 541
	struct nfs_net *nn = net_generic(net, nfs_net_id);
	struct dentry *cl_dentry;
542
	struct nfs_client *clp;
543
	int err;
544

545
restart:
546
	spin_lock(&nn->nfs_client_lock);
547
	list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) {
548 549 550 551 552 553 554 555 556 557 558 559 560
		/* 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;
561
		smp_rmb();
562 563
		if (clp->rpc_ops != &nfs_v4_clientops)
			continue;
564 565 566 567 568 569 570 571 572 573
		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 已提交
574 575
}

576 577
static int rpc_pipefs_event(struct notifier_block *nb, unsigned long event,
			    void *ptr)
L
Linus Torvalds 已提交
578
{
579 580 581
	struct super_block *sb = ptr;
	struct nfs_client *clp;
	int error = 0;
L
Linus Torvalds 已提交
582

583 584 585
	if (!try_module_get(THIS_MODULE))
		return 0;

586
	while ((clp = nfs_get_client_for_event(sb->s_fs_info, event))) {
587
		error = __rpc_pipefs_event(clp, event, sb);
588
		nfs_put_client(clp);
589 590 591
		if (error)
			break;
	}
592
	module_put(THIS_MODULE);
593
	return error;
L
Linus Torvalds 已提交
594 595
}

596 597 598 599 600 601
#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 已提交
602

603
int nfs_idmap_init(void)
L
Linus Torvalds 已提交
604
{
605 606 607 608 609 610 611 612 613
	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 已提交
614 615
}

616
void nfs_idmap_quit(void)
L
Linus Torvalds 已提交
617
{
618
	rpc_pipefs_notifier_unregister(&nfs_idmap_block);
619
	nfs_idmap_quit_keyring();
L
Linus Torvalds 已提交
620 621
}

622 623
static int nfs_idmap_prepare_message(char *desc, struct idmap *idmap,
				     struct idmap_msg *im,
624
				     struct rpc_pipe_msg *msg)
L
Linus Torvalds 已提交
625
{
626 627
	substring_t substr;
	int token, ret;
L
Linus Torvalds 已提交
628

629 630
	im->im_type = IDMAP_TYPE_GROUP;
	token = match_token(desc, nfs_idmap_tokens, &substr);
L
Linus Torvalds 已提交
631

632 633 634 635 636 637 638
	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 已提交
639

640 641 642 643 644 645
	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 已提交
646

647 648
	default:
		ret = -EINVAL;
L
Linus Torvalds 已提交
649 650 651
		goto out;
	}

652 653
	msg->data = im;
	msg->len  = sizeof(struct idmap_msg);
L
Linus Torvalds 已提交
654

655
out:
C
Chuck Lever 已提交
656
	return ret;
L
Linus Torvalds 已提交
657 658
}

659 660
static bool
nfs_idmap_prepare_pipe_upcall(struct idmap *idmap,
661
		struct idmap_legacy_upcalldata *data)
662
{
663
	if (idmap->idmap_upcall_data != NULL) {
664 665 666
		WARN_ON_ONCE(1);
		return false;
	}
667
	idmap->idmap_upcall_data = data;
668 669 670 671 672 673
	return true;
}

static void
nfs_idmap_complete_pipe_upcall_locked(struct idmap *idmap, int ret)
{
674
	struct key_construction *cons = idmap->idmap_upcall_data->key_cons;
675

676 677
	kfree(idmap->idmap_upcall_data);
	idmap->idmap_upcall_data = NULL;
678 679 680 681 682 683
	complete_request_key(cons, ret);
}

static void
nfs_idmap_abort_pipe_upcall(struct idmap *idmap, int ret)
{
684
	if (idmap->idmap_upcall_data != NULL)
685 686 687
		nfs_idmap_complete_pipe_upcall_locked(idmap, ret);
}

688 689 690
static int nfs_idmap_legacy_upcall(struct key_construction *cons,
				   const char *op,
				   void *aux)
L
Linus Torvalds 已提交
691
{
692
	struct idmap_legacy_upcalldata *data;
693
	struct rpc_pipe_msg *msg;
L
Linus Torvalds 已提交
694
	struct idmap_msg *im;
695 696
	struct idmap *idmap = (struct idmap *)aux;
	struct key *key = cons->key;
697
	int ret = -ENOMEM;
L
Linus Torvalds 已提交
698

699
	/* msg and im are freed in idmap_pipe_destroy_msg */
700
	data = kzalloc(sizeof(*data), GFP_KERNEL);
701
	if (!data)
702
		goto out1;
L
Linus Torvalds 已提交
703

704 705 706
	msg = &data->pipe_msg;
	im = &data->idmap_msg;
	data->idmap = idmap;
707
	data->key_cons = cons;
708 709

	ret = nfs_idmap_prepare_message(key->description, idmap, im, msg);
710 711
	if (ret < 0)
		goto out2;
L
Linus Torvalds 已提交
712

713
	ret = -EAGAIN;
714
	if (!nfs_idmap_prepare_pipe_upcall(idmap, data))
715
		goto out2;
L
Linus Torvalds 已提交
716

717 718
	ret = rpc_queue_upcall(idmap->idmap_pipe, msg);
	if (ret < 0)
719
		nfs_idmap_abort_pipe_upcall(idmap, ret);
L
Linus Torvalds 已提交
720

721
	return ret;
722
out2:
723
	kfree(data);
724
out1:
725
	complete_request_key(cons, ret);
C
Chuck Lever 已提交
726
	return ret;
L
Linus Torvalds 已提交
727 728
}

729
static int nfs_idmap_instantiate(struct key *key, struct key *authkey, char *data)
L
Linus Torvalds 已提交
730
{
731 732 733 734
	return key_instantiate_and_link(key, data, strlen(data) + 1,
					id_resolver_cache->thread_keyring,
					authkey);
}
L
Linus Torvalds 已提交
735

736 737 738
static int nfs_idmap_read_and_verify_message(struct idmap_msg *im,
		struct idmap_msg *upcall,
		struct key *key, struct key *authkey)
739 740
{
	char id_str[NFS_UINT_MAXLEN];
741
	int ret = -ENOKEY;
L
Linus Torvalds 已提交
742

743 744 745
	/* ret = -ENOKEY */
	if (upcall->im_type != im->im_type || upcall->im_conv != im->im_conv)
		goto out;
746 747
	switch (im->im_conv) {
	case IDMAP_CONV_NAMETOID:
748 749
		if (strcmp(upcall->im_name, im->im_name) != 0)
			break;
750 751 752 753
		sprintf(id_str, "%d", im->im_id);
		ret = nfs_idmap_instantiate(key, authkey, id_str);
		break;
	case IDMAP_CONV_IDTONAME:
754 755
		if (upcall->im_id != im->im_id)
			break;
756 757
		ret = nfs_idmap_instantiate(key, authkey, im->im_name);
		break;
758 759
	default:
		ret = -EINVAL;
L
Linus Torvalds 已提交
760
	}
761
out:
L
Linus Torvalds 已提交
762 763 764 765 766 767
	return ret;
}

static ssize_t
idmap_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
{
C
Chuck Lever 已提交
768
	struct rpc_inode *rpci = RPC_I(filp->f_path.dentry->d_inode);
L
Linus Torvalds 已提交
769
	struct idmap *idmap = (struct idmap *)rpci->private;
770
	struct key_construction *cons;
771
	struct idmap_msg im;
772
	size_t namelen_in;
773
	int ret = -ENOKEY;
L
Linus Torvalds 已提交
774

775 776 777 778
	/* If instantiation is successful, anyone waiting for key construction
	 * will have been woken up and someone else may now have used
	 * idmap_key_cons - so after this point we may no longer touch it.
	 */
779
	if (idmap->idmap_upcall_data == NULL)
780
		goto out_noupcall;
781

782
	cons = idmap->idmap_upcall_data->key_cons;
783

784 785
	if (mlen != sizeof(im)) {
		ret = -ENOSPC;
L
Linus Torvalds 已提交
786 787 788
		goto out;
	}

789 790
	if (copy_from_user(&im, src, mlen) != 0) {
		ret = -EFAULT;
L
Linus Torvalds 已提交
791
		goto out;
792
	}
L
Linus Torvalds 已提交
793

794
	if (!(im.im_status & IDMAP_STATUS_SUCCESS)) {
795 796
		ret = -ENOKEY;
		goto out;
L
Linus Torvalds 已提交
797 798
	}

799 800 801
	namelen_in = strnlen(im.im_name, IDMAP_NAMESZ);
	if (namelen_in == 0 || namelen_in == IDMAP_NAMESZ) {
		ret = -EINVAL;
L
Linus Torvalds 已提交
802
		goto out;
803
}
L
Linus Torvalds 已提交
804

805 806 807
	ret = nfs_idmap_read_and_verify_message(&im,
			&idmap->idmap_upcall_data->idmap_msg,
			cons->key, cons->authkey);
808 809 810 811 812
	if (ret >= 0) {
		key_set_timeout(cons->key, nfs_idmap_cache_timeout);
		ret = mlen;
	}

L
Linus Torvalds 已提交
813
out:
814 815
	nfs_idmap_complete_pipe_upcall_locked(idmap, ret);
out_noupcall:
L
Linus Torvalds 已提交
816 817 818
	return ret;
}

A
Adrian Bunk 已提交
819
static void
L
Linus Torvalds 已提交
820 821
idmap_pipe_destroy_msg(struct rpc_pipe_msg *msg)
{
822 823 824 825
	struct idmap_legacy_upcalldata *data = container_of(msg,
			struct idmap_legacy_upcalldata,
			pipe_msg);
	struct idmap *idmap = data->idmap;
826 827 828

	if (msg->errno)
		nfs_idmap_abort_pipe_upcall(idmap, msg->errno);
829 830 831 832 833 834 835
}

static void
idmap_release_pipe(struct inode *inode)
{
	struct rpc_inode *rpci = RPC_I(inode);
	struct idmap *idmap = (struct idmap *)rpci->private;
836 837

	nfs_idmap_abort_pipe_upcall(idmap, -EPIPE);
L
Linus Torvalds 已提交
838 839
}

840
int nfs_map_name_to_uid(const struct nfs_server *server, const char *name, size_t namelen, kuid_t *uid)
L
Linus Torvalds 已提交
841
{
842
	struct idmap *idmap = server->nfs_client->cl_idmap;
843 844
	__u32 id = -1;
	int ret = 0;
L
Linus Torvalds 已提交
845

846 847 848 849 850 851 852 853
	if (!nfs_map_string_to_numeric(name, namelen, &id))
		ret = nfs_idmap_lookup_id(name, namelen, "uid", &id, idmap);
	if (ret == 0) {
		*uid = make_kuid(&init_user_ns, id);
		if (!uid_valid(*uid))
			ret = -ERANGE;
	}
	return ret;
L
Linus Torvalds 已提交
854 855
}

856
int nfs_map_group_to_gid(const struct nfs_server *server, const char *name, size_t namelen, kgid_t *gid)
L
Linus Torvalds 已提交
857
{
858
	struct idmap *idmap = server->nfs_client->cl_idmap;
859 860
	__u32 id = -1;
	int ret = 0;
L
Linus Torvalds 已提交
861

862 863 864 865 866 867 868 869
	if (!nfs_map_string_to_numeric(name, namelen, &id))
		ret = nfs_idmap_lookup_id(name, namelen, "gid", &id, idmap);
	if (ret == 0) {
		*gid = make_kgid(&init_user_ns, id);
		if (!gid_valid(*gid))
			ret = -ERANGE;
	}
	return ret;
L
Linus Torvalds 已提交
870 871
}

872
int nfs_map_uid_to_name(const struct nfs_server *server, kuid_t uid, char *buf, size_t buflen)
L
Linus Torvalds 已提交
873
{
874
	struct idmap *idmap = server->nfs_client->cl_idmap;
875
	int ret = -EINVAL;
876
	__u32 id;
L
Linus Torvalds 已提交
877

878
	id = from_kuid(&init_user_ns, uid);
879
	if (!(server->caps & NFS_CAP_UIDGID_NOMAP))
880
		ret = nfs_idmap_lookup_name(id, "user", buf, buflen, idmap);
881
	if (ret < 0)
882
		ret = nfs_map_numeric_to_string(id, buf, buflen);
883
	return ret;
L
Linus Torvalds 已提交
884
}
885
int nfs_map_gid_to_group(const struct nfs_server *server, kgid_t gid, char *buf, size_t buflen)
L
Linus Torvalds 已提交
886
{
887
	struct idmap *idmap = server->nfs_client->cl_idmap;
888
	int ret = -EINVAL;
889
	__u32 id;
L
Linus Torvalds 已提交
890

891
	id = from_kgid(&init_user_ns, gid);
892
	if (!(server->caps & NFS_CAP_UIDGID_NOMAP))
893
		ret = nfs_idmap_lookup_name(id, "group", buf, buflen, idmap);
894
	if (ret < 0)
895
		ret = nfs_map_numeric_to_string(id, buf, buflen);
896
	return ret;
L
Linus Torvalds 已提交
897
}