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