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