/* * Mark an extent specified by start and len freed. * Updates all the summary information as well as the bitmap. */ int xfs_rtfree_range( xfs_mount_t *mp, /* file system mount point */ xfs_trans_t *tp, /* transaction pointer */ xfs_rtblock_t start, /* starting block to free */ xfs_extlen_t len, /* length to free */ xfs_buf_t **rbpp, /* in/out: summary block buffer */ xfs_fsblock_t *rsb) /* in/out: summary block number */ { xfs_rtblock_t end; /* end of the freed extent */ int error; /* error value */ xfs_rtblock_t postblock; /* first block freed > end */ xfs_rtblock_t preblock; /* first block freed < start */ end = start + len - 1; /* * Modify the bitmap to mark this extent freed. */ error = xfs_rtmodify_range(mp, tp, start, len, 1); if (error) { return error; } /* * Assume we're freeing out of the middle of an allocated extent. * We need to find the beginning and end of the extent so we can * properly update the summary. */ error = xfs_rtfind_back(mp, tp, start, 0, &preblock); if (error) { return error; } /* * Find the next allocated block (end of allocated extent). */ error = xfs_rtfind_forw(mp, tp, end, mp->m_sb.sb_rextents - 1, &postblock); if (error) return error; /* * If there are blocks not being freed at the front of the * old extent, add summary data for them to be allocated. */ if (preblock < start) { error = xfs_rtmodify_summary(mp, tp, XFS_RTBLOCKLOG(start - preblock), XFS_BITTOBLOCK(mp, preblock), -1, rbpp, rsb); if (error) { return error; } } /* * If there are blocks not being freed at the end of the * old extent, add summary data for them to be allocated. */ if (postblock > end) { error = xfs_rtmodify_summary(mp, tp, XFS_RTBLOCKLOG(postblock - end), XFS_BITTOBLOCK(mp, end + 1), -1, rbpp, rsb); if (error) { return error; } } /* * Increment the summary information corresponding to the entire * (new) free extent. */ error = xfs_rtmodify_summary(mp, tp, XFS_RTBLOCKLOG(postblock + 1 - preblock), XFS_BITTOBLOCK(mp, preblock), 1, rbpp, rsb); return error; }
/* * Attempt to allocate an extent minlen<=len<=maxlen starting from * bitmap block bbno. If we don't get maxlen then use prod to trim * the length, if given. Returns error; returns starting block in *rtblock. * The lengths are all in rtextents. */ STATIC int /* error */ xfs_rtallocate_extent_block( xfs_mount_t *mp, /* file system mount point */ xfs_trans_t *tp, /* transaction pointer */ xfs_rtblock_t bbno, /* bitmap block number */ xfs_extlen_t minlen, /* minimum length to allocate */ xfs_extlen_t maxlen, /* maximum length to allocate */ xfs_extlen_t *len, /* out: actual length allocated */ xfs_rtblock_t *nextp, /* out: next block to try */ xfs_buf_t **rbpp, /* in/out: summary block buffer */ xfs_fsblock_t *rsb, /* in/out: summary block number */ xfs_extlen_t prod, /* extent product factor */ xfs_rtblock_t *rtblock) /* out: start block allocated */ { xfs_rtblock_t besti; /* best rtblock found so far */ xfs_rtblock_t bestlen; /* best length found so far */ xfs_rtblock_t end; /* last rtblock in chunk */ int error; /* error value */ xfs_rtblock_t i; /* current rtblock trying */ xfs_rtblock_t next; /* next rtblock to try */ int stat; /* status from internal calls */ /* * Loop over all the extents starting in this bitmap block, * looking for one that's long enough. */ for (i = XFS_BLOCKTOBIT(mp, bbno), besti = -1, bestlen = 0, end = XFS_BLOCKTOBIT(mp, bbno + 1) - 1; i <= end; i++) { /* * See if there's a free extent of maxlen starting at i. * If it's not so then next will contain the first non-free. */ error = xfs_rtcheck_range(mp, tp, i, maxlen, 1, &next, &stat); if (error) { return error; } if (stat) { /* * i for maxlen is all free, allocate and return that. */ error = xfs_rtallocate_range(mp, tp, i, maxlen, rbpp, rsb); if (error) { return error; } *len = maxlen; *rtblock = i; return 0; } /* * In the case where we have a variable-sized allocation * request, figure out how big this free piece is, * and if it's big enough for the minimum, and the best * so far, remember it. */ if (minlen < maxlen) { xfs_rtblock_t thislen; /* this extent size */ thislen = next - i; if (thislen >= minlen && thislen > bestlen) { besti = i; bestlen = thislen; } } /* * If not done yet, find the start of the next free space. */ if (next < end) { error = xfs_rtfind_forw(mp, tp, next, end, &i); if (error) { return error; } } else break; } /* * Searched the whole thing & didn't find a maxlen free extent. */ if (minlen < maxlen && besti != -1) { xfs_extlen_t p; /* amount to trim length by */ /* * If size should be a multiple of prod, make that so. */ if (prod > 1 && (p = do_mod(bestlen, prod))) bestlen -= p; /* * Allocate besti for bestlen & return that. */ error = xfs_rtallocate_range(mp, tp, besti, bestlen, rbpp, rsb); if (error) { return error; } *len = bestlen; *rtblock = besti; return 0; } /* * Allocation failed. Set *nextp to the next block to try. */ *nextp = next; *rtblock = NULLRTBLOCK; return 0; }