nfsd: Use write gathering only with NFSv2

[safe/jmp/linux-2.6] / fs / gfs2 / inode.c

diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index 7cee695..5a31d42 100644 (file)
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -16,7 +16,6 @@
 #include <linux/sort.h>
 #include <linux/gfs2_ondisk.h>
 #include <linux/crc32.h>
-#include <linux/lm_interface.h>
 #include <linux/security.h>
 #include <linux/time.h>
 
@@ -32,7 +31,6 @@
 #include "log.h"
 #include "meta_io.h"
 #include "ops_address.h"
-#include "ops_inode.h"
 #include "quota.h"
 #include "rgrp.h"
 #include "trans.h"
@@ -138,13 +136,13 @@ void gfs2_set_iop(struct inode *inode)
 
        if (S_ISREG(mode)) {
                inode->i_op = &gfs2_file_iops;
-               if (sdp->sd_args.ar_localflocks)
+               if (gfs2_localflocks(sdp))
                        inode->i_fop = &gfs2_file_fops_nolock;
                else
                        inode->i_fop = &gfs2_file_fops;
        } else if (S_ISDIR(mode)) {
                inode->i_op = &gfs2_dir_iops;
-               if (sdp->sd_args.ar_localflocks)
+               if (gfs2_localflocks(sdp))
                        inode->i_fop = &gfs2_dir_fops_nolock;
                else
                        inode->i_fop = &gfs2_dir_fops;
@@ -248,7 +246,6 @@ fail:
 
 static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
 {
-       struct gfs2_dinode_host *di = &ip->i_di;
        const struct gfs2_dinode *str = buf;
        struct timespec atime;
        u16 height, depth;
@@ -274,8 +271,8 @@ static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
         * to do that.
         */
        ip->i_inode.i_nlink = be32_to_cpu(str->di_nlink);
-       di->di_size = be64_to_cpu(str->di_size);
-       i_size_write(&ip->i_inode, di->di_size);
+       ip->i_disksize = be64_to_cpu(str->di_size);
+       i_size_write(&ip->i_inode, ip->i_disksize);
        gfs2_set_inode_blocks(&ip->i_inode, be64_to_cpu(str->di_blocks));
        atime.tv_sec = be64_to_cpu(str->di_atime);
        atime.tv_nsec = be32_to_cpu(str->di_atime_nsec);
@@ -287,9 +284,9 @@ static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
        ip->i_inode.i_ctime.tv_nsec = be32_to_cpu(str->di_ctime_nsec);
 
        ip->i_goal = be64_to_cpu(str->di_goal_meta);
-       di->di_generation = be64_to_cpu(str->di_generation);
+       ip->i_generation = be64_to_cpu(str->di_generation);
 
-       di->di_flags = be32_to_cpu(str->di_flags);
+       ip->i_diskflags = be32_to_cpu(str->di_flags);
        gfs2_set_inode_flags(&ip->i_inode);
        height = be16_to_cpu(str->di_height);
        if (unlikely(height > GFS2_MAX_META_HEIGHT))
@@ -300,9 +297,9 @@ static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
        if (unlikely(depth > GFS2_DIR_MAX_DEPTH))
                goto corrupt;
        ip->i_depth = (u8)depth;
-       di->di_entries = be32_to_cpu(str->di_entries);
+       ip->i_entries = be32_to_cpu(str->di_entries);
 
-       di->di_eattr = be64_to_cpu(str->di_eattr);
+       ip->i_eattr = be64_to_cpu(str->di_eattr);
        if (S_ISREG(ip->i_inode.i_mode))
                gfs2_set_aops(&ip->i_inode);
 
@@ -388,7 +385,6 @@ int gfs2_dinode_dealloc(struct gfs2_inode *ip)
        gfs2_free_di(rgd, ip);
 
        gfs2_trans_end(sdp);
-       clear_bit(GLF_STICKY, &ip->i_gl->gl_flags);
 
 out_rg_gunlock:
        gfs2_glock_dq_uninit(&al->al_rgd_gh);
@@ -690,7 +686,7 @@ static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
                return error;
        }
 
-       if (dip->i_di.di_entries == (u32)-1)
+       if (dip->i_entries == (u32)-1)
                return -EFBIG;
        if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
                return -EMLINK;
@@ -705,18 +701,18 @@ static void munge_mode_uid_gid(struct gfs2_inode *dip, unsigned int *mode,
            (dip->i_inode.i_mode & S_ISUID) && dip->i_inode.i_uid) {
                if (S_ISDIR(*mode))
                        *mode |= S_ISUID;
-               else if (dip->i_inode.i_uid != current->fsuid)
+               else if (dip->i_inode.i_uid != current_fsuid())
                        *mode &= ~07111;
                *uid = dip->i_inode.i_uid;
        } else
-               *uid = current->fsuid;
+               *uid = current_fsuid();
 
        if (dip->i_inode.i_mode & S_ISGID) {
                if (S_ISDIR(*mode))
                        *mode |= S_ISGID;
                *gid = dip->i_inode.i_gid;
        } else
-               *gid = current->fsgid;
+               *gid = current_fsgid();
 }
 
 static int alloc_dinode(struct gfs2_inode *dip, u64 *no_addr, u64 *generation)
