lkml.org 
[lkml]   [2008]   [May]   [20]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[AUFS PATCH v2.6.26-rc2-mm1 20/39] aufs file
    Date
    From: Junjiro Okajima <hooanon05@yahoo.co.jp>

    initial commit
    file private data and address_space operations

    Signed-off-by: Junjiro Okajima <hooanon05@yahoo.co.jp>
    ---
    fs/aufs/file.c | 747 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
    fs/aufs/file.h | 223 +++++++++++++++++
    fs/aufs/finfo.c | 182 ++++++++++++++
    3 files changed, 1152 insertions(+), 0 deletions(-)
    create mode 100644 fs/aufs/file.c
    create mode 100644 fs/aufs/file.h
    create mode 100644 fs/aufs/finfo.c

    diff --git a/fs/aufs/file.c b/fs/aufs/file.c
    new file mode 100644
    index 0000000..13bc36d
    --- /dev/null
    +++ b/fs/aufs/file.c
    @@ -0,0 +1,747 @@
    +/*
    + * Copyright (C) 2005-2008 Junjiro Okajima
    + *
    + * This program, aufs is free software; you can redistribute it and/or modify
    + * it under the terms of the GNU General Public License as published by
    + * the Free Software Foundation; either version 2 of the License, or
    + * (at your option) any later version.
    + *
    + * This program is distributed in the hope that it will be useful,
    + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    + * GNU General Public License for more details.
    + *
    + * You should have received a copy of the GNU General Public License
    + * along with this program; if not, write to the Free Software
    + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
    + */
    +
    +/*
    + * handling file/dir, and address_space operation
    + */
    +
    +#include <linux/pagemap.h>
    +#include "aufs.h"
    +
    +/*
    + * a dirty trick for handling FMODE_EXEC and deny_write_access().
    + * because FMODE_EXEC flag is not passed to f_op->open(),
    + * set it to file->private_data temporary.
    + */
    +int au_store_fmode_exec(struct nameidata *nd, struct inode *inode)
    +{
    + int err;
    + union {
    + void *p;
    + unsigned long ul;
    + } u;
    +
    + err = 0;
    + if (nd
    + && (nd->flags & LOOKUP_OPEN)
    + && nd->intent.open.file
    + && (nd->intent.open.flags & FMODE_EXEC)
    + && inode
    + && S_ISREG(inode->i_mode)) {
    + u.ul = nd->intent.open.flags;
    + nd->intent.open.file->private_data = u.p;
    + /* smp_mb(); */
    + err = 1;
    + }
    +
    + return err;
    +}
    +
    +/* drop flags for writing */
    +unsigned int au_file_roflags(unsigned int flags)
    +{
    + flags &= ~(O_WRONLY | O_RDWR | O_APPEND | O_CREAT | O_TRUNC);
    + flags |= O_RDONLY | O_NOATIME;
    + return flags;
    +}
    +
    +/* common functions to regular file and dir */
    +struct file *au_h_open(struct dentry *dentry, aufs_bindex_t bindex, int flags,
    + struct file *file)
    +{
    + struct file *h_file;
    + struct dentry *h_dentry;
    + struct inode *h_inode;
    + struct super_block *sb;
    + struct au_branch *br;
    + int hinotify, err;
    +
    + LKTRTrace("%.*s, b%d, flags 0%o, f %d\n",
    + AuDLNPair(dentry), bindex, flags, !!file);
    + AuDebugOn(!dentry);
    + h_dentry = au_h_dptr(dentry, bindex);
    + AuDebugOn(!h_dentry);
    + h_inode = h_dentry->d_inode;
    + AuDebugOn(!h_inode);
    +
    + sb = dentry->d_sb;
    + hinotify = !!au_opt_test(au_mntflags(sb), UDBA_INOTIFY);
    + br = au_sbr(sb, bindex);
    + au_br_get(br);
    + /* drop flags for writing */
    + if (au_test_ro(sb, bindex, dentry->d_inode))
    + flags = au_file_roflags(flags);
    + flags &= ~O_CREAT;
    +
    + h_file = NULL;
    + if (unlikely(file && au_test_nfs(h_dentry->d_sb)))
    + h_file = au_h_intent(dentry, bindex, file);
    + if (!h_file)
    + h_file = dentry_open(dget(h_dentry), mntget(br->br_mnt), flags);
    +
    + /*
    + * a dirty trick for handling FMODE_EXEC and deny_write_access().
    + */
    + if (file && (file->f_mode & FMODE_EXEC)) {
    + h_file->f_mode |= FMODE_EXEC;
    + smp_mb(); /* flush f_mode */
    + err = au_deny_write_access(h_file);
    + if (unlikely(err)) {
    + fput(h_file);
    + h_file = ERR_PTR(err);
    + }
    + }
    + if (!IS_ERR(h_file))
    + return h_file;
    +
    + au_br_put(br);
    + AuTraceErrPtr(h_file);
    + return h_file;
    +}
    +
    +static int do_coo(struct dentry *dentry, aufs_bindex_t bstart)
    +{
    + int err;
    + struct dentry *parent, *h_parent, *h_dentry, *gparent;
    + aufs_bindex_t bcpup;
    + struct inode *h_dir, *h_inode, *dir;
    + struct super_block *sb;
    +
    + LKTRTrace("%.*s\n", AuDLNPair(dentry));
    + AuDebugOn(IS_ROOT(dentry));
    + DiMustWriteLock(dentry);
    +
    + parent = dget_parent(dentry);
    + di_write_lock_parent(parent);
    + sb = dentry->d_sb;
    + err = AuWbrCopyup(au_sbi(sb), dentry);
    + bcpup = err;
    + if (err < 0) {
    + err = 0; /* stop copyup, it is not an error */
    + goto out;
    + }
    + err = 0;
    +
    + h_parent = au_h_dptr(parent, bcpup);
    + if (!h_parent) {
    + err = au_cpup_dirs(dentry, bcpup, NULL);
    + if (unlikely(err))
    + goto out;
    + h_parent = au_h_dptr(parent, bcpup);
    + }
    +
    + h_dir = h_parent->d_inode;
    + h_dentry = au_h_dptr(dentry, bstart);
    + h_inode = h_dentry->d_inode;
    + dir = parent->d_inode;
    + /* todo: meaningless lock if CONFIG_AUFS_DEBUG is disabled. */
    + gparent = NULL;
    + if (unlikely(au_opt_test(au_mntflags(sb), UDBA_INOTIFY)
    + && !IS_ROOT(parent))) {
    + gparent = dget_parent(parent);
    + ii_read_lock_parent2(gparent->d_inode);
    + }
    + au_hdir_lock(h_dir, dir, bcpup);
    + /* todo: test parent-gparent relationship? */
    + mutex_lock_nested(&h_inode->i_mutex, AuLsc_I_CHILD);
    + AuDebugOn(au_h_dptr(dentry, bcpup));
    + err = au_sio_cpup_simple(dentry, bcpup, -1, AuCpup_DTIME);
    + AuTraceErr(err);
    + mutex_unlock(&h_inode->i_mutex);
    + au_hdir_unlock(h_dir, dir, bcpup);
    + if (unlikely(gparent)) {
    + ii_read_unlock(gparent->d_inode);
    + dput(gparent);
    + }
    +
    + out:
    + di_write_unlock(parent);
    + dput(parent);
    + AuTraceErr(err);
    + return err;
    +}
    +
    +int au_do_open(struct inode *inode, struct file *file,
    + int (*open)(struct file *file, int flags))
    +{
    + int err, coo;
    + struct dentry *dentry;
    + struct super_block *sb;
    + aufs_bindex_t bstart;
    +
    + dentry = file->f_dentry;
    + LKTRTrace("i%lu, %.*s\n", inode->i_ino, AuDLNPair(dentry));
    +
    + sb = dentry->d_sb;
    + si_read_lock(sb, AuLock_FLUSH);
    + coo = 0;
    + switch (au_mntflags(sb) & AuOptMask_COO) {
    + case AuOpt_COO_LEAF:
    + coo = !S_ISDIR(inode->i_mode);
    + break;
    + case AuOpt_COO_ALL:
    + coo = 1;
    + break;
    + }
    + err = au_finfo_init(file);
    + if (unlikely(err))
    + goto out;
    +
    + if (!coo) {
    + di_read_lock_child(dentry, AuLock_IR);
    + bstart = au_dbstart(dentry);
    + } else {
    + di_write_lock_child(dentry);
    + bstart = au_dbstart(dentry);
    + if (au_test_ro(sb, bstart, dentry->d_inode)) {
    + err = do_coo(dentry, bstart);
    + if (err) {
    + di_write_unlock(dentry);
    + goto out_finfo;
    + }
    + bstart = au_dbstart(dentry);
    + }
    + di_downgrade_lock(dentry, AuLock_IR);
    + }
    +
    + err = open(file, file->f_flags);
    + di_read_unlock(dentry, AuLock_IR);
    +
    + out_finfo:
    + fi_write_unlock(file);
    + if (unlikely(err))
    + au_finfo_fin(file);
    + out:
    + si_read_unlock(sb);
    + AuTraceErr(err);
    + return err;
    +}
    +
    +int au_reopen_nondir(struct file *file)
    +{
    + int err;
    + struct dentry *dentry;
    + aufs_bindex_t bstart, bindex, bend;
    + struct file *h_file, *h_file_tmp;
    +
    + dentry = file->f_dentry;
    + LKTRTrace("%.*s\n", AuDLNPair(dentry));
    + bstart = au_dbstart(dentry);
    + AuDebugOn(S_ISDIR(dentry->d_inode->i_mode)
    + || !au_h_dptr(dentry, bstart)->d_inode);
    +
    + h_file_tmp = NULL;
    + if (au_fbstart(file) == bstart) {
    + h_file = au_h_fptr(file, bstart);
    + if (file->f_mode == h_file->f_mode)
    + return 0; /* success */
    + h_file_tmp = h_file;
    + get_file(h_file_tmp);
    + au_set_h_fptr(file, bstart, NULL);
    + }
    + AuDebugOn(au_fbstart(file) < bstart
    + || au_fi(file)->fi_hfile[0 + bstart].hf_file);
    +
    + h_file = au_h_open(dentry, bstart, file->f_flags & ~O_TRUNC, file);
    + err = PTR_ERR(h_file);
    + if (IS_ERR(h_file))
    + goto out; /* todo: close all? */
    + err = 0;
    + /* cpup_file_flags(h_file, file); */
    + au_set_fbstart(file, bstart);
    + au_set_h_fptr(file, bstart, h_file);
    + au_update_figen(file);
    + /* todo: necessary? */
    + /* file->f_ra = h_file->f_ra; */
    +
    + /* close lower files */
    + bend = au_fbend(file);
    + for (bindex = bstart + 1; bindex <= bend; bindex++)
    + au_set_h_fptr(file, bindex, NULL);
    + au_set_fbend(file, bstart);
    +
    + out:
    + if (h_file_tmp)
    + fput(h_file_tmp);
    + AuTraceErr(err);
    + return err;
    +}
    +
    +/* ---------------------------------------------------------------------- */
    +
    +static int au_ready_to_write_wh(struct file *file, loff_t len,
    + aufs_bindex_t bcpup)
    +{
    + int err;
    + struct dentry *dentry, *hi_wh, *old_h_dentry;
    + struct au_dinfo *dinfo;
    + aufs_bindex_t old_bstart;
    +
    + AuTraceEnter();
    +
    + dentry = file->f_dentry;
    + hi_wh = au_hi_wh(dentry->d_inode, bcpup);
    + if (!hi_wh)
    + err = au_sio_cpup_wh(dentry, bcpup, len, file);
    + else {
    + /* already copied-up after unlink */
    + dinfo = au_di(dentry);
    + old_bstart = dinfo->di_bstart;
    + dinfo->di_bstart = bcpup;
    + old_h_dentry = dinfo->di_hdentry[0 + bcpup].hd_dentry;
    + dinfo->di_hdentry[0 + bcpup].hd_dentry = hi_wh;
    + err = au_reopen_nondir(file);
    + dinfo->di_hdentry[0 + bcpup].hd_dentry = old_h_dentry;
    + dinfo->di_bstart = old_bstart;
    + }
    +
    + AuTraceErr(err);
    + return err;
    +}
    +
    +/*
    + * prepare the @file for writing.
    + */
    +int au_ready_to_write(struct file *file, loff_t len)
    +{
    + int err;
    + struct dentry *dentry, *parent, *h_dentry, *h_parent, *gparent;
    + struct inode *h_inode, *h_dir, *inode, *dir;
    + struct super_block *sb;
    + aufs_bindex_t bstart, bcpup;
    +
    + dentry = file->f_dentry;
    + LKTRTrace("%.*s, len %Ld\n", AuDLNPair(dentry), len);
    + FiMustWriteLock(file);
    +
    + sb = dentry->d_sb;
    + bstart = au_fbstart(file);
    + AuDebugOn(au_fbr(file, bstart) != au_sbr(sb, bstart));
    +
    + inode = dentry->d_inode;
    + AuDebugOn(S_ISDIR(inode->i_mode));
    + ii_read_lock_child(inode);
    + LKTRTrace("rdonly %d, bstart %d\n",
    + au_test_ro(sb, bstart, inode), bstart);
    + err = au_test_ro(sb, bstart, inode);
    + ii_read_unlock(inode);
    + if (!err && (au_h_fptr(file, bstart)->f_mode & FMODE_WRITE))
    + return 0;
    +
    + /* need to cpup */
    + di_write_lock_child(dentry);
    + parent = dget_parent(dentry);
    + di_write_lock_parent(parent);
    + err = AuWbrCopyup(au_sbi(sb), dentry);
    + bcpup = err;
    + if (unlikely(err < 0))
    + goto out_unlock;
    + err = 0;
    +
    + h_parent = au_h_dptr(parent, bcpup);
    + if (!h_parent) {
    + err = au_cpup_dirs(dentry, bcpup, NULL);
    + if (unlikely(err))
    + goto out_unlock;
    + h_parent = au_h_dptr(parent, bcpup);
    + }
    +
    + /* todo: meaningless lock if CONFIG_AUFS_DEBUG is disabled. */
    + gparent = NULL;
    + if (unlikely(au_opt_test(au_mntflags(sb), UDBA_INOTIFY)
    + && !IS_ROOT(parent))) {
    + gparent = dget_parent(parent);
    + ii_read_lock_parent2(gparent->d_inode);
    + }
    + h_dir = h_parent->d_inode;
    + h_dentry = au_h_fptr(file, au_fbstart(file))->f_dentry;
    + h_inode = h_dentry->d_inode;
    + dir = parent->d_inode;
    + au_hdir_lock(h_dir, dir, bcpup);
    + /* todo: test parent-gparent relationship? */
    + mutex_lock_nested(&h_inode->i_mutex, AuLsc_I_CHILD);
    + if (d_unhashed(dentry) /* || d_unhashed(h_dentry) */
    + /* || !h_inode->i_nlink */)
    + err = au_ready_to_write_wh(file, len, bcpup);
    + else {
    + if (!au_h_dptr(dentry, bcpup))
    + err = au_sio_cpup_simple(dentry, bcpup, len,
    + AuCpup_DTIME);
    + AuTraceErr(err);
    + if (!err)
    + err = au_reopen_nondir(file);
    + AuTraceErr(err);
    + }
    + mutex_unlock(&h_inode->i_mutex);
    + au_hdir_unlock(h_dir, dir, bcpup);
    + if (unlikely(gparent)) {
    + ii_read_unlock(gparent->d_inode);
    + dput(gparent);
    + }
    +
    + out_unlock:
    + di_write_unlock(parent);
    + di_write_unlock(dentry);
    + dput(parent);
    + AuTraceErr(err);
    + return err;
    +
    +}
    +
    +/* ---------------------------------------------------------------------- */
    +
    +static int refresh_file_by_inode(struct file *file, int *need_reopen)
    +{
    + int err;
    + struct au_finfo *finfo;
    + struct dentry *dentry, *parent, *old_h_dentry, *hi_wh;
    + struct inode *inode, *dir, *h_dir;
    + aufs_bindex_t bstart, new_bstart, old_bstart;
    + struct super_block *sb;
    + struct au_dinfo *dinfo;
    +
    + dentry = file->f_dentry;
    + LKTRTrace("%.*s\n", AuDLNPair(dentry));
    + FiMustWriteLock(file);
    +
    + err = 0;
    + finfo = au_fi(file);
    + inode = dentry->d_inode;
    + sb = dentry->d_sb;
    + again:
    + bstart = au_ibstart(inode);
    + if (bstart == finfo->fi_bstart)
    + goto out;
    +
    + new_bstart = bstart;
    + parent = dget_parent(dentry);
    + dir = parent->d_inode;
    + if (au_test_ro(sb, bstart, inode)) {
    + di_read_lock_parent(parent, !AuLock_IR);
    + err = AuWbrCopyup(au_sbi(sb), dentry);
    + new_bstart = err;
    + di_read_unlock(parent, !AuLock_IR);
    + if (unlikely(err < 0))
    + goto out_put;
    + }
    + di_read_unlock(dentry, AuLock_IR);
    + di_write_lock_child(dentry);
    + /* someone else might change our inode while we were sleeping */
    + /* todo: test more? */
    + if (bstart != au_ibstart(inode)) {
    + di_downgrade_lock(dentry, AuLock_IR);
    + err = 0;
    + dput(parent);
    + goto again;
    + }
    + di_read_lock_parent(parent, AuLock_IR);
    + bstart = new_bstart;
    +
    + hi_wh = au_hi_wh(inode, bstart);
    + if (au_opt_test(au_mntflags(sb), PLINK)
    + && au_plink_test(sb, inode)
    + && !d_unhashed(dentry)) {
    + err = au_test_and_cpup_dirs(dentry, bstart, NULL);
    +
    + /* always superio. */
    +#if 1 /* reserved for future use */
    + h_dir = au_h_dptr(parent, bstart)->d_inode;
    + au_hdir_lock(h_dir, dir, bstart);
    + err = au_sio_cpup_simple(dentry, bstart, -1, AuCpup_DTIME);
    + au_hdir_unlock(h_dir, dir, bstart);
    +#else
    + if (!au_test_wkq(current)) {
    + int wkq_err;
    + struct cpup_pseudo_link_args args = {
    + .errp = &err,
    + .dentry = dentry,
    + .bdst = bstart,
    + .do_lock = 1
    + };
    + wkq_err = au_wkq_wait(call_cpup_pseudo_link, &args);
    + if (unlikely(wkq_err))
    + err = wkq_err;
    + } else
    + err = cpup_pseudo_link(dentry, bstart, /*do_lock*/1);
    +#endif
    + } else if (hi_wh) {
    + /* already copied-up after unlink */
    + dinfo = au_di(dentry);
    + old_bstart = dinfo->di_bstart;
    + dinfo->di_bstart = bstart;
    + old_h_dentry = dinfo->di_hdentry[0 + bstart].hd_dentry;
    + dinfo->di_hdentry[0 + bstart].hd_dentry = hi_wh;
    + err = au_reopen_nondir(file);
    + dinfo->di_hdentry[0 + bstart].hd_dentry = old_h_dentry;
    + dinfo->di_bstart = old_bstart;
    + *need_reopen = 0;
    + }
    + di_read_unlock(parent, AuLock_IR);
    + di_downgrade_lock(dentry, AuLock_IR);
    +
    + out_put:
    + dput(parent);
    + out:
    + AuTraceErr(err);
    + return err;
    +}
    +
    +/*
    + * after branch manipulating, refresh the file.
    + */
    +static int refresh_file(struct file *file, int (*reopen)(struct file *file))
    +{
    + int err, new_sz, need_reopen;
    + struct dentry *dentry;
    + aufs_bindex_t bend, bindex, bstart, brid;
    + struct au_hfile *p;
    + struct au_finfo *finfo;
    + struct super_block *sb;
    + struct inode *inode;
    + struct file *hidden_file;
    +
    + dentry = file->f_dentry;
    + LKTRTrace("%.*s\n", AuDLNPair(dentry));
    + FiMustWriteLock(file);
    + DiMustReadLock(dentry);
    + inode = dentry->d_inode;
    + IiMustReadLock(inode);
    +
    + err = -ENOMEM;
    + sb = dentry->d_sb;
    + finfo = au_fi(file);
    + bstart = finfo->fi_bstart;
    + bend = finfo->fi_bstart;
    + new_sz = sizeof(*finfo->fi_hfile) * (au_sbend(sb) + 1);
    + p = au_kzrealloc(finfo->fi_hfile, sizeof(*p) * (finfo->fi_bend + 1),
    + new_sz, GFP_KERNEL);
    + if (unlikely(!p))
    + goto out;
    + finfo->fi_hfile = p;
    + hidden_file = p[0 + bstart].hf_file;
    +
    + p = finfo->fi_hfile + finfo->fi_bstart;
    + brid = p->hf_br->br_id;
    + bend = finfo->fi_bend;
    + for (bindex = finfo->fi_bstart; bindex <= bend; bindex++, p++) {
    + struct au_hfile tmp, *q;
    + aufs_bindex_t new_bindex;
    +
    + if (!p->hf_file)
    + continue;
    + new_bindex = au_find_bindex(sb, p->hf_br);
    + if (new_bindex == bindex)
    + continue;
    + /* todo: test more? */
    + if (new_bindex < 0) {
    + au_set_h_fptr(file, bindex, NULL);
    + continue;
    + }
    +
    + /* swap two hidden inode, and loop again */
    + q = finfo->fi_hfile + new_bindex;
    + tmp = *q;
    + *q = *p;
    + *p = tmp;
    + if (tmp.hf_file) {
    + bindex--;
    + p--;
    + }
    + }
    + {
    + aufs_bindex_t s = finfo->fi_bstart, e = finfo->fi_bend;
    + finfo->fi_bstart = 0;
    + finfo->fi_bend = au_sbend(sb);
    + finfo->fi_bstart = s;
    + finfo->fi_bend = e;
    + }
    +
    + p = finfo->fi_hfile;
    + if (!au_test_mmapped(file) && !d_unhashed(dentry)) {
    + bend = au_sbend(sb);
    + for (finfo->fi_bstart = 0; finfo->fi_bstart <= bend;
    + finfo->fi_bstart++, p++)
    + if (p->hf_file) {
    + if (p->hf_file->f_dentry
    + && p->hf_file->f_dentry->d_inode)
    + break;
    + else
    + au_hfput(p);
    + }
    + } else {
    + bend = au_br_index(sb, brid);
    + for (finfo->fi_bstart = 0; finfo->fi_bstart < bend;
    + finfo->fi_bstart++, p++)
    + if (p->hf_file)
    + au_hfput(p);
    + bend = au_sbend(sb);
    + }
    +
    + p = finfo->fi_hfile + bend;
    + for (finfo->fi_bend = bend; finfo->fi_bend >= finfo->fi_bstart;
    + finfo->fi_bend--, p--)
    + if (p->hf_file) {
    + if (p->hf_file->f_dentry
    + && p->hf_file->f_dentry->d_inode)
    + break;
    + else
    + au_hfput(p);
    + }
    + AuDebugOn(finfo->fi_bend < finfo->fi_bstart);
    +
    + err = 0;
    + need_reopen = 1;
    + if (!au_test_mmapped(file))
    + err = refresh_file_by_inode(file, &need_reopen);
    + if (!err && need_reopen && !d_unhashed(dentry))
    + err = reopen(file);
    + if (!err) {
    + au_update_figen(file);
    + return 0; /* success */
    + }
    +
    + /* error, close all hidden files */
    + bend = au_fbend(file);
    + for (bindex = au_fbstart(file); bindex <= bend; bindex++)
    + au_set_h_fptr(file, bindex, NULL);
    +
    + out:
    + AuTraceErr(err);
    + return err;
    +}
    +
    +/* common function to regular file and dir */
    +int au_reval_and_lock_finfo(struct file *file, int (*reopen)(struct file *file),
    + int wlock, int locked)
    +{
    + int err, pseudo_link;
    + struct dentry *dentry;
    + struct super_block *sb;
    + aufs_bindex_t bstart;
    + au_gen_t sgen, fgen;
    +
    + dentry = file->f_dentry;
    + LKTRTrace("%.*s, w %d, l %d\n", AuDLNPair(dentry), wlock, locked);
    + sb = dentry->d_sb;
    + SiMustAnyLock(sb);
    +
    + err = 0;
    + sgen = au_sigen(sb);
    + fi_write_lock(file);
    + fgen = au_figen(file);
    + di_read_lock_child(dentry, AuLock_IR);
    + bstart = au_dbstart(dentry);
    + pseudo_link = (bstart != au_ibstart(dentry->d_inode));
    + di_read_unlock(dentry, AuLock_IR);
    + if (sgen == fgen && !pseudo_link && au_fbstart(file) == bstart) {
    + if (!wlock)
    + fi_downgrade_lock(file);
    + return 0; /* success */
    + }
    +
    + LKTRTrace("sgen %d, fgen %d\n", sgen, fgen);
    + if (unlikely(sgen != au_digen(dentry)
    + || sgen != au_iigen(dentry->d_inode))) {
    + /*
    + * d_path() and path_lookup() is a simple and good approach
    + * to revalidate. but si_rwsem in DEBUG_RWSEM will cause a
    + * deadlock. removed the code.
    + */
    + di_write_lock_child(dentry);
    + err = au_reval_dpath(dentry, sgen);
    + di_write_unlock(dentry);
    + if (unlikely(err < 0))
    + goto out;
    + AuDebugOn(au_digen(dentry) != sgen
    + || au_iigen(dentry->d_inode) != sgen);
    + }
    +
    + di_read_lock_child(dentry, AuLock_IR);
    + err = refresh_file(file, reopen
    + /* , au_opt_test(au_mnt_flags(sb), REFROF) */);
    + di_read_unlock(dentry, AuLock_IR);
    + if (!err) {
    + if (!wlock)
    + fi_downgrade_lock(file);
    + } else
    + fi_write_unlock(file);
    +
    + out:
    + AuTraceErr(err);
    + return err;
    +}
    +
    +/* ---------------------------------------------------------------------- */
    +
    +/* cf. aufs_nopage() */
    +/* for madvise(2) */
    +static int aufs_readpage(struct file *file, struct page *page)
    +{
    + AuTraceEnter();
    + unlock_page(page);
    + return 0;
    +}
    +
    +/* they will never be called. */
    +#ifdef CONFIG_AUFS_DEBUG
    +static int aufs_prepare_write(struct file *file, struct page *page,
    + unsigned from, unsigned to)
    +{ AuUnsupport(); return 0; }
    +static int aufs_commit_write(struct file *file, struct page *page,
    + unsigned from, unsigned to)
    +{ AuUnsupport(); return 0; }
    +static int aufs_write_begin(struct file *file, struct address_space *mapping,
    + loff_t pos, unsigned len, unsigned flags,
    + struct page **pagep, void **fsdata)
    +{ AuUnsupport(); return 0; }
    +static int aufs_write_end(struct file *file, struct address_space *mapping,
    + loff_t pos, unsigned len, unsigned copied,
    + struct page *page, void *fsdata)
    +{ AuUnsupport(); return 0; }
    +static int aufs_writepage(struct page *page, struct writeback_control *wbc)
    +{ AuUnsupport(); return 0; }
    +static void aufs_sync_page(struct page *page)
    +{ AuUnsupport(); }
    +
    +static int aufs_set_page_dirty(struct page *page)
    +{ AuUnsupport(); return 0; }
    +static void aufs_invalidatepage(struct page *page, unsigned long offset)
    +{ AuUnsupport(); }
    +static int aufs_releasepage(struct page *page, gfp_t gfp)
    +{ AuUnsupport(); return 0; }
    +static ssize_t aufs_direct_IO(int rw, struct kiocb *iocb,
    + const struct iovec *iov, loff_t offset,
    + unsigned long nr_segs)
    +{ AuUnsupport(); return 0; }
    +#endif /* CONFIG_AUFS_DEBUG */
    +
    +struct address_space_operations aufs_aop = {
    + .readpage = aufs_readpage,
    +#ifdef CONFIG_AUFS_DEBUG
    + .writepage = aufs_writepage,
    + .sync_page = aufs_sync_page,
    + .set_page_dirty = aufs_set_page_dirty,
    + .prepare_write = aufs_prepare_write,
    + .commit_write = aufs_commit_write,
    + .write_begin = aufs_write_begin,
    + .write_end = aufs_write_end,
    + .invalidatepage = aufs_invalidatepage,
    + .releasepage = aufs_releasepage,
    + .direct_IO = aufs_direct_IO,
    +#endif /* CONFIG_AUFS_DEBUG */
    +};
    diff --git a/fs/aufs/file.h b/fs/aufs/file.h
    new file mode 100644
    index 0000000..150e53c
    --- /dev/null
    +++ b/fs/aufs/file.h
    @@ -0,0 +1,223 @@
    +/*
    + * Copyright (C) 2005-2008 Junjiro Okajima
    + *
    + * This program, aufs is free software; you can redistribute it and/or modify
    + * it under the terms of the GNU General Public License as published by
    + * the Free Software Foundation; either version 2 of the License, or
    + * (at your option) any later version.
    + *
    + * This program is distributed in the hope that it will be useful,
    + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    + * GNU General Public License for more details.
    + *
    + * You should have received a copy of the GNU General Public License
    + * along with this program; if not, write to the Free Software
    + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
    + */
    +
    +/*
    + * file operations
    + */
    +
    +#ifndef __AUFS_FILE_H__
    +#define __AUFS_FILE_H__
    +
    +#ifdef __KERNEL__
    +
    +#include <linux/file.h>
    +#include <linux/fs.h>
    +#include <linux/mm.h>
    +#include <linux/aufs_type.h>
    +#include "dentry.h"
    +#include "misc.h"
    +#include "super.h"
    +
    +/* ---------------------------------------------------------------------- */
    +
    +struct au_branch;
    +struct au_hfile {
    + struct file *hf_file;
    + struct au_branch *hf_br;
    +};
    +
    +struct au_vdir;
    +struct au_finfo {
    + atomic_t fi_generation;
    +
    + struct au_rwsem fi_rwsem;
    + struct au_hfile *fi_hfile;
    + aufs_bindex_t fi_bstart, fi_bend;
    +
    + union {
    + struct vm_operations_struct *fi_h_vm_ops;
    + struct au_vdir *fi_vdir_cache;
    + };
    +};
    +
    +/* ---------------------------------------------------------------------- */
    +
    +/* file.c */
    +extern struct address_space_operations aufs_aop;
    +unsigned int au_file_roflags(unsigned int flags);
    +struct file *au_h_open(struct dentry *dentry, aufs_bindex_t bindex, int flags,
    + struct file *file);
    +int au_do_open(struct inode *inode, struct file *file,
    + int (*open)(struct file *file, int flags));
    +int au_reopen_nondir(struct file *file);
    +int au_ready_to_write(struct file *file, loff_t len);
    +int au_reval_and_lock_finfo(struct file *file, int (*reopen)(struct file *file),
    + int wlock, int locked);
    +
    +/* f_op.c */
    +extern struct file_operations aufs_file_fop;
    +int aufs_flush(struct file *file, fl_owner_t id);
    +
    +/* finfo.c */
    +struct au_finfo *au_fi(struct file *file);
    +struct au_branch *au_fbr(struct file *file, aufs_bindex_t bindex);
    +struct file *au_h_fptr(struct file *file, aufs_bindex_t bindex);
    +
    +void au_hfput(struct au_hfile *hf);
    +void au_set_h_fptr(struct file *file, aufs_bindex_t bindex,
    + struct file *h_file);
    +
    +void au_finfo_fin(struct file *file);
    +int au_finfo_init(struct file *file);
    +
    +#ifdef CONFIG_AUFS_ROBR
    +/* robr.c */
    +struct file *au_robr_safe_file(struct vm_area_struct *vma);
    +void au_robr_reset_file(struct vm_area_struct *vma, struct file *file);
    +#else
    +static inline struct file *au_robr_safe_file(struct vm_area_struct *vma)
    +{
    + struct file *file;
    +
    + file = vma->vm_file;
    + if (file->private_data && au_test_aufs(file->f_dentry->d_sb))
    + return file;
    + return NULL;
    +}
    +
    +static inline
    +void au_robr_reset_file(struct vm_area_struct *vma, struct file *file)
    +{
    + vma->vm_file = file;
    + /* smp_mb(); */ /* flush vm_file */
    +}
    +#endif /* CONFIG_AUFS_ROBR */
    +
    +/* ---------------------------------------------------------------------- */
    +
    +/* todo: memory barrier? */
    +static inline au_gen_t au_figen(struct file *f)
    +{
    + return atomic_read(&au_fi(f)->fi_generation);
    +}
    +
    +static inline int au_test_mmapped(struct file *f)
    +{
    + return !!(au_fi(f)->fi_h_vm_ops);
    +}
    +
    +static inline int au_test_aufs_file(struct file *f)
    +{
    + return !(f->f_dentry->d_inode->i_mode
    + & (S_IFCHR | S_IFBLK | S_IFIFO | S_IFSOCK));
    +}
    +
    +/* ---------------------------------------------------------------------- */
    +
    +int au_store_fmode_exec(struct nameidata *nd, struct inode *inode);
    +
    +static inline int au_deny_write_access(struct file *h_file)
    +{
    + LKTRTrace("%.*s\n", AuDLNPair(h_file->f_dentry));
    + return deny_write_access(h_file);
    +}
    +
    +static inline void au_allow_write_access(struct file *h_file)
    +{
    + allow_write_access(h_file);
    +}
    +
    +/* ---------------------------------------------------------------------- */
    +
    +/*
    + * fi_read_lock, fi_write_lock,
    + * fi_read_unlock, fi_write_unlock, fi_downgrade_lock
    + */
    +AuSimpleRwsemFuncs(fi, struct file *f, au_fi(f)->fi_rwsem);
    +
    +/* to debug easier, do not make them inlined functions */
    +#define FiMustReadLock(f) do { \
    + SiMustAnyLock((f)->f_dentry->d_sb); \
    + AuRwMustReadLock(&au_fi(f)->fi_rwsem); \
    +} while (0)
    +
    +#define FiMustWriteLock(f) do { \
    + SiMustAnyLock((f)->f_dentry->d_sb); \
    + AuRwMustWriteLock(&au_fi(f)->fi_rwsem); \
    +} while (0)
    +
    +#define FiMustAnyLock(f) do { \
    + SiMustAnyLock((f)->f_dentry->d_sb); \
    + AuRwMustAnyLock(&au_fi(f)->fi_rwsem); \
    +} while (0)
    +
    +#define FiMustNoWaiters(f) AuRwMustNoWaiters(&au_fi(f)->fi_rwsem)
    +
    +/* ---------------------------------------------------------------------- */
    +
    +/* todo: hard/soft set? */
    +static inline aufs_bindex_t au_fbstart(struct file *file)
    +{
    + FiMustAnyLock(file);
    + return au_fi(file)->fi_bstart;
    +}
    +
    +static inline aufs_bindex_t au_fbend(struct file *file)
    +{
    + FiMustAnyLock(file);
    + return au_fi(file)->fi_bend;
    +}
    +
    +static inline struct au_vdir *au_fvdir_cache(struct file *file)
    +{
    + FiMustAnyLock(file);
    + return au_fi(file)->fi_vdir_cache;
    +}
    +
    +static inline void au_set_fbstart(struct file *file, aufs_bindex_t bindex)
    +{
    + FiMustWriteLock(file);
    + AuDebugOn(au_sbend(file->f_dentry->d_sb) < bindex);
    + au_fi(file)->fi_bstart = bindex;
    +}
    +
    +static inline void au_set_fbend(struct file *file, aufs_bindex_t bindex)
    +{
    + FiMustWriteLock(file);
    + AuDebugOn(au_sbend(file->f_dentry->d_sb) < bindex
    + || bindex < au_fbstart(file));
    + au_fi(file)->fi_bend = bindex;
    +}
    +
    +static inline void au_set_fvdir_cache(struct file *file,
    + struct au_vdir *vdir_cache)
    +{
    + FiMustWriteLock(file);
    + AuDebugOn(!S_ISDIR(file->f_dentry->d_inode->i_mode)
    + || (au_fi(file)->fi_vdir_cache && vdir_cache));
    + au_fi(file)->fi_vdir_cache = vdir_cache;
    +}
    +
    +static inline void au_update_figen(struct file *file)
    +{
    + atomic_set(&au_fi(file)->fi_generation, au_digen(file->f_dentry));
    + /* smp_mb(); */ /* atomic_set */
    +}
    +
    +#endif /* __KERNEL__ */
    +#endif /* __AUFS_FILE_H__ */
    diff --git a/fs/aufs/finfo.c b/fs/aufs/finfo.c
    new file mode 100644
    index 0000000..8588fd1
    --- /dev/null
    +++ b/fs/aufs/finfo.c
    @@ -0,0 +1,182 @@
    +/*
    + * Copyright (C) 2005-2008 Junjiro Okajima
    + *
    + * This program, aufs is free software; you can redistribute it and/or modify
    + * it under the terms of the GNU General Public License as published by
    + * the Free Software Foundation; either version 2 of the License, or
    + * (at your option) any later version.
    + *
    + * This program is distributed in the hope that it will be useful,
    + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    + * GNU General Public License for more details.
    + *
    + * You should have received a copy of the GNU General Public License
    + * along with this program; if not, write to the Free Software
    + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
    + */
    +
    +/*
    + * file private data
    + */
    +
    +#include "aufs.h"
    +
    +struct au_finfo *au_fi(struct file *file)
    +{
    + struct au_finfo *finfo = file->private_data;
    + AuDebugOn(!finfo
    + || !finfo->fi_hfile
    + || (0 < finfo->fi_bend
    + && (/* au_sbi(file->f_dentry->d_sb)->si_bend
    + < finfo->fi_bend
    + || */ finfo->fi_bend < finfo->fi_bstart)));
    + return finfo;
    +}
    +
    +struct au_branch *au_fbr(struct file *file, aufs_bindex_t bindex)
    +{
    + struct au_finfo *finfo = au_fi(file);
    + struct au_hfile *hf;
    +
    + FiMustAnyLock(file);
    + AuDebugOn(!finfo
    + || finfo->fi_bstart < 0
    + || bindex < finfo->fi_bstart
    + || finfo->fi_bend < bindex);
    + hf = finfo->fi_hfile + bindex;
    + AuDebugOn(hf->hf_br && au_br_count(hf->hf_br) <= 0);
    + return hf->hf_br;
    +}
    +
    +struct file *au_h_fptr(struct file *file, aufs_bindex_t bindex)
    +{
    + struct au_finfo *finfo = au_fi(file);
    + struct au_hfile *hf;
    +
    + FiMustAnyLock(file);
    + AuDebugOn(!finfo
    + || finfo->fi_bstart < 0
    + || bindex < finfo->fi_bstart
    + || finfo->fi_bend < bindex);
    + hf = finfo->fi_hfile + bindex;
    + AuDebugOn(hf->hf_file
    + && file_count(hf->hf_file) <= 0
    + && au_br_count(hf->hf_br) <= 0);
    + return hf->hf_file;
    +}
    +
    +void au_hfput(struct au_hfile *hf)
    +{
    + if (hf->hf_file->f_mode & FMODE_EXEC)
    + au_allow_write_access(hf->hf_file);
    + fput(hf->hf_file);
    + hf->hf_file = NULL;
    + AuDebugOn(!hf->hf_br);
    + au_br_put(hf->hf_br);
    + hf->hf_br = NULL;
    +}
    +
    +void au_set_h_fptr(struct file *file, aufs_bindex_t bindex, struct file *val)
    +{
    + struct au_finfo *finfo = au_fi(file);
    + struct au_hfile *hf;
    +
    + FiMustWriteLock(file);
    + AuDebugOn(!finfo
    + || finfo->fi_bstart < 0
    + || bindex < finfo->fi_bstart
    + || finfo->fi_bend < bindex);
    + AuDebugOn(val && file_count(val) <= 0);
    + hf = finfo->fi_hfile + bindex;
    + AuDebugOn(val && hf->hf_file);
    + if (hf->hf_file)
    + au_hfput(hf);
    + if (val) {
    + hf->hf_file = val;
    + hf->hf_br = au_sbr(file->f_dentry->d_sb, bindex);
    + }
    +}
    +
    +void au_finfo_fin(struct file *file)
    +{
    + struct au_finfo *finfo;
    + struct dentry *dentry;
    + aufs_bindex_t bindex, bend;
    +
    + dentry = file->f_dentry;
    + LKTRTrace("%.*s\n", AuDLNPair(dentry));
    + SiMustAnyLock(dentry->d_sb);
    +
    + fi_write_lock(file);
    + bend = au_fbend(file);
    + bindex = au_fbstart(file);
    + if (bindex >= 0)
    + for (; bindex <= bend; bindex++)
    + au_set_h_fptr(file, bindex, NULL);
    +
    + finfo = au_fi(file);
    +#ifdef CONFIG_AUFS_DEBUG
    + if (finfo->fi_bstart >= 0) {
    + bend = au_fbend(file);
    + for (bindex = finfo->fi_bstart; bindex <= bend; bindex++) {
    + struct au_hfile *hf;
    + hf = finfo->fi_hfile + bindex;
    + AuDebugOn(hf->hf_file || hf->hf_br);
    + }
    + }
    +#endif
    +
    + kfree(finfo->fi_hfile);
    + fi_write_unlock(file);
    + au_cache_free_finfo(finfo);
    +}
    +
    +int au_finfo_init(struct file *file)
    +{
    + struct au_finfo *finfo;
    + struct dentry *dentry;
    + union {
    + void *p;
    + unsigned long ul;
    + } u;
    +
    + dentry = file->f_dentry;
    + LKTRTrace("%.*s\n", AuDLNPair(dentry));
    + AuDebugOn(!dentry->d_inode);
    +
    + finfo = au_cache_alloc_finfo();
    + if (finfo) {
    + finfo->fi_hfile = kcalloc(au_sbend(dentry->d_sb) + 1,
    + sizeof(*finfo->fi_hfile), GFP_KERNEL);
    + if (finfo->fi_hfile) {
    + au_rw_init_wlock(&finfo->fi_rwsem);
    + finfo->fi_bstart = -1;
    + finfo->fi_bend = -1;
    + atomic_set(&finfo->fi_generation, au_digen(dentry));
    + /* smp_mb(); */ /* atomic_set */
    +
    + /*
    + * a dirty trick for handling FMODE_EXEC and
    + * deny_write_access().
    + * because FMODE_EXEC flag is not passed to
    + * f_op->open(),
    + * aufs set it to file->private_data temporary in lookup
    + * or dentry revalidation operations.
    + * restore the flag to f_mode here.
    + */
    + u.p = file->private_data;
    + if (u.ul & FMODE_EXEC) {
    + file->f_mode |= FMODE_EXEC;
    + smp_mb(); /* flush f_mode */
    + }
    +
    + file->private_data = finfo;
    + return 0; /* success */
    + }
    + au_cache_free_finfo(finfo);
    + }
    +
    + AuTraceErr(-ENOMEM);
    + return -ENOMEM;
    +}
    --
    1.5.5.1.308.g1fbb5.dirty


    \
     
     \ /
      Last update: 2008-05-21 05:43    [W:0.113 / U:0.472 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site