export.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Overlayfs NFS export support.
  4 *
  5 * Amir Goldstein <amir73il@gmail.com>
  6 *
  7 * Copyright (C) 2017-2018 CTERA Networks. All Rights Reserved.
  8 */
  9
 10#include <linux/fs.h>
 11#include <linux/cred.h>
 12#include <linux/mount.h>
 13#include <linux/namei.h>
 14#include <linux/xattr.h>
 15#include <linux/exportfs.h>
 16#include <linux/ratelimit.h>
 17#include "overlayfs.h"
 18
 19static int ovl_encode_maybe_copy_up(struct dentry *dentry)
 20{
 21	int err;
 22
 23	if (ovl_dentry_upper(dentry))
 24		return 0;
 25
 26	err = ovl_copy_up(dentry);
 27	if (err) {
 28		pr_warn_ratelimited("failed to copy up on encode (%pd2, err=%i)\n",
 29				    dentry, err);
 30	}
 31
 32	return err;
 33}
 34
 35/*
 36 * Before encoding a non-upper directory file handle from real layer N, we need
 37 * to check if it will be possible to reconnect an overlay dentry from the real
 38 * lower decoded dentry. This is done by following the overlay ancestry up to a
 39 * "layer N connected" ancestor and verifying that all parents along the way are
 40 * "layer N connectable". If an ancestor that is NOT "layer N connectable" is
 41 * found, we need to copy up an ancestor, which is "layer N connectable", thus
 42 * making that ancestor "layer N connected". For example:
 43 *
 44 * layer 1: /a
 45 * layer 2: /a/b/c
 46 *
 47 * The overlay dentry /a is NOT "layer 2 connectable", because if dir /a is
 48 * copied up and renamed, upper dir /a will be indexed by lower dir /a from
 49 * layer 1. The dir /a from layer 2 will never be indexed, so the algorithm (*)
 50 * in ovl_lookup_real_ancestor() will not be able to lookup a connected overlay
 51 * dentry from the connected lower dentry /a/b/c.
 52 *
 53 * To avoid this problem on decode time, we need to copy up an ancestor of
 54 * /a/b/c, which is "layer 2 connectable", on encode time. That ancestor is
 55 * /a/b. After copy up (and index) of /a/b, it will become "layer 2 connected"
 56 * and when the time comes to decode the file handle from lower dentry /a/b/c,
 57 * ovl_lookup_real_ancestor() will find the indexed ancestor /a/b and decoding
 58 * a connected overlay dentry will be accomplished.
 59 *
 60 * (*) the algorithm in ovl_lookup_real_ancestor() can be improved to lookup an
 61 * entry /a in the lower layers above layer N and find the indexed dir /a from
 62 * layer 1. If that improvement is made, then the check for "layer N connected"
 63 * will need to verify there are no redirects in lower layers above N. In the
 64 * example above, /a will be "layer 2 connectable". However, if layer 2 dir /a
 65 * is a target of a layer 1 redirect, then /a will NOT be "layer 2 connectable":
 66 *
 67 * layer 1: /A (redirect = /a)
 68 * layer 2: /a/b/c
 69 */
 70
 71/* Return the lowest layer for encoding a connectable file handle */
 72static int ovl_connectable_layer(struct dentry *dentry)
 73{
 74	struct ovl_entry *oe = OVL_E(dentry);
 75
 76	/* We can get overlay root from root of any layer */
 77	if (dentry == dentry->d_sb->s_root)
 78		return ovl_numlower(oe);
 79
 80	/*
 81	 * If it's an unindexed merge dir, then it's not connectable with any
 82	 * lower layer
 83	 */
 84	if (ovl_dentry_upper(dentry) &&
 85	    !ovl_test_flag(OVL_INDEX, d_inode(dentry)))
 86		return 0;
 87
 88	/* We can get upper/overlay path from indexed/lower dentry */
 89	return ovl_lowerstack(oe)->layer->idx;
 90}
 91
 92/*
 93 * @dentry is "connected" if all ancestors up to root or a "connected" ancestor
 94 * have the same uppermost lower layer as the origin's layer. We may need to
 95 * copy up a "connectable" ancestor to make it "connected". A "connected" dentry
 96 * cannot become non "connected", so cache positive result in dentry flags.
 97 *
 98 * Return the connected origin layer or < 0 on error.
 99 */
