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.  Could skip
389	 * permission checking altogether, but for now just use non-idmap
390	 * transformed ids.
391	 */
392	this = lookup_one_len(name.name.name, connected, name.name.len);
393	release_dentry_name_snapshot(&name);
394	err = PTR_ERR(this);
395	if (IS_ERR(this)) {
396		goto fail;
397	} else if (!this || !this->d_inode) {
398		dput(this);
399		err = -ENOENT;
400		goto fail;
401	} else if (ovl_dentry_real_at(this, layer->idx) != real) {
402		dput(this);
403		err = -ESTALE;
404		goto fail;
405	}
406
407out:
 
408	dput(parent);
409	inode_unlock(dir);
410	return this;
411
412fail:
413	pr_warn_ratelimited("failed to lookup one by real (%pd2, layer=%d, connected=%pd2, err=%i)\n",
414			    real, layer->idx, connected, err);
415	this = ERR_PTR(err);
416	goto out;
417}
418
419static struct dentry *ovl_lookup_real(struct super_block *sb,
420				      struct dentry *real,
421				      const struct ovl_layer *layer);
422
423/*
424 * Lookup an indexed or hashed overlay dentry by real inode.
425 */
426static struct dentry *ovl_lookup_real_inode(struct super_block *sb,
427					    struct dentry *real,
428					    const struct ovl_layer *layer)
429{
430	struct ovl_fs *ofs = OVL_FS(sb);
 
431	struct dentry *index = NULL;
432	struct dentry *this = NULL;
433	struct inode *inode;
434
435	/*
436	 * Decoding upper dir from index is expensive, so first try to lookup
437	 * overlay dentry in inode/dcache.
438	 */
439	inode = ovl_lookup_inode(sb, real, !layer->idx);
440	if (IS_ERR(inode))
441		return ERR_CAST(inode);
442	if (inode) {
443		this = d_find_any_alias(inode);
444		iput(inode);
445	}
446
447	/*
448	 * For decoded lower dir file handle, lookup index by origin to check
449	 * if lower dir was copied up and and/or removed.
450	 */
451	if (!this && layer->idx && ovl_indexdir(sb) && !WARN_ON(!d_is_dir(real))) {
452		index = ovl_lookup_index(ofs, NULL, real, false);
453		if (IS_ERR(index))
454			return index;
455	}
456
457	/* Get connected upper overlay dir from index */
458	if (index) {
459		struct dentry *upper = ovl_index_upper(ofs, index, true);
460
461		dput(index);
462		if (IS_ERR_OR_NULL(upper))
463			return upper;
464
465		/*
466		 * ovl_lookup_real() in lower layer may call recursively once to
467		 * ovl_lookup_real() in upper layer. The first level call walks
468		 * back lower parents to the topmost indexed parent. The second
469		 * recursive call walks back from indexed upper to the topmost
470		 * connected/hashed upper parent (or up to root).
471		 */
472		this = ovl_lookup_real(sb, upper, &ofs->layers[0]);
473		dput(upper);
474	}
475
476	if (IS_ERR_OR_NULL(this))
477		return this;
478
479	if (ovl_dentry_real_at(this, layer->idx) != real) {
480		dput(this);
481		this = ERR_PTR(-EIO);
482	}
483
484	return this;
485}
486
487/*
488 * Lookup an indexed or hashed overlay dentry, whose real dentry is an
489 * ancestor of @real.
490 */
491static struct dentry *ovl_lookup_real_ancestor(struct super_block *sb,
492					       struct dentry *real,
493					       const struct ovl_layer *layer)
494{
495	struct dentry *next, *parent = NULL;
496	struct dentry *ancestor = ERR_PTR(-EIO);
497
498	if (real == layer->mnt->mnt_root)
499		return dget(sb->s_root);
500
501	/* Find the topmost indexed or hashed ancestor */
502	next = dget(real);
503	for (;;) {
504		parent = dget_parent(next);
505
506		/*
507		 * Lookup a matching overlay dentry in inode/dentry
508		 * cache or in index by real inode.
509		 */
510		ancestor = ovl_lookup_real_inode(sb, next, layer);
511		if (ancestor)
512			break;
513
514		if (parent == layer->mnt->mnt_root) {
515			ancestor = dget(sb->s_root);
516			break;
517		}
518
519		/*
520		 * If @real has been moved out of the layer root directory,
521		 * we will eventully hit the real fs root. This cannot happen
522		 * by legit overlay rename, so we return error in that case.
523		 */
524		if (parent == next) {
525			ancestor = ERR_PTR(-EXDEV);
526			break;
527		}
528
529		dput(next);
530		next = parent;
531	}
532
533	dput(parent);
534	dput(next);
535
536	return ancestor;
537}
538
539/*
540 * Lookup a connected overlay dentry whose real dentry is @real.
541 * If @real is on upper layer, we lookup a child overlay dentry with the same
542 * path the real dentry. Otherwise, we need to consult index for lookup.
543 */
544static struct dentry *ovl_lookup_real(struct super_block *sb,
545				      struct dentry *real,
546				      const struct ovl_layer *layer)
547{
548	struct dentry *connected;
549	int err = 0;
550
551	connected = ovl_lookup_real_ancestor(sb, real, layer);
552	if (IS_ERR(connected))
553		return connected;
554
555	while (!err) {
556		struct dentry *next, *this;
557		struct dentry *parent = NULL;
558		struct dentry *real_connected = ovl_dentry_real_at(connected,
559								   layer->idx);
560
561		if (real_connected == real)
562			break;
563
564		/* Find the topmost dentry not yet connected */
565		next = dget(real);
566		for (;;) {
567			parent = dget_parent(next);
568
569			if (parent == real_connected)
570				break;
571
572			/*
573			 * If real has been moved out of 'real_connected',
574			 * we will not find 'real_connected' and hit the layer
575			 * root. In that case, we need to restart connecting.
576			 * This game can go on forever in the worst case. We
577			 * may want to consider taking s_vfs_rename_mutex if
578			 * this happens more than once.
579			 */
580			if (parent == layer->mnt->mnt_root) {
581				dput(connected);
582				connected = dget(sb->s_root);
583				break;
584			}
585
586			/*
587			 * If real file has been moved out of the layer root
588			 * directory, we will eventully hit the real fs root.
589			 * This cannot happen by legit overlay rename, so we
590			 * return error in that case.
591			 */
592			if (parent == next) {
593				err = -EXDEV;
594				break;
595			}
596
597			dput(next);
598			next = parent;
599		}
600
601		if (!err) {
602			this = ovl_lookup_real_one(connected, next, layer);
603			if (IS_ERR(this))
604				err = PTR_ERR(this);
605
606			/*
607			 * Lookup of child in overlay can fail when racing with
608			 * overlay rename of child away from 'connected' parent.
609			 * In this case, we need to restart the lookup from the
610			 * top, because we cannot trust that 'real_connected' is
611			 * still an ancestor of 'real'. There is a good chance
612			 * that the renamed overlay ancestor is now in cache, so
613			 * ovl_lookup_real_ancestor() will find it and we can
614			 * continue to connect exactly from where lookup failed.
615			 */
616			if (err == -ECHILD) {
617				this = ovl_lookup_real_ancestor(sb, real,
618								layer);
619				err = PTR_ERR_OR_ZERO(this);
620			}
621			if (!err) {
622				dput(connected);
623				connected = this;
624			}
625		}
626
627		dput(parent);
628		dput(next);
629	}
630
631	if (err)
632		goto fail;
633
634	return connected;
635
636fail:
637	pr_warn_ratelimited("failed to lookup by real (%pd2, layer=%d, connected=%pd2, err=%i)\n",
638			    real, layer->idx, connected, err);
639	dput(connected);
640	return ERR_PTR(err);
641}
642
643/*
644 * Get an overlay dentry from upper/lower real dentries and index.
645 */
646static struct dentry *ovl_get_dentry(struct super_block *sb,
647				     struct dentry *upper,
648				     struct ovl_path *lowerpath,
649				     struct dentry *index)
650{
651	struct ovl_fs *ofs = OVL_FS(sb);
652	const struct ovl_layer *layer = upper ? &ofs->layers[0] : lowerpath->layer;
 
653	struct dentry *real = upper ?: (index ?: lowerpath->dentry);
654
655	/*
656	 * Obtain a disconnected overlay dentry from a non-dir real dentry
657	 * and index.
658	 */
659	if (!d_is_dir(real))
660		return ovl_obtain_alias(sb, upper, lowerpath, index);
661
662	/* Removed empty directory? */
663	if ((real->d_flags & DCACHE_DISCONNECTED) || d_unhashed(real))
664		return ERR_PTR(-ENOENT);
665
666	/*
667	 * If real dentry is connected and hashed, get a connected overlay
668	 * dentry whose real dentry is @real.
669	 */
670	return ovl_lookup_real(sb, real, layer);
671}
672
673static struct dentry *ovl_upper_fh_to_d(struct super_block *sb,
674					struct ovl_fh *fh)
675{
676	struct ovl_fs *ofs = OVL_FS(sb);
677	struct dentry *dentry;
678	struct dentry *upper;
679
680	if (!ovl_upper_mnt(ofs))
681		return ERR_PTR(-EACCES);
682
683	upper = ovl_decode_real_fh(ofs, fh, ovl_upper_mnt(ofs), true);
684	if (IS_ERR_OR_NULL(upper))
685		return upper;
686
687	dentry = ovl_get_dentry(sb, upper, NULL, NULL);
688	dput(upper);
689
690	return dentry;
691}
692
693static struct dentry *ovl_lower_fh_to_d(struct super_block *sb,
694					struct ovl_fh *fh)
695{
696	struct ovl_fs *ofs = OVL_FS(sb);
697	struct ovl_path origin = { };
698	struct ovl_path *stack = &origin;
699	struct dentry *dentry = NULL;
700	struct dentry *index = NULL;
701	struct inode *inode;
702	int err;
703
704	/* First lookup overlay inode in inode cache by origin fh */
705	err = ovl_check_origin_fh(ofs, fh, false, NULL, &stack);
706	if (err)
707		return ERR_PTR(err);
708
709	if (!d_is_dir(origin.dentry) ||
710	    !(origin.dentry->d_flags & DCACHE_DISCONNECTED)) {
711		inode = ovl_lookup_inode(sb, origin.dentry, false);
712		err = PTR_ERR(inode);
713		if (IS_ERR(inode))
714			goto out_err;
715		if (inode) {
716			dentry = d_find_any_alias(inode);
717			iput(inode);
718			if (dentry)
719				goto out;
720		}
721	}
722
723	/* Then lookup indexed upper/whiteout by origin fh */
724	if (ovl_indexdir(sb)) {
725		index = ovl_get_index_fh(ofs, fh);
726		err = PTR_ERR(index);
727		if (IS_ERR(index)) {
728			index = NULL;
729			goto out_err;
730		}
731	}
732
733	/* Then try to get a connected upper dir by index */
734	if (index && d_is_dir(index)) {
735		struct dentry *upper = ovl_index_upper(ofs, index, true);
736
737		err = PTR_ERR(upper);
738		if (IS_ERR_OR_NULL(upper))
739			goto out_err;
740
741		dentry = ovl_get_dentry(sb, upper, NULL, NULL);
742		dput(upper);
743		goto out;
744	}
745
746	/* Find origin.dentry again with ovl_acceptable() layer check */
747	if (d_is_dir(origin.dentry)) {
748		dput(origin.dentry);
749		origin.dentry = NULL;
750		err = ovl_check_origin_fh(ofs, fh, true, NULL, &stack);
751		if (err)
752			goto out_err;
753	}
754	if (index) {
755		err = ovl_verify_origin(ofs, index, origin.dentry, false);
756		if (err)
757			goto out_err;
758	}
759
760	/* Get a connected non-upper dir or disconnected non-dir */
761	dentry = ovl_get_dentry(sb, NULL, &origin, index);
762
763out:
764	dput(origin.dentry);
765	dput(index);
766	return dentry;
767
768out_err:
769	dentry = ERR_PTR(err);
770	goto out;
771}
772
773static struct ovl_fh *ovl_fid_to_fh(struct fid *fid, int buflen, int fh_type)
774{
775	struct ovl_fh *fh;
776
777	/* If on-wire inner fid is aligned - nothing to do */
778	if (fh_type == OVL_FILEID_V1)
779		return (struct ovl_fh *)fid;
780
781	if (fh_type != OVL_FILEID_V0)
782		return ERR_PTR(-EINVAL);
783
784	if (buflen <= OVL_FH_WIRE_OFFSET)
785		return ERR_PTR(-EINVAL);
786
787	fh = kzalloc(buflen, GFP_KERNEL);
788	if (!fh)
789		return ERR_PTR(-ENOMEM);
790
791	/* Copy unaligned inner fh into aligned buffer */
792	memcpy(fh->buf, fid, buflen - OVL_FH_WIRE_OFFSET);
793	return fh;
794}
795
796static struct dentry *ovl_fh_to_dentry(struct super_block *sb, struct fid *fid,
797				       int fh_len, int fh_type)
798{
799	struct dentry *dentry = NULL;
800	struct ovl_fh *fh = NULL;
801	int len = fh_len << 2;
802	unsigned int flags = 0;
803	int err;
804
805	fh = ovl_fid_to_fh(fid, len, fh_type);
806	err = PTR_ERR(fh);
807	if (IS_ERR(fh))
808		goto out_err;
809
810	err = ovl_check_fh_len(fh, len);
811	if (err)
812		goto out_err;
813
814	flags = fh->fb.flags;
815	dentry = (flags & OVL_FH_FLAG_PATH_UPPER) ?
816		 ovl_upper_fh_to_d(sb, fh) :
817		 ovl_lower_fh_to_d(sb, fh);
818	err = PTR_ERR(dentry);
819	if (IS_ERR(dentry) && err != -ESTALE)
820		goto out_err;
821
822out:
823	/* We may have needed to re-align OVL_FILEID_V0 */
824	if (!IS_ERR_OR_NULL(fh) && fh != (void *)fid)
825		kfree(fh);
826
827	return dentry;
828
829out_err:
830	pr_warn_ratelimited("failed to decode file handle (len=%d, type=%d, flags=%x, err=%i)\n",
831			    fh_len, fh_type, flags, err);
832	dentry = ERR_PTR(err);
833	goto out;
834}
835
836static struct dentry *ovl_fh_to_parent(struct super_block *sb, struct fid *fid,
837				       int fh_len, int fh_type)
838{
839	pr_warn_ratelimited("connectable file handles not supported; use 'no_subtree_check' exportfs option.\n");
840	return ERR_PTR(-EACCES);
841}
842
843static int ovl_get_name(struct dentry *parent, char *name,
844			struct dentry *child)
845{
846	/*
847	 * ovl_fh_to_dentry() returns connected dir overlay dentries and
848	 * ovl_fh_to_parent() is not implemented, so we should not get here.
849	 */
850	WARN_ON_ONCE(1);
851	return -EIO;
852}
853
854static struct dentry *ovl_get_parent(struct dentry *dentry)
855{
856	/*
857	 * ovl_fh_to_dentry() returns connected dir overlay dentries, so we
858	 * should not get here.
859	 */
860	WARN_ON_ONCE(1);
861	return ERR_PTR(-EIO);
862}
863
864const struct export_operations ovl_export_operations = {
865	.encode_fh	= ovl_encode_fh,
866	.fh_to_dentry	= ovl_fh_to_dentry,
867	.fh_to_parent	= ovl_fh_to_parent,
868	.get_name	= ovl_get_name,
869	.get_parent	= ovl_get_parent,
870};
871
872/* encode_fh() encodes non-decodable file handles with nfs_export=off */
873const struct export_operations ovl_export_fid_operations = {
874	.encode_fh	= ovl_encode_fh,
875};