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

Commit 9b9a72a8 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:
 "This is one of the smallest collections of patches for the merge
  window for some time.  There are some clean ups relating to the
  transaction code and the shrinker, which are mostly in preparation for
  further development, but also make the code much easier to follow in
  these areas.

  There is a patch which allows the use of ->writepages even in the
  default ordered write mode for all writebacks.  This results in
  sending larger i/os to the block layer, and a subsequent increase in
  performance.  It also reduces the number of different i/o paths by
  one.

  There is also a bug fix reinstating the withdraw ack system which
  somehow got lost when the lock modules were merged into GFS2."

* git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-3.0-nmw:
  GFS2: Reinstate withdraw ack system
  GFS2: Get a block reservation before resizing a file
  GFS2: Split glock lru processing into two parts
  GFS2: Use ->writepages for ordered writes
  GFS2: Clean up freeze code
  GFS2: Merge gfs2_attach_bufdata() into trans.c
  GFS2: Copy gfs2_trans_add_bh into new data/meta functions
  GFS2: Split gfs2_trans_add_bh() into two
  GFS2: Merge revoke adding functions
  GFS2: Separate LRU scanning from shrinker
parents 736a4c11 fd95e81c

fs/gfs2/aops.c

+8 −9
Original line number Diff line number Diff line
@@ -51,7 +51,7 @@ static void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page, 
			continue;

		if (gfs2_is_jdata(ip))

			set_buffer_uptodate(bh);

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

		gfs2_trans_add_data(ip->i_gl, bh);

	}

}
@@ -230,15 +230,13 @@ static int gfs2_jdata_writepage(struct page *page, struct writeback_control *wbc 
}



/**

 * gfs2_writeback_writepages - Write a bunch of dirty pages back to disk

 * gfs2_writepages - Write a bunch of dirty pages back to disk

 * @mapping: The mapping to write

 * @wbc: Write-back control

 *

 * For the data=writeback case we can already ignore buffer heads

 * and write whole extents at once. This is a big reduction in the

 * number of I/O requests we send and the bmap calls we make in this case.

 * Used for both ordered and writeback modes.

 */

