overlayfs移植

overlayfs 在linux-3.18后被合并入内核

网上可以找到2.6.38的补丁文件（openwrt）

目前需求是在3.10的内核中加入overlayfs的支持

3.10中file_operations和inode_operations有了修改，所以无法直接拿2.6.38的补丁，也无法直接合3.18的文件

取两者合集合并3.10的补丁

overlayfs.c

#include <linux/fs.h>
#include <linux/namei.h>
#include <linux/sched.h>
#include <linux/fs_struct.h>
#include <linux/file.h>
#include <linux/xattr.h>
#include <linux/security.h>
#include <linux/device_cgroup.h>
#include <linux/mount.h>
#include <linux/splice.h>
#include <linux/slab.h>
#include <linux/parser.h>
#include <linux/module.h>
#include <linux/uaccess.h>
#include <linux/rbtree.h>

MODULE_AUTHOR("Hippo<wcz@longene.com.cn>");
MODULE_DESCRIPTION("Overlay filesystem");
MODULE_LICENSE("GPL");

#define OVL_COPY_UP_CHUNK_SIZE (1 << 20)

extern int __inode_permission(struct inode *, int);
extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
loff_t *opos, size_t len, unsigned int flags);

struct ovl_fs {
struct vfsmount *upper_mnt;
struct vfsmount *lower_mnt;
};

struct ovl_entry {
struct dentry *__upperdentry;
struct dentry *lowerdentry;
union {
struct {
u64 version;
bool opaque;
};
struct rcu_head rcu;
};
};

static const char *ovl_whiteout_xattr = "trusted.overlay.whiteout";
static const char *ovl_opaque_xattr = "trusted.overlay.opaque";
static const char *ovl_whiteout_symlink = "(overlay-whiteout)";

enum ovl_path_type {
OVL_PATH_UPPER,
OVL_PATH_MERGE,
OVL_PATH_LOWER,
};

static enum ovl_path_type ovl_path_type(struct dentry *dentry)
{
struct ovl_entry *oe = dentry->d_fsdata;

if (oe->__upperdentry) {
if (oe->lowerdentry && S_ISDIR(dentry->d_inode->i_mode))
return OVL_PATH_MERGE;
else
return OVL_PATH_UPPER;
} else {
return OVL_PATH_LOWER;
}
}

static struct dentry *ovl_upperdentry_dereference(struct ovl_entry *oe)
{
struct dentry *upperdentry = ACCESS_ONCE(oe->__upperdentry);
smp_read_barrier_depends();
return upperdentry;
}

static void ovl_path_upper(struct dentry *dentry, struct path *path)
{
struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
struct ovl_entry *oe = dentry->d_fsdata;

path->mnt = ofs->upper_mnt;
path->dentry = ovl_upperdentry_dereference(oe);
}

static void ovl_path_lower(struct dentry *dentry, struct path *path)
{
struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
struct ovl_entry *oe = dentry->d_fsdata;

path->mnt = ofs->lower_mnt;
path->dentry = oe->lowerdentry;
}

static enum ovl_path_type ovl_path_real(struct dentry *dentry,
struct path *path)
{

enum ovl_path_type type = ovl_path_type(dentry);

if (type == OVL_PATH_LOWER)
ovl_path_lower(dentry, path);
else
ovl_path_upper(dentry, path);

return type;
}

static struct dentry *ovl_dentry_upper(struct dentry *dentry)
{
struct ovl_entry *oe = dentry->d_fsdata;

return ovl_upperdentry_dereference(oe);
}

static struct dentry *ovl_dentry_lower(struct dentry *dentry)
{
struct ovl_entry *oe = dentry->d_fsdata;

return oe->lowerdentry;
}

static struct dentry *ovl_dentry_real(struct dentry *dentry)
{
struct ovl_entry *oe = dentry->d_fsdata;
struct dentry *realdentry;

realdentry = ovl_upperdentry_dereference(oe);
if (!realdentry)
realdentry = oe->lowerdentry;

return realdentry;
}

static bool ovl_dentry_is_opaque(struct dentry *dentry)
{
struct ovl_entry *oe = dentry->d_fsdata;
return oe->opaque;
}

static void ovl_dentry_set_opaque(struct dentry *dentry, bool opaque)
{
struct ovl_entry *oe = dentry->d_fsdata;
oe->opaque = opaque;
}

static void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry)
{
struct ovl_entry *oe = dentry->d_fsdata;

WARN_ON(!mutex_is_locked(&upperdentry->d_parent->d_inode->i_mutex));
WARN_ON(oe->__upperdentry);
smp_wmb();
oe->__upperdentry = upperdentry;
}

static void ovl_dentry_version_inc(struct dentry *dentry)
{
struct ovl_entry *oe = dentry->d_fsdata;

WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex));
oe->version++;
}

static u64 ovl_dentry_version_get(struct dentry *dentry)
{
struct ovl_entry *oe = dentry->d_fsdata;

WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex));
return oe->version;
}

static bool ovl_is_whiteout(struct dentry *dentry)
{
int res;
char val;

if (!dentry)
return false;
if (!dentry->d_inode)
return false;
if (!S_ISLNK(dentry->d_inode->i_mode))
return false;

res = vfs_getxattr(dentry, ovl_whiteout_xattr, &val, 1);
if (res == 1 && val == 'y')
return true;

return false;
}

static bool ovl_is_opaquedir(struct dentry *dentry)
{
int res;
char val;

if (!S_ISDIR(dentry->d_inode->i_mode))
return false;

res = vfs_getxattr(dentry, ovl_opaque_xattr, &val, 1);
if (res == 1 && val == 'y')
return true;

return false;
}

struct ovl_cache_entry {
const char *name;
unsigned int len;
unsigned int type;
u64 ino;
bool is_whiteout;
struct list_head l_node;
struct rb_node node;
};

struct ovl_readdir_data {
struct rb_root *root;
struct list_head *list;
struct list_head *middle;
struct dentry *dir;
int count;
int err;
};

struct ovl_dir_file {
bool is_real;
bool is_cached;
struct list_head cursor;
u64 cache_version;
struct list_head cache;
struct file *realfile;
};

static struct ovl_cache_entry *ovl_cache_entry_from_node(struct rb_node *n)
{
return container_of(n, struct ovl_cache_entry, node);
}

static struct ovl_cache_entry *ovl_cache_entry_find(struct rb_root *root,
const char *name, int len)
{
struct rb_node *node = root->rb_node;
int cmp;

while (node) {
struct ovl_cache_entry *p = ovl_cache_entry_from_node(node);

cmp = strncmp(name, p->name, len);
if (cmp > 0)
node = p->node.rb_right;
else if (cmp < 0 || len < p->len)
node = p->node.rb_left;
else
return p;
}

return NULL;
}

static struct ovl_cache_entry *ovl_cache_entry_new(const char *name, int len,
u64 ino, unsigned int d_type)
//    bool is_whiteout)
{
struct ovl_cache_entry *p;

p = kmalloc(sizeof(*p) + len + 1, GFP_KERNEL);
if (p) {
char *name_copy = (char *) (p + 1);
memcpy(name_copy, name, len);
name_copy[len] = '\0';
p->name = name_copy;
p->len = len;
p->type = d_type;
p->ino = ino;
//p->is_whiteout = is_whiteout;

4000
p->is_whiteout = false;
}

return p;
}

static int ovl_cache_entry_add_rb(struct ovl_readdir_data *rdd,
const char *name, int len, u64 ino,
unsigned int d_type)
//, bool is_whiteout)
{
struct rb_node **newp = &rdd->root->rb_node;
struct rb_node *parent = NULL;
struct ovl_cache_entry *p;

while (*newp) {
int cmp;
struct ovl_cache_entry *tmp;

parent = *newp;
tmp = ovl_cache_entry_from_node(*newp);
cmp = strncmp(name, tmp->name, len);
if (cmp > 0)
newp = &tmp->node.rb_right;
else if (cmp < 0 || len < tmp->len)
newp = &tmp->node.rb_left;
else
return 0;
}

//p = ovl_cache_entry_new(name, len, ino, d_type, is_whiteout);
p = ovl_cache_entry_new(name, len, ino, d_type);
if (p == NULL)
return -ENOMEM;

//list_add_tail(&p->l_node, rdd->list);
/*
* Add links before other types to be able to quicky mark
* any whiteout entries
*/
if (d_type == DT_LNK)
list_add(&p->l_node, rdd->list);
else
list_add_tail(&p->l_node, rdd->list);
rb_link_node(&p->node, parent, newp);
rb_insert_color(&p->node, rdd->root);

return 0;
}