100static int ovl_connect_layer(struct dentry *dentry)
101{
102	struct dentry *next, *parent = NULL;
103	struct ovl_entry *oe = OVL_E(dentry);
104	int origin_layer;
105	int err = 0;
106
107	if (WARN_ON(dentry == dentry->d_sb->s_root) ||
108	    WARN_ON(!ovl_dentry_lower(dentry)))
109		return -EIO;
110
111	origin_layer = ovl_lowerstack(oe)->layer->idx;
112	if (ovl_dentry_test_flag(OVL_E_CONNECTED, dentry))
113		return origin_layer;
114
115	/* Find the topmost origin layer connectable ancestor of @dentry */
116	next = dget(dentry);
117	for (;;) {
118		parent = dget_parent(next);
119		if (WARN_ON(parent == next)) {
120			err = -EIO;
121			break;
122		}
123
124		/*
125		 * If @parent is not origin layer connectable, then copy up
126		 * @next which is origin layer connectable and we are done.
127		 */
128		if (ovl_connectable_layer(parent) < origin_layer) {
129			err = ovl_encode_maybe_copy_up(next);
130			break;
131		}
132
133		/* If @parent is connected or indexed we are done */
134		if (ovl_dentry_test_flag(OVL_E_CONNECTED, parent) ||
135		    ovl_test_flag(OVL_INDEX, d_inode(parent)))
136			break;
137
138		dput(next);
139		next = parent;
140	}
141
142	dput(parent);
143	dput(next);
144
145	if (!err)
146		ovl_dentry_set_flag(OVL_E_CONNECTED, dentry);
147
148	return err ?: origin_layer;
149}
150
151/*
152 * We only need to encode origin if there is a chance that the same object was
153 * encoded pre copy up and then we need to stay consistent with the same
154 * encoding also after copy up. If non-pure upper is not indexed, then it was
155 * copied up before NFS export was enabled. In that case we don't need to worry
156 * about staying consistent with pre copy up encoding and we encode an upper
157 * file handle. Overlay root dentry is a private case of non-indexed upper.
158 *
159 * The following table summarizes the different file handle encodings used for
160 * different overlay object types:
161 *
162 *  Object type		| Encoding
163 * --------------------------------
164 *  Pure upper		| U
165 *  Non-indexed upper	| U
166 *  Indexed upper	| L (*)
167 *  Non-upper		| L (*)
168 *
169 * U = upper file handle
170 * L = lower file handle
171 *
172 * (*) Decoding a connected overlay dir from real lower dentry is not always
173 * possible when there are redirects in lower layers and non-indexed merge dirs.
174 * To mitigate those case, we may copy up the lower dir ancestor before encode
175 * of a decodable file handle for non-upper dir.
176 *
177 * Return 0 for upper file handle, > 0 for lower file handle or < 0 on error.
178 */
179static int ovl_check_encode_origin(struct inode *inode)
180{
181	struct ovl_fs *ofs = OVL_FS(inode->i_sb);
182	bool decodable = ofs->config.nfs_export;
183	struct dentry *dentry;
184	int err;
185
186	/* No upper layer? */
187	if (!ovl_upper_mnt(ofs))
188		return 1;
189
190	/* Lower file handle for non-upper non-decodable */
191	if (!ovl_inode_upper(inode) && !decodable)
192		return 1;
193
194	/* Upper file handle for pure upper */
195	if (!ovl_inode_lower(inode))
196		return 0;
197
198	/*
199	 * Root is never indexed, so if there's an upper layer, encode upper for
200	 * root.
201	 */
202	if (inode == d_inode(inode->i_sb->s_root))
203		return 0;
204
205	/*
206	 * Upper decodable file handle for non-indexed upper.
207	 */
208	if (ovl_inode_upper(inode) && decodable &&
209	    !ovl_test_flag(OVL_INDEX, inode))
210		return 0;
211
212	/*
213	 * Decoding a merge dir, whose origin's ancestor is under a redirected
214	 * lower dir or under a non-indexed upper is not always possible.
215	 * ovl_connect_layer() will try to make origin's layer "connected" by
216	 * copying up a "connectable" ancestor.
217	 */
218	if (!decodable || !S_ISDIR(inode->i_mode))
219		return 1;
220
221	dentry = d_find_any_alias(inode);
222	if (!dentry)
223		return -ENOENT;
224
225	err = ovl_connect_layer(dentry);
226	dput(dentry);
227	if (err < 0)
228		return err;
229
230	/* Lower file handle for indexed and non-upper dir/non-dir */
231	return 1;
232}
233
234static int ovl_dentry_to_fid(struct ovl_fs *ofs, struct inode *inode,
235			     u32 *fid, int buflen)
236{
237	struct ovl_fh *fh = NULL;
238	int err, enc_lower;
239	int len;
240
241	/*
242	 * Check if we should encode a lower or upper file handle and maybe
243	 * copy up an ancestor to make lower file handle connectable.
244	 */
245	err = enc_lower = ovl_check_encode_origin(inode);
246	if (enc_lower < 0)
247		goto fail;
248
249	/* Encode an upper or lower file handle */
250	fh = ovl_encode_real_fh(ofs, enc_lower ? ovl_inode_lower(inode) :
251				ovl_inode_upper(inode), !enc_lower);
252	if (IS_ERR(fh))
253		return PTR_ERR(fh);
254
255	len = OVL_FH_LEN(fh);
256	if (len <= buflen)
257		memcpy(fid, fh, len);
258	err = len;
259
260out:
261	kfree(fh);
262	return err;
263
264fail:
265	pr_warn_ratelimited("failed to encode file handle (ino=%lu, err=%i)\n",
266			    inode->i_ino, err);
267	goto out;
268}
269
270static int ovl_encode_fh(struct inode *inode, u32 *fid, int *max_len,
271			 struct inode *parent)
272{
273	struct ovl_fs *ofs = OVL_FS(inode->i_sb);
274	int bytes, buflen = *max_len << 2;
275
276	/* TODO: encode connectable file handles */
277	if (parent)
278		return FILEID_INVALID;
279
280	bytes = ovl_dentry_to_fid(ofs, inode, fid, buflen);
281	if (bytes <= 0)
282		return FILEID_INVALID;
283
284	*max_len = bytes >> 2;
285	if (bytes > buflen)
286		return FILEID_INVALID;
287
288	return OVL_FILEID_V1;
289}
290
291/*
292 * Find or instantiate an overlay dentry from real dentries and index.
293 */
294static struct dentry *ovl_obtain_alias(struct super_block *sb,
295				       struct dentry *upper_alias,
296				       struct ovl_path *lowerpath,
297				       struct dentry *index)
298{
299	struct dentry *lower = lowerpath ? lowerpath->dentry : NULL;
300	struct dentry *upper = upper_alias ?: index;
301	struct inode *inode = NULL;
302	struct ovl_entry *oe;
303	struct ovl_inode_params oip = {
304		.index = index,
305	};
306
307	/* We get overlay directory dentries with ovl_lookup_real() */
308	if (d_is_dir(upper ?: lower))
309		return ERR_PTR(-EIO);
310
311	oe = ovl_alloc_entry(!!lower);
312	if (!oe)
313		return ERR_PTR(-ENOMEM);
314
315	oip.upperdentry = dget(upper);
316	if (lower) {
317		ovl_lowerstack(oe)->dentry = dget(lower);
318		ovl_lowerstack(oe)->layer = lowerpath->layer;
319	}
320	oip.oe = oe;
321	inode = ovl_get_inode(sb, &oip);
322	if (IS_ERR(inode)) {
323		ovl_free_entry(oe);
324		dput(upper);
325		return ERR_CAST(inode);
326	}
327
328	if (upper)
329		ovl_set_flag(OVL_UPPERDATA, inode);
330
331	return d_obtain_alias(inode);
332}
333
334/* Get the upper or lower dentry in stack whose on layer @idx */
335static struct dentry *ovl_dentry_real_at(struct dentry *dentry, int idx)
336{
337	struct ovl_entry *oe = OVL_E(dentry);
338	struct ovl_path *lowerstack = ovl_lowerstack(oe);
339	int i;
340
341	if (!idx)
342		return ovl_dentry_upper(dentry);
343
344	for (i = 0; i < ovl_numlower(oe); i++) {
345		if (lowerstack[i].layer->idx == idx)
346			return lowerstack[i].dentry;
347	}
348
349	return NULL;
350}
351
352/*
353 * Lookup a child overlay dentry to get a connected overlay dentry whose real
354 * dentry is @real. If @real is on upper layer, we lookup a child overlay
355 * dentry with the same name as the real dentry. Otherwise, we need to consult
356 * index for lookup.
357 */
358static struct dentry *ovl_lookup_real_one(struct dentry *connected,
359					  struct dentry *real,
360					  const struct ovl_layer *layer)
361{
362	struct inode *dir = d_inode(connected);
363	struct dentry *this, *parent = NULL;
364	struct name_snapshot name;
365	int err;
366
367	/*
368	 * Lookup child overlay dentry by real name. The dir mutex protects us
369	 * from racing with overlay rename. If the overlay dentry that is above
370	 * real has already been moved to a parent that is not under the
371	 * connected overlay dir, we return -ECHILD and restart the lookup of
372	 * connected real path from the top.
373	 */
374	inode_lock_nested(dir, I_MUTEX_PARENT);
375	err = -ECHILD;
376	parent = dget_parent(real);
377	if (ovl_dentry_real_at(connected, layer->idx) != parent)
378		goto fail;
379
380	/*
381	 * We also need to take a snapshot of real dentry name to protect us
382	 * from racing with underlying layer rename. In this case, we don't
383	 * care about returning ESTALE, only from dereferencing a free name
384	 * pointer because we hold no lock on the real dentry.
385	 */
386	take_dentry_name_snapshot(&name, real);
387	/*
388	 * No idmap handling here: it's an internal lookup.
389	 */
390	this = lookup_noperm(&name.name, connected);
391	release_dentry_name_snapshot(&name);
392	err = PTR_ERR(this);
393	if (IS_ERR(this)) {
394		goto fail;
395	} else if (!this || !this->d_inode) {
396		dput(this);
397		err = -ENOENT;
398		goto fail;
399	} else if (ovl_dentry_real_at(this, layer->idx) != real) {
400		dput(this);
401		err = -ESTALE;
402		goto fail;
403	}
404
405out:
406	dput(parent);
407	inode_unlock(dir);
408	return this;
409
410fail:
411	pr_warn_ratelimited("failed to lookup one by real (%pd2, layer=%d, connected=%pd2, err=%i)\n",
412			    real, layer->idx, connected, err);
413	this = ERR_PTR(err);
414	goto out;
415}
416
417static struct dentry *ovl_lookup_real(struct super_block *sb,
418				      struct dentry *real,
419				      const struct ovl_layer *layer);
420
421/*
422 * Lookup an indexed or hashed overlay dentry by real inode.
423 */
424static struct dentry *ovl_lookup_real_inode(struct super_block *sb,
425					    struct dentry *real,
426					    const struct ovl_layer *layer)
427{
428	struct ovl_fs *ofs = OVL_FS(sb);
429	struct dentry *index = NULL;
430	struct dentry *this = NULL;
431	struct inode *inode;
432
433	/*
434	 * Decoding upper dir from index is expensive, so first try to lookup
435	 * overlay dentry in inode/dcache.
436	 */
437	inode = ovl_lookup_inode(sb, real, !layer->idx);
438	if (IS_ERR(inode))
439		return ERR_CAST(inode);
440	if (inode) {
441		this = d_find_any_alias(inode);
442		iput(inode);
443	}
444
445	/*
446	 * For decoded lower dir file handle, lookup index by origin to check
447	 * if lower dir was copied up and and/or removed.
448	 */
449	if (!this && layer->idx && ovl_indexdir(sb) && !WARN_ON(!d_is_dir(real))) {
450		index = ovl_lookup_index(ofs, NULL, real, false);
451		if (IS_ERR(index))
452			return index;
453	}
454
455	/* Get connected upper overlay dir from index */
456	if (index) {
457		struct dentry *upper = ovl_index_upper(ofs, index, true);
458
459		dput(index);
460		if (IS_ERR_OR_NULL(upper))
461			return upper;
462
463		/*
464		 * ovl_lookup_real() in lower layer may call recursively once to
465		 * ovl_lookup_real() in upper layer. The first level call walks
466		 * back lower parents to the topmost indexed parent. The second
467		 * recursive call walks back from indexed upper to the topmost
468		 * connected/hashed upper parent (or up to root).
469		 */
470		this = ovl_lookup_real(sb, upper, &ofs->layers[0]);
471		dput(upper);
472	}
473
474	if (IS_ERR_OR_NULL(this))
475		return this;
476
477	if (ovl_dentry_real_at(this, layer->idx) != real) {
478		dput(this);
479		this = ERR_PTR(-EIO);
480	}
481
482	return this;
483}
484
485/*
486 * Lookup an indexed or hashed overlay dentry, whose real dentry is an
487 * ancestor of @real.
488 */
489static struct dentry *ovl_lookup_real_ancestor(struct super_block *sb,
490					       struct dentry *real,
491					       const struct ovl_layer *layer)
492{
493	struct dentry *next, *parent = NULL;
494	struct dentry *ancestor = ERR_PTR(-EIO);
495
496	if (real == layer->mnt->mnt_root)
497		return dget(sb->s_root);
498
499	/* Find the topmost indexed or hashed ancestor */
500	next = dget(real);
501	for (;;) {
502		parent = dget_parent(next);
503
504		/*
505		 * Lookup a matching overlay dentry in inode/dentry
506		 * cache or in index by real inode.
507		 */
508		ancestor = ovl_lookup_real_inode(sb, next, layer);
509		if (ancestor)
510			break;
511
512		if (parent == layer->mnt->mnt_root) {
513			ancestor = dget(sb->s_root);
514			break;
515		}
516
517		/*
518		 * If @real has been moved out of the layer root directory,
519		 * we will eventully hit the real fs root. This cannot happen
520		 * by legit overlay rename, so we return error in that case.
521		 */
522		if (parent == next) {
523			ancestor = ERR_PTR(-EXDEV);
524			break;
525		}
526
527		dput(next);
528		next = parent;
529	}
530
531	dput(parent);
532	dput(next);
533
534	return ancestor;
535}
536
537/*
538 * Lookup a connected overlay dentry whose real dentry is @real.
539 * If @real is on upper layer, we lookup a child overlay dentry with the same
540 * path the real dentry. Otherwise, we need to consult index for lookup.
541 */
542static struct dentry *ovl_lookup_real(struct super_block *sb,
543				      struct dentry *real,
544				      const struct ovl_layer *layer)
545{
546	struct dentry *connected;
547	int err = 0;
548
549	connected = ovl_lookup_real_ancestor(sb, real, layer);
550	if (IS_ERR(connected))
551		return connected;
552
553	while (!err) {
554		struct dentry *next, *this;
555		struct dentry *parent = NULL;
556		struct dentry *real_connected = ovl_dentry_real_at(connected,
557								   layer->idx);
558
559		if (real_connected == real)
560			break;
561
562		/* Find the topmost dentry not yet connected */
563		next = dget(real);
564		for (;;) {
565			parent = dget_parent(next);
566
567			if (parent == real_connected)
568				break;
569
570			/*
571			 * If real has been moved out of 'real_connected',
572			 * we will not find 'real_connected' and hit the layer
573			 * root. In that case, we need to restart connecting.
574			 * This game can go on forever in the worst case. We
575			 * may want to consider taking s_vfs_rename_mutex if
576			 * this happens more than once.
577			 */
578			if (parent == layer->mnt->mnt_root) {
579				dput(connected);
580				connected = dget(sb->s_root);
581				break;
582			}
583
584			/*
585			 * If real file has been moved out of the layer root
586			 * directory, we will eventully hit the real fs root.
587			 * This cannot happen by legit overlay rename, so we
588			 * return error in that case.
589			 */
590			if (parent == next) {
591				err = -EXDEV;
592				break;
593			}
594
595			dput(next);
596			next = parent;
597		}
598
599		if (!err) {
600			this = ovl_lookup_real_one(connected, next, layer);
601			if (IS_ERR(this))
602				err = PTR_ERR(this);
603
604			/*
605			 * Lookup of child in overlay can fail when racing with
606			 * overlay rename of child away from 'connected' parent.
607			 * In this case, we need to restart the lookup from the
608			 * top, because we cannot trust that 'real_connected' is
609			 * still an ancestor of 'real'. There is a good chance
610			 * that the renamed overlay ancestor is now in cache, so
611			 * ovl_lookup_real_ancestor() will find it and we can
612			 * continue to connect exactly from where lookup failed.
613			 */
614			if (err == -ECHILD) {
615				this = ovl_lookup_real_ancestor(sb, real,
616								layer);
617				err = PTR_ERR_OR_ZERO(this);
618			}
619			if (!err) {
620				dput(connected);
621				connected = this;
622			}
623		}
624
625		dput(parent);
626		dput(next);
627	}
628
629	if (err)
630		goto fail;
631
632	return connected;
633
634fail:
635	pr_warn_ratelimited("failed to lookup by real (%pd2, layer=%d, connected=%pd2, err=%i)\n",
636			    real, layer->idx, connected, err);
637	dput(connected);
638	return ERR_PTR(err);
639}
640
641/*
642 * Get an overlay dentry from upper/lower real dentries and index.
643 */
644static struct dentry *ovl_get_dentry(struct super_block *sb,
645				     struct dentry *upper,
646				     struct ovl_path *lowerpath,
647				     struct dentry *index)
648{
649	struct ovl_fs *ofs = OVL_FS(sb);
650	const struct ovl_layer *layer = upper ? &ofs->layers[0] : lowerpath->layer;
651	struct dentry *real = upper ?: (index ?: lowerpath->dentry);
652
653	/*
654	 * Obtain a disconnected overlay dentry from a non-dir real dentry
655	 * and index.
656	 */
657	if (!d_is_dir(real))
658		return ovl_obtain_alias(sb, upper, lowerpath, index);
659
660	/* Removed empty directory? */
661	if ((real->d_flags & DCACHE_DISCONNECTED) || d_unhashed(real))
662		return ERR_PTR(-ENOENT);
663
664	/*
665	 * If real dentry is connected and hashed, get a connected overlay
666	 * dentry whose real dentry is @real.
667	 */
668	return ovl_lookup_real(sb, real, layer);
669}
670
671static struct dentry *ovl_upper_fh_to_d(struct super_block *sb,
672					struct ovl_fh *fh)
673{
674	struct ovl_fs *ofs = OVL_FS(sb);
675	struct dentry *dentry;
676	struct dentry *upper;
677
678	if (!ovl_upper_mnt(ofs))
679		return ERR_PTR(-EACCES);
680
681	upper = ovl_decode_real_fh(ofs, fh, ovl_upper_mnt(ofs), true);
682	if (IS_ERR_OR_NULL(upper))
683		return upper;
684
685	dentry = ovl_get_dentry(sb, upper, NULL, NULL);
686	dput(upper);
687
688	return dentry;
689}
690
691static struct dentry *ovl_lower_fh_to_d(struct super_block *sb,
692					struct ovl_fh *fh)
693{
694	struct ovl_fs *ofs = OVL_FS(sb);
695	struct ovl_path origin = { };
696	struct ovl_path *stack = &origin;
697	struct dentry *dentry = NULL;
698	struct dentry *index = NULL;
699	struct inode *inode;
700	int err;
701
702	/* First lookup overlay inode in inode cache by origin fh */
703	err = ovl_check_origin_fh(ofs, fh, false, NULL, &stack);
704	if (err)
705		return ERR_PTR(err);
706
707	if (!d_is_dir(origin.dentry) ||
708	    !(origin.dentry->d_flags & DCACHE_DISCONNECTED)) {
709		inode = ovl_lookup_inode(sb, origin.dentry, false);
710		err = PTR_ERR(inode);
711		if (IS_ERR(inode))
712			goto out_err;
713		if (inode) {
714			dentry = d_find_any_alias(inode);
715			iput(inode);
716			if (dentry)
717				goto out;
718		}
719	}
720
721	/* Then lookup indexed upper/whiteout by origin fh */
722	if (ovl_indexdir(sb)) {
723		index = ovl_get_index_fh(ofs, fh);
724		err = PTR_ERR(index);
725		if (IS_ERR(index)) {
726			index = NULL;
727			goto out_err;
728		}
729	}
730
731	/* Then try to get a connected upper dir by index */
732	if (index && d_is_dir(index)) {
733		struct dentry *upper = ovl_index_upper(ofs, index, true);
734
735		err = PTR_ERR(upper);
736		if (IS_ERR_OR_NULL(upper))
737			goto out_err;
738
739		dentry = ovl_get_dentry(sb, upper, NULL, NULL);
740		dput(upper);
741		goto out;
742	}
743
744	/* Find origin.dentry again with ovl_acceptable() layer check */
745	if (d_is_dir(origin.dentry)) {
746		dput(origin.dentry);
747		origin.dentry = NULL;
748		err = ovl_check_origin_fh(ofs, fh, true, NULL, &stack);
749		if (err)
750			goto out_err;
751	}
752	if (index) {
753		err = ovl_verify_origin(ofs, index, origin.dentry, false);
754		if (err)
755			goto out_err;
756	}
757
758	/* Get a connected non-upper dir or disconnected non-dir */
759	dentry = ovl_get_dentry(sb, NULL, &origin, index);
760
761out:
762	dput(origin.dentry);
763	dput(index);
764	return dentry;
765
766out_err:
767	dentry = ERR_PTR(err);
768	goto out;
769}
770
771static struct ovl_fh *ovl_fid_to_fh(struct fid *fid, int buflen, int fh_type)
772{
773	struct ovl_fh *fh;
774
775	/* If on-wire inner fid is aligned - nothing to do */
776	if (fh_type == OVL_FILEID_V1)
777		return (struct ovl_fh *)fid;
778
779	if (fh_type != OVL_FILEID_V0)
780		return ERR_PTR(-EINVAL);
781
782	if (buflen <= OVL_FH_WIRE_OFFSET)
783		return ERR_PTR(-EINVAL);
784
785	fh = kzalloc(buflen, GFP_KERNEL);
786	if (!fh)
787		return ERR_PTR(-ENOMEM);
788
789	/* Copy unaligned inner fh into aligned buffer */
790	memcpy(fh->buf, fid, buflen - OVL_FH_WIRE_OFFSET);
791	return fh;
792}
793
794static struct dentry *ovl_fh_to_dentry(struct super_block *sb, struct fid *fid,
795				       int fh_len, int fh_type)
796{
797	struct dentry *dentry = NULL;
798	struct ovl_fh *fh = NULL;
799	int len = fh_len << 2;
800	unsigned int flags = 0;
801	int err;
802
803	fh = ovl_fid_to_fh(fid, len, fh_type);
804	err = PTR_ERR(fh);
805	if (IS_ERR(fh))
806		goto out_err;
807
808	err = ovl_check_fh_len(fh, len);
809	if (err)
810		goto out_err;
811
812	flags = fh->fb.flags;
813	dentry = (flags & OVL_FH_FLAG_PATH_UPPER) ?
814		 ovl_upper_fh_to_d(sb, fh) :
815		 ovl_lower_fh_to_d(sb, fh);
816	err = PTR_ERR(dentry);
817	if (IS_ERR(dentry) && err != -ESTALE)
818		goto out_err;
819
820out:
821	/* We may have needed to re-align OVL_FILEID_V0 */
822	if (!IS_ERR_OR_NULL(fh) && fh != (void *)fid)
823		kfree(fh);
824
825	return dentry;
826
827out_err:
828	pr_warn_ratelimited("failed to decode file handle (len=%d, type=%d, flags=%x, err=%i)\n",
829			    fh_len, fh_type, flags, err);
830	dentry = ERR_PTR(err);
831	goto out;
832}
833
834static struct dentry *ovl_fh_to_parent(struct super_block *sb, struct fid *fid,
835				       int fh_len, int fh_type)
836{
837	pr_warn_ratelimited("connectable file handles not supported; use 'no_subtree_check' exportfs option.\n");
838	return ERR_PTR(-EACCES);
839}
840
841static int ovl_get_name(struct dentry *parent, char *name,
842			struct dentry *child)
843{
844	/*
845	 * ovl_fh_to_dentry() returns connected dir overlay dentries and
846	 * ovl_fh_to_parent() is not implemented, so we should not get here.
847	 */
848	WARN_ON_ONCE(1);
849	return -EIO;
850}
851
852static struct dentry *ovl_get_parent(struct dentry *dentry)
853{
854	/*
855	 * ovl_fh_to_dentry() returns connected dir overlay dentries, so we
856	 * should not get here.
857	 */
858	WARN_ON_ONCE(1);
859	return ERR_PTR(-EIO);
860}
861
862const struct export_operations ovl_export_operations = {
863	.encode_fh	= ovl_encode_fh,
864	.fh_to_dentry	= ovl_fh_to_dentry,
865	.fh_to_parent	= ovl_fh_to_parent,
866	.get_name	= ovl_get_name,
867	.get_parent	= ovl_get_parent,
868};
869
870/* encode_fh() encodes non-decodable file handles with nfs_export=off */
871const struct export_operations ovl_export_fid_operations = {
872	.encode_fh	= ovl_encode_fh,
873};