export.c 22.3 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * Overlayfs NFS export support.
 *
 * Amir Goldstein <amir73il@gmail.com>
 *
 * Copyright (C) 2017-2018 CTERA Networks. All Rights Reserved.
 */

#include <linux/fs.h>
#include <linux/cred.h>
#include <linux/mount.h>
#include <linux/namei.h>
#include <linux/xattr.h>
#include <linux/exportfs.h>
#include <linux/ratelimit.h>
#include "overlayfs.h"

19 20 21 22 23 24 25 26 27 28 29 30 31 32
static int ovl_encode_maybe_copy_up(struct dentry *dentry)
{
	int err;

	if (ovl_dentry_upper(dentry))
		return 0;

	err = ovl_want_write(dentry);
	if (!err) {
		err = ovl_copy_up(dentry);
		ovl_drop_write(dentry);
	}

	if (err) {
lijiazi's avatar
lijiazi committed
33
		pr_warn_ratelimited("failed to copy up on encode (%pd2, err=%i)\n",
34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 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 142 143 144 145 146 147 148 149 150 151 152 153 154
				    dentry, err);
	}

	return err;
}

/*
 * Before encoding a non-upper directory file handle from real layer N, we need
 * to check if it will be possible to reconnect an overlay dentry from the real
 * lower decoded dentry. This is done by following the overlay ancestry up to a
 * "layer N connected" ancestor and verifying that all parents along the way are
 * "layer N connectable". If an ancestor that is NOT "layer N connectable" is
 * found, we need to copy up an ancestor, which is "layer N connectable", thus
 * making that ancestor "layer N connected". For example:
 *
 * layer 1: /a
 * layer 2: /a/b/c
 *
 * The overlay dentry /a is NOT "layer 2 connectable", because if dir /a is
 * copied up and renamed, upper dir /a will be indexed by lower dir /a from
 * layer 1. The dir /a from layer 2 will never be indexed, so the algorithm (*)
 * in ovl_lookup_real_ancestor() will not be able to lookup a connected overlay
 * dentry from the connected lower dentry /a/b/c.
 *
 * To avoid this problem on decode time, we need to copy up an ancestor of
 * /a/b/c, which is "layer 2 connectable", on encode time. That ancestor is
 * /a/b. After copy up (and index) of /a/b, it will become "layer 2 connected"
 * and when the time comes to decode the file handle from lower dentry /a/b/c,
 * ovl_lookup_real_ancestor() will find the indexed ancestor /a/b and decoding
 * a connected overlay dentry will be accomplished.
 *
 * (*) the algorithm in ovl_lookup_real_ancestor() can be improved to lookup an
 * entry /a in the lower layers above layer N and find the indexed dir /a from
 * layer 1. If that improvement is made, then the check for "layer N connected"
 * will need to verify there are no redirects in lower layers above N. In the
 * example above, /a will be "layer 2 connectable". However, if layer 2 dir /a
 * is a target of a layer 1 redirect, then /a will NOT be "layer 2 connectable":
 *
 * layer 1: /A (redirect = /a)
 * layer 2: /a/b/c
 */

/* Return the lowest layer for encoding a connectable file handle */
static int ovl_connectable_layer(struct dentry *dentry)
{
	struct ovl_entry *oe = OVL_E(dentry);

	/* We can get overlay root from root of any layer */
	if (dentry == dentry->d_sb->s_root)
		return oe->numlower;

	/*
	 * If it's an unindexed merge dir, then it's not connectable with any
	 * lower layer
	 */
	if (ovl_dentry_upper(dentry) &&
	    !ovl_test_flag(OVL_INDEX, d_inode(dentry)))
		return 0;

	/* We can get upper/overlay path from indexed/lower dentry */
	return oe->lowerstack[0].layer->idx;
}

/*
 * @dentry is "connected" if all ancestors up to root or a "connected" ancestor
 * have the same uppermost lower layer as the origin's layer. We may need to
 * copy up a "connectable" ancestor to make it "connected". A "connected" dentry
 * cannot become non "connected", so cache positive result in dentry flags.
 *
 * Return the connected origin layer or < 0 on error.
 */
