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) && ovl_upper_mnt(ofs))
208 return ovl_connect_layer(dentry);
209
210
211 return 1;
212}
213
214static int ovl_dentry_to_fid(struct ovl_fs *ofs, struct dentry *dentry,
215 u32 *fid, int buflen)
216{
217 struct ovl_fh *fh = NULL;
218 int err, enc_lower;
219 int len;
220
221
222
223
224
225 err = enc_lower = ovl_check_encode_origin(dentry);
226 if (enc_lower < 0)
227 goto fail;
228
229
230 fh = ovl_encode_real_fh(ofs, enc_lower ? ovl_dentry_lower(dentry) :
231 ovl_dentry_upper(dentry), !enc_lower);
232 if (IS_ERR(fh))
233 return PTR_ERR(fh);
234
235 len = OVL_FH_LEN(fh);
236 if (len <= buflen)
237 memcpy(fid, fh, len);
238 err = len;
239
240out:
241 kfree(fh);
242 return err;
243
244fail:
245 pr_warn_ratelimited("failed to encode file handle (%pd2, err=%i)\n",
246 dentry, err);
247 goto out;
248}
249
250static int ovl_encode_fh(struct inode *inode, u32 *fid, int *max_len,
251 struct inode *parent)
252{
253 struct ovl_fs *ofs = OVL_FS(inode->i_sb);
254 struct dentry *dentry;
255 int bytes, buflen = *max_len << 2;
256
257
258 if (parent)
259 return FILEID_INVALID;
260
261 dentry = d_find_any_alias(inode);
262 if (WARN_ON(!dentry))
263 return FILEID_INVALID;
264
265 bytes = ovl_dentry_to_fid(ofs, dentry, fid, buflen);
266 dput(dentry);
267 if (bytes <= 0)
268 return FILEID_INVALID;
269
270 *max_len = bytes >> 2;
271 if (bytes > buflen)
272 return FILEID_INVALID;
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 goto out_iput;
313
314 dentry = d_alloc_anon(inode->i_sb);
315 if (unlikely(!dentry))
316 goto nomem;
317 oe = ovl_alloc_entry(lower ? 1 : 0);
318 if (!oe)
319 goto nomem;
320
321 if (lower) {
322 oe->lowerstack->dentry = dget(lower);
323 oe->lowerstack->layer = lowerpath->layer;
324 }
325 dentry->d_fsdata = oe;
326 if (upper_alias)
327 ovl_dentry_set_upper_alias(dentry);
328
329 ovl_dentry_update_reval(dentry, upper,
330 DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE);
331
332 return d_instantiate_anon(dentry, inode);
333
334nomem:
335 dput(dentry);
336 dentry = ERR_PTR(-ENOMEM);
337out_iput:
338 iput(inode);
339 return dentry;
340}
341
342
343static struct dentry *ovl_dentry_real_at(struct dentry *dentry, int idx)
344{
345 struct ovl_entry *oe = dentry->d_fsdata;
346 int i;
347
348 if (!idx)
349 return ovl_dentry_upper(dentry);
350
351 for (i = 0; i < oe->numlower; i++) {
352 if (oe->lowerstack[i].layer->idx == idx)
353 return oe->lowerstack[i].dentry;
354 }
355
356 return NULL;
357}
358
359
360
361
362
363
364
365static struct dentry *ovl_lookup_real_one(struct dentry *connected,
366 struct dentry *real,
367 const struct ovl_layer *layer)
368{
369 struct inode *dir = d_inode(connected);
370 struct dentry *this, *parent = NULL;
371 struct name_snapshot name;
372 int err;
373
374
375
376
377
378
379
380
381 inode_lock_nested(dir, I_MUTEX_PARENT);
382 err = -ECHILD;
383 parent = dget_parent(real);
384 if (ovl_dentry_real_at(connected, layer->idx) != parent)
385 goto fail;
386
387
388
389
390
391
392
393 take_dentry_name_snapshot(&name, real);
394 this = lookup_one_len(name.name.name, connected, name.name.len);
395 release_dentry_name_snapshot(&name);
396 err = PTR_ERR(this);
397 if (IS_ERR(this)) {
398 goto fail;
399 } else if (!this || !this->d_inode) {
400 dput(this);
401 err = -ENOENT;
402 goto fail;
403 } else if (ovl_dentry_real_at(this, layer->idx) != real) {
404 dput(this);
405 err = -ESTALE;
406 goto fail;
407 }
408
409out:
410 dput(parent);
411 inode_unlock(dir);
412 return this;
413
414fail:
415 pr_warn_ratelimited("failed to lookup one by real (%pd2, layer=%d, connected=%pd2, err=%i)\n",
416 real, layer->idx, connected, err);
417 this = ERR_PTR(err);
418 goto out;
419}
420
421static struct dentry *ovl_lookup_real(struct super_block *sb,
422 struct dentry *real,
423 const struct ovl_layer *layer);
424
425
426
427
428static struct dentry *ovl_lookup_real_inode(struct super_block *sb,
429 struct dentry *real,
430 const struct ovl_layer *layer)
431{
432 struct ovl_fs *ofs = sb->s_fs_info;
433 struct dentry *index = NULL;
434 struct dentry *this = NULL;
435 struct inode *inode;
436
437
438
439
440
441 inode = ovl_lookup_inode(sb, real, !layer->idx);
442 if (IS_ERR(inode))
443 return ERR_CAST(inode);
444 if (inode) {
445 this = d_find_any_alias(inode);
446 iput(inode);
447 }
448
449
450
451
452
453 if (!this && layer->idx && ofs->indexdir && !WARN_ON(!d_is_dir(real))) {
454 index = ovl_lookup_index(ofs, NULL, real, false);
455 if (IS_ERR(index))
456 return index;
457 }
458
459
460 if (index) {
461 struct dentry *upper = ovl_index_upper(ofs, index);
462
463 dput(index);
464 if (IS_ERR_OR_NULL(upper))
465 return upper;
466
467
468
469
470
471
472
473
474 this = ovl_lookup_real(sb, upper, &ofs->layers[0]);
475 dput(upper);
476 }
477
478 if (IS_ERR_OR_NULL(this))
479 return this;
480
481 if (ovl_dentry_real_at(this, layer->idx) != real) {
482 dput(this);
483 this = ERR_PTR(-EIO);
484 }
485
486 return this;
487}
488
489
490
491
492
493static struct dentry *ovl_lookup_real_ancestor(struct super_block *sb,
494 struct dentry *real,
495 const struct ovl_layer *layer)
496{
497 struct dentry *next, *parent = NULL;
498 struct dentry *ancestor = ERR_PTR(-EIO);
499
500 if (real == layer->mnt->mnt_root)
501 return dget(sb->s_root);
502
503
504 next = dget(real);
505 for (;;) {
506 parent = dget_parent(next);
507
508
509
510
511
512 ancestor = ovl_lookup_real_inode(sb, next, layer);
513 if (ancestor)
514 break;
515
516 if (parent == layer->mnt->mnt_root) {
517 ancestor = dget(sb->s_root);
518 break;
519 }
520
521
522
523
524
525
526 if (parent == next) {
527 ancestor = ERR_PTR(-EXDEV);
528 break;
529 }
530
531 dput(next);
532 next = parent;
533 }
534
535 dput(parent);
536 dput(next);
537
538 return ancestor;
539}
540
541
542
543
544
545
546static struct dentry *ovl_lookup_real(struct super_block *sb,
547 struct dentry *real,
548 const struct ovl_layer *layer)
549{
550 struct dentry *connected;
551 int err = 0;
552
553 connected = ovl_lookup_real_ancestor(sb, real, layer);
554 if (IS_ERR(connected))
555 return connected;
556
557 while (!err) {
558 struct dentry *next, *this;
559 struct dentry *parent = NULL;
560 struct dentry *real_connected = ovl_dentry_real_at(connected,
561 layer->idx);
562
563 if (real_connected == real)
564 break;
565
566
567 next = dget(real);
568 for (;;) {
569 parent = dget_parent(next);
570
571 if (parent == real_connected)
572 break;
573
574
575
576
577
578
579
580
581
582 if (parent == layer->mnt->mnt_root) {
583 dput(connected);
584 connected = dget(sb->s_root);
585 break;
586 }
587
588
589
590
591
592
593
594 if (parent == next) {
595 err = -EXDEV;
596 break;
597 }
598
599 dput(next);
600 next = parent;
601 }
602
603 if (!err) {
604 this = ovl_lookup_real_one(connected, next, layer);
605 if (IS_ERR(this))
606 err = PTR_ERR(this);
607
608
609
610
611
612
613
614
615
616
617
618 if (err == -ECHILD) {
619 this = ovl_lookup_real_ancestor(sb, real,
620 layer);
621 err = PTR_ERR_OR_ZERO(this);
622 }
623 if (!err) {
624 dput(connected);
625 connected = this;
626 }
627 }
628
629 dput(parent);
630 dput(next);
631 }
632
633 if (err)
634 goto fail;
635
636 return connected;
637
638fail:
639 pr_warn_ratelimited("failed to lookup by real (%pd2, layer=%d, connected=%pd2, err=%i)\n",
640 real, layer->idx, connected, err);
641 dput(connected);
642 return ERR_PTR(err);
643}
644
645
646
647
648static struct dentry *ovl_get_dentry(struct super_block *sb,
649 struct dentry *upper,
650 struct ovl_path *lowerpath,
651 struct dentry *index)
652{
653 struct ovl_fs *ofs = sb->s_fs_info;
654 const struct ovl_layer *layer = upper ? &ofs->layers[0] : lowerpath->layer;
655 struct dentry *real = upper ?: (index ?: lowerpath->dentry);
656
657
658
659
660
661 if (!d_is_dir(real))
662 return ovl_obtain_alias(sb, upper, lowerpath, index);
663
664
665 if ((real->d_flags & DCACHE_DISCONNECTED) || d_unhashed(real))
666 return ERR_PTR(-ENOENT);
667
668
669
670
671
672 return ovl_lookup_real(sb, real, layer);
673}
674
675static struct dentry *ovl_upper_fh_to_d(struct super_block *sb,
676 struct ovl_fh *fh)
677{
678 struct ovl_fs *ofs = sb->s_fs_info;
679 struct dentry *dentry;
680 struct dentry *upper;
681
682 if (!ovl_upper_mnt(ofs))
683 return ERR_PTR(-EACCES);
684
685 upper = ovl_decode_real_fh(ofs, fh, ovl_upper_mnt(ofs), true);
686 if (IS_ERR_OR_NULL(upper))
687 return upper;
688
689 dentry = ovl_get_dentry(sb, upper, NULL, NULL);
690 dput(upper);
691
692 return dentry;
693}
694
695static struct dentry *ovl_lower_fh_to_d(struct super_block *sb,
696 struct ovl_fh *fh)
697{
698 struct ovl_fs *ofs = sb->s_fs_info;
699 struct ovl_path origin = { };
700 struct ovl_path *stack = &origin;
701 struct dentry *dentry = NULL;
702 struct dentry *index = NULL;
703 struct inode *inode;
704 int err;
705
706
707 err = ovl_check_origin_fh(ofs, fh, false, NULL, &stack);
708 if (err)
709 return ERR_PTR(err);
710
711 if (!d_is_dir(origin.dentry) ||
712 !(origin.dentry->d_flags & DCACHE_DISCONNECTED)) {
713 inode = ovl_lookup_inode(sb, origin.dentry, false);
714 err = PTR_ERR(inode);
715 if (IS_ERR(inode))
716 goto out_err;
717 if (inode) {
718 dentry = d_find_any_alias(inode);
719 iput(inode);
720 if (dentry)
721 goto out;
722 }
723 }
724
725
726 if (ofs->indexdir) {
727 index = ovl_get_index_fh(ofs, fh);
728 err = PTR_ERR(index);
729 if (IS_ERR(index)) {
730 index = NULL;
731 goto out_err;
732 }
733 }
734
735
736 if (index && d_is_dir(index)) {
737 struct dentry *upper = ovl_index_upper(ofs, index);
738
739 err = PTR_ERR(upper);
740 if (IS_ERR_OR_NULL(upper))
741 goto out_err;
742
743 dentry = ovl_get_dentry(sb, upper, NULL, NULL);
744 dput(upper);
745 goto out;
746 }
747
748
749 if (d_is_dir(origin.dentry)) {
750 dput(origin.dentry);
751 origin.dentry = NULL;
752 err = ovl_check_origin_fh(ofs, fh, true, NULL, &stack);
753 if (err)
754 goto out_err;
755 }
756 if (index) {
757 err = ovl_verify_origin(ofs, index, origin.dentry, false);
758 if (err)
759 goto out_err;
760 }
761
762
763 dentry = ovl_get_dentry(sb, NULL, &origin, index);
764
765out:
766 dput(origin.dentry);
767 dput(index);
768 return dentry;
769
770out_err:
771 dentry = ERR_PTR(err);
772 goto out;
773}
774
775static struct ovl_fh *ovl_fid_to_fh(struct fid *fid, int buflen, int fh_type)
776{
777 struct ovl_fh *fh;
778
779
780 if (fh_type == OVL_FILEID_V1)
781 return (struct ovl_fh *)fid;
782
783 if (fh_type != OVL_FILEID_V0)
784 return ERR_PTR(-EINVAL);
785
786 if (buflen <= OVL_FH_WIRE_OFFSET)
787 return ERR_PTR(-EINVAL);
788
789 fh = kzalloc(buflen, GFP_KERNEL);
790 if (!fh)
791 return ERR_PTR(-ENOMEM);
792
793
794 memcpy(&fh->fb, fid, buflen - OVL_FH_WIRE_OFFSET);
795 return fh;
796}
797
798static struct dentry *ovl_fh_to_dentry(struct super_block *sb, struct fid *fid,
799 int fh_len, int fh_type)
800{
801 struct dentry *dentry = NULL;
802 struct ovl_fh *fh = NULL;
803 int len = fh_len << 2;
804 unsigned int flags = 0;
805 int err;
806
807 fh = ovl_fid_to_fh(fid, len, fh_type);
808 err = PTR_ERR(fh);
809 if (IS_ERR(fh))
810 goto out_err;
811
812 err = ovl_check_fh_len(fh, len);
813 if (err)
814 goto out_err;
815
816 flags = fh->fb.flags;
817 dentry = (flags & OVL_FH_FLAG_PATH_UPPER) ?
818 ovl_upper_fh_to_d(sb, fh) :
819 ovl_lower_fh_to_d(sb, fh);
820 err = PTR_ERR(dentry);
821 if (IS_ERR(dentry) && err != -ESTALE)
822 goto out_err;
823
824out:
825
826 if (!IS_ERR_OR_NULL(fh) && fh != (void *)fid)
827 kfree(fh);
828
829 return dentry;
830
831out_err:
832 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 dentry = ERR_PTR(err);
835 goto out;
836}
837
838static struct dentry *ovl_fh_to_parent(struct super_block *sb, struct fid *fid,
839 int fh_len, int fh_type)
840{
841 pr_warn_ratelimited("connectable file handles not supported; use 'no_subtree_check' exportfs option.\n");
842 return ERR_PTR(-EACCES);
843}
844
845static int ovl_get_name(struct dentry *parent, char *name,
846 struct dentry *child)
847{
848
849
850
851
852 WARN_ON_ONCE(1);
853 return -EIO;
854}
855
856static struct dentry *ovl_get_parent(struct dentry *dentry)
857{
858
859
860
861
862 WARN_ON_ONCE(1);
863 return ERR_PTR(-EIO);
864}
865
866const 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};
873