Changeset 29727


Ignore:
Timestamp:
2012-01-13T15:42:53+01:00 (6 years ago)
Author:
jogo
Message:

kernel: backport overlayfs v11 to 3.0 and 2.6.39

Should fix whiteout issues and missing files when using extroot.

Location:
trunk/target/linux/generic
Files:
2 moved

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/generic/patches-2.6.39/100-overlayfs_v11.patch

    r29726 r29727  
    1 --- a/include/linux/fs.h 
    2 +++ b/include/linux/fs.h 
    3 @@ -1594,6 +1594,7 @@ struct inode_operations { 
    4         void (*truncate_range)(struct inode *, loff_t, loff_t); 
    5         int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start, 
    6                       u64 len); 
    7 +       struct file *(*open)(struct dentry *, int flags, const struct cred *); 
    8  } ____cacheline_aligned; 
     1--- /dev/null 
     2+++ b/Documentation/filesystems/overlayfs.txt 
     3@@ -0,0 +1,199 @@ 
     4+Written by: Neil Brown <neilb@suse.de> 
     5+ 
     6+Overlay Filesystem 
     7+================== 
     8+ 
     9+This document describes a prototype for a new approach to providing 
     10+overlay-filesystem functionality in Linux (sometimes referred to as 
     11+union-filesystems).  An overlay-filesystem tries to present a 
     12+filesystem which is the result over overlaying one filesystem on top 
     13+of the other. 
     14+ 
     15+The result will inevitably fail to look exactly like a normal 
     16+filesystem for various technical reasons.  The expectation is that 
     17+many use cases will be able to ignore these differences. 
     18+ 
     19+This approach is 'hybrid' because the objects that appear in the 
     20+filesystem do not all appear to belong to that filesystem.  In many 
     21+cases an object accessed in the union will be indistinguishable 
     22+from accessing the corresponding object from the original filesystem. 
     23+This is most obvious from the 'st_dev' field returned by stat(2). 
     24+ 
     25+While directories will report an st_dev from the overlay-filesystem, 
     26+all non-directory objects will report an st_dev from the lower or 
     27+upper filesystem that is providing the object.  Similarly st_ino will 
     28+only be unique when combined with st_dev, and both of these can change 
     29+over the lifetime of a non-directory object.  Many applications and 
     30+tools ignore these values and will not be affected. 
     31+ 
     32+Upper and Lower 
     33+--------------- 
     34+ 
     35+An overlay filesystem combines two filesystems - an 'upper' filesystem 
     36+and a 'lower' filesystem.  When a name exists in both filesystems, the 
     37+object in the 'upper' filesystem is visible while the object in the 
     38+'lower' filesystem is either hidden or, in the case of directories, 
     39+merged with the 'upper' object. 
     40+ 
     41+It would be more correct to refer to an upper and lower 'directory 
     42+tree' rather than 'filesystem' as it is quite possible for both 
     43+directory trees to be in the same filesystem and there is no 
     44+requirement that the root of a filesystem be given for either upper or 
     45+lower. 
     46+ 
     47+The lower filesystem can be any filesystem supported by Linux and does 
     48+not need to be writable.  The lower filesystem can even be another 
     49+overlayfs.  The upper filesystem will normally be writable and if it 
     50+is it must support the creation of trusted.* extended attributes, and 
     51+must provide valid d_type in readdir responses, at least for symbolic 
     52+links - so NFS is not suitable. 
     53+ 
     54+A read-only overlay of two read-only filesystems may use any 
     55+filesystem type. 
     56+ 
     57+Directories 
     58+----------- 
     59+ 
     60+Overlaying mainly involved directories.  If a given name appears in both 
     61+upper and lower filesystems and refers to a non-directory in either, 
     62+then the lower object is hidden - the name refers only to the upper 
     63+object. 
     64+ 
     65+Where both upper and lower objects are directories, a merged directory 
     66+is formed. 
     67+ 
     68+At mount time, the two directories given as mount options are combined 
     69+into a merged directory: 
     70+ 
     71+  mount -t overlayfs overlayfs -olowerdir=/lower,upperdir=/upper /overlay 
     72+ 
     73+Then whenever a lookup is requested in such a merged directory, the 
     74+lookup is performed in each actual directory and the combined result 
     75+is cached in the dentry belonging to the overlay filesystem.  If both 
     76+actual lookups find directories, both are stored and a merged 
     77+directory is created, otherwise only one is stored: the upper if it 
     78+exists, else the lower. 
     79+ 
     80+Only the lists of names from directories are merged.  Other content 
     81+such as metadata and extended attributes are reported for the upper 
     82+directory only.  These attributes of the lower directory are hidden. 
     83+ 
     84+whiteouts and opaque directories 
     85+-------------------------------- 
     86+ 
     87+In order to support rm and rmdir without changing the lower 
     88+filesystem, an overlay filesystem needs to record in the upper filesystem 
     89+that files have been removed.  This is done using whiteouts and opaque 
     90+directories (non-directories are always opaque). 
     91+ 
     92+The overlay filesystem uses extended attributes with a 
     93+"trusted.overlay."  prefix to record these details. 
     94+ 
     95+A whiteout is created as a symbolic link with target 
     96+"(overlay-whiteout)" and with xattr "trusted.overlay.whiteout" set to "y". 
     97+When a whiteout is found in the upper level of a merged directory, any 
     98+matching name in the lower level is ignored, and the whiteout itself 
     99+is also hidden. 
     100+ 
     101+A directory is made opaque by setting the xattr "trusted.overlay.opaque" 
     102+to "y".  Where the upper filesystem contains an opaque directory, any 
     103+directory in the lower filesystem with the same name is ignored. 
     104+ 
     105+readdir 
     106+------- 
     107+ 
     108+When a 'readdir' request is made on a merged directory, the upper and 
     109+lower directories are each read and the name lists merged in the 
     110+obvious way (upper is read first, then lower - entries that already 
     111+exist are not re-added).  This merged name list is cached in the 
     112+'struct file' and so remains as long as the file is kept open.  If the 
     113+directory is opened and read by two processes at the same time, they 
     114+will each have separate caches.  A seekdir to the start of the 
     115+directory (offset 0) followed by a readdir will cause the cache to be 
     116+discarded and rebuilt. 
     117+ 
     118+This means that changes to the merged directory do not appear while a 
     119+directory is being read.  This is unlikely to be noticed by many 
     120+programs. 
     121+ 
     122+seek offsets are assigned sequentially when the directories are read. 
     123+Thus if 
     124+  - read part of a directory 
     125+  - remember an offset, and close the directory 
     126+  - re-open the directory some time later 
     127+  - seek to the remembered offset 
     128+ 
     129+there may be little correlation between the old and new locations in 
     130+the list of filenames, particularly if anything has changed in the 
     131+directory. 
     132+ 
     133+Readdir on directories that are not merged is simply handled by the 
     134+underlying directory (upper or lower). 
     135+ 
     136+ 
     137+Non-directories 
     138+--------------- 
     139+ 
     140+Objects that are not directories (files, symlinks, device-special 
     141+files etc.) are presented either from the upper or lower filesystem as 
     142+appropriate.  When a file in the lower filesystem is accessed in a way 
     143+the requires write-access, such as opening for write access, changing 
     144+some metadata etc., the file is first copied from the lower filesystem 
     145+to the upper filesystem (copy_up).  Note that creating a hard-link 
     146+also requires copy_up, though of course creation of a symlink does 
     147+not. 
     148+ 
     149+The copy_up may turn out to be unnecessary, for example if the file is 
     150+opened for read-write but the data is not modified. 
     151+ 
     152+The copy_up process first makes sure that the containing directory 
     153+exists in the upper filesystem - creating it and any parents as 
     154+necessary.  It then creates the object with the same metadata (owner, 
     155+mode, mtime, symlink-target etc.) and then if the object is a file, the 
     156+data is copied from the lower to the upper filesystem.  Finally any 
     157+extended attributes are copied up. 
     158+ 
     159+Once the copy_up is complete, the overlay filesystem simply 
     160+provides direct access to the newly created file in the upper 
     161+filesystem - future operations on the file are barely noticed by the 
     162+overlay filesystem (though an operation on the name of the file such as 
     163+rename or unlink will of course be noticed and handled). 
     164+ 
     165+ 
     166+Non-standard behavior 
     167+--------------------- 
     168+ 
     169+The copy_up operation essentially creates a new, identical file and 
     170+moves it over to the old name.  The new file may be on a different 
     171+filesystem, so both st_dev and st_ino of the file may change. 
     172+ 
     173+Any open files referring to this inode will access the old data and 
     174+metadata.  Similarly any file locks obtained before copy_up will not 
     175+apply to the copied up file. 
     176+ 
     177+On a file is opened with O_RDONLY fchmod(2), fchown(2), futimesat(2) 
     178+and fsetxattr(2) will fail with EROFS. 
     179+ 
     180+If a file with multiple hard links is copied up, then this will 
     181+"break" the link.  Changes will not be propagated to other names 
     182+referring to the same inode. 
     183+ 
     184+Symlinks in /proc/PID/ and /proc/PID/fd which point to a non-directory 
     185+object in overlayfs will not contain vaid absolute paths, only 
     186+relative paths leading up to the filesystem's root.  This will be 
     187+fixed in the future. 
     188+ 
     189+Some operations are not atomic, for example a crash during copy_up or 
     190+rename will leave the filesystem in an inconsitent state.  This will 
     191+be addressed in the future. 
     192+ 
     193+Changes to underlying filesystems 
     194+--------------------------------- 
     195+ 
     196+Offline changes, when the overlay is not mounted, are allowed to either 
     197+the upper or the lower trees. 
     198+ 
     199+Changes to the underlying filesystems while part of a mounted overlay 
     200+filesystem are not allowed.  If the underlying filesystem is changed, 
     201+the behavior of the overlay is undefined, though it will not result in 
     202+a crash or deadlock. 
     203--- a/MAINTAINERS 
     204+++ b/MAINTAINERS 
     205@@ -4689,6 +4689,13 @@ F:       drivers/scsi/osd/ 
     206 F:     include/scsi/osd_* 
     207 F:     fs/exofs/ 
    9208  
    10  struct seq_file; 
    11 @@ -1988,6 +1989,7 @@ extern long do_sys_open(int dfd, const c 
    12  extern struct file *filp_open(const char *, int, int); 
    13  extern struct file *file_open_root(struct dentry *, struct vfsmount *, 
    14                                    const char *, int); 
    15 +extern struct file *vfs_open(struct path *, int flags, const struct cred *); 
    16  extern struct file * dentry_open(struct dentry *, struct vfsmount *, int, 
    17                                  const struct cred *); 
    18  extern int filp_close(struct file *, fl_owner_t id); 
     209+OVERLAYFS FILESYSTEM 
     210+M:     Miklos Szeredi <miklos@szeredi.hu> 
     211+L:     linux-fsdevel@vger.kernel.org 
     212+S:     Supported 
     213+F:     fs/overlayfs/* 
     214+F:     Documentation/filesystems/overlayfs.txt 
     215+ 
     216 P54 WIRELESS DRIVER 
     217 M:     Christian Lamparter <chunkeey@googlemail.com> 
     218 L:     linux-wireless@vger.kernel.org 
     219--- a/fs/Kconfig 
     220+++ b/fs/Kconfig 
     221@@ -63,6 +63,7 @@ source "fs/quota/Kconfig" 
     222  
     223 source "fs/autofs4/Kconfig" 
     224 source "fs/fuse/Kconfig" 
     225+source "fs/overlayfs/Kconfig" 
     226  
     227 config CUSE 
     228        tristate "Character device in Userspace support" 
     229--- a/fs/Makefile 
     230+++ b/fs/Makefile 
     231@@ -105,6 +105,7 @@ obj-$(CONFIG_QNX4FS_FS)             += qnx4/ 
     232 obj-$(CONFIG_AUTOFS4_FS)       += autofs4/ 
     233 obj-$(CONFIG_ADFS_FS)          += adfs/ 
     234 obj-$(CONFIG_FUSE_FS)          += fuse/ 
     235+obj-$(CONFIG_OVERLAYFS_FS)     += overlayfs/ 
     236 obj-$(CONFIG_UDF_FS)           += udf/ 
     237 obj-$(CONFIG_SUN_OPENPROMFS)   += openpromfs/ 
     238 obj-$(CONFIG_OMFS_FS)          += omfs/ 
     239--- a/fs/ecryptfs/main.c 
     240+++ b/fs/ecryptfs/main.c 
     241@@ -594,6 +594,13 @@ static struct dentry *ecryptfs_mount(str 
     242        s->s_maxbytes = path.dentry->d_sb->s_maxbytes; 
     243        s->s_blocksize = path.dentry->d_sb->s_blocksize; 
     244        s->s_magic = ECRYPTFS_SUPER_MAGIC; 
     245+       s->s_stack_depth = path.dentry->d_sb->s_stack_depth + 1; 
     246+ 
     247+       rc = -EINVAL; 
     248+       if (s->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 
     249+               printk(KERN_ERR "eCryptfs: maximum fs stacking depth exceeded\n"); 
     250+               goto out_free; 
     251+       } 
     252  
     253        inode = ecryptfs_get_inode(path.dentry->d_inode, s); 
     254        rc = PTR_ERR(inode); 
     255--- a/fs/namespace.c 
     256+++ b/fs/namespace.c 
     257@@ -1494,6 +1494,23 @@ void drop_collected_mounts(struct vfsmou 
     258        release_mounts(&umount_list); 
     259 } 
     260  
     261+struct vfsmount *clone_private_mount(struct path *path) 
     262+{ 
     263+       struct vfsmount *mnt; 
     264+ 
     265+       if (IS_MNT_UNBINDABLE(path->mnt)) 
     266+               return ERR_PTR(-EINVAL); 
     267+ 
     268+       down_read(&namespace_sem); 
     269+       mnt = clone_mnt(path->mnt, path->dentry, CL_PRIVATE); 
     270+       up_read(&namespace_sem); 
     271+       if (!mnt) 
     272+               return ERR_PTR(-ENOMEM); 
     273+ 
     274+       return mnt; 
     275+} 
     276+EXPORT_SYMBOL_GPL(clone_private_mount); 
     277+ 
     278 int iterate_mounts(int (*f)(struct vfsmount *, void *), void *arg, 
     279                   struct vfsmount *root) 
     280 { 
    19281--- a/fs/open.c 
    20282+++ b/fs/open.c 
     
    173435 static void __put_unused_fd(struct files_struct *files, unsigned int fd) 
    174436 { 
    175 --- a/fs/splice.c 
    176 +++ b/fs/splice.c 
    177 @@ -1296,6 +1296,7 @@ long do_splice_direct(struct file *in, l 
    178   
    179         return ret; 
    180  } 
    181 +EXPORT_SYMBOL(do_splice_direct); 
    182   
    183  static int splice_pipe_to_pipe(struct pipe_inode_info *ipipe, 
    184                                struct pipe_inode_info *opipe, 
    185 --- a/fs/namespace.c 
    186 +++ b/fs/namespace.c 
    187 @@ -1494,6 +1494,23 @@ void drop_collected_mounts(struct vfsmou 
    188         release_mounts(&umount_list); 
    189  } 
    190   
    191 +struct vfsmount *clone_private_mount(struct path *path) 
    192 +{ 
    193 +       struct vfsmount *mnt; 
    194 + 
    195 +       if (IS_MNT_UNBINDABLE(path->mnt)) 
    196 +               return ERR_PTR(-EINVAL); 
    197 + 
    198 +       down_read(&namespace_sem); 
    199 +       mnt = clone_mnt(path->mnt, path->dentry, CL_PRIVATE); 
    200 +       up_read(&namespace_sem); 
    201 +       if (!mnt) 
    202 +               return ERR_PTR(-ENOMEM); 
    203 + 
    204 +       return mnt; 
    205 +} 
    206 +EXPORT_SYMBOL_GPL(clone_private_mount); 
    207 + 
    208  int iterate_mounts(int (*f)(struct vfsmount *, void *), void *arg, 
    209                    struct vfsmount *root) 
    210  { 
    211 --- a/include/linux/mount.h 
    212 +++ b/include/linux/mount.h 
    213 @@ -100,6 +100,9 @@ extern void mnt_pin(struct vfsmount *mnt 
    214  extern void mnt_unpin(struct vfsmount *mnt); 
    215  extern int __mnt_is_readonly(struct vfsmount *mnt); 
    216   
    217 +struct path; 
    218 +extern struct vfsmount *clone_private_mount(struct path *path); 
    219 + 
    220  extern struct vfsmount *do_kern_mount(const char *fstype, int flags, 
    221                                       const char *name, void *data); 
    222   
    223437--- /dev/null 
    224 +++ b/fs/overlayfs/overlayfs.c 
    225 @@ -0,0 +1,2414 @@ 
     438+++ b/fs/overlayfs/Kconfig 
     439@@ -0,0 +1,4 @@ 
     440+config OVERLAYFS_FS 
     441+       tristate "Overlay filesystem support" 
     442+       help 
     443+         Add support for overlay filesystem. 
     444--- /dev/null 
     445+++ b/fs/overlayfs/Makefile 
     446@@ -0,0 +1,7 @@ 
     447+# 
     448+# Makefile for the overlay filesystem. 
     449+# 
     450+ 
     451+obj-$(CONFIG_OVERLAYFS_FS) += overlayfs.o 
     452+ 
     453+overlayfs-objs := super.o inode.o dir.o readdir.o copy_up.o 
     454--- /dev/null 
     455+++ b/fs/overlayfs/copy_up.c 
     456@@ -0,0 +1,383 @@ 
     457+/* 
     458+ * 
     459+ * Copyright (C) 2011 Novell Inc. 
     460+ * 
     461+ * This program is free software; you can redistribute it and/or modify it 
     462+ * under the terms of the GNU General Public License version 2 as published by 
     463+ * the Free Software Foundation. 
     464+ */ 
     465+ 
    226466+#include <linux/fs.h> 
    227 +#include <linux/namei.h> 
    228 +#include <linux/sched.h> 
    229 +#include <linux/fs_struct.h> 
     467+#include <linux/slab.h> 
    230468+#include <linux/file.h> 
     469+#include <linux/splice.h> 
    231470+#include <linux/xattr.h> 
    232471+#include <linux/security.h> 
    233 +#include <linux/device_cgroup.h> 
    234 +#include <linux/mount.h> 
    235 +#include <linux/splice.h> 
    236 +#include <linux/slab.h> 
    237 +#include <linux/parser.h> 
    238 +#include <linux/module.h> 
    239472+#include <linux/uaccess.h> 
    240 +#include <linux/rbtree.h> 
    241 + 
    242 +MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 
    243 +MODULE_DESCRIPTION("Overlay filesystem"); 
    244 +MODULE_LICENSE("GPL"); 
     473+#include "overlayfs.h" 
    245474+ 
    246475+#define OVL_COPY_UP_CHUNK_SIZE (1 << 20) 
    247 + 
    248 +struct ovl_fs { 
    249 +       struct vfsmount *upper_mnt; 
    250 +       struct vfsmount *lower_mnt; 
    251 +}; 
    252 + 
    253 +struct ovl_entry { 
    254 +       struct dentry *__upperdentry; 
    255 +       struct dentry *lowerdentry; 
    256 +       union { 
    257 +               struct { 
    258 +                       u64 version; 
    259 +                       bool opaque; 
    260 +               }; 
    261 +               struct rcu_head rcu; 
    262 +       }; 
    263 +}; 
    264 + 
    265 +static const char *ovl_whiteout_xattr = "trusted.overlay.whiteout"; 
    266 +static const char *ovl_opaque_xattr = "trusted.overlay.opaque"; 
    267 +static const char *ovl_whiteout_symlink = "(overlay-whiteout)"; 
    268 + 
    269 +enum ovl_path_type { 
    270 +       OVL_PATH_UPPER, 
    271 +       OVL_PATH_MERGE, 
    272 +       OVL_PATH_LOWER, 
    273 +}; 
    274 + 
    275 +static enum ovl_path_type ovl_path_type(struct dentry *dentry) 
    276 +{ 
    277 +       struct ovl_entry *oe = dentry->d_fsdata; 
    278 + 
    279 +       if (oe->__upperdentry) { 
    280 +               if (oe->lowerdentry && S_ISDIR(dentry->d_inode->i_mode)) 
    281 +                       return OVL_PATH_MERGE; 
    282 +               else 
    283 +                       return OVL_PATH_UPPER; 
    284 +       } else { 
    285 +               return OVL_PATH_LOWER; 
    286 +       } 
    287 +} 
    288 + 
    289 +static struct dentry *ovl_upperdentry_dereference(struct ovl_entry *oe) 
    290 +{ 
    291 +       struct dentry *upperdentry = ACCESS_ONCE(oe->__upperdentry); 
    292 +       smp_read_barrier_depends(); 
    293 +       return upperdentry; 
    294 +} 
    295 + 
    296 +static void ovl_path_upper(struct dentry *dentry, struct path *path) 
    297 +{ 
    298 +       struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 
    299 +       struct ovl_entry *oe = dentry->d_fsdata; 
    300 + 
    301 +       path->mnt = ofs->upper_mnt; 
    302 +       path->dentry = ovl_upperdentry_dereference(oe); 
    303 +} 
    304 + 
    305 +static void ovl_path_lower(struct dentry *dentry, struct path *path) 
    306 +{ 
    307 +       struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 
    308 +       struct ovl_entry *oe = dentry->d_fsdata; 
    309 + 
    310 +       path->mnt = ofs->lower_mnt; 
    311 +       path->dentry = oe->lowerdentry; 
    312 +} 
    313 + 
    314 +static enum ovl_path_type ovl_path_real(struct dentry *dentry, 
    315 +                                       struct path *path) 
    316 +{ 
    317 + 
    318 +       enum ovl_path_type type = ovl_path_type(dentry); 
    319 + 
    320 +       if (type == OVL_PATH_LOWER) 
    321 +               ovl_path_lower(dentry, path); 
    322 +       else 
    323 +               ovl_path_upper(dentry, path); 
    324 + 
    325 +       return type; 
    326 +} 
    327 + 
    328 +static struct dentry *ovl_dentry_upper(struct dentry *dentry) 
    329 +{ 
    330 +       struct ovl_entry *oe = dentry->d_fsdata; 
    331 + 
    332 +       return ovl_upperdentry_dereference(oe); 
    333 +} 
    334 + 
    335 +static struct dentry *ovl_dentry_lower(struct dentry *dentry) 
    336 +{ 
    337 +       struct ovl_entry *oe = dentry->d_fsdata; 
    338 + 
    339 +       return oe->lowerdentry; 
    340 +} 
    341 + 
    342 +static struct dentry *ovl_dentry_real(struct dentry *dentry) 
    343 +{ 
    344 +       struct ovl_entry *oe = dentry->d_fsdata; 
    345 +       struct dentry *realdentry; 
    346 + 
    347 +       realdentry = ovl_upperdentry_dereference(oe); 
    348 +       if (!realdentry) 
    349 +               realdentry = oe->lowerdentry; 
    350 + 
    351 +       return realdentry; 
    352 +} 
    353 + 
    354 +static bool ovl_dentry_is_opaque(struct dentry *dentry) 
    355 +{ 
    356 +       struct ovl_entry *oe = dentry->d_fsdata; 
    357 +       return oe->opaque; 
    358 +} 
    359 + 
    360 +static void ovl_dentry_set_opaque(struct dentry *dentry, bool opaque) 
    361 +{ 
    362 +       struct ovl_entry *oe = dentry->d_fsdata; 
    363 +       oe->opaque = opaque; 
    364 +} 
    365 + 
    366 +static void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry) 
    367 +{ 
    368 +       struct ovl_entry *oe = dentry->d_fsdata; 
    369 + 
    370 +       WARN_ON(!mutex_is_locked(&upperdentry->d_parent->d_inode->i_mutex)); 
    371 +       WARN_ON(oe->__upperdentry); 
    372 +       smp_wmb(); 
    373 +       oe->__upperdentry = upperdentry; 
    374 +} 
    375 + 
    376 +static void ovl_dentry_version_inc(struct dentry *dentry) 
    377 +{ 
    378 +       struct ovl_entry *oe = dentry->d_fsdata; 
    379 + 
    380 +       WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex)); 
    381 +       oe->version++; 
    382 +} 
    383 + 
    384 +static u64 ovl_dentry_version_get(struct dentry *dentry) 
    385 +{ 
    386 +       struct ovl_entry *oe = dentry->d_fsdata; 
    387 + 
    388 +       WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex)); 
    389 +       return oe->version; 
    390 +} 
    391 + 
    392 +static bool ovl_is_whiteout(struct dentry *dentry) 
    393 +{ 
    394 +       int res; 
    395 +       char val; 
    396 + 
    397 +       if (!dentry) 
    398 +               return false; 
    399 +       if (!dentry->d_inode) 
    400 +               return false; 
    401 +       if (!S_ISLNK(dentry->d_inode->i_mode)) 
    402 +               return false; 
    403 + 
    404 +       res = vfs_getxattr(dentry, ovl_whiteout_xattr, &val, 1); 
    405 +       if (res == 1 && val == 'y') 
    406 +               return true; 
    407 + 
    408 +       return false; 
    409 +} 
    410 + 
    411 +static bool ovl_is_opaquedir(struct dentry *dentry) 
    412 +{ 
    413 +       int res; 
    414 +       char val; 
    415 + 
    416 +       if (!S_ISDIR(dentry->d_inode->i_mode)) 
    417 +               return false; 
    418 + 
    419 +       res = vfs_getxattr(dentry, ovl_opaque_xattr, &val, 1); 
    420 +       if (res == 1 && val == 'y') 
    421 +               return true; 
    422 + 
    423 +       return false; 
    424 +} 
    425 + 
    426 +struct ovl_cache_entry { 
    427 +       const char *name; 
    428 +       unsigned int len; 
    429 +       unsigned int type; 
    430 +       u64 ino; 
    431 +       bool is_whiteout; 
    432 +       struct list_head l_node; 
    433 +       struct rb_node node; 
    434 +}; 
    435 + 
    436 +struct ovl_readdir_data { 
    437 +       struct rb_root *root; 
    438 +       struct list_head *list; 
    439 +       struct list_head *middle; 
    440 +       struct dentry *dir; 
    441 +       int count; 
    442 +       int err; 
    443 +}; 
    444 + 
    445 +struct ovl_dir_file { 
    446 +       bool is_real; 
    447 +       bool is_cached; 
    448 +       struct list_head cursor; 
    449 +       u64 cache_version; 
    450 +       struct list_head cache; 
    451 +       struct file *realfile; 
    452 +}; 
    453 + 
    454 +static struct ovl_cache_entry *ovl_cache_entry_from_node(struct rb_node *n) 
    455 +{ 
    456 +       return container_of(n, struct ovl_cache_entry, node); 
    457 +} 
    458 + 
    459 +static struct ovl_cache_entry *ovl_cache_entry_find(struct rb_root *root, 
    460 +                                                   const char *name, int len) 
    461 +{ 
    462 +       struct rb_node *node = root->rb_node; 
    463 +       int cmp; 
    464 + 
    465 +       while (node) { 
    466 +               struct ovl_cache_entry *p = ovl_cache_entry_from_node(node); 
    467 + 
    468 +               cmp = strncmp(name, p->name, len); 
    469 +               if (cmp > 0) 
    470 +                       node = p->node.rb_right; 
    471 +               else if (cmp < 0 || len < p->len) 
    472 +                       node = p->node.rb_left; 
    473 +               else 
    474 +                       return p; 
    475 +       } 
    476 + 
    477 +       return NULL; 
    478 +} 
    479 + 
    480 +static struct ovl_cache_entry *ovl_cache_entry_new(const char *name, int len, 
    481 +                                                  u64 ino, unsigned int d_type) 
    482 +{ 
    483 +       struct ovl_cache_entry *p; 
    484 + 
    485 +       p = kmalloc(sizeof(*p) + len + 1, GFP_KERNEL); 
    486 +       if (p) { 
    487 +               char *name_copy = (char *) (p + 1); 
    488 +               memcpy(name_copy, name, len); 
    489 +               name_copy[len] = '\0'; 
    490 +               p->name = name_copy; 
    491 +               p->len = len; 
    492 +               p->type = d_type; 
    493 +               p->ino = ino; 
    494 +               p->is_whiteout = false; 
    495 +       } 
    496 + 
    497 +       return p; 
    498 +} 
    499 + 
    500 +static int ovl_cache_entry_add_rb(struct ovl_readdir_data *rdd, 
    501 +                                 const char *name, int len, u64 ino, 
    502 +                                 unsigned int d_type) 
    503 +{ 
    504 +       struct rb_node **newp = &rdd->root->rb_node; 
    505 +       struct rb_node *parent = NULL; 
    506 +       struct ovl_cache_entry *p; 
    507 + 
    508 +       while (*newp) { 
    509 +               int cmp; 
    510 +               struct ovl_cache_entry *tmp; 
    511 + 
    512 +               parent = *newp; 
    513 +               tmp = ovl_cache_entry_from_node(*newp); 
    514 +               cmp = strncmp(name, tmp->name, len); 
    515 +               if (cmp > 0) 
    516 +                       newp = &tmp->node.rb_right; 
    517 +               else if (cmp < 0 || len < tmp->len) 
    518 +                       newp = &tmp->node.rb_left; 
    519 +               else 
    520 +                       return 0; 
    521 +       } 
    522 + 
    523 +       p = ovl_cache_entry_new(name, len, ino, d_type); 
    524 +       if (p == NULL) 
    525 +               return -ENOMEM; 
    526 + 
    527 +       list_add_tail(&p->l_node, rdd->list); 
    528 +       rb_link_node(&p->node, parent, newp); 
    529 +       rb_insert_color(&p->node, rdd->root); 
    530 + 
    531 +       return 0; 
    532 +} 
    533 + 
    534 +static int ovl_fill_lower(void *buf, const char *name, int namelen, 
    535 +                           loff_t offset, u64 ino, unsigned int d_type) 
    536 +{ 
    537 +       struct ovl_readdir_data *rdd = buf; 
    538 +       struct ovl_cache_entry *p; 
    539 + 
    540 +       rdd->count++; 
    541 +       p = ovl_cache_entry_find(rdd->root, name, namelen); 
    542 +       if (p) { 
    543 +               list_move_tail(&p->l_node, rdd->middle); 
    544 +       } else { 
    545 +               p = ovl_cache_entry_new(name, namelen, ino, d_type); 
    546 +               if (p == NULL) 
    547 +                       rdd->err = -ENOMEM; 
    548 +               else 
    549 +                       list_add_tail(&p->l_node, rdd->middle); 
    550 +       } 
    551 + 
    552 +       return rdd->err; 
    553 +} 
    554 + 
    555 +static void ovl_cache_free(struct list_head *list) 
    556 +{ 
    557 +       struct ovl_cache_entry *p; 
    558 +       struct ovl_cache_entry *n; 
    559 + 
    560 +       list_for_each_entry_safe(p, n, list, l_node) 
    561 +               kfree(p); 
    562 + 
    563 +       INIT_LIST_HEAD(list); 
    564 +} 
    565 + 
    566 +static int ovl_fill_upper(void *buf, const char *name, int namelen, 
    567 +                         loff_t offset, u64 ino, unsigned int d_type) 
    568 +{ 
    569 +       struct ovl_readdir_data *rdd = buf; 
    570 + 
    571 +       rdd->count++; 
    572 +       return ovl_cache_entry_add_rb(rdd, name, namelen, ino, d_type); 
    573 +} 
    574 + 
    575 +static int ovl_dir_read(struct path *realpath, struct ovl_readdir_data *rdd, 
    576 +                         filldir_t filler) 
    577 +{ 
    578 +       struct file *realfile; 
    579 +       int err; 
    580 + 
    581 +       realfile = vfs_open(realpath, O_RDONLY | O_DIRECTORY, current_cred()); 
    582 +       if (IS_ERR(realfile)) 
    583 +               return PTR_ERR(realfile); 
    584 + 
    585 +       do { 
    586 +               rdd->count = 0; 
    587 +               rdd->err = 0; 
    588 +               err = vfs_readdir(realfile, filler, rdd); 
    589 +               if (err >= 0) 
    590 +                       err = rdd->err; 
    591 +       } while (!err && rdd->count); 
    592 +       fput(realfile); 
    593 + 
    594 +       return 0; 
    595 +} 
    596 + 
    597 +static void ovl_dir_reset(struct file *file) 
    598 +{ 
    599 +       struct ovl_dir_file *od = file->private_data; 
    600 +       enum ovl_path_type type = ovl_path_type(file->f_path.dentry); 
    601 + 
    602 +       if (ovl_dentry_version_get(file->f_path.dentry) != od->cache_version) { 
    603 +               list_del_init(&od->cursor); 
    604 +               ovl_cache_free(&od->cache); 
    605 +               od->is_cached = false; 
    606 +       } 
    607 +       WARN_ON(!od->is_real && type != OVL_PATH_MERGE); 
    608 +       if (od->is_real && type == OVL_PATH_MERGE) { 
    609 +               fput(od->realfile); 
    610 +               od->realfile = NULL; 
    611 +               od->is_real = false; 
    612 +       } 
    613 +} 
    614 + 
    615 +static int ovl_dir_mark_whiteouts(struct ovl_readdir_data *rdd) 
    616 +{ 
    617 +       struct ovl_cache_entry *p; 
    618 +       struct dentry *dentry; 
    619 +       const struct cred *old_cred; 
    620 +       struct cred *override_cred; 
    621 + 
    622 +       override_cred = prepare_creds(); 
    623 +       if (!override_cred) { 
    624 +               ovl_cache_free(rdd->list); 
    625 +               return -ENOMEM; 
    626 +       } 
    627 + 
    628 +       /* 
    629 +        * CAP_SYS_ADMIN for getxattr 
    630 +        * CAP_DAC_OVERRIDE for lookup 
    631 +        */ 
    632 +       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
    633 +       cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 
    634 +       old_cred = override_creds(override_cred); 
    635 + 
    636 +       mutex_lock(&rdd->dir->d_inode->i_mutex); 
    637 +       list_for_each_entry(p, rdd->list, l_node) { 
    638 +               if (p->type != DT_LNK) 
    639 +                       continue; 
    640 + 
    641 +               dentry = lookup_one_len(p->name, rdd->dir, p->len); 
    642 +               if (IS_ERR(dentry)) 
    643 +                       continue; 
    644 + 
    645 +               p->is_whiteout = ovl_is_whiteout(dentry); 
    646 +               dput(dentry); 
    647 +       } 
    648 +       mutex_unlock(&rdd->dir->d_inode->i_mutex); 
    649 + 
    650 +       revert_creds(old_cred); 
    651 +       put_cred(override_cred); 
    652 + 
    653 +       return 0; 
    654 +} 
    655 + 
    656 +static int ovl_dir_read_merged(struct path *upperpath, struct path *lowerpath, 
    657 +                              struct ovl_readdir_data *rdd) 
    658 +{ 
    659 +       int err; 
    660 +       struct rb_root root = RB_ROOT; 
    661 +       struct list_head middle; 
    662 + 
    663 +       rdd->root = &root; 
    664 +       if (upperpath->dentry) { 
    665 +               rdd->dir = upperpath->dentry; 
    666 +               err = ovl_dir_read(upperpath, rdd, ovl_fill_upper); 
    667 +               if (err) 
    668 +                       goto out; 
    669 + 
    670 +               err = ovl_dir_mark_whiteouts(rdd); 
    671 +               if (err) 
    672 +                       goto out; 
    673 +       } 
    674 +       /* 
    675 +        * Insert lowerpath entries before upperpath ones, this allows 
    676 +        * offsets to be reasonably constant 
    677 +        */ 
    678 +       list_add(&middle, rdd->list); 
    679 +       rdd->middle = &middle; 
    680 +       err = ovl_dir_read(lowerpath, rdd, ovl_fill_lower); 
    681 +       list_del(&middle); 
    682 +out: 
    683 +       rdd->root = NULL; 
    684 + 
    685 +       return err; 
    686 +} 
    687 + 
    688 +static void ovl_seek_cursor(struct ovl_dir_file *od, loff_t pos) 
    689 +{ 
    690 +       struct list_head *l; 
    691 +       loff_t off; 
    692 + 
    693 +       l = od->cache.next; 
    694 +       for (off = 0; off < pos; off++) { 
    695 +               if (l == &od->cache) 
    696 +                       break; 
    697 +               l = l->next; 
    698 +       } 
    699 +       list_move_tail(&od->cursor, l); 
    700 +} 
    701 + 
    702 +static int ovl_readdir(struct file *file, void *buf, filldir_t filler) 
    703 +{ 
    704 +       struct ovl_dir_file *od = file->private_data; 
    705 +       int res; 
    706 + 
    707 +       if (!file->f_pos) 
    708 +               ovl_dir_reset(file); 
    709 + 
    710 +       if (od->is_real) { 
    711 +               res = vfs_readdir(od->realfile, filler, buf); 
    712 +               file->f_pos = od->realfile->f_pos; 
    713 + 
    714 +               return res; 
    715 +       } 
    716 + 
    717 +       if (!od->is_cached) { 
    718 +               struct path lowerpath; 
    719 +               struct path upperpath; 
    720 +               struct ovl_readdir_data rdd = { .list = &od->cache }; 
    721 + 
    722 +               ovl_path_lower(file->f_path.dentry, &lowerpath); 
    723 +               ovl_path_upper(file->f_path.dentry, &upperpath); 
    724 + 
    725 +               res = ovl_dir_read_merged(&upperpath, &lowerpath, &rdd); 
    726 +               if (res) { 
    727 +                       ovl_cache_free(rdd.list); 
    728 +                       return res; 
    729 +               } 
    730 + 
    731 +               od->cache_version = ovl_dentry_version_get(file->f_path.dentry); 
    732 +               od->is_cached = true; 
    733 + 
    734 +               ovl_seek_cursor(od, file->f_pos); 
    735 +       } 
    736 + 
    737 +       while (od->cursor.next != &od->cache) { 
    738 +               int over; 
    739 +               loff_t off; 
    740 +               struct ovl_cache_entry *p; 
    741 + 
    742 +               p = list_entry(od->cursor.next, struct ovl_cache_entry, l_node); 
    743 +               off = file->f_pos; 
    744 +               file->f_pos++; 
    745 +               list_move(&od->cursor, &p->l_node); 
    746 + 
    747 +               if (p->is_whiteout) 
    748 +                       continue; 
    749 + 
    750 +               over = filler(buf, p->name, p->len, off, p->ino, p->type); 
    751 +               if (over) 
    752 +                       break; 
    753 +       } 
    754 + 
    755 +       return 0; 
    756 +} 
    757 + 
    758 +static loff_t ovl_dir_llseek(struct file *file, loff_t offset, int origin) 
    759 +{ 
    760 +       loff_t res; 
    761 +       struct ovl_dir_file *od = file->private_data; 
    762 + 
    763 +       mutex_lock(&file->f_dentry->d_inode->i_mutex); 
    764 +       if (!file->f_pos) 
    765 +               ovl_dir_reset(file); 
    766 + 
    767 +       if (od->is_real) { 
    768 +               res = vfs_llseek(od->realfile, offset, origin); 
    769 +               file->f_pos = od->realfile->f_pos; 
    770 +       } else { 
    771 +               res = -EINVAL; 
    772 + 
    773 +               switch (origin) { 
    774 +               case SEEK_CUR: 
    775 +                       offset += file->f_pos; 
    776 +                       break; 
    777 +               case SEEK_SET: 
    778 +                       break; 
    779 +               default: 
    780 +                       goto out_unlock; 
    781 +               } 
    782 +               if (offset < 0) 
    783 +                       goto out_unlock; 
    784 + 
    785 +               if (offset != file->f_pos) { 
    786 +                       file->f_pos = offset; 
    787 +                       if (od->is_cached) 
    788 +                               ovl_seek_cursor(od, offset); 
    789 +               } 
    790 +               res = offset; 
    791 +       } 
    792 +out_unlock: 
    793 +       mutex_unlock(&file->f_dentry->d_inode->i_mutex); 
    794 + 
    795 +       return res; 
    796 +} 
    797 + 
    798 +static int ovl_dir_fsync(struct file *file, int datasync) 
    799 +{ 
    800 +       struct ovl_dir_file *od = file->private_data; 
    801 + 
    802 +       /* May need to reopen directory if it got copied up */ 
    803 +       if (!od->realfile) { 
    804 +               struct path upperpath; 
    805 + 
    806 +               ovl_path_upper(file->f_path.dentry, &upperpath); 
    807 +               od->realfile = vfs_open(&upperpath, O_RDONLY, current_cred()); 
    808 +               if (IS_ERR(od->realfile)) 
    809 +                       return PTR_ERR(od->realfile); 
    810 +       } 
    811 + 
    812 +       return vfs_fsync(od->realfile, datasync); 
    813 +} 
    814 + 
    815 +static int ovl_dir_release(struct inode *inode, struct file *file) 
    816 +{ 
    817 +       struct ovl_dir_file *od = file->private_data; 
    818 + 
    819 +       list_del(&od->cursor); 
    820 +       ovl_cache_free(&od->cache); 
    821 +       if (od->realfile) 
    822 +               fput(od->realfile); 
    823 +       kfree(od); 
    824 + 
    825 +       return 0; 
    826 +} 
    827 + 
    828 +static int ovl_dir_open(struct inode *inode, struct file *file) 
    829 +{ 
    830 +       struct path realpath; 
    831 +       struct file *realfile; 
    832 +       struct ovl_dir_file *od; 
    833 +       enum ovl_path_type type; 
    834 + 
    835 +       od = kzalloc(sizeof(struct ovl_dir_file), GFP_KERNEL); 
    836 +       if (!od) 
    837 +               return -ENOMEM; 
    838 + 
    839 +       type = ovl_path_real(file->f_path.dentry, &realpath); 
    840 +       realfile = vfs_open(&realpath, file->f_flags, current_cred()); 
    841 +       if (IS_ERR(realfile)) { 
    842 +               kfree(od); 
    843 +               return PTR_ERR(realfile); 
    844 +       } 
    845 +       INIT_LIST_HEAD(&od->cache); 
    846 +       INIT_LIST_HEAD(&od->cursor); 
    847 +       od->is_cached = false; 
    848 +       od->realfile = realfile; 
    849 +       od->is_real = (type != OVL_PATH_MERGE); 
    850 +       file->private_data = od; 
    851 + 
    852 +       return 0; 
    853 +} 
    854 + 
    855 +static const struct file_operations ovl_dir_operations = { 
    856 +       .read           = generic_read_dir, 
    857 +       .open           = ovl_dir_open, 
    858 +       .readdir        = ovl_readdir, 
    859 +       .llseek         = ovl_dir_llseek, 
    860 +       .fsync          = ovl_dir_fsync, 
    861 +       .release        = ovl_dir_release, 
    862 +}; 
    863 + 
    864 +static const struct inode_operations ovl_dir_inode_operations; 
    865 + 
    866 +static void ovl_entry_free(struct rcu_head *head) 
    867 +{ 
    868 +       struct ovl_entry *oe = container_of(head, struct ovl_entry, rcu); 
    869 +       kfree(oe); 
    870 +} 
    871 + 
    872 +static void ovl_dentry_release(struct dentry *dentry) 
    873 +{ 
    874 +       struct ovl_entry *oe = dentry->d_fsdata; 
    875 + 
    876 +       if (oe) { 
    877 +               dput(oe->__upperdentry); 
    878 +               dput(oe->lowerdentry); 
    879 +               call_rcu(&oe->rcu, ovl_entry_free); 
    880 +       } 
    881 +} 
    882 + 
    883 +static const struct dentry_operations ovl_dentry_operations = { 
    884 +       .d_release = ovl_dentry_release, 
    885 +}; 
    886 + 
    887 +static struct dentry *ovl_lookup_real(struct dentry *dir, struct qstr *name) 
    888 +{ 
    889 +       struct dentry *dentry; 
    890 + 
    891 +       mutex_lock(&dir->d_inode->i_mutex); 
    892 +       dentry = lookup_one_len(name->name, dir, name->len); 
    893 +       mutex_unlock(&dir->d_inode->i_mutex); 
    894 + 
    895 +       if (IS_ERR(dentry)) { 
    896 +               if (PTR_ERR(dentry) == -ENOENT) 
    897 +                       dentry = NULL; 
    898 +       } else if (!dentry->d_inode) { 
    899 +               dput(dentry); 
    900 +               dentry = NULL; 
    901 +       } 
    902 +       return dentry; 
    903 +} 
    904 + 
    905 +static struct ovl_entry *ovl_alloc_entry(void) 
    906 +{ 
    907 +       return kzalloc(sizeof(struct ovl_entry), GFP_KERNEL); 
    908 +} 
    909 + 
    910 +static struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, 
    911 +                                  struct ovl_entry *oe); 
    912 + 
    913 +static int ovl_whiteout(struct dentry *upperdir, struct dentry *dentry) 
    914 +{ 
    915 +       int err; 
    916 +       struct dentry *newdentry; 
    917 +       const struct cred *old_cred; 
    918 +       struct cred *override_cred; 
    919 + 
    920 +       /* FIXME: recheck lower dentry to see if whiteout is really needed */ 
    921 + 
    922 +       err = -ENOMEM; 
    923 +       override_cred = prepare_creds(); 
    924 +       if (!override_cred) 
    925 +               goto out; 
    926 + 
    927 +       /* 
    928 +        * CAP_SYS_ADMIN for setxattr 
    929 +        * CAP_DAC_OVERRIDE for symlink creation 
    930 +        */ 
    931 +       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
    932 +       cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 
    933 +       override_cred->fsuid = 0; 
    934 +       override_cred->fsgid = 0; 
    935 +       old_cred = override_creds(override_cred); 
    936 + 
    937 +       newdentry = lookup_one_len(dentry->d_name.name, upperdir, 
    938 +                                  dentry->d_name.len); 
    939 +       err = PTR_ERR(newdentry); 
    940 +       if (IS_ERR(newdentry)) 
    941 +               goto out_put_cred; 
    942 + 
    943 +       /* Just been removed within the same locked region */ 
    944 +       WARN_ON(newdentry->d_inode); 
    945 + 
    946 +       err = vfs_symlink(upperdir->d_inode, newdentry, ovl_whiteout_symlink); 
    947 +       if (err) 
    948 +               goto out_dput; 
    949 + 
    950 +       ovl_dentry_version_inc(dentry->d_parent); 
    951 + 
    952 +       err = vfs_setxattr(newdentry, ovl_whiteout_xattr, "y", 1, 0); 
    953 +       if (err) 
    954 +               vfs_unlink(upperdir->d_inode, newdentry); 
    955 + 
    956 +out_dput: 
    957 +       dput(newdentry); 
    958 +out_put_cred: 
    959 +       revert_creds(old_cred); 
    960 +       put_cred(override_cred); 
    961 +out: 
    962 +       if (err) { 
    963 +               /* 
    964 +                * There's no way to recover from failure to whiteout. 
    965 +                * What should we do?  Log a big fat error and... ? 
    966 +                */ 
    967 +               printk(KERN_ERR "overlayfs: ERROR - failed to whiteout '%s'\n", 
    968 +                      dentry->d_name.name); 
    969 +       } 
    970 + 
    971 +       return err; 
    972 +} 
    973 + 
    974 +static struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, 
    975 +                                  struct nameidata *nd) 
    976 +{ 
    977 +       struct ovl_entry *oe; 
    978 +       struct dentry *upperdir; 
    979 +       struct dentry *lowerdir; 
    980 +       struct dentry *upperdentry = NULL; 
    981 +       struct dentry *lowerdentry = NULL; 
    982 +       struct inode *inode = NULL; 
    983 +       int err; 
    984 + 
    985 +       err = -ENOMEM; 
    986 +       oe = ovl_alloc_entry(); 
    987 +       if (!oe) 
    988 +               goto out; 
    989 + 
    990 +       upperdir = ovl_dentry_upper(dentry->d_parent); 
    991 +       lowerdir = ovl_dentry_lower(dentry->d_parent); 
    992 + 
    993 +       if (upperdir) { 
    994 +               upperdentry = ovl_lookup_real(upperdir, &dentry->d_name); 
    995 +               err = PTR_ERR(upperdentry); 
    996 +               if (IS_ERR(upperdentry)) 
    997 +                       goto out_put_dir; 
    998 + 
    999 +               if (lowerdir && upperdentry && 
    1000 +                   (S_ISLNK(upperdentry->d_inode->i_mode) || 
    1001 +                    S_ISDIR(upperdentry->d_inode->i_mode))) { 
    1002 +                       const struct cred *old_cred; 
    1003 +                       struct cred *override_cred; 
    1004 + 
    1005 +                       err = -ENOMEM; 
    1006 +                       override_cred = prepare_creds(); 
    1007 +                       if (!override_cred) 
    1008 +                               goto out_dput_upper; 
    1009 + 
    1010 +                       /* CAP_SYS_ADMIN needed for getxattr */ 
    1011 +                       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
    1012 +                       old_cred = override_creds(override_cred); 
    1013 + 
    1014 +                       if (ovl_is_opaquedir(upperdentry)) { 
    1015 +                               oe->opaque = true; 
    1016 +                       } else if (ovl_is_whiteout(upperdentry)) { 
    1017 +                               dput(upperdentry); 
    1018 +                               upperdentry = NULL; 
    1019 +                               oe->opaque = true; 
    1020 +                       } 
    1021 +                       revert_creds(old_cred); 
    1022 +                       put_cred(override_cred); 
    1023 +               } 
    1024 +       } 
    1025 +       if (lowerdir && !oe->opaque) { 
    1026 +               lowerdentry = ovl_lookup_real(lowerdir, &dentry->d_name); 
    1027 +               err = PTR_ERR(lowerdentry); 
    1028 +               if (IS_ERR(lowerdentry)) 
    1029 +                       goto out_dput_upper; 
    1030 +       } 
    1031 + 
    1032 +       if (lowerdentry && upperdentry && 
    1033 +           (!S_ISDIR(upperdentry->d_inode->i_mode) || 
    1034 +            !S_ISDIR(lowerdentry->d_inode->i_mode))) { 
    1035 +               dput(lowerdentry); 
    1036 +               lowerdentry = NULL; 
    1037 +               oe->opaque = true; 
    1038 +       } 
    1039 + 
    1040 +       if (lowerdentry || upperdentry) { 
    1041 +               struct dentry *realdentry; 
    1042 + 
    1043 +               realdentry = upperdentry ? upperdentry : lowerdentry; 
    1044 +               err = -ENOMEM; 
    1045 +               inode = ovl_new_inode(dir->i_sb, realdentry->d_inode->i_mode, oe); 
    1046 +               if (!inode) 
    1047 +                       goto out_dput; 
    1048 +       } 
    1049 + 
    1050 +       if (upperdentry) 
    1051 +               oe->__upperdentry = upperdentry; 
    1052 + 
    1053 +       if (lowerdentry) 
    1054 +               oe->lowerdentry = lowerdentry; 
    1055 + 
    1056 +       dentry->d_fsdata = oe; 
    1057 +       dentry->d_op = &ovl_dentry_operations; 
    1058 +       d_add(dentry, inode); 
    1059 + 
    1060 +       return NULL; 
    1061 + 
    1062 +out_dput: 
    1063 +       dput(lowerdentry); 
    1064 +out_dput_upper: 
    1065 +       dput(upperdentry); 
    1066 +out_put_dir: 
    1067 +       kfree(oe); 
    1068 +out: 
    1069 +       return ERR_PTR(err); 
    1070 +} 
    1071476+ 
    1072477+static int ovl_copy_up_xattr(struct dentry *old, struct dentry *new) 
     
    1169574+} 
    1170575+ 
    1171 +static struct dentry *ovl_lookup_create(struct dentry *upperdir, 
    1172 +                                       struct dentry *template) 
    1173 +{ 
    1174 +       int err; 
    1175 +       struct dentry *newdentry; 
    1176 +       struct qstr *name = &template->d_name; 
    1177 + 
    1178 +       newdentry = lookup_one_len(name->name, upperdir, name->len); 
    1179 +       if (IS_ERR(newdentry)) 
    1180 +               return newdentry; 
    1181 + 
    1182 +       if (newdentry->d_inode) { 
    1183 +               const struct cred *old_cred; 
    1184 +               struct cred *override_cred; 
    1185 + 
    1186 +               /* No need to check whiteout if lower parent is non-existent */ 
    1187 +               err = -EEXIST; 
    1188 +               if (!ovl_dentry_lower(template->d_parent)) 
    1189 +                       goto out_dput; 
    1190 + 
    1191 +               if (!S_ISLNK(newdentry->d_inode->i_mode)) 
    1192 +                       goto out_dput; 
    1193 + 
    1194 +               err = -ENOMEM; 
    1195 +               override_cred = prepare_creds(); 
    1196 +               if (!override_cred) 
    1197 +                       goto out_dput; 
    1198 + 
    1199 +               /* 
    1200 +                * CAP_SYS_ADMIN for getxattr 
    1201 +                * CAP_FOWNER for unlink in sticky directory 
    1202 +                */ 
    1203 +               cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
    1204 +               cap_raise(override_cred->cap_effective, CAP_FOWNER); 
    1205 +               old_cred = override_creds(override_cred); 
    1206 + 
    1207 +               err = -EEXIST; 
    1208 +               if (ovl_is_whiteout(newdentry)) 
    1209 +                       err = vfs_unlink(upperdir->d_inode, newdentry); 
    1210 + 
    1211 +               revert_creds(old_cred); 
    1212 +               put_cred(override_cred); 
    1213 +               if (err) 
    1214 +                       goto out_dput; 
    1215 + 
    1216 +               dput(newdentry); 
    1217 +               newdentry = lookup_one_len(name->name, upperdir, name->len); 
    1218 +               if (IS_ERR(newdentry)) { 
    1219 +                       ovl_whiteout(upperdir, template); 
    1220 +                       return newdentry; 
    1221 +               } 
    1222 + 
    1223 +               /* 
    1224 +                * Whiteout just been successfully removed, parent 
    1225 +                * i_mutex is still held, there's no way the lookup 
    1226 +                * could return positive. 
    1227 +                */ 
    1228 +               WARN_ON(newdentry->d_inode); 
    1229 +       } 
    1230 + 
    1231 +       return newdentry; 
    1232 + 
    1233 +out_dput: 
    1234 +       dput(newdentry); 
    1235 +       return ERR_PTR(err); 
    1236 +} 
    1237 + 
    1238 +static struct dentry *ovl_upper_create(struct dentry *upperdir, 
    1239 +                                      struct dentry *dentry, 
    1240 +                                      struct kstat *stat, const char *link) 
    1241 +{ 
    1242 +       int err; 
    1243 +       struct dentry *newdentry; 
    1244 +       struct inode *dir = upperdir->d_inode; 
    1245 + 
    1246 +       newdentry = ovl_lookup_create(upperdir, dentry); 
    1247 +       if (IS_ERR(newdentry)) 
    1248 +               goto out; 
    1249 + 
    1250 +       switch (stat->mode & S_IFMT) { 
    1251 +       case S_IFREG: 
    1252 +               err = vfs_create(dir, newdentry, stat->mode, NULL); 
    1253 +               break; 
    1254 + 
    1255 +       case S_IFDIR: 
    1256 +               err = vfs_mkdir(dir, newdentry, stat->mode); 
    1257 +               break; 
    1258 + 
    1259 +       case S_IFCHR: 
    1260 +       case S_IFBLK: 
    1261 +       case S_IFIFO: 
    1262 +       case S_IFSOCK: 
    1263 +               err = vfs_mknod(dir, newdentry, stat->mode, stat->rdev); 
    1264 +               break; 
    1265 + 
    1266 +       case S_IFLNK: 
    1267 +               err = vfs_symlink(dir, newdentry, link); 
    1268 +               break; 
    1269 + 
    1270 +       default: 
    1271 +               err = -EPERM; 
    1272 +       } 
    1273 +       if (err) { 
    1274 +               if (ovl_dentry_is_opaque(dentry)) 
    1275 +                       ovl_whiteout(upperdir, dentry); 
    1276 +               dput(newdentry); 
    1277 +               newdentry = ERR_PTR(err); 
    1278 +       } 
    1279 + 
    1280 +out: 
    1281 +       return newdentry; 
    1282 + 
    1283 +} 
    1284 + 
    1285576+static char *ovl_read_symlink(struct dentry *realdentry) 
    1286577+{ 
     
    1338629+} 
    1339630+ 
    1340 +static int ovl_set_opaque(struct dentry *upperdentry) 
    1341 +{ 
    1342 +       int err; 
    1343 +       const struct cred *old_cred; 
    1344 +       struct cred *override_cred; 
    1345 + 
    1346 +       override_cred = prepare_creds(); 
    1347 +       if (!override_cred) 
    1348 +               return -ENOMEM; 
    1349 + 
    1350 +       /* CAP_SYS_ADMIN for setxattr of "trusted" namespace */ 
    1351 +       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
    1352 +       old_cred = override_creds(override_cred); 
    1353 +       err = vfs_setxattr(upperdentry, ovl_opaque_xattr, "y", 1, 0); 
    1354 +       revert_creds(old_cred); 
    1355 +       put_cred(override_cred); 
    1356 + 
    1357 +       return err; 
    1358 +} 
    1359 + 
    1360 +static int ovl_remove_opaque(struct dentry *upperdentry) 
    1361 +{ 
    1362 +       int err; 
    1363 +       const struct cred *old_cred; 
    1364 +       struct cred *override_cred; 
    1365 + 
    1366 +       override_cred = prepare_creds(); 
    1367 +       if (!override_cred) 
    1368 +               return -ENOMEM; 
    1369 + 
    1370 +       /* CAP_SYS_ADMIN for removexattr of "trusted" namespace */ 
    1371 +       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
    1372 +       old_cred = override_creds(override_cred); 
    1373 +       err = vfs_removexattr(upperdentry, ovl_opaque_xattr); 
    1374 +       revert_creds(old_cred); 
    1375 +       put_cred(override_cred); 
    1376 + 
    1377 +       return err; 
    1378 +} 
    1379 + 
    1380631+static int ovl_copy_up_locked(struct dentry *upperdir, struct dentry *dentry, 
    1381632+                             struct path *lowerpath, struct kstat *stat, 
     
    1385636+       struct path newpath; 
    1386637+       umode_t mode = stat->mode; 
    1387 +       struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 
    1388638+ 
    1389639+       /* Can't properly set mode on creation because of the umask */ 
    1390640+       stat->mode &= S_IFMT; 
    1391641+ 
    1392 +       newpath.mnt = ofs->upper_mnt; 
     642+       ovl_path_upper(dentry, &newpath); 
     643+       WARN_ON(newpath.dentry); 
    1393644+       newpath.dentry = ovl_upper_create(upperdir, dentry, stat, link); 
    1394 +       if (IS_ERR(newpath.dentry)) { 
    1395 +               err = PTR_ERR(newpath.dentry); 
    1396 + 
    1397 +               /* Already copied up? */ 
    1398 +               if (err == -EEXIST && ovl_path_type(dentry) != OVL_PATH_LOWER) 
    1399 +                       return 0; 
    1400 + 
    1401 +               return err; 
    1402 +       } 
     645+       if (IS_ERR(newpath.dentry)) 
     646+               return PTR_ERR(newpath.dentry); 
    1403647+ 
    1404648+       if (S_ISREG(stat->mode)) { 
     
    1444688+} 
    1445689+ 
     690+/* 
     691+ * Copy up a single dentry 
     692+ * 
     693+ * Directory renames only allowed on "pure upper" (already created on 
     694+ * upper filesystem, never copied up).  Directories which are on lower or 
     695+ * are merged may not be renamed.  For these -EXDEV is returned and 
     696+ * userspace has to deal with it.  This means, when copying up a 
     697+ * directory we can rely on it and ancestors being stable. 
     698+ * 
     699+ * Non-directory renames start with copy up of source if necessary.  The 
     700+ * actual rename will only proceed once the copy up was successful.  Copy 
     701+ * up uses upper parent i_mutex for exclusion.  Since rename can change 
     702+ * d_parent it is possible that the copy up will lock the old parent.  At 
     703+ * that point the file will have already been copied up anyway. 
     704+ */ 
    1446705+static int ovl_copy_up_one(struct dentry *parent, struct dentry *dentry, 
    1447706+                          struct path *lowerpath, struct kstat *stat) 
     
    1490749+ 
    1491750+       mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
    1492 +       /* 
    1493 +        * Using upper filesystem locking to protect against copy up 
    1494 +        * racing with rename (rename means the copy up was already 
    1495 +        * successful). 
    1496 +        */ 
    1497 +       if (dentry->d_parent != parent) { 
    1498 +               WARN_ON((ovl_path_type(dentry) == OVL_PATH_LOWER)); 
     751+       if (ovl_path_type(dentry) != OVL_PATH_LOWER) { 
    1499752+               err = 0; 
    1500753+       } else { 
     
    1519772+} 
    1520773+ 
    1521 +static int ovl_copy_up(struct dentry *dentry) 
     774+int ovl_copy_up(struct dentry *dentry) 
    1522775+{ 
    1523776+       int err; 
     
    1560813+ 
    1561814+/* Optimize by not copying up the file first and truncating later */ 
    1562 +static int ovl_copy_up_truncate(struct dentry *dentry, loff_t size) 
     815+int ovl_copy_up_truncate(struct dentry *dentry, loff_t size) 
    1563816+{ 
    1564817+       int err; 
     
    1585838+       return err; 
    1586839+} 
    1587 + 
    1588 +static int ovl_setattr(struct dentry *dentry, struct iattr *attr) 
    1589 +{ 
    1590 +       struct dentry *upperdentry; 
     840--- /dev/null 
     841+++ b/fs/overlayfs/dir.c 
     842@@ -0,0 +1,596 @@ 
     843+/* 
     844+ * 
     845+ * Copyright (C) 2011 Novell Inc. 
     846+ * 
     847+ * This program is free software; you can redistribute it and/or modify it 
     848+ * under the terms of the GNU General Public License version 2 as published by 
     849+ * the Free Software Foundation. 
     850+ */ 
     851+ 
     852+#include <linux/fs.h> 
     853+#include <linux/namei.h> 
     854+#include <linux/xattr.h> 
     855+#include <linux/security.h> 
     856+#include "overlayfs.h" 
     857+ 
     858+static const char *ovl_whiteout_symlink = "(overlay-whiteout)"; 
     859+ 
     860+static int ovl_whiteout(struct dentry *upperdir, struct dentry *dentry) 
     861+{ 
    1591862+       int err; 
    1592 + 
    1593 +       if ((attr->ia_valid & ATTR_SIZE) && !ovl_dentry_upper(dentry)) 
    1594 +               err = ovl_copy_up_truncate(dentry, attr->ia_size); 
    1595 +       else 
    1596 +               err = ovl_copy_up(dentry); 
     863+       struct dentry *newdentry; 
     864+       const struct cred *old_cred; 
     865+       struct cred *override_cred; 
     866+ 
     867+       /* FIXME: recheck lower dentry to see if whiteout is really needed */ 
     868+ 
     869+       err = -ENOMEM; 
     870+       override_cred = prepare_creds(); 
     871+       if (!override_cred) 
     872+               goto out; 
     873+ 
     874+       /* 
     875+        * CAP_SYS_ADMIN for setxattr 
     876+        * CAP_DAC_OVERRIDE for symlink creation 
     877+        * CAP_FOWNER for unlink in sticky directory 
     878+        */ 
     879+       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     880+       cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 
     881+       cap_raise(override_cred->cap_effective, CAP_FOWNER); 
     882+       override_cred->fsuid = 0; 
     883+       override_cred->fsgid = 0; 
     884+       old_cred = override_creds(override_cred); 
     885+ 
     886+       newdentry = lookup_one_len(dentry->d_name.name, upperdir, 
     887+                                  dentry->d_name.len); 
     888+       err = PTR_ERR(newdentry); 
     889+       if (IS_ERR(newdentry)) 
     890+               goto out_put_cred; 
     891+ 
     892+       /* Just been removed within the same locked region */ 
     893+       WARN_ON(newdentry->d_inode); 
     894+ 
     895+       err = vfs_symlink(upperdir->d_inode, newdentry, ovl_whiteout_symlink); 
    1597896+       if (err) 
    1598 +               return err; 
    1599 + 
    1600 +       upperdentry = ovl_dentry_upper(dentry); 
    1601 + 
    1602 +       if (attr->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID)) 
    1603 +               attr->ia_valid &= ~ATTR_MODE; 
    1604 + 
    1605 +       mutex_lock(&upperdentry->d_inode->i_mutex); 
    1606 +       err = notify_change(upperdentry, attr); 
    1607 +       mutex_unlock(&upperdentry->d_inode->i_mutex); 
     897+               goto out_dput; 
     898+ 
     899+       ovl_dentry_version_inc(dentry->d_parent); 
     900+ 
     901+       err = vfs_setxattr(newdentry, ovl_whiteout_xattr, "y", 1, 0); 
     902+       if (err) 
     903+               vfs_unlink(upperdir->d_inode, newdentry); 
     904+ 
     905+out_dput: 
     906+       dput(newdentry); 
     907+out_put_cred: 
     908+       revert_creds(old_cred); 
     909+       put_cred(override_cred); 
     910+out: 
     911+       if (err) { 
     912+               /* 
     913+                * There's no way to recover from failure to whiteout. 
     914+                * What should we do?  Log a big fat error and... ? 
     915+                */ 
     916+               printk(KERN_ERR "overlayfs: ERROR - failed to whiteout '%s'\n", 
     917+                      dentry->d_name.name); 
     918+       } 
    1608919+ 
    1609920+       return err; 
    1610921+} 
    1611922+ 
    1612 +static int ovl_getattr(struct vfsmount *mnt, struct dentry *dentry, 
    1613 +                        struct kstat *stat) 
    1614 +{ 
    1615 +       struct path realpath; 
    1616 + 
    1617 +       ovl_path_real(dentry, &realpath); 
    1618 +       return vfs_getattr(realpath.mnt, realpath.dentry, stat); 
     923+static struct dentry *ovl_lookup_create(struct dentry *upperdir, 
     924+                                       struct dentry *template) 
     925+{ 
     926+       int err; 
     927+       struct dentry *newdentry; 
     928+       struct qstr *name = &template->d_name; 
     929+ 
     930+       newdentry = lookup_one_len(name->name, upperdir, name->len); 
     931+       if (IS_ERR(newdentry)) 
     932+               return newdentry; 
     933+ 
     934+       if (newdentry->d_inode) { 
     935+               const struct cred *old_cred; 
     936+               struct cred *override_cred; 
     937+ 
     938+               /* No need to check whiteout if lower parent is non-existent */ 
     939+               err = -EEXIST; 
     940+               if (!ovl_dentry_lower(template->d_parent)) 
     941+                       goto out_dput; 
     942+ 
     943+               if (!S_ISLNK(newdentry->d_inode->i_mode)) 
     944+                       goto out_dput; 
     945+ 
     946+               err = -ENOMEM; 
     947+               override_cred = prepare_creds(); 
     948+               if (!override_cred) 
     949+                       goto out_dput; 
     950+ 
     951+               /* 
     952+                * CAP_SYS_ADMIN for getxattr 
     953+                * CAP_FOWNER for unlink in sticky directory 
     954+                */ 
     955+               cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     956+               cap_raise(override_cred->cap_effective, CAP_FOWNER); 
     957+               old_cred = override_creds(override_cred); 
     958+ 
     959+               err = -EEXIST; 
     960+               if (ovl_is_whiteout(newdentry)) 
     961+                       err = vfs_unlink(upperdir->d_inode, newdentry); 
     962+ 
     963+               revert_creds(old_cred); 
     964+               put_cred(override_cred); 
     965+               if (err) 
     966+                       goto out_dput; 
     967+ 
     968+               dput(newdentry); 
     969+               newdentry = lookup_one_len(name->name, upperdir, name->len); 
     970+               if (IS_ERR(newdentry)) { 
     971+                       ovl_whiteout(upperdir, template); 
     972+                       return newdentry; 
     973+               } 
     974+ 
     975+               /* 
     976+                * Whiteout just been successfully removed, parent 
     977+                * i_mutex is still held, there's no way the lookup 
     978+                * could return positive. 
     979+                */ 
     980+               WARN_ON(newdentry->d_inode); 
     981+       } 
     982+ 
     983+       return newdentry; 
     984+ 
     985+out_dput: 
     986+       dput(newdentry); 
     987+       return ERR_PTR(err); 
     988+} 
     989+ 
     990+struct dentry *ovl_upper_create(struct dentry *upperdir, struct dentry *dentry, 
     991+                               struct kstat *stat, const char *link) 
     992+{ 
     993+       int err; 
     994+       struct dentry *newdentry; 
     995+       struct inode *dir = upperdir->d_inode; 
     996+ 
     997+       newdentry = ovl_lookup_create(upperdir, dentry); 
     998+       if (IS_ERR(newdentry)) 
     999+               goto out; 
     1000+ 
     1001+       switch (stat->mode & S_IFMT) { 
     1002+       case S_IFREG: 
     1003+               err = vfs_create(dir, newdentry, stat->mode, NULL); 
     1004+               break; 
     1005+ 
     1006+       case S_IFDIR: 
     1007+               err = vfs_mkdir(dir, newdentry, stat->mode); 
     1008+               break; 
     1009+ 
     1010+       case S_IFCHR: 
     1011+       case S_IFBLK: 
     1012+       case S_IFIFO: 
     1013+       case S_IFSOCK: 
     1014+               err = vfs_mknod(dir, newdentry, stat->mode, stat->rdev); 
     1015+               break; 
     1016+ 
     1017+       case S_IFLNK: 
     1018+               err = vfs_symlink(dir, newdentry, link); 
     1019+               break; 
     1020+ 
     1021+       default: 
     1022+               err = -EPERM; 
     1023+       } 
     1024+       if (err) { 
     1025+               if (ovl_dentry_is_opaque(dentry)) 
     1026+                       ovl_whiteout(upperdir, dentry); 
     1027+               dput(newdentry); 
     1028+               newdentry = ERR_PTR(err); 
     1029+       } else if (WARN_ON(!newdentry->d_inode)) { 
     1030+               /* 
     1031+                * Not quite sure if non-instantiated dentry is legal or not. 
     1032+                * VFS doesn't seem to care so check and warn here. 
     1033+                */ 
     1034+               dput(newdentry); 
     1035+               newdentry = ERR_PTR(-ENOENT); 
     1036+       } 
     1037+ 
     1038+out: 
     1039+       return newdentry; 
     1040+ 
     1041+} 
     1042+ 
     1043+static int ovl_set_opaque(struct dentry *upperdentry) 
     1044+{ 
     1045+       int err; 
     1046+       const struct cred *old_cred; 
     1047+       struct cred *override_cred; 
     1048+ 
     1049+       override_cred = prepare_creds(); 
     1050+       if (!override_cred) 
     1051+               return -ENOMEM; 
     1052+ 
     1053+       /* CAP_SYS_ADMIN for setxattr of "trusted" namespace */ 
     1054+       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     1055+       old_cred = override_creds(override_cred); 
     1056+       err = vfs_setxattr(upperdentry, ovl_opaque_xattr, "y", 1, 0); 
     1057+       revert_creds(old_cred); 
     1058+       put_cred(override_cred); 
     1059+ 
     1060+       return err; 
     1061+} 
     1062+ 
     1063+static int ovl_remove_opaque(struct dentry *upperdentry) 
     1064+{ 
     1065+       int err; 
     1066+       const struct cred *old_cred; 
     1067+       struct cred *override_cred; 
     1068+ 
     1069+       override_cred = prepare_creds(); 
     1070+       if (!override_cred) 
     1071+               return -ENOMEM; 
     1072+ 
     1073+       /* CAP_SYS_ADMIN for removexattr of "trusted" namespace */ 
     1074+       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     1075+       old_cred = override_creds(override_cred); 
     1076+       err = vfs_removexattr(upperdentry, ovl_opaque_xattr); 
     1077+       revert_creds(old_cred); 
     1078+       put_cred(override_cred); 
     1079+ 
     1080+       return err; 
    16191081+} 
    16201082+ 
     
    16451107+} 
    16461108+ 
    1647 +static int ovl_permission(struct inode *inode, int mask, unsigned int flags) 
     1109+static int ovl_create_object(struct dentry *dentry, int mode, dev_t rdev, 
     1110+                            const char *link) 
     1111+{ 
     1112+       int err; 
     1113+       struct dentry *newdentry; 
     1114+       struct dentry *upperdir; 
     1115+       struct inode *inode; 
     1116+       struct kstat stat = { 
     1117+               .mode = mode, 
     1118+               .rdev = rdev, 
     1119+       }; 
     1120+ 
     1121+       err = -ENOMEM; 
     1122+       inode = ovl_new_inode(dentry->d_sb, mode, dentry->d_fsdata); 
     1123+       if (!inode) 
     1124+               goto out; 
     1125+ 
     1126+       err = ovl_copy_up(dentry->d_parent); 
     1127+       if (err) 
     1128+               goto out_iput; 
     1129+ 
     1130+       upperdir = ovl_dentry_upper(dentry->d_parent); 
     1131+       mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
     1132+ 
     1133+       newdentry = ovl_upper_create(upperdir, dentry, &stat, link); 
     1134+       err = PTR_ERR(newdentry); 
     1135+       if (IS_ERR(newdentry)) 
     1136+               goto out_unlock; 
     1137+ 
     1138+       ovl_dentry_version_inc(dentry->d_parent); 
     1139+       if (ovl_dentry_is_opaque(dentry) && S_ISDIR(mode)) { 
     1140+               err = ovl_set_opaque(newdentry); 
     1141+               if (err) { 
     1142+                       vfs_rmdir(upperdir->d_inode, newdentry); 
     1143+                       ovl_whiteout(upperdir, dentry); 
     1144+                       goto out_dput; 
     1145+               } 
     1146+       } 
     1147+       ovl_dentry_update(dentry, newdentry); 
     1148+       d_instantiate(dentry, inode); 
     1149+       inode = NULL; 
     1150+       newdentry = NULL; 
     1151+       err = 0; 
     1152+ 
     1153+out_dput: 
     1154+       dput(newdentry); 
     1155+out_unlock: 
     1156+       mutex_unlock(&upperdir->d_inode->i_mutex); 
     1157+out_iput: 
     1158+       iput(inode); 
     1159+out: 
     1160+       return err; 
     1161+} 
     1162+ 
     1163+static int ovl_create(struct inode *dir, struct dentry *dentry, int mode, 
     1164+                       struct nameidata *nd) 
     1165+{ 
     1166+       return ovl_create_object(dentry, (mode & 07777) | S_IFREG, 0, NULL); 
     1167+} 
     1168+ 
     1169+static int ovl_mkdir(struct inode *dir, struct dentry *dentry, int mode) 
     1170+{ 
     1171+       return ovl_create_object(dentry, (mode & 07777) | S_IFDIR, 0, NULL); 
     1172+} 
     1173+ 
     1174+static int ovl_mknod(struct inode *dir, struct dentry *dentry, int mode, 
     1175+                      dev_t rdev) 
     1176+{ 
     1177+       return ovl_create_object(dentry, mode, rdev, NULL); 
     1178+} 
     1179+ 
     1180+static int ovl_symlink(struct inode *dir, struct dentry *dentry, 
     1181+                        const char *link) 
     1182+{ 
     1183+       return ovl_create_object(dentry, S_IFLNK, 0, link); 
     1184+} 
     1185+ 
     1186+static int ovl_do_remove(struct dentry *dentry, bool is_dir) 
     1187+{ 
     1188+       int err; 
     1189+       enum ovl_path_type type; 
     1190+       struct path realpath; 
     1191+       struct dentry *upperdir; 
     1192+ 
     1193+       err = ovl_copy_up(dentry->d_parent); 
     1194+       if (err) 
     1195+               return err; 
     1196+ 
     1197+       upperdir = ovl_dentry_upper(dentry->d_parent); 
     1198+       mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
     1199+       type = ovl_path_real(dentry, &realpath); 
     1200+       if (type != OVL_PATH_LOWER) { 
     1201+               err = -ESTALE; 
     1202+               if (realpath.dentry->d_parent != upperdir) 
     1203+                       goto out_d_drop; 
     1204+ 
     1205+               /* FIXME: create whiteout up front and rename to target */ 
     1206+ 
     1207+               if (is_dir) 
     1208+                       err = vfs_rmdir(upperdir->d_inode, realpath.dentry); 
     1209+               else 
     1210+                       err = vfs_unlink(upperdir->d_inode, realpath.dentry); 
     1211+               if (err) 
     1212+                       goto out_d_drop; 
     1213+ 
     1214+               ovl_dentry_version_inc(dentry->d_parent); 
     1215+       } 
     1216+ 
     1217+       if (type != OVL_PATH_UPPER || ovl_dentry_is_opaque(dentry)) 
     1218+               err = ovl_whiteout(upperdir, dentry); 
     1219+ 
     1220+       /* 
     1221+        * Keeping this dentry hashed would mean having to release 
     1222+        * upperpath/lowerpath, which could only be done if we are the 
     1223+        * sole user of this dentry.  Too tricky...  Just unhash for 
     1224+        * now. 
     1225+        */ 
     1226+out_d_drop: 
     1227+       d_drop(dentry); 
     1228+       mutex_unlock(&upperdir->d_inode->i_mutex); 
     1229+ 
     1230+       return err; 
     1231+} 
     1232+ 
     1233+static int ovl_unlink(struct inode *dir, struct dentry *dentry) 
     1234+{ 
     1235+       return ovl_do_remove(dentry, false); 
     1236+} 
     1237+ 
     1238+ 
     1239+static int ovl_rmdir(struct inode *dir, struct dentry *dentry) 
     1240+{ 
     1241+       int err; 
     1242+       enum ovl_path_type type; 
     1243+ 
     1244+       type = ovl_path_type(dentry); 
     1245+       if (type != OVL_PATH_UPPER) { 
     1246+               err = ovl_check_empty_and_clear(dentry, type); 
     1247+               if (err) 
     1248+                       return err; 
     1249+       } 
     1250+ 
     1251+       return ovl_do_remove(dentry, true); 
     1252+} 
     1253+ 
     1254+static int ovl_link(struct dentry *old, struct inode *newdir, 
     1255+                   struct dentry *new) 
     1256+{ 
     1257+       int err; 
     1258+       struct dentry *olddentry; 
     1259+       struct dentry *newdentry; 
     1260+       struct dentry *upperdir; 
     1261+ 
     1262+       err = ovl_copy_up(old); 
     1263+       if (err) 
     1264+               goto out; 
     1265+ 
     1266+       err = ovl_copy_up(new->d_parent); 
     1267+       if (err) 
     1268+               goto out; 
     1269+ 
     1270+       upperdir = ovl_dentry_upper(new->d_parent); 
     1271+       mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
     1272+       newdentry = ovl_lookup_create(upperdir, new); 
     1273+       err = PTR_ERR(newdentry); 
     1274+       if (IS_ERR(newdentry)) 
     1275+               goto out_unlock; 
     1276+ 
     1277+       olddentry = ovl_dentry_upper(old); 
     1278+       err = vfs_link(olddentry, upperdir->d_inode, newdentry); 
     1279+       if (!err) { 
     1280+               if (WARN_ON(!newdentry->d_inode)) { 
     1281+                       dput(newdentry); 
     1282+                       err = -ENOENT; 
     1283+                       goto out_unlock; 
     1284+               } 
     1285+ 
     1286+               ovl_dentry_version_inc(new->d_parent); 
     1287+               ovl_dentry_update(new, newdentry); 
     1288+ 
     1289+               ihold(old->d_inode); 
     1290+               d_instantiate(new, old->d_inode); 
     1291+       } else { 
     1292+               if (ovl_dentry_is_opaque(new)) 
     1293+                       ovl_whiteout(upperdir, new); 
     1294+               dput(newdentry); 
     1295+       } 
     1296+out_unlock: 
     1297+       mutex_unlock(&upperdir->d_inode->i_mutex); 
     1298+out: 
     1299+       return err; 
     1300+ 
     1301+} 
     1302+ 
     1303+static int ovl_rename(struct inode *olddir, struct dentry *old, 
     1304+                       struct inode *newdir, struct dentry *new) 
     1305+{ 
     1306+       int err; 
     1307+       enum ovl_path_type old_type; 
     1308+       enum ovl_path_type new_type; 
     1309+       struct dentry *old_upperdir; 
     1310+       struct dentry *new_upperdir; 
     1311+       struct dentry *olddentry; 
     1312+       struct dentry *newdentry; 
     1313+       struct dentry *trap; 
     1314+       bool old_opaque; 
     1315+       bool new_opaque; 
     1316+       bool new_create = false; 
     1317+       bool is_dir = S_ISDIR(old->d_inode->i_mode); 
     1318+ 
     1319+       /* Don't copy up directory trees */ 
     1320+       old_type = ovl_path_type(old); 
     1321+       if (old_type != OVL_PATH_UPPER && is_dir) 
     1322+               return -EXDEV; 
     1323+ 
     1324+       if (new->d_inode) { 
     1325+               new_type = ovl_path_type(new); 
     1326+ 
     1327+               if (new_type == OVL_PATH_LOWER && old_type == OVL_PATH_LOWER) { 
     1328+                       if (ovl_dentry_lower(old)->d_inode == 
     1329+                           ovl_dentry_lower(new)->d_inode) 
     1330+                               return 0; 
     1331+               } 
     1332+               if (new_type != OVL_PATH_LOWER && old_type != OVL_PATH_LOWER) { 
     1333+                       if (ovl_dentry_upper(old)->d_inode == 
     1334+                           ovl_dentry_upper(new)->d_inode) 
     1335+                               return 0; 
     1336+               } 
     1337+ 
     1338+               if (new_type != OVL_PATH_UPPER && 
     1339+                   S_ISDIR(new->d_inode->i_mode)) { 
     1340+                       err = ovl_check_empty_and_clear(new, new_type); 
     1341+                       if (err) 
     1342+                               return err; 
     1343+               } 
     1344+       } else { 
     1345+               new_type = OVL_PATH_UPPER; 
     1346+       } 
     1347+ 
     1348+       err = ovl_copy_up(old); 
     1349+       if (err) 
     1350+               return err; 
     1351+ 
     1352+       err = ovl_copy_up(new->d_parent); 
     1353+       if (err) 
     1354+               return err; 
     1355+ 
     1356+       old_upperdir = ovl_dentry_upper(old->d_parent); 
     1357+       new_upperdir = ovl_dentry_upper(new->d_parent); 
     1358+ 
     1359+       trap = lock_rename(new_upperdir, old_upperdir); 
     1360+ 
     1361+       olddentry = ovl_dentry_upper(old); 
     1362+       newdentry = ovl_dentry_upper(new); 
     1363+       if (newdentry) { 
     1364+               dget(newdentry); 
     1365+       } else { 
     1366+               new_create = true; 
     1367+               newdentry = ovl_lookup_create(new_upperdir, new); 
     1368+               err = PTR_ERR(newdentry); 
     1369+               if (IS_ERR(newdentry)) 
     1370+                       goto out_unlock; 
     1371+       } 
     1372+ 
     1373+       err = -ESTALE; 
     1374+       if (olddentry->d_parent != old_upperdir) 
     1375+               goto out_dput; 
     1376+       if (newdentry->d_parent != new_upperdir) 
     1377+               goto out_dput; 
     1378+       if (olddentry == trap) 
     1379+               goto out_dput; 
     1380+       if (newdentry == trap) 
     1381+               goto out_dput; 
     1382+ 
     1383+       old_opaque = ovl_dentry_is_opaque(old); 
     1384+       new_opaque = ovl_dentry_is_opaque(new) || new_type != OVL_PATH_UPPER; 
     1385+ 
     1386+       if (is_dir && !old_opaque && new_opaque) { 
     1387+               err = ovl_set_opaque(olddentry); 
     1388+               if (err) 
     1389+                       goto out_dput; 
     1390+       } 
     1391+ 
     1392+       err = vfs_rename(old_upperdir->d_inode, olddentry, 
     1393+                        new_upperdir->d_inode, newdentry); 
     1394+ 
     1395+       if (err) { 
     1396+               if (new_create && ovl_dentry_is_opaque(new)) 
     1397+                       ovl_whiteout(new_upperdir, new); 
     1398+               if (is_dir && !old_opaque && new_opaque) 
     1399+                       ovl_remove_opaque(olddentry); 
     1400+               goto out_dput; 
     1401+       } 
     1402+ 
     1403+       if (old_type != OVL_PATH_UPPER || old_opaque) 
     1404+               err = ovl_whiteout(old_upperdir, old); 
     1405+       if (is_dir && old_opaque && !new_opaque) 
     1406+               ovl_remove_opaque(olddentry); 
     1407+ 
     1408+       if (old_opaque != new_opaque) 
     1409+               ovl_dentry_set_opaque(old, new_opaque); 
     1410+ 
     1411+       ovl_dentry_version_inc(old->d_parent); 
     1412+       ovl_dentry_version_inc(new->d_parent); 
     1413+ 
     1414+out_dput: 
     1415+       dput(newdentry); 
     1416+out_unlock: 
     1417+       unlock_rename(new_upperdir, old_upperdir); 
     1418+       return err; 
     1419+} 
     1420+ 
     1421+const struct inode_operations ovl_dir_inode_operations = { 
     1422+       .lookup         = ovl_lookup, 
     1423+       .mkdir          = ovl_mkdir, 
     1424+       .symlink        = ovl_symlink, 
     1425+       .unlink         = ovl_unlink, 
     1426+       .rmdir          = ovl_rmdir, 
     1427+       .rename         = ovl_rename, 
     1428+       .link           = ovl_link, 
     1429+       .setattr        = ovl_setattr, 
     1430+       .create         = ovl_create, 
     1431+       .mknod          = ovl_mknod, 
     1432+       .permission     = ovl_permission, 
     1433+       .getattr        = ovl_dir_getattr, 
     1434+       .setxattr       = ovl_setxattr, 
     1435+       .getxattr       = ovl_getxattr, 
     1436+       .listxattr      = ovl_listxattr, 
     1437+       .removexattr    = ovl_removexattr, 
     1438+}; 
     1439--- /dev/null 
     1440+++ b/fs/overlayfs/inode.c 
     1441@@ -0,0 +1,384 @@ 
     1442+/* 
     1443+ * 
     1444+ * Copyright (C) 2011 Novell Inc. 
     1445+ * 
     1446+ * This program is free software; you can redistribute it and/or modify it 
     1447+ * under the terms of the GNU General Public License version 2 as published by 
     1448+ * the Free Software Foundation. 
     1449+ */ 
     1450+ 
     1451+#include <linux/fs.h> 
     1452+#include <linux/slab.h> 
     1453+#include <linux/xattr.h> 
     1454+#include "overlayfs.h" 
     1455+ 
     1456+int ovl_setattr(struct dentry *dentry, struct iattr *attr) 
     1457+{ 
     1458+       struct dentry *upperdentry; 
     1459+       int err; 
     1460+ 
     1461+       if ((attr->ia_valid & ATTR_SIZE) && !ovl_dentry_upper(dentry)) 
     1462+               err = ovl_copy_up_truncate(dentry, attr->ia_size); 
     1463+       else 
     1464+               err = ovl_copy_up(dentry); 
     1465+       if (err) 
     1466+               return err; 
     1467+ 
     1468+       upperdentry = ovl_dentry_upper(dentry); 
     1469+ 
     1470+       if (attr->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID)) 
     1471+               attr->ia_valid &= ~ATTR_MODE; 
     1472+ 
     1473+       mutex_lock(&upperdentry->d_inode->i_mutex); 
     1474+       err = notify_change(upperdentry, attr); 
     1475+       mutex_unlock(&upperdentry->d_inode->i_mutex); 
     1476+ 
     1477+       return err; 
     1478+} 
     1479+ 
     1480+static int ovl_getattr(struct vfsmount *mnt, struct dentry *dentry, 
     1481+                        struct kstat *stat) 
     1482+{ 
     1483+       struct path realpath; 
     1484+ 
     1485+       ovl_path_real(dentry, &realpath); 
     1486+       return vfs_getattr(realpath.mnt, realpath.dentry, stat); 
     1487+} 
     1488+ 
     1489+int ovl_permission(struct inode *inode, int mask, unsigned int flags) 
    16481490+{ 
    16491491+       struct ovl_entry *oe; 
     
    16741516+       } 
    16751517+ 
    1676 +       realdentry = ovl_upperdentry_dereference(oe); 
    1677 +       is_upper = true; 
    1678 +       if (!realdentry) { 
    1679 +               realdentry = oe->lowerdentry; 
    1680 +               is_upper = false; 
    1681 +       } 
     1518+       realdentry = ovl_entry_real(oe, &is_upper); 
    16821519+ 
    16831520+       /* Careful in RCU walk mode */ 
     
    16851522+       if (!realinode) { 
    16861523+               WARN_ON(!(flags & IPERM_FLAG_RCU)); 
    1687 +               return -ENOENT; 
     1524+               err = -ENOENT; 
     1525+               goto out_dput; 
    16881526+       } 
    16891527+ 
     
    16941532+                * Writes will always be redirected to upper layer, so 
    16951533+                * ignore lower layer being read-only. 
     1534+                * 
     1535+                * If the overlay itself is read-only then proceed 
     1536+                * with the permission check, don't return EROFS. 
     1537+                * This will only happen if this is the lower layer of 
     1538+                * another overlayfs. 
     1539+                * 
     1540+                * If upper fs becomes read-only after the overlay was 
     1541+                * constructed return EROFS to prevent modification of 
     1542+                * upper layer. 
    16961543+                */ 
    16971544+               err = -EROFS; 
    1698 +               if (is_upper && IS_RDONLY(realinode) && 
     1545+               if (is_upper && !IS_RDONLY(inode) && IS_RDONLY(realinode) && 
    16991546+                   (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))) 
    17001547+                       goto out_dput; 
     
    17181565+} 
    17191566+ 
    1720 +static int ovl_create_object(struct dentry *dentry, int mode, dev_t rdev, 
    1721 +                            const char *link) 
    1722 +{ 
    1723 +       int err; 
    1724 +       struct dentry *newdentry; 
    1725 +       struct dentry *upperdir; 
    1726 +       struct inode *inode; 
    1727 +       struct kstat stat = { 
    1728 +               .mode = mode, 
    1729 +               .rdev = rdev, 
    1730 +       }; 
    1731 + 
    1732 +       err = -ENOMEM; 
    1733 +       inode = ovl_new_inode(dentry->d_sb, mode, dentry->d_fsdata); 
    1734 +       if (!inode) 
    1735 +               goto out; 
    1736 + 
    1737 +       err = ovl_copy_up(dentry->d_parent); 
    1738 +       if (err) 
    1739 +               goto out_iput; 
    1740 + 
    1741 +       upperdir = ovl_dentry_upper(dentry->d_parent); 
    1742 +       mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
    1743 + 
    1744 +       newdentry = ovl_upper_create(upperdir, dentry, &stat, link); 
    1745 +       err = PTR_ERR(newdentry); 
    1746 +       if (IS_ERR(newdentry)) 
    1747 +               goto out_unlock; 
    1748 + 
    1749 +       ovl_dentry_version_inc(dentry->d_parent); 
    1750 +       if (ovl_dentry_is_opaque(dentry) && S_ISDIR(mode)) { 
    1751 +               err = ovl_set_opaque(newdentry); 
    1752 +               if (err) { 
    1753 +                       vfs_rmdir(upperdir->d_inode, newdentry); 
    1754 +                       ovl_whiteout(upperdir, dentry); 
    1755 +                       goto out_dput; 
    1756 +               } 
    1757 +       } 
    1758 +       ovl_dentry_update(dentry, newdentry); 
    1759 +       d_instantiate(dentry, inode); 
    1760 +       inode = NULL; 
    1761 +       newdentry = NULL; 
    1762 +       err = 0; 
    1763 + 
    1764 +out_dput: 
    1765 +       dput(newdentry); 
    1766 +out_unlock: 
    1767 +       mutex_unlock(&upperdir->d_inode->i_mutex); 
    1768 +out_iput: 
    1769 +       iput(inode); 
    1770 +out: 
    1771 +       return err; 
    1772 +} 
    1773 + 
    1774 +static int ovl_create(struct inode *dir, struct dentry *dentry, int mode, 
    1775 +                       struct nameidata *nd) 
    1776 +{ 
    1777 +       return ovl_create_object(dentry, (mode & 07777) | S_IFREG, 0, NULL); 
    1778 +} 
    1779 + 
    1780 +static int ovl_mkdir(struct inode *dir, struct dentry *dentry, int mode) 
    1781 +{ 
    1782 +       return ovl_create_object(dentry, (mode & 07777) | S_IFDIR, 0, NULL); 
    1783 +} 
    1784 + 
    1785 +static int ovl_mknod(struct inode *dir, struct dentry *dentry, int mode, 
    1786 +                      dev_t rdev) 
    1787 +{ 
    1788 +       return ovl_create_object(dentry, mode, rdev, NULL); 
    1789 +} 
    1790 + 
    1791 +static int ovl_symlink(struct inode *dir, struct dentry *dentry, 
    1792 +                        const char *link) 
    1793 +{ 
    1794 +       return ovl_create_object(dentry, S_IFLNK, 0, link); 
    1795 +} 
    17961567+ 
    17971568+struct ovl_link_data { 
     
    18621633+} 
    18631634+ 
    1864 +static int ovl_do_remove(struct dentry *dentry, bool is_dir) 
    1865 +{ 
    1866 +       int err; 
    1867 +       enum ovl_path_type type; 
    1868 +       struct path realpath; 
    1869 +       struct dentry *upperdir; 
    1870 + 
    1871 +       err = ovl_copy_up(dentry->d_parent); 
    1872 +       if (err) 
    1873 +               return err; 
    1874 + 
    1875 +       upperdir = ovl_dentry_upper(dentry->d_parent); 
    1876 +       mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
    1877 +       type = ovl_path_real(dentry, &realpath); 
    1878 +       if (type != OVL_PATH_LOWER) { 
    1879 +               err = -ESTALE; 
    1880 +               if (realpath.dentry->d_parent != upperdir) 
    1881 +                       goto out_d_drop; 
    1882 + 
    1883 +               if (is_dir) 
    1884 +                       err = vfs_rmdir(upperdir->d_inode, realpath.dentry); 
    1885 +               else 
    1886 +                       err = vfs_unlink(upperdir->d_inode, realpath.dentry); 
    1887 +               if (err) 
    1888 +                       goto out_d_drop; 
    1889 + 
    1890 +               ovl_dentry_version_inc(dentry->d_parent); 
    1891 +       } 
    1892 + 
    1893 +       if (type != OVL_PATH_UPPER || ovl_dentry_is_opaque(dentry)) 
    1894 +               err = ovl_whiteout(upperdir, dentry); 
    1895 + 
    1896 +       /* 
    1897 +        * Keeping this dentry hashed would mean having to release 
    1898 +        * upperpath/lowerpath, which could only be done if we are the 
    1899 +        * sole user of this dentry.  Too tricky...  Just unhash for 
    1900 +        * now. 
    1901 +        */ 
    1902 +out_d_drop: 
    1903 +       d_drop(dentry); 
    1904 +       mutex_unlock(&upperdir->d_inode->i_mutex); 
    1905 + 
    1906 +       return err; 
    1907 +} 
    1908 + 
    1909 +static int ovl_unlink(struct inode *dir, struct dentry *dentry) 
    1910 +{ 
    1911 +       return ovl_do_remove(dentry, false); 
    1912 +} 
    1913 + 
    1914 +static int ovl_check_empty_dir(struct dentry *dentry, struct list_head *list) 
    1915 +{ 
    1916 +       int err; 
    1917 +       struct path lowerpath; 
    1918 +       struct path upperpath; 
    1919 +       struct ovl_cache_entry *p; 
    1920 +       struct ovl_readdir_data rdd = { .list = list }; 
    1921 + 
    1922 +       ovl_path_upper(dentry, &upperpath); 
    1923 +       ovl_path_lower(dentry, &lowerpath); 
    1924 + 
    1925 +       err = ovl_dir_read_merged(&upperpath, &lowerpath, &rdd); 
    1926 +       if (err) 
    1927 +               return err; 
    1928 + 
    1929 +       err = 0; 
    1930 + 
    1931 +       list_for_each_entry(p, list, l_node) { 
    1932 +               if (p->is_whiteout) 
    1933 +                       continue; 
    1934 + 
    1935 +               if (p->name[0] == '.') { 
    1936 +                       if (p->len == 1) 
    1937 +                               continue; 
    1938 +                       if (p->len == 2 && p->name[1] == '.') 
    1939 +                               continue; 
    1940 +               } 
    1941 +               err = -ENOTEMPTY; 
    1942 +               break; 
    1943 +       } 
    1944 + 
    1945 +       return err; 
    1946 +} 
    1947 + 
    1948 +static int ovl_remove_whiteouts(struct dentry *dir, struct list_head *list) 
    1949 +{ 
    1950 +       struct path upperpath; 
    1951 +       struct dentry *upperdir; 
    1952 +       struct ovl_cache_entry *p; 
    1953 +       const struct cred *old_cred; 
    1954 +       struct cred *override_cred; 
    1955 +       int ret = 0; 
    1956 + 
    1957 +       ovl_path_upper(dir, &upperpath); 
    1958 +       upperdir = upperpath.dentry; 
    1959 + 
    1960 +       override_cred = prepare_creds(); 
    1961 +       if (!override_cred) 
    1962 +               return -ENOMEM; 
    1963 + 
    1964 +       /* 
    1965 +        * CAP_DAC_OVERRIDE for lookup and unlink 
    1966 +        */ 
    1967 +       cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 
    1968 +       old_cred = override_creds(override_cred); 
    1969 + 
    1970 +       mutex_lock(&upperdir->d_inode->i_mutex); 
    1971 +       list_for_each_entry(p, list, l_node) { 
    1972 +               if (p->is_whiteout) { 
    1973 +                       struct dentry *dentry; 
    1974 + 
    1975 +                       dentry = lookup_one_len(p->name, upperdir, p->len); 
    1976 +                       if (IS_ERR(dentry)) { 
    1977 +                               ret = PTR_ERR(dentry); 
    1978 +                               break; 
    1979 +                       } 
    1980 +                       ret = vfs_unlink(upperdir->d_inode, dentry); 
    1981 +                       dput(dentry); 
    1982 +                       if (ret) 
    1983 +                               break; 
    1984 +               } 
    1985 +       } 
    1986 +       mutex_unlock(&upperdir->d_inode->i_mutex); 
    1987 + 
    1988 +       revert_creds(old_cred); 
    1989 +       put_cred(override_cred); 
    1990 + 
    1991 +       return ret; 
    1992 +} 
    1993 + 
    1994 +static int ovl_check_empty_and_clear(struct dentry *dentry, 
    1995 +                                    enum ovl_path_type type) 
    1996 +{ 
    1997 +       int err; 
    1998 +       LIST_HEAD(list); 
    1999 + 
    2000 +       err = ovl_check_empty_dir(dentry, &list); 
    2001 +       if (!err && type == OVL_PATH_MERGE) 
    2002 +               err = ovl_remove_whiteouts(dentry, &list); 
    2003 + 
    2004 +       ovl_cache_free(&list); 
    2005 + 
    2006 +       return err; 
    2007 +} 
    2008 + 
    2009 +static int ovl_rmdir(struct inode *dir, struct dentry *dentry) 
    2010 +{ 
    2011 +       int err; 
    2012 +       enum ovl_path_type type; 
    2013 + 
    2014 +       type = ovl_path_type(dentry); 
    2015 +       if (type != OVL_PATH_UPPER) { 
    2016 +               err = ovl_check_empty_and_clear(dentry, type); 
    2017 +               if (err) 
    2018 +                       return err; 
    2019 +       } 
    2020 + 
    2021 +       return ovl_do_remove(dentry, true); 
    2022 +} 
    2023 + 
    2024 +static int ovl_link(struct dentry *old, struct inode *newdir, 
    2025 +                   struct dentry *new) 
    2026 +{ 
    2027 +       int err; 
    2028 +       struct dentry *olddentry; 
    2029 +       struct dentry *newdentry; 
    2030 +       struct dentry *upperdir; 
    2031 + 
    2032 +       err = ovl_copy_up(old); 
    2033 +       if (err) 
    2034 +               goto out; 
    2035 + 
    2036 +       err = ovl_copy_up(new->d_parent); 
    2037 +       if (err) 
    2038 +               goto out; 
    2039 + 
    2040 +       upperdir = ovl_dentry_upper(new->d_parent); 
    2041 +       mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
    2042 +       newdentry = ovl_lookup_create(upperdir, new); 
    2043 +       err = PTR_ERR(newdentry); 
    2044 +       if (IS_ERR(newdentry)) 
    2045 +               goto out_unlock; 
    2046 + 
    2047 +       olddentry = ovl_dentry_upper(old); 
    2048 +       err = vfs_link(olddentry, upperdir->d_inode, newdentry); 
    2049 +       if (!err) { 
    2050 +               ovl_dentry_version_inc(new->d_parent); 
    2051 +               ovl_dentry_update(new, newdentry); 
    2052 + 
    2053 +               ihold(old->d_inode); 
    2054 +               d_instantiate(new, old->d_inode); 
    2055 +       } else { 
    2056 +               if (ovl_dentry_is_opaque(new)) 
    2057 +                       ovl_whiteout(upperdir, new); 
    2058 +               dput(newdentry); 
    2059 +       } 
    2060 +out_unlock: 
    2061 +       mutex_unlock(&upperdir->d_inode->i_mutex); 
    2062 +out: 
    2063 +       return err; 
    2064 + 
    2065 +} 
    2066 + 
    2067 +static int ovl_rename(struct inode *olddir, struct dentry *old, 
    2068 +                       struct inode *newdir, struct dentry *new) 
    2069 +{ 
    2070 +       int err; 
    2071 +       enum ovl_path_type old_type; 
    2072 +       struct dentry *old_upperdir; 
    2073 +       struct dentry *new_upperdir; 
    2074 +       struct dentry *olddentry; 
    2075 +       struct dentry *newdentry; 
    2076 +       struct dentry *trap; 
    2077 +       bool old_opaque; 
    2078 +       bool new_opaque; 
    2079 +       bool is_dir = S_ISDIR(old->d_inode->i_mode); 
    2080 + 
    2081 +       /* Don't copy up directory trees */ 
    2082 +       old_type = ovl_path_type(old); 
    2083 +       if (old_type != OVL_PATH_UPPER && is_dir) 
    2084 +               return -EXDEV; 
    2085 + 
    2086 +       if (new->d_inode) { 
    2087 +               enum ovl_path_type new_type; 
    2088 + 
    2089 +               new_type = ovl_path_type(new); 
    2090 + 
    2091 +               if (new_type == OVL_PATH_LOWER && old_type == OVL_PATH_LOWER) { 
    2092 +                       if (ovl_dentry_lower(old)->d_inode == 
    2093 +                           ovl_dentry_lower(new)->d_inode) 
    2094 +                               return 0; 
    2095 +               } 
    2096 +               if (new_type != OVL_PATH_LOWER && old_type != OVL_PATH_LOWER) { 
    2097 +                       if (ovl_dentry_upper(old)->d_inode == 
    2098 +                           ovl_dentry_upper(new)->d_inode) 
    2099 +                               return 0; 
    2100 +               } 
    2101 + 
    2102 +               if (new_type != OVL_PATH_UPPER && 
    2103 +                   S_ISDIR(new->d_inode->i_mode)) { 
    2104 +                       err = ovl_check_empty_and_clear(new, new_type); 
    2105 +                       if (err) 
    2106 +                               return err; 
    2107 +               } 
    2108 +       } 
    2109 + 
    2110 +       err = ovl_copy_up(old); 
    2111 +       if (err) 
    2112 +               return err; 
    2113 + 
    2114 +       err = ovl_copy_up(new->d_parent); 
    2115 +       if (err) 
    2116 +               return err; 
    2117 + 
    2118 +       old_upperdir = ovl_dentry_upper(old->d_parent); 
    2119 +       new_upperdir = ovl_dentry_upper(new->d_parent); 
    2120 + 
    2121 +       trap = lock_rename(new_upperdir, old_upperdir); 
    2122 + 
    2123 +       olddentry = ovl_dentry_upper(old); 
    2124 +       newdentry = ovl_dentry_upper(new); 
    2125 +       if (newdentry) { 
    2126 +               dget(newdentry); 
    2127 +       } else { 
    2128 +               newdentry = ovl_lookup_create(new_upperdir, new); 
    2129 +               err = PTR_ERR(newdentry); 
    2130 +               if (IS_ERR(newdentry)) 
    2131 +                       goto out_unlock; 
    2132 +       } 
    2133 + 
    2134 +       err = -ESTALE; 
    2135 +       if (olddentry->d_parent != old_upperdir) 
    2136 +               goto out_dput; 
    2137 +       if (newdentry->d_parent != new_upperdir) 
    2138 +               goto out_dput; 
    2139 +       if (olddentry == trap) 
    2140 +               goto out_dput; 
    2141 +       if (newdentry == trap) 
    2142 +               goto out_dput; 
    2143 + 
    2144 +       old_opaque = ovl_dentry_is_opaque(old); 
    2145 +       new_opaque = ovl_dentry_is_opaque(new) || 
    2146 +               ovl_path_type(new) != OVL_PATH_UPPER; 
    2147 + 
    2148 +       if (is_dir && !old_opaque && new_opaque) { 
    2149 +               err = ovl_set_opaque(olddentry); 
    2150 +               if (err) 
    2151 +                       goto out_dput; 
    2152 +       } 
    2153 + 
    2154 +       err = vfs_rename(old_upperdir->d_inode, olddentry, 
    2155 +                        new_upperdir->d_inode, newdentry); 
    2156 + 
    2157 +       if (err) { 
    2158 +               if (ovl_dentry_is_opaque(new)) 
    2159 +                       ovl_whiteout(new_upperdir, new); 
    2160 +               if (is_dir && !old_opaque && new_opaque) 
    2161 +                       ovl_remove_opaque(olddentry); 
    2162 +               goto out_dput; 
    2163 +       } 
    2164 + 
    2165 +       if (old_type != OVL_PATH_UPPER || old_opaque) 
    2166 +               err = ovl_whiteout(old_upperdir, old); 
    2167 +       if (is_dir && old_opaque && !new_opaque) 
    2168 +               ovl_remove_opaque(olddentry); 
    2169 + 
    2170 +       if (old_opaque != new_opaque) 
    2171 +               ovl_dentry_set_opaque(old, new_opaque); 
    2172 + 
    2173 +       ovl_dentry_version_inc(old->d_parent); 
    2174 +       ovl_dentry_version_inc(new->d_parent); 
    2175 + 
    2176 +out_dput: 
    2177 +       dput(newdentry); 
    2178 +out_unlock: 
    2179 +       unlock_rename(new_upperdir, old_upperdir); 
    2180 +       return err; 
    2181 +} 
    21821635+ 
    21831636+static bool ovl_is_private_xattr(const char *name) 
     
    21861639+} 
    21871640+ 
    2188 +static int ovl_setxattr(struct dentry *dentry, const char *name, 
    2189 +                         const void *value, size_t size, int flags) 
     1641+int ovl_setxattr(struct dentry *dentry, const char *name, 
     1642+                const void *value, size_t size, int flags) 
    21901643+{ 
    21911644+       int err; 
     
    22031656+} 
    22041657+ 
    2205 +static ssize_t ovl_getxattr(struct dentry *dentry, const char *name, 
    2206 +                             void *value, size_t size) 
     1658+ssize_t ovl_getxattr(struct dentry *dentry, const char *name, 
     1659+                    void *value, size_t size) 
    22071660+{ 
    22081661+       if (ovl_path_type(dentry->d_parent) == OVL_PATH_MERGE && 
     
    22131666+} 
    22141667+ 
    2215 +static ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size) 
     1668+ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size) 
    22161669+{ 
    22171670+       ssize_t res; 
     
    22431696+} 
    22441697+ 
    2245 +static int ovl_removexattr(struct dentry *dentry, const char *name) 
     1698+int ovl_removexattr(struct dentry *dentry, const char *name) 
    22461699+{ 
    22471700+       int err; 
     
    23051758+       return vfs_open(&realpath, flags, cred); 
    23061759+} 
    2307 + 
    2308 +static const struct inode_operations ovl_dir_inode_operations = { 
    2309 +       .lookup         = ovl_lookup, 
    2310 +       .mkdir          = ovl_mkdir, 
    2311 +       .symlink        = ovl_symlink, 
    2312 +       .unlink         = ovl_unlink, 
    2313 +       .rmdir          = ovl_rmdir, 
    2314 +       .rename         = ovl_rename, 
    2315 +       .link           = ovl_link, 
    2316 +       .setattr        = ovl_setattr, 
    2317 +       .create         = ovl_create, 
    2318 +       .mknod          = ovl_mknod, 
    2319 +       .permission     = ovl_permission, 
    2320 +       .getattr        = ovl_dir_getattr, 
    2321 +       .setxattr       = ovl_setxattr, 
    2322 +       .getxattr       = ovl_getxattr, 
    2323 +       .listxattr      = ovl_listxattr, 
    2324 +       .removexattr    = ovl_removexattr, 
    2325 +}; 
    23261760+ 
    23271761+static const struct inode_operations ovl_file_inode_operations = { 
     
    23481782+}; 
    23491783+ 
    2350 +static struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, 
    2351 +                                  struct ovl_entry *oe) 
     1784+struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, 
     1785+                           struct ovl_entry *oe) 
    23521786+{ 
    23531787+       struct inode *inode; 
     
    23901824+ 
    23911825+} 
     1826--- /dev/null 
     1827+++ b/fs/overlayfs/overlayfs.h 
     1828@@ -0,0 +1,63 @@ 
     1829+/* 
     1830+ * 
     1831+ * Copyright (C) 2011 Novell Inc. 
     1832+ * 
     1833+ * This program is free software; you can redistribute it and/or modify it 
     1834+ * under the terms of the GNU General Public License version 2 as published by 
     1835+ * the Free Software Foundation. 
     1836+ */ 
     1837+ 
     1838+struct ovl_entry; 
     1839+ 
     1840+enum ovl_path_type { 
     1841+       OVL_PATH_UPPER, 
     1842+       OVL_PATH_MERGE, 
     1843+       OVL_PATH_LOWER, 
     1844+}; 
     1845+ 
     1846+extern const char *ovl_opaque_xattr; 
     1847+extern const char *ovl_whiteout_xattr; 
     1848+extern const struct dentry_operations ovl_dentry_operations; 
     1849+ 
     1850+enum ovl_path_type ovl_path_type(struct dentry *dentry); 
     1851+u64 ovl_dentry_version_get(struct dentry *dentry); 
     1852+void ovl_dentry_version_inc(struct dentry *dentry); 
     1853+void ovl_path_upper(struct dentry *dentry, struct path *path); 
     1854+void ovl_path_lower(struct dentry *dentry, struct path *path); 
     1855+enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path); 
     1856+struct dentry *ovl_dentry_upper(struct dentry *dentry); 
     1857+struct dentry *ovl_dentry_lower(struct dentry *dentry); 
     1858+struct dentry *ovl_dentry_real(struct dentry *dentry); 
     1859+struct dentry *ovl_entry_real(struct ovl_entry *oe, bool *is_upper); 
     1860+bool ovl_dentry_is_opaque(struct dentry *dentry); 
     1861+void ovl_dentry_set_opaque(struct dentry *dentry, bool opaque); 
     1862+bool ovl_is_whiteout(struct dentry *dentry); 
     1863+void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry); 
     1864+struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, 
     1865+                         struct nameidata *nd); 
     1866+ 
     1867+struct dentry *ovl_upper_create(struct dentry *upperdir, struct dentry *dentry, 
     1868+                               struct kstat *stat, const char *link); 
     1869+ 
     1870+/* readdir.c */ 
     1871+extern const struct file_operations ovl_dir_operations; 
     1872+int ovl_check_empty_and_clear(struct dentry *dentry, enum ovl_path_type type); 
     1873+ 
     1874+/* inode.c */ 
     1875+int ovl_setattr(struct dentry *dentry, struct iattr *attr); 
     1876+int ovl_permission(struct inode *inode, int mask, unsigned int flags); 
     1877+int ovl_setxattr(struct dentry *dentry, const char *name, 
     1878+                const void *value, size_t size, int flags); 
     1879+ssize_t ovl_getxattr(struct dentry *dentry, const char *name, 
     1880+                    void *value, size_t size); 
     1881+ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size); 
     1882+int ovl_removexattr(struct dentry *dentry, const char *name); 
     1883+ 
     1884+struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, 
     1885+                           struct ovl_entry *oe); 
     1886+/* dir.c */ 
     1887+extern const struct inode_operations ovl_dir_inode_operations; 
     1888+ 
     1889+/* copy_up.c */ 
     1890+int ovl_copy_up(struct dentry *dentry); 
     1891+int ovl_copy_up_truncate(struct dentry *dentry, loff_t size); 
     1892--- /dev/null 
     1893+++ b/fs/overlayfs/readdir.c 
     1894@@ -0,0 +1,558 @@ 
     1895+/* 
     1896+ * 
     1897+ * Copyright (C) 2011 Novell Inc. 
     1898+ * 
     1899+ * This program is free software; you can redistribute it and/or modify it 
     1900+ * under the terms of the GNU General Public License version 2 as published by 
     1901+ * the Free Software Foundation. 
     1902+ */ 
     1903+ 
     1904+#include <linux/fs.h> 
     1905+#include <linux/slab.h> 
     1906+#include <linux/namei.h> 
     1907+#include <linux/file.h> 
     1908+#include <linux/xattr.h> 
     1909+#include <linux/rbtree.h> 
     1910+#include <linux/security.h> 
     1911+#include "overlayfs.h" 
     1912+ 
     1913+struct ovl_cache_entry { 
     1914+       const char *name; 
     1915+       unsigned int len; 
     1916+       unsigned int type; 
     1917+       u64 ino; 
     1918+       bool is_whiteout; 
     1919+       struct list_head l_node; 
     1920+       struct rb_node node; 
     1921+}; 
     1922+ 
     1923+struct ovl_readdir_data { 
     1924+       struct rb_root *root; 
     1925+       struct list_head *list; 
     1926+       struct list_head *middle; 
     1927+       struct dentry *dir; 
     1928+       int count; 
     1929+       int err; 
     1930+}; 
     1931+ 
     1932+struct ovl_dir_file { 
     1933+       bool is_real; 
     1934+       bool is_cached; 
     1935+       struct list_head cursor; 
     1936+       u64 cache_version; 
     1937+       struct list_head cache; 
     1938+       struct file *realfile; 
     1939+}; 
     1940+ 
     1941+static struct ovl_cache_entry *ovl_cache_entry_from_node(struct rb_node *n) 
     1942+{ 
     1943+       return container_of(n, struct ovl_cache_entry, node); 
     1944+} 
     1945+ 
     1946+static struct ovl_cache_entry *ovl_cache_entry_find(struct rb_root *root, 
     1947+                                                   const char *name, int len) 
     1948+{ 
     1949+       struct rb_node *node = root->rb_node; 
     1950+       int cmp; 
     1951+ 
     1952+       while (node) { 
     1953+               struct ovl_cache_entry *p = ovl_cache_entry_from_node(node); 
     1954+ 
     1955+               cmp = strncmp(name, p->name, len); 
     1956+               if (cmp > 0) 
     1957+                       node = p->node.rb_right; 
     1958+               else if (cmp < 0 || len < p->len) 
     1959+                       node = p->node.rb_left; 
     1960+               else 
     1961+                       return p; 
     1962+       } 
     1963+ 
     1964+       return NULL; 
     1965+} 
     1966+ 
     1967+static struct ovl_cache_entry *ovl_cache_entry_new(const char *name, int len, 
     1968+                                                  u64 ino, unsigned int d_type) 
     1969+{ 
     1970+       struct ovl_cache_entry *p; 
     1971+ 
     1972+       p = kmalloc(sizeof(*p) + len + 1, GFP_KERNEL); 
     1973+       if (p) { 
     1974+               char *name_copy = (char *) (p + 1); 
     1975+               memcpy(name_copy, name, len); 
     1976+               name_copy[len] = '\0'; 
     1977+               p->name = name_copy; 
     1978+               p->len = len; 
     1979+               p->type = d_type; 
     1980+               p->ino = ino; 
     1981+               p->is_whiteout = false; 
     1982+       } 
     1983+ 
     1984+       return p; 
     1985+} 
     1986+ 
     1987+static int ovl_cache_entry_add_rb(struct ovl_readdir_data *rdd, 
     1988+                                 const char *name, int len, u64 ino, 
     1989+                                 unsigned int d_type) 
     1990+{ 
     1991+       struct rb_node **newp = &rdd->root->rb_node; 
     1992+       struct rb_node *parent = NULL; 
     1993+       struct ovl_cache_entry *p; 
     1994+ 
     1995+       while (*newp) { 
     1996+               int cmp; 
     1997+               struct ovl_cache_entry *tmp; 
     1998+ 
     1999+               parent = *newp; 
     2000+               tmp = ovl_cache_entry_from_node(*newp); 
     2001+               cmp = strncmp(name, tmp->name, len); 
     2002+               if (cmp > 0) 
     2003+                       newp = &tmp->node.rb_right; 
     2004+               else if (cmp < 0 || len < tmp->len) 
     2005+                       newp = &tmp->node.rb_left; 
     2006+               else 
     2007+                       return 0; 
     2008+       } 
     2009+ 
     2010+       p = ovl_cache_entry_new(name, len, ino, d_type); 
     2011+       if (p == NULL) 
     2012+               return -ENOMEM; 
     2013+ 
     2014+       list_add_tail(&p->l_node, rdd->list); 
     2015+       rb_link_node(&p->node, parent, newp); 
     2016+       rb_insert_color(&p->node, rdd->root); 
     2017+ 
     2018+       return 0; 
     2019+} 
     2020+ 
     2021+static int ovl_fill_lower(void *buf, const char *name, int namelen, 
     2022+                           loff_t offset, u64 ino, unsigned int d_type) 
     2023+{ 
     2024+       struct ovl_readdir_data *rdd = buf; 
     2025+       struct ovl_cache_entry *p; 
     2026+ 
     2027+       rdd->count++; 
     2028+       p = ovl_cache_entry_find(rdd->root, name, namelen); 
     2029+       if (p) { 
     2030+               list_move_tail(&p->l_node, rdd->middle); 
     2031+       } else { 
     2032+               p = ovl_cache_entry_new(name, namelen, ino, d_type); 
     2033+               if (p == NULL) 
     2034+                       rdd->err = -ENOMEM; 
     2035+               else 
     2036+                       list_add_tail(&p->l_node, rdd->middle); 
     2037+       } 
     2038+ 
     2039+       return rdd->err; 
     2040+} 
     2041+ 
     2042+static void ovl_cache_free(struct list_head *list) 
     2043+{ 
     2044+       struct ovl_cache_entry *p; 
     2045+       struct ovl_cache_entry *n; 
     2046+ 
     2047+       list_for_each_entry_safe(p, n, list, l_node) 
     2048+               kfree(p); 
     2049+ 
     2050+       INIT_LIST_HEAD(list); 
     2051+} 
     2052+ 
     2053+static int ovl_fill_upper(void *buf, const char *name, int namelen, 
     2054+                         loff_t offset, u64 ino, unsigned int d_type) 
     2055+{ 
     2056+       struct ovl_readdir_data *rdd = buf; 
     2057+ 
     2058+       rdd->count++; 
     2059+       return ovl_cache_entry_add_rb(rdd, name, namelen, ino, d_type); 
     2060+} 
     2061+ 
     2062+static inline int ovl_dir_read(struct path *realpath, 
     2063+                              struct ovl_readdir_data *rdd, filldir_t filler) 
     2064+{ 
     2065+       struct file *realfile; 
     2066+       int err; 
     2067+ 
     2068+       realfile = vfs_open(realpath, O_RDONLY | O_DIRECTORY, current_cred()); 
     2069+       if (IS_ERR(realfile)) 
     2070+               return PTR_ERR(realfile); 
     2071+ 
     2072+       do { 
     2073+               rdd->count = 0; 
     2074+               rdd->err = 0; 
     2075+               err = vfs_readdir(realfile, filler, rdd); 
     2076+               if (err >= 0) 
     2077+                       err = rdd->err; 
     2078+       } while (!err && rdd->count); 
     2079+       fput(realfile); 
     2080+ 
     2081+       return 0; 
     2082+} 
     2083+ 
     2084+static void ovl_dir_reset(struct file *file) 
     2085+{ 
     2086+       struct ovl_dir_file *od = file->private_data; 
     2087+       enum ovl_path_type type = ovl_path_type(file->f_path.dentry); 
     2088+ 
     2089+       if (ovl_dentry_version_get(file->f_path.dentry) != od->cache_version) { 
     2090+               list_del_init(&od->cursor); 
     2091+               ovl_cache_free(&od->cache); 
     2092+               od->is_cached = false; 
     2093+       } 
     2094+       WARN_ON(!od->is_real && type != OVL_PATH_MERGE); 
     2095+       if (od->is_real && type == OVL_PATH_MERGE) { 
     2096+               fput(od->realfile); 
     2097+               od->realfile = NULL; 
     2098+               od->is_real = false; 
     2099+       } 
     2100+} 
     2101+ 
     2102+static int ovl_dir_mark_whiteouts(struct ovl_readdir_data *rdd) 
     2103+{ 
     2104+       struct ovl_cache_entry *p; 
     2105+       struct dentry *dentry; 
     2106+       const struct cred *old_cred; 
     2107+       struct cred *override_cred; 
     2108+ 
     2109+       override_cred = prepare_creds(); 
     2110+       if (!override_cred) { 
     2111+               ovl_cache_free(rdd->list); 
     2112+               return -ENOMEM; 
     2113+       } 
     2114+ 
     2115+       /* 
     2116+        * CAP_SYS_ADMIN for getxattr 
     2117+        * CAP_DAC_OVERRIDE for lookup 
     2118+        */ 
     2119+       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     2120+       cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 
     2121+       old_cred = override_creds(override_cred); 
     2122+ 
     2123+       mutex_lock(&rdd->dir->d_inode->i_mutex); 
     2124+       list_for_each_entry(p, rdd->list, l_node) { 
     2125+               if (p->type != DT_LNK) 
     2126+                       continue; 
     2127+ 
     2128+               dentry = lookup_one_len(p->name, rdd->dir, p->len); 
     2129+               if (IS_ERR(dentry)) 
     2130+                       continue; 
     2131+ 
     2132+               p->is_whiteout = ovl_is_whiteout(dentry); 
     2133+               dput(dentry); 
     2134+       } 
     2135+       mutex_unlock(&rdd->dir->d_inode->i_mutex); 
     2136+ 
     2137+       revert_creds(old_cred); 
     2138+       put_cred(override_cred); 
     2139+ 
     2140+       return 0; 
     2141+} 
     2142+ 
     2143+static inline int ovl_dir_read_merged(struct path *upperpath, struct path *lowerpath, 
     2144+                              struct ovl_readdir_data *rdd) 
     2145+{ 
     2146+       int err; 
     2147+       struct rb_root root = RB_ROOT; 
     2148+       struct list_head middle; 
     2149+ 
     2150+       rdd->root = &root; 
     2151+       if (upperpath->dentry) { 
     2152+               rdd->dir = upperpath->dentry; 
     2153+               err = ovl_dir_read(upperpath, rdd, ovl_fill_upper); 
     2154+               if (err) 
     2155+                       goto out; 
     2156+ 
     2157+               err = ovl_dir_mark_whiteouts(rdd); 
     2158+               if (err) 
     2159+                       goto out; 
     2160+       } 
     2161+       /* 
     2162+        * Insert lowerpath entries before upperpath ones, this allows 
     2163+        * offsets to be reasonably constant 
     2164+        */ 
     2165+       list_add(&middle, rdd->list); 
     2166+       rdd->middle = &middle; 
     2167+       err = ovl_dir_read(lowerpath, rdd, ovl_fill_lower); 
     2168+       list_del(&middle); 
     2169+out: 
     2170+       rdd->root = NULL; 
     2171+ 
     2172+       return err; 
     2173+} 
     2174+ 
     2175+static void ovl_seek_cursor(struct ovl_dir_file *od, loff_t pos) 
     2176+{ 
     2177+       struct list_head *l; 
     2178+       loff_t off; 
     2179+ 
     2180+       l = od->cache.next; 
     2181+       for (off = 0; off < pos; off++) { 
     2182+               if (l == &od->cache) 
     2183+                       break; 
     2184+               l = l->next; 
     2185+       } 
     2186+       list_move_tail(&od->cursor, l); 
     2187+} 
     2188+ 
     2189+static int ovl_readdir(struct file *file, void *buf, filldir_t filler) 
     2190+{ 
     2191+       struct ovl_dir_file *od = file->private_data; 
     2192+       int res; 
     2193+ 
     2194+       if (!file->f_pos) 
     2195+               ovl_dir_reset(file); 
     2196+ 
     2197+       if (od->is_real) { 
     2198+               res = vfs_readdir(od->realfile, filler, buf); 
     2199+               file->f_pos = od->realfile->f_pos; 
     2200+ 
     2201+               return res; 
     2202+       } 
     2203+ 
     2204+       if (!od->is_cached) { 
     2205+               struct path lowerpath; 
     2206+               struct path upperpath; 
     2207+               struct ovl_readdir_data rdd = { .list = &od->cache }; 
     2208+ 
     2209+               ovl_path_lower(file->f_path.dentry, &lowerpath); 
     2210+               ovl_path_upper(file->f_path.dentry, &upperpath); 
     2211+ 
     2212+               res = ovl_dir_read_merged(&upperpath, &lowerpath, &rdd); 
     2213+               if (res) { 
     2214+                       ovl_cache_free(rdd.list); 
     2215+                       return res; 
     2216+               } 
     2217+ 
     2218+               od->cache_version = ovl_dentry_version_get(file->f_path.dentry); 
     2219+               od->is_cached = true; 
     2220+ 
     2221+               ovl_seek_cursor(od, file->f_pos); 
     2222+       } 
     2223+ 
     2224+       while (od->cursor.next != &od->cache) { 
     2225+               int over; 
     2226+               loff_t off; 
     2227+               struct ovl_cache_entry *p; 
     2228+ 
     2229+               p = list_entry(od->cursor.next, struct ovl_cache_entry, l_node); 
     2230+               off = file->f_pos; 
     2231+               if (!p->is_whiteout) { 
     2232+                       over = filler(buf, p->name, p->len, off, p->ino, p->type); 
     2233+                       if (over) 
     2234+                               break; 
     2235+               } 
     2236+               file->f_pos++; 
     2237+               list_move(&od->cursor, &p->l_node); 
     2238+       } 
     2239+ 
     2240+       return 0; 
     2241+} 
     2242+ 
     2243+static loff_t ovl_dir_llseek(struct file *file, loff_t offset, int origin) 
     2244+{ 
     2245+       loff_t res; 
     2246+       struct ovl_dir_file *od = file->private_data; 
     2247+ 
     2248+       mutex_lock(&file->f_dentry->d_inode->i_mutex); 
     2249+       if (!file->f_pos) 
     2250+               ovl_dir_reset(file); 
     2251+ 
     2252+       if (od->is_real) { 
     2253+               res = vfs_llseek(od->realfile, offset, origin); 
     2254+               file->f_pos = od->realfile->f_pos; 
     2255+       } else { 
     2256+               res = -EINVAL; 
     2257+ 
     2258+               switch (origin) { 
     2259+               case SEEK_CUR: 
     2260+                       offset += file->f_pos; 
     2261+                       break; 
     2262+               case SEEK_SET: 
     2263+                       break; 
     2264+               default: 
     2265+                       goto out_unlock; 
     2266+               } 
     2267+               if (offset < 0) 
     2268+                       goto out_unlock; 
     2269+ 
     2270+               if (offset != file->f_pos) { 
     2271+                       file->f_pos = offset; 
     2272+                       if (od->is_cached) 
     2273+                               ovl_seek_cursor(od, offset); 
     2274+               } 
     2275+               res = offset; 
     2276+       } 
     2277+out_unlock: 
     2278+       mutex_unlock(&file->f_dentry->d_inode->i_mutex); 
     2279+ 
     2280+       return res; 
     2281+} 
     2282+ 
     2283+static int ovl_dir_fsync(struct file *file, int datasync) 
     2284+{ 
     2285+       struct ovl_dir_file *od = file->private_data; 
     2286+ 
     2287+       /* May need to reopen directory if it got copied up */ 
     2288+       if (!od->realfile) { 
     2289+               struct path upperpath; 
     2290+ 
     2291+               ovl_path_upper(file->f_path.dentry, &upperpath); 
     2292+               od->realfile = vfs_open(&upperpath, O_RDONLY, current_cred()); 
     2293+               if (IS_ERR(od->realfile)) 
     2294+                       return PTR_ERR(od->realfile); 
     2295+       } 
     2296+ 
     2297+       return vfs_fsync(od->realfile, datasync); 
     2298+} 
     2299+ 
     2300+static int ovl_dir_release(struct inode *inode, struct file *file) 
     2301+{ 
     2302+       struct ovl_dir_file *od = file->private_data; 
     2303+ 
     2304+       list_del(&od->cursor); 
     2305+       ovl_cache_free(&od->cache); 
     2306+       if (od->realfile) 
     2307+               fput(od->realfile); 
     2308+       kfree(od); 
     2309+ 
     2310+       return 0; 
     2311+} 
     2312+ 
     2313+static int ovl_dir_open(struct inode *inode, struct file *file) 
     2314+{ 
     2315+       struct path realpath; 
     2316+       struct file *realfile; 
     2317+       struct ovl_dir_file *od; 
     2318+       enum ovl_path_type type; 
     2319+ 
     2320+       od = kzalloc(sizeof(struct ovl_dir_file), GFP_KERNEL); 
     2321+       if (!od) 
     2322+               return -ENOMEM; 
     2323+ 
     2324+       type = ovl_path_real(file->f_path.dentry, &realpath); 
     2325+       realfile = vfs_open(&realpath, file->f_flags, current_cred()); 
     2326+       if (IS_ERR(realfile)) { 
     2327+               kfree(od); 
     2328+               return PTR_ERR(realfile); 
     2329+       } 
     2330+       INIT_LIST_HEAD(&od->cache); 
     2331+       INIT_LIST_HEAD(&od->cursor); 
     2332+       od->is_cached = false; 
     2333+       od->realfile = realfile; 
     2334+       od->is_real = (type != OVL_PATH_MERGE); 
     2335+       file->private_data = od; 
     2336+ 
     2337+       return 0; 
     2338+} 
     2339+ 
     2340+const struct file_operations ovl_dir_operations = { 
     2341+       .read           = generic_read_dir, 
     2342+       .open           = ovl_dir_open, 
     2343+       .readdir        = ovl_readdir, 
     2344+       .llseek         = ovl_dir_llseek, 
     2345+       .fsync          = ovl_dir_fsync, 
     2346+       .release        = ovl_dir_release, 
     2347+}; 
     2348+ 
     2349+static int ovl_check_empty_dir(struct dentry *dentry, struct list_head *list) 
     2350+{ 
     2351+       int err; 
     2352+       struct path lowerpath; 
     2353+       struct path upperpath; 
     2354+       struct ovl_cache_entry *p; 
     2355+       struct ovl_readdir_data rdd = { .list = list }; 
     2356+ 
     2357+       ovl_path_upper(dentry, &upperpath); 
     2358+       ovl_path_lower(dentry, &lowerpath); 
     2359+ 
     2360+       err = ovl_dir_read_merged(&upperpath, &lowerpath, &rdd); 
     2361+       if (err) 
     2362+               return err; 
     2363+ 
     2364+       err = 0; 
     2365+ 
     2366+       list_for_each_entry(p, list, l_node) { 
     2367+               if (p->is_whiteout) 
     2368+                       continue; 
     2369+ 
     2370+               if (p->name[0] == '.') { 
     2371+                       if (p->len == 1) 
     2372+                               continue; 
     2373+                       if (p->len == 2 && p->name[1] == '.') 
     2374+                               continue; 
     2375+               } 
     2376+               err = -ENOTEMPTY; 
     2377+               break; 
     2378+       } 
     2379+ 
     2380+       return err; 
     2381+} 
     2382+ 
     2383+static int ovl_remove_whiteouts(struct dentry *dir, struct list_head *list) 
     2384+{ 
     2385+       struct path upperpath; 
     2386+       struct dentry *upperdir; 
     2387+       struct ovl_cache_entry *p; 
     2388+       const struct cred *old_cred; 
     2389+       struct cred *override_cred; 
     2390+       int err; 
     2391+ 
     2392+       ovl_path_upper(dir, &upperpath); 
     2393+       upperdir = upperpath.dentry; 
     2394+ 
     2395+       override_cred = prepare_creds(); 
     2396+       if (!override_cred) 
     2397+               return -ENOMEM; 
     2398+ 
     2399+       /* 
     2400+        * CAP_DAC_OVERRIDE for lookup and unlink 
     2401+        * CAP_SYS_ADMIN for setxattr of "trusted" namespace 
     2402+        * CAP_FOWNER for unlink in sticky directory 
     2403+        */ 
     2404+       cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 
     2405+       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     2406+       cap_raise(override_cred->cap_effective, CAP_FOWNER); 
     2407+       old_cred = override_creds(override_cred); 
     2408+ 
     2409+       err = vfs_setxattr(upperdir, ovl_opaque_xattr, "y", 1, 0); 
     2410+       if (err) 
     2411+               goto out_revert_creds; 
     2412+ 
     2413+       mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
     2414+       list_for_each_entry(p, list, l_node) { 
     2415+               struct dentry *dentry; 
     2416+               int ret; 
     2417+ 
     2418+               if (!p->is_whiteout) 
     2419+                       continue; 
     2420+ 
     2421+               dentry = lookup_one_len(p->name, upperdir, p->len); 
     2422+               if (IS_ERR(dentry)) { 
     2423+                       printk(KERN_WARNING "overlayfs: failed to lookup whiteout %.*s: %li\n", p->len, p->name, PTR_ERR(dentry)); 
     2424+                       continue; 
     2425+               } 
     2426+               ret = vfs_unlink(upperdir->d_inode, dentry); 
     2427+               dput(dentry); 
     2428+               if (ret) 
     2429+                       printk(KERN_WARNING "overlayfs: failed to unlink whiteout %.*s: %i\n", p->len, p->name, ret); 
     2430+       } 
     2431+       mutex_unlock(&upperdir->d_inode->i_mutex); 
     2432+ 
     2433+out_revert_creds: 
     2434+       revert_creds(old_cred); 
     2435+       put_cred(override_cred); 
     2436+ 
     2437+       return err; 
     2438+} 
     2439+ 
     2440+int ovl_check_empty_and_clear(struct dentry *dentry, enum ovl_path_type type) 
     2441+{ 
     2442+       int err; 
     2443+       LIST_HEAD(list); 
     2444+ 
     2445+       err = ovl_check_empty_dir(dentry, &list); 
     2446+       if (!err && type == OVL_PATH_MERGE) 
     2447+               err = ovl_remove_whiteouts(dentry, &list); 
     2448+ 
     2449+       ovl_cache_free(&list); 
     2450+ 
     2451+       return err; 
     2452+} 
     2453--- /dev/null 
     2454+++ b/fs/overlayfs/super.c 
     2455@@ -0,0 +1,656 @@ 
     2456+/* 
     2457+ * 
     2458+ * Copyright (C) 2011 Novell Inc. 
     2459+ * 
     2460+ * This program is free software; you can redistribute it and/or modify it 
     2461+ * under the terms of the GNU General Public License version 2 as published by 
     2462+ * the Free Software Foundation. 
     2463+ */ 
     2464+ 
     2465+#include <linux/fs.h> 
     2466+#include <linux/namei.h> 
     2467+#include <linux/xattr.h> 
     2468+#include <linux/security.h> 
     2469+#include <linux/mount.h> 
     2470+#include <linux/slab.h> 
     2471+#include <linux/parser.h> 
     2472+#include <linux/module.h> 
     2473+#include <linux/seq_file.h> 
     2474+#include "overlayfs.h" 
     2475+ 
     2476+MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 
     2477+MODULE_DESCRIPTION("Overlay filesystem"); 
     2478+MODULE_LICENSE("GPL"); 
     2479+ 
     2480+struct ovl_config { 
     2481+       char *lowerdir; 
     2482+       char *upperdir; 
     2483+}; 
     2484+ 
     2485+/* private information held for overlayfs's superblock */ 
     2486+struct ovl_fs { 
     2487+       struct vfsmount *upper_mnt; 
     2488+       struct vfsmount *lower_mnt; 
     2489+       /* pathnames of lower and upper dirs, for show_options */ 
     2490+       struct ovl_config config; 
     2491+}; 
     2492+ 
     2493+/* private information held for every overlayfs dentry */ 
     2494+struct ovl_entry { 
     2495+       /* 
     2496+        * Keep "double reference" on upper dentries, so that 
     2497+        * d_delete() doesn't think it's OK to reset d_inode to NULL. 
     2498+        */ 
     2499+       struct dentry *__upperdentry; 
     2500+       struct dentry *lowerdentry; 
     2501+       union { 
     2502+               struct { 
     2503+                       u64 version; 
     2504+                       bool opaque; 
     2505+               }; 
     2506+               struct rcu_head rcu; 
     2507+       }; 
     2508+}; 
     2509+ 
     2510+const char *ovl_whiteout_xattr = "trusted.overlay.whiteout"; 
     2511+const char *ovl_opaque_xattr = "trusted.overlay.opaque"; 
     2512+ 
     2513+ 
     2514+enum ovl_path_type ovl_path_type(struct dentry *dentry) 
     2515+{ 
     2516+       struct ovl_entry *oe = dentry->d_fsdata; 
     2517+ 
     2518+       if (oe->__upperdentry) { 
     2519+               if (oe->lowerdentry && S_ISDIR(dentry->d_inode->i_mode)) 
     2520+                       return OVL_PATH_MERGE; 
     2521+               else 
     2522+                       return OVL_PATH_UPPER; 
     2523+       } else { 
     2524+               return OVL_PATH_LOWER; 
     2525+       } 
     2526+} 
     2527+ 
     2528+static struct dentry *ovl_upperdentry_dereference(struct ovl_entry *oe) 
     2529+{ 
     2530+       struct dentry *upperdentry = ACCESS_ONCE(oe->__upperdentry); 
     2531+       smp_read_barrier_depends(); 
     2532+       return upperdentry; 
     2533+} 
     2534+ 
     2535+void ovl_path_upper(struct dentry *dentry, struct path *path) 
     2536+{ 
     2537+       struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 
     2538+       struct ovl_entry *oe = dentry->d_fsdata; 
     2539+ 
     2540+       path->mnt = ofs->upper_mnt; 
     2541+       path->dentry = ovl_upperdentry_dereference(oe); 
     2542+} 
     2543+ 
     2544+void ovl_path_lower(struct dentry *dentry, struct path *path) 
     2545+{ 
     2546+       struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 
     2547+       struct ovl_entry *oe = dentry->d_fsdata; 
     2548+ 
     2549+       path->mnt = ofs->lower_mnt; 
     2550+       path->dentry = oe->lowerdentry; 
     2551+} 
     2552+ 
     2553+enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path) 
     2554+{ 
     2555+ 
     2556+       enum ovl_path_type type = ovl_path_type(dentry); 
     2557+ 
     2558+       if (type == OVL_PATH_LOWER) 
     2559+               ovl_path_lower(dentry, path); 
     2560+       else 
     2561+               ovl_path_upper(dentry, path); 
     2562+ 
     2563+       return type; 
     2564+} 
     2565+ 
     2566+struct dentry *ovl_dentry_upper(struct dentry *dentry) 
     2567+{ 
     2568+       struct ovl_entry *oe = dentry->d_fsdata; 
     2569+ 
     2570+       return ovl_upperdentry_dereference(oe); 
     2571+} 
     2572+ 
     2573+struct dentry *ovl_dentry_lower(struct dentry *dentry) 
     2574+{ 
     2575+       struct ovl_entry *oe = dentry->d_fsdata; 
     2576+ 
     2577+       return oe->lowerdentry; 
     2578+} 
     2579+ 
     2580+struct dentry *ovl_dentry_real(struct dentry *dentry) 
     2581+{ 
     2582+       struct ovl_entry *oe = dentry->d_fsdata; 
     2583+       struct dentry *realdentry; 
     2584+ 
     2585+       realdentry = ovl_upperdentry_dereference(oe); 
     2586+       if (!realdentry) 
     2587+               realdentry = oe->lowerdentry; 
     2588+ 
     2589+       return realdentry; 
     2590+} 
     2591+ 
     2592+struct dentry *ovl_entry_real(struct ovl_entry *oe, bool *is_upper) 
     2593+{ 
     2594+       struct dentry *realdentry; 
     2595+ 
     2596+       realdentry = ovl_upperdentry_dereference(oe); 
     2597+       if (realdentry) { 
     2598+               *is_upper = true; 
     2599+       } else { 
     2600+               realdentry = oe->lowerdentry; 
     2601+               *is_upper = false; 
     2602+       } 
     2603+       return realdentry; 
     2604+} 
     2605+ 
     2606+bool ovl_dentry_is_opaque(struct dentry *dentry) 
     2607+{ 
     2608+       struct ovl_entry *oe = dentry->d_fsdata; 
     2609+       return oe->opaque; 
     2610+} 
     2611+ 
     2612+void ovl_dentry_set_opaque(struct dentry *dentry, bool opaque) 
     2613+{ 
     2614+       struct ovl_entry *oe = dentry->d_fsdata; 
     2615+       oe->opaque = opaque; 
     2616+} 
     2617+ 
     2618+void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry) 
     2619+{ 
     2620+       struct ovl_entry *oe = dentry->d_fsdata; 
     2621+ 
     2622+       WARN_ON(!mutex_is_locked(&upperdentry->d_parent->d_inode->i_mutex)); 
     2623+       WARN_ON(oe->__upperdentry); 
     2624+       BUG_ON(!upperdentry->d_inode); 
     2625+       smp_wmb(); 
     2626+       oe->__upperdentry = dget(upperdentry); 
     2627+} 
     2628+ 
     2629+void ovl_dentry_version_inc(struct dentry *dentry) 
     2630+{ 
     2631+       struct ovl_entry *oe = dentry->d_fsdata; 
     2632+ 
     2633+       WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex)); 
     2634+       oe->version++; 
     2635+} 
     2636+ 
     2637+u64 ovl_dentry_version_get(struct dentry *dentry) 
     2638+{ 
     2639+       struct ovl_entry *oe = dentry->d_fsdata; 
     2640+ 
     2641+       WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex)); 
     2642+       return oe->version; 
     2643+} 
     2644+ 
     2645+bool ovl_is_whiteout(struct dentry *dentry) 
     2646+{ 
     2647+       int res; 
     2648+       char val; 
     2649+ 
     2650+       if (!dentry) 
     2651+               return false; 
     2652+       if (!dentry->d_inode) 
     2653+               return false; 
     2654+       if (!S_ISLNK(dentry->d_inode->i_mode)) 
     2655+               return false; 
     2656+ 
     2657+       res = vfs_getxattr(dentry, ovl_whiteout_xattr, &val, 1); 
     2658+       if (res == 1 && val == 'y') 
     2659+               return true; 
     2660+ 
     2661+       return false; 
     2662+} 
     2663+ 
     2664+static bool ovl_is_opaquedir(struct dentry *dentry) 
     2665+{ 
     2666+       int res; 
     2667+       char val; 
     2668+ 
     2669+       if (!S_ISDIR(dentry->d_inode->i_mode)) 
     2670+               return false; 
     2671+ 
     2672+       res = vfs_getxattr(dentry, ovl_opaque_xattr, &val, 1); 
     2673+       if (res == 1 && val == 'y') 
     2674+               return true; 
     2675+ 
     2676+       return false; 
     2677+} 
     2678+ 
     2679+static void ovl_entry_free(struct rcu_head *head) 
     2680+{ 
     2681+       struct ovl_entry *oe = container_of(head, struct ovl_entry, rcu); 
     2682+       kfree(oe); 
     2683+} 
     2684+ 
     2685+static void ovl_dentry_release(struct dentry *dentry) 
     2686+{ 
     2687+       struct ovl_entry *oe = dentry->d_fsdata; 
     2688+ 
     2689+       if (oe) { 
     2690+               dput(oe->__upperdentry); 
     2691+               dput(oe->__upperdentry); 
     2692+               dput(oe->lowerdentry); 
     2693+               call_rcu(&oe->rcu, ovl_entry_free); 
     2694+       } 
     2695+} 
     2696+ 
     2697+const struct dentry_operations ovl_dentry_operations = { 
     2698+       .d_release = ovl_dentry_release, 
     2699+}; 
     2700+ 
     2701+static struct ovl_entry *ovl_alloc_entry(void) 
     2702+{ 
     2703+       return kzalloc(sizeof(struct ovl_entry), GFP_KERNEL); 
     2704+} 
     2705+ 
     2706+static inline struct dentry *ovl_lookup_real(struct dentry *dir, struct qstr *name) 
     2707+{ 
     2708+       struct dentry *dentry; 
     2709+ 
     2710+       mutex_lock(&dir->d_inode->i_mutex); 
     2711+       dentry = lookup_one_len(name->name, dir, name->len); 
     2712+       mutex_unlock(&dir->d_inode->i_mutex); 
     2713+ 
     2714+       if (IS_ERR(dentry)) { 
     2715+               if (PTR_ERR(dentry) == -ENOENT) 
     2716+                       dentry = NULL; 
     2717+       } else if (!dentry->d_inode) { 
     2718+               dput(dentry); 
     2719+               dentry = NULL; 
     2720+       } 
     2721+       return dentry; 
     2722+} 
     2723+ 
     2724+static int ovl_do_lookup(struct dentry *dentry) 
     2725+{ 
     2726+       struct ovl_entry *oe; 
     2727+       struct dentry *upperdir; 
     2728+       struct dentry *lowerdir; 
     2729+       struct dentry *upperdentry = NULL; 
     2730+       struct dentry *lowerdentry = NULL; 
     2731+       struct inode *inode = NULL; 
     2732+       int err; 
     2733+ 
     2734+       err = -ENOMEM; 
     2735+       oe = ovl_alloc_entry(); 
     2736+       if (!oe) 
     2737+               goto out; 
     2738+ 
     2739+       upperdir = ovl_dentry_upper(dentry->d_parent); 
     2740+       lowerdir = ovl_dentry_lower(dentry->d_parent); 
     2741+ 
     2742+       if (upperdir) { 
     2743+               upperdentry = ovl_lookup_real(upperdir, &dentry->d_name); 
     2744+               err = PTR_ERR(upperdentry); 
     2745+               if (IS_ERR(upperdentry)) 
     2746+                       goto out_put_dir; 
     2747+ 
     2748+               if (lowerdir && upperdentry && 
     2749+                   (S_ISLNK(upperdentry->d_inode->i_mode) || 
     2750+                    S_ISDIR(upperdentry->d_inode->i_mode))) { 
     2751+                       const struct cred *old_cred; 
     2752+                       struct cred *override_cred; 
     2753+ 
     2754+                       err = -ENOMEM; 
     2755+                       override_cred = prepare_creds(); 
     2756+                       if (!override_cred) 
     2757+                               goto out_dput_upper; 
     2758+ 
     2759+                       /* CAP_SYS_ADMIN needed for getxattr */ 
     2760+                       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     2761+                       old_cred = override_creds(override_cred); 
     2762+ 
     2763+                       if (ovl_is_opaquedir(upperdentry)) { 
     2764+                               oe->opaque = true; 
     2765+                       } else if (ovl_is_whiteout(upperdentry)) { 
     2766+                               dput(upperdentry); 
     2767+                               upperdentry = NULL; 
     2768+                               oe->opaque = true; 
     2769+                       } 
     2770+                       revert_creds(old_cred); 
     2771+                       put_cred(override_cred); 
     2772+               } 
     2773+       } 
     2774+       if (lowerdir && !oe->opaque) { 
     2775+               lowerdentry = ovl_lookup_real(lowerdir, &dentry->d_name); 
     2776+               err = PTR_ERR(lowerdentry); 
     2777+               if (IS_ERR(lowerdentry)) 
     2778+                       goto out_dput_upper; 
     2779+       } 
     2780+ 
     2781+       if (lowerdentry && upperdentry && 
     2782+           (!S_ISDIR(upperdentry->d_inode->i_mode) || 
     2783+            !S_ISDIR(lowerdentry->d_inode->i_mode))) { 
     2784+               dput(lowerdentry); 
     2785+               lowerdentry = NULL; 
     2786+               oe->opaque = true; 
     2787+       } 
     2788+ 
     2789+       if (lowerdentry || upperdentry) { 
     2790+               struct dentry *realdentry; 
     2791+ 
     2792+               realdentry = upperdentry ? upperdentry : lowerdentry; 
     2793+               err = -ENOMEM; 
     2794+               inode = ovl_new_inode(dentry->d_sb, realdentry->d_inode->i_mode, oe); 
     2795+               if (!inode) 
     2796+                       goto out_dput; 
     2797+       } 
     2798+ 
     2799+       if (upperdentry) 
     2800+               oe->__upperdentry = dget(upperdentry); 
     2801+ 
     2802+       if (lowerdentry) 
     2803+               oe->lowerdentry = lowerdentry; 
     2804+ 
     2805+       dentry->d_fsdata = oe; 
     2806+       dentry->d_op = &ovl_dentry_operations; 
     2807+       d_add(dentry, inode); 
     2808+ 
     2809+       return 0; 
     2810+ 
     2811+out_dput: 
     2812+       dput(lowerdentry); 
     2813+out_dput_upper: 
     2814+       dput(upperdentry); 
     2815+out_put_dir: 
     2816+       kfree(oe); 
     2817+out: 
     2818+       return err; 
     2819+} 
     2820+ 
     2821+struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, 
     2822+                         struct nameidata *nd) 
     2823+{ 
     2824+       int err = ovl_do_lookup(dentry); 
     2825+ 
     2826+       if (err) 
     2827+               return ERR_PTR(err); 
     2828+ 
     2829+       return NULL; 
     2830+} 
    23922831+ 
    23932832+static void ovl_put_super(struct super_block *sb) 
     
    24012840+       mntput(ufs->lower_mnt); 
    24022841+ 
     2842+       kfree(ufs->config.lowerdir); 
     2843+       kfree(ufs->config.upperdir); 
    24032844+       kfree(ufs); 
    24042845+} 
     
    24422883+} 
    24432884+ 
     2885+/** 
     2886+ * ovl_show_options 
     2887+ * 
     2888+ * Prints the mount options for a given superblock. 
     2889+ * Returns zero; does not fail. 
     2890+ */ 
     2891+static int ovl_show_options(struct seq_file *m, struct vfsmount *mnt) 
     2892+{ 
     2893+       struct super_block *sb = mnt->mnt_sb; 
     2894+       struct ovl_fs *ufs = sb->s_fs_info; 
     2895+ 
     2896+       seq_printf(m, ",lowerdir=%s", ufs->config.lowerdir); 
     2897+       seq_printf(m, ",upperdir=%s", ufs->config.upperdir); 
     2898+       return 0; 
     2899+} 
     2900+ 
    24442901+static const struct super_operations ovl_super_operations = { 
    24452902+       .put_super      = ovl_put_super, 
    24462903+       .remount_fs     = ovl_remount_fs, 
    24472904+       .statfs         = ovl_statfs, 
    2448 +}; 
    2449 + 
    2450 +struct ovl_config { 
    2451 +       char *lowerdir; 
    2452 +       char *upperdir; 
     2905+       .show_options   = ovl_show_options, 
    24532906+}; 
    24542907+ 
     
    25102963+       struct ovl_entry *oe; 
    25112964+       struct ovl_fs *ufs; 
    2512 +       struct ovl_config config; 
    25132965+       int err; 
    2514 + 
    2515 +       err = ovl_parse_opt((char *) data, &config); 
    2516 +       if (err) 
    2517 +               goto out; 
    2518 + 
    2519 +       err = -EINVAL; 
    2520 +       if (!config.upperdir || !config.lowerdir) { 
    2521 +               printk(KERN_ERR "overlayfs: missing upperdir or lowerdir\n"); 
    2522 +               goto out_free_config; 
    2523 +       } 
    25242966+ 
    25252967+       err = -ENOMEM; 
    25262968+       ufs = kmalloc(sizeof(struct ovl_fs), GFP_KERNEL); 
    25272969+       if (!ufs) 
     2970+               goto out; 
     2971+ 
     2972+       err = ovl_parse_opt((char *) data, &ufs->config); 
     2973+       if (err) 
     2974+               goto out_free_ufs; 
     2975+ 
     2976+       err = -EINVAL; 
     2977+       if (!ufs->config.upperdir || !ufs->config.lowerdir) { 
     2978+               printk(KERN_ERR "overlayfs: missing upperdir or lowerdir\n"); 
    25282979+               goto out_free_config; 
     2980+       } 
    25292981+ 
    25302982+       oe = ovl_alloc_entry(); 
    25312983+       if (oe == NULL) 
    2532 +               goto out_free_ufs; 
     2984+               goto out_free_config; 
    25332985+ 
    25342986+       root_inode = ovl_new_inode(sb, S_IFDIR, oe); 
     
    25362988+               goto out_free_oe; 
    25372989+ 
    2538 +       err = kern_path(config.upperdir, LOOKUP_FOLLOW, &upperpath); 
     2990+       err = kern_path(ufs->config.upperdir, LOOKUP_FOLLOW, &upperpath); 
    25392991+       if (err) 
    25402992+               goto out_put_root; 
    25412993+ 
    2542 +       err = kern_path(config.lowerdir, LOOKUP_FOLLOW, &lowerpath); 
     2994+       err = kern_path(ufs->config.lowerdir, LOOKUP_FOLLOW, &lowerpath); 
    25432995+       if (err) 
    25442996+               goto out_put_upperpath; 
     
    25483000+           !S_ISDIR(lowerpath.dentry->d_inode->i_mode)) 
    25493001+               goto out_put_lowerpath; 
     3002+ 
     3003+       sb->s_stack_depth = max(upperpath.mnt->mnt_sb->s_stack_depth, 
     3004+                               lowerpath.mnt->mnt_sb->s_stack_depth) + 1; 
     3005+ 
     3006+       err = -EINVAL; 
     3007+       if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 
     3008+               printk(KERN_ERR "overlayfs: maximum fs stacking depth exceeded\n"); 
     3009+               goto out_put_lowerpath; 
     3010+       } 
     3011+ 
    25503012+ 
    25513013+       ufs->upper_mnt = clone_private_mount(&upperpath); 
     
    25633025+       } 
    25643026+ 
     3027+       /* 
     3028+        * Make lower_mnt R/O.  That way fchmod/fchown on lower file 
     3029+        * will fail instead of modifying lower fs. 
     3030+        */ 
     3031+       ufs->lower_mnt->mnt_flags |= MNT_READONLY; 
     3032+ 
     3033+       /* If the upper fs is r/o, we mark overlayfs r/o too */ 
     3034+       if (ufs->upper_mnt->mnt_sb->s_flags & MS_RDONLY) 
     3035+               sb->s_flags |= MS_RDONLY; 
     3036+ 
    25653037+       if (!(sb->s_flags & MS_RDONLY)) { 
    25663038+               err = mnt_want_write(ufs->upper_mnt); 
     
    25773049+       mntput(lowerpath.mnt); 
    25783050+ 
    2579 +       oe->__upperdentry = upperpath.dentry; 
     3051+       oe->__upperdentry = dget(upperpath.dentry); 
    25803052+       oe->lowerdentry = lowerpath.dentry; 
    25813053+ 
     
    26043076+out_free_oe: 
    26053077+       kfree(oe); 
     3078+out_free_config: 
     3079+       kfree(ufs->config.lowerdir); 
     3080+       kfree(ufs->config.upperdir); 
    26063081+out_free_ufs: 
    26073082+       kfree(ufs); 
    2608 +out_free_config: 
    2609 +       kfree(config.lowerdir); 
    2610 +       kfree(config.upperdir); 
    26113083+out: 
    26123084+       return err; 
     
    26383110+module_init(ovl_init); 
    26393111+module_exit(ovl_exit); 
    2640 --- a/fs/Kconfig 
    2641 +++ b/fs/Kconfig 
    2642 @@ -63,6 +63,7 @@ source "fs/quota/Kconfig" 
     3112--- a/fs/splice.c 
     3113+++ b/fs/splice.c 
     3114@@ -1296,6 +1296,7 @@ long do_splice_direct(struct file *in, l 
    26433115  
    2644  source "fs/autofs4/Kconfig" 
    2645  source "fs/fuse/Kconfig" 
    2646 +source "fs/overlayfs/Kconfig" 
     3116        return ret; 
     3117 } 
     3118+EXPORT_SYMBOL(do_splice_direct); 
    26473119  
    2648  config CUSE 
    2649         tristate "Character device in Userspace support" 
    2650 --- a/fs/Makefile 
    2651 +++ b/fs/Makefile 
    2652 @@ -105,6 +105,7 @@ obj-$(CONFIG_QNX4FS_FS)             += qnx4/ 
    2653  obj-$(CONFIG_AUTOFS4_FS)       += autofs4/ 
    2654  obj-$(CONFIG_ADFS_FS)          += adfs/ 
    2655  obj-$(CONFIG_FUSE_FS)          += fuse/ 
    2656 +obj-$(CONFIG_OVERLAYFS_FS)     += overlayfs/ 
    2657  obj-$(CONFIG_UDF_FS)           += udf/ 
    2658  obj-$(CONFIG_SUN_OPENPROMFS)   += openpromfs/ 
    2659  obj-$(CONFIG_OMFS_FS)          += omfs/ 
    2660 --- /dev/null 
    2661 +++ b/fs/overlayfs/Kconfig 
    2662 @@ -0,0 +1,4 @@ 
    2663 +config OVERLAYFS_FS 
    2664 +       tristate "Overlay filesystem support" 
    2665 +       help 
    2666 +         Add support for overlay filesystem. 
    2667 --- /dev/null 
    2668 +++ b/fs/overlayfs/Makefile 
    2669 @@ -0,0 +1,5 @@ 
    2670 +# 
    2671 +# Makefile for the overlay filesystem. 
    2672 +# 
    2673 + 
    2674 +obj-$(CONFIG_OVERLAYFS_FS) += overlayfs.o 
    2675 --- /dev/null 
    2676 +++ b/Documentation/filesystems/overlayfs.txt 
    2677 @@ -0,0 +1,163 @@ 
    2678 +Written by: Neil Brown <neilb@suse.de> 
    2679 + 
    2680 +Overlay Filesystem 
    2681 +================== 
    2682 + 
    2683 +This document describes a prototype for a new approach to providing 
    2684 +overlay-filesystem functionality in Linux (sometimes referred to as 
    2685 +union-filesystems).  An overlay-filesystem tries to present a 
    2686 +filesystem which is the result over overlaying one filesystem on top 
    2687 +of the other. 
    2688 + 
    2689 +The result will inevitably fail to look exactly like a normal 
    2690 +filesystem for various technical reasons.  The expectation is that 
    2691 +many use cases will be able to ignore these differences. 
    2692 + 
    2693 +This approach is 'hybrid' because the objects that appear in the 
    2694 +filesystem do not all appear to belong to that filesystem.  In many 
    2695 +cases an object accessed in the union will be indistinguishable 
    2696 +from accessing the corresponding object from the original filesystem. 
    2697 +This is most obvious from the 'st_dev' field returned by stat(2). 
    2698 + 
    2699 +While directories will report an st_dev from the overlay-filesystem, 
    2700 +all non-directory objects will report an st_dev from the lower or 
    2701 +upper filesystem that is providing the object.  Similarly st_ino will 
    2702 +only be unique when combined with st_dev, and both of these can change 
    2703 +over the lifetime of a non-directory object.  Many applications and 
    2704 +tools ignore these values and will not be affected. 
    2705 + 
    2706 +Upper and Lower 
    2707 +--------------- 
    2708 + 
    2709 +An overlay filesystem combines two filesystems - an 'upper' filesystem 
    2710 +and a 'lower' filesystem.  When a name exists in both filesystems, the 
    2711 +object in the 'upper' filesystem is visible while the object in the 
    2712 +'lower' filesystem is either hidden or, in the case of directories, 
    2713 +merged with the 'upper' object. 
    2714 + 
    2715 +It would be more correct to refer to an upper and lower 'directory 
    2716 +tree' rather than 'filesystem' as it is quite possible for both 
    2717 +directory trees to be in the same filesystem and there is no 
    2718 +requirement that the root of a filesystem be given for either upper or 
    2719 +lower. 
    2720 + 
    2721 +The lower filesystem can be any filesystem supported by Linux and does 
    2722 +not need to be writable.  The lower filesystem can even be another 
    2723 +overlayfs.  The upper filesystem will normally be writable and if it 
    2724 +is it must support the creation of trusted.* extended attributes, and 
    2725 +must provide valid d_type in readdir responses, at least for symbolic 
    2726 +links - so NFS is not suitable. 
    2727 + 
    2728 +A read-only overlay of two read-only filesystems may use any 
    2729 +filesystem type. 
    2730 + 
    2731 +Directories 
    2732 +----------- 
    2733 + 
    2734 +Overlaying mainly involved directories.  If a given name appears in both 
    2735 +upper and lower filesystems and refers to a non-directory in either, 
    2736 +then the lower object is hidden - the name refers only to the upper 
    2737 +object. 
    2738 + 
    2739 +Where both upper and lower objects are directories, a merged directory 
    2740 +is formed. 
    2741 + 
    2742 +At mount time, the two directories given as mount options are combined 
    2743 +into a merged directory.  Then whenever a lookup is requested in such 
    2744 +a merged directory, the lookup is performed in each actual directory 
    2745 +and the combined result is cached in the dentry belonging to the overlay 
    2746 +filesystem.  If both actual lookups find directories, both are stored 
    2747 +and a merged directory is created, otherwise only one is stored: the 
    2748 +upper if it exists, else the lower. 
    2749 + 
    2750 +Only the lists of names from directories are merged.  Other content 
    2751 +such as metadata and extended attributes are reported for the upper 
    2752 +directory only.  These attributes of the lower directory are hidden. 
    2753 + 
    2754 +whiteouts and opaque directories 
    2755 +-------------------------------- 
    2756 + 
    2757 +In order to support rm and rmdir without changing the lower 
    2758 +filesystem, an overlay filesystem needs to record in the upper filesystem 
    2759 +that files have been removed.  This is done using whiteouts and opaque 
    2760 +directories (non-directories are always opaque). 
    2761 + 
    2762 +The overlay filesystem uses extended attributes with a 
    2763 +"trusted.overlay."  prefix to record these details. 
    2764 + 
    2765 +A whiteout is created as a symbolic link with target 
    2766 +"(overlay-whiteout)" and with xattr "trusted.overlay.whiteout" set to "y". 
    2767 +When a whiteout is found in the upper level of a merged directory, any 
    2768 +matching name in the lower level is ignored, and the whiteout itself 
    2769 +is also hidden. 
    2770 + 
    2771 +A directory is made opaque by setting the xattr "trusted.overlay.opaque" 
    2772 +to "y".  Where the upper filesystem contains an opaque directory, any 
    2773 +directory in the lower filesystem with the same name is ignored. 
    2774 + 
    2775 +readdir 
    2776 +------- 
    2777 + 
    2778 +When a 'readdir' request is made on a merged directory, the upper and 
    2779 +lower directories are each read and the name lists merged in the 
    2780 +obvious way (upper is read first, then lower - entries that already 
    2781 +exist are not re-added).  This merged name list is cached in the 
    2782 +'struct file' and so remains as long as the file is kept open.  If the 
    2783 +directory is opened and read by two processes at the same time, they 
    2784 +will each have separate caches.  A seekdir to the start of the 
    2785 +directory (offset 0) followed by a readdir will cause the cache to be 
    2786 +discarded and rebuilt. 
    2787 + 
    2788 +This means that changes to the merged directory do not appear while a 
    2789 +directory is being read.  This is unlikely to be noticed by many 
    2790 +programs. 
    2791 + 
    2792 +seek offsets are assigned sequentially when the directories are read. 
    2793 +Thus if 
    2794 +  - read part of a directory 
    2795 +  - remember an offset, and close the directory 
    2796 +  - re-open the directory some time later 
    2797 +  - seek to the remembered offset 
    2798 + 
    2799 +there may be little correlation between the old and new locations in 
    2800 +the list of filenames, particularly if anything has changed in the 
    2801 +directory. 
    2802 + 
    2803 +Readdir on directories that are not merged is simply handled by the 
    2804 +underlying directory (upper or lower). 
    2805 + 
    2806 + 
    2807 +Non-directories 
    2808 +--------------- 
    2809 + 
    2810 +Objects that are not directories (files, symlinks, device-special 
    2811 +files etc.) are presented either from the upper or lower filesystem as 
    2812 +appropriate.  When a file in the lower filesystem is accessed in a way 
    2813 +the requires write-access, such as opening for write access, changing 
    2814 +some metadata etc., the file is first copied from the lower filesystem 
    2815 +to the upper filesystem (copy_up).  Note that creating a hard-link 
    2816 +also requires copy_up, though of course creation of a symlink does 
    2817 +not. 
    2818 + 
    2819 +The copy_up process first makes sure that the containing directory 
    2820 +exists in the upper filesystem - creating it and any parents as 
    2821 +necessary.  It then creates the object with the same metadata (owner, 
    2822 +mode, mtime, symlink-target etc.) and then if the object is a file, the 
    2823 +data is copied from the lower to the upper filesystem.  Finally any 
    2824 +extended attributes are copied up. 
    2825 + 
    2826 +Once the copy_up is complete, the overlay filesystem simply 
    2827 +provides direct access to the newly created file in the upper 
    2828 +filesystem - future operations on the file are barely noticed by the 
    2829 +overlay filesystem (though an operation on the name of the file such as 
    2830 +rename or unlink will of course be noticed and handled). 
    2831 + 
    2832 +Changes to underlying filesystems 
    2833 +--------------------------------- 
    2834 + 
    2835 +Offline changes, when the overlay is not mounted, are allowed to either 
    2836 +the upper or the lower trees. 
    2837 + 
    2838 +Changes to the underlying filesystems while part of a mounted overlay 
    2839 +filesystem are not allowed.  This is not yet enforced, but will be in 
    2840 +the future. 
     3120 static int splice_pipe_to_pipe(struct pipe_inode_info *ipipe, 
     3121                               struct pipe_inode_info *opipe, 
     3122--- a/include/linux/fs.h 
     3123+++ b/include/linux/fs.h 
     3124@@ -476,6 +476,12 @@ struct iattr { 
     3125  */ 
     3126 #include <linux/quota.h> 
     3127  
     3128+/* 
     3129+ * Maximum number of layers of fs stack.  Needs to be limited to 
     3130+ * prevent kernel stack overflow 
     3131+ */ 
     3132+#define FILESYSTEM_MAX_STACK_DEPTH 2 
     3133+ 
     3134 /**  
     3135  * enum positive_aop_returns - aop return codes with specific semantics 
     3136  * 
     3137@@ -1429,6 +1435,11 @@ struct super_block { 
     3138         */ 
     3139        char __rcu *s_options; 
     3140        const struct dentry_operations *s_d_op; /* default d_op for dentries */ 
     3141+ 
     3142+       /* 
     3143+        * Indicates how deep in a filesystem stack this SB is 
     3144+        */ 
     3145+       int s_stack_depth; 
     3146 }; 
     3147  
     3148 extern struct timespec current_fs_time(struct super_block *sb); 
     3149@@ -1594,6 +1605,7 @@ struct inode_operations { 
     3150        void (*truncate_range)(struct inode *, loff_t, loff_t); 
     3151        int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start, 
     3152                      u64 len); 
     3153+       struct file *(*open)(struct dentry *, int flags, const struct cred *); 
     3154 } ____cacheline_aligned; 
     3155  
     3156 struct seq_file; 
     3157@@ -1988,6 +2000,7 @@ extern long do_sys_open(int dfd, const c 
     3158 extern struct file *filp_open(const char *, int, int); 
     3159 extern struct file *file_open_root(struct dentry *, struct vfsmount *, 
     3160                                   const char *, int); 
     3161+extern struct file *vfs_open(struct path *, int flags, const struct cred *); 
     3162 extern struct file * dentry_open(struct dentry *, struct vfsmount *, int, 
     3163                                 const struct cred *); 
     3164 extern int filp_close(struct file *, fl_owner_t id); 
     3165--- a/include/linux/mount.h 
     3166+++ b/include/linux/mount.h 
     3167@@ -100,6 +100,9 @@ extern void mnt_pin(struct vfsmount *mnt 
     3168 extern void mnt_unpin(struct vfsmount *mnt); 
     3169 extern int __mnt_is_readonly(struct vfsmount *mnt); 
     3170  
     3171+struct path; 
     3172+extern struct vfsmount *clone_private_mount(struct path *path); 
     3173+ 
     3174 extern struct vfsmount *do_kern_mount(const char *fstype, int flags, 
     3175                                      const char *name, void *data); 
     3176  
  • trunk/target/linux/generic/patches-3.0/100-overlayfs_v11.patch

    r29726 r29727  
     1--- /dev/null 
     2+++ b/Documentation/filesystems/overlayfs.txt 
     3@@ -0,0 +1,199 @@ 
     4+Written by: Neil Brown <neilb@suse.de> 
     5+ 
     6+Overlay Filesystem 
     7+================== 
     8+ 
     9+This document describes a prototype for a new approach to providing 
     10+overlay-filesystem functionality in Linux (sometimes referred to as 
     11+union-filesystems).  An overlay-filesystem tries to present a 
     12+filesystem which is the result over overlaying one filesystem on top 
     13+of the other. 
     14+ 
     15+The result will inevitably fail to look exactly like a normal 
     16+filesystem for various technical reasons.  The expectation is that 
     17+many use cases will be able to ignore these differences. 
     18+ 
     19+This approach is 'hybrid' because the objects that appear in the 
     20+filesystem do not all appear to belong to that filesystem.  In many 
     21+cases an object accessed in the union will be indistinguishable 
     22+from accessing the corresponding object from the original filesystem. 
     23+This is most obvious from the 'st_dev' field returned by stat(2). 
     24+ 
     25+While directories will report an st_dev from the overlay-filesystem, 
     26+all non-directory objects will report an st_dev from the lower or 
     27+upper filesystem that is providing the object.  Similarly st_ino will 
     28+only be unique when combined with st_dev, and both of these can change 
     29+over the lifetime of a non-directory object.  Many applications and 
     30+tools ignore these values and will not be affected. 
     31+ 
     32+Upper and Lower 
     33+--------------- 
     34+ 
     35+An overlay filesystem combines two filesystems - an 'upper' filesystem 
     36+and a 'lower' filesystem.  When a name exists in both filesystems, the 
     37+object in the 'upper' filesystem is visible while the object in the 
     38+'lower' filesystem is either hidden or, in the case of directories, 
     39+merged with the 'upper' object. 
     40+ 
     41+It would be more correct to refer to an upper and lower 'directory 
     42+tree' rather than 'filesystem' as it is quite possible for both 
     43+directory trees to be in the same filesystem and there is no 
     44+requirement that the root of a filesystem be given for either upper or 
     45+lower. 
     46+ 
     47+The lower filesystem can be any filesystem supported by Linux and does 
     48+not need to be writable.  The lower filesystem can even be another 
     49+overlayfs.  The upper filesystem will normally be writable and if it 
     50+is it must support the creation of trusted.* extended attributes, and 
     51+must provide valid d_type in readdir responses, at least for symbolic 
     52+links - so NFS is not suitable. 
     53+ 
     54+A read-only overlay of two read-only filesystems may use any 
     55+filesystem type. 
     56+ 
     57+Directories 
     58+----------- 
     59+ 
     60+Overlaying mainly involved directories.  If a given name appears in both 
     61+upper and lower filesystems and refers to a non-directory in either, 
     62+then the lower object is hidden - the name refers only to the upper 
     63+object. 
     64+ 
     65+Where both upper and lower objects are directories, a merged directory 
     66+is formed. 
     67+ 
     68+At mount time, the two directories given as mount options are combined 
     69+into a merged directory: 
     70+ 
     71+  mount -t overlayfs overlayfs -olowerdir=/lower,upperdir=/upper /overlay 
     72+ 
     73+Then whenever a lookup is requested in such a merged directory, the 
     74+lookup is performed in each actual directory and the combined result 
     75+is cached in the dentry belonging to the overlay filesystem.  If both 
     76+actual lookups find directories, both are stored and a merged 
     77+directory is created, otherwise only one is stored: the upper if it 
     78+exists, else the lower. 
     79+ 
     80+Only the lists of names from directories are merged.  Other content 
     81+such as metadata and extended attributes are reported for the upper 
     82+directory only.  These attributes of the lower directory are hidden. 
     83+ 
     84+whiteouts and opaque directories 
     85+-------------------------------- 
     86+ 
     87+In order to support rm and rmdir without changing the lower 
     88+filesystem, an overlay filesystem needs to record in the upper filesystem 
     89+that files have been removed.  This is done using whiteouts and opaque 
     90+directories (non-directories are always opaque). 
     91+ 
     92+The overlay filesystem uses extended attributes with a 
     93+"trusted.overlay."  prefix to record these details. 
     94+ 
     95+A whiteout is created as a symbolic link with target 
     96+"(overlay-whiteout)" and with xattr "trusted.overlay.whiteout" set to "y". 
     97+When a whiteout is found in the upper level of a merged directory, any 
     98+matching name in the lower level is ignored, and the whiteout itself 
     99+is also hidden. 
     100+ 
     101+A directory is made opaque by setting the xattr "trusted.overlay.opaque" 
     102+to "y".  Where the upper filesystem contains an opaque directory, any 
     103+directory in the lower filesystem with the same name is ignored. 
     104+ 
     105+readdir 
     106+------- 
     107+ 
     108+When a 'readdir' request is made on a merged directory, the upper and 
     109+lower directories are each read and the name lists merged in the 
     110+obvious way (upper is read first, then lower - entries that already 
     111+exist are not re-added).  This merged name list is cached in the 
     112+'struct file' and so remains as long as the file is kept open.  If the 
     113+directory is opened and read by two processes at the same time, they 
     114+will each have separate caches.  A seekdir to the start of the 
     115+directory (offset 0) followed by a readdir will cause the cache to be 
     116+discarded and rebuilt. 
     117+ 
     118+This means that changes to the merged directory do not appear while a 
     119+directory is being read.  This is unlikely to be noticed by many 
     120+programs. 
     121+ 
     122+seek offsets are assigned sequentially when the directories are read. 
     123+Thus if 
     124+  - read part of a directory 
     125+  - remember an offset, and close the directory 
     126+  - re-open the directory some time later 
     127+  - seek to the remembered offset 
     128+ 
     129+there may be little correlation between the old and new locations in 
     130+the list of filenames, particularly if anything has changed in the 
     131+directory. 
     132+ 
     133+Readdir on directories that are not merged is simply handled by the 
     134+underlying directory (upper or lower). 
     135+ 
     136+ 
     137+Non-directories 
     138+--------------- 
     139+ 
     140+Objects that are not directories (files, symlinks, device-special 
     141+files etc.) are presented either from the upper or lower filesystem as 
     142+appropriate.  When a file in the lower filesystem is accessed in a way 
     143+the requires write-access, such as opening for write access, changing 
     144+some metadata etc., the file is first copied from the lower filesystem 
     145+to the upper filesystem (copy_up).  Note that creating a hard-link 
     146+also requires copy_up, though of course creation of a symlink does 
     147+not. 
     148+ 
     149+The copy_up may turn out to be unnecessary, for example if the file is 
     150+opened for read-write but the data is not modified. 
     151+ 
     152+The copy_up process first makes sure that the containing directory 
     153+exists in the upper filesystem - creating it and any parents as 
     154+necessary.  It then creates the object with the same metadata (owner, 
     155+mode, mtime, symlink-target etc.) and then if the object is a file, the 
     156+data is copied from the lower to the upper filesystem.  Finally any 
     157+extended attributes are copied up. 
     158+ 
     159+Once the copy_up is complete, the overlay filesystem simply 
     160+provides direct access to the newly created file in the upper 
     161+filesystem - future operations on the file are barely noticed by the 
     162+overlay filesystem (though an operation on the name of the file such as 
     163+rename or unlink will of course be noticed and handled). 
     164+ 
     165+ 
     166+Non-standard behavior 
     167+--------------------- 
     168+ 
     169+The copy_up operation essentially creates a new, identical file and 
     170+moves it over to the old name.  The new file may be on a different 
     171+filesystem, so both st_dev and st_ino of the file may change. 
     172+ 
     173+Any open files referring to this inode will access the old data and 
     174+metadata.  Similarly any file locks obtained before copy_up will not 
     175+apply to the copied up file. 
     176+ 
     177+On a file is opened with O_RDONLY fchmod(2), fchown(2), futimesat(2) 
     178+and fsetxattr(2) will fail with EROFS. 
     179+ 
     180+If a file with multiple hard links is copied up, then this will 
     181+"break" the link.  Changes will not be propagated to other names 
     182+referring to the same inode. 
     183+ 
     184+Symlinks in /proc/PID/ and /proc/PID/fd which point to a non-directory 
     185+object in overlayfs will not contain vaid absolute paths, only 
     186+relative paths leading up to the filesystem's root.  This will be 
     187+fixed in the future. 
     188+ 
     189+Some operations are not atomic, for example a crash during copy_up or 
     190+rename will leave the filesystem in an inconsitent state.  This will 
     191+be addressed in the future. 
     192+ 
     193+Changes to underlying filesystems 
     194+--------------------------------- 
     195+ 
     196+Offline changes, when the overlay is not mounted, are allowed to either 
     197+the upper or the lower trees. 
     198+ 
     199+Changes to the underlying filesystems while part of a mounted overlay 
     200+filesystem are not allowed.  If the underlying filesystem is changed, 
     201+the behavior of the overlay is undefined, though it will not result in 
     202+a crash or deadlock. 
     203--- a/MAINTAINERS 
     204+++ b/MAINTAINERS 
     205@@ -4727,6 +4727,13 @@ F:       drivers/scsi/osd/ 
     206 F:     include/scsi/osd_* 
     207 F:     fs/exofs/ 
     208  
     209+OVERLAYFS FILESYSTEM 
     210+M:     Miklos Szeredi <miklos@szeredi.hu> 
     211+L:     linux-fsdevel@vger.kernel.org 
     212+S:     Supported 
     213+F:     fs/overlayfs/* 
     214+F:     Documentation/filesystems/overlayfs.txt 
     215+ 
     216 P54 WIRELESS DRIVER 
     217 M:     Christian Lamparter <chunkeey@googlemail.com> 
     218 L:     linux-wireless@vger.kernel.org 
     219--- a/fs/Kconfig 
     220+++ b/fs/Kconfig 
     221@@ -63,6 +63,7 @@ source "fs/quota/Kconfig" 
     222  
     223 source "fs/autofs4/Kconfig" 
     224 source "fs/fuse/Kconfig" 
     225+source "fs/overlayfs/Kconfig" 
     226  
     227 config CUSE 
     228        tristate "Character device in Userspace support" 
     229--- a/fs/Makefile 
     230+++ b/fs/Makefile 
     231@@ -105,6 +105,7 @@ obj-$(CONFIG_QNX4FS_FS)             += qnx4/ 
     232 obj-$(CONFIG_AUTOFS4_FS)       += autofs4/ 
     233 obj-$(CONFIG_ADFS_FS)          += adfs/ 
     234 obj-$(CONFIG_FUSE_FS)          += fuse/ 
     235+obj-$(CONFIG_OVERLAYFS_FS)     += overlayfs/ 
     236 obj-$(CONFIG_UDF_FS)           += udf/ 
     237 obj-$(CONFIG_SUN_OPENPROMFS)   += openpromfs/ 
     238 obj-$(CONFIG_OMFS_FS)          += omfs/ 
     239--- a/fs/ecryptfs/main.c 
     240+++ b/fs/ecryptfs/main.c 
     241@@ -544,6 +544,13 @@ static struct dentry *ecryptfs_mount(str 
     242        s->s_maxbytes = path.dentry->d_sb->s_maxbytes; 
     243        s->s_blocksize = path.dentry->d_sb->s_blocksize; 
     244        s->s_magic = ECRYPTFS_SUPER_MAGIC; 
     245+       s->s_stack_depth = path.dentry->d_sb->s_stack_depth + 1; 
     246+ 
     247+       rc = -EINVAL; 
     248+       if (s->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 
     249+               printk(KERN_ERR "eCryptfs: maximum fs stacking depth exceeded\n"); 
     250+               goto out_free; 
     251+       } 
     252  
     253        inode = ecryptfs_get_inode(path.dentry->d_inode, s); 
     254        rc = PTR_ERR(inode); 
     255--- a/fs/namespace.c 
     256+++ b/fs/namespace.c 
     257@@ -1492,6 +1492,23 @@ void drop_collected_mounts(struct vfsmou 
     258        release_mounts(&umount_list); 
     259 } 
     260  
     261+struct vfsmount *clone_private_mount(struct path *path) 
     262+{ 
     263+       struct vfsmount *mnt; 
     264+ 
     265+       if (IS_MNT_UNBINDABLE(path->mnt)) 
     266+               return ERR_PTR(-EINVAL); 
     267+ 
     268+       down_read(&namespace_sem); 
     269+       mnt = clone_mnt(path->mnt, path->dentry, CL_PRIVATE); 
     270+       up_read(&namespace_sem); 
     271+       if (!mnt) 
     272+               return ERR_PTR(-ENOMEM); 
     273+ 
     274+       return mnt; 
     275+} 
     276+EXPORT_SYMBOL_GPL(clone_private_mount); 
     277+ 
     278 int iterate_mounts(int (*f)(struct vfsmount *, void *), void *arg, 
     279                   struct vfsmount *root) 
     280 { 
    1281--- a/fs/open.c 
    2282+++ b/fs/open.c 
     
    155435 static void __put_unused_fd(struct files_struct *files, unsigned int fd) 
    156436 { 
    157 --- a/include/linux/fs.h 
    158 +++ b/include/linux/fs.h 
    159 @@ -1603,6 +1603,7 @@ struct inode_operations { 
    160         void (*truncate_range)(struct inode *, loff_t, loff_t); 
    161         int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start, 
    162                       u64 len); 
    163 +       struct file *(*open)(struct dentry *, int flags, const struct cred *); 
    164  } ____cacheline_aligned; 
    165   
    166  struct seq_file; 
    167 @@ -1998,6 +1999,7 @@ extern long do_sys_open(int dfd, const c 
    168  extern struct file *filp_open(const char *, int, int); 
    169  extern struct file *file_open_root(struct dentry *, struct vfsmount *, 
    170                                    const char *, int); 
    171 +extern struct file *vfs_open(struct path *, int flags, const struct cred *); 
    172  extern struct file * dentry_open(struct dentry *, struct vfsmount *, int, 
    173                                  const struct cred *); 
    174  extern int filp_close(struct file *, fl_owner_t id); 
    175 --- a/fs/splice.c 
    176 +++ b/fs/splice.c 
    177 @@ -1300,6 +1300,7 @@ long do_splice_direct(struct file *in, l 
    178   
    179         return ret; 
    180  } 
    181 +EXPORT_SYMBOL(do_splice_direct); 
    182   
    183  static int splice_pipe_to_pipe(struct pipe_inode_info *ipipe, 
    184                                struct pipe_inode_info *opipe, 
    185 --- a/fs/namespace.c 
    186 +++ b/fs/namespace.c 
    187 @@ -1492,6 +1492,23 @@ void drop_collected_mounts(struct vfsmou 
    188         release_mounts(&umount_list); 
    189  } 
    190   
    191 +struct vfsmount *clone_private_mount(struct path *path) 
    192 +{ 
    193 +       struct vfsmount *mnt; 
    194 + 
    195 +       if (IS_MNT_UNBINDABLE(path->mnt)) 
    196 +               return ERR_PTR(-EINVAL); 
    197 + 
    198 +       down_read(&namespace_sem); 
    199 +       mnt = clone_mnt(path->mnt, path->dentry, CL_PRIVATE); 
    200 +       up_read(&namespace_sem); 
    201 +       if (!mnt) 
    202 +               return ERR_PTR(-ENOMEM); 
    203 + 
    204 +       return mnt; 
    205 +} 
    206 +EXPORT_SYMBOL_GPL(clone_private_mount); 
    207 + 
    208  int iterate_mounts(int (*f)(struct vfsmount *, void *), void *arg, 
    209                    struct vfsmount *root) 
    210  { 
    211 --- a/include/linux/mount.h 
    212 +++ b/include/linux/mount.h 
    213 @@ -100,6 +100,9 @@ extern void mnt_pin(struct vfsmount *mnt 
    214  extern void mnt_unpin(struct vfsmount *mnt); 
    215  extern int __mnt_is_readonly(struct vfsmount *mnt); 
    216   
    217 +struct path; 
    218 +extern struct vfsmount *clone_private_mount(struct path *path); 
    219 + 
    220  extern struct vfsmount *do_kern_mount(const char *fstype, int flags, 
    221                                       const char *name, void *data); 
    222   
    223 --- a/fs/Kconfig 
    224 +++ b/fs/Kconfig 
    225 @@ -63,6 +63,7 @@ source "fs/quota/Kconfig" 
    226   
    227  source "fs/autofs4/Kconfig" 
    228  source "fs/fuse/Kconfig" 
    229 +source "fs/overlayfs/Kconfig" 
    230   
    231  config CUSE 
    232         tristate "Character device in Userspace support" 
    233 --- a/fs/Makefile 
    234 +++ b/fs/Makefile 
    235 @@ -105,6 +105,7 @@ obj-$(CONFIG_QNX4FS_FS)             += qnx4/ 
    236  obj-$(CONFIG_AUTOFS4_FS)       += autofs4/ 
    237  obj-$(CONFIG_ADFS_FS)          += adfs/ 
    238  obj-$(CONFIG_FUSE_FS)          += fuse/ 
    239 +obj-$(CONFIG_OVERLAYFS_FS)     += overlayfs/ 
    240  obj-$(CONFIG_UDF_FS)           += udf/ 
    241  obj-$(CONFIG_SUN_OPENPROMFS)   += openpromfs/ 
    242  obj-$(CONFIG_OMFS_FS)          += omfs/ 
    243437--- /dev/null 
    244438+++ b/fs/overlayfs/Kconfig 
     
    646840--- /dev/null 
    647841+++ b/fs/overlayfs/dir.c 
    648 @@ -0,0 +1,607 @@ 
     842@@ -0,0 +1,596 @@ 
    649843+/* 
    650844+ * 
     
    663857+ 
    664858+static const char *ovl_whiteout_symlink = "(overlay-whiteout)"; 
    665 + 
    666 +static struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, 
    667 +                                struct nameidata *nd) 
    668 +{ 
    669 +       int err = ovl_do_lookup(dentry); 
    670 + 
    671 +       if (err) 
    672 +               return ERR_PTR(err); 
    673 + 
    674 +       return NULL; 
    675 +} 
    676859+ 
    677860+static int ovl_whiteout(struct dentry *upperdir, struct dentry *dentry) 
     
    12561439--- /dev/null 
    12571440+++ b/fs/overlayfs/inode.c 
    1258 @@ -0,0 +1,375 @@ 
     1441@@ -0,0 +1,384 @@ 
    12591442+/* 
    12601443+ * 
     
    13491532+                * Writes will always be redirected to upper layer, so 
    13501533+                * ignore lower layer being read-only. 
     1534+                * 
     1535+                * If the overlay itself is read-only then proceed 
     1536+                * with the permission check, don't return EROFS. 
     1537+                * This will only happen if this is the lower layer of 
     1538+                * another overlayfs. 
     1539+                * 
     1540+                * If upper fs becomes read-only after the overlay was 
     1541+                * constructed return EROFS to prevent modification of 
     1542+                * upper layer. 
    13511543+                */ 
    13521544+               err = -EROFS; 
    1353 +               if (is_upper && IS_RDONLY(realinode) && 
     1545+               if (is_upper && !IS_RDONLY(inode) && IS_RDONLY(realinode) && 
    13541546+                   (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))) 
    13551547+                       goto out_dput; 
     
    16341826--- /dev/null 
    16351827+++ b/fs/overlayfs/overlayfs.h 
    1636 @@ -0,0 +1,62 @@ 
     1828@@ -0,0 +1,63 @@ 
    16371829+/* 
    16381830+ * 
     
    16701862+bool ovl_is_whiteout(struct dentry *dentry); 
    16711863+void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry); 
    1672 +int ovl_do_lookup(struct dentry *dentry); 
     1864+struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, 
     1865+                         struct nameidata *nd); 
    16731866+ 
    16741867+struct dentry *ovl_upper_create(struct dentry *upperdir, struct dentry *dentry, 
     
    18672060+} 
    18682061+ 
    1869 +static int ovl_dir_read(struct path *realpath, struct ovl_readdir_data *rdd, 
    1870 +                         filldir_t filler) 
     2062+static inline int ovl_dir_read(struct path *realpath, 
     2063+                              struct ovl_readdir_data *rdd, filldir_t filler) 
    18712064+{ 
    18722065+       struct file *realfile; 
     
    19482141+} 
    19492142+ 
    1950 +static int ovl_dir_read_merged(struct path *upperpath, struct path *lowerpath, 
     2143+static inline int ovl_dir_read_merged(struct path *upperpath, struct path *lowerpath, 
    19512144+                              struct ovl_readdir_data *rdd) 
    19522145+{ 
     
    22602453--- /dev/null 
    22612454+++ b/fs/overlayfs/super.c 
    2262 @@ -0,0 +1,625 @@ 
     2455@@ -0,0 +1,656 @@ 
    22632456+/* 
    22642457+ * 
     
    25112704+} 
    25122705+ 
    2513 +static struct dentry *ovl_lookup_real(struct dentry *dir, struct qstr *name) 
     2706+static inline struct dentry *ovl_lookup_real(struct dentry *dir, struct qstr *name) 
    25142707+{ 
    25152708+       struct dentry *dentry; 
     
    25292722+} 
    25302723+ 
    2531 +int ovl_do_lookup(struct dentry *dentry) 
     2724+static int ovl_do_lookup(struct dentry *dentry) 
    25322725+{ 
    25332726+       struct ovl_entry *oe; 
     
    26262819+} 
    26272820+ 
     2821+struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, 
     2822+                         struct nameidata *nd) 
     2823+{ 
     2824+       int err = ovl_do_lookup(dentry); 
     2825+ 
     2826+       if (err) 
     2827+               return ERR_PTR(err); 
     2828+ 
     2829+       return NULL; 
     2830+} 
     2831+ 
    26282832+static void ovl_put_super(struct super_block *sb) 
    26292833+{ 
     
    27973001+               goto out_put_lowerpath; 
    27983002+ 
     3003+       sb->s_stack_depth = max(upperpath.mnt->mnt_sb->s_stack_depth, 
     3004+                               lowerpath.mnt->mnt_sb->s_stack_depth) + 1; 
     3005+ 
     3006+       err = -EINVAL; 
     3007+       if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 
     3008+               printk(KERN_ERR "overlayfs: maximum fs stacking depth exceeded\n"); 
     3009+               goto out_put_lowerpath; 
     3010+       } 
     3011+ 
     3012+ 
    27993013+       ufs->upper_mnt = clone_private_mount(&upperpath); 
    28003014+       err = PTR_ERR(ufs->upper_mnt); 
     
    28103024+               goto out_put_upper_mnt; 
    28113025+       } 
     3026+ 
     3027+       /* 
     3028+        * Make lower_mnt R/O.  That way fchmod/fchown on lower file 
     3029+        * will fail instead of modifying lower fs. 
     3030+        */ 
     3031+       ufs->lower_mnt->mnt_flags |= MNT_READONLY; 
     3032+ 
     3033+       /* If the upper fs is r/o, we mark overlayfs r/o too */ 
     3034+       if (ufs->upper_mnt->mnt_sb->s_flags & MS_RDONLY) 
     3035+               sb->s_flags |= MS_RDONLY; 
    28123036+ 
    28133037+       if (!(sb->s_flags & MS_RDONLY)) { 
     
    28863110+module_init(ovl_init); 
    28873111+module_exit(ovl_exit); 
    2888 --- /dev/null 
    2889 +++ b/Documentation/filesystems/overlayfs.txt 
    2890 @@ -0,0 +1,167 @@ 
    2891 +Written by: Neil Brown <neilb@suse.de> 
    2892 + 
    2893 +Overlay Filesystem 
    2894 +================== 
    2895 + 
    2896 +This document describes a prototype for a new approach to providing 
    2897 +overlay-filesystem functionality in Linux (sometimes referred to as 
    2898 +union-filesystems).  An overlay-filesystem tries to present a 
    2899 +filesystem which is the result over overlaying one filesystem on top 
    2900 +of the other. 
    2901 + 
    2902 +The result will inevitably fail to look exactly like a normal 
    2903 +filesystem for various technical reasons.  The expectation is that 
    2904 +many use cases will be able to ignore these differences. 
    2905 + 
    2906 +This approach is 'hybrid' because the objects that appear in the 
    2907 +filesystem do not all appear to belong to that filesystem.  In many 
    2908 +cases an object accessed in the union will be indistinguishable 
    2909 +from accessing the corresponding object from the original filesystem. 
    2910 +This is most obvious from the 'st_dev' field returned by stat(2). 
    2911 + 
    2912 +While directories will report an st_dev from the overlay-filesystem, 
    2913 +all non-directory objects will report an st_dev from the lower or 
    2914 +upper filesystem that is providing the object.  Similarly st_ino will 
    2915 +only be unique when combined with st_dev, and both of these can change 
    2916 +over the lifetime of a non-directory object.  Many applications and 
    2917 +tools ignore these values and will not be affected. 
    2918 + 
    2919 +Upper and Lower 
    2920 +--------------- 
    2921 + 
    2922 +An overlay filesystem combines two filesystems - an 'upper' filesystem 
    2923 +and a 'lower' filesystem.  When a name exists in both filesystems, the 
    2924 +object in the 'upper' filesystem is visible while the object in the 
    2925 +'lower' filesystem is either hidden or, in the case of directories, 
    2926 +merged with the 'upper' object. 
    2927 + 
    2928 +It would be more correct to refer to an upper and lower 'directory 
    2929 +tree' rather than 'filesystem' as it is quite possible for both 
    2930 +directory trees to be in the same filesystem and there is no 
    2931 +requirement that the root of a filesystem be given for either upper or 
    2932 +lower. 
    2933 + 
    2934 +The lower filesystem can be any filesystem supported by Linux and does 
    2935 +not need to be writable.  The lower filesystem can even be another 
    2936 +overlayfs.  The upper filesystem will normally be writable and if it 
    2937 +is it must support the creation of trusted.* extended attributes, and 
    2938 +must provide valid d_type in readdir responses, at least for symbolic 
    2939 +links - so NFS is not suitable. 
    2940 + 
    2941 +A read-only overlay of two read-only filesystems may use any 
    2942 +filesystem type. 
    2943 + 
    2944 +Directories 
    2945 +----------- 
    2946 + 
    2947 +Overlaying mainly involved directories.  If a given name appears in both 
    2948 +upper and lower filesystems and refers to a non-directory in either, 
    2949 +then the lower object is hidden - the name refers only to the upper 
    2950 +object. 
    2951 + 
    2952 +Where both upper and lower objects are directories, a merged directory 
    2953 +is formed. 
    2954 + 
    2955 +At mount time, the two directories given as mount options are combined 
    2956 +into a merged directory: 
    2957 + 
    2958 +  mount -t overlayfs overlayfs -olowerdir=/lower,upperdir=/upper /overlay 
    2959 + 
    2960 +Then whenever a lookup is requested in such a merged directory, the 
    2961 +lookup is performed in each actual directory and the combined result 
    2962 +is cached in the dentry belonging to the overlay filesystem.  If both 
    2963 +actual lookups find directories, both are stored and a merged 
    2964 +directory is created, otherwise only one is stored: the upper if it 
    2965 +exists, else the lower. 
    2966 + 
    2967 +Only the lists of names from directories are merged.  Other content 
    2968 +such as metadata and extended attributes are reported for the upper 
    2969 +directory only.  These attributes of the lower directory are hidden. 
    2970 + 
    2971 +whiteouts and opaque directories 
    2972 +-------------------------------- 
    2973 + 
    2974 +In order to support rm and rmdir without changing the lower 
    2975 +filesystem, an overlay filesystem needs to record in the upper filesystem 
    2976 +that files have been removed.  This is done using whiteouts and opaque 
    2977 +directories (non-directories are always opaque). 
    2978 + 
    2979 +The overlay filesystem uses extended attributes with a 
    2980 +"trusted.overlay."  prefix to record these details. 
    2981 + 
    2982 +A whiteout is created as a symbolic link with target 
    2983 +"(overlay-whiteout)" and with xattr "trusted.overlay.whiteout" set to "y". 
    2984 +When a whiteout is found in the upper level of a merged directory, any 
    2985 +matching name in the lower level is ignored, and the whiteout itself 
    2986 +is also hidden. 
    2987 + 
    2988 +A directory is made opaque by setting the xattr "trusted.overlay.opaque" 
    2989 +to "y".  Where the upper filesystem contains an opaque directory, any 
    2990 +directory in the lower filesystem with the same name is ignored. 
    2991 + 
    2992 +readdir 
    2993 +------- 
    2994 + 
    2995 +When a 'readdir' request is made on a merged directory, the upper and 
    2996 +lower directories are each read and the name lists merged in the 
    2997 +obvious way (upper is read first, then lower - entries that already 
    2998 +exist are not re-added).  This merged name list is cached in the 
    2999 +'struct file' and so remains as long as the file is kept open.  If the 
    3000 +directory is opened and read by two processes at the same time, they 
    3001 +will each have separate caches.  A seekdir to the start of the 
    3002 +directory (offset 0) followed by a readdir will cause the cache to be 
    3003 +discarded and rebuilt. 
    3004 + 
    3005 +This means that changes to the merged directory do not appear while a 
    3006 +directory is being read.  This is unlikely to be noticed by many 
    3007 +programs. 
    3008 + 
    3009 +seek offsets are assigned sequentially when the directories are read. 
    3010 +Thus if 
    3011 +  - read part of a directory 
    3012 +  - remember an offset, and close the directory 
    3013 +  - re-open the directory some time later 
    3014 +  - seek to the remembered offset 
    3015 + 
    3016 +there may be little correlation between the old and new locations in 
    3017 +the list of filenames, particularly if anything has changed in the 
    3018 +directory. 
    3019 + 
    3020 +Readdir on directories that are not merged is simply handled by the 
    3021 +underlying directory (upper or lower). 
    3022 + 
    3023 + 
    3024 +Non-directories 
    3025 +--------------- 
    3026 + 
    3027 +Objects that are not directories (files, symlinks, device-special 
    3028 +files etc.) are presented either from the upper or lower filesystem as 
    3029 +appropriate.  When a file in the lower filesystem is accessed in a way 
    3030 +the requires write-access, such as opening for write access, changing 
    3031 +some metadata etc., the file is first copied from the lower filesystem 
    3032 +to the upper filesystem (copy_up).  Note that creating a hard-link 
    3033 +also requires copy_up, though of course creation of a symlink does 
    3034 +not. 
    3035 + 
    3036 +The copy_up process first makes sure that the containing directory 
    3037 +exists in the upper filesystem - creating it and any parents as 
    3038 +necessary.  It then creates the object with the same metadata (owner, 
    3039 +mode, mtime, symlink-target etc.) and then if the object is a file, the 
    3040 +data is copied from the lower to the upper filesystem.  Finally any 
    3041 +extended attributes are copied up. 
    3042 + 
    3043 +Once the copy_up is complete, the overlay filesystem simply 
    3044 +provides direct access to the newly created file in the upper 
    3045 +filesystem - future operations on the file are barely noticed by the 
    3046 +overlay filesystem (though an operation on the name of the file such as 
    3047 +rename or unlink will of course be noticed and handled). 
    3048 + 
    3049 +Changes to underlying filesystems 
    3050 +--------------------------------- 
    3051 + 
    3052 +Offline changes, when the overlay is not mounted, are allowed to either 
    3053 +the upper or the lower trees. 
    3054 + 
    3055 +Changes to the underlying filesystems while part of a mounted overlay 
    3056 +filesystem are not allowed.  This is not yet enforced, but will be in 
    3057 +the future. 
    3058 --- a/MAINTAINERS 
    3059 +++ b/MAINTAINERS 
    3060 @@ -4727,6 +4727,13 @@ F:       drivers/scsi/osd/ 
    3061  F:     include/scsi/osd_* 
    3062  F:     fs/exofs/ 
     3112--- a/fs/splice.c 
     3113+++ b/fs/splice.c 
     3114@@ -1300,6 +1300,7 @@ long do_splice_direct(struct file *in, l 
    30633115  
    3064 +OVERLAYFS FILESYSTEM 
    3065 +M:     Miklos Szeredi <miklos@szeredi.hu> 
    3066 +L:     linux-fsdevel@vger.kernel.org 
    3067 +S:     Supported 
    3068 +F:     fs/overlayfs/* 
    3069 +F:     Documentation/filesystems/overlayfs.txt 
    3070 + 
    3071  P54 WIRELESS DRIVER 
    3072  M:     Christian Lamparter <chunkeey@googlemail.com> 
    3073  L:     linux-wireless@vger.kernel.org 
     3116        return ret; 
     3117 } 
     3118+EXPORT_SYMBOL(do_splice_direct); 
     3119  
     3120 static int splice_pipe_to_pipe(struct pipe_inode_info *ipipe, 
     3121                               struct pipe_inode_info *opipe, 
     3122--- a/include/linux/fs.h 
     3123+++ b/include/linux/fs.h 
     3124@@ -480,6 +480,12 @@ struct iattr { 
     3125  */ 
     3126 #include <linux/quota.h> 
     3127  
     3128+/* 
     3129+ * Maximum number of layers of fs stack.  Needs to be limited to 
     3130+ * prevent kernel stack overflow 
     3131+ */ 
     3132+#define FILESYSTEM_MAX_STACK_DEPTH 2 
     3133+ 
     3134 /**  
     3135  * enum positive_aop_returns - aop return codes with specific semantics 
     3136  * 
     3137@@ -1438,6 +1444,11 @@ struct super_block { 
     3138         * Saved pool identifier for cleancache (-1 means none) 
     3139         */ 
     3140        int cleancache_poolid; 
     3141+ 
     3142+       /* 
     3143+        * Indicates how deep in a filesystem stack this SB is 
     3144+        */ 
     3145+       int s_stack_depth; 
     3146 }; 
     3147  
     3148 extern struct timespec current_fs_time(struct super_block *sb); 
     3149@@ -1603,6 +1614,7 @@ struct inode_operations { 
     3150        void (*truncate_range)(struct inode *, loff_t, loff_t); 
     3151        int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start, 
     3152                      u64 len); 
     3153+       struct file *(*open)(struct dentry *, int flags, const struct cred *); 
     3154 } ____cacheline_aligned; 
     3155  
     3156 struct seq_file; 
     3157@@ -1998,6 +2010,7 @@ extern long do_sys_open(int dfd, const c 
     3158 extern struct file *filp_open(const char *, int, int); 
     3159 extern struct file *file_open_root(struct dentry *, struct vfsmount *, 
     3160                                   const char *, int); 
     3161+extern struct file *vfs_open(struct path *, int flags, const struct cred *); 
     3162 extern struct file * dentry_open(struct dentry *, struct vfsmount *, int, 
     3163                                 const struct cred *); 
     3164 extern int filp_close(struct file *, fl_owner_t id); 
     3165--- a/include/linux/mount.h 
     3166+++ b/include/linux/mount.h 
     3167@@ -100,6 +100,9 @@ extern void mnt_pin(struct vfsmount *mnt 
     3168 extern void mnt_unpin(struct vfsmount *mnt); 
     3169 extern int __mnt_is_readonly(struct vfsmount *mnt); 
     3170  
     3171+struct path; 
     3172+extern struct vfsmount *clone_private_mount(struct path *path); 
     3173+ 
     3174 extern struct vfsmount *do_kern_mount(const char *fstype, int flags, 
     3175                                      const char *name, void *data); 
     3176  
Note: See TracChangeset for help on using the changeset viewer.