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

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

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

* git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-2.6-fixes:
  GFS2: filesystem hang caused by incorrect lock order
  GFS2: Don't try to deallocate unlinked inodes when mounted ro
  GFS2: directly write blocks past i_size
  GFS2: write_end error path fails to unlock transaction lock
parents f0e615c3 44ad37d6

fs/gfs2/aops.c

+1 −1
Original line number Diff line number Diff line
@@ -884,8 +884,8 @@ static int gfs2_write_end(struct file *file, struct address_space *mapping, 
	}



	brelse(dibh);

	gfs2_trans_end(sdp);

failed:

	gfs2_trans_end(sdp);

	if (al) {

		gfs2_inplace_release(ip);

		gfs2_quota_unlock(ip);

fs/gfs2/dir.c

+1 −1
Original line number Diff line number Diff line
@@ -1506,7 +1506,7 @@ struct inode *gfs2_dir_search(struct inode *dir, const struct qstr *name) 
		inode = gfs2_inode_lookup(dir->i_sb, 

				be16_to_cpu(dent->de_type),

				be64_to_cpu(dent->de_inum.no_addr),

				be64_to_cpu(dent->de_inum.no_formal_ino));

				be64_to_cpu(dent->de_inum.no_formal_ino), 0);

		brelse(bh);

		return inode;

	}

fs/gfs2/file.c

+48 −10
Original line number Diff line number Diff line
@@ -617,18 +617,51 @@ static ssize_t gfs2_file_aio_write(struct kiocb *iocb, const struct iovec *iov, 
	return generic_file_aio_write(iocb, iov, nr_segs, pos);

}



static void empty_write_end(struct page *page, unsigned from,

			   unsigned to)

static int empty_write_end(struct page *page, unsigned from,

			   unsigned to, int mode)

{

	struct gfs2_inode *ip = GFS2_I(page->mapping->host);

	struct inode *inode = page->mapping->host;

	struct gfs2_inode *ip = GFS2_I(inode);

	struct buffer_head *bh;

	unsigned offset, blksize = 1 << inode->i_blkbits;

	pgoff_t end_index = i_size_read(inode) >> PAGE_CACHE_SHIFT;



	zero_user(page, from, to-from);

	mark_page_accessed(page);



	if (page->index < end_index || !(mode & FALLOC_FL_KEEP_SIZE)) {

		if (!gfs2_is_writeback(ip))

			gfs2_page_add_databufs(ip, page, from, to);



		block_commit_write(page, from, to);

		return 0;

	}



	offset = 0;

	bh = page_buffers(page);

	while (offset < to) {

		if (offset >= from) {

			set_buffer_uptodate(bh);

			mark_buffer_dirty(bh);

			clear_buffer_new(bh);

			write_dirty_buffer(bh, WRITE);

		}

		offset += blksize;

		bh = bh->b_this_page;

	}



	offset = 0;

	bh = page_buffers(page);

	while (offset < to) {

		if (offset >= from) {

			wait_on_buffer(bh);

			if (!buffer_uptodate(bh))

				return -EIO;

		}

		offset += blksize;

		bh = bh->b_this_page;

	}

	return 0;

}



static int needs_empty_write(sector_t block, struct inode *inode)
@@ -643,7 +676,8 @@ static int needs_empty_write(sector_t block, struct inode *inode) 
	return !buffer_mapped(&bh_map);

}



static int write_empty_blocks(struct page *page, unsigned from, unsigned to)

static int write_empty_blocks(struct page *page, unsigned from, unsigned to,

			      int mode)

{

	struct inode *inode = page->mapping->host;

	unsigned start, end, next, blksize;
@@ -668,7 +702,9 @@ static int write_empty_blocks(struct page *page, unsigned from, unsigned to) 
							  gfs2_block_map);

				if (unlikely(ret))

					return ret;

				empty_write_end(page, start, end);

				ret = empty_write_end(page, start, end, mode);

				if (unlikely(ret))

					return ret;

				end = 0;

			}

			start = next;
@@ -682,7 +718,9 @@ static int write_empty_blocks(struct page *page, unsigned from, unsigned to) 
		ret = __block_write_begin(page, start, end - start, gfs2_block_map);

		if (unlikely(ret))

			return ret;

		empty_write_end(page, start, end);

		ret = empty_write_end(page, start, end, mode);

		if (unlikely(ret))

			return ret;

	}



	return 0;
