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

Commit 2b2f2aed authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull gfs2 updates from Andreas Gruenbacher:

 - iomap support for buffered writes and for direct I/O

 - two patches that reduce the size of struct gfs2_inode

 - lots of fixes and cleanups

* tag 'gfs2-4.19.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/gfs2/linux-gfs2: (25 commits)
  gfs2: eliminate update_rgrp_lvb_unlinked
  gfs2: Fix gfs2_testbit to use clone bitmaps
  gfs2: Get rid of gfs2_ea_strlen
  gfs2: cleanup: call gfs2_rgrp_ondisk2lvb from gfs2_rgrp_out
  gfs2: Special-case rindex for gfs2_grow
  GFS2: rgrp free blocks used incorrectly
  gfs2: remove redundant variable 'moved'
  gfs2: use iomap_readpage for blocksize == PAGE_SIZE
  gfs2: Use iomap for stuffed direct I/O reads
  gfs2: fallocate_chunk: Always initialize struct iomap
  GFS2: Fix recovery issues for spectators
  fs: gfs2: Adding new return type vm_fault_t
  gfs2: using posix_acl_xattr_size instead of posix_acl_to_xattr
  gfs2: Don't reject a supposedly full bitmap if we have blocks reserved
  gfs2: Eliminate redundant ip->i_rgd
  gfs2: Stop messing with ip->i_rgd in the rlist code
  gfs2: Remove gfs2_write_{begin,end}
  gfs2: iomap direct I/O support
  gfs2: gfs2_extent_length cleanup
  gfs2: iomap buffered write support
  ...
parents 72f02ba6 f5580d0f

fs/gfs2/acl.c

+2 −4
Original line number Diff line number Diff line
@@ -82,14 +82,12 @@ struct posix_acl *gfs2_get_acl(struct inode *inode, int type) 
int __gfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type)

