source: trunk/target/linux/generic/patches-2.6.38/209-overlayfs.patch @ 26213

Last change on this file since 26213 was 26213, checked in by nbd, 5 years ago

kernel: replace mini_fo with overlayfs for 2.6.38

File size: 66.7 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 
     18case 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 for the overlay-filesystem, 
     23all non-directory objects will report an st_dev whichever of the 
     24'lower' or 'upper' filesystem that is providing the object.  Similarly 
     25st_ino will only be unique when combined with st_dev, and both of 
     26these can change over the lifetime of a non-directory object.  Many 
     27applications and tools 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.  Then whenever a lookup is requested in such 
     67a merged directory, the lookup is performed in each actual directory 
     68and the combined result is cached in the dentry belonging to the overlay 
     69filesystem.  If both actual lookups find directories, both are stored 
     70and a merged directory is created, otherwise only one is stored: the 
     71upper if it exists, else the lower. 
     72 
     73Only the lists of names from directories are merged.  Other content 
     74such as metadata and extended attributes are reported for the upper 
     75directory only.  These attributes of the lower directory are hidden. 
     76 
     77whiteouts and opaque directories 
     78-------------------------------- 
     79 
     80In order to support rm and rmdir without changing the lower 
     81filesystem, an overlay filesystem needs to record in the upper filesystem 
     82that files have been removed.  This is done using whiteouts and opaque 
     83directories (non-directories are always opaque). 
     84 
     85The overlay filesystem uses extended attributes with a 
     86"trusted.overlay."  prefix to record these details. 
     87 
     88A whiteout is created as a symbolic link with target 
     89"(overlay-whiteout)" and with xattr "trusted.overlay.whiteout" set to "y". 
     90When a whiteout is found in the upper level of a merged directory, any 
     91matching name in the lower level is ignored, and the whiteout itself 
     92is also hidden. 
     93 
     94A directory is made opaque by setting the xattr "trusted.overlay.opaque" 
     95to "y".  Where the upper filesystem contains an opaque directory, any 
     96directory in the lower filesystem with the same name is ignored. 
     97 
     98readdir 
     99------- 
     100 
     101When a 'readdir' request is made on a merged directory, the upper and 
     102lower directories are each read and the name lists merged in the 
     103obvious way (upper is read first, then lower - entries that already 
     104exist are not re-added).  This merged name list is cached in the 
     105'struct file' and so remains as long as the file is kept open.  If the 
     106directory is opened and read by two processes at the same time, they 
     107will each have separate caches.  A seekdir to the start of the 
     108directory (offset 0) followed by a readdir will cause the cache to be 
     109discarded and rebuilt. 
     110 
     111This means that changes to the merged directory do not appear while a 
     112directory is being read.  This is unlikely to be noticed by many 
     113programs. 
     114 
     115seek offsets are assigned sequentially when the directories are read. 
     116Thus if 
     117  - read part of a directory 
     118  - remember an offset, and close the directory 
     119  - re-open the directory some time later 
     120  - seek to the remembered offset 
     121 
     122there may be little correlation between the old and new locations in 
     123the list of filenames, particularly if anything has changed in the 
     124directory. 
     125 
     126Readdir on directories that are not merged is simply handled by the 
     127underlying directory (upper or lower). 
     128 
     129 
     130Non-directories 
     131--------------- 
     132 
     133Objects that are not directories (files, symlinks, device-special 
     134files etc) are presented either from the upper or lower filesystem as 
     135appropriate.  When a file in the lower filesystem is accessed in a way 
     136the requires write-access; such as opening for write access, changing 
     137some metadata etc, the file is first copied from the lower filesystem 
     138to the upper filesystem (copy_up).  Note that creating a hard-link 
     139also requires copy-up, though of course creation of a symlink does 
     140not. 
     141 
     142The copy_up process first makes sure that the containing directory 
     143exists in the upper filesystem - creating it and any parents as 
     144necessary.  It then creates the object with the same metadata (owner, 
     145mode, mtime, symlink-target etc) and then if the object is a file, the 
     146data is copied from the lower to the upper filesystem.  Finally any 
     147extended attributes are copied up. 
     148 
     149Once the copy_up is complete, the overlay filesystem simply 
     150provides direct access to the newly created file in the upper 
     151filesystem - future operations on the file are barely noticed by the 
     152overlay filesystem (though an operation on the name of the file such as 
     153rename or unlink will of course be noticed and handled). 
     154 
     155Changes to underlying filesystems 
     156--------------------------------- 
     157 
     158Offline changes, when the overlay is not mounted, are allowed to either 
     159the upper or the lower trees. 
     160 
     161Changes to the underlying filesystems while part of a mounted overlay 
     162filesystem are not allowed.  This is not yet enforced, but will be in 
     163the future. 
  • 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/ 
    103103obj-$(CONFIG_AUTOFS4_FS)        += autofs4/ 
    104104obj-$(CONFIG_ADFS_FS)           += adfs/ 
    105105obj-$(CONFIG_FUSE_FS)           += fuse/ 
     106obj-$(CONFIG_OVERLAYFS_FS)      += overlayfs/ 
    106107obj-$(CONFIG_UDF_FS)            += udf/ 
    107108obj-$(CONFIG_SUN_OPENPROMFS)    += openpromfs/ 
    108109obj-$(CONFIG_OMFS_FS)           += omfs/ 
  • fs/namespace.c

    a b void drop_collected_mounts(struct vfsmou 
    14511451        release_mounts(&umount_list); 
    14521452} 
    14531453 
     1454struct vfsmount *clone_private_mount(struct path *path) 
     1455{ 
     1456        struct vfsmount *mnt; 
     1457 
     1458        if (IS_MNT_UNBINDABLE(path->mnt)) 
     1459                return ERR_PTR(-EINVAL); 
     1460 
     1461        down_read(&namespace_sem); 
     1462        mnt = clone_mnt(path->mnt, path->dentry, CL_PRIVATE); 
     1463        up_read(&namespace_sem); 
     1464        if (!mnt) 
     1465                return ERR_PTR(-ENOMEM); 
     1466 
     1467        return mnt; 
     1468} 
     1469EXPORT_SYMBOL_GPL(clone_private_mount); 
     1470 
    14541471int iterate_mounts(int (*f)(struct vfsmount *, void *), void *arg, 
    14551472                   struct vfsmount *root) 
    14561473{ 
  • fs/open.c

    a b static inline int __get_file_write_acces 
    664664        return error; 
    665665} 
    666666 
    667 static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt, 
    668                                         struct file *f, 
     667static struct file *__dentry_open(struct path *path, struct file *f, 
    669668                                        int (*open)(struct inode *, struct file *), 
    670669                                        const struct cred *cred) 
    671670{ 
    672671        struct inode *inode; 
    673672        int error; 
    674673 
     674        path_get(path); 
    675675        f->f_mode = OPEN_FMODE(f->f_flags) | FMODE_LSEEK | 
    676676                                FMODE_PREAD | FMODE_PWRITE; 
    677         inode = dentry->d_inode; 
     677        inode = path->dentry->d_inode; 
    678678        if (f->f_mode & FMODE_WRITE) { 
    679                 error = __get_file_write_access(inode, mnt); 
     679                error = __get_file_write_access(inode, path->mnt); 
    680680                if (error) 
    681681                        goto cleanup_file; 
    682682                if (!special_file(inode->i_mode)) 
    static struct file *__dentry_open(struct 
    684684        } 
    685685 
    686686        f->f_mapping = inode->i_mapping; 
    687         f->f_path.dentry = dentry; 
    688         f->f_path.mnt = mnt; 
     687        f->f_path = *path; 
    689688        f->f_pos = 0; 
    690689        f->f_op = fops_get(inode->i_fop); 
    691690        file_sb_list_add(f, inode->i_sb); 
    cleanup_all: 
    731730                         * here, so just reset the state. 
    732731                         */ 
    733732                        file_reset_write(f); 
    734                         mnt_drop_write(mnt); 
     733                        mnt_drop_write(path->mnt); 
    735734                } 
    736735        } 
    737736        file_sb_list_del(f); 
    cleanup_all: 
    739738        f->f_path.mnt = NULL; 
    740739cleanup_file: 
    741740        put_filp(f); 
    742         dput(dentry); 
    743         mntput(mnt); 
     741        path_put(path); 
    744742        return ERR_PTR(error); 
    745743} 
    746744 
    cleanup_file: 
    766764struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry *dentry, 
    767765                int (*open)(struct inode *, struct file *)) 
    768766{ 
     767        struct path path = { .dentry = dentry, .mnt = nd->path.mnt }; 
    769768        const struct cred *cred = current_cred(); 
    770769 
    771770        if (IS_ERR(nd->intent.open.file)) 
    772771                goto out; 
    773772        if (IS_ERR(dentry)) 
    774773                goto out_err; 
    775         nd->intent.open.file = __dentry_open(dget(dentry), mntget(nd->path.mnt), 
    776                                              nd->intent.open.file, 
     774        nd->intent.open.file = __dentry_open(&path, nd->intent.open.file, 
    777775                                             open, cred); 
    778776out: 
    779777        return nd->intent.open.file; 
    struct file *nameidata_to_filp(struct na 
    802800 
    803801        /* Has the filesystem initialised the file for us? */ 
    804802        if (filp->f_path.dentry == NULL) { 
    805                 path_get(&nd->path); 
    806                 filp = __dentry_open(nd->path.dentry, nd->path.mnt, filp, 
    807                                      NULL, cred); 
     803                struct inode *inode = nd->path.dentry->d_inode; 
     804 
     805                if (inode->i_op->open) { 
     806                        int flags = filp->f_flags; 
     807                        put_filp(filp); 
     808                        filp = inode->i_op->open(nd->path.dentry, flags, cred); 
     809                } else { 
     810                        filp = __dentry_open(&nd->path, filp, NULL, cred); 
     811                } 
    808812        } 
     813 
    809814        return filp; 
    810815} 
    811816 
    struct file *nameidata_to_filp(struct na 
    816821struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags, 
    817822                         const struct cred *cred) 
    818823{ 
    819         int error; 
     824        struct path path = { .dentry = dentry, .mnt = mnt }; 
     825        struct file *ret; 
     826 
     827        BUG_ON(!mnt); 
     828 
     829        ret = vfs_open(&path, flags, cred); 
     830        path_put(&path); 
     831 
     832        return ret; 
     833} 
     834EXPORT_SYMBOL(dentry_open); 
     835 
     836/** 
     837 * vfs_open - open the file at the given path 
     838 * @path: path to open 
     839 * @flags: open flags 
     840 * @cred: credentials to use 
     841 * 
     842 * Open the file.  If successful, the returned file will have acquired 
     843 * an additional reference for path. 
     844 */ 
     845struct file *vfs_open(struct path *path, int flags, const struct cred *cred) 
     846{ 
    820847        struct file *f; 
     848        struct inode *inode = path->dentry->d_inode; 
    821849 
    822850        validate_creds(cred); 
    823851 
    824         /* 
    825          * We must always pass in a valid mount pointer.   Historically 
    826          * callers got away with not passing it, but we must enforce this at 
    827          * the earliest possible point now to avoid strange problems deep in the 
    828          * filesystem stack. 
    829          */ 
    830         if (!mnt) { 
    831                 printk(KERN_WARNING "%s called with NULL vfsmount\n", __func__); 
    832                 dump_stack(); 
    833                 return ERR_PTR(-EINVAL); 
    834         } 
     852        if (inode->i_op->open) 
     853                return inode->i_op->open(path->dentry, flags, cred); 
    835854 
    836         error = -ENFILE; 
    837855        f = get_empty_filp(); 
    838         if (f == NULL) { 
    839                 dput(dentry); 
    840                 mntput(mnt); 
    841                 return ERR_PTR(error); 
    842         } 
     856        if (f == NULL) 
     857                return ERR_PTR(-ENFILE); 
    843858 
    844859        f->f_flags = flags; 
    845         return __dentry_open(dentry, mnt, f, NULL, cred); 
     860        return __dentry_open(path, f, NULL, cred); 
    846861} 
    847 EXPORT_SYMBOL(dentry_open); 
     862EXPORT_SYMBOL(vfs_open); 
    848863 
    849864static void __put_unused_fd(struct files_struct *files, unsigned int fd) 
    850865{ 
  • 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 
  • new file fs/overlayfs/overlayfs.c

    - +  
     1#include <linux/fs.h> 
     2#include <linux/namei.h> 
     3#include <linux/sched.h> 
     4#include <linux/fs_struct.h> 
     5#include <linux/file.h> 
     6#include <linux/xattr.h> 
     7#include <linux/security.h> 
     8#include <linux/device_cgroup.h> 
     9#include <linux/mount.h> 
     10#include <linux/splice.h> 
     11#include <linux/slab.h> 
     12#include <linux/parser.h> 
     13#include <linux/module.h> 
     14#include <linux/uaccess.h> 
     15#include <linux/rbtree.h> 
     16 
     17MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 
     18MODULE_DESCRIPTION("Overlay filesystem"); 
     19MODULE_LICENSE("GPL"); 
     20 
     21#define OVL_COPY_UP_CHUNK_SIZE (1 << 20) 
     22 
     23struct ovl_fs { 
     24        struct vfsmount *upper_mnt; 
     25        struct vfsmount *lower_mnt; 
     26}; 
     27 
     28struct ovl_entry { 
     29        struct dentry *__upperdentry; 
     30        struct dentry *lowerdentry; 
     31        union { 
     32                struct { 
     33                        u64 version; 
     34                        bool opaque; 
     35                }; 
     36                struct rcu_head rcu; 
     37        }; 
     38}; 
     39 
     40static const char *ovl_whiteout_xattr = "trusted.overlay.whiteout"; 
     41static const char *ovl_opaque_xattr = "trusted.overlay.opaque"; 
     42static const char *ovl_whiteout_symlink = "(overlay-whiteout)"; 
     43 
     44enum ovl_path_type { 
     45        OVL_PATH_UPPER, 
     46        OVL_PATH_MERGE, 
     47        OVL_PATH_LOWER, 
     48}; 
     49 
     50static enum ovl_path_type ovl_path_type(struct dentry *dentry) 
     51{ 
     52        struct ovl_entry *oe = dentry->d_fsdata; 
     53 
     54        if (oe->__upperdentry) { 
     55                if (oe->lowerdentry && S_ISDIR(dentry->d_inode->i_mode)) 
     56                        return OVL_PATH_MERGE; 
     57                else 
     58                        return OVL_PATH_UPPER; 
     59        } else { 
     60                return OVL_PATH_LOWER; 
     61        } 
     62} 
     63 
     64static struct dentry *ovl_upperdentry_dereference(struct ovl_entry *oe) 
     65{ 
     66        struct dentry *upperdentry = ACCESS_ONCE(oe->__upperdentry); 
     67        smp_read_barrier_depends(); 
     68        return upperdentry; 
     69} 
     70 
     71static void ovl_path_upper(struct dentry *dentry, struct path *path) 
     72{ 
     73        struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 
     74        struct ovl_entry *oe = dentry->d_fsdata; 
     75 
     76        path->mnt = ofs->upper_mnt; 
     77        path->dentry = ovl_upperdentry_dereference(oe); 
     78} 
     79 
     80static void ovl_path_lower(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->lower_mnt; 
     86        path->dentry = oe->lowerdentry; 
     87} 
     88 
     89static enum ovl_path_type ovl_path_real(struct dentry *dentry, 
     90                                        struct path *path) 
     91{ 
     92 
     93        enum ovl_path_type type = ovl_path_type(dentry); 
     94 
     95        if (type == OVL_PATH_LOWER) 
     96                ovl_path_lower(dentry, path); 
     97        else 
     98                ovl_path_upper(dentry, path); 
     99 
     100        return type; 
     101} 
     102 
     103static struct dentry *ovl_dentry_upper(struct dentry *dentry) 
     104{ 
     105        struct ovl_entry *oe = dentry->d_fsdata; 
     106 
     107        return ovl_upperdentry_dereference(oe); 
     108} 
     109 
     110static struct dentry *ovl_dentry_lower(struct dentry *dentry) 
     111{ 
     112        struct ovl_entry *oe = dentry->d_fsdata; 
     113 
     114        return oe->lowerdentry; 
     115} 
     116 
     117static struct dentry *ovl_dentry_real(struct dentry *dentry) 
     118{ 
     119        struct ovl_entry *oe = dentry->d_fsdata; 
     120        struct dentry *realdentry; 
     121 
     122        realdentry = ovl_upperdentry_dereference(oe); 
     123        if (!realdentry) 
     124                realdentry = oe->lowerdentry; 
     125 
     126        return realdentry; 
     127} 
     128 
     129static bool ovl_dentry_is_opaque(struct dentry *dentry) 
     130{ 
     131        struct ovl_entry *oe = dentry->d_fsdata; 
     132        return oe->opaque; 
     133} 
     134 
     135static void ovl_dentry_set_opaque(struct dentry *dentry, bool opaque) 
     136{ 
     137        struct ovl_entry *oe = dentry->d_fsdata; 
     138        oe->opaque = opaque; 
     139} 
     140 
     141static void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry) 
     142{ 
     143        struct ovl_entry *oe = dentry->d_fsdata; 
     144 
     145        WARN_ON(!mutex_is_locked(&upperdentry->d_parent->d_inode->i_mutex)); 
     146        WARN_ON(oe->__upperdentry); 
     147        smp_wmb(); 
     148        oe->__upperdentry = upperdentry; 
     149} 
     150 
     151static void ovl_dentry_version_inc(struct dentry *dentry) 
     152{ 
     153        struct ovl_entry *oe = dentry->d_fsdata; 
     154 
     155        WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex)); 
     156        oe->version++; 
     157} 
     158 
     159static u64 ovl_dentry_version_get(struct dentry *dentry) 
     160{ 
     161        struct ovl_entry *oe = dentry->d_fsdata; 
     162 
     163        WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex)); 
     164        return oe->version; 
     165} 
     166 
     167static bool ovl_is_whiteout(struct dentry *dentry) 
     168{ 
     169        int res; 
     170        char val; 
     171 
     172        if (!dentry) 
     173                return false; 
     174        if (!dentry->d_inode) 
     175                return false; 
     176        if (!S_ISLNK(dentry->d_inode->i_mode)) 
     177                return false; 
     178 
     179        res = vfs_getxattr(dentry, ovl_whiteout_xattr, &val, 1); 
     180        if (res == 1 && val == 'y') 
     181                return true; 
     182 
     183        return false; 
     184} 
     185 
     186static bool ovl_is_opaquedir(struct dentry *dentry) 
     187{ 
     188        int res; 
     189        char val; 
     190 
     191        if (!S_ISDIR(dentry->d_inode->i_mode)) 
     192                return false; 
     193 
     194        res = vfs_getxattr(dentry, ovl_opaque_xattr, &val, 1); 
     195        if (res == 1 && val == 'y') 
     196                return true; 
     197 
     198        return false; 
     199} 
     200 
     201struct ovl_cache_entry { 
     202        const char *name; 
     203        unsigned int len; 
     204        unsigned int type; 
     205        u64 ino; 
     206        bool is_whiteout; 
     207        struct list_head l_node; 
     208        struct rb_node node; 
     209}; 
     210 
     211struct ovl_readdir_data { 
     212        struct rb_root *root; 
     213        struct list_head *list; 
     214        struct list_head *middle; 
     215        struct dentry *dir; 
     216        int count; 
     217        int err; 
     218}; 
     219 
     220struct ovl_dir_file { 
     221        bool is_real; 
     222        bool is_cached; 
     223        struct list_head cursor; 
     224        u64 cache_version; 
     225        struct list_head cache; 
     226        struct file *realfile; 
     227}; 
     228 
     229static struct ovl_cache_entry *ovl_cache_entry_from_node(struct rb_node *n) 
     230{ 
     231        return container_of(n, struct ovl_cache_entry, node); 
     232} 
     233 
     234static struct ovl_cache_entry *ovl_cache_entry_find(struct rb_root *root, 
     235                                                    const char *name, int len) 
     236{ 
     237        struct rb_node *node = root->rb_node; 
     238        int cmp; 
     239 
     240        while (node) { 
     241                struct ovl_cache_entry *p = ovl_cache_entry_from_node(node); 
     242 
     243                cmp = strncmp(name, p->name, len); 
     244                if (cmp > 0) 
     245                        node = p->node.rb_right; 
     246                else if (cmp < 0 || len < p->len) 
     247                        node = p->node.rb_left; 
     248                else 
     249                        return p; 
     250        } 
     251 
     252        return NULL; 
     253} 
     254 
     255static struct ovl_cache_entry *ovl_cache_entry_new(const char *name, int len, 
     256                                                   u64 ino, unsigned int d_type, 
     257                                                   bool is_whiteout) 
     258{ 
     259        struct ovl_cache_entry *p; 
     260 
     261        p = kmalloc(sizeof(*p) + len + 1, GFP_KERNEL); 
     262        if (p) { 
     263                char *name_copy = (char *) (p + 1); 
     264                memcpy(name_copy, name, len); 
     265                name_copy[len] = '\0'; 
     266                p->name = name_copy; 
     267                p->len = len; 
     268                p->type = d_type; 
     269                p->ino = ino; 
     270                p->is_whiteout = is_whiteout; 
     271        } 
     272 
     273        return p; 
     274} 
     275 
     276static int ovl_cache_entry_add_rb(struct ovl_readdir_data *rdd, 
     277                                  const char *name, int len, u64 ino, 
     278                                  unsigned int d_type, bool is_whiteout) 
     279{ 
     280        struct rb_node **newp = &rdd->root->rb_node; 
     281        struct rb_node *parent = NULL; 
     282        struct ovl_cache_entry *p; 
     283 
     284        while (*newp) { 
     285                int cmp; 
     286                struct ovl_cache_entry *tmp; 
     287 
     288                parent = *newp; 
     289                tmp = ovl_cache_entry_from_node(*newp); 
     290                cmp = strncmp(name, tmp->name, len); 
     291                if (cmp > 0) 
     292                        newp = &tmp->node.rb_right; 
     293                else if (cmp < 0 || len < tmp->len) 
     294                        newp = &tmp->node.rb_left; 
     295                else 
     296                        return 0; 
     297        } 
     298 
     299        p = ovl_cache_entry_new(name, len, ino, d_type, is_whiteout); 
     300        if (p == NULL) 
     301                return -ENOMEM; 
     302 
     303        list_add_tail(&p->l_node, rdd->list); 
     304        rb_link_node(&p->node, parent, newp); 
     305        rb_insert_color(&p->node, rdd->root); 
     306 
     307        return 0; 
     308} 
     309 
     310static int ovl_fill_lower(void *buf, const char *name, int namelen, 
     311                            loff_t offset, u64 ino, unsigned int d_type) 
     312{ 
     313        struct ovl_readdir_data *rdd = buf; 
     314        struct ovl_cache_entry *p; 
     315 
     316        rdd->count++; 
     317        p = ovl_cache_entry_find(rdd->root, name, namelen); 
     318        if (p) { 
     319                list_move_tail(&p->l_node, rdd->middle); 
     320        } else { 
     321                p = ovl_cache_entry_new(name, namelen, ino, d_type, false); 
     322                if (p == NULL) 
     323                        rdd->err = -ENOMEM; 
     324                else 
     325                        list_add_tail(&p->l_node, rdd->middle); 
     326        } 
     327 
     328        return rdd->err; 
     329} 
     330 
     331static void ovl_cache_free(struct list_head *list) 
     332{ 
     333        struct ovl_cache_entry *p; 
     334        struct ovl_cache_entry *n; 
     335 
     336        list_for_each_entry_safe(p, n, list, l_node) 
     337                kfree(p); 
     338 
     339        INIT_LIST_HEAD(list); 
     340} 
     341 
     342static int ovl_fill_upper(void *buf, const char *name, int namelen, 
     343                          loff_t offset, u64 ino, unsigned int d_type) 
     344{ 
     345        struct ovl_readdir_data *rdd = buf; 
     346        bool is_whiteout = false; 
     347 
     348        rdd->count++; 
     349        if (d_type == DT_LNK) { 
     350                struct dentry *dentry; 
     351 
     352                dentry = lookup_one_len(name, rdd->dir, namelen); 
     353                if (IS_ERR(dentry)) { 
     354                        rdd->err = PTR_ERR(dentry); 
     355                        goto out; 
     356                } 
     357                is_whiteout = ovl_is_whiteout(dentry); 
     358                dput(dentry); 
     359        } 
     360 
     361        rdd->err = ovl_cache_entry_add_rb(rdd, name, namelen, ino, d_type, 
     362                                          is_whiteout); 
     363 
     364out: 
     365        return rdd->err; 
     366} 
     367 
     368static int ovl_dir_read(struct path *realpath, struct ovl_readdir_data *rdd, 
     369                          filldir_t filler) 
     370{ 
     371        const struct cred *old_cred; 
     372        struct cred *override_cred; 
     373        struct file *realfile; 
     374        int err; 
     375 
     376        realfile = vfs_open(realpath, O_RDONLY | O_DIRECTORY, current_cred()); 
     377        if (IS_ERR(realfile)) 
     378                return PTR_ERR(realfile); 
     379 
     380        err = -ENOMEM; 
     381        override_cred = prepare_creds(); 
     382        if (override_cred) { 
     383                /* 
     384                 * CAP_SYS_ADMIN for getxattr 
     385                 * CAP_DAC_OVERRIDE for lookup and unlink 
     386                 */ 
     387                cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     388                cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 
     389                old_cred = override_creds(override_cred); 
     390 
     391                do { 
     392                        rdd->count = 0; 
     393                        rdd->err = 0; 
     394                        err = vfs_readdir(realfile, filler, rdd); 
     395                        if (err >= 0) 
     396                                err = rdd->err; 
     397                } while (!err && rdd->count); 
     398 
     399                revert_creds(old_cred); 
     400                put_cred(override_cred); 
     401        } 
     402        fput(realfile); 
     403 
     404        if (err) { 
     405                if (rdd->list) 
     406                        ovl_cache_free(rdd->list); 
     407                return err; 
     408        } 
     409 
     410        return 0; 
     411} 
     412 
     413static void ovl_dir_reset(struct file *file) 
     414{ 
     415        struct ovl_dir_file *od = file->private_data; 
     416        enum ovl_path_type type = ovl_path_type(file->f_path.dentry); 
     417 
     418        if (ovl_dentry_version_get(file->f_path.dentry) != od->cache_version) { 
     419                list_del_init(&od->cursor); 
     420                ovl_cache_free(&od->cache); 
     421                od->is_cached = false; 
     422        } 
     423        WARN_ON(!od->is_real && type != OVL_PATH_MERGE); 
     424        if (od->is_real && type == OVL_PATH_MERGE) { 
     425                fput(od->realfile); 
     426                od->realfile = NULL; 
     427                od->is_real = false; 
     428        } 
     429} 
     430 
     431static int ovl_dir_read_merged(struct path *upperpath, struct path *lowerpath, 
     432                               struct ovl_readdir_data *rdd) 
     433{ 
     434        int err; 
     435        struct rb_root root = RB_ROOT; 
     436        struct list_head middle; 
     437 
     438        rdd->root = &root; 
     439        if (upperpath->dentry) { 
     440                rdd->dir = upperpath->dentry; 
     441                err = ovl_dir_read(upperpath, rdd, ovl_fill_upper); 
     442                if (err) 
     443                        goto out; 
     444        } 
     445        /* 
     446         * Insert lowerpath entries before upperpath ones, this allows 
     447         * offsets to be reasonably constant 
     448         */ 
     449        list_add(&middle, rdd->list); 
     450        rdd->middle = &middle; 
     451        err = ovl_dir_read(lowerpath, rdd, ovl_fill_lower); 
     452        list_del(&middle); 
     453out: 
     454        rdd->root = NULL; 
     455 
     456        return err; 
     457} 
     458 
     459static void ovl_seek_cursor(struct ovl_dir_file *od, loff_t pos) 
     460{ 
     461        struct list_head *l; 
     462        loff_t off; 
     463 
     464        l = od->cache.next; 
     465        for (off = 0; off < pos; off++) { 
     466                if (l == &od->cache) 
     467                        break; 
     468                l = l->next; 
     469        } 
     470        list_move_tail(&od->cursor, l); 
     471} 
     472 
     473static int ovl_readdir(struct file *file, void *buf, filldir_t filler) 
     474{ 
     475        struct ovl_dir_file *od = file->private_data; 
     476        int res; 
     477 
     478        if (!file->f_pos) 
     479                ovl_dir_reset(file); 
     480 
     481        if (od->is_real) { 
     482                res = vfs_readdir(od->realfile, filler, buf); 
     483                file->f_pos = od->realfile->f_pos; 
     484 
     485                return res; 
     486        } 
     487 
     488        if (!od->is_cached) { 
     489                struct path lowerpath; 
     490                struct path upperpath; 
     491                struct ovl_readdir_data rdd = { .list = &od->cache }; 
     492 
     493                ovl_path_lower(file->f_path.dentry, &lowerpath); 
     494                ovl_path_upper(file->f_path.dentry, &upperpath); 
     495 
     496                res = ovl_dir_read_merged(&upperpath, &lowerpath, &rdd); 
     497                if (res) 
     498                        return res; 
     499 
     500                od->cache_version = ovl_dentry_version_get(file->f_path.dentry); 
     501                od->is_cached = true; 
     502 
     503                ovl_seek_cursor(od, file->f_pos); 
     504        } 
     505 
     506        while (od->cursor.next != &od->cache) { 
     507                int over; 
     508                loff_t off; 
     509                struct ovl_cache_entry *p; 
     510 
     511                p = list_entry(od->cursor.next, struct ovl_cache_entry, l_node); 
     512                off = file->f_pos; 
     513                file->f_pos++; 
     514                list_move(&od->cursor, &p->l_node); 
     515 
     516                if (p->is_whiteout) 
     517                        continue; 
     518 
     519                over = filler(buf, p->name, p->len, off, p->ino, p->type); 
     520                if (over) 
     521                        break; 
     522        } 
     523 
     524        return 0; 
     525} 
     526 
     527static loff_t ovl_dir_llseek(struct file *file, loff_t offset, int origin) 
     528{ 
     529        loff_t res; 
     530        struct ovl_dir_file *od = file->private_data; 
     531 
     532        mutex_lock(&file->f_dentry->d_inode->i_mutex); 
     533        if (!file->f_pos) 
     534                ovl_dir_reset(file); 
     535 
     536        if (od->is_real) { 
     537                res = vfs_llseek(od->realfile, offset, origin); 
     538                file->f_pos = od->realfile->f_pos; 
     539        } else { 
     540                res = -EINVAL; 
     541 
     542                switch (origin) { 
     543                case SEEK_CUR: 
     544                        offset += file->f_pos; 
     545                        break; 
     546                case SEEK_SET: 
     547                        break; 
     548                default: 
     549                        goto out_unlock; 
     550                } 
     551                if (offset < 0) 
     552                        goto out_unlock; 
     553 
     554                if (offset != file->f_pos) { 
     555                        file->f_pos = offset; 
     556                        if (od->is_cached) 
     557                                ovl_seek_cursor(od, offset); 
     558                } 
     559                res = offset; 
     560        } 
     561out_unlock: 
     562        mutex_unlock(&file->f_dentry->d_inode->i_mutex); 
     563 
     564        return res; 
     565} 
     566 
     567static int ovl_dir_fsync(struct file *file, int datasync) 
     568{ 
     569        struct ovl_dir_file *od = file->private_data; 
     570 
     571        /* May need to reopen directory if it got copied up */ 
     572        if (!od->realfile) { 
     573                struct path upperpath; 
     574 
     575                ovl_path_upper(file->f_path.dentry, &upperpath); 
     576                od->realfile = vfs_open(&upperpath, O_RDONLY, current_cred()); 
     577                if (IS_ERR(od->realfile)) 
     578                        return PTR_ERR(od->realfile); 
     579        } 
     580 
     581        return vfs_fsync(od->realfile, datasync); 
     582} 
     583 
     584static int ovl_dir_release(struct inode *inode, struct file *file) 
     585{ 
     586        struct ovl_dir_file *od = file->private_data; 
     587 
     588        list_del(&od->cursor); 
     589        ovl_cache_free(&od->cache); 
     590        if (od->realfile) 
     591                fput(od->realfile); 
     592        kfree(od); 
     593 
     594        return 0; 
     595} 
     596 
     597static int ovl_dir_open(struct inode *inode, struct file *file) 
     598{ 
     599        struct path realpath; 
     600        struct file *realfile; 
     601        struct ovl_dir_file *od; 
     602        enum ovl_path_type type; 
     603 
     604        od = kzalloc(sizeof(struct ovl_dir_file), GFP_KERNEL); 
     605        if (!od) 
     606                return -ENOMEM; 
     607 
     608        type = ovl_path_real(file->f_path.dentry, &realpath); 
     609        realfile = vfs_open(&realpath, file->f_flags, current_cred()); 
     610        if (IS_ERR(realfile)) { 
     611                kfree(od); 
     612                return PTR_ERR(realfile); 
     613        } 
     614        INIT_LIST_HEAD(&od->cache); 
     615        INIT_LIST_HEAD(&od->cursor); 
     616        od->is_cached = false; 
     617        od->realfile = realfile; 
     618        od->is_real = (type != OVL_PATH_MERGE); 
     619        file->private_data = od; 
     620 
     621        return 0; 
     622} 
     623 
     624static const struct file_operations ovl_dir_operations = { 
     625        .read           = generic_read_dir, 
     626        .open           = ovl_dir_open, 
     627        .readdir        = ovl_readdir, 
     628        .llseek         = ovl_dir_llseek, 
     629        .fsync          = ovl_dir_fsync, 
     630        .release        = ovl_dir_release, 
     631}; 
     632 
     633static const struct inode_operations ovl_dir_inode_operations; 
     634 
     635static void ovl_entry_free(struct rcu_head *head) 
     636{ 
     637        struct ovl_entry *oe = container_of(head, struct ovl_entry, rcu); 
     638        kfree(oe); 
     639} 
     640 
     641static void ovl_dentry_release(struct dentry *dentry) 
     642{ 
     643        struct ovl_entry *oe = dentry->d_fsdata; 
     644 
     645        if (oe) { 
     646                dput(oe->__upperdentry); 
     647                dput(oe->lowerdentry); 
     648                call_rcu(&oe->rcu, ovl_entry_free); 
     649        } 
     650} 
     651 
     652static const struct dentry_operations ovl_dentry_operations = { 
     653        .d_release = ovl_dentry_release, 
     654}; 
     655 
     656static struct dentry *ovl_lookup_real(struct dentry *dir, struct qstr *name) 
     657{ 
     658        struct dentry *dentry; 
     659 
     660        mutex_lock(&dir->d_inode->i_mutex); 
     661        dentry = lookup_one_len(name->name, dir, name->len); 
     662        mutex_unlock(&dir->d_inode->i_mutex); 
     663 
     664        if (IS_ERR(dentry)) { 
     665                if (PTR_ERR(dentry) == -ENOENT) 
     666                        dentry = NULL; 
     667        } else if (!dentry->d_inode) { 
     668                dput(dentry); 
     669                dentry = NULL; 
     670        } 
     671        return dentry; 
     672} 
     673 
     674static struct ovl_entry *ovl_alloc_entry(void) 
     675{ 
     676        return kzalloc(sizeof(struct ovl_entry), GFP_KERNEL); 
     677} 
     678 
     679static struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, 
     680                                   struct ovl_entry *oe); 
     681 
     682static struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, 
     683                                   struct nameidata *nd) 
     684{ 
     685        struct ovl_entry *oe; 
     686        struct dentry *upperdir; 
     687        struct dentry *lowerdir; 
     688        struct dentry *upperdentry = NULL; 
     689        struct dentry *lowerdentry = NULL; 
     690        struct inode *inode = NULL; 
     691        int err; 
     692 
     693        err = -ENOMEM; 
     694        oe = ovl_alloc_entry(); 
     695        if (!oe) 
     696                goto out; 
     697 
     698        upperdir = ovl_dentry_upper(dentry->d_parent); 
     699        lowerdir = ovl_dentry_lower(dentry->d_parent); 
     700 
     701        if (upperdir) { 
     702                upperdentry = ovl_lookup_real(upperdir, &dentry->d_name); 
     703                err = PTR_ERR(upperdentry); 
     704                if (IS_ERR(upperdentry)) 
     705                        goto out_put_dir; 
     706 
     707                if (lowerdir && upperdentry && 
     708                    (S_ISLNK(upperdentry->d_inode->i_mode) || 
     709                     S_ISDIR(upperdentry->d_inode->i_mode))) { 
     710                        const struct cred *old_cred; 
     711                        struct cred *override_cred; 
     712 
     713                        err = -ENOMEM; 
     714                        override_cred = prepare_creds(); 
     715                        if (!override_cred) 
     716                                goto out_dput_upper; 
     717 
     718                        /* CAP_SYS_ADMIN needed for getxattr */ 
     719                        cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     720                        old_cred = override_creds(override_cred); 
     721 
     722                        if (ovl_is_opaquedir(upperdentry)) { 
     723                                oe->opaque = true; 
     724                        } else if (ovl_is_whiteout(upperdentry)) { 
     725                                dput(upperdentry); 
     726                                upperdentry = NULL; 
     727                                oe->opaque = true; 
     728                        } 
     729                        revert_creds(old_cred); 
     730                        put_cred(override_cred); 
     731                } 
     732        } 
     733        if (lowerdir && !oe->opaque) { 
     734                lowerdentry = ovl_lookup_real(lowerdir, &dentry->d_name); 
     735                err = PTR_ERR(lowerdentry); 
     736                if (IS_ERR(lowerdentry)) 
     737                        goto out_dput_upper; 
     738        } 
     739 
     740        if (lowerdentry && upperdentry && 
     741            (!S_ISDIR(upperdentry->d_inode->i_mode) || 
     742             !S_ISDIR(lowerdentry->d_inode->i_mode))) { 
     743                dput(lowerdentry); 
     744                lowerdentry = NULL; 
     745                oe->opaque = true; 
     746        } 
     747 
     748        if (lowerdentry || upperdentry) { 
     749                struct dentry *realdentry; 
     750 
     751                realdentry = upperdentry ? upperdentry : lowerdentry; 
     752                err = -ENOMEM; 
     753                inode = ovl_new_inode(dir->i_sb, realdentry->d_inode->i_mode, oe); 
     754                if (!inode) 
     755                        goto out_dput; 
     756        } 
     757 
     758        if (upperdentry) 
     759                oe->__upperdentry = upperdentry; 
     760 
     761        if (lowerdentry) 
     762                oe->lowerdentry = lowerdentry; 
     763 
     764        dentry->d_fsdata = oe; 
     765        dentry->d_op = &ovl_dentry_operations; 
     766        d_add(dentry, inode); 
     767 
     768        return NULL; 
     769 
     770out_dput: 
     771        dput(lowerdentry); 
     772out_dput_upper: 
     773        dput(upperdentry); 
     774out_put_dir: 
     775        kfree(oe); 
     776out: 
     777        return ERR_PTR(err); 
     778} 
     779 
     780static int ovl_copy_up_xattr(struct dentry *old, struct dentry *new) 
     781{ 
     782        ssize_t list_size, size; 
     783        char *buf, *name, *value; 
     784        int error; 
     785 
     786        if (!old->d_inode->i_op->getxattr || 
     787            !new->d_inode->i_op->getxattr) 
     788                return 0; 
     789 
     790        list_size = vfs_listxattr(old, NULL, 0); 
     791        if (list_size <= 0) { 
     792                if (list_size == -EOPNOTSUPP) 
     793                        return 0; 
     794                return list_size; 
     795        } 
     796 
     797        buf = kzalloc(list_size, GFP_KERNEL); 
     798        if (!buf) 
     799                return -ENOMEM; 
     800 
     801        error = -ENOMEM; 
     802        value = kmalloc(XATTR_SIZE_MAX, GFP_KERNEL); 
     803        if (!value) 
     804                goto out; 
     805 
     806        list_size = vfs_listxattr(old, buf, list_size); 
     807        if (list_size <= 0) { 
     808                error = list_size; 
     809                goto out_free_value; 
     810        } 
     811 
     812        for (name = buf; name < (buf + list_size); name += strlen(name) + 1) { 
     813                size = vfs_getxattr(old, name, value, XATTR_SIZE_MAX); 
     814                if (size <= 0) { 
     815                        error = size; 
     816                        goto out_free_value; 
     817                } 
     818                error = vfs_setxattr(new, name, value, size, 0); 
     819                if (error) 
     820                        goto out_free_value; 
     821        } 
     822 
     823out_free_value: 
     824        kfree(value); 
     825out: 
     826        kfree(buf); 
     827        return error; 
     828} 
     829 
     830static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len) 
     831{ 
     832        struct file *old_file; 
     833        struct file *new_file; 
     834        int error = 0; 
     835 
     836        if (len == 0) 
     837                return 0; 
     838 
     839        old_file = vfs_open(old, O_RDONLY, current_cred()); 
     840        if (IS_ERR(old_file)) 
     841                return PTR_ERR(old_file); 
     842 
     843        new_file = vfs_open(new, O_WRONLY, current_cred()); 
     844        if (IS_ERR(new_file)) { 
     845                error = PTR_ERR(new_file); 
     846                goto out_fput; 
     847        } 
     848 
     849        /* FIXME: copy up sparse files efficiently */ 
     850        while (len) { 
     851                loff_t offset = new_file->f_pos; 
     852                size_t this_len = OVL_COPY_UP_CHUNK_SIZE; 
     853                long bytes; 
     854 
     855                if (len < this_len) 
     856                        this_len = len; 
     857 
     858                if (signal_pending_state(TASK_KILLABLE, current)) 
     859                        return -EINTR; 
     860 
     861                bytes = do_splice_direct(old_file, &offset, new_file, this_len, 
     862                                 SPLICE_F_MOVE); 
     863                if (bytes <= 0) { 
     864                        error = bytes; 
     865                        break; 
     866                } 
     867 
     868                len -= bytes; 
     869        } 
     870 
     871        fput(new_file); 
     872out_fput: 
     873        fput(old_file); 
     874        return error; 
     875} 
     876 
     877static struct dentry *ovl_lookup_create(struct dentry *upperdir, 
     878                                        struct dentry *template) 
     879{ 
     880        int err; 
     881        struct dentry *newdentry; 
     882        struct qstr *name = &template->d_name; 
     883 
     884        newdentry = lookup_one_len(name->name, upperdir, name->len); 
     885        if (IS_ERR(newdentry)) 
     886                return newdentry; 
     887 
     888        if (newdentry->d_inode) { 
     889                const struct cred *old_cred; 
     890                struct cred *override_cred; 
     891 
     892                /* No need to check whiteout if lower parent is non-existent */ 
     893                err = -EEXIST; 
     894                if (!ovl_dentry_lower(template->d_parent)) 
     895                        goto out_dput; 
     896 
     897                if (!S_ISLNK(newdentry->d_inode->i_mode)) 
     898                        goto out_dput; 
     899 
     900                err = -ENOMEM; 
     901                override_cred = prepare_creds(); 
     902                if (!override_cred) 
     903                        goto out_dput; 
     904 
     905                /* 
     906                 * CAP_SYS_ADMIN for getxattr 
     907                 * CAP_FOWNER for unlink in sticky directory 
     908                 */ 
     909                cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     910                cap_raise(override_cred->cap_effective, CAP_FOWNER); 
     911                old_cred = override_creds(override_cred); 
     912 
     913                err = -EEXIST; 
     914                if (ovl_is_whiteout(newdentry)) 
     915                        err = vfs_unlink(upperdir->d_inode, newdentry); 
     916 
     917                revert_creds(old_cred); 
     918                put_cred(override_cred); 
     919                if (err) 
     920                        goto out_dput; 
     921 
     922                dput(newdentry); 
     923                newdentry = lookup_one_len(name->name, upperdir, name->len); 
     924                if (IS_ERR(newdentry)) 
     925                        return newdentry; 
     926 
     927                /* 
     928                 * Whiteout just been successfully removed, parent 
     929                 * i_mutex is still held, there's no way the lookup 
     930                 * could return positive. 
     931                 */ 
     932                WARN_ON(newdentry->d_inode); 
     933        } 
     934 
     935        return newdentry; 
     936 
     937out_dput: 
     938        dput(newdentry); 
     939        return ERR_PTR(err); 
     940} 
     941 
     942static struct dentry *ovl_upper_create(struct dentry *upperdir, 
     943                                       struct dentry *dentry, 
     944                                       struct kstat *stat, const char *link) 
     945{ 
     946        int err; 
     947        struct dentry *newdentry; 
     948        struct inode *dir = upperdir->d_inode; 
     949 
     950        newdentry = ovl_lookup_create(upperdir, dentry); 
     951        if (IS_ERR(newdentry)) 
     952                goto out; 
     953 
     954        switch (stat->mode & S_IFMT) { 
     955        case S_IFREG: 
     956                err = vfs_create(dir, newdentry, stat->mode, NULL); 
     957                break; 
     958 
     959        case S_IFDIR: 
     960                err = vfs_mkdir(dir, newdentry, stat->mode); 
     961                break; 
     962 
     963        case S_IFCHR: 
     964        case S_IFBLK: 
     965        case S_IFIFO: 
     966        case S_IFSOCK: 
     967                err = vfs_mknod(dir, newdentry, stat->mode, stat->rdev); 
     968                break; 
     969 
     970        case S_IFLNK: 
     971                err = vfs_symlink(dir, newdentry, link); 
     972                break; 
     973 
     974        default: 
     975                err = -EPERM; 
     976        } 
     977        if (err) { 
     978                dput(newdentry); 
     979                newdentry = ERR_PTR(err); 
     980        } 
     981 
     982out: 
     983        return newdentry; 
     984 
     985} 
     986 
     987static char *ovl_read_symlink(struct dentry *realdentry) 
     988{ 
     989        int res; 
     990        char *buf; 
     991        struct inode *inode = realdentry->d_inode; 
     992        mm_segment_t old_fs; 
     993 
     994        res = -EINVAL; 
     995        if (!inode->i_op->readlink) 
     996                goto err; 
     997 
     998        res = -ENOMEM; 
     999        buf = (char *) __get_free_page(GFP_KERNEL); 
     1000        if (!buf) 
     1001                goto err; 
     1002 
     1003        old_fs = get_fs(); 
     1004        set_fs(get_ds()); 
     1005        /* The cast to a user pointer is valid due to the set_fs() */ 
     1006        res = inode->i_op->readlink(realdentry, 
     1007                                    (char __user *)buf, PAGE_SIZE - 1); 
     1008        set_fs(old_fs); 
     1009        if (res < 0) { 
     1010                free_page((unsigned long) buf); 
     1011                goto err; 
     1012        } 
     1013        buf[res] = '\0'; 
     1014 
     1015        return buf; 
     1016 
     1017err: 
     1018        return ERR_PTR(res); 
     1019} 
     1020 
     1021static int ovl_set_timestamps(struct dentry *upperdentry, struct kstat *stat) 
     1022{ 
     1023        struct iattr attr = { 
     1024                .ia_valid = ATTR_ATIME | ATTR_MTIME | ATTR_ATIME_SET | ATTR_MTIME_SET, 
     1025                .ia_atime = stat->atime, 
     1026                .ia_mtime = stat->mtime, 
     1027        }; 
     1028 
     1029        return notify_change(upperdentry, &attr); 
     1030} 
     1031 
     1032static int ovl_set_mode(struct dentry *upperdentry, umode_t mode) 
     1033{ 
     1034        struct iattr attr = { 
     1035                .ia_valid = ATTR_MODE, 
     1036                .ia_mode = mode, 
     1037        }; 
     1038 
     1039        return notify_change(upperdentry, &attr); 
     1040} 
     1041 
     1042static int ovl_set_opaque(struct dentry *upperdentry) 
     1043{ 
     1044        int err; 
     1045        const struct cred *old_cred; 
     1046        struct cred *override_cred; 
     1047 
     1048        override_cred = prepare_creds(); 
     1049        if (!override_cred) 
     1050                return -ENOMEM; 
     1051 
     1052        /* CAP_SYS_ADMIN for setxattr of "trusted" namespace */ 
     1053        cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     1054        old_cred = override_creds(override_cred); 
     1055        err = vfs_setxattr(upperdentry, ovl_opaque_xattr, "y", 1, 0); 
     1056        revert_creds(old_cred); 
     1057        put_cred(override_cred); 
     1058 
     1059        return err; 
     1060} 
     1061 
     1062static int ovl_remove_opaque(struct dentry *upperdentry) 
     1063{ 
     1064        int err; 
     1065        const struct cred *old_cred; 
     1066        struct cred *override_cred; 
     1067 
     1068        override_cred = prepare_creds(); 
     1069        if (!override_cred) 
     1070                return -ENOMEM; 
     1071 
     1072        /* CAP_SYS_ADMIN for removexattr of "trusted" namespace */ 
     1073        cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     1074        old_cred = override_creds(override_cred); 
     1075        err = vfs_removexattr(upperdentry, ovl_opaque_xattr); 
     1076        revert_creds(old_cred); 
     1077        put_cred(override_cred); 
     1078 
     1079        return err; 
     1080} 
     1081 
     1082static int ovl_copy_up_locked(struct dentry *upperdir, struct dentry *dentry, 
     1083                              struct path *lowerpath, struct kstat *stat, 
     1084                              const char *link) 
     1085{ 
     1086        int err; 
     1087        struct path newpath; 
     1088        umode_t mode = stat->mode; 
     1089        struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 
     1090 
     1091        /* Can't properly set mode on creation because of the umask */ 
     1092        stat->mode &= S_IFMT; 
     1093 
     1094        newpath.mnt = ofs->upper_mnt; 
     1095        newpath.dentry = ovl_upper_create(upperdir, dentry, stat, link); 
     1096        if (IS_ERR(newpath.dentry)) { 
     1097                err = PTR_ERR(newpath.dentry); 
     1098 
     1099                /* Already copied up? */ 
     1100                if (err == -EEXIST && ovl_path_type(dentry) != OVL_PATH_LOWER) 
     1101                        return 0; 
     1102 
     1103                return err; 
     1104        } 
     1105 
     1106        /* FIXME: recovery from failure to copy up */ 
     1107 
     1108        if (S_ISREG(stat->mode)) { 
     1109                err = ovl_copy_up_data(lowerpath, &newpath, stat->size); 
     1110                if (err) 
     1111                        return err; 
     1112        } 
     1113 
     1114        err = ovl_copy_up_xattr(lowerpath->dentry, newpath.dentry); 
     1115        if (err) 
     1116                return err; 
     1117 
     1118        mutex_lock(&newpath.dentry->d_inode->i_mutex); 
     1119        if (!S_ISLNK(stat->mode)) 
     1120                err = ovl_set_mode(newpath.dentry, mode); 
     1121        if (!err) 
     1122                err = ovl_set_timestamps(newpath.dentry, stat); 
     1123        mutex_unlock(&newpath.dentry->d_inode->i_mutex); 
     1124        if (err) 
     1125                return err; 
     1126 
     1127        ovl_dentry_update(dentry, newpath.dentry); 
     1128 
     1129        /* 
     1130         * Easiest way to get rid of the lower dentry reference is to 
     1131         * drop this dentry.  This is neither needed nor possible for 
     1132         * directories. 
     1133         */ 
     1134        if (!S_ISDIR(stat->mode)) 
     1135                d_drop(dentry); 
     1136 
     1137        return 0; 
     1138} 
     1139 
     1140static int ovl_copy_up_one(struct dentry *parent, struct dentry *dentry, 
     1141                           struct path *lowerpath, struct kstat *stat) 
     1142{ 
     1143        int err; 
     1144        struct kstat pstat; 
     1145        struct path parentpath; 
     1146        struct dentry *upperdir; 
     1147        const struct cred *old_cred; 
     1148        struct cred *override_cred; 
     1149        char *link = NULL; 
     1150 
     1151        ovl_path_upper(parent, &parentpath); 
     1152        upperdir = parentpath.dentry; 
     1153 
     1154        err = vfs_getattr(parentpath.mnt, parentpath.dentry, &pstat); 
     1155        if (err) 
     1156                return err; 
     1157 
     1158        if (S_ISLNK(stat->mode)) { 
     1159                link = ovl_read_symlink(lowerpath->dentry); 
     1160                if (IS_ERR(link)) 
     1161                        return PTR_ERR(link); 
     1162        } 
     1163 
     1164        err = -ENOMEM; 
     1165        override_cred = prepare_creds(); 
     1166        if (!override_cred) 
     1167                goto out_free_link; 
     1168 
     1169        override_cred->fsuid = stat->uid; 
     1170        override_cred->fsgid = stat->gid; 
     1171        /* 
     1172         * CAP_SYS_ADMIN for copying up extended attributes 
     1173         * CAP_DAC_OVERRIDE for create 
     1174         * CAP_FOWNER for chmod, timestamp update 
     1175         * CAP_FSETID for chmod 
     1176         * CAP_MKNOD for mknod 
     1177         */ 
     1178        cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     1179        cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 
     1180        cap_raise(override_cred->cap_effective, CAP_FOWNER); 
     1181        cap_raise(override_cred->cap_effective, CAP_FSETID); 
     1182        cap_raise(override_cred->cap_effective, CAP_MKNOD); 
     1183        old_cred = override_creds(override_cred); 
     1184 
     1185        mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
     1186        /* 
     1187         * Using upper filesystem locking to protect against copy up 
     1188         * racing with rename (rename means the copy up was already 
     1189         * successful). 
     1190         */ 
     1191        if (dentry->d_parent != parent) { 
     1192                WARN_ON((ovl_path_type(dentry) == OVL_PATH_LOWER)); 
     1193                err = 0; 
     1194        } else { 
     1195                err = ovl_copy_up_locked(upperdir, dentry, lowerpath, 
     1196                                         stat, link); 
     1197                if (!err) { 
     1198                        /* Restore timestamps on parent (best effort) */ 
     1199                        ovl_set_timestamps(upperdir, &pstat); 
     1200                } 
     1201        } 
     1202 
     1203        mutex_unlock(&upperdir->d_inode->i_mutex); 
     1204 
     1205        revert_creds(old_cred); 
     1206        put_cred(override_cred); 
     1207 
     1208out_free_link: 
     1209        if (link) 
     1210                free_page((unsigned long) link); 
     1211 
     1212        return err; 
     1213} 
     1214 
     1215static int ovl_copy_up(struct dentry *dentry) 
     1216{ 
     1217        int err; 
     1218 
     1219        err = 0; 
     1220        while (!err) { 
     1221                struct dentry *next; 
     1222                struct dentry *parent; 
     1223                struct path lowerpath; 
     1224                struct kstat stat; 
     1225                enum ovl_path_type type = ovl_path_type(dentry); 
     1226 
     1227                if (type != OVL_PATH_LOWER) 
     1228                        break; 
     1229 
     1230                next = dget(dentry); 
     1231                /* find the topmost dentry not yet copied up */ 
     1232                for (;;) { 
     1233                        parent = dget_parent(next); 
     1234 
     1235                        type = ovl_path_type(parent); 
     1236                        if (type != OVL_PATH_LOWER) 
     1237                                break; 
     1238 
     1239                        dput(next); 
     1240                        next = parent; 
     1241                } 
     1242 
     1243                ovl_path_lower(next, &lowerpath); 
     1244                err = vfs_getattr(lowerpath.mnt, lowerpath.dentry, &stat); 
     1245                if (!err) 
     1246                        err = ovl_copy_up_one(parent, next, &lowerpath, &stat); 
     1247 
     1248                dput(parent); 
     1249                dput(next); 
     1250        } 
     1251 
     1252        return err; 
     1253} 
     1254 
     1255/* Optimize by not copying up the file first and truncating later */ 
     1256static int ovl_copy_up_truncate(struct dentry *dentry, loff_t size) 
     1257{ 
     1258        int err; 
     1259        struct kstat stat; 
     1260        struct path lowerpath; 
     1261        struct dentry *parent = dget_parent(dentry); 
     1262 
     1263        err = ovl_copy_up(parent); 
     1264        if (err) 
     1265                goto out_dput_parent; 
     1266 
     1267        ovl_path_lower(dentry, &lowerpath); 
     1268        err = vfs_getattr(lowerpath.mnt, lowerpath.dentry, &stat); 
     1269        if (err) 
     1270                goto out_dput_parent; 
     1271 
     1272        if (size < stat.size) 
     1273                stat.size = size; 
     1274 
     1275        err = ovl_copy_up_one(parent, dentry, &lowerpath, &stat); 
     1276 
     1277out_dput_parent: 
     1278        dput(parent); 
     1279        return err; 
     1280} 
     1281 
     1282static int ovl_setattr(struct dentry *dentry, struct iattr *attr) 
     1283{ 
     1284        struct dentry *upperdentry; 
     1285        int err; 
     1286 
     1287        if ((attr->ia_valid & ATTR_SIZE) && !ovl_dentry_upper(dentry)) 
     1288                err = ovl_copy_up_truncate(dentry, attr->ia_size); 
     1289        else 
     1290                err = ovl_copy_up(dentry); 
     1291        if (err) 
     1292                return err; 
     1293 
     1294        upperdentry = ovl_dentry_upper(dentry); 
     1295 
     1296        if (attr->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID)) 
     1297                attr->ia_valid &= ~ATTR_MODE; 
     1298 
     1299        mutex_lock(&upperdentry->d_inode->i_mutex); 
     1300        err = notify_change(upperdentry, attr); 
     1301        mutex_unlock(&upperdentry->d_inode->i_mutex); 
     1302 
     1303        return err; 
     1304} 
     1305 
     1306static int ovl_getattr(struct vfsmount *mnt, struct dentry *dentry, 
     1307                         struct kstat *stat) 
     1308{ 
     1309        struct path realpath; 
     1310 
     1311        ovl_path_real(dentry, &realpath); 
     1312        return vfs_getattr(realpath.mnt, realpath.dentry, stat); 
     1313} 
     1314 
     1315static int ovl_dir_getattr(struct vfsmount *mnt, struct dentry *dentry, 
     1316                         struct kstat *stat) 
     1317{ 
     1318        int err; 
     1319        enum ovl_path_type type; 
     1320        struct path realpath; 
     1321 
     1322        type = ovl_path_real(dentry, &realpath); 
     1323        err = vfs_getattr(realpath.mnt, realpath.dentry, stat); 
     1324        if (err) 
     1325                return err; 
     1326 
     1327        stat->dev = dentry->d_sb->s_dev; 
     1328        stat->ino = dentry->d_inode->i_ino; 
     1329 
     1330        /* 
     1331         * It's probably not worth it to count subdirs to get the 
     1332         * correct link count.  nlink=1 seems to pacify 'find' and 
     1333         * other utilities. 
     1334         */ 
     1335        if (type == OVL_PATH_MERGE) 
     1336                stat->nlink = 1; 
     1337 
     1338        return 0; 
     1339} 
     1340 
     1341static int ovl_permission(struct inode *inode, int mask, unsigned int flags) 
     1342{ 
     1343        struct ovl_entry *oe; 
     1344        struct dentry *alias = NULL; 
     1345        struct inode *realinode; 
     1346        struct dentry *realdentry; 
     1347        bool is_upper; 
     1348        int err; 
     1349 
     1350        if (S_ISDIR(inode->i_mode)) { 
     1351                oe = inode->i_private; 
     1352        } else if (flags & IPERM_FLAG_RCU) { 
     1353                return -ECHILD; 
     1354        } else { 
     1355                /* 
     1356                 * For non-directories find an alias and get the info 
     1357                 * from there. 
     1358                 */ 
     1359                spin_lock(&inode->i_lock); 
     1360                if (WARN_ON(list_empty(&inode->i_dentry))) { 
     1361                        spin_unlock(&inode->i_lock); 
     1362                        return -ENOENT; 
     1363                } 
     1364                alias = list_entry(inode->i_dentry.next, struct dentry, d_alias); 
     1365                dget(alias); 
     1366                spin_unlock(&inode->i_lock); 
     1367                oe = alias->d_fsdata; 
     1368        } 
     1369 
     1370        realdentry = ovl_upperdentry_dereference(oe); 
     1371        is_upper = true; 
     1372        if (!realdentry) { 
     1373                realdentry = oe->lowerdentry; 
     1374                is_upper = false; 
     1375        } 
     1376 
     1377        /* Careful in RCU walk mode */ 
     1378        realinode = ACCESS_ONCE(realdentry->d_inode); 
     1379        if (!realinode) { 
     1380                WARN_ON(!(flags & IPERM_FLAG_RCU)); 
     1381                return -ENOENT; 
     1382        } 
     1383 
     1384        if (mask & MAY_WRITE) { 
     1385                umode_t mode = realinode->i_mode; 
     1386 
     1387                /* 
     1388                 * Writes will always be redirected to upper layer, so 
     1389                 * ignore lower layer being read-only. 
     1390                 */ 
     1391                err = -EROFS; 
     1392                if (is_upper && IS_RDONLY(realinode) && 
     1393                    (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))) 
     1394                        goto out_dput; 
     1395 
     1396                /* 
     1397                 * Nobody gets write access to an immutable file. 
     1398                 */ 
     1399                err = -EACCES; 
     1400                if (IS_IMMUTABLE(realinode)) 
     1401                        goto out_dput; 
     1402        } 
     1403 
     1404        if (realinode->i_op->permission) 
     1405                err = realinode->i_op->permission(realinode, mask, flags); 
     1406        else 
     1407                err = generic_permission(realinode, mask, flags, 
     1408                                         realinode->i_op->check_acl); 
     1409out_dput: 
     1410        dput(alias); 
     1411        return err; 
     1412} 
     1413 
     1414static int ovl_create_object(struct dentry *dentry, int mode, dev_t rdev, 
     1415                             const char *link) 
     1416{ 
     1417        int err; 
     1418        struct dentry *newdentry; 
     1419        struct dentry *upperdir; 
     1420        struct inode *inode; 
     1421        struct kstat stat = { 
     1422                .mode = mode, 
     1423                .rdev = rdev, 
     1424        }; 
     1425 
     1426        err = -ENOMEM; 
     1427        inode = ovl_new_inode(dentry->d_sb, mode, dentry->d_fsdata); 
     1428        if (!inode) 
     1429                goto out; 
     1430 
     1431        err = ovl_copy_up(dentry->d_parent); 
     1432        if (err) 
     1433                goto out_iput; 
     1434 
     1435        upperdir = ovl_dentry_upper(dentry->d_parent); 
     1436        mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
     1437 
     1438        newdentry = ovl_upper_create(upperdir, dentry, &stat, link); 
     1439        err = PTR_ERR(newdentry); 
     1440        if (IS_ERR(newdentry)) 
     1441                goto out_unlock; 
     1442 
     1443        ovl_dentry_version_inc(dentry->d_parent); 
     1444        if (ovl_dentry_is_opaque(dentry) && S_ISDIR(mode)) { 
     1445                err = ovl_set_opaque(newdentry); 
     1446                if (err) 
     1447                        goto out_dput; 
     1448        } 
     1449        ovl_dentry_update(dentry, newdentry); 
     1450        d_instantiate(dentry, inode); 
     1451        inode = NULL; 
     1452        newdentry = NULL; 
     1453        err = 0; 
     1454 
     1455out_dput: 
     1456        dput(newdentry); 
     1457out_unlock: 
     1458        mutex_unlock(&upperdir->d_inode->i_mutex); 
     1459out_iput: 
     1460        iput(inode); 
     1461out: 
     1462        return err; 
     1463} 
     1464 
     1465static int ovl_create(struct inode *dir, struct dentry *dentry, int mode, 
     1466                        struct nameidata *nd) 
     1467{ 
     1468        return ovl_create_object(dentry, (mode & 07777) | S_IFREG, 0, NULL); 
     1469} 
     1470 
     1471static int ovl_mkdir(struct inode *dir, struct dentry *dentry, int mode) 
     1472{ 
     1473        return ovl_create_object(dentry, (mode & 07777) | S_IFDIR, 0, NULL); 
     1474} 
     1475 
     1476static int ovl_mknod(struct inode *dir, struct dentry *dentry, int mode, 
     1477                       dev_t rdev) 
     1478{ 
     1479        return ovl_create_object(dentry, mode, rdev, NULL); 
     1480} 
     1481 
     1482static int ovl_symlink(struct inode *dir, struct dentry *dentry, 
     1483                         const char *link) 
     1484{ 
     1485        return ovl_create_object(dentry, S_IFLNK, 0, link); 
     1486} 
     1487 
     1488struct ovl_link_data { 
     1489        struct dentry *realdentry; 
     1490        void *cookie; 
     1491}; 
     1492 
     1493static void *ovl_follow_link(struct dentry *dentry, struct nameidata *nd) 
     1494{ 
     1495        void *ret; 
     1496        struct dentry *realdentry; 
     1497        struct inode *realinode; 
     1498 
     1499        realdentry = ovl_dentry_real(dentry); 
     1500        realinode = realdentry->d_inode; 
     1501 
     1502        if (WARN_ON(!realinode->i_op->follow_link)) 
     1503                return ERR_PTR(-EPERM); 
     1504 
     1505        ret = realinode->i_op->follow_link(realdentry, nd); 
     1506        if (IS_ERR(ret)) 
     1507                return ret; 
     1508 
     1509        if (realinode->i_op->put_link) { 
     1510                struct ovl_link_data *data; 
     1511 
     1512                data = kmalloc(sizeof(struct ovl_link_data), GFP_KERNEL); 
     1513                if (!data) { 
     1514                        realinode->i_op->put_link(realdentry, nd, ret); 
     1515                        return ERR_PTR(-ENOMEM); 
     1516                } 
     1517                data->realdentry = realdentry; 
     1518                data->cookie = ret; 
     1519 
     1520                return data; 
     1521        } else { 
     1522                return NULL; 
     1523        } 
     1524} 
     1525 
     1526static void ovl_put_link(struct dentry *dentry, struct nameidata *nd, void *c) 
     1527{ 
     1528        struct inode *realinode; 
     1529        struct ovl_link_data *data = c; 
     1530 
     1531        if (!data) 
     1532                return; 
     1533 
     1534        realinode = data->realdentry->d_inode; 
     1535        realinode->i_op->put_link(data->realdentry, nd, data->cookie); 
     1536        kfree(data); 
     1537} 
     1538 
     1539static int ovl_readlink(struct dentry *dentry, char __user *buf, int bufsiz) 
     1540{ 
     1541        struct path realpath; 
     1542        struct inode *realinode; 
     1543 
     1544        ovl_path_real(dentry, &realpath); 
     1545        realinode = realpath.dentry->d_inode; 
     1546 
     1547        if (!realinode->i_op->readlink) 
     1548                return -EINVAL; 
     1549 
     1550        touch_atime(realpath.mnt, realpath.dentry); 
     1551 
     1552        return realinode->i_op->readlink(realpath.dentry, buf, bufsiz); 
     1553} 
     1554 
     1555static int ovl_whiteout(struct dentry *upperdir, struct dentry *dentry) 
     1556{ 
     1557        int err; 
     1558        struct dentry *newdentry; 
     1559        const struct cred *old_cred; 
     1560        struct cred *override_cred; 
     1561 
     1562        /* FIXME: recheck lower dentry to see if whiteout is really needed */ 
     1563 
     1564        err = -ENOMEM; 
     1565        override_cred = prepare_creds(); 
     1566        if (!override_cred) 
     1567                goto out; 
     1568 
     1569        /* 
     1570         * CAP_SYS_ADMIN for setxattr 
     1571         * CAP_DAC_OVERRIDE for symlink creation 
     1572         */ 
     1573        cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     1574        cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 
     1575        override_cred->fsuid = 0; 
     1576        override_cred->fsgid = 0; 
     1577        old_cred = override_creds(override_cred); 
     1578 
     1579        newdentry = lookup_one_len(dentry->d_name.name, upperdir, 
     1580                                   dentry->d_name.len); 
     1581        err = PTR_ERR(newdentry); 
     1582        if (IS_ERR(newdentry)) 
     1583                goto out_put_cred; 
     1584 
     1585        /* Just been removed within the same locked region */ 
     1586        WARN_ON(newdentry->d_inode); 
     1587 
     1588        err = vfs_symlink(upperdir->d_inode, newdentry, ovl_whiteout_symlink); 
     1589        if (err) 
     1590                goto out_dput; 
     1591 
     1592        ovl_dentry_version_inc(dentry->d_parent); 
     1593 
     1594        err = vfs_setxattr(newdentry, ovl_whiteout_xattr, "y", 1, 0); 
     1595 
     1596out_dput: 
     1597        dput(newdentry); 
     1598out_put_cred: 
     1599        revert_creds(old_cred); 
     1600        put_cred(override_cred); 
     1601out: 
     1602        return err; 
     1603} 
     1604 
     1605static int ovl_do_remove(struct dentry *dentry, bool is_dir) 
     1606{ 
     1607        int err; 
     1608        enum ovl_path_type type; 
     1609        struct path realpath; 
     1610        struct dentry *upperdir; 
     1611 
     1612        err = ovl_copy_up(dentry->d_parent); 
     1613        if (err) 
     1614                return err; 
     1615 
     1616        upperdir = ovl_dentry_upper(dentry->d_parent); 
     1617        mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
     1618        type = ovl_path_real(dentry, &realpath); 
     1619        if (type != OVL_PATH_LOWER) { 
     1620                err = -ESTALE; 
     1621                if (realpath.dentry->d_parent != upperdir) 
     1622                        goto out_d_drop; 
     1623 
     1624                if (is_dir) 
     1625                        err = vfs_rmdir(upperdir->d_inode, realpath.dentry); 
     1626                else 
     1627                        err = vfs_unlink(upperdir->d_inode, realpath.dentry); 
     1628                if (err) 
     1629                        goto out_d_drop; 
     1630 
     1631                ovl_dentry_version_inc(dentry->d_parent); 
     1632        } 
     1633 
     1634        if (type != OVL_PATH_UPPER || ovl_dentry_is_opaque(dentry)) 
     1635                err = ovl_whiteout(upperdir, dentry); 
     1636 
     1637        /* 
     1638         * Keeping this dentry hashed would mean having to release 
     1639         * upperpath/lowerpath, which could only be done if we are the 
     1640         * sole user of this dentry.  Too tricky...  Just unhash for 
     1641         * now. 
     1642         */ 
     1643out_d_drop: 
     1644        d_drop(dentry); 
     1645        mutex_unlock(&upperdir->d_inode->i_mutex); 
     1646 
     1647        return err; 
     1648} 
     1649 
     1650static int ovl_unlink(struct inode *dir, struct dentry *dentry) 
     1651{ 
     1652        return ovl_do_remove(dentry, false); 
     1653} 
     1654 
     1655static int ovl_check_empty_dir(struct dentry *dentry) 
     1656{ 
     1657        int err; 
     1658        struct path lowerpath; 
     1659        struct path upperpath; 
     1660        struct ovl_cache_entry *p; 
     1661        LIST_HEAD(list); 
     1662        struct ovl_readdir_data rdd = { .list = &list }; 
     1663 
     1664        ovl_path_upper(dentry, &upperpath); 
     1665        ovl_path_lower(dentry, &lowerpath); 
     1666 
     1667        err = ovl_dir_read_merged(&upperpath, &lowerpath, &rdd); 
     1668        if (err) 
     1669                return err; 
     1670 
     1671        err = 0; 
     1672 
     1673        list_for_each_entry(p, &list, l_node) { 
     1674                if (p->is_whiteout) 
     1675                        continue; 
     1676 
     1677                if (p->name[0] == '.') { 
     1678                        if (p->len == 1) 
     1679                                continue; 
     1680                        if (p->len == 2 && p->name[1] == '.') 
     1681                                continue; 
     1682                } 
     1683                err = -ENOTEMPTY; 
     1684                break; 
     1685        } 
     1686 
     1687        ovl_cache_free(&list); 
     1688 
     1689        return err; 
     1690} 
     1691 
     1692static int ovl_unlink_whiteout(void *buf, const char *name, int namelen, 
     1693                                 loff_t offset, u64 ino, unsigned int d_type) 
     1694{ 
     1695        struct ovl_readdir_data *rdd = buf; 
     1696 
     1697        rdd->count++; 
     1698        /* check d_type to filter out "." and ".." */ 
     1699        if (d_type == DT_LNK) { 
     1700                struct dentry *dentry; 
     1701 
     1702                dentry = lookup_one_len(name, rdd->dir, namelen); 
     1703                if (IS_ERR(dentry)) { 
     1704                        rdd->err = PTR_ERR(dentry); 
     1705                } else { 
     1706                        rdd->err = vfs_unlink(rdd->dir->d_inode, dentry); 
     1707                        dput(dentry); 
     1708                } 
     1709        } 
     1710 
     1711        return rdd->err; 
     1712} 
     1713 
     1714static int ovl_remove_whiteouts(struct dentry *dentry) 
     1715{ 
     1716        struct path upperpath; 
     1717        struct ovl_readdir_data rdd = { .list = NULL }; 
     1718 
     1719        ovl_path_upper(dentry, &upperpath); 
     1720        rdd.dir = upperpath.dentry; 
     1721 
     1722        return ovl_dir_read(&upperpath, &rdd, ovl_unlink_whiteout); 
     1723} 
     1724 
     1725static int ovl_rmdir(struct inode *dir, struct dentry *dentry) 
     1726{ 
     1727        int err; 
     1728        enum ovl_path_type type; 
     1729 
     1730        type = ovl_path_type(dentry); 
     1731        if (type != OVL_PATH_UPPER) { 
     1732                err = ovl_check_empty_dir(dentry); 
     1733                if (err) 
     1734                        return err; 
     1735 
     1736                if (type == OVL_PATH_MERGE) { 
     1737                        err = ovl_remove_whiteouts(dentry); 
     1738                        if (err) 
     1739                                return err; 
     1740                } 
     1741        } 
     1742 
     1743        return ovl_do_remove(dentry, true); 
     1744} 
     1745 
     1746static int ovl_link(struct dentry *old, struct inode *newdir, 
     1747                    struct dentry *new) 
     1748{ 
     1749        int err; 
     1750        struct dentry *olddentry; 
     1751        struct dentry *newdentry; 
     1752        struct dentry *upperdir; 
     1753 
     1754        err = ovl_copy_up(old); 
     1755        if (err) 
     1756                goto out; 
     1757 
     1758        err = ovl_copy_up(new->d_parent); 
     1759        if (err) 
     1760                goto out; 
     1761 
     1762        upperdir = ovl_dentry_upper(new->d_parent); 
     1763        mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
     1764        newdentry = ovl_lookup_create(upperdir, new); 
     1765        err = PTR_ERR(newdentry); 
     1766        if (IS_ERR(newdentry)) 
     1767                goto out_unlock; 
     1768 
     1769        olddentry = ovl_dentry_upper(old); 
     1770        err = vfs_link(olddentry, upperdir->d_inode, newdentry); 
     1771        if (!err) { 
     1772                ovl_dentry_version_inc(new->d_parent); 
     1773                ovl_dentry_update(new, newdentry); 
     1774 
     1775                ihold(old->d_inode); 
     1776                d_instantiate(new, old->d_inode); 
     1777        } else { 
     1778                dput(newdentry); 
     1779        } 
     1780out_unlock: 
     1781        mutex_unlock(&upperdir->d_inode->i_mutex); 
     1782out: 
     1783        return err; 
     1784 
     1785} 
     1786 
     1787static int ovl_rename(struct inode *olddir, struct dentry *old, 
     1788                        struct inode *newdir, struct dentry *new) 
     1789{ 
     1790        int err; 
     1791        enum ovl_path_type old_type; 
     1792        struct dentry *old_upperdir; 
     1793        struct dentry *new_upperdir; 
     1794        struct dentry *olddentry; 
     1795        struct dentry *newdentry; 
     1796        struct dentry *trap; 
     1797        bool is_dir = S_ISDIR(old->d_inode->i_mode); 
     1798 
     1799        /* Don't copy up directory trees */ 
     1800        old_type = ovl_path_type(old); 
     1801        if (old_type != OVL_PATH_UPPER && is_dir) 
     1802                return -EXDEV; 
     1803 
     1804        if (new->d_inode) { 
     1805                enum ovl_path_type new_type; 
     1806 
     1807                new_type = ovl_path_type(new); 
     1808 
     1809                if (new_type == OVL_PATH_LOWER && old_type == OVL_PATH_LOWER) { 
     1810                        if (ovl_dentry_lower(old)->d_inode == 
     1811                            ovl_dentry_lower(new)->d_inode) 
     1812                                return 0; 
     1813                } 
     1814                if (new_type != OVL_PATH_LOWER && old_type != OVL_PATH_LOWER) { 
     1815                        if (ovl_dentry_upper(old)->d_inode == 
     1816                            ovl_dentry_upper(new)->d_inode) 
     1817                                return 0; 
     1818                } 
     1819 
     1820                if (new_type != OVL_PATH_UPPER && 
     1821                    S_ISDIR(new->d_inode->i_mode)) { 
     1822                        err = ovl_check_empty_dir(new); 
     1823                        if (err) 
     1824                                return err; 
     1825 
     1826                        if (new_type == OVL_PATH_MERGE) { 
     1827                                err = ovl_remove_whiteouts(new); 
     1828                                if (err) 
     1829                                        return err; 
     1830                        } 
     1831                } 
     1832        } 
     1833 
     1834        err = ovl_copy_up(old); 
     1835        if (err) 
     1836                return err; 
     1837 
     1838        err = ovl_copy_up(new->d_parent); 
     1839        if (err) 
     1840                return err; 
     1841 
     1842        old_upperdir = ovl_dentry_upper(old->d_parent); 
     1843        new_upperdir = ovl_dentry_upper(new->d_parent); 
     1844 
     1845        trap = lock_rename(new_upperdir, old_upperdir); 
     1846 
     1847        olddentry = ovl_dentry_upper(old); 
     1848        newdentry = ovl_dentry_upper(new); 
     1849        if (newdentry) { 
     1850                dget(newdentry); 
     1851        } else { 
     1852                newdentry = ovl_lookup_create(new_upperdir, new); 
     1853                err = PTR_ERR(newdentry); 
     1854                if (IS_ERR(newdentry)) 
     1855                        goto out_unlock; 
     1856        } 
     1857 
     1858        err = -ESTALE; 
     1859        if (olddentry->d_parent != old_upperdir) 
     1860                goto out_dput; 
     1861        if (newdentry->d_parent != new_upperdir) 
     1862                goto out_dput; 
     1863        if (olddentry == trap) 
     1864                goto out_dput; 
     1865        if (newdentry == trap) 
     1866                goto out_dput; 
     1867 
     1868        err = vfs_rename(old_upperdir->d_inode, olddentry, 
     1869                         new_upperdir->d_inode, newdentry); 
     1870 
     1871        if (!err) { 
     1872                bool old_opaque = ovl_dentry_is_opaque(old); 
     1873                bool new_opaque = ovl_dentry_is_opaque(new); 
     1874 
     1875                if (ovl_path_type(new) != OVL_PATH_UPPER) 
     1876                        new_opaque = true; 
     1877 
     1878                if (old_type != OVL_PATH_UPPER || old_opaque) 
     1879                        err = ovl_whiteout(old_upperdir, old); 
     1880                if (!err && is_dir) { 
     1881                        if (old_opaque && !new_opaque) { 
     1882                                ovl_remove_opaque(olddentry); 
     1883                                ovl_dentry_set_opaque(old, false); 
     1884                        } 
     1885                        if (!old_opaque && new_opaque) { 
     1886                                err = ovl_set_opaque(olddentry); 
     1887                                ovl_dentry_set_opaque(old, true); 
     1888                        } 
     1889                } 
     1890                ovl_dentry_version_inc(old->d_parent); 
     1891                ovl_dentry_version_inc(new->d_parent); 
     1892        } 
     1893 
     1894out_dput: 
     1895        dput(newdentry); 
     1896out_unlock: 
     1897        unlock_rename(new_upperdir, old_upperdir); 
     1898        return err; 
     1899} 
     1900 
     1901static bool ovl_is_private_xattr(const char *name) 
     1902{ 
     1903        return strncmp(name, "trusted.overlay.", 14) == 0; 
     1904} 
     1905 
     1906static int ovl_setxattr(struct dentry *dentry, const char *name, 
     1907                          const void *value, size_t size, int flags) 
     1908{ 
     1909        int err; 
     1910        struct dentry *upperdentry; 
     1911 
     1912        if (ovl_is_private_xattr(name)) 
     1913                return -EPERM; 
     1914 
     1915        err = ovl_copy_up(dentry); 
     1916        if (err) 
     1917                return err; 
     1918 
     1919        upperdentry = ovl_dentry_upper(dentry); 
     1920        return  vfs_setxattr(upperdentry, name, value, size, flags); 
     1921} 
     1922 
     1923static ssize_t ovl_getxattr(struct dentry *dentry, const char *name, 
     1924                              void *value, size_t size) 
     1925{ 
     1926        if (ovl_path_type(dentry->d_parent) == OVL_PATH_MERGE && 
     1927            ovl_is_private_xattr(name)) 
     1928                return -ENODATA; 
     1929 
     1930        return vfs_getxattr(ovl_dentry_real(dentry), name, value, size); 
     1931} 
     1932 
     1933static ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size) 
     1934{ 
     1935        ssize_t res; 
     1936        int off; 
     1937 
     1938        res = vfs_listxattr(ovl_dentry_real(dentry), list, size); 
     1939        if (res <= 0 || size == 0) 
     1940                return res; 
     1941 
     1942        if (ovl_path_type(dentry->d_parent) != OVL_PATH_MERGE) 
     1943                return res; 
     1944 
     1945        /* filter out private xattrs */ 
     1946        for (off = 0; off < res;) { 
     1947                char *s = list + off; 
     1948                size_t slen = strlen(s) + 1; 
     1949 
     1950                BUG_ON(off + slen > res); 
     1951 
     1952                if (ovl_is_private_xattr(s)) { 
     1953                        res -= slen; 
     1954                        memmove(s, s + slen, res - off); 
     1955                } else { 
     1956                        off += slen; 
     1957                } 
     1958        } 
     1959 
     1960        return res; 
     1961} 
     1962 
     1963static int ovl_removexattr(struct dentry *dentry, const char *name) 
     1964{ 
     1965        int err; 
     1966        struct path realpath; 
     1967        enum ovl_path_type type; 
     1968 
     1969        if (ovl_path_type(dentry->d_parent) == OVL_PATH_MERGE && 
     1970            ovl_is_private_xattr(name)) 
     1971                return -ENODATA; 
     1972 
     1973        type = ovl_path_real(dentry, &realpath); 
     1974        if (type == OVL_PATH_LOWER) { 
     1975                err = vfs_getxattr(realpath.dentry, name, NULL, 0); 
     1976                if (err < 0) 
     1977                        return err; 
     1978 
     1979                err = ovl_copy_up(dentry); 
     1980                if (err) 
     1981                        return err; 
     1982 
     1983                ovl_path_upper(dentry, &realpath); 
     1984        } 
     1985 
     1986        return vfs_removexattr(realpath.dentry, name); 
     1987} 
     1988 
     1989static bool ovl_open_need_copy_up(int flags, enum ovl_path_type type, 
     1990                                  struct dentry *realdentry) 
     1991{ 
     1992        if (type != OVL_PATH_LOWER) 
     1993                return false; 
     1994 
     1995        if (special_file(realdentry->d_inode->i_mode)) 
     1996                return false; 
     1997 
     1998        if (!(OPEN_FMODE(flags) & FMODE_WRITE) && !(flags & O_TRUNC)) 
     1999                return false; 
     2000 
     2001        return true; 
     2002} 
     2003 
     2004static struct file *ovl_open(struct dentry *dentry, int flags, 
     2005                             const struct cred *cred) 
     2006{ 
     2007        int err; 
     2008        struct path realpath; 
     2009        enum ovl_path_type type; 
     2010 
     2011        type = ovl_path_real(dentry, &realpath); 
     2012        if (ovl_open_need_copy_up(flags, type, realpath.dentry)) { 
     2013                if (flags & O_TRUNC) 
     2014                        err = ovl_copy_up_truncate(dentry, 0); 
     2015                else 
     2016                        err = ovl_copy_up(dentry); 
     2017                if (err) 
     2018                        return ERR_PTR(err); 
     2019 
     2020                ovl_path_upper(dentry, &realpath); 
     2021        } 
     2022 
     2023        return vfs_open(&realpath, flags, cred); 
     2024} 
     2025 
     2026static const struct inode_operations ovl_dir_inode_operations = { 
     2027        .lookup         = ovl_lookup, 
     2028        .mkdir          = ovl_mkdir, 
     2029        .symlink        = ovl_symlink, 
     2030        .unlink         = ovl_unlink, 
     2031        .rmdir          = ovl_rmdir, 
     2032        .rename         = ovl_rename, 
     2033        .link           = ovl_link, 
     2034        .setattr        = ovl_setattr, 
     2035        .create         = ovl_create, 
     2036        .mknod          = ovl_mknod, 
     2037        .permission     = ovl_permission, 
     2038        .getattr        = ovl_dir_getattr, 
     2039        .setxattr       = ovl_setxattr, 
     2040        .getxattr       = ovl_getxattr, 
     2041        .listxattr      = ovl_listxattr, 
     2042        .removexattr    = ovl_removexattr, 
     2043}; 
     2044 
     2045static const struct inode_operations ovl_file_inode_operations = { 
     2046        .setattr        = ovl_setattr, 
     2047        .permission     = ovl_permission, 
     2048        .getattr        = ovl_getattr, 
     2049        .setxattr       = ovl_setxattr, 
     2050        .getxattr       = ovl_getxattr, 
     2051        .listxattr      = ovl_listxattr, 
     2052        .removexattr    = ovl_removexattr, 
     2053        .open           = ovl_open, 
     2054}; 
     2055 
     2056static const struct inode_operations ovl_symlink_inode_operations = { 
     2057        .setattr        = ovl_setattr, 
     2058        .follow_link    = ovl_follow_link, 
     2059        .put_link       = ovl_put_link, 
     2060        .readlink       = ovl_readlink, 
     2061        .getattr        = ovl_getattr, 
     2062        .setxattr       = ovl_setxattr, 
     2063        .getxattr       = ovl_getxattr, 
     2064        .listxattr      = ovl_listxattr, 
     2065        .removexattr    = ovl_removexattr, 
     2066}; 
     2067 
     2068static struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, 
     2069                                   struct ovl_entry *oe) 
     2070{ 
     2071        struct inode *inode; 
     2072 
     2073        inode = new_inode(sb); 
     2074        if (!inode) 
     2075                return NULL; 
     2076 
     2077        mode &= S_IFMT; 
     2078 
     2079        inode->i_ino = get_next_ino(); 
     2080        inode->i_mode = mode; 
     2081        inode->i_flags |= S_NOATIME | S_NOCMTIME; 
     2082 
     2083        switch (mode) { 
     2084        case S_IFDIR: 
     2085                inode->i_private = oe; 
     2086                inode->i_op = &ovl_dir_inode_operations; 
     2087                inode->i_fop = &ovl_dir_operations; 
     2088                break; 
     2089 
     2090        case S_IFLNK: 
     2091                inode->i_op = &ovl_symlink_inode_operations; 
     2092                break; 
     2093 
     2094        case S_IFREG: 
     2095        case S_IFSOCK: 
     2096        case S_IFBLK: 
     2097        case S_IFCHR: 
     2098        case S_IFIFO: 
     2099                inode->i_op = &ovl_file_inode_operations; 
     2100                break; 
     2101 
     2102        default: 
     2103                WARN(1, "illegal file type: %i\n", mode); 
     2104                inode = NULL; 
     2105        } 
     2106 
     2107        return inode; 
     2108 
     2109} 
     2110 
     2111static void ovl_put_super(struct super_block *sb) 
     2112{ 
     2113        struct ovl_fs *ufs = sb->s_fs_info; 
     2114 
     2115        if (!(sb->s_flags & MS_RDONLY)) 
     2116                mnt_drop_write(ufs->upper_mnt); 
     2117 
     2118        mntput(ufs->upper_mnt); 
     2119        mntput(ufs->lower_mnt); 
     2120 
     2121        kfree(ufs); 
     2122} 
     2123 
     2124static int ovl_remount_fs(struct super_block *sb, int *flagsp, char *data) 
     2125{ 
     2126        int flags = *flagsp; 
     2127        struct ovl_fs *ufs = sb->s_fs_info; 
     2128 
     2129        /* When remounting rw or ro, we need to adjust the write access to the 
     2130         * upper fs. 
     2131         */ 
     2132        if (((flags ^ sb->s_flags) & MS_RDONLY) == 0) 
     2133                /* No change to readonly status */ 
     2134                return 0; 
     2135 
     2136        if (flags & MS_RDONLY) { 
     2137                mnt_drop_write(ufs->upper_mnt); 
     2138                return 0; 
     2139        } else 
     2140                return mnt_want_write(ufs->upper_mnt); 
     2141} 
     2142 
     2143/** 
     2144 * ovl_statfs 
     2145 * @sb: The overlayfs super block 
     2146 * @buf: The struct kstatfs to fill in with stats 
     2147 * 
     2148 * Get the filesystem statistics.  As writes always target the upper layer 
     2149 * filesystem pass the statfs to the same filesystem. 
     2150 */ 
     2151static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 
     2152{ 
     2153        struct dentry *root_dentry = dentry->d_sb->s_root; 
     2154        struct path path; 
     2155        ovl_path_upper(root_dentry, &path); 
     2156 
     2157        if (!path.dentry->d_sb->s_op->statfs) 
     2158                return -ENOSYS; 
     2159        return path.dentry->d_sb->s_op->statfs(path.dentry, buf); 
     2160} 
     2161 
     2162static const struct super_operations ovl_super_operations = { 
     2163        .put_super      = ovl_put_super, 
     2164        .remount_fs     = ovl_remount_fs, 
     2165        .statfs         = ovl_statfs, 
     2166}; 
     2167 
     2168struct ovl_config { 
     2169        char *lowerdir; 
     2170        char *upperdir; 
     2171}; 
     2172 
     2173enum { 
     2174        Opt_lowerdir, 
     2175        Opt_upperdir, 
     2176        Opt_err, 
     2177}; 
     2178 
     2179static const match_table_t ovl_tokens = { 
     2180        {Opt_lowerdir,                  "lowerdir=%s"}, 
     2181        {Opt_upperdir,                  "upperdir=%s"}, 
     2182        {Opt_err,                       NULL} 
     2183}; 
     2184 
     2185static int ovl_parse_opt(char *opt, struct ovl_config *config) 
     2186{ 
     2187        char *p; 
     2188 
     2189        config->upperdir = NULL; 
     2190        config->lowerdir = NULL; 
     2191 
     2192        while ((p = strsep(&opt, ",")) != NULL) { 
     2193                int token; 
     2194                substring_t args[MAX_OPT_ARGS]; 
     2195 
     2196                if (!*p) 
     2197                        continue; 
     2198 
     2199                token = match_token(p, ovl_tokens, args); 
     2200                switch (token) { 
     2201                case Opt_upperdir: 
     2202                        kfree(config->upperdir); 
     2203                        config->upperdir = match_strdup(&args[0]); 
     2204                        if (!config->upperdir) 
     2205                                return -ENOMEM; 
     2206                        break; 
     2207 
     2208                case Opt_lowerdir: 
     2209                        kfree(config->lowerdir); 
     2210                        config->lowerdir = match_strdup(&args[0]); 
     2211                        if (!config->lowerdir) 
     2212                                return -ENOMEM; 
     2213                        break; 
     2214 
     2215                default: 
     2216                        return -EINVAL; 
     2217                } 
     2218        } 
     2219        return 0; 
     2220} 
     2221 
     2222static int ovl_fill_super(struct super_block *sb, void *data, int silent) 
     2223{ 
     2224        struct path lowerpath; 
     2225        struct path upperpath; 
     2226        struct inode *root_inode; 
     2227        struct dentry *root_dentry; 
     2228        struct ovl_entry *oe; 
     2229        struct ovl_fs *ufs; 
     2230        struct ovl_config config; 
     2231        int err; 
     2232 
     2233        err = ovl_parse_opt((char *) data, &config); 
     2234        if (err) 
     2235                goto out; 
     2236 
     2237        err = -EINVAL; 
     2238        if (!config.upperdir || !config.lowerdir) { 
     2239                printk(KERN_ERR "overlayfs: missing upperdir or lowerdir\n"); 
     2240                goto out_free_config; 
     2241        } 
     2242 
     2243        err = -ENOMEM; 
     2244        ufs = kmalloc(sizeof(struct ovl_fs), GFP_KERNEL); 
     2245        if (!ufs) 
     2246                goto out_free_config; 
     2247 
     2248        oe = ovl_alloc_entry(); 
     2249        if (oe == NULL) 
     2250                goto out_free_ufs; 
     2251 
     2252        root_inode = ovl_new_inode(sb, S_IFDIR, oe); 
     2253        if (!root_inode) 
     2254                goto out_free_oe; 
     2255 
     2256        err = kern_path(config.upperdir, LOOKUP_FOLLOW, &upperpath); 
     2257        if (err) 
     2258                goto out_put_root; 
     2259 
     2260        err = kern_path(config.lowerdir, LOOKUP_FOLLOW, &lowerpath); 
     2261        if (err) 
     2262                goto out_put_upperpath; 
     2263 
     2264        err = -ENOTDIR; 
     2265        if (!S_ISDIR(upperpath.dentry->d_inode->i_mode) || 
     2266            !S_ISDIR(lowerpath.dentry->d_inode->i_mode)) 
     2267                goto out_put_lowerpath; 
     2268 
     2269        ufs->upper_mnt = clone_private_mount(&upperpath); 
     2270        err = PTR_ERR(ufs->upper_mnt); 
     2271        if (IS_ERR(ufs->upper_mnt)) { 
     2272                printk(KERN_ERR "overlayfs: failed to clone upperpath\n"); 
     2273                goto out_put_lowerpath; 
     2274        } 
     2275 
     2276        ufs->lower_mnt = clone_private_mount(&lowerpath); 
     2277        err = PTR_ERR(ufs->lower_mnt); 
     2278        if (IS_ERR(ufs->lower_mnt)) { 
     2279                printk(KERN_ERR "overlayfs: failed to clone lowerpath\n"); 
     2280                goto out_put_upper_mnt; 
     2281        } 
     2282 
     2283        if (!(sb->s_flags & MS_RDONLY)) { 
     2284                err = mnt_want_write(ufs->upper_mnt); 
     2285                if (err) 
     2286                        goto out_put_lower_mnt; 
     2287        } 
     2288 
     2289        err = -ENOMEM; 
     2290        root_dentry = d_alloc_root(root_inode); 
     2291        if (!root_dentry) 
     2292                goto out_drop_write; 
     2293 
     2294        mntput(upperpath.mnt); 
     2295        mntput(lowerpath.mnt); 
     2296 
     2297        oe->__upperdentry = upperpath.dentry; 
     2298        oe->lowerdentry = lowerpath.dentry; 
     2299 
     2300        root_dentry->d_fsdata = oe; 
     2301        root_dentry->d_op = &ovl_dentry_operations; 
     2302 
     2303        sb->s_op = &ovl_super_operations; 
     2304        sb->s_root = root_dentry; 
     2305        sb->s_fs_info = ufs; 
     2306 
     2307        return 0; 
     2308 
     2309out_drop_write: 
     2310        if (!(sb->s_flags & MS_RDONLY)) 
     2311                mnt_drop_write(ufs->upper_mnt); 
     2312out_put_lower_mnt: 
     2313        mntput(ufs->lower_mnt); 
     2314out_put_upper_mnt: 
     2315        mntput(ufs->upper_mnt); 
     2316out_put_lowerpath: 
     2317        path_put(&lowerpath); 
     2318out_put_upperpath: 
     2319        path_put(&upperpath); 
     2320out_put_root: 
     2321        iput(root_inode); 
     2322out_free_oe: 
     2323        kfree(oe); 
     2324out_free_ufs: 
     2325        kfree(ufs); 
     2326out_free_config: 
     2327        kfree(config.lowerdir); 
     2328        kfree(config.upperdir); 
     2329out: 
     2330        return err; 
     2331} 
     2332 
     2333static int ovl_get_sb(struct file_system_type *fs_type, 
     2334                        int flags, const char *dev_name, 
     2335                        void *raw_data, struct vfsmount *mnt) 
     2336{ 
     2337        return get_sb_nodev(fs_type, flags, raw_data, ovl_fill_super, mnt); 
     2338} 
     2339 
     2340static struct file_system_type ovl_fs_type = { 
     2341        .owner          = THIS_MODULE, 
     2342        .name           = "overlayfs", 
     2343        .get_sb         = ovl_get_sb, 
     2344        .kill_sb        = kill_anon_super, 
     2345}; 
     2346 
     2347static int __init ovl_init(void) 
     2348{ 
     2349        return register_filesystem(&ovl_fs_type); 
     2350} 
     2351 
     2352static void __exit ovl_exit(void) 
     2353{ 
     2354        unregister_filesystem(&ovl_fs_type); 
     2355} 
     2356 
     2357module_init(ovl_init); 
     2358module_exit(ovl_exit); 
  • fs/splice.c

    a b long do_splice_direct(struct file *in, l 
    12961296 
    12971297        return ret; 
    12981298} 
     1299EXPORT_SYMBOL(do_splice_direct); 
    12991300 
    13001301static int splice_pipe_to_pipe(struct pipe_inode_info *ipipe, 
    13011302                               struct pipe_inode_info *opipe, 
  • include/linux/fs.h

    a b struct inode_operations { 
    15871587        void (*truncate_range)(struct inode *, loff_t, loff_t); 
    15881588        int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start, 
    15891589                      u64 len); 
     1590        struct file *(*open)(struct dentry *, int flags, const struct cred *); 
    15901591} ____cacheline_aligned; 
    15911592 
    15921593struct seq_file; 
    extern int do_fallocate(struct file *fil 
    19901991extern long do_sys_open(int dfd, const char __user *filename, int flags, 
    19911992                        int mode); 
    19921993extern struct file *filp_open(const char *, int, int); 
     1994extern struct file *vfs_open(struct path *, int flags, const struct cred *); 
    19931995extern struct file * dentry_open(struct dentry *, struct vfsmount *, int, 
    19941996                                 const struct cred *); 
    19951997extern 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.