Merge tag 'rproc-v4.16' of git://github.com/andersson/remoteproc
[sfrench/cifs-2.6.git] / fs / overlayfs / dir.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/fs.h>
11 #include <linux/namei.h>
12 #include <linux/xattr.h>
13 #include <linux/security.h>
14 #include <linux/cred.h>
15 #include <linux/module.h>
16 #include <linux/posix_acl.h>
17 #include <linux/posix_acl_xattr.h>
18 #include <linux/atomic.h>
19 #include <linux/ratelimit.h>
20 #include "overlayfs.h"
21
22 static unsigned short ovl_redirect_max = 256;
23 module_param_named(redirect_max, ovl_redirect_max, ushort, 0644);
24 MODULE_PARM_DESC(ovl_redirect_max,
25                  "Maximum length of absolute redirect xattr value");
26
27 int ovl_cleanup(struct inode *wdir, struct dentry *wdentry)
28 {
29         int err;
30
31         dget(wdentry);
32         if (d_is_dir(wdentry))
33                 err = ovl_do_rmdir(wdir, wdentry);
34         else
35                 err = ovl_do_unlink(wdir, wdentry);
36         dput(wdentry);
37
38         if (err) {
39                 pr_err("overlayfs: cleanup of '%pd2' failed (%i)\n",
40                        wdentry, err);
41         }
42
43         return err;
44 }
45
46 struct dentry *ovl_lookup_temp(struct dentry *workdir)
47 {
48         struct dentry *temp;
49         char name[20];
50         static atomic_t temp_id = ATOMIC_INIT(0);
51
52         /* counter is allowed to wrap, since temp dentries are ephemeral */
53         snprintf(name, sizeof(name), "#%x", atomic_inc_return(&temp_id));
54
55         temp = lookup_one_len(name, workdir, strlen(name));
56         if (!IS_ERR(temp) && temp->d_inode) {
57                 pr_err("overlayfs: workdir/%s already exists\n", name);
58                 dput(temp);
59                 temp = ERR_PTR(-EIO);
60         }
61
62         return temp;
63 }
64
65 /* caller holds i_mutex on workdir */
66 static struct dentry *ovl_whiteout(struct dentry *workdir,
67                                    struct dentry *dentry)
68 {
69         int err;
70         struct dentry *whiteout;
71         struct inode *wdir = workdir->d_inode;
72
73         whiteout = ovl_lookup_temp(workdir);
74         if (IS_ERR(whiteout))
75                 return whiteout;
76
77         err = ovl_do_whiteout(wdir, whiteout);
78         if (err) {
79                 dput(whiteout);
80                 whiteout = ERR_PTR(err);
81         }
82
83         return whiteout;
84 }
85
86 int ovl_create_real(struct inode *dir, struct dentry *newdentry,
87                     struct cattr *attr, struct dentry *hardlink, bool debug)
88 {
89         int err;
90
91         if (newdentry->d_inode)
92                 return -ESTALE;
93
94         if (hardlink) {
95                 err = ovl_do_link(hardlink, dir, newdentry, debug);
96         } else {
97                 switch (attr->mode & S_IFMT) {
98                 case S_IFREG:
99                         err = ovl_do_create(dir, newdentry, attr->mode, debug);
100                         break;
101
102                 case S_IFDIR:
103                         err = ovl_do_mkdir(dir, newdentry, attr->mode, debug);
104                         break;
105
106                 case S_IFCHR:
107                 case S_IFBLK:
108                 case S_IFIFO:
109                 case S_IFSOCK:
110                         err = ovl_do_mknod(dir, newdentry,
111                                            attr->mode, attr->rdev, debug);
112                         break;
113
114                 case S_IFLNK:
115                         err = ovl_do_symlink(dir, newdentry, attr->link, debug);
116                         break;
117
118                 default:
119                         err = -EPERM;
120                 }
121         }
122         if (!err && WARN_ON(!newdentry->d_inode)) {
123                 /*
124                  * Not quite sure if non-instantiated dentry is legal or not.
125                  * VFS doesn't seem to care so check and warn here.
126                  */
127                 err = -ENOENT;
128         }
129         return err;
130 }
131
132 static int ovl_set_opaque_xerr(struct dentry *dentry, struct dentry *upper,
133                                int xerr)
134 {
135         int err;
136
137         err = ovl_check_setxattr(dentry, upper, OVL_XATTR_OPAQUE, "y", 1, xerr);
138         if (!err)
139                 ovl_dentry_set_opaque(dentry);
140
141         return err;
142 }
143
144 static int ovl_set_opaque(struct dentry *dentry, struct dentry *upperdentry)
145 {
146         /*
147          * Fail with -EIO when trying to create opaque dir and upper doesn't
148          * support xattrs. ovl_rename() calls ovl_set_opaque_xerr(-EXDEV) to
149          * return a specific error for noxattr case.
150          */
151         return ovl_set_opaque_xerr(dentry, upperdentry, -EIO);
152 }
153
154 /* Common operations required to be done after creation of file on upper */
155 static void ovl_instantiate(struct dentry *dentry, struct inode *inode,
156                             struct dentry *newdentry, bool hardlink)
157 {
158         ovl_dentry_version_inc(dentry->d_parent, false);
159         ovl_dentry_set_upper_alias(dentry);
160         if (!hardlink) {
161                 ovl_inode_update(inode, newdentry);
162                 ovl_copyattr(newdentry->d_inode, inode);
163         } else {
164                 WARN_ON(ovl_inode_real(inode) != d_inode(newdentry));
165                 dput(newdentry);
166                 inc_nlink(inode);
167         }
168         d_instantiate(dentry, inode);
169         /* Force lookup of new upper hardlink to find its lower */
170         if (hardlink)
171                 d_drop(dentry);
172 }
173
174 static bool ovl_type_merge(struct dentry *dentry)
175 {
176         return OVL_TYPE_MERGE(ovl_path_type(dentry));
177 }
178
179 static bool ovl_type_origin(struct dentry *dentry)
180 {
181         return OVL_TYPE_ORIGIN(ovl_path_type(dentry));
182 }
183
184 static bool ovl_may_have_whiteouts(struct dentry *dentry)
185 {
186         return ovl_test_flag(OVL_WHITEOUTS, d_inode(dentry));
187 }
188
189 static int ovl_create_upper(struct dentry *dentry, struct inode *inode,
190                             struct cattr *attr, struct dentry *hardlink)
191 {
192         struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
193         struct inode *udir = upperdir->d_inode;
194         struct dentry *newdentry;
195         int err;
196
197         if (!hardlink && !IS_POSIXACL(udir))
198                 attr->mode &= ~current_umask();
199
200         inode_lock_nested(udir, I_MUTEX_PARENT);
201         newdentry = lookup_one_len(dentry->d_name.name, upperdir,
202                                    dentry->d_name.len);
203         err = PTR_ERR(newdentry);
204         if (IS_ERR(newdentry))
205                 goto out_unlock;
206         err = ovl_create_real(udir, newdentry, attr, hardlink, false);
207         if (err)
208                 goto out_dput;
209
210         if (ovl_type_merge(dentry->d_parent) && d_is_dir(newdentry)) {
211                 /* Setting opaque here is just an optimization, allow to fail */
212                 ovl_set_opaque(dentry, newdentry);
213         }
214
215         ovl_instantiate(dentry, inode, newdentry, !!hardlink);
216         newdentry = NULL;
217 out_dput:
218         dput(newdentry);
219 out_unlock:
220         inode_unlock(udir);
221         return err;
222 }
223
224 static struct dentry *ovl_clear_empty(struct dentry *dentry,
225                                       struct list_head *list)
226 {
227         struct dentry *workdir = ovl_workdir(dentry);
228         struct inode *wdir = workdir->d_inode;
229         struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
230         struct inode *udir = upperdir->d_inode;
231         struct path upperpath;
232         struct dentry *upper;
233         struct dentry *opaquedir;
234         struct kstat stat;
235         int err;
236
237         if (WARN_ON(!workdir))
238                 return ERR_PTR(-EROFS);
239
240         err = ovl_lock_rename_workdir(workdir, upperdir);
241         if (err)
242                 goto out;
243
244         ovl_path_upper(dentry, &upperpath);
245         err = vfs_getattr(&upperpath, &stat,
246                           STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
247         if (err)
248                 goto out_unlock;
249
250         err = -ESTALE;
251         if (!S_ISDIR(stat.mode))
252                 goto out_unlock;
253         upper = upperpath.dentry;
254         if (upper->d_parent->d_inode != udir)
255                 goto out_unlock;
256
257         opaquedir = ovl_lookup_temp(workdir);
258         err = PTR_ERR(opaquedir);
259         if (IS_ERR(opaquedir))
260                 goto out_unlock;
261
262         err = ovl_create_real(wdir, opaquedir,
263                               &(struct cattr){.mode = stat.mode}, NULL, true);
264         if (err)
265                 goto out_dput;
266
267         err = ovl_copy_xattr(upper, opaquedir);
268         if (err)
269                 goto out_cleanup;
270
271         err = ovl_set_opaque(dentry, opaquedir);
272         if (err)
273                 goto out_cleanup;
274
275         inode_lock(opaquedir->d_inode);
276         err = ovl_set_attr(opaquedir, &stat);
277         inode_unlock(opaquedir->d_inode);
278         if (err)
279                 goto out_cleanup;
280
281         err = ovl_do_rename(wdir, opaquedir, udir, upper, RENAME_EXCHANGE);
282         if (err)
283                 goto out_cleanup;
284
285         ovl_cleanup_whiteouts(upper, list);
286         ovl_cleanup(wdir, upper);
287         unlock_rename(workdir, upperdir);
288
289         /* dentry's upper doesn't match now, get rid of it */
290         d_drop(dentry);
291
292         return opaquedir;
293
294 out_cleanup:
295         ovl_cleanup(wdir, opaquedir);
296 out_dput:
297         dput(opaquedir);
298 out_unlock:
299         unlock_rename(workdir, upperdir);
300 out:
301         return ERR_PTR(err);
302 }
303
304 static struct dentry *ovl_check_empty_and_clear(struct dentry *dentry)
305 {
306         int err;
307         struct dentry *ret = NULL;
308         LIST_HEAD(list);
309
310         err = ovl_check_empty_dir(dentry, &list);
311         if (err) {
312                 ret = ERR_PTR(err);
313                 goto out_free;
314         }
315
316         /*
317          * When removing an empty opaque directory, then it makes no sense to
318          * replace it with an exact replica of itself.
319          *
320          * If upperdentry has whiteouts, clear them.
321          *
322          * Can race with copy-up, since we don't hold the upperdir mutex.
323          * Doesn't matter, since copy-up can't create a non-empty directory
324          * from an empty one.
325          */
326         if (!list_empty(&list))
327                 ret = ovl_clear_empty(dentry, &list);
328
329 out_free:
330         ovl_cache_free(&list);
331
332         return ret;
333 }
334
335 static int ovl_set_upper_acl(struct dentry *upperdentry, const char *name,
336                              const struct posix_acl *acl)
337 {
338         void *buffer;
339         size_t size;
340         int err;
341
342         if (!IS_ENABLED(CONFIG_FS_POSIX_ACL) || !acl)
343                 return 0;
344
345         size = posix_acl_to_xattr(NULL, acl, NULL, 0);
346         buffer = kmalloc(size, GFP_KERNEL);
347         if (!buffer)
348                 return -ENOMEM;
349
350         size = posix_acl_to_xattr(&init_user_ns, acl, buffer, size);
351         err = size;
352         if (err < 0)
353                 goto out_free;
354
355         err = vfs_setxattr(upperdentry, name, buffer, size, XATTR_CREATE);
356 out_free:
357         kfree(buffer);
358         return err;
359 }
360
361 static int ovl_create_over_whiteout(struct dentry *dentry, struct inode *inode,
362                                     struct cattr *cattr,
363                                     struct dentry *hardlink)
364 {
365         struct dentry *workdir = ovl_workdir(dentry);
366         struct inode *wdir = workdir->d_inode;
367         struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
368         struct inode *udir = upperdir->d_inode;
369         struct dentry *upper;
370         struct dentry *newdentry;
371         int err;
372         struct posix_acl *acl, *default_acl;
373
374         if (WARN_ON(!workdir))
375                 return -EROFS;
376
377         if (!hardlink) {
378                 err = posix_acl_create(dentry->d_parent->d_inode,
379                                        &cattr->mode, &default_acl, &acl);
380                 if (err)
381                         return err;
382         }
383
384         err = ovl_lock_rename_workdir(workdir, upperdir);
385         if (err)
386                 goto out;
387
388         newdentry = ovl_lookup_temp(workdir);
389         err = PTR_ERR(newdentry);
390         if (IS_ERR(newdentry))
391                 goto out_unlock;
392
393         upper = lookup_one_len(dentry->d_name.name, upperdir,
394                                dentry->d_name.len);
395         err = PTR_ERR(upper);
396         if (IS_ERR(upper))
397                 goto out_dput;
398
399         err = ovl_create_real(wdir, newdentry, cattr, hardlink, true);
400         if (err)
401                 goto out_dput2;
402
403         /*
404          * mode could have been mutilated due to umask (e.g. sgid directory)
405          */
406         if (!hardlink &&
407             !S_ISLNK(cattr->mode) &&
408             newdentry->d_inode->i_mode != cattr->mode) {
409                 struct iattr attr = {
410                         .ia_valid = ATTR_MODE,
411                         .ia_mode = cattr->mode,
412                 };
413                 inode_lock(newdentry->d_inode);
414                 err = notify_change(newdentry, &attr, NULL);
415                 inode_unlock(newdentry->d_inode);
416                 if (err)
417                         goto out_cleanup;
418         }
419         if (!hardlink) {
420                 err = ovl_set_upper_acl(newdentry, XATTR_NAME_POSIX_ACL_ACCESS,
421                                         acl);
422                 if (err)
423                         goto out_cleanup;
424
425                 err = ovl_set_upper_acl(newdentry, XATTR_NAME_POSIX_ACL_DEFAULT,
426                                         default_acl);
427                 if (err)
428                         goto out_cleanup;
429         }
430
431         if (!hardlink && S_ISDIR(cattr->mode)) {
432                 err = ovl_set_opaque(dentry, newdentry);
433                 if (err)
434                         goto out_cleanup;
435
436                 err = ovl_do_rename(wdir, newdentry, udir, upper,
437                                     RENAME_EXCHANGE);
438                 if (err)
439                         goto out_cleanup;
440
441                 ovl_cleanup(wdir, upper);
442         } else {
443                 err = ovl_do_rename(wdir, newdentry, udir, upper, 0);
444                 if (err)
445                         goto out_cleanup;
446         }
447         ovl_instantiate(dentry, inode, newdentry, !!hardlink);
448         newdentry = NULL;
449 out_dput2:
450         dput(upper);
451 out_dput:
452         dput(newdentry);
453 out_unlock:
454         unlock_rename(workdir, upperdir);
455 out:
456         if (!hardlink) {
457                 posix_acl_release(acl);
458                 posix_acl_release(default_acl);
459         }
460         return err;
461
462 out_cleanup:
463         ovl_cleanup(wdir, newdentry);
464         goto out_dput2;
465 }
466
467 static int ovl_create_or_link(struct dentry *dentry, struct inode *inode,
468                               struct cattr *attr, struct dentry *hardlink,
469                               bool origin)
470 {
471         int err;
472         const struct cred *old_cred;
473         struct cred *override_cred;
474         struct dentry *parent = dentry->d_parent;
475
476         err = ovl_copy_up(parent);
477         if (err)
478                 return err;
479
480         old_cred = ovl_override_creds(dentry->d_sb);
481
482         /*
483          * When linking a file with copy up origin into a new parent, mark the
484          * new parent dir "impure".
485          */
486         if (origin) {
487                 err = ovl_set_impure(parent, ovl_dentry_upper(parent));
488                 if (err)
489                         goto out_revert_creds;
490         }
491
492         err = -ENOMEM;
493         override_cred = prepare_creds();
494         if (override_cred) {
495                 override_cred->fsuid = inode->i_uid;
496                 override_cred->fsgid = inode->i_gid;
497                 if (!hardlink) {
498                         err = security_dentry_create_files_as(dentry,
499                                         attr->mode, &dentry->d_name, old_cred,
500                                         override_cred);
501                         if (err) {
502                                 put_cred(override_cred);
503                                 goto out_revert_creds;
504                         }
505                 }
506                 put_cred(override_creds(override_cred));
507                 put_cred(override_cred);
508
509                 if (!ovl_dentry_is_whiteout(dentry))
510                         err = ovl_create_upper(dentry, inode, attr,
511                                                 hardlink);
512                 else
513                         err = ovl_create_over_whiteout(dentry, inode, attr,
514                                                         hardlink);
515         }
516 out_revert_creds:
517         revert_creds(old_cred);
518         if (!err) {
519                 struct inode *realinode = d_inode(ovl_dentry_upper(dentry));
520
521                 WARN_ON(inode->i_mode != realinode->i_mode);
522                 WARN_ON(!uid_eq(inode->i_uid, realinode->i_uid));
523                 WARN_ON(!gid_eq(inode->i_gid, realinode->i_gid));
524         }
525         return err;
526 }
527
528 static int ovl_create_object(struct dentry *dentry, int mode, dev_t rdev,
529                              const char *link)
530 {
531         int err;
532         struct inode *inode;
533         struct cattr attr = {
534                 .rdev = rdev,
535                 .link = link,
536         };
537
538         err = ovl_want_write(dentry);
539         if (err)
540                 goto out;
541
542         err = -ENOMEM;
543         inode = ovl_new_inode(dentry->d_sb, mode, rdev);
544         if (!inode)
545                 goto out_drop_write;
546
547         inode_init_owner(inode, dentry->d_parent->d_inode, mode);
548         attr.mode = inode->i_mode;
549
550         err = ovl_create_or_link(dentry, inode, &attr, NULL, false);
551         if (err)
552                 iput(inode);
553
554 out_drop_write:
555         ovl_drop_write(dentry);
556 out:
557         return err;
558 }
559
560 static int ovl_create(struct inode *dir, struct dentry *dentry, umode_t mode,
561                       bool excl)
562 {
563         return ovl_create_object(dentry, (mode & 07777) | S_IFREG, 0, NULL);
564 }
565
566 static int ovl_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
567 {
568         return ovl_create_object(dentry, (mode & 07777) | S_IFDIR, 0, NULL);
569 }
570
571 static int ovl_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
572                      dev_t rdev)
573 {
574         /* Don't allow creation of "whiteout" on overlay */
575         if (S_ISCHR(mode) && rdev == WHITEOUT_DEV)
576                 return -EPERM;
577
578         return ovl_create_object(dentry, mode, rdev, NULL);
579 }
580
581 static int ovl_symlink(struct inode *dir, struct dentry *dentry,
582                        const char *link)
583 {
584         return ovl_create_object(dentry, S_IFLNK, 0, link);
585 }
586
587 static int ovl_link(struct dentry *old, struct inode *newdir,
588                     struct dentry *new)
589 {
590         int err;
591         bool locked = false;
592         struct inode *inode;
593
594         err = ovl_want_write(old);
595         if (err)
596                 goto out;
597
598         err = ovl_copy_up(old);
599         if (err)
600                 goto out_drop_write;
601
602         err = ovl_nlink_start(old, &locked);
603         if (err)
604                 goto out_drop_write;
605
606         inode = d_inode(old);
607         ihold(inode);
608
609         err = ovl_create_or_link(new, inode, NULL, ovl_dentry_upper(old),
610                                  ovl_type_origin(old));
611         if (err)
612                 iput(inode);
613
614         ovl_nlink_end(old, locked);
615 out_drop_write:
616         ovl_drop_write(old);
617 out:
618         return err;
619 }
620
621 static bool ovl_matches_upper(struct dentry *dentry, struct dentry *upper)
622 {
623         return d_inode(ovl_dentry_upper(dentry)) == d_inode(upper);
624 }
625
626 static int ovl_remove_and_whiteout(struct dentry *dentry, bool is_dir)
627 {
628         struct dentry *workdir = ovl_workdir(dentry);
629         struct inode *wdir = workdir->d_inode;
630         struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
631         struct inode *udir = upperdir->d_inode;
632         struct dentry *whiteout;
633         struct dentry *upper;
634         struct dentry *opaquedir = NULL;
635         int err;
636         int flags = 0;
637
638         if (WARN_ON(!workdir))
639                 return -EROFS;
640
641         if (is_dir) {
642                 opaquedir = ovl_check_empty_and_clear(dentry);
643                 err = PTR_ERR(opaquedir);
644                 if (IS_ERR(opaquedir))
645                         goto out;
646         }
647
648         err = ovl_lock_rename_workdir(workdir, upperdir);
649         if (err)
650                 goto out_dput;
651
652         upper = lookup_one_len(dentry->d_name.name, upperdir,
653                                dentry->d_name.len);
654         err = PTR_ERR(upper);
655         if (IS_ERR(upper))
656                 goto out_unlock;
657
658         err = -ESTALE;
659         if ((opaquedir && upper != opaquedir) ||
660             (!opaquedir && ovl_dentry_upper(dentry) &&
661              !ovl_matches_upper(dentry, upper))) {
662                 goto out_dput_upper;
663         }
664
665         whiteout = ovl_whiteout(workdir, dentry);
666         err = PTR_ERR(whiteout);
667         if (IS_ERR(whiteout))
668                 goto out_dput_upper;
669
670         if (d_is_dir(upper))
671                 flags = RENAME_EXCHANGE;
672
673         err = ovl_do_rename(wdir, whiteout, udir, upper, flags);
674         if (err)
675                 goto kill_whiteout;
676         if (flags)
677                 ovl_cleanup(wdir, upper);
678
679         ovl_dentry_version_inc(dentry->d_parent, true);
680 out_d_drop:
681         d_drop(dentry);
682         dput(whiteout);
683 out_dput_upper:
684         dput(upper);
685 out_unlock:
686         unlock_rename(workdir, upperdir);
687 out_dput:
688         dput(opaquedir);
689 out:
690         return err;
691
692 kill_whiteout:
693         ovl_cleanup(wdir, whiteout);
694         goto out_d_drop;
695 }
696
697 static int ovl_remove_upper(struct dentry *dentry, bool is_dir)
698 {
699         struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
700         struct inode *dir = upperdir->d_inode;
701         struct dentry *upper;
702         struct dentry *opaquedir = NULL;
703         int err;
704
705         /* Redirect/origin dir can be !ovl_lower_positive && not clean */
706         if (is_dir && (ovl_dentry_get_redirect(dentry) ||
707                        ovl_may_have_whiteouts(dentry))) {
708                 opaquedir = ovl_check_empty_and_clear(dentry);
709                 err = PTR_ERR(opaquedir);
710                 if (IS_ERR(opaquedir))
711                         goto out;
712         }
713
714         inode_lock_nested(dir, I_MUTEX_PARENT);
715         upper = lookup_one_len(dentry->d_name.name, upperdir,
716                                dentry->d_name.len);
717         err = PTR_ERR(upper);
718         if (IS_ERR(upper))
719                 goto out_unlock;
720
721         err = -ESTALE;
722         if ((opaquedir && upper != opaquedir) ||
723             (!opaquedir && !ovl_matches_upper(dentry, upper)))
724                 goto out_dput_upper;
725
726         if (is_dir)
727                 err = vfs_rmdir(dir, upper);
728         else
729                 err = vfs_unlink(dir, upper, NULL);
730         ovl_dentry_version_inc(dentry->d_parent, ovl_type_origin(dentry));
731
732         /*
733          * Keeping this dentry hashed would mean having to release
734          * upperpath/lowerpath, which could only be done if we are the
735          * sole user of this dentry.  Too tricky...  Just unhash for
736          * now.
737          */
738         if (!err)
739                 d_drop(dentry);
740 out_dput_upper:
741         dput(upper);
742 out_unlock:
743         inode_unlock(dir);
744         dput(opaquedir);
745 out:
746         return err;
747 }
748
749 static int ovl_do_remove(struct dentry *dentry, bool is_dir)
750 {
751         int err;
752         bool locked = false;
753         const struct cred *old_cred;
754
755         err = ovl_want_write(dentry);
756         if (err)
757                 goto out;
758
759         err = ovl_copy_up(dentry->d_parent);
760         if (err)
761                 goto out_drop_write;
762
763         err = ovl_nlink_start(dentry, &locked);
764         if (err)
765                 goto out_drop_write;
766
767         old_cred = ovl_override_creds(dentry->d_sb);
768         if (!ovl_lower_positive(dentry))
769                 err = ovl_remove_upper(dentry, is_dir);
770         else
771                 err = ovl_remove_and_whiteout(dentry, is_dir);
772         revert_creds(old_cred);
773         if (!err) {
774                 if (is_dir)
775                         clear_nlink(dentry->d_inode);
776                 else
777                         drop_nlink(dentry->d_inode);
778         }
779         ovl_nlink_end(dentry, locked);
780 out_drop_write:
781         ovl_drop_write(dentry);
782 out:
783         return err;
784 }
785
786 static int ovl_unlink(struct inode *dir, struct dentry *dentry)
787 {
788         return ovl_do_remove(dentry, false);
789 }
790
791 static int ovl_rmdir(struct inode *dir, struct dentry *dentry)
792 {
793         return ovl_do_remove(dentry, true);
794 }
795
796 static bool ovl_type_merge_or_lower(struct dentry *dentry)
797 {
798         enum ovl_path_type type = ovl_path_type(dentry);
799
800         return OVL_TYPE_MERGE(type) || !OVL_TYPE_UPPER(type);
801 }
802
803 static bool ovl_can_move(struct dentry *dentry)
804 {
805         return ovl_redirect_dir(dentry->d_sb) ||
806                 !d_is_dir(dentry) || !ovl_type_merge_or_lower(dentry);
807 }
808
809 static char *ovl_get_redirect(struct dentry *dentry, bool samedir)
810 {
811         char *buf, *ret;
812         struct dentry *d, *tmp;
813         int buflen = ovl_redirect_max + 1;
814
815         if (samedir) {
816                 ret = kstrndup(dentry->d_name.name, dentry->d_name.len,
817                                GFP_KERNEL);
818                 goto out;
819         }
820
821         buf = ret = kmalloc(buflen, GFP_KERNEL);
822         if (!buf)
823                 goto out;
824
825         buflen--;
826         buf[buflen] = '\0';
827         for (d = dget(dentry); !IS_ROOT(d);) {
828                 const char *name;
829                 int thislen;
830
831                 spin_lock(&d->d_lock);
832                 name = ovl_dentry_get_redirect(d);
833                 if (name) {
834                         thislen = strlen(name);
835                 } else {
836                         name = d->d_name.name;
837                         thislen = d->d_name.len;
838                 }
839
840                 /* If path is too long, fall back to userspace move */
841                 if (thislen + (name[0] != '/') > buflen) {
842                         ret = ERR_PTR(-EXDEV);
843                         spin_unlock(&d->d_lock);
844                         goto out_put;
845                 }
846
847                 buflen -= thislen;
848                 memcpy(&buf[buflen], name, thislen);
849                 tmp = dget_dlock(d->d_parent);
850                 spin_unlock(&d->d_lock);
851
852                 dput(d);
853                 d = tmp;
854
855                 /* Absolute redirect: finished */
856                 if (buf[buflen] == '/')
857                         break;
858                 buflen--;
859                 buf[buflen] = '/';
860         }
861         ret = kstrdup(&buf[buflen], GFP_KERNEL);
862 out_put:
863         dput(d);
864         kfree(buf);
865 out:
866         return ret ? ret : ERR_PTR(-ENOMEM);
867 }
868
869 static int ovl_set_redirect(struct dentry *dentry, bool samedir)
870 {
871         int err;
872         const char *redirect = ovl_dentry_get_redirect(dentry);
873
874         if (redirect && (samedir || redirect[0] == '/'))
875                 return 0;
876
877         redirect = ovl_get_redirect(dentry, samedir);
878         if (IS_ERR(redirect))
879                 return PTR_ERR(redirect);
880
881         err = ovl_check_setxattr(dentry, ovl_dentry_upper(dentry),
882                                  OVL_XATTR_REDIRECT,
883                                  redirect, strlen(redirect), -EXDEV);
884         if (!err) {
885                 spin_lock(&dentry->d_lock);
886                 ovl_dentry_set_redirect(dentry, redirect);
887                 spin_unlock(&dentry->d_lock);
888         } else {
889                 kfree(redirect);
890                 pr_warn_ratelimited("overlayfs: failed to set redirect (%i)\n",
891                                     err);
892                 /* Fall back to userspace copy-up */
893                 err = -EXDEV;
894         }
895         return err;
896 }
897
898 static int ovl_rename(struct inode *olddir, struct dentry *old,
899                       struct inode *newdir, struct dentry *new,
900                       unsigned int flags)
901 {
902         int err;
903         bool locked = false;
904         struct dentry *old_upperdir;
905         struct dentry *new_upperdir;
906         struct dentry *olddentry;
907         struct dentry *newdentry;
908         struct dentry *trap;
909         bool old_opaque;
910         bool new_opaque;
911         bool cleanup_whiteout = false;
912         bool overwrite = !(flags & RENAME_EXCHANGE);
913         bool is_dir = d_is_dir(old);
914         bool new_is_dir = d_is_dir(new);
915         bool samedir = olddir == newdir;
916         struct dentry *opaquedir = NULL;
917         const struct cred *old_cred = NULL;
918
919         err = -EINVAL;
920         if (flags & ~(RENAME_EXCHANGE | RENAME_NOREPLACE))
921                 goto out;
922
923         flags &= ~RENAME_NOREPLACE;
924
925         /* Don't copy up directory trees */
926         err = -EXDEV;
927         if (!ovl_can_move(old))
928                 goto out;
929         if (!overwrite && !ovl_can_move(new))
930                 goto out;
931
932         err = ovl_want_write(old);
933         if (err)
934                 goto out;
935
936         err = ovl_copy_up(old);
937         if (err)
938                 goto out_drop_write;
939
940         err = ovl_copy_up(new->d_parent);
941         if (err)
942                 goto out_drop_write;
943         if (!overwrite) {
944                 err = ovl_copy_up(new);
945                 if (err)
946                         goto out_drop_write;
947         } else {
948                 err = ovl_nlink_start(new, &locked);
949                 if (err)
950                         goto out_drop_write;
951         }
952
953         old_cred = ovl_override_creds(old->d_sb);
954
955         if (overwrite && new_is_dir && (ovl_type_merge_or_lower(new) ||
956                                         ovl_may_have_whiteouts(new))) {
957                 opaquedir = ovl_check_empty_and_clear(new);
958                 err = PTR_ERR(opaquedir);
959                 if (IS_ERR(opaquedir)) {
960                         opaquedir = NULL;
961                         goto out_revert_creds;
962                 }
963         }
964
965         if (overwrite) {
966                 if (ovl_lower_positive(old)) {
967                         if (!ovl_dentry_is_whiteout(new)) {
968                                 /* Whiteout source */
969                                 flags |= RENAME_WHITEOUT;
970                         } else {
971                                 /* Switch whiteouts */
972                                 flags |= RENAME_EXCHANGE;
973                         }
974                 } else if (is_dir && ovl_dentry_is_whiteout(new)) {
975                         flags |= RENAME_EXCHANGE;
976                         cleanup_whiteout = true;
977                 }
978         }
979
980         old_upperdir = ovl_dentry_upper(old->d_parent);
981         new_upperdir = ovl_dentry_upper(new->d_parent);
982
983         if (!samedir) {
984                 /*
985                  * When moving a merge dir or non-dir with copy up origin into
986                  * a new parent, we are marking the new parent dir "impure".
987                  * When ovl_iterate() iterates an "impure" upper dir, it will
988                  * lookup the origin inodes of the entries to fill d_ino.
989                  */
990                 if (ovl_type_origin(old)) {
991                         err = ovl_set_impure(new->d_parent, new_upperdir);
992                         if (err)
993                                 goto out_revert_creds;
994                 }
995                 if (!overwrite && ovl_type_origin(new)) {
996                         err = ovl_set_impure(old->d_parent, old_upperdir);
997                         if (err)
998                                 goto out_revert_creds;
999                 }
1000         }
1001
1002         trap = lock_rename(new_upperdir, old_upperdir);
1003
1004         olddentry = lookup_one_len(old->d_name.name, old_upperdir,
1005                                    old->d_name.len);
1006         err = PTR_ERR(olddentry);
1007         if (IS_ERR(olddentry))
1008                 goto out_unlock;
1009
1010         err = -ESTALE;
1011         if (!ovl_matches_upper(old, olddentry))
1012                 goto out_dput_old;
1013
1014         newdentry = lookup_one_len(new->d_name.name, new_upperdir,
1015                                    new->d_name.len);
1016         err = PTR_ERR(newdentry);
1017         if (IS_ERR(newdentry))
1018                 goto out_dput_old;
1019
1020         old_opaque = ovl_dentry_is_opaque(old);
1021         new_opaque = ovl_dentry_is_opaque(new);
1022
1023         err = -ESTALE;
1024         if (d_inode(new) && ovl_dentry_upper(new)) {
1025                 if (opaquedir) {
1026                         if (newdentry != opaquedir)
1027                                 goto out_dput;
1028                 } else {
1029                         if (!ovl_matches_upper(new, newdentry))
1030                                 goto out_dput;
1031                 }
1032         } else {
1033                 if (!d_is_negative(newdentry) &&
1034                     (!new_opaque || !ovl_is_whiteout(newdentry)))
1035                         goto out_dput;
1036         }
1037
1038         if (olddentry == trap)
1039                 goto out_dput;
1040         if (newdentry == trap)
1041                 goto out_dput;
1042
1043         if (WARN_ON(olddentry->d_inode == newdentry->d_inode))
1044                 goto out_dput;
1045
1046         err = 0;
1047         if (is_dir) {
1048                 if (ovl_type_merge_or_lower(old))
1049                         err = ovl_set_redirect(old, samedir);
1050                 else if (!old_opaque && ovl_type_merge(new->d_parent))
1051                         err = ovl_set_opaque_xerr(old, olddentry, -EXDEV);
1052                 if (err)
1053                         goto out_dput;
1054         }
1055         if (!overwrite && new_is_dir) {
1056                 if (ovl_type_merge_or_lower(new))
1057                         err = ovl_set_redirect(new, samedir);
1058                 else if (!new_opaque && ovl_type_merge(old->d_parent))
1059                         err = ovl_set_opaque_xerr(new, newdentry, -EXDEV);
1060                 if (err)
1061                         goto out_dput;
1062         }
1063
1064         err = ovl_do_rename(old_upperdir->d_inode, olddentry,
1065                             new_upperdir->d_inode, newdentry, flags);
1066         if (err)
1067                 goto out_dput;
1068
1069         if (cleanup_whiteout)
1070                 ovl_cleanup(old_upperdir->d_inode, newdentry);
1071
1072         if (overwrite && d_inode(new)) {
1073                 if (new_is_dir)
1074                         clear_nlink(d_inode(new));
1075                 else
1076                         drop_nlink(d_inode(new));
1077         }
1078
1079         ovl_dentry_version_inc(old->d_parent, ovl_type_origin(old) ||
1080                                (!overwrite && ovl_type_origin(new)));
1081         ovl_dentry_version_inc(new->d_parent, ovl_type_origin(old) ||
1082                                (d_inode(new) && ovl_type_origin(new)));
1083
1084 out_dput:
1085         dput(newdentry);
1086 out_dput_old:
1087         dput(olddentry);
1088 out_unlock:
1089         unlock_rename(new_upperdir, old_upperdir);
1090 out_revert_creds:
1091         revert_creds(old_cred);
1092         ovl_nlink_end(new, locked);
1093 out_drop_write:
1094         ovl_drop_write(old);
1095 out:
1096         dput(opaquedir);
1097         return err;
1098 }
1099
1100 const struct inode_operations ovl_dir_inode_operations = {
1101         .lookup         = ovl_lookup,
1102         .mkdir          = ovl_mkdir,
1103         .symlink        = ovl_symlink,
1104         .unlink         = ovl_unlink,
1105         .rmdir          = ovl_rmdir,
1106         .rename         = ovl_rename,
1107         .link           = ovl_link,
1108         .setattr        = ovl_setattr,
1109         .create         = ovl_create,
1110         .mknod          = ovl_mknod,
1111         .permission     = ovl_permission,
1112         .getattr        = ovl_getattr,
1113         .listxattr      = ovl_listxattr,
1114         .get_acl        = ovl_get_acl,
1115         .update_time    = ovl_update_time,
1116 };