Commit ef38ff9d authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-2.6-nmw 

* git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-2.6-nmw: (49 commits)
  [GFS2] fix assertion in log_refund()
  [GFS2] fix GFP_KERNEL misuses
  [GFS2] test for IS_ERR rather than 0
  [GFS2] Invalidate cache at correct point
  [GFS2] fs/gfs2/recovery.c: suppress warnings
  [GFS2] Faster gfs2_bitfit algorithm
  [GFS2] Streamline quota lock/check for no-quota case
  [GFS2] Remove drop of module ref where not needed
  [GFS2] gfs2_adjust_quota has broken unstuffing code
  [GFS2] possible null pointer dereference fixup
  [GFS2] Need to ensure that sector_t is 64bits for GFS2
  [GFS2] re-support special inode
  [GFS2] remove gfs2_dev_iops
  [GFS2] fix file_system_type leak on gfs2meta mount
  [GFS2] Allow bmap to allocate extents
  [GFS2] Fix a page lock / glock deadlock
  [GFS2] proper extern for gfs2/locking/dlm/mount.c:gdlm_ops
  [GFS2] gfs2/ops_file.c should #include "ops_inode.h"
  [GFS2] be*_add_cpu conversion
  [GFS2] Fix bug where we called drop_bh incorrectly
  ...
parents fda31d7d 62be1f71

fs/gfs2/Kconfig

+1 −1
Original line number Diff line number Diff line 
config GFS2_FS

	tristate "GFS2 file system support"

	depends on EXPERIMENTAL

	depends on EXPERIMENTAL && (64BIT || (LSF && LBD))

	select FS_POSIX_ACL

	select CRC32

	help

fs/gfs2/Makefile

+1 −1
Original line number Diff line number Diff line 
obj-$(CONFIG_GFS2_FS) += gfs2.o

gfs2-y := acl.o bmap.o daemon.o dir.o eaops.o eattr.o glock.o \

	glops.o inode.o lm.o log.o lops.o locking.o main.o meta_io.o \

	glops.o inode.o log.o lops.o locking.o main.o meta_io.o \

	mount.o ops_address.o ops_dentry.o ops_export.o ops_file.o \

	ops_fstype.o ops_inode.o ops_super.o quota.o \

	recovery.o rgrp.o super.o sys.o trans.o util.o

fs/gfs2/acl.c

+3 −3
Original line number Diff line number Diff line
@@ -116,7 +116,7 @@ static int acl_get(struct gfs2_inode *ip, int access, struct posix_acl **acl, 
		goto out;



	er.er_data_len = GFS2_EA_DATA_LEN(el->el_ea);

	er.er_data = kmalloc(er.er_data_len, GFP_KERNEL);

	er.er_data = kmalloc(er.er_data_len, GFP_NOFS);

	error = -ENOMEM;

	if (!er.er_data)

		goto out;
@@ -222,7 +222,7 @@ int gfs2_acl_create(struct gfs2_inode *dip, struct gfs2_inode *ip) 
		return error;

	}



	clone = posix_acl_clone(acl, GFP_KERNEL);

	clone = posix_acl_clone(acl, GFP_NOFS);

	error = -ENOMEM;

	if (!clone)

		goto out;
@@ -272,7 +272,7 @@ int gfs2_acl_chmod(struct gfs2_inode *ip, struct iattr *attr) 
	if (!acl)

		return gfs2_setattr_simple(ip, attr);



	clone = posix_acl_clone(acl, GFP_KERNEL);

	clone = posix_acl_clone(acl, GFP_NOFS);

	error = -ENOMEM;

	if (!clone)

		goto out;

fs/gfs2/bmap.c

+375 −295

File changed.

Preview size limit exceeded, changes collapsed.

fs/gfs2/dir.c

