forge/linux-pinenote
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

xfs: refactor xfs_trans_reserve() interface

Browse source 
With the new xfs_trans_res structure has been introduced, the log
reservation size, log count as well as log flags are pre-initialized
at mount time.  So it's time to refine xfs_trans_reserve() interface
to be more neat.

Also, introduce a new helper M_RES() to return a pointer to the
mp->m_resv structure to simplify the input.

Signed-off-by: Jie Liu <jeff.liu@oracle.com>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
This commit is contained in:
Jie Liu 2013-08-12 20:49:59 +10:00 • committed by Ben Myers
commit 3d3c8b5222
21 changed files with 150 additions and 197 deletions
Download patch file Download diff file Expand all files Collapse all files

2
fs/xfs/xfs_aops.c
View file

@ -116,7 +116,7 @@ xfs_setfilesize_trans_alloc(
tp = xfs_trans_alloc(mp, XFS_TRANS_FSYNC_TS); tp = xfs_trans_alloc(mp, XFS_TRANS_FSYNC_TS);
error = xfs_trans_reserve(tp, 0, XFS_FSYNC_TS_LOG_RES(mp), 0, 0, 0); error = xfs_trans_reserve(tp, &M_RES(mp)->tr_fsyncts, 0, 0);
if (error) { if (error) {
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
return error; return error;

21
fs/xfs/xfs_attr.c
View file

@ -230,7 +230,8 @@ xfs_attr_set_int(
xfs_fsblock_t firstblock; xfs_fsblock_t firstblock;
xfs_bmap_free_t flist; xfs_bmap_free_t flist;
int error, err2, committed; int error, err2, committed;
xfs_mount_t *mp = dp->i_mount; struct xfs_mount *mp = dp->i_mount;
struct xfs_trans_res tres;
int rsvd = (flags & ATTR_ROOT) != 0; int rsvd = (flags & ATTR_ROOT) != 0;
int local; int local;
@ -292,11 +293,11 @@ xfs_attr_set_int(
if (rsvd) if (rsvd)
args.trans->t_flags |= XFS_TRANS_RESERVE; args.trans->t_flags |= XFS_TRANS_RESERVE;
error = xfs_trans_reserve(args.trans, args.total, tres.tr_logres = M_RES(mp)->tr_attrsetm.tr_logres +
XFS_ATTRSETM_LOG_RES(mp) + M_RES(mp)->tr_attrsetrt.tr_logres * args.total;
XFS_ATTRSETRT_LOG_RES(mp) * args.total, tres.tr_logcount = XFS_ATTRSET_LOG_COUNT;
0, XFS_TRANS_PERM_LOG_RES, tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
XFS_ATTRSET_LOG_COUNT); error = xfs_trans_reserve(args.trans, &tres, args.total, 0);
if (error) { if (error) {
xfs_trans_cancel(args.trans, 0); xfs_trans_cancel(args.trans, 0);
return(error); return(error);
@ -516,11 +517,9 @@ xfs_attr_remove_int(xfs_inode_t *dp, struct xfs_name *name, int flags)
if (flags & ATTR_ROOT) if (flags & ATTR_ROOT)
args.trans->t_flags |= XFS_TRANS_RESERVE; args.trans->t_flags |= XFS_TRANS_RESERVE;
if ((error = xfs_trans_reserve(args.trans, error = xfs_trans_reserve(args.trans, &M_RES(mp)->tr_attrrm,
XFS_ATTRRM_SPACE_RES(mp), XFS_ATTRRM_SPACE_RES(mp), 0);
XFS_ATTRRM_LOG_RES(mp), if (error) {
0, XFS_TRANS_PERM_LOG_RES,
XFS_ATTRRM_LOG_COUNT))) {
xfs_trans_cancel(args.trans, 0); xfs_trans_cancel(args.trans, 0);
return(error); return(error);
} }

5
fs/xfs/xfs_attr_inactive.c
View file

@ -412,9 +412,8 @@ xfs_attr_inactive(xfs_inode_t *dp)
* the log. * the log.
*/ */
trans = xfs_trans_alloc(mp, XFS_TRANS_ATTRINVAL); trans = xfs_trans_alloc(mp, XFS_TRANS_ATTRINVAL);
if ((error = xfs_trans_reserve(trans, 0, XFS_ATTRINVAL_LOG_RES(mp), 0, error = xfs_trans_reserve(trans, &M_RES(mp)->tr_attrinval, 0, 0);
XFS_TRANS_PERM_LOG_RES, if (error) {
XFS_ATTRINVAL_LOG_COUNT))) {
xfs_trans_cancel(trans, 0); xfs_trans_cancel(trans, 0);
return(error); return(error);
} }

4
fs/xfs/xfs_bmap.c
View file

@ -1148,8 +1148,8 @@ xfs_bmap_add_attrfork(
blks = XFS_ADDAFORK_SPACE_RES(mp); blks = XFS_ADDAFORK_SPACE_RES(mp);
if (rsvd) if (rsvd)
tp->t_flags |= XFS_TRANS_RESERVE; tp->t_flags |= XFS_TRANS_RESERVE;
if ((error = xfs_trans_reserve(tp, blks, XFS_ADDAFORK_LOG_RES(mp), 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_addafork, blks, 0);
XFS_TRANS_PERM_LOG_RES, XFS_ADDAFORK_LOG_COUNT))) if (error)
goto error0; goto error0;
xfs_ilock(ip, XFS_ILOCK_EXCL); xfs_ilock(ip, XFS_ILOCK_EXCL);
error = xfs_trans_reserve_quota_nblks(tp, ip, blks, 0, rsvd ? error = xfs_trans_reserve_quota_nblks(tp, ip, blks, 0, rsvd ?

42
fs/xfs/xfs_bmap_util.c
View file

@ -78,8 +78,7 @@ xfs_bmap_finish(
xfs_efi_log_item_t *efi; /* extent free intention */ xfs_efi_log_item_t *efi; /* extent free intention */
int error; /* error return value */ int error; /* error return value */
xfs_bmap_free_item_t *free; /* free extent item */ xfs_bmap_free_item_t *free; /* free extent item */
unsigned int logres; /* new log reservation */ struct xfs_trans_res tres; /* new log reservation */
unsigned int logcount; /* new log count */
xfs_mount_t *mp; /* filesystem mount structure */ xfs_mount_t *mp; /* filesystem mount structure */
xfs_bmap_free_item_t *next; /* next item on free list */ xfs_bmap_free_item_t *next; /* next item on free list */
xfs_trans_t *ntp; /* new transaction pointer */ xfs_trans_t *ntp; /* new transaction pointer */
@ -94,8 +93,10 @@ xfs_bmap_finish(
for (free = flist->xbf_first; free; free = free->xbfi_next) for (free = flist->xbf_first; free; free = free->xbfi_next)
xfs_trans_log_efi_extent(ntp, efi, free->xbfi_startblock, xfs_trans_log_efi_extent(ntp, efi, free->xbfi_startblock,
free->xbfi_blockcount); free->xbfi_blockcount);
logres = ntp->t_log_res;
logcount = ntp->t_log_count; tres.tr_logres = ntp->t_log_res;
tres.tr_logcount = ntp->t_log_count;
tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
ntp = xfs_trans_dup(*tp); ntp = xfs_trans_dup(*tp);
error = xfs_trans_commit(*tp, 0); error = xfs_trans_commit(*tp, 0);
*tp = ntp; *tp = ntp;
@ -113,8 +114,8 @@ xfs_bmap_finish(
*/ */
xfs_log_ticket_put(ntp->t_ticket); xfs_log_ticket_put(ntp->t_ticket);
if ((error = xfs_trans_reserve(ntp, 0, logres, 0, XFS_TRANS_PERM_LOG_RES, error = xfs_trans_reserve(ntp, &tres, 0, 0);
logcount))) if (error)
return error; return error;
efd = xfs_trans_get_efd(ntp, efi, flist->xbf_count); efd = xfs_trans_get_efd(ntp, efi, flist->xbf_count);
for (free = flist->xbf_first; free != NULL; free = next) { for (free = flist->xbf_first; free != NULL; free = next) {
@ -929,10 +930,7 @@ xfs_free_eofblocks(
} }
} }
error = xfs_trans_reserve(tp, 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
XFS_ITRUNCATE_LOG_RES(mp),
0, XFS_TRANS_PERM_LOG_RES,
XFS_ITRUNCATE_LOG_COUNT);
if (error) { if (error) {
ASSERT(XFS_FORCED_SHUTDOWN(mp)); ASSERT(XFS_FORCED_SHUTDOWN(mp));
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
@ -1085,10 +1083,8 @@ xfs_alloc_file_space(
* Allocate and setup the transaction. * Allocate and setup the transaction.
*/ */
tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT); tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
error = xfs_trans_reserve(tp, resblks, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_write,
XFS_WRITE_LOG_RES(mp), resrtextents, resblks, resrtextents);
XFS_TRANS_PERM_LOG_RES,
XFS_WRITE_LOG_COUNT);
/* /*
* Check for running out of space * Check for running out of space
*/ */
@ -1378,12 +1374,7 @@ xfs_free_file_space(
*/ */
tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT); tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
tp->t_flags |= XFS_TRANS_RESERVE; tp->t_flags |= XFS_TRANS_RESERVE;
error = xfs_trans_reserve(tp, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_write, resblks, 0);
resblks,
XFS_WRITE_LOG_RES(mp),
0,
XFS_TRANS_PERM_LOG_RES,
XFS_WRITE_LOG_COUNT);
/* /*
* check for running out of space * check for running out of space
@ -1657,10 +1648,8 @@ xfs_change_file_space(
* update the inode timestamp, mode, and prealloc flag bits * update the inode timestamp, mode, and prealloc flag bits
*/ */
tp = xfs_trans_alloc(mp, XFS_TRANS_WRITEID); tp = xfs_trans_alloc(mp, XFS_TRANS_WRITEID);
error = xfs_trans_reserve(tp, &M_RES(mp)->tr_writeid, 0, 0);
if ((error = xfs_trans_reserve(tp, 0, XFS_WRITEID_LOG_RES(mp), if (error) {
0, 0, 0))) {
/* ASSERT(0); */
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
return error; return error;
} }
@ -1905,9 +1894,8 @@ xfs_swap_extents(
truncate_pagecache_range(VFS_I(ip), 0, -1); truncate_pagecache_range(VFS_I(ip), 0, -1);
tp = xfs_trans_alloc(mp, XFS_TRANS_SWAPEXT); tp = xfs_trans_alloc(mp, XFS_TRANS_SWAPEXT);
if ((error = xfs_trans_reserve(tp, 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
XFS_ICHANGE_LOG_RES(mp), 0, if (error) {
0, 0))) {
xfs_iunlock(ip, XFS_IOLOCK_EXCL); xfs_iunlock(ip, XFS_IOLOCK_EXCL);
xfs_iunlock(tip, XFS_IOLOCK_EXCL); xfs_iunlock(tip, XFS_IOLOCK_EXCL);
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);

6
fs/xfs/xfs_dquot.c
View file

@ -712,10 +712,8 @@ xfs_qm_dqread(
if (flags & XFS_QMOPT_DQALLOC) { if (flags & XFS_QMOPT_DQALLOC) {
tp = xfs_trans_alloc(mp, XFS_TRANS_QM_DQALLOC); tp = xfs_trans_alloc(mp, XFS_TRANS_QM_DQALLOC);
error = xfs_trans_reserve(tp, XFS_QM_DQALLOC_SPACE_RES(mp), error = xfs_trans_reserve(tp, &M_RES(mp)->tr_attrsetm,
XFS_QM_DQALLOC_LOG_RES(mp), 0, XFS_QM_DQALLOC_SPACE_RES(mp), 0);
XFS_TRANS_PERM_LOG_RES,
XFS_WRITE_LOG_COUNT);
if (error) if (error)
goto error1; goto error1;
cancelflags = XFS_TRANS_RELEASE_LOG_RES; cancelflags = XFS_TRANS_RELEASE_LOG_RES;

8
fs/xfs/xfs_fsops.c
View file

@ -203,8 +203,9 @@ xfs_growfs_data_private(
tp = xfs_trans_alloc(mp, XFS_TRANS_GROWFS); tp = xfs_trans_alloc(mp, XFS_TRANS_GROWFS);
tp->t_flags |= XFS_TRANS_RESERVE; tp->t_flags |= XFS_TRANS_RESERVE;
if ((error = xfs_trans_reserve(tp, XFS_GROWFS_SPACE_RES(mp), error = xfs_trans_reserve(tp, &M_RES(mp)->tr_growdata,
XFS_GROWDATA_LOG_RES(mp), 0, 0, 0))) { XFS_GROWFS_SPACE_RES(mp), 0);
if (error) {
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
return error; return error;
} }
@ -739,8 +740,7 @@ xfs_fs_log_dummy(
int error; int error;
tp = _xfs_trans_alloc(mp, XFS_TRANS_DUMMY1, KM_SLEEP); tp = _xfs_trans_alloc(mp, XFS_TRANS_DUMMY1, KM_SLEEP);
error = xfs_trans_reserve(tp, 0, XFS_SB_LOG_RES(mp), 0, 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_sb, 0, 0);
XFS_DEFAULT_LOG_COUNT);
if (error) { if (error) {
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
return error; return error;

78
fs/xfs/xfs_inode.c
View file

@ -892,8 +892,6 @@ xfs_dir_ialloc(
xfs_inode_t *ip; xfs_inode_t *ip;
xfs_buf_t *ialloc_context = NULL; xfs_buf_t *ialloc_context = NULL;
int code; int code;
uint log_res;
uint log_count;
void *dqinfo; void *dqinfo;
uint tflags; uint tflags;
@ -939,6 +937,8 @@ xfs_dir_ialloc(
* to succeed the second time. * to succeed the second time.
*/ */
if (ialloc_context) { if (ialloc_context) {
struct xfs_trans_res tres;
/* /*
* Normally, xfs_trans_commit releases all the locks. * Normally, xfs_trans_commit releases all the locks.
* We call bhold to hang on to the ialloc_context across * We call bhold to hang on to the ialloc_context across
@ -951,8 +951,8 @@ xfs_dir_ialloc(
* Save the log reservation so we can use * Save the log reservation so we can use
* them in the next transaction. * them in the next transaction.
*/ */
log_res = xfs_trans_get_log_res(tp); tres.tr_logres = xfs_trans_get_log_res(tp);
log_count = xfs_trans_get_log_count(tp); tres.tr_logcount = xfs_trans_get_log_count(tp);
/* /*
* We want the quota changes to be associated with the next * We want the quota changes to be associated with the next
@ -995,8 +995,9 @@ xfs_dir_ialloc(
* reference that we gained in xfs_trans_dup() * reference that we gained in xfs_trans_dup()
*/ */
xfs_log_ticket_put(tp->t_ticket); xfs_log_ticket_put(tp->t_ticket);
code = xfs_trans_reserve(tp, 0, log_res, 0, tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
XFS_TRANS_PERM_LOG_RES, log_count); code = xfs_trans_reserve(tp, &tres, 0, 0);
/* /*
* Re-attach the quota info that we detached from prev trx. * Re-attach the quota info that we detached from prev trx.
*/ */
@ -1161,9 +1162,8 @@ xfs_create(
struct xfs_dquot *udqp = NULL; struct xfs_dquot *udqp = NULL;
struct xfs_dquot *gdqp = NULL; struct xfs_dquot *gdqp = NULL;
struct xfs_dquot *pdqp = NULL; struct xfs_dquot *pdqp = NULL;
struct xfs_trans_res tres;
uint resblks; uint resblks;
uint log_res;
uint log_count;
trace_xfs_create(dp, name); trace_xfs_create(dp, name);
@ -1187,13 +1187,13 @@ xfs_create(
if (is_dir) { if (is_dir) {
rdev = 0; rdev = 0;
resblks = XFS_MKDIR_SPACE_RES(mp, name->len); resblks = XFS_MKDIR_SPACE_RES(mp, name->len);
log_res = XFS_MKDIR_LOG_RES(mp); tres.tr_logres = M_RES(mp)->tr_mkdir.tr_logres;
log_count = XFS_MKDIR_LOG_COUNT; tres.tr_logcount = XFS_MKDIR_LOG_COUNT;
tp = xfs_trans_alloc(mp, XFS_TRANS_MKDIR); tp = xfs_trans_alloc(mp, XFS_TRANS_MKDIR);
} else { } else {
resblks = XFS_CREATE_SPACE_RES(mp, name->len); resblks = XFS_CREATE_SPACE_RES(mp, name->len);
log_res = XFS_CREATE_LOG_RES(mp); tres.tr_logres = M_RES(mp)->tr_create.tr_logres;
log_count = XFS_CREATE_LOG_COUNT; tres.tr_logcount = XFS_CREATE_LOG_COUNT;
tp = xfs_trans_alloc(mp, XFS_TRANS_CREATE); tp = xfs_trans_alloc(mp, XFS_TRANS_CREATE);
} }
@ -1205,19 +1205,17 @@ xfs_create(
* the case we'll drop the one we have and get a more * the case we'll drop the one we have and get a more
* appropriate transaction later. * appropriate transaction later.
*/ */
error = xfs_trans_reserve(tp, resblks, log_res, 0, tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
XFS_TRANS_PERM_LOG_RES, log_count); error = xfs_trans_reserve(tp, &tres, resblks, 0);
if (error == ENOSPC) { if (error == ENOSPC) {
/* flush outstanding delalloc blocks and retry */ /* flush outstanding delalloc blocks and retry */
xfs_flush_inodes(mp); xfs_flush_inodes(mp);
error = xfs_trans_reserve(tp, resblks, log_res, 0, error = xfs_trans_reserve(tp, &tres, resblks, 0);
XFS_TRANS_PERM_LOG_RES, log_count);
} }
if (error == ENOSPC) { if (error == ENOSPC) {
/* No space at all so try a "no-allocation" reservation */ /* No space at all so try a "no-allocation" reservation */
resblks = 0; resblks = 0;
error = xfs_trans_reserve(tp, 0, log_res, 0, error = xfs_trans_reserve(tp, &tres, 0, 0);
XFS_TRANS_PERM_LOG_RES, log_count);
} }
if (error) { if (error) {
cancel_flags = 0; cancel_flags = 0;
@ -1371,12 +1369,10 @@ xfs_link(
tp = xfs_trans_alloc(mp, XFS_TRANS_LINK); tp = xfs_trans_alloc(mp, XFS_TRANS_LINK);
cancel_flags = XFS_TRANS_RELEASE_LOG_RES; cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
resblks = XFS_LINK_SPACE_RES(mp, target_name->len); resblks = XFS_LINK_SPACE_RES(mp, target_name->len);
error = xfs_trans_reserve(tp, resblks, XFS_LINK_LOG_RES(mp), 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_link, resblks, 0);
XFS_TRANS_PERM_LOG_RES, XFS_LINK_LOG_COUNT);
if (error == ENOSPC) { if (error == ENOSPC) {
resblks = 0; resblks = 0;
error = xfs_trans_reserve(tp, 0, XFS_LINK_LOG_RES(mp), 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_link, 0, 0);
XFS_TRANS_PERM_LOG_RES, XFS_LINK_LOG_COUNT);
} }
if (error) { if (error) {
cancel_flags = 0; cancel_flags = 0;
@ -1551,10 +1547,7 @@ xfs_itruncate_extents(
* reference that we gained in xfs_trans_dup() * reference that we gained in xfs_trans_dup()
*/ */
xfs_log_ticket_put(tp->t_ticket); xfs_log_ticket_put(tp->t_ticket);
error = xfs_trans_reserve(tp, 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
XFS_ITRUNCATE_LOG_RES(mp), 0,
XFS_TRANS_PERM_LOG_RES,
XFS_ITRUNCATE_LOG_COUNT);
if (error) if (error)
goto out; goto out;
} }
@ -1683,8 +1676,9 @@ xfs_inactive(
xfs_bmap_free_t free_list; xfs_bmap_free_t free_list;
xfs_fsblock_t first_block; xfs_fsblock_t first_block;
int committed; int committed;
xfs_trans_t *tp; struct xfs_trans *tp;
xfs_mount_t *mp; struct xfs_mount *mp;
struct xfs_trans_res *resp;
int error; int error;
int truncate = 0; int truncate = 0;
@ -1730,13 +1724,10 @@ xfs_inactive(
return VN_INACTIVE_CACHE; return VN_INACTIVE_CACHE;
tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE); tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
error = xfs_trans_reserve(tp, 0, resp = (truncate || S_ISLNK(ip->i_d.di_mode)) ?
(truncate || S_ISLNK(ip->i_d.di_mode)) ? &M_RES(mp)->tr_itruncate : &M_RES(mp)->tr_ifree;
XFS_ITRUNCATE_LOG_RES(mp) :
XFS_IFREE_LOG_RES(mp), error = xfs_trans_reserve(tp, resp, 0, 0);
0,
XFS_TRANS_PERM_LOG_RES,
XFS_ITRUNCATE_LOG_COUNT);
if (error) { if (error) {
ASSERT(XFS_FORCED_SHUTDOWN(mp)); ASSERT(XFS_FORCED_SHUTDOWN(mp));
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
@ -1781,10 +1772,7 @@ xfs_inactive(
goto out; goto out;
tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE); tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
error = xfs_trans_reserve(tp, 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ifree, 0, 0);
XFS_IFREE_LOG_RES(mp),
0, XFS_TRANS_PERM_LOG_RES,
XFS_INACTIVE_LOG_COUNT);
if (error) { if (error) {
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
goto out; goto out;
@ -2431,12 +2419,10 @@ xfs_remove(
* block from the directory. * block from the directory.
*/ */
resblks = XFS_REMOVE_SPACE_RES(mp); resblks = XFS_REMOVE_SPACE_RES(mp);
error = xfs_trans_reserve(tp, resblks, XFS_REMOVE_LOG_RES(mp), 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_remove, resblks, 0);
XFS_TRANS_PERM_LOG_RES, log_count);
if (error == ENOSPC) { if (error == ENOSPC) {
resblks = 0; resblks = 0;
error = xfs_trans_reserve(tp, 0, XFS_REMOVE_LOG_RES(mp), 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_remove, 0, 0);
XFS_TRANS_PERM_LOG_RES, log_count);
} }
if (error) { if (error) {
ASSERT(error != ENOSPC); ASSERT(error != ENOSPC);
@ -2631,12 +2617,10 @@ xfs_rename(
tp = xfs_trans_alloc(mp, XFS_TRANS_RENAME); tp = xfs_trans_alloc(mp, XFS_TRANS_RENAME);
cancel_flags = XFS_TRANS_RELEASE_LOG_RES; cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
spaceres = XFS_RENAME_SPACE_RES(mp, target_name->len); spaceres = XFS_RENAME_SPACE_RES(mp, target_name->len);
error = xfs_trans_reserve(tp, spaceres, XFS_RENAME_LOG_RES(mp), 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_rename, spaceres, 0);
XFS_TRANS_PERM_LOG_RES, XFS_RENAME_LOG_COUNT);
if (error == ENOSPC) { if (error == ENOSPC) {
spaceres = 0; spaceres = 0;
error = xfs_trans_reserve(tp, 0, XFS_RENAME_LOG_RES(mp), 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_rename, 0, 0);
XFS_TRANS_PERM_LOG_RES, XFS_RENAME_LOG_COUNT);
} }
if (error) { if (error) {
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);

4
fs/xfs/xfs_ioctl.c
View file

@ -367,7 +367,7 @@ xfs_set_dmattrs(
return XFS_ERROR(EIO); return XFS_ERROR(EIO);
tp = xfs_trans_alloc(mp, XFS_TRANS_SET_DMATTRS); tp = xfs_trans_alloc(mp, XFS_TRANS_SET_DMATTRS);
error = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES (mp), 0, 0, 0); error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
if (error) { if (error) {
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
return error; return error;
@ -1001,7 +1001,7 @@ xfs_ioctl_setattr(
* first do an error checking pass. * first do an error checking pass.
*/ */
tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE); tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
code = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp), 0, 0, 0); code = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
if (code) if (code)
goto error_return; goto error_return;

18
fs/xfs/xfs_iomap.c
View file

@ -188,10 +188,8 @@ xfs_iomap_write_direct(
* Allocate and setup the transaction * Allocate and setup the transaction
*/ */
tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT); tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
error = xfs_trans_reserve(tp, resblks, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_write,
XFS_WRITE_LOG_RES(mp), resrtextents, resblks, resrtextents);
XFS_TRANS_PERM_LOG_RES,
XFS_WRITE_LOG_COUNT);
/* /*
* Check for running out of space, note: need lock to return * Check for running out of space, note: need lock to return
*/ */
@ -699,10 +697,8 @@ xfs_iomap_write_allocate(
tp = xfs_trans_alloc(mp, XFS_TRANS_STRAT_WRITE); tp = xfs_trans_alloc(mp, XFS_TRANS_STRAT_WRITE);
tp->t_flags |= XFS_TRANS_RESERVE; tp->t_flags |= XFS_TRANS_RESERVE;
nres = XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK); nres = XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK);
error = xfs_trans_reserve(tp, nres, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_write,
XFS_WRITE_LOG_RES(mp), nres, 0);
0, XFS_TRANS_PERM_LOG_RES,
XFS_WRITE_LOG_COUNT);
if (error) { if (error) {
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
return XFS_ERROR(error); return XFS_ERROR(error);
@ -865,10 +861,8 @@ xfs_iomap_write_unwritten(
sb_start_intwrite(mp->m_super); sb_start_intwrite(mp->m_super);
tp = _xfs_trans_alloc(mp, XFS_TRANS_STRAT_WRITE, KM_NOFS); tp = _xfs_trans_alloc(mp, XFS_TRANS_STRAT_WRITE, KM_NOFS);
tp->t_flags |= XFS_TRANS_RESERVE | XFS_TRANS_FREEZE_PROT; tp->t_flags |= XFS_TRANS_RESERVE | XFS_TRANS_FREEZE_PROT;
error = xfs_trans_reserve(tp, resblks, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_write,
XFS_WRITE_LOG_RES(mp), 0, resblks, 0);
XFS_TRANS_PERM_LOG_RES,
XFS_WRITE_LOG_COUNT);
if (error) { if (error) {
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
return XFS_ERROR(error); return XFS_ERROR(error);

8
fs/xfs/xfs_iops.c
View file

@ -546,7 +546,7 @@ xfs_setattr_nonsize(
} }
tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE); tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
error = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp), 0, 0, 0); error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
if (error) if (error)
goto out_dqrele; goto out_dqrele;
@ -808,9 +808,7 @@ xfs_setattr_size(
goto out_unlock; goto out_unlock;
tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_SIZE); tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_SIZE);
error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
XFS_TRANS_PERM_LOG_RES,
XFS_ITRUNCATE_LOG_COUNT);
if (error) if (error)
goto out_trans_cancel; goto out_trans_cancel;
@ -933,7 +931,7 @@ xfs_vn_update_time(
trace_xfs_update_time(ip); trace_xfs_update_time(ip);
tp = xfs_trans_alloc(mp, XFS_TRANS_FSYNC_TS); tp = xfs_trans_alloc(mp, XFS_TRANS_FSYNC_TS);
error = xfs_trans_reserve(tp, 0, XFS_FSYNC_TS_LOG_RES(mp), 0, 0, 0); error = xfs_trans_reserve(tp, &M_RES(mp)->tr_fsyncts, 0, 0);
if (error) { if (error) {
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
return -error; return -error;

5
fs/xfs/xfs_log_recover.c
View file

@ -3377,7 +3377,7 @@ xlog_recover_process_efi(
} }
tp = xfs_trans_alloc(mp, 0); tp = xfs_trans_alloc(mp, 0);
error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0, 0, 0); error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
if (error) if (error)
goto abort_error; goto abort_error;
efdp = xfs_trans_get_efd(tp, efip, efip->efi_format.efi_nextents); efdp = xfs_trans_get_efd(tp, efip, efip->efi_format.efi_nextents);
@ -3483,8 +3483,7 @@ xlog_recover_clear_agi_bucket(
int error; int error;
tp = xfs_trans_alloc(mp, XFS_TRANS_CLEAR_AGI_BUCKET); tp = xfs_trans_alloc(mp, XFS_TRANS_CLEAR_AGI_BUCKET);
error = xfs_trans_reserve(tp, 0, XFS_CLEAR_AGI_BUCKET_LOG_RES(mp), error = xfs_trans_reserve(tp, &M_RES(mp)->tr_clearagi, 0, 0);
0, 0, 0);
if (error) if (error)
goto out_abort; goto out_abort;

9
fs/xfs/xfs_mount.c
View file

@ -597,8 +597,7 @@ xfs_mount_reset_sbqflags(
return 0; return 0;
tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE); tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
error = xfs_trans_reserve(tp, 0, XFS_QM_SBCHANGE_LOG_RES(mp), error = xfs_trans_reserve(tp, &M_RES(mp)->tr_qm_sbchange, 0, 0);
0, 0, XFS_DEFAULT_LOG_COUNT);
if (error) { if (error) {
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
xfs_alert(mp, "%s: Superblock update failed!", __func__); xfs_alert(mp, "%s: Superblock update failed!", __func__);
@ -1071,8 +1070,7 @@ xfs_log_sbcount(xfs_mount_t *mp)
return 0; return 0;
tp = _xfs_trans_alloc(mp, XFS_TRANS_SB_COUNT, KM_SLEEP); tp = _xfs_trans_alloc(mp, XFS_TRANS_SB_COUNT, KM_SLEEP);
error = xfs_trans_reserve(tp, 0, XFS_SB_LOG_RES(mp), 0, 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_sb, 0, 0);
XFS_DEFAULT_LOG_COUNT);
if (error) { if (error) {
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
return error; return error;
@ -1392,8 +1390,7 @@ xfs_mount_log_sb(
XFS_SB_VERSIONNUM)); XFS_SB_VERSIONNUM));
tp = xfs_trans_alloc(mp, XFS_TRANS_SB_UNIT); tp = xfs_trans_alloc(mp, XFS_TRANS_SB_UNIT);
error = xfs_trans_reserve(tp, 0, XFS_SB_LOG_RES(mp), 0, 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_sb, 0, 0);
XFS_DEFAULT_LOG_COUNT);
if (error) { if (error) {
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
return error; return error;

11
fs/xfs/xfs_qm.c
View file

@ -865,11 +865,9 @@ xfs_qm_qino_alloc(
} }
tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QINOCREATE); tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QINOCREATE);
if ((error = xfs_trans_reserve(tp, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_create,
XFS_QM_QINOCREATE_SPACE_RES(mp), XFS_QM_QINOCREATE_SPACE_RES(mp), 0);
XFS_CREATE_LOG_RES(mp), 0, if (error) {
XFS_TRANS_PERM_LOG_RES,
XFS_CREATE_LOG_COUNT))) {
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
return error; return error;
} }
@ -1740,8 +1738,7 @@ xfs_qm_write_sb_changes(
int error; int error;
tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE); tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
error = xfs_trans_reserve(tp, 0, XFS_QM_SBCHANGE_LOG_RES(mp), error = xfs_trans_reserve(tp, &M_RES(mp)->tr_qm_sbchange, 0, 0);
0, 0, XFS_DEFAULT_LOG_COUNT);
if (error) { if (error) {
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
return error; return error;

13
fs/xfs/xfs_qm_syscalls.c
View file

@ -247,9 +247,7 @@ xfs_qm_scall_trunc_qfile(
xfs_ilock(ip, XFS_IOLOCK_EXCL); xfs_ilock(ip, XFS_IOLOCK_EXCL);
tp = xfs_trans_alloc(mp, XFS_TRANS_TRUNCATE_FILE); tp = xfs_trans_alloc(mp, XFS_TRANS_TRUNCATE_FILE);
error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
XFS_TRANS_PERM_LOG_RES,
XFS_ITRUNCATE_LOG_COUNT);
if (error) { if (error) {
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
xfs_iunlock(ip, XFS_IOLOCK_EXCL); xfs_iunlock(ip, XFS_IOLOCK_EXCL);
@ -540,8 +538,7 @@ xfs_qm_scall_setqlim(
xfs_dqunlock(dqp); xfs_dqunlock(dqp);
tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SETQLIM); tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SETQLIM);
error = xfs_trans_reserve(tp, 0, XFS_QM_SETQLIM_LOG_RES(mp), error = xfs_trans_reserve(tp, &M_RES(mp)->tr_qm_setqlim, 0, 0);
0, 0, XFS_DEFAULT_LOG_COUNT);
if (error) { if (error) {
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
goto out_rele; goto out_rele;
@ -675,8 +672,7 @@ xfs_qm_log_quotaoff_end(
tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QUOTAOFF_END); tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QUOTAOFF_END);
error = xfs_trans_reserve(tp, 0, XFS_QM_QUOTAOFF_END_LOG_RES(mp), error = xfs_trans_reserve(tp, &M_RES(mp)->tr_qm_equotaoff, 0, 0);
0, 0, XFS_DEFAULT_LOG_COUNT);
if (error) { if (error) {
xfs_trans_cancel(tp, 0); xfs_trans_cancel(tp, 0);
return (error); return (error);
@ -709,8 +705,7 @@ xfs_qm_log_quotaoff(
uint oldsbqflag=0; uint oldsbqflag=0;
tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QUOTAOFF); tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QUOTAOFF);
error = xfs_trans_reserve(tp, 0, XFS_QM_QUOTAOFF_LOG_RES(mp), error = xfs_trans_reserve(tp, &M_RES(mp)->tr_qm_quotaoff, 0, 0);
0, 0, XFS_DEFAULT_LOG_COUNT);
if (error) if (error)
goto error0; goto error0;

17
fs/xfs/xfs_rtalloc.c
View file

@ -100,10 +100,9 @@ xfs_growfs_rt_alloc(
/* /*
* Reserve space & log for one extent added to the file. * Reserve space & log for one extent added to the file.
*/ */
if ((error = xfs_trans_reserve(tp, resblks, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_growdata,
XFS_GROWRTALLOC_LOG_RES(mp), 0, resblks, 0);
XFS_TRANS_PERM_LOG_RES, if (error)
XFS_DEFAULT_PERM_LOG_COUNT)))
goto error_cancel; goto error_cancel;
cancelflags = XFS_TRANS_RELEASE_LOG_RES; cancelflags = XFS_TRANS_RELEASE_LOG_RES;
/* /*
@ -146,8 +145,9 @@ xfs_growfs_rt_alloc(
/* /*
* Reserve log for one block zeroing. * Reserve log for one block zeroing.
*/ */
if ((error = xfs_trans_reserve(tp, 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_growrtzero,
XFS_GROWRTZERO_LOG_RES(mp), 0, 0, 0))) 0, 0);
if (error)
goto error_cancel; goto error_cancel;
/* /*
* Lock the bitmap inode. * Lock the bitmap inode.
@ -1957,8 +1957,9 @@ xfs_growfs_rt(
* Start a transaction, get the log reservation. * Start a transaction, get the log reservation.
*/ */
tp = xfs_trans_alloc(mp, XFS_TRANS_GROWFSRT_FREE); tp = xfs_trans_alloc(mp, XFS_TRANS_GROWFSRT_FREE);
if ((error = xfs_trans_reserve(tp, 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_growrtfree,
XFS_GROWRTFREE_LOG_RES(nmp), 0, 0, 0))) 0, 0);
if (error)
goto error_cancel; goto error_cancel;
/* /*
* Lock out other callers by grabbing the bitmap inode lock. * Lock out other callers by grabbing the bitmap inode lock.

10
fs/xfs/xfs_symlink.c
View file

@ -231,12 +231,10 @@ xfs_symlink(
else else
fs_blocks = xfs_symlink_blocks(mp, pathlen); fs_blocks = xfs_symlink_blocks(mp, pathlen);
resblks = XFS_SYMLINK_SPACE_RES(mp, link_name->len, fs_blocks); resblks = XFS_SYMLINK_SPACE_RES(mp, link_name->len, fs_blocks);
error = xfs_trans_reserve(tp, resblks, XFS_SYMLINK_LOG_RES(mp), 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_symlink, resblks, 0);
XFS_TRANS_PERM_LOG_RES, XFS_SYMLINK_LOG_COUNT);
if (error == ENOSPC && fs_blocks == 0) { if (error == ENOSPC && fs_blocks == 0) {
resblks = 0; resblks = 0;
error = xfs_trans_reserve(tp, 0, XFS_SYMLINK_LOG_RES(mp), 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_symlink, 0, 0);
XFS_TRANS_PERM_LOG_RES, XFS_SYMLINK_LOG_COUNT);
} }
if (error) { if (error) {
cancel_flags = 0; cancel_flags = 0;
@ -539,8 +537,8 @@ xfs_inactive_symlink_rmt(
* Put an itruncate log reservation in the new transaction * Put an itruncate log reservation in the new transaction
* for our caller. * for our caller.
*/ */
if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0, error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
XFS_TRANS_PERM_LOG_RES, XFS_ITRUNCATE_LOG_COUNT))) { if (error) {
ASSERT(XFS_FORCED_SHUTDOWN(mp)); ASSERT(XFS_FORCED_SHUTDOWN(mp));
goto error0; goto error0;
} }

49
fs/xfs/xfs_trans.c
View file

@ -56,7 +56,7 @@ void
xfs_trans_init( xfs_trans_init(
struct xfs_mount *mp) struct xfs_mount *mp)
{ {
xfs_trans_resv_calc(mp, &mp->m_resv); xfs_trans_resv_calc(mp, M_RES(mp));
} }
/* /*
@ -180,12 +180,10 @@ xfs_trans_dup(
*/ */
int int
xfs_trans_reserve( xfs_trans_reserve(
xfs_trans_t *tp, struct xfs_trans *tp,
struct xfs_trans_res *resp,
uint blocks, uint blocks,
uint logspace, uint rtextents)
uint rtextents,
uint flags,
uint logcount)
{ {
int error = 0; int error = 0;
int rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0; int rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
@ -211,13 +209,15 @@ xfs_trans_reserve(
/* /*
* Reserve the log space needed for this transaction. * Reserve the log space needed for this transaction.
*/ */
if (logspace > 0) { if (resp->tr_logres > 0) {
bool permanent = false; bool permanent = false;
ASSERT(tp->t_log_res == 0 || tp->t_log_res == logspace); ASSERT(tp->t_log_res == 0 ||
ASSERT(tp->t_log_count == 0 || tp->t_log_count == logcount); tp->t_log_res == resp->tr_logres);
ASSERT(tp->t_log_count == 0 ||
tp->t_log_count == resp->tr_logcount);
if (flags & XFS_TRANS_PERM_LOG_RES) { if (resp->tr_logflags & XFS_TRANS_PERM_LOG_RES) {
tp->t_flags |= XFS_TRANS_PERM_LOG_RES; tp->t_flags |= XFS_TRANS_PERM_LOG_RES;
permanent = true; permanent = true;
} else { } else {
@ -226,20 +226,21 @@ xfs_trans_reserve(
} }
if (tp->t_ticket != NULL) { if (tp->t_ticket != NULL) {
ASSERT(flags & XFS_TRANS_PERM_LOG_RES); ASSERT(resp->tr_logflags & XFS_TRANS_PERM_LOG_RES);
error = xfs_log_regrant(tp->t_mountp, tp->t_ticket); error = xfs_log_regrant(tp->t_mountp, tp->t_ticket);
} else { } else {
error = xfs_log_reserve(tp->t_mountp, logspace, error = xfs_log_reserve(tp->t_mountp,
logcount, &tp->t_ticket, resp->tr_logres,
XFS_TRANSACTION, permanent, resp->tr_logcount,
tp->t_type); &tp->t_ticket, XFS_TRANSACTION,
permanent, tp->t_type);
} }
if (error) if (error)
goto undo_blocks; goto undo_blocks;
tp->t_log_res = logspace; tp->t_log_res = resp->tr_logres;
tp->t_log_count = logcount; tp->t_log_count = resp->tr_logcount;
} }
/* /*
@ -264,10 +265,10 @@ xfs_trans_reserve(
* reservations which have already been performed. * reservations which have already been performed.
*/ */
undo_log: undo_log:
if (logspace > 0) { if (resp->tr_logres > 0) {
int log_flags; int log_flags;
if (flags & XFS_TRANS_PERM_LOG_RES) { if (resp->tr_logflags & XFS_TRANS_PERM_LOG_RES) {
log_flags = XFS_LOG_REL_PERM_RESERV; log_flags = XFS_LOG_REL_PERM_RESERV;
} else { } else {
log_flags = 0; log_flags = 0;
@ -1014,7 +1015,7 @@ xfs_trans_roll(
struct xfs_inode *dp) struct xfs_inode *dp)
{ {
struct xfs_trans *trans; struct xfs_trans *trans;
unsigned int logres, count; struct xfs_trans_res tres;
int error; int error;
/* /*
@ -1026,8 +1027,8 @@ xfs_trans_roll(
/* /*
* Copy the critical parameters from one trans to the next. * Copy the critical parameters from one trans to the next.
*/ */
logres = trans->t_log_res; tres.tr_logres = trans->t_log_res;
count = trans->t_log_count; tres.tr_logcount = trans->t_log_count;
*tpp = xfs_trans_dup(trans); *tpp = xfs_trans_dup(trans);
/* /*
@ -1058,8 +1059,8 @@ xfs_trans_roll(
* across this call, or that anything that is locked be logged in * across this call, or that anything that is locked be logged in
* the prior and the next transactions. * the prior and the next transactions.
*/ */
error = xfs_trans_reserve(trans, 0, logres, 0, tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
XFS_TRANS_PERM_LOG_RES, count); error = xfs_trans_reserve(trans, &tres, 0, 0);
/* /*
* Ensure that the inode is in the new transaction and locked. * Ensure that the inode is in the new transaction and locked.
*/ */

3
fs/xfs/xfs_trans.h
View file

@ -34,6 +34,7 @@ struct xfs_log_iovec;
struct xfs_log_item_desc; struct xfs_log_item_desc;
struct xfs_mount; struct xfs_mount;
struct xfs_trans; struct xfs_trans;
struct xfs_trans_res;
struct xfs_dquot_acct; struct xfs_dquot_acct;
struct xfs_busy_extent; struct xfs_busy_extent;
@ -170,7 +171,7 @@ typedef struct xfs_trans {
xfs_trans_t *xfs_trans_alloc(struct xfs_mount *, uint); xfs_trans_t *xfs_trans_alloc(struct xfs_mount *, uint);
xfs_trans_t *_xfs_trans_alloc(struct xfs_mount *, uint, xfs_km_flags_t); xfs_trans_t *_xfs_trans_alloc(struct xfs_mount *, uint, xfs_km_flags_t);
xfs_trans_t *xfs_trans_dup(xfs_trans_t *); xfs_trans_t *xfs_trans_dup(xfs_trans_t *);
int xfs_trans_reserve(xfs_trans_t *, uint, uint, uint, int xfs_trans_reserve(struct xfs_trans *, struct xfs_trans_res *,
uint, uint); uint, uint);
void xfs_trans_mod_sb(xfs_trans_t *, uint, int64_t); void xfs_trans_mod_sb(xfs_trans_t *, uint, int64_t);

7
fs/xfs/xfs_trans_resv.c
View file

@ -547,7 +547,8 @@ xfs_calc_attrsetm_reservation(
* Since the runtime attribute transaction space is dependent on the total * Since the runtime attribute transaction space is dependent on the total
* blocks needed for the 1st bmap, here we calculate out the space unit for * blocks needed for the 1st bmap, here we calculate out the space unit for
* one block so that the caller could figure out the total space according * one block so that the caller could figure out the total space according
* to the attibute extent length in blocks by: ext * XFS_ATTRSETRT_LOG_RES(mp). * to the attibute extent length in blocks by:
* ext * M_RES(mp)->tr_attrsetrt.tr_logres
*/ */
STATIC uint STATIC uint
xfs_calc_attrsetrt_reservation( xfs_calc_attrsetrt_reservation(
@ -619,14 +620,14 @@ xfs_calc_qm_setqlim_reservation(
/* /*
* Allocating quota on disk if needed. * Allocating quota on disk if needed.
* the write transaction log space: XFS_WRITE_LOG_RES(mp) * the write transaction log space: M_RES(mp)->tr_write.tr_logres
* the unit of quota allocation: one system block size * the unit of quota allocation: one system block size
*/ */
STATIC uint STATIC uint
xfs_calc_qm_dqalloc_reservation( xfs_calc_qm_dqalloc_reservation(
struct xfs_mount *mp) struct xfs_mount *mp)
{ {
return XFS_WRITE_LOG_RES(mp) + return M_RES(mp)->tr_write.tr_logres +
xfs_calc_buf_res(1, xfs_calc_buf_res(1,
XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB) - 1); XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB) - 1);
} }

3
fs/xfs/xfs_trans_resv.h
View file

@ -65,6 +65,9 @@ struct xfs_trans_resv {
struct xfs_trans_res tr_fsyncts; /* update timestamps on fsync */ struct xfs_trans_res tr_fsyncts; /* update timestamps on fsync */
}; };
/* shorthand way of accessing reservation structure */
#define M_RES(mp) (&(mp)->m_resv)
/* /*
* Per-extent log reservation for the allocation btree changes * Per-extent log reservation for the allocation btree changes
* involved in freeing or allocating an extent. * involved in freeing or allocating an extent.