Commit 34f76326 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'xfs-6.7-merge-2' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux 

Pull xfs updates from Chandan Babu:

 - Realtime device subsystem:
    - Cleanup usage of xfs_rtblock_t and xfs_fsblock_t data types
    - Replace open coded conversions between rt blocks and rt extents
      with calls to static inline helpers
    - Replace open coded realtime geometry compuation and macros with
      helper functions
    - CPU usage optimizations for realtime allocator
    - Misc bug fixes associated with Realtime device

 - Allow read operations to execute while an FICLONE ioctl is being
   serviced

 - Misc bug fixes:
    - Alert user when xfs_droplink() encounters an inode with a link
      count of zero
    - Handle the case where the allocator could return zero extents when
      servicing an fallocate request

* tag 'xfs-6.7-merge-2' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux: (40 commits)
  xfs: allow read IO and FICLONE to run concurrently
  xfs: handle nimaps=0 from xfs_bmapi_write in xfs_alloc_file_space
  xfs: introduce protection for drop nlink
  xfs: don't look for end of extent further than necessary in xfs_rtallocate_extent_near()
  xfs: don't try redundant allocations in xfs_rtallocate_extent_near()
  xfs: limit maxlen based on available space in xfs_rtallocate_extent_near()
  xfs: return maximum free size from xfs_rtany_summary()
  xfs: invert the realtime summary cache
  xfs: simplify rt bitmap/summary block accessor functions
  xfs: simplify xfs_rtbuf_get calling conventions
  xfs: cache last bitmap block in realtime allocator
  xfs: use accessor functions for summary info words
  xfs: consolidate realtime allocation arguments
  xfs: create helpers for rtsummary block/wordcount computations
  xfs: use accessor functions for bitmap words
  xfs: create helpers for rtbitmap block/wordcount computations
  xfs: create a helper to handle logging parts of rt bitmap/summary blocks
  xfs: convert rt summary macros to helpers
  xfs: convert open-coded xfs_rtword_t pointer accesses to helper
  xfs: remove XFS_BLOCKWSIZE and XFS_BLOCKWMASK macros
  ...
parents 6d795e2a 14a53798

fs/xfs/libxfs/xfs_bmap.c

+14 −31
Original line number Diff line number Diff line
@@ -21,7 +21,7 @@ 
#include "xfs_bmap.h"

#include "xfs_bmap_util.h"

#include "xfs_bmap_btree.h"

#include "xfs_rtalloc.h"

#include "xfs_rtbitmap.h"

#include "xfs_errortag.h"

#include "xfs_error.h"