@@ -790,11 +786,11 @@ static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
        di->di_flags = 0;
 
        if (S_ISREG(mode)) {
-               if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_JDATA) ||
+               if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) ||
                    gfs2_tune_get(sdp, gt_new_files_jdata))
                        di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
        } else if (S_ISDIR(mode)) {
-               di->di_flags |= cpu_to_be32(dip->i_di.di_flags &
+               di->di_flags |= cpu_to_be32(dip->i_diskflags &
                                            GFS2_DIF_INHERIT_JDATA);
        }
 
@@ -1068,7 +1064,7 @@ int gfs2_rmdiri(struct gfs2_inode *dip, const struct qstr *name,
        struct qstr dotname;
        int error;
 
-       if (ip->i_di.di_entries != 2) {
+       if (ip->i_entries != 2) {
                if (gfs2_consist_inode(ip))
                        gfs2_dinode_print(ip);
                return -EIO;
@@ -1124,8 +1120,8 @@ int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
                return -EPERM;
 
        if ((dip->i_inode.i_mode & S_ISVTX) &&
-           dip->i_inode.i_uid != current->fsuid &&
-           ip->i_inode.i_uid != current->fsuid && !capable(CAP_FOWNER))
+           dip->i_inode.i_uid != current_fsuid() &&
+           ip->i_inode.i_uid != current_fsuid() && !capable(CAP_FOWNER))
                return -EPERM;
 
        if (IS_APPEND(&dip->i_inode))
@@ -1168,7 +1164,7 @@ int gfs2_readlinki(struct gfs2_inode *ip, char **buf, unsigned int *len)
                return error;
        }
 
-       if (!ip->i_di.di_size) {
+       if (!ip->i_disksize) {
                gfs2_consist_inode(ip);
                error = -EIO;
                goto out;
@@ -1178,7 +1174,7 @@ int gfs2_readlinki(struct gfs2_inode *ip, char **buf, unsigned int *len)
        if (error)
                goto out;
 
-       x = ip->i_di.di_size + 1;
+       x = ip->i_disksize + 1;
        if (x > *len) {
                *buf = kmalloc(x, GFP_NOFS);
                if (!*buf) {
@@ -1242,7 +1238,6 @@ int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
 
 void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf)
 {
-       const struct gfs2_dinode_host *di = &ip->i_di;
        struct gfs2_dinode *str = buf;
 
        str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
@@ -1256,7 +1251,7 @@ void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf)
        str->di_uid = cpu_to_be32(ip->i_inode.i_uid);
        str->di_gid = cpu_to_be32(ip->i_inode.i_gid);
        str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink);
-       str->di_size = cpu_to_be64(di->di_size);
+       str->di_size = cpu_to_be64(ip->i_disksize);
        str->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode));
        str->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec);
        str->di_mtime = cpu_to_be64(ip->i_inode.i_mtime.tv_sec);
@@ -1264,17 +1259,17 @@ void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf)
 
        str->di_goal_meta = cpu_to_be64(ip->i_goal);
        str->di_goal_data = cpu_to_be64(ip->i_goal);
-       str->di_generation = cpu_to_be64(di->di_generation);
+       str->di_generation = cpu_to_be64(ip->i_generation);
 
-       str->di_flags = cpu_to_be32(di->di_flags);
+       str->di_flags = cpu_to_be32(ip->i_diskflags);
        str->di_height = cpu_to_be16(ip->i_height);
        str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) &&
-                                            !(ip->i_di.di_flags & GFS2_DIF_EXHASH) ?
+                                            !(ip->i_diskflags & GFS2_DIF_EXHASH) ?
                                             GFS2_FORMAT_DE : 0);
        str->di_depth = cpu_to_be16(ip->i_depth);
-       str->di_entries = cpu_to_be32(di->di_entries);
+       str->di_entries = cpu_to_be32(ip->i_entries);
 
-       str->di_eattr = cpu_to_be64(di->di_eattr);
+       str->di_eattr = cpu_to_be64(ip->i_eattr);
        str->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec);
        str->di_mtime_nsec = cpu_to_be32(ip->i_inode.i_mtime.tv_nsec);
        str->di_ctime_nsec = cpu_to_be32(ip->i_inode.i_ctime.tv_nsec);
@@ -1282,22 +1277,21 @@ void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf)
 
 void gfs2_dinode_print(const struct gfs2_inode *ip)
 {
-       const struct gfs2_dinode_host *di = &ip->i_di;
-
        printk(KERN_INFO "  no_formal_ino = %llu\n",
               (unsigned long long)ip->i_no_formal_ino);
        printk(KERN_INFO "  no_addr = %llu\n",
               (unsigned long long)ip->i_no_addr);
-       printk(KERN_INFO "  di_size = %llu\n", (unsigned long long)di->di_size);
+       printk(KERN_INFO "  i_disksize = %llu\n",
+              (unsigned long long)ip->i_disksize);
        printk(KERN_INFO "  blocks = %llu\n",
               (unsigned long long)gfs2_get_inode_blocks(&ip->i_inode));
        printk(KERN_INFO "  i_goal = %llu\n",
               (unsigned long long)ip->i_goal);
-       printk(KERN_INFO "  di_flags = 0x%.8X\n", di->di_flags);
+       printk(KERN_INFO "  i_diskflags = 0x%.8X\n", ip->i_diskflags);
        printk(KERN_INFO "  i_height = %u\n", ip->i_height);
        printk(KERN_INFO "  i_depth = %u\n", ip->i_depth);
-       printk(KERN_INFO "  di_entries = %u\n", di->di_entries);
-       printk(KERN_INFO "  di_eattr = %llu\n",
-              (unsigned long long)di->di_eattr);
+       printk(KERN_INFO "  i_entries = %u\n", ip->i_entries);
+       printk(KERN_INFO "  i_eattr = %llu\n",
+              (unsigned long long)ip->i_eattr);
 }