static int ovl_connect_layer(struct dentry *dentry)
{
	struct dentry *next, *parent = NULL;
	int origin_layer;
	int err = 0;

	if (WARN_ON(dentry == dentry->d_sb->s_root) ||
	    WARN_ON(!ovl_dentry_lower(dentry)))
		return -EIO;

	origin_layer = OVL_E(dentry)->lowerstack[0].layer->idx;
	if (ovl_dentry_test_flag(OVL_E_CONNECTED, dentry))
		return origin_layer;

	/* Find the topmost origin layer connectable ancestor of @dentry */
	next = dget(dentry);
	for (;;) {
		parent = dget_parent(next);
		if (WARN_ON(parent == next)) {
			err = -EIO;
			break;
		}

		/*
		 * If @parent is not origin layer connectable, then copy up
		 * @next which is origin layer connectable and we are done.
		 */
		if (ovl_connectable_layer(parent) < origin_layer) {
			err = ovl_encode_maybe_copy_up(next);
			break;
		}

		/* If @parent is connected or indexed we are done */
		if (ovl_dentry_test_flag(OVL_E_CONNECTED, parent) ||
		    ovl_test_flag(OVL_INDEX, d_inode(parent)))
			break;

		dput(next);
		next = parent;
	}

	dput(parent);
	dput(next);

	if (!err)
		ovl_dentry_set_flag(OVL_E_CONNECTED, dentry);

	return err ?: origin_layer;
}

155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
/*
 * We only need to encode origin if there is a chance that the same object was
 * encoded pre copy up and then we need to stay consistent with the same
 * encoding also after copy up. If non-pure upper is not indexed, then it was
 * copied up before NFS export was enabled. In that case we don't need to worry
 * about staying consistent with pre copy up encoding and we encode an upper
 * file handle. Overlay root dentry is a private case of non-indexed upper.
 *
 * The following table summarizes the different file handle encodings used for
 * different overlay object types:
 *
 *  Object type		| Encoding
 * --------------------------------
 *  Pure upper		| U
 *  Non-indexed upper	| U
170 171
 *  Indexed upper	| L (*)
 *  Non-upper		| L (*)
172 173 174
 *
 * U = upper file handle
 * L = lower file handle
175 176
 *
 * (*) Connecting an overlay dir from real lower dentry is not always
177 178 179 180 181
 * possible when there are redirects in lower layers and non-indexed merge dirs.
 * To mitigate those case, we may copy up the lower dir ancestor before encode
 * a lower dir file handle.
 *
 * Return 0 for upper file handle, > 0 for lower file handle or < 0 on error.
182
 */
183
static int ovl_check_encode_origin(struct dentry *dentry)
184
{
185 186
	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;

187
	/* Upper file handle for pure upper */
188
	if (!ovl_dentry_lower(dentry))
189
		return 0;
190

191
	/*
192
	 * Upper file handle for non-indexed upper.
193
	 *
194 195
	 * Root is never indexed, so if there's an upper layer, encode upper for
	 * root.
196
	 */
197 198
	if (ovl_dentry_upper(dentry) &&
	    !ovl_test_flag(OVL_INDEX, d_inode(dentry)))
199 200
		return 0;

201 202 203 204 205 206 207 208
	/*
	 * Decoding a merge dir, whose origin's ancestor is under a redirected
	 * lower dir or under a non-indexed upper is not always possible.
	 * ovl_connect_layer() will try to make origin's layer "connected" by
	 * copying up a "connectable" ancestor.
	 */
	if (d_is_dir(dentry) && ofs->upper_mnt)
		return ovl_connect_layer(dentry);
209

210 211
	/* Lower file handle for indexed and non-upper dir/non-dir */
	return 1;
212 213
}

214
static int ovl_dentry_to_fid(struct dentry *dentry, u32 *fid, int buflen)
215 216
{
	struct ovl_fh *fh = NULL;
217
	int err, enc_lower;
218
	int len;
219

220
	/*
221 222
	 * Check if we should encode a lower or upper file handle and maybe
	 * copy up an ancestor to make lower file handle connectable.
223
	 */
224 225 226
	err = enc_lower = ovl_check_encode_origin(dentry);
	if (enc_lower < 0)
		goto fail;
227

228
	/* Encode an upper or lower file handle */
229 230
	fh = ovl_encode_real_fh(enc_lower ? ovl_dentry_lower(dentry) :
				ovl_dentry_upper(dentry), !enc_lower);
231
	if (IS_ERR(fh))
232
		return PTR_ERR(fh);
233 234

	err = -EOVERFLOW;
235 236
	len = OVL_FH_LEN(fh);
	if (len > buflen)
237 238
		goto fail;

239 240
	memcpy(fid, fh, len);
	err = len;
241 242 243 244 245 246

out:
	kfree(fh);
	return err;

fail:
lijiazi's avatar
lijiazi committed
247
	pr_warn_ratelimited("failed to encode file handle (%pd2, err=%i, buflen=%d, len=%d, type=%d)\n",
248 249
			    dentry, err, buflen, fh ? (int)fh->fb.len : 0,
			    fh ? fh->fb.type : 0);
250 251 252
	goto out;
}