static int ovl_fill_lower(void *buf, const char *name, int namelen,
loff_t offset, u64 ino, unsigned int d_type)
{
struct ovl_readdir_data *rdd = buf;
struct ovl_cache_entry *p;

rdd->count++;
p = ovl_cache_entry_find(rdd->root, name, namelen);
if (p) {
list_move_tail(&p->l_node, rdd->middle);
} else {
//p = ovl_cache_entry_new(name, namelen, ino, d_type, false);
p = ovl_cache_entry_new(name, namelen, ino, d_type);
if (p == NULL)
rdd->err = -ENOMEM;
else
list_add_tail(&p->l_node, rdd->middle);
}

return rdd->err;
}

static void ovl_cache_free(struct list_head *list)
{
struct ovl_cache_entry *p;
struct ovl_cache_entry *n;

list_for_each_entry_safe(p, n, list, l_node)
kfree(p);

INIT_LIST_HEAD(list);
}

static int ovl_fill_upper(void *buf, const char *name, int namelen,
loff_t offset, u64 ino, unsigned int d_type)
{
struct ovl_readdir_data *rdd = buf;
//bool is_whiteout = false;

rdd->count++;
/*
if (d_type == DT_LNK) {
struct dentry *dentry;

dentry = lookup_one_len(name, rdd->dir, namelen);
if (IS_ERR(dentry)) {
rdd->err = PTR_ERR(dentry);
goto out;
}
is_whiteout = ovl_is_whiteout(dentry);
dput(dentry);
}

rdd->err = ovl_cache_entry_add_rb(rdd, name, namelen, ino, d_type,
is_whiteout);

out:
return rdd->err;
*/
return ovl_cache_entry_add_rb(rdd, name, namelen, ino, d_type);
}

static int ovl_dir_read(struct path *realpath, struct ovl_readdir_data *rdd,
filldir_t filler)
{
const struct cred *old_cred;
struct cred *override_cred;
struct file *realfile;
int err;

//realfile = vfs_open(realpath, O_RDONLY | O_DIRECTORY, current_cred());
realfile = dentry_open(realpath, O_RDONLY | O_DIRECTORY, current_cred());
if (IS_ERR(realfile))
return PTR_ERR(realfile);

err = -ENOMEM;
override_cred = prepare_creds();
if (override_cred) {
/*
* CAP_SYS_ADMIN for getxattr
* CAP_DAC_OVERRIDE for lookup and unlink
*/
cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE);
old_cred = override_creds(override_cred);

do {
rdd->count = 0;
rdd->err = 0;
err = vfs_readdir(realfile, filler, rdd);
if (err >= 0)
err = rdd->err;
} while (!err && rdd->count);

revert_creds(old_cred);
put_cred(override_cred);
}
fput(realfile);

if (err) {
if (rdd->list)
ovl_cache_free(rdd->list);
return err;
}

return 0;
}

static void ovl_dir_reset(struct file *file)
{
struct ovl_dir_file *od = file->private_data;
enum ovl_path_type type = ovl_path_type(file->f_path.dentry);

if (ovl_dentry_version_get(file->f_path.dentry) != od->cache_version) {
list_del_init(&od->cursor);
ovl_cache_free(&od->cache);
od->is_cached = false;
}
WARN_ON(!od->is_real && type != OVL_PATH_MERGE);
if (od->is_real && type == OVL_PATH_MERGE) {
fput(od->realfile);
od->realfile = NULL;
od->is_real = false;
}
}

static void ovl_dir_mark_whiteouts(struct ovl_readdir_data *rdd)
{
struct ovl_cache_entry *p;
struct dentry *dentry;

mutex_lock(&rdd->dir->d_inode->i_mutex);
list_for_each_entry(p, rdd->list, l_node) {
if (p->type != DT_LNK)
break;

dentry = lookup_one_len(p->name, rdd->dir, p->len);
if (IS_ERR(dentry))
continue;

p->is_whiteout = ovl_is_whiteout(dentry);
dput(dentry);
}
mutex_unlock(&rdd->dir->d_inode->i_mutex);
}

static int ovl_dir_read_merged(struct path *upperpath, struct path *lowerpath,
struct ovl_readdir_data *rdd)
{
int err;
struct rb_root root = RB_ROOT;
struct list_head middle;

rdd->root = &root;
if (upperpath->dentry) {
rdd->dir = upperpath->dentry;
err = ovl_dir_read(upperpath, rdd, ovl_fill_upper);
if (err)
goto out;

ovl_dir_mark_whiteouts(rdd);
}
/*
* Insert lowerpath entries before upperpath ones, this allows
* offsets to be reasonably constant
*/
list_add(&middle, rdd->list);
rdd->middle = &middle;
err = ovl_dir_read(lowerpath, rdd, ovl_fill_lower);
list_del(&middle);
out:
rdd->root = NULL;

return err;
}

static void ovl_seek_cursor(struct ovl_dir_file *od, loff_t pos)
{
struct list_head *l;
loff_t off;

l = od->cache.next;
for (off = 0; off < pos; off++) {
if (l == &od->cache)
break;
l = l->next;
}
list_move_tail(&od->cursor, l);
}

static int ovl_readdir(struct file *file, void *buf, filldir_t filler)
{
struct ovl_dir_file *od = file->private_data;
int res;

if (!file->f_pos)
ovl_dir_reset(file);

if (od->is_real) {
res = vfs_readdir(od->realfile, filler, buf);
file->f_pos = od->realfile->f_pos;

return res;
}

if (!od->is_cached) {
struct path lowerpath;
struct path upperpath;
struct ovl_readdir_data rdd = { .list = &od->cache };

ovl_path_lower(file->f_path.dentry, &lowerpath);
ovl_path_upper(file->f_path.dentry, &upperpath);

res = ovl_dir_read_merged(&upperpath, &lowerpath, &rdd);
if (res)
return res;

od->cache_version = ovl_dentry_version_get(file->f_path.dentry);
od->is_cached = true;

ovl_seek_cursor(od, file->f_pos);
}

while (od->cursor.next != &od->cache) {
int over;
loff_t off;
struct ovl_cache_entry *p;

p = list_entry(od->cursor.next, struct ovl_cache_entry, l_node);
off = file->f_pos;
file->f_pos++;
list_move(&od->cursor, &p->l_node);

if (p->is_whiteout)
continue;

over = filler(buf, p->name, p->len, off, p->ino, p->type);
if (over)
break;
}

return 0;
}

static loff_t ovl_dir_llseek(struct file *file, loff_t offset, int origin)
{
loff_t res;
struct ovl_dir_file *od = file->private_data;

mutex_lock(&file->f_dentry->d_inode->i_mutex);
if (!file->f_pos)
ovl_dir_reset(file);

if (od->is_real) {
res = vfs_llseek(od->realfile, offset, origin);
file->f_pos = od->realfile->f_pos;
} else {
res = -EINVAL;

switch (origin) {
case SEEK_CUR:
offset += file->f_pos;
break;
case SEEK_SET:
break;
default:
goto out_unlock;
}
if (offset < 0)
goto out_unlock;

if (offset != file->f_pos) {
file->f_pos = offset;
if (od->is_cached)
ovl_seek_cursor(od, offset);
}
res = offset;
}
out_unlock:
mutex_unlock(&file->f_dentry->d_inode->i_mutex);

return res;
}

static int ovl_dir_fsync(struct file *file, loff_t start, loff_t end,
int datasync)
//static int ovl_dir_fsync(struct file *file, int datasync)
{
struct ovl_dir_file *od = file->private_data;

/* May need to reopen directory if it got copied up */
if (!od->realfile) {
struct path upperpath;

ovl_path_upper(file->f_path.dentry, &upperpath);
//od->realfile = vfs_open(&upperpath, O_RDONLY, current_cred());
od->realfile = dentry_open(&upperpath, O_RDONLY, current_cred());
if (IS_ERR(od->realfile))
return PTR_ERR(od->realfile);
}

//return vfs_fsync(od->realfile, datasync);
return vfs_fsync_range(od->realfile, start, end, datasync);
}

static int ovl_dir_release(struct inode *inode, struct file *file)
{
struct ovl_dir_file *od = file->private_data;

list_del(&od->cursor);
ovl_cache_free(&od->cache);
if (od->realfile)
fput(od->realfile);
kfree(od);

return 0;
}

