source: trunk/target/linux/generic/patches-3.2/100-overlayfs_v11.patch @ 30767

Last change on this file since 30767 was 30767, checked in by juhosg, 4 years ago

kernel: update linux 3.2 to 3.2.9

File size: 78.3 KB
  • new file Documentation/filesystems/overlayfs.txt

    - +  
     1Written by: Neil Brown <neilb@suse.de> 
     2 
     3Overlay Filesystem 
     4================== 
     5 
     6This document describes a prototype for a new approach to providing 
     7overlay-filesystem functionality in Linux (sometimes referred to as 
     8union-filesystems).  An overlay-filesystem tries to present a 
     9filesystem which is the result over overlaying one filesystem on top 
     10of the other. 
     11 
     12The result will inevitably fail to look exactly like a normal 
     13filesystem for various technical reasons.  The expectation is that 
     14many use cases will be able to ignore these differences. 
     15 
     16This approach is 'hybrid' because the objects that appear in the 
     17filesystem do not all appear to belong to that filesystem.  In many 
     18cases an object accessed in the union will be indistinguishable 
     19from accessing the corresponding object from the original filesystem. 
     20This is most obvious from the 'st_dev' field returned by stat(2). 
     21 
     22While directories will report an st_dev from the overlay-filesystem, 
     23all non-directory objects will report an st_dev from the lower or 
     24upper filesystem that is providing the object.  Similarly st_ino will 
     25only be unique when combined with st_dev, and both of these can change 
     26over the lifetime of a non-directory object.  Many applications and 
     27tools ignore these values and will not be affected. 
     28 
     29Upper and Lower 
     30--------------- 
     31 
     32An overlay filesystem combines two filesystems - an 'upper' filesystem 
     33and a 'lower' filesystem.  When a name exists in both filesystems, the 
     34object in the 'upper' filesystem is visible while the object in the 
     35'lower' filesystem is either hidden or, in the case of directories, 
     36merged with the 'upper' object. 
     37 
     38It would be more correct to refer to an upper and lower 'directory 
     39tree' rather than 'filesystem' as it is quite possible for both 
     40directory trees to be in the same filesystem and there is no 
     41requirement that the root of a filesystem be given for either upper or 
     42lower. 
     43 
     44The lower filesystem can be any filesystem supported by Linux and does 
     45not need to be writable.  The lower filesystem can even be another 
     46overlayfs.  The upper filesystem will normally be writable and if it 
     47is it must support the creation of trusted.* extended attributes, and 
     48must provide valid d_type in readdir responses, at least for symbolic 
     49links - so NFS is not suitable. 
     50 
     51A read-only overlay of two read-only filesystems may use any 
     52filesystem type. 
     53 
     54Directories 
     55----------- 
     56 
     57Overlaying mainly involved directories.  If a given name appears in both 
     58upper and lower filesystems and refers to a non-directory in either, 
     59then the lower object is hidden - the name refers only to the upper 
     60object. 
     61 
     62Where both upper and lower objects are directories, a merged directory 
     63is formed. 
     64 
     65At mount time, the two directories given as mount options are combined 
     66into a merged directory: 
     67 
     68  mount -t overlayfs overlayfs -olowerdir=/lower,upperdir=/upper /overlay 
     69 
     70Then whenever a lookup is requested in such a merged directory, the 
     71lookup is performed in each actual directory and the combined result 
     72is cached in the dentry belonging to the overlay filesystem.  If both 
     73actual lookups find directories, both are stored and a merged 
     74directory is created, otherwise only one is stored: the upper if it 
     75exists, else the lower. 
     76 
     77Only the lists of names from directories are merged.  Other content 
     78such as metadata and extended attributes are reported for the upper 
     79directory only.  These attributes of the lower directory are hidden. 
     80 
     81whiteouts and opaque directories 
     82-------------------------------- 
     83 
     84In order to support rm and rmdir without changing the lower 
     85filesystem, an overlay filesystem needs to record in the upper filesystem 
     86that files have been removed.  This is done using whiteouts and opaque 
     87directories (non-directories are always opaque). 
     88 
     89The overlay filesystem uses extended attributes with a 
     90"trusted.overlay."  prefix to record these details. 
     91 
     92A whiteout is created as a symbolic link with target 
     93"(overlay-whiteout)" and with xattr "trusted.overlay.whiteout" set to "y". 
     94When a whiteout is found in the upper level of a merged directory, any 
     95matching name in the lower level is ignored, and the whiteout itself 
     96is also hidden. 
     97 
     98A directory is made opaque by setting the xattr "trusted.overlay.opaque" 
     99to "y".  Where the upper filesystem contains an opaque directory, any 
     100directory in the lower filesystem with the same name is ignored. 
     101 
     102readdir 
     103------- 
     104 
     105When a 'readdir' request is made on a merged directory, the upper and 
     106lower directories are each read and the name lists merged in the 
     107obvious way (upper is read first, then lower - entries that already 
     108exist are not re-added).  This merged name list is cached in the 
     109'struct file' and so remains as long as the file is kept open.  If the 
     110directory is opened and read by two processes at the same time, they 
     111will each have separate caches.  A seekdir to the start of the 
     112directory (offset 0) followed by a readdir will cause the cache to be 
     113discarded and rebuilt. 
     114 
     115This means that changes to the merged directory do not appear while a 
     116directory is being read.  This is unlikely to be noticed by many 
     117programs. 
     118 
     119seek offsets are assigned sequentially when the directories are read. 
     120Thus if 
     121  - read part of a directory 
     122  - remember an offset, and close the directory 
     123  - re-open the directory some time later 
     124  - seek to the remembered offset 
     125 
     126there may be little correlation between the old and new locations in 
     127the list of filenames, particularly if anything has changed in the 
     128directory. 
     129 
     130Readdir on directories that are not merged is simply handled by the 
     131underlying directory (upper or lower). 
     132 
     133 
     134Non-directories 
     135--------------- 
     136 
     137Objects that are not directories (files, symlinks, device-special 
     138files etc.) are presented either from the upper or lower filesystem as 
     139appropriate.  When a file in the lower filesystem is accessed in a way 
     140the requires write-access, such as opening for write access, changing 
     141some metadata etc., the file is first copied from the lower filesystem 
     142to the upper filesystem (copy_up).  Note that creating a hard-link 
     143also requires copy_up, though of course creation of a symlink does 
     144not. 
     145 
     146The copy_up may turn out to be unnecessary, for example if the file is 
     147opened for read-write but the data is not modified. 
     148 
     149The copy_up process first makes sure that the containing directory 
     150exists in the upper filesystem - creating it and any parents as 
     151necessary.  It then creates the object with the same metadata (owner, 
     152mode, mtime, symlink-target etc.) and then if the object is a file, the 
     153data is copied from the lower to the upper filesystem.  Finally any 
     154extended attributes are copied up. 
     155 
     156Once the copy_up is complete, the overlay filesystem simply 
     157provides direct access to the newly created file in the upper 
     158filesystem - future operations on the file are barely noticed by the 
     159overlay filesystem (though an operation on the name of the file such as 
     160rename or unlink will of course be noticed and handled). 
     161 
     162 
     163Non-standard behavior 
     164--------------------- 
     165 
     166The copy_up operation essentially creates a new, identical file and 
     167moves it over to the old name.  The new file may be on a different 
     168filesystem, so both st_dev and st_ino of the file may change. 
     169 
     170Any open files referring to this inode will access the old data and 
     171metadata.  Similarly any file locks obtained before copy_up will not 
     172apply to the copied up file. 
     173 
     174On a file is opened with O_RDONLY fchmod(2), fchown(2), futimesat(2) 
     175and fsetxattr(2) will fail with EROFS. 
     176 
     177If a file with multiple hard links is copied up, then this will 
     178"break" the link.  Changes will not be propagated to other names 
     179referring to the same inode. 
     180 
     181Symlinks in /proc/PID/ and /proc/PID/fd which point to a non-directory 
     182object in overlayfs will not contain vaid absolute paths, only 
     183relative paths leading up to the filesystem's root.  This will be 
     184fixed in the future. 
     185 
     186Some operations are not atomic, for example a crash during copy_up or 
     187rename will leave the filesystem in an inconsitent state.  This will 
     188be addressed in the future. 
     189 
     190Changes to underlying filesystems 
     191--------------------------------- 
     192 
     193Offline changes, when the overlay is not mounted, are allowed to either 
     194the upper or the lower trees. 
     195 
     196Changes to the underlying filesystems while part of a mounted overlay 
     197filesystem are not allowed.  If the underlying filesystem is changed, 
     198the behavior of the overlay is undefined, though it will not result in 
     199a crash or deadlock. 
  • MAINTAINERS

    a b F: drivers/scsi/osd/ 
    49014901F:      include/scsi/osd_* 
    49024902F:      fs/exofs/ 
    49034903 
     4904OVERLAYFS FILESYSTEM 
     4905M:      Miklos Szeredi <miklos@szeredi.hu> 
     4906L:      linux-fsdevel@vger.kernel.org 
     4907S:      Supported 
     4908F:      fs/overlayfs/* 
     4909F:      Documentation/filesystems/overlayfs.txt 
     4910 
    49044911P54 WIRELESS DRIVER 
    49054912M:      Christian Lamparter <chunkeey@googlemail.com> 
    49064913L:      linux-wireless@vger.kernel.org 
  • fs/Kconfig

    a b source "fs/quota/Kconfig" 
    6363 
    6464source "fs/autofs4/Kconfig" 
    6565source "fs/fuse/Kconfig" 
     66source "fs/overlayfs/Kconfig" 
    6667 
    6768config CUSE 
    6869        tristate "Character device in Userspace support" 
  • fs/Makefile

    a b obj-$(CONFIG_QNX4FS_FS) += qnx4/ 
    104104obj-$(CONFIG_AUTOFS4_FS)        += autofs4/ 
    105105obj-$(CONFIG_ADFS_FS)           += adfs/ 
    106106obj-$(CONFIG_FUSE_FS)           += fuse/ 
     107obj-$(CONFIG_OVERLAYFS_FS)      += overlayfs/ 
    107108obj-$(CONFIG_UDF_FS)            += udf/ 
    108109obj-$(CONFIG_SUN_OPENPROMFS)    += openpromfs/ 
    109110obj-$(CONFIG_OMFS_FS)           += omfs/ 
  • fs/ecryptfs/main.c

    a b static struct dentry *ecryptfs_mount(str 
    544544        s->s_maxbytes = path.dentry->d_sb->s_maxbytes; 
    545545        s->s_blocksize = path.dentry->d_sb->s_blocksize; 
    546546        s->s_magic = ECRYPTFS_SUPER_MAGIC; 
     547        s->s_stack_depth = path.dentry->d_sb->s_stack_depth + 1; 
     548 
     549        rc = -EINVAL; 
     550        if (s->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 
     551                printk(KERN_ERR "eCryptfs: maximum fs stacking depth exceeded\n"); 
     552                goto out_free; 
     553        } 
    547554 
    548555        inode = ecryptfs_get_inode(path.dentry->d_inode, s); 
    549556        rc = PTR_ERR(inode); 
  • fs/namespace.c

    a b void drop_collected_mounts(struct vfsmou 
    14921492        release_mounts(&umount_list); 
    14931493} 
    14941494 
     1495struct vfsmount *clone_private_mount(struct path *path) 
     1496{ 
     1497        struct vfsmount *mnt; 
     1498 
     1499        if (IS_MNT_UNBINDABLE(path->mnt)) 
     1500                return ERR_PTR(-EINVAL); 
     1501 
     1502        down_read(&namespace_sem); 
     1503        mnt = clone_mnt(path->mnt, path->dentry, CL_PRIVATE); 
     1504        up_read(&namespace_sem); 
     1505        if (!mnt) 
     1506                return ERR_PTR(-ENOMEM); 
     1507 
     1508        return mnt; 
     1509} 
     1510EXPORT_SYMBOL_GPL(clone_private_mount); 
     1511 
    14951512int iterate_mounts(int (*f)(struct vfsmount *, void *), void *arg, 
    14961513                   struct vfsmount *root) 
    14971514{ 
  • fs/open.c

    a b static inline int __get_file_write_acces 
    644644        return error; 
    645645} 
    646646 
    647 static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt, 
    648                                         struct file *f, 
     647static struct file *__dentry_open(struct path *path, struct file *f, 
    649648                                        int (*open)(struct inode *, struct file *), 
    650649                                        const struct cred *cred) 
    651650{ 
    static struct file *__dentry_open(struct 
    653652        struct inode *inode; 
    654653        int error; 
    655654 
     655        path_get(path); 
    656656        f->f_mode = OPEN_FMODE(f->f_flags) | FMODE_LSEEK | 
    657657                                FMODE_PREAD | FMODE_PWRITE; 
    658658 
    659659        if (unlikely(f->f_flags & O_PATH)) 
    660660                f->f_mode = FMODE_PATH; 
    661661 
    662         inode = dentry->d_inode; 
     662        inode = path->dentry->d_inode; 
    663663        if (f->f_mode & FMODE_WRITE) { 
    664                 error = __get_file_write_access(inode, mnt); 
     664                error = __get_file_write_access(inode, path->mnt); 
    665665                if (error) 
    666666                        goto cleanup_file; 
    667667                if (!special_file(inode->i_mode)) 
    static struct file *__dentry_open(struct 
    669669        } 
    670670 
    671671        f->f_mapping = inode->i_mapping; 
    672         f->f_path.dentry = dentry; 
    673         f->f_path.mnt = mnt; 
     672        f->f_path = *path; 
    674673        f->f_pos = 0; 
    675674        file_sb_list_add(f, inode->i_sb); 
    676675 
    cleanup_all: 
    727726                         * here, so just reset the state. 
    728727                         */ 
    729728                        file_reset_write(f); 
    730                         mnt_drop_write(mnt); 
     729                        mnt_drop_write(path->mnt); 
    731730                } 
    732731        } 
    733732        file_sb_list_del(f); 
    cleanup_all: 
    735734        f->f_path.mnt = NULL; 
    736735cleanup_file: 
    737736        put_filp(f); 
    738         dput(dentry); 
    739         mntput(mnt); 
     737        path_put(path); 
    740738        return ERR_PTR(error); 
    741739} 
    742740 
    cleanup_file: 
    762760struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry *dentry, 
    763761                int (*open)(struct inode *, struct file *)) 
    764762{ 
     763        struct path path = { .dentry = dentry, .mnt = nd->path.mnt }; 
    765764        const struct cred *cred = current_cred(); 
    766765 
    767766        if (IS_ERR(nd->intent.open.file)) 
    768767                goto out; 
    769768        if (IS_ERR(dentry)) 
    770769                goto out_err; 
    771         nd->intent.open.file = __dentry_open(dget(dentry), mntget(nd->path.mnt), 
    772                                              nd->intent.open.file, 
     770        nd->intent.open.file = __dentry_open(&path, nd->intent.open.file, 
    773771                                             open, cred); 
    774772out: 
    775773        return nd->intent.open.file; 
    struct file *nameidata_to_filp(struct na 
    798796 
    799797        /* Has the filesystem initialised the file for us? */ 
    800798        if (filp->f_path.dentry == NULL) { 
    801                 path_get(&nd->path); 
    802                 filp = __dentry_open(nd->path.dentry, nd->path.mnt, filp, 
    803                                      NULL, cred); 
     799                struct inode *inode = nd->path.dentry->d_inode; 
     800 
     801                if (inode->i_op->open) { 
     802                        int flags = filp->f_flags; 
     803                        put_filp(filp); 
     804                        filp = inode->i_op->open(nd->path.dentry, flags, cred); 
     805                } else { 
     806                        filp = __dentry_open(&nd->path, filp, NULL, cred); 
     807                } 
    804808        } 
     809 
    805810        return filp; 
    806811} 
    807812 
    struct file *nameidata_to_filp(struct na 
    812817struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags, 
    813818                         const struct cred *cred) 
    814819{ 
    815         int error; 
    816         struct file *f; 
    817  
    818         validate_creds(cred); 
     820        struct path path = { .dentry = dentry, .mnt = mnt }; 
     821        struct file *ret; 
    819822 
    820823        /* We must always pass in a valid mount pointer. */ 
    821824        BUG_ON(!mnt); 
    822825 
    823         error = -ENFILE; 
     826        ret = vfs_open(&path, flags, cred); 
     827        path_put(&path); 
     828 
     829        return ret; 
     830} 
     831EXPORT_SYMBOL(dentry_open); 
     832 
     833/** 
     834 * vfs_open - open the file at the given path 
     835 * @path: path to open 
     836 * @flags: open flags 
     837 * @cred: credentials to use 
     838 * 
     839 * Open the file.  If successful, the returned file will have acquired 
     840 * an additional reference for path. 
     841 */ 
     842struct file *vfs_open(struct path *path, int flags, const struct cred *cred) 
     843{ 
     844        struct file *f; 
     845        struct inode *inode = path->dentry->d_inode; 
     846 
     847        validate_creds(cred); 
     848 
     849        if (inode->i_op->open) 
     850                return inode->i_op->open(path->dentry, flags, cred); 
    824851        f = get_empty_filp(); 
    825         if (f == NULL) { 
    826                 dput(dentry); 
    827                 mntput(mnt); 
    828                 return ERR_PTR(error); 
    829         } 
     852        if (f == NULL) 
     853                return ERR_PTR(-ENFILE); 
    830854 
    831855        f->f_flags = flags; 
    832         return __dentry_open(dentry, mnt, f, NULL, cred); 
     856        return __dentry_open(path, f, NULL, cred); 
    833857} 
    834 EXPORT_SYMBOL(dentry_open); 
     858EXPORT_SYMBOL(vfs_open); 
    835859 
    836860static void __put_unused_fd(struct files_struct *files, unsigned int fd) 
    837861{ 
  • new file fs/overlayfs/Kconfig

    - +  
     1config OVERLAYFS_FS 
     2        tristate "Overlay filesystem support" 
     3        help 
     4          Add support for overlay filesystem. 
  • new file fs/overlayfs/Makefile

    - +  
     1# 
     2# Makefile for the overlay filesystem. 
     3# 
     4 
     5obj-$(CONFIG_OVERLAYFS_FS) += overlayfs.o 
     6 
     7overlayfs-objs := super.o inode.o dir.o readdir.o copy_up.o 
  • new file 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/fs.h> 
     11#include <linux/slab.h> 
     12#include <linux/file.h> 
     13#include <linux/splice.h> 
     14#include <linux/xattr.h> 
     15#include <linux/security.h> 
     16#include <linux/uaccess.h> 
     17#include "overlayfs.h" 
     18 
     19#define OVL_COPY_UP_CHUNK_SIZE (1 << 20) 
     20 
     21static int ovl_copy_up_xattr(struct dentry *old, struct dentry *new) 
     22{ 
     23        ssize_t list_size, size; 
     24        char *buf, *name, *value; 
     25        int error; 
     26 
     27        if (!old->d_inode->i_op->getxattr || 
     28            !new->d_inode->i_op->getxattr) 
     29                return 0; 
     30 
     31        list_size = vfs_listxattr(old, NULL, 0); 
     32        if (list_size <= 0) { 
     33                if (list_size == -EOPNOTSUPP) 
     34                        return 0; 
     35                return list_size; 
     36        } 
     37 
     38        buf = kzalloc(list_size, GFP_KERNEL); 
     39        if (!buf) 
     40                return -ENOMEM; 
     41 
     42        error = -ENOMEM; 
     43        value = kmalloc(XATTR_SIZE_MAX, GFP_KERNEL); 
     44        if (!value) 
     45                goto out; 
     46 
     47        list_size = vfs_listxattr(old, buf, list_size); 
     48        if (list_size <= 0) { 
     49                error = list_size; 
     50                goto out_free_value; 
     51        } 
     52 
     53        for (name = buf; name < (buf + list_size); name += strlen(name) + 1) { 
     54                size = vfs_getxattr(old, name, value, XATTR_SIZE_MAX); 
     55                if (size <= 0) { 
     56                        error = size; 
     57                        goto out_free_value; 
     58                } 
     59                error = vfs_setxattr(new, name, value, size, 0); 
     60                if (error) 
     61                        goto out_free_value; 
     62        } 
     63 
     64out_free_value: 
     65        kfree(value); 
     66out: 
     67        kfree(buf); 
     68        return error; 
     69} 
     70 
     71static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len) 
     72{ 
     73        struct file *old_file; 
     74        struct file *new_file; 
     75        int error = 0; 
     76 
     77        if (len == 0) 
     78                return 0; 
     79 
     80        old_file = vfs_open(old, O_RDONLY, current_cred()); 
     81        if (IS_ERR(old_file)) 
     82                return PTR_ERR(old_file); 
     83 
     84        new_file = vfs_open(new, O_WRONLY, current_cred()); 
     85        if (IS_ERR(new_file)) { 
     86                error = PTR_ERR(new_file); 
     87                goto out_fput; 
     88        } 
     89 
     90        /* FIXME: copy up sparse files efficiently */ 
     91        while (len) { 
     92                loff_t offset = new_file->f_pos; 
     93                size_t this_len = OVL_COPY_UP_CHUNK_SIZE; 
     94                long bytes; 
     95 
     96                if (len < this_len) 
     97                        this_len = len; 
     98 
     99                if (signal_pending_state(TASK_KILLABLE, current)) { 
     100                        error = -EINTR; 
     101                        break; 
     102                } 
     103 
     104                bytes = do_splice_direct(old_file, &offset, new_file, this_len, 
     105                                 SPLICE_F_MOVE); 
     106                if (bytes <= 0) { 
     107                        error = bytes; 
     108                        break; 
     109                } 
     110 
     111                len -= bytes; 
     112        } 
     113 
     114        fput(new_file); 
     115out_fput: 
     116        fput(old_file); 
     117        return error; 
     118} 
     119 
     120static char *ovl_read_symlink(struct dentry *realdentry) 
     121{ 
     122        int res; 
     123        char *buf; 
     124        struct inode *inode = realdentry->d_inode; 
     125        mm_segment_t old_fs; 
     126 
     127        res = -EINVAL; 
     128        if (!inode->i_op->readlink) 
     129                goto err; 
     130 
     131        res = -ENOMEM; 
     132        buf = (char *) __get_free_page(GFP_KERNEL); 
     133        if (!buf) 
     134                goto err; 
     135 
     136        old_fs = get_fs(); 
     137        set_fs(get_ds()); 
     138        /* The cast to a user pointer is valid due to the set_fs() */ 
     139        res = inode->i_op->readlink(realdentry, 
     140                                    (char __user *)buf, PAGE_SIZE - 1); 
     141        set_fs(old_fs); 
     142        if (res < 0) { 
     143                free_page((unsigned long) buf); 
     144                goto err; 
     145        } 
     146        buf[res] = '\0'; 
     147 
     148        return buf; 
     149 
     150err: 
     151        return ERR_PTR(res); 
     152} 
     153 
     154static int ovl_set_timestamps(struct dentry *upperdentry, struct kstat *stat) 
     155{ 
     156        struct iattr attr = { 
     157                .ia_valid = ATTR_ATIME | ATTR_MTIME | ATTR_ATIME_SET | ATTR_MTIME_SET, 
     158                .ia_atime = stat->atime, 
     159                .ia_mtime = stat->mtime, 
     160        }; 
     161 
     162        return notify_change(upperdentry, &attr); 
     163} 
     164 
     165static int ovl_set_mode(struct dentry *upperdentry, umode_t mode) 
     166{ 
     167        struct iattr attr = { 
     168                .ia_valid = ATTR_MODE, 
     169                .ia_mode = mode, 
     170        }; 
     171 
     172        return notify_change(upperdentry, &attr); 
     173} 
     174 
     175static int ovl_copy_up_locked(struct dentry *upperdir, struct dentry *dentry, 
     176                              struct path *lowerpath, struct kstat *stat, 
     177                              const char *link) 
     178{ 
     179        int err; 
     180        struct path newpath; 
     181        umode_t mode = stat->mode; 
     182 
     183        /* Can't properly set mode on creation because of the umask */ 
     184        stat->mode &= S_IFMT; 
     185 
     186        ovl_path_upper(dentry, &newpath); 
     187        WARN_ON(newpath.dentry); 
     188        newpath.dentry = ovl_upper_create(upperdir, dentry, stat, link); 
     189        if (IS_ERR(newpath.dentry)) 
     190                return PTR_ERR(newpath.dentry); 
     191 
     192        if (S_ISREG(stat->mode)) { 
     193                err = ovl_copy_up_data(lowerpath, &newpath, stat->size); 
     194                if (err) 
     195                        goto err_remove; 
     196        } 
     197 
     198        err = ovl_copy_up_xattr(lowerpath->dentry, newpath.dentry); 
     199        if (err) 
     200                goto err_remove; 
     201 
     202        mutex_lock(&newpath.dentry->d_inode->i_mutex); 
     203        if (!S_ISLNK(stat->mode)) 
     204                err = ovl_set_mode(newpath.dentry, mode); 
     205        if (!err) 
     206                err = ovl_set_timestamps(newpath.dentry, stat); 
     207        mutex_unlock(&newpath.dentry->d_inode->i_mutex); 
     208        if (err) 
     209                goto err_remove; 
     210 
     211        ovl_dentry_update(dentry, newpath.dentry); 
     212 
     213        /* 
     214         * Easiest way to get rid of the lower dentry reference is to 
     215         * drop this dentry.  This is neither needed nor possible for 
     216         * directories. 
     217         */ 
     218        if (!S_ISDIR(stat->mode)) 
     219                d_drop(dentry); 
     220 
     221        return 0; 
     222 
     223err_remove: 
     224        if (S_ISDIR(stat->mode)) 
     225                vfs_rmdir(upperdir->d_inode, newpath.dentry); 
     226        else 
     227                vfs_unlink(upperdir->d_inode, newpath.dentry); 
     228 
     229        dput(newpath.dentry); 
     230 
     231        return err; 
     232} 
     233 
     234/* 
     235 * Copy up a single dentry 
     236 * 
     237 * Directory renames only allowed on "pure upper" (already created on 
     238 * upper filesystem, never copied up).  Directories which are on lower or 
     239 * are merged may not be renamed.  For these -EXDEV is returned and 
     240 * userspace has to deal with it.  This means, when copying up a 
     241 * directory we can rely on it and ancestors being stable. 
     242 * 
     243 * Non-directory renames start with copy up of source if necessary.  The 
     244 * actual rename will only proceed once the copy up was successful.  Copy 
     245 * up uses upper parent i_mutex for exclusion.  Since rename can change 
     246 * d_parent it is possible that the copy up will lock the old parent.  At 
     247 * that point the file will have already been copied up anyway. 
     248 */ 
     249static int ovl_copy_up_one(struct dentry *parent, struct dentry *dentry, 
     250                           struct path *lowerpath, struct kstat *stat) 
     251{ 
     252        int err; 
     253        struct kstat pstat; 
     254        struct path parentpath; 
     255        struct dentry *upperdir; 
     256        const struct cred *old_cred; 
     257        struct cred *override_cred; 
     258        char *link = NULL; 
     259 
     260        ovl_path_upper(parent, &parentpath); 
     261        upperdir = parentpath.dentry; 
     262 
     263        err = vfs_getattr(parentpath.mnt, parentpath.dentry, &pstat); 
     264        if (err) 
     265                return err; 
     266 
     267        if (S_ISLNK(stat->mode)) { 
     268                link = ovl_read_symlink(lowerpath->dentry); 
     269                if (IS_ERR(link)) 
     270                        return PTR_ERR(link); 
     271        } 
     272 
     273        err = -ENOMEM; 
     274        override_cred = prepare_creds(); 
     275        if (!override_cred) 
     276                goto out_free_link; 
     277 
     278        override_cred->fsuid = stat->uid; 
     279        override_cred->fsgid = stat->gid; 
     280        /* 
     281         * CAP_SYS_ADMIN for copying up extended attributes 
     282         * CAP_DAC_OVERRIDE for create 
     283         * CAP_FOWNER for chmod, timestamp update 
     284         * CAP_FSETID for chmod 
     285         * CAP_MKNOD for mknod 
     286         */ 
     287        cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     288        cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 
     289        cap_raise(override_cred->cap_effective, CAP_FOWNER); 
     290        cap_raise(override_cred->cap_effective, CAP_FSETID); 
     291        cap_raise(override_cred->cap_effective, CAP_MKNOD); 
     292        old_cred = override_creds(override_cred); 
     293 
     294        mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
     295        if (ovl_path_type(dentry) != OVL_PATH_LOWER) { 
     296                err = 0; 
     297        } else { 
     298                err = ovl_copy_up_locked(upperdir, dentry, lowerpath, 
     299                                         stat, link); 
     300                if (!err) { 
     301                        /* Restore timestamps on parent (best effort) */ 
     302                        ovl_set_timestamps(upperdir, &pstat); 
     303                } 
     304        } 
     305 
     306        mutex_unlock(&upperdir->d_inode->i_mutex); 
     307 
     308        revert_creds(old_cred); 
     309        put_cred(override_cred); 
     310 
     311out_free_link: 
     312        if (link) 
     313                free_page((unsigned long) link); 
     314 
     315        return err; 
     316} 
     317 
     318int ovl_copy_up(struct dentry *dentry) 
     319{ 
     320        int err; 
     321 
     322        err = 0; 
     323        while (!err) { 
     324                struct dentry *next; 
     325                struct dentry *parent; 
     326                struct path lowerpath; 
     327                struct kstat stat; 
     328                enum ovl_path_type type = ovl_path_type(dentry); 
     329 
     330                if (type != OVL_PATH_LOWER) 
     331                        break; 
     332 
     333                next = dget(dentry); 
     334                /* find the topmost dentry not yet copied up */ 
     335                for (;;) { 
     336                        parent = dget_parent(next); 
     337 
     338                        type = ovl_path_type(parent); 
     339                        if (type != OVL_PATH_LOWER) 
     340                                break; 
     341 
     342                        dput(next); 
     343                        next = parent; 
     344                } 
     345 
     346                ovl_path_lower(next, &lowerpath); 
     347                err = vfs_getattr(lowerpath.mnt, lowerpath.dentry, &stat); 
     348                if (!err) 
     349                        err = ovl_copy_up_one(parent, next, &lowerpath, &stat); 
     350 
     351                dput(parent); 
     352                dput(next); 
     353        } 
     354 
     355        return err; 
     356} 
     357 
     358/* Optimize by not copying up the file first and truncating later */ 
     359int ovl_copy_up_truncate(struct dentry *dentry, loff_t size) 
     360{ 
     361        int err; 
     362        struct kstat stat; 
     363        struct path lowerpath; 
     364        struct dentry *parent = dget_parent(dentry); 
     365 
     366        err = ovl_copy_up(parent); 
     367        if (err) 
     368                goto out_dput_parent; 
     369 
     370        ovl_path_lower(dentry, &lowerpath); 
     371        err = vfs_getattr(lowerpath.mnt, lowerpath.dentry, &stat); 
     372        if (err) 
     373                goto out_dput_parent; 
     374 
     375        if (size < stat.size) 
     376                stat.size = size; 
     377 
     378        err = ovl_copy_up_one(parent, dentry, &lowerpath, &stat); 
     379 
     380out_dput_parent: 
     381        dput(parent); 
     382        return err; 
     383} 
  • new file 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 "overlayfs.h" 
     15 
     16static const char *ovl_whiteout_symlink = "(overlay-whiteout)"; 
     17 
     18static int ovl_whiteout(struct dentry *upperdir, struct dentry *dentry) 
     19{ 
     20        int err; 
     21        struct dentry *newdentry; 
     22        const struct cred *old_cred; 
     23        struct cred *override_cred; 
     24 
     25        /* FIXME: recheck lower dentry to see if whiteout is really needed */ 
     26 
     27        err = -ENOMEM; 
     28        override_cred = prepare_creds(); 
     29        if (!override_cred) 
     30                goto out; 
     31 
     32        /* 
     33         * CAP_SYS_ADMIN for setxattr 
     34         * CAP_DAC_OVERRIDE for symlink creation 
     35         * CAP_FOWNER for unlink in sticky directory 
     36         */ 
     37        cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     38        cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 
     39        cap_raise(override_cred->cap_effective, CAP_FOWNER); 
     40        override_cred->fsuid = 0; 
     41        override_cred->fsgid = 0; 
     42        old_cred = override_creds(override_cred); 
     43 
     44        newdentry = lookup_one_len(dentry->d_name.name, upperdir, 
     45                                   dentry->d_name.len); 
     46        err = PTR_ERR(newdentry); 
     47        if (IS_ERR(newdentry)) 
     48                goto out_put_cred; 
     49 
     50        /* Just been removed within the same locked region */ 
     51        WARN_ON(newdentry->d_inode); 
     52 
     53        err = vfs_symlink(upperdir->d_inode, newdentry, ovl_whiteout_symlink); 
     54        if (err) 
     55                goto out_dput; 
     56 
     57        ovl_dentry_version_inc(dentry->d_parent); 
     58 
     59        err = vfs_setxattr(newdentry, ovl_whiteout_xattr, "y", 1, 0); 
     60        if (err) 
     61                vfs_unlink(upperdir->d_inode, newdentry); 
     62 
     63out_dput: 
     64        dput(newdentry); 
     65out_put_cred: 
     66        revert_creds(old_cred); 
     67        put_cred(override_cred); 
     68out: 
     69        if (err) { 
     70                /* 
     71                 * There's no way to recover from failure to whiteout. 
     72                 * What should we do?  Log a big fat error and... ? 
     73                 */ 
     74                printk(KERN_ERR "overlayfs: ERROR - failed to whiteout '%s'\n", 
     75                       dentry->d_name.name); 
     76        } 
     77 
     78        return err; 
     79} 
     80 
     81static struct dentry *ovl_lookup_create(struct dentry *upperdir, 
     82                                        struct dentry *template) 
     83{ 
     84        int err; 
     85        struct dentry *newdentry; 
     86        struct qstr *name = &template->d_name; 
     87 
     88        newdentry = lookup_one_len(name->name, upperdir, name->len); 
     89        if (IS_ERR(newdentry)) 
     90                return newdentry; 
     91 
     92        if (newdentry->d_inode) { 
     93                const struct cred *old_cred; 
     94                struct cred *override_cred; 
     95 
     96                /* No need to check whiteout if lower parent is non-existent */ 
     97                err = -EEXIST; 
     98                if (!ovl_dentry_lower(template->d_parent)) 
     99                        goto out_dput; 
     100 
     101                if (!S_ISLNK(newdentry->d_inode->i_mode)) 
     102                        goto out_dput; 
     103 
     104                err = -ENOMEM; 
     105                override_cred = prepare_creds(); 
     106                if (!override_cred) 
     107                        goto out_dput; 
     108 
     109                /* 
     110                 * CAP_SYS_ADMIN for getxattr 
     111                 * CAP_FOWNER for unlink in sticky directory 
     112                 */ 
     113                cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     114                cap_raise(override_cred->cap_effective, CAP_FOWNER); 
     115                old_cred = override_creds(override_cred); 
     116 
     117                err = -EEXIST; 
     118                if (ovl_is_whiteout(newdentry)) 
     119                        err = vfs_unlink(upperdir->d_inode, newdentry); 
     120 
     121                revert_creds(old_cred); 
     122                put_cred(override_cred); 
     123                if (err) 
     124                        goto out_dput; 
     125 
     126                dput(newdentry); 
     127                newdentry = lookup_one_len(name->name, upperdir, name->len); 
     128                if (IS_ERR(newdentry)) { 
     129                        ovl_whiteout(upperdir, template); 
     130                        return newdentry; 
     131                } 
     132 
     133                /* 
     134                 * Whiteout just been successfully removed, parent 
     135                 * i_mutex is still held, there's no way the lookup 
     136                 * could return positive. 
     137                 */ 
     138                WARN_ON(newdentry->d_inode); 
     139        } 
     140 
     141        return newdentry; 
     142 
     143out_dput: 
     144        dput(newdentry); 
     145        return ERR_PTR(err); 
     146} 
     147 
     148struct dentry *ovl_upper_create(struct dentry *upperdir, struct dentry *dentry, 
     149                                struct kstat *stat, const char *link) 
     150{ 
     151        int err; 
     152        struct dentry *newdentry; 
     153        struct inode *dir = upperdir->d_inode; 
     154 
     155        newdentry = ovl_lookup_create(upperdir, dentry); 
     156        if (IS_ERR(newdentry)) 
     157                goto out; 
     158 
     159        switch (stat->mode & S_IFMT) { 
     160        case S_IFREG: 
     161                err = vfs_create(dir, newdentry, stat->mode, NULL); 
     162                break; 
     163 
     164        case S_IFDIR: 
     165                err = vfs_mkdir(dir, newdentry, stat->mode); 
     166                break; 
     167 
     168        case S_IFCHR: 
     169        case S_IFBLK: 
     170        case S_IFIFO: 
     171        case S_IFSOCK: 
     172                err = vfs_mknod(dir, newdentry, stat->mode, stat->rdev); 
     173                break; 
     174 
     175        case S_IFLNK: 
     176                err = vfs_symlink(dir, newdentry, link); 
     177                break; 
     178 
     179        default: 
     180                err = -EPERM; 
     181        } 
     182        if (err) { 
     183                if (ovl_dentry_is_opaque(dentry)) 
     184                        ovl_whiteout(upperdir, dentry); 
     185                dput(newdentry); 
     186                newdentry = ERR_PTR(err); 
     187        } else if (WARN_ON(!newdentry->d_inode)) { 
     188                /* 
     189                 * Not quite sure if non-instantiated dentry is legal or not. 
     190                 * VFS doesn't seem to care so check and warn here. 
     191                 */ 
     192                dput(newdentry); 
     193                newdentry = ERR_PTR(-ENOENT); 
     194        } 
     195 
     196out: 
     197        return newdentry; 
     198 
     199} 
     200 
     201static int ovl_set_opaque(struct dentry *upperdentry) 
     202{ 
     203        int err; 
     204        const struct cred *old_cred; 
     205        struct cred *override_cred; 
     206 
     207        override_cred = prepare_creds(); 
     208        if (!override_cred) 
     209                return -ENOMEM; 
     210 
     211        /* CAP_SYS_ADMIN for setxattr of "trusted" namespace */ 
     212        cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     213        old_cred = override_creds(override_cred); 
     214        err = vfs_setxattr(upperdentry, ovl_opaque_xattr, "y", 1, 0); 
     215        revert_creds(old_cred); 
     216        put_cred(override_cred); 
     217 
     218        return err; 
     219} 
     220 
     221static int ovl_remove_opaque(struct dentry *upperdentry) 
     222{ 
     223        int err; 
     224        const struct cred *old_cred; 
     225        struct cred *override_cred; 
     226 
     227        override_cred = prepare_creds(); 
     228        if (!override_cred) 
     229                return -ENOMEM; 
     230 
     231        /* CAP_SYS_ADMIN for removexattr of "trusted" namespace */ 
     232        cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     233        old_cred = override_creds(override_cred); 
     234        err = vfs_removexattr(upperdentry, ovl_opaque_xattr); 
     235        revert_creds(old_cred); 
     236        put_cred(override_cred); 
     237 
     238        return err; 
     239} 
     240 
     241static int ovl_dir_getattr(struct vfsmount *mnt, struct dentry *dentry, 
     242                         struct kstat *stat) 
     243{ 
     244        int err; 
     245        enum ovl_path_type type; 
     246        struct path realpath; 
     247 
     248        type = ovl_path_real(dentry, &realpath); 
     249        err = vfs_getattr(realpath.mnt, realpath.dentry, stat); 
     250        if (err) 
     251                return err; 
     252 
     253        stat->dev = dentry->d_sb->s_dev; 
     254        stat->ino = dentry->d_inode->i_ino; 
     255 
     256        /* 
     257         * It's probably not worth it to count subdirs to get the 
     258         * correct link count.  nlink=1 seems to pacify 'find' and 
     259         * other utilities. 
     260         */ 
     261        if (type == OVL_PATH_MERGE) 
     262                stat->nlink = 1; 
     263 
     264        return 0; 
     265} 
     266 
     267static int ovl_create_object(struct dentry *dentry, int mode, dev_t rdev, 
     268                             const char *link) 
     269{ 
     270        int err; 
     271        struct dentry *newdentry; 
     272        struct dentry *upperdir; 
     273        struct inode *inode; 
     274        struct kstat stat = { 
     275                .mode = mode, 
     276                .rdev = rdev, 
     277        }; 
     278 
     279        err = -ENOMEM; 
     280        inode = ovl_new_inode(dentry->d_sb, mode, dentry->d_fsdata); 
     281        if (!inode) 
     282                goto out; 
     283 
     284        err = ovl_copy_up(dentry->d_parent); 
     285        if (err) 
     286                goto out_iput; 
     287 
     288        upperdir = ovl_dentry_upper(dentry->d_parent); 
     289        mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
     290 
     291        newdentry = ovl_upper_create(upperdir, dentry, &stat, link); 
     292        err = PTR_ERR(newdentry); 
     293        if (IS_ERR(newdentry)) 
     294                goto out_unlock; 
     295 
     296        ovl_dentry_version_inc(dentry->d_parent); 
     297        if (ovl_dentry_is_opaque(dentry) && S_ISDIR(mode)) { 
     298                err = ovl_set_opaque(newdentry); 
     299                if (err) { 
     300                        vfs_rmdir(upperdir->d_inode, newdentry); 
     301                        ovl_whiteout(upperdir, dentry); 
     302                        goto out_dput; 
     303                } 
     304        } 
     305        ovl_dentry_update(dentry, newdentry); 
     306        d_instantiate(dentry, inode); 
     307        inode = NULL; 
     308        newdentry = NULL; 
     309        err = 0; 
     310 
     311out_dput: 
     312        dput(newdentry); 
     313out_unlock: 
     314        mutex_unlock(&upperdir->d_inode->i_mutex); 
     315out_iput: 
     316        iput(inode); 
     317out: 
     318        return err; 
     319} 
     320 
     321static int ovl_create(struct inode *dir, struct dentry *dentry, int mode, 
     322                        struct nameidata *nd) 
     323{ 
     324        return ovl_create_object(dentry, (mode & 07777) | S_IFREG, 0, NULL); 
     325} 
     326 
     327static int ovl_mkdir(struct inode *dir, struct dentry *dentry, int mode) 
     328{ 
     329        return ovl_create_object(dentry, (mode & 07777) | S_IFDIR, 0, NULL); 
     330} 
     331 
     332static int ovl_mknod(struct inode *dir, struct dentry *dentry, int mode, 
     333                       dev_t rdev) 
     334{ 
     335        return ovl_create_object(dentry, mode, rdev, NULL); 
     336} 
     337 
     338static int ovl_symlink(struct inode *dir, struct dentry *dentry, 
     339                         const char *link) 
     340{ 
     341        return ovl_create_object(dentry, S_IFLNK, 0, link); 
     342} 
     343 
     344static int ovl_do_remove(struct dentry *dentry, bool is_dir) 
     345{ 
     346        int err; 
     347        enum ovl_path_type type; 
     348        struct path realpath; 
     349        struct dentry *upperdir; 
     350 
     351        err = ovl_copy_up(dentry->d_parent); 
     352        if (err) 
     353                return err; 
     354 
     355        upperdir = ovl_dentry_upper(dentry->d_parent); 
     356        mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
     357        type = ovl_path_real(dentry, &realpath); 
     358        if (type != OVL_PATH_LOWER) { 
     359                err = -ESTALE; 
     360                if (realpath.dentry->d_parent != upperdir) 
     361                        goto out_d_drop; 
     362 
     363                /* FIXME: create whiteout up front and rename to target */ 
     364 
     365                if (is_dir) 
     366                        err = vfs_rmdir(upperdir->d_inode, realpath.dentry); 
     367                else 
     368                        err = vfs_unlink(upperdir->d_inode, realpath.dentry); 
     369                if (err) 
     370                        goto out_d_drop; 
     371 
     372                ovl_dentry_version_inc(dentry->d_parent); 
     373        } 
     374 
     375        if (type != OVL_PATH_UPPER || ovl_dentry_is_opaque(dentry)) 
     376                err = ovl_whiteout(upperdir, dentry); 
     377 
     378        /* 
     379         * Keeping this dentry hashed would mean having to release 
     380         * upperpath/lowerpath, which could only be done if we are the 
     381         * sole user of this dentry.  Too tricky...  Just unhash for 
     382         * now. 
     383         */ 
     384out_d_drop: 
     385        d_drop(dentry); 
     386        mutex_unlock(&upperdir->d_inode->i_mutex); 
     387 
     388        return err; 
     389} 
     390 
     391static int ovl_unlink(struct inode *dir, struct dentry *dentry) 
     392{ 
     393        return ovl_do_remove(dentry, false); 
     394} 
     395 
     396 
     397static int ovl_rmdir(struct inode *dir, struct dentry *dentry) 
     398{ 
     399        int err; 
     400        enum ovl_path_type type; 
     401 
     402        type = ovl_path_type(dentry); 
     403        if (type != OVL_PATH_UPPER) { 
     404                err = ovl_check_empty_and_clear(dentry, type); 
     405                if (err) 
     406                        return err; 
     407        } 
     408 
     409        return ovl_do_remove(dentry, true); 
     410} 
     411 
     412static int ovl_link(struct dentry *old, struct inode *newdir, 
     413                    struct dentry *new) 
     414{ 
     415        int err; 
     416        struct dentry *olddentry; 
     417        struct dentry *newdentry; 
     418        struct dentry *upperdir; 
     419 
     420        err = ovl_copy_up(old); 
     421        if (err) 
     422                goto out; 
     423 
     424        err = ovl_copy_up(new->d_parent); 
     425        if (err) 
     426                goto out; 
     427 
     428        upperdir = ovl_dentry_upper(new->d_parent); 
     429        mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
     430        newdentry = ovl_lookup_create(upperdir, new); 
     431        err = PTR_ERR(newdentry); 
     432        if (IS_ERR(newdentry)) 
     433                goto out_unlock; 
     434 
     435        olddentry = ovl_dentry_upper(old); 
     436        err = vfs_link(olddentry, upperdir->d_inode, newdentry); 
     437        if (!err) { 
     438                if (WARN_ON(!newdentry->d_inode)) { 
     439                        dput(newdentry); 
     440                        err = -ENOENT; 
     441                        goto out_unlock; 
     442                } 
     443 
     444                ovl_dentry_version_inc(new->d_parent); 
     445                ovl_dentry_update(new, newdentry); 
     446 
     447                ihold(old->d_inode); 
     448                d_instantiate(new, old->d_inode); 
     449        } else { 
     450                if (ovl_dentry_is_opaque(new)) 
     451                        ovl_whiteout(upperdir, new); 
     452                dput(newdentry); 
     453        } 
     454out_unlock: 
     455        mutex_unlock(&upperdir->d_inode->i_mutex); 
     456out: 
     457        return err; 
     458 
     459} 
     460 
     461static int ovl_rename(struct inode *olddir, struct dentry *old, 
     462                        struct inode *newdir, struct dentry *new) 
     463{ 
     464        int err; 
     465        enum ovl_path_type old_type; 
     466        enum ovl_path_type new_type; 
     467        struct dentry *old_upperdir; 
     468        struct dentry *new_upperdir; 
     469        struct dentry *olddentry; 
     470        struct dentry *newdentry; 
     471        struct dentry *trap; 
     472        bool old_opaque; 
     473        bool new_opaque; 
     474        bool new_create = false; 
     475        bool is_dir = S_ISDIR(old->d_inode->i_mode); 
     476 
     477        /* Don't copy up directory trees */ 
     478        old_type = ovl_path_type(old); 
     479        if (old_type != OVL_PATH_UPPER && is_dir) 
     480                return -EXDEV; 
     481 
     482        if (new->d_inode) { 
     483                new_type = ovl_path_type(new); 
     484 
     485                if (new_type == OVL_PATH_LOWER && old_type == OVL_PATH_LOWER) { 
     486                        if (ovl_dentry_lower(old)->d_inode == 
     487                            ovl_dentry_lower(new)->d_inode) 
     488                                return 0; 
     489                } 
     490                if (new_type != OVL_PATH_LOWER && old_type != OVL_PATH_LOWER) { 
     491                        if (ovl_dentry_upper(old)->d_inode == 
     492                            ovl_dentry_upper(new)->d_inode) 
     493                                return 0; 
     494                } 
     495 
     496                if (new_type != OVL_PATH_UPPER && 
     497                    S_ISDIR(new->d_inode->i_mode)) { 
     498                        err = ovl_check_empty_and_clear(new, new_type); 
     499                        if (err) 
     500                                return err; 
     501                } 
     502        } else { 
     503                new_type = OVL_PATH_UPPER; 
     504        } 
     505 
     506        err = ovl_copy_up(old); 
     507        if (err) 
     508                return err; 
     509 
     510        err = ovl_copy_up(new->d_parent); 
     511        if (err) 
     512                return err; 
     513 
     514        old_upperdir = ovl_dentry_upper(old->d_parent); 
     515        new_upperdir = ovl_dentry_upper(new->d_parent); 
     516 
     517        trap = lock_rename(new_upperdir, old_upperdir); 
     518 
     519        olddentry = ovl_dentry_upper(old); 
     520        newdentry = ovl_dentry_upper(new); 
     521        if (newdentry) { 
     522                dget(newdentry); 
     523        } else { 
     524                new_create = true; 
     525                newdentry = ovl_lookup_create(new_upperdir, new); 
     526                err = PTR_ERR(newdentry); 
     527                if (IS_ERR(newdentry)) 
     528                        goto out_unlock; 
     529        } 
     530 
     531        err = -ESTALE; 
     532        if (olddentry->d_parent != old_upperdir) 
     533                goto out_dput; 
     534        if (newdentry->d_parent != new_upperdir) 
     535                goto out_dput; 
     536        if (olddentry == trap) 
     537                goto out_dput; 
     538        if (newdentry == trap) 
     539                goto out_dput; 
     540 
     541        old_opaque = ovl_dentry_is_opaque(old); 
     542        new_opaque = ovl_dentry_is_opaque(new) || new_type != OVL_PATH_UPPER; 
     543 
     544        if (is_dir && !old_opaque && new_opaque) { 
     545                err = ovl_set_opaque(olddentry); 
     546                if (err) 
     547                        goto out_dput; 
     548        } 
     549 
     550        err = vfs_rename(old_upperdir->d_inode, olddentry, 
     551                         new_upperdir->d_inode, newdentry); 
     552 
     553        if (err) { 
     554                if (new_create && ovl_dentry_is_opaque(new)) 
     555                        ovl_whiteout(new_upperdir, new); 
     556                if (is_dir && !old_opaque && new_opaque) 
     557                        ovl_remove_opaque(olddentry); 
     558                goto out_dput; 
     559        } 
     560 
     561        if (old_type != OVL_PATH_UPPER || old_opaque) 
     562                err = ovl_whiteout(old_upperdir, old); 
     563        if (is_dir && old_opaque && !new_opaque) 
     564                ovl_remove_opaque(olddentry); 
     565 
     566        if (old_opaque != new_opaque) 
     567                ovl_dentry_set_opaque(old, new_opaque); 
     568 
     569        ovl_dentry_version_inc(old->d_parent); 
     570        ovl_dentry_version_inc(new->d_parent); 
     571 
     572out_dput: 
     573        dput(newdentry); 
     574out_unlock: 
     575        unlock_rename(new_upperdir, old_upperdir); 
     576        return err; 
     577} 
     578 
     579const struct inode_operations ovl_dir_inode_operations = { 
     580        .lookup         = ovl_lookup, 
     581        .mkdir          = ovl_mkdir, 
     582        .symlink        = ovl_symlink, 
     583        .unlink         = ovl_unlink, 
     584        .rmdir          = ovl_rmdir, 
     585        .rename         = ovl_rename, 
     586        .link           = ovl_link, 
     587        .setattr        = ovl_setattr, 
     588        .create         = ovl_create, 
     589        .mknod          = ovl_mknod, 
     590        .permission     = ovl_permission, 
     591        .getattr        = ovl_dir_getattr, 
     592        .setxattr       = ovl_setxattr, 
     593        .getxattr       = ovl_getxattr, 
     594        .listxattr      = ovl_listxattr, 
     595        .removexattr    = ovl_removexattr, 
     596}; 
  • new file fs/overlayfs/inode.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/slab.h> 
     12#include <linux/xattr.h> 
     13#include "overlayfs.h" 
     14 
     15int ovl_setattr(struct dentry *dentry, struct iattr *attr) 
     16{ 
     17        struct dentry *upperdentry; 
     18        int err; 
     19 
     20        if ((attr->ia_valid & ATTR_SIZE) && !ovl_dentry_upper(dentry)) 
     21                err = ovl_copy_up_truncate(dentry, attr->ia_size); 
     22        else 
     23                err = ovl_copy_up(dentry); 
     24        if (err) 
     25                return err; 
     26 
     27        upperdentry = ovl_dentry_upper(dentry); 
     28 
     29        if (attr->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID)) 
     30                attr->ia_valid &= ~ATTR_MODE; 
     31 
     32        mutex_lock(&upperdentry->d_inode->i_mutex); 
     33        err = notify_change(upperdentry, attr); 
     34        mutex_unlock(&upperdentry->d_inode->i_mutex); 
     35 
     36        return err; 
     37} 
     38 
     39static int ovl_getattr(struct vfsmount *mnt, struct dentry *dentry, 
     40                         struct kstat *stat) 
     41{ 
     42        struct path realpath; 
     43 
     44        ovl_path_real(dentry, &realpath); 
     45        return vfs_getattr(realpath.mnt, realpath.dentry, stat); 
     46} 
     47 
     48int ovl_permission(struct inode *inode, int mask) 
     49{ 
     50        struct ovl_entry *oe; 
     51        struct dentry *alias = NULL; 
     52        struct inode *realinode; 
     53        struct dentry *realdentry; 
     54        bool is_upper; 
     55        int err; 
     56 
     57        if (S_ISDIR(inode->i_mode)) { 
     58                oe = inode->i_private; 
     59        } else if (mask & MAY_NOT_BLOCK) { 
     60                return -ECHILD; 
     61        } else { 
     62                /* 
     63                 * For non-directories find an alias and get the info 
     64                 * from there. 
     65                 */ 
     66                spin_lock(&inode->i_lock); 
     67                if (WARN_ON(list_empty(&inode->i_dentry))) { 
     68                        spin_unlock(&inode->i_lock); 
     69                        return -ENOENT; 
     70                } 
     71                alias = list_entry(inode->i_dentry.next, struct dentry, d_alias); 
     72                dget(alias); 
     73                spin_unlock(&inode->i_lock); 
     74                oe = alias->d_fsdata; 
     75        } 
     76 
     77        realdentry = ovl_entry_real(oe, &is_upper); 
     78 
     79        /* Careful in RCU walk mode */ 
     80        realinode = ACCESS_ONCE(realdentry->d_inode); 
     81        if (!realinode) { 
     82                WARN_ON(!(mask & MAY_NOT_BLOCK)); 
     83                err = -ENOENT; 
     84                goto out_dput; 
     85        } 
     86 
     87        if (mask & MAY_WRITE) { 
     88                umode_t mode = realinode->i_mode; 
     89 
     90                /* 
     91                 * Writes will always be redirected to upper layer, so 
     92                 * ignore lower layer being read-only. 
     93                 * 
     94                 * If the overlay itself is read-only then proceed 
     95                 * with the permission check, don't return EROFS. 
     96                 * This will only happen if this is the lower layer of 
     97                 * another overlayfs. 
     98                 * 
     99                 * If upper fs becomes read-only after the overlay was 
     100                 * constructed return EROFS to prevent modification of 
     101                 * upper layer. 
     102                 */ 
     103                err = -EROFS; 
     104                if (is_upper && !IS_RDONLY(inode) && IS_RDONLY(realinode) && 
     105                    (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))) 
     106                        goto out_dput; 
     107 
     108                /* 
     109                 * Nobody gets write access to an immutable file. 
     110                 */ 
     111                err = -EACCES; 
     112                if (IS_IMMUTABLE(realinode)) 
     113                        goto out_dput; 
     114        } 
     115 
     116        if (realinode->i_op->permission) 
     117                err = realinode->i_op->permission(realinode, mask); 
     118        else 
     119                err = generic_permission(realinode, mask); 
     120out_dput: 
     121        dput(alias); 
     122        return err; 
     123} 
     124 
     125 
     126struct ovl_link_data { 
     127        struct dentry *realdentry; 
     128        void *cookie; 
     129}; 
     130 
     131static void *ovl_follow_link(struct dentry *dentry, struct nameidata *nd) 
     132{ 
     133        void *ret; 
     134        struct dentry *realdentry; 
     135        struct inode *realinode; 
     136 
     137        realdentry = ovl_dentry_real(dentry); 
     138        realinode = realdentry->d_inode; 
     139 
     140        if (WARN_ON(!realinode->i_op->follow_link)) 
     141                return ERR_PTR(-EPERM); 
     142 
     143        ret = realinode->i_op->follow_link(realdentry, nd); 
     144        if (IS_ERR(ret)) 
     145                return ret; 
     146 
     147        if (realinode->i_op->put_link) { 
     148                struct ovl_link_data *data; 
     149 
     150                data = kmalloc(sizeof(struct ovl_link_data), GFP_KERNEL); 
     151                if (!data) { 
     152                        realinode->i_op->put_link(realdentry, nd, ret); 
     153                        return ERR_PTR(-ENOMEM); 
     154                } 
     155                data->realdentry = realdentry; 
     156                data->cookie = ret; 
     157 
     158                return data; 
     159        } else { 
     160                return NULL; 
     161        } 
     162} 
     163 
     164static void ovl_put_link(struct dentry *dentry, struct nameidata *nd, void *c) 
     165{ 
     166        struct inode *realinode; 
     167        struct ovl_link_data *data = c; 
     168 
     169        if (!data) 
     170                return; 
     171 
     172        realinode = data->realdentry->d_inode; 
     173        realinode->i_op->put_link(data->realdentry, nd, data->cookie); 
     174        kfree(data); 
     175} 
     176 
     177static int ovl_readlink(struct dentry *dentry, char __user *buf, int bufsiz) 
     178{ 
     179        struct path realpath; 
     180        struct inode *realinode; 
     181 
     182        ovl_path_real(dentry, &realpath); 
     183        realinode = realpath.dentry->d_inode; 
     184 
     185        if (!realinode->i_op->readlink) 
     186                return -EINVAL; 
     187 
     188        touch_atime(realpath.mnt, realpath.dentry); 
     189 
     190        return realinode->i_op->readlink(realpath.dentry, buf, bufsiz); 
     191} 
     192 
     193 
     194static bool ovl_is_private_xattr(const char *name) 
     195{ 
     196        return strncmp(name, "trusted.overlay.", 14) == 0; 
     197} 
     198 
     199int ovl_setxattr(struct dentry *dentry, const char *name, 
     200                 const void *value, size_t size, int flags) 
     201{ 
     202        int err; 
     203        struct dentry *upperdentry; 
     204 
     205        if (ovl_is_private_xattr(name)) 
     206                return -EPERM; 
     207 
     208        err = ovl_copy_up(dentry); 
     209        if (err) 
     210                return err; 
     211 
     212        upperdentry = ovl_dentry_upper(dentry); 
     213        return  vfs_setxattr(upperdentry, name, value, size, flags); 
     214} 
     215 
     216ssize_t ovl_getxattr(struct dentry *dentry, const char *name, 
     217                     void *value, size_t size) 
     218{ 
     219        if (ovl_path_type(dentry->d_parent) == OVL_PATH_MERGE && 
     220            ovl_is_private_xattr(name)) 
     221                return -ENODATA; 
     222 
     223        return vfs_getxattr(ovl_dentry_real(dentry), name, value, size); 
     224} 
     225 
     226ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size) 
     227{ 
     228        ssize_t res; 
     229        int off; 
     230 
     231        res = vfs_listxattr(ovl_dentry_real(dentry), list, size); 
     232        if (res <= 0 || size == 0) 
     233                return res; 
     234 
     235        if (ovl_path_type(dentry->d_parent) != OVL_PATH_MERGE) 
     236                return res; 
     237 
     238        /* filter out private xattrs */ 
     239        for (off = 0; off < res;) { 
     240                char *s = list + off; 
     241                size_t slen = strlen(s) + 1; 
     242 
     243                BUG_ON(off + slen > res); 
     244 
     245                if (ovl_is_private_xattr(s)) { 
     246                        res -= slen; 
     247                        memmove(s, s + slen, res - off); 
     248                } else { 
     249                        off += slen; 
     250                } 
     251        } 
     252 
     253        return res; 
     254} 
     255 
     256int ovl_removexattr(struct dentry *dentry, const char *name) 
     257{ 
     258        int err; 
     259        struct path realpath; 
     260        enum ovl_path_type type; 
     261 
     262        if (ovl_path_type(dentry->d_parent) == OVL_PATH_MERGE && 
     263            ovl_is_private_xattr(name)) 
     264                return -ENODATA; 
     265 
     266        type = ovl_path_real(dentry, &realpath); 
     267        if (type == OVL_PATH_LOWER) { 
     268                err = vfs_getxattr(realpath.dentry, name, NULL, 0); 
     269                if (err < 0) 
     270                        return err; 
     271 
     272                err = ovl_copy_up(dentry); 
     273                if (err) 
     274                        return err; 
     275 
     276                ovl_path_upper(dentry, &realpath); 
     277        } 
     278 
     279        return vfs_removexattr(realpath.dentry, name); 
     280} 
     281 
     282static bool ovl_open_need_copy_up(int flags, enum ovl_path_type type, 
     283                                  struct dentry *realdentry) 
     284{ 
     285        if (type != OVL_PATH_LOWER) 
     286                return false; 
     287 
     288        if (special_file(realdentry->d_inode->i_mode)) 
     289                return false; 
     290 
     291        if (!(OPEN_FMODE(flags) & FMODE_WRITE) && !(flags & O_TRUNC)) 
     292                return false; 
     293 
     294        return true; 
     295} 
     296 
     297static struct file *ovl_open(struct dentry *dentry, int flags, 
     298                             const struct cred *cred) 
     299{ 
     300        int err; 
     301        struct path realpath; 
     302        enum ovl_path_type type; 
     303 
     304        type = ovl_path_real(dentry, &realpath); 
     305        if (ovl_open_need_copy_up(flags, type, realpath.dentry)) { 
     306                if (flags & O_TRUNC) 
     307                        err = ovl_copy_up_truncate(dentry, 0); 
     308                else 
     309                        err = ovl_copy_up(dentry); 
     310                if (err) 
     311                        return ERR_PTR(err); 
     312 
     313                ovl_path_upper(dentry, &realpath); 
     314        } 
     315 
     316        return vfs_open(&realpath, flags, cred); 
     317} 
     318 
     319static const struct inode_operations ovl_file_inode_operations = { 
     320        .setattr        = ovl_setattr, 
     321        .permission     = ovl_permission, 
     322        .getattr        = ovl_getattr, 
     323        .setxattr       = ovl_setxattr, 
     324        .getxattr       = ovl_getxattr, 
     325        .listxattr      = ovl_listxattr, 
     326        .removexattr    = ovl_removexattr, 
     327        .open           = ovl_open, 
     328}; 
     329 
     330static const struct inode_operations ovl_symlink_inode_operations = { 
     331        .setattr        = ovl_setattr, 
     332        .follow_link    = ovl_follow_link, 
     333        .put_link       = ovl_put_link, 
     334        .readlink       = ovl_readlink, 
     335        .getattr        = ovl_getattr, 
     336        .setxattr       = ovl_setxattr, 
     337        .getxattr       = ovl_getxattr, 
     338        .listxattr      = ovl_listxattr, 
     339        .removexattr    = ovl_removexattr, 
     340}; 
     341 
     342struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, 
     343                            struct ovl_entry *oe) 
     344{ 
     345        struct inode *inode; 
     346 
     347        inode = new_inode(sb); 
     348        if (!inode) 
     349                return NULL; 
     350 
     351        mode &= S_IFMT; 
     352 
     353        inode->i_ino = get_next_ino(); 
     354        inode->i_mode = mode; 
     355        inode->i_flags |= S_NOATIME | S_NOCMTIME; 
     356 
     357        switch (mode) { 
     358        case S_IFDIR: 
     359                inode->i_private = oe; 
     360                inode->i_op = &ovl_dir_inode_operations; 
     361                inode->i_fop = &ovl_dir_operations; 
     362                break; 
     363 
     364        case S_IFLNK: 
     365                inode->i_op = &ovl_symlink_inode_operations; 
     366                break; 
     367 
     368        case S_IFREG: 
     369        case S_IFSOCK: 
     370        case S_IFBLK: 
     371        case S_IFCHR: 
     372        case S_IFIFO: 
     373                inode->i_op = &ovl_file_inode_operations; 
     374                break; 
     375 
     376        default: 
     377                WARN(1, "illegal file type: %i\n", mode); 
     378                inode = NULL; 
     379        } 
     380 
     381        return inode; 
     382 
     383} 
  • new file fs/overlayfs/overlayfs.h

    - +  
     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 
     10struct ovl_entry; 
     11 
     12enum ovl_path_type { 
     13        OVL_PATH_UPPER, 
     14        OVL_PATH_MERGE, 
     15        OVL_PATH_LOWER, 
     16}; 
     17 
     18extern const char *ovl_opaque_xattr; 
     19extern const char *ovl_whiteout_xattr; 
     20extern const struct dentry_operations ovl_dentry_operations; 
     21 
     22enum ovl_path_type ovl_path_type(struct dentry *dentry); 
     23u64 ovl_dentry_version_get(struct dentry *dentry); 
     24void ovl_dentry_version_inc(struct dentry *dentry); 
     25void ovl_path_upper(struct dentry *dentry, struct path *path); 
     26void ovl_path_lower(struct dentry *dentry, struct path *path); 
     27enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path); 
     28struct dentry *ovl_dentry_upper(struct dentry *dentry); 
     29struct dentry *ovl_dentry_lower(struct dentry *dentry); 
     30struct dentry *ovl_dentry_real(struct dentry *dentry); 
     31struct dentry *ovl_entry_real(struct ovl_entry *oe, bool *is_upper); 
     32bool ovl_dentry_is_opaque(struct dentry *dentry); 
     33void ovl_dentry_set_opaque(struct dentry *dentry, bool opaque); 
     34bool ovl_is_whiteout(struct dentry *dentry); 
     35void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry); 
     36struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, 
     37                          struct nameidata *nd); 
     38 
     39struct dentry *ovl_upper_create(struct dentry *upperdir, struct dentry *dentry, 
     40                                struct kstat *stat, const char *link); 
     41 
     42/* readdir.c */ 
     43extern const struct file_operations ovl_dir_operations; 
     44int ovl_check_empty_and_clear(struct dentry *dentry, enum ovl_path_type type); 
     45 
     46/* inode.c */ 
     47int ovl_setattr(struct dentry *dentry, struct iattr *attr); 
     48int ovl_permission(struct inode *inode, int mask); 
     49int ovl_setxattr(struct dentry *dentry, const char *name, 
     50                 const void *value, size_t size, int flags); 
     51ssize_t ovl_getxattr(struct dentry *dentry, const char *name, 
     52                     void *value, size_t size); 
     53ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size); 
     54int ovl_removexattr(struct dentry *dentry, const char *name); 
     55 
     56struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, 
     57                            struct ovl_entry *oe); 
     58/* dir.c */ 
     59extern const struct inode_operations ovl_dir_inode_operations; 
     60 
     61/* copy_up.c */ 
     62int ovl_copy_up(struct dentry *dentry); 
     63int ovl_copy_up_truncate(struct dentry *dentry, loff_t size); 
  • new file fs/overlayfs/readdir.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/slab.h> 
     12#include <linux/namei.h> 
     13#include <linux/file.h> 
     14#include <linux/xattr.h> 
     15#include <linux/rbtree.h> 
     16#include <linux/security.h> 
     17#include "overlayfs.h" 
     18 
     19struct ovl_cache_entry { 
     20        const char *name; 
     21        unsigned int len; 
     22        unsigned int type; 
     23        u64 ino; 
     24        bool is_whiteout; 
     25        struct list_head l_node; 
     26        struct rb_node node; 
     27}; 
     28 
     29struct ovl_readdir_data { 
     30        struct rb_root *root; 
     31        struct list_head *list; 
     32        struct list_head *middle; 
     33        struct dentry *dir; 
     34        int count; 
     35        int err; 
     36}; 
     37 
     38struct ovl_dir_file { 
     39        bool is_real; 
     40        bool is_cached; 
     41        struct list_head cursor; 
     42        u64 cache_version; 
     43        struct list_head cache; 
     44        struct file *realfile; 
     45}; 
     46 
     47static struct ovl_cache_entry *ovl_cache_entry_from_node(struct rb_node *n) 
     48{ 
     49        return container_of(n, struct ovl_cache_entry, node); 
     50} 
     51 
     52static struct ovl_cache_entry *ovl_cache_entry_find(struct rb_root *root, 
     53                                                    const char *name, int len) 
     54{ 
     55        struct rb_node *node = root->rb_node; 
     56        int cmp; 
     57 
     58        while (node) { 
     59                struct ovl_cache_entry *p = ovl_cache_entry_from_node(node); 
     60 
     61                cmp = strncmp(name, p->name, len); 
     62                if (cmp > 0) 
     63                        node = p->node.rb_right; 
     64                else if (cmp < 0 || len < p->len) 
     65                        node = p->node.rb_left; 
     66                else 
     67                        return p; 
     68        } 
     69 
     70        return NULL; 
     71} 
     72 
     73static struct ovl_cache_entry *ovl_cache_entry_new(const char *name, int len, 
     74                                                   u64 ino, unsigned int d_type) 
     75{ 
     76        struct ovl_cache_entry *p; 
     77 
     78        p = kmalloc(sizeof(*p) + len + 1, GFP_KERNEL); 
     79        if (p) { 
     80                char *name_copy = (char *) (p + 1); 
     81                memcpy(name_copy, name, len); 
     82                name_copy[len] = '\0'; 
     83                p->name = name_copy; 
     84                p->len = len; 
     85                p->type = d_type; 
     86                p->ino = ino; 
     87                p->is_whiteout = false; 
     88        } 
     89 
     90        return p; 
     91} 
     92 
     93static int ovl_cache_entry_add_rb(struct ovl_readdir_data *rdd, 
     94                                  const char *name, int len, u64 ino, 
     95                                  unsigned int d_type) 
     96{ 
     97        struct rb_node **newp = &rdd->root->rb_node; 
     98        struct rb_node *parent = NULL; 
     99        struct ovl_cache_entry *p; 
     100 
     101        while (*newp) { 
     102                int cmp; 
     103                struct ovl_cache_entry *tmp; 
     104 
     105                parent = *newp; 
     106                tmp = ovl_cache_entry_from_node(*newp); 
     107                cmp = strncmp(name, tmp->name, len); 
     108                if (cmp > 0) 
     109                        newp = &tmp->node.rb_right; 
     110                else if (cmp < 0 || len < tmp->len) 
     111                        newp = &tmp->node.rb_left; 
     112                else 
     113                        return 0; 
     114        } 
     115 
     116        p = ovl_cache_entry_new(name, len, ino, d_type); 
     117        if (p == NULL) 
     118                return -ENOMEM; 
     119 
     120        list_add_tail(&p->l_node, rdd->list); 
     121        rb_link_node(&p->node, parent, newp); 
     122        rb_insert_color(&p->node, rdd->root); 
     123 
     124        return 0; 
     125} 
     126 
     127static int ovl_fill_lower(void *buf, const char *name, int namelen, 
     128                            loff_t offset, u64 ino, unsigned int d_type) 
     129{ 
     130        struct ovl_readdir_data *rdd = buf; 
     131        struct ovl_cache_entry *p; 
     132 
     133        rdd->count++; 
     134        p = ovl_cache_entry_find(rdd->root, name, namelen); 
     135        if (p) { 
     136                list_move_tail(&p->l_node, rdd->middle); 
     137        } else { 
     138                p = ovl_cache_entry_new(name, namelen, ino, d_type); 
     139                if (p == NULL) 
     140                        rdd->err = -ENOMEM; 
     141                else 
     142                        list_add_tail(&p->l_node, rdd->middle); 
     143        } 
     144 
     145        return rdd->err; 
     146} 
     147 
     148static void ovl_cache_free(struct list_head *list) 
     149{ 
     150        struct ovl_cache_entry *p; 
     151        struct ovl_cache_entry *n; 
     152 
     153        list_for_each_entry_safe(p, n, list, l_node) 
     154                kfree(p); 
     155 
     156        INIT_LIST_HEAD(list); 
     157} 
     158 
     159static int ovl_fill_upper(void *buf, const char *name, int namelen, 
     160                          loff_t offset, u64 ino, unsigned int d_type) 
     161{ 
     162        struct ovl_readdir_data *rdd = buf; 
     163 
     164        rdd->count++; 
     165        return ovl_cache_entry_add_rb(rdd, name, namelen, ino, d_type); 
     166} 
     167 
     168static inline int ovl_dir_read(struct path *realpath, 
     169                               struct ovl_readdir_data *rdd, filldir_t filler) 
     170{ 
     171        struct file *realfile; 
     172        int err; 
     173 
     174        realfile = vfs_open(realpath, O_RDONLY | O_DIRECTORY, current_cred()); 
     175        if (IS_ERR(realfile)) 
     176                return PTR_ERR(realfile); 
     177 
     178        do { 
     179                rdd->count = 0; 
     180                rdd->err = 0; 
     181                err = vfs_readdir(realfile, filler, rdd); 
     182                if (err >= 0) 
     183                        err = rdd->err; 
     184        } while (!err && rdd->count); 
     185        fput(realfile); 
     186 
     187        return 0; 
     188} 
     189 
     190static void ovl_dir_reset(struct file *file) 
     191{ 
     192        struct ovl_dir_file *od = file->private_data; 
     193        enum ovl_path_type type = ovl_path_type(file->f_path.dentry); 
     194 
     195        if (ovl_dentry_version_get(file->f_path.dentry) != od->cache_version) { 
     196                list_del_init(&od->cursor); 
     197                ovl_cache_free(&od->cache); 
     198                od->is_cached = false; 
     199        } 
     200        WARN_ON(!od->is_real && type != OVL_PATH_MERGE); 
     201        if (od->is_real && type == OVL_PATH_MERGE) { 
     202                fput(od->realfile); 
     203                od->realfile = NULL; 
     204                od->is_real = false; 
     205        } 
     206} 
     207 
     208static int ovl_dir_mark_whiteouts(struct ovl_readdir_data *rdd) 
     209{ 
     210        struct ovl_cache_entry *p; 
     211        struct dentry *dentry; 
     212        const struct cred *old_cred; 
     213        struct cred *override_cred; 
     214 
     215        override_cred = prepare_creds(); 
     216        if (!override_cred) { 
     217                ovl_cache_free(rdd->list); 
     218                return -ENOMEM; 
     219        } 
     220 
     221        /* 
     222         * CAP_SYS_ADMIN for getxattr 
     223         * CAP_DAC_OVERRIDE for lookup 
     224         */ 
     225        cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     226        cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 
     227        old_cred = override_creds(override_cred); 
     228 
     229        mutex_lock(&rdd->dir->d_inode->i_mutex); 
     230        list_for_each_entry(p, rdd->list, l_node) { 
     231                if (p->type != DT_LNK) 
     232                        continue; 
     233 
     234                dentry = lookup_one_len(p->name, rdd->dir, p->len); 
     235                if (IS_ERR(dentry)) 
     236                        continue; 
     237 
     238                p->is_whiteout = ovl_is_whiteout(dentry); 
     239                dput(dentry); 
     240        } 
     241        mutex_unlock(&rdd->dir->d_inode->i_mutex); 
     242 
     243        revert_creds(old_cred); 
     244        put_cred(override_cred); 
     245 
     246        return 0; 
     247} 
     248 
     249static inline int ovl_dir_read_merged(struct path *upperpath, struct path *lowerpath, 
     250                               struct ovl_readdir_data *rdd) 
     251{ 
     252        int err; 
     253        struct rb_root root = RB_ROOT; 
     254        struct list_head middle; 
     255 
     256        rdd->root = &root; 
     257        if (upperpath->dentry) { 
     258                rdd->dir = upperpath->dentry; 
     259                err = ovl_dir_read(upperpath, rdd, ovl_fill_upper); 
     260                if (err) 
     261                        goto out; 
     262 
     263                err = ovl_dir_mark_whiteouts(rdd); 
     264                if (err) 
     265                        goto out; 
     266        } 
     267        /* 
     268         * Insert lowerpath entries before upperpath ones, this allows 
     269         * offsets to be reasonably constant 
     270         */ 
     271        list_add(&middle, rdd->list); 
     272        rdd->middle = &middle; 
     273        err = ovl_dir_read(lowerpath, rdd, ovl_fill_lower); 
     274        list_del(&middle); 
     275out: 
     276        rdd->root = NULL; 
     277 
     278        return err; 
     279} 
     280 
     281static void ovl_seek_cursor(struct ovl_dir_file *od, loff_t pos) 
     282{ 
     283        struct list_head *l; 
     284        loff_t off; 
     285 
     286        l = od->cache.next; 
     287        for (off = 0; off < pos; off++) { 
     288                if (l == &od->cache) 
     289                        break; 
     290                l = l->next; 
     291        } 
     292        list_move_tail(&od->cursor, l); 
     293} 
     294 
     295static int ovl_readdir(struct file *file, void *buf, filldir_t filler) 
     296{ 
     297        struct ovl_dir_file *od = file->private_data; 
     298        int res; 
     299 
     300        if (!file->f_pos) 
     301                ovl_dir_reset(file); 
     302 
     303        if (od->is_real) { 
     304                res = vfs_readdir(od->realfile, filler, buf); 
     305                file->f_pos = od->realfile->f_pos; 
     306 
     307                return res; 
     308        } 
     309 
     310        if (!od->is_cached) { 
     311                struct path lowerpath; 
     312                struct path upperpath; 
     313                struct ovl_readdir_data rdd = { .list = &od->cache }; 
     314 
     315                ovl_path_lower(file->f_path.dentry, &lowerpath); 
     316                ovl_path_upper(file->f_path.dentry, &upperpath); 
     317 
     318                res = ovl_dir_read_merged(&upperpath, &lowerpath, &rdd); 
     319                if (res) { 
     320                        ovl_cache_free(rdd.list); 
     321                        return res; 
     322                } 
     323 
     324                od->cache_version = ovl_dentry_version_get(file->f_path.dentry); 
     325                od->is_cached = true; 
     326 
     327                ovl_seek_cursor(od, file->f_pos); 
     328        } 
     329 
     330        while (od->cursor.next != &od->cache) { 
     331                int over; 
     332                loff_t off; 
     333                struct ovl_cache_entry *p; 
     334 
     335                p = list_entry(od->cursor.next, struct ovl_cache_entry, l_node); 
     336                off = file->f_pos; 
     337                if (!p->is_whiteout) { 
     338                        over = filler(buf, p->name, p->len, off, p->ino, p->type); 
     339                        if (over) 
     340                                break; 
     341                } 
     342                file->f_pos++; 
     343                list_move(&od->cursor, &p->l_node); 
     344        } 
     345 
     346        return 0; 
     347} 
     348 
     349static loff_t ovl_dir_llseek(struct file *file, loff_t offset, int origin) 
     350{ 
     351        loff_t res; 
     352        struct ovl_dir_file *od = file->private_data; 
     353 
     354        mutex_lock(&file->f_dentry->d_inode->i_mutex); 
     355        if (!file->f_pos) 
     356                ovl_dir_reset(file); 
     357 
     358        if (od->is_real) { 
     359                res = vfs_llseek(od->realfile, offset, origin); 
     360                file->f_pos = od->realfile->f_pos; 
     361        } else { 
     362                res = -EINVAL; 
     363 
     364                switch (origin) { 
     365                case SEEK_CUR: 
     366                        offset += file->f_pos; 
     367                        break; 
     368                case SEEK_SET: 
     369                        break; 
     370                default: 
     371                        goto out_unlock; 
     372                } 
     373                if (offset < 0) 
     374                        goto out_unlock; 
     375 
     376                if (offset != file->f_pos) { 
     377                        file->f_pos = offset; 
     378                        if (od->is_cached) 
     379                                ovl_seek_cursor(od, offset); 
     380                } 
     381                res = offset; 
     382        } 
     383out_unlock: 
     384        mutex_unlock(&file->f_dentry->d_inode->i_mutex); 
     385 
     386        return res; 
     387} 
     388 
     389static int ovl_dir_fsync(struct file *file, loff_t start, loff_t end, 
     390                         int datasync) 
     391{ 
     392        struct ovl_dir_file *od = file->private_data; 
     393 
     394        /* May need to reopen directory if it got copied up */ 
     395        if (!od->realfile) { 
     396                struct path upperpath; 
     397 
     398                ovl_path_upper(file->f_path.dentry, &upperpath); 
     399                od->realfile = vfs_open(&upperpath, O_RDONLY, current_cred()); 
     400                if (IS_ERR(od->realfile)) 
     401                        return PTR_ERR(od->realfile); 
     402        } 
     403 
     404        return vfs_fsync_range(od->realfile, start, end, datasync); 
     405} 
     406 
     407static int ovl_dir_release(struct inode *inode, struct file *file) 
     408{ 
     409        struct ovl_dir_file *od = file->private_data; 
     410 
     411        list_del(&od->cursor); 
     412        ovl_cache_free(&od->cache); 
     413        if (od->realfile) 
     414                fput(od->realfile); 
     415        kfree(od); 
     416 
     417        return 0; 
     418} 
     419 
     420static int ovl_dir_open(struct inode *inode, struct file *file) 
     421{ 
     422        struct path realpath; 
     423        struct file *realfile; 
     424        struct ovl_dir_file *od; 
     425        enum ovl_path_type type; 
     426 
     427        od = kzalloc(sizeof(struct ovl_dir_file), GFP_KERNEL); 
     428        if (!od) 
     429                return -ENOMEM; 
     430 
     431        type = ovl_path_real(file->f_path.dentry, &realpath); 
     432        realfile = vfs_open(&realpath, file->f_flags, current_cred()); 
     433        if (IS_ERR(realfile)) { 
     434                kfree(od); 
     435                return PTR_ERR(realfile); 
     436        } 
     437        INIT_LIST_HEAD(&od->cache); 
     438        INIT_LIST_HEAD(&od->cursor); 
     439        od->is_cached = false; 
     440        od->realfile = realfile; 
     441        od->is_real = (type != OVL_PATH_MERGE); 
     442        file->private_data = od; 
     443 
     444        return 0; 
     445} 
     446 
     447const struct file_operations ovl_dir_operations = { 
     448        .read           = generic_read_dir, 
     449        .open           = ovl_dir_open, 
     450        .readdir        = ovl_readdir, 
     451        .llseek         = ovl_dir_llseek, 
     452        .fsync          = ovl_dir_fsync, 
     453        .release        = ovl_dir_release, 
     454}; 
     455 
     456static int ovl_check_empty_dir(struct dentry *dentry, struct list_head *list) 
     457{ 
     458        int err; 
     459        struct path lowerpath; 
     460        struct path upperpath; 
     461        struct ovl_cache_entry *p; 
     462        struct ovl_readdir_data rdd = { .list = list }; 
     463 
     464        ovl_path_upper(dentry, &upperpath); 
     465        ovl_path_lower(dentry, &lowerpath); 
     466 
     467        err = ovl_dir_read_merged(&upperpath, &lowerpath, &rdd); 
     468        if (err) 
     469                return err; 
     470 
     471        err = 0; 
     472 
     473        list_for_each_entry(p, list, l_node) { 
     474                if (p->is_whiteout) 
     475                        continue; 
     476 
     477                if (p->name[0] == '.') { 
     478                        if (p->len == 1) 
     479                                continue; 
     480                        if (p->len == 2 && p->name[1] == '.') 
     481                                continue; 
     482                } 
     483                err = -ENOTEMPTY; 
     484                break; 
     485        } 
     486 
     487        return err; 
     488} 
     489 
     490static int ovl_remove_whiteouts(struct dentry *dir, struct list_head *list) 
     491{ 
     492        struct path upperpath; 
     493        struct dentry *upperdir; 
     494        struct ovl_cache_entry *p; 
     495        const struct cred *old_cred; 
     496        struct cred *override_cred; 
     497        int err; 
     498 
     499        ovl_path_upper(dir, &upperpath); 
     500        upperdir = upperpath.dentry; 
     501 
     502        override_cred = prepare_creds(); 
     503        if (!override_cred) 
     504                return -ENOMEM; 
     505 
     506        /* 
     507         * CAP_DAC_OVERRIDE for lookup and unlink 
     508         * CAP_SYS_ADMIN for setxattr of "trusted" namespace 
     509         * CAP_FOWNER for unlink in sticky directory 
     510         */ 
     511        cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 
     512        cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     513        cap_raise(override_cred->cap_effective, CAP_FOWNER); 
     514        old_cred = override_creds(override_cred); 
     515 
     516        err = vfs_setxattr(upperdir, ovl_opaque_xattr, "y", 1, 0); 
     517        if (err) 
     518                goto out_revert_creds; 
     519 
     520        mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
     521        list_for_each_entry(p, list, l_node) { 
     522                struct dentry *dentry; 
     523                int ret; 
     524 
     525                if (!p->is_whiteout) 
     526                        continue; 
     527 
     528                dentry = lookup_one_len(p->name, upperdir, p->len); 
     529                if (IS_ERR(dentry)) { 
     530                        printk(KERN_WARNING "overlayfs: failed to lookup whiteout %.*s: %li\n", p->len, p->name, PTR_ERR(dentry)); 
     531                        continue; 
     532                } 
     533                ret = vfs_unlink(upperdir->d_inode, dentry); 
     534                dput(dentry); 
     535                if (ret) 
     536                        printk(KERN_WARNING "overlayfs: failed to unlink whiteout %.*s: %i\n", p->len, p->name, ret); 
     537        } 
     538        mutex_unlock(&upperdir->d_inode->i_mutex); 
     539 
     540out_revert_creds: 
     541        revert_creds(old_cred); 
     542        put_cred(override_cred); 
     543 
     544        return err; 
     545} 
     546 
     547int ovl_check_empty_and_clear(struct dentry *dentry, enum ovl_path_type type) 
     548{ 
     549        int err; 
     550        LIST_HEAD(list); 
     551 
     552        err = ovl_check_empty_dir(dentry, &list); 
     553        if (!err && type == OVL_PATH_MERGE) 
     554                err = ovl_remove_whiteouts(dentry, &list); 
     555 
     556        ovl_cache_free(&list); 
     557 
     558        return err; 
     559} 
  • new file fs/overlayfs/super.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/mount.h> 
     15#include <linux/slab.h> 
     16#include <linux/parser.h> 
     17#include <linux/module.h> 
     18#include <linux/seq_file.h> 
     19#include "overlayfs.h" 
     20 
     21MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 
     22MODULE_DESCRIPTION("Overlay filesystem"); 
     23MODULE_LICENSE("GPL"); 
     24 
     25struct ovl_config { 
     26        char *lowerdir; 
     27        char *upperdir; 
     28}; 
     29 
     30/* private information held for overlayfs's superblock */ 
     31struct ovl_fs { 
     32        struct vfsmount *upper_mnt; 
     33        struct vfsmount *lower_mnt; 
     34        /* pathnames of lower and upper dirs, for show_options */ 
     35        struct ovl_config config; 
     36}; 
     37 
     38/* private information held for every overlayfs dentry */ 
     39struct ovl_entry { 
     40        /* 
     41         * Keep "double reference" on upper dentries, so that 
     42         * d_delete() doesn't think it's OK to reset d_inode to NULL. 
     43         */ 
     44        struct dentry *__upperdentry; 
     45        struct dentry *lowerdentry; 
     46        union { 
     47                struct { 
     48                        u64 version; 
     49                        bool opaque; 
     50                }; 
     51                struct rcu_head rcu; 
     52        }; 
     53}; 
     54 
     55const char *ovl_whiteout_xattr = "trusted.overlay.whiteout"; 
     56const char *ovl_opaque_xattr = "trusted.overlay.opaque"; 
     57 
     58 
     59enum ovl_path_type ovl_path_type(struct dentry *dentry) 
     60{ 
     61        struct ovl_entry *oe = dentry->d_fsdata; 
     62 
     63        if (oe->__upperdentry) { 
     64                if (oe->lowerdentry && S_ISDIR(dentry->d_inode->i_mode)) 
     65                        return OVL_PATH_MERGE; 
     66                else 
     67                        return OVL_PATH_UPPER; 
     68        } else { 
     69                return OVL_PATH_LOWER; 
     70        } 
     71} 
     72 
     73static struct dentry *ovl_upperdentry_dereference(struct ovl_entry *oe) 
     74{ 
     75        struct dentry *upperdentry = ACCESS_ONCE(oe->__upperdentry); 
     76        smp_read_barrier_depends(); 
     77        return upperdentry; 
     78} 
     79 
     80void ovl_path_upper(struct dentry *dentry, struct path *path) 
     81{ 
     82        struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 
     83        struct ovl_entry *oe = dentry->d_fsdata; 
     84 
     85        path->mnt = ofs->upper_mnt; 
     86        path->dentry = ovl_upperdentry_dereference(oe); 
     87} 
     88 
     89void ovl_path_lower(struct dentry *dentry, struct path *path) 
     90{ 
     91        struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 
     92        struct ovl_entry *oe = dentry->d_fsdata; 
     93 
     94        path->mnt = ofs->lower_mnt; 
     95        path->dentry = oe->lowerdentry; 
     96} 
     97 
     98enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path) 
     99{ 
     100 
     101        enum ovl_path_type type = ovl_path_type(dentry); 
     102 
     103        if (type == OVL_PATH_LOWER) 
     104                ovl_path_lower(dentry, path); 
     105        else 
     106                ovl_path_upper(dentry, path); 
     107 
     108        return type; 
     109} 
     110 
     111struct dentry *ovl_dentry_upper(struct dentry *dentry) 
     112{ 
     113        struct ovl_entry *oe = dentry->d_fsdata; 
     114 
     115        return ovl_upperdentry_dereference(oe); 
     116} 
     117 
     118struct dentry *ovl_dentry_lower(struct dentry *dentry) 
     119{ 
     120        struct ovl_entry *oe = dentry->d_fsdata; 
     121 
     122        return oe->lowerdentry; 
     123} 
     124 
     125struct dentry *ovl_dentry_real(struct dentry *dentry) 
     126{ 
     127        struct ovl_entry *oe = dentry->d_fsdata; 
     128        struct dentry *realdentry; 
     129 
     130        realdentry = ovl_upperdentry_dereference(oe); 
     131        if (!realdentry) 
     132                realdentry = oe->lowerdentry; 
     133 
     134        return realdentry; 
     135} 
     136 
     137struct dentry *ovl_entry_real(struct ovl_entry *oe, bool *is_upper) 
     138{ 
     139        struct dentry *realdentry; 
     140 
     141        realdentry = ovl_upperdentry_dereference(oe); 
     142        if (realdentry) { 
     143                *is_upper = true; 
     144        } else { 
     145                realdentry = oe->lowerdentry; 
     146                *is_upper = false; 
     147        } 
     148        return realdentry; 
     149} 
     150 
     151bool ovl_dentry_is_opaque(struct dentry *dentry) 
     152{ 
     153        struct ovl_entry *oe = dentry->d_fsdata; 
     154        return oe->opaque; 
     155} 
     156 
     157void ovl_dentry_set_opaque(struct dentry *dentry, bool opaque) 
     158{ 
     159        struct ovl_entry *oe = dentry->d_fsdata; 
     160        oe->opaque = opaque; 
     161} 
     162 
     163void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry) 
     164{ 
     165        struct ovl_entry *oe = dentry->d_fsdata; 
     166 
     167        WARN_ON(!mutex_is_locked(&upperdentry->d_parent->d_inode->i_mutex)); 
     168        WARN_ON(oe->__upperdentry); 
     169        BUG_ON(!upperdentry->d_inode); 
     170        smp_wmb(); 
     171        oe->__upperdentry = dget(upperdentry); 
     172} 
     173 
     174void ovl_dentry_version_inc(struct dentry *dentry) 
     175{ 
     176        struct ovl_entry *oe = dentry->d_fsdata; 
     177 
     178        WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex)); 
     179        oe->version++; 
     180} 
     181 
     182u64 ovl_dentry_version_get(struct dentry *dentry) 
     183{ 
     184        struct ovl_entry *oe = dentry->d_fsdata; 
     185 
     186        WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex)); 
     187        return oe->version; 
     188} 
     189 
     190bool ovl_is_whiteout(struct dentry *dentry) 
     191{ 
     192        int res; 
     193        char val; 
     194 
     195        if (!dentry) 
     196                return false; 
     197        if (!dentry->d_inode) 
     198                return false; 
     199        if (!S_ISLNK(dentry->d_inode->i_mode)) 
     200                return false; 
     201 
     202        res = vfs_getxattr(dentry, ovl_whiteout_xattr, &val, 1); 
     203        if (res == 1 && val == 'y') 
     204                return true; 
     205 
     206        return false; 
     207} 
     208 
     209static bool ovl_is_opaquedir(struct dentry *dentry) 
     210{ 
     211        int res; 
     212        char val; 
     213 
     214        if (!S_ISDIR(dentry->d_inode->i_mode)) 
     215                return false; 
     216 
     217        res = vfs_getxattr(dentry, ovl_opaque_xattr, &val, 1); 
     218        if (res == 1 && val == 'y') 
     219                return true; 
     220 
     221        return false; 
     222} 
     223 
     224static void ovl_entry_free(struct rcu_head *head) 
     225{ 
     226        struct ovl_entry *oe = container_of(head, struct ovl_entry, rcu); 
     227        kfree(oe); 
     228} 
     229 
     230static void ovl_dentry_release(struct dentry *dentry) 
     231{ 
     232        struct ovl_entry *oe = dentry->d_fsdata; 
     233 
     234        if (oe) { 
     235                dput(oe->__upperdentry); 
     236                dput(oe->__upperdentry); 
     237                dput(oe->lowerdentry); 
     238                call_rcu(&oe->rcu, ovl_entry_free); 
     239        } 
     240} 
     241 
     242const struct dentry_operations ovl_dentry_operations = { 
     243        .d_release = ovl_dentry_release, 
     244}; 
     245 
     246static struct ovl_entry *ovl_alloc_entry(void) 
     247{ 
     248        return kzalloc(sizeof(struct ovl_entry), GFP_KERNEL); 
     249} 
     250 
     251static inline struct dentry *ovl_lookup_real(struct dentry *dir, struct qstr *name) 
     252{ 
     253        struct dentry *dentry; 
     254 
     255        mutex_lock(&dir->d_inode->i_mutex); 
     256        dentry = lookup_one_len(name->name, dir, name->len); 
     257        mutex_unlock(&dir->d_inode->i_mutex); 
     258 
     259        if (IS_ERR(dentry)) { 
     260                if (PTR_ERR(dentry) == -ENOENT) 
     261                        dentry = NULL; 
     262        } else if (!dentry->d_inode) { 
     263                dput(dentry); 
     264                dentry = NULL; 
     265        } 
     266        return dentry; 
     267} 
     268 
     269static int ovl_do_lookup(struct dentry *dentry) 
     270{ 
     271        struct ovl_entry *oe; 
     272        struct dentry *upperdir; 
     273        struct dentry *lowerdir; 
     274        struct dentry *upperdentry = NULL; 
     275        struct dentry *lowerdentry = NULL; 
     276        struct inode *inode = NULL; 
     277        int err; 
     278 
     279        err = -ENOMEM; 
     280        oe = ovl_alloc_entry(); 
     281        if (!oe) 
     282                goto out; 
     283 
     284        upperdir = ovl_dentry_upper(dentry->d_parent); 
     285        lowerdir = ovl_dentry_lower(dentry->d_parent); 
     286 
     287        if (upperdir) { 
     288                upperdentry = ovl_lookup_real(upperdir, &dentry->d_name); 
     289                err = PTR_ERR(upperdentry); 
     290                if (IS_ERR(upperdentry)) 
     291                        goto out_put_dir; 
     292 
     293                if (lowerdir && upperdentry && 
     294                    (S_ISLNK(upperdentry->d_inode->i_mode) || 
     295                     S_ISDIR(upperdentry->d_inode->i_mode))) { 
     296                        const struct cred *old_cred; 
     297                        struct cred *override_cred; 
     298 
     299                        err = -ENOMEM; 
     300                        override_cred = prepare_creds(); 
     301                        if (!override_cred) 
     302                                goto out_dput_upper; 
     303 
     304                        /* CAP_SYS_ADMIN needed for getxattr */ 
     305                        cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     306                        old_cred = override_creds(override_cred); 
     307 
     308                        if (ovl_is_opaquedir(upperdentry)) { 
     309                                oe->opaque = true; 
     310                        } else if (ovl_is_whiteout(upperdentry)) { 
     311                                dput(upperdentry); 
     312                                upperdentry = NULL; 
     313                                oe->opaque = true; 
     314                        } 
     315                        revert_creds(old_cred); 
     316                        put_cred(override_cred); 
     317                } 
     318        } 
     319        if (lowerdir && !oe->opaque) { 
     320                lowerdentry = ovl_lookup_real(lowerdir, &dentry->d_name); 
     321                err = PTR_ERR(lowerdentry); 
     322                if (IS_ERR(lowerdentry)) 
     323                        goto out_dput_upper; 
     324        } 
     325 
     326        if (lowerdentry && upperdentry && 
     327            (!S_ISDIR(upperdentry->d_inode->i_mode) || 
     328             !S_ISDIR(lowerdentry->d_inode->i_mode))) { 
     329                dput(lowerdentry); 
     330                lowerdentry = NULL; 
     331                oe->opaque = true; 
     332        } 
     333 
     334        if (lowerdentry || upperdentry) { 
     335                struct dentry *realdentry; 
     336 
     337                realdentry = upperdentry ? upperdentry : lowerdentry; 
     338                err = -ENOMEM; 
     339                inode = ovl_new_inode(dentry->d_sb, realdentry->d_inode->i_mode, oe); 
     340                if (!inode) 
     341                        goto out_dput; 
     342        } 
     343 
     344        if (upperdentry) 
     345                oe->__upperdentry = dget(upperdentry); 
     346 
     347        if (lowerdentry) 
     348                oe->lowerdentry = lowerdentry; 
     349 
     350        dentry->d_fsdata = oe; 
     351        dentry->d_op = &ovl_dentry_operations; 
     352        d_add(dentry, inode); 
     353 
     354        return 0; 
     355 
     356out_dput: 
     357        dput(lowerdentry); 
     358out_dput_upper: 
     359        dput(upperdentry); 
     360out_put_dir: 
     361        kfree(oe); 
     362out: 
     363        return err; 
     364} 
     365 
     366struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, 
     367                          struct nameidata *nd) 
     368{ 
     369        int err = ovl_do_lookup(dentry); 
     370 
     371        if (err) 
     372                return ERR_PTR(err); 
     373 
     374        return NULL; 
     375} 
     376 
     377static void ovl_put_super(struct super_block *sb) 
     378{ 
     379        struct ovl_fs *ufs = sb->s_fs_info; 
     380 
     381        if (!(sb->s_flags & MS_RDONLY)) 
     382                mnt_drop_write(ufs->upper_mnt); 
     383 
     384        mntput(ufs->upper_mnt); 
     385        mntput(ufs->lower_mnt); 
     386 
     387        kfree(ufs->config.lowerdir); 
     388        kfree(ufs->config.upperdir); 
     389        kfree(ufs); 
     390} 
     391 
     392static int ovl_remount_fs(struct super_block *sb, int *flagsp, char *data) 
     393{ 
     394        int flags = *flagsp; 
     395        struct ovl_fs *ufs = sb->s_fs_info; 
     396 
     397        /* When remounting rw or ro, we need to adjust the write access to the 
     398         * upper fs. 
     399         */ 
     400        if (((flags ^ sb->s_flags) & MS_RDONLY) == 0) 
     401                /* No change to readonly status */ 
     402                return 0; 
     403 
     404        if (flags & MS_RDONLY) { 
     405                mnt_drop_write(ufs->upper_mnt); 
     406                return 0; 
     407        } else 
     408                return mnt_want_write(ufs->upper_mnt); 
     409} 
     410 
     411/** 
     412 * ovl_statfs 
     413 * @sb: The overlayfs super block 
     414 * @buf: The struct kstatfs to fill in with stats 
     415 * 
     416 * Get the filesystem statistics.  As writes always target the upper layer 
     417 * filesystem pass the statfs to the same filesystem. 
     418 */ 
     419static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 
     420{ 
     421        struct dentry *root_dentry = dentry->d_sb->s_root; 
     422        struct path path; 
     423        ovl_path_upper(root_dentry, &path); 
     424 
     425        if (!path.dentry->d_sb->s_op->statfs) 
     426                return -ENOSYS; 
     427        return path.dentry->d_sb->s_op->statfs(path.dentry, buf); 
     428} 
     429 
     430/** 
     431 * ovl_show_options 
     432 * 
     433 * Prints the mount options for a given superblock. 
     434 * Returns zero; does not fail. 
     435 */ 
     436static int ovl_show_options(struct seq_file *m, struct vfsmount *mnt) 
     437{ 
     438        struct super_block *sb = mnt->mnt_sb; 
     439        struct ovl_fs *ufs = sb->s_fs_info; 
     440 
     441        seq_printf(m, ",lowerdir=%s", ufs->config.lowerdir); 
     442        seq_printf(m, ",upperdir=%s", ufs->config.upperdir); 
     443        return 0; 
     444} 
     445 
     446static const struct super_operations ovl_super_operations = { 
     447        .put_super      = ovl_put_super, 
     448        .remount_fs     = ovl_remount_fs, 
     449        .statfs         = ovl_statfs, 
     450        .show_options   = ovl_show_options, 
     451}; 
     452 
     453enum { 
     454        Opt_lowerdir, 
     455        Opt_upperdir, 
     456        Opt_err, 
     457}; 
     458 
     459static const match_table_t ovl_tokens = { 
     460        {Opt_lowerdir,                  "lowerdir=%s"}, 
     461        {Opt_upperdir,                  "upperdir=%s"}, 
     462        {Opt_err,                       NULL} 
     463}; 
     464 
     465static int ovl_parse_opt(char *opt, struct ovl_config *config) 
     466{ 
     467        char *p; 
     468 
     469        config->upperdir = NULL; 
     470        config->lowerdir = NULL; 
     471 
     472        while ((p = strsep(&opt, ",")) != NULL) { 
     473                int token; 
     474                substring_t args[MAX_OPT_ARGS]; 
     475 
     476                if (!*p) 
     477                        continue; 
     478 
     479                token = match_token(p, ovl_tokens, args); 
     480                switch (token) { 
     481                case Opt_upperdir: 
     482                        kfree(config->upperdir); 
     483                        config->upperdir = match_strdup(&args[0]); 
     484                        if (!config->upperdir) 
     485                                return -ENOMEM; 
     486                        break; 
     487 
     488                case Opt_lowerdir: 
     489                        kfree(config->lowerdir); 
     490                        config->lowerdir = match_strdup(&args[0]); 
     491                        if (!config->lowerdir) 
     492                                return -ENOMEM; 
     493                        break; 
     494 
     495                default: 
     496                        return -EINVAL; 
     497                } 
     498        } 
     499        return 0; 
     500} 
     501 
     502static int ovl_fill_super(struct super_block *sb, void *data, int silent) 
     503{ 
     504        struct path lowerpath; 
     505        struct path upperpath; 
     506        struct inode *root_inode; 
     507        struct dentry *root_dentry; 
     508        struct ovl_entry *oe; 
     509        struct ovl_fs *ufs; 
     510        int err; 
     511 
     512        err = -ENOMEM; 
     513        ufs = kmalloc(sizeof(struct ovl_fs), GFP_KERNEL); 
     514        if (!ufs) 
     515                goto out; 
     516 
     517        err = ovl_parse_opt((char *) data, &ufs->config); 
     518        if (err) 
     519                goto out_free_ufs; 
     520 
     521        err = -EINVAL; 
     522        if (!ufs->config.upperdir || !ufs->config.lowerdir) { 
     523                printk(KERN_ERR "overlayfs: missing upperdir or lowerdir\n"); 
     524                goto out_free_config; 
     525        } 
     526 
     527        oe = ovl_alloc_entry(); 
     528        if (oe == NULL) 
     529                goto out_free_config; 
     530 
     531        root_inode = ovl_new_inode(sb, S_IFDIR, oe); 
     532        if (!root_inode) 
     533                goto out_free_oe; 
     534 
     535        err = kern_path(ufs->config.upperdir, LOOKUP_FOLLOW, &upperpath); 
     536        if (err) 
     537                goto out_put_root; 
     538 
     539        err = kern_path(ufs->config.lowerdir, LOOKUP_FOLLOW, &lowerpath); 
     540        if (err) 
     541                goto out_put_upperpath; 
     542 
     543        err = -ENOTDIR; 
     544        if (!S_ISDIR(upperpath.dentry->d_inode->i_mode) || 
     545            !S_ISDIR(lowerpath.dentry->d_inode->i_mode)) 
     546                goto out_put_lowerpath; 
     547 
     548        sb->s_stack_depth = max(upperpath.mnt->mnt_sb->s_stack_depth, 
     549                                lowerpath.mnt->mnt_sb->s_stack_depth) + 1; 
     550 
     551        err = -EINVAL; 
     552        if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 
     553                printk(KERN_ERR "overlayfs: maximum fs stacking depth exceeded\n"); 
     554                goto out_put_lowerpath; 
     555        } 
     556 
     557 
     558        ufs->upper_mnt = clone_private_mount(&upperpath); 
     559        err = PTR_ERR(ufs->upper_mnt); 
     560        if (IS_ERR(ufs->upper_mnt)) { 
     561                printk(KERN_ERR "overlayfs: failed to clone upperpath\n"); 
     562                goto out_put_lowerpath; 
     563        } 
     564 
     565        ufs->lower_mnt = clone_private_mount(&lowerpath); 
     566        err = PTR_ERR(ufs->lower_mnt); 
     567        if (IS_ERR(ufs->lower_mnt)) { 
     568                printk(KERN_ERR "overlayfs: failed to clone lowerpath\n"); 
     569                goto out_put_upper_mnt; 
     570        } 
     571 
     572        /* 
     573         * Make lower_mnt R/O.  That way fchmod/fchown on lower file 
     574         * will fail instead of modifying lower fs. 
     575         */ 
     576        ufs->lower_mnt->mnt_flags |= MNT_READONLY; 
     577 
     578        /* If the upper fs is r/o, we mark overlayfs r/o too */ 
     579        if (ufs->upper_mnt->mnt_sb->s_flags & MS_RDONLY) 
     580                sb->s_flags |= MS_RDONLY; 
     581 
     582        if (!(sb->s_flags & MS_RDONLY)) { 
     583                err = mnt_want_write(ufs->upper_mnt); 
     584                if (err) 
     585                        goto out_put_lower_mnt; 
     586        } 
     587 
     588        err = -ENOMEM; 
     589        root_dentry = d_alloc_root(root_inode); 
     590        if (!root_dentry) 
     591                goto out_drop_write; 
     592 
     593        mntput(upperpath.mnt); 
     594        mntput(lowerpath.mnt); 
     595 
     596        oe->__upperdentry = dget(upperpath.dentry); 
     597        oe->lowerdentry = lowerpath.dentry; 
     598 
     599        root_dentry->d_fsdata = oe; 
     600        root_dentry->d_op = &ovl_dentry_operations; 
     601 
     602        sb->s_op = &ovl_super_operations; 
     603        sb->s_root = root_dentry; 
     604        sb->s_fs_info = ufs; 
     605 
     606        return 0; 
     607 
     608out_drop_write: 
     609        if (!(sb->s_flags & MS_RDONLY)) 
     610                mnt_drop_write(ufs->upper_mnt); 
     611out_put_lower_mnt: 
     612        mntput(ufs->lower_mnt); 
     613out_put_upper_mnt: 
     614        mntput(ufs->upper_mnt); 
     615out_put_lowerpath: 
     616        path_put(&lowerpath); 
     617out_put_upperpath: 
     618        path_put(&upperpath); 
     619out_put_root: 
     620        iput(root_inode); 
     621out_free_oe: 
     622        kfree(oe); 
     623out_free_config: 
     624        kfree(ufs->config.lowerdir); 
     625        kfree(ufs->config.upperdir); 
     626out_free_ufs: 
     627        kfree(ufs); 
     628out: 
     629        return err; 
     630} 
     631 
     632static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 
     633                                const char *dev_name, void *raw_data) 
     634{ 
     635        return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 
     636} 
     637 
     638static struct file_system_type ovl_fs_type = { 
     639        .owner          = THIS_MODULE, 
     640        .name           = "overlayfs", 
     641        .mount          = ovl_mount, 
     642        .kill_sb        = kill_anon_super, 
     643}; 
     644 
     645static int __init ovl_init(void) 
     646{ 
     647        return register_filesystem(&ovl_fs_type); 
     648} 
     649 
     650static void __exit ovl_exit(void) 
     651{ 
     652        unregister_filesystem(&ovl_fs_type); 
     653} 
     654 
     655module_init(ovl_init); 
     656module_exit(ovl_exit); 
  • fs/splice.c

    a b long do_splice_direct(struct file *in, l 
    13001300 
    13011301        return ret; 
    13021302} 
     1303EXPORT_SYMBOL(do_splice_direct); 
    13031304 
    13041305static int splice_pipe_to_pipe(struct pipe_inode_info *ipipe, 
    13051306                               struct pipe_inode_info *opipe, 
  • include/linux/fs.h

    a b struct iattr { 
    482482 */ 
    483483#include <linux/quota.h> 
    484484 
     485/* 
     486 * Maximum number of layers of fs stack.  Needs to be limited to 
     487 * prevent kernel stack overflow 
     488 */ 
     489#define FILESYSTEM_MAX_STACK_DEPTH 2 
     490 
    485491/**  
    486492 * enum positive_aop_returns - aop return codes with specific semantics 
    487493 * 
    struct super_block { 
    14821488        int cleancache_poolid; 
    14831489 
    14841490        struct shrinker s_shrink;       /* per-sb shrinker handle */ 
     1491 
     1492        /* 
     1493         * Indicates how deep in a filesystem stack this SB is 
     1494         */ 
     1495        int s_stack_depth; 
    14851496}; 
    14861497 
    14871498/* superblock cache pruning functions */ 
    struct inode_operations { 
    16391650        void (*truncate_range)(struct inode *, loff_t, loff_t); 
    16401651        int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start, 
    16411652                      u64 len); 
     1653        struct file *(*open)(struct dentry *, int flags, const struct cred *); 
    16421654} ____cacheline_aligned; 
    16431655 
    16441656struct seq_file; 
    extern long do_sys_open(int dfd, const c 
    20592071extern struct file *filp_open(const char *, int, int); 
    20602072extern struct file *file_open_root(struct dentry *, struct vfsmount *, 
    20612073                                   const char *, int); 
     2074extern struct file *vfs_open(struct path *, int flags, const struct cred *); 
    20622075extern struct file * dentry_open(struct dentry *, struct vfsmount *, int, 
    20632076                                 const struct cred *); 
    20642077extern int filp_close(struct file *, fl_owner_t id); 
  • include/linux/mount.h

    a b extern void mnt_pin(struct vfsmount *mnt 
    100100extern void mnt_unpin(struct vfsmount *mnt); 
    101101extern int __mnt_is_readonly(struct vfsmount *mnt); 
    102102 
     103struct path; 
     104extern struct vfsmount *clone_private_mount(struct path *path); 
     105 
    103106extern struct vfsmount *do_kern_mount(const char *fstype, int flags, 
    104107                                      const char *name, void *data); 
    105108 
Note: See TracBrowser for help on using the repository browser.