Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 49302baa 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:
  GFS2: combine duplicated block freeing routines
  GFS2: Add S_NOSEC support
  GFS2: Automatically adjust glock min hold time
  GFS2: Cache dir hash table in a contiguous buffer
parents eadc3875 46fcb2ed

fs/gfs2/bmap.c

+2 −10
Original line number Diff line number Diff line
@@ -854,11 +854,7 @@ static int do_strip(struct gfs2_inode *ip, struct buffer_head *dibh, 
			blen++;

		else {

			if (bstart) {

				if (metadata)

					__gfs2_free_meta(ip, bstart, blen);

				else

					__gfs2_free_data(ip, bstart, blen);



				__gfs2_free_blocks(ip, bstart, blen, metadata);

				btotal += blen;

			}
@@ -870,11 +866,7 @@ static int do_strip(struct gfs2_inode *ip, struct buffer_head *dibh, 
		gfs2_add_inode_blocks(&ip->i_inode, -1);

	}

	if (bstart) {

		if (metadata)

			__gfs2_free_meta(ip, bstart, blen);

		else

			__gfs2_free_data(ip, bstart, blen);



		__gfs2_free_blocks(ip, bstart, blen, metadata);

		btotal += blen;

	}

fs/gfs2/dir.c

+109 −112
Original line number Diff line number Diff line
@@ -339,6 +339,67 @@ fail: 
	return (copied) ? copied : error;

}



/**

 * gfs2_dir_get_hash_table - Get pointer to the dir hash table

 * @ip: The inode in question

 *

 * Returns: The hash table or an error

 */



static __be64 *gfs2_dir_get_hash_table(struct gfs2_inode *ip)

{

	struct inode *inode = &ip->i_inode;

	int ret;

	u32 hsize;

	__be64 *hc;



	BUG_ON(!(ip->i_diskflags & GFS2_DIF_EXHASH));



	hc = ip->i_hash_cache;

	if (hc)

		return hc;



	hsize = 1 << ip->i_depth;

	hsize *= sizeof(__be64);

	if (hsize != i_size_read(&ip->i_inode)) {

		gfs2_consist_inode(ip);

		return ERR_PTR(-EIO);

	}



	hc = kmalloc(hsize, GFP_NOFS);

	ret = -ENOMEM;

	if (hc == NULL)

		return ERR_PTR(-ENOMEM);



	ret = gfs2_dir_read_data(ip, (char *)hc, 0, hsize, 1);

	if (ret < 0) {

		kfree(hc);

		return ERR_PTR(ret);

	}



	spin_lock(&inode->i_lock);

	if (ip->i_hash_cache)

		kfree(hc);

	else

		ip->i_hash_cache = hc;

	spin_unlock(&inode->i_lock);



	return ip->i_hash_cache;

}



/**

 * gfs2_dir_hash_inval - Invalidate dir hash

 * @ip: The directory inode

 *

 * Must be called with an exclusive glock, or during glock invalidation.

 */

void gfs2_dir_hash_inval(struct gfs2_inode *ip)

{

	__be64 *hc = ip->i_hash_cache;

	ip->i_hash_cache = NULL;

	kfree(hc);

}



static inline int gfs2_dirent_sentinel(const struct gfs2_dirent *dent)

{

	return dent->de_inum.no_addr == 0 || dent->de_inum.no_formal_ino == 0;
@@ -686,17 +747,12 @@ static int get_leaf(struct gfs2_inode *dip, u64 leaf_no, 
static int get_leaf_nr(struct gfs2_inode *dip, u32 index,

		       u64 *leaf_out)

{

	__be64 leaf_no;

	int error;



	error = gfs2_dir_read_data(dip, (char *)&leaf_no,

				    index * sizeof(__be64),

				    sizeof(__be64), 0);

	if (error != sizeof(u64))

		return (error < 0) ? error : -EIO;



	*leaf_out = be64_to_cpu(leaf_no);

	__be64 *hash;



	hash = gfs2_dir_get_hash_table(dip);

	if (IS_ERR(hash))

		return PTR_ERR(hash);

	*leaf_out = be64_to_cpu(*(hash + index));

	return 0;

}
@@ -966,6 +1022,8 @@ static int dir_split_leaf(struct inode *inode, const struct qstr *name) 
	for (x = 0; x < half_len; x++)

		lp[x] = cpu_to_be64(bn);



	gfs2_dir_hash_inval(dip);



	error = gfs2_dir_write_data(dip, (char *)lp, start * sizeof(u64),

				    half_len * sizeof(u64));

	if (error != half_len * sizeof(u64)) {
@@ -1052,70 +1110,54 @@ fail_brelse: 


static int dir_double_exhash(struct gfs2_inode *dip)

{

	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);

	struct buffer_head *dibh;

	u32 hsize;

	u64 *buf;

	u64 *from, *to;

	u64 block;

	u64 disksize = i_size_read(&dip->i_inode);

	u32 hsize_bytes;

	__be64 *hc;

	__be64 *hc2, *h;

	int x;

	int error = 0;



	hsize = 1 << dip->i_depth;

	if (hsize * sizeof(u64) != disksize) {

		gfs2_consist_inode(dip);

		return -EIO;

	}

	hsize_bytes = hsize * sizeof(__be64);



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

	hc = gfs2_dir_get_hash_table(dip);

	if (IS_ERR(hc))

		return PTR_ERR(hc);



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

	if (!buf)

	h = hc2 = kmalloc(hsize_bytes * 2, GFP_NOFS);

	if (!hc2)

		return -ENOMEM;



	for (block = disksize >> sdp->sd_hash_bsize_shift; block--;) {

		error = gfs2_dir_read_data(dip, (char *)buf,

					    block * sdp->sd_hash_bsize,

					    sdp->sd_hash_bsize, 1);

		if (error != sdp->sd_hash_bsize) {

			if (error >= 0)

				error = -EIO;

			goto fail;

		}



		from = buf;

		to = (u64 *)((char *)buf + sdp->sd_hash_bsize);

	error = gfs2_meta_inode_buffer(dip, &dibh);

	if (error)

		goto out_kfree;



		for (x = sdp->sd_hash_ptrs; x--; from++) {

			*to++ = *from;	/*  No endianess worries  */

			*to++ = *from;

	for (x = 0; x < hsize; x++) {

		*h++ = *hc;

		*h++ = *hc;

		hc++;

	}



		error = gfs2_dir_write_data(dip,

					     (char *)buf + sdp->sd_hash_bsize,

					     block * sdp->sd_sb.sb_bsize,

					     sdp->sd_sb.sb_bsize);

		if (error != sdp->sd_sb.sb_bsize) {

			if (error >= 0)

				error = -EIO;

	error = gfs2_dir_write_data(dip, (char *)hc2, 0, hsize_bytes * 2);

	if (error != (hsize_bytes * 2))

		goto fail;

		}

	}



	kfree(buf);



	error = gfs2_meta_inode_buffer(dip, &dibh);

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

	gfs2_dir_hash_inval(dip);

	dip->i_hash_cache = hc2;

	dip->i_depth++;

	gfs2_dinode_out(dip, dibh->b_data);

	brelse(dibh);

	}



	return error;

	return 0;



fail:

	kfree(buf);

	/* Replace original hash table & size */

	gfs2_dir_write_data(dip, (char *)hc, 0, hsize_bytes);

	i_size_write(&dip->i_inode, hsize_bytes);

	gfs2_dinode_out(dip, dibh->b_data);

	brelse(dibh);

out_kfree:

	kfree(hc2);

	return error;

}
@@ -1348,6 +1390,7 @@ out: 
	return error;

}





/**

 * dir_e_read - Reads the entries from a directory into a filldir buffer

 * @dip: dinode pointer
@@ -1362,9 +1405,7 @@ static int dir_e_read(struct inode *inode, u64 *offset, void *opaque, 
		      filldir_t filldir)

{

	struct gfs2_inode *dip = GFS2_I(inode);

	struct gfs2_sbd *sdp = GFS2_SB(inode);

	u32 hsize, len = 0;

	u32 ht_offset, lp_offset, ht_offset_cur = -1;

	u32 hash, index;

	__be64 *lp;

	int copied = 0;
@@ -1372,37 +1413,17 @@ static int dir_e_read(struct inode *inode, u64 *offset, void *opaque, 
	unsigned depth = 0;



	hsize = 1 << dip->i_depth;

	if (hsize * sizeof(u64) != i_size_read(inode)) {

		gfs2_consist_inode(dip);

		return -EIO;

	}



	hash = gfs2_dir_offset2hash(*offset);

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



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

	if (!lp)

		return -ENOMEM;

	lp = gfs2_dir_get_hash_table(dip);

	if (IS_ERR(lp))

		return PTR_ERR(lp);



	while (index < hsize) {

		lp_offset = index & (sdp->sd_hash_ptrs - 1);

		ht_offset = index - lp_offset;



		if (ht_offset_cur != ht_offset) {

			error = gfs2_dir_read_data(dip, (char *)lp,

						ht_offset * sizeof(__be64),

						sdp->sd_hash_bsize, 1);

			if (error != sdp->sd_hash_bsize) {

				if (error >= 0)

					error = -EIO;

				goto out;

			}

			ht_offset_cur = ht_offset;

		}



		error = gfs2_dir_read_leaf(inode, offset, opaque, filldir,

					   &copied, &depth,

					   be64_to_cpu(lp[lp_offset]));

					   be64_to_cpu(lp[index]));

		if (error)

			break;
@@ -1410,8 +1431,6 @@ static int dir_e_read(struct inode *inode, u64 *offset, void *opaque, 
		index = (index & ~(len - 1)) + len;

	}



out:

	kfree(lp);

	if (error > 0)

		error = 0;

	return error;
@@ -1914,43 +1933,22 @@ out: 


int gfs2_dir_exhash_dealloc(struct gfs2_inode *dip)

{

	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);

	struct buffer_head *bh;

	struct gfs2_leaf *leaf;

	u32 hsize, len;

	u32 ht_offset, lp_offset, ht_offset_cur = -1;

	u32 index = 0, next_index;

	__be64 *lp;

	u64 leaf_no;

	int error = 0, last;



	hsize = 1 << dip->i_depth;

	if (hsize * sizeof(u64) != i_size_read(&dip->i_inode)) {

		gfs2_consist_inode(dip);

		return -EIO;

	}



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

	if (!lp)

		return -ENOMEM;

	lp = gfs2_dir_get_hash_table(dip);

	if (IS_ERR(lp))

		return PTR_ERR(lp);



	while (index < hsize) {

		lp_offset = index & (sdp->sd_hash_ptrs - 1);

		ht_offset = index - lp_offset;



		if (ht_offset_cur != ht_offset) {

			error = gfs2_dir_read_data(dip, (char *)lp,

						ht_offset * sizeof(__be64),

						sdp->sd_hash_bsize, 1);

			if (error != sdp->sd_hash_bsize) {

				if (error >= 0)

					error = -EIO;

				goto out;

			}

			ht_offset_cur = ht_offset;

		}



		leaf_no = be64_to_cpu(lp[lp_offset]);

		leaf_no = be64_to_cpu(lp[index]);

		if (leaf_no) {

			error = get_leaf(dip, leaf_no, &bh);

			if (error)
@@ -1976,7 +1974,6 @@ int gfs2_dir_exhash_dealloc(struct gfs2_inode *dip) 
	}



out:

	kfree(lp);



	return error;

}

fs/gfs2/dir.h

+1 −0
Original line number Diff line number Diff line
@@ -35,6 +35,7 @@ extern int gfs2_diradd_alloc_required(struct inode *dir, 
				      const struct qstr *filename);

extern int gfs2_dir_get_new_buffer(struct gfs2_inode *ip, u64 block,

				   struct buffer_head **bhp);

extern void gfs2_dir_hash_inval(struct gfs2_inode *ip);



static inline u32 gfs2_disk_hash(const char *data, int len)

{

fs/gfs2/file.c

+3 −1
Original line number Diff line number Diff line
@@ -174,7 +174,9 @@ void gfs2_set_inode_flags(struct inode *inode) 
	struct gfs2_inode *ip = GFS2_I(inode);

	unsigned int flags = inode->i_flags;



	flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);

	flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|S_NOSEC);

	if ((ip->i_eattr == 0) && !is_sxid(inode->i_mode))

		inode->i_flags |= S_NOSEC;

	if (ip->i_diskflags & GFS2_DIF_IMMUTABLE)

		flags |= S_IMMUTABLE;

	if (ip->i_diskflags & GFS2_DIF_APPENDONLY)

fs/gfs2/glock.c

+29 −10
Original line number Diff line number Diff line
@@ -409,6 +409,10 @@ static void state_change(struct gfs2_glock *gl, unsigned int new_state) 
	if (held1 && held2 && list_empty(&gl->gl_holders))

		clear_bit(GLF_QUEUED, &gl->gl_flags);



	if (new_state != gl->gl_target)

		/* shorten our minimum hold time */

		gl->gl_hold_time = max(gl->gl_hold_time - GL_GLOCK_HOLD_DECR,

				       GL_GLOCK_MIN_HOLD);

	gl->gl_state = new_state;

	gl->gl_tchange = jiffies;

}
@@ -668,7 +672,7 @@ static void glock_work_func(struct work_struct *work) 
	    gl->gl_demote_state != LM_ST_EXCLUSIVE) {

		unsigned long holdtime, now = jiffies;



		holdtime = gl->gl_tchange + gl->gl_ops->go_min_hold_time;

		holdtime = gl->gl_tchange + gl->gl_hold_time;

		if (time_before(now, holdtime))

			delay = holdtime - now;
@@ -679,9 +683,14 @@ static void glock_work_func(struct work_struct *work) 
	}

	run_queue(gl, 0);

	spin_unlock(&gl->gl_spin);

	if (!delay ||

	    queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)

	if (!delay)

		gfs2_glock_put(gl);

	else {

		if (gl->gl_name.ln_type != LM_TYPE_INODE)

			delay = 0;

		if (queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)

			gfs2_glock_put(gl);

	}

	if (drop_ref)

		gfs2_glock_put(gl);

}
@@ -743,6 +752,7 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number, 
	gl->gl_tchange = jiffies;

	gl->gl_object = NULL;

	gl->gl_sbd = sdp;

	gl->gl_hold_time = GL_GLOCK_DFT_HOLD;

	INIT_DELAYED_WORK(&gl->gl_work, glock_work_func);

	INIT_WORK(&gl->gl_delete, delete_work_func);