static int ovl_dir_open(struct inode *inode, struct file *file)
{
struct path realpath;
struct file *realfile;
struct ovl_dir_file *od;
enum ovl_path_type type;

od = kzalloc(sizeof(struct ovl_dir_file), GFP_KERNEL);
if (!od)
return -ENOMEM;

type = ovl_path_real(file->f_path.dentry, &realpath);
//realfile = vfs_open(&realpath, file->f_flags, current_cred());
realfile = dentry_open(&realpath, file->f_flags, current_cred());
if (IS_ERR(realfile)) {
kfree(od);
return PTR_ERR(realfile);
}
INIT_LIST_HEAD(&od->cache);
INIT_LIST_HEAD(&od->cursor);
od->is_cached = false;
od->realfile = realfile;
od->is_real = (type != OVL_PATH_MERGE);
file->private_data = od;

return 0;
}

static const struct file_operations ovl_dir_operations = {
.read           = generic_read_dir,
.open           = ovl_dir_open,
.readdir        = ovl_readdir,
.llseek         = ovl_dir_llseek,
.fsync          = ovl_dir_fsync,
.release        = ovl_dir_release,
};

static const struct inode_operations ovl_dir_inode_operations;

static void ovl_entry_free(struct rcu_head *head)
{
struct ovl_entry *oe = container_of(head, struct ovl_entry, rcu);
kfree(oe);
}

static void ovl_dentry_release(struct dentry *dentry)
{
struct ovl_entry *oe = dentry->d_fsdata;

if (oe) {
dput(oe->__upperdentry);
dput(oe->lowerdentry);
call_rcu(&oe->rcu, ovl_entry_free);
}
}

static const struct dentry_operations ovl_dentry_operations = {
.d_release = ovl_dentry_release,
};

static struct dentry *ovl_lookup_real(struct dentry *dir, struct qstr *name)
{
struct dentry *dentry;

mutex_lock(&dir->d_inode->i_mutex);
dentry = lookup_one_len(name->name, dir, name->len);
mutex_unlock(&dir->d_inode->i_mutex);

if (IS_ERR(dentry)) {
if (PTR_ERR(dentry) == -ENOENT)
dentry = NULL;
} else if (!dentry->d_inode) {
dput(dentry);
dentry = NULL;
}
return dentry;
}

static struct ovl_entry *ovl_alloc_entry(void)
{
return kzalloc(sizeof(struct ovl_entry), GFP_KERNEL);
}

static struct inode *ovl_new_inode(struct super_block *sb, umode_t mode,
struct ovl_entry *oe);

static struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
unsigned int flags)
//         struct nameidata *nd)
{
struct ovl_entry *oe;
struct dentry *upperdir;
struct dentry *lowerdir;
struct dentry *upperdentry = NULL;
struct dentry *lowerdentry = NULL;
struct inode *inode = NULL;
int err;

err = -ENOMEM;
oe = ovl_alloc_entry();
if (!oe)
goto out;

upperdir = ovl_dentry_upper(dentry->d_parent);
lowerdir = ovl_dentry_lower(dentry->d_parent);

if (upperdir) {
upperdentry = ovl_lookup_real(upperdir, &dentry->d_name);
err = PTR_ERR(upperdentry);
if (IS_ERR(upperdentry))
goto out_put_dir;

if (lowerdir && upperdentry &&
(S_ISLNK(upperdentry->d_inode->i_mode) ||
S_ISDIR(upperdentry->d_inode->i_mode))) {
const struct cred *old_cred;
struct cred *override_cred;

err = -ENOMEM;
override_cred = prepare_creds();
if (!override_cred)
goto out_dput_upper;

/* CAP_SYS_ADMIN needed for getxattr */
cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
old_cred = override_creds(override_cred);

if (ovl_is_opaquedir(upperdentry)) {
oe->opaque = true;
} else if (ovl_is_whiteout(upperdentry)) {
dput(upperdentry);
upperdentry = NULL;
oe->opaque = true;
}
revert_creds(old_cred);

16a55
put_cred(override_cred);
}
}
if (lowerdir && !oe->opaque) {
lowerdentry = ovl_lookup_real(lowerdir, &dentry->d_name);
err = PTR_ERR(lowerdentry);
if (IS_ERR(lowerdentry))
goto out_dput_upper;
}

if (lowerdentry && upperdentry &&
(!S_ISDIR(upperdentry->d_inode->i_mode) ||
!S_ISDIR(lowerdentry->d_inode->i_mode))) {
dput(lowerdentry);
lowerdentry = NULL;
oe->opaque = true;
}

if (lowerdentry || upperdentry) {
struct dentry *realdentry;

realdentry = upperdentry ? upperdentry : lowerdentry;
err = -ENOMEM;
inode = ovl_new_inode(dir->i_sb, realdentry->d_inode->i_mode, oe);
if (!inode)
goto out_dput;
}

if (upperdentry)
oe->__upperdentry = upperdentry;

if (lowerdentry)
oe->lowerdentry = lowerdentry;

dentry->d_fsdata = oe;
dentry->d_op = &ovl_dentry_operations;
d_add(dentry, inode);

return NULL;

out_dput:
dput(lowerdentry);
out_dput_upper:
dput(upperdentry);
out_put_dir:
kfree(oe);
out:
return ERR_PTR(err);
}

static int ovl_copy_up_xattr(struct dentry *old, struct dentry *new)
{
ssize_t list_size, size;
char *buf, *name, *value;
int error;

if (!old->d_inode->i_op->getxattr ||
!new->d_inode->i_op->getxattr)
return 0;

list_size = vfs_listxattr(old, NULL, 0);
if (list_size <= 0) {
if (list_size == -EOPNOTSUPP)
return 0;
return list_size;
}

buf = kzalloc(list_size, GFP_KERNEL);
if (!buf)
return -ENOMEM;

error = -ENOMEM;
value = kmalloc(XATTR_SIZE_MAX, GFP_KERNEL);
if (!value)
goto out;

list_size = vfs_listxattr(old, buf, list_size);
if (list_size <= 0) {
error = list_size;
goto out_free_value;
}

for (name = buf; name < (buf + list_size); name += strlen(name) + 1) {
size = vfs_getxattr(old, name, value, XATTR_SIZE_MAX);
if (size <= 0) {
error = size;
goto out_free_value;
}
error = vfs_setxattr(new, name, value, size, 0);
if (error)
goto out_free_value;
}

out_free_value:
kfree(value);
out:
kfree(buf);
return error;
}

static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len)
{
struct file *old_file;
struct file *new_file;
loff_t old_pos = 0;
loff_t new_pos = 0;
int error = 0;

if (len == 0)
return 0;

//old_file = vfs_open(old, O_RDONLY, current_cred());
old_file = dentry_open(old, O_RDONLY, current_cred());
if (IS_ERR(old_file))
return PTR_ERR(old_file);

//new_file = vfs_open(new, O_WRONLY, current_cred());
new_file = dentry_open(new, O_WRONLY, current_cred());
if (IS_ERR(new_file)) {
error = PTR_ERR(new_file);
goto out_fput;
}

/* FIXME: copy up sparse files efficiently */
while (len) {
//loff_t offset = new_file->f_pos;
size_t this_len = OVL_COPY_UP_CHUNK_SIZE;
long bytes;

if (len < this_len)
this_len = len;

if (signal_pending_state(TASK_KILLABLE, current)){
error = -EINTR;
break;
}
//  return -EINTR;

//hippo
bytes = do_splice_direct(old_file, &old_pos, new_file, &new_pos,this_len,SPLICE_F_MOVE);
if (bytes <= 0) {
error = bytes;
break;
}
WARN_ON(old_pos != new_pos);

len -= bytes;
}

fput(new_file);
out_fput:
fput(old_file);
return error;
}

static struct dentry *ovl_lookup_create(struct dentry *upperdir,
struct dentry *template)
{
int err;
struct dentry *newdentry;
struct qstr *name = &template->d_name;

newdentry = lookup_one_len(name->name, upperdir, name->len);
if (IS_ERR(newdentry))
return newdentry;

if (newdentry->d_inode) {
const struct cred *old_cred;
struct cred *override_cred;

/* No need to check whiteout if lower parent is non-existent */
err = -EEXIST;
if (!ovl_dentry_lower(template->d_parent))
goto out_dput;

if (!S_ISLNK(newdentry->d_inode->i_mode))
goto out_dput;

err = -ENOMEM;
override_cred = prepare_creds();
if (!override_cred)
goto out_dput;

/*
* CAP_SYS_ADMIN for getxattr
* CAP_FOWNER for unlink in sticky directory
*/
cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
cap_raise(override_cred->cap_effective, CAP_FOWNER);
old_cred = override_creds(override_cred);

err = -EEXIST;
if (ovl_is_whiteout(newdentry))
err = vfs_unlink(upperdir->d_inode, newdentry);

revert_creds(old_cred);
put_cred(override_cred);
if (err)
goto out_dput;

dput(newdentry);
newdentry = lookup_one_len(name->name, upperdir, name->len);
if (IS_ERR(newdentry))
return newdentry;

/*
* Whiteout just been successfully removed, parent
* i_mutex is still held, there's no way the lookup
* could return positive.
*/
WARN_ON(newdentry->d_inode);
}

return newdentry;

out_dput:
dput(newdentry);
return ERR_PTR(err);
}

