xfs: consolidate xfs_utils.c (e546cb79) · Commits · e / devices / android_kernel_fairphone_FP4

fs/xfs/Makefile

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -53,7 +53,6 @@ xfs-y += xfs_aops.o \
	xfs_super.o \		xfs_super.o \
	xfs_symlink.o \		xfs_symlink.o \
	xfs_trans.o \		xfs_trans.o \
	xfs_utils.o \
	xfs_xattr.o \		xfs_xattr.o \
	kmem.o \		kmem.o \
	uuid.o		uuid.o

fs/xfs/xfs_error.c

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -26,7 +26,6 @@
	#include "xfs_bmap_btree.h"		#include "xfs_bmap_btree.h"
	#include "xfs_dinode.h"		#include "xfs_dinode.h"
	#include "xfs_inode.h"		#include "xfs_inode.h"
	#include "xfs_utils.h"
	#include "xfs_error.h"		#include "xfs_error.h"

	#ifdef DEBUG		#ifdef DEBUG

fs/xfs/xfs_filestream.c

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -28,7 +28,6 @@
	#include "xfs_bmap.h"		#include "xfs_bmap.h"
	#include "xfs_bmap_util.h"		#include "xfs_bmap_util.h"
	#include "xfs_alloc.h"		#include "xfs_alloc.h"
	#include "xfs_utils.h"
	#include "xfs_mru_cache.h"		#include "xfs_mru_cache.h"
	#include "xfs_filestream.h"		#include "xfs_filestream.h"
	#include "xfs_trace.h"		#include "xfs_trace.h"

fs/xfs/xfs_inode.c

+278 −1

Original line number	Original line	Diff line number	Diff line
	@@ -46,7 +46,6 @@
	#include "xfs_bmap.h"		#include "xfs_bmap.h"
	#include "xfs_bmap_util.h"		#include "xfs_bmap_util.h"
	#include "xfs_error.h"		#include "xfs_error.h"
	#include "xfs_utils.h"
	#include "xfs_quota.h"		#include "xfs_quota.h"
	#include "xfs_filestream.h"		#include "xfs_filestream.h"
	#include "xfs_cksum.h"		#include "xfs_cksum.h"
	@@ -862,6 +861,284 @@ xfs_ialloc(
	return 0;		return 0;
	}		}

			/*
			* Allocates a new inode from disk and return a pointer to the
			* incore copy. This routine will internally commit the current
			* transaction and allocate a new one if the Space Manager needed
			* to do an allocation to replenish the inode free-list.
			*
			* This routine is designed to be called from xfs_create and
			* xfs_create_dir.
			*
			*/
			int
			xfs_dir_ialloc(
			xfs_trans_t *tpp, / input: current transaction;
			output: may be a new transaction. */
			xfs_inode_t dp, / directory within whose allocate
			the inode. */
			umode_t mode,
			xfs_nlink_t nlink,
			xfs_dev_t rdev,
			prid_t prid, /* project id */
			int okalloc, /* ok to allocate new space */
			xfs_inode_t *ipp, / pointer to inode; it will be
			locked. */
			int *committed)

			{
			xfs_trans_t *tp;
			xfs_trans_t *ntp;
			xfs_inode_t *ip;
			xfs_buf_t *ialloc_context = NULL;
			int code;
			uint log_res;
			uint log_count;
			void *dqinfo;
			uint tflags;

			tp = *tpp;
			ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);

			/*
			* xfs_ialloc will return a pointer to an incore inode if
			* the Space Manager has an available inode on the free
			* list. Otherwise, it will do an allocation and replenish
			* the freelist. Since we can only do one allocation per
			* transaction without deadlocks, we will need to commit the
			* current transaction and start a new one. We will then
			* need to call xfs_ialloc again to get the inode.
			*
			* If xfs_ialloc did an allocation to replenish the freelist,
			* it returns the bp containing the head of the freelist as
			* ialloc_context. We will hold a lock on it across the
			* transaction commit so that no other process can steal
			* the inode(s) that we've just allocated.
			*/
			code = xfs_ialloc(tp, dp, mode, nlink, rdev, prid, okalloc,
			&ialloc_context, &ip);

			/*
			* Return an error if we were unable to allocate a new inode.
			* This should only happen if we run out of space on disk or
			* encounter a disk error.
			*/
			if (code) {
			*ipp = NULL;
			return code;
			}
			if (!ialloc_context && !ip) {
			*ipp = NULL;
			return XFS_ERROR(ENOSPC);
			}

			/*
			* If the AGI buffer is non-NULL, then we were unable to get an
			* inode in one operation. We need to commit the current
			* transaction and call xfs_ialloc() again. It is guaranteed
			* to succeed the second time.
			*/
			if (ialloc_context) {
			/*
			* Normally, xfs_trans_commit releases all the locks.
			* We call bhold to hang on to the ialloc_context across
			* the commit. Holding this buffer prevents any other
			* processes from doing any allocations in this
			* allocation group.
			*/
			xfs_trans_bhold(tp, ialloc_context);
			/*
			* Save the log reservation so we can use
			* them in the next transaction.
			*/
			log_res = xfs_trans_get_log_res(tp);
			log_count = xfs_trans_get_log_count(tp);

			/*
			* We want the quota changes to be associated with the next
			* transaction, NOT this one. So, detach the dqinfo from this
			* and attach it to the next transaction.
			*/
			dqinfo = NULL;
			tflags = 0;
			if (tp->t_dqinfo) {
			dqinfo = (void *)tp->t_dqinfo;
			tp->t_dqinfo = NULL;
			tflags = tp->t_flags & XFS_TRANS_DQ_DIRTY;
			tp->t_flags &= ~(XFS_TRANS_DQ_DIRTY);
			}

			ntp = xfs_trans_dup(tp);
			code = xfs_trans_commit(tp, 0);
			tp = ntp;
			if (committed != NULL) {
			*committed = 1;
			}
			/*
			* If we get an error during the commit processing,
			* release the buffer that is still held and return
			* to the caller.
			*/
			if (code) {
			xfs_buf_relse(ialloc_context);
			if (dqinfo) {
			tp->t_dqinfo = dqinfo;
			xfs_trans_free_dqinfo(tp);
			}
			*tpp = ntp;
			*ipp = NULL;
			return code;
			}

			/*
			* transaction commit worked ok so we can drop the extra ticket
			* reference that we gained in xfs_trans_dup()
			*/
			xfs_log_ticket_put(tp->t_ticket);
			code = xfs_trans_reserve(tp, 0, log_res, 0,
			XFS_TRANS_PERM_LOG_RES, log_count);
			/*
			* Re-attach the quota info that we detached from prev trx.
			*/
			if (dqinfo) {
			tp->t_dqinfo = dqinfo;
			tp->t_flags \|= tflags;
			}

			if (code) {
			xfs_buf_relse(ialloc_context);
			*tpp = ntp;
			*ipp = NULL;
			return code;
			}
			xfs_trans_bjoin(tp, ialloc_context);

			/*
			* Call ialloc again. Since we've locked out all
			* other allocations in this allocation group,
			* this call should always succeed.
			*/
			code = xfs_ialloc(tp, dp, mode, nlink, rdev, prid,
			okalloc, &ialloc_context, &ip);

			/*
			* If we get an error at this point, return to the caller
			* so that the current transaction can be aborted.
			*/
			if (code) {
			*tpp = tp;
			*ipp = NULL;
			return code;
			}
			ASSERT(!ialloc_context && ip);

			} else {
			if (committed != NULL)
			*committed = 0;
			}

			*ipp = ip;
			*tpp = tp;

			return 0;
			}

			/*
			* Decrement the link count on an inode & log the change.
			* If this causes the link count to go to zero, initiate the
			* logging activity required to truncate a file.
			*/
			int /* error */
			xfs_droplink(
			xfs_trans_t *tp,
			xfs_inode_t *ip)
			{
			int error;

			xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);

			ASSERT (ip->i_d.di_nlink > 0);
			ip->i_d.di_nlink--;
			drop_nlink(VFS_I(ip));
			xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);

			error = 0;
			if (ip->i_d.di_nlink == 0) {
			/*
			* We're dropping the last link to this file.
			* Move the on-disk inode to the AGI unlinked list.
			* From xfs_inactive() we will pull the inode from
			* the list and free it.
			*/
			error = xfs_iunlink(tp, ip);
			}
			return error;
			}

			/*
			* This gets called when the inode's version needs to be changed from 1 to 2.
			* Currently this happens when the nlink field overflows the old 16-bit value
			* or when chproj is called to change the project for the first time.
			* As a side effect the superblock version will also get rev'd
			* to contain the NLINK bit.
			*/
			void
			xfs_bump_ino_vers2(
			xfs_trans_t *tp,
			xfs_inode_t *ip)
			{
			xfs_mount_t *mp;

			ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
			ASSERT(ip->i_d.di_version == 1);

			ip->i_d.di_version = 2;
			ip->i_d.di_onlink = 0;
			memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
			mp = tp->t_mountp;
			if (!xfs_sb_version_hasnlink(&mp->m_sb)) {
			spin_lock(&mp->m_sb_lock);
			if (!xfs_sb_version_hasnlink(&mp->m_sb)) {
			xfs_sb_version_addnlink(&mp->m_sb);
			spin_unlock(&mp->m_sb_lock);
			xfs_mod_sb(tp, XFS_SB_VERSIONNUM);
			} else {
			spin_unlock(&mp->m_sb_lock);
			}
			}
			/* Caller must log the inode */
			}

			/*
			* Increment the link count on an inode & log the change.
			*/
			int
			xfs_bumplink(
			xfs_trans_t *tp,
			xfs_inode_t *ip)
			{
			xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);

			ASSERT(ip->i_d.di_nlink > 0);
			ip->i_d.di_nlink++;
			inc_nlink(VFS_I(ip));
			if ((ip->i_d.di_version == 1) &&
			(ip->i_d.di_nlink > XFS_MAXLINK_1)) {
			/*
			* The inode has increased its number of links beyond
			* what can fit in an old format inode. It now needs
			* to be converted to a version 2 inode with a 32 bit
			* link count. If this is the first inode in the file
			* system to do this, then we need to bump the superblock
			* version number as well.
			*/
			xfs_bump_ino_vers2(tp, ip);
			}

			xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
			return 0;
			}

	int		int
	xfs_create(		xfs_create(
	xfs_inode_t *dp,		xfs_inode_t *dp,

fs/xfs/xfs_inode.h

+7 −0

Original line number	Original line	Diff line number	Diff line
	@@ -360,6 +360,13 @@ void xfs_lock_two_inodes(xfs_inode_t , xfs_inode_t , uint);

	xfs_extlen_t xfs_get_extsz_hint(struct xfs_inode *ip);		xfs_extlen_t xfs_get_extsz_hint(struct xfs_inode *ip);

			int xfs_dir_ialloc(struct xfs_trans *, struct xfs_inode , umode_t,
			xfs_nlink_t, xfs_dev_t, prid_t, int,
			struct xfs_inode *, int );
			int xfs_droplink(struct xfs_trans , struct xfs_inode );
			int xfs_bumplink(struct xfs_trans , struct xfs_inode );
			void xfs_bump_ino_vers2(struct xfs_trans , struct xfs_inode );

	/* from xfs_file.c */		/* from xfs_file.c */
	int xfs_zero_eof(struct xfs_inode *, xfs_off_t, xfs_fsize_t);		int xfs_zero_eof(struct xfs_inode *, xfs_off_t, xfs_fsize_t);
	int xfs_iozero(struct xfs_inode *, loff_t, size_t);		int xfs_iozero(struct xfs_inode *, loff_t, size_t);