aboutsummaryrefslogtreecommitdiffstats
path: root/fs/gfs2
diff options
context:
space:
mode:
authorSteven Whitehouse <swhiteho@redhat.com>2007-06-01 09:11:58 -0400
committerSteven Whitehouse <swhiteho@redhat.com>2007-07-09 03:23:10 -0400
commitbb8d8a6f54c1c84d7c74623491bab043b36a38c5 (patch)
tree76c62c505df2a1acd090f4aacc63fb9eddd3950f /fs/gfs2
parentddf4b426aababdae4cb96326d7aeb9d119f42c50 (diff)
[GFS2] Fix sign problem in quota/statfs and cleanup _host structures
This patch fixes some sign issues which were accidentally introduced into the quota & statfs code during the endianess annotation process. Also included is a general clean up which moves all of the _host structures out of gfs2_ondisk.h (where they should not have been to start with) and into the places where they are actually used (often only one place). Also those _host structures which are not required any more are removed entirely (which is the eventual plan for all of them). The conversion routines from ondisk.c are also moved into the places where they are actually used, which for almost every one, was just one single place, so all those are now static functions. This also cleans up the end of gfs2_ondisk.h which no longer needs the #ifdef __KERNEL__. The net result is a reduction of about 100 lines of code, many functions now marked static plus the bug fixes as mentioned above. For good measure I ran the code through sparse after making these changes to check that there are no warnings generated. This fixes Red Hat bz #239686 Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Diffstat (limited to 'fs/gfs2')
-rw-r--r--fs/gfs2/Makefile2
-rw-r--r--fs/gfs2/bmap.c4
-rw-r--r--fs/gfs2/dir.c2
-rw-r--r--fs/gfs2/eattr.c6
-rw-r--r--fs/gfs2/incore.h63
-rw-r--r--fs/gfs2/inode.c83
-rw-r--r--fs/gfs2/inode.h10
-rw-r--r--fs/gfs2/ondisk.c246
-rw-r--r--fs/gfs2/ops_export.c10
-rw-r--r--fs/gfs2/ops_export.h22
-rw-r--r--fs/gfs2/ops_fstype.c13
-rw-r--r--fs/gfs2/ops_fstype.h1
-rw-r--r--fs/gfs2/ops_inode.c4
-rw-r--r--fs/gfs2/ops_vm.c2
-rw-r--r--fs/gfs2/quota.c42
-rw-r--r--fs/gfs2/recovery.c22
-rw-r--r--fs/gfs2/rgrp.c111
-rw-r--r--fs/gfs2/super.c77
-rw-r--r--fs/gfs2/super.h2
-rw-r--r--fs/gfs2/util.c2
20 files changed, 372 insertions, 352 deletions
diff --git a/fs/gfs2/Makefile b/fs/gfs2/Makefile
index e3f1ada643ac..04ad0caebedb 100644
--- a/fs/gfs2/Makefile
+++ b/fs/gfs2/Makefile
@@ -1,7 +1,7 @@
1obj-$(CONFIG_GFS2_FS) += gfs2.o 1obj-$(CONFIG_GFS2_FS) += gfs2.o
2gfs2-y := acl.o bmap.o daemon.o dir.o eaops.o eattr.o glock.o \ 2gfs2-y := acl.o bmap.o daemon.o dir.o eaops.o eattr.o glock.o \
3 glops.o inode.o lm.o log.o lops.o locking.o main.o meta_io.o \ 3 glops.o inode.o lm.o log.o lops.o locking.o main.o meta_io.o \
4 mount.o ondisk.o ops_address.o ops_dentry.o ops_export.o ops_file.o \ 4 mount.o ops_address.o ops_dentry.o ops_export.o ops_file.o \
5 ops_fstype.o ops_inode.o ops_super.o ops_vm.o quota.o \ 5 ops_fstype.o ops_inode.o ops_super.o ops_vm.o quota.o \
6 recovery.o rgrp.o super.o sys.o trans.o util.o 6 recovery.o rgrp.o super.o sys.o trans.o util.o
7 7
diff --git a/fs/gfs2/bmap.c b/fs/gfs2/bmap.c
index e76a887a89b2..b784cf3c6482 100644
--- a/fs/gfs2/bmap.c
+++ b/fs/gfs2/bmap.c
@@ -718,7 +718,7 @@ static int do_strip(struct gfs2_inode *ip, struct buffer_head *dibh,
718 for (x = 0; x < rlist.rl_rgrps; x++) { 718 for (x = 0; x < rlist.rl_rgrps; x++) {
719 struct gfs2_rgrpd *rgd; 719 struct gfs2_rgrpd *rgd;
720 rgd = rlist.rl_ghs[x].gh_gl->gl_object; 720 rgd = rlist.rl_ghs[x].gh_gl->gl_object;
721 rg_blocks += rgd->rd_ri.ri_length; 721 rg_blocks += rgd->rd_length;
722 } 722 }
723 723
724 error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs); 724 error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
@@ -824,7 +824,7 @@ static int do_grow(struct gfs2_inode *ip, u64 size)
824 goto out_gunlock_q; 824 goto out_gunlock_q;
825 825
826 error = gfs2_trans_begin(sdp, 826 error = gfs2_trans_begin(sdp,
827 sdp->sd_max_height + al->al_rgd->rd_ri.ri_length + 827 sdp->sd_max_height + al->al_rgd->rd_length +
828 RES_JDATA + RES_DINODE + RES_STATFS + RES_QUOTA, 0); 828 RES_JDATA + RES_DINODE + RES_STATFS + RES_QUOTA, 0);
829 if (error) 829 if (error)
830 goto out_ipres; 830 goto out_ipres;
diff --git a/fs/gfs2/dir.c b/fs/gfs2/dir.c
index 9cdd71cef59c..2f154049b59d 100644
--- a/fs/gfs2/dir.c
+++ b/fs/gfs2/dir.c
@@ -1897,7 +1897,7 @@ static int leaf_dealloc(struct gfs2_inode *dip, u32 index, u32 len,
1897 for (x = 0; x < rlist.rl_rgrps; x++) { 1897 for (x = 0; x < rlist.rl_rgrps; x++) {
1898 struct gfs2_rgrpd *rgd; 1898 struct gfs2_rgrpd *rgd;
1899 rgd = rlist.rl_ghs[x].gh_gl->gl_object; 1899 rgd = rlist.rl_ghs[x].gh_gl->gl_object;
1900 rg_blocks += rgd->rd_ri.ri_length; 1900 rg_blocks += rgd->rd_length;
1901 } 1901 }
1902 1902
1903 error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs); 1903 error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
diff --git a/fs/gfs2/eattr.c b/fs/gfs2/eattr.c
index 5b83ca6acab1..40e1d37112e6 100644
--- a/fs/gfs2/eattr.c
+++ b/fs/gfs2/eattr.c
@@ -254,7 +254,7 @@ static int ea_dealloc_unstuffed(struct gfs2_inode *ip, struct buffer_head *bh,
254 if (error) 254 if (error)
255 return error; 255 return error;
256 256
257 error = gfs2_trans_begin(sdp, rgd->rd_ri.ri_length + RES_DINODE + 257 error = gfs2_trans_begin(sdp, rgd->rd_length + RES_DINODE +
258 RES_EATTR + RES_STATFS + RES_QUOTA, blks); 258 RES_EATTR + RES_STATFS + RES_QUOTA, blks);
259 if (error) 259 if (error)
260 goto out_gunlock; 260 goto out_gunlock;
@@ -700,7 +700,7 @@ static int ea_alloc_skeleton(struct gfs2_inode *ip, struct gfs2_ea_request *er,
700 goto out_gunlock_q; 700 goto out_gunlock_q;
701 701
702 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), 702 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode),
703 blks + al->al_rgd->rd_ri.ri_length + 703 blks + al->al_rgd->rd_length +
704 RES_DINODE + RES_STATFS + RES_QUOTA, 0); 704 RES_DINODE + RES_STATFS + RES_QUOTA, 0);
705 if (error) 705 if (error)
706 goto out_ipres; 706 goto out_ipres;
@@ -1352,7 +1352,7 @@ static int ea_dealloc_indirect(struct gfs2_inode *ip)
1352 for (x = 0; x < rlist.rl_rgrps; x++) { 1352 for (x = 0; x < rlist.rl_rgrps; x++) {
1353 struct gfs2_rgrpd *rgd; 1353 struct gfs2_rgrpd *rgd;
1354 rgd = rlist.rl_ghs[x].gh_gl->gl_object; 1354 rgd = rlist.rl_ghs[x].gh_gl->gl_object;
1355 rg_blocks += rgd->rd_ri.ri_length; 1355 rg_blocks += rgd->rd_length;
1356 } 1356 }
1357 1357
1358 error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs); 1358 error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
diff --git a/fs/gfs2/incore.h b/fs/gfs2/incore.h
index b2079fcd2513..e5069b912d5e 100644
--- a/fs/gfs2/incore.h
+++ b/fs/gfs2/incore.h
@@ -28,6 +28,14 @@ struct gfs2_sbd;
28 28
29typedef void (*gfs2_glop_bh_t) (struct gfs2_glock *gl, unsigned int ret); 29typedef void (*gfs2_glop_bh_t) (struct gfs2_glock *gl, unsigned int ret);
30 30
31struct gfs2_log_header_host {
32 u64 lh_sequence; /* Sequence number of this transaction */
33 u32 lh_flags; /* GFS2_LOG_HEAD_... */
34 u32 lh_tail; /* Block number of log tail */
35 u32 lh_blkno;
36 u32 lh_hash;
37};
38
31/* 39/*
32 * Structure of operations that are associated with each 40 * Structure of operations that are associated with each
33 * type of element in the log. 41 * type of element in the log.
@@ -60,12 +68,23 @@ struct gfs2_bitmap {
60 u32 bi_len; 68 u32 bi_len;
61}; 69};
62 70
71struct gfs2_rgrp_host {
72 u32 rg_flags;
73 u32 rg_free;
74 u32 rg_dinodes;
75 u64 rg_igeneration;
76};
77
63struct gfs2_rgrpd { 78struct gfs2_rgrpd {
64 struct list_head rd_list; /* Link with superblock */ 79 struct list_head rd_list; /* Link with superblock */
65 struct list_head rd_list_mru; 80 struct list_head rd_list_mru;
66 struct list_head rd_recent; /* Recently used rgrps */ 81 struct list_head rd_recent; /* Recently used rgrps */
67 struct gfs2_glock *rd_gl; /* Glock for this rgrp */ 82 struct gfs2_glock *rd_gl; /* Glock for this rgrp */
68 struct gfs2_rindex_host rd_ri; 83 u64 rd_addr; /* grp block disk address */
84 u64 rd_data0; /* first data location */
85 u32 rd_length; /* length of rgrp header in fs blocks */
86 u32 rd_data; /* num of data blocks in rgrp */
87 u32 rd_bitbytes; /* number of bytes in data bitmaps */
69 struct gfs2_rgrp_host rd_rg; 88 struct gfs2_rgrp_host rd_rg;
70 u64 rd_rg_vn; 89 u64 rd_rg_vn;
71 struct gfs2_bitmap *rd_bits; 90 struct gfs2_bitmap *rd_bits;
@@ -211,6 +230,20 @@ enum {
211 GIF_SW_PAGED = 3, 230 GIF_SW_PAGED = 3,
212}; 231};
213 232
233struct gfs2_dinode_host {
234 u64 di_size; /* number of bytes in file */
235 u64 di_blocks; /* number of blocks in file */
236 u64 di_goal_meta; /* rgrp to alloc from next */
237 u64 di_goal_data; /* data block goal */
238 u64 di_generation; /* generation number for NFS */
239 u32 di_flags; /* GFS2_DIF_... */
240 u16 di_height; /* height of metadata */
241 /* These only apply to directories */
242 u16 di_depth; /* Number of bits in the table */
243 u32 di_entries; /* The number of entries in the directory */
244 u64 di_eattr; /* extended attribute block number */
245};
246
214struct gfs2_inode { 247struct gfs2_inode {
215 struct inode i_inode; 248 struct inode i_inode;
216 u64 i_no_addr; 249 u64 i_no_addr;
@@ -346,6 +379,12 @@ struct gfs2_jdesc {
346 unsigned int jd_blocks; 379 unsigned int jd_blocks;
347}; 380};
348 381
382struct gfs2_statfs_change_host {
383 s64 sc_total;
384 s64 sc_free;
385 s64 sc_dinodes;
386};
387
349#define GFS2_GLOCKD_DEFAULT 1 388#define GFS2_GLOCKD_DEFAULT 1
350#define GFS2_GLOCKD_MAX 16 389#define GFS2_GLOCKD_MAX 16
351 390
@@ -418,6 +457,28 @@ enum {
418 457
419#define GFS2_FSNAME_LEN 256 458#define GFS2_FSNAME_LEN 256
420 459
460struct gfs2_inum_host {
461 u64 no_formal_ino;
462 u64 no_addr;
463};
464
465struct gfs2_sb_host {
466 u32 sb_magic;
467 u32 sb_type;
468 u32 sb_format;
469
470 u32 sb_fs_format;
471 u32 sb_multihost_format;
472 u32 sb_bsize;
473 u32 sb_bsize_shift;
474
475 struct gfs2_inum_host sb_master_dir;
476 struct gfs2_inum_host sb_root_dir;
477
478 char sb_lockproto[GFS2_LOCKNAME_LEN];
479 char sb_locktable[GFS2_LOCKNAME_LEN];
480};
481
421struct gfs2_sbd { 482struct gfs2_sbd {
422 struct super_block *sd_vfs; 483 struct super_block *sd_vfs;
423 struct super_block *sd_vfs_meta; 484 struct super_block *sd_vfs_meta;
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index 58f5a67e1c35..a31a4b80ba3c 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -38,6 +38,11 @@
38#include "trans.h" 38#include "trans.h"
39#include "util.h" 39#include "util.h"
40 40
41struct gfs2_inum_range_host {
42 u64 ir_start;
43 u64 ir_length;
44};
45
41static int iget_test(struct inode *inode, void *opaque) 46static int iget_test(struct inode *inode, void *opaque)
42{ 47{
43 struct gfs2_inode *ip = GFS2_I(inode); 48 struct gfs2_inode *ip = GFS2_I(inode);
@@ -402,6 +407,22 @@ out:
402 return inode ? inode : ERR_PTR(error); 407 return inode ? inode : ERR_PTR(error);
403} 408}
404 409
410static void gfs2_inum_range_in(struct gfs2_inum_range_host *ir, const void *buf)
411{
412 const struct gfs2_inum_range *str = buf;
413
414 ir->ir_start = be64_to_cpu(str->ir_start);
415 ir->ir_length = be64_to_cpu(str->ir_length);
416}
417
418static void gfs2_inum_range_out(const struct gfs2_inum_range_host *ir, void *buf)
419{
420 struct gfs2_inum_range *str = buf;
421
422 str->ir_start = cpu_to_be64(ir->ir_start);
423 str->ir_length = cpu_to_be64(ir->ir_length);
424}
425
405static int pick_formal_ino_1(struct gfs2_sbd *sdp, u64 *formal_ino) 426static int pick_formal_ino_1(struct gfs2_sbd *sdp, u64 *formal_ino)
406{ 427{
407 struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode); 428 struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode);
@@ -741,7 +762,7 @@ static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
741 goto fail_quota_locks; 762 goto fail_quota_locks;
742 763
743 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres + 764 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
744 al->al_rgd->rd_ri.ri_length + 765 al->al_rgd->rd_length +
745 2 * RES_DINODE + 766 2 * RES_DINODE +
746 RES_STATFS + RES_QUOTA, 0); 767 RES_STATFS + RES_QUOTA, 0);
747 if (error) 768 if (error)
@@ -1234,3 +1255,63 @@ int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
1234 return error; 1255 return error;
1235} 1256}
1236 1257
1258void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf)
1259{
1260 const struct gfs2_dinode_host *di = &ip->i_di;
1261 struct gfs2_dinode *str = buf;
1262
1263 str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
1264 str->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI);
1265 str->di_header.__pad0 = 0;
1266 str->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI);
1267 str->di_header.__pad1 = 0;
1268 str->di_num.no_addr = cpu_to_be64(ip->i_no_addr);
1269 str->di_num.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino);
1270 str->di_mode = cpu_to_be32(ip->i_inode.i_mode);
1271 str->di_uid = cpu_to_be32(ip->i_inode.i_uid);
1272 str->di_gid = cpu_to_be32(ip->i_inode.i_gid);
1273 str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink);
1274 str->di_size = cpu_to_be64(di->di_size);
1275 str->di_blocks = cpu_to_be64(di->di_blocks);
1276 str->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec);
1277 str->di_mtime = cpu_to_be64(ip->i_inode.i_mtime.tv_sec);
1278 str->di_ctime = cpu_to_be64(ip->i_inode.i_ctime.tv_sec);
1279
1280 str->di_goal_meta = cpu_to_be64(di->di_goal_meta);
1281 str->di_goal_data = cpu_to_be64(di->di_goal_data);
1282 str->di_generation = cpu_to_be64(di->di_generation);
1283
1284 str->di_flags = cpu_to_be32(di->di_flags);
1285 str->di_height = cpu_to_be16(di->di_height);
1286 str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) &&
1287 !(ip->i_di.di_flags & GFS2_DIF_EXHASH) ?
1288 GFS2_FORMAT_DE : 0);
1289 str->di_depth = cpu_to_be16(di->di_depth);
1290 str->di_entries = cpu_to_be32(di->di_entries);
1291
1292 str->di_eattr = cpu_to_be64(di->di_eattr);
1293}
1294
1295void gfs2_dinode_print(const struct gfs2_inode *ip)
1296{
1297 const struct gfs2_dinode_host *di = &ip->i_di;
1298
1299 printk(KERN_INFO " no_formal_ino = %llu\n",
1300 (unsigned long long)ip->i_no_formal_ino);
1301 printk(KERN_INFO " no_addr = %llu\n",
1302 (unsigned long long)ip->i_no_addr);
1303 printk(KERN_INFO " di_size = %llu\n", (unsigned long long)di->di_size);
1304 printk(KERN_INFO " di_blocks = %llu\n",
1305 (unsigned long long)di->di_blocks);
1306 printk(KERN_INFO " di_goal_meta = %llu\n",
1307 (unsigned long long)di->di_goal_meta);
1308 printk(KERN_INFO " di_goal_data = %llu\n",
1309 (unsigned long long)di->di_goal_data);
1310 printk(KERN_INFO " di_flags = 0x%.8X\n", di->di_flags);
1311 printk(KERN_INFO " di_height = %u\n", di->di_height);
1312 printk(KERN_INFO " di_depth = %u\n", di->di_depth);
1313 printk(KERN_INFO " di_entries = %u\n", di->di_entries);
1314 printk(KERN_INFO " di_eattr = %llu\n",
1315 (unsigned long long)di->di_eattr);
1316}
1317
diff --git a/fs/gfs2/inode.h b/fs/gfs2/inode.h
index 05fc095d8540..35375fc43fa3 100644
--- a/fs/gfs2/inode.h
+++ b/fs/gfs2/inode.h
@@ -38,6 +38,14 @@ static inline int gfs2_check_inum(const struct gfs2_inode *ip, u64 no_addr,
38 return ip->i_no_addr == no_addr && ip->i_no_formal_ino == no_formal_ino; 38 return ip->i_no_addr == no_addr && ip->i_no_formal_ino == no_formal_ino;
39} 39}
40 40
41static inline void gfs2_inum_out(const struct gfs2_inode *ip,
42 struct gfs2_dirent *dent)
43{
44 dent->de_inum.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino);
45 dent->de_inum.no_addr = cpu_to_be64(ip->i_no_addr);
46}
47
48
41void gfs2_inode_attr_in(struct gfs2_inode *ip); 49void gfs2_inode_attr_in(struct gfs2_inode *ip);
42struct inode *gfs2_inode_lookup(struct super_block *sb, u64 no_addr, unsigned type); 50struct inode *gfs2_inode_lookup(struct super_block *sb, u64 no_addr, unsigned type);
43struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr); 51struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr);
@@ -59,6 +67,8 @@ int gfs2_readlinki(struct gfs2_inode *ip, char **buf, unsigned int *len);
59int gfs2_glock_nq_atime(struct gfs2_holder *gh); 67int gfs2_glock_nq_atime(struct gfs2_holder *gh);
60int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr); 68int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr);
61struct inode *gfs2_lookup_simple(struct inode *dip, const char *name); 69struct inode *gfs2_lookup_simple(struct inode *dip, const char *name);
70void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf);
71void gfs2_dinode_print(const struct gfs2_inode *ip);
62 72
63#endif /* __INODE_DOT_H__ */ 73#endif /* __INODE_DOT_H__ */
64 74
diff --git a/fs/gfs2/ondisk.c b/fs/gfs2/ondisk.c
deleted file mode 100644
index a5b05ea3d4c7..000000000000
--- a/fs/gfs2/ondisk.c
+++ /dev/null
@@ -1,246 +0,0 @@
1/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
4 *
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
7 * of the GNU General Public License version 2.
8 */
9
10#include <linux/slab.h>
11#include <linux/spinlock.h>
12#include <linux/completion.h>
13#include <linux/buffer_head.h>
14
15#include "gfs2.h"
16#include <linux/gfs2_ondisk.h>
17#include <linux/lm_interface.h>
18#include "incore.h"
19
20#define pv(struct, member, fmt) printk(KERN_INFO " "#member" = "fmt"\n", \
21 struct->member);
22
23/*
24 * gfs2_xxx_in - read in an xxx struct
25 * first arg: the cpu-order structure
26 * buf: the disk-order buffer
27 *
28 * gfs2_xxx_out - write out an xxx struct
29 * first arg: the cpu-order structure
30 * buf: the disk-order buffer
31 *
32 * gfs2_xxx_print - print out an xxx struct
33 * first arg: the cpu-order structure
34 */
35
36void gfs2_inum_out(const struct gfs2_inode *ip, struct gfs2_dirent *dent)
37{
38 dent->de_inum.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino);
39 dent->de_inum.no_addr = cpu_to_be64(ip->i_no_addr);
40}
41
42static void gfs2_meta_header_in(struct gfs2_meta_header_host *mh, const void *buf)
43{
44 const struct gfs2_meta_header *str = buf;
45
46 mh->mh_magic = be32_to_cpu(str->mh_magic);
47 mh->mh_type = be32_to_cpu(str->mh_type);
48 mh->mh_format = be32_to_cpu(str->mh_format);
49}
50
51void gfs2_sb_in(struct gfs2_sb_host *sb, const void *buf)
52{
53 const struct gfs2_sb *str = buf;
54
55 gfs2_meta_header_in(&sb->sb_header, buf);
56
57 sb->sb_fs_format = be32_to_cpu(str->sb_fs_format);
58 sb->sb_multihost_format = be32_to_cpu(str->sb_multihost_format);
59 sb->sb_bsize = be32_to_cpu(str->sb_bsize);
60 sb->sb_bsize_shift = be32_to_cpu(str->sb_bsize_shift);
61 sb->sb_master_dir.no_addr = be64_to_cpu(str->sb_master_dir.no_addr);
62 sb->sb_master_dir.no_formal_ino = be64_to_cpu(str->sb_master_dir.no_formal_ino);
63 sb->sb_root_dir.no_addr = be64_to_cpu(str->sb_root_dir.no_addr);
64 sb->sb_root_dir.no_formal_ino = be64_to_cpu(str->sb_root_dir.no_formal_ino);
65
66 memcpy(sb->sb_lockproto, str->sb_lockproto, GFS2_LOCKNAME_LEN);
67 memcpy(sb->sb_locktable, str->sb_locktable, GFS2_LOCKNAME_LEN);
68}
69
70void gfs2_rindex_in(struct gfs2_rindex_host *ri, const void *buf)
71{
72 const struct gfs2_rindex *str = buf;
73
74 ri->ri_addr = be64_to_cpu(str->ri_addr);
75 ri->ri_length = be32_to_cpu(str->ri_length);
76 ri->ri_data0 = be64_to_cpu(str->ri_data0);
77 ri->ri_data = be32_to_cpu(str->ri_data);
78 ri->ri_bitbytes = be32_to_cpu(str->ri_bitbytes);
79
80}
81
82void gfs2_rindex_print(const struct gfs2_rindex_host *ri)
83{
84 printk(KERN_INFO " ri_addr = %llu\n", (unsigned long long)ri->ri_addr);
85 pv(ri, ri_length, "%u");
86
87 printk(KERN_INFO " ri_data0 = %llu\n", (unsigned long long)ri->ri_data0);
88 pv(ri, ri_data, "%u");
89
90 pv(ri, ri_bitbytes, "%u");
91}
92
93void gfs2_rgrp_in(struct gfs2_rgrp_host *rg, const void *buf)
94{
95 const struct gfs2_rgrp *str = buf;
96
97 rg->rg_flags = be32_to_cpu(str->rg_flags);
98 rg->rg_free = be32_to_cpu(str->rg_free);
99 rg->rg_dinodes = be32_to_cpu(str->rg_dinodes);
100 rg->rg_igeneration = be64_to_cpu(str->rg_igeneration);
101}
102
103void gfs2_rgrp_out(const struct gfs2_rgrp_host *rg, void *buf)
104{
105 struct gfs2_rgrp *str = buf;
106
107 str->rg_flags = cpu_to_be32(rg->rg_flags);
108 str->rg_free = cpu_to_be32(rg->rg_free);
109 str->rg_dinodes = cpu_to_be32(rg->rg_dinodes);
110 str->__pad = cpu_to_be32(0);
111 str->rg_igeneration = cpu_to_be64(rg->rg_igeneration);
112 memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
113}
114
115void gfs2_quota_in(struct gfs2_quota_host *qu, const void *buf)
116{
117 const struct gfs2_quota *str = buf;
118
119 qu->qu_limit = be64_to_cpu(str->qu_limit);
120 qu->qu_warn = be64_to_cpu(str->qu_warn);
121 qu->qu_value = be64_to_cpu(str->qu_value);
122}
123
124void gfs2_quota_out(const struct gfs2_quota_host *qu, void *buf)
125{
126 struct gfs2_quota *str = buf;
127
128 str->qu_limit = cpu_to_be64(qu->qu_limit);
129 str->qu_warn = cpu_to_be64(qu->qu_warn);
130 str->qu_value = cpu_to_be64(qu->qu_value);
131 memset(&str->qu_reserved, 0, sizeof(str->qu_reserved));
132}
133
134void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf)
135{
136 const struct gfs2_dinode_host *di = &ip->i_di;
137 struct gfs2_dinode *str = buf;
138
139 str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
140 str->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI);
141 str->di_header.__pad0 = 0;
142 str->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI);
143 str->di_header.__pad1 = 0;
144 str->di_num.no_addr = cpu_to_be64(ip->i_no_addr);
145 str->di_num.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino);
146 str->di_mode = cpu_to_be32(ip->i_inode.i_mode);
147 str->di_uid = cpu_to_be32(ip->i_inode.i_uid);
148 str->di_gid = cpu_to_be32(ip->i_inode.i_gid);
149 str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink);
150 str->di_size = cpu_to_be64(di->di_size);
151 str->di_blocks = cpu_to_be64(di->di_blocks);
152 str->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec);
153 str->di_mtime = cpu_to_be64(ip->i_inode.i_mtime.tv_sec);
154 str->di_ctime = cpu_to_be64(ip->i_inode.i_ctime.tv_sec);
155
156 str->di_goal_meta = cpu_to_be64(di->di_goal_meta);
157 str->di_goal_data = cpu_to_be64(di->di_goal_data);
158 str->di_generation = cpu_to_be64(di->di_generation);
159
160 str->di_flags = cpu_to_be32(di->di_flags);
161 str->di_height = cpu_to_be16(di->di_height);
162 str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) &&
163 !(ip->i_di.di_flags & GFS2_DIF_EXHASH) ?
164 GFS2_FORMAT_DE : 0);
165 str->di_depth = cpu_to_be16(di->di_depth);
166 str->di_entries = cpu_to_be32(di->di_entries);
167
168 str->di_eattr = cpu_to_be64(di->di_eattr);
169}
170
171void gfs2_dinode_print(const struct gfs2_inode *ip)
172{
173 const struct gfs2_dinode_host *di = &ip->i_di;
174
175 printk(KERN_INFO " no_formal_ino = %llu\n", (unsigned long long)ip->i_no_formal_ino);
176 printk(KERN_INFO " no_addr = %llu\n", (unsigned long long)ip->i_no_addr);
177
178 printk(KERN_INFO " di_size = %llu\n", (unsigned long long)di->di_size);
179 printk(KERN_INFO " di_blocks = %llu\n", (unsigned long long)di->di_blocks);
180 printk(KERN_INFO " di_goal_meta = %llu\n", (unsigned long long)di->di_goal_meta);
181 printk(KERN_INFO " di_goal_data = %llu\n", (unsigned long long)di->di_goal_data);
182
183 pv(di, di_flags, "0x%.8X");
184 pv(di, di_height, "%u");
185
186 pv(di, di_depth, "%u");
187 pv(di, di_entries, "%u");
188
189 printk(KERN_INFO " di_eattr = %llu\n", (unsigned long long)di->di_eattr);
190}
191
192void gfs2_log_header_in(struct gfs2_log_header_host *lh, const void *buf)
193{
194 const struct gfs2_log_header *str = buf;
195
196 gfs2_meta_header_in(&lh->lh_header, buf);
197 lh->lh_sequence = be64_to_cpu(str->lh_sequence);
198 lh->lh_flags = be32_to_cpu(str->lh_flags);
199 lh->lh_tail = be32_to_cpu(str->lh_tail);
200 lh->lh_blkno = be32_to_cpu(str->lh_blkno);
201 lh->lh_hash = be32_to_cpu(str->lh_hash);
202}
203
204void gfs2_inum_range_in(struct gfs2_inum_range_host *ir, const void *buf)
205{
206 const struct gfs2_inum_range *str = buf;
207
208 ir->ir_start = be64_to_cpu(str->ir_start);
209 ir->ir_length = be64_to_cpu(str->ir_length);
210}
211
212void gfs2_inum_range_out(const struct gfs2_inum_range_host *ir, void *buf)
213{
214 struct gfs2_inum_range *str = buf;
215
216 str->ir_start = cpu_to_be64(ir->ir_start);
217 str->ir_length = cpu_to_be64(ir->ir_length);
218}
219
220void gfs2_statfs_change_in(struct gfs2_statfs_change_host *sc, const void *buf)
221{
222 const struct gfs2_statfs_change *str = buf;
223
224 sc->sc_total = be64_to_cpu(str->sc_total);
225 sc->sc_free = be64_to_cpu(str->sc_free);
226 sc->sc_dinodes = be64_to_cpu(str->sc_dinodes);
227}
228
229void gfs2_statfs_change_out(const struct gfs2_statfs_change_host *sc, void *buf)
230{
231 struct gfs2_statfs_change *str = buf;
232
233 str->sc_total = cpu_to_be64(sc->sc_total);
234 str->sc_free = cpu_to_be64(sc->sc_free);
235 str->sc_dinodes = cpu_to_be64(sc->sc_dinodes);
236}
237
238void gfs2_quota_change_in(struct gfs2_quota_change_host *qc, const void *buf)
239{
240 const struct gfs2_quota_change *str = buf;
241
242 qc->qc_change = be64_to_cpu(str->qc_change);
243 qc->qc_flags = be32_to_cpu(str->qc_flags);
244 qc->qc_id = be32_to_cpu(str->qc_id);
245}
246
diff --git a/fs/gfs2/ops_export.c b/fs/gfs2/ops_export.c
index 51a8a14deb29..d07230ee5fc0 100644
--- a/fs/gfs2/ops_export.c
+++ b/fs/gfs2/ops_export.c
@@ -22,10 +22,18 @@
22#include "glops.h" 22#include "glops.h"
23#include "inode.h" 23#include "inode.h"
24#include "ops_dentry.h" 24#include "ops_dentry.h"
25#include "ops_export.h" 25#include "ops_fstype.h"
26#include "rgrp.h" 26#include "rgrp.h"
27#include "util.h" 27#include "util.h"
28 28
29#define GFS2_SMALL_FH_SIZE 4
30#define GFS2_LARGE_FH_SIZE 10
31
32struct gfs2_fh_obj {
33 struct gfs2_inum_host this;
34 u32 imode;
35};
36
29static struct dentry *gfs2_decode_fh(struct super_block *sb, 37static struct dentry *gfs2_decode_fh(struct super_block *sb,
30 __u32 *p, 38 __u32 *p,
31 int fh_len, 39 int fh_len,
diff --git a/fs/gfs2/ops_export.h b/fs/gfs2/ops_export.h
deleted file mode 100644
index f925a955b3b8..000000000000
--- a/fs/gfs2/ops_export.h
+++ /dev/null
@@ -1,22 +0,0 @@
1/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
4 *
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
7 * of the GNU General Public License version 2.
8 */
9
10#ifndef __OPS_EXPORT_DOT_H__
11#define __OPS_EXPORT_DOT_H__
12
13#define GFS2_SMALL_FH_SIZE 4
14#define GFS2_LARGE_FH_SIZE 10
15
16extern struct export_operations gfs2_export_ops;
17struct gfs2_fh_obj {
18 struct gfs2_inum_host this;
19 __u32 imode;
20};
21
22#endif /* __OPS_EXPORT_DOT_H__ */
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index c682371717ff..0443e255173d 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -27,7 +27,6 @@
27#include "inode.h" 27#include "inode.h"
28#include "lm.h" 28#include "lm.h"
29#include "mount.h" 29#include "mount.h"
30#include "ops_export.h"
31#include "ops_fstype.h" 30#include "ops_fstype.h"
32#include "ops_super.h" 31#include "ops_super.h"
33#include "recovery.h" 32#include "recovery.h"
@@ -116,7 +115,6 @@ static void init_vfs(struct super_block *sb, unsigned noatime)
116 115
117static int init_names(struct gfs2_sbd *sdp, int silent) 116static int init_names(struct gfs2_sbd *sdp, int silent)
118{ 117{
119 struct page *page;
120 char *proto, *table; 118 char *proto, *table;
121 int error = 0; 119 int error = 0;
122 120
@@ -126,14 +124,9 @@ static int init_names(struct gfs2_sbd *sdp, int silent)
126 /* Try to autodetect */ 124 /* Try to autodetect */
127 125
128 if (!proto[0] || !table[0]) { 126 if (!proto[0] || !table[0]) {
129 struct gfs2_sb *sb; 127 error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift);
130 page = gfs2_read_super(sdp->sd_vfs, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift); 128 if (error)
131 if (!page) 129 return error;
132 return -ENOBUFS;
133 sb = kmap(page);
134 gfs2_sb_in(&sdp->sd_sb, sb);
135 kunmap(page);
136 __free_page(page);
137 130
138 error = gfs2_check_sb(sdp, &sdp->sd_sb, silent); 131 error = gfs2_check_sb(sdp, &sdp->sd_sb, silent);
139 if (error) 132 if (error)
diff --git a/fs/gfs2/ops_fstype.h b/fs/gfs2/ops_fstype.h
index 7cc2c296271b..407029b3b2b3 100644
--- a/fs/gfs2/ops_fstype.h
+++ b/fs/gfs2/ops_fstype.h
@@ -14,5 +14,6 @@
14 14
15extern struct file_system_type gfs2_fs_type; 15extern struct file_system_type gfs2_fs_type;
16extern struct file_system_type gfs2meta_fs_type; 16extern struct file_system_type gfs2meta_fs_type;
17extern struct export_operations gfs2_export_ops;
17 18
18#endif /* __OPS_FSTYPE_DOT_H__ */ 19#endif /* __OPS_FSTYPE_DOT_H__ */
diff --git a/fs/gfs2/ops_inode.c b/fs/gfs2/ops_inode.c
index f8ecfec4064b..919a661e4f79 100644
--- a/fs/gfs2/ops_inode.c
+++ b/fs/gfs2/ops_inode.c
@@ -206,7 +206,7 @@ static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
206 goto out_gunlock_q; 206 goto out_gunlock_q;
207 207
208 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres + 208 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
209 al->al_rgd->rd_ri.ri_length + 209 al->al_rgd->rd_length +
210 2 * RES_DINODE + RES_STATFS + 210 2 * RES_DINODE + RES_STATFS +
211 RES_QUOTA, 0); 211 RES_QUOTA, 0);
212 if (error) 212 if (error)
@@ -711,7 +711,7 @@ static int gfs2_rename(struct inode *odir, struct dentry *odentry,
711 goto out_gunlock_q; 711 goto out_gunlock_q;
712 712
713 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres + 713 error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
714 al->al_rgd->rd_ri.ri_length + 714 al->al_rgd->rd_length +
715 4 * RES_DINODE + 4 * RES_LEAF + 715 4 * RES_DINODE + 4 * RES_LEAF +
716 RES_STATFS + RES_QUOTA + 4, 0); 716 RES_STATFS + RES_QUOTA + 4, 0);
717 if (error) 717 if (error)
diff --git a/fs/gfs2/ops_vm.c b/fs/gfs2/ops_vm.c
index aa0dbd2aac1b..404b7cc9f8c4 100644
--- a/fs/gfs2/ops_vm.c
+++ b/fs/gfs2/ops_vm.c
@@ -66,7 +66,7 @@ static int alloc_page_backing(struct gfs2_inode *ip, struct page *page)
66 if (error) 66 if (error)
67 goto out_gunlock_q; 67 goto out_gunlock_q;
68 68
69 error = gfs2_trans_begin(sdp, al->al_rgd->rd_ri.ri_length + 69 error = gfs2_trans_begin(sdp, al->al_rgd->rd_length +
70 ind_blocks + RES_DINODE + 70 ind_blocks + RES_DINODE +
71 RES_STATFS + RES_QUOTA, 0); 71 RES_STATFS + RES_QUOTA, 0);
72 if (error) 72 if (error)
diff --git a/fs/gfs2/quota.c b/fs/gfs2/quota.c
index 8a58815dea08..6e546ee8f3d4 100644
--- a/fs/gfs2/quota.c
+++ b/fs/gfs2/quota.c
@@ -66,6 +66,18 @@
66#define QUOTA_USER 1 66#define QUOTA_USER 1
67#define QUOTA_GROUP 0 67#define QUOTA_GROUP 0
68 68
69struct gfs2_quota_host {
70 u64 qu_limit;
71 u64 qu_warn;
72 s64 qu_value;
73};
74
75struct gfs2_quota_change_host {
76 u64 qc_change;
77 u32 qc_flags; /* GFS2_QCF_... */
78 u32 qc_id;
79};
80
69static u64 qd2offset(struct gfs2_quota_data *qd) 81static u64 qd2offset(struct gfs2_quota_data *qd)
70{ 82{
71 u64 offset; 83 u64 offset;
@@ -561,6 +573,25 @@ static void do_qc(struct gfs2_quota_data *qd, s64 change)
561 mutex_unlock(&sdp->sd_quota_mutex); 573 mutex_unlock(&sdp->sd_quota_mutex);
562} 574}
563 575
576static void gfs2_quota_in(struct gfs2_quota_host *qu, const void *buf)
577{
578 const struct gfs2_quota *str = buf;
579
580 qu->qu_limit = be64_to_cpu(str->qu_limit);
581 qu->qu_warn = be64_to_cpu(str->qu_warn);
582 qu->qu_value = be64_to_cpu(str->qu_value);
583}
584
585static void gfs2_quota_out(const struct gfs2_quota_host *qu, void *buf)
586{
587 struct gfs2_quota *str = buf;
588
589 str->qu_limit = cpu_to_be64(qu->qu_limit);
590 str->qu_warn = cpu_to_be64(qu->qu_warn);
591 str->qu_value = cpu_to_be64(qu->qu_value);
592 memset(&str->qu_reserved, 0, sizeof(str->qu_reserved));
593}
594
564/** 595/**
565 * gfs2_adjust_quota 596 * gfs2_adjust_quota
566 * 597 *
@@ -694,7 +725,7 @@ static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda)
694 goto out_alloc; 725 goto out_alloc;
695 726
696 error = gfs2_trans_begin(sdp, 727 error = gfs2_trans_begin(sdp,
697 al->al_rgd->rd_ri.ri_length + 728 al->al_rgd->rd_length +
698 num_qd * data_blocks + 729 num_qd * data_blocks +
699 nalloc * ind_blocks + 730 nalloc * ind_blocks +
700 RES_DINODE + num_qd + 731 RES_DINODE + num_qd +
@@ -1055,6 +1086,15 @@ int gfs2_quota_refresh(struct gfs2_sbd *sdp, int user, u32 id)
1055 return error; 1086 return error;
1056} 1087}
1057 1088
1089static void gfs2_quota_change_in(struct gfs2_quota_change_host *qc, const void *buf)
1090{
1091 const struct gfs2_quota_change *str = buf;
1092
1093 qc->qc_change = be64_to_cpu(str->qc_change);
1094 qc->qc_flags = be32_to_cpu(str->qc_flags);
1095 qc->qc_id = be32_to_cpu(str->qc_id);
1096}
1097
1058int gfs2_quota_init(struct gfs2_sbd *sdp) 1098int gfs2_quota_init(struct gfs2_sbd *sdp)
1059{ 1099{
1060 struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode); 1100 struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);
diff --git a/fs/gfs2/recovery.c b/fs/gfs2/recovery.c
index 8bc182c7e2ef..5ada38c99a2c 100644
--- a/fs/gfs2/recovery.c
+++ b/fs/gfs2/recovery.c
@@ -116,6 +116,22 @@ void gfs2_revoke_clean(struct gfs2_sbd *sdp)
116 } 116 }
117} 117}
118 118
119static int gfs2_log_header_in(struct gfs2_log_header_host *lh, const void *buf)
120{
121 const struct gfs2_log_header *str = buf;
122
123 if (str->lh_header.mh_magic != cpu_to_be32(GFS2_MAGIC) ||
124 str->lh_header.mh_type != cpu_to_be32(GFS2_METATYPE_LH))
125 return 1;
126
127 lh->lh_sequence = be64_to_cpu(str->lh_sequence);
128 lh->lh_flags = be32_to_cpu(str->lh_flags);
129 lh->lh_tail = be32_to_cpu(str->lh_tail);
130 lh->lh_blkno = be32_to_cpu(str->lh_blkno);
131 lh->lh_hash = be32_to_cpu(str->lh_hash);
132 return 0;
133}
134
119/** 135/**
120 * get_log_header - read the log header for a given segment 136 * get_log_header - read the log header for a given segment
121 * @jd: the journal 137 * @jd: the journal
@@ -147,12 +163,10 @@ static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk,
147 sizeof(u32)); 163 sizeof(u32));
148 hash = crc32_le(hash, (unsigned char const *)&nothing, sizeof(nothing)); 164 hash = crc32_le(hash, (unsigned char const *)&nothing, sizeof(nothing));
149 hash ^= (u32)~0; 165 hash ^= (u32)~0;
150 gfs2_log_header_in(&lh, bh->b_data); 166 error = gfs2_log_header_in(&lh, bh->b_data);
151 brelse(bh); 167 brelse(bh);
152 168
153 if (lh.lh_header.mh_magic != GFS2_MAGIC || 169 if (error || lh.lh_blkno != blk || lh.lh_hash != hash)
154 lh.lh_header.mh_type != GFS2_METATYPE_LH ||
155 lh.lh_blkno != blk || lh.lh_hash != hash)
156 return 1; 170 return 1;
157 171
158 *head = lh; 172 *head = lh;
diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c
index 30eb428065c5..027f6ec5b0d9 100644
--- a/fs/gfs2/rgrp.c
+++ b/fs/gfs2/rgrp.c
@@ -204,7 +204,7 @@ void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd)
204{ 204{
205 struct gfs2_sbd *sdp = rgd->rd_sbd; 205 struct gfs2_sbd *sdp = rgd->rd_sbd;
206 struct gfs2_bitmap *bi = NULL; 206 struct gfs2_bitmap *bi = NULL;
207 u32 length = rgd->rd_ri.ri_length; 207 u32 length = rgd->rd_length;
208 u32 count[4], tmp; 208 u32 count[4], tmp;
209 int buf, x; 209 int buf, x;
210 210
@@ -227,7 +227,7 @@ void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd)
227 return; 227 return;
228 } 228 }
229 229
230 tmp = rgd->rd_ri.ri_data - 230 tmp = rgd->rd_data -
231 rgd->rd_rg.rg_free - 231 rgd->rd_rg.rg_free -
232 rgd->rd_rg.rg_dinodes; 232 rgd->rd_rg.rg_dinodes;
233 if (count[1] + count[2] != tmp) { 233 if (count[1] + count[2] != tmp) {
@@ -253,10 +253,10 @@ void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd)
253 253
254} 254}
255 255
256static inline int rgrp_contains_block(struct gfs2_rindex_host *ri, u64 block) 256static inline int rgrp_contains_block(struct gfs2_rgrpd *rgd, u64 block)
257{ 257{
258 u64 first = ri->ri_data0; 258 u64 first = rgd->rd_data0;
259 u64 last = first + ri->ri_data; 259 u64 last = first + rgd->rd_data;
260 return first <= block && block < last; 260 return first <= block && block < last;
261} 261}
262 262
@@ -275,7 +275,7 @@ struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk)
275 spin_lock(&sdp->sd_rindex_spin); 275 spin_lock(&sdp->sd_rindex_spin);
276 276
277 list_for_each_entry(rgd, &sdp->sd_rindex_mru_list, rd_list_mru) { 277 list_for_each_entry(rgd, &sdp->sd_rindex_mru_list, rd_list_mru) {
278 if (rgrp_contains_block(&rgd->rd_ri, blk)) { 278 if (rgrp_contains_block(rgd, blk)) {
279 list_move(&rgd->rd_list_mru, &sdp->sd_rindex_mru_list); 279 list_move(&rgd->rd_list_mru, &sdp->sd_rindex_mru_list);
280 spin_unlock(&sdp->sd_rindex_spin); 280 spin_unlock(&sdp->sd_rindex_spin);
281 return rgd; 281 return rgd;
@@ -354,6 +354,15 @@ void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
354 mutex_unlock(&sdp->sd_rindex_mutex); 354 mutex_unlock(&sdp->sd_rindex_mutex);
355} 355}
356 356
357static void gfs2_rindex_print(const struct gfs2_rgrpd *rgd)
358{
359 printk(KERN_INFO " ri_addr = %llu\n", (unsigned long long)rgd->rd_addr);
360 printk(KERN_INFO " ri_length = %u\n", rgd->rd_length);
361 printk(KERN_INFO " ri_data0 = %llu\n", (unsigned long long)rgd->rd_data0);
362 printk(KERN_INFO " ri_data = %u\n", rgd->rd_data);
363 printk(KERN_INFO " ri_bitbytes = %u\n", rgd->rd_bitbytes);
364}
365
357/** 366/**
358 * gfs2_compute_bitstructs - Compute the bitmap sizes 367 * gfs2_compute_bitstructs - Compute the bitmap sizes
359 * @rgd: The resource group descriptor 368 * @rgd: The resource group descriptor
@@ -367,7 +376,7 @@ static int compute_bitstructs(struct gfs2_rgrpd *rgd)
367{ 376{
368 struct gfs2_sbd *sdp = rgd->rd_sbd; 377 struct gfs2_sbd *sdp = rgd->rd_sbd;
369 struct gfs2_bitmap *bi; 378 struct gfs2_bitmap *bi;
370 u32 length = rgd->rd_ri.ri_length; /* # blocks in hdr & bitmap */ 379 u32 length = rgd->rd_length; /* # blocks in hdr & bitmap */
371 u32 bytes_left, bytes; 380 u32 bytes_left, bytes;
372 int x; 381 int x;
373 382
@@ -378,7 +387,7 @@ static int compute_bitstructs(struct gfs2_rgrpd *rgd)
378 if (!rgd->rd_bits) 387 if (!rgd->rd_bits)
379 return -ENOMEM; 388 return -ENOMEM;
380 389
381 bytes_left = rgd->rd_ri.ri_bitbytes; 390 bytes_left = rgd->rd_bitbytes;
382 391
383 for (x = 0; x < length; x++) { 392 for (x = 0; x < length; x++) {
384 bi = rgd->rd_bits + x; 393 bi = rgd->rd_bits + x;
@@ -399,14 +408,14 @@ static int compute_bitstructs(struct gfs2_rgrpd *rgd)
399 } else if (x + 1 == length) { 408 } else if (x + 1 == length) {
400 bytes = bytes_left; 409 bytes = bytes_left;
401 bi->bi_offset = sizeof(struct gfs2_meta_header); 410 bi->bi_offset = sizeof(struct gfs2_meta_header);
402 bi->bi_start = rgd->rd_ri.ri_bitbytes - bytes_left; 411 bi->bi_start = rgd->rd_bitbytes - bytes_left;
403 bi->bi_len = bytes; 412 bi->bi_len = bytes;
404 /* other blocks */ 413 /* other blocks */
405 } else { 414 } else {
406 bytes = sdp->sd_sb.sb_bsize - 415 bytes = sdp->sd_sb.sb_bsize -
407 sizeof(struct gfs2_meta_header); 416 sizeof(struct gfs2_meta_header);
408 bi->bi_offset = sizeof(struct gfs2_meta_header); 417 bi->bi_offset = sizeof(struct gfs2_meta_header);
409 bi->bi_start = rgd->rd_ri.ri_bitbytes - bytes_left; 418 bi->bi_start = rgd->rd_bitbytes - bytes_left;
410 bi->bi_len = bytes; 419 bi->bi_len = bytes;
411 } 420 }
412 421
@@ -418,9 +427,9 @@ static int compute_bitstructs(struct gfs2_rgrpd *rgd)
418 return -EIO; 427 return -EIO;
419 } 428 }
420 bi = rgd->rd_bits + (length - 1); 429 bi = rgd->rd_bits + (length - 1);
421 if ((bi->bi_start + bi->bi_len) * GFS2_NBBY != rgd->rd_ri.ri_data) { 430 if ((bi->bi_start + bi->bi_len) * GFS2_NBBY != rgd->rd_data) {
422 if (gfs2_consist_rgrpd(rgd)) { 431 if (gfs2_consist_rgrpd(rgd)) {
423 gfs2_rindex_print(&rgd->rd_ri); 432 gfs2_rindex_print(rgd);
424 fs_err(sdp, "start=%u len=%u offset=%u\n", 433 fs_err(sdp, "start=%u len=%u offset=%u\n",
425 bi->bi_start, bi->bi_len, bi->bi_offset); 434 bi->bi_start, bi->bi_len, bi->bi_offset);
426 } 435 }
@@ -431,6 +440,7 @@ static int compute_bitstructs(struct gfs2_rgrpd *rgd)
431} 440}
432 441
433/** 442/**
443
434 * gfs2_ri_total - Total up the file system space, according to the rindex. 444 * gfs2_ri_total - Total up the file system space, according to the rindex.
435 * 445 *
436 */ 446 */
@@ -439,7 +449,6 @@ u64 gfs2_ri_total(struct gfs2_sbd *sdp)
439 u64 total_data = 0; 449 u64 total_data = 0;
440 struct inode *inode = sdp->sd_rindex; 450 struct inode *inode = sdp->sd_rindex;
441 struct gfs2_inode *ip = GFS2_I(inode); 451 struct gfs2_inode *ip = GFS2_I(inode);
442 struct gfs2_rindex_host ri;
443 char buf[sizeof(struct gfs2_rindex)]; 452 char buf[sizeof(struct gfs2_rindex)];
444 struct file_ra_state ra_state; 453 struct file_ra_state ra_state;
445 int error, rgrps; 454 int error, rgrps;
@@ -455,13 +464,23 @@ u64 gfs2_ri_total(struct gfs2_sbd *sdp)
455 sizeof(struct gfs2_rindex)); 464 sizeof(struct gfs2_rindex));
456 if (error != sizeof(struct gfs2_rindex)) 465 if (error != sizeof(struct gfs2_rindex))
457 break; 466 break;
458 gfs2_rindex_in(&ri, buf); 467 total_data += be32_to_cpu(((struct gfs2_rindex *)buf)->ri_data);
459 total_data += ri.ri_data;
460 } 468 }
461 mutex_unlock(&sdp->sd_rindex_mutex); 469 mutex_unlock(&sdp->sd_rindex_mutex);
462 return total_data; 470 return total_data;
463} 471}
464 472
473static void gfs2_rindex_in(struct gfs2_rgrpd *rgd, const void *buf)
474{
475 const struct gfs2_rindex *str = buf;
476
477 rgd->rd_addr = be64_to_cpu(str->ri_addr);
478 rgd->rd_length = be32_to_cpu(str->ri_length);
479 rgd->rd_data0 = be64_to_cpu(str->ri_data0);
480 rgd->rd_data = be32_to_cpu(str->ri_data);
481 rgd->rd_bitbytes = be32_to_cpu(str->ri_bitbytes);
482}
483
465/** 484/**
466 * read_rindex_entry - Pull in a new resource index entry from the disk 485 * read_rindex_entry - Pull in a new resource index entry from the disk
467 * @gl: The glock covering the rindex inode 486 * @gl: The glock covering the rindex inode
@@ -500,12 +519,12 @@ static int read_rindex_entry(struct gfs2_inode *ip,
500 list_add_tail(&rgd->rd_list, &sdp->sd_rindex_list); 519 list_add_tail(&rgd->rd_list, &sdp->sd_rindex_list);
501 list_add_tail(&rgd->rd_list_mru, &sdp->sd_rindex_mru_list); 520 list_add_tail(&rgd->rd_list_mru, &sdp->sd_rindex_mru_list);
502 521
503 gfs2_rindex_in(&rgd->rd_ri, buf); 522 gfs2_rindex_in(rgd, buf);
504 error = compute_bitstructs(rgd); 523 error = compute_bitstructs(rgd);
505 if (error) 524 if (error)
506 return error; 525 return error;
507 526
508 error = gfs2_glock_get(sdp, rgd->rd_ri.ri_addr, 527 error = gfs2_glock_get(sdp, rgd->rd_addr,
509 &gfs2_rgrp_glops, CREATE, &rgd->rd_gl); 528 &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
510 if (error) 529 if (error)
511 return error; 530 return error;
@@ -626,6 +645,28 @@ int gfs2_rindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ri_gh)
626 return error; 645 return error;
627} 646}
628 647
648static void gfs2_rgrp_in(struct gfs2_rgrp_host *rg, const void *buf)
649{
650 const struct gfs2_rgrp *str = buf;
651
652 rg->rg_flags = be32_to_cpu(str->rg_flags);
653 rg->rg_free = be32_to_cpu(str->rg_free);
654 rg->rg_dinodes = be32_to_cpu(str->rg_dinodes);
655 rg->rg_igeneration = be64_to_cpu(str->rg_igeneration);
656}
657
658static void gfs2_rgrp_out(const struct gfs2_rgrp_host *rg, void *buf)
659{
660 struct gfs2_rgrp *str = buf;
661
662 str->rg_flags = cpu_to_be32(rg->rg_flags);
663 str->rg_free = cpu_to_be32(rg->rg_free);
664 str->rg_dinodes = cpu_to_be32(rg->rg_dinodes);
665 str->__pad = cpu_to_be32(0);
666 str->rg_igeneration = cpu_to_be64(rg->rg_igeneration);
667 memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
668}
669
629/** 670/**
630 * gfs2_rgrp_bh_get - Read in a RG's header and bitmaps 671 * gfs2_rgrp_bh_get - Read in a RG's header and bitmaps
631 * @rgd: the struct gfs2_rgrpd describing the RG to read in 672 * @rgd: the struct gfs2_rgrpd describing the RG to read in
@@ -640,7 +681,7 @@ int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
640{ 681{
641 struct gfs2_sbd *sdp = rgd->rd_sbd; 682 struct gfs2_sbd *sdp = rgd->rd_sbd;
642 struct gfs2_glock *gl = rgd->rd_gl; 683 struct gfs2_glock *gl = rgd->rd_gl;
643 unsigned int length = rgd->rd_ri.ri_length; 684 unsigned int length = rgd->rd_length;
644 struct gfs2_bitmap *bi; 685 struct gfs2_bitmap *bi;
645 unsigned int x, y; 686 unsigned int x, y;
646 int error; 687 int error;
@@ -658,7 +699,7 @@ int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
658 699
659 for (x = 0; x < length; x++) { 700 for (x = 0; x < length; x++) {
660 bi = rgd->rd_bits + x; 701 bi = rgd->rd_bits + x;
661 error = gfs2_meta_read(gl, rgd->rd_ri.ri_addr + x, 0, &bi->bi_bh); 702 error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, &bi->bi_bh);
662 if (error) 703 if (error)
663 goto fail; 704 goto fail;
664 } 705 }
@@ -720,7 +761,7 @@ void gfs2_rgrp_bh_hold(struct gfs2_rgrpd *rgd)
720void gfs2_rgrp_bh_put(struct gfs2_rgrpd *rgd) 761void gfs2_rgrp_bh_put(struct gfs2_rgrpd *rgd)
721{ 762{
722 struct gfs2_sbd *sdp = rgd->rd_sbd; 763 struct gfs2_sbd *sdp = rgd->rd_sbd;
723 int x, length = rgd->rd_ri.ri_length; 764 int x, length = rgd->rd_length;
724 765
725 spin_lock(&sdp->sd_rindex_spin); 766 spin_lock(&sdp->sd_rindex_spin);
726 gfs2_assert_warn(rgd->rd_sbd, rgd->rd_bh_count); 767 gfs2_assert_warn(rgd->rd_sbd, rgd->rd_bh_count);
@@ -743,7 +784,7 @@ void gfs2_rgrp_bh_put(struct gfs2_rgrpd *rgd)
743void gfs2_rgrp_repolish_clones(struct gfs2_rgrpd *rgd) 784void gfs2_rgrp_repolish_clones(struct gfs2_rgrpd *rgd)
744{ 785{
745 struct gfs2_sbd *sdp = rgd->rd_sbd; 786 struct gfs2_sbd *sdp = rgd->rd_sbd;
746 unsigned int length = rgd->rd_ri.ri_length; 787 unsigned int length = rgd->rd_length;
747 unsigned int x; 788 unsigned int x;
748 789
749 for (x = 0; x < length; x++) { 790 for (x = 0; x < length; x++) {
@@ -826,7 +867,7 @@ static struct gfs2_rgrpd *recent_rgrp_first(struct gfs2_sbd *sdp,
826 goto first; 867 goto first;
827 868
828 list_for_each_entry(rgd, &sdp->sd_rindex_recent_list, rd_recent) { 869 list_for_each_entry(rgd, &sdp->sd_rindex_recent_list, rd_recent) {
829 if (rgd->rd_ri.ri_addr == rglast) 870 if (rgd->rd_addr == rglast)
830 goto out; 871 goto out;
831 } 872 }
832 873
@@ -1037,7 +1078,7 @@ static int get_local_rgrp(struct gfs2_inode *ip)
1037 } 1078 }
1038 1079
1039out: 1080out:
1040 ip->i_last_rg_alloc = rgd->rd_ri.ri_addr; 1081 ip->i_last_rg_alloc = rgd->rd_addr;
1041 1082
1042 if (begin) { 1083 if (begin) {
1043 recent_rgrp_add(rgd); 1084 recent_rgrp_add(rgd);
@@ -1128,8 +1169,8 @@ unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block)
1128 unsigned int buf; 1169 unsigned int buf;
1129 unsigned char type; 1170 unsigned char type;
1130 1171
1131 length = rgd->rd_ri.ri_length; 1172 length = rgd->rd_length;
1132 rgrp_block = block - rgd->rd_ri.ri_data0; 1173 rgrp_block = block - rgd->rd_data0;
1133 1174
1134 for (buf = 0; buf < length; buf++) { 1175 for (buf = 0; buf < length; buf++) {
1135 bi = rgd->rd_bits + buf; 1176 bi = rgd->rd_bits + buf;
@@ -1171,7 +1212,7 @@ static u32 rgblk_search(struct gfs2_rgrpd *rgd, u32 goal,
1171 unsigned char old_state, unsigned char new_state) 1212 unsigned char old_state, unsigned char new_state)
1172{ 1213{
1173 struct gfs2_bitmap *bi = NULL; 1214 struct gfs2_bitmap *bi = NULL;
1174 u32 length = rgd->rd_ri.ri_length; 1215 u32 length = rgd->rd_length;
1175 u32 blk = 0; 1216 u32 blk = 0;
1176 unsigned int buf, x; 1217 unsigned int buf, x;
1177 1218
@@ -1247,9 +1288,9 @@ static struct gfs2_rgrpd *rgblk_free(struct gfs2_sbd *sdp, u64 bstart,
1247 return NULL; 1288 return NULL;
1248 } 1289 }
1249 1290
1250 length = rgd->rd_ri.ri_length; 1291 length = rgd->rd_length;
1251 1292
1252 rgrp_blk = bstart - rgd->rd_ri.ri_data0; 1293 rgrp_blk = bstart - rgd->rd_data0;
1253 1294
1254 while (blen--) { 1295 while (blen--) {
1255 for (buf = 0; buf < length; buf++) { 1296 for (buf = 0; buf < length; buf++) {
@@ -1293,15 +1334,15 @@ u64 gfs2_alloc_data(struct gfs2_inode *ip)
1293 u32 goal, blk; 1334 u32 goal, blk;
1294 u64 block; 1335 u64 block;
1295 1336
1296 if (rgrp_contains_block(&rgd->rd_ri, ip->i_di.di_goal_data)) 1337 if (rgrp_contains_block(rgd, ip->i_di.di_goal_data))
1297 goal = ip->i_di.di_goal_data - rgd->rd_ri.ri_data0; 1338 goal = ip->i_di.di_goal_data - rgd->rd_data0;
1298 else 1339 else
1299 goal = rgd->rd_last_alloc_data; 1340 goal = rgd->rd_last_alloc_data;
1300 1341
1301 blk = rgblk_search(rgd, goal, GFS2_BLKST_FREE, GFS2_BLKST_USED); 1342 blk = rgblk_search(rgd, goal, GFS2_BLKST_FREE, GFS2_BLKST_USED);
1302 rgd->rd_last_alloc_data = blk; 1343 rgd->rd_last_alloc_data = blk;
1303 1344
1304 block = rgd->rd_ri.ri_data0 + blk; 1345 block = rgd->rd_data0 + blk;
1305 ip->i_di.di_goal_data = block; 1346 ip->i_di.di_goal_data = block;
1306 1347
1307 gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free); 1348 gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free);
@@ -1337,15 +1378,15 @@ u64 gfs2_alloc_meta(struct gfs2_inode *ip)
1337 u32 goal, blk; 1378 u32 goal, blk;
1338 u64 block; 1379 u64 block;
1339 1380
1340 if (rgrp_contains_block(&rgd->rd_ri, ip->i_di.di_goal_meta)) 1381 if (rgrp_contains_block(rgd, ip->i_di.di_goal_meta))
1341 goal = ip->i_di.di_goal_meta - rgd->rd_ri.ri_data0; 1382 goal = ip->i_di.di_goal_meta - rgd->rd_data0;
1342 else 1383 else
1343 goal = rgd->rd_last_alloc_meta; 1384 goal = rgd->rd_last_alloc_meta;
1344 1385
1345 blk = rgblk_search(rgd, goal, GFS2_BLKST_FREE, GFS2_BLKST_USED); 1386 blk = rgblk_search(rgd, goal, GFS2_BLKST_FREE, GFS2_BLKST_USED);
1346 rgd->rd_last_alloc_meta = blk; 1387 rgd->rd_last_alloc_meta = blk;
1347 1388
1348 block = rgd->rd_ri.ri_data0 + blk; 1389 block = rgd->rd_data0 + blk;
1349 ip->i_di.di_goal_meta = block; 1390 ip->i_di.di_goal_meta = block;
1350 1391
1351 gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free); 1392 gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free);
@@ -1387,7 +1428,7 @@ u64 gfs2_alloc_di(struct gfs2_inode *dip, u64 *generation)
1387 1428
1388 rgd->rd_last_alloc_meta = blk; 1429 rgd->rd_last_alloc_meta = blk;
1389 1430
1390 block = rgd->rd_ri.ri_data0 + blk; 1431 block = rgd->rd_data0 + blk;
1391 1432
1392 gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free); 1433 gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free);
1393 rgd->rd_rg.rg_free--; 1434 rgd->rd_rg.rg_free--;
diff --git a/fs/gfs2/super.c b/fs/gfs2/super.c
index faccffd19907..f916b9740c75 100644
--- a/fs/gfs2/super.c
+++ b/fs/gfs2/super.c
@@ -95,8 +95,8 @@ int gfs2_check_sb(struct gfs2_sbd *sdp, struct gfs2_sb_host *sb, int silent)
95{ 95{
96 unsigned int x; 96 unsigned int x;
97 97
98 if (sb->sb_header.mh_magic != GFS2_MAGIC || 98 if (sb->sb_magic != GFS2_MAGIC ||
99 sb->sb_header.mh_type != GFS2_METATYPE_SB) { 99 sb->sb_type != GFS2_METATYPE_SB) {
100 if (!silent) 100 if (!silent)
101 printk(KERN_WARNING "GFS2: not a GFS2 filesystem\n"); 101 printk(KERN_WARNING "GFS2: not a GFS2 filesystem\n");
102 return -EINVAL; 102 return -EINVAL;
@@ -174,10 +174,31 @@ static int end_bio_io_page(struct bio *bio, unsigned int bytes_done, int error)
174 return 0; 174 return 0;
175} 175}
176 176
177static void gfs2_sb_in(struct gfs2_sb_host *sb, const void *buf)
178{
179 const struct gfs2_sb *str = buf;
180
181 sb->sb_magic = be32_to_cpu(str->sb_header.mh_magic);
182 sb->sb_type = be32_to_cpu(str->sb_header.mh_type);
183 sb->sb_format = be32_to_cpu(str->sb_header.mh_format);
184 sb->sb_fs_format = be32_to_cpu(str->sb_fs_format);
185 sb->sb_multihost_format = be32_to_cpu(str->sb_multihost_format);
186 sb->sb_bsize = be32_to_cpu(str->sb_bsize);
187 sb->sb_bsize_shift = be32_to_cpu(str->sb_bsize_shift);
188 sb->sb_master_dir.no_addr = be64_to_cpu(str->sb_master_dir.no_addr);
189 sb->sb_master_dir.no_formal_ino = be64_to_cpu(str->sb_master_dir.no_formal_ino);
190 sb->sb_root_dir.no_addr = be64_to_cpu(str->sb_root_dir.no_addr);
191 sb->sb_root_dir.no_formal_ino = be64_to_cpu(str->sb_root_dir.no_formal_ino);
192
193 memcpy(sb->sb_lockproto, str->sb_lockproto, GFS2_LOCKNAME_LEN);
194 memcpy(sb->sb_locktable, str->sb_locktable, GFS2_LOCKNAME_LEN);
195}
196
177/** 197/**
178 * gfs2_read_super - Read the gfs2 super block from disk 198 * gfs2_read_super - Read the gfs2 super block from disk
179 * @sb: The VFS super block 199 * @sdp: The GFS2 super block
180 * @sector: The location of the super block 200 * @sector: The location of the super block
201 * @error: The error code to return
181 * 202 *
182 * This uses the bio functions to read the super block from disk 203 * This uses the bio functions to read the super block from disk
183 * because we want to be 100% sure that we never read cached data. 204 * because we want to be 100% sure that we never read cached data.
@@ -189,17 +210,19 @@ static int end_bio_io_page(struct bio *bio, unsigned int bytes_done, int error)
189 * the master directory (contains pointers to journals etc) and the 210 * the master directory (contains pointers to journals etc) and the
190 * root directory. 211 * root directory.
191 * 212 *
192 * Returns: A page containing the sb or NULL 213 * Returns: 0 on success or error
193 */ 214 */
194 215
195struct page *gfs2_read_super(struct super_block *sb, sector_t sector) 216int gfs2_read_super(struct gfs2_sbd *sdp, sector_t sector)
196{ 217{
218 struct super_block *sb = sdp->sd_vfs;
219 struct gfs2_sb *p;
197 struct page *page; 220 struct page *page;
198 struct bio *bio; 221 struct bio *bio;
199 222
200 page = alloc_page(GFP_KERNEL); 223 page = alloc_page(GFP_KERNEL);
201 if (unlikely(!page)) 224 if (unlikely(!page))
202 return NULL; 225 return -ENOBUFS;
203 226
204 ClearPageUptodate(page); 227 ClearPageUptodate(page);
205 ClearPageDirty(page); 228 ClearPageDirty(page);
@@ -208,7 +231,7 @@ struct page *gfs2_read_super(struct super_block *sb, sector_t sector)
208 bio = bio_alloc(GFP_KERNEL, 1); 231 bio = bio_alloc(GFP_KERNEL, 1);
209 if (unlikely(!bio)) { 232 if (unlikely(!bio)) {
210 __free_page(page); 233 __free_page(page);
211 return NULL; 234 return -ENOBUFS;
212 } 235 }
213 236
214 bio->bi_sector = sector * (sb->s_blocksize >> 9); 237 bio->bi_sector = sector * (sb->s_blocksize >> 9);
@@ -222,9 +245,13 @@ struct page *gfs2_read_super(struct super_block *sb, sector_t sector)
222 bio_put(bio); 245 bio_put(bio);
223 if (!PageUptodate(page)) { 246 if (!PageUptodate(page)) {
224 __free_page(page); 247 __free_page(page);
225 return NULL; 248 return -EIO;
226 } 249 }
227 return page; 250 p = kmap(page);
251 gfs2_sb_in(&sdp->sd_sb, p);
252 kunmap(page);
253 __free_page(page);
254 return 0;
228} 255}
229 256
230/** 257/**
@@ -241,19 +268,13 @@ int gfs2_read_sb(struct gfs2_sbd *sdp, struct gfs2_glock *gl, int silent)
241 u32 tmp_blocks; 268 u32 tmp_blocks;
242 unsigned int x; 269 unsigned int x;
243 int error; 270 int error;
244 struct page *page;
245 char *sb;
246 271
247 page = gfs2_read_super(sdp->sd_vfs, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift); 272 error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift);
248 if (!page) { 273 if (error) {
249 if (!silent) 274 if (!silent)
250 fs_err(sdp, "can't read superblock\n"); 275 fs_err(sdp, "can't read superblock\n");
251 return -EIO; 276 return error;
252 } 277 }
253 sb = kmap(page);
254 gfs2_sb_in(&sdp->sd_sb, sb);
255 kunmap(page);
256 __free_page(page);
257 278
258 error = gfs2_check_sb(sdp, &sdp->sd_sb, silent); 279 error = gfs2_check_sb(sdp, &sdp->sd_sb, silent);
259 if (error) 280 if (error)
@@ -593,6 +614,24 @@ int gfs2_make_fs_ro(struct gfs2_sbd *sdp)
593 return error; 614 return error;
594} 615}
595 616
617static void gfs2_statfs_change_in(struct gfs2_statfs_change_host *sc, const void *buf)
618{
619 const struct gfs2_statfs_change *str = buf;
620
621 sc->sc_total = be64_to_cpu(str->sc_total);
622 sc->sc_free = be64_to_cpu(str->sc_free);
623 sc->sc_dinodes = be64_to_cpu(str->sc_dinodes);
624}
625
626static void gfs2_statfs_change_out(const struct gfs2_statfs_change_host *sc, void *buf)
627{
628 struct gfs2_statfs_change *str = buf;
629
630 str->sc_total = cpu_to_be64(sc->sc_total);
631 str->sc_free = cpu_to_be64(sc->sc_free);
632 str->sc_dinodes = cpu_to_be64(sc->sc_dinodes);
633}
634
596int gfs2_statfs_init(struct gfs2_sbd *sdp) 635int gfs2_statfs_init(struct gfs2_sbd *sdp)
597{ 636{
598 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode); 637 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
@@ -772,7 +811,7 @@ static int statfs_slow_fill(struct gfs2_rgrpd *rgd,
772 struct gfs2_statfs_change_host *sc) 811 struct gfs2_statfs_change_host *sc)
773{ 812{
774 gfs2_rgrp_verify(rgd); 813 gfs2_rgrp_verify(rgd);
775 sc->sc_total += rgd->rd_ri.ri_data; 814 sc->sc_total += rgd->rd_data;
776 sc->sc_free += rgd->rd_rg.rg_free; 815 sc->sc_free += rgd->rd_rg.rg_free;
777 sc->sc_dinodes += rgd->rd_rg.rg_dinodes; 816 sc->sc_dinodes += rgd->rd_rg.rg_dinodes;
778 return 0; 817 return 0;
diff --git a/fs/gfs2/super.h b/fs/gfs2/super.h
index e590b2df11dc..60a870e430be 100644
--- a/fs/gfs2/super.h
+++ b/fs/gfs2/super.h
@@ -16,7 +16,7 @@ void gfs2_tune_init(struct gfs2_tune *gt);
16 16
17int gfs2_check_sb(struct gfs2_sbd *sdp, struct gfs2_sb_host *sb, int silent); 17int gfs2_check_sb(struct gfs2_sbd *sdp, struct gfs2_sb_host *sb, int silent);
18int gfs2_read_sb(struct gfs2_sbd *sdp, struct gfs2_glock *gl, int silent); 18int gfs2_read_sb(struct gfs2_sbd *sdp, struct gfs2_glock *gl, int silent);
19struct page *gfs2_read_super(struct super_block *sb, sector_t sector); 19int gfs2_read_super(struct gfs2_sbd *sdp, sector_t sector);
20 20
21static inline unsigned int gfs2_jindex_size(struct gfs2_sbd *sdp) 21static inline unsigned int gfs2_jindex_size(struct gfs2_sbd *sdp)
22{ 22{
diff --git a/fs/gfs2/util.c b/fs/gfs2/util.c
index 3f5edc54e80a..424a0774eda8 100644
--- a/fs/gfs2/util.c
+++ b/fs/gfs2/util.c
@@ -137,7 +137,7 @@ int gfs2_consist_rgrpd_i(struct gfs2_rgrpd *rgd, int cluster_wide,
137 "GFS2: fsid=%s: RG = %llu\n" 137 "GFS2: fsid=%s: RG = %llu\n"
138 "GFS2: fsid=%s: function = %s, file = %s, line = %u\n", 138 "GFS2: fsid=%s: function = %s, file = %s, line = %u\n",
139 sdp->sd_fsname, 139 sdp->sd_fsname,
140 sdp->sd_fsname, (unsigned long long)rgd->rd_ri.ri_addr, 140 sdp->sd_fsname, (unsigned long long)rgd->rd_addr,
141 sdp->sd_fsname, function, file, line); 141 sdp->sd_fsname, function, file, line);
142 return rv; 142 return rv;
143} 143}
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-24 00:39:05 -0500