Commit 8418dabd authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'gfs2-v5.13-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/gfs2/linux-gfs2 

Pull gfs2 updates from Andreas Gruenbacher:
 "Various minor gfs2 cleanups and fixes"

* tag 'gfs2-v5.13-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/gfs2/linux-gfs2:
  gfs2: Clean up gfs2_unstuff_dinode
  gfs2: Unstuff before locking page in gfs2_page_mkwrite
  gfs2: Clean up the error handling in gfs2_page_mkwrite
  gfs2: Fix error handling in init_statfs
  gfs2: Fix underflow in gfs2_page_mkwrite
  gfs2: Use list_move_tail instead of list_del/list_add_tail
  gfs2: Fix do_gfs2_set_flags description
parents bbd91626 7a607a41

fs/gfs2/bmap.c

+31 −31
Original line number Diff line number Diff line
@@ -56,14 +56,6 @@ static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh, 
			       u64 block, struct page *page)

{

	struct inode *inode = &ip->i_inode;

	int release = 0;



	if (!page || page->index) {

		page = find_or_create_page(inode->i_mapping, 0, GFP_NOFS);

		if (!page)

			return -ENOMEM;

		release = 1;

	}



	if (!PageUptodate(page)) {

		void *kaddr = kmap(page);
@@ -97,26 +89,10 @@ static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh, 
		gfs2_ordered_add_inode(ip);

	}



	if (release) {

		unlock_page(page);

		put_page(page);

	}



	return 0;

}



/**

 * gfs2_unstuff_dinode - Unstuff a dinode when the data has grown too big

 * @ip: The GFS2 inode to unstuff

 * @page: The (optional) page. This is looked up if the @page is NULL

 *

 * This routine unstuffs a dinode and returns it to a "normal" state such

 * that the height can be grown in the traditional way.

 *

 * Returns: errno

 */



int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page)

static int __gfs2_unstuff_inode(struct gfs2_inode *ip, struct page *page)