#include "xfs_quota.h"
@@ -2989,7 +2989,7 @@ xfs_bmap_extsize_align( 
	 * If realtime, and the result isn't a multiple of the realtime

	 * extent size we need to remove blocks until it is.

	 */

	if (rt && (temp = (align_alen % mp->m_sb.sb_rextsize))) {

	if (rt && (temp = xfs_extlen_to_rtxmod(mp, align_alen))) {

		/*

		 * We're not covering the original request, or

		 * we won't be able to once we fix the length.
@@ -3016,7 +3016,7 @@ xfs_bmap_extsize_align( 
		else {

			align_alen -= orig_off - align_off;

			align_off = orig_off;

			align_alen -= align_alen % mp->m_sb.sb_rextsize;

			align_alen -= xfs_extlen_to_rtxmod(mp, align_alen);

		}

		/*

		 * Result doesn't cover the request, fail it.
@@ -4826,12 +4826,8 @@ xfs_bmap_del_extent_delay( 
	ASSERT(got->br_startoff <= del->br_startoff);

	ASSERT(got_endoff >= del_endoff);



	if (isrt) {

		uint64_t rtexts = XFS_FSB_TO_B(mp, del->br_blockcount);



		do_div(rtexts, mp->m_sb.sb_rextsize);

		xfs_mod_frextents(mp, rtexts);

	}

	if (isrt)

		xfs_mod_frextents(mp, xfs_rtb_to_rtx(mp, del->br_blockcount));



	/*

	 * Update the inode delalloc counter now and wait to update the
@@ -5057,33 +5053,20 @@ xfs_bmap_del_extent_real( 


	flags = XFS_ILOG_CORE;

	if (whichfork == XFS_DATA_FORK && XFS_IS_REALTIME_INODE(ip)) {

		xfs_filblks_t	len;

		xfs_extlen_t	mod;



		len = div_u64_rem(del->br_blockcount, mp->m_sb.sb_rextsize,

				  &mod);

		ASSERT(mod == 0);



		if (!(bflags & XFS_BMAPI_REMAP)) {

			xfs_fsblock_t	bno;



			bno = div_u64_rem(del->br_startblock,

					mp->m_sb.sb_rextsize, &mod);

			ASSERT(mod == 0);



			error = xfs_rtfree_extent(tp, bno, (xfs_extlen_t)len);

			error = xfs_rtfree_blocks(tp, del->br_startblock,

					del->br_blockcount);

			if (error)

				goto done;

		}



		do_fx = 0;

		nblks = len * mp->m_sb.sb_rextsize;

		qfield = XFS_TRANS_DQ_RTBCOUNT;

	} else {

		do_fx = 1;

		nblks = del->br_blockcount;

		qfield = XFS_TRANS_DQ_BCOUNT;

	}

	nblks = del->br_blockcount;



	del_endblock = del->br_startblock + del->br_blockcount;

	if (cur) {
@@ -5289,7 +5272,6 @@ __xfs_bunmapi( 
	int			tmp_logflags;	/* partial logging flags */

	int			wasdel;		/* was a delayed alloc extent */

	int			whichfork;	/* data or attribute fork */

	xfs_fsblock_t		sum;

	xfs_filblks_t		len = *rlen;	/* length to unmap in file */

	xfs_fileoff_t		end;

	struct xfs_iext_cursor	icur;
@@ -5384,8 +5366,8 @@ __xfs_bunmapi( 
		if (!isrt)

			goto delete;



		sum = del.br_startblock + del.br_blockcount;

		div_u64_rem(sum, mp->m_sb.sb_rextsize, &mod);

		mod = xfs_rtb_to_rtxoff(mp,

				del.br_startblock + del.br_blockcount);

		if (mod) {

			/*

			 * Realtime extent not lined up at the end.
@@ -5432,7 +5414,8 @@ __xfs_bunmapi( 
				goto error0;

			goto nodelete;

		}

		div_u64_rem(del.br_startblock, mp->m_sb.sb_rextsize, &mod);



		mod = xfs_rtb_to_rtxoff(mp, del.br_startblock);

		if (mod) {

			xfs_extlen_t off = mp->m_sb.sb_rextsize - mod;
@@ -6209,7 +6192,7 @@ xfs_bmap_validate_extent( 
		return __this_address;



	if (XFS_IS_REALTIME_INODE(ip) && whichfork == XFS_DATA_FORK) {

		if (!xfs_verify_rtext(mp, irec->br_startblock,

		if (!xfs_verify_rtbext(mp, irec->br_startblock,

					   irec->br_blockcount))

			return __this_address;

	} else {

fs/xfs/libxfs/xfs_format.h

+18 −16
Original line number Diff line number Diff line
@@ -98,7 +98,7 @@ typedef struct xfs_sb { 
	uint32_t	sb_blocksize;	/* logical block size, bytes */

	xfs_rfsblock_t	sb_dblocks;	/* number of data blocks */

	xfs_rfsblock_t	sb_rblocks;	/* number of realtime blocks */

	xfs_rtblock_t	sb_rextents;	/* number of realtime extents */

	xfs_rtbxlen_t	sb_rextents;	/* number of realtime extents */

	uuid_t		sb_uuid;	/* user-visible file system unique id */

	xfs_fsblock_t	sb_logstart;	/* starting block of log if internal */

	xfs_ino_t	sb_rootino;	/* root inode number */
@@ -690,6 +690,22 @@ struct xfs_agfl { 
	    ASSERT(xfs_daddr_to_agno(mp, d) == \

		   xfs_daddr_to_agno(mp, (d) + (len) - 1)))



/*

 * Realtime bitmap information is accessed by the word, which is currently

 * stored in host-endian format.

 */

union xfs_rtword_raw {

	__u32		old;

};



/*

 * Realtime summary counts are accessed by the word, which is currently

 * stored in host-endian format.

 */

union xfs_suminfo_raw {

	__u32		old;

};



/*

 * XFS Timestamps

 * ==============
@@ -1142,24 +1158,10 @@ static inline bool xfs_dinode_has_large_extent_counts( 


#define	XFS_BLOCKSIZE(mp)	((mp)->m_sb.sb_blocksize)

#define	XFS_BLOCKMASK(mp)	((mp)->m_blockmask)

#define	XFS_BLOCKWSIZE(mp)	((mp)->m_blockwsize)

#define	XFS_BLOCKWMASK(mp)	((mp)->m_blockwmask)



/*

 * RT Summary and bit manipulation macros.

 * RT bit manipulation macros.

 */

#define	XFS_SUMOFFS(mp,ls,bb)	((int)((ls) * (mp)->m_sb.sb_rbmblocks + (bb)))

#define	XFS_SUMOFFSTOBLOCK(mp,s)	\

	(((s) * (uint)sizeof(xfs_suminfo_t)) >> (mp)->m_sb.sb_blocklog)

#define	XFS_SUMPTR(mp,bp,so)	\

	((xfs_suminfo_t *)((bp)->b_addr + \

		(((so) * (uint)sizeof(xfs_suminfo_t)) & XFS_BLOCKMASK(mp))))



#define	XFS_BITTOBLOCK(mp,bi)	((bi) >> (mp)->m_blkbit_log)

#define	XFS_BLOCKTOBIT(mp,bb)	((bb) << (mp)->m_blkbit_log)

#define	XFS_BITTOWORD(mp,bi)	\

	((int)(((bi) >> XFS_NBWORDLOG) & XFS_BLOCKWMASK(mp)))



#define	XFS_RTMIN(a,b)	((a) < (b) ? (a) : (b))

#define	XFS_RTMAX(a,b)	((a) > (b) ? (a) : (b))

fs/xfs/libxfs/xfs_rtbitmap.c

+440 −367

File changed.

Preview size limit exceeded, changes collapsed.

fs/xfs/libxfs/xfs_rtbitmap.h

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

/*

 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.

 * All Rights Reserved.

 */

#ifndef __XFS_RTBITMAP_H__

#define	__XFS_RTBITMAP_H__



struct xfs_rtalloc_args {

	struct xfs_mount	*mp;

	struct xfs_trans	*tp;



	struct xfs_buf		*rbmbp;	/* bitmap block buffer */

	struct xfs_buf		*sumbp;	/* summary block buffer */



	xfs_fileoff_t		rbmoff;	/* bitmap block number */

	xfs_fileoff_t		sumoff;	/* summary block number */

};



static inline xfs_rtblock_t

xfs_rtx_to_rtb(

	struct xfs_mount	*mp,

	xfs_rtxnum_t		rtx)

{

	if (mp->m_rtxblklog >= 0)

		return rtx << mp->m_rtxblklog;



	return rtx * mp->m_sb.sb_rextsize;

}



static inline xfs_extlen_t

xfs_rtxlen_to_extlen(

	struct xfs_mount	*mp,

	xfs_rtxlen_t		rtxlen)

{

	if (mp->m_rtxblklog >= 0)

		return rtxlen << mp->m_rtxblklog;



	return rtxlen * mp->m_sb.sb_rextsize;

}



/* Compute the misalignment between an extent length and a realtime extent .*/

static inline unsigned int

xfs_extlen_to_rtxmod(

	struct xfs_mount	*mp,

	xfs_extlen_t		len)

{

	if (mp->m_rtxblklog >= 0)

		return len & mp->m_rtxblkmask;



	return len % mp->m_sb.sb_rextsize;

}



static inline xfs_rtxlen_t

xfs_extlen_to_rtxlen(

	struct xfs_mount	*mp,

	xfs_extlen_t		len)

{

	if (mp->m_rtxblklog >= 0)

		return len >> mp->m_rtxblklog;



	return len / mp->m_sb.sb_rextsize;

}



/* Convert an rt block number into an rt extent number. */

static inline xfs_rtxnum_t

xfs_rtb_to_rtx(

	struct xfs_mount	*mp,

	xfs_rtblock_t		rtbno)

{

	if (likely(mp->m_rtxblklog >= 0))

		return rtbno >> mp->m_rtxblklog;



	return div_u64(rtbno, mp->m_sb.sb_rextsize);

}



/* Return the offset of an rt block number within an rt extent. */

static inline xfs_extlen_t

xfs_rtb_to_rtxoff(

	struct xfs_mount	*mp,

	xfs_rtblock_t		rtbno)

{

	if (likely(mp->m_rtxblklog >= 0))

		return rtbno & mp->m_rtxblkmask;



	return do_div(rtbno, mp->m_sb.sb_rextsize);

}



/*

 * Crack an rt block number into an rt extent number and an offset within that

 * rt extent.  Returns the rt extent number directly and the offset in @off.

 */

static inline xfs_rtxnum_t

xfs_rtb_to_rtxrem(

	struct xfs_mount	*mp,

	xfs_rtblock_t		rtbno,

	xfs_extlen_t		*off)

{

	if (likely(mp->m_rtxblklog >= 0)) {

		*off = rtbno & mp->m_rtxblkmask;

		return rtbno >> mp->m_rtxblklog;

	}



	return div_u64_rem(rtbno, mp->m_sb.sb_rextsize, off);

}



/*

 * Convert an rt block number into an rt extent number, rounding up to the next

 * rt extent if the rt block is not aligned to an rt extent boundary.

 */

static inline xfs_rtxnum_t

xfs_rtb_to_rtxup(

	struct xfs_mount	*mp,

	xfs_rtblock_t		rtbno)

{

	if (likely(mp->m_rtxblklog >= 0)) {

		if (rtbno & mp->m_rtxblkmask)

			return (rtbno >> mp->m_rtxblklog) + 1;

		return rtbno >> mp->m_rtxblklog;

	}



	if (do_div(rtbno, mp->m_sb.sb_rextsize))

		rtbno++;

	return rtbno;

}



/* Round this rtblock up to the nearest rt extent size. */

static inline xfs_rtblock_t

xfs_rtb_roundup_rtx(

	struct xfs_mount	*mp,

	xfs_rtblock_t		rtbno)

{

	return roundup_64(rtbno, mp->m_sb.sb_rextsize);

}



/* Round this rtblock down to the nearest rt extent size. */

static inline xfs_rtblock_t

xfs_rtb_rounddown_rtx(

	struct xfs_mount	*mp,

	xfs_rtblock_t		rtbno)

{

	return rounddown_64(rtbno, mp->m_sb.sb_rextsize);

}



/* Convert an rt extent number to a file block offset in the rt bitmap file. */

static inline xfs_fileoff_t

xfs_rtx_to_rbmblock(

	struct xfs_mount	*mp,

	xfs_rtxnum_t		rtx)

{

	return rtx >> mp->m_blkbit_log;

}



/* Convert an rt extent number to a word offset within an rt bitmap block. */

static inline unsigned int

xfs_rtx_to_rbmword(

	struct xfs_mount	*mp,

	xfs_rtxnum_t		rtx)

{

	return (rtx >> XFS_NBWORDLOG) & (mp->m_blockwsize - 1);

}



/* Convert a file block offset in the rt bitmap file to an rt extent number. */

static inline xfs_rtxnum_t

xfs_rbmblock_to_rtx(

	struct xfs_mount	*mp,

	xfs_fileoff_t		rbmoff)

{

	return rbmoff << mp->m_blkbit_log;

}



/* Return a pointer to a bitmap word within a rt bitmap block. */

static inline union xfs_rtword_raw *

xfs_rbmblock_wordptr(

	struct xfs_rtalloc_args	*args,

	unsigned int		index)

{

	union xfs_rtword_raw	*words = args->rbmbp->b_addr;



	return words + index;

}



/* Convert an ondisk bitmap word to its incore representation. */

static inline xfs_rtword_t

xfs_rtbitmap_getword(

	struct xfs_rtalloc_args	*args,

	unsigned int		index)

{

	union xfs_rtword_raw	*word = xfs_rbmblock_wordptr(args, index);



	return word->old;

}



/* Set an ondisk bitmap word from an incore representation. */

static inline void

xfs_rtbitmap_setword(

	struct xfs_rtalloc_args	*args,

	unsigned int		index,

	xfs_rtword_t		value)

{

	union xfs_rtword_raw	*word = xfs_rbmblock_wordptr(args, index);



	word->old = value;

}



/*

 * Convert a rt extent length and rt bitmap block number to a xfs_suminfo_t

 * offset within the rt summary file.

 */

static inline xfs_rtsumoff_t

xfs_rtsumoffs(

	struct xfs_mount	*mp,

	int			log2_len,

	xfs_fileoff_t		rbmoff)

{

	return log2_len * mp->m_sb.sb_rbmblocks + rbmoff;

}



/*

 * Convert an xfs_suminfo_t offset to a file block offset within the rt summary

 * file.

 */

static inline xfs_fileoff_t

xfs_rtsumoffs_to_block(

	struct xfs_mount	*mp,

	xfs_rtsumoff_t		rsumoff)

{

	return XFS_B_TO_FSBT(mp, rsumoff * sizeof(xfs_suminfo_t));

}



/*

 * Convert an xfs_suminfo_t offset to an info word offset within an rt summary

 * block.

 */

static inline unsigned int

xfs_rtsumoffs_to_infoword(

	struct xfs_mount	*mp,

	xfs_rtsumoff_t		rsumoff)

{

	unsigned int		mask = mp->m_blockmask >> XFS_SUMINFOLOG;



	return rsumoff & mask;

}



/* Return a pointer to a summary info word within a rt summary block. */

static inline union xfs_suminfo_raw *

xfs_rsumblock_infoptr(

	struct xfs_rtalloc_args	*args,

	unsigned int		index)

{

	union xfs_suminfo_raw	*info = args->sumbp->b_addr;



	return info + index;

}



/* Get the current value of a summary counter. */

static inline xfs_suminfo_t

xfs_suminfo_get(

	struct xfs_rtalloc_args	*args,

	unsigned int		index)

{

	union xfs_suminfo_raw	*info = xfs_rsumblock_infoptr(args, index);



	return info->old;

}



/* Add to the current value of a summary counter and return the new value. */

static inline xfs_suminfo_t

xfs_suminfo_add(

	struct xfs_rtalloc_args	*args,

	unsigned int		index,

	int			delta)

{

	union xfs_suminfo_raw	*info = xfs_rsumblock_infoptr(args, index);



	info->old += delta;

	return info->old;

}



/*

 * Functions for walking free space rtextents in the realtime bitmap.

 */

struct xfs_rtalloc_rec {

	xfs_rtxnum_t		ar_startext;

	xfs_rtbxlen_t		ar_extcount;

};



typedef int (*xfs_rtalloc_query_range_fn)(

	struct xfs_mount		*mp,

	struct xfs_trans		*tp,

	const struct xfs_rtalloc_rec	*rec,

	void				*priv);



#ifdef CONFIG_XFS_RT

void xfs_rtbuf_cache_relse(struct xfs_rtalloc_args *args);



int xfs_rtbuf_get(struct xfs_rtalloc_args *args, xfs_fileoff_t block,

		int issum);



static inline int

xfs_rtbitmap_read_buf(

	struct xfs_rtalloc_args		*args,

	xfs_fileoff_t			block)

{

	return xfs_rtbuf_get(args, block, 0);

}



static inline int

xfs_rtsummary_read_buf(

	struct xfs_rtalloc_args		*args,

	xfs_fileoff_t			block)

{

	return xfs_rtbuf_get(args, block, 1);

}



int xfs_rtcheck_range(struct xfs_rtalloc_args *args, xfs_rtxnum_t start,

		xfs_rtxlen_t len, int val, xfs_rtxnum_t *new, int *stat);

int xfs_rtfind_back(struct xfs_rtalloc_args *args, xfs_rtxnum_t start,

		xfs_rtxnum_t limit, xfs_rtxnum_t *rtblock);

int xfs_rtfind_forw(struct xfs_rtalloc_args *args, xfs_rtxnum_t start,

		xfs_rtxnum_t limit, xfs_rtxnum_t *rtblock);

int xfs_rtmodify_range(struct xfs_rtalloc_args *args, xfs_rtxnum_t start,

		xfs_rtxlen_t len, int val);

int xfs_rtmodify_summary_int(struct xfs_rtalloc_args *args, int log,

		xfs_fileoff_t bbno, int delta, xfs_suminfo_t *sum);

int xfs_rtmodify_summary(struct xfs_rtalloc_args *args, int log,

		xfs_fileoff_t bbno, int delta);

int xfs_rtfree_range(struct xfs_rtalloc_args *args, xfs_rtxnum_t start,

		xfs_rtxlen_t len);

int xfs_rtalloc_query_range(struct xfs_mount *mp, struct xfs_trans *tp,

		const struct xfs_rtalloc_rec *low_rec,

		const struct xfs_rtalloc_rec *high_rec,

		xfs_rtalloc_query_range_fn fn, void *priv);

int xfs_rtalloc_query_all(struct xfs_mount *mp, struct xfs_trans *tp,

			  xfs_rtalloc_query_range_fn fn,

			  void *priv);

int xfs_rtalloc_extent_is_free(struct xfs_mount *mp, struct xfs_trans *tp,

			       xfs_rtxnum_t start, xfs_rtxlen_t len,

			       bool *is_free);

/*

 * Free an extent in the realtime subvolume.  Length is expressed in

 * realtime extents, as is the block number.

 */

int					/* error */

xfs_rtfree_extent(

	struct xfs_trans	*tp,	/* transaction pointer */

	xfs_rtxnum_t		start,	/* starting rtext number to free */

	xfs_rtxlen_t		len);	/* length of extent freed */



/* Same as above, but in units of rt blocks. */

int xfs_rtfree_blocks(struct xfs_trans *tp, xfs_fsblock_t rtbno,

		xfs_filblks_t rtlen);



xfs_filblks_t xfs_rtbitmap_blockcount(struct xfs_mount *mp, xfs_rtbxlen_t

		rtextents);

unsigned long long xfs_rtbitmap_wordcount(struct xfs_mount *mp,

		xfs_rtbxlen_t rtextents);



xfs_filblks_t xfs_rtsummary_blockcount(struct xfs_mount *mp,

		unsigned int rsumlevels, xfs_extlen_t rbmblocks);

unsigned long long xfs_rtsummary_wordcount(struct xfs_mount *mp,

		unsigned int rsumlevels, xfs_extlen_t rbmblocks);

#else /* CONFIG_XFS_RT */

# define xfs_rtfree_extent(t,b,l)			(-ENOSYS)

# define xfs_rtfree_blocks(t,rb,rl)			(-ENOSYS)

# define xfs_rtalloc_query_range(m,t,l,h,f,p)		(-ENOSYS)

# define xfs_rtalloc_query_all(m,t,f,p)			(-ENOSYS)

# define xfs_rtbitmap_read_buf(a,b)			(-ENOSYS)

# define xfs_rtsummary_read_buf(a,b)			(-ENOSYS)

# define xfs_rtbuf_cache_relse(a)			(0)

# define xfs_rtalloc_extent_is_free(m,t,s,l,i)		(-ENOSYS)

static inline xfs_filblks_t

xfs_rtbitmap_blockcount(struct xfs_mount *mp, xfs_rtbxlen_t rtextents)

{

	/* shut up gcc */

	return 0;

}

# define xfs_rtbitmap_wordcount(mp, r)			(0)

# define xfs_rtsummary_blockcount(mp, l, b)		(0)

# define xfs_rtsummary_wordcount(mp, l, b)		(0)

#endif /* CONFIG_XFS_RT */



#endif /* __XFS_RTBITMAP_H__ */

fs/xfs/libxfs/xfs_sb.c

+2 −0
Original line number Diff line number Diff line
@@ -975,6 +975,8 @@ xfs_sb_mount_common( 
	mp->m_blockmask = sbp->sb_blocksize - 1;

	mp->m_blockwsize = sbp->sb_blocksize >> XFS_WORDLOG;

	mp->m_blockwmask = mp->m_blockwsize - 1;

	mp->m_rtxblklog = log2_if_power2(sbp->sb_rextsize);

	mp->m_rtxblkmask = mask64_if_power2(sbp->sb_rextsize);



	mp->m_alloc_mxr[0] = xfs_allocbt_maxrecs(mp, sbp->sb_blocksize, 1);

	mp->m_alloc_mxr[1] = xfs_allocbt_maxrecs(mp, sbp->sb_blocksize, 0);