Commit 801b0365 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull GFS2 updates from Steven Whitehouse.

* git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-3.0-nmw:
  GFS2: Eliminate 64-bit divides
  GFS2: Reduce file fragmentation
  GFS2: kernel panic with small gfs2 filesystems - 1 RG
  GFS2: Fixing double brelse'ing bh allocated in gfs2_meta_read when EIO occurs
  GFS2: Combine functions get_local_rgrp and gfs2_inplace_reserve
  GFS2: Add kobject release method
  GFS2: Size seq_file buffer more carefully
  GFS2: Use seq_vprintf for glocks debugfs file
  seq_file: Add seq_vprintf function and export it
  GFS2: Use lvbs for storing rgrp information with mount option
  GFS2: Cache last hash bucket for glock seq_files
  GFS2: Increase buffer size for glocks and glstats debugfs files
  GFS2: Fix error handling when reading an invalid block from the journal
  GFS2: Add "top dir" flag support
  GFS2: Fold quota data into the reservations struct
  GFS2: Extend the life of the reservations
parents 614a6d43 15e1c960

fs/gfs2/aops.c

+3 −15
Original line number Diff line number Diff line
@@ -614,7 +614,6 @@ static int gfs2_write_begin(struct file *file, struct address_space *mapping, 
	unsigned int data_blocks = 0, ind_blocks = 0, rblocks;

	int alloc_required;

	int error = 0;

	struct gfs2_qadata *qa = NULL;

	pgoff_t index = pos >> PAGE_CACHE_SHIFT;

	unsigned from = pos & (PAGE_CACHE_SIZE - 1);

	struct page *page;
@@ -638,15 +637,9 @@ static int gfs2_write_begin(struct file *file, struct address_space *mapping, 
		gfs2_write_calc_reserv(ip, len, &data_blocks, &ind_blocks);



	if (alloc_required) {

		qa = gfs2_qadata_get(ip);

		if (!qa) {

			error = -ENOMEM;

			goto out_unlock;

		}



		error = gfs2_quota_lock_check(ip);

		if (error)

			goto out_alloc_put;

			goto out_unlock;



		error = gfs2_inplace_reserve(ip, data_blocks + ind_blocks);

		if (error)
@@ -708,8 +701,6 @@ out_trans_fail: 
		gfs2_inplace_release(ip);

out_qunlock:

		gfs2_quota_unlock(ip);

out_alloc_put:

		gfs2_qadata_put(ip);

	}

out_unlock:

	if (&ip->i_inode == sdp->sd_rindex) {
@@ -846,7 +837,6 @@ static int gfs2_write_end(struct file *file, struct address_space *mapping, 
	struct gfs2_sbd *sdp = GFS2_SB(inode);

	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);

	struct buffer_head *dibh;

	struct gfs2_qadata *qa = ip->i_qadata;

	unsigned int from = pos & (PAGE_CACHE_SIZE - 1);

	unsigned int to = from + len;

	int ret;
@@ -878,12 +868,10 @@ static int gfs2_write_end(struct file *file, struct address_space *mapping, 
	brelse(dibh);

failed:

	gfs2_trans_end(sdp);

	if (ip->i_res)

	if (gfs2_mb_reserved(ip))

		gfs2_inplace_release(ip);

	if (qa) {

	if (ip->i_res->rs_qa_qd_num)

		gfs2_quota_unlock(ip);

		gfs2_qadata_put(ip);

	}

	if (inode == sdp->sd_rindex) {

		gfs2_glock_dq(&m_ip->i_gh);

		gfs2_holder_uninit(&m_ip->i_gh);

fs/gfs2/bmap.c

+8 −13
Original line number Diff line number Diff line
@@ -785,6 +785,9 @@ static int do_strip(struct gfs2_inode *ip, struct buffer_head *dibh, 
	if (error)

		goto out_rlist;



	if (gfs2_rs_active(ip->i_res)) /* needs to be done with the rgrp glock held */

		gfs2_rs_deltree(ip->i_res);



	error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE +

				 RES_INDIRECT + RES_STATFS + RES_QUOTA,

				 revokes);
@@ -1045,12 +1048,13 @@ static int trunc_dealloc(struct gfs2_inode *ip, u64 size) 
		lblock = (size - 1) >> sdp->sd_sb.sb_bsize_shift;



	find_metapath(sdp, lblock, &mp, ip->i_height);

	if (!gfs2_qadata_get(ip))

		return -ENOMEM;

	error = gfs2_rindex_update(sdp);

	if (error)

		return error;



	error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);

	if (error)

		goto out;

		return error;



	while (height--) {

		struct strip_mine sm;
@@ -1064,8 +1068,6 @@ static int trunc_dealloc(struct gfs2_inode *ip, u64 size) 


	gfs2_quota_unhold(ip);



out:

	gfs2_qadata_put(ip);

	return error;

}
@@ -1167,19 +1169,14 @@ static int do_grow(struct inode *inode, u64 size) 
	struct gfs2_inode *ip = GFS2_I(inode);

	struct gfs2_sbd *sdp = GFS2_SB(inode);

	struct buffer_head *dibh;

	struct gfs2_qadata *qa = NULL;

	int error;

	int unstuff = 0;



	if (gfs2_is_stuffed(ip) &&

	    (size > (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)))) {

		qa = gfs2_qadata_get(ip);

		if (qa == NULL)

			return -ENOMEM;



		error = gfs2_quota_lock_check(ip);

		if (error)

			goto do_grow_alloc_put;

			return error;



		error = gfs2_inplace_reserve(ip, 1);

		if (error)
@@ -1214,8 +1211,6 @@ do_grow_release: 
		gfs2_inplace_release(ip);

do_grow_qunlock:

		gfs2_quota_unlock(ip);

do_grow_alloc_put:

		gfs2_qadata_put(ip);

	}

	return error;

}

fs/gfs2/dir.c

+1 −8
Original line number Diff line number Diff line
@@ -1854,14 +1854,9 @@ static int leaf_dealloc(struct gfs2_inode *dip, u32 index, u32 len, 
	if (!ht)

		return -ENOMEM;



	if (!gfs2_qadata_get(dip)) {

		error = -ENOMEM;

		goto out;

	}



	error = gfs2_quota_hold(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);

	if (error)

		goto out_put;

		goto out;



	/*  Count the number of leaves  */

	bh = leaf_bh;
@@ -1942,8 +1937,6 @@ out_rg_gunlock: 
out_rlist:

	gfs2_rlist_free(&rlist);

	gfs2_quota_unhold(dip);

out_put:

	gfs2_qadata_put(dip);

out:

	kfree(ht);

	return error;

fs/gfs2/file.c

+37 −28
Original line number Diff line number Diff line
@@ -142,6 +142,7 @@ static const u32 fsflags_to_gfs2[32] = { 
	[7] = GFS2_DIF_NOATIME,

	[12] = GFS2_DIF_EXHASH,

	[14] = GFS2_DIF_INHERIT_JDATA,

	[17] = GFS2_DIF_TOPDIR,

};



static const u32 gfs2_to_fsflags[32] = {
@@ -150,6 +151,7 @@ static const u32 gfs2_to_fsflags[32] = { 
	[gfs2fl_AppendOnly] = FS_APPEND_FL,

	[gfs2fl_NoAtime] = FS_NOATIME_FL,

	[gfs2fl_ExHash] = FS_INDEX_FL,

	[gfs2fl_TopLevel] = FS_TOPDIR_FL,

	[gfs2fl_InheritJdata] = FS_JOURNAL_DATA_FL,

};
@@ -203,6 +205,7 @@ void gfs2_set_inode_flags(struct inode *inode) 
			     GFS2_DIF_NOATIME|			\

			     GFS2_DIF_SYNC|			\

			     GFS2_DIF_SYSTEM|			\

			     GFS2_DIF_TOPDIR|			\

			     GFS2_DIF_INHERIT_JDATA)



/**
@@ -298,6 +301,7 @@ static int gfs2_set_flags(struct file *filp, u32 __user *ptr) 


	gfsflags = fsflags_cvt(fsflags_to_gfs2, fsflags);

	if (!S_ISDIR(inode->i_mode)) {

		gfsflags &= ~GFS2_DIF_TOPDIR;

		if (gfsflags & GFS2_DIF_INHERIT_JDATA)

			gfsflags ^= (GFS2_DIF_JDATA | GFS2_DIF_INHERIT_JDATA);

		return do_gfs2_set_flags(filp, gfsflags, ~0);
@@ -366,7 +370,6 @@ static int gfs2_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf) 
	u64 pos = page->index << PAGE_CACHE_SHIFT;

	unsigned int data_blocks, ind_blocks, rblocks;

	struct gfs2_holder gh;

	struct gfs2_qadata *qa;

	loff_t size;

	int ret;
@@ -376,6 +379,13 @@ static int gfs2_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf) 
	 */

	vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);



	ret = gfs2_rs_alloc(ip);

	if (ret)

		return ret;



	atomic_set(&ip->i_res->rs_sizehint,

		   PAGE_CACHE_SIZE >> sdp->sd_sb.sb_bsize_shift);



	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);

	ret = gfs2_glock_nq(&gh);

	if (ret)
@@ -393,14 +403,13 @@ static int gfs2_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf) 
		goto out_unlock;

	}



	ret = -ENOMEM;

	qa = gfs2_qadata_get(ip);

	if (qa == NULL)

	ret = gfs2_rindex_update(sdp);

	if (ret)

		goto out_unlock;



	ret = gfs2_quota_lock_check(ip);

	if (ret)

		goto out_alloc_put;

		goto out_unlock;

	gfs2_write_calc_reserv(ip, PAGE_CACHE_SIZE, &data_blocks, &ind_blocks);

	ret = gfs2_inplace_reserve(ip, data_blocks + ind_blocks);

	if (ret)