@@ -855,8 +865,15 @@ static int gfs2_glock_demote_wait(void *word) 


static void wait_on_holder(struct gfs2_holder *gh)

{

	unsigned long time1 = jiffies;



	might_sleep();

	wait_on_bit(&gh->gh_iflags, HIF_WAIT, gfs2_glock_holder_wait, TASK_UNINTERRUPTIBLE);

	if (time_after(jiffies, time1 + HZ)) /* have we waited > a second? */

		/* Lengthen the minimum hold time. */

		gh->gh_gl->gl_hold_time = min(gh->gh_gl->gl_hold_time +

					      GL_GLOCK_HOLD_INCR,

					      GL_GLOCK_MAX_HOLD);

}



static void wait_on_demote(struct gfs2_glock *gl)
@@ -1093,8 +1110,9 @@ void gfs2_glock_dq(struct gfs2_holder *gh) 


	gfs2_glock_hold(gl);

	if (test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&

	    !test_bit(GLF_DEMOTE, &gl->gl_flags))

		delay = gl->gl_ops->go_min_hold_time;

	    !test_bit(GLF_DEMOTE, &gl->gl_flags) &&

	    gl->gl_name.ln_type == LM_TYPE_INODE)

		delay = gl->gl_hold_time;

	if (queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)

		gfs2_glock_put(gl);

}
@@ -1273,12 +1291,13 @@ void gfs2_glock_cb(struct gfs2_glock *gl, unsigned int state) 
	unsigned long now = jiffies;



	gfs2_glock_hold(gl);

	holdtime = gl->gl_tchange + gl->gl_ops->go_min_hold_time;

	if (test_bit(GLF_QUEUED, &gl->gl_flags)) {

	holdtime = gl->gl_tchange + gl->gl_hold_time;

	if (test_bit(GLF_QUEUED, &gl->gl_flags) &&

	    gl->gl_name.ln_type == LM_TYPE_INODE) {

		if (time_before(now, holdtime))

			delay = holdtime - now;

		if (test_bit(GLF_REPLY_PENDING, &gl->gl_flags))

			delay = gl->gl_ops->go_min_hold_time;

			delay = gl->gl_hold_time;

	}



	spin_lock(&gl->gl_spin);
@@ -1667,7 +1686,7 @@ static int __dump_glock(struct seq_file *seq, const struct gfs2_glock *gl) 
	dtime *= 1000000/HZ; /* demote time in uSec */

	if (!test_bit(GLF_DEMOTE, &gl->gl_flags))

		dtime = 0;

	gfs2_print_dbg(seq, "G:  s:%s n:%u/%llx f:%s t:%s d:%s/%llu a:%d v:%d r:%d\n",

	gfs2_print_dbg(seq, "G:  s:%s n:%u/%llx f:%s t:%s d:%s/%llu a:%d v:%d r:%d m:%ld\n",

		  state2str(gl->gl_state),

		  gl->gl_name.ln_type,

		  (unsigned long long)gl->gl_name.ln_number,
@@ -1676,7 +1695,7 @@ static int __dump_glock(struct seq_file *seq, const struct gfs2_glock *gl) 
		  state2str(gl->gl_demote_state), dtime,

		  atomic_read(&gl->gl_ail_count),

		  atomic_read(&gl->gl_revokes),

		  atomic_read(&gl->gl_ref));

		  atomic_read(&gl->gl_ref), gl->gl_hold_time);



	list_for_each_entry(gh, &gl->gl_holders, gh_list) {

		error = dump_holder(seq, gh);