| // SPDX-License-Identifier: GPL-2.0 | |
| /* | |
| * Copyright (c) 2000-2005 Silicon Graphics, Inc. | |
| * All Rights Reserved. | |
| */ | |
| #include "xfs.h" | |
| #include "xfs_fs.h" | |
| #include "xfs_shared.h" | |
| #include "xfs_format.h" | |
| #include "xfs_log_format.h" | |
| #include "xfs_trans_resv.h" | |
| #include "xfs_bit.h" | |
| #include "xfs_mount.h" | |
| #include "xfs_inode.h" | |
| #include "xfs_alloc.h" | |
| #include "xfs_bmap.h" | |
| #include "xfs_bmap_btree.h" | |
| #include "xfs_bmap_util.h" | |
| #include "xfs_trans.h" | |
| #include "xfs_trans_space.h" | |
| #include "xfs_icache.h" | |
| #include "xfs_rtalloc.h" | |
| #include "xfs_sb.h" | |
| #include "xfs_rtbitmap.h" | |
| #include "xfs_quota.h" | |
| #include "xfs_log_priv.h" | |
| #include "xfs_health.h" | |
| /* | |
| * Return whether there are any free extents in the size range given | |
| * by low and high, for the bitmap block bbno. | |
| */ | |
| STATIC int | |
| xfs_rtany_summary( | |
| struct xfs_rtalloc_args *args, | |
| int low, /* low log2 extent size */ | |
| int high, /* high log2 extent size */ | |
| xfs_fileoff_t bbno, /* bitmap block number */ | |
| int *maxlog) /* out: max log2 extent size free */ | |
| { | |
| struct xfs_mount *mp = args->mp; | |
| int error; | |
| int log; /* loop counter, log2 of ext. size */ | |
| xfs_suminfo_t sum; /* summary data */ | |
| /* There are no extents at levels >= m_rsum_cache[bbno]. */ | |
| if (mp->m_rsum_cache) { | |
| high = min(high, mp->m_rsum_cache[bbno] - 1); | |
| if (low > high) { | |
| *maxlog = -1; | |
| return 0; | |
| } | |
| } | |
| /* | |
| * Loop over logs of extent sizes. | |
| */ | |
| for (log = high; log >= low; log--) { | |
| /* | |
| * Get one summary datum. | |
| */ | |
| error = xfs_rtget_summary(args, log, bbno, &sum); | |
| if (error) { | |
| return error; | |
| } | |
| /* | |
| * If there are any, return success. | |
| */ | |
| if (sum) { | |
| *maxlog = log; | |
| goto out; | |
| } | |
| } | |
| /* | |
| * Found nothing, return failure. | |
| */ | |
| *maxlog = -1; | |
| out: | |
| /* There were no extents at levels > log. */ | |
| if (mp->m_rsum_cache && log + 1 < mp->m_rsum_cache[bbno]) | |
| mp->m_rsum_cache[bbno] = log + 1; | |
| return 0; | |
| } | |
| /* | |
| * Copy and transform the summary file, given the old and new | |
| * parameters in the mount structures. | |
| */ | |
| STATIC int | |
| xfs_rtcopy_summary( | |
| struct xfs_rtalloc_args *oargs, | |
| struct xfs_rtalloc_args *nargs) | |
| { | |
| xfs_fileoff_t bbno; /* bitmap block number */ | |
| int error; | |
| int log; /* summary level number (log length) */ | |
| xfs_suminfo_t sum; /* summary data */ | |
| for (log = oargs->mp->m_rsumlevels - 1; log >= 0; log--) { | |
| for (bbno = oargs->mp->m_sb.sb_rbmblocks - 1; | |
| (xfs_srtblock_t)bbno >= 0; | |
| bbno--) { | |
| error = xfs_rtget_summary(oargs, log, bbno, &sum); | |
| if (error) | |
| goto out; | |
| if (sum == 0) | |
| continue; | |
| error = xfs_rtmodify_summary(oargs, log, bbno, -sum); | |
| if (error) | |
| goto out; | |
| error = xfs_rtmodify_summary(nargs, log, bbno, sum); | |
| if (error) | |
| goto out; | |
| ASSERT(sum > 0); | |
| } | |
| } | |
| error = 0; | |
| out: | |
| xfs_rtbuf_cache_relse(oargs); | |
| return 0; | |
| } | |
| /* | |
| * Mark an extent specified by start and len allocated. | |
| * Updates all the summary information as well as the bitmap. | |
| */ | |
| STATIC int | |
| xfs_rtallocate_range( | |
| struct xfs_rtalloc_args *args, | |
| xfs_rtxnum_t start, /* start rtext to allocate */ | |
| xfs_rtxlen_t len) /* in/out: summary block number */ | |
| { | |
| struct xfs_mount *mp = args->mp; | |
| xfs_rtxnum_t end; /* end of the allocated rtext */ | |
| int error; | |
| xfs_rtxnum_t postblock = 0; /* first rtext allocated > end */ | |
| xfs_rtxnum_t preblock = 0; /* first rtext allocated < start */ | |
| end = start + len - 1; | |
| /* | |
| * Assume we're allocating out of the middle of a free extent. | |
| * We need to find the beginning and end of the extent so we can | |
| * properly update the summary. | |
| */ | |
| error = xfs_rtfind_back(args, start, &preblock); | |
| if (error) | |
| return error; | |
| /* | |
| * Find the next allocated block (end of free extent). | |
| */ | |
| error = xfs_rtfind_forw(args, end, mp->m_sb.sb_rextents - 1, | |
| &postblock); | |
| if (error) | |
| return error; | |
| /* | |
| * Decrement the summary information corresponding to the entire | |
| * (old) free extent. | |
| */ | |
| error = xfs_rtmodify_summary(args, | |
| xfs_highbit64(postblock + 1 - preblock), | |
| xfs_rtx_to_rbmblock(mp, preblock), -1); | |
| if (error) | |
| return error; | |
| /* | |
| * If there are blocks not being allocated at the front of the | |
| * old extent, add summary data for them to be free. | |
| */ | |
| if (preblock < start) { | |
| error = xfs_rtmodify_summary(args, | |
| xfs_highbit64(start - preblock), | |
| xfs_rtx_to_rbmblock(mp, preblock), 1); | |
| if (error) | |
| return error; | |
| } | |
| /* | |
| * If there are blocks not being allocated at the end of the | |
| * old extent, add summary data for them to be free. | |
| */ | |
| if (postblock > end) { | |
| error = xfs_rtmodify_summary(args, | |
| xfs_highbit64(postblock - end), | |
| xfs_rtx_to_rbmblock(mp, end + 1), 1); | |
| if (error) | |
| return error; | |
| } | |
| /* | |
| * Modify the bitmap to mark this extent allocated. | |
| */ | |
| return xfs_rtmodify_range(args, start, len, 0); | |
| } | |
| /* Reduce @rtxlen until it is a multiple of @prod. */ | |
| static inline xfs_rtxlen_t | |
| xfs_rtalloc_align_len( | |
| xfs_rtxlen_t rtxlen, | |
| xfs_rtxlen_t prod) | |
| { | |
| if (unlikely(prod > 1)) | |
| return rounddown(rtxlen, prod); | |
| return rtxlen; | |
| } | |
| /* | |
| * Make sure we don't run off the end of the rt volume. Be careful that | |
| * adjusting maxlen downwards doesn't cause us to fail the alignment checks. | |
| */ | |
| static inline xfs_rtxlen_t | |
| xfs_rtallocate_clamp_len( | |
| struct xfs_mount *mp, | |
| xfs_rtxnum_t startrtx, | |
| xfs_rtxlen_t rtxlen, | |
| xfs_rtxlen_t prod) | |
| { | |
| xfs_rtxlen_t ret; | |
| ret = min(mp->m_sb.sb_rextents, startrtx + rtxlen) - startrtx; | |
| return xfs_rtalloc_align_len(ret, prod); | |
| } | |
| /* | |
| * 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 *rtx. | |
| * The lengths are all in rtextents. | |
| */ | |
| STATIC int | |
| xfs_rtallocate_extent_block( | |
| struct xfs_rtalloc_args *args, | |
| xfs_fileoff_t bbno, /* bitmap block number */ | |
| xfs_rtxlen_t minlen, /* minimum length to allocate */ | |
| xfs_rtxlen_t maxlen, /* maximum length to allocate */ | |
| xfs_rtxlen_t *len, /* out: actual length allocated */ | |
| xfs_rtxnum_t *nextp, /* out: next rtext to try */ | |
| xfs_rtxlen_t prod, /* extent product factor */ | |
| xfs_rtxnum_t *rtx) /* out: start rtext allocated */ | |
| { | |
| struct xfs_mount *mp = args->mp; | |
| xfs_rtxnum_t besti = -1; /* best rtext found so far */ | |
| xfs_rtxnum_t end; /* last rtext in chunk */ | |
| xfs_rtxnum_t i; /* current rtext trying */ | |
| xfs_rtxnum_t next; /* next rtext to try */ | |
| xfs_rtxlen_t scanlen; /* number of free rtx to look for */ | |
| xfs_rtxlen_t bestlen = 0; /* best length found so far */ | |
| int stat; /* status from internal calls */ | |
| int error; | |
| /* | |
| * Loop over all the extents starting in this bitmap block up to the | |
| * end of the rt volume, looking for one that's long enough. | |
| */ | |
| end = min(mp->m_sb.sb_rextents, xfs_rbmblock_to_rtx(mp, bbno + 1)) - 1; | |
| for (i = xfs_rbmblock_to_rtx(mp, bbno); i <= end; i++) { | |
| /* Make sure we don't scan off the end of the rt volume. */ | |
| scanlen = xfs_rtallocate_clamp_len(mp, i, maxlen, prod); | |
| if (scanlen < minlen) | |
| break; | |
| /* | |
| * See if there's a free extent of scanlen starting at i. | |
| * If it's not so then next will contain the first non-free. | |
| */ | |
| error = xfs_rtcheck_range(args, i, scanlen, 1, &next, &stat); | |
| if (error) | |
| return error; | |
| if (stat) { | |
| /* | |
| * i to scanlen is all free, allocate and return that. | |
| */ | |
| *len = scanlen; | |
| *rtx = 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_rtxnum_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) | |
| break; | |
| error = xfs_rtfind_forw(args, next, end, &i); | |
| if (error) | |
| return error; | |
| } | |
| /* Searched the whole thing & didn't find a maxlen free extent. */ | |
| if (besti == -1) | |
| goto nospace; | |
| /* | |
| * Ensure bestlen is a multiple of prod, but don't return a too-short | |
| * extent. | |
| */ | |
| bestlen = xfs_rtalloc_align_len(bestlen, prod); | |
| if (bestlen < minlen) | |
| goto nospace; | |
| /* | |
| * Pick besti for bestlen & return that. | |
| */ | |
| *len = bestlen; | |
| *rtx = besti; | |
| return 0; | |
| nospace: | |
| /* Allocation failed. Set *nextp to the next block to try. */ | |
| *nextp = next; | |
| return -ENOSPC; | |
| } | |
| /* | |
| * Allocate an extent of length minlen<=len<=maxlen, starting at block | |
| * bno. If we don't get maxlen then use prod to trim the length, if given. | |
| * Returns error; returns starting block in *rtx. | |
| * The lengths are all in rtextents. | |
| */ | |
| STATIC int | |
| xfs_rtallocate_extent_exact( | |
| struct xfs_rtalloc_args *args, | |
| xfs_rtxnum_t start, /* starting rtext number to allocate */ | |
| xfs_rtxlen_t minlen, /* minimum length to allocate */ | |
| xfs_rtxlen_t maxlen, /* maximum length to allocate */ | |
| xfs_rtxlen_t *len, /* out: actual length allocated */ | |
| xfs_rtxlen_t prod, /* extent product factor */ | |
| xfs_rtxnum_t *rtx) /* out: start rtext allocated */ | |
| { | |
| struct xfs_mount *mp = args->mp; | |
| xfs_rtxnum_t next; /* next rtext to try (dummy) */ | |
| xfs_rtxlen_t alloclen; /* candidate length */ | |
| xfs_rtxlen_t scanlen; /* number of free rtx to look for */ | |
| int isfree; /* extent is free */ | |
| int error; | |
| ASSERT(minlen % prod == 0); | |
| ASSERT(maxlen % prod == 0); | |
| /* Make sure we don't run off the end of the rt volume. */ | |
| scanlen = xfs_rtallocate_clamp_len(mp, start, maxlen, prod); | |
| if (scanlen < minlen) | |
| return -ENOSPC; | |
| /* Check if the range in question (for scanlen) is free. */ | |
| error = xfs_rtcheck_range(args, start, scanlen, 1, &next, &isfree); | |
| if (error) | |
| return error; | |
| if (isfree) { | |
| /* start to scanlen is all free; allocate it. */ | |
| *len = scanlen; | |
| *rtx = start; | |
| return 0; | |
| } | |
| /* | |
| * If not, allocate what there is, if it's at least minlen. | |
| */ | |
| alloclen = next - start; | |
| if (alloclen < minlen) | |
| return -ENOSPC; | |
| /* Ensure alloclen is a multiple of prod. */ | |
| alloclen = xfs_rtalloc_align_len(alloclen, prod); | |
| if (alloclen < minlen) | |
| return -ENOSPC; | |
| *len = alloclen; | |
| *rtx = start; | |
| return 0; | |
| } | |
| /* | |
| * Allocate an extent of length minlen<=len<=maxlen, starting as near | |
| * to start as possible. If we don't get maxlen then use prod to trim | |
| * the length, if given. The lengths are all in rtextents. | |
| */ | |
| STATIC int | |
| xfs_rtallocate_extent_near( | |
| struct xfs_rtalloc_args *args, | |
| xfs_rtxnum_t start, /* starting rtext number to allocate */ | |
| xfs_rtxlen_t minlen, /* minimum length to allocate */ | |
| xfs_rtxlen_t maxlen, /* maximum length to allocate */ | |
| xfs_rtxlen_t *len, /* out: actual length allocated */ | |
| xfs_rtxlen_t prod, /* extent product factor */ | |
| xfs_rtxnum_t *rtx) /* out: start rtext allocated */ | |
| { | |
| struct xfs_mount *mp = args->mp; | |
| int maxlog; /* max useful extent from summary */ | |
| xfs_fileoff_t bbno; /* bitmap block number */ | |
| int error; | |
| int i; /* bitmap block offset (loop control) */ | |
| int j; /* secondary loop control */ | |
| int log2len; /* log2 of minlen */ | |
| xfs_rtxnum_t n; /* next rtext to try */ | |
| ASSERT(minlen % prod == 0); | |
| ASSERT(maxlen % prod == 0); | |
| /* | |
| * If the block number given is off the end, silently set it to | |
| * the last block. | |
| */ | |
| if (start >= mp->m_sb.sb_rextents) | |
| start = mp->m_sb.sb_rextents - 1; | |
| /* | |
| * Try the exact allocation first. | |
| */ | |
| error = xfs_rtallocate_extent_exact(args, start, minlen, maxlen, len, | |
| prod, rtx); | |
| if (error != -ENOSPC) | |
| return error; | |
| bbno = xfs_rtx_to_rbmblock(mp, start); | |
| i = 0; | |
| j = -1; | |
| ASSERT(minlen != 0); | |
| log2len = xfs_highbit32(minlen); | |
| /* | |
| * Loop over all bitmap blocks (bbno + i is current block). | |
| */ | |
| for (;;) { | |
| /* | |
| * Get summary information of extents of all useful levels | |
| * starting in this bitmap block. | |
| */ | |
| error = xfs_rtany_summary(args, log2len, mp->m_rsumlevels - 1, | |
| bbno + i, &maxlog); | |
| if (error) | |
| return error; | |
| /* | |
| * If there are any useful extents starting here, try | |
| * allocating one. | |
| */ | |
| if (maxlog >= 0) { | |
| xfs_extlen_t maxavail = | |
| min_t(xfs_rtblock_t, maxlen, | |
| (1ULL << (maxlog + 1)) - 1); | |
| /* | |
| * On the positive side of the starting location. | |
| */ | |
| if (i >= 0) { | |
| /* | |
| * Try to allocate an extent starting in | |
| * this block. | |
| */ | |
| error = xfs_rtallocate_extent_block(args, | |
| bbno + i, minlen, maxavail, len, | |
| &n, prod, rtx); | |
| if (error != -ENOSPC) | |
| return error; | |
| } | |
| /* | |
| * On the negative side of the starting location. | |
| */ | |
| else { /* i < 0 */ | |
| int maxblocks; | |
| /* | |
| * Loop backwards to find the end of the extent | |
| * we found in the realtime summary. | |
| * | |
| * maxblocks is the maximum possible number of | |
| * bitmap blocks from the start of the extent | |
| * to the end of the extent. | |
| */ | |
| if (maxlog == 0) | |
| maxblocks = 0; | |
| else if (maxlog < mp->m_blkbit_log) | |
| maxblocks = 1; | |
| else | |
| maxblocks = 2 << (maxlog - mp->m_blkbit_log); | |
| /* | |
| * We need to check bbno + i + maxblocks down to | |
| * bbno + i. We already checked bbno down to | |
| * bbno + j + 1, so we don't need to check those | |
| * again. | |
| */ | |
| j = min(i + maxblocks, j); | |
| for (; j >= i; j--) { | |
| error = xfs_rtallocate_extent_block(args, | |
| bbno + j, minlen, | |
| maxavail, len, &n, prod, | |
| rtx); | |
| if (error != -ENOSPC) | |
| return error; | |
| } | |
| } | |
| } | |
| /* | |
| * Loop control. If we were on the positive side, and there's | |
| * still more blocks on the negative side, go there. | |
| */ | |
| if (i > 0 && (int)bbno - i >= 0) | |
| i = -i; | |
| /* | |
| * If positive, and no more negative, but there are more | |
| * positive, go there. | |
| */ | |
| else if (i > 0 && (int)bbno + i < mp->m_sb.sb_rbmblocks - 1) | |
| i++; | |
| /* | |
| * If negative or 0 (just started), and there are positive | |
| * blocks to go, go there. The 0 case moves to block 1. | |
| */ | |
| else if (i <= 0 && (int)bbno - i < mp->m_sb.sb_rbmblocks - 1) | |
| i = 1 - i; | |
| /* | |
| * If negative or 0 and there are more negative blocks, | |
| * go there. | |
| */ | |
| else if (i <= 0 && (int)bbno + i > 0) | |
| i--; | |
| /* | |
| * Must be done. Return failure. | |
| */ | |
| else | |
| break; | |
| } | |
| return -ENOSPC; | |
| } | |
| static int | |
| xfs_rtalloc_sumlevel( | |
| struct xfs_rtalloc_args *args, | |
| int l, /* level number */ | |
| xfs_rtxlen_t minlen, /* minimum length to allocate */ | |
| xfs_rtxlen_t maxlen, /* maximum length to allocate */ | |
| xfs_rtxlen_t prod, /* extent product factor */ | |
| xfs_rtxlen_t *len, /* out: actual length allocated */ | |
| xfs_rtxnum_t *rtx) /* out: start rtext allocated */ | |
| { | |
| xfs_fileoff_t i; /* bitmap block number */ | |
| int error; | |
| for (i = 0; i < args->mp->m_sb.sb_rbmblocks; i++) { | |
| xfs_suminfo_t sum; /* summary information for extents */ | |
| xfs_rtxnum_t n; /* next rtext to be tried */ | |
| error = xfs_rtget_summary(args, l, i, &sum); | |
| if (error) | |
| return error; | |
| /* | |
| * Nothing there, on to the next block. | |
| */ | |
| if (!sum) | |
| continue; | |
| /* | |
| * Try allocating the extent. | |
| */ | |
| error = xfs_rtallocate_extent_block(args, i, minlen, maxlen, | |
| len, &n, prod, rtx); | |
| if (error != -ENOSPC) | |
| return error; | |
| /* | |
| * If the "next block to try" returned from the allocator is | |
| * beyond the next bitmap block, skip to that bitmap block. | |
| */ | |
| if (xfs_rtx_to_rbmblock(args->mp, n) > i + 1) | |
| i = xfs_rtx_to_rbmblock(args->mp, n) - 1; | |
| } | |
| return -ENOSPC; | |
| } | |
| /* | |
| * Allocate an extent of length minlen<=len<=maxlen, with no position | |
| * specified. If we don't get maxlen then use prod to trim | |
| * the length, if given. The lengths are all in rtextents. | |
| */ | |
| STATIC int | |
| xfs_rtallocate_extent_size( | |
| struct xfs_rtalloc_args *args, | |
| xfs_rtxlen_t minlen, /* minimum length to allocate */ | |
| xfs_rtxlen_t maxlen, /* maximum length to allocate */ | |
| xfs_rtxlen_t *len, /* out: actual length allocated */ | |
| xfs_rtxlen_t prod, /* extent product factor */ | |
| xfs_rtxnum_t *rtx) /* out: start rtext allocated */ | |
| { | |
| int error; | |
| int l; /* level number (loop control) */ | |
| ASSERT(minlen % prod == 0); | |
| ASSERT(maxlen % prod == 0); | |
| ASSERT(maxlen != 0); | |
| /* | |
| * Loop over all the levels starting with maxlen. | |
| * | |
| * At each level, look at all the bitmap blocks, to see if there are | |
| * extents starting there that are long enough (>= maxlen). | |
| * | |
| * Note, only on the initial level can the allocation fail if the | |
| * summary says there's an extent. | |
| */ | |
| for (l = xfs_highbit32(maxlen); l < args->mp->m_rsumlevels; l++) { | |
| error = xfs_rtalloc_sumlevel(args, l, minlen, maxlen, prod, len, | |
| rtx); | |
| if (error != -ENOSPC) | |
| return error; | |
| } | |
| /* | |
| * Didn't find any maxlen blocks. Try smaller ones, unless we are | |
| * looking for a fixed size extent. | |
| */ | |
| if (minlen > --maxlen) | |
| return -ENOSPC; | |
| ASSERT(minlen != 0); | |
| ASSERT(maxlen != 0); | |
| /* | |
| * Loop over sizes, from maxlen down to minlen. | |
| * | |
| * This time, when we do the allocations, allow smaller ones to succeed, | |
| * but make sure the specified minlen/maxlen are in the possible range | |
| * for this summary level. | |
| */ | |
| for (l = xfs_highbit32(maxlen); l >= xfs_highbit32(minlen); l--) { | |
| error = xfs_rtalloc_sumlevel(args, l, | |
| max_t(xfs_rtxlen_t, minlen, 1 << l), | |
| min_t(xfs_rtxlen_t, maxlen, (1 << (l + 1)) - 1), | |
| prod, len, rtx); | |
| if (error != -ENOSPC) | |
| return error; | |
| } | |
| return -ENOSPC; | |
| } | |
| static int | |
| xfs_alloc_rsum_cache( | |
| struct xfs_mount *mp, | |
| xfs_extlen_t rbmblocks) | |
| { | |
| /* | |
| * The rsum cache is initialized to the maximum value, which is | |
| * trivially an upper bound on the maximum level with any free extents. | |
| */ | |
| mp->m_rsum_cache = kvmalloc(rbmblocks, GFP_KERNEL); | |
| if (!mp->m_rsum_cache) | |
| return -ENOMEM; | |
| memset(mp->m_rsum_cache, -1, rbmblocks); | |
| return 0; | |
| } | |
| /* | |
| * If we changed the rt extent size (meaning there was no rt volume previously) | |
| * and the root directory had EXTSZINHERIT and RTINHERIT set, it's possible | |
| * that the extent size hint on the root directory is no longer congruent with | |
| * the new rt extent size. Log the rootdir inode to fix this. | |
| */ | |
| static int | |
| xfs_growfs_rt_fixup_extsize( | |
| struct xfs_mount *mp) | |
| { | |
| struct xfs_inode *ip = mp->m_rootip; | |
| struct xfs_trans *tp; | |
| int error = 0; | |
| xfs_ilock(ip, XFS_IOLOCK_EXCL); | |
| if (!(ip->i_diflags & XFS_DIFLAG_RTINHERIT) || | |
| !(ip->i_diflags & XFS_DIFLAG_EXTSZINHERIT)) | |
| goto out_iolock; | |
| error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_ichange, 0, 0, false, | |
| &tp); | |
| if (error) | |
| goto out_iolock; | |
| xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); | |
| error = xfs_trans_commit(tp); | |
| xfs_iunlock(ip, XFS_ILOCK_EXCL); | |
| out_iolock: | |
| xfs_iunlock(ip, XFS_IOLOCK_EXCL); | |
| return error; | |
| } | |
| static int | |
| xfs_growfs_rt_bmblock( | |
| struct xfs_mount *mp, | |
| xfs_rfsblock_t nrblocks, | |
| xfs_agblock_t rextsize, | |
| xfs_fileoff_t bmbno) | |
| { | |
| struct xfs_inode *rbmip = mp->m_rbmip; | |
| struct xfs_inode *rsumip = mp->m_rsumip; | |
| struct xfs_rtalloc_args args = { | |
| .mp = mp, | |
| }; | |
| struct xfs_rtalloc_args nargs = { | |
| }; | |
| struct xfs_mount *nmp; | |
| xfs_rfsblock_t nrblocks_step; | |
| xfs_rtbxlen_t freed_rtx; | |
| int error; | |
| nrblocks_step = (bmbno + 1) * NBBY * mp->m_sb.sb_blocksize * rextsize; | |
| nmp = nargs.mp = kmemdup(mp, sizeof(*mp), GFP_KERNEL); | |
| if (!nmp) | |
| return -ENOMEM; | |
| /* | |
| * Calculate new sb and mount fields for this round. | |
| */ | |
| nmp->m_sb.sb_rextsize = rextsize; | |
| xfs_mount_sb_set_rextsize(nmp, &nmp->m_sb); | |
| nmp->m_sb.sb_rbmblocks = bmbno + 1; | |
| nmp->m_sb.sb_rblocks = min(nrblocks, nrblocks_step); | |
| nmp->m_sb.sb_rextents = xfs_rtb_to_rtx(nmp, nmp->m_sb.sb_rblocks); | |
| nmp->m_sb.sb_rextslog = xfs_compute_rextslog(nmp->m_sb.sb_rextents); | |
| nmp->m_rsumlevels = nmp->m_sb.sb_rextslog + 1; | |
| nmp->m_rsumblocks = xfs_rtsummary_blockcount(mp, nmp->m_rsumlevels, | |
| nmp->m_sb.sb_rbmblocks); | |
| /* | |
| * Recompute the growfsrt reservation from the new rsumsize, so that the | |
| * transaction below use the new, potentially larger value. | |
| * */ | |
| xfs_trans_resv_calc(nmp, &nmp->m_resv); | |
| error = xfs_trans_alloc(mp, &M_RES(nmp)->tr_growrtfree, 0, 0, 0, | |
| &args.tp); | |
| if (error) | |
| goto out_free; | |
| nargs.tp = args.tp; | |
| xfs_rtbitmap_lock(mp); | |
| xfs_rtbitmap_trans_join(args.tp); | |
| /* | |
| * Update the bitmap inode's size ondisk and incore. We need to update | |
| * the incore size so that inode inactivation won't punch what it thinks | |
| * are "posteof" blocks. | |
| */ | |
| rbmip->i_disk_size = nmp->m_sb.sb_rbmblocks * nmp->m_sb.sb_blocksize; | |
| i_size_write(VFS_I(rbmip), rbmip->i_disk_size); | |
| xfs_trans_log_inode(args.tp, rbmip, XFS_ILOG_CORE); | |
| /* | |
| * Update the summary inode's size. We need to update the incore size | |
| * so that inode inactivation won't punch what it thinks are "posteof" | |
| * blocks. | |
| */ | |
| rsumip->i_disk_size = nmp->m_rsumblocks * nmp->m_sb.sb_blocksize; | |
| i_size_write(VFS_I(rsumip), rsumip->i_disk_size); | |
| xfs_trans_log_inode(args.tp, rsumip, XFS_ILOG_CORE); | |
| /* | |
| * Copy summary data from old to new sizes when the real size (not | |
| * block-aligned) changes. | |
| */ | |
| if (mp->m_sb.sb_rbmblocks != nmp->m_sb.sb_rbmblocks || | |
| mp->m_rsumlevels != nmp->m_rsumlevels) { | |
| error = xfs_rtcopy_summary(&args, &nargs); | |
| if (error) | |
| goto out_cancel; | |
| } | |
| /* | |
| * Update superblock fields. | |
| */ | |
| if (nmp->m_sb.sb_rextsize != mp->m_sb.sb_rextsize) | |
| xfs_trans_mod_sb(args.tp, XFS_TRANS_SB_REXTSIZE, | |
| nmp->m_sb.sb_rextsize - mp->m_sb.sb_rextsize); | |
| if (nmp->m_sb.sb_rbmblocks != mp->m_sb.sb_rbmblocks) | |
| xfs_trans_mod_sb(args.tp, XFS_TRANS_SB_RBMBLOCKS, | |
| nmp->m_sb.sb_rbmblocks - mp->m_sb.sb_rbmblocks); | |
| if (nmp->m_sb.sb_rblocks != mp->m_sb.sb_rblocks) | |
| xfs_trans_mod_sb(args.tp, XFS_TRANS_SB_RBLOCKS, | |
| nmp->m_sb.sb_rblocks - mp->m_sb.sb_rblocks); | |
| if (nmp->m_sb.sb_rextents != mp->m_sb.sb_rextents) | |
| xfs_trans_mod_sb(args.tp, XFS_TRANS_SB_REXTENTS, | |
| nmp->m_sb.sb_rextents - mp->m_sb.sb_rextents); | |
| if (nmp->m_sb.sb_rextslog != mp->m_sb.sb_rextslog) | |
| xfs_trans_mod_sb(args.tp, XFS_TRANS_SB_REXTSLOG, | |
| nmp->m_sb.sb_rextslog - mp->m_sb.sb_rextslog); | |
| /* | |
| * Free the new extent. | |
| */ | |
| freed_rtx = nmp->m_sb.sb_rextents - mp->m_sb.sb_rextents; | |
| error = xfs_rtfree_range(&nargs, mp->m_sb.sb_rextents, freed_rtx); | |
| xfs_rtbuf_cache_relse(&nargs); | |
| if (error) | |
| goto out_cancel; | |
| /* | |
| * Mark more blocks free in the superblock. | |
| */ | |
| xfs_trans_mod_sb(args.tp, XFS_TRANS_SB_FREXTENTS, freed_rtx); | |
| /* | |
| * Update the calculated values in the real mount structure. | |
| */ | |
| mp->m_rsumlevels = nmp->m_rsumlevels; | |
| mp->m_rsumblocks = nmp->m_rsumblocks; | |
| xfs_mount_sb_set_rextsize(mp, &mp->m_sb); | |
| /* | |
| * Recompute the growfsrt reservation from the new rsumsize. | |
| */ | |
| xfs_trans_resv_calc(mp, &mp->m_resv); | |
| error = xfs_trans_commit(args.tp); | |
| if (error) | |
| goto out_free; | |
| /* | |
| * Ensure the mount RT feature flag is now set. | |
| */ | |
| mp->m_features |= XFS_FEAT_REALTIME; | |
| kfree(nmp); | |
| return 0; | |
| out_cancel: | |
| xfs_trans_cancel(args.tp); | |
| out_free: | |
| kfree(nmp); | |
| return error; | |
| } | |
| /* | |
| * Calculate the last rbmblock currently used. | |
| * | |
| * This also deals with the case where there were no rtextents before. | |
| */ | |
| static xfs_fileoff_t | |
| xfs_last_rt_bmblock( | |
| struct xfs_mount *mp) | |
| { | |
| xfs_fileoff_t bmbno = mp->m_sb.sb_rbmblocks; | |
| /* Skip the current block if it is exactly full. */ | |
| if (xfs_rtx_to_rbmword(mp, mp->m_sb.sb_rextents) != 0) | |
| bmbno--; | |
| return bmbno; | |
| } | |
| /* | |
| * Grow the realtime area of the filesystem. | |
| */ | |
| int | |
| xfs_growfs_rt( | |
| xfs_mount_t *mp, /* mount point for filesystem */ | |
| xfs_growfs_rt_t *in) /* growfs rt input struct */ | |
| { | |
| xfs_fileoff_t bmbno; /* bitmap block number */ | |
| struct xfs_buf *bp; /* temporary buffer */ | |
| int error; /* error return value */ | |
| xfs_extlen_t nrbmblocks; /* new number of rt bitmap blocks */ | |
| xfs_rtxnum_t nrextents; /* new number of realtime extents */ | |
| xfs_extlen_t nrsumblocks; /* new number of summary blocks */ | |
| xfs_extlen_t rbmblocks; /* current number of rt bitmap blocks */ | |
| xfs_extlen_t rsumblocks; /* current number of rt summary blks */ | |
| uint8_t *rsum_cache; /* old summary cache */ | |
| xfs_agblock_t old_rextsize = mp->m_sb.sb_rextsize; | |
| if (!capable(CAP_SYS_ADMIN)) | |
| return -EPERM; | |
| /* Needs to have been mounted with an rt device. */ | |
| if (!XFS_IS_REALTIME_MOUNT(mp)) | |
| return -EINVAL; | |
| if (!mutex_trylock(&mp->m_growlock)) | |
| return -EWOULDBLOCK; | |
| /* | |
| * Mount should fail if the rt bitmap/summary files don't load, but | |
| * we'll check anyway. | |
| */ | |
| error = -EINVAL; | |
| if (!mp->m_rbmip || !mp->m_rsumip) | |
| goto out_unlock; | |
| /* Shrink not supported. */ | |
| if (in->newblocks <= mp->m_sb.sb_rblocks) | |
| goto out_unlock; | |
| /* Can only change rt extent size when adding rt volume. */ | |
| if (mp->m_sb.sb_rblocks > 0 && in->extsize != mp->m_sb.sb_rextsize) | |
| goto out_unlock; | |
| /* Range check the extent size. */ | |
| if (XFS_FSB_TO_B(mp, in->extsize) > XFS_MAX_RTEXTSIZE || | |
| XFS_FSB_TO_B(mp, in->extsize) < XFS_MIN_RTEXTSIZE) | |
| goto out_unlock; | |
| /* Unsupported realtime features. */ | |
| error = -EOPNOTSUPP; | |
| if (xfs_has_rmapbt(mp) || xfs_has_reflink(mp) || xfs_has_quota(mp)) | |
| goto out_unlock; | |
| error = xfs_sb_validate_fsb_count(&mp->m_sb, in->newblocks); | |
| if (error) | |
| goto out_unlock; | |
| /* | |
| * Read in the last block of the device, make sure it exists. | |
| */ | |
| error = xfs_buf_read_uncached(mp->m_rtdev_targp, | |
| XFS_FSB_TO_BB(mp, in->newblocks - 1), | |
| XFS_FSB_TO_BB(mp, 1), 0, &bp, NULL); | |
| if (error) | |
| goto out_unlock; | |
| xfs_buf_relse(bp); | |
| /* | |
| * Calculate new parameters. These are the final values to be reached. | |
| */ | |
| nrextents = div_u64(in->newblocks, in->extsize); | |
| if (nrextents == 0) { | |
| error = -EINVAL; | |
| goto out_unlock; | |
| } | |
| nrbmblocks = xfs_rtbitmap_blockcount(mp, nrextents); | |
| nrsumblocks = xfs_rtsummary_blockcount(mp, | |
| xfs_compute_rextslog(nrextents) + 1, nrbmblocks); | |
| /* | |
| * New summary size can't be more than half the size of | |
| * the log. This prevents us from getting a log overflow, | |
| * since we'll log basically the whole summary file at once. | |
| */ | |
| if (nrsumblocks > (mp->m_sb.sb_logblocks >> 1)) { | |
| error = -EINVAL; | |
| goto out_unlock; | |
| } | |
| /* | |
| * Get the old block counts for bitmap and summary inodes. | |
| * These can't change since other growfs callers are locked out. | |
| */ | |
| rbmblocks = XFS_B_TO_FSB(mp, mp->m_rbmip->i_disk_size); | |
| rsumblocks = XFS_B_TO_FSB(mp, mp->m_rsumip->i_disk_size); | |
| /* | |
| * Allocate space to the bitmap and summary files, as necessary. | |
| */ | |
| error = xfs_rtfile_initialize_blocks(mp->m_rbmip, rbmblocks, | |
| nrbmblocks, NULL); | |
| if (error) | |
| goto out_unlock; | |
| error = xfs_rtfile_initialize_blocks(mp->m_rsumip, rsumblocks, | |
| nrsumblocks, NULL); | |
| if (error) | |
| goto out_unlock; | |
| rsum_cache = mp->m_rsum_cache; | |
| if (nrbmblocks != mp->m_sb.sb_rbmblocks) { | |
| error = xfs_alloc_rsum_cache(mp, nrbmblocks); | |
| if (error) | |
| goto out_unlock; | |
| } | |
| /* Initialize the free space bitmap one bitmap block at a time. */ | |
| for (bmbno = xfs_last_rt_bmblock(mp); bmbno < nrbmblocks; bmbno++) { | |
| error = xfs_growfs_rt_bmblock(mp, in->newblocks, in->extsize, | |
| bmbno); | |
| if (error) | |
| goto out_free; | |
| } | |
| if (old_rextsize != in->extsize) { | |
| error = xfs_growfs_rt_fixup_extsize(mp); | |
| if (error) | |
| goto out_free; | |
| } | |
| /* Update secondary superblocks now the physical grow has completed */ | |
| error = xfs_update_secondary_sbs(mp); | |
| out_free: | |
| /* | |
| * If we had to allocate a new rsum_cache, we either need to free the | |
| * old one (if we succeeded) or free the new one and restore the old one | |
| * (if there was an error). | |
| */ | |
| if (rsum_cache != mp->m_rsum_cache) { | |
| if (error) { | |
| kvfree(mp->m_rsum_cache); | |
| mp->m_rsum_cache = rsum_cache; | |
| } else { | |
| kvfree(rsum_cache); | |
| } | |
| } | |
| out_unlock: | |
| mutex_unlock(&mp->m_growlock); | |
| return error; | |
| } | |
| /* | |
| * Initialize realtime fields in the mount structure. | |
| */ | |
| int /* error */ | |
| xfs_rtmount_init( | |
| struct xfs_mount *mp) /* file system mount structure */ | |
| { | |
| struct xfs_buf *bp; /* buffer for last block of subvolume */ | |
| struct xfs_sb *sbp; /* filesystem superblock copy in mount */ | |
| xfs_daddr_t d; /* address of last block of subvolume */ | |
| int error; | |
| sbp = &mp->m_sb; | |
| if (sbp->sb_rblocks == 0) | |
| return 0; | |
| if (mp->m_rtdev_targp == NULL) { | |
| xfs_warn(mp, | |
| "Filesystem has a realtime volume, use rtdev=device option"); | |
| return -ENODEV; | |
| } | |
| mp->m_rsumlevels = sbp->sb_rextslog + 1; | |
| mp->m_rsumblocks = xfs_rtsummary_blockcount(mp, mp->m_rsumlevels, | |
| mp->m_sb.sb_rbmblocks); | |
| mp->m_rbmip = mp->m_rsumip = NULL; | |
| /* | |
| * Check that the realtime section is an ok size. | |
| */ | |
| d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_rblocks); | |
| if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_rblocks) { | |
| xfs_warn(mp, "realtime mount -- %llu != %llu", | |
| (unsigned long long) XFS_BB_TO_FSB(mp, d), | |
| (unsigned long long) mp->m_sb.sb_rblocks); | |
| return -EFBIG; | |
| } | |
| error = xfs_buf_read_uncached(mp->m_rtdev_targp, | |
| d - XFS_FSB_TO_BB(mp, 1), | |
| XFS_FSB_TO_BB(mp, 1), 0, &bp, NULL); | |
| if (error) { | |
| xfs_warn(mp, "realtime device size check failed"); | |
| return error; | |
| } | |
| xfs_buf_relse(bp); | |
| return 0; | |
| } | |
| static int | |
| xfs_rtalloc_count_frextent( | |
| struct xfs_mount *mp, | |
| struct xfs_trans *tp, | |
| const struct xfs_rtalloc_rec *rec, | |
| void *priv) | |
| { | |
| uint64_t *valp = priv; | |
| *valp += rec->ar_extcount; | |
| return 0; | |
| } | |
| /* | |
| * Reinitialize the number of free realtime extents from the realtime bitmap. | |
| * Callers must ensure that there is no other activity in the filesystem. | |
| */ | |
| int | |
| xfs_rtalloc_reinit_frextents( | |
| struct xfs_mount *mp) | |
| { | |
| uint64_t val = 0; | |
| int error; | |
| xfs_rtbitmap_lock_shared(mp, XFS_RBMLOCK_BITMAP); | |
| error = xfs_rtalloc_query_all(mp, NULL, xfs_rtalloc_count_frextent, | |
| &val); | |
| xfs_rtbitmap_unlock_shared(mp, XFS_RBMLOCK_BITMAP); | |
| if (error) | |
| return error; | |
| spin_lock(&mp->m_sb_lock); | |
| mp->m_sb.sb_frextents = val; | |
| spin_unlock(&mp->m_sb_lock); | |
| percpu_counter_set(&mp->m_frextents, mp->m_sb.sb_frextents); | |
| return 0; | |
| } | |
| /* | |
| * Read in the bmbt of an rt metadata inode so that we never have to load them | |
| * at runtime. This enables the use of shared ILOCKs for rtbitmap scans. Use | |
| * an empty transaction to avoid deadlocking on loops in the bmbt. | |
| */ | |
| static inline int | |
| xfs_rtmount_iread_extents( | |
| struct xfs_inode *ip, | |
| unsigned int lock_class) | |
| { | |
| struct xfs_trans *tp; | |
| int error; | |
| error = xfs_trans_alloc_empty(ip->i_mount, &tp); | |
| if (error) | |
| return error; | |
| xfs_ilock(ip, XFS_ILOCK_EXCL | lock_class); | |
| error = xfs_iread_extents(tp, ip, XFS_DATA_FORK); | |
| if (error) | |
| goto out_unlock; | |
| if (xfs_inode_has_attr_fork(ip)) { | |
| error = xfs_iread_extents(tp, ip, XFS_ATTR_FORK); | |
| if (error) | |
| goto out_unlock; | |
| } | |
| out_unlock: | |
| xfs_iunlock(ip, XFS_ILOCK_EXCL | lock_class); | |
| xfs_trans_cancel(tp); | |
| return error; | |
| } | |
| /* | |
| * Get the bitmap and summary inodes and the summary cache into the mount | |
| * structure at mount time. | |
| */ | |
| int /* error */ | |
| xfs_rtmount_inodes( | |
| xfs_mount_t *mp) /* file system mount structure */ | |
| { | |
| int error; /* error return value */ | |
| xfs_sb_t *sbp; | |
| sbp = &mp->m_sb; | |
| error = xfs_iget(mp, NULL, sbp->sb_rbmino, 0, 0, &mp->m_rbmip); | |
| if (xfs_metadata_is_sick(error)) | |
| xfs_rt_mark_sick(mp, XFS_SICK_RT_BITMAP); | |
| if (error) | |
| return error; | |
| ASSERT(mp->m_rbmip != NULL); | |
| error = xfs_rtmount_iread_extents(mp->m_rbmip, XFS_ILOCK_RTBITMAP); | |
| if (error) | |
| goto out_rele_bitmap; | |
| error = xfs_iget(mp, NULL, sbp->sb_rsumino, 0, 0, &mp->m_rsumip); | |
| if (xfs_metadata_is_sick(error)) | |
| xfs_rt_mark_sick(mp, XFS_SICK_RT_SUMMARY); | |
| if (error) | |
| goto out_rele_bitmap; | |
| ASSERT(mp->m_rsumip != NULL); | |
| error = xfs_rtmount_iread_extents(mp->m_rsumip, XFS_ILOCK_RTSUM); | |
| if (error) | |
| goto out_rele_summary; | |
| error = xfs_alloc_rsum_cache(mp, sbp->sb_rbmblocks); | |
| if (error) | |
| goto out_rele_summary; | |
| return 0; | |
| out_rele_summary: | |
| xfs_irele(mp->m_rsumip); | |
| out_rele_bitmap: | |
| xfs_irele(mp->m_rbmip); | |
| return error; | |
| } | |
| void | |
| xfs_rtunmount_inodes( | |
| struct xfs_mount *mp) | |
| { | |
| kvfree(mp->m_rsum_cache); | |
| if (mp->m_rbmip) | |
| xfs_irele(mp->m_rbmip); | |
| if (mp->m_rsumip) | |
| xfs_irele(mp->m_rsumip); | |
| } | |
| /* | |
| * Pick an extent for allocation at the start of a new realtime file. | |
| * Use the sequence number stored in the atime field of the bitmap inode. | |
| * Translate this to a fraction of the rtextents, and return the product | |
| * of rtextents and the fraction. | |
| * The fraction sequence is 0, 1/2, 1/4, 3/4, 1/8, ..., 7/8, 1/16, ... | |
| */ | |
| static xfs_rtxnum_t | |
| xfs_rtpick_extent( | |
| xfs_mount_t *mp, /* file system mount point */ | |
| xfs_trans_t *tp, /* transaction pointer */ | |
| xfs_rtxlen_t len) /* allocation length (rtextents) */ | |
| { | |
| xfs_rtxnum_t b; /* result rtext */ | |
| int log2; /* log of sequence number */ | |
| uint64_t resid; /* residual after log removed */ | |
| uint64_t seq; /* sequence number of file creation */ | |
| struct timespec64 ts; /* timespec in inode */ | |
| xfs_assert_ilocked(mp->m_rbmip, XFS_ILOCK_EXCL); | |
| ts = inode_get_atime(VFS_I(mp->m_rbmip)); | |
| if (!(mp->m_rbmip->i_diflags & XFS_DIFLAG_NEWRTBM)) { | |
| mp->m_rbmip->i_diflags |= XFS_DIFLAG_NEWRTBM; | |
| seq = 0; | |
| } else { | |
| seq = ts.tv_sec; | |
| } | |
| if ((log2 = xfs_highbit64(seq)) == -1) | |
| b = 0; | |
| else { | |
| resid = seq - (1ULL << log2); | |
| b = (mp->m_sb.sb_rextents * ((resid << 1) + 1ULL)) >> | |
| (log2 + 1); | |
| if (b >= mp->m_sb.sb_rextents) | |
| div64_u64_rem(b, mp->m_sb.sb_rextents, &b); | |
| if (b + len > mp->m_sb.sb_rextents) | |
| b = mp->m_sb.sb_rextents - len; | |
| } | |
| ts.tv_sec = seq + 1; | |
| inode_set_atime_to_ts(VFS_I(mp->m_rbmip), ts); | |
| xfs_trans_log_inode(tp, mp->m_rbmip, XFS_ILOG_CORE); | |
| return b; | |
| } | |
| static void | |
| xfs_rtalloc_align_minmax( | |
| xfs_rtxlen_t *raminlen, | |
| xfs_rtxlen_t *ramaxlen, | |
| xfs_rtxlen_t *prod) | |
| { | |
| xfs_rtxlen_t newmaxlen = *ramaxlen; | |
| xfs_rtxlen_t newminlen = *raminlen; | |
| xfs_rtxlen_t slack; | |
| slack = newmaxlen % *prod; | |
| if (slack) | |
| newmaxlen -= slack; | |
| slack = newminlen % *prod; | |
| if (slack) | |
| newminlen += *prod - slack; | |
| /* | |
| * If adjusting for extent size hint alignment produces an invalid | |
| * min/max len combination, go ahead without it. | |
| */ | |
| if (newmaxlen < newminlen) { | |
| *prod = 1; | |
| return; | |
| } | |
| *ramaxlen = newmaxlen; | |
| *raminlen = newminlen; | |
| } | |
| static int | |
| xfs_rtallocate( | |
| struct xfs_trans *tp, | |
| xfs_rtblock_t bno_hint, | |
| xfs_rtxlen_t minlen, | |
| xfs_rtxlen_t maxlen, | |
| xfs_rtxlen_t prod, | |
| bool wasdel, | |
| bool initial_user_data, | |
| bool *rtlocked, | |
| xfs_rtblock_t *bno, | |
| xfs_extlen_t *blen) | |
| { | |
| struct xfs_rtalloc_args args = { | |
| .mp = tp->t_mountp, | |
| .tp = tp, | |
| }; | |
| xfs_rtxnum_t start = 0; | |
| xfs_rtxnum_t rtx; | |
| xfs_rtxlen_t len = 0; | |
| int error = 0; | |
| /* | |
| * Lock out modifications to both the RT bitmap and summary inodes. | |
| */ | |
| if (!*rtlocked) { | |
| xfs_rtbitmap_lock(args.mp); | |
| xfs_rtbitmap_trans_join(tp); | |
| *rtlocked = true; | |
| } | |
| /* | |
| * For an allocation to an empty file at offset 0, pick an extent that | |
| * will space things out in the rt area. | |
| */ | |
| if (bno_hint) | |
| start = xfs_rtb_to_rtx(args.mp, bno_hint); | |
| else if (initial_user_data) | |
| start = xfs_rtpick_extent(args.mp, tp, maxlen); | |
| if (start) { | |
| error = xfs_rtallocate_extent_near(&args, start, minlen, maxlen, | |
| &len, prod, &rtx); | |
| /* | |
| * If we can't allocate near a specific rt extent, try again | |
| * without locality criteria. | |
| */ | |
| if (error == -ENOSPC) { | |
| xfs_rtbuf_cache_relse(&args); | |
| error = 0; | |
| } | |
| } | |
| if (!error) { | |
| error = xfs_rtallocate_extent_size(&args, minlen, maxlen, &len, | |
| prod, &rtx); | |
| } | |
| if (error) | |
| goto out_release; | |
| error = xfs_rtallocate_range(&args, rtx, len); | |
| if (error) | |
| goto out_release; | |
| xfs_trans_mod_sb(tp, wasdel ? | |
| XFS_TRANS_SB_RES_FREXTENTS : XFS_TRANS_SB_FREXTENTS, | |
| -(long)len); | |
| *bno = xfs_rtx_to_rtb(args.mp, rtx); | |
| *blen = xfs_rtxlen_to_extlen(args.mp, len); | |
| out_release: | |
| xfs_rtbuf_cache_relse(&args); | |
| return error; | |
| } | |
| static int | |
| xfs_rtallocate_align( | |
| struct xfs_bmalloca *ap, | |
| xfs_rtxlen_t *ralen, | |
| xfs_rtxlen_t *raminlen, | |
| xfs_rtxlen_t *prod, | |
| bool *noalign) | |
| { | |
| struct xfs_mount *mp = ap->ip->i_mount; | |
| xfs_fileoff_t orig_offset = ap->offset; | |
| xfs_extlen_t minlen = mp->m_sb.sb_rextsize; | |
| xfs_extlen_t align; /* minimum allocation alignment */ | |
| xfs_extlen_t mod; /* product factor for allocators */ | |
| int error; | |
| if (*noalign) { | |
| align = mp->m_sb.sb_rextsize; | |
| } else { | |
| align = xfs_get_extsz_hint(ap->ip); | |
| if (!align) | |
| align = 1; | |
| if (align == mp->m_sb.sb_rextsize) | |
| *noalign = true; | |
| } | |
| error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev, align, 1, | |
| ap->eof, 0, ap->conv, &ap->offset, &ap->length); | |
| if (error) | |
| return error; | |
| ASSERT(ap->length); | |
| ASSERT(xfs_extlen_to_rtxmod(mp, ap->length) == 0); | |
| /* | |
| * If we shifted the file offset downward to satisfy an extent size | |
| * hint, increase minlen by that amount so that the allocator won't | |
| * give us an allocation that's too short to cover at least one of the | |
| * blocks that the caller asked for. | |
| */ | |
| if (ap->offset != orig_offset) | |
| minlen += orig_offset - ap->offset; | |
| /* | |
| * Set ralen to be the actual requested length in rtextents. | |
| * | |
| * If the old value was close enough to XFS_BMBT_MAX_EXTLEN that | |
| * we rounded up to it, cut it back so it's valid again. | |
| * Note that if it's a really large request (bigger than | |
| * XFS_BMBT_MAX_EXTLEN), we don't hear about that number, and can't | |
| * adjust the starting point to match it. | |
| */ | |
| *ralen = xfs_extlen_to_rtxlen(mp, min(ap->length, XFS_MAX_BMBT_EXTLEN)); | |
| *raminlen = max_t(xfs_rtxlen_t, 1, xfs_extlen_to_rtxlen(mp, minlen)); | |
| ASSERT(*raminlen > 0); | |
| ASSERT(*raminlen <= *ralen); | |
| /* | |
| * Only bother calculating a real prod factor if offset & length are | |
| * perfectly aligned, otherwise it will just get us in trouble. | |
| */ | |
| div_u64_rem(ap->offset, align, &mod); | |
| if (mod || ap->length % align) | |
| *prod = 1; | |
| else | |
| *prod = xfs_extlen_to_rtxlen(mp, align); | |
| if (*prod > 1) | |
| xfs_rtalloc_align_minmax(raminlen, ralen, prod); | |
| return 0; | |
| } | |
| int | |
| xfs_bmap_rtalloc( | |
| struct xfs_bmalloca *ap) | |
| { | |
| xfs_fileoff_t orig_offset = ap->offset; | |
| xfs_rtxlen_t prod = 0; /* product factor for allocators */ | |
| xfs_rtxlen_t ralen = 0; /* realtime allocation length */ | |
| xfs_rtblock_t bno_hint = NULLRTBLOCK; | |
| xfs_extlen_t orig_length = ap->length; | |
| xfs_rtxlen_t raminlen; | |
| bool rtlocked = false; | |
| bool noalign = false; | |
| bool initial_user_data = | |
| ap->datatype & XFS_ALLOC_INITIAL_USER_DATA; | |
| int error; | |
| retry: | |
| error = xfs_rtallocate_align(ap, &ralen, &raminlen, &prod, &noalign); | |
| if (error) | |
| return error; | |
| if (xfs_bmap_adjacent(ap)) | |
| bno_hint = ap->blkno; | |
| error = xfs_rtallocate(ap->tp, bno_hint, raminlen, ralen, prod, | |
| ap->wasdel, initial_user_data, &rtlocked, | |
| &ap->blkno, &ap->length); | |
| if (error == -ENOSPC) { | |
| if (!noalign) { | |
| /* | |
| * We previously enlarged the request length to try to | |
| * satisfy an extent size hint. The allocator didn't | |
| * return anything, so reset the parameters to the | |
| * original values and try again without alignment | |
| * criteria. | |
| */ | |
| ap->offset = orig_offset; | |
| ap->length = orig_length; | |
| noalign = true; | |
| goto retry; | |
| } | |
| ap->blkno = NULLFSBLOCK; | |
| ap->length = 0; | |
| return 0; | |
| } | |
| if (error) | |
| return error; | |
| xfs_bmap_alloc_account(ap); | |
| return 0; | |
| } |