@@ -731,7 +769,7 @@ static int fallocate_chunk(struct inode *inode, loff_t offset, loff_t len, 


		if (curr == end)

			to = end_offset;

		error = write_empty_blocks(page, from, to);

		error = write_empty_blocks(page, from, to, mode);

		if (!error && offset + to > inode->i_size &&

		    !(mode & FALLOC_FL_KEEP_SIZE)) {

			i_size_write(inode, offset + to);

fs/gfs2/glops.c

+4 −0
Original line number Diff line number Diff line
@@ -385,6 +385,10 @@ static int trans_go_demote_ok(const struct gfs2_glock *gl) 
static void iopen_go_callback(struct gfs2_glock *gl)

{

	struct gfs2_inode *ip = (struct gfs2_inode *)gl->gl_object;

	struct gfs2_sbd *sdp = gl->gl_sbd;



	if (sdp->sd_vfs->s_flags & MS_RDONLY)

		return;



	if (gl->gl_demote_state == LM_ST_UNLOCKED &&

	    gl->gl_state == LM_ST_SHARED && ip) {

fs/gfs2/inode.c

+41 −15
Original line number Diff line number Diff line
@@ -40,37 +40,61 @@ struct gfs2_inum_range_host { 
	u64 ir_length;

};



struct gfs2_skip_data {

	u64 no_addr;

	int skipped;

	int non_block;

};



static int iget_test(struct inode *inode, void *opaque)

{

	struct gfs2_inode *ip = GFS2_I(inode);

	u64 *no_addr = opaque;

	struct gfs2_skip_data *data = opaque;



	if (ip->i_no_addr == *no_addr)

	if (ip->i_no_addr == data->no_addr) {

		if (data->non_block &&

		    inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)) {

			data->skipped = 1;

			return 0;

		}

		return 1;



	}

	return 0;

}



static int iget_set(struct inode *inode, void *opaque)

{

	struct gfs2_inode *ip = GFS2_I(inode);

	u64 *no_addr = opaque;

	struct gfs2_skip_data *data = opaque;



	inode->i_ino = (unsigned long)*no_addr;

	ip->i_no_addr = *no_addr;

	if (data->skipped)

		return -ENOENT;

	inode->i_ino = (unsigned long)(data->no_addr);

	ip->i_no_addr = data->no_addr;

	return 0;

}



struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr)

{

	unsigned long hash = (unsigned long)no_addr;

	return ilookup5(sb, hash, iget_test, &no_addr);

	struct gfs2_skip_data data;



	data.no_addr = no_addr;

	data.skipped = 0;

	data.non_block = 0;

	return ilookup5(sb, hash, iget_test, &data);

}



static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr)

static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr,

			       int non_block)

{

	struct gfs2_skip_data data;

	unsigned long hash = (unsigned long)no_addr;

	return iget5_locked(sb, hash, iget_test, iget_set, &no_addr);



	data.no_addr = no_addr;

	data.skipped = 0;

	data.non_block = non_block;

	return iget5_locked(sb, hash, iget_test, iget_set, &data);

}



/**
@@ -111,19 +135,20 @@ static void gfs2_set_iop(struct inode *inode) 
 * @sb: The super block

 * @no_addr: The inode number

 * @type: The type of the inode

 * non_block: Can we block on inodes that are being freed?

 *

 * Returns: A VFS inode, or an error

 */



struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int type,

				u64 no_addr, u64 no_formal_ino)

				u64 no_addr, u64 no_formal_ino, int non_block)

{

	struct inode *inode;

	struct gfs2_inode *ip;

	struct gfs2_glock *io_gl = NULL;

	int error;



	inode = gfs2_iget(sb, no_addr);

	inode = gfs2_iget(sb, no_addr, non_block);

	ip = GFS2_I(inode);



	if (!inode)
@@ -185,11 +210,12 @@ struct inode *gfs2_lookup_by_inum(struct gfs2_sbd *sdp, u64 no_addr, 
{

	struct super_block *sb = sdp->sd_vfs;

	struct gfs2_holder i_gh;

	struct inode *inode;

	struct inode *inode = NULL;

	int error;



	/* Must not read in block until block type is verified */

	error = gfs2_glock_nq_num(sdp, no_addr, &gfs2_inode_glops,

				  LM_ST_SHARED, LM_FLAG_ANY, &i_gh);

				  LM_ST_EXCLUSIVE, GL_SKIP, &i_gh);

	if (error)

		return ERR_PTR(error);
@@ -197,7 +223,7 @@ struct inode *gfs2_lookup_by_inum(struct gfs2_sbd *sdp, u64 no_addr, 
	if (error)

		goto fail;



	inode = gfs2_inode_lookup(sb, DT_UNKNOWN, no_addr, 0);

	inode = gfs2_inode_lookup(sb, DT_UNKNOWN, no_addr, 0, 1);

	if (IS_ERR(inode))

		goto fail;
@@ -843,7 +869,7 @@ struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name, 
		goto fail_gunlock2;



	inode = gfs2_inode_lookup(dir->i_sb, IF2DT(mode), inum.no_addr,

				  inum.no_formal_ino);

				  inum.no_formal_ino, 0);

	if (IS_ERR(inode))

		goto fail_gunlock2;