[AUFS PATCH v2.6.26-rc2-mm1 20/39] aufs file
From: hooanon05
Date: Tue May 20 2008 - 23:41:28 EST
From: Junjiro Okajima <hooanon05@xxxxxxxxxxx>
initial commit
file private data and address_space operations
Signed-off-by: Junjiro Okajima <hooanon05@xxxxxxxxxxx>
---
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
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/