253 254
static int ovl_encode_fh(struct inode *inode, u32 *fid, int *max_len,
			 struct inode *parent)
255 256
{
	struct dentry *dentry;
257
	int bytes = *max_len << 2;
258 259 260 261 262 263 264 265 266

	/* TODO: encode connectable file handles */
	if (parent)
		return FILEID_INVALID;

	dentry = d_find_any_alias(inode);
	if (WARN_ON(!dentry))
		return FILEID_INVALID;

267
	bytes = ovl_dentry_to_fid(dentry, fid, bytes);
268
	dput(dentry);
269 270 271 272 273 274
	if (bytes <= 0)
		return FILEID_INVALID;

	*max_len = bytes >> 2;

	return OVL_FILEID_V1;
275 276
}

277
/*
278
 * Find or instantiate an overlay dentry from real dentries and index.
279 280
 */
static struct dentry *ovl_obtain_alias(struct super_block *sb,
281 282 283
				       struct dentry *upper_alias,
				       struct ovl_path *lowerpath,
				       struct dentry *index)
284
{
285
	struct dentry *lower = lowerpath ? lowerpath->dentry : NULL;
286
	struct dentry *upper = upper_alias ?: index;
287
	struct dentry *dentry;
288
	struct inode *inode;
289
	struct ovl_entry *oe;
290 291 292 293 294
	struct ovl_inode_params oip = {
		.lowerpath = lowerpath,
		.index = index,
		.numlower = !!lower
	};
295

296 297
	/* We get overlay directory dentries with ovl_lookup_real() */
	if (d_is_dir(upper ?: lower))
298 299
		return ERR_PTR(-EIO);

300 301
	oip.upperdentry = dget(upper);
	inode = ovl_get_inode(sb, &oip);
302 303 304 305 306
	if (IS_ERR(inode)) {
		dput(upper);
		return ERR_CAST(inode);
	}

307 308 309
	if (upper)
		ovl_set_flag(OVL_UPPERDATA, inode);

310
	dentry = d_find_any_alias(inode);
311 312 313 314 315 316 317 318 319 320 321 322 323
	if (dentry)
		goto out_iput;

	dentry = d_alloc_anon(inode->i_sb);
	if (unlikely(!dentry))
		goto nomem;
	oe = ovl_alloc_entry(lower ? 1 : 0);
	if (!oe)
		goto nomem;

	if (lower) {
		oe->lowerstack->dentry = dget(lower);
		oe->lowerstack->layer = lowerpath->layer;
324
	}
325 326 327 328
	dentry->d_fsdata = oe;
	if (upper_alias)
		ovl_dentry_set_upper_alias(dentry);

329 330
	ovl_dentry_update_reval(dentry, upper,
			DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE);
331 332 333 334 335

	return d_instantiate_anon(dentry, inode);

nomem:
	dput(dentry);
336 337 338 339
	dentry = ERR_PTR(-ENOMEM);
out_iput:
	iput(inode);
	return dentry;
340 341
}

342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358
/* Get the upper or lower dentry in stach whose on layer @idx */
static struct dentry *ovl_dentry_real_at(struct dentry *dentry, int idx)
{
	struct ovl_entry *oe = dentry->d_fsdata;
	int i;

	if (!idx)
		return ovl_dentry_upper(dentry);

	for (i = 0; i < oe->numlower; i++) {
		if (oe->lowerstack[i].layer->idx == idx)
			return oe->lowerstack[i].dentry;
	}

	return NULL;
}

359 360 361 362 363 364 365 366
/*
 * Lookup a child overlay dentry to get a connected overlay dentry whose real
 * dentry is @real. If @real is on upper layer, we lookup a child overlay
 * dentry with the same name as the real dentry. Otherwise, we need to consult
 * index for lookup.
 */
