Changeset 27191


Ignore:
Timestamp:
2011-06-15T23:31:01+02:00 (7 years ago)
Author:
hauke
Message:

linux/generic: Add support for 3.0-rc3

Also make linux identify itself properly as 3.0, not 3.0.0.

Signed-off-by: Jonas Gorski <jonas.gorski+openwrt@…>

Location:
trunk/target/linux/generic
Files:
3 added
6 deleted
42 edited
3 copied

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/generic/config-3.0

    r27190 r27191  
    100100CONFIG_ARM_DMA_MEM_BUFFERABLE=y 
    101101# CONFIG_ARM_ERRATA_411920 is not set 
    102 # CONFIG_ARM_PATCH_PHYS_VIRT is not set 
    103102# CONFIG_ARM_UNWIND is not set 
    104103CONFIG_ARPD=y 
     
    180179# CONFIG_BCM63XX is not set 
    181180# CONFIG_BCM63XX_PHY is not set 
     181# CONFIG_BCMA is not set 
    182182# CONFIG_BCM_WIMAX is not set 
    183183# CONFIG_BDI_SWITCH is not set 
     
    266266CONFIG_BLOCK=y 
    267267# CONFIG_BMP085 is not set 
    268 # CONFIG_BNA is not set 
    269268# CONFIG_BNX2 is not set 
    270269# CONFIG_BONDING is not set 
     
    357356# CONFIG_CHELSIO_T3 is not set 
    358357# CONFIG_CHELSIO_T4 is not set 
    359 # CONFIG_CHELSIO_T4VF is not set 
    360358# CONFIG_CHR_DEV_OSST is not set 
    361359# CONFIG_CHR_DEV_SCH is not set 
     
    366364# CONFIG_CIFS_DEBUG2 is not set 
    367365# CONFIG_CIFS_EXPERIMENTAL is not set 
     366# CONFIG_CIFS_NFSD_EXPORT is not set 
    368367CONFIG_CIFS_POSIX=y 
    369368CONFIG_CIFS_STATS=y 
     
    371370# CONFIG_CIFS_WEAK_PW_HASH is not set 
    372371# CONFIG_CIFS_XATTR is not set 
     372# CONFIG_CLEANCACHE is not set 
    373373CONFIG_CLS_U32_MARK=y 
    374374CONFIG_CLS_U32_PERF=y 
     
    699699# CONFIG_FT1000 is not set 
    700700# CONFIG_FTL is not set 
    701 # CONFIG_FTMAC100 is not set 
    702701# CONFIG_FTRACE is not set 
    703702# CONFIG_FTRACE_STARTUP_TEST is not set 
     
    10311030# CONFIG_INPUT_WINBOND_CIR is not set 
    10321031# CONFIG_INPUT_WISTRON_BTNS is not set 
     1032# CONFIG_INTEL_MID_PTI is not set 
    10331033# CONFIG_INPUT_YEALINK is not set 
    10341034# CONFIG_INTEL_IDLE is not set 
     1035# CONFIG_INTEL_MID_PTI is not set 
    10351036# CONFIG_IOSCHED_CFQ is not set 
    10361037CONFIG_IOSCHED_DEADLINE=y 
     
    11991200# CONFIG_KEXEC is not set 
    12001201# CONFIG_KEYBOARD_ADP5588 is not set 
     1202# CONFIG_KEYBOARD_ADP5589 is not set 
    12011203# CONFIG_KEYBOARD_ATKBD is not set 
    12021204# CONFIG_KEYBOARD_GPIO_POLLED is not set 
     
    12061208# CONFIG_KEYBOARD_MAX7359 is not set 
    12071209# CONFIG_KEYBOARD_MCS is not set 
     1210# CONFIG_KEYBOARD_MPR121 is not set 
    12081211# CONFIG_KEYBOARD_NEWTON is not set 
    12091212# CONFIG_KEYBOARD_OPENCORES is not set 
     
    13281331# CONFIG_MFD_JANZ_CMODIO is not set 
    13291332# CONFIG_MFD_MAX8925 is not set 
    1330 # CONFIG_MFD_MAX8997 is not set 
    13311333# CONFIG_MFD_MAX8998 is not set 
    13321334# CONFIG_MFD_MC13783 is not set 
     
    13931395# CONFIG_MMC_USHC is not set 
    13941396# CONFIG_MMC_VIA_SDMMC is not set 
     1397# CONFIG_MMC_VUB300 is not set 
    13951398CONFIG_MMU=y 
    13961399CONFIG_MODULES=y 
     
    16531656# CONFIG_NET_SCH_NETEM is not set 
    16541657# CONFIG_NET_SCH_PRIO is not set 
     1658# CONFIG_NET_SCH_QFQ is not set 
    16551659# CONFIG_NET_SCH_RED is not set 
    16561660# CONFIG_NET_SCH_SFB is not set 
     
    17141718# CONFIG_NILFS2_FS is not set 
    17151719CONFIG_NLATTR=y 
     1720# CONFIG_NLM_XLR_BOARD is not set 
    17161721# CONFIG_NLS is not set 
    17171722# CONFIG_NLS_ASCII is not set 
     
    20172022# CONFIG_RT2870 is not set 
    20182023# CONFIG_RT2X00 is not set 
    2019 # CONFIG_RTC_CLASS is not set 
     2024# ONFIG_RTC_CLASS is not set 
    20202025# CONFIG_RTC_DEBUG is not set 
    20212026# CONFIG_RTC_DRV_BQ32K is not set 
     
    20332038# CONFIG_RTC_DRV_DS3232 is not set 
    20342039# CONFIG_RTC_DRV_DS3234 is not set 
     2040# CONFIG_RTC_DRV_EM3027 is not set 
    20352041# CONFIG_RTC_DRV_EP93XX is not set 
    20362042# CONFIG_RTC_DRV_FM3130 is not set 
     
    20392045# CONFIG_RTC_DRV_ISL1208 is not set 
    20402046# CONFIG_RTC_DRV_M41T80 is not set 
     2047# CONFIG_RTC_DRV_M41T93 is not set 
    20412048# CONFIG_RTC_DRV_M41T94 is not set 
    20422049# CONFIG_RTC_DRV_M48T35 is not set 
     
    20562063# CONFIG_RTC_DRV_RS5C372 is not set 
    20572064# CONFIG_RTC_DRV_RTC7301 is not set 
     2065# CONFIG_RTC_DRV_RV3029C2 is not set 
    20582066# CONFIG_RTC_DRV_RX8025 is not set 
    20592067# CONFIG_RTC_DRV_RX8581 is not set 
     
    22272235# CONFIG_SENSORS_EMC1403 is not set 
    22282236# CONFIG_SENSORS_EMC2103 is not set 
     2237# CONFIG_SENSORS_EMC6W201 is not set 
    22292238# CONFIG_SENSORS_F71805F is not set 
    22302239# CONFIG_SENSORS_F71882FG is not set 
     
    22632272# CONFIG_SENSORS_LTC4261 is not set 
    22642273# CONFIG_SENSORS_MAX1111 is not set 
     2274# CONFIG_SENSORS_MAX16065 is not set 
    22652275# CONFIG_SENSORS_MAX1619 is not set 
    22662276# CONFIG_SENSORS_MAX6639 is not set 
     2277# CONFIG_SENSORS_MAX6642 is not set 
    22672278# CONFIG_SENSORS_MAX6650 is not set 
    22682279# CONFIG_SENSORS_PC87360 is not set 
     
    23162327# CONFIG_SERIAL_TIMBERDALE is not set 
    23172328# CONFIG_SERIAL_UARTLITE is not set 
     2329# CONFIG_SERIAL_XILINX_PS_UART is not set 
    23182330# CONFIG_SERIO is not set 
    23192331# CONFIG_SERIO_ALTERA_PS2 is not set 
    2320 # CONFIG_SERIO_PS2MULT is not set 
    23212332# CONFIG_SFI is not set 
    23222333# CONFIG_SGI_IOC4 is not set 
     
    24382449# CONFIG_SND_LAYLA20 is not set 
    24392450# CONFIG_SND_LAYLA24 is not set 
     2451# CONFIG_SND_LOLA is not set 
    24402452# CONFIG_SND_LX6464ES is not set 
    24412453# CONFIG_SND_MAESTRO3 is not set 
     
    26292641# CONFIG_TMD_HERMES is not set 
    26302642CONFIG_TMPFS=y 
     2643CONFIG_TMPFS_XATTR=y 
    26312644# CONFIG_TMPFS_POSIX_ACL is not set 
    26322645# CONFIG_TOUCHSCREEN_AD7877 is not set 
     
    26352648# CONFIG_TOUCHSCREEN_AD7879_SPI is not set 
    26362649# CONFIG_TOUCHSCREEN_ADS7846 is not set 
    2637 # CONFIG_TOUCHSCREEN_ATMEL_MXT is not set 
    2638 # CONFIG_TOUCHSCREEN_BU21013 is not set 
    26392650# CONFIG_TOUCHSCREEN_CLEARPAD_TM1217 is not set 
    26402651# CONFIG_TOUCHSCREEN_CY8CTMG110 is not set 
     
    26502661# CONFIG_TOUCHSCREEN_QT602240 is not set 
    26512662# CONFIG_TOUCHSCREEN_S3C2410 is not set 
    2652 # CONFIG_TOUCHSCREEN_ST1232 is not set 
    26532663# CONFIG_TOUCHSCREEN_SYNAPTICS_I2C_RMI4 is not set 
    26542664# CONFIG_TOUCHSCREEN_TOUCHIT213 is not set 
     
    26562666# CONFIG_TOUCHSCREEN_TOUCHWIN is not set 
    26572667# CONFIG_TOUCHSCREEN_TPS6507X is not set 
    2658 # CONFIG_TOUCHSCREEN_TSC2005 is not set 
    26592668# CONFIG_TOUCHSCREEN_TSC2007 is not set 
    26602669# CONFIG_TOUCHSCREEN_USB_COMPOSITE is not set 
     
    26672676# CONFIG_TRACE_BRANCH_PROFILING is not set 
    26682677CONFIG_TRACE_IRQFLAGS_SUPPORT=y 
     2678# CONFIG_TRACE_SINK is not set 
    26692679CONFIG_TRACING_SUPPORT=y 
    26702680CONFIG_TRAD_SIGNALS=y 
     
    27342744# CONFIG_USB_GSPCA_FINEPIX is not set 
    27352745# CONFIG_USB_GSPCA_JEILINJ is not set 
     2746# CONFIG_USB_GSPCA_KINECT is not set 
    27362747# CONFIG_USB_GSPCA_KONICA is not set 
    27372748# CONFIG_USB_GSPCA_MARS is not set 
     
    30693080# CONFIG_W1_MASTER_MATROX is not set 
    30703081# CONFIG_W1_SLAVE_BQ27000 is not set 
     3082# CONFIG_W1_SLAVE_DS2408 is not set 
    30713083# CONFIG_W1_SLAVE_DS2423 is not set 
    30723084# CONFIG_W1_SLAVE_DS2431 is not set 
    30733085# CONFIG_W1_SLAVE_DS2433 is not set 
    30743086# CONFIG_W1_SLAVE_DS2760 is not set 
     3087# CONFIG_W1_SLAVE_DS2780 is not set 
    30753088# CONFIG_W1_SLAVE_SMEM is not set 
    30763089# CONFIG_W1_SLAVE_THERM is not set 
  • trunk/target/linux/generic/patches-3.0/100-overlayfs_v10.patch

    r27190 r27191  
    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; 
    9   
    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); 
    191--- a/fs/open.c 
    202+++ b/fs/open.c 
     
    173155 static void __put_unused_fd(struct files_struct *files, unsigned int fd) 
    174156 { 
     157--- a/include/linux/fs.h 
     158+++ b/include/linux/fs.h 
     159@@ -1602,6 +1602,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@@ -1996,6 +1997,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); 
    175175--- a/fs/splice.c 
    176176+++ b/fs/splice.c 
    177 @@ -1296,6 +1296,7 @@ long do_splice_direct(struct file *in, l 
     177@@ -1300,6 +1300,7 @@ long do_splice_direct(struct file *in, l 
    178178  
    179179        return ret; 
     
    221221                                      const char *name, void *data); 
    222222  
    223 --- /dev/null 
    224 +++ b/fs/overlayfs/overlayfs.c 
    225 @@ -0,0 +1,2414 @@ 
    226 +#include <linux/fs.h> 
    227 +#include <linux/namei.h> 
    228 +#include <linux/sched.h> 
    229 +#include <linux/fs_struct.h> 
    230 +#include <linux/file.h> 
    231 +#include <linux/xattr.h> 
    232 +#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> 
    239 +#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"); 
    245 + 
    246 +#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 +} 
    1071 + 
    1072 +static int ovl_copy_up_xattr(struct dentry *old, struct dentry *new) 
    1073 +{ 
    1074 +       ssize_t list_size, size; 
    1075 +       char *buf, *name, *value; 
    1076 +       int error; 
    1077 + 
    1078 +       if (!old->d_inode->i_op->getxattr || 
    1079 +           !new->d_inode->i_op->getxattr) 
    1080 +               return 0; 
    1081 + 
    1082 +       list_size = vfs_listxattr(old, NULL, 0); 
    1083 +       if (list_size <= 0) { 
    1084 +               if (list_size == -EOPNOTSUPP) 
    1085 +                       return 0; 
    1086 +               return list_size; 
    1087 +       } 
    1088 + 
    1089 +       buf = kzalloc(list_size, GFP_KERNEL); 
    1090 +       if (!buf) 
    1091 +               return -ENOMEM; 
    1092 + 
    1093 +       error = -ENOMEM; 
    1094 +       value = kmalloc(XATTR_SIZE_MAX, GFP_KERNEL); 
    1095 +       if (!value) 
    1096 +               goto out; 
    1097 + 
    1098 +       list_size = vfs_listxattr(old, buf, list_size); 
    1099 +       if (list_size <= 0) { 
    1100 +               error = list_size; 
    1101 +               goto out_free_value; 
    1102 +       } 
    1103 + 
    1104 +       for (name = buf; name < (buf + list_size); name += strlen(name) + 1) { 
    1105 +               size = vfs_getxattr(old, name, value, XATTR_SIZE_MAX); 
    1106 +               if (size <= 0) { 
    1107 +                       error = size; 
    1108 +                       goto out_free_value; 
    1109 +               } 
    1110 +               error = vfs_setxattr(new, name, value, size, 0); 
    1111 +               if (error) 
    1112 +                       goto out_free_value; 
    1113 +       } 
    1114 + 
    1115 +out_free_value: 
    1116 +       kfree(value); 
    1117 +out: 
    1118 +       kfree(buf); 
    1119 +       return error; 
    1120 +} 
    1121 + 
    1122 +static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len) 
    1123 +{ 
    1124 +       struct file *old_file; 
    1125 +       struct file *new_file; 
    1126 +       int error = 0; 
    1127 + 
    1128 +       if (len == 0) 
    1129 +               return 0; 
    1130 + 
    1131 +       old_file = vfs_open(old, O_RDONLY, current_cred()); 
    1132 +       if (IS_ERR(old_file)) 
    1133 +               return PTR_ERR(old_file); 
    1134 + 
    1135 +       new_file = vfs_open(new, O_WRONLY, current_cred()); 
    1136 +       if (IS_ERR(new_file)) { 
    1137 +               error = PTR_ERR(new_file); 
    1138 +               goto out_fput; 
    1139 +       } 
    1140 + 
    1141 +       /* FIXME: copy up sparse files efficiently */ 
    1142 +       while (len) { 
    1143 +               loff_t offset = new_file->f_pos; 
    1144 +               size_t this_len = OVL_COPY_UP_CHUNK_SIZE; 
    1145 +               long bytes; 
    1146 + 
    1147 +               if (len < this_len) 
    1148 +                       this_len = len; 
    1149 + 
    1150 +               if (signal_pending_state(TASK_KILLABLE, current)) { 
    1151 +                       error = -EINTR; 
    1152 +                       break; 
    1153 +               } 
    1154 + 
    1155 +               bytes = do_splice_direct(old_file, &offset, new_file, this_len, 
    1156 +                                SPLICE_F_MOVE); 
    1157 +               if (bytes <= 0) { 
    1158 +                       error = bytes; 
    1159 +                       break; 
    1160 +               } 
    1161 + 
    1162 +               len -= bytes; 
    1163 +       } 
    1164 + 
    1165 +       fput(new_file); 
    1166 +out_fput: 
    1167 +       fput(old_file); 
    1168 +       return error; 
    1169 +} 
    1170 + 
    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 + 
    1285 +static char *ovl_read_symlink(struct dentry *realdentry) 
    1286 +{ 
    1287 +       int res; 
    1288 +       char *buf; 
    1289 +       struct inode *inode = realdentry->d_inode; 
    1290 +       mm_segment_t old_fs; 
    1291 + 
    1292 +       res = -EINVAL; 
    1293 +       if (!inode->i_op->readlink) 
    1294 +               goto err; 
    1295 + 
    1296 +       res = -ENOMEM; 
    1297 +       buf = (char *) __get_free_page(GFP_KERNEL); 
    1298 +       if (!buf) 
    1299 +               goto err; 
    1300 + 
    1301 +       old_fs = get_fs(); 
    1302 +       set_fs(get_ds()); 
    1303 +       /* The cast to a user pointer is valid due to the set_fs() */ 
    1304 +       res = inode->i_op->readlink(realdentry, 
    1305 +                                   (char __user *)buf, PAGE_SIZE - 1); 
    1306 +       set_fs(old_fs); 
    1307 +       if (res < 0) { 
    1308 +               free_page((unsigned long) buf); 
    1309 +               goto err; 
    1310 +       } 
    1311 +       buf[res] = '\0'; 
    1312 + 
    1313 +       return buf; 
    1314 + 
    1315 +err: 
    1316 +       return ERR_PTR(res); 
    1317 +} 
    1318 + 
    1319 +static int ovl_set_timestamps(struct dentry *upperdentry, struct kstat *stat) 
    1320 +{ 
    1321 +       struct iattr attr = { 
    1322 +               .ia_valid = ATTR_ATIME | ATTR_MTIME | ATTR_ATIME_SET | ATTR_MTIME_SET, 
    1323 +               .ia_atime = stat->atime, 
    1324 +               .ia_mtime = stat->mtime, 
    1325 +       }; 
    1326 + 
    1327 +       return notify_change(upperdentry, &attr); 
    1328 +} 
    1329 + 
    1330 +static int ovl_set_mode(struct dentry *upperdentry, umode_t mode) 
    1331 +{ 
    1332 +       struct iattr attr = { 
    1333 +               .ia_valid = ATTR_MODE, 
    1334 +               .ia_mode = mode, 
    1335 +       }; 
    1336 + 
    1337 +       return notify_change(upperdentry, &attr); 
    1338 +} 
    1339 + 
    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 + 
    1380 +static int ovl_copy_up_locked(struct dentry *upperdir, struct dentry *dentry, 
    1381 +                             struct path *lowerpath, struct kstat *stat, 
    1382 +                             const char *link) 
    1383 +{ 
    1384 +       int err; 
    1385 +       struct path newpath; 
    1386 +       umode_t mode = stat->mode; 
    1387 +       struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 
    1388 + 
    1389 +       /* Can't properly set mode on creation because of the umask */ 
    1390 +       stat->mode &= S_IFMT; 
    1391 + 
    1392 +       newpath.mnt = ofs->upper_mnt; 
    1393 +       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 +       } 
    1403 + 
    1404 +       if (S_ISREG(stat->mode)) { 
    1405 +               err = ovl_copy_up_data(lowerpath, &newpath, stat->size); 
    1406 +               if (err) 
    1407 +                       goto err_remove; 
    1408 +       } 
    1409 + 
    1410 +       err = ovl_copy_up_xattr(lowerpath->dentry, newpath.dentry); 
    1411 +       if (err) 
    1412 +               goto err_remove; 
    1413 + 
    1414 +       mutex_lock(&newpath.dentry->d_inode->i_mutex); 
    1415 +       if (!S_ISLNK(stat->mode)) 
    1416 +               err = ovl_set_mode(newpath.dentry, mode); 
    1417 +       if (!err) 
    1418 +               err = ovl_set_timestamps(newpath.dentry, stat); 
    1419 +       mutex_unlock(&newpath.dentry->d_inode->i_mutex); 
    1420 +       if (err) 
    1421 +               goto err_remove; 
    1422 + 
    1423 +       ovl_dentry_update(dentry, newpath.dentry); 
    1424 + 
    1425 +       /* 
    1426 +        * Easiest way to get rid of the lower dentry reference is to 
    1427 +        * drop this dentry.  This is neither needed nor possible for 
    1428 +        * directories. 
    1429 +        */ 
    1430 +       if (!S_ISDIR(stat->mode)) 
    1431 +               d_drop(dentry); 
    1432 + 
    1433 +       return 0; 
    1434 + 
    1435 +err_remove: 
    1436 +       if (S_ISDIR(stat->mode)) 
    1437 +               vfs_rmdir(upperdir->d_inode, newpath.dentry); 
    1438 +       else 
    1439 +               vfs_unlink(upperdir->d_inode, newpath.dentry); 
    1440 + 
    1441 +       dput(newpath.dentry); 
    1442 + 
    1443 +       return err; 
    1444 +} 
    1445 + 
    1446 +static int ovl_copy_up_one(struct dentry *parent, struct dentry *dentry, 
    1447 +                          struct path *lowerpath, struct kstat *stat) 
    1448 +{ 
    1449 +       int err; 
    1450 +       struct kstat pstat; 
    1451 +       struct path parentpath; 
    1452 +       struct dentry *upperdir; 
    1453 +       const struct cred *old_cred; 
    1454 +       struct cred *override_cred; 
    1455 +       char *link = NULL; 
    1456 + 
    1457 +       ovl_path_upper(parent, &parentpath); 
    1458 +       upperdir = parentpath.dentry; 
    1459 + 
    1460 +       err = vfs_getattr(parentpath.mnt, parentpath.dentry, &pstat); 
    1461 +       if (err) 
    1462 +               return err; 
    1463 + 
    1464 +       if (S_ISLNK(stat->mode)) { 
    1465 +               link = ovl_read_symlink(lowerpath->dentry); 
    1466 +               if (IS_ERR(link)) 
    1467 +                       return PTR_ERR(link); 
    1468 +       } 
    1469 + 
    1470 +       err = -ENOMEM; 
    1471 +       override_cred = prepare_creds(); 
    1472 +       if (!override_cred) 
    1473 +               goto out_free_link; 
    1474 + 
    1475 +       override_cred->fsuid = stat->uid; 
    1476 +       override_cred->fsgid = stat->gid; 
    1477 +       /* 
    1478 +        * CAP_SYS_ADMIN for copying up extended attributes 
    1479 +        * CAP_DAC_OVERRIDE for create 
    1480 +        * CAP_FOWNER for chmod, timestamp update 
    1481 +        * CAP_FSETID for chmod 
    1482 +        * CAP_MKNOD for mknod 
    1483 +        */ 
    1484 +       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
    1485 +       cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 
    1486 +       cap_raise(override_cred->cap_effective, CAP_FOWNER); 
    1487 +       cap_raise(override_cred->cap_effective, CAP_FSETID); 
    1488 +       cap_raise(override_cred->cap_effective, CAP_MKNOD); 
    1489 +       old_cred = override_creds(override_cred); 
    1490 + 
    1491 +       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)); 
    1499 +               err = 0; 
    1500 +       } else { 
    1501 +               err = ovl_copy_up_locked(upperdir, dentry, lowerpath, 
    1502 +                                        stat, link); 
    1503 +               if (!err) { 
    1504 +                       /* Restore timestamps on parent (best effort) */ 
    1505 +                       ovl_set_timestamps(upperdir, &pstat); 
    1506 +               } 
    1507 +       } 
    1508 + 
    1509 +       mutex_unlock(&upperdir->d_inode->i_mutex); 
    1510 + 
    1511 +       revert_creds(old_cred); 
    1512 +       put_cred(override_cred); 
    1513 + 
    1514 +out_free_link: 
    1515 +       if (link) 
    1516 +               free_page((unsigned long) link); 
    1517 + 
    1518 +       return err; 
    1519 +} 
    1520 + 
    1521 +static int ovl_copy_up(struct dentry *dentry) 
    1522 +{ 
    1523 +       int err; 
    1524 + 
    1525 +       err = 0; 
    1526 +       while (!err) { 
    1527 +               struct dentry *next; 
    1528 +               struct dentry *parent; 
    1529 +               struct path lowerpath; 
    1530 +               struct kstat stat; 
    1531 +               enum ovl_path_type type = ovl_path_type(dentry); 
    1532 + 
    1533 +               if (type != OVL_PATH_LOWER) 
    1534 +                       break; 
    1535 + 
    1536 +               next = dget(dentry); 
    1537 +               /* find the topmost dentry not yet copied up */ 
    1538 +               for (;;) { 
    1539 +                       parent = dget_parent(next); 
    1540 + 
    1541 +                       type = ovl_path_type(parent); 
    1542 +                       if (type != OVL_PATH_LOWER) 
    1543 +                               break; 
    1544 + 
    1545 +                       dput(next); 
    1546 +                       next = parent; 
    1547 +               } 
    1548 + 
    1549 +               ovl_path_lower(next, &lowerpath); 
    1550 +               err = vfs_getattr(lowerpath.mnt, lowerpath.dentry, &stat); 
    1551 +               if (!err) 
    1552 +                       err = ovl_copy_up_one(parent, next, &lowerpath, &stat); 
    1553 + 
    1554 +               dput(parent); 
    1555 +               dput(next); 
    1556 +       } 
    1557 + 
    1558 +       return err; 
    1559 +} 
    1560 + 
    1561 +/* Optimize by not copying up the file first and truncating later */ 
    1562 +static int ovl_copy_up_truncate(struct dentry *dentry, loff_t size) 
    1563 +{ 
    1564 +       int err; 
    1565 +       struct kstat stat; 
    1566 +       struct path lowerpath; 
    1567 +       struct dentry *parent = dget_parent(dentry); 
    1568 + 
    1569 +       err = ovl_copy_up(parent); 
    1570 +       if (err) 
    1571 +               goto out_dput_parent; 
    1572 + 
    1573 +       ovl_path_lower(dentry, &lowerpath); 
    1574 +       err = vfs_getattr(lowerpath.mnt, lowerpath.dentry, &stat); 
    1575 +       if (err) 
    1576 +               goto out_dput_parent; 
    1577 + 
    1578 +       if (size < stat.size) 
    1579 +               stat.size = size; 
    1580 + 
    1581 +       err = ovl_copy_up_one(parent, dentry, &lowerpath, &stat); 
    1582 + 
    1583 +out_dput_parent: 
    1584 +       dput(parent); 
    1585 +       return err; 
    1586 +} 
    1587 + 
    1588 +static int ovl_setattr(struct dentry *dentry, struct iattr *attr) 
    1589 +{ 
    1590 +       struct dentry *upperdentry; 
    1591 +       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); 
    1597 +       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); 
    1608 + 
    1609 +       return err; 
    1610 +} 
    1611 + 
    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); 
    1619 +} 
    1620 + 
    1621 +static int ovl_dir_getattr(struct vfsmount *mnt, struct dentry *dentry, 
    1622 +                        struct kstat *stat) 
    1623 +{ 
    1624 +       int err; 
    1625 +       enum ovl_path_type type; 
    1626 +       struct path realpath; 
    1627 + 
    1628 +       type = ovl_path_real(dentry, &realpath); 
    1629 +       err = vfs_getattr(realpath.mnt, realpath.dentry, stat); 
    1630 +       if (err) 
    1631 +               return err; 
    1632 + 
    1633 +       stat->dev = dentry->d_sb->s_dev; 
    1634 +       stat->ino = dentry->d_inode->i_ino; 
    1635 + 
    1636 +       /* 
    1637 +        * It's probably not worth it to count subdirs to get the 
    1638 +        * correct link count.  nlink=1 seems to pacify 'find' and 
    1639 +        * other utilities. 
    1640 +        */ 
    1641 +       if (type == OVL_PATH_MERGE) 
    1642 +               stat->nlink = 1; 
    1643 + 
    1644 +       return 0; 
    1645 +} 
    1646 + 
    1647 +static int ovl_permission(struct inode *inode, int mask, unsigned int flags) 
    1648 +{ 
    1649 +       struct ovl_entry *oe; 
    1650 +       struct dentry *alias = NULL; 
    1651 +       struct inode *realinode; 
    1652 +       struct dentry *realdentry; 
    1653 +       bool is_upper; 
    1654 +       int err; 
    1655 + 
    1656 +       if (S_ISDIR(inode->i_mode)) { 
    1657 +               oe = inode->i_private; 
    1658 +       } else if (flags & IPERM_FLAG_RCU) { 
    1659 +               return -ECHILD; 
    1660 +       } else { 
    1661 +               /* 
    1662 +                * For non-directories find an alias and get the info 
    1663 +                * from there. 
    1664 +                */ 
    1665 +               spin_lock(&inode->i_lock); 
    1666 +               if (WARN_ON(list_empty(&inode->i_dentry))) { 
    1667 +                       spin_unlock(&inode->i_lock); 
    1668 +                       return -ENOENT; 
    1669 +               } 
    1670 +               alias = list_entry(inode->i_dentry.next, struct dentry, d_alias); 
    1671 +               dget(alias); 
    1672 +               spin_unlock(&inode->i_lock); 
    1673 +               oe = alias->d_fsdata; 
    1674 +       } 
    1675 + 
    1676 +       realdentry = ovl_upperdentry_dereference(oe); 
    1677 +       is_upper = true; 
    1678 +       if (!realdentry) { 
    1679 +               realdentry = oe->lowerdentry; 
    1680 +               is_upper = false; 
    1681 +       } 
    1682 + 
    1683 +       /* Careful in RCU walk mode */ 
    1684 +       realinode = ACCESS_ONCE(realdentry->d_inode); 
    1685 +       if (!realinode) { 
    1686 +               WARN_ON(!(flags & IPERM_FLAG_RCU)); 
    1687 +               return -ENOENT; 
    1688 +       } 
    1689 + 
    1690 +       if (mask & MAY_WRITE) { 
    1691 +               umode_t mode = realinode->i_mode; 
    1692 + 
    1693 +               /* 
    1694 +                * Writes will always be redirected to upper layer, so 
    1695 +                * ignore lower layer being read-only. 
    1696 +                */ 
    1697 +               err = -EROFS; 
    1698 +               if (is_upper && IS_RDONLY(realinode) && 
    1699 +                   (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))) 
    1700 +                       goto out_dput; 
    1701 + 
    1702 +               /* 
    1703 +                * Nobody gets write access to an immutable file. 
    1704 +                */ 
    1705 +               err = -EACCES; 
    1706 +               if (IS_IMMUTABLE(realinode)) 
    1707 +                       goto out_dput; 
    1708 +       } 
    1709 + 
    1710 +       if (realinode->i_op->permission) 
    1711 +               err = realinode->i_op->permission(realinode, mask, flags); 
    1712 +       else 
    1713 +               err = generic_permission(realinode, mask, flags, 
    1714 +                                        realinode->i_op->check_acl); 
    1715 +out_dput: 
    1716 +       dput(alias); 
    1717 +       return err; 
    1718 +} 
    1719 + 
    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 +} 
    1796 + 
    1797 +struct ovl_link_data { 
    1798 +       struct dentry *realdentry; 
    1799 +       void *cookie; 
    1800 +}; 
    1801 + 
    1802 +static void *ovl_follow_link(struct dentry *dentry, struct nameidata *nd) 
    1803 +{ 
    1804 +       void *ret; 
    1805 +       struct dentry *realdentry; 
    1806 +       struct inode *realinode; 
    1807 + 
    1808 +       realdentry = ovl_dentry_real(dentry); 
    1809 +       realinode = realdentry->d_inode; 
    1810 + 
    1811 +       if (WARN_ON(!realinode->i_op->follow_link)) 
    1812 +               return ERR_PTR(-EPERM); 
    1813 + 
    1814 +       ret = realinode->i_op->follow_link(realdentry, nd); 
    1815 +       if (IS_ERR(ret)) 
    1816 +               return ret; 
    1817 + 
    1818 +       if (realinode->i_op->put_link) { 
    1819 +               struct ovl_link_data *data; 
    1820 + 
    1821 +               data = kmalloc(sizeof(struct ovl_link_data), GFP_KERNEL); 
    1822 +               if (!data) { 
    1823 +                       realinode->i_op->put_link(realdentry, nd, ret); 
    1824 +                       return ERR_PTR(-ENOMEM); 
    1825 +               } 
    1826 +               data->realdentry = realdentry; 
    1827 +               data->cookie = ret; 
    1828 + 
    1829 +               return data; 
    1830 +       } else { 
    1831 +               return NULL; 
    1832 +       } 
    1833 +} 
    1834 + 
    1835 +static void ovl_put_link(struct dentry *dentry, struct nameidata *nd, void *c) 
    1836 +{ 
    1837 +       struct inode *realinode; 
    1838 +       struct ovl_link_data *data = c; 
    1839 + 
    1840 +       if (!data) 
    1841 +               return; 
    1842 + 
    1843 +       realinode = data->realdentry->d_inode; 
    1844 +       realinode->i_op->put_link(data->realdentry, nd, data->cookie); 
    1845 +       kfree(data); 
    1846 +} 
    1847 + 
    1848 +static int ovl_readlink(struct dentry *dentry, char __user *buf, int bufsiz) 
    1849 +{ 
    1850 +       struct path realpath; 
    1851 +       struct inode *realinode; 
    1852 + 
    1853 +       ovl_path_real(dentry, &realpath); 
    1854 +       realinode = realpath.dentry->d_inode; 
    1855 + 
    1856 +       if (!realinode->i_op->readlink) 
    1857 +               return -EINVAL; 
    1858 + 
    1859 +       touch_atime(realpath.mnt, realpath.dentry); 
    1860 + 
    1861 +       return realinode->i_op->readlink(realpath.dentry, buf, bufsiz); 
    1862 +} 
    1863 + 
    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 +} 
    2182 + 
    2183 +static bool ovl_is_private_xattr(const char *name) 
    2184 +{ 
    2185 +       return strncmp(name, "trusted.overlay.", 14) == 0; 
    2186 +} 
    2187 + 
    2188 +static int ovl_setxattr(struct dentry *dentry, const char *name, 
    2189 +                         const void *value, size_t size, int flags) 
    2190 +{ 
    2191 +       int err; 
    2192 +       struct dentry *upperdentry; 
    2193 + 
    2194 +       if (ovl_is_private_xattr(name)) 
    2195 +               return -EPERM; 
    2196 + 
    2197 +       err = ovl_copy_up(dentry); 
    2198 +       if (err) 
    2199 +               return err; 
    2200 + 
    2201 +       upperdentry = ovl_dentry_upper(dentry); 
    2202 +       return  vfs_setxattr(upperdentry, name, value, size, flags); 
    2203 +} 
    2204 + 
    2205 +static ssize_t ovl_getxattr(struct dentry *dentry, const char *name, 
    2206 +                             void *value, size_t size) 
    2207 +{ 
    2208 +       if (ovl_path_type(dentry->d_parent) == OVL_PATH_MERGE && 
    2209 +           ovl_is_private_xattr(name)) 
    2210 +               return -ENODATA; 
    2211 + 
    2212 +       return vfs_getxattr(ovl_dentry_real(dentry), name, value, size); 
    2213 +} 
    2214 + 
    2215 +static ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size) 
    2216 +{ 
    2217 +       ssize_t res; 
    2218 +       int off; 
    2219 + 
    2220 +       res = vfs_listxattr(ovl_dentry_real(dentry), list, size); 
    2221 +       if (res <= 0 || size == 0) 
    2222 +               return res; 
    2223 + 
    2224 +       if (ovl_path_type(dentry->d_parent) != OVL_PATH_MERGE) 
    2225 +               return res; 
    2226 + 
    2227 +       /* filter out private xattrs */ 
    2228 +       for (off = 0; off < res;) { 
    2229 +               char *s = list + off; 
    2230 +               size_t slen = strlen(s) + 1; 
    2231 + 
    2232 +               BUG_ON(off + slen > res); 
    2233 + 
    2234 +               if (ovl_is_private_xattr(s)) { 
    2235 +                       res -= slen; 
    2236 +                       memmove(s, s + slen, res - off); 
    2237 +               } else { 
    2238 +                       off += slen; 
    2239 +               } 
    2240 +       } 
    2241 + 
    2242 +       return res; 
    2243 +} 
    2244 + 
    2245 +static int ovl_removexattr(struct dentry *dentry, const char *name) 
    2246 +{ 
    2247 +       int err; 
    2248 +       struct path realpath; 
    2249 +       enum ovl_path_type type; 
    2250 + 
    2251 +       if (ovl_path_type(dentry->d_parent) == OVL_PATH_MERGE && 
    2252 +           ovl_is_private_xattr(name)) 
    2253 +               return -ENODATA; 
    2254 + 
    2255 +       type = ovl_path_real(dentry, &realpath); 
    2256 +       if (type == OVL_PATH_LOWER) { 
    2257 +               err = vfs_getxattr(realpath.dentry, name, NULL, 0); 
    2258 +               if (err < 0) 
    2259 +                       return err; 
    2260 + 
    2261 +               err = ovl_copy_up(dentry); 
    2262 +               if (err) 
    2263 +                       return err; 
    2264 + 
    2265 +               ovl_path_upper(dentry, &realpath); 
    2266 +       } 
    2267 + 
    2268 +       return vfs_removexattr(realpath.dentry, name); 
    2269 +} 
    2270 + 
    2271 +static bool ovl_open_need_copy_up(int flags, enum ovl_path_type type, 
    2272 +                                 struct dentry *realdentry) 
    2273 +{ 
    2274 +       if (type != OVL_PATH_LOWER) 
    2275 +               return false; 
    2276 + 
    2277 +       if (special_file(realdentry->d_inode->i_mode)) 
    2278 +               return false; 
    2279 + 
    2280 +       if (!(OPEN_FMODE(flags) & FMODE_WRITE) && !(flags & O_TRUNC)) 
    2281 +               return false; 
    2282 + 
    2283 +       return true; 
    2284 +} 
    2285 + 
    2286 +static struct file *ovl_open(struct dentry *dentry, int flags, 
    2287 +                            const struct cred *cred) 
    2288 +{ 
    2289 +       int err; 
    2290 +       struct path realpath; 
    2291 +       enum ovl_path_type type; 
    2292 + 
    2293 +       type = ovl_path_real(dentry, &realpath); 
    2294 +       if (ovl_open_need_copy_up(flags, type, realpath.dentry)) { 
    2295 +               if (flags & O_TRUNC) 
    2296 +                       err = ovl_copy_up_truncate(dentry, 0); 
    2297 +               else 
    2298 +                       err = ovl_copy_up(dentry); 
    2299 +               if (err) 
    2300 +                       return ERR_PTR(err); 
    2301 + 
    2302 +               ovl_path_upper(dentry, &realpath); 
    2303 +       } 
    2304 + 
    2305 +       return vfs_open(&realpath, flags, cred); 
    2306 +} 
    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 +}; 
    2326 + 
    2327 +static const struct inode_operations ovl_file_inode_operations = { 
    2328 +       .setattr        = ovl_setattr, 
    2329 +       .permission     = ovl_permission, 
    2330 +       .getattr        = ovl_getattr, 
    2331 +       .setxattr       = ovl_setxattr, 
    2332 +       .getxattr       = ovl_getxattr, 
    2333 +       .listxattr      = ovl_listxattr, 
    2334 +       .removexattr    = ovl_removexattr, 
    2335 +       .open           = ovl_open, 
    2336 +}; 
    2337 + 
    2338 +static const struct inode_operations ovl_symlink_inode_operations = { 
    2339 +       .setattr        = ovl_setattr, 
    2340 +       .follow_link    = ovl_follow_link, 
    2341 +       .put_link       = ovl_put_link, 
    2342 +       .readlink       = ovl_readlink, 
    2343 +       .getattr        = ovl_getattr, 
    2344 +       .setxattr       = ovl_setxattr, 
    2345 +       .getxattr       = ovl_getxattr, 
    2346 +       .listxattr      = ovl_listxattr, 
    2347 +       .removexattr    = ovl_removexattr, 
    2348 +}; 
    2349 + 
    2350 +static struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, 
    2351 +                                  struct ovl_entry *oe) 
    2352 +{ 
    2353 +       struct inode *inode; 
    2354 + 
    2355 +       inode = new_inode(sb); 
    2356 +       if (!inode) 
    2357 +               return NULL; 
    2358 + 
    2359 +       mode &= S_IFMT; 
    2360 + 
    2361 +       inode->i_ino = get_next_ino(); 
    2362 +       inode->i_mode = mode; 
    2363 +       inode->i_flags |= S_NOATIME | S_NOCMTIME; 
    2364 + 
    2365 +       switch (mode) { 
    2366 +       case S_IFDIR: 
    2367 +               inode->i_private = oe; 
    2368 +               inode->i_op = &ovl_dir_inode_operations; 
    2369 +               inode->i_fop = &ovl_dir_operations; 
    2370 +               break; 
    2371 + 
    2372 +       case S_IFLNK: 
    2373 +               inode->i_op = &ovl_symlink_inode_operations; 
    2374 +               break; 
    2375 + 
    2376 +       case S_IFREG: 
    2377 +       case S_IFSOCK: 
    2378 +       case S_IFBLK: 
    2379 +       case S_IFCHR: 
    2380 +       case S_IFIFO: 
    2381 +               inode->i_op = &ovl_file_inode_operations; 
    2382 +               break; 
    2383 + 
    2384 +       default: 
    2385 +               WARN(1, "illegal file type: %i\n", mode); 
    2386 +               inode = NULL; 
    2387 +       } 
    2388 + 
    2389 +       return inode; 
    2390 + 
    2391 +} 
    2392 + 
    2393 +static void ovl_put_super(struct super_block *sb) 
    2394 +{ 
    2395 +       struct ovl_fs *ufs = sb->s_fs_info; 
    2396 + 
    2397 +       if (!(sb->s_flags & MS_RDONLY)) 
    2398 +               mnt_drop_write(ufs->upper_mnt); 
    2399 + 
    2400 +       mntput(ufs->upper_mnt); 
    2401 +       mntput(ufs->lower_mnt); 
    2402 + 
    2403 +       kfree(ufs); 
    2404 +} 
    2405 + 
    2406 +static int ovl_remount_fs(struct super_block *sb, int *flagsp, char *data) 
    2407 +{ 
    2408 +       int flags = *flagsp; 
    2409 +       struct ovl_fs *ufs = sb->s_fs_info; 
    2410 + 
    2411 +       /* When remounting rw or ro, we need to adjust the write access to the 
    2412 +        * upper fs. 
    2413 +        */ 
    2414 +       if (((flags ^ sb->s_flags) & MS_RDONLY) == 0) 
    2415 +               /* No change to readonly status */ 
    2416 +               return 0; 
    2417 + 
    2418 +       if (flags & MS_RDONLY) { 
    2419 +               mnt_drop_write(ufs->upper_mnt); 
    2420 +               return 0; 
    2421 +       } else 
    2422 +               return mnt_want_write(ufs->upper_mnt); 
    2423 +} 
    2424 + 
    2425 +/** 
    2426 + * ovl_statfs 
    2427 + * @sb: The overlayfs super block 
    2428 + * @buf: The struct kstatfs to fill in with stats 
    2429 + * 
    2430 + * Get the filesystem statistics.  As writes always target the upper layer 
    2431 + * filesystem pass the statfs to the same filesystem. 
    2432 + */ 
    2433 +static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 
    2434 +{ 
    2435 +       struct dentry *root_dentry = dentry->d_sb->s_root; 
    2436 +       struct path path; 
    2437 +       ovl_path_upper(root_dentry, &path); 
    2438 + 
    2439 +       if (!path.dentry->d_sb->s_op->statfs) 
    2440 +               return -ENOSYS; 
    2441 +       return path.dentry->d_sb->s_op->statfs(path.dentry, buf); 
    2442 +} 
    2443 + 
    2444 +static const struct super_operations ovl_super_operations = { 
    2445 +       .put_super      = ovl_put_super, 
    2446 +       .remount_fs     = ovl_remount_fs, 
    2447 +       .statfs         = ovl_statfs, 
    2448 +}; 
    2449 + 
    2450 +struct ovl_config { 
    2451 +       char *lowerdir; 
    2452 +       char *upperdir; 
    2453 +}; 
    2454 + 
    2455 +enum { 
    2456 +       Opt_lowerdir, 
    2457 +       Opt_upperdir, 
    2458 +       Opt_err, 
    2459 +}; 
    2460 + 
    2461 +static const match_table_t ovl_tokens = { 
    2462 +       {Opt_lowerdir,                  "lowerdir=%s"}, 
    2463 +       {Opt_upperdir,                  "upperdir=%s"}, 
    2464 +       {Opt_err,                       NULL} 
    2465 +}; 
    2466 + 
    2467 +static int ovl_parse_opt(char *opt, struct ovl_config *config) 
    2468 +{ 
    2469 +       char *p; 
    2470 + 
    2471 +       config->upperdir = NULL; 
    2472 +       config->lowerdir = NULL; 
    2473 + 
    2474 +       while ((p = strsep(&opt, ",")) != NULL) { 
    2475 +               int token; 
    2476 +               substring_t args[MAX_OPT_ARGS]; 
    2477 + 
    2478 +               if (!*p) 
    2479 +                       continue; 
    2480 + 
    2481 +               token = match_token(p, ovl_tokens, args); 
    2482 +               switch (token) { 
    2483 +               case Opt_upperdir: 
    2484 +                       kfree(config->upperdir); 
    2485 +                       config->upperdir = match_strdup(&args[0]); 
    2486 +                       if (!config->upperdir) 
    2487 +                               return -ENOMEM; 
    2488 +                       break; 
    2489 + 
    2490 +               case Opt_lowerdir: 
    2491 +                       kfree(config->lowerdir); 
    2492 +                       config->lowerdir = match_strdup(&args[0]); 
    2493 +                       if (!config->lowerdir) 
    2494 +                               return -ENOMEM; 
    2495 +                       break; 
    2496 + 
    2497 +               default: 
    2498 +                       return -EINVAL; 
    2499 +               } 
    2500 +       } 
    2501 +       return 0; 
    2502 +} 
    2503 + 
    2504 +static int ovl_fill_super(struct super_block *sb, void *data, int silent) 
    2505 +{ 
    2506 +       struct path lowerpath; 
    2507 +       struct path upperpath; 
    2508 +       struct inode *root_inode; 
    2509 +       struct dentry *root_dentry; 
    2510 +       struct ovl_entry *oe; 
    2511 +       struct ovl_fs *ufs; 
    2512 +       struct ovl_config config; 
    2513 +       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 +       } 
    2524 + 
    2525 +       err = -ENOMEM; 
    2526 +       ufs = kmalloc(sizeof(struct ovl_fs), GFP_KERNEL); 
    2527 +       if (!ufs) 
    2528 +               goto out_free_config; 
    2529 + 
    2530 +       oe = ovl_alloc_entry(); 
    2531 +       if (oe == NULL) 
    2532 +               goto out_free_ufs; 
    2533 + 
    2534 +       root_inode = ovl_new_inode(sb, S_IFDIR, oe); 
    2535 +       if (!root_inode) 
    2536 +               goto out_free_oe; 
    2537 + 
    2538 +       err = kern_path(config.upperdir, LOOKUP_FOLLOW, &upperpath); 
    2539 +       if (err) 
    2540 +               goto out_put_root; 
    2541 + 
    2542 +       err = kern_path(config.lowerdir, LOOKUP_FOLLOW, &lowerpath); 
    2543 +       if (err) 
    2544 +               goto out_put_upperpath; 
    2545 + 
    2546 +       err = -ENOTDIR; 
    2547 +       if (!S_ISDIR(upperpath.dentry->d_inode->i_mode) || 
    2548 +           !S_ISDIR(lowerpath.dentry->d_inode->i_mode)) 
    2549 +               goto out_put_lowerpath; 
    2550 + 
    2551 +       ufs->upper_mnt = clone_private_mount(&upperpath); 
    2552 +       err = PTR_ERR(ufs->upper_mnt); 
    2553 +       if (IS_ERR(ufs->upper_mnt)) { 
    2554 +               printk(KERN_ERR "overlayfs: failed to clone upperpath\n"); 
    2555 +               goto out_put_lowerpath; 
    2556 +       } 
    2557 + 
    2558 +       ufs->lower_mnt = clone_private_mount(&lowerpath); 
    2559 +       err = PTR_ERR(ufs->lower_mnt); 
    2560 +       if (IS_ERR(ufs->lower_mnt)) { 
    2561 +               printk(KERN_ERR "overlayfs: failed to clone lowerpath\n"); 
    2562 +               goto out_put_upper_mnt; 
    2563 +       } 
    2564 + 
    2565 +       if (!(sb->s_flags & MS_RDONLY)) { 
    2566 +               err = mnt_want_write(ufs->upper_mnt); 
    2567 +               if (err) 
    2568 +                       goto out_put_lower_mnt; 
    2569 +       } 
    2570 + 
    2571 +       err = -ENOMEM; 
    2572 +       root_dentry = d_alloc_root(root_inode); 
    2573 +       if (!root_dentry) 
    2574 +               goto out_drop_write; 
    2575 + 
    2576 +       mntput(upperpath.mnt); 
    2577 +       mntput(lowerpath.mnt); 
    2578 + 
    2579 +       oe->__upperdentry = upperpath.dentry; 
    2580 +       oe->lowerdentry = lowerpath.dentry; 
    2581 + 
    2582 +       root_dentry->d_fsdata = oe; 
    2583 +       root_dentry->d_op = &ovl_dentry_operations; 
    2584 + 
    2585 +       sb->s_op = &ovl_super_operations; 
    2586 +       sb->s_root = root_dentry; 
    2587 +       sb->s_fs_info = ufs; 
    2588 + 
    2589 +       return 0; 
    2590 + 
    2591 +out_drop_write: 
    2592 +       if (!(sb->s_flags & MS_RDONLY)) 
    2593 +               mnt_drop_write(ufs->upper_mnt); 
    2594 +out_put_lower_mnt: 
    2595 +       mntput(ufs->lower_mnt); 
    2596 +out_put_upper_mnt: 
    2597 +       mntput(ufs->upper_mnt); 
    2598 +out_put_lowerpath: 
    2599 +       path_put(&lowerpath); 
    2600 +out_put_upperpath: 
    2601 +       path_put(&upperpath); 
    2602 +out_put_root: 
    2603 +       iput(root_inode); 
    2604 +out_free_oe: 
    2605 +       kfree(oe); 
    2606 +out_free_ufs: 
    2607 +       kfree(ufs); 
    2608 +out_free_config: 
    2609 +       kfree(config.lowerdir); 
    2610 +       kfree(config.upperdir); 
    2611 +out: 
    2612 +       return err; 
    2613 +} 
    2614 + 
    2615 +static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 
    2616 +                               const char *dev_name, void *raw_data) 
    2617 +{ 
    2618 +       return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 
    2619 +} 
    2620 + 
    2621 +static struct file_system_type ovl_fs_type = { 
    2622 +       .owner          = THIS_MODULE, 
    2623 +       .name           = "overlayfs", 
    2624 +       .mount          = ovl_mount, 
    2625 +       .kill_sb        = kill_anon_super, 
    2626 +}; 
    2627 + 
    2628 +static int __init ovl_init(void) 
    2629 +{ 
    2630 +       return register_filesystem(&ovl_fs_type); 
    2631 +} 
    2632 + 
    2633 +static void __exit ovl_exit(void) 
    2634 +{ 
    2635 +       unregister_filesystem(&ovl_fs_type); 
    2636 +} 
    2637 + 
    2638 +module_init(ovl_init); 
    2639 +module_exit(ovl_exit); 
    2640223--- a/fs/Kconfig 
    2641224+++ b/fs/Kconfig 
     
    2667250--- /dev/null 
    2668251+++ b/fs/overlayfs/Makefile 
    2669 @@ -0,0 +1,5 @@ 
     252@@ -0,0 +1,7 @@ 
    2670253+# 
    2671254+# Makefile for the overlay filesystem. 
     
    2673256+ 
    2674257+obj-$(CONFIG_OVERLAYFS_FS) += overlayfs.o 
     258+ 
     259+overlayfs-objs := super.o inode.o dir.o readdir.o copy_up.o 
     260--- /dev/null 
     261+++ b/fs/overlayfs/copy_up.c 
     262@@ -0,0 +1,383 @@ 
     263+/* 
     264+ * 
     265+ * Copyright (C) 2011 Novell Inc. 
     266+ * 
     267+ * This program is free software; you can redistribute it and/or modify it 
     268+ * under the terms of the GNU General Public License version 2 as published by 
     269+ * the Free Software Foundation. 
     270+ */ 
     271+ 
     272+#include <linux/fs.h> 
     273+#include <linux/slab.h> 
     274+#include <linux/file.h> 
     275+#include <linux/splice.h> 
     276+#include <linux/xattr.h> 
     277+#include <linux/security.h> 
     278+#include <linux/uaccess.h> 
     279+#include "overlayfs.h" 
     280+ 
     281+#define OVL_COPY_UP_CHUNK_SIZE (1 << 20) 
     282+ 
     283+static int ovl_copy_up_xattr(struct dentry *old, struct dentry *new) 
     284+{ 
     285+       ssize_t list_size, size; 
     286+       char *buf, *name, *value; 
     287+       int error; 
     288+ 
     289+       if (!old->d_inode->i_op->getxattr || 
     290+           !new->d_inode->i_op->getxattr) 
     291+               return 0; 
     292+ 
     293+       list_size = vfs_listxattr(old, NULL, 0); 
     294+       if (list_size <= 0) { 
     295+               if (list_size == -EOPNOTSUPP) 
     296+                       return 0; 
     297+               return list_size; 
     298+       } 
     299+ 
     300+       buf = kzalloc(list_size, GFP_KERNEL); 
     301+       if (!buf) 
     302+               return -ENOMEM; 
     303+ 
     304+       error = -ENOMEM; 
     305+       value = kmalloc(XATTR_SIZE_MAX, GFP_KERNEL); 
     306+       if (!value) 
     307+               goto out; 
     308+ 
     309+       list_size = vfs_listxattr(old, buf, list_size); 
     310+       if (list_size <= 0) { 
     311+               error = list_size; 
     312+               goto out_free_value; 
     313+       } 
     314+ 
     315+       for (name = buf; name < (buf + list_size); name += strlen(name) + 1) { 
     316+               size = vfs_getxattr(old, name, value, XATTR_SIZE_MAX); 
     317+               if (size <= 0) { 
     318+                       error = size; 
     319+                       goto out_free_value; 
     320+               } 
     321+               error = vfs_setxattr(new, name, value, size, 0); 
     322+               if (error) 
     323+                       goto out_free_value; 
     324+       } 
     325+ 
     326+out_free_value: 
     327+       kfree(value); 
     328+out: 
     329+       kfree(buf); 
     330+       return error; 
     331+} 
     332+ 
     333+static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len) 
     334+{ 
     335+       struct file *old_file; 
     336+       struct file *new_file; 
     337+       int error = 0; 
     338+ 
     339+       if (len == 0) 
     340+               return 0; 
     341+ 
     342+       old_file = vfs_open(old, O_RDONLY, current_cred()); 
     343+       if (IS_ERR(old_file)) 
     344+               return PTR_ERR(old_file); 
     345+ 
     346+       new_file = vfs_open(new, O_WRONLY, current_cred()); 
     347+       if (IS_ERR(new_file)) { 
     348+               error = PTR_ERR(new_file); 
     349+               goto out_fput; 
     350+       } 
     351+ 
     352+       /* FIXME: copy up sparse files efficiently */ 
     353+       while (len) { 
     354+               loff_t offset = new_file->f_pos; 
     355+               size_t this_len = OVL_COPY_UP_CHUNK_SIZE; 
     356+               long bytes; 
     357+ 
     358+               if (len < this_len) 
     359+                       this_len = len; 
     360+ 
     361+               if (signal_pending_state(TASK_KILLABLE, current)) { 
     362+                       error = -EINTR; 
     363+                       break; 
     364+               } 
     365+ 
     366+               bytes = do_splice_direct(old_file, &offset, new_file, this_len, 
     367+                                SPLICE_F_MOVE); 
     368+               if (bytes <= 0) { 
     369+                       error = bytes; 
     370+                       break; 
     371+               } 
     372+ 
     373+               len -= bytes; 
     374+       } 
     375+ 
     376+       fput(new_file); 
     377+out_fput: 
     378+       fput(old_file); 
     379+       return error; 
     380+} 
     381+ 
     382+static char *ovl_read_symlink(struct dentry *realdentry) 
     383+{ 
     384+       int res; 
     385+       char *buf; 
     386+       struct inode *inode = realdentry->d_inode; 
     387+       mm_segment_t old_fs; 
     388+ 
     389+       res = -EINVAL; 
     390+       if (!inode->i_op->readlink) 
     391+               goto err; 
     392+ 
     393+       res = -ENOMEM; 
     394+       buf = (char *) __get_free_page(GFP_KERNEL); 
     395+       if (!buf) 
     396+               goto err; 
     397+ 
     398+       old_fs = get_fs(); 
     399+       set_fs(get_ds()); 
     400+       /* The cast to a user pointer is valid due to the set_fs() */ 
     401+       res = inode->i_op->readlink(realdentry, 
     402+                                   (char __user *)buf, PAGE_SIZE - 1); 
     403+       set_fs(old_fs); 
     404+       if (res < 0) { 
     405+               free_page((unsigned long) buf); 
     406+               goto err; 
     407+       } 
     408+       buf[res] = '\0'; 
     409+ 
     410+       return buf; 
     411+ 
     412+err: 
     413+       return ERR_PTR(res); 
     414+} 
     415+ 
     416+static int ovl_set_timestamps(struct dentry *upperdentry, struct kstat *stat) 
     417+{ 
     418+       struct iattr attr = { 
     419+               .ia_valid = ATTR_ATIME | ATTR_MTIME | ATTR_ATIME_SET | ATTR_MTIME_SET, 
     420+               .ia_atime = stat->atime, 
     421+               .ia_mtime = stat->mtime, 
     422+       }; 
     423+ 
     424+       return notify_change(upperdentry, &attr); 
     425+} 
     426+ 
     427+static int ovl_set_mode(struct dentry *upperdentry, umode_t mode) 
     428+{ 
     429+       struct iattr attr = { 
     430+               .ia_valid = ATTR_MODE, 
     431+               .ia_mode = mode, 
     432+       }; 
     433+ 
     434+       return notify_change(upperdentry, &attr); 
     435+} 
     436+ 
     437+static int ovl_copy_up_locked(struct dentry *upperdir, struct dentry *dentry, 
     438+                             struct path *lowerpath, struct kstat *stat, 
     439+                             const char *link) 
     440+{ 
     441+       int err; 
     442+       struct path newpath; 
     443+       umode_t mode = stat->mode; 
     444+ 
     445+       /* Can't properly set mode on creation because of the umask */ 
     446+       stat->mode &= S_IFMT; 
     447+ 
     448+       ovl_path_upper(dentry, &newpath); 
     449+       WARN_ON(newpath.dentry); 
     450+       newpath.dentry = ovl_upper_create(upperdir, dentry, stat, link); 
     451+       if (IS_ERR(newpath.dentry)) 
     452+               return PTR_ERR(newpath.dentry); 
     453+ 
     454+       if (S_ISREG(stat->mode)) { 
     455+               err = ovl_copy_up_data(lowerpath, &newpath, stat->size); 
     456+               if (err) 
     457+                       goto err_remove; 
     458+       } 
     459+ 
     460+       err = ovl_copy_up_xattr(lowerpath->dentry, newpath.dentry); 
     461+       if (err) 
     462+               goto err_remove; 
     463+ 
     464+       mutex_lock(&newpath.dentry->d_inode->i_mutex); 
     465+       if (!S_ISLNK(stat->mode)) 
     466+               err = ovl_set_mode(newpath.dentry, mode); 
     467+       if (!err) 
     468+               err = ovl_set_timestamps(newpath.dentry, stat); 
     469+       mutex_unlock(&newpath.dentry->d_inode->i_mutex); 
     470+       if (err) 
     471+               goto err_remove; 
     472+ 
     473+       ovl_dentry_update(dentry, newpath.dentry); 
     474+ 
     475+       /* 
     476+        * Easiest way to get rid of the lower dentry reference is to 
     477+        * drop this dentry.  This is neither needed nor possible for 
     478+        * directories. 
     479+        */ 
     480+       if (!S_ISDIR(stat->mode)) 
     481+               d_drop(dentry); 
     482+ 
     483+       return 0; 
     484+ 
     485+err_remove: 
     486+       if (S_ISDIR(stat->mode)) 
     487+               vfs_rmdir(upperdir->d_inode, newpath.dentry); 
     488+       else 
     489+               vfs_unlink(upperdir->d_inode, newpath.dentry); 
     490+ 
     491+       dput(newpath.dentry); 
     492+ 
     493+       return err; 
     494+} 
     495+ 
     496+/* 
     497+ * Copy up a single dentry 
     498+ * 
     499+ * Directory renames only allowed on "pure upper" (already created on 
     500+ * upper filesystem, never copied up).  Directories which are on lower or 
     501+ * are merged may not be renamed.  For these -EXDEV is returned and 
     502+ * userspace has to deal with it.  This means, when copying up a 
     503+ * directory we can rely on it and ancestors being stable. 
     504+ * 
     505+ * Non-directory renames start with copy up of source if necessary.  The 
     506+ * actual rename will only proceed once the copy up was successful.  Copy 
     507+ * up uses upper parent i_mutex for exclusion.  Since rename can change 
     508+ * d_parent it is possible that the copy up will lock the old parent.  At 
     509+ * that point the file will have already been copied up anyway. 
     510+ */ 
     511+static int ovl_copy_up_one(struct dentry *parent, struct dentry *dentry, 
     512+                          struct path *lowerpath, struct kstat *stat) 
     513+{ 
     514+       int err; 
     515+       struct kstat pstat; 
     516+       struct path parentpath; 
     517+       struct dentry *upperdir; 
     518+       const struct cred *old_cred; 
     519+       struct cred *override_cred; 
     520+       char *link = NULL; 
     521+ 
     522+       ovl_path_upper(parent, &parentpath); 
     523+       upperdir = parentpath.dentry; 
     524+ 
     525+       err = vfs_getattr(parentpath.mnt, parentpath.dentry, &pstat); 
     526+       if (err) 
     527+               return err; 
     528+ 
     529+       if (S_ISLNK(stat->mode)) { 
     530+               link = ovl_read_symlink(lowerpath->dentry); 
     531+               if (IS_ERR(link)) 
     532+                       return PTR_ERR(link); 
     533+       } 
     534+ 
     535+       err = -ENOMEM; 
     536+       override_cred = prepare_creds(); 
     537+       if (!override_cred) 
     538+               goto out_free_link; 
     539+ 
     540+       override_cred->fsuid = stat->uid; 
     541+       override_cred->fsgid = stat->gid; 
     542+       /* 
     543+        * CAP_SYS_ADMIN for copying up extended attributes 
     544+        * CAP_DAC_OVERRIDE for create 
     545+        * CAP_FOWNER for chmod, timestamp update 
     546+        * CAP_FSETID for chmod 
     547+        * CAP_MKNOD for mknod 
     548+        */ 
     549+       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     550+       cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 
     551+       cap_raise(override_cred->cap_effective, CAP_FOWNER); 
     552+       cap_raise(override_cred->cap_effective, CAP_FSETID); 
     553+       cap_raise(override_cred->cap_effective, CAP_MKNOD); 
     554+       old_cred = override_creds(override_cred); 
     555+ 
     556+       mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
     557+       if (ovl_path_type(dentry) != OVL_PATH_LOWER) { 
     558+               err = 0; 
     559+       } else { 
     560+               err = ovl_copy_up_locked(upperdir, dentry, lowerpath, 
     561+                                        stat, link); 
     562+               if (!err) { 
     563+                       /* Restore timestamps on parent (best effort) */ 
     564+                       ovl_set_timestamps(upperdir, &pstat); 
     565+               } 
     566+       } 
     567+ 
     568+       mutex_unlock(&upperdir->d_inode->i_mutex); 
     569+ 
     570+       revert_creds(old_cred); 
     571+       put_cred(override_cred); 
     572+ 
     573+out_free_link: 
     574+       if (link) 
     575+               free_page((unsigned long) link); 
     576+ 
     577+       return err; 
     578+} 
     579+ 
     580+int ovl_copy_up(struct dentry *dentry) 
     581+{ 
     582+       int err; 
     583+ 
     584+       err = 0; 
     585+       while (!err) { 
     586+               struct dentry *next; 
     587+               struct dentry *parent; 
     588+               struct path lowerpath; 
     589+               struct kstat stat; 
     590+               enum ovl_path_type type = ovl_path_type(dentry); 
     591+ 
     592+               if (type != OVL_PATH_LOWER) 
     593+                       break; 
     594+ 
     595+               next = dget(dentry); 
     596+               /* find the topmost dentry not yet copied up */ 
     597+               for (;;) { 
     598+                       parent = dget_parent(next); 
     599+ 
     600+                       type = ovl_path_type(parent); 
     601+                       if (type != OVL_PATH_LOWER) 
     602+                               break; 
     603+ 
     604+                       dput(next); 
     605+                       next = parent; 
     606+               } 
     607+ 
     608+               ovl_path_lower(next, &lowerpath); 
     609+               err = vfs_getattr(lowerpath.mnt, lowerpath.dentry, &stat); 
     610+               if (!err) 
     611+                       err = ovl_copy_up_one(parent, next, &lowerpath, &stat); 
     612+ 
     613+               dput(parent); 
     614+               dput(next); 
     615+       } 
     616+ 
     617+       return err; 
     618+} 
     619+ 
     620+/* Optimize by not copying up the file first and truncating later */ 
     621+int ovl_copy_up_truncate(struct dentry *dentry, loff_t size) 
     622+{ 
     623+       int err; 
     624+       struct kstat stat; 
     625+       struct path lowerpath; 
     626+       struct dentry *parent = dget_parent(dentry); 
     627+ 
     628+       err = ovl_copy_up(parent); 
     629+       if (err) 
     630+               goto out_dput_parent; 
     631+ 
     632+       ovl_path_lower(dentry, &lowerpath); 
     633+       err = vfs_getattr(lowerpath.mnt, lowerpath.dentry, &stat); 
     634+       if (err) 
     635+               goto out_dput_parent; 
     636+ 
     637+       if (size < stat.size) 
     638+               stat.size = size; 
     639+ 
     640+       err = ovl_copy_up_one(parent, dentry, &lowerpath, &stat); 
     641+ 
     642+out_dput_parent: 
     643+       dput(parent); 
     644+       return err; 
     645+} 
     646--- /dev/null 
     647+++ b/fs/overlayfs/dir.c 
     648@@ -0,0 +1,607 @@ 
     649+/* 
     650+ * 
     651+ * Copyright (C) 2011 Novell Inc. 
     652+ * 
     653+ * This program is free software; you can redistribute it and/or modify it 
     654+ * under the terms of the GNU General Public License version 2 as published by 
     655+ * the Free Software Foundation. 
     656+ */ 
     657+ 
     658+#include <linux/fs.h> 
     659+#include <linux/namei.h> 
     660+#include <linux/xattr.h> 
     661+#include <linux/security.h> 
     662+#include "overlayfs.h" 
     663+ 
     664+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+} 
     676+ 
     677+static int ovl_whiteout(struct dentry *upperdir, struct dentry *dentry) 
     678+{ 
     679+       int err; 
     680+       struct dentry *newdentry; 
     681+       const struct cred *old_cred; 
     682+       struct cred *override_cred; 
     683+ 
     684+       /* FIXME: recheck lower dentry to see if whiteout is really needed */ 
     685+ 
     686+       err = -ENOMEM; 
     687+       override_cred = prepare_creds(); 
     688+       if (!override_cred) 
     689+               goto out; 
     690+ 
     691+       /* 
     692+        * CAP_SYS_ADMIN for setxattr 
     693+        * CAP_DAC_OVERRIDE for symlink creation 
     694+        * CAP_FOWNER for unlink in sticky directory 
     695+        */ 
     696+       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     697+       cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 
     698+       cap_raise(override_cred->cap_effective, CAP_FOWNER); 
     699+       override_cred->fsuid = 0; 
     700+       override_cred->fsgid = 0; 
     701+       old_cred = override_creds(override_cred); 
     702+ 
     703+       newdentry = lookup_one_len(dentry->d_name.name, upperdir, 
     704+                                  dentry->d_name.len); 
     705+       err = PTR_ERR(newdentry); 
     706+       if (IS_ERR(newdentry)) 
     707+               goto out_put_cred; 
     708+ 
     709+       /* Just been removed within the same locked region */ 
     710+       WARN_ON(newdentry->d_inode); 
     711+ 
     712+       err = vfs_symlink(upperdir->d_inode, newdentry, ovl_whiteout_symlink); 
     713+       if (err) 
     714+               goto out_dput; 
     715+ 
     716+       ovl_dentry_version_inc(dentry->d_parent); 
     717+ 
     718+       err = vfs_setxattr(newdentry, ovl_whiteout_xattr, "y", 1, 0); 
     719+       if (err) 
     720+               vfs_unlink(upperdir->d_inode, newdentry); 
     721+ 
     722+out_dput: 
     723+       dput(newdentry); 
     724+out_put_cred: 
     725+       revert_creds(old_cred); 
     726+       put_cred(override_cred); 
     727+out: 
     728+       if (err) { 
     729+               /* 
     730+                * There's no way to recover from failure to whiteout. 
     731+                * What should we do?  Log a big fat error and... ? 
     732+                */ 
     733+               printk(KERN_ERR "overlayfs: ERROR - failed to whiteout '%s'\n", 
     734+                      dentry->d_name.name); 
     735+       } 
     736+ 
     737+       return err; 
     738+} 
     739+ 
     740+static struct dentry *ovl_lookup_create(struct dentry *upperdir, 
     741+                                       struct dentry *template) 
     742+{ 
     743+       int err; 
     744+       struct dentry *newdentry; 
     745+       struct qstr *name = &template->d_name; 
     746+ 
     747+       newdentry = lookup_one_len(name->name, upperdir, name->len); 
     748+       if (IS_ERR(newdentry)) 
     749+               return newdentry; 
     750+ 
     751+       if (newdentry->d_inode) { 
     752+               const struct cred *old_cred; 
     753+               struct cred *override_cred; 
     754+ 
     755+               /* No need to check whiteout if lower parent is non-existent */ 
     756+               err = -EEXIST; 
     757+               if (!ovl_dentry_lower(template->d_parent)) 
     758+                       goto out_dput; 
     759+ 
     760+               if (!S_ISLNK(newdentry->d_inode->i_mode)) 
     761+                       goto out_dput; 
     762+ 
     763+               err = -ENOMEM; 
     764+               override_cred = prepare_creds(); 
     765+               if (!override_cred) 
     766+                       goto out_dput; 
     767+ 
     768+               /* 
     769+                * CAP_SYS_ADMIN for getxattr 
     770+                * CAP_FOWNER for unlink in sticky directory 
     771+                */ 
     772+               cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     773+               cap_raise(override_cred->cap_effective, CAP_FOWNER); 
     774+               old_cred = override_creds(override_cred); 
     775+ 
     776+               err = -EEXIST; 
     777+               if (ovl_is_whiteout(newdentry)) 
     778+                       err = vfs_unlink(upperdir->d_inode, newdentry); 
     779+ 
     780+               revert_creds(old_cred); 
     781+               put_cred(override_cred); 
     782+               if (err) 
     783+                       goto out_dput; 
     784+ 
     785+               dput(newdentry); 
     786+               newdentry = lookup_one_len(name->name, upperdir, name->len); 
     787+               if (IS_ERR(newdentry)) { 
     788+                       ovl_whiteout(upperdir, template); 
     789+                       return newdentry; 
     790+               } 
     791+ 
     792+               /* 
     793+                * Whiteout just been successfully removed, parent 
     794+                * i_mutex is still held, there's no way the lookup 
     795+                * could return positive. 
     796+                */ 
     797+               WARN_ON(newdentry->d_inode); 
     798+       } 
     799+ 
     800+       return newdentry; 
     801+ 
     802+out_dput: 
     803+       dput(newdentry); 
     804+       return ERR_PTR(err); 
     805+} 
     806+ 
     807+struct dentry *ovl_upper_create(struct dentry *upperdir, struct dentry *dentry, 
     808+                               struct kstat *stat, const char *link) 
     809+{ 
     810+       int err; 
     811+       struct dentry *newdentry; 
     812+       struct inode *dir = upperdir->d_inode; 
     813+ 
     814+       newdentry = ovl_lookup_create(upperdir, dentry); 
     815+       if (IS_ERR(newdentry)) 
     816+               goto out; 
     817+ 
     818+       switch (stat->mode & S_IFMT) { 
     819+       case S_IFREG: 
     820+               err = vfs_create(dir, newdentry, stat->mode, NULL); 
     821+               break; 
     822+ 
     823+       case S_IFDIR: 
     824+               err = vfs_mkdir(dir, newdentry, stat->mode); 
     825+               break; 
     826+ 
     827+       case S_IFCHR: 
     828+       case S_IFBLK: 
     829+       case S_IFIFO: 
     830+       case S_IFSOCK: 
     831+               err = vfs_mknod(dir, newdentry, stat->mode, stat->rdev); 
     832+               break; 
     833+ 
     834+       case S_IFLNK: 
     835+               err = vfs_symlink(dir, newdentry, link); 
     836+               break; 
     837+ 
     838+       default: 
     839+               err = -EPERM; 
     840+       } 
     841+       if (err) { 
     842+               if (ovl_dentry_is_opaque(dentry)) 
     843+                       ovl_whiteout(upperdir, dentry); 
     844+               dput(newdentry); 
     845+               newdentry = ERR_PTR(err); 
     846+       } else if (WARN_ON(!newdentry->d_inode)) { 
     847+               /* 
     848+                * Not quite sure if non-instantiated dentry is legal or not. 
     849+                * VFS doesn't seem to care so check and warn here. 
     850+                */ 
     851+               dput(newdentry); 
     852+               newdentry = ERR_PTR(-ENOENT); 
     853+       } 
     854+ 
     855+out: 
     856+       return newdentry; 
     857+ 
     858+} 
     859+ 
     860+static int ovl_set_opaque(struct dentry *upperdentry) 
     861+{ 
     862+       int err; 
     863+       const struct cred *old_cred; 
     864+       struct cred *override_cred; 
     865+ 
     866+       override_cred = prepare_creds(); 
     867+       if (!override_cred) 
     868+               return -ENOMEM; 
     869+ 
     870+       /* CAP_SYS_ADMIN for setxattr of "trusted" namespace */ 
     871+       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     872+       old_cred = override_creds(override_cred); 
     873+       err = vfs_setxattr(upperdentry, ovl_opaque_xattr, "y", 1, 0); 
     874+       revert_creds(old_cred); 
     875+       put_cred(override_cred); 
     876+ 
     877+       return err; 
     878+} 
     879+ 
     880+static int ovl_remove_opaque(struct dentry *upperdentry) 
     881+{ 
     882+       int err; 
     883+       const struct cred *old_cred; 
     884+       struct cred *override_cred; 
     885+ 
     886+       override_cred = prepare_creds(); 
     887+       if (!override_cred) 
     888+               return -ENOMEM; 
     889+ 
     890+       /* CAP_SYS_ADMIN for removexattr of "trusted" namespace */ 
     891+       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     892+       old_cred = override_creds(override_cred); 
     893+       err = vfs_removexattr(upperdentry, ovl_opaque_xattr); 
     894+       revert_creds(old_cred); 
     895+       put_cred(override_cred); 
     896+ 
     897+       return err; 
     898+} 
     899+ 
     900+static int ovl_dir_getattr(struct vfsmount *mnt, struct dentry *dentry, 
     901+                        struct kstat *stat) 
     902+{ 
     903+       int err; 
     904+       enum ovl_path_type type; 
     905+       struct path realpath; 
     906+ 
     907+       type = ovl_path_real(dentry, &realpath); 
     908+       err = vfs_getattr(realpath.mnt, realpath.dentry, stat); 
     909+       if (err) 
     910+               return err; 
     911+ 
     912+       stat->dev = dentry->d_sb->s_dev; 
     913+       stat->ino = dentry->d_inode->i_ino; 
     914+ 
     915+       /* 
     916+        * It's probably not worth it to count subdirs to get the 
     917+        * correct link count.  nlink=1 seems to pacify 'find' and 
     918+        * other utilities. 
     919+        */ 
     920+       if (type == OVL_PATH_MERGE) 
     921+               stat->nlink = 1; 
     922+ 
     923+       return 0; 
     924+} 
     925+ 
     926+static int ovl_create_object(struct dentry *dentry, int mode, dev_t rdev, 
     927+                            const char *link) 
     928+{ 
     929+       int err; 
     930+       struct dentry *newdentry; 
     931+       struct dentry *upperdir; 
     932+       struct inode *inode; 
     933+       struct kstat stat = { 
     934+               .mode = mode, 
     935+               .rdev = rdev, 
     936+       }; 
     937+ 
     938+       err = -ENOMEM; 
     939+       inode = ovl_new_inode(dentry->d_sb, mode, dentry->d_fsdata); 
     940+       if (!inode) 
     941+               goto out; 
     942+ 
     943+       err = ovl_copy_up(dentry->d_parent); 
     944+       if (err) 
     945+               goto out_iput; 
     946+ 
     947+       upperdir = ovl_dentry_upper(dentry->d_parent); 
     948+       mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
     949+ 
     950+       newdentry = ovl_upper_create(upperdir, dentry, &stat, link); 
     951+       err = PTR_ERR(newdentry); 
     952+       if (IS_ERR(newdentry)) 
     953+               goto out_unlock; 
     954+ 
     955+       ovl_dentry_version_inc(dentry->d_parent); 
     956+       if (ovl_dentry_is_opaque(dentry) && S_ISDIR(mode)) { 
     957+               err = ovl_set_opaque(newdentry); 
     958+               if (err) { 
     959+                       vfs_rmdir(upperdir->d_inode, newdentry); 
     960+                       ovl_whiteout(upperdir, dentry); 
     961+                       goto out_dput; 
     962+               } 
     963+       } 
     964+       ovl_dentry_update(dentry, newdentry); 
     965+       d_instantiate(dentry, inode); 
     966+       inode = NULL; 
     967+       newdentry = NULL; 
     968+       err = 0; 
     969+ 
     970+out_dput: 
     971+       dput(newdentry); 
     972+out_unlock: 
     973+       mutex_unlock(&upperdir->d_inode->i_mutex); 
     974+out_iput: 
     975+       iput(inode); 
     976+out: 
     977+       return err; 
     978+} 
     979+ 
     980+static int ovl_create(struct inode *dir, struct dentry *dentry, int mode, 
     981+                       struct nameidata *nd) 
     982+{ 
     983+       return ovl_create_object(dentry, (mode & 07777) | S_IFREG, 0, NULL); 
     984+} 
     985+ 
     986+static int ovl_mkdir(struct inode *dir, struct dentry *dentry, int mode) 
     987+{ 
     988+       return ovl_create_object(dentry, (mode & 07777) | S_IFDIR, 0, NULL); 
     989+} 
     990+ 
     991+static int ovl_mknod(struct inode *dir, struct dentry *dentry, int mode, 
     992+                      dev_t rdev) 
     993+{ 
     994+       return ovl_create_object(dentry, mode, rdev, NULL); 
     995+} 
     996+ 
     997+static int ovl_symlink(struct inode *dir, struct dentry *dentry, 
     998+                        const char *link) 
     999+{ 
     1000+       return ovl_create_object(dentry, S_IFLNK, 0, link); 
     1001+} 
     1002+ 
     1003+static int ovl_do_remove(struct dentry *dentry, bool is_dir) 
     1004+{ 
     1005+       int err; 
     1006+       enum ovl_path_type type; 
     1007+       struct path realpath; 
     1008+       struct dentry *upperdir; 
     1009+ 
     1010+       err = ovl_copy_up(dentry->d_parent); 
     1011+       if (err) 
     1012+               return err; 
     1013+ 
     1014+       upperdir = ovl_dentry_upper(dentry->d_parent); 
     1015+       mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
     1016+       type = ovl_path_real(dentry, &realpath); 
     1017+       if (type != OVL_PATH_LOWER) { 
     1018+               err = -ESTALE; 
     1019+               if (realpath.dentry->d_parent != upperdir) 
     1020+                       goto out_d_drop; 
     1021+ 
     1022+               /* FIXME: create whiteout up front and rename to target */ 
     1023+ 
     1024+               if (is_dir) 
     1025+                       err = vfs_rmdir(upperdir->d_inode, realpath.dentry); 
     1026+               else 
     1027+                       err = vfs_unlink(upperdir->d_inode, realpath.dentry); 
     1028+               if (err) 
     1029+                       goto out_d_drop; 
     1030+ 
     1031+               ovl_dentry_version_inc(dentry->d_parent); 
     1032+       } 
     1033+ 
     1034+       if (type != OVL_PATH_UPPER || ovl_dentry_is_opaque(dentry)) 
     1035+               err = ovl_whiteout(upperdir, dentry); 
     1036+ 
     1037+       /* 
     1038+        * Keeping this dentry hashed would mean having to release 
     1039+        * upperpath/lowerpath, which could only be done if we are the 
     1040+        * sole user of this dentry.  Too tricky...  Just unhash for 
     1041+        * now. 
     1042+        */ 
     1043+out_d_drop: 
     1044+       d_drop(dentry); 
     1045+       mutex_unlock(&upperdir->d_inode->i_mutex); 
     1046+ 
     1047+       return err; 
     1048+} 
     1049+ 
     1050+static int ovl_unlink(struct inode *dir, struct dentry *dentry) 
     1051+{ 
     1052+       return ovl_do_remove(dentry, false); 
     1053+} 
     1054+ 
     1055+ 
     1056+static int ovl_rmdir(struct inode *dir, struct dentry *dentry) 
     1057+{ 
     1058+       int err; 
     1059+       enum ovl_path_type type; 
     1060+ 
     1061+       type = ovl_path_type(dentry); 
     1062+       if (type != OVL_PATH_UPPER) { 
     1063+               err = ovl_check_empty_and_clear(dentry, type); 
     1064+               if (err) 
     1065+                       return err; 
     1066+       } 
     1067+ 
     1068+       return ovl_do_remove(dentry, true); 
     1069+} 
     1070+ 
     1071+static int ovl_link(struct dentry *old, struct inode *newdir, 
     1072+                   struct dentry *new) 
     1073+{ 
     1074+       int err; 
     1075+       struct dentry *olddentry; 
     1076+       struct dentry *newdentry; 
     1077+       struct dentry *upperdir; 
     1078+ 
     1079+       err = ovl_copy_up(old); 
     1080+       if (err) 
     1081+               goto out; 
     1082+ 
     1083+       err = ovl_copy_up(new->d_parent); 
     1084+       if (err) 
     1085+               goto out; 
     1086+ 
     1087+       upperdir = ovl_dentry_upper(new->d_parent); 
     1088+       mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
     1089+       newdentry = ovl_lookup_create(upperdir, new); 
     1090+       err = PTR_ERR(newdentry); 
     1091+       if (IS_ERR(newdentry)) 
     1092+               goto out_unlock; 
     1093+ 
     1094+       olddentry = ovl_dentry_upper(old); 
     1095+       err = vfs_link(olddentry, upperdir->d_inode, newdentry); 
     1096+       if (!err) { 
     1097+               if (WARN_ON(!newdentry->d_inode)) { 
     1098+                       dput(newdentry); 
     1099+                       err = -ENOENT; 
     1100+                       goto out_unlock; 
     1101+               } 
     1102+ 
     1103+               ovl_dentry_version_inc(new->d_parent); 
     1104+               ovl_dentry_update(new, newdentry); 
     1105+ 
     1106+               ihold(old->d_inode); 
     1107+               d_instantiate(new, old->d_inode); 
     1108+       } else { 
     1109+               if (ovl_dentry_is_opaque(new)) 
     1110+                       ovl_whiteout(upperdir, new); 
     1111+               dput(newdentry); 
     1112+       } 
     1113+out_unlock: 
     1114+       mutex_unlock(&upperdir->d_inode->i_mutex); 
     1115+out: 
     1116+       return err; 
     1117+ 
     1118+} 
     1119+ 
     1120+static int ovl_rename(struct inode *olddir, struct dentry *old, 
     1121+                       struct inode *newdir, struct dentry *new) 
     1122+{ 
     1123+       int err; 
     1124+       enum ovl_path_type old_type; 
     1125+       enum ovl_path_type new_type; 
     1126+       struct dentry *old_upperdir; 
     1127+       struct dentry *new_upperdir; 
     1128+       struct dentry *olddentry; 
     1129+       struct dentry *newdentry; 
     1130+       struct dentry *trap; 
     1131+       bool old_opaque; 
     1132+       bool new_opaque; 
     1133+       bool new_create = false; 
     1134+       bool is_dir = S_ISDIR(old->d_inode->i_mode); 
     1135+ 
     1136+       /* Don't copy up directory trees */ 
     1137+       old_type = ovl_path_type(old); 
     1138+       if (old_type != OVL_PATH_UPPER && is_dir) 
     1139+               return -EXDEV; 
     1140+ 
     1141+       if (new->d_inode) { 
     1142+               new_type = ovl_path_type(new); 
     1143+ 
     1144+               if (new_type == OVL_PATH_LOWER && old_type == OVL_PATH_LOWER) { 
     1145+                       if (ovl_dentry_lower(old)->d_inode == 
     1146+                           ovl_dentry_lower(new)->d_inode) 
     1147+                               return 0; 
     1148+               } 
     1149+               if (new_type != OVL_PATH_LOWER && old_type != OVL_PATH_LOWER) { 
     1150+                       if (ovl_dentry_upper(old)->d_inode == 
     1151+                           ovl_dentry_upper(new)->d_inode) 
     1152+                               return 0; 
     1153+               } 
     1154+ 
     1155+               if (new_type != OVL_PATH_UPPER && 
     1156+                   S_ISDIR(new->d_inode->i_mode)) { 
     1157+                       err = ovl_check_empty_and_clear(new, new_type); 
     1158+                       if (err) 
     1159+                               return err; 
     1160+               } 
     1161+       } else { 
     1162+               new_type = OVL_PATH_UPPER; 
     1163+       } 
     1164+ 
     1165+       err = ovl_copy_up(old); 
     1166+       if (err) 
     1167+               return err; 
     1168+ 
     1169+       err = ovl_copy_up(new->d_parent); 
     1170+       if (err) 
     1171+               return err; 
     1172+ 
     1173+       old_upperdir = ovl_dentry_upper(old->d_parent); 
     1174+       new_upperdir = ovl_dentry_upper(new->d_parent); 
     1175+ 
     1176+       trap = lock_rename(new_upperdir, old_upperdir); 
     1177+ 
     1178+       olddentry = ovl_dentry_upper(old); 
     1179+       newdentry = ovl_dentry_upper(new); 
     1180+       if (newdentry) { 
     1181+               dget(newdentry); 
     1182+       } else { 
     1183+               new_create = true; 
     1184+               newdentry = ovl_lookup_create(new_upperdir, new); 
     1185+               err = PTR_ERR(newdentry); 
     1186+               if (IS_ERR(newdentry)) 
     1187+                       goto out_unlock; 
     1188+       } 
     1189+ 
     1190+       err = -ESTALE; 
     1191+       if (olddentry->d_parent != old_upperdir) 
     1192+               goto out_dput; 
     1193+       if (newdentry->d_parent != new_upperdir) 
     1194+               goto out_dput; 
     1195+       if (olddentry == trap) 
     1196+               goto out_dput; 
     1197+       if (newdentry == trap) 
     1198+               goto out_dput; 
     1199+ 
     1200+       old_opaque = ovl_dentry_is_opaque(old); 
     1201+       new_opaque = ovl_dentry_is_opaque(new) || new_type != OVL_PATH_UPPER; 
     1202+ 
     1203+       if (is_dir && !old_opaque && new_opaque) { 
     1204+               err = ovl_set_opaque(olddentry); 
     1205+               if (err) 
     1206+                       goto out_dput; 
     1207+       } 
     1208+ 
     1209+       err = vfs_rename(old_upperdir->d_inode, olddentry, 
     1210+                        new_upperdir->d_inode, newdentry); 
     1211+ 
     1212+       if (err) { 
     1213+               if (new_create && ovl_dentry_is_opaque(new)) 
     1214+                       ovl_whiteout(new_upperdir, new); 
     1215+               if (is_dir && !old_opaque && new_opaque) 
     1216+                       ovl_remove_opaque(olddentry); 
     1217+               goto out_dput; 
     1218+       } 
     1219+ 
     1220+       if (old_type != OVL_PATH_UPPER || old_opaque) 
     1221+               err = ovl_whiteout(old_upperdir, old); 
     1222+       if (is_dir && old_opaque && !new_opaque) 
     1223+               ovl_remove_opaque(olddentry); 
     1224+ 
     1225+       if (old_opaque != new_opaque) 
     1226+               ovl_dentry_set_opaque(old, new_opaque); 
     1227+ 
     1228+       ovl_dentry_version_inc(old->d_parent); 
     1229+       ovl_dentry_version_inc(new->d_parent); 
     1230+ 
     1231+out_dput: 
     1232+       dput(newdentry); 
     1233+out_unlock: 
     1234+       unlock_rename(new_upperdir, old_upperdir); 
     1235+       return err; 
     1236+} 
     1237+ 
     1238+const struct inode_operations ovl_dir_inode_operations = { 
     1239+       .lookup         = ovl_lookup, 
     1240+       .mkdir          = ovl_mkdir, 
     1241+       .symlink        = ovl_symlink, 
     1242+       .unlink         = ovl_unlink, 
     1243+       .rmdir          = ovl_rmdir, 
     1244+       .rename         = ovl_rename, 
     1245+       .link           = ovl_link, 
     1246+       .setattr        = ovl_setattr, 
     1247+       .create         = ovl_create, 
     1248+       .mknod          = ovl_mknod, 
     1249+       .permission     = ovl_permission, 
     1250+       .getattr        = ovl_dir_getattr, 
     1251+       .setxattr       = ovl_setxattr, 
     1252+       .getxattr       = ovl_getxattr, 
     1253+       .listxattr      = ovl_listxattr, 
     1254+       .removexattr    = ovl_removexattr, 
     1255+}; 
     1256--- /dev/null 
     1257+++ b/fs/overlayfs/inode.c 
     1258@@ -0,0 +1,375 @@ 
     1259+/* 
     1260+ * 
     1261+ * Copyright (C) 2011 Novell Inc. 
     1262+ * 
     1263+ * This program is free software; you can redistribute it and/or modify it 
     1264+ * under the terms of the GNU General Public License version 2 as published by 
     1265+ * the Free Software Foundation. 
     1266+ */ 
     1267+ 
     1268+#include <linux/fs.h> 
     1269+#include <linux/slab.h> 
     1270+#include <linux/xattr.h> 
     1271+#include "overlayfs.h" 
     1272+ 
     1273+int ovl_setattr(struct dentry *dentry, struct iattr *attr) 
     1274+{ 
     1275+       struct dentry *upperdentry; 
     1276+       int err; 
     1277+ 
     1278+       if ((attr->ia_valid & ATTR_SIZE) && !ovl_dentry_upper(dentry)) 
     1279+               err = ovl_copy_up_truncate(dentry, attr->ia_size); 
     1280+       else 
     1281+               err = ovl_copy_up(dentry); 
     1282+       if (err) 
     1283+               return err; 
     1284+ 
     1285+       upperdentry = ovl_dentry_upper(dentry); 
     1286+ 
     1287+       if (attr->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID)) 
     1288+               attr->ia_valid &= ~ATTR_MODE; 
     1289+ 
     1290+       mutex_lock(&upperdentry->d_inode->i_mutex); 
     1291+       err = notify_change(upperdentry, attr); 
     1292+       mutex_unlock(&upperdentry->d_inode->i_mutex); 
     1293+ 
     1294+       return err; 
     1295+} 
     1296+ 
     1297+static int ovl_getattr(struct vfsmount *mnt, struct dentry *dentry, 
     1298+                        struct kstat *stat) 
     1299+{ 
     1300+       struct path realpath; 
     1301+ 
     1302+       ovl_path_real(dentry, &realpath); 
     1303+       return vfs_getattr(realpath.mnt, realpath.dentry, stat); 
     1304+} 
     1305+ 
     1306+int ovl_permission(struct inode *inode, int mask, unsigned int flags) 
     1307+{ 
     1308+       struct ovl_entry *oe; 
     1309+       struct dentry *alias = NULL; 
     1310+       struct inode *realinode; 
     1311+       struct dentry *realdentry; 
     1312+       bool is_upper; 
     1313+       int err; 
     1314+ 
     1315+       if (S_ISDIR(inode->i_mode)) { 
     1316+               oe = inode->i_private; 
     1317+       } else if (flags & IPERM_FLAG_RCU) { 
     1318+               return -ECHILD; 
     1319+       } else { 
     1320+               /* 
     1321+                * For non-directories find an alias and get the info 
     1322+                * from there. 
     1323+                */ 
     1324+               spin_lock(&inode->i_lock); 
     1325+               if (WARN_ON(list_empty(&inode->i_dentry))) { 
     1326+                       spin_unlock(&inode->i_lock); 
     1327+                       return -ENOENT; 
     1328+               } 
     1329+               alias = list_entry(inode->i_dentry.next, struct dentry, d_alias); 
     1330+               dget(alias); 
     1331+               spin_unlock(&inode->i_lock); 
     1332+               oe = alias->d_fsdata; 
     1333+       } 
     1334+ 
     1335+       realdentry = ovl_entry_real(oe, &is_upper); 
     1336+ 
     1337+       /* Careful in RCU walk mode */ 
     1338+       realinode = ACCESS_ONCE(realdentry->d_inode); 
     1339+       if (!realinode) { 
     1340+               WARN_ON(!(flags & IPERM_FLAG_RCU)); 
     1341+               err = -ENOENT; 
     1342+               goto out_dput; 
     1343+       } 
     1344+ 
     1345+       if (mask & MAY_WRITE) { 
     1346+               umode_t mode = realinode->i_mode; 
     1347+ 
     1348+               /* 
     1349+                * Writes will always be redirected to upper layer, so 
     1350+                * ignore lower layer being read-only. 
     1351+                */ 
     1352+               err = -EROFS; 
     1353+               if (is_upper && IS_RDONLY(realinode) && 
     1354+                   (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))) 
     1355+                       goto out_dput; 
     1356+ 
     1357+               /* 
     1358+                * Nobody gets write access to an immutable file. 
     1359+                */ 
     1360+               err = -EACCES; 
     1361+               if (IS_IMMUTABLE(realinode)) 
     1362+                       goto out_dput; 
     1363+       } 
     1364+ 
     1365+       if (realinode->i_op->permission) 
     1366+               err = realinode->i_op->permission(realinode, mask, flags); 
     1367+       else 
     1368+               err = generic_permission(realinode, mask, flags, 
     1369+                                        realinode->i_op->check_acl); 
     1370+out_dput: 
     1371+       dput(alias); 
     1372+       return err; 
     1373+} 
     1374+ 
     1375+ 
     1376+struct ovl_link_data { 
     1377+       struct dentry *realdentry; 
     1378+       void *cookie; 
     1379+}; 
     1380+ 
     1381+static void *ovl_follow_link(struct dentry *dentry, struct nameidata *nd) 
     1382+{ 
     1383+       void *ret; 
     1384+       struct dentry *realdentry; 
     1385+       struct inode *realinode; 
     1386+ 
     1387+       realdentry = ovl_dentry_real(dentry); 
     1388+       realinode = realdentry->d_inode; 
     1389+ 
     1390+       if (WARN_ON(!realinode->i_op->follow_link)) 
     1391+               return ERR_PTR(-EPERM); 
     1392+ 
     1393+       ret = realinode->i_op->follow_link(realdentry, nd); 
     1394+       if (IS_ERR(ret)) 
     1395+               return ret; 
     1396+ 
     1397+       if (realinode->i_op->put_link) { 
     1398+               struct ovl_link_data *data; 
     1399+ 
     1400+               data = kmalloc(sizeof(struct ovl_link_data), GFP_KERNEL); 
     1401+               if (!data) { 
     1402+                       realinode->i_op->put_link(realdentry, nd, ret); 
     1403+                       return ERR_PTR(-ENOMEM); 
     1404+               } 
     1405+               data->realdentry = realdentry; 
     1406+               data->cookie = ret; 
     1407+ 
     1408+               return data; 
     1409+       } else { 
     1410+               return NULL; 
     1411+       } 
     1412+} 
     1413+ 
     1414+static void ovl_put_link(struct dentry *dentry, struct nameidata *nd, void *c) 
     1415+{ 
     1416+       struct inode *realinode; 
     1417+       struct ovl_link_data *data = c; 
     1418+ 
     1419+       if (!data) 
     1420+               return; 
     1421+ 
     1422+       realinode = data->realdentry->d_inode; 
     1423+       realinode->i_op->put_link(data->realdentry, nd, data->cookie); 
     1424+       kfree(data); 
     1425+} 
     1426+ 
     1427+static int ovl_readlink(struct dentry *dentry, char __user *buf, int bufsiz) 
     1428+{ 
     1429+       struct path realpath; 
     1430+       struct inode *realinode; 
     1431+ 
     1432+       ovl_path_real(dentry, &realpath); 
     1433+       realinode = realpath.dentry->d_inode; 
     1434+ 
     1435+       if (!realinode->i_op->readlink) 
     1436+               return -EINVAL; 
     1437+ 
     1438+       touch_atime(realpath.mnt, realpath.dentry); 
     1439+ 
     1440+       return realinode->i_op->readlink(realpath.dentry, buf, bufsiz); 
     1441+} 
     1442+ 
     1443+ 
     1444+static bool ovl_is_private_xattr(const char *name) 
     1445+{ 
     1446+       return strncmp(name, "trusted.overlay.", 14) == 0; 
     1447+} 
     1448+ 
     1449+int ovl_setxattr(struct dentry *dentry, const char *name, 
     1450+                const void *value, size_t size, int flags) 
     1451+{ 
     1452+       int err; 
     1453+       struct dentry *upperdentry; 
     1454+ 
     1455+       if (ovl_is_private_xattr(name)) 
     1456+               return -EPERM; 
     1457+ 
     1458+       err = ovl_copy_up(dentry); 
     1459+       if (err) 
     1460+               return err; 
     1461+ 
     1462+       upperdentry = ovl_dentry_upper(dentry); 
     1463+       return  vfs_setxattr(upperdentry, name, value, size, flags); 
     1464+} 
     1465+ 
     1466+ssize_t ovl_getxattr(struct dentry *dentry, const char *name, 
     1467+                    void *value, size_t size) 
     1468+{ 
     1469+       if (ovl_path_type(dentry->d_parent) == OVL_PATH_MERGE && 
     1470+           ovl_is_private_xattr(name)) 
     1471+               return -ENODATA; 
     1472+ 
     1473+       return vfs_getxattr(ovl_dentry_real(dentry), name, value, size); 
     1474+} 
     1475+ 
     1476+ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size) 
     1477+{ 
     1478+       ssize_t res; 
     1479+       int off; 
     1480+ 
     1481+       res = vfs_listxattr(ovl_dentry_real(dentry), list, size); 
     1482+       if (res <= 0 || size == 0) 
     1483+               return res; 
     1484+ 
     1485+       if (ovl_path_type(dentry->d_parent) != OVL_PATH_MERGE) 
     1486+               return res; 
     1487+ 
     1488+       /* filter out private xattrs */ 
     1489+       for (off = 0; off < res;) { 
     1490+               char *s = list + off; 
     1491+               size_t slen = strlen(s) + 1; 
     1492+ 
     1493+               BUG_ON(off + slen > res); 
     1494+ 
     1495+               if (ovl_is_private_xattr(s)) { 
     1496+                       res -= slen; 
     1497+                       memmove(s, s + slen, res - off); 
     1498+               } else { 
     1499+                       off += slen; 
     1500+               } 
     1501+       } 
     1502+ 
     1503+       return res; 
     1504+} 
     1505+ 
     1506+int ovl_removexattr(struct dentry *dentry, const char *name) 
     1507+{ 
     1508+       int err; 
     1509+       struct path realpath; 
     1510+       enum ovl_path_type type; 
     1511+ 
     1512+       if (ovl_path_type(dentry->d_parent) == OVL_PATH_MERGE && 
     1513+           ovl_is_private_xattr(name)) 
     1514+               return -ENODATA; 
     1515+ 
     1516+       type = ovl_path_real(dentry, &realpath); 
     1517+       if (type == OVL_PATH_LOWER) { 
     1518+               err = vfs_getxattr(realpath.dentry, name, NULL, 0); 
     1519+               if (err < 0) 
     1520+                       return err; 
     1521+ 
     1522+               err = ovl_copy_up(dentry); 
     1523+               if (err) 
     1524+                       return err; 
     1525+ 
     1526+               ovl_path_upper(dentry, &realpath); 
     1527+       } 
     1528+ 
     1529+       return vfs_removexattr(realpath.dentry, name); 
     1530+} 
     1531+ 
     1532+static bool ovl_open_need_copy_up(int flags, enum ovl_path_type type, 
     1533+                                 struct dentry *realdentry) 
     1534+{ 
     1535+       if (type != OVL_PATH_LOWER) 
     1536+               return false; 
     1537+ 
     1538+       if (special_file(realdentry->d_inode->i_mode)) 
     1539+               return false; 
     1540+ 
     1541+       if (!(OPEN_FMODE(flags) & FMODE_WRITE) && !(flags & O_TRUNC)) 
     1542+               return false; 
     1543+ 
     1544+       return true; 
     1545+} 
     1546+ 
     1547+static struct file *ovl_open(struct dentry *dentry, int flags, 
     1548+                            const struct cred *cred) 
     1549+{ 
     1550+       int err; 
     1551+       struct path realpath; 
     1552+       enum ovl_path_type type; 
     1553+ 
     1554+       type = ovl_path_real(dentry, &realpath); 
     1555+       if (ovl_open_need_copy_up(flags, type, realpath.dentry)) { 
     1556+               if (flags & O_TRUNC) 
     1557+                       err = ovl_copy_up_truncate(dentry, 0); 
     1558+               else 
     1559+                       err = ovl_copy_up(dentry); 
     1560+               if (err) 
     1561+                       return ERR_PTR(err); 
     1562+ 
     1563+               ovl_path_upper(dentry, &realpath); 
     1564+       } 
     1565+ 
     1566+       return vfs_open(&realpath, flags, cred); 
     1567+} 
     1568+ 
     1569+static const struct inode_operations ovl_file_inode_operations = { 
     1570+       .setattr        = ovl_setattr, 
     1571+       .permission     = ovl_permission, 
     1572+       .getattr        = ovl_getattr, 
     1573+       .setxattr       = ovl_setxattr, 
     1574+       .getxattr       = ovl_getxattr, 
     1575+       .listxattr      = ovl_listxattr, 
     1576+       .removexattr    = ovl_removexattr, 
     1577+       .open           = ovl_open, 
     1578+}; 
     1579+ 
     1580+static const struct inode_operations ovl_symlink_inode_operations = { 
     1581+       .setattr        = ovl_setattr, 
     1582+       .follow_link    = ovl_follow_link, 
     1583+       .put_link       = ovl_put_link, 
     1584+       .readlink       = ovl_readlink, 
     1585+       .getattr        = ovl_getattr, 
     1586+       .setxattr       = ovl_setxattr, 
     1587+       .getxattr       = ovl_getxattr, 
     1588+       .listxattr      = ovl_listxattr, 
     1589+       .removexattr    = ovl_removexattr, 
     1590+}; 
     1591+ 
     1592+struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, 
     1593+                           struct ovl_entry *oe) 
     1594+{ 
     1595+       struct inode *inode; 
     1596+ 
     1597+       inode = new_inode(sb); 
     1598+       if (!inode) 
     1599+               return NULL; 
     1600+ 
     1601+       mode &= S_IFMT; 
     1602+ 
     1603+       inode->i_ino = get_next_ino(); 
     1604+       inode->i_mode = mode; 
     1605+       inode->i_flags |= S_NOATIME | S_NOCMTIME; 
     1606+ 
     1607+       switch (mode) { 
     1608+       case S_IFDIR: 
     1609+               inode->i_private = oe; 
     1610+               inode->i_op = &ovl_dir_inode_operations; 
     1611+               inode->i_fop = &ovl_dir_operations; 
     1612+               break; 
     1613+ 
     1614+       case S_IFLNK: 
     1615+               inode->i_op = &ovl_symlink_inode_operations; 
     1616+               break; 
     1617+ 
     1618+       case S_IFREG: 
     1619+       case S_IFSOCK: 
     1620+       case S_IFBLK: 
     1621+       case S_IFCHR: 
     1622+       case S_IFIFO: 
     1623+               inode->i_op = &ovl_file_inode_operations; 
     1624+               break; 
     1625+ 
     1626+       default: 
     1627+               WARN(1, "illegal file type: %i\n", mode); 
     1628+               inode = NULL; 
     1629+       } 
     1630+ 
     1631+       return inode; 
     1632+ 
     1633+} 
     1634--- /dev/null 
     1635+++ b/fs/overlayfs/overlayfs.h 
     1636@@ -0,0 +1,62 @@ 
     1637+/* 
     1638+ * 
     1639+ * Copyright (C) 2011 Novell Inc. 
     1640+ * 
     1641+ * This program is free software; you can redistribute it and/or modify it 
     1642+ * under the terms of the GNU General Public License version 2 as published by 
     1643+ * the Free Software Foundation. 
     1644+ */ 
     1645+ 
     1646+struct ovl_entry; 
     1647+ 
     1648+enum ovl_path_type { 
     1649+       OVL_PATH_UPPER, 
     1650+       OVL_PATH_MERGE, 
     1651+       OVL_PATH_LOWER, 
     1652+}; 
     1653+ 
     1654+extern const char *ovl_opaque_xattr; 
     1655+extern const char *ovl_whiteout_xattr; 
     1656+extern const struct dentry_operations ovl_dentry_operations; 
     1657+ 
     1658+enum ovl_path_type ovl_path_type(struct dentry *dentry); 
     1659+u64 ovl_dentry_version_get(struct dentry *dentry); 
     1660+void ovl_dentry_version_inc(struct dentry *dentry); 
     1661+void ovl_path_upper(struct dentry *dentry, struct path *path); 
     1662+void ovl_path_lower(struct dentry *dentry, struct path *path); 
     1663+enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path); 
     1664+struct dentry *ovl_dentry_upper(struct dentry *dentry); 
     1665+struct dentry *ovl_dentry_lower(struct dentry *dentry); 
     1666+struct dentry *ovl_dentry_real(struct dentry *dentry); 
     1667+struct dentry *ovl_entry_real(struct ovl_entry *oe, bool *is_upper); 
     1668+bool ovl_dentry_is_opaque(struct dentry *dentry); 
     1669+void ovl_dentry_set_opaque(struct dentry *dentry, bool opaque); 
     1670+bool ovl_is_whiteout(struct dentry *dentry); 
     1671+void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry); 
     1672+int ovl_do_lookup(struct dentry *dentry); 
     1673+ 
     1674+struct dentry *ovl_upper_create(struct dentry *upperdir, struct dentry *dentry, 
     1675+                               struct kstat *stat, const char *link); 
     1676+ 
     1677+/* readdir.c */ 
     1678+extern const struct file_operations ovl_dir_operations; 
     1679+int ovl_check_empty_and_clear(struct dentry *dentry, enum ovl_path_type type); 
     1680+ 
     1681+/* inode.c */ 
     1682+int ovl_setattr(struct dentry *dentry, struct iattr *attr); 
     1683+int ovl_permission(struct inode *inode, int mask, unsigned int flags); 
     1684+int ovl_setxattr(struct dentry *dentry, const char *name, 
     1685+                const void *value, size_t size, int flags); 
     1686+ssize_t ovl_getxattr(struct dentry *dentry, const char *name, 
     1687+                    void *value, size_t size); 
     1688+ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size); 
     1689+int ovl_removexattr(struct dentry *dentry, const char *name); 
     1690+ 
     1691+struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, 
     1692+                           struct ovl_entry *oe); 
     1693+/* dir.c */ 
     1694+extern const struct inode_operations ovl_dir_inode_operations; 
     1695+ 
     1696+/* copy_up.c */ 
     1697+int ovl_copy_up(struct dentry *dentry); 
     1698+int ovl_copy_up_truncate(struct dentry *dentry, loff_t size); 
     1699--- /dev/null 
     1700+++ b/fs/overlayfs/readdir.c 
     1701@@ -0,0 +1,558 @@ 
     1702+/* 
     1703+ * 
     1704+ * Copyright (C) 2011 Novell Inc. 
     1705+ * 
     1706+ * This program is free software; you can redistribute it and/or modify it 
     1707+ * under the terms of the GNU General Public License version 2 as published by 
     1708+ * the Free Software Foundation. 
     1709+ */ 
     1710+ 
     1711+#include <linux/fs.h> 
     1712+#include <linux/slab.h> 
     1713+#include <linux/namei.h> 
     1714+#include <linux/file.h> 
     1715+#include <linux/xattr.h> 
     1716+#include <linux/rbtree.h> 
     1717+#include <linux/security.h> 
     1718+#include "overlayfs.h" 
     1719+ 
     1720+struct ovl_cache_entry { 
     1721+       const char *name; 
     1722+       unsigned int len; 
     1723+       unsigned int type; 
     1724+       u64 ino; 
     1725+       bool is_whiteout; 
     1726+       struct list_head l_node; 
     1727+       struct rb_node node; 
     1728+}; 
     1729+ 
     1730+struct ovl_readdir_data { 
     1731+       struct rb_root *root; 
     1732+       struct list_head *list; 
     1733+       struct list_head *middle; 
     1734+       struct dentry *dir; 
     1735+       int count; 
     1736+       int err; 
     1737+}; 
     1738+ 
     1739+struct ovl_dir_file { 
     1740+       bool is_real; 
     1741+       bool is_cached; 
     1742+       struct list_head cursor; 
     1743+       u64 cache_version; 
     1744+       struct list_head cache; 
     1745+       struct file *realfile; 
     1746+}; 
     1747+ 
     1748+static struct ovl_cache_entry *ovl_cache_entry_from_node(struct rb_node *n) 
     1749+{ 
     1750+       return container_of(n, struct ovl_cache_entry, node); 
     1751+} 
     1752+ 
     1753+static struct ovl_cache_entry *ovl_cache_entry_find(struct rb_root *root, 
     1754+                                                   const char *name, int len) 
     1755+{ 
     1756+       struct rb_node *node = root->rb_node; 
     1757+       int cmp; 
     1758+ 
     1759+       while (node) { 
     1760+               struct ovl_cache_entry *p = ovl_cache_entry_from_node(node); 
     1761+ 
     1762+               cmp = strncmp(name, p->name, len); 
     1763+               if (cmp > 0) 
     1764+                       node = p->node.rb_right; 
     1765+               else if (cmp < 0 || len < p->len) 
     1766+                       node = p->node.rb_left; 
     1767+               else 
     1768+                       return p; 
     1769+       } 
     1770+ 
     1771+       return NULL; 
     1772+} 
     1773+ 
     1774+static struct ovl_cache_entry *ovl_cache_entry_new(const char *name, int len, 
     1775+                                                  u64 ino, unsigned int d_type) 
     1776+{ 
     1777+       struct ovl_cache_entry *p; 
     1778+ 
     1779+       p = kmalloc(sizeof(*p) + len + 1, GFP_KERNEL); 
     1780+       if (p) { 
     1781+               char *name_copy = (char *) (p + 1); 
     1782+               memcpy(name_copy, name, len); 
     1783+               name_copy[len] = '\0'; 
     1784+               p->name = name_copy; 
     1785+               p->len = len; 
     1786+               p->type = d_type; 
     1787+               p->ino = ino; 
     1788+               p->is_whiteout = false; 
     1789+       } 
     1790+ 
     1791+       return p; 
     1792+} 
     1793+ 
     1794+static int ovl_cache_entry_add_rb(struct ovl_readdir_data *rdd, 
     1795+                                 const char *name, int len, u64 ino, 
     1796+                                 unsigned int d_type) 
     1797+{ 
     1798+       struct rb_node **newp = &rdd->root->rb_node; 
     1799+       struct rb_node *parent = NULL; 
     1800+       struct ovl_cache_entry *p; 
     1801+ 
     1802+       while (*newp) { 
     1803+               int cmp; 
     1804+               struct ovl_cache_entry *tmp; 
     1805+ 
     1806+               parent = *newp; 
     1807+               tmp = ovl_cache_entry_from_node(*newp); 
     1808+               cmp = strncmp(name, tmp->name, len); 
     1809+               if (cmp > 0) 
     1810+                       newp = &tmp->node.rb_right; 
     1811+               else if (cmp < 0 || len < tmp->len) 
     1812+                       newp = &tmp->node.rb_left; 
     1813+               else 
     1814+                       return 0; 
     1815+       } 
     1816+ 
     1817+       p = ovl_cache_entry_new(name, len, ino, d_type); 
     1818+       if (p == NULL) 
     1819+               return -ENOMEM; 
     1820+ 
     1821+       list_add_tail(&p->l_node, rdd->list); 
     1822+       rb_link_node(&p->node, parent, newp); 
     1823+       rb_insert_color(&p->node, rdd->root); 
     1824+ 
     1825+       return 0; 
     1826+} 
     1827+ 
     1828+static int ovl_fill_lower(void *buf, const char *name, int namelen, 
     1829+                           loff_t offset, u64 ino, unsigned int d_type) 
     1830+{ 
     1831+       struct ovl_readdir_data *rdd = buf; 
     1832+       struct ovl_cache_entry *p; 
     1833+ 
     1834+       rdd->count++; 
     1835+       p = ovl_cache_entry_find(rdd->root, name, namelen); 
     1836+       if (p) { 
     1837+               list_move_tail(&p->l_node, rdd->middle); 
     1838+       } else { 
     1839+               p = ovl_cache_entry_new(name, namelen, ino, d_type); 
     1840+               if (p == NULL) 
     1841+                       rdd->err = -ENOMEM; 
     1842+               else 
     1843+                       list_add_tail(&p->l_node, rdd->middle); 
     1844+       } 
     1845+ 
     1846+       return rdd->err; 
     1847+} 
     1848+ 
     1849+static void ovl_cache_free(struct list_head *list) 
     1850+{ 
     1851+       struct ovl_cache_entry *p; 
     1852+       struct ovl_cache_entry *n; 
     1853+ 
     1854+       list_for_each_entry_safe(p, n, list, l_node) 
     1855+               kfree(p); 
     1856+ 
     1857+       INIT_LIST_HEAD(list); 
     1858+} 
     1859+ 
     1860+static int ovl_fill_upper(void *buf, const char *name, int namelen, 
     1861+                         loff_t offset, u64 ino, unsigned int d_type) 
     1862+{ 
     1863+       struct ovl_readdir_data *rdd = buf; 
     1864+ 
     1865+       rdd->count++; 
     1866+       return ovl_cache_entry_add_rb(rdd, name, namelen, ino, d_type); 
     1867+} 
     1868+ 
     1869+static int ovl_dir_read(struct path *realpath, struct ovl_readdir_data *rdd, 
     1870+                         filldir_t filler) 
     1871+{ 
     1872+       struct file *realfile; 
     1873+       int err; 
     1874+ 
     1875+       realfile = vfs_open(realpath, O_RDONLY | O_DIRECTORY, current_cred()); 
     1876+       if (IS_ERR(realfile)) 
     1877+               return PTR_ERR(realfile); 
     1878+ 
     1879+       do { 
     1880+               rdd->count = 0; 
     1881+               rdd->err = 0; 
     1882+               err = vfs_readdir(realfile, filler, rdd); 
     1883+               if (err >= 0) 
     1884+                       err = rdd->err; 
     1885+       } while (!err && rdd->count); 
     1886+       fput(realfile); 
     1887+ 
     1888+       return 0; 
     1889+} 
     1890+ 
     1891+static void ovl_dir_reset(struct file *file) 
     1892+{ 
     1893+       struct ovl_dir_file *od = file->private_data; 
     1894+       enum ovl_path_type type = ovl_path_type(file->f_path.dentry); 
     1895+ 
     1896+       if (ovl_dentry_version_get(file->f_path.dentry) != od->cache_version) { 
     1897+               list_del_init(&od->cursor); 
     1898+               ovl_cache_free(&od->cache); 
     1899+               od->is_cached = false; 
     1900+       } 
     1901+       WARN_ON(!od->is_real && type != OVL_PATH_MERGE); 
     1902+       if (od->is_real && type == OVL_PATH_MERGE) { 
     1903+               fput(od->realfile); 
     1904+               od->realfile = NULL; 
     1905+               od->is_real = false; 
     1906+       } 
     1907+} 
     1908+ 
     1909+static int ovl_dir_mark_whiteouts(struct ovl_readdir_data *rdd) 
     1910+{ 
     1911+       struct ovl_cache_entry *p; 
     1912+       struct dentry *dentry; 
     1913+       const struct cred *old_cred; 
     1914+       struct cred *override_cred; 
     1915+ 
     1916+       override_cred = prepare_creds(); 
     1917+       if (!override_cred) { 
     1918+               ovl_cache_free(rdd->list); 
     1919+               return -ENOMEM; 
     1920+       } 
     1921+ 
     1922+       /* 
     1923+        * CAP_SYS_ADMIN for getxattr 
     1924+        * CAP_DAC_OVERRIDE for lookup 
     1925+        */ 
     1926+       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     1927+       cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 
     1928+       old_cred = override_creds(override_cred); 
     1929+ 
     1930+       mutex_lock(&rdd->dir->d_inode->i_mutex); 
     1931+       list_for_each_entry(p, rdd->list, l_node) { 
     1932+               if (p->type != DT_LNK) 
     1933+                       continue; 
     1934+ 
     1935+               dentry = lookup_one_len(p->name, rdd->dir, p->len); 
     1936+               if (IS_ERR(dentry)) 
     1937+                       continue; 
     1938+ 
     1939+               p->is_whiteout = ovl_is_whiteout(dentry); 
     1940+               dput(dentry); 
     1941+       } 
     1942+       mutex_unlock(&rdd->dir->d_inode->i_mutex); 
     1943+ 
     1944+       revert_creds(old_cred); 
     1945+       put_cred(override_cred); 
     1946+ 
     1947+       return 0; 
     1948+} 
     1949+ 
     1950+static int ovl_dir_read_merged(struct path *upperpath, struct path *lowerpath, 
     1951+                              struct ovl_readdir_data *rdd) 
     1952+{ 
     1953+       int err; 
     1954+       struct rb_root root = RB_ROOT; 
     1955+       struct list_head middle; 
     1956+ 
     1957+       rdd->root = &root; 
     1958+       if (upperpath->dentry) { 
     1959+               rdd->dir = upperpath->dentry; 
     1960+               err = ovl_dir_read(upperpath, rdd, ovl_fill_upper); 
     1961+               if (err) 
     1962+                       goto out; 
     1963+ 
     1964+               err = ovl_dir_mark_whiteouts(rdd); 
     1965+               if (err) 
     1966+                       goto out; 
     1967+       } 
     1968+       /* 
     1969+        * Insert lowerpath entries before upperpath ones, this allows 
     1970+        * offsets to be reasonably constant 
     1971+        */ 
     1972+       list_add(&middle, rdd->list); 
     1973+       rdd->middle = &middle; 
     1974+       err = ovl_dir_read(lowerpath, rdd, ovl_fill_lower); 
     1975+       list_del(&middle); 
     1976+out: 
     1977+       rdd->root = NULL; 
     1978+ 
     1979+       return err; 
     1980+} 
     1981+ 
     1982+static void ovl_seek_cursor(struct ovl_dir_file *od, loff_t pos) 
     1983+{ 
     1984+       struct list_head *l; 
     1985+       loff_t off; 
     1986+ 
     1987+       l = od->cache.next; 
     1988+       for (off = 0; off < pos; off++) { 
     1989+               if (l == &od->cache) 
     1990+                       break; 
     1991+               l = l->next; 
     1992+       } 
     1993+       list_move_tail(&od->cursor, l); 
     1994+} 
     1995+ 
     1996+static int ovl_readdir(struct file *file, void *buf, filldir_t filler) 
     1997+{ 
     1998+       struct ovl_dir_file *od = file->private_data; 
     1999+       int res; 
     2000+ 
     2001+       if (!file->f_pos) 
     2002+               ovl_dir_reset(file); 
     2003+ 
     2004+       if (od->is_real) { 
     2005+               res = vfs_readdir(od->realfile, filler, buf); 
     2006+               file->f_pos = od->realfile->f_pos; 
     2007+ 
     2008+               return res; 
     2009+       } 
     2010+ 
     2011+       if (!od->is_cached) { 
     2012+               struct path lowerpath; 
     2013+               struct path upperpath; 
     2014+               struct ovl_readdir_data rdd = { .list = &od->cache }; 
     2015+ 
     2016+               ovl_path_lower(file->f_path.dentry, &lowerpath); 
     2017+               ovl_path_upper(file->f_path.dentry, &upperpath); 
     2018+ 
     2019+               res = ovl_dir_read_merged(&upperpath, &lowerpath, &rdd); 
     2020+               if (res) { 
     2021+                       ovl_cache_free(rdd.list); 
     2022+                       return res; 
     2023+               } 
     2024+ 
     2025+               od->cache_version = ovl_dentry_version_get(file->f_path.dentry); 
     2026+               od->is_cached = true; 
     2027+ 
     2028+               ovl_seek_cursor(od, file->f_pos); 
     2029+       } 
     2030+ 
     2031+       while (od->cursor.next != &od->cache) { 
     2032+               int over; 
     2033+               loff_t off; 
     2034+               struct ovl_cache_entry *p; 
     2035+ 
     2036+               p = list_entry(od->cursor.next, struct ovl_cache_entry, l_node); 
     2037+               off = file->f_pos; 
     2038+               if (!p->is_whiteout) { 
     2039+                       over = filler(buf, p->name, p->len, off, p->ino, p->type); 
     2040+                       if (over) 
     2041+                               break; 
     2042+               } 
     2043+               file->f_pos++; 
     2044+               list_move(&od->cursor, &p->l_node); 
     2045+       } 
     2046+ 
     2047+       return 0; 
     2048+} 
     2049+ 
     2050+static loff_t ovl_dir_llseek(struct file *file, loff_t offset, int origin) 
     2051+{ 
     2052+       loff_t res; 
     2053+       struct ovl_dir_file *od = file->private_data; 
     2054+ 
     2055+       mutex_lock(&file->f_dentry->d_inode->i_mutex); 
     2056+       if (!file->f_pos) 
     2057+               ovl_dir_reset(file); 
     2058+ 
     2059+       if (od->is_real) { 
     2060+               res = vfs_llseek(od->realfile, offset, origin); 
     2061+               file->f_pos = od->realfile->f_pos; 
     2062+       } else { 
     2063+               res = -EINVAL; 
     2064+ 
     2065+               switch (origin) { 
     2066+               case SEEK_CUR: 
     2067+                       offset += file->f_pos; 
     2068+                       break; 
     2069+               case SEEK_SET: 
     2070+                       break; 
     2071+               default: 
     2072+                       goto out_unlock; 
     2073+               } 
     2074+               if (offset < 0) 
     2075+                       goto out_unlock; 
     2076+ 
     2077+               if (offset != file->f_pos) { 
     2078+                       file->f_pos = offset; 
     2079+                       if (od->is_cached) 
     2080+                               ovl_seek_cursor(od, offset); 
     2081+               } 
     2082+               res = offset; 
     2083+       } 
     2084+out_unlock: 
     2085+       mutex_unlock(&file->f_dentry->d_inode->i_mutex); 
     2086+ 
     2087+       return res; 
     2088+} 
     2089+ 
     2090+static int ovl_dir_fsync(struct file *file, int datasync) 
     2091+{ 
     2092+       struct ovl_dir_file *od = file->private_data; 
     2093+ 
     2094+       /* May need to reopen directory if it got copied up */ 
     2095+       if (!od->realfile) { 
     2096+               struct path upperpath; 
     2097+ 
     2098+               ovl_path_upper(file->f_path.dentry, &upperpath); 
     2099+               od->realfile = vfs_open(&upperpath, O_RDONLY, current_cred()); 
     2100+               if (IS_ERR(od->realfile)) 
     2101+                       return PTR_ERR(od->realfile); 
     2102+       } 
     2103+ 
     2104+       return vfs_fsync(od->realfile, datasync); 
     2105+} 
     2106+ 
     2107+static int ovl_dir_release(struct inode *inode, struct file *file) 
     2108+{ 
     2109+       struct ovl_dir_file *od = file->private_data; 
     2110+ 
     2111+       list_del(&od->cursor); 
     2112+       ovl_cache_free(&od->cache); 
     2113+       if (od->realfile) 
     2114+               fput(od->realfile); 
     2115+       kfree(od); 
     2116+ 
     2117+       return 0; 
     2118+} 
     2119+ 
     2120+static int ovl_dir_open(struct inode *inode, struct file *file) 
     2121+{ 
     2122+       struct path realpath; 
     2123+       struct file *realfile; 
     2124+       struct ovl_dir_file *od; 
     2125+       enum ovl_path_type type; 
     2126+ 
     2127+       od = kzalloc(sizeof(struct ovl_dir_file), GFP_KERNEL); 
     2128+       if (!od) 
     2129+               return -ENOMEM; 
     2130+ 
     2131+       type = ovl_path_real(file->f_path.dentry, &realpath); 
     2132+       realfile = vfs_open(&realpath, file->f_flags, current_cred()); 
     2133+       if (IS_ERR(realfile)) { 
     2134+               kfree(od); 
     2135+               return PTR_ERR(realfile); 
     2136+       } 
     2137+       INIT_LIST_HEAD(&od->cache); 
     2138+       INIT_LIST_HEAD(&od->cursor); 
     2139+       od->is_cached = false; 
     2140+       od->realfile = realfile; 
     2141+       od->is_real = (type != OVL_PATH_MERGE); 
     2142+       file->private_data = od; 
     2143+ 
     2144+       return 0; 
     2145+} 
     2146+ 
     2147+const struct file_operations ovl_dir_operations = { 
     2148+       .read           = generic_read_dir, 
     2149+       .open           = ovl_dir_open, 
     2150+       .readdir        = ovl_readdir, 
     2151+       .llseek         = ovl_dir_llseek, 
     2152+       .fsync          = ovl_dir_fsync, 
     2153+       .release        = ovl_dir_release, 
     2154+}; 
     2155+ 
     2156+static int ovl_check_empty_dir(struct dentry *dentry, struct list_head *list) 
     2157+{ 
     2158+       int err; 
     2159+       struct path lowerpath; 
     2160+       struct path upperpath; 
     2161+       struct ovl_cache_entry *p; 
     2162+       struct ovl_readdir_data rdd = { .list = list }; 
     2163+ 
     2164+       ovl_path_upper(dentry, &upperpath); 
     2165+       ovl_path_lower(dentry, &lowerpath); 
     2166+ 
     2167+       err = ovl_dir_read_merged(&upperpath, &lowerpath, &rdd); 
     2168+       if (err) 
     2169+               return err; 
     2170+ 
     2171+       err = 0; 
     2172+ 
     2173+       list_for_each_entry(p, list, l_node) { 
     2174+               if (p->is_whiteout) 
     2175+                       continue; 
     2176+ 
     2177+               if (p->name[0] == '.') { 
     2178+                       if (p->len == 1) 
     2179+                               continue; 
     2180+                       if (p->len == 2 && p->name[1] == '.') 
     2181+                               continue; 
     2182+               } 
     2183+               err = -ENOTEMPTY; 
     2184+               break; 
     2185+       } 
     2186+ 
     2187+       return err; 
     2188+} 
     2189+ 
     2190+static int ovl_remove_whiteouts(struct dentry *dir, struct list_head *list) 
     2191+{ 
     2192+       struct path upperpath; 
     2193+       struct dentry *upperdir; 
     2194+       struct ovl_cache_entry *p; 
     2195+       const struct cred *old_cred; 
     2196+       struct cred *override_cred; 
     2197+       int err; 
     2198+ 
     2199+       ovl_path_upper(dir, &upperpath); 
     2200+       upperdir = upperpath.dentry; 
     2201+ 
     2202+       override_cred = prepare_creds(); 
     2203+       if (!override_cred) 
     2204+               return -ENOMEM; 
     2205+ 
     2206+       /* 
     2207+        * CAP_DAC_OVERRIDE for lookup and unlink 
     2208+        * CAP_SYS_ADMIN for setxattr of "trusted" namespace 
     2209+        * CAP_FOWNER for unlink in sticky directory 
     2210+        */ 
     2211+       cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE); 
     2212+       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     2213+       cap_raise(override_cred->cap_effective, CAP_FOWNER); 
     2214+       old_cred = override_creds(override_cred); 
     2215+ 
     2216+       err = vfs_setxattr(upperdir, ovl_opaque_xattr, "y", 1, 0); 
     2217+       if (err) 
     2218+               goto out_revert_creds; 
     2219+ 
     2220+       mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT); 
     2221+       list_for_each_entry(p, list, l_node) { 
     2222+               struct dentry *dentry; 
     2223+               int ret; 
     2224+ 
     2225+               if (!p->is_whiteout) 
     2226+                       continue; 
     2227+ 
     2228+               dentry = lookup_one_len(p->name, upperdir, p->len); 
     2229+               if (IS_ERR(dentry)) { 
     2230+                       printk(KERN_WARNING "overlayfs: failed to lookup whiteout %.*s: %li\n", p->len, p->name, PTR_ERR(dentry)); 
     2231+                       continue; 
     2232+               } 
     2233+               ret = vfs_unlink(upperdir->d_inode, dentry); 
     2234+               dput(dentry); 
     2235+               if (ret) 
     2236+                       printk(KERN_WARNING "overlayfs: failed to unlink whiteout %.*s: %i\n", p->len, p->name, ret); 
     2237+       } 
     2238+       mutex_unlock(&upperdir->d_inode->i_mutex); 
     2239+ 
     2240+out_revert_creds: 
     2241+       revert_creds(old_cred); 
     2242+       put_cred(override_cred); 
     2243+ 
     2244+       return err; 
     2245+} 
     2246+ 
     2247+int ovl_check_empty_and_clear(struct dentry *dentry, enum ovl_path_type type) 
     2248+{ 
     2249+       int err; 
     2250+       LIST_HEAD(list); 
     2251+ 
     2252+       err = ovl_check_empty_dir(dentry, &list); 
     2253+       if (!err && type == OVL_PATH_MERGE) 
     2254+               err = ovl_remove_whiteouts(dentry, &list); 
     2255+ 
     2256+       ovl_cache_free(&list); 
     2257+ 
     2258+       return err; 
     2259+} 
     2260--- /dev/null 
     2261+++ b/fs/overlayfs/super.c 
     2262@@ -0,0 +1,625 @@ 
     2263+/* 
     2264+ * 
     2265+ * Copyright (C) 2011 Novell Inc. 
     2266+ * 
     2267+ * This program is free software; you can redistribute it and/or modify it 
     2268+ * under the terms of the GNU General Public License version 2 as published by 
     2269+ * the Free Software Foundation. 
     2270+ */ 
     2271+ 
     2272+#include <linux/fs.h> 
     2273+#include <linux/namei.h> 
     2274+#include <linux/xattr.h> 
     2275+#include <linux/security.h> 
     2276+#include <linux/mount.h> 
     2277+#include <linux/slab.h> 
     2278+#include <linux/parser.h> 
     2279+#include <linux/module.h> 
     2280+#include <linux/seq_file.h> 
     2281+#include "overlayfs.h" 
     2282+ 
     2283+MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 
     2284+MODULE_DESCRIPTION("Overlay filesystem"); 
     2285+MODULE_LICENSE("GPL"); 
     2286+ 
     2287+struct ovl_config { 
     2288+       char *lowerdir; 
     2289+       char *upperdir; 
     2290+}; 
     2291+ 
     2292+/* private information held for overlayfs's superblock */ 
     2293+struct ovl_fs { 
     2294+       struct vfsmount *upper_mnt; 
     2295+       struct vfsmount *lower_mnt; 
     2296+       /* pathnames of lower and upper dirs, for show_options */ 
     2297+       struct ovl_config config; 
     2298+}; 
     2299+ 
     2300+/* private information held for every overlayfs dentry */ 
     2301+struct ovl_entry { 
     2302+       /* 
     2303+        * Keep "double reference" on upper dentries, so that 
     2304+        * d_delete() doesn't think it's OK to reset d_inode to NULL. 
     2305+        */ 
     2306+       struct dentry *__upperdentry; 
     2307+       struct dentry *lowerdentry; 
     2308+       union { 
     2309+               struct { 
     2310+                       u64 version; 
     2311+                       bool opaque; 
     2312+               }; 
     2313+               struct rcu_head rcu; 
     2314+       }; 
     2315+}; 
     2316+ 
     2317+const char *ovl_whiteout_xattr = "trusted.overlay.whiteout"; 
     2318+const char *ovl_opaque_xattr = "trusted.overlay.opaque"; 
     2319+ 
     2320+ 
     2321+enum ovl_path_type ovl_path_type(struct dentry *dentry) 
     2322+{ 
     2323+       struct ovl_entry *oe = dentry->d_fsdata; 
     2324+ 
     2325+       if (oe->__upperdentry) { 
     2326+               if (oe->lowerdentry && S_ISDIR(dentry->d_inode->i_mode)) 
     2327+                       return OVL_PATH_MERGE; 
     2328+               else 
     2329+                       return OVL_PATH_UPPER; 
     2330+       } else { 
     2331+               return OVL_PATH_LOWER; 
     2332+       } 
     2333+} 
     2334+ 
     2335+static struct dentry *ovl_upperdentry_dereference(struct ovl_entry *oe) 
     2336+{ 
     2337+       struct dentry *upperdentry = ACCESS_ONCE(oe->__upperdentry); 
     2338+       smp_read_barrier_depends(); 
     2339+       return upperdentry; 
     2340+} 
     2341+ 
     2342+void ovl_path_upper(struct dentry *dentry, struct path *path) 
     2343+{ 
     2344+       struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 
     2345+       struct ovl_entry *oe = dentry->d_fsdata; 
     2346+ 
     2347+       path->mnt = ofs->upper_mnt; 
     2348+       path->dentry = ovl_upperdentry_dereference(oe); 
     2349+} 
     2350+ 
     2351+void ovl_path_lower(struct dentry *dentry, struct path *path) 
     2352+{ 
     2353+       struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 
     2354+       struct ovl_entry *oe = dentry->d_fsdata; 
     2355+ 
     2356+       path->mnt = ofs->lower_mnt; 
     2357+       path->dentry = oe->lowerdentry; 
     2358+} 
     2359+ 
     2360+enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path) 
     2361+{ 
     2362+ 
     2363+       enum ovl_path_type type = ovl_path_type(dentry); 
     2364+ 
     2365+       if (type == OVL_PATH_LOWER) 
     2366+               ovl_path_lower(dentry, path); 
     2367+       else 
     2368+               ovl_path_upper(dentry, path); 
     2369+ 
     2370+       return type; 
     2371+} 
     2372+ 
     2373+struct dentry *ovl_dentry_upper(struct dentry *dentry) 
     2374+{ 
     2375+       struct ovl_entry *oe = dentry->d_fsdata; 
     2376+ 
     2377+       return ovl_upperdentry_dereference(oe); 
     2378+} 
     2379+ 
     2380+struct dentry *ovl_dentry_lower(struct dentry *dentry) 
     2381+{ 
     2382+       struct ovl_entry *oe = dentry->d_fsdata; 
     2383+ 
     2384+       return oe->lowerdentry; 
     2385+} 
     2386+ 
     2387+struct dentry *ovl_dentry_real(struct dentry *dentry) 
     2388+{ 
     2389+       struct ovl_entry *oe = dentry->d_fsdata; 
     2390+       struct dentry *realdentry; 
     2391+ 
     2392+       realdentry = ovl_upperdentry_dereference(oe); 
     2393+       if (!realdentry) 
     2394+               realdentry = oe->lowerdentry; 
     2395+ 
     2396+       return realdentry; 
     2397+} 
     2398+ 
     2399+struct dentry *ovl_entry_real(struct ovl_entry *oe, bool *is_upper) 
     2400+{ 
     2401+       struct dentry *realdentry; 
     2402+ 
     2403+       realdentry = ovl_upperdentry_dereference(oe); 
     2404+       if (realdentry) { 
     2405+               *is_upper = true; 
     2406+       } else { 
     2407+               realdentry = oe->lowerdentry; 
     2408+               *is_upper = false; 
     2409+       } 
     2410+       return realdentry; 
     2411+} 
     2412+ 
     2413+bool ovl_dentry_is_opaque(struct dentry *dentry) 
     2414+{ 
     2415+       struct ovl_entry *oe = dentry->d_fsdata; 
     2416+       return oe->opaque; 
     2417+} 
     2418+ 
     2419+void ovl_dentry_set_opaque(struct dentry *dentry, bool opaque) 
     2420+{ 
     2421+       struct ovl_entry *oe = dentry->d_fsdata; 
     2422+       oe->opaque = opaque; 
     2423+} 
     2424+ 
     2425+void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry) 
     2426+{ 
     2427+       struct ovl_entry *oe = dentry->d_fsdata; 
     2428+ 
     2429+       WARN_ON(!mutex_is_locked(&upperdentry->d_parent->d_inode->i_mutex)); 
     2430+       WARN_ON(oe->__upperdentry); 
     2431+       BUG_ON(!upperdentry->d_inode); 
     2432+       smp_wmb(); 
     2433+       oe->__upperdentry = dget(upperdentry); 
     2434+} 
     2435+ 
     2436+void ovl_dentry_version_inc(struct dentry *dentry) 
     2437+{ 
     2438+       struct ovl_entry *oe = dentry->d_fsdata; 
     2439+ 
     2440+       WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex)); 
     2441+       oe->version++; 
     2442+} 
     2443+ 
     2444+u64 ovl_dentry_version_get(struct dentry *dentry) 
     2445+{ 
     2446+       struct ovl_entry *oe = dentry->d_fsdata; 
     2447+ 
     2448+       WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex)); 
     2449+       return oe->version; 
     2450+} 
     2451+ 
     2452+bool ovl_is_whiteout(struct dentry *dentry) 
     2453+{ 
     2454+       int res; 
     2455+       char val; 
     2456+ 
     2457+       if (!dentry) 
     2458+               return false; 
     2459+       if (!dentry->d_inode) 
     2460+               return false; 
     2461+       if (!S_ISLNK(dentry->d_inode->i_mode)) 
     2462+               return false; 
     2463+ 
     2464+       res = vfs_getxattr(dentry, ovl_whiteout_xattr, &val, 1); 
     2465+       if (res == 1 && val == 'y') 
     2466+               return true; 
     2467+ 
     2468+       return false; 
     2469+} 
     2470+ 
     2471+static bool ovl_is_opaquedir(struct dentry *dentry) 
     2472+{ 
     2473+       int res; 
     2474+       char val; 
     2475+ 
     2476+       if (!S_ISDIR(dentry->d_inode->i_mode)) 
     2477+               return false; 
     2478+ 
     2479+       res = vfs_getxattr(dentry, ovl_opaque_xattr, &val, 1); 
     2480+       if (res == 1 && val == 'y') 
     2481+               return true; 
     2482+ 
     2483+       return false; 
     2484+} 
     2485+ 
     2486+static void ovl_entry_free(struct rcu_head *head) 
     2487+{ 
     2488+       struct ovl_entry *oe = container_of(head, struct ovl_entry, rcu); 
     2489+       kfree(oe); 
     2490+} 
     2491+ 
     2492+static void ovl_dentry_release(struct dentry *dentry) 
     2493+{ 
     2494+       struct ovl_entry *oe = dentry->d_fsdata; 
     2495+ 
     2496+       if (oe) { 
     2497+               dput(oe->__upperdentry); 
     2498+               dput(oe->__upperdentry); 
     2499+               dput(oe->lowerdentry); 
     2500+               call_rcu(&oe->rcu, ovl_entry_free); 
     2501+       } 
     2502+} 
     2503+ 
     2504+const struct dentry_operations ovl_dentry_operations = { 
     2505+       .d_release = ovl_dentry_release, 
     2506+}; 
     2507+ 
     2508+static struct ovl_entry *ovl_alloc_entry(void) 
     2509+{ 
     2510+       return kzalloc(sizeof(struct ovl_entry), GFP_KERNEL); 
     2511+} 
     2512+ 
     2513+static struct dentry *ovl_lookup_real(struct dentry *dir, struct qstr *name) 
     2514+{ 
     2515+       struct dentry *dentry; 
     2516+ 
     2517+       mutex_lock(&dir->d_inode->i_mutex); 
     2518+       dentry = lookup_one_len(name->name, dir, name->len); 
     2519+       mutex_unlock(&dir->d_inode->i_mutex); 
     2520+ 
     2521+       if (IS_ERR(dentry)) { 
     2522+               if (PTR_ERR(dentry) == -ENOENT) 
     2523+                       dentry = NULL; 
     2524+       } else if (!dentry->d_inode) { 
     2525+               dput(dentry); 
     2526+               dentry = NULL; 
     2527+       } 
     2528+       return dentry; 
     2529+} 
     2530+ 
     2531+int ovl_do_lookup(struct dentry *dentry) 
     2532+{ 
     2533+       struct ovl_entry *oe; 
     2534+       struct dentry *upperdir; 
     2535+       struct dentry *lowerdir; 
     2536+       struct dentry *upperdentry = NULL; 
     2537+       struct dentry *lowerdentry = NULL; 
     2538+       struct inode *inode = NULL; 
     2539+       int err; 
     2540+ 
     2541+       err = -ENOMEM; 
     2542+       oe = ovl_alloc_entry(); 
     2543+       if (!oe) 
     2544+               goto out; 
     2545+ 
     2546+       upperdir = ovl_dentry_upper(dentry->d_parent); 
     2547+       lowerdir = ovl_dentry_lower(dentry->d_parent); 
     2548+ 
     2549+       if (upperdir) { 
     2550+               upperdentry = ovl_lookup_real(upperdir, &dentry->d_name); 
     2551+               err = PTR_ERR(upperdentry); 
     2552+               if (IS_ERR(upperdentry)) 
     2553+                       goto out_put_dir; 
     2554+ 
     2555+               if (lowerdir && upperdentry && 
     2556+                   (S_ISLNK(upperdentry->d_inode->i_mode) || 
     2557+                    S_ISDIR(upperdentry->d_inode->i_mode))) { 
     2558+                       const struct cred *old_cred; 
     2559+                       struct cred *override_cred; 
     2560+ 
     2561+                       err = -ENOMEM; 
     2562+                       override_cred = prepare_creds(); 
     2563+                       if (!override_cred) 
     2564+                               goto out_dput_upper; 
     2565+ 
     2566+                       /* CAP_SYS_ADMIN needed for getxattr */ 
     2567+                       cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN); 
     2568+                       old_cred = override_creds(override_cred); 
     2569+ 
     2570+                       if (ovl_is_opaquedir(upperdentry)) { 
     2571+                               oe->opaque = true; 
     2572+                       } else if (ovl_is_whiteout(upperdentry)) { 
     2573+                               dput(upperdentry); 
     2574+                               upperdentry = NULL; 
     2575+                               oe->opaque = true; 
     2576+                       } 
     2577+                       revert_creds(old_cred); 
     2578+                       put_cred(override_cred); 
     2579+               } 
     2580+       } 
     2581+       if (lowerdir && !oe->opaque) { 
     2582+               lowerdentry = ovl_lookup_real(lowerdir, &dentry->d_name); 
     2583+               err = PTR_ERR(lowerdentry); 
     2584+               if (IS_ERR(lowerdentry)) 
     2585+                       goto out_dput_upper; 
     2586+       } 
     2587+ 
     2588+       if (lowerdentry && upperdentry && 
     2589+           (!S_ISDIR(upperdentry->d_inode->i_mode) || 
     2590+            !S_ISDIR(lowerdentry->d_inode->i_mode))) { 
     2591+               dput(lowerdentry); 
     2592+               lowerdentry = NULL; 
     2593+               oe->opaque = true; 
     2594+       } 
     2595+ 
     2596+       if (lowerdentry || upperdentry) { 
     2597+               struct dentry *realdentry; 
     2598+ 
     2599+               realdentry = upperdentry ? upperdentry : lowerdentry; 
     2600+               err = -ENOMEM; 
     2601+               inode = ovl_new_inode(dentry->d_sb, realdentry->d_inode->i_mode, oe); 
     2602+               if (!inode) 
     2603+                       goto out_dput; 
     2604+       } 
     2605+ 
     2606+       if (upperdentry) 
     2607+               oe->__upperdentry = dget(upperdentry); 
     2608+ 
     2609+       if (lowerdentry) 
     2610+               oe->lowerdentry = lowerdentry; 
     2611+ 
     2612+       dentry->d_fsdata = oe; 
     2613+       dentry->d_op = &ovl_dentry_operations; 
     2614+       d_add(dentry, inode); 
     2615+ 
     2616+       return 0; 
     2617+ 
     2618+out_dput: 
     2619+       dput(lowerdentry); 
     2620+out_dput_upper: 
     2621+       dput(upperdentry); 
     2622+out_put_dir: 
     2623+       kfree(oe); 
     2624+out: 
     2625+       return err; 
     2626+} 
     2627+ 
     2628+static void ovl_put_super(struct super_block *sb) 
     2629+{ 
     2630+       struct ovl_fs *ufs = sb->s_fs_info; 
     2631+ 
     2632+       if (!(sb->s_flags & MS_RDONLY)) 
     2633+               mnt_drop_write(ufs->upper_mnt); 
     2634+ 
     2635+       mntput(ufs->upper_mnt); 
     2636+       mntput(ufs->lower_mnt); 
     2637+ 
     2638+       kfree(ufs->config.lowerdir); 
     2639+       kfree(ufs->config.upperdir); 
     2640+       kfree(ufs); 
     2641+} 
     2642+ 
     2643+static int ovl_remount_fs(struct super_block *sb, int *flagsp, char *data) 
     2644+{ 
     2645+       int flags = *flagsp; 
     2646+       struct ovl_fs *ufs = sb->s_fs_info; 
     2647+ 
     2648+       /* When remounting rw or ro, we need to adjust the write access to the 
     2649+        * upper fs. 
     2650+        */ 
     2651+       if (((flags ^ sb->s_flags) & MS_RDONLY) == 0) 
     2652+               /* No change to readonly status */ 
     2653+               return 0; 
     2654+ 
     2655+       if (flags & MS_RDONLY) { 
     2656+               mnt_drop_write(ufs->upper_mnt); 
     2657+               return 0; 
     2658+       } else 
     2659+               return mnt_want_write(ufs->upper_mnt); 
     2660+} 
     2661+ 
     2662+/** 
     2663+ * ovl_statfs 
     2664+ * @sb: The overlayfs super block 
     2665+ * @buf: The struct kstatfs to fill in with stats 
     2666+ * 
     2667+ * Get the filesystem statistics.  As writes always target the upper layer 
     2668+ * filesystem pass the statfs to the same filesystem. 
     2669+ */ 
     2670+static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 
     2671+{ 
     2672+       struct dentry *root_dentry = dentry->d_sb->s_root; 
     2673+       struct path path; 
     2674+       ovl_path_upper(root_dentry, &path); 
     2675+ 
     2676+       if (!path.dentry->d_sb->s_op->statfs) 
     2677+               return -ENOSYS; 
     2678+       return path.dentry->d_sb->s_op->statfs(path.dentry, buf); 
     2679+} 
     2680+ 
     2681+/** 
     2682+ * ovl_show_options 
     2683+ * 
     2684+ * Prints the mount options for a given superblock. 
     2685+ * Returns zero; does not fail. 
     2686+ */ 
     2687+static int ovl_show_options(struct seq_file *m, struct vfsmount *mnt) 
     2688+{ 
     2689+       struct super_block *sb = mnt->mnt_sb; 
     2690+       struct ovl_fs *ufs = sb->s_fs_info; 
     2691+ 
     2692+       seq_printf(m, ",lowerdir=%s", ufs->config.lowerdir); 
     2693+       seq_printf(m, ",upperdir=%s", ufs->config.upperdir); 
     2694+       return 0; 
     2695+} 
     2696+ 
     2697+static const struct super_operations ovl_super_operations = { 
     2698+       .put_super      = ovl_put_super, 
     2699+       .remount_fs     = ovl_remount_fs, 
     2700+       .statfs         = ovl_statfs, 
     2701+       .show_options   = ovl_show_options, 
     2702+}; 
     2703+ 
     2704+enum { 
     2705+       Opt_lowerdir, 
     2706+       Opt_upperdir, 
     2707+       Opt_err, 
     2708+}; 
     2709+ 
     2710+static const match_table_t ovl_tokens = { 
     2711+       {Opt_lowerdir,                  "lowerdir=%s"}, 
     2712+       {Opt_upperdir,                  "upperdir=%s"}, 
     2713+       {Opt_err,                       NULL} 
     2714+}; 
     2715+ 
     2716+static int ovl_parse_opt(char *opt, struct ovl_config *config) 
     2717+{ 
     2718+       char *p; 
     2719+ 
     2720+       config->upperdir = NULL; 
     2721+       config->lowerdir = NULL; 
     2722+ 
     2723+       while ((p = strsep(&opt, ",")) != NULL) { 
     2724+               int token; 
     2725+               substring_t args[MAX_OPT_ARGS]; 
     2726+ 
     2727+               if (!*p) 
     2728+                       continue; 
     2729+ 
     2730+               token = match_token(p, ovl_tokens, args); 
     2731+               switch (token) { 
     2732+               case Opt_upperdir: 
     2733+                       kfree(config->upperdir); 
     2734+                       config->upperdir = match_strdup(&args[0]); 
     2735+                       if (!config->upperdir) 
     2736+                               return -ENOMEM; 
     2737+                       break; 
     2738+ 
     2739+               case Opt_lowerdir: 
     2740+                       kfree(config->lowerdir); 
     2741+                       config->lowerdir = match_strdup(&args[0]); 
     2742+                       if (!config->lowerdir) 
     2743+                               return -ENOMEM; 
     2744+                       break; 
     2745+ 
     2746+               default: 
     2747+                       return -EINVAL; 
     2748+               } 
     2749+       } 
     2750+       return 0; 
     2751+} 
     2752+ 
     2753+static int ovl_fill_super(struct super_block *sb, void *data, int silent) 
     2754+{ 
     2755+       struct path lowerpath; 
     2756+       struct path upperpath; 
     2757+       struct inode *root_inode; 
     2758+       struct dentry *root_dentry; 
     2759+       struct ovl_entry *oe; 
     2760+       struct ovl_fs *ufs; 
     2761+       int err; 
     2762+ 
     2763+       err = -ENOMEM; 
     2764+       ufs = kmalloc(sizeof(struct ovl_fs), GFP_KERNEL); 
     2765+       if (!ufs) 
     2766+               goto out; 
     2767+ 
     2768+       err = ovl_parse_opt((char *) data, &ufs->config); 
     2769+       if (err) 
     2770+               goto out_free_ufs; 
     2771+ 
     2772+       err = -EINVAL; 
     2773+       if (!ufs->config.upperdir || !ufs->config.lowerdir) { 
     2774+               printk(KERN_ERR "overlayfs: missing upperdir or lowerdir\n"); 
     2775+               goto out_free_config; 
     2776+       } 
     2777+ 
     2778+       oe = ovl_alloc_entry(); 
     2779+       if (oe == NULL) 
     2780+               goto out_free_config; 
     2781+ 
     2782+       root_inode = ovl_new_inode(sb, S_IFDIR, oe); 
     2783+       if (!root_inode) 
     2784+               goto out_free_oe; 
     2785+ 
     2786+       err = kern_path(ufs->config.upperdir, LOOKUP_FOLLOW, &upperpath); 
     2787+       if (err) 
     2788+               goto out_put_root; 
     2789+ 
     2790+       err = kern_path(ufs->config.lowerdir, LOOKUP_FOLLOW, &lowerpath); 
     2791+       if (err) 
     2792+               goto out_put_upperpath; 
     2793+ 
     2794+       err = -ENOTDIR; 
     2795+       if (!S_ISDIR(upperpath.dentry->d_inode->i_mode) || 
     2796+           !S_ISDIR(lowerpath.dentry->d_inode->i_mode)) 
     2797+               goto out_put_lowerpath; 
     2798+ 
     2799+       ufs->upper_mnt = clone_private_mount(&upperpath); 
     2800+       err = PTR_ERR(ufs->upper_mnt); 
     2801+       if (IS_ERR(ufs->upper_mnt)) { 
     2802+               printk(KERN_ERR "overlayfs: failed to clone upperpath\n"); 
     2803+               goto out_put_lowerpath; 
     2804+       } 
     2805+ 
     2806+       ufs->lower_mnt = clone_private_mount(&lowerpath); 
     2807+       err = PTR_ERR(ufs->lower_mnt); 
     2808+       if (IS_ERR(ufs->lower_mnt)) { 
     2809+               printk(KERN_ERR "overlayfs: failed to clone lowerpath\n"); 
     2810+               goto out_put_upper_mnt; 
     2811+       } 
     2812+ 
     2813+       if (!(sb->s_flags & MS_RDONLY)) { 
     2814+               err = mnt_want_write(ufs->upper_mnt); 
     2815+               if (err) 
     2816+                       goto out_put_lower_mnt; 
     2817+       } 
     2818+ 
     2819+       err = -ENOMEM; 
     2820+       root_dentry = d_alloc_root(root_inode); 
     2821+       if (!root_dentry) 
     2822+               goto out_drop_write; 
     2823+ 
     2824+       mntput(upperpath.mnt); 
     2825+       mntput(lowerpath.mnt); 
     2826+ 
     2827+       oe->__upperdentry = dget(upperpath.dentry); 
     2828+       oe->lowerdentry = lowerpath.dentry; 
     2829+ 
     2830+       root_dentry->d_fsdata = oe; 
     2831+       root_dentry->d_op = &ovl_dentry_operations; 
     2832+ 
     2833+       sb->s_op = &ovl_super_operations; 
     2834+       sb->s_root = root_dentry; 
     2835+       sb->s_fs_info = ufs; 
     2836+ 
     2837+       return 0; 
     2838+ 
     2839+out_drop_write: 
     2840+       if (!(sb->s_flags & MS_RDONLY)) 
     2841+               mnt_drop_write(ufs->upper_mnt); 
     2842+out_put_lower_mnt: 
     2843+       mntput(ufs->lower_mnt); 
     2844+out_put_upper_mnt: 
     2845+       mntput(ufs->upper_mnt); 
     2846+out_put_lowerpath: 
     2847+       path_put(&lowerpath); 
     2848+out_put_upperpath: 
     2849+       path_put(&upperpath); 
     2850+out_put_root: 
     2851+       iput(root_inode); 
     2852+out_free_oe: 
     2853+       kfree(oe); 
     2854+out_free_config: 
     2855+       kfree(ufs->config.lowerdir); 
     2856+       kfree(ufs->config.upperdir); 
     2857+out_free_ufs: 
     2858+       kfree(ufs); 
     2859+out: 
     2860+       return err; 
     2861+} 
     2862+ 
     2863+static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 
     2864+                               const char *dev_name, void *raw_data) 
     2865+{ 
     2866+       return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 
     2867+} 
     2868+ 
     2869+static struct file_system_type ovl_fs_type = { 
     2870+       .owner          = THIS_MODULE, 
     2871+       .name           = "overlayfs", 
     2872+       .mount          = ovl_mount, 
     2873+       .kill_sb        = kill_anon_super, 
     2874+}; 
     2875+ 
     2876+static int __init ovl_init(void) 
     2877+{ 
     2878+       return register_filesystem(&ovl_fs_type); 
     2879+} 
     2880+ 
     2881+static void __exit ovl_exit(void) 
     2882+{ 
     2883+       unregister_filesystem(&ovl_fs_type); 
     2884+} 
     2885+ 
     2886+module_init(ovl_init); 
     2887+module_exit(ovl_exit); 
    26752888--- /dev/null 
    26762889+++ b/Documentation/filesystems/overlayfs.txt 
    2677 @@ -0,0 +1,163 @@ 
     2890@@ -0,0 +1,167 @@ 
    26782891+Written by: Neil Brown <neilb@suse.de> 
    26792892+ 
     
    27412954+ 
    27422955+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. 
     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. 
    27492966+ 
    27502967+Only the lists of names from directories are merged.  Other content 
     
    28393056+filesystem are not allowed.  This is not yet enforced, but will be in 
    28403057+the future. 
     3058--- a/MAINTAINERS 
     3059+++ b/MAINTAINERS 
     3060@@ -4713,6 +4713,13 @@ F:       drivers/scsi/osd/ 
     3061 F:     include/scsi/osd_* 
     3062 F:     fs/exofs/ 
     3063  
     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 
  • trunk/target/linux/generic/patches-3.0/201-extra_optimization.patch

    r26691 r27191  
    11--- a/Makefile 
    22+++ b/Makefile 
    3 @@ -543,9 +543,9 @@ endif # $(dot-config) 
     3@@ -559,9 +559,9 @@ endif # $(dot-config) 
    44 all: vmlinux 
    55  
     
    1313  
    1414 include $(srctree)/arch/$(SRCARCH)/Makefile 
    15 @@ -600,6 +600,9 @@ endif 
     15@@ -620,6 +620,9 @@ endif 
    1616 NOSTDINC_FLAGS += -nostdinc -isystem $(shell $(CC) -print-file-name=include) 
    1717 CHECKFLAGS     += $(NOSTDINC_FLAGS) 
  • trunk/target/linux/generic/patches-3.0/210-darwin_scripts_include.patch

    r26691 r27191  
    3939--- a/scripts/kconfig/Makefile 
    4040+++ b/scripts/kconfig/Makefile 
    41 @@ -147,6 +147,9 @@ check-lxdialog  := $(srctree)/$(src)/lxd 
     41@@ -148,6 +148,9 @@ check-lxdialog  := $(srctree)/$(src)/lxd 
    4242 # we really need to do so. (Do not call gcc as part of make mrproper) 
    4343 HOST_EXTRACFLAGS += $(shell $(CONFIG_SHELL) $(check-lxdialog) -ccflags) \ 
  • trunk/target/linux/generic/patches-3.0/220-module_exports.patch

    r26691 r27191  
    66  
    77+#ifndef SYMTAB_KEEP_STR 
    8 +#define SYMTAB_KEEP_STR *(__ksymtab_strings.*) 
     8+#define SYMTAB_KEEP_STR *(__ksymtab_strings+*) 
    99+#define SYMTAB_DISCARD_STR 
    1010+#else 
    11 +#define SYMTAB_DISCARD_STR *(__ksymtab_strings.*) 
     11+#define SYMTAB_DISCARD_STR *(__ksymtab_strings+*) 
    1212+#endif 
    1313+ 
    1414+#ifndef SYMTAB_KEEP 
    15 +#define SYMTAB_KEEP *(__ksymtab.*) 
     15+#define SYMTAB_KEEP *(SORT(___ksymtab+*)) 
    1616+#define SYMTAB_DISCARD 
    1717+#else 
    18 +#define SYMTAB_DISCARD *(__ksymtab.*) 
     18+#define SYMTAB_DISCARD *(SORT(___ksymtab+*)) 
    1919+#endif 
    2020+ 
    2121+#ifndef SYMTAB_KEEP_GPL 
    22 +#define SYMTAB_KEEP_GPL *(__ksymtab_gpl.*) 
     22+#define SYMTAB_KEEP_GPL *(SORT(___ksymtab_gpl+*)) 
    2323+#define SYMTAB_DISCARD_GPL 
    2424+#else 
    25 +#define SYMTAB_DISCARD_GPL *(__ksymtab_gpl.*) 
     25+#define SYMTAB_DISCARD_GPL *(SORT(___ksymtab_gpl+*)) 
    2626+#endif 
    2727+ 
     
    2929 #define VMLINUX_SYMBOL(sym) sym 
    3030 #else 
    31 @@ -274,35 +295,35 @@ 
     31@@ -276,14 +297,14 @@ 
    3232        /* Kernel symbol table: Normal symbols */                       \ 
    3333        __ksymtab         : AT(ADDR(__ksymtab) - LOAD_OFFSET) {         \ 
    3434                VMLINUX_SYMBOL(__start___ksymtab) = .;                  \ 
    35 -               *(__ksymtab)                                            \ 
     35-               *(SORT(___ksymtab+*))                                   \ 
    3636+               SYMTAB_KEEP                                             \ 
    3737                VMLINUX_SYMBOL(__stop___ksymtab) = .;                   \ 
     
    4141        __ksymtab_gpl     : AT(ADDR(__ksymtab_gpl) - LOAD_OFFSET) {     \ 
    4242                VMLINUX_SYMBOL(__start___ksymtab_gpl) = .;              \ 
    43 -               *(__ksymtab_gpl)                                        \ 
     43-               *(SORT(___ksymtab_gpl+*))                               \ 
    4444+               SYMTAB_KEEP_GPL                                         \ 
    4545                VMLINUX_SYMBOL(__stop___ksymtab_gpl) = .;               \ 
    4646        }                                                               \ 
    4747                                                                        \ 
    48         /* Kernel symbol table: Normal unused symbols */                \ 
    49         __ksymtab_unused  : AT(ADDR(__ksymtab_unused) - LOAD_OFFSET) {  \ 
    50                 VMLINUX_SYMBOL(__start___ksymtab_unused) = .;           \ 
    51 -               *(__ksymtab_unused)                                     \ 
    52 +               *(__ksymtab_unused.*)                                   \ 
    53                 VMLINUX_SYMBOL(__stop___ksymtab_unused) = .;            \ 
    54         }                                                               \ 
    55                                                                         \ 
    56         /* Kernel symbol table: GPL-only unused symbols */              \ 
    57         __ksymtab_unused_gpl : AT(ADDR(__ksymtab_unused_gpl) - LOAD_OFFSET) { \ 
    58                 VMLINUX_SYMBOL(__start___ksymtab_unused_gpl) = .;       \ 
    59 -               *(__ksymtab_unused_gpl)                                 \ 
    60 +               *(__ksymtab_unused_gpl.*)                               \ 
    61                 VMLINUX_SYMBOL(__stop___ksymtab_unused_gpl) = .;        \ 
    62         }                                                               \ 
    63                                                                         \ 
    64         /* Kernel symbol table: GPL-future-only symbols */              \ 
    65         __ksymtab_gpl_future : AT(ADDR(__ksymtab_gpl_future) - LOAD_OFFSET) { \ 
    66                 VMLINUX_SYMBOL(__start___ksymtab_gpl_future) = .;       \ 
    67 -               *(__ksymtab_gpl_future)                                 \ 
    68 +               *(__ksymtab_gpl_future.*)                               \ 
    69                 VMLINUX_SYMBOL(__stop___ksymtab_gpl_future) = .;        \ 
    70         }                                                               \ 
    71                                                                         \ 
    72 @@ -343,7 +364,7 @@ 
     48@@ -345,7 +366,7 @@ 
    7349                                                                        \ 
    7450        /* Kernel symbol table: strings */                              \ 
     
    7955                                                                        \ 
    8056        /* __*init sections */                                          \ 
    81 @@ -683,6 +704,9 @@ 
     57@@ -677,6 +698,9 @@ 
    8258        EXIT_TEXT                                                       \ 
    8359        EXIT_DATA                                                       \ 
     
    9167--- a/include/linux/module.h 
    9268+++ b/include/linux/module.h 
    93 @@ -229,16 +229,24 @@ struct module_use { 
     69@@ -230,12 +230,19 @@ struct module_use { 
    9470 #define __CRC_SYMBOL(sym, sec) 
    9571 #endif 
     
    9874+#define __EXPORT_SUFFIX(sym) 
    9975+#else 
    100 +#define __EXPORT_SUFFIX(sym) "." #sym 
     76+#define __EXPORT_SUFFIX(sym) "+" #sym 
    10177+#endif 
    10278+ 
     
    11288        static const struct kernel_symbol __ksymtab_##sym       \ 
    11389        __used                                                  \ 
    114 -       __attribute__((section("__ksymtab" sec), unused))       \ 
    115 +       __attribute__((section("__ksymtab" sec                  \ 
    116 +         __EXPORT_SUFFIX(sym)), unused))                       \ 
    117         = { (unsigned long)&sym, __kstrtab_##sym } 
    118   
    119  #define EXPORT_SYMBOL(sym)                                     \ 
  • trunk/target/linux/generic/patches-3.0/230-openwrt_lzma_options.patch

    r27009 r27191  
    1616 output_file="" 
    1717 is_cpio_compressed= 
    18 -compr="gzip -9 -f" 
    19 +compr="gzip -9 -f -" 
     18-compr="gzip -n -9 -f" 
     19+compr="gzip -n -9 -f -" 
    2020  
    2121 arg="$1" 
     
    2525                cpio_list="$(mktemp ${TMPDIR:-/tmp}/cpiolist.XXXXXX)" 
    2626                output=${cpio_list} 
    27 -               echo "$output_file" | grep -q "\.gz$" && compr="gzip -9 -f" 
     27-               echo "$output_file" | grep -q "\.gz$" && compr="gzip -n -9 -f" 
    2828-               echo "$output_file" | grep -q "\.bz2$" && compr="bzip2 -9 -f" 
    2929-               echo "$output_file" | grep -q "\.lzma$" && compr="lzma -9 -f" 
    30 +               echo "$output_file" | grep -q "\.gz$" && compr="gzip -9 -f -" 
     30+               echo "$output_file" | grep -q "\.gz$" && compr="gzip -n -9 -f -" 
    3131+               echo "$output_file" | grep -q "\.bz2$" && compr="bzip2 -9 -f -" 
    3232+               echo "$output_file" | grep -q "\.lzma$" && compr="lzma e -d20 -lc1 -lp2 -pb2 -eos -si -so" 
     
    3434                                compr="xz --check=crc32 --lzma2=dict=1MiB" 
    3535                echo "$output_file" | grep -q "\.lzo$" && compr="lzop -9 -f" 
    36 @@ -296,7 +296,7 @@ if [ ! -z ${output_file} ]; then 
     36@@ -303,7 +303,7 @@ if [ ! -z ${output_file} ]; then 
    3737        if [ "${is_cpio_compressed}" = "compressed" ]; then 
    3838                cat ${cpio_tfile} > ${output_file} 
  • trunk/target/linux/generic/patches-3.0/252-mv_cesa_depends.patch

    r26691 r27191  
    11--- a/drivers/crypto/Kconfig 
    22+++ b/drivers/crypto/Kconfig 
    3 @@ -162,6 +162,7 @@ config CRYPTO_DEV_MV_CESA 
     3@@ -172,6 +172,7 @@ config CRYPTO_DEV_MV_CESA 
    44        depends on PLAT_ORION 
    55        select CRYPTO_ALGAPI 
  • trunk/target/linux/generic/patches-3.0/254-textsearch_kconfig_hacks.patch

    r26691 r27191  
    11--- a/lib/Kconfig 
    22+++ b/lib/Kconfig 
    3 @@ -200,16 +200,16 @@ config BCH_CONST_T 
     3@@ -190,16 +190,16 @@ config BCH_CONST_T 
    44 # Textsearch support is select'ed if needed 
    55 # 
  • trunk/target/linux/generic/patches-3.0/300-mips_expose_boot_raw.patch

    r27009 r27191  
    99--- a/arch/mips/Kconfig 
    1010+++ b/arch/mips/Kconfig 
    11 @@ -811,9 +811,6 @@ config ARC 
     11@@ -850,9 +850,6 @@ config ARC 
    1212 config ARCH_MAY_HAVE_PC_FDC 
    1313        bool 
     
    1919        bool 
    2020  
    21 @@ -2247,6 +2244,18 @@ config USE_OF 
     21@@ -2300,6 +2297,18 @@ config USE_OF 
    2222        help 
    2323          Include support for flattened device tree machine descriptions. 
  • trunk/target/linux/generic/patches-3.0/301-mips_image_cmdline_hack.patch

    r26691 r27191  
    11--- a/arch/mips/Kconfig 
    22+++ b/arch/mips/Kconfig 
    3 @@ -910,6 +910,10 @@ config SYNC_R4K 
     3@@ -949,6 +949,10 @@ config SYNC_R4K 
    44 config MIPS_MACHINE 
    55        def_bool n 
  • trunk/target/linux/generic/patches-3.0/304-mips_disable_fpu.patch

    r26691 r27191  
    99--- a/arch/mips/Kconfig 
    1010+++ b/arch/mips/Kconfig 
    11 @@ -895,6 +895,17 @@ config I8259 
     11@@ -934,6 +934,17 @@ config I8259 
    1212 config MIPS_BONITO64 
    1313        bool 
  • trunk/target/linux/generic/patches-3.0/321-powerpc_crtsavres_prereq.patch

    r26691 r27191  
    11--- a/Makefile 
    22+++ b/Makefile 
    3 @@ -366,6 +366,7 @@ KBUILD_AFLAGS   := -D__ASSEMBLY__ 
     3@@ -375,6 +375,7 @@ KBUILD_AFLAGS   := -D__ASSEMBLY__ 
    44 KBUILD_AFLAGS_MODULE  := -DMODULE 
    55 KBUILD_CFLAGS_MODULE  := -DMODULE 
     
    99 # Read KERNELRELEASE from include/config/kernel.release (if it exists) 
    1010 KERNELRELEASE = $(shell cat include/config/kernel.release 2> /dev/null) 
    11 @@ -375,7 +376,7 @@ export VERSION PATCHLEVEL SUBLEVEL KERNE 
     11@@ -384,7 +385,7 @@ export VERSION PATCHLEVEL SUBLEVEL KERNE 
    1212 export ARCH SRCARCH CONFIG_SHELL HOSTCC HOSTCFLAGS CROSS_COMPILE AS LD CC 
    1313 export CPP AR NM STRIP OBJCOPY OBJDUMP 
  • trunk/target/linux/generic/patches-3.0/400-rootfs_split.patch

    r27009 r27191  
    11--- a/drivers/mtd/Kconfig 
    22+++ b/drivers/mtd/Kconfig 
    3 @@ -47,6 +47,16 @@ config MTD_PARTITIONS 
    4   
    5  if MTD_PARTITIONS 
     3@@ -33,6 +33,14 @@ config MTD_TESTS 
     4          should normally be compiled as kernel modules. The modules perform 
     5          various checks and verifications when loaded. 
    66  
    77+config MTD_ROOTFS_ROOT_DEV 
    88+       bool "Automatically set 'rootfs' partition to be root filesystem" 
    9 +       depends on MTD_PARTITIONS 
    109+       default y 
    1110+ 
    1211+config MTD_ROOTFS_SPLIT 
    1312+       bool "Automatically split 'rootfs' partition for squashfs" 
    14 +       depends on MTD_PARTITIONS 
    1513+       default y 
    1614+ 
     
    2826 #include <linux/err.h> 
    2927  
    30  /* Our partition linked list */ 
    31 @@ -48,7 +50,7 @@ struct mtd_part { 
     28 #include "mtdcore.h" 
     29@@ -50,7 +52,7 @@ struct mtd_part { 
    3230  * the pointer to that structure with this macro. 
    3331  */ 
     
    3836 /* 
    3937  * MTD methods which simply translate the effective address and pass through 
    40 @@ -636,6 +638,155 @@ int mtd_del_partition(struct mtd_info *m 
     38@@ -637,6 +639,155 @@ int mtd_del_partition(struct mtd_info *m 
    4139 } 
    4240 EXPORT_SYMBOL_GPL(mtd_del_partition); 
     
    194192  * This function, given a master MTD object and a partition table, creates 
    195193  * and registers slave MTD objects which are bound to the master according to 
    196 @@ -652,6 +803,9 @@ int add_mtd_partitions(struct mtd_info * 
     194@@ -653,6 +804,9 @@ int add_mtd_partitions(struct mtd_info * 
    197195        struct mtd_part *slave; 
    198196        uint64_t cur_offset = 0; 
     
    204202        printk(KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name); 
    205203  
    206 @@ -666,6 +820,21 @@ int add_mtd_partitions(struct mtd_info * 
     204@@ -667,12 +821,53 @@ int add_mtd_partitions(struct mtd_info * 
    207205  
    208206                add_mtd_device(&slave->mtd); 
     
    226224        } 
    227225  
    228 @@ -673,6 +842,32 @@ int add_mtd_partitions(struct mtd_info * 
     226        return 0; 
    229227 } 
    230  EXPORT_SYMBOL(add_mtd_partitions); 
    231   
    232 +int refresh_mtd_partitions(struct mtd_info *mtd) 
     228  
     229+int mtd_device_refresh(struct mtd_info *mtd) 
    233230+{ 
    234231+       int ret = 0; 
     
    254251+       return 0; 
    255252+} 
    256 +EXPORT_SYMBOL_GPL(refresh_mtd_partitions); 
     253+EXPORT_SYMBOL_GPL(mtd_device_refresh); 
    257254+ 
    258255 static DEFINE_SPINLOCK(part_parser_lock); 
     
    261258--- a/drivers/mtd/mtdchar.c 
    262259+++ b/drivers/mtd/mtdchar.c 
    263 @@ -841,6 +841,13 @@ static int mtd_ioctl(struct file *file, 
     260@@ -834,6 +834,11 @@ static int mtd_ioctl(struct file *file, 
    264261                file->f_pos = 0; 
    265262                break; 
    266263        } 
    267 +#ifdef CONFIG_MTD_PARTITIONS 
    268264+       case MTDREFRESH: 
    269265+       { 
    270 +               ret = refresh_mtd_partitions(mtd); 
     266+               ret = mtd_device_refresh(mtd); 
    271267+               break; 
    272268+       } 
    273 +#endif 
    274269  
    275270        case OTPGETREGIONCOUNT: 
     
    295290         * its own reference counting. The below functions are only for driver. 
    296291         * The driver may register its callbacks. These callbacks are not 
     292@@ -327,6 +331,7 @@ struct mtd_partition; 
     293 extern int mtd_device_register(struct mtd_info *master, 
     294                               const struct mtd_partition *parts, 
     295                               int nr_parts); 
     296+extern int mtd_device_refresh(struct mtd_info *master); 
     297 extern int mtd_device_unregister(struct mtd_info *master); 
     298 extern struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num); 
     299 extern int __get_mtd_device(struct mtd_info *mtd); 
    297300--- a/include/linux/mtd/partitions.h 
    298301+++ b/include/linux/mtd/partitions.h 
     
    312315  
    313316 #define MTDPART_OFS_NXTBLK     (-2) 
    314 @@ -51,6 +53,7 @@ struct mtd_info; 
    315   
    316  int add_mtd_partitions(struct mtd_info *, const struct mtd_partition *, int); 
    317  int del_mtd_partitions(struct mtd_info *); 
    318 +int refresh_mtd_partitions(struct mtd_info *); 
    319   
    320  /* 
    321   * Functions dealing with the various ways of partitioning the space 
    322 --- a/include/mtd/mtd-abi.h 
    323 +++ b/include/mtd/mtd-abi.h 
    324 @@ -127,6 +127,7 @@ struct otp_info { 
    325  #define MEMWRITEOOB64          _IOWR('M', 21, struct mtd_oob_buf64) 
    326  #define MEMREADOOB64           _IOWR('M', 22, struct mtd_oob_buf64) 
    327  #define MEMISLOCKED            _IOR('M', 23, struct erase_info_user) 
    328 +#define MTDREFRESH             _IO('M', 23) 
    329   
    330  /* 
    331   * Obsolete legacy interface. Keep it in order not to break userspace 
  • trunk/target/linux/generic/patches-3.0/401-partial_eraseblock_write.patch

    r26691 r27191  
    11--- a/drivers/mtd/mtdpart.c 
    22+++ b/drivers/mtd/mtdpart.c 
    3 @@ -33,6 +33,8 @@ 
    4  #include <linux/magic.h> 
    5  #include <linux/err.h> 
     3@@ -35,6 +35,8 @@ 
     4  
     5 #include "mtdcore.h" 
    66  
    77+#define MTD_ERASE_PARTIAL      0x8000 /* partition only covers parts of an erase block */ 
     
    1010 static LIST_HEAD(mtd_partitions); 
    1111 static DEFINE_MUTEX(mtd_partitions_mutex); 
    12 @@ -256,13 +258,60 @@ static int part_erase(struct mtd_info *m 
     12@@ -258,13 +260,60 @@ static int part_erase(struct mtd_info *m 
    1313                return -EROFS; 
    1414        if (instr->addr >= mtd->size) 
     
    7171 } 
    7272  
    73 @@ -270,7 +319,25 @@ void mtd_erase_callback(struct erase_inf 
     73@@ -272,7 +321,25 @@ void mtd_erase_callback(struct erase_inf 
    7474 { 
    7575        if (instr->mtd->erase == part_erase) { 
     
    9797                        instr->fail_addr -= part->offset; 
    9898                instr->addr -= part->offset; 
    99 @@ -529,18 +596,24 @@ static struct mtd_part *allocate_partiti 
     99@@ -530,18 +597,24 @@ static struct mtd_part *allocate_partiti 
    100100        if ((slave->mtd.flags & MTD_WRITEABLE) && 
    101101            mtd_mod_by_eb(slave->offset, &slave->mtd)) { 
  • trunk/target/linux/generic/patches-3.0/410-mtd_info_move_forward_decl.patch

    r26691 r27191  
    1515-struct mtd_info; 
    1616  
    17  int add_mtd_partitions(struct mtd_info *, const struct mtd_partition *, int); 
    18  int del_mtd_partitions(struct mtd_info *); 
     17 /* 
     18  * Functions dealing with the various ways of partitioning the space 
  • trunk/target/linux/generic/patches-3.0/430-mtd_myloader_partition_parser.patch

    r26691 r27191  
    11--- a/drivers/mtd/Kconfig 
    22+++ b/drivers/mtd/Kconfig 
    3 @@ -176,6 +176,22 @@ config MTD_AR7_PARTS 
    4   
    5  endif # MTD_PARTITIONS 
     3@@ -157,6 +157,22 @@ config MTD_AR7_PARTS 
     4        ---help--- 
     5          TI AR7 partitioning support 
    66  
    77+config MTD_MYLOADER_PARTS 
     
    2626--- a/drivers/mtd/Makefile 
    2727+++ b/drivers/mtd/Makefile 
    28 @@ -12,6 +12,7 @@ obj-$(CONFIG_MTD_REDBOOT_PARTS) += redbo 
     28@@ -11,6 +11,7 @@ obj-$(CONFIG_MTD_REDBOOT_PARTS) += redbo 
    2929 obj-$(CONFIG_MTD_CMDLINE_PARTS) += cmdlinepart.o 
    3030 obj-$(CONFIG_MTD_AFS_PARTS)    += afs.o 
  • trunk/target/linux/generic/patches-3.0/440-block2mtd_init.patch

    r26691 r27191  
    4646        dev->mtd.owner = THIS_MODULE; 
    4747  
    48 -       if (add_mtd_device(&dev->mtd)) { 
     48-       if (mtd_device_register(&dev->mtd, NULL, 0)) { 
    4949+       part = kzalloc(sizeof(struct mtd_partition), GFP_KERNEL); 
    5050+       part->name = name; 
    5151+       part->offset = 0; 
    5252+       part->size = dev->mtd.size; 
    53 +       if (add_mtd_partitions(&dev->mtd, part, 1)) { 
     53+       if (mtd_device_register(&dev->mtd, part, 1)) { 
    5454                /* Device didn't get added, so free the entry */ 
    5555                goto devinit_err; 
  • trunk/target/linux/generic/patches-3.0/450-mtd_plat_nand_chip_fixup.patch

    r26691 r27191  
    1616--- a/drivers/mtd/nand/plat_nand.c 
    1717+++ b/drivers/mtd/nand/plat_nand.c 
    18 @@ -96,7 +96,18 @@ static int __devinit plat_nand_probe(str 
     18@@ -94,7 +94,18 @@ static int __devinit plat_nand_probe(str 
    1919        } 
    2020  
  • trunk/target/linux/generic/patches-3.0/470-mtd_m25p80_add_pm25lv_flash_support.patch

    r26691 r27191  
    11--- a/drivers/mtd/devices/m25p80.c 
    22+++ b/drivers/mtd/devices/m25p80.c 
    3 @@ -43,6 +43,7 @@ 
     3@@ -44,6 +44,7 @@ 
    44 #define        OPCODE_BE_4K            0x20    /* Erase 4KiB block */ 
    55 #define        OPCODE_BE_32K           0x52    /* Erase 32KiB block */ 
     
    99 #define        OPCODE_RDID             0x9f    /* Read JEDEC ID */ 
    1010  
    11 @@ -617,6 +618,7 @@ struct flash_info { 
     11@@ -630,6 +631,7 @@ struct flash_info { 
    1212        u16             flags; 
    1313 #define        SECT_4K         0x01            /* OPCODE_BE_4K works uniformly */ 
     
    1717  
    1818 #define INFO(_jedec_id, _ext_id, _sector_size, _n_sectors, _flags)     \ 
    19 @@ -675,6 +677,10 @@ static const struct spi_device_id m25p_i 
     19@@ -689,6 +691,10 @@ static const struct spi_device_id m25p_i 
    2020        { "mx25l25635e", INFO(0xc22019, 0, 64 * 1024, 512, 0) }, 
    2121        { "mx25l25655e", INFO(0xc22619, 0, 64 * 1024, 512, 0) }, 
     
    2828         * for the chips listed here (without boot sectors). 
    2929         */