{

	int error;

	int len;

	size_t len;

	char *data;

	const char *name = gfs2_acl_name(type);



	if (acl) {

		len = posix_acl_to_xattr(&init_user_ns, acl, NULL, 0);

		if (len == 0)

			return 0;

		len = posix_acl_xattr_size(acl->a_count);

		data = kmalloc(len, GFP_NOFS);

		if (data == NULL)

			return -ENOMEM;

fs/gfs2/aops.c

+17 −320
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ 
#include <linux/backing-dev.h>

#include <linux/uio.h>

#include <trace/events/writeback.h>

#include <linux/sched/signal.h>



#include "gfs2.h"

#include "incore.h"
@@ -36,9 +37,10 @@ 
#include "super.h"

#include "util.h"

#include "glops.h"

#include "aops.h"





static void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page,

void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page,

			    unsigned int from, unsigned int len)

{

	struct buffer_head *head = page_buffers(page);
@@ -82,12 +84,6 @@ static int gfs2_get_block_noalloc(struct inode *inode, sector_t lblock, 
	return 0;

}



static int gfs2_get_block_direct(struct inode *inode, sector_t lblock,

				 struct buffer_head *bh_result, int create)

{

	return gfs2_block_map(inode, lblock, bh_result, 0);

}



/**

 * gfs2_writepage_common - Common bits of writepage

 * @page: The page to be written
@@ -462,7 +458,7 @@ static int gfs2_jdata_writepages(struct address_space *mapping, 
 * Returns: errno

 */



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

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

{

	struct buffer_head *dibh;

	u64 dsize = i_size_read(&ip->i_inode);
@@ -512,9 +508,13 @@ static int __gfs2_readpage(void *file, struct page *page) 
{

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

	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);



	int error;



	if (gfs2_is_stuffed(ip)) {

	if (i_blocksize(page->mapping->host) == PAGE_SIZE &&

	    !page_has_buffers(page)) {

		error = iomap_readpage(page, &gfs2_iomap_ops);

	} else if (gfs2_is_stuffed(ip)) {

		error = stuffed_readpage(ip, page);

		unlock_page(page);

	} else {
@@ -643,140 +643,11 @@ static int gfs2_readpages(struct file *file, struct address_space *mapping, 
	return ret;

}



/**

 * gfs2_write_begin - Begin to write to a file

 * @file: The file to write to

 * @mapping: The mapping in which to write

 * @pos: The file offset at which to start writing

 * @len: Length of the write

 * @flags: Various flags

 * @pagep: Pointer to return the page

 * @fsdata: Pointer to return fs data (unused by GFS2)

 *

 * Returns: errno

 */



static int gfs2_write_begin(struct file *file, struct address_space *mapping,

			    loff_t pos, unsigned len, unsigned flags,

			    struct page **pagep, void **fsdata)

{

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

	struct gfs2_sbd *sdp = GFS2_SB(mapping->host);

	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);

	unsigned int data_blocks = 0, ind_blocks = 0, rblocks;

	unsigned requested = 0;

	int alloc_required;

	int error = 0;

	pgoff_t index = pos >> PAGE_SHIFT;

	unsigned from = pos & (PAGE_SIZE - 1);

	struct page *page;



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

	error = gfs2_glock_nq(&ip->i_gh);

	if (unlikely(error))

		goto out_uninit;

	if (&ip->i_inode == sdp->sd_rindex) {

		error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE,

					   GL_NOCACHE, &m_ip->i_gh);

		if (unlikely(error)) {

			gfs2_glock_dq(&ip->i_gh);

			goto out_uninit;

		}

	}



	alloc_required = gfs2_write_alloc_required(ip, pos, len);



	if (alloc_required || gfs2_is_jdata(ip))

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



	if (alloc_required) {

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

		requested = data_blocks + ind_blocks;

		ap.target = requested;

		error = gfs2_quota_lock_check(ip, &ap);

		if (error)

			goto out_unlock;



		error = gfs2_inplace_reserve(ip, &ap);

		if (error)

			goto out_qunlock;

	}



	rblocks = RES_DINODE + ind_blocks;

	if (gfs2_is_jdata(ip))

		rblocks += data_blocks ? data_blocks : 1;

	if (ind_blocks || data_blocks)

		rblocks += RES_STATFS + RES_QUOTA;

	if (&ip->i_inode == sdp->sd_rindex)

		rblocks += 2 * RES_STATFS;

	if (alloc_required)

		rblocks += gfs2_rg_blocks(ip, requested);



	error = gfs2_trans_begin(sdp, rblocks,

				 PAGE_SIZE/sdp->sd_sb.sb_bsize);

	if (error)

		goto out_trans_fail;



	error = -ENOMEM;

	flags |= AOP_FLAG_NOFS;

	page = grab_cache_page_write_begin(mapping, index, flags);

	*pagep = page;

	if (unlikely(!page))

		goto out_endtrans;



	if (gfs2_is_stuffed(ip)) {

		error = 0;

		if (pos + len > gfs2_max_stuffed_size(ip)) {

			error = gfs2_unstuff_dinode(ip, page);

			if (error == 0)

				goto prepare_write;

		} else if (!PageUptodate(page)) {

			error = stuffed_readpage(ip, page);

		}

		goto out;

	}



prepare_write:

	error = __block_write_begin(page, from, len, gfs2_block_map);

out:

	if (error == 0)

		return 0;



	unlock_page(page);

	put_page(page);



	gfs2_trans_end(sdp);

	if (alloc_required) {

		gfs2_inplace_release(ip);

		if (pos + len > ip->i_inode.i_size)

			gfs2_trim_blocks(&ip->i_inode);

	}

	goto out_qunlock;



out_endtrans:

	gfs2_trans_end(sdp);

out_trans_fail:

	if (alloc_required)

		gfs2_inplace_release(ip);

out_qunlock:

	if (alloc_required)

		gfs2_quota_unlock(ip);

out_unlock:

	if (&ip->i_inode == sdp->sd_rindex) {

		gfs2_glock_dq(&m_ip->i_gh);

		gfs2_holder_uninit(&m_ip->i_gh);

	}

	gfs2_glock_dq(&ip->i_gh);

out_uninit:

	gfs2_holder_uninit(&ip->i_gh);

	return error;

}



/**

 * adjust_fs_space - Adjusts the free space available due to gfs2_grow

 * @inode: the rindex inode

 */

static void adjust_fs_space(struct inode *inode)

void adjust_fs_space(struct inode *inode)

{

	struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;

	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
@@ -822,9 +693,9 @@ static void adjust_fs_space(struct inode *inode) 
 * This copies the data from the page into the inode block after

 * the inode data structure itself.

 *

 * Returns: errno

 * Returns: copied bytes or errno

 */

static int gfs2_stuffed_write_end(struct inode *inode, struct buffer_head *dibh,

int gfs2_stuffed_write_end(struct inode *inode, struct buffer_head *dibh,

			   loff_t pos, unsigned copied,

			   struct page *page)

{
@@ -852,84 +723,6 @@ static int gfs2_stuffed_write_end(struct inode *inode, struct buffer_head *dibh, 
	return copied;

}



/**

 * gfs2_write_end

 * @file: The file to write to

 * @mapping: The address space to write to

 * @pos: The file position

 * @len: The length of the data

 * @copied: How much was actually copied by the VFS

 * @page: The page that has been written

 * @fsdata: The fsdata (unused in GFS2)

 *

 * The main write_end function for GFS2. We just put our locking around the VFS

 * provided functions.

 *

 * Returns: errno

 */



static int gfs2_write_end(struct file *file, struct address_space *mapping,

			  loff_t pos, unsigned len, unsigned copied,

			  struct page *page, void *fsdata)

{

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

	struct gfs2_inode *ip = GFS2_I(inode);

	struct gfs2_sbd *sdp = GFS2_SB(inode);

	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);

	struct buffer_head *dibh;

	int ret;

	struct gfs2_trans *tr = current->journal_info;

	BUG_ON(!tr);



	BUG_ON(gfs2_glock_is_locked_by_me(ip->i_gl) == NULL);



	ret = gfs2_meta_inode_buffer(ip, &dibh);

	if (unlikely(ret))

		goto out;



	if (gfs2_is_stuffed(ip)) {

		ret = gfs2_stuffed_write_end(inode, dibh, pos, copied, page);

		page = NULL;

		goto out2;

	}



	if (gfs2_is_jdata(ip))

		gfs2_page_add_databufs(ip, page, pos & ~PAGE_MASK, len);

	else

		gfs2_ordered_add_inode(ip);



	ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);

	page = NULL;

	if (tr->tr_num_buf_new)

		__mark_inode_dirty(inode, I_DIRTY_DATASYNC);

	else

		gfs2_trans_add_meta(ip->i_gl, dibh);



out2:

	if (inode == sdp->sd_rindex) {

		adjust_fs_space(inode);

		sdp->sd_rindex_uptodate = 0;

	}



	brelse(dibh);

out:

	if (page) {

		unlock_page(page);

		put_page(page);

	}

	gfs2_trans_end(sdp);

	gfs2_inplace_release(ip);

	if (ip->i_qadata && ip->i_qadata->qa_qd_num)

		gfs2_quota_unlock(ip);

	if (inode == sdp->sd_rindex) {

		gfs2_glock_dq(&m_ip->i_gh);

		gfs2_holder_uninit(&m_ip->i_gh);

	}

	gfs2_glock_dq(&ip->i_gh);

	gfs2_holder_uninit(&ip->i_gh);

	return ret;

}



/**

 * jdata_set_page_dirty - Page dirtying function

 * @page: The page to dirty
@@ -1022,96 +815,6 @@ static void gfs2_invalidatepage(struct page *page, unsigned int offset, 
		try_to_release_page(page, 0);

}



/**

 * gfs2_ok_for_dio - check that dio is valid on this file

 * @ip: The inode

 * @offset: The offset at which we are reading or writing

 *

 * Returns: 0 (to ignore the i/o request and thus fall back to buffered i/o)

 *          1 (to accept the i/o request)

 */

static int gfs2_ok_for_dio(struct gfs2_inode *ip, loff_t offset)

{

	/*

	 * Should we return an error here? I can't see that O_DIRECT for

	 * a stuffed file makes any sense. For now we'll silently fall

	 * back to buffered I/O

	 */

	if (gfs2_is_stuffed(ip))

		return 0;



	if (offset >= i_size_read(&ip->i_inode))

		return 0;

	return 1;

}







static ssize_t gfs2_direct_IO(struct kiocb *iocb, struct iov_iter *iter)

{

	struct file *file = iocb->ki_filp;

	struct inode *inode = file->f_mapping->host;

	struct address_space *mapping = inode->i_mapping;

	struct gfs2_inode *ip = GFS2_I(inode);

	loff_t offset = iocb->ki_pos;

	struct gfs2_holder gh;

	int rv;



	/*

	 * Deferred lock, even if its a write, since we do no allocation

	 * on this path. All we need change is atime, and this lock mode

	 * ensures that other nodes have flushed their buffered read caches

	 * (i.e. their page cache entries for this inode). We do not,

	 * unfortunately have the option of only flushing a range like

	 * the VFS does.

	 */

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

	rv = gfs2_glock_nq(&gh);

	if (rv)

		goto out_uninit;

	rv = gfs2_ok_for_dio(ip, offset);

	if (rv != 1)

		goto out; /* dio not valid, fall back to buffered i/o */



	/*

	 * Now since we are holding a deferred (CW) lock at this point, you

	 * might be wondering why this is ever needed. There is a case however

	 * where we've granted a deferred local lock against a cached exclusive

	 * glock. That is ok provided all granted local locks are deferred, but

	 * it also means that it is possible to encounter pages which are

	 * cached and possibly also mapped. So here we check for that and sort

	 * them out ahead of the dio. The glock state machine will take care of

	 * everything else.

	 *

	 * If in fact the cached glock state (gl->gl_state) is deferred (CW) in

	 * the first place, mapping->nr_pages will always be zero.

	 */

	if (mapping->nrpages) {

		loff_t lstart = offset & ~(PAGE_SIZE - 1);

		loff_t len = iov_iter_count(iter);

		loff_t end = PAGE_ALIGN(offset + len) - 1;



		rv = 0;

		if (len == 0)

			goto out;

		if (test_and_clear_bit(GIF_SW_PAGED, &ip->i_flags))

			unmap_shared_mapping_range(ip->i_inode.i_mapping, offset, len);

		rv = filemap_write_and_wait_range(mapping, lstart, end);

		if (rv)

			goto out;

		if (iov_iter_rw(iter) == WRITE)

			truncate_inode_pages_range(mapping, lstart, end);

	}



	rv = __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter,

				  gfs2_get_block_direct, NULL, NULL, 0);

out:

	gfs2_glock_dq(&gh);

out_uninit:

	gfs2_holder_uninit(&gh);

	return rv;

}



/**

 * gfs2_releasepage - free the metadata associated with a page

 * @page: the page that's being released
@@ -1187,12 +890,10 @@ static const struct address_space_operations gfs2_writeback_aops = { 
	.writepages = gfs2_writepages,

	.readpage = gfs2_readpage,

	.readpages = gfs2_readpages,

	.write_begin = gfs2_write_begin,

	.write_end = gfs2_write_end,

	.bmap = gfs2_bmap,

	.invalidatepage = gfs2_invalidatepage,

	.releasepage = gfs2_releasepage,

	.direct_IO = gfs2_direct_IO,

	.direct_IO = noop_direct_IO,

	.migratepage = buffer_migrate_page,

	.is_partially_uptodate = block_is_partially_uptodate,

	.error_remove_page = generic_error_remove_page,
@@ -1203,13 +904,11 @@ static const struct address_space_operations gfs2_ordered_aops = { 
	.writepages = gfs2_writepages,

	.readpage = gfs2_readpage,

	.readpages = gfs2_readpages,

	.write_begin = gfs2_write_begin,

	.write_end = gfs2_write_end,

	.set_page_dirty = __set_page_dirty_buffers,

	.bmap = gfs2_bmap,

	.invalidatepage = gfs2_invalidatepage,

	.releasepage = gfs2_releasepage,

	.direct_IO = gfs2_direct_IO,

	.direct_IO = noop_direct_IO,

	.migratepage = buffer_migrate_page,

	.is_partially_uptodate = block_is_partially_uptodate,

	.error_remove_page = generic_error_remove_page,
@@ -1220,8 +919,6 @@ static const struct address_space_operations gfs2_jdata_aops = { 
	.writepages = gfs2_jdata_writepages,

	.readpage = gfs2_readpage,

	.readpages = gfs2_readpages,

	.write_begin = gfs2_write_begin,

	.write_end = gfs2_write_end,

	.set_page_dirty = jdata_set_page_dirty,

	.bmap = gfs2_bmap,

	.invalidatepage = gfs2_invalidatepage,

fs/gfs2/aops.h

0 → 100644
+19 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

/*

 * Copyright (C) 2018 Red Hat, Inc.  All rights reserved.

 */



#ifndef __AOPS_DOT_H__

#define __AOPS_DOT_H__



#include "incore.h"



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

extern int gfs2_stuffed_write_end(struct inode *inode, struct buffer_head *dibh,

				  loff_t pos, unsigned copied,

				  struct page *page);

extern void adjust_fs_space(struct inode *inode);

extern void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page,

				   unsigned int from, unsigned int len);



#endif /* __AOPS_DOT_H__ */

fs/gfs2/bmap.c

+335 −79

File changed.

Preview size limit exceeded, changes collapsed.

fs/gfs2/dir.c

+1 −3
Original line number Diff line number Diff line
@@ -1011,7 +1011,7 @@ static int dir_split_leaf(struct inode *inode, const struct qstr *name) 
	u64 bn, leaf_no;

	__be64 *lp;

	u32 index;

	int x, moved = 0;

	int x;

	int error;



	index = name->hash >> (32 - dip->i_depth);
@@ -1113,8 +1113,6 @@ static int dir_split_leaf(struct inode *inode, const struct qstr *name) 


			if (!prev)

				prev = dent;



			moved = 1;

		} else {

			prev = dent;

		}