static struct dentry *ovl_lookup_real_one(struct dentry *connected,
					  struct dentry *real,
Miklos Szeredi's avatar
Miklos Szeredi committed
367
					  const struct ovl_layer *layer)
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
{
	struct inode *dir = d_inode(connected);
	struct dentry *this, *parent = NULL;
	struct name_snapshot name;
	int err;

	/*
	 * Lookup child overlay dentry by real name. The dir mutex protects us
	 * from racing with overlay rename. If the overlay dentry that is above
	 * real has already been moved to a parent that is not under the
	 * connected overlay dir, we return -ECHILD and restart the lookup of
	 * connected real path from the top.
	 */
	inode_lock_nested(dir, I_MUTEX_PARENT);
	err = -ECHILD;
	parent = dget_parent(real);
384
	if (ovl_dentry_real_at(connected, layer->idx) != parent)
385 386 387 388 389 390 391 392 393
		goto fail;

	/*
	 * We also need to take a snapshot of real dentry name to protect us
	 * from racing with underlying layer rename. In this case, we don't
	 * care about returning ESTALE, only from dereferencing a free name
	 * pointer because we hold no lock on the real dentry.
	 */
	take_dentry_name_snapshot(&name, real);
394
	this = lookup_one_len(name.name.name, connected, name.name.len);
395 396 397 398 399 400 401
	err = PTR_ERR(this);
	if (IS_ERR(this)) {
		goto fail;
	} else if (!this || !this->d_inode) {
		dput(this);
		err = -ENOENT;
		goto fail;
402
	} else if (ovl_dentry_real_at(this, layer->idx) != real) {
403 404 405 406 407 408 409 410 411 412 413 414
		dput(this);
		err = -ESTALE;
		goto fail;
	}

out:
	release_dentry_name_snapshot(&name);
	dput(parent);
	inode_unlock(dir);
	return this;

fail:
lijiazi's avatar
lijiazi committed
415
	pr_warn_ratelimited("failed to lookup one by real (%pd2, layer=%d, connected=%pd2, err=%i)\n",
416 417 418 419 420
			    real, layer->idx, connected, err);
	this = ERR_PTR(err);
	goto out;
}

421 422
static struct dentry *ovl_lookup_real(struct super_block *sb,
				      struct dentry *real,
Miklos Szeredi's avatar
Miklos Szeredi committed
423
				      const struct ovl_layer *layer);
424

425 426 427 428 429
/*
 * Lookup an indexed or hashed overlay dentry by real inode.
 */
static struct dentry *ovl_lookup_real_inode(struct super_block *sb,
					    struct dentry *real,
Miklos Szeredi's avatar
Miklos Szeredi committed
430
					    const struct ovl_layer *layer)
431
{
432 433
	struct ovl_fs *ofs = sb->s_fs_info;
	struct dentry *index = NULL;
434 435 436
	struct dentry *this = NULL;
	struct inode *inode;

437 438 439 440
	/*
	 * Decoding upper dir from index is expensive, so first try to lookup
	 * overlay dentry in inode/dcache.
	 */
441 442 443 444 445 446 447 448
	inode = ovl_lookup_inode(sb, real, !layer->idx);
	if (IS_ERR(inode))
		return ERR_CAST(inode);
	if (inode) {
		this = d_find_any_alias(inode);
		iput(inode);
	}

449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473
	/*
	 * For decoded lower dir file handle, lookup index by origin to check
	 * if lower dir was copied up and and/or removed.
	 */
	if (!this && layer->idx && ofs->indexdir && !WARN_ON(!d_is_dir(real))) {
		index = ovl_lookup_index(ofs, NULL, real, false);
		if (IS_ERR(index))
			return index;
	}

	/* Get connected upper overlay dir from index */
	if (index) {
		struct dentry *upper = ovl_index_upper(ofs, index);

		dput(index);
		if (IS_ERR_OR_NULL(upper))
			return upper;

		/*
		 * ovl_lookup_real() in lower layer may call recursively once to
		 * ovl_lookup_real() in upper layer. The first level call walks
		 * back lower parents to the topmost indexed parent. The second
		 * recursive call walks back from indexed upper to the topmost
		 * connected/hashed upper parent (or up to root).
		 */
474
		this = ovl_lookup_real(sb, upper, &ofs->layers[0]);
475 476 477
		dput(upper);
	}

478 479
	if (IS_ERR_OR_NULL(this))
		return this;
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494

	if (WARN_ON(ovl_dentry_real_at(this, layer->idx) != real)) {
		dput(this);
		this = ERR_PTR(-EIO);
	}

	return this;
}

