decouple the in-memory from the on-disk log format V2
cover decouple the in-memory from the on-disk log format V2
Since the introduction of the CIL we already have a layer of indirection between the physical log format and the data structure tracking the changes in memory. But due to the way iop_format works we are still forced to keep a copy of everything that goes out to the log in memory even before copying it into the CIL.
The first patch in this series changes iop_format so that the log items are free to store their in-memory data however they want before formatting them into the CIL, and the other patches take advantage of that by not keeping most log formats in memory all the time. Especially the EFI and EFD related ones at the end start to show the benefit.
What's missing from this series are larger changes to the in-core inode layout. No needing the full struct icdinode at all times will be the biggest benefit of this change, but it will be large enough series of it's own.
Changes from V1:
- split into more patches
- added the xlog_copy_iovec helper
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 1/10 xfs: remove duplicate code in xlog_cil_insert_format_items
Share code that was previously duplicated in two branches.
--- fs/xfs/xfs_log_cil.c | 33 +++++++++++++-------------------- 1 file changed, 13 insertions(+), 20 deletions(-)
fs/xfs/xfs_log_cil.c +13 -20
@@ -254,29 +254,22 @@ xlog_cil_insert_format_items(*/ *diff_iovecs -= lv->lv_niovecs; *diff_len -= lv->lv_buf_len; - -/* Ensure the lv is set up according to ->iop_size */ - lv->lv_niovecs = niovecs; - lv->lv_buf = (char *)lv + buf_size - nbytes; - - lv->lv_buf_len =xlog_cil_lv_item_format (lip, lv); - goto insert; + }else { +/* allocate new data chunk */ + lv =kmem_zalloc (buf_size,KM_SLEEP |KM_NOFS ); + lv->lv_item = lip; + lv->lv_size = buf_size; +if (ordered) { +/* track as an ordered logvec */ +ASSERT (lip->li_lv ==NULL ); + lv->lv_buf_len =XFS_LOG_VEC_ORDERED ; + goto insert; + } + lv->lv_iovecp = (struct xfs_log_iovec *)&lv[1 ]; } -/* allocate new data chunk */ - lv =kmem_zalloc (buf_size,KM_SLEEP |KM_NOFS ); - lv->lv_item = lip; - lv->lv_size = buf_size; +/* Ensure the lv is set up according to ->iop_size */ lv->lv_niovecs = niovecs; -if (ordered) { -/* track as an ordered logvec */ -ASSERT (lip->li_lv ==NULL ); - lv->lv_buf_len =XFS_LOG_VEC_ORDERED ; - goto insert; - } - -/* The allocated iovec region lies beyond the log vector. */ - lv->lv_iovecp = (struct xfs_log_iovec *)&lv[1 ];/* The allocated data region lies beyond the iovec region */ lv->lv_buf = (char *)lv + buf_size - nbytes;
Signature · 7 lines
1.7.10.4 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 01/10] xfs: remove duplicate code in xlog_cil_insert_format_items
Quoted 3 lines · Christoph Hellwig
Share code that was previously duplicated in two branches.
Signed-off-by Christoph Hellwig <[email protected]>
looks good.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 01/10] xfs: remove duplicate code in xlog_cil_insert_format_items
In reply to Christoph HellwigChristoph,
Quoted 22 lines · Christoph Hellwig
Share code that was previously duplicated in two branches.
Signed-off-by Christoph Hellwig <[email protected]>--- fs/xfs/xfs_log_cil.c | 33 +++++++++++++-------------------- 1 file changed, 13 insertions(+), 20 deletions(-)fs/xfs/xfs_log_cil.c +0
-7@@ -254,29 +254,22 @@ xlog_cil_insert_format_items(*/ *diff_iovecs -= lv->lv_niovecs; *diff_len -= lv->lv_buf_len; - -/* Ensure the lv is set up according to ->iop_size */ - lv->lv_niovecs = niovecs; - lv->lv_buf = (char *)lv + buf_size - nbytes; - - lv->lv_buf_len =xlog_cil_lv_item_format (lip, lv); - goto insert;
fs/xfs/xfs_log_cil.c xlog_cil_insert_format_items( · line 266
Quoted 10 lines
fs/xfs/xfs_log_cil.c +10
-0+ }else { +/* allocate new data chunk */ + lv =kmem_zalloc (buf_size,KM_SLEEP |KM_NOFS ); + lv->lv_item = lip; + lv->lv_size = buf_size; +if (ordered) { +/* track as an ordered logvec */ +ASSERT (lip->li_lv ==NULL ); + lv->lv_buf_len =XFS_LOG_VEC_ORDERED ; + goto insert;
It looks like lv->lv_niovecs is no longer being set in this case. Was that intentional?
Thanks,
Ben
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 01/10] xfs: remove duplicate code in xlog_cil_insert_format_items
Quoted 7 lines · Ben Myers
fs/xfs/xfs_log_cil.c xlog_cil_insert_format_items( · line 266
Quoted 5 lines
fs/xfs/xfs_log_cil.c +5
-0+if (ordered) { +/* track as an ordered logvec */ +ASSERT (lip->li_lv ==NULL ); + lv->lv_buf_len =XFS_LOG_VEC_ORDERED ; + goto insert;It looks like
lv->lv_niovecsis no longer being set in this case. Was that intentional?
Yes, ordered log vecs don't have iovecs attached, so the implicit zero from the kmem_zalloc is the right value.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 2/10 xfs: refactor xfs_buf_item_format_segment
In reply to Christoph HellwigAdd two helpers to make the code more readable.
--- fs/xfs/xfs_buf_item.c | 72 ++++++++++++++++++++++++++----------------------- 1 file changed, 39 insertions(+), 33 deletions(-)
fs/xfs/xfs_buf_item.c +39 -33
@@ -182,6 +182,34 @@ xfs_buf_item_size(trace_xfs_buf_item_size (bip); } +static inline struct xfs_log_iovec * +xfs_buf_item_copy_iovec ( +struct xfs_log_iovec *vecp, +struct xfs_buf *bp, +uint offset, +int first_bit, +uint nbits) +{ + offset += first_bit *XFS_BLF_CHUNK ; + + vecp->i_type =XLOG_REG_TYPE_BCHUNK ; + vecp->i_addr =xfs_buf_offset (bp, offset); + vecp->i_len = nbits *XFS_BLF_CHUNK ; +return vecp +1 ; +} + +static inline bool +xfs_buf_item_straddle ( +struct xfs_buf *bp, +uint offset, +int next_bit, +int last_bit) +{ +return xfs_buf_offset (bp, offset + (next_bit <<XFS_BLF_SHIFT )) != + (xfs_buf_offset (bp, offset + (last_bit <<XFS_BLF_SHIFT )) + +XFS_BLF_CHUNK ); +} +static struct xfs_log_iovec * xfs_buf_item_format_segment( struct xfs_buf_log_item *bip,
@@ -196,7 +224,6 @@ xfs_buf_item_format_segment(int last_bit;int next_bit;uint nbits; -uint buffer_offset;/* copy the flags across from the base format item */ blfp->blf_flags = bip->__bli_format.blf_flags;
@@ -239,7 +266,6 @@ xfs_buf_item_format_segment(/* * Fill in an iovec for each set of contiguous chunks. */ - last_bit = first_bit; nbits =1 ;for (;;) {
@@ -252,42 +278,22 @@ xfs_buf_item_format_segment( next_bit =xfs_next_bit (blfp->blf_data_map, blfp->blf_map_size, (uint )last_bit +1 );/* -* If we run out of bits fill in the last iovec and get -* out of the loop. -* Else if we start a new set of bits then fill in the -* iovec for the series we were looking at and start -* counting the bits in the new one. -* Else we're still in the same set of bits so just -* keep counting and scanning. +* If we run out of bits fill in the last iovec and get out of +* the loop. Else if we start a new set of bits then fill in +* the iovec for the series we were looking at and start +* counting the bits in the new one. Else we're still in the +* same set of bits so just keep counting and scanning. */ if (next_bit ==-1 ) { - buffer_offset = offset + first_bit *XFS_BLF_CHUNK ; - vecp->i_addr =xfs_buf_offset (bp, buffer_offset); - vecp->i_len = nbits *XFS_BLF_CHUNK ; - vecp->i_type =XLOG_REG_TYPE_BCHUNK ; +xfs_buf_item_copy_iovec (vecp, bp, offset, + first_bit, nbits); nvecs++;break ; - }else if (next_bit != last_bit +1 ) { - buffer_offset = offset + first_bit *XFS_BLF_CHUNK ; - vecp->i_addr =xfs_buf_offset (bp, buffer_offset); - vecp->i_len = nbits *XFS_BLF_CHUNK ; - vecp->i_type =XLOG_REG_TYPE_BCHUNK ; - nvecs++; - vecp++; - first_bit = next_bit; - last_bit = next_bit; - nbits =1 ; - }else if (xfs_buf_offset (bp, offset + - (next_bit <<XFS_BLF_SHIFT )) != - (xfs_buf_offset (bp, offset + - (last_bit <<XFS_BLF_SHIFT )) + -XFS_BLF_CHUNK )) { - buffer_offset = offset + first_bit *XFS_BLF_CHUNK ; - vecp->i_addr =xfs_buf_offset (bp, buffer_offset); - vecp->i_len = nbits *XFS_BLF_CHUNK ; - vecp->i_type =XLOG_REG_TYPE_BCHUNK ; + }else if (next_bit != last_bit +1 || +xfs_buf_item_straddle (bp, offset, next_bit, last_bit)) { + vecp =xfs_buf_item_copy_iovec (vecp, bp, offset, + first_bit, nbits); nvecs++; - vecp++; first_bit = next_bit; last_bit = next_bit; nbits =1 ;
Signature · 7 lines
1.7.10.4 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 02/10] xfs: refactor xfs_buf_item_format_segment
Quoted 3 lines · Christoph Hellwig
Add two helpers to make the code more readable.
Signed-off-by Christoph Hellwig <[email protected]>
Looks good. Much easier to understand split out like this, so thanks for doing that.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH 3/10 xfs: refactor xfs_inode_item_size
In reply to Christoph HellwigSplit out two helpers to size the data and attribute to make the function more readable.
--- fs/xfs/xfs_inode_item.c | 62 ++++++++++++++++++++++++++--------------------- 1 file changed, 35 insertions(+), 27 deletions(-)
fs/xfs/xfs_inode_item.c +35 -27
@@ -39,27 +39,14 @@ static inline struct xfs_inode_log_item *INODE_ITEM(struct xfs_log_item *lip) return container_of(lip, struct xfs_inode_log_item, ili_item); } - -/* -* This returns the number of iovecs needed to log the given inode item. -* -* We need one iovec for the inode log format structure, one for the -* inode core, and possibly one for the inode data/extents/b-tree root -* and one for the inode attribute data/extents/b-tree root. -*/ STATIC void -xfs_inode_item_size ( -struct xfs_log_item *lip, +xfs_inode_item_data_fork_size ( +struct xfs_inode_log_item *iip,int *nvecs,int *nbytes) { -struct xfs_inode_log_item *iip =INODE_ITEM (lip);struct xfs_inode *ip = iip->ili_inode; - *nvecs +=2 ; - *nbytes +=sizeof (struct xfs_inode_log_format ) + -xfs_icdinode_size (ip->i_d.di_version); -switch (ip->i_d.di_format) {case XFS_DINODE_FMT_EXTENTS : if ((iip->ili_fields & XFS_ILOG_DEXT) &&
@@ -70,7 +57,6 @@ xfs_inode_item_size( *nvecs +=1 ; }break ; -case XFS_DINODE_FMT_BTREE :if ((iip->ili_fields &XFS_ILOG_DBROOT ) && ip->i_df.if_broot_bytes >0 ) {
@@ -78,7 +64,6 @@ xfs_inode_item_size( *nvecs +=1 ; }break ; -case XFS_DINODE_FMT_LOCAL :if ((iip->ili_fields &XFS_ILOG_DDATA ) && ip->i_df.if_bytes >0 ) {
@@ -90,19 +75,20 @@ xfs_inode_item_size(case XFS_DINODE_FMT_DEV :case XFS_DINODE_FMT_UUID :break ; -default :ASSERT (0 );break ; } +} -if (!XFS_IFORK_Q (ip)) -return ; - +STATIC void +xfs_inode_item_attr_fork_size ( +struct xfs_inode_log_item *iip, +int *nvecs, +int *nbytes) +{ +struct xfs_inode *ip = iip->ili_inode; -/* -* Log any necessary attribute data. -*/ switch (ip->i_d.di_aformat) {case XFS_DINODE_FMT_EXTENTS : if ((iip->ili_fields & XFS_ILOG_AEXT) &&
@@ -113,7 +99,6 @@ xfs_inode_item_size( *nvecs +=1 ; }break ; -case XFS_DINODE_FMT_BTREE :if ((iip->ili_fields &XFS_ILOG_ABROOT ) && ip->i_afp->if_broot_bytes >0 ) {
@@ -121,7 +106,6 @@ xfs_inode_item_size( *nvecs +=1 ; }break ; -case XFS_DINODE_FMT_LOCAL :if ((iip->ili_fields &XFS_ILOG_ADATA ) && ip->i_afp->if_bytes >0 ) {
@@ -129,7 +113,6 @@ xfs_inode_item_size( *nvecs +=1 ; }break ; -default :ASSERT (0 );break ;
@@ -137,6 +120,31 @@ xfs_inode_item_size( }/* +* This returns the number of iovecs needed to log the given inode item. +* +* We need one iovec for the inode log format structure, one for the +* inode core, and possibly one for the inode data/extents/b-tree root +* and one for the inode attribute data/extents/b-tree root. +*/ +STATIC void +xfs_inode_item_size ( +struct xfs_log_item *lip, +int *nvecs, +int *nbytes) +{ +struct xfs_inode_log_item *iip =INODE_ITEM (lip); +struct xfs_inode *ip = iip->ili_inode; + + *nvecs +=2 ; + *nbytes +=sizeof (struct xfs_inode_log_format ) + +xfs_icdinode_size (ip->i_d.di_version); + +xfs_inode_item_data_fork_size (iip, nvecs, nbytes); +if (XFS_IFORK_Q (ip)) +xfs_inode_item_attr_fork_size (iip, nvecs, nbytes); +} + +/* * xfs_inode_item_format_extents - convert in-core extents to on-disk form * * For either the data or attr fork in extent format, we need to endian convert
Signature · 7 lines
1.7.10.4 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 03/10] xfs: refactor xfs_inode_item_size
Quoted 4 lines · Christoph Hellwig
Split out two helpers to size the data and attribute to make the function more readable.
Signed-off-by Christoph Hellwig <[email protected]>
Looks good.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH 4/10 xfs: refactor xfs_inode_item_format
In reply to Christoph HellwigSplit out a function to handle the data and attr fork, as well as a helper for the really old v1 inodes.
--- fs/xfs/xfs_inode_item.c | 165 +++++++++++++++++++++++++---------------------- 1 file changed, 89 insertions(+), 76 deletions(-)
fs/xfs/xfs_inode_item.c +89 -76
@@ -180,63 +180,41 @@ xfs_inode_item_format_extents( }/* -* This is called to fill in the vector of log iovecs for the -* given inode log item. It fills the first item with an inode -* log format structure, the second with the on-disk inode structure, -* and a possible third and/or fourth with the inode data/extents/b-tree -* root and inode attributes data/extents/b-tree root. +* If this is a v1 format inode, then we need to log it as such. This means +* that we have to copy the link count from the new field to the old. We +* don't have to worry about the new fields, because nothing trusts them as +* long as the old inode version number is there. */ STATIC void -xfs_inode_item_format ( -struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +xfs_inode_item_format_v1_inode ( +struct xfs_inode *ip) +{ +if (!xfs_sb_version_hasnlink (&ip->i_mount->m_sb)) { +/* +* Convert it back. +*/ +ASSERT (ip->i_d.di_nlink <=XFS_MAXLINK_1 ); + ip->i_d.di_onlink = ip->i_d.di_nlink; + }else { +/* +* The superblock version has already been bumped, +* so just make the conversion to the new inode +* format permanent. +*/ + 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)); + } +} + +STATIC struct xfs_log_iovec * +xfs_inode_item_format_data_fork ( +struct xfs_inode_log_item *iip, +struct xfs_log_iovec *vecp, +int *nvecs) { -struct xfs_inode_log_item *iip =INODE_ITEM (lip);struct xfs_inode *ip = iip->ili_inode; -uint nvecs;size_t data_bytes; -xfs_mount_t *mp; - - vecp->i_addr = &iip->ili_format; - vecp->i_len =sizeof (xfs_inode_log_format_t); - vecp->i_type =XLOG_REG_TYPE_IFORMAT ; - vecp++; - nvecs =1 ; - - vecp->i_addr = &ip->i_d; - vecp->i_len =xfs_icdinode_size (ip->i_d.di_version); - vecp->i_type =XLOG_REG_TYPE_ICORE ; - vecp++; - nvecs++; - -/* -* If this is really an old format inode, then we need to -* log it as such. This means that we have to copy the link -* count from the new field to the old. We don't have to worry -* about the new fields, because nothing trusts them as long as -* the old inode version number is there. If the superblock already -* has a new version number, then we don't bother converting back. -*/ - mp = ip->i_mount; -ASSERT (ip->i_d.di_version ==1 ||xfs_sb_version_hasnlink (&mp->m_sb)); -if (ip->i_d.di_version ==1 ) { -if (!xfs_sb_version_hasnlink (&mp->m_sb)) { -/* -* Convert it back. -*/ -ASSERT (ip->i_d.di_nlink <=XFS_MAXLINK_1 ); - ip->i_d.di_onlink = ip->i_d.di_nlink; - }else { -/* -* The superblock version has already been bumped, -* so just make the conversion to the new inode -* format permanent. -*/ - 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)); - } - }switch (ip->i_d.di_format) {case XFS_DINODE_FMT_EXTENTS :
@@ -271,12 +249,11 @@ xfs_inode_item_format(ASSERT (vecp->i_len <= ip->i_df.if_bytes); iip->ili_format.ilf_dsize = vecp->i_len; vecp++; - nvecs++; + (*nvecs)++; }else { iip->ili_fields &= ~XFS_ILOG_DEXT ; }break ; -case XFS_DINODE_FMT_BTREE : iip->ili_fields &= ~(XFS_ILOG_DDATA | XFS_ILOG_DEXT |
@@ -289,7 +266,7 @@ xfs_inode_item_format( vecp->i_len = ip->i_df.if_broot_bytes; vecp->i_type =XLOG_REG_TYPE_IBROOT ; vecp++; - nvecs++; + (*nvecs)++; iip->ili_format.ilf_dsize = ip->i_df.if_broot_bytes; }else { ASSERT(!(iip->ili_fields &
@@ -297,7 +274,6 @@ xfs_inode_item_format( iip->ili_fields &= ~XFS_ILOG_DBROOT ; }break ; -case XFS_DINODE_FMT_LOCAL : iip->ili_fields &= ~(XFS_ILOG_DEXT | XFS_ILOG_DBROOT |
@@ -319,13 +295,12 @@ xfs_inode_item_format( vecp->i_len = (int )data_bytes; vecp->i_type =XLOG_REG_TYPE_ILOCAL ; vecp++; - nvecs++; + (*nvecs)++; iip->ili_format.ilf_dsize = (unsigned )data_bytes; }else { iip->ili_fields &= ~XFS_ILOG_DDATA ; }break ; -case XFS_DINODE_FMT_DEV : iip->ili_fields &= ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT |
@@ -335,7 +310,6 @@ xfs_inode_item_format( ip->i_df.if_u2.if_rdev; }break ; -case XFS_DINODE_FMT_UUID : iip->ili_fields &= ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT |
@@ -345,20 +319,22 @@ xfs_inode_item_format( ip->i_df.if_u2.if_uuid; }break ; -default :ASSERT (0 );break ; } -/* -* If there are no attributes associated with the file, then we're done. -*/ -if (!XFS_IFORK_Q (ip)) { - iip->ili_fields &= - ~(XFS_ILOG_ADATA |XFS_ILOG_ABROOT |XFS_ILOG_AEXT ); - goto out; - } +return vecp; +} + +STATIC struct xfs_log_iovec * +xfs_inode_item_format_attr_fork ( +struct xfs_inode_log_item *iip, +struct xfs_log_iovec *vecp, +int *nvecs) +{ +struct xfs_inode *ip = iip->ili_inode; +size_t data_bytes;switch (ip->i_d.di_aformat) {case XFS_DINODE_FMT_EXTENTS :
@@ -386,12 +362,11 @@ xfs_inode_item_format(#endif iip->ili_format.ilf_asize = vecp->i_len; vecp++; - nvecs++; + (*nvecs)++; }else { iip->ili_fields &= ~XFS_ILOG_AEXT ; }break ; -case XFS_DINODE_FMT_BTREE : iip->ili_fields &= ~(XFS_ILOG_ADATA |XFS_ILOG_AEXT );
@@ -404,13 +379,12 @@ xfs_inode_item_format( vecp->i_len = ip->i_afp->if_broot_bytes; vecp->i_type =XLOG_REG_TYPE_IATTR_BROOT ; vecp++; - nvecs++; + (*nvecs)++; iip->ili_format.ilf_asize = ip->i_afp->if_broot_bytes; }else { iip->ili_fields &= ~XFS_ILOG_ABROOT ; }break ; -case XFS_DINODE_FMT_LOCAL : iip->ili_fields &= ~(XFS_ILOG_AEXT |XFS_ILOG_ABROOT );
@@ -431,19 +405,59 @@ xfs_inode_item_format( vecp->i_len = (int )data_bytes; vecp->i_type =XLOG_REG_TYPE_IATTR_LOCAL ; vecp++; - nvecs++; + (*nvecs)++; iip->ili_format.ilf_asize = (unsigned )data_bytes; }else { iip->ili_fields &= ~XFS_ILOG_ADATA ; }break ; -default :ASSERT (0 );break ; } -out: +return vecp; +} + +/* +* This is called to fill in the vector of log iovecs for the given inode +* log item. It fills the first item with an inode log format structure, +* the second with the on-disk inode structure, and a possible third and/or +* fourth with the inode data/extents/b-tree root and inode attributes +* data/extents/b-tree root. +*/ +STATIC void +xfs_inode_item_format ( +struct xfs_log_item *lip, +struct xfs_log_iovec *vecp) +{ +struct xfs_inode_log_item *iip =INODE_ITEM (lip); +struct xfs_inode *ip = iip->ili_inode; +uint nvecs; + + vecp->i_addr = &iip->ili_format; + vecp->i_len =sizeof (xfs_inode_log_format_t); + vecp->i_type =XLOG_REG_TYPE_IFORMAT ; + vecp++; + nvecs =1 ; + + vecp->i_addr = &ip->i_d; + vecp->i_len =xfs_icdinode_size (ip->i_d.di_version); + vecp->i_type =XLOG_REG_TYPE_ICORE ; + vecp++; + nvecs++; + +if (ip->i_d.di_version ==1 ) +xfs_inode_item_format_v1_inode (ip); + + vecp =xfs_inode_item_format_data_fork (iip, vecp, &nvecs); +if (XFS_IFORK_Q (ip)) { + vecp =xfs_inode_item_format_attr_fork (iip, vecp, &nvecs); + }else { + iip->ili_fields &= + ~(XFS_ILOG_ADATA |XFS_ILOG_ABROOT |XFS_ILOG_AEXT ); + } +/* * Now update the log format that goes out to disk from the in-core * values. We always write the inode core to make the arithmetic
@@ -455,7 +469,6 @@ out: iip->ili_format.ilf_size = nvecs; } -/* * This is called to pin the inode associated with the inode log * item in memory so it cannot be written out.
Signature · 7 lines
1.7.10.4 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 04/10] xfs: refactor xfs_inode_item_format
Quoted 4 lines · Christoph Hellwig
Split out a function to handle the data and attr fork, as well as a helper for the really old v1 inodes.
Signed-off-by Christoph Hellwig <[email protected]>
Much nicer!
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH 5/10 xfs: introduce xlog_copy_iovec
In reply to Christoph HellwigAdd a helper to abstract out filling the log iovecs in the log item format handlers. This will allow us to change the way we do the log item formatting more easily.
The copy in the name is a bit confusing for now as it just assigns a pointer and lets the CIL code perform the copy, but that will change soon.
--- fs/xfs/xfs_buf_item.c | 30 +++++------- fs/xfs/xfs_dquot_item.c | 25 +++++----- fs/xfs/xfs_extfree_item.c | 19 ++++---- fs/xfs/xfs_icreate_item.c | 9 ++-- fs/xfs/xfs_inode_item.c | 115 ++++++++++++++++++++------------------------- fs/xfs/xfs_log.h | 13 +++++ 6 files changed, 103 insertions(+), 108 deletions(-)
fs/xfs/xfs_buf_item.c +12 -18
@@ -182,20 +182,18 @@ xfs_buf_item_size(trace_xfs_buf_item_size (bip); } -static inline struct xfs_log_iovec * +static inline void xfs_buf_item_copy_iovec ( -struct xfs_log_iovec *vecp, +struct xfs_log_iovec **vecp,struct xfs_buf *bp,uint offset,int first_bit,uint nbits) { offset += first_bit *XFS_BLF_CHUNK ; - - vecp->i_type =XLOG_REG_TYPE_BCHUNK ; - vecp->i_addr =xfs_buf_offset (bp, offset); - vecp->i_len = nbits *XFS_BLF_CHUNK ; -return vecp +1 ; +xlog_copy_iovec (vecp,XLOG_REG_TYPE_BCHUNK , +xfs_buf_offset (bp, offset), + nbits *XFS_BLF_CHUNK ); } static inline bool
@@ -210,10 +208,10 @@ xfs_buf_item_straddle( XFS_BLF_CHUNK); } -static struct xfs_log_iovec * +static void xfs_buf_item_format_segment (struct xfs_buf_log_item *bip, -struct xfs_log_iovec *vecp, +struct xfs_log_iovec **vecp,uint offset,struct xfs_buf_log_format *blfp) {
@@ -245,10 +243,7 @@ xfs_buf_item_format_segment( goto out; } - vecp->i_addr = blfp; - vecp->i_len = base_size; - vecp->i_type =XLOG_REG_TYPE_BFORMAT ; - vecp++; +xlog_copy_iovec (vecp,XLOG_REG_TYPE_BFORMAT , blfp, base_size); nvecs =1 ;if (bip->bli_flags &XFS_BLI_STALE ) {
@@ -291,8 +286,8 @@ xfs_buf_item_format_segment(break ; }else if (next_bit != last_bit +1 ||xfs_buf_item_straddle (bp, offset, next_bit, last_bit)) { - vecp =xfs_buf_item_copy_iovec (vecp, bp, offset, - first_bit, nbits); +xfs_buf_item_copy_iovec (vecp, bp, offset, + first_bit, nbits); nvecs++; first_bit = next_bit; last_bit = next_bit;
@@ -304,7 +299,6 @@ xfs_buf_item_format_segment( } out: blfp->blf_size = nvecs; -return vecp; }/*
@@ -360,8 +354,8 @@ xfs_buf_item_format( }for (i =0 ; i < bip->bli_format_count; i++) { - vecp =xfs_buf_item_format_segment (bip, vecp, offset, - &bip->bli_formats[i]); +xfs_buf_item_format_segment (bip, &vecp, offset, + &bip->bli_formats[i]); offset += bp->b_maps[i].bm_len; }
fs/xfs/xfs_dquot_item.c +12 -13
@@ -57,20 +57,18 @@ xfs_qm_dquot_logitem_size( STATIC voidxfs_qm_dquot_logitem_format (struct xfs_log_item *lip, -struct xfs_log_iovec *logvec) +struct xfs_log_iovec *vecp) {struct xfs_dq_logitem *qlip =DQUOT_ITEM (lip); - logvec->i_addr = &qlip->qli_format; - logvec->i_len =sizeof (xfs_dq_logformat_t); - logvec->i_type =XLOG_REG_TYPE_QFORMAT ; - logvec++; - logvec->i_addr = &qlip->qli_dquot->q_core; - logvec->i_len =sizeof (xfs_disk_dquot_t); - logvec->i_type =XLOG_REG_TYPE_DQUOT ; +xlog_copy_iovec (&vecp,XLOG_REG_TYPE_QFORMAT , + &qlip->qli_format, +sizeof (struct xfs_dq_logformat )); +xlog_copy_iovec (&vecp,XLOG_REG_TYPE_DQUOT , + &qlip->qli_dquot->q_core, +sizeof (struct xfs_disk_dquot )); qlip->qli_format.qlf_size =2 ; - }/*
@@ -304,15 +302,16 @@ xfs_qm_qoff_logitem_size( STATIC voidxfs_qm_qoff_logitem_format (struct xfs_log_item *lip, -struct xfs_log_iovec *log_vector) +struct xfs_log_iovec *vecp) {struct xfs_qoff_logitem *qflip =QOFF_ITEM (lip);ASSERT (qflip->qql_format.qf_type ==XFS_LI_QUOTAOFF ); - log_vector->i_addr = &qflip->qql_format; - log_vector->i_len =sizeof (xfs_qoff_logitem_t); - log_vector->i_type =XLOG_REG_TYPE_QUOTAOFF ; +xlog_copy_iovec (&vecp,XLOG_REG_TYPE_QUOTAOFF , + &qflip->qql_format, +sizeof (struct xfs_qoff_logitem )); + qflip->qql_format.qf_size =1 ; }
fs/xfs/xfs_extfree_item.c +9 -10
@@ -26,6 +26,7 @@#include "xfs_trans_priv.h" #include "xfs_buf_item.h" #include "xfs_extfree_item.h" +#include "xfs_log.h" kmem_zone_t *xfs_efi_zone;
@@ -101,7 +102,7 @@ xfs_efi_item_size( STATIC voidxfs_efi_item_format (struct xfs_log_item *lip, -struct xfs_log_iovec *log_vector) +struct xfs_log_iovec *vecp) {struct xfs_efi_log_item *efip =EFI_ITEM (lip);
@@ -111,10 +112,9 @@ xfs_efi_item_format( efip->efi_format.efi_type =XFS_LI_EFI ; efip->efi_format.efi_size =1 ; - log_vector->i_addr = &efip->efi_format; - log_vector->i_len =xfs_efi_item_sizeof (efip); - log_vector->i_type =XLOG_REG_TYPE_EFI_FORMAT ; -ASSERT (log_vector->i_len >=sizeof (xfs_efi_log_format_t)); +xlog_copy_iovec (&vecp,XLOG_REG_TYPE_EFI_FORMAT , + &efip->efi_format, +xfs_efi_item_sizeof (efip)); }
@@ -368,7 +368,7 @@ xfs_efd_item_size( STATIC voidxfs_efd_item_format (struct xfs_log_item *lip, -struct xfs_log_iovec *log_vector) +struct xfs_log_iovec *vecp) {struct xfs_efd_log_item *efdp =EFD_ITEM (lip);
@@ -377,10 +377,9 @@ xfs_efd_item_format( efdp->efd_format.efd_type =XFS_LI_EFD ; efdp->efd_format.efd_size =1 ; - log_vector->i_addr = &efdp->efd_format; - log_vector->i_len =xfs_efd_item_sizeof (efdp); - log_vector->i_type =XLOG_REG_TYPE_EFD_FORMAT ; -ASSERT (log_vector->i_len >=sizeof (xfs_efd_log_format_t)); +xlog_copy_iovec (&vecp,XLOG_REG_TYPE_EFD_FORMAT , + &efdp->efd_format, +xfs_efd_item_sizeof (efdp)); }/*
fs/xfs/xfs_icreate_item.c +5 -4
@@ -28,6 +28,7 @@#include "xfs_trans_priv.h" #include "xfs_error.h" #include "xfs_icreate_item.h" +#include "xfs_log.h" kmem_zone_t *xfs_icreate_zone;/* inode create item zone */
@@ -58,13 +59,13 @@ xfs_icreate_item_size( STATIC voidxfs_icreate_item_format (struct xfs_log_item *lip, -struct xfs_log_iovec *log_vector) +struct xfs_log_iovec *vecp) {struct xfs_icreate_item *icp =ICR_ITEM (lip); - log_vector->i_addr = (xfs_caddr_t)&icp->ic_format; - log_vector->i_len =sizeof (struct xfs_icreate_log ); - log_vector->i_type =XLOG_REG_TYPE_ICREATE ; +xlog_copy_iovec (&vecp,XLOG_REG_TYPE_ICREATE , + &icp->ic_format, +sizeof (struct xfs_icreate_log )); }
fs/xfs/xfs_inode_item.c +52 -63
232 lines not on this page · raw message
fs/xfs/xfs_log.h +13 -0
@@ -30,6 +30,19 @@ struct xfs_log_vec {#define XFS_LOG_VEC_ORDERED (-1) +static inline void * +xlog_copy_iovec (struct xfs_log_iovec **vecp,uint type,void *data,int len) +{ +struct xfs_log_iovec *vec = *vecp; + + vec->i_type = type; + vec->i_addr = data; + vec->i_len = len; + + *vecp = vec +1 ; +return vec->i_addr; +} +/* * Structure used to pass callback function and the function's argument * to the log manager.
Signature · 7 lines
1.7.10.4 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 05/10] xfs: introduce xlog_copy_iovec
Quoted 9 lines · Christoph Hellwig
Add a helper to abstract out filling the log iovecs in the log item format handlers. This will allow us to change the way we do the log item formatting more easily.
The copy in the name is a bit confusing for now as it just assigns a pointer and lets the CIL code perform the copy, but that will change soon.
Signed-off-by Christoph Hellwig <[email protected]>
Looks good - I think the helper was worth the effort. ;)
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 05/10] xfs: introduce xlog_copy_iovec
Quoted 3 lines · Dave Chinner
Quoted 1 line
Signed-off-by Christoph Hellwig <[email protected]>Looks good - I think the helper was worth the effort. ;)
This one is very different from the version I had earlier. Took me a long rainy Saturday to arrive at this version..
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 6/10 xfs: format log items write directly into the linear CIL buffer
In reply to Christoph HellwigInstead of setting up pointers to memory locations in iop_format which then get copied into the CIL linear buffer after return move the copy into the individual inode items. This avoids the need to always have a memory block in the exact same layout that gets written into the log around, and allow the log items to be much more flexible in their in-memory layouts.
Note that all log item format routines now need to be careful to modify the copy of the item that was placed into the CIL after calls to xlog_copy_iovec instead of the in-memory copy.
--- fs/xfs/xfs_buf_item.c | 29 +++++++------- fs/xfs/xfs_dquot_item.c | 19 +++++----- fs/xfs/xfs_extfree_item.c | 10 +++-- fs/xfs/xfs_icreate_item.c | 5 ++- fs/xfs/xfs_inode_item.c | 92 ++++++++++++++++++++++----------------------- fs/xfs/xfs_log.h | 34 +++++++++++++++-- fs/xfs/xfs_log_cil.c | 34 +---------------- fs/xfs/xfs_trans.h | 2 +- 8 files changed, 111 insertions(+), 114 deletions(-)
fs/xfs/xfs_buf_item.c +14 -15
@@ -184,6 +184,7 @@ xfs_buf_item_size( static inline void xfs_buf_item_copy_iovec( + struct xfs_log_vec *lv, struct xfs_log_iovec **vecp, struct xfs_buf *bp, uint offset,
@@ -191,7 +192,7 @@ xfs_buf_item_copy_iovec( uint nbits) { offset += first_bit *XFS_BLF_CHUNK ; -xlog_copy_iovec (vecp,XLOG_REG_TYPE_BCHUNK , +xlog_copy_iovec (lv, vecp,XLOG_REG_TYPE_BCHUNK ,xfs_buf_offset (bp, offset), nbits *XFS_BLF_CHUNK ); }
@@ -211,13 +212,13 @@ xfs_buf_item_straddle(static void xfs_buf_item_format_segment (struct xfs_buf_log_item *bip, +struct xfs_log_vec *lv,struct xfs_log_iovec **vecp,uint offset,struct xfs_buf_log_format *blfp) {struct xfs_buf *bp = bip->bli_buf;uint base_size; -uint nvecs;int first_bit;int last_bit;int next_bit;
@@ -233,18 +234,17 @@ xfs_buf_item_format_segment(*/ base_size =xfs_buf_log_format_size (blfp); - nvecs =0 ; first_bit =xfs_next_bit (blfp->blf_data_map, blfp->blf_map_size,0 );if (!(bip->bli_flags &XFS_BLI_STALE ) && first_bit ==-1 ) {/* * If the map is not be dirty in the transaction, mark * the size as zero and do not advance the vector pointer. */ - goto out; +return ; } -xlog_copy_iovec (vecp,XLOG_REG_TYPE_BFORMAT , blfp, base_size); - nvecs =1 ; + blfp =xlog_copy_iovec (lv, vecp,XLOG_REG_TYPE_BFORMAT , blfp, base_size); + blfp->blf_size =1 ;if (bip->bli_flags &XFS_BLI_STALE ) {/*
@@ -254,7 +254,7 @@ xfs_buf_item_format_segment(*/ trace_xfs_buf_item_format_stale (bip);ASSERT (blfp->blf_flags &XFS_BLF_CANCEL ); - goto out; +return ; }
@@ -280,15 +280,15 @@ xfs_buf_item_format_segment(* same set of bits so just keep counting and scanning. */ if (next_bit ==-1 ) { -xfs_buf_item_copy_iovec (vecp, bp, offset, +xfs_buf_item_copy_iovec (lv, vecp, bp, offset, first_bit, nbits); - nvecs++; + blfp->blf_size++;break ; }else if (next_bit != last_bit +1 ||xfs_buf_item_straddle (bp, offset, next_bit, last_bit)) { -xfs_buf_item_copy_iovec (vecp, bp, offset, +xfs_buf_item_copy_iovec (lv, vecp, bp, offset, first_bit, nbits); - nvecs++; + blfp->blf_size++; first_bit = next_bit; last_bit = next_bit; nbits =1 ;
@@ -297,8 +297,6 @@ xfs_buf_item_format_segment( nbits++; } } -out: - blfp->blf_size = nvecs; }/*
@@ -310,10 +308,11 @@ out: STATIC voidxfs_buf_item_format (struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +struct xfs_log_vec *lv) {struct xfs_buf_log_item *bip =BUF_ITEM (lip);struct xfs_buf *bp = bip->bli_buf; +struct xfs_log_iovec *vecp =NULL ;uint offset =0 ;int i;
@@ -354,7 +353,7 @@ xfs_buf_item_format( }for (i =0 ; i < bip->bli_format_count; i++) { -xfs_buf_item_format_segment (bip, &vecp, offset, +xfs_buf_item_format_segment (bip, lv, &vecp, offset, &bip->bli_formats[i]); offset += bp->b_maps[i].bm_len; }
fs/xfs/xfs_dquot_item.c +10 -9
@@ -57,18 +57,19 @@ xfs_qm_dquot_logitem_size( STATIC voidxfs_qm_dquot_logitem_format (struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +struct xfs_log_vec *lv) {struct xfs_dq_logitem *qlip =DQUOT_ITEM (lip); +struct xfs_log_iovec *vecp =NULL ; -xlog_copy_iovec (&vecp,XLOG_REG_TYPE_QFORMAT , + qlip->qli_format.qlf_size =2 ; + +xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_QFORMAT , &qlip->qli_format,sizeof (struct xfs_dq_logformat )); -xlog_copy_iovec (&vecp,XLOG_REG_TYPE_DQUOT , +xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_DQUOT , &qlip->qli_dquot->q_core,sizeof (struct xfs_disk_dquot )); - - qlip->qli_format.qlf_size =2 ; }/*
@@ -302,17 +303,17 @@ xfs_qm_qoff_logitem_size( STATIC voidxfs_qm_qoff_logitem_format (struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +struct xfs_log_vec *lv) {struct xfs_qoff_logitem *qflip =QOFF_ITEM (lip); +struct xfs_log_iovec *vecp =NULL ;ASSERT (qflip->qql_format.qf_type ==XFS_LI_QUOTAOFF ); + qflip->qql_format.qf_size =1 ; -xlog_copy_iovec (&vecp,XLOG_REG_TYPE_QUOTAOFF , +xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_QUOTAOFF , &qflip->qql_format,sizeof (struct xfs_qoff_logitem )); - - qflip->qql_format.qf_size =1 ; }/*
fs/xfs/xfs_extfree_item.c +6 -4
@@ -102,9 +102,10 @@ xfs_efi_item_size( STATIC voidxfs_efi_item_format (struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +struct xfs_log_vec *lv) {struct xfs_efi_log_item *efip =EFI_ITEM (lip); +struct xfs_log_iovec *vecp =NULL ;ASSERT (atomic_read (&efip->efi_next_extent) == efip->efi_format.efi_nextents);
@@ -112,7 +113,7 @@ xfs_efi_item_format( efip->efi_format.efi_type =XFS_LI_EFI ; efip->efi_format.efi_size =1 ; -xlog_copy_iovec (&vecp,XLOG_REG_TYPE_EFI_FORMAT , +xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_EFI_FORMAT , &efip->efi_format,xfs_efi_item_sizeof (efip)); }
@@ -368,16 +369,17 @@ xfs_efd_item_size( STATIC voidxfs_efd_item_format (struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +struct xfs_log_vec *lv) {struct xfs_efd_log_item *efdp =EFD_ITEM (lip); +struct xfs_log_iovec *vecp =NULL ;ASSERT (efdp->efd_next_extent == efdp->efd_format.efd_nextents); efdp->efd_format.efd_type =XFS_LI_EFD ; efdp->efd_format.efd_size =1 ; -xlog_copy_iovec (&vecp,XLOG_REG_TYPE_EFD_FORMAT , +xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_EFD_FORMAT , &efdp->efd_format,xfs_efd_item_sizeof (efdp)); }
fs/xfs/xfs_icreate_item.c +3 -2
@@ -59,11 +59,12 @@ xfs_icreate_item_size( STATIC voidxfs_icreate_item_format (struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +struct xfs_log_vec *lv) {struct xfs_icreate_item *icp =ICR_ITEM (lip); +struct xfs_log_iovec *vecp =NULL ; -xlog_copy_iovec (&vecp,XLOG_REG_TYPE_ICREATE , +xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_ICREATE , &icp->ic_format,sizeof (struct xfs_icreate_log )); }
fs/xfs/xfs_inode_item.c +45 -47
207 lines not on this page · raw message
fs/xfs/xfs_log.h +30 -4
@@ -31,18 +31,44 @@ struct xfs_log_vec {#define XFS_LOG_VEC_ORDERED (-1)static inline void * -xlog_copy_iovec (struct xfs_log_iovec **vecp,uint type,void *data,int len) +xlog_prepare_iovec (struct xfs_log_vec *lv,struct xfs_log_iovec **vecp, +uint type) {struct xfs_log_iovec *vec = *vecp; +if (vec) { +ASSERT (vec - lv->lv_iovecp < lv->lv_niovecs); + vec++; + }else { + vec = &lv->lv_iovecp[0 ]; + } + vec->i_type = type; - vec->i_addr = data; - vec->i_len = len; + vec->i_addr = lv->lv_buf + lv->lv_buf_len; - *vecp = vec +1 ; + *vecp = vec;return vec->i_addr; } +static inline void +xlog_finish_iovec (struct xfs_log_vec *lv,struct xfs_log_iovec *vec,int len) +{ + lv->lv_buf_len += len; + vec->i_len = len; +} + +static inline void * +xlog_copy_iovec (struct xfs_log_vec *lv,struct xfs_log_iovec **vecp, +uint type,void *data,int len) +{ +void *buf; + + buf =xlog_prepare_iovec (lv, vecp, type); +memcpy (buf, data, len); +xlog_finish_iovec (lv, *vecp, len); +return buf; +} +/* * Structure used to pass callback function and the function's argument * to the log manager.
fs/xfs/xfs_log_cil.c +2 -32
@@ -82,36 +82,6 @@ xlog_cil_init_post_recovery( log->l_curr_block); } -STATIC int -xlog_cil_lv_item_format ( -struct xfs_log_item *lip, -struct xfs_log_vec *lv) -{ -int index; -char *ptr; - -/* format new vectors into array */ - lip->li_ops->iop_format (lip, lv->lv_iovecp); - -/* copy data into existing array */ - ptr = lv->lv_buf; -for (index =0 ; index < lv->lv_niovecs; index++) { -struct xfs_log_iovec *vec = &lv->lv_iovecp[index]; - -memcpy (ptr, vec->i_addr, vec->i_len); - vec->i_addr = ptr; - ptr += vec->i_len; - } - -/* -* some size calculations for log vectors over-estimate, so the caller -* doesn't know the amount of space actually used by the item. Return -* the byte count to the caller so they can check and store it -* appropriately. -*/ -return ptr - lv->lv_buf; -} -/* * Prepare the log item for insertion into the CIL. Calculate the difference in * log space and vectors it will consume, and if it is a new item pin it as
@@ -272,9 +242,9 @@ xlog_cil_insert_format_items( lv->lv_niovecs = niovecs;/* The allocated data region lies beyond the iovec region */ + lv->lv_buf_len =0 ; lv->lv_buf = (char *)lv + buf_size - nbytes; - - lv->lv_buf_len =xlog_cil_lv_item_format (lip, lv); + lip->li_ops->iop_format (lip, lv); insert:ASSERT (lv->lv_buf_len <= nbytes);xfs_cil_prepare_item (log, lv, old_lv, diff_len, diff_iovecs);
fs/xfs/xfs_trans.h +1 -1
@@ -64,7 +64,7 @@ typedef struct xfs_log_item {struct xfs_item_ops {void (*iop_size)(xfs_log_item_t *,int *,int *); -void (*iop_format)(xfs_log_item_t *,struct xfs_log_iovec *); +void (*iop_format)(xfs_log_item_t *,struct xfs_log_vec *);void (*iop_pin)(xfs_log_item_t *);void (*iop_unpin)(xfs_log_item_t *,int remove);uint (*iop_push)(struct xfs_log_item *,struct list_head *);
Signature · 7 lines
1.7.10.4 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 06/10] xfs: format log items write directly into the linear CIL buffer
Quoted 19 lines · Christoph Hellwig
Instead of setting up pointers to memory locations in
iop_formatwhich then get copied into the CIL linear buffer after return move the copy into the individual inode items. This avoids the need to always have a memory block in the exact same layout that gets written into the log around, and allow the log items to be much more flexible in their in-memory layouts.Note that all log item format routines now need to be careful to modify the copy of the item that was placed into the CIL after calls to
xlog_copy_iovecinstead of the in-memory copy.Signed-off-by Christoph Hellwig <[email protected]>fs/xfs/xfs_buf_item.c +0
-1*/ base_size =xfs_buf_log_format_size (blfp); - nvecs =0 ; first_bit =xfs_next_bit (blfp->blf_data_map, blfp->blf_map_size,0 );if (!(bip->bli_flags &XFS_BLI_STALE ) && first_bit ==-1 ) {/* * If the map is not be dirty in the transaction, mark
fs/xfs/xfs_buf_item.c xfs_buf_item_format_segment( · line 247
Quoted 10 lines
fs/xfs/xfs_buf_item.c +3
-3* the size as zero and do not advance the vector pointer. */ - goto out; +return ; } -xlog_copy_iovec (vecp,XLOG_REG_TYPE_BFORMAT , blfp, base_size); - nvecs =1 ; + blfp =xlog_copy_iovec (lv, vecp,XLOG_REG_TYPE_BFORMAT , blfp, base_size); + blfp->blf_size =1 ;
Hmmmm. What guarantee do we have blf_size is now natuarally aligned? We've returned a pointer that could have any offset into the logvec buffer, and so some platforms are going to have problems if blfp is at an address that is not a multiple of 4 or 8, right?
Quoted 11 lines
xfs_inode_item_format_data_fork(
fs/xfs/xfs_inode_item.c +3
-2struct xfs_inode_log_item *iip, - struct xfs_log_iovec **vecp, - int *nvecs) + struct xfs_inode_log_format *ilf, + struct xfs_log_vec *lv, + struct xfs_log_iovec **vecp) { struct xfs_inode *ip = iip->ili_inode;size_t data_bytes;
fs/xfs/xfs_inode_item.c xfs_inode_item_format_data_fork( · line 247
Quoted 9 lines
fs/xfs/xfs_inode_item.c +2
-2@@ -239,19 +241,19 @@ xfs_inode_item_format_data_fork(* extents, so just point to the * real extents array. */ -xlog_copy_iovec (vecp,XLOG_REG_TYPE_IEXT , +xlog_copy_iovec (lv, vecp,XLOG_REG_TYPE_IEXT , ip->i_df.if_u1.if_extents, ip->i_df.if_bytes); - iip->ili_format.ilf_dsize = ip->i_df.if_bytes; + ilf->ilf_dsize = ip->i_df.if_bytes;
And by the looks of it, we could have the same problems here?
Quoted 15 lines
fs/xfs/xfs_log.h +3
-1@@ -31,18 +31,44 @@ struct xfs_log_vec {#define XFS_LOG_VEC_ORDERED (-1)static inline void * -xlog_copy_iovec (struct xfs_log_iovec **vecp,uint type,void *data,int len) +xlog_prepare_iovec (struct xfs_log_vec *lv,struct xfs_log_iovec **vecp, +uint type) {struct xfs_log_iovec *vec = *vecp; +if (vec) {
fs/xfs/xfs_log.h struct xfs_log_vec { · line 47
Quoted 10 lines
fs/xfs/xfs_log.h +7
-2+ASSERT (vec - lv->lv_iovecp < lv->lv_niovecs); + vec++; + }else { + vec = &lv->lv_iovecp[0 ]; + } + vec->i_type = type; - vec->i_addr = data; - vec->i_len = len; + vec->i_addr = lv->lv_buf + lv->lv_buf_len;
We could at least check here that the alignment is good...
fs/xfs/xfs_log.h struct xfs_log_vec { · line 56
Quoted 10 lines
fs/xfs/xfs_log.h +5
-1- *vecp = vec +1 ; + *vecp = vec;return vec->i_addr; } +static inline void +xlog_finish_iovec (struct xfs_log_vec *lv,struct xfs_log_iovec *vec,int len) +{ + lv->lv_buf_len += len;
And if we need to guarantee alignment, then maybe roundup here to ensure we don't end up with bad offsets? That would require padding the allocation of the buffer to take it into account, too....
Other than this concern, the code looks fine.
Cheers,
Dave.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 06/10] xfs: format log items write directly into the linear CIL buffer
Quoted 102 lines · Dave Chinner
Quoted 19 lines · Christoph Hellwig
Instead of setting up pointers to memory locations in
iop_formatwhich then get copied into the CIL linear buffer after return move the copy into the individual inode items. This avoids the need to always have a memory block in the exact same layout that gets written into the log around, and allow the log items to be much more flexible in their in-memory layouts.Note that all log item format routines now need to be careful to modify the copy of the item that was placed into the CIL after calls to
xlog_copy_iovecinstead of the in-memory copy.Signed-off-by Christoph Hellwig <[email protected]>fs/xfs/xfs_buf_item.c +0
-1*/ base_size =xfs_buf_log_format_size (blfp); - nvecs =0 ; first_bit =xfs_next_bit (blfp->blf_data_map, blfp->blf_map_size,0 );if (!(bip->bli_flags &XFS_BLI_STALE ) && first_bit ==-1 ) {/* * If the map is not be dirty in the transaction, mark fs/xfs/xfs_buf_item.c xfs_buf_item_format_segment( · line 247
Quoted 10 lines
fs/xfs/xfs_buf_item.c +3
-3* the size as zero and do not advance the vector pointer. */ - goto out; +return ; } -xlog_copy_iovec (vecp,XLOG_REG_TYPE_BFORMAT , blfp, base_size); - nvecs =1 ; + blfp =xlog_copy_iovec (lv, vecp,XLOG_REG_TYPE_BFORMAT , blfp, base_size); + blfp->blf_size =1 ;Hmmmm. What guarantee do we have
blf_sizeis now natuarally aligned? We've returned a pointer that could have any offset into the logvec buffer, and so some platforms are going to have problems if blfp is at an address that is not a multiple of 4 or 8, right?Quoted 11 lines
xfs_inode_item_format_data_fork(
fs/xfs/xfs_inode_item.c +3
-2struct xfs_inode_log_item *iip, - struct xfs_log_iovec **vecp, - int *nvecs) + struct xfs_inode_log_format *ilf, + struct xfs_log_vec *lv, + struct xfs_log_iovec **vecp) { struct xfs_inode *ip = iip->ili_inode;size_t data_bytes;fs/xfs/xfs_inode_item.c xfs_inode_item_format_data_fork( · line 247
Quoted 9 lines
fs/xfs/xfs_inode_item.c +2
-2@@ -239,19 +241,19 @@ xfs_inode_item_format_data_fork(* extents, so just point to the * real extents array. */ -xlog_copy_iovec (vecp,XLOG_REG_TYPE_IEXT , +xlog_copy_iovec (lv, vecp,XLOG_REG_TYPE_IEXT , ip->i_df.if_u1.if_extents, ip->i_df.if_bytes); - iip->ili_format.ilf_dsize = ip->i_df.if_bytes; + ilf->ilf_dsize = ip->i_df.if_bytes;And by the looks of it, we could have the same problems here?
Quoted 15 lines
fs/xfs/xfs_log.h +3
-1@@ -31,18 +31,44 @@ struct xfs_log_vec {#define XFS_LOG_VEC_ORDERED (-1)static inline void * -xlog_copy_iovec (struct xfs_log_iovec **vecp,uint type,void *data,int len) +xlog_prepare_iovec (struct xfs_log_vec *lv,struct xfs_log_iovec **vecp, +uint type) {struct xfs_log_iovec *vec = *vecp; +if (vec) {fs/xfs/xfs_log.h struct xfs_log_vec { · line 47
Quoted 10 lines
fs/xfs/xfs_log.h +7
-2+ASSERT (vec - lv->lv_iovecp < lv->lv_niovecs); + vec++; + }else { + vec = &lv->lv_iovecp[0 ]; + } + vec->i_type = type; - vec->i_addr = data; - vec->i_len = len; + vec->i_addr = lv->lv_buf + lv->lv_buf_len;We could at least check here that the alignment is good...
fs/xfs/xfs_log.h struct xfs_log_vec { · line 56
Quoted 10 lines
fs/xfs/xfs_log.h +5
-1- *vecp = vec +1 ; + *vecp = vec;return vec->i_addr; } +static inline void +xlog_finish_iovec (struct xfs_log_vec *lv,struct xfs_log_iovec *vec,int len) +{ + lv->lv_buf_len += len;And if we need to guarantee alignment, then maybe roundup here to ensure we don't end up with bad offsets? That would require padding the allocation of the buffer to take it into account, too....
Quoted 1 line
Other than this concern, the code looks fine.
Christoph, what about this alignment issue?
Thanks,
Ben
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 06/10] xfs: format log items write directly into the linear CIL buffer
Quoted 7 lines · Ben Myers
Quoted 5 lines
And if we need to guarantee alignment, then maybe roundup here to ensure we don't end up with bad offsets? That would require padding the allocation of the buffer to take it into account, too....
Other than this concern, the code looks fine.
Christoph, what about this alignment issue?
I think Dave is right, but I haven't had time to look at the issue in detail and respin the patchset yet.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH v2 6/10 xfs: format log items write directly into the linear CIL buffer
In reply to Christoph HellwigInstead of setting up pointers to memory locations in iop_format which then get copied into the CIL linear buffer after return move the copy into the individual inode items. This avoids the need to always have a memory block in the exact same layout that gets written into the log around, and allow the log items to be much more flexible in their in-memory layouts.
The only caveat is that we need to properly align the data for each iovec so that don't have structures misaligned in subsequent iovecs.
Note that all log item format routines now need to be careful to modify the copy of the item that was placed into the CIL after calls to xlog_copy_iovec instead of the in-memory copy.
--- fs/xfs/xfs_buf_item.c | 29 +++++++------- fs/xfs/xfs_dquot_item.c | 19 +++++----- fs/xfs/xfs_extfree_item.c | 10 +++-- fs/xfs/xfs_icreate_item.c | 5 ++- fs/xfs/xfs_inode_item.c | 92 ++++++++++++++++++++++----------------------- fs/xfs/xfs_log.h | 39 +++++++++++++++++-- fs/xfs/xfs_log_cil.c | 41 +++++--------------- fs/xfs/xfs_trans.h | 2 +- 8 files changed, 123 insertions(+), 114 deletions(-)
fs/xfs/xfs_buf_item.c +14 -15
@@ -184,6 +184,7 @@ xfs_buf_item_size( static inline void xfs_buf_item_copy_iovec( + struct xfs_log_vec *lv, struct xfs_log_iovec **vecp, struct xfs_buf *bp, uint offset,
@@ -191,7 +192,7 @@ xfs_buf_item_copy_iovec( uint nbits) { offset += first_bit *XFS_BLF_CHUNK ; -xlog_copy_iovec (vecp,XLOG_REG_TYPE_BCHUNK , +xlog_copy_iovec (lv, vecp,XLOG_REG_TYPE_BCHUNK ,xfs_buf_offset (bp, offset), nbits *XFS_BLF_CHUNK ); }
@@ -211,13 +212,13 @@ xfs_buf_item_straddle(static void xfs_buf_item_format_segment (struct xfs_buf_log_item *bip, +struct xfs_log_vec *lv,struct xfs_log_iovec **vecp,uint offset,struct xfs_buf_log_format *blfp) {struct xfs_buf *bp = bip->bli_buf;uint base_size; -uint nvecs;int first_bit;int last_bit;int next_bit;
@@ -233,18 +234,17 @@ xfs_buf_item_format_segment(*/ base_size =xfs_buf_log_format_size (blfp); - nvecs =0 ; first_bit =xfs_next_bit (blfp->blf_data_map, blfp->blf_map_size,0 );if (!(bip->bli_flags &XFS_BLI_STALE ) && first_bit ==-1 ) {/* * If the map is not be dirty in the transaction, mark * the size as zero and do not advance the vector pointer. */ - goto out; +return ; } -xlog_copy_iovec (vecp,XLOG_REG_TYPE_BFORMAT , blfp, base_size); - nvecs =1 ; + blfp =xlog_copy_iovec (lv, vecp,XLOG_REG_TYPE_BFORMAT , blfp, base_size); + blfp->blf_size =1 ;if (bip->bli_flags &XFS_BLI_STALE ) {/*
@@ -254,7 +254,7 @@ xfs_buf_item_format_segment(*/ trace_xfs_buf_item_format_stale (bip);ASSERT (blfp->blf_flags &XFS_BLF_CANCEL ); - goto out; +return ; }
@@ -280,15 +280,15 @@ xfs_buf_item_format_segment(* same set of bits so just keep counting and scanning. */ if (next_bit ==-1 ) { -xfs_buf_item_copy_iovec (vecp, bp, offset, +xfs_buf_item_copy_iovec (lv, vecp, bp, offset, first_bit, nbits); - nvecs++; + blfp->blf_size++;break ; }else if (next_bit != last_bit +1 ||xfs_buf_item_straddle (bp, offset, next_bit, last_bit)) { -xfs_buf_item_copy_iovec (vecp, bp, offset, +xfs_buf_item_copy_iovec (lv, vecp, bp, offset, first_bit, nbits); - nvecs++; + blfp->blf_size++; first_bit = next_bit; last_bit = next_bit; nbits =1 ;
@@ -297,8 +297,6 @@ xfs_buf_item_format_segment( nbits++; } } -out: - blfp->blf_size = nvecs; }/*
@@ -310,10 +308,11 @@ out: STATIC voidxfs_buf_item_format (struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +struct xfs_log_vec *lv) {struct xfs_buf_log_item *bip =BUF_ITEM (lip);struct xfs_buf *bp = bip->bli_buf; +struct xfs_log_iovec *vecp =NULL ;uint offset =0 ;int i;
@@ -354,7 +353,7 @@ xfs_buf_item_format( }for (i =0 ; i < bip->bli_format_count; i++) { -xfs_buf_item_format_segment (bip, &vecp, offset, +xfs_buf_item_format_segment (bip, lv, &vecp, offset, &bip->bli_formats[i]); offset += bp->b_maps[i].bm_len; }
fs/xfs/xfs_dquot_item.c +10 -9
@@ -57,18 +57,19 @@ xfs_qm_dquot_logitem_size( STATIC voidxfs_qm_dquot_logitem_format (struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +struct xfs_log_vec *lv) {struct xfs_dq_logitem *qlip =DQUOT_ITEM (lip); +struct xfs_log_iovec *vecp =NULL ; -xlog_copy_iovec (&vecp,XLOG_REG_TYPE_QFORMAT , + qlip->qli_format.qlf_size =2 ; + +xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_QFORMAT , &qlip->qli_format,sizeof (struct xfs_dq_logformat )); -xlog_copy_iovec (&vecp,XLOG_REG_TYPE_DQUOT , +xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_DQUOT , &qlip->qli_dquot->q_core,sizeof (struct xfs_disk_dquot )); - - qlip->qli_format.qlf_size =2 ; }/*
@@ -302,17 +303,17 @@ xfs_qm_qoff_logitem_size( STATIC voidxfs_qm_qoff_logitem_format (struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +struct xfs_log_vec *lv) {struct xfs_qoff_logitem *qflip =QOFF_ITEM (lip); +struct xfs_log_iovec *vecp =NULL ;ASSERT (qflip->qql_format.qf_type ==XFS_LI_QUOTAOFF ); + qflip->qql_format.qf_size =1 ; -xlog_copy_iovec (&vecp,XLOG_REG_TYPE_QUOTAOFF , +xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_QUOTAOFF , &qflip->qql_format,sizeof (struct xfs_qoff_logitem )); - - qflip->qql_format.qf_size =1 ; }/*
fs/xfs/xfs_extfree_item.c +6 -4
@@ -102,9 +102,10 @@ xfs_efi_item_size( STATIC voidxfs_efi_item_format (struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +struct xfs_log_vec *lv) {struct xfs_efi_log_item *efip =EFI_ITEM (lip); +struct xfs_log_iovec *vecp =NULL ;ASSERT (atomic_read (&efip->efi_next_extent) == efip->efi_format.efi_nextents);
@@ -112,7 +113,7 @@ xfs_efi_item_format( efip->efi_format.efi_type =XFS_LI_EFI ; efip->efi_format.efi_size =1 ; -xlog_copy_iovec (&vecp,XLOG_REG_TYPE_EFI_FORMAT , +xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_EFI_FORMAT , &efip->efi_format,xfs_efi_item_sizeof (efip)); }
@@ -368,16 +369,17 @@ xfs_efd_item_size( STATIC voidxfs_efd_item_format (struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +struct xfs_log_vec *lv) {struct xfs_efd_log_item *efdp =EFD_ITEM (lip); +struct xfs_log_iovec *vecp =NULL ;ASSERT (efdp->efd_next_extent == efdp->efd_format.efd_nextents); efdp->efd_format.efd_type =XFS_LI_EFD ; efdp->efd_format.efd_size =1 ; -xlog_copy_iovec (&vecp,XLOG_REG_TYPE_EFD_FORMAT , +xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_EFD_FORMAT , &efdp->efd_format,xfs_efd_item_sizeof (efdp)); }
fs/xfs/xfs_icreate_item.c +3 -2
@@ -59,11 +59,12 @@ xfs_icreate_item_size( STATIC voidxfs_icreate_item_format (struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +struct xfs_log_vec *lv) {struct xfs_icreate_item *icp =ICR_ITEM (lip); +struct xfs_log_iovec *vecp =NULL ; -xlog_copy_iovec (&vecp,XLOG_REG_TYPE_ICREATE , +xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_ICREATE , &icp->ic_format,sizeof (struct xfs_icreate_log )); }
fs/xfs/xfs_inode_item.c +45 -47
207 lines not on this page · raw message
fs/xfs/xfs_log.h +35 -4
@@ -31,18 +31,49 @@ struct xfs_log_vec {#define XFS_LOG_VEC_ORDERED (-1)static inline void * -xlog_copy_iovec (struct xfs_log_iovec **vecp,uint type,void *data,int len) +xlog_prepare_iovec (struct xfs_log_vec *lv,struct xfs_log_iovec **vecp, +uint type) {struct xfs_log_iovec *vec = *vecp; +if (vec) { +ASSERT (vec - lv->lv_iovecp < lv->lv_niovecs); + vec++; + }else { + vec = &lv->lv_iovecp[0 ]; + } + vec->i_type = type; - vec->i_addr = data; - vec->i_len = len; + vec->i_addr = lv->lv_buf + lv->lv_buf_len; - *vecp = vec +1 ; + *vecp = vec;return vec->i_addr; } +static inline void +xlog_finish_iovec (struct xfs_log_vec *lv,struct xfs_log_iovec *vec,int len) +{ +/* +* We need to make sure the next buffer is naturally aligned for the +* biggest basic data type we put into it. We already accounted for +* this when sizing the buffer. +*/ + lv->lv_buf_len +=round_up (len,sizeof (uint64_t )); + vec->i_len = len; +} + +static inline void * +xlog_copy_iovec (struct xfs_log_vec *lv,struct xfs_log_iovec **vecp, +uint type,void *data,int len) +{ +void *buf; + + buf =xlog_prepare_iovec (lv, vecp, type); +memcpy (buf, data, len); +xlog_finish_iovec (lv, *vecp, len); +return buf; +} +/* * Structure used to pass callback function and the function's argument * to the log manager.
fs/xfs/xfs_log_cil.c +9 -32
60 lines not on this page · raw message
fs/xfs/xfs_trans.h +1 -1
@@ -64,7 +64,7 @@ typedef struct xfs_log_item {struct xfs_item_ops {void (*iop_size)(xfs_log_item_t *,int *,int *); -void (*iop_format)(xfs_log_item_t *,struct xfs_log_iovec *); +void (*iop_format)(xfs_log_item_t *,struct xfs_log_vec *);void (*iop_pin)(xfs_log_item_t *);void (*iop_unpin)(xfs_log_item_t *,int remove);uint (*iop_push)(struct xfs_log_item *,struct list_head *);
Signature · 6 lines
1.7.10.4 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 06/10 v2] xfs: format log items write directly into the linear CIL buffer
Quoted 8 lines · Christoph Hellwig
Instead of setting up pointers to memory locations in
iop_formatwhich then get copied into the CIL linear buffer after return move the copy into the individual inode items. This avoids the need to always have a memory block in the exact same layout that gets written into the log around, and allow the log items to be much more flexible in their in-memory layouts.The only caveat is that we need to properly align the data for each iovec so that don't have structures misaligned in subsequent iovecs.
.....
Quoted 19 lines
fs/xfs/xfs_log.h +7
-1@@ -31,18 +31,49 @@ struct xfs_log_vec {#define XFS_LOG_VEC_ORDERED (-1)static inline void * -xlog_copy_iovec (struct xfs_log_iovec **vecp,uint type,void *data,int len) +xlog_prepare_iovec (struct xfs_log_vec *lv,struct xfs_log_iovec **vecp, +uint type) {struct xfs_log_iovec *vec = *vecp; +if (vec) { +ASSERT (vec - lv->lv_iovecp < lv->lv_niovecs); + vec++; + }else { + vec = &lv->lv_iovecp[0 ];
fs/xfs/xfs_log.h struct xfs_log_vec { · line 50
Quoted 10 lines
fs/xfs/xfs_log.h +4
-3+ } + vec->i_type = type; - vec->i_addr = data; - vec->i_len = len; + vec->i_addr = lv->lv_buf + lv->lv_buf_len; - *vecp = vec +1 ; + *vecp = vec;return vec->i_addr;
Can you add an assert here like this:
ASSERT(IS_ALIGNED(vec->i_addr, sizeof(uint64_t));
So we catch any situation where the alignment ends up wrong?
Otherwise, it looks good, so consider it:
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH v3 6/10 xfs: format log items write directly into the linear CIL buffer
In reply to Christoph HellwigInstead of setting up pointers to memory locations in iop_format which then get copied into the CIL linear buffer after return move the copy into the individual inode items. This avoids the need to always have a memory block in the exact same layout that gets written into the log around, and allow the log items to be much more flexible in their in-memory layouts.
The only caveat is that we need to properly align the data for each iovec so that don't have structures misaligned in subsequent iovecs.
Note that all log item format routines now need to be careful to modify the copy of the item that was placed into the CIL after calls to xlog_copy_iovec instead of the in-memory copy.
--- fs/xfs/xfs_buf_item.c | 29 +++++++------- fs/xfs/xfs_dquot_item.c | 19 +++++----- fs/xfs/xfs_extfree_item.c | 10 +++-- fs/xfs/xfs_icreate_item.c | 5 ++- fs/xfs/xfs_inode_item.c | 92 ++++++++++++++++++++++----------------------- fs/xfs/xfs_log.h | 41 ++++++++++++++++++-- fs/xfs/xfs_log_cil.c | 41 +++++--------------- fs/xfs/xfs_trans.h | 2 +- 8 files changed, 125 insertions(+), 114 deletions(-)
fs/xfs/xfs_buf_item.c +14 -15
@@ -184,6 +184,7 @@ xfs_buf_item_size( static inline void xfs_buf_item_copy_iovec( + struct xfs_log_vec *lv, struct xfs_log_iovec **vecp, struct xfs_buf *bp, uint offset,
@@ -191,7 +192,7 @@ xfs_buf_item_copy_iovec( uint nbits) { offset += first_bit *XFS_BLF_CHUNK ; -xlog_copy_iovec (vecp,XLOG_REG_TYPE_BCHUNK , +xlog_copy_iovec (lv, vecp,XLOG_REG_TYPE_BCHUNK ,xfs_buf_offset (bp, offset), nbits *XFS_BLF_CHUNK ); }
@@ -211,13 +212,13 @@ xfs_buf_item_straddle(static void xfs_buf_item_format_segment (struct xfs_buf_log_item *bip, +struct xfs_log_vec *lv,struct xfs_log_iovec **vecp,uint offset,struct xfs_buf_log_format *blfp) {struct xfs_buf *bp = bip->bli_buf;uint base_size; -uint nvecs;int first_bit;int last_bit;int next_bit;
@@ -233,18 +234,17 @@ xfs_buf_item_format_segment(*/ base_size =xfs_buf_log_format_size (blfp); - nvecs =0 ; first_bit =xfs_next_bit (blfp->blf_data_map, blfp->blf_map_size,0 );if (!(bip->bli_flags &XFS_BLI_STALE ) && first_bit ==-1 ) {/* * If the map is not be dirty in the transaction, mark * the size as zero and do not advance the vector pointer. */ - goto out; +return ; } -xlog_copy_iovec (vecp,XLOG_REG_TYPE_BFORMAT , blfp, base_size); - nvecs =1 ; + blfp =xlog_copy_iovec (lv, vecp,XLOG_REG_TYPE_BFORMAT , blfp, base_size); + blfp->blf_size =1 ;if (bip->bli_flags &XFS_BLI_STALE ) {/*
@@ -254,7 +254,7 @@ xfs_buf_item_format_segment(*/ trace_xfs_buf_item_format_stale (bip);ASSERT (blfp->blf_flags &XFS_BLF_CANCEL ); - goto out; +return ; }
@@ -280,15 +280,15 @@ xfs_buf_item_format_segment(* same set of bits so just keep counting and scanning. */ if (next_bit ==-1 ) { -xfs_buf_item_copy_iovec (vecp, bp, offset, +xfs_buf_item_copy_iovec (lv, vecp, bp, offset, first_bit, nbits); - nvecs++; + blfp->blf_size++;break ; }else if (next_bit != last_bit +1 ||xfs_buf_item_straddle (bp, offset, next_bit, last_bit)) { -xfs_buf_item_copy_iovec (vecp, bp, offset, +xfs_buf_item_copy_iovec (lv, vecp, bp, offset, first_bit, nbits); - nvecs++; + blfp->blf_size++; first_bit = next_bit; last_bit = next_bit; nbits =1 ;
@@ -297,8 +297,6 @@ xfs_buf_item_format_segment( nbits++; } } -out: - blfp->blf_size = nvecs; }/*
@@ -310,10 +308,11 @@ out: STATIC voidxfs_buf_item_format (struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +struct xfs_log_vec *lv) {struct xfs_buf_log_item *bip =BUF_ITEM (lip);struct xfs_buf *bp = bip->bli_buf; +struct xfs_log_iovec *vecp =NULL ;uint offset =0 ;int i;
@@ -354,7 +353,7 @@ xfs_buf_item_format( }for (i =0 ; i < bip->bli_format_count; i++) { -xfs_buf_item_format_segment (bip, &vecp, offset, +xfs_buf_item_format_segment (bip, lv, &vecp, offset, &bip->bli_formats[i]); offset += bp->b_maps[i].bm_len; }
fs/xfs/xfs_dquot_item.c +10 -9
@@ -57,18 +57,19 @@ xfs_qm_dquot_logitem_size( STATIC voidxfs_qm_dquot_logitem_format (struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +struct xfs_log_vec *lv) {struct xfs_dq_logitem *qlip =DQUOT_ITEM (lip); +struct xfs_log_iovec *vecp =NULL ; -xlog_copy_iovec (&vecp,XLOG_REG_TYPE_QFORMAT , + qlip->qli_format.qlf_size =2 ; + +xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_QFORMAT , &qlip->qli_format,sizeof (struct xfs_dq_logformat )); -xlog_copy_iovec (&vecp,XLOG_REG_TYPE_DQUOT , +xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_DQUOT , &qlip->qli_dquot->q_core,sizeof (struct xfs_disk_dquot )); - - qlip->qli_format.qlf_size =2 ; }/*
@@ -302,17 +303,17 @@ xfs_qm_qoff_logitem_size( STATIC voidxfs_qm_qoff_logitem_format (struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +struct xfs_log_vec *lv) {struct xfs_qoff_logitem *qflip =QOFF_ITEM (lip); +struct xfs_log_iovec *vecp =NULL ;ASSERT (qflip->qql_format.qf_type ==XFS_LI_QUOTAOFF ); + qflip->qql_format.qf_size =1 ; -xlog_copy_iovec (&vecp,XLOG_REG_TYPE_QUOTAOFF , +xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_QUOTAOFF , &qflip->qql_format,sizeof (struct xfs_qoff_logitem )); - - qflip->qql_format.qf_size =1 ; }/*
fs/xfs/xfs_extfree_item.c +6 -4
@@ -102,9 +102,10 @@ xfs_efi_item_size( STATIC voidxfs_efi_item_format (struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +struct xfs_log_vec *lv) {struct xfs_efi_log_item *efip =EFI_ITEM (lip); +struct xfs_log_iovec *vecp =NULL ;ASSERT (atomic_read (&efip->efi_next_extent) == efip->efi_format.efi_nextents);
@@ -112,7 +113,7 @@ xfs_efi_item_format( efip->efi_format.efi_type =XFS_LI_EFI ; efip->efi_format.efi_size =1 ; -xlog_copy_iovec (&vecp,XLOG_REG_TYPE_EFI_FORMAT , +xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_EFI_FORMAT , &efip->efi_format,xfs_efi_item_sizeof (efip)); }
@@ -368,16 +369,17 @@ xfs_efd_item_size( STATIC voidxfs_efd_item_format (struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +struct xfs_log_vec *lv) {struct xfs_efd_log_item *efdp =EFD_ITEM (lip); +struct xfs_log_iovec *vecp =NULL ;ASSERT (efdp->efd_next_extent == efdp->efd_format.efd_nextents); efdp->efd_format.efd_type =XFS_LI_EFD ; efdp->efd_format.efd_size =1 ; -xlog_copy_iovec (&vecp,XLOG_REG_TYPE_EFD_FORMAT , +xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_EFD_FORMAT , &efdp->efd_format,xfs_efd_item_sizeof (efdp)); }
fs/xfs/xfs_icreate_item.c +3 -2
@@ -59,11 +59,12 @@ xfs_icreate_item_size( STATIC voidxfs_icreate_item_format (struct xfs_log_item *lip, -struct xfs_log_iovec *vecp) +struct xfs_log_vec *lv) {struct xfs_icreate_item *icp =ICR_ITEM (lip); +struct xfs_log_iovec *vecp =NULL ; -xlog_copy_iovec (&vecp,XLOG_REG_TYPE_ICREATE , +xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_ICREATE , &icp->ic_format,sizeof (struct xfs_icreate_log )); }
fs/xfs/xfs_inode_item.c +45 -47
207 lines not on this page · raw message
fs/xfs/xfs_log.h +37 -4
55 lines not on this page · raw message
fs/xfs/xfs_log_cil.c +9 -32
60 lines not on this page · raw message
fs/xfs/xfs_trans.h +1 -1
@@ -64,7 +64,7 @@ typedef struct xfs_log_item {struct xfs_item_ops {void (*iop_size)(xfs_log_item_t *,int *,int *); -void (*iop_format)(xfs_log_item_t *,struct xfs_log_iovec *); +void (*iop_format)(xfs_log_item_t *,struct xfs_log_vec *);void (*iop_pin)(xfs_log_item_t *);void (*iop_unpin)(xfs_log_item_t *,int remove);uint (*iop_push)(struct xfs_log_item *,struct list_head *);
Signature · 6 lines
1.7.10.4 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH 7/10 xfs: format logged extents directly into the CIL
In reply to Christoph HellwigWith the new iop_format scheme there is no need to have a temporary buffer to format logged extents into, we can do so directly into the CIL. This also allows to remove the shortcut for big endian systems that probably hasn't gotten a lot of test coverage for a long time.
--- fs/xfs/xfs_inode_fork.c | 15 ++++--- fs/xfs/xfs_inode_item.c | 113 ++++++++--------------------------------------- fs/xfs/xfs_inode_item.h | 4 -- 3 files changed, 26 insertions(+), 106 deletions(-)
fs/xfs/xfs_inode_fork.c +8 -7
@@ -721,15 +721,16 @@ xfs_idestroy_fork( }/* -* xfs_iextents_copy() +* Convert in-core extents to on-disk form * -* This is called to copy the REAL extents (as opposed to the delayed -* allocation extents) from the inode into the given buffer. It -* returns the number of bytes copied into the buffer. +* For either the data or attr fork in extent format, we need to endian convert +* the in-core extent as we place them into the on-disk inode. * -* If there are no delayed allocation extents, then we can just -* memcpy() the extents into the buffer. Otherwise, we need to -* examine each extent in turn and skip those which are delayed. +* In the case of the data fork, the in-core and on-disk fork sizes can be +* different due to delayed allocation extents. We only copy on-disk extents +* here, so callers must always use the physical fork size to determine the +* size of the buffer passed to this routine. We will return the size actually +* used. */ int xfs_iextents_copy(
fs/xfs/xfs_inode_item.c +18 -95
142 lines not on this page · raw message
fs/xfs/xfs_inode_item.h +0 -4
@@ -34,10 +34,6 @@ typedef struct xfs_inode_log_item {unsigned short ili_logged;/* flushed logged data */ unsigned int ili_last_fields;/* fields when flushed */ unsigned int ili_fields;/* fields to be logged */ -struct xfs_bmbt_rec *ili_extents_buf;/* array of logged -data exts */ -struct xfs_bmbt_rec *ili_aextents_buf;/* array of logged -attr exts */ xfs_inode_log_format_t ili_format;/* logged structure */ } xfs_inode_log_item_t;
Signature · 7 lines
1.7.10.4 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 07/10] xfs: format logged extents directly into the CIL
Quoted 6 lines · Christoph Hellwig
With the new
iop_formatscheme there is no need to have a temporary buffer to format logged extents into, we can do so directly into the CIL. This also allows to remove the shortcut for big endian systems that probably hasn't gotten a lot of test coverage for a long time.Signed-off-by Christoph Hellwig <[email protected]>
Very nice! Lots of cruft just disappears here :)
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH 8/10 xfs: remove the inode log format from the inode log item
In reply to Christoph HellwigNo need to keep the inode log format around all the time, we can easily generate it at iop_format time.
--- fs/xfs/xfs_inode_item.c | 29 +++++++++++------------------ fs/xfs/xfs_inode_item.h | 1 - 2 files changed, 11 insertions(+), 19 deletions(-)
fs/xfs/xfs_inode_item.c +11 -18
@@ -370,17 +370,21 @@ xfs_inode_item_format(struct xfs_inode_log_format *ilf;struct xfs_log_iovec *vecp =NULL ; - ilf =xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_IFORMAT , - &iip->ili_format, -sizeof (struct xfs_inode_log_format )); - ilf->ilf_size =1 ; + ilf =xlog_prepare_iovec (lv, &vecp,XLOG_REG_TYPE_IFORMAT ); + ilf->ilf_type =XFS_LI_INODE ; + ilf->ilf_ino = ip->i_ino; + ilf->ilf_blkno = ip->i_imap.im_blkno; + ilf->ilf_len = ip->i_imap.im_len; + ilf->ilf_boffset = ip->i_imap.im_boffset; + ilf->ilf_fields =XFS_ILOG_CORE ; + ilf->ilf_size =2 ;/* format + core */ +xlog_finish_iovec (lv, vecp,sizeof (struct xfs_inode_log_format ));if (ip->i_d.di_version ==1 )xfs_inode_item_format_v1_inode (ip);xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_ICORE , &ip->i_d,xfs_icdinode_size (ip->i_d.di_version)); - ilf->ilf_size++;xfs_inode_item_format_data_fork (iip, ilf, lv, &vecp);if (XFS_IFORK_Q (ip)) {
@@ -390,14 +394,8 @@ xfs_inode_item_format( ~(XFS_ILOG_ADATA |XFS_ILOG_ABROOT |XFS_ILOG_AEXT ); } -/* -* Now update the log format that goes out to disk from the in-core -* values. We always write the inode core to make the arithmetic -* games in recovery easier, which isn't a big deal as just about any -* transaction would dirty it anyway. -*/ - iip->ili_format.ilf_fields =XFS_ILOG_CORE | - (iip->ili_fields & ~XFS_ILOG_TIMESTAMP ); +/* update the format with the exact fields we actually logged */ + ilf->ilf_fields |= (iip->ili_fields & ~XFS_ILOG_TIMESTAMP ); }/*
@@ -601,11 +599,6 @@ xfs_inode_item_init( iip->ili_inode = ip;xfs_log_item_init (mp, &iip->ili_item,XFS_LI_INODE , &xfs_inode_item_ops); - iip->ili_format.ilf_type =XFS_LI_INODE ; - iip->ili_format.ilf_ino = ip->i_ino; - iip->ili_format.ilf_blkno = ip->i_imap.im_blkno; - iip->ili_format.ilf_len = ip->i_imap.im_len; - iip->ili_format.ilf_boffset = ip->i_imap.im_boffset; }/*
fs/xfs/xfs_inode_item.h +0 -1
@@ -34,7 +34,6 @@ typedef struct xfs_inode_log_item {unsigned short ili_logged;/* flushed logged data */ unsigned int ili_last_fields;/* fields when flushed */ unsigned int ili_fields;/* fields to be logged */ -xfs_inode_log_format_t ili_format;/* logged structure */ } xfs_inode_log_item_t;static inline int xfs_inode_clean (xfs_inode_t *ip)
Signature · 7 lines
1.7.10.4 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 08/10] xfs: remove the inode log format from the inode log item
Quoted 4 lines · Christoph Hellwig
No need to keep the inode log format around all the time, we can easily generate it at
iop_formattime.Signed-off-by Christoph Hellwig <[email protected]>
Ignoring the previously mentioned structure alignment issue, this change looks good. Overall, the inode log item is reduced in size by about 72 bytes. :)
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH 9/10 xfs: remove the dquot log format from the dquot log item
In reply to Christoph HellwigNo need to keep the dquot log format around all the time, we can easily generate it at iop_format time.
--- fs/xfs/xfs_dquot_item.c | 25 +++++++++---------------- fs/xfs/xfs_dquot_item.h | 1 - 2 files changed, 9 insertions(+), 17 deletions(-)
fs/xfs/xfs_dquot_item.c +9 -16
@@ -61,12 +61,17 @@ xfs_qm_dquot_logitem_format( {struct xfs_dq_logitem *qlip =DQUOT_ITEM (lip);struct xfs_log_iovec *vecp =NULL ; +struct xfs_dq_logformat *qlf; - qlip->qli_format.qlf_size =2 ; + qlf =xlog_prepare_iovec (lv, &vecp,XLOG_REG_TYPE_QFORMAT ); + qlf->qlf_type =XFS_LI_DQUOT ; + qlf->qlf_size =2 ; + qlf->qlf_id =be32_to_cpu (qlip->qli_dquot->q_core.d_id); + qlf->qlf_blkno = qlip->qli_dquot->q_blkno; + qlf->qlf_len =1 ; + qlf->qlf_boffset = qlip->qli_dquot->q_bufoffset; +xlog_finish_iovec (lv, vecp,sizeof (struct xfs_dq_logformat )); -xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_QFORMAT , - &qlip->qli_format, -sizeof (struct xfs_dq_logformat ));xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_DQUOT , &qlip->qli_dquot->q_core,sizeof (struct xfs_disk_dquot ));
@@ -256,18 +261,6 @@ xfs_qm_dquot_logitem_init(xfs_log_item_init (dqp->q_mount, &lp->qli_item,XFS_LI_DQUOT , &xfs_dquot_item_ops); lp->qli_dquot = dqp; - lp->qli_format.qlf_type =XFS_LI_DQUOT ; - lp->qli_format.qlf_id =be32_to_cpu (dqp->q_core.d_id); - lp->qli_format.qlf_blkno = dqp->q_blkno; - lp->qli_format.qlf_len =1 ; -/* -* This is just the offset of this dquot within its buffer -* (which is currently 1 FSB and probably won't change). -* Hence 32 bits for this offset should be just fine. -* Alternatively, we can store (bufoffset / sizeof(xfs_dqblk_t)) -* here, and recompute it at recovery time. -*/ - lp->qli_format.qlf_boffset = (__uint32_t )dqp->q_bufoffset; }/*------------------ QUOTAOFF LOG ITEMS -------------------*/
fs/xfs/xfs_dquot_item.h +0 -1
@@ -27,7 +27,6 @@ typedef struct xfs_dq_logitem {xfs_log_item_t qli_item;/* common portion */ struct xfs_dquot *qli_dquot;/* dquot ptr */ xfs_lsn_t qli_flush_lsn;/* lsn at last flush */ -xfs_dq_logformat_t qli_format;/* logged structure */ } xfs_dq_logitem_t; typedef struct xfs_qoff_logitem {
Signature · 7 lines
1.7.10.4 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 09/10] xfs: remove the dquot log format from the dquot log item
Quoted 4 lines · Christoph Hellwig
No need to keep the dquot log format around all the time, we can easily generate it at
iop_formattime.Signed-off-by Christoph Hellwig <[email protected]>
looks good.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH 10/10 xfs: remove the quotaoff log format from the quotaoff log item
In reply to Christoph HellwigThis one doesn't save a whole lot of memory, but still makes the code simpler.
--- fs/xfs/xfs_dquot_item.c | 22 +++++++--------------- fs/xfs/xfs_dquot_item.h | 2 +- 2 files changed, 8 insertions(+), 16 deletions(-)
fs/xfs/xfs_dquot_item.c +7 -15
@@ -286,13 +286,6 @@ xfs_qm_qoff_logitem_size( *nbytes +=sizeof (struct xfs_qoff_logitem ); } -/* -* This is called to fill in the vector of log iovecs for the -* given quotaoff log item. We use only 1 iovec, and we point that -* at the quotaoff_log_format structure embedded in the quotaoff item. -* It is at this point that we assert that all of the extent -* slots in the quotaoff item have been filled. -*/ STATIC void xfs_qm_qoff_logitem_format( struct xfs_log_item *lip,
@@ -300,13 +293,13 @@ xfs_qm_qoff_logitem_format( {struct xfs_qoff_logitem *qflip =QOFF_ITEM (lip);struct xfs_log_iovec *vecp =NULL ; +struct xfs_qoff_logformat *qlf; -ASSERT (qflip->qql_format.qf_type ==XFS_LI_QUOTAOFF ); - qflip->qql_format.qf_size =1 ; - -xlog_copy_iovec (lv, &vecp,XLOG_REG_TYPE_QUOTAOFF , - &qflip->qql_format, -sizeof (struct xfs_qoff_logitem )); + qlf =xlog_prepare_iovec (lv, &vecp,XLOG_REG_TYPE_QUOTAOFF ); + qlf->qf_type =XFS_LI_QUOTAOFF ; + qlf->qf_size =1 ; + qlf->qf_flags = qflip->qql_flags; +xlog_finish_iovec (lv, vecp,sizeof (struct xfs_qoff_logitem )); }/*
@@ -446,8 +439,7 @@ xfs_qm_qoff_logitem_init(xfs_log_item_init (mp, &qf->qql_item,XFS_LI_QUOTAOFF , start ? &xfs_qm_qoffend_logitem_ops : &xfs_qm_qoff_logitem_ops); qf->qql_item.li_mountp = mp; - qf->qql_format.qf_type =XFS_LI_QUOTAOFF ; - qf->qql_format.qf_flags = flags; qf->qql_start_lip = start; + qf->qql_flags = flags;return qf; }
fs/xfs/xfs_dquot_item.h +1 -1
@@ -32,7 +32,7 @@ typedef struct xfs_dq_logitem {typedef struct xfs_qoff_logitem {xfs_log_item_t qql_item;/* common portion */ struct xfs_qoff_logitem *qql_start_lip;/* qoff-start logitem, if any */ -xfs_qoff_logformat_t qql_format;/* logged structure */ +unsigned int qql_flags; }xfs_qoff_logitem_t ;
Signature · 7 lines
1.7.10.4 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 10/10] xfs: remove the quotaoff log format from the quotaoff log item
Quoted 4 lines · Christoph Hellwig
This one doesn't save a whole lot of memory, but still makes the code simpler.
Signed-off-by Christoph Hellwig <[email protected]>
Looks good,
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs