mm: variable length argument support

[pandora-kernel.git] / fs / gfs2 / ops_super.c

diff --git a/fs/gfs2/ops_super.c b/fs/gfs2/ops_super.c
index 7685b46..603d940 100644 (file)
--- a/fs/gfs2/ops_super.c
+++ b/fs/gfs2/ops_super.c
@@ -173,6 +173,9 @@ static void gfs2_write_super_lockfs(struct super_block *sb)
        struct gfs2_sbd *sdp = sb->s_fs_info;
        int error;
 
+       if (test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
+               return;
+
        for (;;) {
                error = gfs2_freeze_fs(sdp);
                if (!error)
@@ -280,6 +283,31 @@ static int gfs2_remount_fs(struct super_block *sb, int *flags, char *data)
        return error;
 }
 
+/**
+ * gfs2_drop_inode - Drop an inode (test for remote unlink)
+ * @inode: The inode to drop
+ *
+ * If we've received a callback on an iopen lock then its because a
+ * remote node tried to deallocate the inode but failed due to this node
+ * still having the inode open. Here we mark the link count zero
+ * since we know that it must have reached zero if the GLF_DEMOTE flag
+ * is set on the iopen glock. If we didn't do a disk read since the
+ * remote node removed the final link then we might otherwise miss
+ * this event. This check ensures that this node will deallocate the
+ * inode's blocks, or alternatively pass the baton on to another
+ * node for later deallocation.
+ */
+static void gfs2_drop_inode(struct inode *inode)
+{
+       if (inode->i_private && inode->i_nlink) {
+               struct gfs2_inode *ip = GFS2_I(inode);
+               struct gfs2_glock *gl = ip->i_iopen_gh.gh_gl;
+               if (gl && test_bit(GLF_DEMOTE, &gl->gl_flags))
+                       clear_nlink(inode);
+       }
+       generic_drop_inode(inode);
+}
+
 /**
  * gfs2_clear_inode - Deallocate an inode when VFS is done with it
  * @inode: The VFS inode
@@ -298,8 +326,10 @@ static void gfs2_clear_inode(struct inode *inode)
                gfs2_glock_schedule_for_reclaim(ip->i_gl);
                gfs2_glock_put(ip->i_gl);
                ip->i_gl = NULL;
-               if (ip->i_iopen_gh.gh_gl)
+               if (ip->i_iopen_gh.gh_gl) {
+                       ip->i_iopen_gh.gh_gl->gl_object = NULL;
                        gfs2_glock_dq_uninit(&ip->i_iopen_gh);
+               }
        }
 }
 
@@ -394,13 +424,13 @@ static void gfs2_delete_inode(struct inode *inode)
        if (!inode->i_private)
                goto out;
 
-       error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, LM_FLAG_TRY_1CB, &gh);
+       error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
        if (unlikely(error)) {
                gfs2_glock_dq_uninit(&ip->i_iopen_gh);
                goto out;
        }
 
-       gfs2_glock_dq(&ip->i_iopen_gh);
+       gfs2_glock_dq_wait(&ip->i_iopen_gh);
        gfs2_holder_reinit(LM_ST_EXCLUSIVE, LM_FLAG_TRY_1CB | GL_NOCACHE, &ip->i_iopen_gh);
        error = gfs2_glock_nq(&ip->i_iopen_gh);
        if (error)
@@ -426,13 +456,19 @@ static void gfs2_delete_inode(struct inode *inode)
        }
 
        error = gfs2_dinode_dealloc(ip);
+       /*
+        * Must do this before unlock to avoid trying to write back
+        * potentially dirty data now that inode no longer exists
+        * on disk.
+        */
+       truncate_inode_pages(&inode->i_data, 0);
 
 out_unlock:
        gfs2_glock_dq(&ip->i_iopen_gh);
 out_uninit:
        gfs2_holder_uninit(&ip->i_iopen_gh);
        gfs2_glock_dq_uninit(&gh);
-       if (error)
+       if (error && error != GLR_TRYFAILED)
                fs_warn(sdp, "gfs2_delete_inode: %d\n", error);
 out:
        truncate_inode_pages(&inode->i_data, 0);
@@ -443,14 +479,12 @@ out:
 
 static struct inode *gfs2_alloc_inode(struct super_block *sb)
 {
-       struct gfs2_sbd *sdp = sb->s_fs_info;
        struct gfs2_inode *ip;
 
        ip = kmem_cache_alloc(gfs2_inode_cachep, GFP_KERNEL);
        if (ip) {
                ip->i_flags = 0;
                ip->i_gl = NULL;
-               ip->i_greedy = gfs2_tune_get(sdp, gt_greedy_default);
                ip->i_last_pfault = jiffies;
        }
        return &ip->i_inode;
@@ -461,7 +495,7 @@ static void gfs2_destroy_inode(struct inode *inode)
        kmem_cache_free(gfs2_inode_cachep, inode);
 }
 
-struct super_operations gfs2_super_ops = {
+const struct super_operations gfs2_super_ops = {
        .alloc_inode            = gfs2_alloc_inode,
        .destroy_inode          = gfs2_destroy_inode,
        .write_inode            = gfs2_write_inode,
@@ -474,6 +508,7 @@ struct super_operations gfs2_super_ops = {
        .statfs                 = gfs2_statfs,
        .remount_fs             = gfs2_remount_fs,
        .clear_inode            = gfs2_clear_inode,
+       .drop_inode             = gfs2_drop_inode,
        .show_options           = gfs2_show_options,
 };