/*
 * Lookup an indexed or hashed overlay dentry, whose real dentry is an
 * ancestor of @real.
 */
static struct dentry *ovl_lookup_real_ancestor(struct super_block *sb,
					       struct dentry *real,
Miklos Szeredi's avatar
Miklos Szeredi committed
495
					       const struct ovl_layer *layer)
496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
{
	struct dentry *next, *parent = NULL;
	struct dentry *ancestor = ERR_PTR(-EIO);

	if (real == layer->mnt->mnt_root)
		return dget(sb->s_root);

	/* Find the topmost indexed or hashed ancestor */
	next = dget(real);
	for (;;) {
		parent = dget_parent(next);

		/*
		 * Lookup a matching overlay dentry in inode/dentry
		 * cache or in index by real inode.
		 */
		ancestor = ovl_lookup_real_inode(sb, next, layer);
		if (ancestor)
			break;

		if (parent == layer->mnt->mnt_root) {
			ancestor = dget(sb->s_root);
			break;
		}

		/*
		 * If @real has been moved out of the layer root directory,
		 * we will eventully hit the real fs root. This cannot happen
		 * by legit overlay rename, so we return error in that case.
		 */
		if (parent == next) {
			ancestor = ERR_PTR(-EXDEV);
			break;
		}

		dput(next);
		next = parent;
	}

	dput(parent);
	dput(next);

	return ancestor;
}

541 542 543 544 545 546 547
/*
 * Lookup a connected overlay dentry whose real dentry is @real.
 * If @real is on upper layer, we lookup a child overlay dentry with the same
 * path the real dentry. Otherwise, we need to consult index for lookup.
 */
static struct dentry *ovl_lookup_real(struct super_block *sb,
				      struct dentry *real,
Miklos Szeredi's avatar
Miklos Szeredi committed
548
				      const struct ovl_layer *layer)
549 550 551 552
{
	struct dentry *connected;
	int err = 0;

553 554 555
	connected = ovl_lookup_real_ancestor(sb, real, layer);
	if (IS_ERR(connected))
		return connected;
556 557 558 559

	while (!err) {
		struct dentry *next, *this;
		struct dentry *parent = NULL;
560 561
		struct dentry *real_connected = ovl_dentry_real_at(connected,
								   layer->idx);
562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612

		if (real_connected == real)
			break;

		/* Find the topmost dentry not yet connected */
		next = dget(real);
		for (;;) {
			parent = dget_parent(next);

			if (parent == real_connected)
				break;

			/*
			 * If real has been moved out of 'real_connected',
			 * we will not find 'real_connected' and hit the layer
			 * root. In that case, we need to restart connecting.
			 * This game can go on forever in the worst case. We
			 * may want to consider taking s_vfs_rename_mutex if
			 * this happens more than once.
			 */
			if (parent == layer->mnt->mnt_root) {
				dput(connected);
				connected = dget(sb->s_root);
				break;
			}

			/*
			 * If real file has been moved out of the layer root
			 * directory, we will eventully hit the real fs root.
			 * This cannot happen by legit overlay rename, so we
			 * return error in that case.
			 */
			if (parent == next) {
				err = -EXDEV;
				break;
			}

			dput(next);
			next = parent;
		}

		if (!err) {
			this = ovl_lookup_real_one(connected, next, layer);
			if (IS_ERR(this))
				err = PTR_ERR(this);

			/*
			 * Lookup of child in overlay can fail when racing with
			 * overlay rename of child away from 'connected' parent.
			 * In this case, we need to restart the lookup from the
			 * top, because we cannot trust that 'real_connected' is
613 614 615 616
			 * still an ancestor of 'real'. There is a good chance
			 * that the renamed overlay ancestor is now in cache, so
			 * ovl_lookup_real_ancestor() will find it and we can
			 * continue to connect exactly from where lookup failed.
617 618
			 */
			if (err == -ECHILD) {
619 620
				this = ovl_lookup_real_ancestor(sb, real,
								layer);
Fengguang Wu's avatar
Fengguang Wu committed
621
				err = PTR_ERR_OR_ZERO(this);
622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638
			}
			if (!err) {
				dput(connected);
				connected = this;
			}
		}

		dput(parent);
		dput(next);
	}

	if (err)
		goto fail;

	return connected;

fail:
lijiazi's avatar
lijiazi committed
639
	pr_warn_ratelimited("failed to lookup by real (%pd2, layer=%d, connected=%pd2, err=%i)\n",
640 641 642 643 644 645
			    real, layer->idx, connected, err);
	dput(connected);
	return ERR_PTR(err);
}

