1
2
3
4
5
6
7
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_want_write(dentry);
27 if (!err) {
28 err = ovl_copy_up(dentry);
29 ovl_drop_write(dentry);
30 }
31
32 if (err) {
33 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
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
77static int ovl_connectable_layer(struct dentry *dentry)
78{
79 struct ovl_entry *oe = OVL_E(dentry);
80
81
82 if (dentry == dentry->d_sb->s_root)
83 return oe->numlower;
84
85
86
87
88
89 if (ovl_dentry_upper(dentry) &&
90 !ovl_test_flag(OVL_INDEX, d_inode(dentry)))
91 return 0;
92
93
94 return oe->lowerstack[0].layer->idx;
95}
96
97
98
99
100
101
102
103
104
105static int ovl_connect_layer(struct dentry *dentry)
106{
107 struct dentry *next, *parent = NULL;
108 int origin_layer;
109 int err = 0;
110
111 if (WARN_ON(dentry == dentry->d_sb->s_root) ||
112 WARN_ON(!ovl_dentry_lower(dentry)))
113 return -EIO;
114
115 origin_layer = OVL_E(dentry)->lowerstack[0].layer->idx;
116 if (ovl_dentry_test_flag(OVL_E_CONNECTED, dentry))
117 return origin_layer;
118
119
120 next = dget(dentry);
121 for (;;) {
122 parent = dget_parent(next);
123 if (WARN_ON(parent == next)) {
124 err = -EIO;
125 break;
126 }
127
128
129
130
131
132 if (ovl_connectable_layer(parent) < origin_layer) {
133 err = ovl_encode_maybe_copy_up(next);
134 break;
135 }
136
137
138 if (ovl_dentry_test_flag(OVL_E_CONNECTED, parent) ||
139 ovl_test_flag(OVL_INDEX, d_inode(parent)))
140 break;
141
142 dput(next);
143 next = parent;
144 }
145
146 dput(parent);
147 dput(next);
148
149 if (!err)
150 ovl_dentry_set_flag(OVL_E_CONNECTED, dentry);
151
152 return err ?: origin_layer;
153}
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183static int ovl_check_encode_origin(struct dentry *dentry)
184{
185 struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
186
187
188 if (!ovl_dentry_lower(dentry))
189 return 0;
190
191
192
193
194
195
196
197 if (ovl_dentry_upper(dentry) &&
198 !ovl_test_flag(OVL_INDEX, d_inode(dentry)))
199 return 0;
200
201
202
203
204
205
206
207 if (d_is_dir(dentry) && ofs->upper_mnt)
208 return ovl_connect_layer(dentry);
209
210
211 return 1;
212}
213
214static 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
223
224 err = enc_lower = ovl_check_encode_origin(dentry);
225 if (enc_lower < 0)
226 goto fail;
227
228
229 fh = ovl_encode_real_fh(enc_lower ? ovl_dentry_lower(dentry) :
230 ovl_dentry_upper(dentry), !enc_lower);
231 if (IS_ERR(fh))
232 return PTR_ERR(fh);
233
234 err = -EOVERFLOW;
235 len = OVL_FH_LEN(fh);
236 if (len > buflen)
237 goto fail;
238
239 memcpy(fid, fh, len);
240 err = len;
241
242out:
243 kfree(fh);
244 return err;
245
246fail:
247 pr_warn_ratelimited("failed to encode file handle (%pd2, err=%i, buflen=%d, len=%d, type=%d)\n",
248 dentry, err, buflen, fh ? (int)fh->fb.len : 0,
249 fh ? fh->fb.type : 0);
250 goto out;
251}
252
253static int ovl_encode_fh(struct inode *inode, u32 *fid, int *max_len,
254 struct inode *parent)
255{
256 struct dentry *dentry;
257 int bytes = *max_len << 2;
258
259
260 if (parent)
261 return FILEID_INVALID;
262
263 dentry = d_find_any_alias(inode);
264 if (WARN_ON(!dentry))
265 return FILEID_INVALID;
266
267 bytes = ovl_dentry_to_fid(dentry, fid, bytes);
268 dput(dentry);
269 if (bytes <= 0)
270 return FILEID_INVALID;
271
272 *max_len = bytes >> 2;
273
274 return OVL_FILEID_V1;
275}
276
277
278
279
280static 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 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 struct ovl_inode_params oip = {
291 .lowerpath = lowerpath,
292 .index = index,
293 .numlower = !!lower
294 };
295
296
297 if (d_is_dir(upper ?: lower))
298 return ERR_PTR(-EIO);
299
300 oip.upperdentry = dget(upper);
301 inode = ovl_get_inode(sb, &oip);
302 if (IS_ERR(inode)) {
303 dput(upper);
304 return ERR_CAST(inode);
305 }
306
307 if (upper)
308 ovl_set_flag(OVL_UPPERDATA, inode);
309
310 dentry = d_find_any_alias(inode);
311 if (!dentry) {
312 dentry = d_alloc_anon(inode->i_sb);
313 if (!dentry)
314 goto nomem;
315 oe = ovl_alloc_entry(lower ? 1 : 0);
316 if (!oe)
317 goto nomem;
318
319 if (lower) {
320 oe->lowerstack->dentry = dget(lower);
321 oe->lowerstack->layer = lowerpath->layer;
322 }
323 dentry->d_fsdata = oe;
324 if (upper_alias)
325 ovl_dentry_set_upper_alias(dentry);
326 }
327
328 return d_instantiate_anon(dentry, inode);
329
330nomem:
331 iput(inode);
332 dput(dentry);
333 return ERR_PTR(-ENOMEM);
334}
335
336
337static struct dentry *ovl_dentry_real_at(struct dentry *dentry, int idx)
338{
339 struct ovl_entry *oe = dentry->d_fsdata;
340 int i;
341
342 if (!idx)
343 return ovl_dentry_upper(dentry);
344
345 for (i = 0; i < oe->numlower; i++) {
346 if (oe->lowerstack[i].layer->idx == idx)
347 return oe->lowerstack[i].dentry;
348 }
349
350 return NULL;
351}
352
353
354
355
356
357
358
359static struct dentry *ovl_lookup_real_one(struct dentry *connected,
360 struct dentry *real,
361 const struct ovl_layer *layer)
362{
363 struct inode *dir = d_inode(connected);
364 struct dentry *this, *parent = NULL;
365 struct name_snapshot name;
366 int err;
367
368
369
370
371
372
373
374
375 inode_lock_nested(dir, I_MUTEX_PARENT);
376 err = -ECHILD;
377 parent = dget_parent(real);
378 if (ovl_dentry_real_at(connected, layer->idx) != parent)
379 goto fail;
380
381
382
383
384
385
386
387 take_dentry_name_snapshot(&name, real);
388 this = lookup_one_len(name.name.name, connected, name.name.len);
389 err = PTR_ERR(this);
390 if (IS_ERR(this)) {
391 goto fail;
392 } else if (!this || !this->d_inode) {
393 dput(this);
394 err = -ENOENT;
395 goto fail;
396 } else if (ovl_dentry_real_at(this, layer->idx) != real) {
397 dput(this);
398 err = -ESTALE;
399 goto fail;
400 }
401
402out:
403 release_dentry_name_snapshot(&name);
404 dput(parent);
405 inode_unlock(dir);
406 return this;
407
408fail:
409 pr_warn_ratelimited("failed to lookup one by real (%pd2, layer=%d, connected=%pd2, err=%i)\n",
410 real, layer->idx, connected, err);
411 this = ERR_PTR(err);
412 goto out;
413}
414
415static struct dentry *ovl_lookup_real(struct super_block *sb,
416 struct dentry *real,
417 const struct ovl_layer *layer);
418
419
420
421
422static struct dentry *ovl_lookup_real_inode(struct super_block *sb,
423 struct dentry *real,
424 const struct ovl_layer *layer)
425{
426 struct ovl_fs *ofs = sb->s_fs_info;
427 struct dentry *index = NULL;
428 struct dentry *this = NULL;
429 struct inode *inode;
430
431
432
433
434
435 inode = ovl_lookup_inode(sb, real, !layer->idx);
436 if (IS_ERR(inode))
437 return ERR_CAST(inode);
438 if (inode) {
439 this = d_find_any_alias(inode);
440 iput(inode);
441 }
442
443
444
445
446
447 if (!this && layer->idx && ofs->indexdir && !WARN_ON(!d_is_dir(real))) {
448 index = ovl_lookup_index(ofs, NULL, real, false);
449 if (IS_ERR(index))
450 return index;
451 }
452
453
454 if (index) {
455 struct dentry *upper = ovl_index_upper(ofs, index);
456
457 dput(index);
458 if (IS_ERR_OR_NULL(upper))
459 return upper;
460
461
462
463
464
465
466
467
468 this = ovl_lookup_real(sb, upper, &ofs->layers[0]);
469 dput(upper);
470 }
471
472 if (IS_ERR_OR_NULL(this))
473 return this;
474
475 if (WARN_ON(ovl_dentry_real_at(this, layer->idx) != real)) {
476 dput(this);
477 this = ERR_PTR(-EIO);
478 }
479
480 return this;
481}
482
483
484
485
486
487static struct dentry *ovl_lookup_real_ancestor(struct super_block *sb,
488 struct dentry *real,
489 const struct ovl_layer *layer)
490{
491 struct dentry *next, *parent = NULL;
492 struct dentry *ancestor = ERR_PTR(-EIO);
493
494 if (real == layer->mnt->mnt_root)
495 return dget(sb->s_root);
496
497
498 next = dget(real);
499 for (;;) {
500 parent = dget_parent(next);
501
502
503
504
505
506 ancestor = ovl_lookup_real_inode(sb, next, layer);
507 if (ancestor)
508 break;
509
510 if (parent == layer->mnt->mnt_root) {
511 ancestor = dget(sb->s_root);
512 break;
513 }
514
515
516
517
518
519
520 if (parent == next) {
521 ancestor = ERR_PTR(-EXDEV);
522 break;
523 }
524
525 dput(next);
526 next = parent;
527 }
528
529 dput(parent);
530 dput(next);
531
532 return ancestor;
533}
534
535
536
537
538
539
540static struct dentry *ovl_lookup_real(struct super_block *sb,
541 struct dentry *real,
542 const struct ovl_layer *layer)
543{
544 struct dentry *connected;
545 int err = 0;
546
547 connected = ovl_lookup_real_ancestor(sb, real, layer);
548 if (IS_ERR(connected))
549 return connected;
550
551 while (!err) {
552 struct dentry *next, *this;
553 struct dentry *parent = NULL;
554 struct dentry *real_connected = ovl_dentry_real_at(connected,
555 layer->idx);
556
557 if (real_connected == real)
558 break;
559
560
561 next = dget(real);
562 for (;;) {
563 parent = dget_parent(next);
564
565 if (parent == real_connected)
566 break;
567
568
569
570
571
572
573
574
575
576 if (parent == layer->mnt->mnt_root) {
577 dput(connected);
578 connected = dget(sb->s_root);
579 break;
580 }
581
582
583
584
585
586
587
588 if (parent == next) {
589 err = -EXDEV;
590 break;
591 }
592
593 dput(next);
594 next = parent;
595 }
596
597 if (!err) {
598 this = ovl_lookup_real_one(connected, next, layer);
599 if (IS_ERR(this))
600 err = PTR_ERR(this);
601
602
603
604
605
606
607
608
609
610
611
612 if (err == -ECHILD) {
613 this = ovl_lookup_real_ancestor(sb, real,
614 layer);
615 err = PTR_ERR_OR_ZERO(this);
616 }
617 if (!err) {
618 dput(connected);
619 connected = this;
620 }
621 }
622
623 dput(parent);
624 dput(next);
625 }
626
627 if (err)
628 goto fail;
629
630 return connected;
631
632fail:
633 pr_warn_ratelimited("failed to lookup by real (%pd2, layer=%d, connected=%pd2, err=%i)\n",
634 real, layer->idx, connected, err);
635 dput(connected);
636 return ERR_PTR(err);
637}
638
639
640
641
642static struct dentry *ovl_get_dentry(struct super_block *sb,
643 struct dentry *upper,
644 struct ovl_path *lowerpath,
645 struct dentry *index)
646{
647 struct ovl_fs *ofs = sb->s_fs_info;
648 const struct ovl_layer *layer = upper ? &ofs->layers[0] : lowerpath->layer;
649 struct dentry *real = upper ?: (index ?: lowerpath->dentry);
650
651
652
653
654
655 if (!d_is_dir(real))
656 return ovl_obtain_alias(sb, upper, lowerpath, index);
657
658
659 if ((real->d_flags & DCACHE_DISCONNECTED) || d_unhashed(real))
660 return ERR_PTR(-ENOENT);
661
662
663
664
665
666 return ovl_lookup_real(sb, real, layer);
667}
668
669static struct dentry *ovl_upper_fh_to_d(struct super_block *sb,
670 struct ovl_fh *fh)
671{
672 struct ovl_fs *ofs = sb->s_fs_info;
673 struct dentry *dentry;
674 struct dentry *upper;
675
676 if (!ofs->upper_mnt)
677 return ERR_PTR(-EACCES);
678
679 upper = ovl_decode_real_fh(fh, ofs->upper_mnt, true);
680 if (IS_ERR_OR_NULL(upper))
681 return upper;
682
683 dentry = ovl_get_dentry(sb, upper, NULL, NULL);
684 dput(upper);
685
686 return dentry;
687}
688
689static struct dentry *ovl_lower_fh_to_d(struct super_block *sb,
690 struct ovl_fh *fh)
691{
692 struct ovl_fs *ofs = sb->s_fs_info;
693 struct ovl_path origin = { };
694 struct ovl_path *stack = &origin;
695 struct dentry *dentry = NULL;
696 struct dentry *index = NULL;
697 struct inode *inode;
698 int err;
699
700
701 err = ovl_check_origin_fh(ofs, fh, false, NULL, &stack);
702 if (err)
703 return ERR_PTR(err);
704
705 if (!d_is_dir(origin.dentry) ||
706 !(origin.dentry->d_flags & DCACHE_DISCONNECTED)) {
707 inode = ovl_lookup_inode(sb, origin.dentry, false);
708 err = PTR_ERR(inode);
709 if (IS_ERR(inode))
710 goto out_err;
711 if (inode) {
712 dentry = d_find_any_alias(inode);
713 iput(inode);
714 if (dentry)
715 goto out;
716 }
717 }
718
719
720 if (ofs->indexdir) {
721 index = ovl_get_index_fh(ofs, fh);
722 err = PTR_ERR(index);
723 if (IS_ERR(index)) {
724 index = NULL;
725 goto out_err;
726 }
727 }
728
729
730 if (index && d_is_dir(index)) {
731 struct dentry *upper = ovl_index_upper(ofs, index);
732
733 err = PTR_ERR(upper);
734 if (IS_ERR_OR_NULL(upper))
735 goto out_err;
736
737 dentry = ovl_get_dentry(sb, upper, NULL, NULL);
738 dput(upper);
739 goto out;
740 }
741
742
743 if (d_is_dir(origin.dentry)) {
744 dput(origin.dentry);
745 origin.dentry = NULL;
746 err = ovl_check_origin_fh(ofs, fh, true, NULL, &stack);
747 if (err)
748 goto out_err;
749 }
750 if (index) {
751 err = ovl_verify_origin(index, origin.dentry, false);
752 if (err)
753 goto out_err;
754 }
755
756
757 dentry = ovl_get_dentry(sb, NULL, &origin, index);
758
759out:
760 dput(origin.dentry);
761 dput(index);
762 return dentry;
763
764out_err:
765 dentry = ERR_PTR(err);
766 goto out;
767}
768
769static struct ovl_fh *ovl_fid_to_fh(struct fid *fid, int buflen, int fh_type)
770{
771 struct ovl_fh *fh;
772
773
774 if (fh_type == OVL_FILEID_V1)
775 return (struct ovl_fh *)fid;
776
777 if (fh_type != OVL_FILEID_V0)
778 return ERR_PTR(-EINVAL);
779
780 fh = kzalloc(buflen, GFP_KERNEL);
781 if (!fh)
782 return ERR_PTR(-ENOMEM);
783
784
785 memcpy(&fh->fb, fid, buflen - OVL_FH_WIRE_OFFSET);
786 return fh;
787}
788
789static struct dentry *ovl_fh_to_dentry(struct super_block *sb, struct fid *fid,
790 int fh_len, int fh_type)
791{
792 struct dentry *dentry = NULL;
793 struct ovl_fh *fh = NULL;
794 int len = fh_len << 2;
795 unsigned int flags = 0;
796 int err;
797
798 fh = ovl_fid_to_fh(fid, len, fh_type);
799 err = PTR_ERR(fh);
800 if (IS_ERR(fh))
801 goto out_err;
802
803 err = ovl_check_fh_len(fh, len);
804 if (err)
805 goto out_err;
806
807 flags = fh->fb.flags;
808 dentry = (flags & OVL_FH_FLAG_PATH_UPPER) ?
809 ovl_upper_fh_to_d(sb, fh) :
810 ovl_lower_fh_to_d(sb, fh);
811 err = PTR_ERR(dentry);
812 if (IS_ERR(dentry) && err != -ESTALE)
813 goto out_err;
814
815out:
816
817 if (!IS_ERR_OR_NULL(fh) && fh != (void *)fid)
818 kfree(fh);
819
820 return dentry;
821
822out_err:
823 pr_warn_ratelimited("failed to decode file handle (len=%d, type=%d, flags=%x, err=%i)\n",
824 fh_len, fh_type, flags, err);
825 dentry = ERR_PTR(err);
826 goto out;
827}
828
829static struct dentry *ovl_fh_to_parent(struct super_block *sb, struct fid *fid,
830 int fh_len, int fh_type)
831{
832 pr_warn_ratelimited("connectable file handles not supported; use 'no_subtree_check' exportfs option.\n");
833 return ERR_PTR(-EACCES);
834}
835
836static int ovl_get_name(struct dentry *parent, char *name,
837 struct dentry *child)
838{
839
840
841
842
843 WARN_ON_ONCE(1);
844 return -EIO;
845}
846
847static struct dentry *ovl_get_parent(struct dentry *dentry)
848{
849
850
851
852
853 WARN_ON_ONCE(1);
854 return ERR_PTR(-EIO);
855}
856
857const struct export_operations ovl_export_operations = {
858 .encode_fh = ovl_encode_fh,
859 .fh_to_dentry = ovl_fh_to_dentry,
860 .fh_to_parent = ovl_fh_to_parent,
861 .get_name = ovl_get_name,
862 .get_parent = ovl_get_parent,
863};
864