1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 *
4 * Copyright (C) 2011 Novell Inc.
5 */
6
7 #include <linux/module.h>
8 #include <linux/fs.h>
9 #include <linux/slab.h>
10 #include <linux/file.h>
11 #include <linux/splice.h>
12 #include <linux/xattr.h>
13 #include <linux/security.h>
14 #include <linux/uaccess.h>
15 #include <linux/sched/signal.h>
16 #include <linux/cred.h>
17 #include <linux/namei.h>
18 #include <linux/fdtable.h>
19 #include <linux/ratelimit.h>
20 #include <linux/exportfs.h>
21 #include "overlayfs.h"
22
23 #define OVL_COPY_UP_CHUNK_SIZE (1 << 20)
24
25 static int ovl_ccup_set(const char *buf, const struct kernel_param *param)
26 {
27 pr_warn("overlayfs: \"check_copy_up\" module option is obsolete\n");
28 return 0;
29 }
30
31 static int ovl_ccup_get(char *buf, const struct kernel_param *param)
32 {
33 return sprintf(buf, "N\n");
34 }
35
36 module_param_call(check_copy_up, ovl_ccup_set, ovl_ccup_get, NULL, 0644);
37 MODULE_PARM_DESC(check_copy_up, "Obsolete; does nothing");
38
39 int ovl_copy_xattr(struct dentry *old, struct dentry *new)
40 {
41 ssize_t list_size, size, value_size = 0;
42 char *buf, *name, *value = NULL;
43 int uninitialized_var(error);
44 size_t slen;
45
46 if (!(old->d_inode->i_opflags & IOP_XATTR) ||
47 !(new->d_inode->i_opflags & IOP_XATTR))
48 return 0;
49
50 list_size = vfs_listxattr(old, NULL, 0);
51 if (list_size <= 0) {
52 if (list_size == -EOPNOTSUPP)
53 return 0;
54 return list_size;
55 }
56
57 buf = kzalloc(list_size, GFP_KERNEL);
58 if (!buf)
59 return -ENOMEM;
60
61 list_size = vfs_listxattr(old, buf, list_size);
62 if (list_size <= 0) {
63 error = list_size;
64 goto out;
65 }
66
67 for (name = buf; list_size; name += slen) {
68 slen = strnlen(name, list_size) + 1;
69
70 /* underlying fs providing us with an broken xattr list? */
71 if (WARN_ON(slen > list_size)) {
72 error = -EIO;
73 break;
74 }
75 list_size -= slen;
76
77 if (ovl_is_private_xattr(name))
78 continue;
79 retry:
80 size = vfs_getxattr(old, name, value, value_size);
81 if (size == -ERANGE)
82 size = vfs_getxattr(old, name, NULL, 0);
83
84 if (size < 0) {
85 error = size;
86 break;
87 }
88
89 if (size > value_size) {
90 void *new;
91
92 new = krealloc(value, size, GFP_KERNEL);
93 if (!new) {
94 error = -ENOMEM;
95 break;
96 }
97 value = new;
98 value_size = size;
99 goto retry;
100 }
101
102 error = security_inode_copy_up_xattr(name);
103 if (error < 0 && error != -EOPNOTSUPP)
104 break;
105 if (error == 1) {
106 error = 0;
107 continue; /* Discard */
108 }
109 error = vfs_setxattr(new, name, value, size, 0);
110 if (error)
111 break;
112 }
113 kfree(value);
114 out:
115 kfree(buf);
116 return error;
117 }
118
119 static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len)
120 {
121 struct file *old_file;
122 struct file *new_file;
123 loff_t old_pos = 0;
124 loff_t new_pos = 0;
125 loff_t cloned;
126 int error = 0;
127
128 if (len == 0)
129 return 0;
130
131 old_file = ovl_path_open(old, O_LARGEFILE | O_RDONLY);
132 if (IS_ERR(old_file))
133 return PTR_ERR(old_file);
134
135 new_file = ovl_path_open(new, O_LARGEFILE | O_WRONLY);
136 if (IS_ERR(new_file)) {
137 error = PTR_ERR(new_file);
138 goto out_fput;
139 }
140
141 /* Try to use clone_file_range to clone up within the same fs */
142 cloned = do_clone_file_range(old_file, 0, new_file, 0, len, 0);
143 if (cloned == len)
144 goto out;
145 /* Couldn't clone, so now we try to copy the data */
146
147 /* FIXME: copy up sparse files efficiently */
148 while (len) {
149 size_t this_len = OVL_COPY_UP_CHUNK_SIZE;
150 long bytes;
151
152 if (len < this_len)
153 this_len = len;
154
155 if (signal_pending_state(TASK_KILLABLE, current)) {
156 error = -EINTR;
157 break;
158 }
159
160 bytes = do_splice_direct(old_file, &old_pos,
161 new_file, &new_pos,
162 this_len, SPLICE_F_MOVE);
163 if (bytes <= 0) {
164 error = bytes;
165 break;
166 }
167 WARN_ON(old_pos != new_pos);
168
169 len -= bytes;
170 }
171 out:
172 if (!error)
173 error = vfs_fsync(new_file, 0);
174 fput(new_file);
175 out_fput:
176 fput(old_file);
177 return error;
178 }
179
180 static int ovl_set_size(struct dentry *upperdentry, struct kstat *stat)
181 {
182 struct iattr attr = {
183 .ia_valid = ATTR_SIZE,
184 .ia_size = stat->size,
185 };
186
187 return notify_change(upperdentry, &attr, NULL);
188 }
189
190 static int ovl_set_timestamps(struct dentry *upperdentry, struct kstat *stat)
191 {
192 struct iattr attr = {
193 .ia_valid =
194 ATTR_ATIME | ATTR_MTIME | ATTR_ATIME_SET | ATTR_MTIME_SET,
195 .ia_atime = stat->atime,
196 .ia_mtime = stat->mtime,
197 };
198
199 return notify_change(upperdentry, &attr, NULL);
200 }
201
202 int ovl_set_attr(struct dentry *upperdentry, struct kstat *stat)
203 {
204 int err = 0;
205
206 if (!S_ISLNK(stat->mode)) {
207 struct iattr attr = {
208 .ia_valid = ATTR_MODE,
209 .ia_mode = stat->mode,
210 };
211 err = notify_change(upperdentry, &attr, NULL);
212 }
213 if (!err) {
214 struct iattr attr = {
215 .ia_valid = ATTR_UID | ATTR_GID,
216 .ia_uid = stat->uid,
217 .ia_gid = stat->gid,
218 };
219 err = notify_change(upperdentry, &attr, NULL);
220 }
221 if (!err)
222 ovl_set_timestamps(upperdentry, stat);
223
224 return err;
225 }
226
227 struct ovl_fh *ovl_encode_real_fh(struct dentry *real, bool is_upper)
228 {
229 struct ovl_fh *fh;
230 int fh_type, fh_len, dwords;
231 void *buf;
232 int buflen = MAX_HANDLE_SZ;
233 uuid_t *uuid = &real->d_sb->s_uuid;
234
235 buf = kmalloc(buflen, GFP_KERNEL);
236 if (!buf)
237 return ERR_PTR(-ENOMEM);
238
239 /*
240 * We encode a non-connectable file handle for non-dir, because we
241 * only need to find the lower inode number and we don't want to pay
242 * the price or reconnecting the dentry.
243 */
244 dwords = buflen >> 2;
245 fh_type = exportfs_encode_fh(real, buf, &dwords, 0);
246 buflen = (dwords << 2);
247
248 fh = ERR_PTR(-EIO);
249 if (WARN_ON(fh_type < 0) ||
250 WARN_ON(buflen > MAX_HANDLE_SZ) ||
251 WARN_ON(fh_type == FILEID_INVALID))
252 goto out;
253
254 BUILD_BUG_ON(MAX_HANDLE_SZ + offsetof(struct ovl_fh, fid) > 255);
255 fh_len = offsetof(struct ovl_fh, fid) + buflen;
256 fh = kmalloc(fh_len, GFP_KERNEL);
257 if (!fh) {
258 fh = ERR_PTR(-ENOMEM);
259 goto out;
260 }
261
262 fh->version = OVL_FH_VERSION;
263 fh->magic = OVL_FH_MAGIC;
264 fh->type = fh_type;
265 fh->flags = OVL_FH_FLAG_CPU_ENDIAN;
266 /*
267 * When we will want to decode an overlay dentry from this handle
268 * and all layers are on the same fs, if we get a disconncted real
269 * dentry when we decode fid, the only way to tell if we should assign
270 * it to upperdentry or to lowerstack is by checking this flag.
271 */
272 if (is_upper)
273 fh->flags |= OVL_FH_FLAG_PATH_UPPER;
274 fh->len = fh_len;
275 fh->uuid = *uuid;
276 memcpy(fh->fid, buf, buflen);
277
278 out:
279 kfree(buf);
280 return fh;
281 }
282
283 int ovl_set_origin(struct dentry *dentry, struct dentry *lower,
284 struct dentry *upper)
285 {
286 const struct ovl_fh *fh = NULL;
287 int err;
288
289 /*
290 * When lower layer doesn't support export operations store a 'null' fh,
291 * so we can use the overlay.origin xattr to distignuish between a copy
292 * up and a pure upper inode.
293 */
294 if (ovl_can_decode_fh(lower->d_sb)) {
295 fh = ovl_encode_real_fh(lower, false);
296 if (IS_ERR(fh))
297 return PTR_ERR(fh);
298 }
299
300 /*
301 * Do not fail when upper doesn't support xattrs.
302 */
303 err = ovl_check_setxattr(dentry, upper, OVL_XATTR_ORIGIN, fh,
304 fh ? fh->len : 0, 0);
305 kfree(fh);
306
307 return err;
308 }
309
310 /* Store file handle of @upper dir in @index dir entry */
311 static int ovl_set_upper_fh(struct dentry *upper, struct dentry *index)
312 {
313 const struct ovl_fh *fh;
314 int err;
315
316 fh = ovl_encode_real_fh(upper, true);
317 if (IS_ERR(fh))
318 return PTR_ERR(fh);
319
320 err = ovl_do_setxattr(index, OVL_XATTR_UPPER, fh, fh->len, 0);
321
322 kfree(fh);
323 return err;
324 }
325
326 /*
327 * Create and install index entry.
328 *
329 * Caller must hold i_mutex on indexdir.
330 */
331 static int ovl_create_index(struct dentry *dentry, struct dentry *origin,
332 struct dentry *upper)
333 {
334 struct dentry *indexdir = ovl_indexdir(dentry->d_sb);
335 struct inode *dir = d_inode(indexdir);
336 struct dentry *index = NULL;
337 struct dentry *temp = NULL;
338 struct qstr name = { };
339 int err;
340
341 /*
342 * For now this is only used for creating index entry for directories,
343 * because non-dir are copied up directly to index and then hardlinked
344 * to upper dir.
345 *
346 * TODO: implement create index for non-dir, so we can call it when
347 * encoding file handle for non-dir in case index does not exist.
348 */
349 if (WARN_ON(!d_is_dir(dentry)))
350 return -EIO;
351
352 /* Directory not expected to be indexed before copy up */
353 if (WARN_ON(ovl_test_flag(OVL_INDEX, d_inode(dentry))))
354 return -EIO;
355
356 err = ovl_get_index_name(origin, &name);
357 if (err)
358 return err;
359
360 temp = ovl_create_temp(indexdir, OVL_CATTR(S_IFDIR | 0));
361 err = PTR_ERR(temp);
362 if (IS_ERR(temp))
363 goto free_name;
364
365 err = ovl_set_upper_fh(upper, temp);
366 if (err)
367 goto out;
368
369 index = lookup_one_len(name.name, indexdir, name.len);
370 if (IS_ERR(index)) {
371 err = PTR_ERR(index);
372 } else {
373 err = ovl_do_rename(dir, temp, dir, index, 0);
374 dput(index);
375 }
376 out:
377 if (err)
378 ovl_cleanup(dir, temp);
379 dput(temp);
380 free_name:
381 kfree(name.name);
382 return err;
383 }
384
385 struct ovl_copy_up_ctx {
386 struct dentry *parent;
387 struct dentry *dentry;
388 struct path lowerpath;
389 struct kstat stat;
390 struct kstat pstat;
391 const char *link;
392 struct dentry *destdir;
393 struct qstr destname;
394 struct dentry *workdir;
395 bool origin;
396 bool indexed;
397 bool metacopy;
398 };
399
400 static int ovl_link_up(struct ovl_copy_up_ctx *c)
401 {
402 int err;
403 struct dentry *upper;
404 struct dentry *upperdir = ovl_dentry_upper(c->parent);
405 struct inode *udir = d_inode(upperdir);
406
407 /* Mark parent "impure" because it may now contain non-pure upper */
408 err = ovl_set_impure(c->parent, upperdir);
409 if (err)
410 return err;
411
412 err = ovl_set_nlink_lower(c->dentry);
413 if (err)
414 return err;
415
416 inode_lock_nested(udir, I_MUTEX_PARENT);
417 upper = lookup_one_len(c->dentry->d_name.name, upperdir,
418 c->dentry->d_name.len);
419 err = PTR_ERR(upper);
420 if (!IS_ERR(upper)) {
421 err = ovl_do_link(ovl_dentry_upper(c->dentry), udir, upper);
422 dput(upper);
423
424 if (!err) {
425 /* Restore timestamps on parent (best effort) */
426 ovl_set_timestamps(upperdir, &c->pstat);
427 ovl_dentry_set_upper_alias(c->dentry);
428 }
429 }
430 inode_unlock(udir);
431 if (err)
432 return err;
433
434 err = ovl_set_nlink_upper(c->dentry);
435
436 return err;
437 }
438
439 static int ovl_copy_up_inode(struct ovl_copy_up_ctx *c, struct dentry *temp)
440 {
441 int err;
442
443 /*
444 * Copy up data first and then xattrs. Writing data after
445 * xattrs will remove security.capability xattr automatically.
446 */
447 if (S_ISREG(c->stat.mode) && !c->metacopy) {
448 struct path upperpath, datapath;
449
450 ovl_path_upper(c->dentry, &upperpath);
451 if (WARN_ON(upperpath.dentry != NULL))
452 return -EIO;
453 upperpath.dentry = temp;
454
455 ovl_path_lowerdata(c->dentry, &datapath);
456 err = ovl_copy_up_data(&datapath, &upperpath, c->stat.size);
457 if (err)
458 return err;
459 }
460
461 err = ovl_copy_xattr(c->lowerpath.dentry, temp);
462 if (err)
463 return err;
464
465 /*
466 * Store identifier of lower inode in upper inode xattr to
467 * allow lookup of the copy up origin inode.
468 *
469 * Don't set origin when we are breaking the association with a lower
470 * hard link.
471 */
472 if (c->origin) {
473 err = ovl_set_origin(c->dentry, c->lowerpath.dentry, temp);
474 if (err)
475 return err;
476 }
477
478 if (c->metacopy) {
479 err = ovl_check_setxattr(c->dentry, temp, OVL_XATTR_METACOPY,
480 NULL, 0, -EOPNOTSUPP);
481 if (err)
482 return err;
483 }
484
485 inode_lock(temp->d_inode);
486 if (c->metacopy)
487 err = ovl_set_size(temp, &c->stat);
488 if (!err)
489 err = ovl_set_attr(temp, &c->stat);
490 inode_unlock(temp->d_inode);
491
492 return err;
493 }
494
495 struct ovl_cu_creds {
496 const struct cred *old;
497 struct cred *new;
498 };
499
500 static int ovl_prep_cu_creds(struct dentry *dentry, struct ovl_cu_creds *cc)
501 {
502 int err;
503
504 cc->old = cc->new = NULL;
505 err = security_inode_copy_up(dentry, &cc->new);
506 if (err < 0)
507 return err;
508
509 if (cc->new)
510 cc->old = override_creds(cc->new);
511
512 return 0;
513 }
514
515 static void ovl_revert_cu_creds(struct ovl_cu_creds *cc)
516 {
517 if (cc->new) {
518 revert_creds(cc->old);
519 put_cred(cc->new);
520 }
521 }
522
523 /*
524 * Copyup using workdir to prepare temp file. Used when copying up directories,
525 * special files or when upper fs doesn't support O_TMPFILE.
526 */
527 static int ovl_copy_up_workdir(struct ovl_copy_up_ctx *c)
528 {
529 struct inode *inode;
530 struct inode *udir = d_inode(c->destdir), *wdir = d_inode(c->workdir);
531 struct dentry *temp, *upper;
532 struct ovl_cu_creds cc;
533 int err;
534 struct ovl_cattr cattr = {
535 /* Can't properly set mode on creation because of the umask */
536 .mode = c->stat.mode & S_IFMT,
537 .rdev = c->stat.rdev,
538 .link = c->link
539 };
540
541 err = ovl_lock_rename_workdir(c->workdir, c->destdir);
542 if (err)
543 return err;
544
545 err = ovl_prep_cu_creds(c->dentry, &cc);
546 if (err)
547 goto unlock;
548
549 temp = ovl_create_temp(c->workdir, &cattr);
550 ovl_revert_cu_creds(&cc);
551
552 err = PTR_ERR(temp);
553 if (IS_ERR(temp))
554 goto unlock;
555
556 err = ovl_copy_up_inode(c, temp);
557 if (err)
558 goto cleanup;
559
560 if (S_ISDIR(c->stat.mode) && c->indexed) {
561 err = ovl_create_index(c->dentry, c->lowerpath.dentry, temp);
562 if (err)
563 goto cleanup;
564 }
565
566 upper = lookup_one_len(c->destname.name, c->destdir, c->destname.len);
567 err = PTR_ERR(upper);
568 if (IS_ERR(upper))
569 goto cleanup;
570
571 err = ovl_do_rename(wdir, temp, udir, upper, 0);
572 dput(upper);
573 if (err)
574 goto cleanup;
575
576 if (!c->metacopy)
577 ovl_set_upperdata(d_inode(c->dentry));
578 inode = d_inode(c->dentry);
579 ovl_inode_update(inode, temp);
580 if (S_ISDIR(inode->i_mode))
581 ovl_set_flag(OVL_WHITEOUTS, inode);
582 unlock:
583 unlock_rename(c->workdir, c->destdir);
584
585 return err;
586
587 cleanup:
588 ovl_cleanup(wdir, temp);
589 dput(temp);
590 goto unlock;
591 }
592
593 /* Copyup using O_TMPFILE which does not require cross dir locking */
594 static int ovl_copy_up_tmpfile(struct ovl_copy_up_ctx *c)
595 {
596 struct inode *udir = d_inode(c->destdir);
597 struct dentry *temp, *upper;
598 struct ovl_cu_creds cc;
599 int err;
600
601 err = ovl_prep_cu_creds(c->dentry, &cc);
602 if (err)
603 return err;
604
605 temp = ovl_do_tmpfile(c->workdir, c->stat.mode);
606 ovl_revert_cu_creds(&cc);
607
608 if (IS_ERR(temp))
609 return PTR_ERR(temp);
610
611 err = ovl_copy_up_inode(c, temp);
612 if (err)
613 goto out_dput;
614
615 inode_lock_nested(udir, I_MUTEX_PARENT);
616
617 upper = lookup_one_len(c->destname.name, c->destdir, c->destname.len);
618 err = PTR_ERR(upper);
619 if (!IS_ERR(upper)) {
620 err = ovl_do_link(temp, udir, upper);
621 dput(upper);
622 }
623 inode_unlock(udir);
624
625 if (err)
626 goto out_dput;
627
628 if (!c->metacopy)
629 ovl_set_upperdata(d_inode(c->dentry));
630 ovl_inode_update(d_inode(c->dentry), temp);
631
632 return 0;
633
634 out_dput:
635 dput(temp);
636 return err;
637 }
638
639 /*
640 * Copy up a single dentry
641 *
642 * All renames start with copy up of source if necessary. The actual
643 * rename will only proceed once the copy up was successful. Copy up uses
644 * upper parent i_mutex for exclusion. Since rename can change d_parent it
645 * is possible that the copy up will lock the old parent. At that point
646 * the file will have already been copied up anyway.
647 */
648 static int ovl_do_copy_up(struct ovl_copy_up_ctx *c)
649 {
650 int err;
651 struct ovl_fs *ofs = c->dentry->d_sb->s_fs_info;
652 bool to_index = false;
653
654 /*
655 * Indexed non-dir is copied up directly to the index entry and then
656 * hardlinked to upper dir. Indexed dir is copied up to indexdir,
657 * then index entry is created and then copied up dir installed.
658 * Copying dir up to indexdir instead of workdir simplifies locking.
659 */
660 if (ovl_need_index(c->dentry)) {
661 c->indexed = true;
662 if (S_ISDIR(c->stat.mode))
663 c->workdir = ovl_indexdir(c->dentry->d_sb);
664 else
665 to_index = true;
666 }
667
668 if (S_ISDIR(c->stat.mode) || c->stat.nlink == 1 || to_index)
669 c->origin = true;
670
671 if (to_index) {
672 c->destdir = ovl_indexdir(c->dentry->d_sb);
673 err = ovl_get_index_name(c->lowerpath.dentry, &c->destname);
674 if (err)
675 return err;
676 } else if (WARN_ON(!c->parent)) {
677 /* Disconnected dentry must be copied up to index dir */
678 return -EIO;
679 } else {
680 /*
681 * Mark parent "impure" because it may now contain non-pure
682 * upper
683 */
684 err = ovl_set_impure(c->parent, c->destdir);
685 if (err)
686 return err;
687 }
688
689 /* Should we copyup with O_TMPFILE or with workdir? */
690 if (S_ISREG(c->stat.mode) && ofs->tmpfile)
691 err = ovl_copy_up_tmpfile(c);
692 else
693 err = ovl_copy_up_workdir(c);
694 if (err)
695 goto out;
696
697 if (c->indexed)
698 ovl_set_flag(OVL_INDEX, d_inode(c->dentry));
699
700 if (to_index) {
701 /* Initialize nlink for copy up of disconnected dentry */
702 err = ovl_set_nlink_upper(c->dentry);
703 } else {
704 struct inode *udir = d_inode(c->destdir);
705
706 /* Restore timestamps on parent (best effort) */
707 inode_lock(udir);
708 ovl_set_timestamps(c->destdir, &c->pstat);
709 inode_unlock(udir);
710
711 ovl_dentry_set_upper_alias(c->dentry);
712 }
713
714 out:
715 if (to_index)
716 kfree(c->destname.name);
717 return err;
718 }
719
720 static bool ovl_need_meta_copy_up(struct dentry *dentry, umode_t mode,
721 int flags)
722 {
723 struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
724
725 if (!ofs->config.metacopy)
726 return false;
727
728 if (!S_ISREG(mode))
729 return false;
730
731 if (flags && ((OPEN_FMODE(flags) & FMODE_WRITE) || (flags & O_TRUNC)))
732 return false;
733
734 return true;
735 }
736
737 /* Copy up data of an inode which was copied up metadata only in the past. */
738 static int ovl_copy_up_meta_inode_data(struct ovl_copy_up_ctx *c)
739 {
740 struct path upperpath, datapath;
741 int err;
742 char *capability = NULL;
743 ssize_t uninitialized_var(cap_size);
744
745 ovl_path_upper(c->dentry, &upperpath);
746 if (WARN_ON(upperpath.dentry == NULL))
747 return -EIO;
748
749 ovl_path_lowerdata(c->dentry, &datapath);
750 if (WARN_ON(datapath.dentry == NULL))
751 return -EIO;
752
753 if (c->stat.size) {
754 err = cap_size = ovl_getxattr(upperpath.dentry, XATTR_NAME_CAPS,
755 &capability, 0);
756 if (err < 0 && err != -ENODATA)
757 goto out;
758 }
759
760 err = ovl_copy_up_data(&datapath, &upperpath, c->stat.size);
761 if (err)
762 goto out_free;
763
764 /*
765 * Writing to upper file will clear security.capability xattr. We
766 * don't want that to happen for normal copy-up operation.
767 */
768 if (capability) {
769 err = ovl_do_setxattr(upperpath.dentry, XATTR_NAME_CAPS,
770 capability, cap_size, 0);
771 if (err)
772 goto out_free;
773 }
774
775
776 err = vfs_removexattr(upperpath.dentry, OVL_XATTR_METACOPY);
777 if (err)
778 goto out_free;
779
780 ovl_set_upperdata(d_inode(c->dentry));
781 out_free:
782 kfree(capability);
783 out:
784 return err;
785 }
786
787 static int ovl_copy_up_one(struct dentry *parent, struct dentry *dentry,
788 int flags)
789 {
790 int err;
791 DEFINE_DELAYED_CALL(done);
792 struct path parentpath;
793 struct ovl_copy_up_ctx ctx = {
794 .parent = parent,
795 .dentry = dentry,
796 .workdir = ovl_workdir(dentry),
797 };
798
799 if (WARN_ON(!ctx.workdir))
800 return -EROFS;
801
802 ovl_path_lower(dentry, &ctx.lowerpath);
803 err = vfs_getattr(&ctx.lowerpath, &ctx.stat,
804 STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
805 if (err)
806 return err;
807
808 ctx.metacopy = ovl_need_meta_copy_up(dentry, ctx.stat.mode, flags);
809
810 if (parent) {
811 ovl_path_upper(parent, &parentpath);
812 ctx.destdir = parentpath.dentry;
813 ctx.destname = dentry->d_name;
814
815 err = vfs_getattr(&parentpath, &ctx.pstat,
816 STATX_ATIME | STATX_MTIME,
817 AT_STATX_SYNC_AS_STAT);
818 if (err)
819 return err;
820 }
821
822 /* maybe truncate regular file. this has no effect on dirs */
823 if (flags & O_TRUNC)
824 ctx.stat.size = 0;
825
826 if (S_ISLNK(ctx.stat.mode)) {
827 ctx.link = vfs_get_link(ctx.lowerpath.dentry, &done);
828 if (IS_ERR(ctx.link))
829 return PTR_ERR(ctx.link);
830 }
831
832 err = ovl_copy_up_start(dentry, flags);
833 /* err < 0: interrupted, err > 0: raced with another copy-up */
834 if (unlikely(err)) {
835 if (err > 0)
836 err = 0;
837 } else {
838 if (!ovl_dentry_upper(dentry))
839 err = ovl_do_copy_up(&ctx);
840 if (!err && parent && !ovl_dentry_has_upper_alias(dentry))
841 err = ovl_link_up(&ctx);
842 if (!err && ovl_dentry_needs_data_copy_up_locked(dentry, flags))
843 err = ovl_copy_up_meta_inode_data(&ctx);
844 ovl_copy_up_end(dentry);
845 }
846 do_delayed_call(&done);
847
848 return err;
849 }
850
851 int ovl_copy_up_flags(struct dentry *dentry, int flags)
852 {
853 int err = 0;
854 const struct cred *old_cred = ovl_override_creds(dentry->d_sb);
855 bool disconnected = (dentry->d_flags & DCACHE_DISCONNECTED);
856
857 /*
858 * With NFS export, copy up can get called for a disconnected non-dir.
859 * In this case, we will copy up lower inode to index dir without
860 * linking it to upper dir.
861 */
862 if (WARN_ON(disconnected && d_is_dir(dentry)))
863 return -EIO;
864
865 while (!err) {
866 struct dentry *next;
867 struct dentry *parent = NULL;
868
869 if (ovl_already_copied_up(dentry, flags))
870 break;
871
872 next = dget(dentry);
873 /* find the topmost dentry not yet copied up */
874 for (; !disconnected;) {
875 parent = dget_parent(next);
876
877 if (ovl_dentry_upper(parent))
878 break;
879
880 dput(next);
881 next = parent;
882 }
883
884 err = ovl_copy_up_one(parent, next, flags);
885
886 dput(parent);
887 dput(next);
888 }
889 revert_creds(old_cred);
890
891 return err;
892 }
893
894 static bool ovl_open_need_copy_up(struct dentry *dentry, int flags)
895 {
896 /* Copy up of disconnected dentry does not set upper alias */
897 if (ovl_already_copied_up(dentry, flags))
898 return false;
899
900 if (special_file(d_inode(dentry)->i_mode))
901 return false;
902
903 if (!ovl_open_flags_need_copy_up(flags))
904 return false;
905
906 return true;
907 }
908
909 int ovl_maybe_copy_up(struct dentry *dentry, int flags)
910 {
911 int err = 0;
912
913 if (ovl_open_need_copy_up(dentry, flags)) {
914 err = ovl_want_write(dentry);
915 if (!err) {
916 err = ovl_copy_up_flags(dentry, flags);
917 ovl_drop_write(dentry);
918 }
919 }
920
921 return err;
922 }
923
924 int ovl_copy_up_with_data(struct dentry *dentry)
925 {
926 return ovl_copy_up_flags(dentry, O_WRONLY);
927 }
928
929 int ovl_copy_up(struct dentry *dentry)
930 {
931 return ovl_copy_up_flags(dentry, 0);
932 }
933
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.