{

	struct buffer_head *bh, *dibh;

	struct gfs2_dinode *di;
@@ -124,11 +100,9 @@ int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page) 
	int isdir = gfs2_is_dir(ip);

	int error;



	down_write(&ip->i_rw_mutex);



	error = gfs2_meta_inode_buffer(ip, &dibh);

	if (error)

		goto out;

		return error;



	if (i_size_read(&ip->i_inode)) {

		/* Get a free block, fill it with the stuffed data,
@@ -170,12 +144,38 @@ int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page) 


out_brelse:

	brelse(dibh);

	return error;

}



/**

 * gfs2_unstuff_dinode - Unstuff a dinode when the data has grown too big

 * @ip: The GFS2 inode to unstuff

 *

 * This routine unstuffs a dinode and returns it to a "normal" state such

 * that the height can be grown in the traditional way.

 *

 * Returns: errno

 */



int gfs2_unstuff_dinode(struct gfs2_inode *ip)

{

	struct inode *inode = &ip->i_inode;

	struct page *page;

	int error;



	down_write(&ip->i_rw_mutex);

	page = find_or_create_page(inode->i_mapping, 0, GFP_NOFS);

	error = -ENOMEM;

	if (!page)

		goto out;

	error = __gfs2_unstuff_inode(ip, page);

	unlock_page(page);

	put_page(page);

out:

	up_write(&ip->i_rw_mutex);

	return error;

}





/**

 * find_metapath - Find path through the metadata tree

 * @sdp: The superblock
@@ -1079,7 +1079,7 @@ static int gfs2_iomap_begin_write(struct inode *inode, loff_t pos, 
			goto out_trans_fail;



		if (unstuff) {

			ret = gfs2_unstuff_dinode(ip, NULL);

			ret = gfs2_unstuff_dinode(ip);

			if (ret)

				goto out_trans_end;

			release_metapath(mp);
@@ -2143,7 +2143,7 @@ static int do_grow(struct inode *inode, u64 size) 
		goto do_grow_release;



	if (unstuff) {

		error = gfs2_unstuff_dinode(ip, NULL);

		error = gfs2_unstuff_dinode(ip);

		if (error)

			goto do_end_trans;

	}

fs/gfs2/bmap.h

+1 −1
Original line number Diff line number Diff line
@@ -46,7 +46,7 @@ static inline void gfs2_write_calc_reserv(const struct gfs2_inode *ip, 
extern const struct iomap_ops gfs2_iomap_ops;

extern const struct iomap_writeback_ops gfs2_writeback_ops;



extern int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page);

extern int gfs2_unstuff_dinode(struct gfs2_inode *ip);

extern int gfs2_block_map(struct inode *inode, sector_t lblock,

			  struct buffer_head *bh, int create);

extern int gfs2_iomap_get(struct inode *inode, loff_t pos, loff_t length,

fs/gfs2/dir.c

+1 −1
Original line number Diff line number Diff line
@@ -172,7 +172,7 @@ static int gfs2_dir_write_data(struct gfs2_inode *ip, const char *buf, 
		return -EINVAL;



	if (gfs2_is_stuffed(ip)) {

		error = gfs2_unstuff_dinode(ip, NULL);

		error = gfs2_unstuff_dinode(ip);

		if (error)

			return error;

	}

fs/gfs2/file.c

+49 −30
Original line number Diff line number Diff line
@@ -210,7 +210,7 @@ void gfs2_set_inode_flags(struct inode *inode) 


/**

 * do_gfs2_set_flags - set flags on an inode

 * @filp: file pointer

 * @inode: The inode

 * @reqflags: The flags to set

 * @mask: Indicates which flags are valid

 * @fsflags: The FS_* inode flags passed in
@@ -427,22 +427,25 @@ static vm_fault_t gfs2_page_mkwrite(struct vm_fault *vmf) 
	struct gfs2_alloc_parms ap = { .aflags = 0, };

	u64 offset = page_offset(page);

	unsigned int data_blocks, ind_blocks, rblocks;

	vm_fault_t ret = VM_FAULT_LOCKED;

	struct gfs2_holder gh;

	unsigned int length;

	loff_t size;

	int ret;

	int err;



	sb_start_pagefault(inode->i_sb);



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

	ret = gfs2_glock_nq(&gh);

	if (ret)

	err = gfs2_glock_nq(&gh);

	if (err) {

		ret = block_page_mkwrite_return(err);

		goto out_uninit;

	}



	/* Check page index against inode size */

	size = i_size_read(inode);

	if (offset >= size) {

		ret = -EINVAL;

		ret = VM_FAULT_SIGBUS;

		goto out_unlock;

	}
@@ -450,8 +453,8 @@ static vm_fault_t gfs2_page_mkwrite(struct vm_fault *vmf) 
	file_update_time(vmf->vma->vm_file);



	/* page is wholly or partially inside EOF */

	if (offset > size - PAGE_SIZE)

		length = offset_in_page(size);

	if (size - offset < PAGE_SIZE)

		length = size - offset;

	else

		length = PAGE_SIZE;
@@ -469,24 +472,30 @@ static vm_fault_t gfs2_page_mkwrite(struct vm_fault *vmf) 
	    !gfs2_write_alloc_required(ip, offset, length)) {

		lock_page(page);

		if (!PageUptodate(page) || page->mapping != inode->i_mapping) {

			ret = -EAGAIN;

			ret = VM_FAULT_NOPAGE;

			unlock_page(page);

		}

		goto out_unlock;

	}



	ret = gfs2_rindex_update(sdp);

	if (ret)

	err = gfs2_rindex_update(sdp);

	if (err) {

		ret = block_page_mkwrite_return(err);

		goto out_unlock;

	}



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

	ap.target = data_blocks + ind_blocks;

	ret = gfs2_quota_lock_check(ip, &ap);

	if (ret)

	err = gfs2_quota_lock_check(ip, &ap);

	if (err) {

		ret = block_page_mkwrite_return(err);

		goto out_unlock;

	ret = gfs2_inplace_reserve(ip, &ap);

	if (ret)

	}

	err = gfs2_inplace_reserve(ip, &ap);

	if (err) {

		ret = block_page_mkwrite_return(err);

		goto out_quota_unlock;

	}



	rblocks = RES_DINODE + ind_blocks;

	if (gfs2_is_jdata(ip))