static struct dentry *ovl_upper_create(struct dentry *upperdir,
struct dentry *dentry,
struct kstat *stat, const char *link)
{
int err;
struct dentry *newdentry;
struct inode *dir = upperdir->d_inode;

newdentry = ovl_lookup_create(upperdir, dentry);
if (IS_ERR(newdentry))
goto out;

switch (stat->mode & S_IFMT) {
case S_IFREG:
err = vfs_create(dir, newdentry, stat->mode, NULL);
break;

case S_IFDIR:
err = vfs_mkdir(dir, newdentry, stat->mode);
break;

case S_IFCHR:
case S_IFBLK:
case S_IFIFO:
case S_IFSOCK:
err = vfs_mknod(dir, newdentry, stat->mode, stat->rdev);
break;

case S_IFLNK:
err = vfs_symlink(dir, newdentry, link);
break;

default:
err = -EPERM;
}
if (err) {
dput(newdentry);
newdentry = ERR_PTR(err);
}

out:
return newdentry;

}

static char *ovl_read_symlink(struct dentry *realdentry)
{
int res;
char *buf;
struct inode *inode = realdentry->d_inode;
mm_segment_t old_fs;

res = -EINVAL;
if (!inode->i_op->readlink)
goto err;

res = -ENOMEM;
buf = (char *) __get_free_page(GFP_KERNEL);
if (!buf)
goto err;

old_fs = get_fs();
set_fs(get_ds());
/* The cast to a user pointer is valid due to the set_fs() */
res = inode->i_op->readlink(realdentry,
(char __user *)buf, PAGE_SIZE - 1);
set_fs(old_fs);
if (res < 0) {
free_page((unsigned long) buf);
goto err;
}
buf[res] = '\0';

return buf;

err:
return ERR_PTR(res);
}

static int ovl_set_timestamps(struct dentry *upperdentry, struct kstat *stat)
{
struct iattr attr = {
.ia_valid = ATTR_ATIME | ATTR_MTIME | ATTR_ATIME_SET | ATTR_MTIME_SET,
.ia_atime = stat->atime,
.ia_mtime = stat->mtime,
};

return notify_change(upperdentry, &attr);
}

static int ovl_set_mode(struct dentry *upperdentry, umode_t mode)
{
struct iattr attr = {
.ia_valid = ATTR_MODE,
.ia_mode = mode,
};

return notify_change(upperdentry, &attr);
}

static int ovl_set_opaque(struct dentry *upperdentry)
{
int err;
const struct cred *old_cred;
struct cred *override_cred;

override_cred = prepare_creds();
if (!override_cred)
return -ENOMEM;

/* CAP_SYS_ADMIN for setxattr of "trusted" namespace */
cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
old_cred = override_creds(override_cred);
err = vfs_setxattr(upperdentry, ovl_opaque_xattr, "y", 1, 0);
revert_creds(old_cred);
put_cred(override_cred);

return err;
}

static int ovl_remove_opaque(struct dentry *upperdentry)
{
int err;
const struct cred *old_cred;
struct cred *override_cred;

override_cred = prepare_creds();
if (!override_cred)
return -ENOMEM;

/* CAP_SYS_ADMIN for removexattr of "trusted" namespace */
cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
old_cred = override_creds(override_cred);
err = vfs_removexattr(upperdentry, ovl_opaque_xattr);
revert_creds(old_cred);
put_cred(override_cred);

return err;
}

static int ovl_copy_up_locked(struct dentry *upperdir, struct dentry *dentry,
struct path *lowerpath, struct kstat *stat,
const char *link)
{
int err;
struct path newpath;
umode_t mode = stat->mode;
struct ovl_fs *ofs = dentry->d_sb->s_fs_info;

/* Can't properly set mode on creation because of the umask */
stat->mode &= S_IFMT;

newpath.mnt = ofs->upper_mnt;
newpath.dentry = ovl_upper_create(upperdir, dentry, stat, link);
if (IS_ERR(newpath.dentry)) {
err = PTR_ERR(newpath.dentry);

/* Already copied up? */
if (err == -EEXIST && ovl_path_type(dentry) != OVL_PATH_LOWER)
return 0;

return err;
}

/* FIXME: recovery from failure to copy up */

if (S_ISREG(stat->mode)) {
err = ovl_copy_up_data(lowerpath, &newpath, stat->size);
if (err)
return err;
}

err = ovl_copy_up_xattr(lowerpath->dentry, newpath.dentry);
if (err)
return err;

mutex_lock(&newpath.dentry->d_inode->i_mutex);
if (!S_ISLNK(stat->mode))
err = ovl_set_mode(newpath.dentry, mode);
if (!err)
err = ovl_set_timestamps(newpath.dentry, stat);
mutex_unlock(&newpath.dentry->d_inode->i_mutex);
if (err)
return err;

ovl_dentry_update(dentry, newpath.dentry);

/*
* Easiest way to get rid of the lower dentry reference is to
* drop this dentry.  This is neither needed nor possible for
* directories.
*/
if (!S_ISDIR(stat->mode))
d_drop(dentry);

return 0;
}

static int ovl_copy_up_one(struct dentry *parent, struct dentry *dentry,
struct path *lowerpath, struct kstat *stat)
{
int err;
struct kstat pstat;
struct path parentpath;
struct dentry *upperdir;
const struct cred *old_cred;
struct cred *override_cred;
char *link = NULL;

ovl_path_upper(parent, &parentpath);
upperdir = parentpath.dentry;

//err = vfs_getattr(parentpath.mnt, parentpath.dentry, &pstat);
err = vfs_getattr(&parentpath, &pstat);
if (err)
return err;

if (S_ISLNK(stat->mode)) {
link = ovl_read_symlink(lowerpath->dentry);
if (IS_ERR(link))
return PTR_ERR(link);
}

err = -ENOMEM;
override_cred = prepare_creds();
if (!override_cred)
goto out_free_link;

override_cred->fsuid = stat->uid;
override_cred->fsgid = stat->gid;
/*
* CAP_SYS_ADMIN for copying up extended attributes
* CAP_DAC_OVERRIDE for create
* CAP_FOWNER for chmod, timestamp update
* CAP_FSETID for chmod
* CAP_MKNOD for mknod
*/
cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE);
cap_raise(override_cred->cap_effective, CAP_FOWNER);
cap_raise(override_cred->cap_effective, CAP_FSETID);
cap_raise(override_cred->cap_effective, CAP_MKNOD);
old_cred = override_creds(override_cred);

mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT);
/*
* Using upper filesystem locking to protect against copy up
* racing with rename (rename means the copy up was already
* successful).
*/
if (dentry->d_parent != parent) {
WARN_ON((ovl_path_type(dentry) == OVL_PATH_LOWER));
err = 0;
} else {
err = ovl_copy_up_locked(upperdir, dentry, lowerpath,
stat, link);
if (!err) {
/* Restore timestamps on parent (best effort) */
ovl_set_timestamps(upperdir, &pstat);
}
}

mutex_unlock(&upperdir->d_inode->i_mutex);

revert_creds(old_cred);
put_cred(override_cred);

out_free_link:
if (link)
free_page((unsigned long) link);

return err;
}

static int ovl_copy_up(struct dentry *dentry)
{
int err;

err = 0;
while (!err) {
struct dentry *next;
struct dentry *parent;
struct path lowerpath;
struct kstat stat;
enum ovl_path_type type = ovl_path_type(dentry);

if (type != OVL_PATH_LOWER)
break;

next = dget(dentry);
/* find the topmost dentry not yet copied up */
for (;;) {
parent = dget_parent(next);

type = ovl_path_type(parent);
if (type != OVL_PATH_LOWER)
break;

dput(next);
next = parent;
}

ovl_path_lower(next, &lowerpath);
//err = vfs_getattr(lowerpath.mnt, lowerpath.dentry, &stat);
err = vfs_getattr(&lowerpath, &stat);
if (!err)
err = ovl_copy_up_one(parent, next, &lowerpath, &stat);

dput(parent);
dput(next);
}

return err;
}