/*
646
 * Get an overlay dentry from upper/lower real dentries and index.
647 648 649
 */
static struct dentry *ovl_get_dentry(struct super_block *sb,
				     struct dentry *upper,
650 651
				     struct ovl_path *lowerpath,
				     struct dentry *index)
652 653
{
	struct ovl_fs *ofs = sb->s_fs_info;
Miklos Szeredi's avatar
Miklos Szeredi committed
654
	const struct ovl_layer *layer = upper ? &ofs->layers[0] : lowerpath->layer;
655
	struct dentry *real = upper ?: (index ?: lowerpath->dentry);
656

657
	/*
658 659
	 * Obtain a disconnected overlay dentry from a non-dir real dentry
	 * and index.
660
	 */
661 662
	if (!d_is_dir(real))
		return ovl_obtain_alias(sb, upper, lowerpath, index);
663

664
	/* Removed empty directory? */
665
	if ((real->d_flags & DCACHE_DISCONNECTED) || d_unhashed(real))
666 667 668
		return ERR_PTR(-ENOENT);

	/*
669 670
	 * If real dentry is connected and hashed, get a connected overlay
	 * dentry whose real dentry is @real.
671
	 */
672
	return ovl_lookup_real(sb, real, layer);
673 674
}

675 676 677 678 679 680 681 682 683 684
static struct dentry *ovl_upper_fh_to_d(struct super_block *sb,
					struct ovl_fh *fh)
{
	struct ovl_fs *ofs = sb->s_fs_info;
	struct dentry *dentry;
	struct dentry *upper;

	if (!ofs->upper_mnt)
		return ERR_PTR(-EACCES);

685
	upper = ovl_decode_real_fh(fh, ofs->upper_mnt, true);
686 687 688
	if (IS_ERR_OR_NULL(upper))
		return upper;

689
	dentry = ovl_get_dentry(sb, upper, NULL, NULL);
690 691 692 693 694
	dput(upper);

	return dentry;
}

695 696 697 698 699 700 701
static struct dentry *ovl_lower_fh_to_d(struct super_block *sb,
					struct ovl_fh *fh)
{
	struct ovl_fs *ofs = sb->s_fs_info;
	struct ovl_path origin = { };
	struct ovl_path *stack = &origin;
	struct dentry *dentry = NULL;
702
	struct dentry *index = NULL;
703
	struct inode *inode;
704 705
	int err;

706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725
	/* First lookup overlay inode in inode cache by origin fh */
	err = ovl_check_origin_fh(ofs, fh, false, NULL, &stack);
	if (err)
		return ERR_PTR(err);

	if (!d_is_dir(origin.dentry) ||
	    !(origin.dentry->d_flags & DCACHE_DISCONNECTED)) {
		inode = ovl_lookup_inode(sb, origin.dentry, false);
		err = PTR_ERR(inode);
		if (IS_ERR(inode))
			goto out_err;
		if (inode) {
			dentry = d_find_any_alias(inode);
			iput(inode);
			if (dentry)
				goto out;
		}
	}

	/* Then lookup indexed upper/whiteout by origin fh */
726 727 728
	if (ofs->indexdir) {
		index = ovl_get_index_fh(ofs, fh);
		err = PTR_ERR(index);
729 730
		if (IS_ERR(index)) {
			index = NULL;
731
			goto out_err;
732
		}
733 734
	}

735
	/* Then try to get a connected upper dir by index */
736 737 738 739 740 741 742 743 744 745 746 747
	if (index && d_is_dir(index)) {
		struct dentry *upper = ovl_index_upper(ofs, index);

		err = PTR_ERR(upper);
		if (IS_ERR_OR_NULL(upper))
			goto out_err;

		dentry = ovl_get_dentry(sb, upper, NULL, NULL);
		dput(upper);
		goto out;
	}

748 749
	/* Find origin.dentry again with ovl_acceptable() layer check */
	if (d_is_dir(origin.dentry)) {
750 751 752
		dput(origin.dentry);
		origin.dentry = NULL;
		err = ovl_check_origin_fh(ofs, fh, true, NULL, &stack);
753 754
		if (err)
			goto out_err;
755 756 757 758
	}
	if (index) {
		err = ovl_verify_origin(index, origin.dentry, false);
		if (err)
759
			goto out_err;
760
	}
761

762
	/* Get a connected non-upper dir or disconnected non-dir */
763
	dentry = ovl_get_dentry(sb, NULL, &origin, index);
764

765 766 767
out:
	dput(origin.dentry);
	dput(index);
768
	return dentry;
769 770 771 772

out_err:
	dentry = ERR_PTR(err);
	goto out;
773 774
}