@@ -495,28 +504,38 @@ static vm_fault_t gfs2_page_mkwrite(struct vm_fault *vmf) 
		rblocks += RES_STATFS + RES_QUOTA;

		rblocks += gfs2_rg_blocks(ip, data_blocks + ind_blocks);

	}

	ret = gfs2_trans_begin(sdp, rblocks, 0);

	if (ret)

	err = gfs2_trans_begin(sdp, rblocks, 0);

	if (err) {

		ret = block_page_mkwrite_return(err);

		goto out_trans_fail;

	}



	/* Unstuff, if required, and allocate backing blocks for page */

	if (gfs2_is_stuffed(ip)) {

		err = gfs2_unstuff_dinode(ip);

		if (err) {

			ret = block_page_mkwrite_return(err);

			goto out_trans_end;

		}

	}



	lock_page(page);

	ret = -EAGAIN;

	/* If truncated, we must retry the operation, we may have raced

	 * with the glock demotion code.

	 */

	if (!PageUptodate(page) || page->mapping != inode->i_mapping)

		goto out_trans_end;

	if (!PageUptodate(page) || page->mapping != inode->i_mapping) {

		ret = VM_FAULT_NOPAGE;

		goto out_page_locked;

	}



	/* Unstuff, if required, and allocate backing blocks for page */

	ret = 0;

	if (gfs2_is_stuffed(ip))

		ret = gfs2_unstuff_dinode(ip, page);

	if (ret == 0)

		ret = gfs2_allocate_page_backing(page, length);

	err = gfs2_allocate_page_backing(page, length);

	if (err)

		ret = block_page_mkwrite_return(err);



out_trans_end:

	if (ret)

out_page_locked:

	if (ret != VM_FAULT_LOCKED)

		unlock_page(page);

out_trans_end:

	gfs2_trans_end(sdp);

out_trans_fail:

	gfs2_inplace_release(ip);
@@ -526,12 +545,12 @@ static vm_fault_t gfs2_page_mkwrite(struct vm_fault *vmf) 
	gfs2_glock_dq(&gh);

out_uninit:

	gfs2_holder_uninit(&gh);

	if (ret == 0) {

	if (ret == VM_FAULT_LOCKED) {

		set_page_dirty(page);

		wait_for_stable_page(page);

	}

	sb_end_pagefault(inode->i_sb);

	return block_page_mkwrite_return(ret);

	return ret;

}



static vm_fault_t gfs2_fault(struct vm_fault *vmf)
@@ -962,7 +981,7 @@ static int fallocate_chunk(struct inode *inode, loff_t offset, loff_t len, 
	gfs2_trans_add_meta(ip->i_gl, dibh);



	if (gfs2_is_stuffed(ip)) {

		error = gfs2_unstuff_dinode(ip, NULL);

		error = gfs2_unstuff_dinode(ip);

		if (unlikely(error))

			goto out;

	}

fs/gfs2/glock.c

+1 −2
Original line number Diff line number Diff line
@@ -212,8 +212,7 @@ void gfs2_glock_add_to_lru(struct gfs2_glock *gl) 


	spin_lock(&lru_lock);



	list_del(&gl->gl_lru);

	list_add_tail(&gl->gl_lru, &lru_list);

	list_move_tail(&gl->gl_lru, &lru_list);



	if (!test_bit(GLF_LRU, &gl->gl_flags)) {

		set_bit(GLF_LRU, &gl->gl_flags);