static int gfs2_writeback_writepages(struct address_space *mapping,

static int gfs2_writepages(struct address_space *mapping,

			   struct writeback_control *wbc)

{

	return mpage_writepages(mapping, wbc, gfs2_get_block_noalloc);
@@ -852,7 +850,7 @@ static int gfs2_write_end(struct file *file, struct address_space *mapping, 
		goto failed;

	}



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

	gfs2_trans_add_meta(ip->i_gl, dibh);



	if (gfs2_is_stuffed(ip))

		return gfs2_stuffed_write_end(inode, dibh, pos, len, copied, page);
@@ -1102,7 +1100,7 @@ int gfs2_releasepage(struct page *page, gfp_t gfp_mask) 


static const struct address_space_operations gfs2_writeback_aops = {

	.writepage = gfs2_writeback_writepage,

	.writepages = gfs2_writeback_writepages,

	.writepages = gfs2_writepages,

	.readpage = gfs2_readpage,

	.readpages = gfs2_readpages,

	.write_begin = gfs2_write_begin,
@@ -1118,6 +1116,7 @@ static const struct address_space_operations gfs2_writeback_aops = { 


static const struct address_space_operations gfs2_ordered_aops = {

	.writepage = gfs2_ordered_writepage,

	.writepages = gfs2_writepages,

	.readpage = gfs2_readpage,

	.readpages = gfs2_readpages,

	.write_begin = gfs2_write_begin,

fs/gfs2/bmap.c

+18 −12
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ 
#include "meta_io.h"

#include "quota.h"

#include "rgrp.h"

#include "log.h"

#include "super.h"

#include "trans.h"

#include "dir.h"
@@ -93,7 +94,7 @@ static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh, 
	if (!gfs2_is_jdata(ip))

		mark_buffer_dirty(bh);

	if (!gfs2_is_writeback(ip))

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

		gfs2_trans_add_data(ip->i_gl, bh);



	if (release) {

		unlock_page(page);
@@ -153,7 +154,7 @@ int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page) 


	/*  Set up the pointer to the new block  */



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

	gfs2_trans_add_meta(ip->i_gl, dibh);

	di = (struct gfs2_dinode *)dibh->b_data;

	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
@@ -405,7 +406,7 @@ static inline __be64 *gfs2_indirect_init(struct metapath *mp, 
	BUG_ON(i < 1);

	BUG_ON(mp->mp_bh[i] != NULL);

	mp->mp_bh[i] = gfs2_meta_new(gl, bn);

	gfs2_trans_add_bh(gl, mp->mp_bh[i], 1);

	gfs2_trans_add_meta(gl, mp->mp_bh[i]);

	gfs2_metatype_set(mp->mp_bh[i], GFS2_METATYPE_IN, GFS2_FORMAT_IN);

	gfs2_buffer_clear_tail(mp->mp_bh[i], sizeof(struct gfs2_meta_header));

	ptr += offset;
@@ -468,7 +469,7 @@ static int gfs2_bmap_alloc(struct inode *inode, const sector_t lblock, 
	BUG_ON(sheight < 1);

	BUG_ON(dibh == NULL);



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

	gfs2_trans_add_meta(ip->i_gl, dibh);



	if (height == sheight) {

		struct buffer_head *bh;
@@ -544,7 +545,7 @@ static int gfs2_bmap_alloc(struct inode *inode, const sector_t lblock, 
		/* Branching from existing tree */

		case ALLOC_GROW_DEPTH:

			if (i > 1 && i < height)

				gfs2_trans_add_bh(ip->i_gl, mp->mp_bh[i-1], 1);

				gfs2_trans_add_meta(ip->i_gl, mp->mp_bh[i-1]);

			for (; i < height && n > 0; i++, n--)

				gfs2_indirect_init(mp, ip->i_gl, i,

						   mp->mp_list[i-1], bn++);
@@ -556,7 +557,7 @@ static int gfs2_bmap_alloc(struct inode *inode, const sector_t lblock, 
		case ALLOC_DATA:

			BUG_ON(n > dblks);

			BUG_ON(mp->mp_bh[end_of_metadata] == NULL);

			gfs2_trans_add_bh(ip->i_gl, mp->mp_bh[end_of_metadata], 1);

			gfs2_trans_add_meta(ip->i_gl, mp->mp_bh[end_of_metadata]);

			dblks = n;

			ptr = metapointer(end_of_metadata, mp);

			dblock = bn;
@@ -796,8 +797,8 @@ static int do_strip(struct gfs2_inode *ip, struct buffer_head *dibh, 


	down_write(&ip->i_rw_mutex);



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

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

	gfs2_trans_add_meta(ip->i_gl, dibh);

	gfs2_trans_add_meta(ip->i_gl, bh);



	bstart = 0;

	blen = 0;
@@ -981,7 +982,7 @@ static int gfs2_block_truncate_page(struct address_space *mapping, loff_t from) 
	}



	if (!gfs2_is_writeback(ip))

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

		gfs2_trans_add_data(ip->i_gl, bh);



	zero_user(page, offset, length);

	mark_buffer_dirty(bh);
@@ -1046,7 +1047,7 @@ static int trunc_start(struct inode *inode, u64 oldsize, u64 newsize) 
	if (error)

		goto out;



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

	gfs2_trans_add_meta(ip->i_gl, dibh);



	if (gfs2_is_stuffed(ip)) {

		gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode) + newsize);
@@ -1137,11 +1138,12 @@ static int trunc_end(struct gfs2_inode *ip) 
		ip->i_height = 0;

		ip->i_goal = ip->i_no_addr;

		gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));

		gfs2_ordered_del_inode(ip);

	}

	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;

	ip->i_diskflags &= ~GFS2_DIF_TRUNC_IN_PROG;



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

	gfs2_trans_add_meta(ip->i_gl, dibh);

	gfs2_dinode_out(ip, dibh->b_data);

	brelse(dibh);
@@ -1246,7 +1248,7 @@ static int do_grow(struct inode *inode, u64 size) 


	i_size_write(inode, size);

	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;

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

	gfs2_trans_add_meta(ip->i_gl, dibh);

	gfs2_dinode_out(ip, dibh->b_data);

	brelse(dibh);
@@ -1286,6 +1288,10 @@ int gfs2_setattr_size(struct inode *inode, u64 newsize) 


	inode_dio_wait(inode);



	ret = gfs2_rs_alloc(GFS2_I(inode));

	if (ret)

		return ret;



	oldsize = inode->i_size;

	if (newsize >= oldsize)

		return do_grow(inode, newsize);

fs/gfs2/dir.c

+15 −15
Original line number Diff line number Diff line
@@ -93,7 +93,7 @@ int gfs2_dir_get_new_buffer(struct gfs2_inode *ip, u64 block, 
	struct buffer_head *bh;



	bh = gfs2_meta_new(ip->i_gl, block);

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

	gfs2_trans_add_meta(ip->i_gl, bh);

	gfs2_metatype_set(bh, GFS2_METATYPE_JD, GFS2_FORMAT_JD);

	gfs2_buffer_clear_tail(bh, sizeof(struct gfs2_meta_header));

	*bhp = bh;
@@ -127,7 +127,7 @@ static int gfs2_dir_write_stuffed(struct gfs2_inode *ip, const char *buf, 
	if (error)

		return error;



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

	gfs2_trans_add_meta(ip->i_gl, dibh);

	memcpy(dibh->b_data + offset + sizeof(struct gfs2_dinode), buf, size);

	if (ip->i_inode.i_size < offset + size)

		i_size_write(&ip->i_inode, offset + size);
@@ -209,7 +209,7 @@ static int gfs2_dir_write_data(struct gfs2_inode *ip, const char *buf, 
		if (error)

			goto fail;



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

		gfs2_trans_add_meta(ip->i_gl, bh);

		memcpy(bh->b_data + o, buf, amount);

		brelse(bh);
@@ -231,7 +231,7 @@ static int gfs2_dir_write_data(struct gfs2_inode *ip, const char *buf, 
		i_size_write(&ip->i_inode, offset + copied);

	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;



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

	gfs2_trans_add_meta(ip->i_gl, dibh);

	gfs2_dinode_out(ip, dibh->b_data);

	brelse(dibh);
@@ -647,7 +647,7 @@ static void dirent_del(struct gfs2_inode *dip, struct buffer_head *bh, 
		return;

	}



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

	gfs2_trans_add_meta(dip->i_gl, bh);



	/* If there is no prev entry, this is the first entry in the block.

	   The de_rec_len is already as big as it needs to be.  Just zero
@@ -690,7 +690,7 @@ static struct gfs2_dirent *gfs2_init_dirent(struct inode *inode, 
		offset = GFS2_DIRENT_SIZE(be16_to_cpu(dent->de_name_len));

	totlen = be16_to_cpu(dent->de_rec_len);

	BUG_ON(offset + name->len > totlen);

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

	gfs2_trans_add_meta(ip->i_gl, bh);

	ndent = (struct gfs2_dirent *)((char *)dent + offset);

	dent->de_rec_len = cpu_to_be16(offset);

	gfs2_qstr2dirent(name, totlen - offset, ndent);
@@ -831,7 +831,7 @@ static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh, 
		return NULL;



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

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

	gfs2_trans_add_meta(ip->i_gl, bh);

	gfs2_metatype_set(bh, GFS2_METATYPE_LF, GFS2_FORMAT_LF);

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

	leaf->lf_depth = cpu_to_be16(depth);
@@ -916,7 +916,7 @@ static int dir_make_exhash(struct inode *inode) 
	/*  We're done with the new leaf block, now setup the new

	    hash table.  */



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

	gfs2_trans_add_meta(dip->i_gl, dibh);

	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));



	lp = (__be64 *)(dibh->b_data + sizeof(struct gfs2_dinode));
@@ -976,7 +976,7 @@ static int dir_split_leaf(struct inode *inode, const struct qstr *name) 
		return 1; /* can't split */

	}



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

	gfs2_trans_add_meta(dip->i_gl, obh);



	nleaf = new_leaf(inode, &nbh, be16_to_cpu(oleaf->lf_depth) + 1);

	if (!nleaf) {
@@ -1069,7 +1069,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);

		gfs2_trans_add_meta(dip->i_gl, dibh);

		gfs2_add_inode_blocks(&dip->i_inode, 1);

		gfs2_dinode_out(dip, dibh->b_data);

		brelse(dibh);
@@ -1622,7 +1622,7 @@ static int dir_new_leaf(struct inode *inode, const struct qstr *name) 
			return error;

	} while(1);



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

	gfs2_trans_add_meta(ip->i_gl, obh);



	leaf = new_leaf(inode, &bh, be16_to_cpu(oleaf->lf_depth));

	if (!leaf) {
@@ -1636,7 +1636,7 @@ static int dir_new_leaf(struct inode *inode, const struct qstr *name) 
	error = gfs2_meta_inode_buffer(ip, &bh);

	if (error)

		return error;

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

	gfs2_trans_add_meta(ip->i_gl, bh);

	gfs2_add_inode_blocks(&ip->i_inode, 1);

	gfs2_dinode_out(ip, bh->b_data);

	brelse(bh);
@@ -1795,7 +1795,7 @@ int gfs2_dir_mvino(struct gfs2_inode *dip, const struct qstr *filename, 
	if (IS_ERR(dent))

		return PTR_ERR(dent);



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

	gfs2_trans_add_meta(dip->i_gl, bh);

	gfs2_inum_out(nip, dent);

	dent->de_type = cpu_to_be16(new_type);
@@ -1804,7 +1804,7 @@ int gfs2_dir_mvino(struct gfs2_inode *dip, const struct qstr *filename, 
		error = gfs2_meta_inode_buffer(dip, &bh);

		if (error)

			return error;

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

		gfs2_trans_add_meta(dip->i_gl, bh);

	}



	dip->i_inode.i_mtime = dip->i_inode.i_ctime = CURRENT_TIME;
@@ -1917,7 +1917,7 @@ static int leaf_dealloc(struct gfs2_inode *dip, u32 index, u32 len, 
	if (error)

		goto out_end_trans;



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

	gfs2_trans_add_meta(dip->i_gl, dibh);

	/* On the last dealloc, make this a regular file in case we crash.

	   (We don't want to free these blocks a second time.)  */

	if (last_dealloc)

fs/gfs2/file.c

+2 −2
Original line number Diff line number Diff line
@@ -276,7 +276,7 @@ static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask) 
	error = gfs2_meta_inode_buffer(ip, &bh);

	if (error)

		goto out_trans_end;

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

	gfs2_trans_add_meta(ip->i_gl, bh);

	ip->i_diskflags = new_flags;

	gfs2_dinode_out(ip, bh->b_data);

	brelse(bh);
@@ -709,7 +709,7 @@ static int fallocate_chunk(struct inode *inode, loff_t offset, loff_t len, 
	if (unlikely(error))

		return error;



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

	gfs2_trans_add_meta(ip->i_gl, dibh);



	if (gfs2_is_stuffed(ip)) {

		error = gfs2_unstuff_dinode(ip, NULL);

fs/gfs2/glock.c

+83 −33
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ 
#include <linux/rculist_bl.h>

#include <linux/bit_spinlock.h>

#include <linux/percpu.h>

#include <linux/list_sort.h>



#include "gfs2.h"

#include "incore.h"
@@ -1376,56 +1377,105 @@ void gfs2_glock_complete(struct gfs2_glock *gl, int ret) 
		gfs2_glock_put(gl);

}





static int gfs2_shrink_glock_memory(struct shrinker *shrink,

				    struct shrink_control *sc)

static int glock_cmp(void *priv, struct list_head *a, struct list_head *b)

{

	struct gfs2_glock *gl;

	int may_demote;

	int nr_skipped = 0;

	int nr = sc->nr_to_scan;

	gfp_t gfp_mask = sc->gfp_mask;

	LIST_HEAD(skipped);

	struct gfs2_glock *gla, *glb;



	if (nr == 0)

		goto out;

	gla = list_entry(a, struct gfs2_glock, gl_lru);

	glb = list_entry(b, struct gfs2_glock, gl_lru);



	if (!(gfp_mask & __GFP_FS))

	if (gla->gl_name.ln_number > glb->gl_name.ln_number)

		return 1;

	if (gla->gl_name.ln_number < glb->gl_name.ln_number)

		return -1;



	spin_lock(&lru_lock);

	while(nr && !list_empty(&lru_list)) {

		gl = list_entry(lru_list.next, struct gfs2_glock, gl_lru);

	return 0;

}



/**

 * gfs2_dispose_glock_lru - Demote a list of glocks

 * @list: The list to dispose of

 *

 * Disposing of glocks may involve disk accesses, so that here we sort

 * the glocks by number (i.e. disk location of the inodes) so that if

 * there are any such accesses, they'll be sent in order (mostly).

 *

 * Must be called under the lru_lock, but may drop and retake this

 * lock. While the lru_lock is dropped, entries may vanish from the

 * list, but no new entries will appear on the list (since it is

 * private)

 */



static void gfs2_dispose_glock_lru(struct list_head *list)

__releases(&lru_lock)

__acquires(&lru_lock)

{

	struct gfs2_glock *gl;



	list_sort(NULL, list, glock_cmp);



	while(!list_empty(list)) {

		gl = list_entry(list->next, struct gfs2_glock, gl_lru);

		list_del_init(&gl->gl_lru);

		clear_bit(GLF_LRU, &gl->gl_flags);

		atomic_dec(&lru_count);



		/* Test for being demotable */

		if (!test_and_set_bit(GLF_LOCK, &gl->gl_flags)) {

		gfs2_glock_hold(gl);

		spin_unlock(&lru_lock);

		spin_lock(&gl->gl_spin);

			may_demote = demote_ok(gl);

			if (may_demote) {

		if (demote_ok(gl))

			handle_callback(gl, LM_ST_UNLOCKED, 0);

				nr--;

			}

			clear_bit(GLF_LOCK, &gl->gl_flags);

		WARN_ON(!test_and_clear_bit(GLF_LOCK, &gl->gl_flags));

		smp_mb__after_clear_bit();

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

			gfs2_glock_put_nolock(gl);

		spin_unlock(&gl->gl_spin);

		spin_lock(&lru_lock);

	}

}



/**

 * gfs2_scan_glock_lru - Scan the LRU looking for locks to demote

 * @nr: The number of entries to scan

 *

 * This function selects the entries on the LRU which are able to

 * be demoted, and then kicks off the process by calling

 * gfs2_dispose_glock_lru() above.

 */



static void gfs2_scan_glock_lru(int nr)

{

	struct gfs2_glock *gl;

	LIST_HEAD(skipped);

	LIST_HEAD(dispose);



	spin_lock(&lru_lock);

	while(nr && !list_empty(&lru_list)) {

		gl = list_entry(lru_list.next, struct gfs2_glock, gl_lru);



		/* Test for being demotable */

		if (!test_and_set_bit(GLF_LOCK, &gl->gl_flags)) {

			list_move(&gl->gl_lru, &dispose);

			atomic_dec(&lru_count);

			nr--;

			continue;

		}

		nr_skipped++;

		list_add(&gl->gl_lru, &skipped);

		set_bit(GLF_LRU, &gl->gl_flags);



		list_move(&gl->gl_lru, &skipped);

	}

	list_splice(&skipped, &lru_list);

	atomic_add(nr_skipped, &lru_count);

	if (!list_empty(&dispose))

		gfs2_dispose_glock_lru(&dispose);

	spin_unlock(&lru_lock);

out:

}



static int gfs2_shrink_glock_memory(struct shrinker *shrink,

				    struct shrink_control *sc)

{

	if (sc->nr_to_scan) {

		if (!(sc->gfp_mask & __GFP_FS))

			return -1;

		gfs2_scan_glock_lru(sc->nr_to_scan);

	}



	return (atomic_read(&lru_count) / 100) * sysctl_vfs_cache_pressure;

}