struct xfs_mount *mp = args->mp;
xfs_agblock_t agsize;
- args->otype = args->type;
args->agbno = NULLAGBLOCK;
/*
trace_xfs_alloc_vextent_loopfailed(args);
if (args->agno == start_agno &&
- args->otype == XFS_ALLOCTYPE_START_BNO)
+ args->otype == XFS_ALLOCTYPE_NEAR_BNO)
args->type = XFS_ALLOCTYPE_THIS_AG;
/*
}
flags = 0;
- if (args->otype == XFS_ALLOCTYPE_START_BNO) {
+ if (args->otype == XFS_ALLOCTYPE_NEAR_BNO) {
args->agbno = XFS_FSB_TO_AGBNO(mp, args->fsbno);
args->type = XFS_ALLOCTYPE_NEAR_BNO;
}
* otherwise will wrap back to the start AG and run a second blocking pass to
* the end of the filesystem.
*/
-static int
+int
xfs_alloc_vextent_start_ag(
struct xfs_alloc_arg *args,
- xfs_agnumber_t minimum_agno)
+ xfs_fsblock_t target)
{
struct xfs_mount *mp = args->mp;
+ xfs_agnumber_t minimum_agno = 0;
xfs_agnumber_t start_agno;
xfs_agnumber_t rotorstep = xfs_rotorstep;
bool bump_rotor = false;
int error;
- error = xfs_alloc_vextent_check_args(args, args->fsbno);
+ if (args->tp->t_highest_agno != NULLAGNUMBER)
+ minimum_agno = args->tp->t_highest_agno;
+
+ error = xfs_alloc_vextent_check_args(args, target);
if (error) {
if (error == -ENOSPC)
return 0;
if ((args->datatype & XFS_ALLOC_INITIAL_USER_DATA) &&
xfs_is_inode32(mp)) {
- args->fsbno = XFS_AGB_TO_FSB(mp,
+ target = XFS_AGB_TO_FSB(mp,
((mp->m_agfrotor / rotorstep) %
mp->m_sb.sb_agcount), 0);
bump_rotor = 1;
}
- start_agno = max(minimum_agno, XFS_FSB_TO_AGNO(mp, args->fsbno));
- args->agbno = XFS_FSB_TO_AGBNO(mp, args->fsbno);
+ start_agno = max(minimum_agno, XFS_FSB_TO_AGNO(mp, target));
+ args->agbno = XFS_FSB_TO_AGBNO(mp, target);
args->type = XFS_ALLOCTYPE_NEAR_BNO;
+ args->fsbno = target;
error = xfs_alloc_vextent_iterate_ags(args, minimum_agno, start_agno,
XFS_ALLOC_FLAG_TRYLOCK);
error = xfs_alloc_vextent_this_ag(args);
xfs_perag_put(args->pag);
break;
- case XFS_ALLOCTYPE_START_BNO:
- return xfs_alloc_vextent_start_ag(args, minimum_agno);
default:
error = -EFSCORRUPTED;
ASSERT(0);
* Freespace allocation types. Argument to xfs_alloc_[v]extent.
*/
#define XFS_ALLOCTYPE_THIS_AG 0x08 /* anywhere in this a.g. */
-#define XFS_ALLOCTYPE_START_BNO 0x10 /* near this block else anywhere */
#define XFS_ALLOCTYPE_NEAR_BNO 0x20 /* in this a.g. and near this block */
#define XFS_ALLOCTYPE_THIS_BNO 0x40 /* at exactly this block */
#define XFS_ALLOC_TYPES \
{ XFS_ALLOCTYPE_THIS_AG, "THIS_AG" }, \
- { XFS_ALLOCTYPE_START_BNO, "START_BNO" }, \
{ XFS_ALLOCTYPE_NEAR_BNO, "NEAR_BNO" }, \
{ XFS_ALLOCTYPE_THIS_BNO, "THIS_BNO" }
*/
int xfs_alloc_vextent_this_ag(struct xfs_alloc_arg *args);
+/*
+ * Best effort full filesystem allocation scan.
+ *
+ * Locality aware allocation will be attempted in the initial AG, but on failure
+ * non-localised attempts will be made. The AGs are constrained by previous
+ * allocations in the current transaction. Two passes will be made - the first
+ * non-blocking, the second blocking.
+ */
+int xfs_alloc_vextent_start_ag(struct xfs_alloc_arg *args,
+ xfs_fsblock_t target);
+
/*
* Iterate from the AG indicated from args->fsbno through to the end of the
* filesystem attempting blocking allocation. This is for use in last
args.mp = mp;
xfs_rmap_ino_bmbt_owner(&args.oinfo, ip->i_ino, whichfork);
- args.type = XFS_ALLOCTYPE_START_BNO;
- args.fsbno = XFS_INO_TO_FSB(mp, ip->i_ino);
args.minlen = args.maxlen = args.prod = 1;
args.wasdel = wasdel;
*logflagsp = 0;
- error = xfs_alloc_vextent(&args);
+ error = xfs_alloc_vextent_start_ag(&args,
+ XFS_INO_TO_FSB(mp, ip->i_ino));
if (error)
goto out_root_realloc;
args.total = total;
args.minlen = args.maxlen = args.prod = 1;
xfs_rmap_ino_owner(&args.oinfo, ip->i_ino, whichfork, 0);
+
/*
* Allocate a block. We know we need only one, since the
* file currently fits in an inode.
*/
- args.fsbno = XFS_INO_TO_FSB(args.mp, ip->i_ino);
- args.type = XFS_ALLOCTYPE_START_BNO;
args.total = total;
args.minlen = args.maxlen = args.prod = 1;
- error = xfs_alloc_vextent(&args);
+ error = xfs_alloc_vextent_start_ag(&args,
+ XFS_INO_TO_FSB(args.mp, ip->i_ino));
if (error)
goto done;
int notinit = 0;
int error = 0;
- args->type = XFS_ALLOCTYPE_START_BNO;
if (ap->tp->t_flags & XFS_TRANS_LOWMODE) {
args->total = ap->minlen;
args->minlen = ap->minlen;
struct xfs_bmalloca *ap,
struct xfs_alloc_arg *args,
xfs_extlen_t blen,
- int stripe_align)
+ int stripe_align,
+ bool ag_only)
{
struct xfs_mount *mp = args->mp;
xfs_alloctype_t atype;
args->minalignslop = 0;
}
- error = xfs_alloc_vextent(args);
+ if (ag_only)
+ error = xfs_alloc_vextent(args);
+ else
+ error = xfs_alloc_vextent_start_ag(args, ap->blkno);
if (error)
return error;
{
struct xfs_mount *mp = args->mp;
xfs_extlen_t blen = 0;
+ bool is_filestream = false;
int error;
+ if ((ap->datatype & XFS_ALLOC_USERDATA) &&
+ xfs_inode_is_filestream(ap->ip))
+ is_filestream = true;
+
/*
* Determine the initial block number we will target for allocation.
*/
- if ((ap->datatype & XFS_ALLOC_USERDATA) &&
- xfs_inode_is_filestream(ap->ip)) {
+ if (is_filestream) {
xfs_agnumber_t agno = xfs_filestream_lookup_ag(ap->ip);
if (agno == NULLAGNUMBER)
agno = 0;
* the request. If one isn't found, then adjust the minimum allocation
* size to the largest space found.
*/
- if ((ap->datatype & XFS_ALLOC_USERDATA) &&
- xfs_inode_is_filestream(ap->ip)) {
+ if (is_filestream) {
/*
* If there is very little free space before we start a
* filestreams allocation, we're almost guaranteed to fail to
* trying.
*/
if (ap->aeof && !(ap->tp->t_flags & XFS_TRANS_LOWMODE)) {
- error = xfs_bmap_btalloc_at_eof(ap, args, blen, stripe_align);
+ error = xfs_bmap_btalloc_at_eof(ap, args, blen, stripe_align,
+ is_filestream);
if (error)
return error;
if (args->fsbno != NULLFSBLOCK)
return 0;
}
- error = xfs_alloc_vextent(args);
+ if (is_filestream)
+ error = xfs_alloc_vextent(args);
+ else
+ error = xfs_alloc_vextent_start_ag(args, ap->blkno);
if (error)
return error;
if (args->fsbno != NULLFSBLOCK)
*/
if (args->minlen > ap->minlen) {
args->minlen = ap->minlen;
- args->type = XFS_ALLOCTYPE_START_BNO;
- args->fsbno = ap->blkno;
- error = xfs_alloc_vextent(args);
+ error = xfs_alloc_vextent_start_ag(args, ap->blkno);
if (error)
return error;
}
if (!args.wasdel && args.tp->t_blk_res == 0)
return -ENOSPC;
- args.fsbno = be64_to_cpu(start->l);
- args.type = XFS_ALLOCTYPE_START_BNO;
-
/*
* If we are coming here from something like unwritten extent
* conversion, there has been no data extent allocation already done, so
args.minleft = xfs_bmapi_minleft(cur->bc_tp, cur->bc_ino.ip,
cur->bc_ino.whichfork);
- error = xfs_alloc_vextent(&args);
+ error = xfs_alloc_vextent_start_ag(&args, be64_to_cpu(start->l));
if (error)
return error;
* a full btree split. Try again and if
* successful activate the lowspace algorithm.
*/
- args.fsbno = 0;
args.minleft = 0;
- args.type = XFS_ALLOCTYPE_START_BNO;
- error = xfs_alloc_vextent(&args);
+ error = xfs_alloc_vextent_start_ag(&args, 0);
if (error)
return error;
cur->bc_tp->t_flags |= XFS_TRANS_LOWMODE;