Merge tag 'rproc-v4.16' of git://github.com/andersson/remoteproc
[sfrench/cifs-2.6.git] / fs / overlayfs / copy_up.c
1 /*
2  *
3  * Copyright (C) 2011 Novell Inc.
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 as published by
7  * the Free Software Foundation.
8  */
9
10 #include <linux/module.h>
11 #include <linux/fs.h>
12 #include <linux/slab.h>
13 #include <linux/file.h>
14 #include <linux/splice.h>
15 #include <linux/xattr.h>
16 #include <linux/security.h>
17 #include <linux/uaccess.h>
18 #include <linux/sched/signal.h>
19 #include <linux/cred.h>
20 #include <linux/namei.h>
21 #include <linux/fdtable.h>
22 #include <linux/ratelimit.h>
23 #include <linux/exportfs.h>
24 #include "overlayfs.h"
25
26 #define OVL_COPY_UP_CHUNK_SIZE (1 << 20)
27
28 static bool __read_mostly ovl_check_copy_up;
29 module_param_named(check_copy_up, ovl_check_copy_up, bool,
30                    S_IWUSR | S_IRUGO);
31 MODULE_PARM_DESC(ovl_check_copy_up,
32                  "Warn on copy-up when causing process also has a R/O fd open");
33
34 static int ovl_check_fd(const void *data, struct file *f, unsigned int fd)
35 {
36         const struct dentry *dentry = data;
37
38         if (file_inode(f) == d_inode(dentry))
39                 pr_warn_ratelimited("overlayfs: Warning: Copying up %pD, but open R/O on fd %u which will cease to be coherent [pid=%d %s]\n",
40                                     f, fd, current->pid, current->comm);
41         return 0;
42 }
43
44 /*
45  * Check the fds open by this process and warn if something like the following
46  * scenario is about to occur:
47  *
48  *      fd1 = open("foo", O_RDONLY);
49  *      fd2 = open("foo", O_RDWR);
50  */
51 static void ovl_do_check_copy_up(struct dentry *dentry)
52 {
53         if (ovl_check_copy_up)
54                 iterate_fd(current->files, 0, ovl_check_fd, dentry);
55 }
56
57 int ovl_copy_xattr(struct dentry *old, struct dentry *new)
58 {
59         ssize_t list_size, size, value_size = 0;
60         char *buf, *name, *value = NULL;
61         int uninitialized_var(error);
62         size_t slen;
63
64         if (!(old->d_inode->i_opflags & IOP_XATTR) ||
65             !(new->d_inode->i_opflags & IOP_XATTR))
66                 return 0;
67
68         list_size = vfs_listxattr(old, NULL, 0);
69         if (list_size <= 0) {
70                 if (list_size == -EOPNOTSUPP)
71                         return 0;
72                 return list_size;
73         }
74
75         buf = kzalloc(list_size, GFP_KERNEL);
76         if (!buf)
77                 return -ENOMEM;
78
79         list_size = vfs_listxattr(old, buf, list_size);
80         if (list_size <= 0) {
81                 error = list_size;
82                 goto out;
83         }
84
85         for (name = buf; list_size; name += slen) {
86                 slen = strnlen(name, list_size) + 1;
87
88                 /* underlying fs providing us with an broken xattr list? */
89                 if (WARN_ON(slen > list_size)) {
90                         error = -EIO;
91                         break;
92                 }
93                 list_size -= slen;
94
95                 if (ovl_is_private_xattr(name))
96                         continue;
97 retry:
98                 size = vfs_getxattr(old, name, value, value_size);
99                 if (size == -ERANGE)
100                         size = vfs_getxattr(old, name, NULL, 0);
101
102                 if (size < 0) {
103                         error = size;
104                         break;
105                 }
106
107                 if (size > value_size) {
108                         void *new;
109
110                         new = krealloc(value, size, GFP_KERNEL);
111                         if (!new) {
112                                 error = -ENOMEM;
113                                 break;
114                         }
115                         value = new;
116                         value_size = size;
117                         goto retry;
118                 }
119
120                 error = security_inode_copy_up_xattr(name);
121                 if (error < 0 && error != -EOPNOTSUPP)
122                         break;
123                 if (error == 1) {
124                         error = 0;
125                         continue; /* Discard */
126                 }
127                 error = vfs_setxattr(new, name, value, size, 0);
128                 if (error)
129                         break;
130         }
131         kfree(value);
132 out:
133         kfree(buf);
134         return error;
135 }
136
137 static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len)
138 {
139         struct file *old_file;
140         struct file *new_file;
141         loff_t old_pos = 0;
142         loff_t new_pos = 0;
143         int error = 0;
144
145         if (len == 0)
146                 return 0;
147
148         old_file = ovl_path_open(old, O_LARGEFILE | O_RDONLY);
149         if (IS_ERR(old_file))
150                 return PTR_ERR(old_file);
151
152         new_file = ovl_path_open(new, O_LARGEFILE | O_WRONLY);
153         if (IS_ERR(new_file)) {
154                 error = PTR_ERR(new_file);
155                 goto out_fput;
156         }
157
158         /* Try to use clone_file_range to clone up within the same fs */
159         error = vfs_clone_file_range(old_file, 0, new_file, 0, len);
160         if (!error)
161                 goto out;
162         /* Couldn't clone, so now we try to copy the data */
163         error = 0;
164
165         /* FIXME: copy up sparse files efficiently */
166         while (len) {
167                 size_t this_len = OVL_COPY_UP_CHUNK_SIZE;
168                 long bytes;
169
170                 if (len < this_len)
171                         this_len = len;
172
173                 if (signal_pending_state(TASK_KILLABLE, current)) {
174                         error = -EINTR;
175                         break;
176                 }
177
178                 bytes = do_splice_direct(old_file, &old_pos,
179                                          new_file, &new_pos,
180                                          this_len, SPLICE_F_MOVE);
181                 if (bytes <= 0) {
182                         error = bytes;
183                         break;
184                 }
185                 WARN_ON(old_pos != new_pos);
186
187                 len -= bytes;
188         }
189 out:
190         if (!error)
191                 error = vfs_fsync(new_file, 0);
192         fput(new_file);
193 out_fput:
194         fput(old_file);
195         return error;
196 }
197
198 static int ovl_set_timestamps(struct dentry *upperdentry, struct kstat *stat)
199 {
200         struct iattr attr = {
201                 .ia_valid =
202                      ATTR_ATIME | ATTR_MTIME | ATTR_ATIME_SET | ATTR_MTIME_SET,
203                 .ia_atime = stat->atime,
204                 .ia_mtime = stat->mtime,
205         };
206
207         return notify_change(upperdentry, &attr, NULL);
208 }
209
210 int ovl_set_attr(struct dentry *upperdentry, struct kstat *stat)
211 {
212         int err = 0;
213
214         if (!S_ISLNK(stat->mode)) {
215                 struct iattr attr = {
216                         .ia_valid = ATTR_MODE,
217                         .ia_mode = stat->mode,
218                 };
219                 err = notify_change(upperdentry, &attr, NULL);
220         }
221         if (!err) {
222                 struct iattr attr = {
223                         .ia_valid = ATTR_UID | ATTR_GID,
224                         .ia_uid = stat->uid,
225                         .ia_gid = stat->gid,
226                 };
227                 err = notify_change(upperdentry, &attr, NULL);
228         }
229         if (!err)
230                 ovl_set_timestamps(upperdentry, stat);
231
232         return err;
233 }
234
235 struct ovl_fh *ovl_encode_fh(struct dentry *lower, bool is_upper)
236 {
237         struct ovl_fh *fh;
238         int fh_type, fh_len, dwords;
239         void *buf;
240         int buflen = MAX_HANDLE_SZ;
241         uuid_t *uuid = &lower->d_sb->s_uuid;
242
243         buf = kmalloc(buflen, GFP_KERNEL);
244         if (!buf)
245                 return ERR_PTR(-ENOMEM);
246
247         /*
248          * We encode a non-connectable file handle for non-dir, because we
249          * only need to find the lower inode number and we don't want to pay
250          * the price or reconnecting the dentry.
251          */
252         dwords = buflen >> 2;
253         fh_type = exportfs_encode_fh(lower, buf, &dwords, 0);
254         buflen = (dwords << 2);
255
256         fh = ERR_PTR(-EIO);
257         if (WARN_ON(fh_type < 0) ||
258             WARN_ON(buflen > MAX_HANDLE_SZ) ||
259             WARN_ON(fh_type == FILEID_INVALID))
260                 goto out;
261
262         BUILD_BUG_ON(MAX_HANDLE_SZ + offsetof(struct ovl_fh, fid) > 255);
263         fh_len = offsetof(struct ovl_fh, fid) + buflen;
264         fh = kmalloc(fh_len, GFP_KERNEL);
265         if (!fh) {
266                 fh = ERR_PTR(-ENOMEM);
267                 goto out;
268         }
269
270         fh->version = OVL_FH_VERSION;
271         fh->magic = OVL_FH_MAGIC;
272         fh->type = fh_type;
273         fh->flags = OVL_FH_FLAG_CPU_ENDIAN;
274         /*
275          * When we will want to decode an overlay dentry from this handle
276          * and all layers are on the same fs, if we get a disconncted real
277          * dentry when we decode fid, the only way to tell if we should assign
278          * it to upperdentry or to lowerstack is by checking this flag.
279          */
280         if (is_upper)
281                 fh->flags |= OVL_FH_FLAG_PATH_UPPER;
282         fh->len = fh_len;
283         fh->uuid = *uuid;
284         memcpy(fh->fid, buf, buflen);
285
286 out:
287         kfree(buf);
288         return fh;
289 }
290
291 static int ovl_set_origin(struct dentry *dentry, struct dentry *lower,
292                           struct dentry *upper)
293 {
294         const struct ovl_fh *fh = NULL;
295         int err;
296
297         /*
298          * When lower layer doesn't support export operations store a 'null' fh,
299          * so we can use the overlay.origin xattr to distignuish between a copy
300          * up and a pure upper inode.
301          */
302         if (ovl_can_decode_fh(lower->d_sb)) {
303                 fh = ovl_encode_fh(lower, false);
304                 if (IS_ERR(fh))
305                         return PTR_ERR(fh);
306         }
307
308         /*
309          * Do not fail when upper doesn't support xattrs.
310          */
311         err = ovl_check_setxattr(dentry, upper, OVL_XATTR_ORIGIN, fh,
312                                  fh ? fh->len : 0, 0);
313         kfree(fh);
314
315         return err;
316 }
317
318 struct ovl_copy_up_ctx {
319         struct dentry *parent;
320         struct dentry *dentry;
321         struct path lowerpath;
322         struct kstat stat;
323         struct kstat pstat;
324         const char *link;
325         struct dentry *destdir;
326         struct qstr destname;
327         struct dentry *workdir;
328         bool tmpfile;
329         bool origin;
330 };
331
332 static int ovl_link_up(struct ovl_copy_up_ctx *c)
333 {
334         int err;
335         struct dentry *upper;
336         struct dentry *upperdir = ovl_dentry_upper(c->parent);
337         struct inode *udir = d_inode(upperdir);
338
339         /* Mark parent "impure" because it may now contain non-pure upper */
340         err = ovl_set_impure(c->parent, upperdir);
341         if (err)
342                 return err;
343
344         err = ovl_set_nlink_lower(c->dentry);
345         if (err)
346                 return err;
347
348         inode_lock_nested(udir, I_MUTEX_PARENT);
349         upper = lookup_one_len(c->dentry->d_name.name, upperdir,
350                                c->dentry->d_name.len);
351         err = PTR_ERR(upper);
352         if (!IS_ERR(upper)) {
353                 err = ovl_do_link(ovl_dentry_upper(c->dentry), udir, upper,
354                                   true);
355                 dput(upper);
356
357                 if (!err) {
358                         /* Restore timestamps on parent (best effort) */
359                         ovl_set_timestamps(upperdir, &c->pstat);
360                         ovl_dentry_set_upper_alias(c->dentry);
361                 }
362         }
363         inode_unlock(udir);
364         ovl_set_nlink_upper(c->dentry);
365
366         return err;
367 }
368
369 static int ovl_install_temp(struct ovl_copy_up_ctx *c, struct dentry *temp,
370                             struct dentry **newdentry)
371 {
372         int err;
373         struct dentry *upper;
374         struct inode *udir = d_inode(c->destdir);
375
376         upper = lookup_one_len(c->destname.name, c->destdir, c->destname.len);
377         if (IS_ERR(upper))
378                 return PTR_ERR(upper);
379
380         if (c->tmpfile)
381                 err = ovl_do_link(temp, udir, upper, true);
382         else
383                 err = ovl_do_rename(d_inode(c->workdir), temp, udir, upper, 0);
384
385         if (!err)
386                 *newdentry = dget(c->tmpfile ? upper : temp);
387         dput(upper);
388
389         return err;
390 }
391
392 static int ovl_get_tmpfile(struct ovl_copy_up_ctx *c, struct dentry **tempp)
393 {
394         int err;
395         struct dentry *temp;
396         const struct cred *old_creds = NULL;
397         struct cred *new_creds = NULL;
398         struct cattr cattr = {
399                 /* Can't properly set mode on creation because of the umask */
400                 .mode = c->stat.mode & S_IFMT,
401                 .rdev = c->stat.rdev,
402                 .link = c->link
403         };
404
405         err = security_inode_copy_up(c->dentry, &new_creds);
406         if (err < 0)
407                 goto out;
408
409         if (new_creds)
410                 old_creds = override_creds(new_creds);
411
412         if (c->tmpfile) {
413                 temp = ovl_do_tmpfile(c->workdir, c->stat.mode);
414                 if (IS_ERR(temp))
415                         goto temp_err;
416         } else {
417                 temp = ovl_lookup_temp(c->workdir);
418                 if (IS_ERR(temp))
419                         goto temp_err;
420
421                 err = ovl_create_real(d_inode(c->workdir), temp, &cattr,
422                                       NULL, true);
423                 if (err) {
424                         dput(temp);
425                         goto out;
426                 }
427         }
428         err = 0;
429         *tempp = temp;
430 out:
431         if (new_creds) {
432                 revert_creds(old_creds);
433                 put_cred(new_creds);
434         }
435
436         return err;
437
438 temp_err:
439         err = PTR_ERR(temp);
440         goto out;
441 }
442
443 static int ovl_copy_up_inode(struct ovl_copy_up_ctx *c, struct dentry *temp)
444 {
445         int err;
446
447         if (S_ISREG(c->stat.mode)) {
448                 struct path upperpath;
449
450                 ovl_path_upper(c->dentry, &upperpath);
451                 BUG_ON(upperpath.dentry != NULL);
452                 upperpath.dentry = temp;
453
454                 err = ovl_copy_up_data(&c->lowerpath, &upperpath, c->stat.size);
455                 if (err)
456                         return err;
457         }
458
459         err = ovl_copy_xattr(c->lowerpath.dentry, temp);
460         if (err)
461                 return err;
462
463         inode_lock(temp->d_inode);
464         err = ovl_set_attr(temp, &c->stat);
465         inode_unlock(temp->d_inode);
466         if (err)
467                 return err;
468
469         /*
470          * Store identifier of lower inode in upper inode xattr to
471          * allow lookup of the copy up origin inode.
472          *
473          * Don't set origin when we are breaking the association with a lower
474          * hard link.
475          */
476         if (c->origin) {
477                 err = ovl_set_origin(c->dentry, c->lowerpath.dentry, temp);
478                 if (err)
479                         return err;
480         }
481
482         return 0;
483 }
484
485 static int ovl_copy_up_locked(struct ovl_copy_up_ctx *c)
486 {
487         struct inode *udir = c->destdir->d_inode;
488         struct inode *inode;
489         struct dentry *newdentry = NULL;
490         struct dentry *temp = NULL;
491         int err;
492
493         err = ovl_get_tmpfile(c, &temp);
494         if (err)
495                 goto out;
496
497         err = ovl_copy_up_inode(c, temp);
498         if (err)
499                 goto out_cleanup;
500
501         if (c->tmpfile) {
502                 inode_lock_nested(udir, I_MUTEX_PARENT);
503                 err = ovl_install_temp(c, temp, &newdentry);
504                 inode_unlock(udir);
505         } else {
506                 err = ovl_install_temp(c, temp, &newdentry);
507         }
508         if (err)
509                 goto out_cleanup;
510
511         inode = d_inode(c->dentry);
512         ovl_inode_update(inode, newdentry);
513         if (S_ISDIR(inode->i_mode))
514                 ovl_set_flag(OVL_WHITEOUTS, inode);
515
516 out:
517         dput(temp);
518         return err;
519
520 out_cleanup:
521         if (!c->tmpfile)
522                 ovl_cleanup(d_inode(c->workdir), temp);
523         goto out;
524 }
525
526 /*
527  * Copy up a single dentry
528  *
529  * All renames start with copy up of source if necessary.  The actual
530  * rename will only proceed once the copy up was successful.  Copy up uses
531  * upper parent i_mutex for exclusion.  Since rename can change d_parent it
532  * is possible that the copy up will lock the old parent.  At that point
533  * the file will have already been copied up anyway.
534  */
535 static int ovl_do_copy_up(struct ovl_copy_up_ctx *c)
536 {
537         int err;
538         struct ovl_fs *ofs = c->dentry->d_sb->s_fs_info;
539         bool indexed = false;
540
541         if (ovl_indexdir(c->dentry->d_sb) && !S_ISDIR(c->stat.mode) &&
542             c->stat.nlink > 1)
543                 indexed = true;
544
545         if (S_ISDIR(c->stat.mode) || c->stat.nlink == 1 || indexed)
546                 c->origin = true;
547
548         if (indexed) {
549                 c->destdir = ovl_indexdir(c->dentry->d_sb);
550                 err = ovl_get_index_name(c->lowerpath.dentry, &c->destname);
551                 if (err)
552                         return err;
553         } else {
554                 /*
555                  * Mark parent "impure" because it may now contain non-pure
556                  * upper
557                  */
558                 err = ovl_set_impure(c->parent, c->destdir);
559                 if (err)
560                         return err;
561         }
562
563         /* Should we copyup with O_TMPFILE or with workdir? */
564         if (S_ISREG(c->stat.mode) && ofs->tmpfile) {
565                 c->tmpfile = true;
566                 err = ovl_copy_up_locked(c);
567         } else {
568                 err = ovl_lock_rename_workdir(c->workdir, c->destdir);
569                 if (!err) {
570                         err = ovl_copy_up_locked(c);
571                         unlock_rename(c->workdir, c->destdir);
572                 }
573         }
574
575         if (indexed) {
576                 if (!err)
577                         ovl_set_flag(OVL_INDEX, d_inode(c->dentry));
578                 kfree(c->destname.name);
579         } else if (!err) {
580                 struct inode *udir = d_inode(c->destdir);
581
582                 /* Restore timestamps on parent (best effort) */
583                 inode_lock(udir);
584                 ovl_set_timestamps(c->destdir, &c->pstat);
585                 inode_unlock(udir);
586
587                 ovl_dentry_set_upper_alias(c->dentry);
588         }
589
590         return err;
591 }
592
593 static int ovl_copy_up_one(struct dentry *parent, struct dentry *dentry,
594                            int flags)
595 {
596         int err;
597         DEFINE_DELAYED_CALL(done);
598         struct path parentpath;
599         struct ovl_copy_up_ctx ctx = {
600                 .parent = parent,
601                 .dentry = dentry,
602                 .workdir = ovl_workdir(dentry),
603         };
604
605         if (WARN_ON(!ctx.workdir))
606                 return -EROFS;
607
608         ovl_path_lower(dentry, &ctx.lowerpath);
609         err = vfs_getattr(&ctx.lowerpath, &ctx.stat,
610                           STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
611         if (err)
612                 return err;
613
614         ovl_path_upper(parent, &parentpath);
615         ctx.destdir = parentpath.dentry;
616         ctx.destname = dentry->d_name;
617
618         err = vfs_getattr(&parentpath, &ctx.pstat,
619                           STATX_ATIME | STATX_MTIME, AT_STATX_SYNC_AS_STAT);
620         if (err)
621                 return err;
622
623         /* maybe truncate regular file. this has no effect on dirs */
624         if (flags & O_TRUNC)
625                 ctx.stat.size = 0;
626
627         if (S_ISLNK(ctx.stat.mode)) {
628                 ctx.link = vfs_get_link(ctx.lowerpath.dentry, &done);
629                 if (IS_ERR(ctx.link))
630                         return PTR_ERR(ctx.link);
631         }
632         ovl_do_check_copy_up(ctx.lowerpath.dentry);
633
634         err = ovl_copy_up_start(dentry);
635         /* err < 0: interrupted, err > 0: raced with another copy-up */
636         if (unlikely(err)) {
637                 if (err > 0)
638                         err = 0;
639         } else {
640                 if (!ovl_dentry_upper(dentry))
641                         err = ovl_do_copy_up(&ctx);
642                 if (!err && !ovl_dentry_has_upper_alias(dentry))
643                         err = ovl_link_up(&ctx);
644                 ovl_copy_up_end(dentry);
645         }
646         do_delayed_call(&done);
647
648         return err;
649 }
650
651 int ovl_copy_up_flags(struct dentry *dentry, int flags)
652 {
653         int err = 0;
654         const struct cred *old_cred = ovl_override_creds(dentry->d_sb);
655
656         while (!err) {
657                 struct dentry *next;
658                 struct dentry *parent;
659
660                 /*
661                  * Check if copy-up has happened as well as for upper alias (in
662                  * case of hard links) is there.
663                  *
664                  * Both checks are lockless:
665                  *  - false negatives: will recheck under oi->lock
666                  *  - false positives:
667                  *    + ovl_dentry_upper() uses memory barriers to ensure the
668                  *      upper dentry is up-to-date
669                  *    + ovl_dentry_has_upper_alias() relies on locking of
670                  *      upper parent i_rwsem to prevent reordering copy-up
671                  *      with rename.
672                  */
673                 if (ovl_dentry_upper(dentry) &&
674                     ovl_dentry_has_upper_alias(dentry))
675                         break;
676
677                 next = dget(dentry);
678                 /* find the topmost dentry not yet copied up */
679                 for (;;) {
680                         parent = dget_parent(next);
681
682                         if (ovl_dentry_upper(parent))
683                                 break;
684
685                         dput(next);
686                         next = parent;
687                 }
688
689                 err = ovl_copy_up_one(parent, next, flags);
690
691                 dput(parent);
692                 dput(next);
693         }
694         revert_creds(old_cred);
695
696         return err;
697 }
698
699 int ovl_copy_up(struct dentry *dentry)
700 {
701         return ovl_copy_up_flags(dentry, 0);
702 }