/* Optimize by not copying up the file first and truncating later */
static int ovl_copy_up_truncate(struct dentry *dentry, loff_t size)
{
int err;
struct kstat stat;
struct path lowerpath;
struct dentry *parent = dget_parent(dentry);

err = ovl_copy_up(parent);
if (err)
goto out_dput_parent;

ovl_path_lower(dentry, &lowerpath);
//err = vfs_getattr(lowerpath.mnt, lowerpath.dentry, &stat);
err = vfs_getattr(&lowerpath, &stat);
if (err)
goto out_dput_parent;

if (size < stat.size)
stat.size = size;

err = ovl_copy_up_one(parent, dentry, &lowerpath, &stat);

out_dput_parent:
dput(parent);
return err;
}

static int ovl_setattr(struct dentry *dentry, struct iattr *attr)
{
struct dentry *upperdentry;
int err;

if ((attr->ia_valid & ATTR_SIZE) && !ovl_dentry_upper(dentry))
err = ovl_copy_up_truncate(dentry, attr->ia_size);
else
err = ovl_copy_up(dentry);
if (err)
return err;

upperdentry = ovl_dentry_upper(dentry);

if (attr->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
attr->ia_valid &= ~ATTR_MODE;

mutex_lock(&upperdentry->d_inode->i_mutex);
err = notify_change(upperdentry, attr);
mutex_unlock(&upperdentry->d_inode->i_mutex);

return err;
}

static int ovl_getattr(struct vfsmount *mnt, struct dentry *dentry,
struct kstat *stat)
{
struct path realpath;

ovl_path_real(dentry, &realpath);
//return vfs_getattr(realpath.mnt, realpath.dentry, stat);
return vfs_getattr(&realpath, stat);
}

static int ovl_dir_getattr(struct vfsmount *mnt, struct dentry *dentry,
struct kstat *stat)
{
int err;
enum ovl_path_type type;
struct path realpath;

type = ovl_path_real(dentry, &realpath);
//err = vfs_getattr(realpath.mnt, realpath.dentry, stat);
err = vfs_getattr(&realpath, stat);
if (err)
return err;

stat->dev = dentry->d_sb->s_dev;
stat->ino = dentry->d_inode->i_ino;

/*
* It's probably not worth it to count subdirs to get the
* correct link count.  nlink=1 seems to pacify 'find' and
* other utilities.
*/
if (type == OVL_PATH_MERGE)
stat->nlink = 1;

return 0;
}

struct dentry *ovl_entry_real(struct ovl_entry *oe, bool *is_upper)
{
struct dentry *realdentry;

realdentry = ovl_upperdentry_dereference(oe);
if (realdentry) {
*is_upper = true;
} else {
realdentry = oe->lowerdentry;
*is_upper = false;
}
return realdentry;
}

//static int ovl_permission(struct inode *inode, int mask, unsigned int flags)
int ovl_permission(struct inode *inode, int mask)
{
#if 1
struct ovl_entry *oe;
struct dentry *alias = NULL;
struct inode *realinode;
struct dentry *realdentry;
bool is_upper;
int err;

if (S_ISDIR(inode->i_mode)) {
oe = inode->i_private;
//} else if (flags & IPERM_FLAG_RCU) {
//return -ECHILD;
} else {
/*
* For non-directories find an alias and get the info
* from there.
*/
spin_lock(&inode->i_lock);
//if (WARN_ON(list_empty(&inode->i_dentry))) {
if (WARN_ON(hlist_empty(&inode->i_dentry))) {
spin_unlock(&inode->i_lock);
return -ENOENT;
}
//alias = list_entry(inode->i_dentry.next, struct dentry, d_alias);
alias = hlist_entry(inode->i_dentry.first, struct dentry, d_alias);
dget(alias);
spin_unlock(&inode->i_lock);
oe = alias->d_fsdata;
}

realdentry = ovl_upperdentry_dereference(oe);
is_upper = true;
if (!realdentry) {
realdentry = oe->lowerdentry;
is_upper = false;
}

/* Careful in RCU walk mode */
realinode = ACCESS_ONCE(realdentry->d_inode);
if (!realinode) {
//WARN_ON(!(flags & IPERM_FLAG_RCU));
return -ENOENT;
}

if (mask & MAY_WRITE) {
umode_t mode = realinode->i_mode;

/*
* Writes will always be redirected to upper layer, so
* ignore lower layer being read-only.
*/
err = -EROFS;
if (is_upper && IS_RDONLY(realinode) &&
(S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
goto out_dput;

/*
* Nobody gets write access to an immutable file.
*/
err = -EACCES;
if (IS_IMMUTABLE(realinode))
goto out_dput;
}

if (realinode->i_op->permission)
//err = realinode->i_op->permission(realinode, mask, flags);
err = realinode->i_op->permission(realinode, mask);
else
err = generic_permission(realinode, mask);
//err = generic_permission(realinode, mask, flags,
//                        realinode->i_op->check_acl);
out_dput:
dput(alias);
return err;
#else

struct ovl_entry *oe;
struct dentry *alias = NULL;
struct inode *realinode;
struct dentry *realdentry;
bool is_upper;
int err;

if (S_ISDIR(inode->i_mode)) {
oe = inode->i_private;
} else if (mask & MAY_NOT_BLOCK) {
return -ECHILD;
} else {
/*
* For non-directories find an alias and get the info
* from there.
*/
alias = d_find_any_alias(inode);
if (WARN_ON(!alias))
return -ENOENT;

oe = alias->d_fsdata;
}

realdentry = ovl_entry_real(oe, &is_upper);

/* Careful in RCU walk mode */
realinode = ACCESS_ONCE(realdentry->d_inode);
if (!realinode) {
WARN_ON(!(mask & MAY_NOT_BLOCK));
err = -ENOENT;
goto out_dput;
}

if (mask & MAY_WRITE) {
umode_t mode = realinode->i_mode;

/*
* Writes will always be redirected to upper layer, so
* ignore lower layer being read-only.
*
* If the overlay itself is read-only then proceed
* with the permission check, don't return EROFS.
* This will only happen if this is the lower layer of
* another overlayfs.
*
* If upper fs becomes read-only after the overlay was
* constructed return EROFS to prevent modification of
* upper layer.
*/
err = -EROFS;
if (is_upper && !IS_RDONLY(inode) && IS_RDONLY(realinode) &&
(S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
goto out_dput;
}

err = __inode_permission(realinode, mask);
out_dput:
dput(alias);
return err;
#endif
}

static int ovl_create_object(struct dentry *dentry, int mode, dev_t rdev,
const char *link)
{
int err;
struct dentry *newdentry;
struct dentry *upperdir;
struct inode *inode;
struct kstat stat = {
.mode = mode,
.rdev = rdev,
};

err = -ENOMEM;
inode = ovl_new_inode(dentry->d_sb, mode, dentry->d_fsdata);
if (!inode)
goto out;

err = ovl_copy_up(dentry->d_parent);
if (err)
goto out_iput;

upperdir = ovl_dentry_upper(dentry->d_parent);
mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT);

newdentry = ovl_upper_create(upperdir, dentry, &stat, link);
err = PTR_ERR(newdentry);
if (IS_ERR(newdentry))
goto out_unlock;

ovl_dentry_version_inc(dentry->d_parent);
if (ovl_dentry_is_opaque(dentry) && S_ISDIR(mode)) {
err = ovl_set_opaque(newdentry);
if (err)
goto out_dput;
}
ovl_dentry_update(dentry, newdentry);
d_instantiate(dentry, inode);
inode = NULL;
newdentry = NULL;
err = 0;

out_dput:
dput(newdentry);
out_unlock:
mutex_unlock(&upperdir->d_inode->i_mutex);
out_iput:
iput(inode);
out:
return err;
}

//static int ovl_create(struct inode *dir, struct dentry *dentry, int mode,
//                      struct nameidata *nd)
static int ovl_create(struct inode *dir, struct dentry *dentry, umode_t mode,
bool excl)
{
return ovl_create_object(dentry, (mode & 07777) | S_IFREG, 0, NULL);
}

//static int ovl_mkdir(struct inode *dir, struct dentry *dentry, int mode)
static int ovl_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
{
return ovl_create_object(dentry, (mode & 07777) | S_IFDIR, 0, NULL);
}

//static int ovl_mknod(struct inode *dir, struct dentry *dentry, int mode,
static int ovl_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
dev_t rdev)
{
return ovl_create_object(dentry, mode, rdev, NULL);
}

static int ovl_symlink(struct inode *dir, struct dentry *dentry,
const char *link)
{
return ovl_create_object(dentry, S_IFLNK, 0, link);
}

struct ovl_link_data {
struct dentry *realdentry;
void *cookie;
};

static void *ovl_follow_link(struct dentry *dentry, struct nameidata *nd)
{
void *ret;
struct dentry *realdentry;
struct inode *realinode;

realdentry = ovl_dentry_real(dentry);
realinode = realdentry->d_inode;

if (WARN_ON(!realinode->i_op->follow_link))
return ERR_PTR(-EPERM);

ret = realinode->i_op->follow_link(realdentry, nd);
if (IS_ERR(ret))
return ret;

if (realinode->i_op->put_link) {
struct ovl_link_data *data;

data = kmalloc(sizeof(struct ovl_link_data), GFP_KERNEL);
if (!data) {
realinode->i_op->put_link(realdentry, nd, ret);
return ERR_PTR(-ENOMEM);
}
data->realdentry = realdentry;
data->cookie = ret;

return data;
} else {
return NULL;
}
}

static void ovl_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
{
struct inode *realinode;
struct ovl_link_data *data = c;

if (!data)
return;

realinode = data->realdentry->d_inode;
realinode->i_op->put_link(data->realdentry, nd, data->cookie);
kfree(data);
}

static int ovl_readlink(struct dentry *dentry, char __user *buf, int bufsiz)
{
struct path realpath;
struct inode *realinode;

ovl_path_real(dentry, &realpath);
realinode = realpath.dentry->d_inode;

if (!realinode->i_op->readlink)
return -EINVAL;

//touch_atime(realpath.mnt, realpath.dentry);
touch_atime(&realpath);

return realinode->i_op->readlink(realpath.dentry, buf, bufsiz);
}

static int ovl_whiteout(struct dentry *upperdir, struct dentry *dentry)
{
int err;
struct dentry *newdentry;
const struct cred *old_cred;
struct cred *override_cred;

/* FIXME: recheck lower dentry to see if whiteout is really needed */

err = -ENOMEM;
override_cred = prepare_creds();
if (!override_cred)
goto out;

/*
* CAP_SYS_ADMIN for setxattr
* CAP_DAC_OVERRIDE for symlink creation
*/
cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE);
override_cred->fsuid = 0;
override_cred->fsgid = 0;
old_cred = override_creds(override_cred);

newdentry = lookup_one_len(dentry->d_name.name, upperdir,
dentry->d_name.len);
err = PTR_ERR(newdentry);
if (IS_ERR(newdentry))
goto out_put_cred;

/* Just been removed within the same locked region */
WARN_ON(newdentry->d_inode);

err = vfs_symlink(upperdir->d_inode, newdentry, ovl_whiteout_symlink);
if (err)
goto out_dput;

ovl_dentry_version_inc(dentry->d_parent);

err = vfs_setxattr(newdentry, ovl_whiteout_xattr, "y", 1, 0);

out_dput:
dput(newdentry);
out_put_cred:
revert_creds(old_cred);
put_cred(override_cred);
out:
return err;
}

static int ovl_do_remove(struct dentry *dentry, bool is_dir)
{
int err;
enum ovl_path_type type;
struct path realpath;
struct dentry *upperdir;

err = ovl_copy_up(dentry->d_parent);
if (err)
return err;

upperdir = ovl_dentry_upper(dentry->d_parent);
mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT);
type = ovl_path_real(dentry, &realpath);
if (type != OVL_PATH_LOWER) {
err = -ESTALE;
if (realpath.dentry->d_parent != upperdir)
goto out_d_drop;

if (is_dir)
err = vfs_rmdir(upperdir->d_inode, realpath.dentry);
else
err = vfs_unlink(upperdir->d_inode, realpath.dentry);
if (err)
goto out_d_drop;

ovl_dentry_version_inc(dentry->d_parent);
}

if (type != OVL_PATH_UPPER || ovl_dentry_is_opaque(dentry))
err = ovl_whiteout(upperdir, dentry);

/*
* Keeping this dentry hashed would mean having to release
* upperpath/lowerpath, which could only be done if we are the
* sole user of this dentry.  Too tricky...  Just unhash for
* now.
*/
out_d_drop:
d_drop(dentry);
mutex_unlock(&upperdir->d_inode->i_mutex);

return err;
}

static int ovl_unlink(struct inode *dir, struct dentry *dentry)
{
return ovl_do_remove(dentry, false);
}

static int ovl_check_empty_dir(struct dentry *dentry)
{
int err;
struct path lowerpath;
struct path upperpath;
struct ovl_cache_entry *p;
LIST_HEAD(list);
struct ovl_readdir_data rdd = { .list = &list };

ovl_path_upper(dentry, &upperpath);
ovl_path_lower(dentry, &lowerpath);

err = ovl_dir_read_merged(&upperpath, &lowerpath, &rdd);
if (err)
return err;

err = 0;

list_for_each_entry(p, &list, l_node) {
if (p->is_whiteout)
continue;

if (p->name[0] == '.') {
if (p->len == 1)
continue;
if (p->len == 2 && p->name[1] == '.')
continue;
}
err = -ENOTEMPTY;
break;
}

ovl_cache_free(&list);

return err;
}

static int ovl_unlink_whiteout(void *buf, const char *name, int namelen,
loff_t offset, u64 ino, unsigned int d_type)
{
struct ovl_readdir_data *rdd = buf;

rdd->count++;
/* check d_type to filter out "." and ".." */
if (d_type == DT_LNK) {
struct dentry *dentry;

dentry = lookup_one_len(name, rdd->dir, namelen);
if (IS_ERR(dentry)) {
rdd->err = PTR_ERR(dentry);
} else {
rdd->err = vfs_unlink(rdd->dir->d_inode, dentry);
dput(dentry);
}
}

return rdd->err;
}

static int ovl_remove_whiteouts(struct dentry *dentry)
{
struct path upperpath;
struct ovl_readdir_data rdd = { .list = NULL };

ovl_path_upper(dentry, &upperpath);
rdd.dir = upperpath.dentry;

return ovl_dir_read(&upperpath, &rdd, ovl_unlink_whiteout);
}

static int ovl_rmdir(struct inode *dir, struct dentry *dentry)
{
int err;
enum ovl_path_type type;

type = ovl_path_type(dentry);
if (type != OVL_PATH_UPPER) {
err = ovl_check_empty_dir(dentry);
if (err)
return err;

if (type == OVL_PATH_MERGE) {
err = ovl_remove_whiteouts(dentry);
if (err)
return err;
}
}

return ovl_do_remove(dentry, true);
}

static int ovl_link(struct dentry *old, struct inode *newdir,
struct dentry *new)
{
int err;
struct dentry *olddentry;
struct dentry *newdentry;
struct dentry *upperdir;

err = ovl_copy_up(old);
if (err)
goto out;

err = ovl_copy_up(new->d_parent);
if (err)
goto out;

upperdir = ovl_dentry_upper(new->d_parent);
mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT);
newdentry = ovl_lookup_create(upperdir, new);
err = PTR_ERR(newdentry);
if (IS_ERR(newdentry))
goto out_unlock;

olddentry = ovl_dentry_upper(old);
err = vfs_link(olddentry, upperdir->d_inode, newdentry);
if (!err) {
ovl_dentry_version_inc(new->d_parent);
ovl_dentry_update(new, newdentry);

ihold(old->d_inode);
d_instantiate(new, old->d_inode);
} else {
dput(newdentry);
}
out_unlock:
mutex_unlock(&upperdir->d_inode->i_mutex);
out:
return err;

}