+41 −43
Original line number Diff line number Diff line
@@ -159,6 +159,7 @@ static int gfs2_dir_write_data(struct gfs2_inode *ip, const char *buf, 
	unsigned int o;

	int copied = 0;

	int error = 0;

	int new = 0;



	if (!size)

		return 0;
@@ -183,7 +184,6 @@ static int gfs2_dir_write_data(struct gfs2_inode *ip, const char *buf, 
	while (copied < size) {

		unsigned int amount;

		struct buffer_head *bh;

		int new = 0;



		amount = size - copied;

		if (amount > sdp->sd_sb.sb_bsize - o)
@@ -757,7 +757,7 @@ static struct gfs2_dirent *gfs2_dirent_search(struct inode *inode, 


	if (ip->i_di.di_flags & GFS2_DIF_EXHASH) {

		struct gfs2_leaf *leaf;

		unsigned hsize = 1 << ip->i_di.di_depth;

		unsigned hsize = 1 << ip->i_depth;

		unsigned index;

		u64 ln;

		if (hsize * sizeof(u64) != ip->i_di.di_size) {
@@ -765,7 +765,7 @@ static struct gfs2_dirent *gfs2_dirent_search(struct inode *inode, 
			return ERR_PTR(-EIO);

		}



		index = name->hash >> (32 - ip->i_di.di_depth);

		index = name->hash >> (32 - ip->i_depth);

		error = get_first_leaf(ip, index, &bh);

		if (error)

			return ERR_PTR(error);
@@ -803,14 +803,15 @@ got_dent: 
static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh, u16 depth)

{

	struct gfs2_inode *ip = GFS2_I(inode);

	u64 bn = gfs2_alloc_meta(ip);

	unsigned int n = 1;

	u64 bn = gfs2_alloc_block(ip, &n);

	struct buffer_head *bh = gfs2_meta_new(ip->i_gl, bn);

	struct gfs2_leaf *leaf;

	struct gfs2_dirent *dent;

	struct qstr name = { .name = "", .len = 0, .hash = 0 };

	if (!bh)

		return NULL;



	gfs2_trans_add_unrevoke(GFS2_SB(inode), bn, 1);

	gfs2_trans_add_bh(ip->i_gl, bh, 1);

	gfs2_metatype_set(bh, GFS2_METATYPE_LF, GFS2_FORMAT_LF);

	leaf = (struct gfs2_leaf *)bh->b_data;
@@ -905,12 +906,11 @@ static int dir_make_exhash(struct inode *inode) 
		*lp = cpu_to_be64(bn);



	dip->i_di.di_size = sdp->sd_sb.sb_bsize / 2;

	dip->i_di.di_blocks++;

	gfs2_set_inode_blocks(&dip->i_inode);

	gfs2_add_inode_blocks(&dip->i_inode, 1);

	dip->i_di.di_flags |= GFS2_DIF_EXHASH;



	for (x = sdp->sd_hash_ptrs, y = -1; x; x >>= 1, y++) ;

	dip->i_di.di_depth = y;

	dip->i_depth = y;



	gfs2_dinode_out(dip, dibh->b_data);
@@ -941,7 +941,7 @@ static int dir_split_leaf(struct inode *inode, const struct qstr *name) 
	int x, moved = 0;

	int error;



	index = name->hash >> (32 - dip->i_di.di_depth);

	index = name->hash >> (32 - dip->i_depth);

	error = get_leaf_nr(dip, index, &leaf_no);

	if (error)

		return error;
@@ -952,7 +952,7 @@ static int dir_split_leaf(struct inode *inode, const struct qstr *name) 
		return error;



	oleaf = (struct gfs2_leaf *)obh->b_data;

	if (dip->i_di.di_depth == be16_to_cpu(oleaf->lf_depth)) {

	if (dip->i_depth == be16_to_cpu(oleaf->lf_depth)) {

		brelse(obh);

		return 1; /* can't split */

	}
@@ -967,10 +967,10 @@ static int dir_split_leaf(struct inode *inode, const struct qstr *name) 
	bn = nbh->b_blocknr;



	/*  Compute the start and len of leaf pointers in the hash table.  */

	len = 1 << (dip->i_di.di_depth - be16_to_cpu(oleaf->lf_depth));

	len = 1 << (dip->i_depth - be16_to_cpu(oleaf->lf_depth));

	half_len = len >> 1;

	if (!half_len) {

		printk(KERN_WARNING "di_depth %u lf_depth %u index %u\n", dip->i_di.di_depth, be16_to_cpu(oleaf->lf_depth), index);

		printk(KERN_WARNING "i_depth %u lf_depth %u index %u\n", dip->i_depth, be16_to_cpu(oleaf->lf_depth), index);

		gfs2_consist_inode(dip);

		error = -EIO;

		goto fail_brelse;
@@ -997,7 +997,7 @@ static int dir_split_leaf(struct inode *inode, const struct qstr *name) 
	kfree(lp);



	/*  Compute the divider  */

	divider = (start + half_len) << (32 - dip->i_di.di_depth);

	divider = (start + half_len) << (32 - dip->i_depth);



	/*  Copy the entries  */

	dirent_first(dip, obh, &dent);
@@ -1021,13 +1021,13 @@ static int dir_split_leaf(struct inode *inode, const struct qstr *name) 


			new->de_inum = dent->de_inum; /* No endian worries */

			new->de_type = dent->de_type; /* No endian worries */

			nleaf->lf_entries = cpu_to_be16(be16_to_cpu(nleaf->lf_entries)+1);

			be16_add_cpu(&nleaf->lf_entries, 1);



			dirent_del(dip, obh, prev, dent);



			if (!oleaf->lf_entries)

				gfs2_consist_inode(dip);

			oleaf->lf_entries = cpu_to_be16(be16_to_cpu(oleaf->lf_entries)-1);

			be16_add_cpu(&oleaf->lf_entries, -1);



			if (!prev)

				prev = dent;
@@ -1044,8 +1044,7 @@ static int dir_split_leaf(struct inode *inode, const struct qstr *name) 
	error = gfs2_meta_inode_buffer(dip, &dibh);

	if (!gfs2_assert_withdraw(GFS2_SB(&dip->i_inode), !error)) {

		gfs2_trans_add_bh(dip->i_gl, dibh, 1);

		dip->i_di.di_blocks++;

		gfs2_set_inode_blocks(&dip->i_inode);

		gfs2_add_inode_blocks(&dip->i_inode, 1);

		gfs2_dinode_out(dip, dibh->b_data);

		brelse(dibh);

	}
@@ -1082,7 +1081,7 @@ static int dir_double_exhash(struct gfs2_inode *dip) 
	int x;

	int error = 0;



	hsize = 1 << dip->i_di.di_depth;

	hsize = 1 << dip->i_depth;

	if (hsize * sizeof(u64) != dip->i_di.di_size) {

		gfs2_consist_inode(dip);

		return -EIO;
@@ -1090,7 +1089,7 @@ static int dir_double_exhash(struct gfs2_inode *dip) 


	/*  Allocate both the "from" and "to" buffers in one big chunk  */



	buf = kcalloc(3, sdp->sd_hash_bsize, GFP_KERNEL | __GFP_NOFAIL);

	buf = kcalloc(3, sdp->sd_hash_bsize, GFP_NOFS | __GFP_NOFAIL);



	for (block = dip->i_di.di_size >> sdp->sd_hash_bsize_shift; block--;) {

		error = gfs2_dir_read_data(dip, (char *)buf,
@@ -1125,7 +1124,7 @@ static int dir_double_exhash(struct gfs2_inode *dip) 


	error = gfs2_meta_inode_buffer(dip, &dibh);

	if (!gfs2_assert_withdraw(sdp, !error)) {

		dip->i_di.di_depth++;

		dip->i_depth++;

		gfs2_dinode_out(dip, dibh->b_data);

		brelse(dibh);

	}
@@ -1370,16 +1369,16 @@ static int dir_e_read(struct inode *inode, u64 *offset, void *opaque, 
	int error = 0;

	unsigned depth = 0;



	hsize = 1 << dip->i_di.di_depth;

	hsize = 1 << dip->i_depth;

	if (hsize * sizeof(u64) != dip->i_di.di_size) {

		gfs2_consist_inode(dip);

		return -EIO;

	}



	hash = gfs2_dir_offset2hash(*offset);

	index = hash >> (32 - dip->i_di.di_depth);

	index = hash >> (32 - dip->i_depth);



	lp = kmalloc(sdp->sd_hash_bsize, GFP_KERNEL);

	lp = kmalloc(sdp->sd_hash_bsize, GFP_NOFS);

	if (!lp)

		return -ENOMEM;
@@ -1405,7 +1404,7 @@ static int dir_e_read(struct inode *inode, u64 *offset, void *opaque, 
		if (error)

			break;



		len = 1 << (dip->i_di.di_depth - depth);

		len = 1 << (dip->i_depth - depth);

		index = (index & ~(len - 1)) + len;

	}
@@ -1444,7 +1443,7 @@ int gfs2_dir_read(struct inode *inode, u64 *offset, void *opaque, 


	error = -ENOMEM;

	/* 96 is max number of dirents which can be stuffed into an inode */

	darr = kmalloc(96 * sizeof(struct gfs2_dirent *), GFP_KERNEL);

	darr = kmalloc(96 * sizeof(struct gfs2_dirent *), GFP_NOFS);

	if (darr) {

		g.pdent = darr;

		g.offset = 0;
@@ -1549,7 +1548,7 @@ static int dir_new_leaf(struct inode *inode, const struct qstr *name) 
	u32 index;

	u64 bn;



	index = name->hash >> (32 - ip->i_di.di_depth);

	index = name->hash >> (32 - ip->i_depth);

	error = get_first_leaf(ip, index, &obh);

	if (error)

		return error;
@@ -1579,8 +1578,7 @@ static int dir_new_leaf(struct inode *inode, const struct qstr *name) 
	if (error)

		return error;

	gfs2_trans_add_bh(ip->i_gl, bh, 1);

	ip->i_di.di_blocks++;

	gfs2_set_inode_blocks(&ip->i_inode);

	gfs2_add_inode_blocks(&ip->i_inode, 1);

	gfs2_dinode_out(ip, bh->b_data);

	brelse(bh);

	return 0;
@@ -1616,7 +1614,7 @@ int gfs2_dir_add(struct inode *inode, const struct qstr *name, 
			dent->de_type = cpu_to_be16(type);

			if (ip->i_di.di_flags & GFS2_DIF_EXHASH) {

				leaf = (struct gfs2_leaf *)bh->b_data;

				leaf->lf_entries = cpu_to_be16(be16_to_cpu(leaf->lf_entries) + 1);

				be16_add_cpu(&leaf->lf_entries, 1);

			}

			brelse(bh);

			error = gfs2_meta_inode_buffer(ip, &bh);
@@ -1641,7 +1639,7 @@ int gfs2_dir_add(struct inode *inode, const struct qstr *name, 
			continue;

		if (error < 0)

			break;

		if (ip->i_di.di_depth < GFS2_DIR_MAX_DEPTH) {

		if (ip->i_depth < GFS2_DIR_MAX_DEPTH) {

			error = dir_double_exhash(ip);

			if (error)

				break;
@@ -1785,13 +1783,13 @@ static int foreach_leaf(struct gfs2_inode *dip, leaf_call_t lc, void *data) 
	u64 leaf_no;

	int error = 0;



	hsize = 1 << dip->i_di.di_depth;

	hsize = 1 << dip->i_depth;

	if (hsize * sizeof(u64) != dip->i_di.di_size) {

		gfs2_consist_inode(dip);

		return -EIO;

	}



	lp = kmalloc(sdp->sd_hash_bsize, GFP_KERNEL);

	lp = kmalloc(sdp->sd_hash_bsize, GFP_NOFS);

	if (!lp)

		return -ENOMEM;
@@ -1817,7 +1815,7 @@ static int foreach_leaf(struct gfs2_inode *dip, leaf_call_t lc, void *data) 
			if (error)

				goto out;

			leaf = (struct gfs2_leaf *)bh->b_data;

			len = 1 << (dip->i_di.di_depth - be16_to_cpu(leaf->lf_depth));

			len = 1 << (dip->i_depth - be16_to_cpu(leaf->lf_depth));

			brelse(bh);



			error = lc(dip, index, len, leaf_no, data);
@@ -1866,15 +1864,18 @@ static int leaf_dealloc(struct gfs2_inode *dip, u32 index, u32 len, 


	memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));



	ht = kzalloc(size, GFP_KERNEL);

	ht = kzalloc(size, GFP_NOFS);

	if (!ht)

		return -ENOMEM;



	gfs2_alloc_get(dip);

	if (!gfs2_alloc_get(dip)) {

		error = -ENOMEM;

		goto out;

	}



	error = gfs2_quota_hold(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);

	if (error)

		goto out;

		goto out_put;



	error = gfs2_rindex_hold(sdp, &dip->i_alloc->al_ri_gh);

	if (error)
@@ -1894,7 +1895,7 @@ static int leaf_dealloc(struct gfs2_inode *dip, u32 index, u32 len, 
		l_blocks++;

	}



	gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE, 0);

	gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);



	for (x = 0; x < rlist.rl_rgrps; x++) {

		struct gfs2_rgrpd *rgd;
@@ -1921,11 +1922,7 @@ static int leaf_dealloc(struct gfs2_inode *dip, u32 index, u32 len, 
		brelse(bh);



		gfs2_free_meta(dip, blk, 1);



		if (!dip->i_di.di_blocks)

			gfs2_consist_inode(dip);

		dip->i_di.di_blocks--;

		gfs2_set_inode_blocks(&dip->i_inode);

		gfs2_add_inode_blocks(&dip->i_inode, -1);

	}



	error = gfs2_dir_write_data(dip, ht, index * sizeof(u64), size);
@@ -1952,8 +1949,9 @@ out_rlist: 
	gfs2_glock_dq_uninit(&dip->i_alloc->al_ri_gh);

out_qs:

	gfs2_quota_unhold(dip);

out:

out_put:

	gfs2_alloc_put(dip);

out:

	kfree(ht);

	return error;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE