Commit 3f1266ec authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'gfs2-for-5.5' of git://git.kernel.org/pub/scm/linux/kernel/git/gfs2/linux-gfs2 

Pull GFS2 updates from Andreas Gruenbacher:
 "Bob's extensive filesystem withdrawal and recovery testing:
   - don't write log headers after file system withdraw
   - clean up iopen glock mess in gfs2_create_inode
   - close timing window with GLF_INVALIDATE_IN_PROGRESS
   - abort gfs2_freeze if io error is seen
   - don't loop forever in gfs2_freeze if withdrawn
   - fix infinite loop in gfs2_ail1_flush on io error
   - introduce function gfs2_withdrawn
   - fix glock reference problem in gfs2_trans_remove_revoke

  Filesystems with a block size smaller than the page size:
   - fix end-of-file handling in gfs2_page_mkwrite
   - improve mmap write vs. punch_hole consistency

  Other:
   - remove active journal side effect from gfs2_write_log_header
   - multi-block allocations in gfs2_page_mkwrite

  Minor cleanups and coding style fixes:
   - remove duplicate call from gfs2_create_inode
   - make gfs2_log_shutdown static
   - make gfs2_fs_parameters static
   - some whitespace cleanups
   - removed unnecessary semicolon"

* tag 'gfs2-for-5.5' of git://git.kernel.org/pub/scm/linux/kernel/git/gfs2/linux-gfs2:
  gfs2: Don't write log headers after file system withdraw
  gfs2: Remove duplicate call from gfs2_create_inode
  gfs2: clean up iopen glock mess in gfs2_create_inode
  gfs2: Close timing window with GLF_INVALIDATE_IN_PROGRESS
  gfs2: Abort gfs2_freeze if io error is seen
  gfs2: Don't loop forever in gfs2_freeze if withdrawn
  gfs2: fix infinite loop in gfs2_ail1_flush on io error
  gfs2: Introduce function gfs2_withdrawn
  gfs2: fix glock reference problem in gfs2_trans_remove_revoke
  gfs2: make gfs2_log_shutdown static
  gfs2: Remove active journal side effect from gfs2_write_log_header
  gfs2: Fix end-of-file handling in gfs2_page_mkwrite
  gfs2: Multi-block allocations in gfs2_page_mkwrite
  gfs2: Improve mmap write vs. punch_hole consistency
  gfs2: make gfs2_fs_parameters static
  gfs2: Some whitespace cleanups
  gfs2: removed unnecessary semicolon
parents a2315823 ade48088

fs/gfs2/aops.c

+3 −3
Original line number Diff line number Diff line
@@ -497,7 +497,7 @@ static int __gfs2_readpage(void *file, struct page *page) 
		error = mpage_readpage(page, gfs2_block_map);

	}



	if (unlikely(test_bit(SDF_WITHDRAWN, &sdp->sd_flags)))

	if (unlikely(gfs2_withdrawn(sdp)))

		return -EIO;



	return error;
@@ -614,7 +614,7 @@ static int gfs2_readpages(struct file *file, struct address_space *mapping, 
	gfs2_glock_dq(&gh);

out_uninit:

	gfs2_holder_uninit(&gh);

	if (unlikely(test_bit(SDF_WITHDRAWN, &sdp->sd_flags)))

	if (unlikely(gfs2_withdrawn(sdp)))

		ret = -EIO;

	return ret;

}

fs/gfs2/bmap.c

+9 −2
Original line number Diff line number Diff line
@@ -2441,8 +2441,16 @@ int __gfs2_punch_hole(struct file *file, loff_t offset, loff_t length) 
	struct inode *inode = file_inode(file);

	struct gfs2_inode *ip = GFS2_I(inode);

	struct gfs2_sbd *sdp = GFS2_SB(inode);

	unsigned int blocksize = i_blocksize(inode);

	loff_t start, end;

	int error;



	start = round_down(offset, blocksize);

	end = round_up(offset + length, blocksize) - 1;

	error = filemap_write_and_wait_range(inode->i_mapping, start, end);

	if (error)

		return error;



	if (gfs2_is_jdata(ip))

		error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_JDATA,

					 GFS2_JTRUNC_REVOKES);
@@ -2456,9 +2464,8 @@ int __gfs2_punch_hole(struct file *file, loff_t offset, loff_t length) 
		if (error)

			goto out;

	} else {

		unsigned int start_off, end_len, blocksize;

		unsigned int start_off, end_len;



		blocksize = i_blocksize(inode);

		start_off = offset & (blocksize - 1);

		end_len = (offset + length) & (blocksize - 1);

		if (start_off) {

fs/gfs2/file.c

+35 −21
Original line number Diff line number Diff line
@@ -407,27 +407,28 @@ static void gfs2_size_hint(struct file *filep, loff_t offset, size_t size) 
/**

 * gfs2_allocate_page_backing - Allocate blocks for a write fault

 * @page: The (locked) page to allocate backing for

 * @length: Size of the allocation

 *

 * We try to allocate all the blocks required for the page in one go.  This

 * might fail for various reasons, so we keep trying until all the blocks to

 * back this page are allocated.  If some of the blocks are already allocated,

 * that is ok too.

 */

static int gfs2_allocate_page_backing(struct page *page)

static int gfs2_allocate_page_backing(struct page *page, unsigned int length)

{

	u64 pos = page_offset(page);

	u64 size = PAGE_SIZE;



	do {

		struct iomap iomap = { };



		if (gfs2_iomap_get_alloc(page->mapping->host, pos, 1, &iomap))

		if (gfs2_iomap_get_alloc(page->mapping->host, pos, length, &iomap))

			return -EIO;



		iomap.length = min(iomap.length, size);

		size -= iomap.length;

		if (length < iomap.length)

			iomap.length = length;

		length -= iomap.length;

		pos += iomap.length;

	} while (size > 0);

	} while (length > 0);



	return 0;

}
@@ -448,10 +449,10 @@ static vm_fault_t gfs2_page_mkwrite(struct vm_fault *vmf) 
	struct gfs2_inode *ip = GFS2_I(inode);

	struct gfs2_sbd *sdp = GFS2_SB(inode);

	struct gfs2_alloc_parms ap = { .aflags = 0, };

	unsigned long last_index;

	u64 pos = page_offset(page);

	u64 offset = page_offset(page);

	unsigned int data_blocks, ind_blocks, rblocks;

	struct gfs2_holder gh;

	unsigned int length;

	loff_t size;

	int ret;
@@ -461,20 +462,39 @@ static vm_fault_t gfs2_page_mkwrite(struct vm_fault *vmf) 
	if (ret)

		goto out;



	gfs2_size_hint(vmf->vma->vm_file, pos, PAGE_SIZE);



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

	ret = gfs2_glock_nq(&gh);

	if (ret)

		goto out_uninit;



	/* Check page index against inode size */

	size = i_size_read(inode);

	if (offset >= size) {

		ret = -EINVAL;

		goto out_unlock;

	}



	/* Update file times before taking page lock */

	file_update_time(vmf->vma->vm_file);



	/* page is wholly or partially inside EOF */

	if (offset > size - PAGE_SIZE)

		length = offset_in_page(size);

	else

		length = PAGE_SIZE;



	gfs2_size_hint(vmf->vma->vm_file, offset, length);



	set_bit(GLF_DIRTY, &ip->i_gl->gl_flags);

	set_bit(GIF_SW_PAGED, &ip->i_flags);



	if (!gfs2_write_alloc_required(ip, pos, PAGE_SIZE)) {

	/*

	 * iomap_writepage / iomap_writepages currently don't support inline

	 * files, so always unstuff here.

	 */



	if (!gfs2_is_stuffed(ip) &&

	    !gfs2_write_alloc_required(ip, offset, length)) {

		lock_page(page);

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

			ret = -EAGAIN;
@@ -487,7 +507,7 @@ static vm_fault_t gfs2_page_mkwrite(struct vm_fault *vmf) 
	if (ret)

		goto out_unlock;



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

	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)
@@ -508,13 +528,6 @@ static vm_fault_t gfs2_page_mkwrite(struct vm_fault *vmf) 
		goto out_trans_fail;



	lock_page(page);

	ret = -EINVAL;

	size = i_size_read(inode);

	last_index = (size - 1) >> PAGE_SHIFT;

	/* Check page index against inode size */

	if (size == 0 || (page->index > last_index))

		goto out_trans_end;



	ret = -EAGAIN;

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

	 * with the glock demotion code.
@@ -527,7 +540,7 @@ static vm_fault_t gfs2_page_mkwrite(struct vm_fault *vmf) 
	if (gfs2_is_stuffed(ip))

		ret = gfs2_unstuff_dinode(ip, page);

	if (ret == 0)

		ret = gfs2_allocate_page_backing(page);

		ret = gfs2_allocate_page_backing(page, length);



out_trans_end:

	if (ret)
@@ -961,6 +974,7 @@ out: 
	brelse(dibh);

	return error;

}



/**

 * calc_max_reserv() - Reverse of write_calc_reserv. Given a number of

 *                     blocks, determine how many bytes can be written.
@@ -1208,7 +1222,7 @@ static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl) 
		cmd = F_SETLK;

		fl->fl_type = F_UNLCK;

	}

	if (unlikely(test_bit(SDF_WITHDRAWN, &sdp->sd_flags))) {

	if (unlikely(gfs2_withdrawn(sdp))) {

		if (fl->fl_type == F_UNLCK)

			locks_lock_file_wait(file, fl);

		return -EIO;

fs/gfs2/glock.c

+11 −5
Original line number Diff line number Diff line
@@ -549,7 +549,7 @@ __acquires(&gl->gl_lockref.lock) 
	unsigned int lck_flags = (unsigned int)(gh ? gh->gh_flags : 0);

	int ret;



	if (unlikely(test_bit(SDF_WITHDRAWN, &sdp->sd_flags)) &&

	if (unlikely(gfs2_withdrawn(sdp)) &&

	    target != LM_ST_UNLOCKED)

		return;

	lck_flags &= (LM_FLAG_TRY | LM_FLAG_TRY_1CB | LM_FLAG_NOEXP |
@@ -558,7 +558,14 @@ __acquires(&gl->gl_lockref.lock) 
	GLOCK_BUG_ON(gl, gl->gl_state == gl->gl_target);

	if ((target == LM_ST_UNLOCKED || target == LM_ST_DEFERRED) &&

	    glops->go_inval) {

		set_bit(GLF_INVALIDATE_IN_PROGRESS, &gl->gl_flags);

		/*

		 * If another process is already doing the invalidate, let that

		 * finish first.  The glock state machine will get back to this

		 * holder again later.

		 */

		if (test_and_set_bit(GLF_INVALIDATE_IN_PROGRESS,

				     &gl->gl_flags))

			return;

		do_error(gl, 0); /* Fail queued try locks */

	}

	gl->gl_req = target;
@@ -586,8 +593,7 @@ __acquires(&gl->gl_lockref.lock) 
		}

		else if (ret) {

			fs_err(sdp, "lm_lock ret %d\n", ret);

			GLOCK_BUG_ON(gl, !test_bit(SDF_WITHDRAWN,

						   &sdp->sd_flags));

			GLOCK_BUG_ON(gl, !gfs2_withdrawn(sdp));

		}

	} else { /* lock_nolock */

		finish_xmote(gl, target);
@@ -1191,7 +1197,7 @@ int gfs2_glock_nq(struct gfs2_holder *gh) 
	struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;

	int error = 0;



	if (unlikely(test_bit(SDF_WITHDRAWN, &sdp->sd_flags)))

	if (unlikely(gfs2_withdrawn(sdp)))

		return -EIO;



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

fs/gfs2/glops.c

+2 −2
Original line number Diff line number Diff line
@@ -350,7 +350,7 @@ static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf) 
		ip->i_inode.i_rdev = MKDEV(be32_to_cpu(str->di_major),

					   be32_to_cpu(str->di_minor));

		break;

	};

	}



	i_uid_write(&ip->i_inode, be32_to_cpu(str->di_uid));

	i_gid_write(&ip->i_inode, be32_to_cpu(str->di_gid));
@@ -540,7 +540,7 @@ static int freeze_go_xmote_bh(struct gfs2_glock *gl, struct gfs2_holder *gh) 
			gfs2_consist(sdp);



		/*  Initialize some head of the log stuff  */

		if (!test_bit(SDF_WITHDRAWN, &sdp->sd_flags)) {

		if (!gfs2_withdrawn(sdp)) {

			sdp->sd_log_sequence = head.lh_sequence + 1;

			gfs2_log_pointers_init(sdp, head.lh_blkno);

		}

CRA Git | Maintained and supported by SUSTech CRA and CCSE