static int ovl_rename(struct inode *olddir, struct dentry *old,
struct inode *newdir, struct dentry *new)
{
int err;
enum ovl_path_type old_type;
struct dentry *old_upperdir;
struct dentry *new_upperdir;
struct dentry *olddentry;
struct dentry *newdentry;
struct dentry *trap;
bool is_dir = S_ISDIR(old->d_inode->i_mode);

/* Don't copy up directory trees */
old_type = ovl_path_type(old);
if (old_type != OVL_PATH_UPPER && is_dir)
return -EXDEV;

if (new->d_inode) {
enum ovl_path_type new_type;

new_type = ovl_path_type(new);

if (new_type == OVL_PATH_LOWER && old_type == OVL_PATH_LOWER) {
if (ovl_dentry_lower(old)->d_inode ==
ovl_dentry_lower(new)->d_inode)
return 0;
}
if (new_type != OVL_PATH_LOWER && old_type != OVL_PATH_LOWER) {
if (ovl_dentry_upper(old)->d_inode ==
ovl_dentry_upper(new)->d_inode)
return 0;
}

if (new_type != OVL_PATH_UPPER &&
S_ISDIR(new->d_inode->i_mode)) {
err = ovl_check_empty_dir(new);
if (err)
return err;

if (new_type == OVL_PATH_MERGE) {
err = ovl_remove_whiteouts(new);
if (err)
return err;
}
}
}

err = ovl_copy_up(old);
if (err)
return err;

err = ovl_copy_up(new->d_parent);
if (err)
return err;

old_upperdir = ovl_dentry_upper(old->d_parent);
new_upperdir = ovl_dentry_upper(new->d_parent);

trap = lock_rename(new_upperdir, old_upperdir);

olddentry = ovl_dentry_upper(old);
newdentry = ovl_dentry_upper(new);
if (newdentry) {
dget(newdentry);
} else {
newdentry = ovl_lookup_create(new_upperdir, new);
err = PTR_ERR(newdentry);
if (IS_ERR(newdentry))
goto out_unlock;
}

err = -ESTALE;
if (olddentry->d_parent != old_upperdir)
goto out_dput;
if (newdentry->d_parent != new_upperdir)
goto out_dput;
if (olddentry == trap)
goto out_dput;
if (newdentry == trap)
goto out_dput;

err = vfs_rename(old_upperdir->d_inode, olddentry,
new_upperdir->d_inode, newdentry);

if (!err) {
bool old_opaque = ovl_dentry_is_opaque(old);
bool new_opaque = ovl_dentry_is_opaque(new);

if (ovl_path_type(new) != OVL_PATH_UPPER)
new_opaque = true;

if (old_type != OVL_PATH_UPPER || old_opaque)
err = ovl_whiteout(old_upperdir, old);
if (!err && is_dir) {
if (old_opaque && !new_opaque) {
ovl_remove_opaque(olddentry);
ovl_dentry_set_opaque(old, false);
}
if (!old_opaque && new_opaque) {
err = ovl_set_opaque(olddentry);
ovl_dentry_set_opaque(old, true);
}
}
ovl_dentry_version_inc(old->d_parent);
ovl_dentry_version_inc(new->d_parent);
}

out_dput:
dput(newdentry);
out_unlock:
unlock_rename(new_upperdir, old_upperdir);
return err;
}