@@ -447,8 +456,6 @@ out_trans_fail: 
	gfs2_inplace_release(ip);

out_quota_unlock:

	gfs2_quota_unlock(ip);

out_alloc_put:

	gfs2_qadata_put(ip);

out_unlock:

	gfs2_glock_dq(&gh);

out:
@@ -567,16 +574,14 @@ fail: 


static int gfs2_release(struct inode *inode, struct file *file)

{

	struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;

	struct gfs2_file *fp;

	struct gfs2_inode *ip = GFS2_I(inode);



	fp = file->private_data;

	kfree(file->private_data);

	file->private_data = NULL;



	if (gfs2_assert_warn(sdp, fp))

		return -EIO;



	kfree(fp);

	if ((file->f_mode & FMODE_WRITE) &&

	    (atomic_read(&inode->i_writecount) == 1))

		gfs2_rs_delete(ip);



	return 0;

}
@@ -653,13 +658,21 @@ static ssize_t gfs2_file_aio_write(struct kiocb *iocb, const struct iovec *iov, 
				   unsigned long nr_segs, loff_t pos)

{

	struct file *file = iocb->ki_filp;



	if (file->f_flags & O_APPEND) {

	size_t writesize = iov_length(iov, nr_segs);

	struct dentry *dentry = file->f_dentry;

	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);

		struct gfs2_holder gh;

	struct gfs2_sbd *sdp;

	int ret;



	sdp = GFS2_SB(file->f_mapping->host);

	ret = gfs2_rs_alloc(ip);

	if (ret)

		return ret;



	atomic_set(&ip->i_res->rs_sizehint, writesize >> sdp->sd_sb.sb_bsize_shift);

	if (file->f_flags & O_APPEND) {

		struct gfs2_holder gh;



		ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);

		if (ret)

			return ret;
@@ -751,7 +764,6 @@ static long gfs2_fallocate(struct file *file, int mode, loff_t offset, 
	struct gfs2_inode *ip = GFS2_I(inode);

	unsigned int data_blocks = 0, ind_blocks = 0, rblocks;

	loff_t bytes, max_bytes;

	struct gfs2_qadata *qa;

	int error;

	const loff_t pos = offset;

	const loff_t count = len;
@@ -774,11 +786,17 @@ static long gfs2_fallocate(struct file *file, int mode, loff_t offset, 
	if (bytes == 0)

		bytes = sdp->sd_sb.sb_bsize;



	error = gfs2_rs_alloc(ip);

	if (error)

		return error;



	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ip->i_gh);

	error = gfs2_glock_nq(&ip->i_gh);

	if (unlikely(error))

		goto out_uninit;



	atomic_set(&ip->i_res->rs_sizehint, len >> sdp->sd_sb.sb_bsize_shift);



	while (len > 0) {

		if (len < bytes)

			bytes = len;
@@ -787,15 +805,9 @@ static long gfs2_fallocate(struct file *file, int mode, loff_t offset, 
			offset += bytes;

			continue;

		}

		qa = gfs2_qadata_get(ip);

		if (!qa) {

			error = -ENOMEM;

			goto out_unlock;

		}



		error = gfs2_quota_lock_check(ip);

		if (error)

			goto out_alloc_put;

			goto out_unlock;



retry:

		gfs2_write_calc_reserv(ip, bytes, &data_blocks, &ind_blocks);
@@ -835,7 +847,6 @@ retry: 
		offset += max_bytes;

		gfs2_inplace_release(ip);

		gfs2_quota_unlock(ip);

		gfs2_qadata_put(ip);

	}



	if (error == 0)
@@ -846,8 +857,6 @@ out_trans_fail: 
	gfs2_inplace_release(ip);

out_qunlock:

	gfs2_quota_unlock(ip);

out_alloc_put:

	gfs2_qadata_put(ip);

out_unlock:

	gfs2_glock_dq(&ip->i_gh);

out_uninit:

fs/gfs2/glock.c

+30 −9
Original line number Diff line number Diff line
@@ -47,9 +47,10 @@ 


struct gfs2_glock_iter {

	int hash;			/* hash bucket index           */

	unsigned nhash;			/* Index within current bucket */

	struct gfs2_sbd *sdp;		/* incore superblock           */

	struct gfs2_glock *gl;		/* current glock struct        */

	char string[512];		/* scratch space             */

	loff_t last_pos;		/* last position               */

};



typedef void (*glock_examiner) (struct gfs2_glock * gl);
@@ -767,6 +768,7 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number, 
	gl->gl_stats.stats[GFS2_LKS_DCOUNT] = 0;

	gl->gl_stats.stats[GFS2_LKS_QCOUNT] = 0;

	memset(&gl->gl_lksb, 0, sizeof(struct dlm_lksb));

	memset(gl->gl_lvb, 0, 32 * sizeof(char));

	gl->gl_lksb.sb_lvbptr = gl->gl_lvb;

	gl->gl_tchange = jiffies;

	gl->gl_object = NULL;
@@ -948,9 +950,7 @@ void gfs2_print_dbg(struct seq_file *seq, const char *fmt, ...) 
	va_start(args, fmt);



	if (seq) {

		struct gfs2_glock_iter *gi = seq->private;

		vsprintf(gi->string, fmt, args);

		seq_printf(seq, gi->string);

		seq_vprintf(seq, fmt, args);

	} else {

		vaf.fmt = fmt;

		vaf.va = &args;
@@ -1854,8 +1854,14 @@ static int gfs2_glock_iter_next(struct gfs2_glock_iter *gi) 
		gl = gi->gl;

		if (gl) {

			gi->gl = glock_hash_next(gl);

			gi->nhash++;

		} else {

			if (gi->hash >= GFS2_GL_HASH_SIZE) {

				rcu_read_unlock();

				return 1;

			}

			gi->gl = glock_hash_chain(gi->hash);

			gi->nhash = 0;

		}

		while (gi->gl == NULL) {

			gi->hash++;
@@ -1864,6 +1870,7 @@ static int gfs2_glock_iter_next(struct gfs2_glock_iter *gi) 
				return 1;

			}

			gi->gl = glock_hash_chain(gi->hash);

			gi->nhash = 0;

		}

	/* Skip entries for other sb and dead entries */

	} while (gi->sdp != gi->gl->gl_sbd || atomic_read(&gi->gl->gl_ref) == 0);
@@ -1876,7 +1883,12 @@ static void *gfs2_glock_seq_start(struct seq_file *seq, loff_t *pos) 
	struct gfs2_glock_iter *gi = seq->private;

	loff_t n = *pos;



	if (gi->last_pos <= *pos)

		n = gi->nhash + (*pos - gi->last_pos);

	else

		gi->hash = 0;



	gi->nhash = 0;

	rcu_read_lock();



	do {
@@ -1884,6 +1896,7 @@ static void *gfs2_glock_seq_start(struct seq_file *seq, loff_t *pos) 
			return NULL;

	} while (n--);



	gi->last_pos = *pos;

	return gi->gl;

}
@@ -1893,7 +1906,7 @@ static void *gfs2_glock_seq_next(struct seq_file *seq, void *iter_ptr, 
	struct gfs2_glock_iter *gi = seq->private;



	(*pos)++;



	gi->last_pos = *pos;

	if (gfs2_glock_iter_next(gi))

		return NULL;
@@ -1964,6 +1977,8 @@ static const struct seq_operations gfs2_sbstats_seq_ops = { 
	.show  = gfs2_sbstats_seq_show,

};



#define GFS2_SEQ_GOODSIZE min(PAGE_SIZE << PAGE_ALLOC_COSTLY_ORDER, 65536UL)



static int gfs2_glocks_open(struct inode *inode, struct file *file)

{

	int ret = seq_open_private(file, &gfs2_glock_seq_ops,
@@ -1972,6 +1987,9 @@ static int gfs2_glocks_open(struct inode *inode, struct file *file) 
		struct seq_file *seq = file->private_data;

		struct gfs2_glock_iter *gi = seq->private;

		gi->sdp = inode->i_private;

		seq->buf = kmalloc(GFS2_SEQ_GOODSIZE, GFP_KERNEL | __GFP_NOWARN);

		if (seq->buf)

			seq->size = GFS2_SEQ_GOODSIZE;

	}

	return ret;

}
@@ -1984,6 +2002,9 @@ static int gfs2_glstats_open(struct inode *inode, struct file *file) 
		struct seq_file *seq = file->private_data;

		struct gfs2_glock_iter *gi = seq->private;

		gi->sdp = inode->i_private;

		seq->buf = kmalloc(GFS2_SEQ_GOODSIZE, GFP_KERNEL | __GFP_NOWARN);

		if (seq->buf)

			seq->size = GFS2_SEQ_GOODSIZE;

	}

	return ret;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE