xfs: Pass xattr name and value length explicitly to xfs_attr_leaf_newentsize
PATCH v4 1/7 xfs: Pass xattr name and value length explicitly to xfs_attr_leaf_newentsize
This commit changes xfs_attr_leaf_newentsize() to explicitly accept name and value length instead of a pointer to struct xfs_da_args. A future commit will need to invoke xfs_attr_leaf_newentsize() from functions that do not have a struct xfs_da_args to pass in.
---
Changelog:
V1 -> V2:
1. Use convenience variables to reduce indentation of code.
V2 -> V3:
1. Introduce 'struct xfs_attr_set_resv' to collect various block size reservations when inserting an xattr.
2. Add xfs_calc_attr_res() to calculate the total log reservation to required when inserting an xattr.
V3 -> V4:
1. Rebase the patchset on top of Christoph's "Clean attr interface" patchset. The patchset can be obtained from
https://github.com/chandanr/linux/tree/xfs-fix-attr-resv-calc-v4.
2. Split the patchset into
- Patches which refactor the existing calculation in
xfs_attr_calc_size().
- One patch which fixes the calculation inside
xfs_attr_calc_size().3. Fix indentation issues.
4. Pass attribute geometry pointer to xfs_attr_leaf_newentsize() instead of a pointer to xfs_mount.
libxfs/xfs_attr.c | 3 ++- libxfs/xfs_attr_leaf.c | 39 ++++++++++++++++++++++++++------------- libxfs/xfs_attr_leaf.h | 3 ++- 3 files changed, 30 insertions(+), 15 deletions(-)
libxfs/xfs_attr.c +2 -1
@@ -149,7 +149,8 @@ xfs_attr_calc_size(* Determine space new attribute will use, and if it would be * "local" or "remote" (note: local != inline). */ - size =xfs_attr_leaf_newentsize (args, local); + size =xfs_attr_leaf_newentsize (args->geo, args->namelen, + args->valuelen, local); nblks =XFS_DAENTER_SPACE_RES (mp,XFS_ATTR_FORK );if (*local) {if (size > (args->geo->blksize /2 )) {
libxfs/xfs_attr_leaf.c +26 -13
@@ -1326,7 +1326,8 @@ xfs_attr3_leaf_add( leaf = bp->b_addr;xfs_attr3_leaf_hdr_from_disk (args->geo, &ichdr, leaf);ASSERT (args->index >=0 && args->index <= ichdr.count); - entsize =xfs_attr_leaf_newentsize (args,NULL ); + entsize =xfs_attr_leaf_newentsize (args->geo, args->namelen, + args->valuelen,NULL );/* * Search through freemap for first-fit on new name length.
@@ -1399,6 +1400,7 @@ xfs_attr3_leaf_add_work(struct xfs_attr_leaf_name_local *name_loc;struct xfs_attr_leaf_name_remote *name_rmt;struct xfs_mount *mp; +int entsize;int tmp;int i;
@@ -1428,11 +1430,14 @@ xfs_attr3_leaf_add_work(ASSERT (ichdr->freemap[mapindex].base < args->geo->blksize);ASSERT ((ichdr->freemap[mapindex].base &0x3 ) ==0 );ASSERT (ichdr->freemap[mapindex].size >= -xfs_attr_leaf_newentsize (args,NULL )); +xfs_attr_leaf_newentsize (args->geo, args->namelen, + args->valuelen,NULL ));ASSERT (ichdr->freemap[mapindex].size < args->geo->blksize);ASSERT ((ichdr->freemap[mapindex].size &0x3 ) ==0 ); - ichdr->freemap[mapindex].size -=xfs_attr_leaf_newentsize (args, &tmp); + entsize =xfs_attr_leaf_newentsize (args->geo, args->namelen, + args->valuelen, &tmp); + ichdr->freemap[mapindex].size -= entsize; entry->nameidx =cpu_to_be16 (ichdr->freemap[mapindex].base + ichdr->freemap[mapindex].size);
@@ -1820,6 +1825,8 @@ xfs_attr3_leaf_figure_balance(struct xfs_attr_leafblock *leaf1 = blk1->bp->b_addr;struct xfs_attr_leafblock *leaf2 = blk2->bp->b_addr;struct xfs_attr_leaf_entry *entry; +struct xfs_da_args *args; +int entsize;int count;int max;int index;
@@ -1829,14 +1836,16 @@ xfs_attr3_leaf_figure_balance(int foundit =0 ;int tmp; + args = state->args;/* * Examine entries until we reduce the absolute difference in * byte usage between the two blocks to a minimum. */ max = ichdr1->count + ichdr2->count; half = (max +1 ) *sizeof (*entry); - half += ichdr1->usedbytes + ichdr2->usedbytes + -xfs_attr_leaf_newentsize (state->args,NULL ); + entsize =xfs_attr_leaf_newentsize (args->geo, args->namelen, + args->valuelen,NULL ); + half += ichdr1->usedbytes + ichdr2->usedbytes + entsize; half /=2 ; lastdelta = state->args->geo->blksize; entry =xfs_attr3_leaf_entryp (leaf1);
@@ -1847,8 +1856,9 @@ xfs_attr3_leaf_figure_balance(* The new entry is in the first block, account for it. */ if (count == blk1->index) { - tmp = totallen +sizeof (*entry) + -xfs_attr_leaf_newentsize (state->args,NULL ); + entsize =xfs_attr_leaf_newentsize (args->geo, + args->namelen, args->valuelen,NULL ); + tmp = totallen +sizeof (*entry) + entsize;if (XFS_ATTR_ABS (half - tmp) > lastdelta)break ; lastdelta =XFS_ATTR_ABS (half - tmp);
@@ -1883,8 +1893,9 @@ xfs_attr3_leaf_figure_balance(*/ totallen -= count *sizeof (*entry);if (foundit) { - totallen -=sizeof (*entry) + -xfs_attr_leaf_newentsize (state->args,NULL ); + entsize =xfs_attr_leaf_newentsize (args->geo, args->namelen, + args->valuelen,NULL ); + totallen -=sizeof (*entry) + entsize; } *countarg = count;
@@ -2660,20 +2671,22 @@ xfs_attr_leaf_entsize(xfs_attr_leafblock_t *leaf, int index)*/ int xfs_attr_leaf_newentsize ( -struct xfs_da_args *args, +struct xfs_da_geometry *geo, +int namelen, +int valuelen,int *local) {int size; - size =xfs_attr_leaf_entsize_local (args->namelen, args->valuelen); -if (size <xfs_attr_leaf_entsize_local_max (args->geo->blksize)) { + size =xfs_attr_leaf_entsize_local (namelen, valuelen); +if (size <xfs_attr_leaf_entsize_local_max (geo->blksize)) {if (local) *local =1 ;return size; }if (local) *local =0 ; -return xfs_attr_leaf_entsize_remote (args->namelen); +return xfs_attr_leaf_entsize_remote (namelen); }
libxfs/xfs_attr_leaf.h +2 -1
@@ -96,7 +96,8 @@ void xfs_attr3_leaf_unbalance(struct xfs_da_state *state,xfs_dahash_t xfs_attr_leaf_lasthash (struct xfs_buf *bp,int *count);int xfs_attr_leaf_order (struct xfs_buf *leaf1_bp,struct xfs_buf *leaf2_bp); -int xfs_attr_leaf_newentsize (struct xfs_da_args *args,int *local); +int xfs_attr_leaf_newentsize (struct xfs_da_geometry *geo,int namelen, +int valuelen,int *local);int xfs_attr3_leaf_read (struct xfs_trans *tp,struct xfs_inode *dp,xfs_dablk_t bno,struct xfs_buf **bpp); void xfs_attr3_leaf_hdr_from_disk(struct xfs_da_geometry *geo,
Signature · 1 line
2.19.1
PATCH v4 2/7 xfs: xfs_attr_calc_size: Use local variables to track individual space components
The size calculated by xfs_attr_calc_size() is a sum of three components,
1. Number of dabtree blocks
2. Number of Bmbt blocks
3. Number of remote blocks
This commit introduces new local variables to track these numbers explicitly.
--- libxfs/xfs_attr.c | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-)
libxfs/xfs_attr.c +12 -7
@@ -142,8 +142,10 @@ xfs_attr_calc_size( int *local) {struct xfs_mount *mp = args->dp->i_mount; +unsigned int total_dablks; +unsigned int bmbt_blks; +unsigned int rmt_blks;int size; -int nblks;/* * Determine space new attribute will use, and if it would be
@@ -151,23 +153,26 @@ xfs_attr_calc_size(*/ size =xfs_attr_leaf_newentsize (args->geo, args->namelen, args->valuelen, local); - nblks =XFS_DAENTER_SPACE_RES (mp,XFS_ATTR_FORK ); + total_dablks =XFS_DAENTER_BLOCKS (mp,XFS_ATTR_FORK ); + bmbt_blks =XFS_DAENTER_BMAPS (mp,XFS_ATTR_FORK );if (*local) {if (size > (args->geo->blksize /2 )) {/* Double split possible */ - nblks *=2 ; + total_dablks *=2 ; + bmbt_blks *=2 ; } + rmt_blks =0 ; }else {/* * Out of line attribute, cannot double split, but * make room for the attribute value itself. */ -uint dblocks =xfs_attr3_rmt_blocks (mp, args->valuelen); - nblks += dblocks; - nblks +=XFS_NEXTENTADD_SPACE_RES (mp, dblocks,XFS_ATTR_FORK ); + rmt_blks =xfs_attr3_rmt_blocks (mp, args->valuelen); + bmbt_blks +=XFS_NEXTENTADD_SPACE_RES (mp, rmt_blks, +XFS_ATTR_FORK ); } -return nblks; +return total_dablks + rmt_blks + bmbt_blks; }STATIC int
Signature · 1 line
2.19.1
PATCH v4 3/7 xfs: xfs_attr_calc_size: Calculate Bmbt blks only once
In reply to Chandan RajendraThe number of Bmbt blocks that is required can be calculated only once by passing the sum of total number of dabtree blocks and remote blocks to XFS_NEXTENTADD_SPACE_RES() macro.
--- libxfs/xfs_attr.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-)
libxfs/xfs_attr.c +3 -4
@@ -154,12 +154,10 @@ xfs_attr_calc_size( size =xfs_attr_leaf_newentsize (args->geo, args->namelen, args->valuelen, local); total_dablks =XFS_DAENTER_BLOCKS (mp,XFS_ATTR_FORK ); - bmbt_blks =XFS_DAENTER_BMAPS (mp,XFS_ATTR_FORK );if (*local) {if (size > (args->geo->blksize /2 )) {/* Double split possible */ total_dablks *=2 ; - bmbt_blks *=2 ; } rmt_blks =0 ; }else {
@@ -168,10 +166,11 @@ xfs_attr_calc_size(* make room for the attribute value itself. */ rmt_blks =xfs_attr3_rmt_blocks (mp, args->valuelen); - bmbt_blks +=XFS_NEXTENTADD_SPACE_RES (mp, rmt_blks, -XFS_ATTR_FORK ); } + bmbt_blks =XFS_NEXTENTADD_SPACE_RES (mp, total_dablks + rmt_blks, +XFS_ATTR_FORK ); +return total_dablks + rmt_blks + bmbt_blks; }
Signature · 1 line
2.19.1
PATCH v4 4/7 xfs: Introduce struct xfs_attr_set_resv
In reply to Chandan RajendraThe intermediate numbers calculated by xfs_attr_calc_size() will be needed by a future commit to correctly calculate log reservation for xattr set operation. Towards this goal, this commit introduces 'struct xfs_attr_set_resv' to collect,
1. Number of dabtree blocks.
2. Number of remote blocks.
3. Number of Bmbt blocks.
4. Total number of blocks we need to reserve.
This will be returned as an out argument by xfs_attr_calc_size().
--- libxfs/xfs_attr.c | 48 +++++++++++++++++++++++++---------------------- libxfs/xfs_attr.h | 13 +++++++++++++ 2 files changed, 39 insertions(+), 22 deletions(-)
libxfs/xfs_attr.c +26 -22
@@ -136,16 +136,14 @@ xfs_attr_get(/* * Calculate how many blocks we need for the new attribute, */ -STATIC int +STATIC voidxfs_attr_calc_size ( -struct xfs_da_args *args, -int *local) +struct xfs_da_args *args, +struct xfs_attr_set_resv *resv, +int *local) { -struct xfs_mount *mp = args->dp->i_mount; -unsigned int total_dablks; -unsigned int bmbt_blks; -unsigned int rmt_blks; -int size; +struct xfs_mount *mp = args->dp->i_mount; +int size;/* * Determine space new attribute will use, and if it would be
@@ -153,25 +151,27 @@ xfs_attr_calc_size(*/ size =xfs_attr_leaf_newentsize (args->geo, args->namelen, args->valuelen, local); - total_dablks =XFS_DAENTER_BLOCKS (mp,XFS_ATTR_FORK ); + resv->total_dablks =XFS_DAENTER_BLOCKS (mp,XFS_ATTR_FORK );if (*local) {if (size > (args->geo->blksize /2 )) {/* Double split possible */ - total_dablks *=2 ; + resv->total_dablks *=2 ; } - rmt_blks =0 ; + resv->rmt_blks =0 ; }else {/* * Out of line attribute, cannot double split, but * make room for the attribute value itself. */ - rmt_blks =xfs_attr3_rmt_blocks (mp, args->valuelen); + resv->rmt_blks =xfs_attr3_rmt_blocks (mp, args->valuelen); } - bmbt_blks =XFS_NEXTENTADD_SPACE_RES (mp, total_dablks + rmt_blks, -XFS_ATTR_FORK ); + resv->bmbt_blks =XFS_NEXTENTADD_SPACE_RES (mp, + resv->total_dablks + resv->rmt_blks, +XFS_ATTR_FORK ); -return total_dablks + rmt_blks + bmbt_blks; + resv->alloc_blks = resv->total_dablks + resv->rmt_blks + + resv->bmbt_blks; }STATIC int
@@ -297,12 +297,15 @@ intxfs_attr_set ( struct xfs_da_args *args) { -struct xfs_inode *dp = args->dp; -struct xfs_mount *mp = dp->i_mount; -struct xfs_trans_res tres; -bool rsvd = (args->attr_namespace &XFS_ATTR_ROOT ); -int error, local; -unsigned int total; +struct xfs_inode *dp = args->dp; +struct xfs_mount *mp = dp->i_mount; +struct xfs_attr_set_resv resv; +struct xfs_trans_res tres; +bool rsvd; +int error, local; +unsigned int total; + + rsvd = (args->attr_namespace &XFS_ATTR_ROOT );if (XFS_FORCED_SHUTDOWN (dp->i_mount))return -EIO ;
@@ -326,7 +329,8 @@ xfs_attr_set(XFS_STATS_INC (mp, xs_attr_set); args->op_flags |=XFS_DA_OP_ADDNAME ; - args->total =xfs_attr_calc_size (args, &local); +xfs_attr_calc_size (args, &resv, &local); + args->total = resv.alloc_blks;/* * If the inode doesn't have an attribute fork, add one.
libxfs/xfs_attr.h +13 -0
@@ -73,6 +73,19 @@ struct xfs_attr_list_context {int index;/* index into output buffer */ }; +struct xfs_attr_set_resv { +/* Number of unlogged blocks needed to store the remote attr value. */ +unsigned int rmt_blks; + +/* Number of filesystem blocks to allocate for the da btree. */ +unsigned int total_dablks; + +/* Blocks we might need to create all the new attr fork mappings. */ +unsigned int bmbt_blks; + +/* Total number of blocks we might have to allocate. */ +unsigned int alloc_blks; +};/*======================================================================== * Function prototypes for the kernel.
Signature · 1 line
2.19.1
PATCH v4 5/7 xfs: xfs_attr_calc_size: Explicitly pass mp, namelen and valuelen args
In reply to Chandan RajendraIn a future commit, xfs_attr_calc_size() will be invoked from a function that does not have a 'struct xfs_da_args' handy. Hence this commit changes xfs_attr_calc_size() to let invokers to explicitly pass 'struct xfs_mount *', namelen and valuelen arguments.
--- libxfs/xfs_attr.c | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-)
libxfs/xfs_attr.c +10 -7
@@ -138,22 +138,24 @@ xfs_attr_get(*/ STATIC voidxfs_attr_calc_size ( -struct xfs_da_args *args, +struct xfs_mount *mp,struct xfs_attr_set_resv *resv, +int namelen, +int valuelen,int *local) { -struct xfs_mount *mp = args->dp->i_mount; +unsigned int blksize = mp->m_attr_geo->blksize;int size;/* * Determine space new attribute will use, and if it would be * "local" or "remote" (note: local != inline). */ - size =xfs_attr_leaf_newentsize (args->geo, args->namelen, - args->valuelen, local); + size =xfs_attr_leaf_newentsize (mp->m_attr_geo, namelen, valuelen, + local); resv->total_dablks =XFS_DAENTER_BLOCKS (mp,XFS_ATTR_FORK );if (*local) { -if (size > (args->geo->blksize /2 )) { +if (size > (blksize /2 )) {/* Double split possible */ resv->total_dablks *=2 ; }
@@ -163,7 +165,7 @@ xfs_attr_calc_size(* Out of line attribute, cannot double split, but * make room for the attribute value itself. */ - resv->rmt_blks =xfs_attr3_rmt_blocks (mp, args->valuelen); + resv->rmt_blks =xfs_attr3_rmt_blocks (mp, valuelen); } resv->bmbt_blks = XFS_NEXTENTADD_SPACE_RES(mp,
@@ -329,7 +331,8 @@ xfs_attr_set(XFS_STATS_INC (mp, xs_attr_set); args->op_flags |=XFS_DA_OP_ADDNAME ; -xfs_attr_calc_size (args, &resv, &local); +xfs_attr_calc_size (mp, &resv, args->namelen, args->valuelen, + &local); args->total = resv.alloc_blks;/*
Signature · 1 line
2.19.1
PATCH v4 6/7 xfs: Make xfs_attr_calc_size() non-static
In reply to Chandan RajendraA future commit will cause xfs_attr_calc_size() to be invoked from a function defined in another file. Hence this commit makes xfs_attr_calc_size() as non-static.
--- libxfs/xfs_attr.c | 58 +++++++++++++++++++++++------------------------ libxfs/xfs_attr.h | 2 ++ 2 files changed, 31 insertions(+), 29 deletions(-)
libxfs/xfs_attr.c +29 -29
@@ -133,10 +133,38 @@ xfs_attr_get(return error; } +STATIC int +xfs_attr_try_sf_addname ( +struct xfs_inode *dp, +struct xfs_da_args *args) +{ + +struct xfs_mount *mp = dp->i_mount; +int error, error2; + + error =xfs_attr_shortform_addname (args); +if (error == -ENOSPC ) +return error; + +/* +* Commit the shortform mods, and we're done. +* NOTE: this is also the error path (EEXIST, etc). +*/ +if (!error && !(args->op_flags &XFS_DA_OP_NOTIME )) +xfs_trans_ichgtime (args->trans, dp,XFS_ICHGTIME_CHG ); + +if (mp->m_flags &XFS_MOUNT_WSYNC ) +xfs_trans_set_sync (args->trans); + + error2 =xfs_trans_commit (args->trans); + args->trans =NULL ; +return error ? error : error2; +} +/* * Calculate how many blocks we need for the new attribute, */ -STATIC void +void xfs_attr_calc_size( struct xfs_mount *mp, struct xfs_attr_set_resv *resv,
@@ -176,34 +204,6 @@ xfs_attr_calc_size( resv->bmbt_blks; } -STATIC int -xfs_attr_try_sf_addname ( -struct xfs_inode *dp, -struct xfs_da_args *args) -{ - -struct xfs_mount *mp = dp->i_mount; -int error, error2; - - error =xfs_attr_shortform_addname (args); -if (error == -ENOSPC ) -return error; - -/* -* Commit the shortform mods, and we're done. -* NOTE: this is also the error path (EEXIST, etc). -*/ -if (!error && !(args->op_flags &XFS_DA_OP_NOTIME )) -xfs_trans_ichgtime (args->trans, dp,XFS_ICHGTIME_CHG ); - -if (mp->m_flags &XFS_MOUNT_WSYNC ) -xfs_trans_set_sync (args->trans); - - error2 =xfs_trans_commit (args->trans); - args->trans =NULL ; -return error ? error : error2; -} -/* * Set the attribute specified in @args. */
libxfs/xfs_attr.h +2 -0
@@ -104,5 +104,7 @@ int xfs_attr_set(struct xfs_da_args *args);int xfs_attr_set_args (struct xfs_da_args *args);int xfs_attr_remove_args (struct xfs_da_args *args);bool xfs_attr_namecheck (const void *name,size_t length); +void xfs_attr_calc_size (struct xfs_mount *mp,struct xfs_attr_set_resv *resv, +int namelen,int valuelen,int *local);#endif /* __XFS_ATTR_H__ */
Signature · 1 line
2.19.1
PATCH v4 7/7 xfs: Fix log reservation calculation for xattr insert operation
In reply to Chandan RajendraLog space reservation for xattr insert operation can be divided into two parts,
1. Mount time
- Inode
- Superblock for accounting space allocations
- AGF for accounting space used by count, block number, rmap and refcnt btrees.
2. The remaining log space can only be calculated at run time because,
- A local xattr can be large enough to cause a double split of the dabtree.
- The value of the xattr can be large enough to be stored in remote blocks. The contents of the remote blocks are not logged.
The log space reservation could be,
- 2 * XFS_DA_NODE_MAXDEPTH number of blocks. Additional XFS_DA_NODE_MAXDEPTH number of blocks are required if xattr is large enough to cause another split of the dabtree path from root to leaf block.
- BMBT blocks for storing (2 * XFS_DA_NODE_MAXDEPTH) record entries. Additional XFS_DA_NODE_MAXDEPTH number of blocks are required in case of a double split of the dabtree path from root to leaf blocks.
- Space for logging blocks of count, block number, rmap and refcnt btrees.
Presently, mount time log reservation includes block count required for a single split of the dabtree. The dabtree block count is also taken into account by xfs_attr_calc_size().
Also, AGF log space reservation isn't accounted for.
Due to the reasons mentioned above, log reservation calculation for xattr insert operation gives an incorrect value.
Apart from the above, xfs_log_calc_max_attrsetm_res() passes byte count as an argument to XFS_NEXTENTADD_SPACE_RES() instead of block count.
To fix these issues, this commit changes xfs_attr_calc_size() to also calculate the number of dabtree blocks that need to be logged.
xfs_attr_set() uses the following values computed by xfs_attr_calc_size()
1. The number of dabtree blocks that need to be logged.
2. The number of remote blocks that need to be allocated.
3. The number of dabtree blocks that need to be allocated.
4. The number of bmbt blocks that need to be allocated.
5. The total number of blocks that need to be allocated.
... to compute number of bytes that need to be reserved in the log.
This commit also modifies xfs_log_calc_max_attrsetm_res() to invoke xfs_attr_calc_size() to obtain the number of blocks to be logged which it uses to figure out the total number of bytes to be logged.
--- libxfs/xfs_attr.c | 6 ++--- libxfs/xfs_attr.h | 3 +++ libxfs/xfs_log_rlimit.c | 16 ++++++------- libxfs/xfs_trans_resv.c | 50 ++++++++++++++++++++--------------------- libxfs/xfs_trans_resv.h | 2 ++ 5 files changed, 40 insertions(+), 37 deletions(-)
libxfs/xfs_attr.c +3 -3
@@ -182,9 +182,11 @@ xfs_attr_calc_size( size =xfs_attr_leaf_newentsize (mp->m_attr_geo, namelen, valuelen, local); resv->total_dablks =XFS_DAENTER_BLOCKS (mp,XFS_ATTR_FORK ); + resv->log_dablks =2 * resv->total_dablks;if (*local) {if (size > (blksize /2 )) {/* Double split possible */ + resv->log_dablks += resv->total_dablks; resv->total_dablks *=2 ; } resv->rmt_blks =0 ;
@@ -349,9 +351,7 @@ xfs_attr_set(return error; } - tres.tr_logres =M_RES (mp)->tr_attrsetm.tr_logres + -M_RES (mp)->tr_attrsetrt.tr_logres * - args->total; + tres.tr_logres =xfs_calc_attr_res (mp, &resv); tres.tr_logcount =XFS_ATTRSET_LOG_COUNT ; tres.tr_logflags =XFS_TRANS_PERM_LOG_RES ; total = args->total;
libxfs/xfs_attr.h +3 -0
@@ -74,6 +74,9 @@ struct xfs_attr_list_context { };struct xfs_attr_set_resv { +/* Number of blocks in the da btree that we might need to log. */ +unsigned int log_dablks; +/* Number of unlogged blocks needed to store the remote attr value. */ unsigned int rmt_blks;
libxfs/xfs_log_rlimit.c +8 -8
@@ -10,6 +10,7 @@#include "xfs_log_format.h" #include "xfs_trans_resv.h" #include "xfs_mount.h" +#include "xfs_attr.h" #include "xfs_da_format.h" #include "xfs_trans_space.h" #include "xfs_da_btree.h"
@@ -21,19 +22,18 @@*/ STATIC intxfs_log_calc_max_attrsetm_res ( -struct xfs_mount *mp) +struct xfs_mount *mp) { -int size; -int nblks; +struct xfs_attr_set_resv resv; +int size; +int local; size =xfs_attr_leaf_entsize_local_max (mp->m_attr_geo->blksize) -MAXNAMELEN -1 ; - nblks =XFS_DAENTER_SPACE_RES (mp,XFS_ATTR_FORK ); - nblks +=XFS_B_TO_FSB (mp, size); - nblks +=XFS_NEXTENTADD_SPACE_RES (mp, size,XFS_ATTR_FORK ); +xfs_attr_calc_size (mp, &resv, size,0 , &local); +ASSERT (local ==1 ); -return M_RES (mp)->tr_attrsetm.tr_logres + -M_RES (mp)->tr_attrsetrt.tr_logres * nblks; +return xfs_calc_attr_res (mp, &resv); }/*
libxfs/xfs_trans_resv.c +24 -26
82 lines not on this page · raw message
libxfs/xfs_trans_resv.h +2 -0
@@ -7,6 +7,7 @@#define __XFS_TRANS_RESV_H__struct xfs_mount ; +struct xfs_attr_set_resv ;/* * structure for maintaining pre-calculated transaction reservations.
@@ -91,6 +92,7 @@ struct xfs_trans_resv {#define XFS_ATTRSET_LOG_COUNT 3#define XFS_ATTRRM_LOG_COUNT 3 +uint xfs_calc_attr_res (struct xfs_mount *mp,struct xfs_attr_set_resv *resv);void xfs_trans_resv_calc (struct xfs_mount *mp,struct xfs_trans_resv *resp);uint xfs_allocfree_log_count (struct xfs_mount *mp,uint num_ops);
Signature · 1 line
2.19.1
Quoted 18 lines · Chandan Rajendra
This commit changes
xfs_attr_leaf_newentsize()to explicitly accept name and value length instead of a pointer to structxfs_da_args. A future commit will need to invokexfs_attr_leaf_newentsize()from functions that do not have a structxfs_da_argsto pass in.Signed-off-by Chandan Rajendra <[email protected]>---
Changelog:
V1 -> V2:
1. Use convenience variables to reduce indentation of code.V2 -> V3:
1. Introduce 'structxfs_attr_set_resv' to collect various block size reservations when inserting an xattr.
2. Addxfs_calc_attr_res()to calculate the total log reservation to required when inserting an xattr.
Quoted 4 lines
V3 -> V4:
1. Rebase the patchset on top of Christoph's "Clean attr interface" patchset. The patchset can be obtained from
https://github.com/chandanr/linux/tree/xfs-fix-attr-resv-calc-v4.
Sorry, The above link should have been
https://github.com/chandanr/xfsprogs-dev/tree/xfs-fix-attr-resv-calc-v4.
Signature · 1 line
chandan