static bool ovl_is_private_xattr(const char *name)
{
return strncmp(name, "trusted.overlay.", 14) == 0;
}

static int ovl_setxattr(struct dentry *dentry, const char *name,
const void *value, size_t size, int flags)
{
int err;
struct dentry *upperdentry;

if (ovl_is_private_xattr(name))
return -EPERM;

err = ovl_copy_up(dentry);
if (err)
return err;

upperdentry = ovl_dentry_upper(dentry);
return  vfs_setxattr(upperdentry, name, value, size, flags);
}

static ssize_t ovl_getxattr(struct dentry *dentry, const char *name,
void *value, size_t size)
{
if (ovl_path_type(dentry->d_parent) == OVL_PATH_MERGE &&
ovl_is_private_xattr(name))
return -ENODATA;

return vfs_getxattr(ovl_dentry_real(dentry), name, value, size);
}

static ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size)
{
ssize_t res;
int off;

res = vfs_listxattr(ovl_dentry_real(dentry), list, size);
if (res <= 0 || size == 0)
return res;

if (ovl_path_type(dentry->d_parent) != OVL_PATH_MERGE)
return res;

/* filter out private xattrs */
for (off = 0; off < res;) {
char *s = list + off;
size_t slen = strlen(s) + 1;

BUG_ON(off + slen > res);

if (ovl_is_private_xattr(s)) {
res -= slen;
memmove(s, s + slen, res - off);
} else {
off += slen;
}
}

return res;
}

static int ovl_removexattr(struct dentry *dentry, const char *name)
{
int err;
struct path realpath;
enum ovl_path_type type;

if (ovl_path_type(dentry->d_parent) == OVL_PATH_MERGE &&
ovl_is_private_xattr(name))
return -ENODATA;

type = ovl_path_real(dentry, &realpath);
if (type == OVL_PATH_LOWER) {
err = vfs_getxattr(realpath.dentry, name, NULL, 0);
if (err < 0)
return err;

err = ovl_copy_up(dentry);
if (err)
return err;

ovl_path_upper(dentry, &realpath);
}

return vfs_removexattr(realpath.dentry, name);
}

static bool ovl_open_need_copy_up(int flags, enum ovl_path_type type,
struct dentry *realdentry)
{
if (type != OVL_PATH_LOWER)
return false;

if (special_file(realdentry->d_inode->i_mode))
return false;

if (!(OPEN_FMODE(flags) & FMODE_WRITE) && !(flags & O_TRUNC))
return false;

return true;
}

//static struct file * ovl_open(struct dentry *dentry, int flags,
static int ovl_open(struct dentry *dentry, struct file *filp, const struct cred *cred)
{
int err;
struct path realpath;
enum ovl_path_type type;

type = ovl_path_real(dentry, &realpath);
if (ovl_open_need_copy_up(filp->f_flags, type, realpath.dentry)) {
if (filp->f_flags & O_TRUNC)
err = ovl_copy_up_truncate(dentry, 0);
else
err = ovl_copy_up(dentry);
if (err)
return err;

ovl_path_upper(dentry, &realpath);
}

return my_vfs_open(&realpath, filp, cred);
}

static const struct inode_operations ovl_dir_inode_operations = {
.lookup         = ovl_lookup,
.mkdir          = ovl_mkdir,
.symlink        = ovl_symlink,
.unlink         = ovl_unlink,
.rmdir          = ovl_rmdir,
.rename         = ovl_rename,
.link           = ovl_link,
.setattr        = ovl_setattr,
.create         = ovl_create,
.mknod          = ovl_mknod,
.permission     = ovl_permission,
.getattr        = ovl_dir_getattr,
.setxattr       = ovl_setxattr,
.getxattr       = ovl_getxattr,
.listxattr      = ovl_listxattr,
.removexattr    = ovl_removexattr,
};

static const struct inode_operations ovl_file_inode_operations = {
.setattr        = ovl_setattr,
.permission     = ovl_permission,
.getattr        = ovl_getattr,
.setxattr       = ovl_setxattr,
.getxattr       = ovl_getxattr,
.listxattr      = ovl_listxattr,
.removexattr    = ovl_removexattr,
.open           = ovl_open,
};

static const struct inode_operations ovl_symlink_inode_operations = {
.setattr        = ovl_setattr,
.follow_link    = ovl_follow_link,
.put_link       = ovl_put_link,
.readlink       = ovl_readlink,
.getattr        = ovl_getattr,
.setxattr       = ovl_setxattr,
.getxattr       = ovl_getxattr,
.listxattr      = ovl_listxattr,
.removexattr    = ovl_removexattr,
};

static struct inode *ovl_new_inode(struct super_block *sb, umode_t mode,
struct ovl_entry *oe)
{
struct inode *inode;

inode = new_inode(sb);
if (!inode)
return NULL;

mode &= S_IFMT;

inode->i_ino = get_next_ino();
inode->i_mode = mode;
inode->i_flags |= S_NOATIME | S_NOCMTIME;

switch (mode) {
case S_IFDIR:
inode->i_private = oe;
inode->i_op = &ovl_dir_inode_operations;
inode->i_fop = &ovl_dir_operations;
break;

case S_IFLNK:
inode->i_op = &ovl_symlink_inode_operations;
break;

case S_IFREG:
case S_IFSOCK:
case S_IFBLK:
case S_IFCHR:
case S_IFIFO:
inode->i_op = &ovl_file_inode_operations;
break;

default:
WARN(1, "illegal file type: %i\n", mode);
inode = NULL;
}

return inode;

}

static void ovl_put_super(struct super_block *sb)
{
struct ovl_fs *ufs = sb->s_fs_info;

if (!(sb->s_flags & MS_RDONLY))
mnt_drop_write(ufs->upper_mnt);

mntput(ufs->upper_mnt);
mntput(ufs->lower_mnt);

kfree(ufs);
}

static int ovl_remount_fs(struct super_block *sb, int *flagsp, char *data)
{
int flags = *flagsp;
struct ovl_fs *ufs = sb->s_fs_info;

/* When remounting rw or ro, we need to adjust the write access to the
* upper fs.
*/
if (((flags ^ sb->s_flags) & MS_RDONLY) == 0)
/* No change to readonly status */
return 0;

if (flags & MS_RDONLY) {
mnt_drop_write(ufs->upper_mnt);
return 0;
} else
return mnt_want_write(ufs->upper_mnt);
}