775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794
static struct ovl_fh *ovl_fid_to_fh(struct fid *fid, int buflen, int fh_type)
{
	struct ovl_fh *fh;

	/* If on-wire inner fid is aligned - nothing to do */
	if (fh_type == OVL_FILEID_V1)
		return (struct ovl_fh *)fid;

	if (fh_type != OVL_FILEID_V0)
		return ERR_PTR(-EINVAL);

	fh = kzalloc(buflen, GFP_KERNEL);
	if (!fh)
		return ERR_PTR(-ENOMEM);

	/* Copy unaligned inner fh into aligned buffer */
	memcpy(&fh->fb, fid, buflen - OVL_FH_WIRE_OFFSET);
	return fh;
}

795 796 797 798
static struct dentry *ovl_fh_to_dentry(struct super_block *sb, struct fid *fid,
				       int fh_len, int fh_type)
{
	struct dentry *dentry = NULL;
799
	struct ovl_fh *fh = NULL;
800 801 802 803
	int len = fh_len << 2;
	unsigned int flags = 0;
	int err;

804 805 806
	fh = ovl_fid_to_fh(fid, len, fh_type);
	err = PTR_ERR(fh);
	if (IS_ERR(fh))
807 808 809 810 811 812
		goto out_err;

	err = ovl_check_fh_len(fh, len);
	if (err)
		goto out_err;

813
	flags = fh->fb.flags;
814 815 816
	dentry = (flags & OVL_FH_FLAG_PATH_UPPER) ?
		 ovl_upper_fh_to_d(sb, fh) :
		 ovl_lower_fh_to_d(sb, fh);
817 818 819 820
	err = PTR_ERR(dentry);
	if (IS_ERR(dentry) && err != -ESTALE)
		goto out_err;

821 822 823 824 825
out:
	/* We may have needed to re-align OVL_FILEID_V0 */
	if (!IS_ERR_OR_NULL(fh) && fh != (void *)fid)
		kfree(fh);

826 827 828
	return dentry;

out_err:
lijiazi's avatar
lijiazi committed
829
	pr_warn_ratelimited("failed to decode file handle (len=%d, type=%d, flags=%x, err=%i)\n",
830 831 832
			    fh_len, fh_type, flags, err);
	dentry = ERR_PTR(err);
	goto out;
833 834
}

835 836 837
static struct dentry *ovl_fh_to_parent(struct super_block *sb, struct fid *fid,
				       int fh_len, int fh_type)
{
lijiazi's avatar
lijiazi committed
838
	pr_warn_ratelimited("connectable file handles not supported; use 'no_subtree_check' exportfs option.\n");
839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862
	return ERR_PTR(-EACCES);
}

static int ovl_get_name(struct dentry *parent, char *name,
			struct dentry *child)
{
	/*
	 * ovl_fh_to_dentry() returns connected dir overlay dentries and
	 * ovl_fh_to_parent() is not implemented, so we should not get here.
	 */
	WARN_ON_ONCE(1);
	return -EIO;
}

static struct dentry *ovl_get_parent(struct dentry *dentry)
{
	/*
	 * ovl_fh_to_dentry() returns connected dir overlay dentries, so we
	 * should not get here.
	 */
	WARN_ON_ONCE(1);
	return ERR_PTR(-EIO);
}

863
const struct export_operations ovl_export_operations = {
864
	.encode_fh	= ovl_encode_fh,
865
	.fh_to_dentry	= ovl_fh_to_dentry,
866 867 868
	.fh_to_parent	= ovl_fh_to_parent,
	.get_name	= ovl_get_name,
	.get_parent	= ovl_get_parent,
869
};