/**
* ovl_statfs
* @sb: The overlayfs super block
* @buf: The struct kstatfs to fill in with stats
*
* Get the filesystem statistics.  As writes always target the upper layer
* filesystem pass the statfs to the same filesystem.
*/
static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf)
{
struct dentry *root_dentry = dentry->d_sb->s_root;
struct path path;
ovl_path_upper(root_dentry, &path);

if (!path.dentry->d_sb->s_op->statfs)
return -ENOSYS;
return path.dentry->d_sb->s_op->statfs(path.dentry, buf);
}

static const struct super_operations ovl_super_operations = {
.put_super      = ovl_put_super,
.remount_fs     = ovl_remount_fs,
.statfs         = ovl_statfs,
};

struct ovl_config {
char *lowerdir;
char *upperdir;
};

enum {
Opt_lowerdir,
Opt_upperdir,
Opt_err,
};

static const match_table_t ovl_tokens = {
{Opt_lowerdir,                  "lowerdir=%s"},
{Opt_upperdir,                  "upperdir=%s"},
{Opt_err,                       NULL}
};

static int ovl_parse_opt(char *opt, struct ovl_config *config)
{
char *p;

config->upperdir = NULL;
config->lowerdir = NULL;

while ((p = strsep(&opt, ",")) != NULL) {
int token;
substring_t args[MAX_OPT_ARGS];

if (!*p)
continue;

token = match_token(p, ovl_tokens, args);
switch (token) {
case Opt_upperdir:
kfree(config->upperdir);
config->upperdir = match_strdup(&args[0]);
if (!config->upperdir)
return -ENOMEM;
break;

case Opt_lowerdir:
kfree(config->lowerdir);
config->lowerdir = match_strdup(&args[0]);
if (!config->lowerdir)
return -ENOMEM;
break;

default:
return -EINVAL;
}
}
return 0;
}

static int ovl_fill_super(struct super_block *sb, void *data, int silent)
{
struct path lowerpath;
struct path upperpath;
struct inode *root_inode;
struct dentry *root_dentry;
struct ovl_entry *oe;
struct ovl_fs *ufs;
struct ovl_config config;
int err;

err = ovl_parse_opt((char *) data, &config);
if (err)
goto out;

err = -EINVAL;
if (!config.upperdir || !config.lowerdir) {
printk(KERN_ERR "overlayfs: missing upperdir or lowerdir\n");
goto out_free_config;
}

err = -ENOMEM;
ufs = kmalloc(sizeof(struct ovl_fs), GFP_KERNEL);
if (!ufs)
goto out_free_config;

oe = ovl_alloc_entry();
if (oe == NULL)
goto out_free_ufs;

root_inode = ovl_new_inode(sb, S_IFDIR, oe);
if (!root_inode)
goto out_free_oe;

err = kern_path(config.upperdir, LOOKUP_FOLLOW, &upperpath);
if (err)
goto out_put_root;

err = kern_path(config.lowerdir, LOOKUP_FOLLOW, &lowerpath);
if (err)
goto out_put_upperpath;

err = -ENOTDIR;
if (!S_ISDIR(upperpath.dentry->d_inode->i_mode) ||
!S_ISDIR(lowerpath.dentry->d_inode->i_mode))
goto out_put_lowerpath;

ufs->upper_mnt = clone_private_mount(&upperpath);
err = PTR_ERR(ufs->upper_mnt);
if (IS_ERR(ufs->upper_mnt)) {
printk(KERN_ERR "overlayfs: failed to clone upperpath\n");
goto out_put_lowerpath;
}

ufs->lower_mnt = clone_private_mount(&lowerpath);
err = PTR_ERR(ufs->lower_mnt);
if (IS_ERR(ufs->lower_mnt)) {
printk(KERN_ERR "overlayfs: failed to clone lowerpath\n");
goto out_put_upper_mnt;
}

if (!(sb->s_flags & MS_RDONLY)) {
err = mnt_want_write(ufs->upper_mnt);
if (err)
goto out_put_lower_mnt;
}

err = -ENOMEM;
//root_dentry = d_alloc_root(root_inode);
root_dentry = d_make_root(root_inode);
if (!root_dentry)
goto out_drop_write;

mntput(upperpath.mnt);
mntput(lowerpath.mnt);

oe->__upperdentry = upperpath.dentry;
oe->lowerdentry = lowerpath.dentry;

root_dentry->d_fsdata = oe;
root_dentry->d_op = &ovl_dentry_operations;

sb->s_op = &ovl_super_operations;
sb->s_root = root_dentry;
sb->s_fs_info = ufs;

return 0;

out_drop_write:
if (!(sb->s_flags & MS_RDONLY))
mnt_drop_write(ufs->upper_mnt);
out_put_lower_mnt:
mntput(ufs->lower_mnt);
out_put_upper_mnt:
mntput(ufs->upper_mnt);
out_put_lowerpath:
path_put(&lowerpath);
out_put_upperpath:
path_put(&upperpath);
out_put_root:
iput(root_inode);
out_free_oe:
kfree(oe);
out_free_ufs:
kfree(ufs);
out_free_config:
kfree(config.lowerdir);
kfree(config.upperdir);
out:
return err;
}

#if 0
static int ovl_get_sb(struct file_system_type *fs_type,
int flags, const char *dev_name,
void *raw_data, struct vfsmount *mnt)
{
return get_sb_nodev(fs_type, flags, raw_data, ovl_fill_super, mnt);
}
#endif

static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags,
const char *dev_name, void *raw_data)
{
return mount_nodev(fs_type, flags, raw_data, ovl_fill_super);
}

static struct file_system_type ovl_fs_type = {
.owner          = THIS_MODULE,
.name           = "overlayfs",
//.get_sb         = ovl_get_sb,
.mount          = ovl_mount,
.kill_sb        = kill_anon_super,
};

static int __init ovl_init(void)
{
return register_filesystem(&ovl_fs_type);
}

static void __exit ovl_exit(void)
{
unregister_filesystem(&ovl_fs_type);
}

module_init(ovl_init);
module_exit(ovl_exit);

fs/namespace.c

+struct vfsmount *clone_private_mount(struct path *path)
+{
+       struct mount *old_mnt = real_mount(path->mnt);
+       struct mount *new_mnt;
+
+       if (IS_MNT_UNBINDABLE(old_mnt))
+               return ERR_PTR(-EINVAL);
+
+       down_read(&namespace_sem);
+       new_mnt = clone_mnt(old_mnt, path->dentry, CL_PRIVATE);
+       up_read(&namespace_sem);
+       if (IS_ERR(new_mnt))
+               return ERR_CAST(new_mnt);
+
+       return &new_mnt->mnt;
+}
+EXPORT_SYMBOL_GPL(clone_private_mount);

fs/open.c

+int my_vfs_open(const struct path *path, struct file *filp,
+       const struct cred *cred)
+{
+    struct inode *inode = path->dentry->d_inode;
+
+    if (inode->i_op->open)
+       return inode->i_op->open(path->dentry, filp, cred);
+    else {
+       filp->f_path = *path;
+       return do_dentry_open(filp, NULL, cred);
+    }
+}
+EXPORT_SYMBOL(my_vfs_open);

fs/namei.c   do_last 函数

2866 finish_open_created:
2867         error = may_open(&nd->path, acc_mode, open_flag);
2868         if (error)
2869                 goto out;
2870 #if 0
2871         file->f_path.mnt = nd->path.mnt;
2872         error = finish_open(file, nd->path.dentry, NULL, opened);
2873         if (error) {
2874                 if (error == -EOPENSTALE)
2875                         goto stale_open;
2876                 goto out;
2877         }
2878 #endif
2879
2880         BUG_ON(*opened & FILE_OPENED); /* once it's opened, it's opened */
2881         error = my_vfs_open(&nd->path, file, current_cred());
2882         if (!error) {
2883             *opened |= FILE_OPENED;
2884         } else {
2885             if (error == -EOPENSTALE)
2886                 goto stale_open;
2887             goto out;
2888         }

3.10内核中还没有vfs_open函数

一次典型的文件打开流程
filp_open     -->    filp_open_name   -->   do_filp_open   --> path_openat  --> do_last
中间包含了dhash等寻找inode过程，do_last已经是找到inode了
需要调用inode的方法，overlayfs提供了open方法我们自己定义的一个方法，其他文件系统则没有，如果定义了open就可以认为是一个overlayfs的inode
ovl_open则主要找到对应的上下层dentry，然后再找到inode调用上下层文件系统的方法，完成一次打开。

其他修改可以参考2.6.38的补丁