~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/xfs/libxfs/xfs_alloc.c

Version: ~ [ linux-5.6.3 ] ~ [ linux-5.5.16 ] ~ [ linux-5.4.31 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.114 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.175 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.218 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.218 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
  4  * All Rights Reserved.
  5  */
  6 #include "xfs.h"
  7 #include "xfs_fs.h"
  8 #include "xfs_format.h"
  9 #include "xfs_log_format.h"
 10 #include "xfs_shared.h"
 11 #include "xfs_trans_resv.h"
 12 #include "xfs_bit.h"
 13 #include "xfs_sb.h"
 14 #include "xfs_mount.h"
 15 #include "xfs_defer.h"
 16 #include "xfs_inode.h"
 17 #include "xfs_btree.h"
 18 #include "xfs_rmap.h"
 19 #include "xfs_alloc_btree.h"
 20 #include "xfs_alloc.h"
 21 #include "xfs_extent_busy.h"
 22 #include "xfs_errortag.h"
 23 #include "xfs_error.h"
 24 #include "xfs_cksum.h"
 25 #include "xfs_trace.h"
 26 #include "xfs_trans.h"
 27 #include "xfs_buf_item.h"
 28 #include "xfs_log.h"
 29 #include "xfs_ag_resv.h"
 30 #include "xfs_bmap.h"
 31 
 32 extern kmem_zone_t      *xfs_bmap_free_item_zone;
 33 
 34 struct workqueue_struct *xfs_alloc_wq;
 35 
 36 #define XFS_ABSDIFF(a,b)        (((a) <= (b)) ? ((b) - (a)) : ((a) - (b)))
 37 
 38 #define XFSA_FIXUP_BNO_OK       1
 39 #define XFSA_FIXUP_CNT_OK       2
 40 
 41 STATIC int xfs_alloc_ag_vextent_exact(xfs_alloc_arg_t *);
 42 STATIC int xfs_alloc_ag_vextent_near(xfs_alloc_arg_t *);
 43 STATIC int xfs_alloc_ag_vextent_size(xfs_alloc_arg_t *);
 44 STATIC int xfs_alloc_ag_vextent_small(xfs_alloc_arg_t *,
 45                 xfs_btree_cur_t *, xfs_agblock_t *, xfs_extlen_t *, int *);
 46 
 47 /*
 48  * Size of the AGFL.  For CRC-enabled filesystes we steal a couple of slots in
 49  * the beginning of the block for a proper header with the location information
 50  * and CRC.
 51  */
 52 unsigned int
 53 xfs_agfl_size(
 54         struct xfs_mount        *mp)
 55 {
 56         unsigned int            size = mp->m_sb.sb_sectsize;
 57 
 58         if (xfs_sb_version_hascrc(&mp->m_sb))
 59                 size -= sizeof(struct xfs_agfl);
 60 
 61         return size / sizeof(xfs_agblock_t);
 62 }
 63 
 64 unsigned int
 65 xfs_refc_block(
 66         struct xfs_mount        *mp)
 67 {
 68         if (xfs_sb_version_hasrmapbt(&mp->m_sb))
 69                 return XFS_RMAP_BLOCK(mp) + 1;
 70         if (xfs_sb_version_hasfinobt(&mp->m_sb))
 71                 return XFS_FIBT_BLOCK(mp) + 1;
 72         return XFS_IBT_BLOCK(mp) + 1;
 73 }
 74 
 75 xfs_extlen_t
 76 xfs_prealloc_blocks(
 77         struct xfs_mount        *mp)
 78 {
 79         if (xfs_sb_version_hasreflink(&mp->m_sb))
 80                 return xfs_refc_block(mp) + 1;
 81         if (xfs_sb_version_hasrmapbt(&mp->m_sb))
 82                 return XFS_RMAP_BLOCK(mp) + 1;
 83         if (xfs_sb_version_hasfinobt(&mp->m_sb))
 84                 return XFS_FIBT_BLOCK(mp) + 1;
 85         return XFS_IBT_BLOCK(mp) + 1;
 86 }
 87 
 88 /*
 89  * In order to avoid ENOSPC-related deadlock caused by out-of-order locking of
 90  * AGF buffer (PV 947395), we place constraints on the relationship among
 91  * actual allocations for data blocks, freelist blocks, and potential file data
 92  * bmap btree blocks. However, these restrictions may result in no actual space
 93  * allocated for a delayed extent, for example, a data block in a certain AG is
 94  * allocated but there is no additional block for the additional bmap btree
 95  * block due to a split of the bmap btree of the file. The result of this may
 96  * lead to an infinite loop when the file gets flushed to disk and all delayed
 97  * extents need to be actually allocated. To get around this, we explicitly set
 98  * aside a few blocks which will not be reserved in delayed allocation.
 99  *
100  * We need to reserve 4 fsbs _per AG_ for the freelist and 4 more to handle a
101  * potential split of the file's bmap btree.
102  */
103 unsigned int
104 xfs_alloc_set_aside(
105         struct xfs_mount        *mp)
106 {
107         return mp->m_sb.sb_agcount * (XFS_ALLOC_AGFL_RESERVE + 4);
108 }
109 
110 /*
111  * When deciding how much space to allocate out of an AG, we limit the
112  * allocation maximum size to the size the AG. However, we cannot use all the
113  * blocks in the AG - some are permanently used by metadata. These
114  * blocks are generally:
115  *      - the AG superblock, AGF, AGI and AGFL
116  *      - the AGF (bno and cnt) and AGI btree root blocks, and optionally
117  *        the AGI free inode and rmap btree root blocks.
118  *      - blocks on the AGFL according to xfs_alloc_set_aside() limits
119  *      - the rmapbt root block
120  *
121  * The AG headers are sector sized, so the amount of space they take up is
122  * dependent on filesystem geometry. The others are all single blocks.
123  */
124 unsigned int
125 xfs_alloc_ag_max_usable(
126         struct xfs_mount        *mp)
127 {
128         unsigned int            blocks;
129 
130         blocks = XFS_BB_TO_FSB(mp, XFS_FSS_TO_BB(mp, 4)); /* ag headers */
131         blocks += XFS_ALLOC_AGFL_RESERVE;
132         blocks += 3;                    /* AGF, AGI btree root blocks */
133         if (xfs_sb_version_hasfinobt(&mp->m_sb))
134                 blocks++;               /* finobt root block */
135         if (xfs_sb_version_hasrmapbt(&mp->m_sb))
136                 blocks++;               /* rmap root block */
137         if (xfs_sb_version_hasreflink(&mp->m_sb))
138                 blocks++;               /* refcount root block */
139 
140         return mp->m_sb.sb_agblocks - blocks;
141 }
142 
143 /*
144  * Lookup the record equal to [bno, len] in the btree given by cur.
145  */
146 STATIC int                              /* error */
147 xfs_alloc_lookup_eq(
148         struct xfs_btree_cur    *cur,   /* btree cursor */
149         xfs_agblock_t           bno,    /* starting block of extent */
150         xfs_extlen_t            len,    /* length of extent */
151         int                     *stat)  /* success/failure */
152 {
153         cur->bc_rec.a.ar_startblock = bno;
154         cur->bc_rec.a.ar_blockcount = len;
155         return xfs_btree_lookup(cur, XFS_LOOKUP_EQ, stat);
156 }
157 
158 /*
159  * Lookup the first record greater than or equal to [bno, len]
160  * in the btree given by cur.
161  */
162 int                             /* error */
163 xfs_alloc_lookup_ge(
164         struct xfs_btree_cur    *cur,   /* btree cursor */
165         xfs_agblock_t           bno,    /* starting block of extent */
166         xfs_extlen_t            len,    /* length of extent */
167         int                     *stat)  /* success/failure */
168 {
169         cur->bc_rec.a.ar_startblock = bno;
170         cur->bc_rec.a.ar_blockcount = len;
171         return xfs_btree_lookup(cur, XFS_LOOKUP_GE, stat);
172 }
173 
174 /*
175  * Lookup the first record less than or equal to [bno, len]
176  * in the btree given by cur.
177  */
178 int                                     /* error */
179 xfs_alloc_lookup_le(
180         struct xfs_btree_cur    *cur,   /* btree cursor */
181         xfs_agblock_t           bno,    /* starting block of extent */
182         xfs_extlen_t            len,    /* length of extent */
183         int                     *stat)  /* success/failure */
184 {
185         cur->bc_rec.a.ar_startblock = bno;
186         cur->bc_rec.a.ar_blockcount = len;
187         return xfs_btree_lookup(cur, XFS_LOOKUP_LE, stat);
188 }
189 
190 /*
191  * Update the record referred to by cur to the value given
192  * by [bno, len].
193  * This either works (return 0) or gets an EFSCORRUPTED error.
194  */
195 STATIC int                              /* error */
196 xfs_alloc_update(
197         struct xfs_btree_cur    *cur,   /* btree cursor */
198         xfs_agblock_t           bno,    /* starting block of extent */
199         xfs_extlen_t            len)    /* length of extent */
200 {
201         union xfs_btree_rec     rec;
202 
203         rec.alloc.ar_startblock = cpu_to_be32(bno);
204         rec.alloc.ar_blockcount = cpu_to_be32(len);
205         return xfs_btree_update(cur, &rec);
206 }
207 
208 /*
209  * Get the data from the pointed-to record.
210  */
211 int                                     /* error */
212 xfs_alloc_get_rec(
213         struct xfs_btree_cur    *cur,   /* btree cursor */
214         xfs_agblock_t           *bno,   /* output: starting block of extent */
215         xfs_extlen_t            *len,   /* output: length of extent */
216         int                     *stat)  /* output: success/failure */
217 {
218         struct xfs_mount        *mp = cur->bc_mp;
219         xfs_agnumber_t          agno = cur->bc_private.a.agno;
220         union xfs_btree_rec     *rec;
221         int                     error;
222 
223         error = xfs_btree_get_rec(cur, &rec, stat);
224         if (error || !(*stat))
225                 return error;
226 
227         *bno = be32_to_cpu(rec->alloc.ar_startblock);
228         *len = be32_to_cpu(rec->alloc.ar_blockcount);
229 
230         if (*len == 0)
231                 goto out_bad_rec;
232 
233         /* check for valid extent range, including overflow */
234         if (!xfs_verify_agbno(mp, agno, *bno))
235                 goto out_bad_rec;
236         if (*bno > *bno + *len)
237                 goto out_bad_rec;
238         if (!xfs_verify_agbno(mp, agno, *bno + *len - 1))
239                 goto out_bad_rec;
240 
241         return 0;
242 
243 out_bad_rec:
244         xfs_warn(mp,
245                 "%s Freespace BTree record corruption in AG %d detected!",
246                 cur->bc_btnum == XFS_BTNUM_BNO ? "Block" : "Size", agno);
247         xfs_warn(mp,
248                 "start block 0x%x block count 0x%x", *bno, *len);
249         return -EFSCORRUPTED;
250 }
251 
252 /*
253  * Compute aligned version of the found extent.
254  * Takes alignment and min length into account.
255  */
256 STATIC bool
257 xfs_alloc_compute_aligned(
258         xfs_alloc_arg_t *args,          /* allocation argument structure */
259         xfs_agblock_t   foundbno,       /* starting block in found extent */
260         xfs_extlen_t    foundlen,       /* length in found extent */
261         xfs_agblock_t   *resbno,        /* result block number */
262         xfs_extlen_t    *reslen,        /* result length */
263         unsigned        *busy_gen)
264 {
265         xfs_agblock_t   bno = foundbno;
266         xfs_extlen_t    len = foundlen;
267         xfs_extlen_t    diff;
268         bool            busy;
269 
270         /* Trim busy sections out of found extent */
271         busy = xfs_extent_busy_trim(args, &bno, &len, busy_gen);
272 
273         /*
274          * If we have a largish extent that happens to start before min_agbno,
275          * see if we can shift it into range...
276          */
277         if (bno < args->min_agbno && bno + len > args->min_agbno) {
278                 diff = args->min_agbno - bno;
279                 if (len > diff) {
280                         bno += diff;
281                         len -= diff;
282                 }
283         }
284 
285         if (args->alignment > 1 && len >= args->minlen) {
286                 xfs_agblock_t   aligned_bno = roundup(bno, args->alignment);
287 
288                 diff = aligned_bno - bno;
289 
290                 *resbno = aligned_bno;
291                 *reslen = diff >= len ? 0 : len - diff;
292         } else {
293                 *resbno = bno;
294                 *reslen = len;
295         }
296 
297         return busy;
298 }
299 
300 /*
301  * Compute best start block and diff for "near" allocations.
302  * freelen >= wantlen already checked by caller.
303  */
304 STATIC xfs_extlen_t                     /* difference value (absolute) */
305 xfs_alloc_compute_diff(
306         xfs_agblock_t   wantbno,        /* target starting block */
307         xfs_extlen_t    wantlen,        /* target length */
308         xfs_extlen_t    alignment,      /* target alignment */
309         int             datatype,       /* are we allocating data? */
310         xfs_agblock_t   freebno,        /* freespace's starting block */
311         xfs_extlen_t    freelen,        /* freespace's length */
312         xfs_agblock_t   *newbnop)       /* result: best start block from free */
313 {
314         xfs_agblock_t   freeend;        /* end of freespace extent */
315         xfs_agblock_t   newbno1;        /* return block number */
316         xfs_agblock_t   newbno2;        /* other new block number */
317         xfs_extlen_t    newlen1=0;      /* length with newbno1 */
318         xfs_extlen_t    newlen2=0;      /* length with newbno2 */
319         xfs_agblock_t   wantend;        /* end of target extent */
320         bool            userdata = xfs_alloc_is_userdata(datatype);
321 
322         ASSERT(freelen >= wantlen);
323         freeend = freebno + freelen;
324         wantend = wantbno + wantlen;
325         /*
326          * We want to allocate from the start of a free extent if it is past
327          * the desired block or if we are allocating user data and the free
328          * extent is before desired block. The second case is there to allow
329          * for contiguous allocation from the remaining free space if the file
330          * grows in the short term.
331          */
332         if (freebno >= wantbno || (userdata && freeend < wantend)) {
333                 if ((newbno1 = roundup(freebno, alignment)) >= freeend)
334                         newbno1 = NULLAGBLOCK;
335         } else if (freeend >= wantend && alignment > 1) {
336                 newbno1 = roundup(wantbno, alignment);
337                 newbno2 = newbno1 - alignment;
338                 if (newbno1 >= freeend)
339                         newbno1 = NULLAGBLOCK;
340                 else
341                         newlen1 = XFS_EXTLEN_MIN(wantlen, freeend - newbno1);
342                 if (newbno2 < freebno)
343                         newbno2 = NULLAGBLOCK;
344                 else
345                         newlen2 = XFS_EXTLEN_MIN(wantlen, freeend - newbno2);
346                 if (newbno1 != NULLAGBLOCK && newbno2 != NULLAGBLOCK) {
347                         if (newlen1 < newlen2 ||
348                             (newlen1 == newlen2 &&
349                              XFS_ABSDIFF(newbno1, wantbno) >
350                              XFS_ABSDIFF(newbno2, wantbno)))
351                                 newbno1 = newbno2;
352                 } else if (newbno2 != NULLAGBLOCK)
353                         newbno1 = newbno2;
354         } else if (freeend >= wantend) {
355                 newbno1 = wantbno;
356         } else if (alignment > 1) {
357                 newbno1 = roundup(freeend - wantlen, alignment);
358                 if (newbno1 > freeend - wantlen &&
359                     newbno1 - alignment >= freebno)
360                         newbno1 -= alignment;
361                 else if (newbno1 >= freeend)
362                         newbno1 = NULLAGBLOCK;
363         } else
364                 newbno1 = freeend - wantlen;
365         *newbnop = newbno1;
366         return newbno1 == NULLAGBLOCK ? 0 : XFS_ABSDIFF(newbno1, wantbno);
367 }
368 
369 /*
370  * Fix up the length, based on mod and prod.
371  * len should be k * prod + mod for some k.
372  * If len is too small it is returned unchanged.
373  * If len hits maxlen it is left alone.
374  */
375 STATIC void
376 xfs_alloc_fix_len(
377         xfs_alloc_arg_t *args)          /* allocation argument structure */
378 {
379         xfs_extlen_t    k;
380         xfs_extlen_t    rlen;
381 
382         ASSERT(args->mod < args->prod);
383         rlen = args->len;
384         ASSERT(rlen >= args->minlen);
385         ASSERT(rlen <= args->maxlen);
386         if (args->prod <= 1 || rlen < args->mod || rlen == args->maxlen ||
387             (args->mod == 0 && rlen < args->prod))
388                 return;
389         k = rlen % args->prod;
390         if (k == args->mod)
391                 return;
392         if (k > args->mod)
393                 rlen = rlen - (k - args->mod);
394         else
395                 rlen = rlen - args->prod + (args->mod - k);
396         /* casts to (int) catch length underflows */
397         if ((int)rlen < (int)args->minlen)
398                 return;
399         ASSERT(rlen >= args->minlen && rlen <= args->maxlen);
400         ASSERT(rlen % args->prod == args->mod);
401         ASSERT(args->pag->pagf_freeblks + args->pag->pagf_flcount >=
402                 rlen + args->minleft);
403         args->len = rlen;
404 }
405 
406 /*
407  * Update the two btrees, logically removing from freespace the extent
408  * starting at rbno, rlen blocks.  The extent is contained within the
409  * actual (current) free extent fbno for flen blocks.
410  * Flags are passed in indicating whether the cursors are set to the
411  * relevant records.
412  */
413 STATIC int                              /* error code */
414 xfs_alloc_fixup_trees(
415         xfs_btree_cur_t *cnt_cur,       /* cursor for by-size btree */
416         xfs_btree_cur_t *bno_cur,       /* cursor for by-block btree */
417         xfs_agblock_t   fbno,           /* starting block of free extent */
418         xfs_extlen_t    flen,           /* length of free extent */
419         xfs_agblock_t   rbno,           /* starting block of returned extent */
420         xfs_extlen_t    rlen,           /* length of returned extent */
421         int             flags)          /* flags, XFSA_FIXUP_... */
422 {
423         int             error;          /* error code */
424         int             i;              /* operation results */
425         xfs_agblock_t   nfbno1;         /* first new free startblock */
426         xfs_agblock_t   nfbno2;         /* second new free startblock */
427         xfs_extlen_t    nflen1=0;       /* first new free length */
428         xfs_extlen_t    nflen2=0;       /* second new free length */
429         struct xfs_mount *mp;
430 
431         mp = cnt_cur->bc_mp;
432 
433         /*
434          * Look up the record in the by-size tree if necessary.
435          */
436         if (flags & XFSA_FIXUP_CNT_OK) {
437 #ifdef DEBUG
438                 if ((error = xfs_alloc_get_rec(cnt_cur, &nfbno1, &nflen1, &i)))
439                         return error;
440                 XFS_WANT_CORRUPTED_RETURN(mp,
441                         i == 1 && nfbno1 == fbno && nflen1 == flen);
442 #endif
443         } else {
444                 if ((error = xfs_alloc_lookup_eq(cnt_cur, fbno, flen, &i)))
445                         return error;
446                 XFS_WANT_CORRUPTED_RETURN(mp, i == 1);
447         }
448         /*
449          * Look up the record in the by-block tree if necessary.
450          */
451         if (flags & XFSA_FIXUP_BNO_OK) {
452 #ifdef DEBUG
453                 if ((error = xfs_alloc_get_rec(bno_cur, &nfbno1, &nflen1, &i)))
454                         return error;
455                 XFS_WANT_CORRUPTED_RETURN(mp,
456                         i == 1 && nfbno1 == fbno && nflen1 == flen);
457 #endif
458         } else {
459                 if ((error = xfs_alloc_lookup_eq(bno_cur, fbno, flen, &i)))
460                         return error;
461                 XFS_WANT_CORRUPTED_RETURN(mp, i == 1);
462         }
463 
464 #ifdef DEBUG
465         if (bno_cur->bc_nlevels == 1 && cnt_cur->bc_nlevels == 1) {
466                 struct xfs_btree_block  *bnoblock;
467                 struct xfs_btree_block  *cntblock;
468 
469                 bnoblock = XFS_BUF_TO_BLOCK(bno_cur->bc_bufs[0]);
470                 cntblock = XFS_BUF_TO_BLOCK(cnt_cur->bc_bufs[0]);
471 
472                 XFS_WANT_CORRUPTED_RETURN(mp,
473                         bnoblock->bb_numrecs == cntblock->bb_numrecs);
474         }
475 #endif
476 
477         /*
478          * Deal with all four cases: the allocated record is contained
479          * within the freespace record, so we can have new freespace
480          * at either (or both) end, or no freespace remaining.
481          */
482         if (rbno == fbno && rlen == flen)
483                 nfbno1 = nfbno2 = NULLAGBLOCK;
484         else if (rbno == fbno) {
485                 nfbno1 = rbno + rlen;
486                 nflen1 = flen - rlen;
487                 nfbno2 = NULLAGBLOCK;
488         } else if (rbno + rlen == fbno + flen) {
489                 nfbno1 = fbno;
490                 nflen1 = flen - rlen;
491                 nfbno2 = NULLAGBLOCK;
492         } else {
493                 nfbno1 = fbno;
494                 nflen1 = rbno - fbno;
495                 nfbno2 = rbno + rlen;
496                 nflen2 = (fbno + flen) - nfbno2;
497         }
498         /*
499          * Delete the entry from the by-size btree.
500          */
501         if ((error = xfs_btree_delete(cnt_cur, &i)))
502                 return error;
503         XFS_WANT_CORRUPTED_RETURN(mp, i == 1);
504         /*
505          * Add new by-size btree entry(s).
506          */
507         if (nfbno1 != NULLAGBLOCK) {
508                 if ((error = xfs_alloc_lookup_eq(cnt_cur, nfbno1, nflen1, &i)))
509                         return error;
510                 XFS_WANT_CORRUPTED_RETURN(mp, i == 0);
511                 if ((error = xfs_btree_insert(cnt_cur, &i)))
512                         return error;
513                 XFS_WANT_CORRUPTED_RETURN(mp, i == 1);
514         }
515         if (nfbno2 != NULLAGBLOCK) {
516                 if ((error = xfs_alloc_lookup_eq(cnt_cur, nfbno2, nflen2, &i)))
517                         return error;
518                 XFS_WANT_CORRUPTED_RETURN(mp, i == 0);
519                 if ((error = xfs_btree_insert(cnt_cur, &i)))
520                         return error;
521                 XFS_WANT_CORRUPTED_RETURN(mp, i == 1);
522         }
523         /*
524          * Fix up the by-block btree entry(s).
525          */
526         if (nfbno1 == NULLAGBLOCK) {
527                 /*
528                  * No remaining freespace, just delete the by-block tree entry.
529                  */
530                 if ((error = xfs_btree_delete(bno_cur, &i)))
531                         return error;
532                 XFS_WANT_CORRUPTED_RETURN(mp, i == 1);
533         } else {
534                 /*
535                  * Update the by-block entry to start later|be shorter.
536                  */
537                 if ((error = xfs_alloc_update(bno_cur, nfbno1, nflen1)))
538                         return error;
539         }
540         if (nfbno2 != NULLAGBLOCK) {
541                 /*
542                  * 2 resulting free entries, need to add one.
543                  */
544                 if ((error = xfs_alloc_lookup_eq(bno_cur, nfbno2, nflen2, &i)))
545                         return error;
546                 XFS_WANT_CORRUPTED_RETURN(mp, i == 0);
547                 if ((error = xfs_btree_insert(bno_cur, &i)))
548                         return error;
549                 XFS_WANT_CORRUPTED_RETURN(mp, i == 1);
550         }
551         return 0;
552 }
553 
554 static xfs_failaddr_t
555 xfs_agfl_verify(
556         struct xfs_buf  *bp)
557 {
558         struct xfs_mount *mp = bp->b_target->bt_mount;
559         struct xfs_agfl *agfl = XFS_BUF_TO_AGFL(bp);
560         int             i;
561 
562         /*
563          * There is no verification of non-crc AGFLs because mkfs does not
564          * initialise the AGFL to zero or NULL. Hence the only valid part of the
565          * AGFL is what the AGF says is active. We can't get to the AGF, so we
566          * can't verify just those entries are valid.
567          */
568         if (!xfs_sb_version_hascrc(&mp->m_sb))
569                 return NULL;
570 
571         if (!uuid_equal(&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid))
572                 return __this_address;
573         if (be32_to_cpu(agfl->agfl_magicnum) != XFS_AGFL_MAGIC)
574                 return __this_address;
575         /*
576          * during growfs operations, the perag is not fully initialised,
577          * so we can't use it for any useful checking. growfs ensures we can't
578          * use it by using uncached buffers that don't have the perag attached
579          * so we can detect and avoid this problem.
580          */
581         if (bp->b_pag && be32_to_cpu(agfl->agfl_seqno) != bp->b_pag->pag_agno)
582                 return __this_address;
583 
584         for (i = 0; i < xfs_agfl_size(mp); i++) {
585                 if (be32_to_cpu(agfl->agfl_bno[i]) != NULLAGBLOCK &&
586                     be32_to_cpu(agfl->agfl_bno[i]) >= mp->m_sb.sb_agblocks)
587                         return __this_address;
588         }
589 
590         if (!xfs_log_check_lsn(mp, be64_to_cpu(XFS_BUF_TO_AGFL(bp)->agfl_lsn)))
591                 return __this_address;
592         return NULL;
593 }
594 
595 static void
596 xfs_agfl_read_verify(
597         struct xfs_buf  *bp)
598 {
599         struct xfs_mount *mp = bp->b_target->bt_mount;
600         xfs_failaddr_t  fa;
601 
602         /*
603          * There is no verification of non-crc AGFLs because mkfs does not
604          * initialise the AGFL to zero or NULL. Hence the only valid part of the
605          * AGFL is what the AGF says is active. We can't get to the AGF, so we
606          * can't verify just those entries are valid.
607          */
608         if (!xfs_sb_version_hascrc(&mp->m_sb))
609                 return;
610 
611         if (!xfs_buf_verify_cksum(bp, XFS_AGFL_CRC_OFF))
612                 xfs_verifier_error(bp, -EFSBADCRC, __this_address);
613         else {
614                 fa = xfs_agfl_verify(bp);
615                 if (fa)
616                         xfs_verifier_error(bp, -EFSCORRUPTED, fa);
617         }
618 }
619 
620 static void
621 xfs_agfl_write_verify(
622         struct xfs_buf  *bp)
623 {
624         struct xfs_mount        *mp = bp->b_target->bt_mount;
625         struct xfs_buf_log_item *bip = bp->b_log_item;
626         xfs_failaddr_t          fa;
627 
628         /* no verification of non-crc AGFLs */
629         if (!xfs_sb_version_hascrc(&mp->m_sb))
630                 return;
631 
632         fa = xfs_agfl_verify(bp);
633         if (fa) {
634                 xfs_verifier_error(bp, -EFSCORRUPTED, fa);
635                 return;
636         }
637 
638         if (bip)
639                 XFS_BUF_TO_AGFL(bp)->agfl_lsn = cpu_to_be64(bip->bli_item.li_lsn);
640 
641         xfs_buf_update_cksum(bp, XFS_AGFL_CRC_OFF);
642 }
643 
644 const struct xfs_buf_ops xfs_agfl_buf_ops = {
645         .name = "xfs_agfl",
646         .verify_read = xfs_agfl_read_verify,
647         .verify_write = xfs_agfl_write_verify,
648         .verify_struct = xfs_agfl_verify,
649 };
650 
651 /*
652  * Read in the allocation group free block array.
653  */
654 int                                     /* error */
655 xfs_alloc_read_agfl(
656         xfs_mount_t     *mp,            /* mount point structure */
657         xfs_trans_t     *tp,            /* transaction pointer */
658         xfs_agnumber_t  agno,           /* allocation group number */
659         xfs_buf_t       **bpp)          /* buffer for the ag free block array */
660 {
661         xfs_buf_t       *bp;            /* return value */
662         int             error;
663 
664         ASSERT(agno != NULLAGNUMBER);
665         error = xfs_trans_read_buf(
666                         mp, tp, mp->m_ddev_targp,
667                         XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)),
668                         XFS_FSS_TO_BB(mp, 1), 0, &bp, &xfs_agfl_buf_ops);
669         if (error)
670                 return error;
671         xfs_buf_set_ref(bp, XFS_AGFL_REF);
672         *bpp = bp;
673         return 0;
674 }
675 
676 STATIC int
677 xfs_alloc_update_counters(
678         struct xfs_trans        *tp,
679         struct xfs_perag        *pag,
680         struct xfs_buf          *agbp,
681         long                    len)
682 {
683         struct xfs_agf          *agf = XFS_BUF_TO_AGF(agbp);
684 
685         pag->pagf_freeblks += len;
686         be32_add_cpu(&agf->agf_freeblks, len);
687 
688         xfs_trans_agblocks_delta(tp, len);
689         if (unlikely(be32_to_cpu(agf->agf_freeblks) >
690                      be32_to_cpu(agf->agf_length)))
691                 return -EFSCORRUPTED;
692 
693         xfs_alloc_log_agf(tp, agbp, XFS_AGF_FREEBLKS);
694         return 0;
695 }
696 
697 /*
698  * Allocation group level functions.
699  */
700 
701 /*
702  * Allocate a variable extent in the allocation group agno.
703  * Type and bno are used to determine where in the allocation group the
704  * extent will start.
705  * Extent's length (returned in *len) will be between minlen and maxlen,
706  * and of the form k * prod + mod unless there's nothing that large.
707  * Return the starting a.g. block, or NULLAGBLOCK if we can't do it.
708  */
709 STATIC int                      /* error */
710 xfs_alloc_ag_vextent(
711         xfs_alloc_arg_t *args)  /* argument structure for allocation */
712 {
713         int             error=0;
714 
715         ASSERT(args->minlen > 0);
716         ASSERT(args->maxlen > 0);
717         ASSERT(args->minlen <= args->maxlen);
718         ASSERT(args->mod < args->prod);
719         ASSERT(args->alignment > 0);
720 
721         /*
722          * Branch to correct routine based on the type.
723          */
724         args->wasfromfl = 0;
725         switch (args->type) {
726         case XFS_ALLOCTYPE_THIS_AG:
727                 error = xfs_alloc_ag_vextent_size(args);
728                 break;
729         case XFS_ALLOCTYPE_NEAR_BNO:
730                 error = xfs_alloc_ag_vextent_near(args);
731                 break;
732         case XFS_ALLOCTYPE_THIS_BNO:
733                 error = xfs_alloc_ag_vextent_exact(args);
734                 break;
735         default:
736                 ASSERT(0);
737                 /* NOTREACHED */
738         }
739 
740         if (error || args->agbno == NULLAGBLOCK)
741                 return error;
742 
743         ASSERT(args->len >= args->minlen);
744         ASSERT(args->len <= args->maxlen);
745         ASSERT(!args->wasfromfl || args->resv != XFS_AG_RESV_AGFL);
746         ASSERT(args->agbno % args->alignment == 0);
747 
748         /* if not file data, insert new block into the reverse map btree */
749         if (!xfs_rmap_should_skip_owner_update(&args->oinfo)) {
750                 error = xfs_rmap_alloc(args->tp, args->agbp, args->agno,
751                                        args->agbno, args->len, &args->oinfo);
752                 if (error)
753                         return error;
754         }
755 
756         if (!args->wasfromfl) {
757                 error = xfs_alloc_update_counters(args->tp, args->pag,
758                                                   args->agbp,
759                                                   -((long)(args->len)));
760                 if (error)
761                         return error;
762 
763                 ASSERT(!xfs_extent_busy_search(args->mp, args->agno,
764                                               args->agbno, args->len));
765         }
766 
767         xfs_ag_resv_alloc_extent(args->pag, args->resv, args);
768 
769         XFS_STATS_INC(args->mp, xs_allocx);
770         XFS_STATS_ADD(args->mp, xs_allocb, args->len);
771         return error;
772 }
773 
774 /*
775  * Allocate a variable extent at exactly agno/bno.
776  * Extent's length (returned in *len) will be between minlen and maxlen,
777  * and of the form k * prod + mod unless there's nothing that large.
778  * Return the starting a.g. block (bno), or NULLAGBLOCK if we can't do it.
779  */
780 STATIC int                      /* error */
781 xfs_alloc_ag_vextent_exact(
782         xfs_alloc_arg_t *args)  /* allocation argument structure */
783 {
784         xfs_btree_cur_t *bno_cur;/* by block-number btree cursor */
785         xfs_btree_cur_t *cnt_cur;/* by count btree cursor */
786         int             error;
787         xfs_agblock_t   fbno;   /* start block of found extent */
788         xfs_extlen_t    flen;   /* length of found extent */
789         xfs_agblock_t   tbno;   /* start block of busy extent */
790         xfs_extlen_t    tlen;   /* length of busy extent */
791         xfs_agblock_t   tend;   /* end block of busy extent */
792         int             i;      /* success/failure of operation */
793         unsigned        busy_gen;
794 
795         ASSERT(args->alignment == 1);
796 
797         /*
798          * Allocate/initialize a cursor for the by-number freespace btree.
799          */
800         bno_cur = xfs_allocbt_init_cursor(args->mp, args->tp, args->agbp,
801                                           args->agno, XFS_BTNUM_BNO);
802 
803         /*
804          * Lookup bno and minlen in the btree (minlen is irrelevant, really).
805          * Look for the closest free block <= bno, it must contain bno
806          * if any free block does.
807          */
808         error = xfs_alloc_lookup_le(bno_cur, args->agbno, args->minlen, &i);
809         if (error)
810                 goto error0;
811         if (!i)
812                 goto not_found;
813 
814         /*
815          * Grab the freespace record.
816          */
817         error = xfs_alloc_get_rec(bno_cur, &fbno, &flen, &i);
818         if (error)
819                 goto error0;
820         XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);
821         ASSERT(fbno <= args->agbno);
822 
823         /*
824          * Check for overlapping busy extents.
825          */
826         tbno = fbno;
827         tlen = flen;
828         xfs_extent_busy_trim(args, &tbno, &tlen, &busy_gen);
829 
830         /*
831          * Give up if the start of the extent is busy, or the freespace isn't
832          * long enough for the minimum request.
833          */
834         if (tbno > args->agbno)
835                 goto not_found;
836         if (tlen < args->minlen)
837                 goto not_found;
838         tend = tbno + tlen;
839         if (tend < args->agbno + args->minlen)
840                 goto not_found;
841 
842         /*
843          * End of extent will be smaller of the freespace end and the
844          * maximal requested end.
845          *
846          * Fix the length according to mod and prod if given.
847          */
848         args->len = XFS_AGBLOCK_MIN(tend, args->agbno + args->maxlen)
849                                                 - args->agbno;
850         xfs_alloc_fix_len(args);
851         ASSERT(args->agbno + args->len <= tend);
852 
853         /*
854          * We are allocating agbno for args->len
855          * Allocate/initialize a cursor for the by-size btree.
856          */
857         cnt_cur = xfs_allocbt_init_cursor(args->mp, args->tp, args->agbp,
858                 args->agno, XFS_BTNUM_CNT);
859         ASSERT(args->agbno + args->len <=
860                 be32_to_cpu(XFS_BUF_TO_AGF(args->agbp)->agf_length));
861         error = xfs_alloc_fixup_trees(cnt_cur, bno_cur, fbno, flen, args->agbno,
862                                       args->len, XFSA_FIXUP_BNO_OK);
863         if (error) {
864                 xfs_btree_del_cursor(cnt_cur, XFS_BTREE_ERROR);
865                 goto error0;
866         }
867 
868         xfs_btree_del_cursor(bno_cur, XFS_BTREE_NOERROR);
869         xfs_btree_del_cursor(cnt_cur, XFS_BTREE_NOERROR);
870 
871         args->wasfromfl = 0;
872         trace_xfs_alloc_exact_done(args);
873         return 0;
874 
875 not_found:
876         /* Didn't find it, return null. */
877         xfs_btree_del_cursor(bno_cur, XFS_BTREE_NOERROR);
878         args->agbno = NULLAGBLOCK;
879         trace_xfs_alloc_exact_notfound(args);
880         return 0;
881 
882 error0:
883         xfs_btree_del_cursor(bno_cur, XFS_BTREE_ERROR);
884         trace_xfs_alloc_exact_error(args);
885         return error;
886 }
887 
888 /*
889  * Search the btree in a given direction via the search cursor and compare
890  * the records found against the good extent we've already found.
891  */
892 STATIC int
893 xfs_alloc_find_best_extent(
894         struct xfs_alloc_arg    *args,  /* allocation argument structure */
895         struct xfs_btree_cur    **gcur, /* good cursor */
896         struct xfs_btree_cur    **scur, /* searching cursor */
897         xfs_agblock_t           gdiff,  /* difference for search comparison */
898         xfs_agblock_t           *sbno,  /* extent found by search */
899         xfs_extlen_t            *slen,  /* extent length */
900         xfs_agblock_t           *sbnoa, /* aligned extent found by search */
901         xfs_extlen_t            *slena, /* aligned extent length */
902         int                     dir)    /* 0 = search right, 1 = search left */
903 {
904         xfs_agblock_t           new;
905         xfs_agblock_t           sdiff;
906         int                     error;
907         int                     i;
908         unsigned                busy_gen;
909 
910         /* The good extent is perfect, no need to  search. */
911         if (!gdiff)
912                 goto out_use_good;
913 
914         /*
915          * Look until we find a better one, run out of space or run off the end.
916          */
917         do {
918                 error = xfs_alloc_get_rec(*scur, sbno, slen, &i);
919                 if (error)
920                         goto error0;
921                 XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);
922                 xfs_alloc_compute_aligned(args, *sbno, *slen,
923                                 sbnoa, slena, &busy_gen);
924 
925                 /*
926                  * The good extent is closer than this one.
927                  */
928                 if (!dir) {
929                         if (*sbnoa > args->max_agbno)
930                                 goto out_use_good;
931                         if (*sbnoa >= args->agbno + gdiff)
932                                 goto out_use_good;
933                 } else {
934                         if (*sbnoa < args->min_agbno)
935                                 goto out_use_good;
936                         if (*sbnoa <= args->agbno - gdiff)
937                                 goto out_use_good;
938                 }
939 
940                 /*
941                  * Same distance, compare length and pick the best.
942                  */
943                 if (*slena >= args->minlen) {
944                         args->len = XFS_EXTLEN_MIN(*slena, args->maxlen);
945                         xfs_alloc_fix_len(args);
946 
947                         sdiff = xfs_alloc_compute_diff(args->agbno, args->len,
948                                                        args->alignment,
949                                                        args->datatype, *sbnoa,
950                                                        *slena, &new);
951 
952                         /*
953                          * Choose closer size and invalidate other cursor.
954                          */
955                         if (sdiff < gdiff)
956                                 goto out_use_search;
957                         goto out_use_good;
958                 }
959 
960                 if (!dir)
961                         error = xfs_btree_increment(*scur, 0, &i);
962                 else
963                         error = xfs_btree_decrement(*scur, 0, &i);
964                 if (error)
965                         goto error0;
966         } while (i);
967 
968 out_use_good:
969         xfs_btree_del_cursor(*scur, XFS_BTREE_NOERROR);
970         *scur = NULL;
971         return 0;
972 
973 out_use_search:
974         xfs_btree_del_cursor(*gcur, XFS_BTREE_NOERROR);
975         *gcur = NULL;
976         return 0;
977 
978 error0:
979         /* caller invalidates cursors */
980         return error;
981 }
982 
983 /*
984  * Allocate a variable extent near bno in the allocation group agno.
985  * Extent's length (returned in len) will be between minlen and maxlen,
986  * and of the form k * prod + mod unless there's nothing that large.
987  * Return the starting a.g. block, or NULLAGBLOCK if we can't do it.
988  */
989 STATIC int                              /* error */
990 xfs_alloc_ag_vextent_near(
991         xfs_alloc_arg_t *args)          /* allocation argument structure */
992 {
993         xfs_btree_cur_t *bno_cur_gt;    /* cursor for bno btree, right side */
994         xfs_btree_cur_t *bno_cur_lt;    /* cursor for bno btree, left side */
995         xfs_btree_cur_t *cnt_cur;       /* cursor for count btree */
996         xfs_agblock_t   gtbno;          /* start bno of right side entry */
997         xfs_agblock_t   gtbnoa;         /* aligned ... */
998         xfs_extlen_t    gtdiff;         /* difference to right side entry */
999         xfs_extlen_t    gtlen;          /* length of right side entry */
1000         xfs_extlen_t    gtlena;         /* aligned ... */
1001         xfs_agblock_t   gtnew;          /* useful start bno of right side */
1002         int             error;          /* error code */
1003         int             i;              /* result code, temporary */
1004         int             j;              /* result code, temporary */
1005         xfs_agblock_t   ltbno;          /* start bno of left side entry */
1006         xfs_agblock_t   ltbnoa;         /* aligned ... */
1007         xfs_extlen_t    ltdiff;         /* difference to left side entry */
1008         xfs_extlen_t    ltlen;          /* length of left side entry */
1009         xfs_extlen_t    ltlena;         /* aligned ... */
1010         xfs_agblock_t   ltnew;          /* useful start bno of left side */
1011         xfs_extlen_t    rlen;           /* length of returned extent */
1012         bool            busy;
1013         unsigned        busy_gen;
1014 #ifdef DEBUG
1015         /*
1016          * Randomly don't execute the first algorithm.
1017          */
1018         int             dofirst;        /* set to do first algorithm */
1019 
1020         dofirst = prandom_u32() & 1;
1021 #endif
1022 
1023         /* handle unitialized agbno range so caller doesn't have to */
1024         if (!args->min_agbno && !args->max_agbno)
1025                 args->max_agbno = args->mp->m_sb.sb_agblocks - 1;
1026         ASSERT(args->min_agbno <= args->max_agbno);
1027 
1028         /* clamp agbno to the range if it's outside */
1029         if (args->agbno < args->min_agbno)
1030                 args->agbno = args->min_agbno;
1031         if (args->agbno > args->max_agbno)
1032                 args->agbno = args->max_agbno;
1033 
1034 restart:
1035         bno_cur_lt = NULL;
1036         bno_cur_gt = NULL;
1037         ltlen = 0;
1038         gtlena = 0;
1039         ltlena = 0;
1040         busy = false;
1041 
1042         /*
1043          * Get a cursor for the by-size btree.
1044          */
1045         cnt_cur = xfs_allocbt_init_cursor(args->mp, args->tp, args->agbp,
1046                 args->agno, XFS_BTNUM_CNT);
1047 
1048         /*
1049          * See if there are any free extents as big as maxlen.
1050          */
1051         if ((error = xfs_alloc_lookup_ge(cnt_cur, 0, args->maxlen, &i)))
1052                 goto error0;
1053         /*
1054          * If none, then pick up the last entry in the tree unless the
1055          * tree is empty.
1056          */
1057         if (!i) {
1058                 if ((error = xfs_alloc_ag_vextent_small(args, cnt_cur, &ltbno,
1059                                 &ltlen, &i)))
1060                         goto error0;
1061                 if (i == 0 || ltlen == 0) {
1062                         xfs_btree_del_cursor(cnt_cur, XFS_BTREE_NOERROR);
1063                         trace_xfs_alloc_near_noentry(args);
1064                         return 0;
1065                 }
1066                 ASSERT(i == 1);
1067         }
1068         args->wasfromfl = 0;
1069 
1070         /*
1071          * First algorithm.
1072          * If the requested extent is large wrt the freespaces available
1073          * in this a.g., then the cursor will be pointing to a btree entry
1074          * near the right edge of the tree.  If it's in the last btree leaf
1075          * block, then we just examine all the entries in that block
1076          * that are big enough, and pick the best one.
1077          * This is written as a while loop so we can break out of it,
1078          * but we never loop back to the top.
1079          */
1080         while (xfs_btree_islastblock(cnt_cur, 0)) {
1081                 xfs_extlen_t    bdiff;
1082                 int             besti=0;
1083                 xfs_extlen_t    blen=0;
1084                 xfs_agblock_t   bnew=0;
1085 
1086 #ifdef DEBUG
1087                 if (dofirst)
1088                         break;
1089 #endif
1090                 /*
1091                  * Start from the entry that lookup found, sequence through
1092                  * all larger free blocks.  If we're actually pointing at a
1093                  * record smaller than maxlen, go to the start of this block,
1094                  * and skip all those smaller than minlen.
1095                  */
1096                 if (ltlen || args->alignment > 1) {
1097                         cnt_cur->bc_ptrs[0] = 1;
1098                         do {
1099                                 if ((error = xfs_alloc_get_rec(cnt_cur, &ltbno,
1100                                                 &ltlen, &i)))
1101                                         goto error0;
1102                                 XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);
1103                                 if (ltlen >= args->minlen)
1104                                         break;
1105                                 if ((error = xfs_btree_increment(cnt_cur, 0, &i)))
1106                                         goto error0;
1107                         } while (i);
1108                         ASSERT(ltlen >= args->minlen);
1109                         if (!i)
1110                                 break;
1111                 }
1112                 i = cnt_cur->bc_ptrs[0];
1113                 for (j = 1, blen = 0, bdiff = 0;
1114                      !error && j && (blen < args->maxlen || bdiff > 0);
1115                      error = xfs_btree_increment(cnt_cur, 0, &j)) {
1116                         /*
1117                          * For each entry, decide if it's better than
1118                          * the previous best entry.
1119                          */
1120                         if ((error = xfs_alloc_get_rec(cnt_cur, &ltbno, &ltlen, &i)))
1121                                 goto error0;
1122                         XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);
1123                         busy = xfs_alloc_compute_aligned(args, ltbno, ltlen,
1124                                         &ltbnoa, &ltlena, &busy_gen);
1125                         if (ltlena < args->minlen)
1126                                 continue;
1127                         if (ltbnoa < args->min_agbno || ltbnoa > args->max_agbno)
1128                                 continue;
1129                         args->len = XFS_EXTLEN_MIN(ltlena, args->maxlen);
1130                         xfs_alloc_fix_len(args);
1131                         ASSERT(args->len >= args->minlen);
1132                         if (args->len < blen)
1133                                 continue;
1134                         ltdiff = xfs_alloc_compute_diff(args->agbno, args->len,
1135                                 args->alignment, args->datatype, ltbnoa,
1136                                 ltlena, &ltnew);
1137                         if (ltnew != NULLAGBLOCK &&
1138                             (args->len > blen || ltdiff < bdiff)) {
1139                                 bdiff = ltdiff;
1140                                 bnew = ltnew;
1141                                 blen = args->len;
1142                                 besti = cnt_cur->bc_ptrs[0];
1143                         }
1144                 }
1145                 /*
1146                  * It didn't work.  We COULD be in a case where
1147                  * there's a good record somewhere, so try again.
1148                  */
1149                 if (blen == 0)
1150                         break;
1151                 /*
1152                  * Point at the best entry, and retrieve it again.
1153                  */
1154                 cnt_cur->bc_ptrs[0] = besti;
1155                 if ((error = xfs_alloc_get_rec(cnt_cur, &ltbno, &ltlen, &i)))
1156                         goto error0;
1157                 XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);
1158                 ASSERT(ltbno + ltlen <= be32_to_cpu(XFS_BUF_TO_AGF(args->agbp)->agf_length));
1159                 args->len = blen;
1160 
1161                 /*
1162                  * We are allocating starting at bnew for blen blocks.
1163                  */
1164                 args->agbno = bnew;
1165                 ASSERT(bnew >= ltbno);
1166                 ASSERT(bnew + blen <= ltbno + ltlen);
1167                 /*
1168                  * Set up a cursor for the by-bno tree.
1169                  */
1170                 bno_cur_lt = xfs_allocbt_init_cursor(args->mp, args->tp,
1171                         args->agbp, args->agno, XFS_BTNUM_BNO);
1172                 /*
1173                  * Fix up the btree entries.
1174                  */
1175                 if ((error = xfs_alloc_fixup_trees(cnt_cur, bno_cur_lt, ltbno,
1176                                 ltlen, bnew, blen, XFSA_FIXUP_CNT_OK)))
1177                         goto error0;
1178                 xfs_btree_del_cursor(cnt_cur, XFS_BTREE_NOERROR);
1179                 xfs_btree_del_cursor(bno_cur_lt, XFS_BTREE_NOERROR);
1180 
1181                 trace_xfs_alloc_near_first(args);
1182                 return 0;
1183         }
1184         /*
1185          * Second algorithm.
1186          * Search in the by-bno tree to the left and to the right
1187          * simultaneously, until in each case we find a space big enough,
1188          * or run into the edge of the tree.  When we run into the edge,
1189          * we deallocate that cursor.
1190          * If both searches succeed, we compare the two spaces and pick
1191          * the better one.
1192          * With alignment, it's possible for both to fail; the upper
1193          * level algorithm that picks allocation groups for allocations
1194          * is not supposed to do this.
1195          */
1196         /*
1197          * Allocate and initialize the cursor for the leftward search.
1198          */
1199         bno_cur_lt = xfs_allocbt_init_cursor(args->mp, args->tp, args->agbp,
1200                 args->agno, XFS_BTNUM_BNO);
1201         /*
1202          * Lookup <= bno to find the leftward search's starting point.
1203          */
1204         if ((error = xfs_alloc_lookup_le(bno_cur_lt, args->agbno, args->maxlen, &i)))
1205                 goto error0;
1206         if (!i) {
1207                 /*
1208                  * Didn't find anything; use this cursor for the rightward
1209                  * search.
1210                  */
1211                 bno_cur_gt = bno_cur_lt;
1212                 bno_cur_lt = NULL;
1213         }
1214         /*
1215          * Found something.  Duplicate the cursor for the rightward search.
1216          */
1217         else if ((error = xfs_btree_dup_cursor(bno_cur_lt, &bno_cur_gt)))
1218                 goto error0;
1219         /*
1220          * Increment the cursor, so we will point at the entry just right
1221          * of the leftward entry if any, or to the leftmost entry.
1222          */
1223         if ((error = xfs_btree_increment(bno_cur_gt, 0, &i)))
1224                 goto error0;
1225         if (!i) {
1226                 /*
1227                  * It failed, there are no rightward entries.
1228                  */
1229                 xfs_btree_del_cursor(bno_cur_gt, XFS_BTREE_NOERROR);
1230                 bno_cur_gt = NULL;
1231         }
1232         /*
1233          * Loop going left with the leftward cursor, right with the
1234          * rightward cursor, until either both directions give up or
1235          * we find an entry at least as big as minlen.
1236          */
1237         do {
1238                 if (bno_cur_lt) {
1239                         if ((error = xfs_alloc_get_rec(bno_cur_lt, &ltbno, &ltlen, &i)))
1240                                 goto error0;
1241                         XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);
1242                         busy |= xfs_alloc_compute_aligned(args, ltbno, ltlen,
1243                                         &ltbnoa, &ltlena, &busy_gen);
1244                         if (ltlena >= args->minlen && ltbnoa >= args->min_agbno)
1245                                 break;
1246                         if ((error = xfs_btree_decrement(bno_cur_lt, 0, &i)))
1247                                 goto error0;
1248                         if (!i || ltbnoa < args->min_agbno) {
1249                                 xfs_btree_del_cursor(bno_cur_lt,
1250                                                      XFS_BTREE_NOERROR);
1251                                 bno_cur_lt = NULL;
1252                         }
1253                 }
1254                 if (bno_cur_gt) {
1255                         if ((error = xfs_alloc_get_rec(bno_cur_gt, &gtbno, &gtlen, &i)))
1256                                 goto error0;
1257                         XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);
1258                         busy |= xfs_alloc_compute_aligned(args, gtbno, gtlen,
1259                                         &gtbnoa, &gtlena, &busy_gen);
1260                         if (gtlena >= args->minlen && gtbnoa <= args->max_agbno)
1261                                 break;
1262                         if ((error = xfs_btree_increment(bno_cur_gt, 0, &i)))
1263                                 goto error0;
1264                         if (!i || gtbnoa > args->max_agbno) {
1265                                 xfs_btree_del_cursor(bno_cur_gt,
1266                                                      XFS_BTREE_NOERROR);
1267                                 bno_cur_gt = NULL;
1268                         }
1269                 }
1270         } while (bno_cur_lt || bno_cur_gt);
1271 
1272         /*
1273          * Got both cursors still active, need to find better entry.
1274          */
1275         if (bno_cur_lt && bno_cur_gt) {
1276                 if (ltlena >= args->minlen) {
1277                         /*
1278                          * Left side is good, look for a right side entry.
1279                          */
1280                         args->len = XFS_EXTLEN_MIN(ltlena, args->maxlen);
1281                         xfs_alloc_fix_len(args);
1282                         ltdiff = xfs_alloc_compute_diff(args->agbno, args->len,
1283                                 args->alignment, args->datatype, ltbnoa,
1284                                 ltlena, &ltnew);
1285 
1286                         error = xfs_alloc_find_best_extent(args,
1287                                                 &bno_cur_lt, &bno_cur_gt,
1288                                                 ltdiff, &gtbno, &gtlen,
1289                                                 &gtbnoa, &gtlena,
1290                                                 0 /* search right */);
1291                 } else {
1292                         ASSERT(gtlena >= args->minlen);
1293 
1294                         /*
1295                          * Right side is good, look for a left side entry.
1296                          */
1297                         args->len = XFS_EXTLEN_MIN(gtlena, args->maxlen);
1298                         xfs_alloc_fix_len(args);
1299                         gtdiff = xfs_alloc_compute_diff(args->agbno, args->len,
1300                                 args->alignment, args->datatype, gtbnoa,
1301                                 gtlena, &gtnew);
1302 
1303                         error = xfs_alloc_find_best_extent(args,
1304                                                 &bno_cur_gt, &bno_cur_lt,
1305                                                 gtdiff, &ltbno, &ltlen,
1306                                                 &ltbnoa, &ltlena,
1307                                                 1 /* search left */);
1308                 }
1309 
1310                 if (error)
1311                         goto error0;
1312         }
1313 
1314         /*
1315          * If we couldn't get anything, give up.
1316          */
1317         if (bno_cur_lt == NULL && bno_cur_gt == NULL) {
1318                 xfs_btree_del_cursor(cnt_cur, XFS_BTREE_NOERROR);
1319 
1320                 if (busy) {
1321                         trace_xfs_alloc_near_busy(args);
1322                         xfs_extent_busy_flush(args->mp, args->pag, busy_gen);
1323                         goto restart;
1324                 }
1325                 trace_xfs_alloc_size_neither(args);
1326                 args->agbno = NULLAGBLOCK;
1327                 return 0;
1328         }
1329 
1330         /*
1331          * At this point we have selected a freespace entry, either to the
1332          * left or to the right.  If it's on the right, copy all the
1333          * useful variables to the "left" set so we only have one
1334          * copy of this code.
1335          */
1336         if (bno_cur_gt) {
1337                 bno_cur_lt = bno_cur_gt;
1338                 bno_cur_gt = NULL;
1339                 ltbno = gtbno;
1340                 ltbnoa = gtbnoa;
1341                 ltlen = gtlen;
1342                 ltlena = gtlena;
1343                 j = 1;
1344         } else
1345                 j = 0;
1346 
1347         /*
1348          * Fix up the length and compute the useful address.
1349          */
1350         args->len = XFS_EXTLEN_MIN(ltlena, args->maxlen);
1351         xfs_alloc_fix_len(args);
1352         rlen = args->len;
1353         (void)xfs_alloc_compute_diff(args->agbno, rlen, args->alignment,
1354                                      args->datatype, ltbnoa, ltlena, &ltnew);
1355         ASSERT(ltnew >= ltbno);
1356         ASSERT(ltnew + rlen <= ltbnoa + ltlena);
1357         ASSERT(ltnew + rlen <= be32_to_cpu(XFS_BUF_TO_AGF(args->agbp)->agf_length));
1358         ASSERT(ltnew >= args->min_agbno && ltnew <= args->max_agbno);
1359         args->agbno = ltnew;
1360 
1361         if ((error = xfs_alloc_fixup_trees(cnt_cur, bno_cur_lt, ltbno, ltlen,
1362                         ltnew, rlen, XFSA_FIXUP_BNO_OK)))
1363                 goto error0;
1364 
1365         if (j)
1366                 trace_xfs_alloc_near_greater(args);
1367         else
1368                 trace_xfs_alloc_near_lesser(args);
1369 
1370         xfs_btree_del_cursor(cnt_cur, XFS_BTREE_NOERROR);
1371         xfs_btree_del_cursor(bno_cur_lt, XFS_BTREE_NOERROR);
1372         return 0;
1373 
1374  error0:
1375         trace_xfs_alloc_near_error(args);
1376         if (cnt_cur != NULL)
1377                 xfs_btree_del_cursor(cnt_cur, XFS_BTREE_ERROR);
1378         if (bno_cur_lt != NULL)
1379                 xfs_btree_del_cursor(bno_cur_lt, XFS_BTREE_ERROR);
1380         if (bno_cur_gt != NULL)
1381                 xfs_btree_del_cursor(bno_cur_gt, XFS_BTREE_ERROR);
1382         return error;
1383 }
1384 
1385 /*
1386  * Allocate a variable extent anywhere in the allocation group agno.
1387  * Extent's length (returned in len) will be between minlen and maxlen,
1388  * and of the form k * prod + mod unless there's nothing that large.
1389  * Return the starting a.g. block, or NULLAGBLOCK if we can't do it.
1390  */
1391 STATIC int                              /* error */
1392 xfs_alloc_ag_vextent_size(
1393         xfs_alloc_arg_t *args)          /* allocation argument structure */
1394 {
1395         xfs_btree_cur_t *bno_cur;       /* cursor for bno btree */
1396         xfs_btree_cur_t *cnt_cur;       /* cursor for cnt btree */
1397         int             error;          /* error result */
1398         xfs_agblock_t   fbno;           /* start of found freespace */
1399         xfs_extlen_t    flen;           /* length of found freespace */
1400         int             i;              /* temp status variable */
1401         xfs_agblock_t   rbno;           /* returned block number */
1402         xfs_extlen_t    rlen;           /* length of returned extent */
1403         bool            busy;
1404         unsigned        busy_gen;
1405 
1406 restart:
1407         /*
1408          * Allocate and initialize a cursor for the by-size btree.
1409          */
1410         cnt_cur = xfs_allocbt_init_cursor(args->mp, args->tp, args->agbp,
1411                 args->agno, XFS_BTNUM_CNT);
1412         bno_cur = NULL;
1413         busy = false;
1414 
1415         /*
1416          * Look for an entry >= maxlen+alignment-1 blocks.
1417          */
1418         if ((error = xfs_alloc_lookup_ge(cnt_cur, 0,
1419                         args->maxlen + args->alignment - 1, &i)))
1420                 goto error0;
1421 
1422         /*
1423          * If none then we have to settle for a smaller extent. In the case that
1424          * there are no large extents, this will return the last entry in the
1425          * tree unless the tree is empty. In the case that there are only busy
1426          * large extents, this will return the largest small extent unless there
1427          * are no smaller extents available.
1428          */
1429         if (!i) {
1430                 error = xfs_alloc_ag_vextent_small(args, cnt_cur,
1431                                                    &fbno, &flen, &i);
1432                 if (error)
1433                         goto error0;
1434                 if (i == 0 || flen == 0) {
1435                         xfs_btree_del_cursor(cnt_cur, XFS_BTREE_NOERROR);
1436                         trace_xfs_alloc_size_noentry(args);
1437                         return 0;
1438                 }
1439                 ASSERT(i == 1);
1440                 busy = xfs_alloc_compute_aligned(args, fbno, flen, &rbno,
1441                                 &rlen, &busy_gen);
1442         } else {
1443                 /*
1444                  * Search for a non-busy extent that is large enough.
1445                  */
1446                 for (;;) {
1447                         error = xfs_alloc_get_rec(cnt_cur, &fbno, &flen, &i);
1448                         if (error)
1449                                 goto error0;
1450                         XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);
1451 
1452                         busy = xfs_alloc_compute_aligned(args, fbno, flen,
1453                                         &rbno, &rlen, &busy_gen);
1454 
1455                         if (rlen >= args->maxlen)
1456                                 break;
1457 
1458                         error = xfs_btree_increment(cnt_cur, 0, &i);
1459                         if (error)
1460                                 goto error0;
1461                         if (i == 0) {
1462                                 /*
1463                                  * Our only valid extents must have been busy.
1464                                  * Make it unbusy by forcing the log out and
1465                                  * retrying.
1466                                  */
1467                                 xfs_btree_del_cursor(cnt_cur,
1468                                                      XFS_BTREE_NOERROR);
1469                                 trace_xfs_alloc_size_busy(args);
1470                                 xfs_extent_busy_flush(args->mp,
1471                                                         args->pag, busy_gen);
1472                                 goto restart;
1473                         }
1474                 }
1475         }
1476 
1477         /*
1478          * In the first case above, we got the last entry in the
1479          * by-size btree.  Now we check to see if the space hits maxlen
1480          * once aligned; if not, we search left for something better.
1481          * This can't happen in the second case above.
1482          */
1483         rlen = XFS_EXTLEN_MIN(args->maxlen, rlen);
1484         XFS_WANT_CORRUPTED_GOTO(args->mp, rlen == 0 ||
1485                         (rlen <= flen && rbno + rlen <= fbno + flen), error0);
1486         if (rlen < args->maxlen) {
1487                 xfs_agblock_t   bestfbno;
1488                 xfs_extlen_t    bestflen;
1489                 xfs_agblock_t   bestrbno;
1490                 xfs_extlen_t    bestrlen;
1491 
1492                 bestrlen = rlen;
1493                 bestrbno = rbno;
1494                 bestflen = flen;
1495                 bestfbno = fbno;
1496                 for (;;) {
1497                         if ((error = xfs_btree_decrement(cnt_cur, 0, &i)))
1498                                 goto error0;
1499                         if (i == 0)
1500                                 break;
1501                         if ((error = xfs_alloc_get_rec(cnt_cur, &fbno, &flen,
1502                                         &i)))
1503                                 goto error0;
1504                         XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);
1505                         if (flen < bestrlen)
1506                                 break;
1507                         busy = xfs_alloc_compute_aligned(args, fbno, flen,
1508                                         &rbno, &rlen, &busy_gen);
1509                         rlen = XFS_EXTLEN_MIN(args->maxlen, rlen);
1510                         XFS_WANT_CORRUPTED_GOTO(args->mp, rlen == 0 ||
1511                                 (rlen <= flen && rbno + rlen <= fbno + flen),
1512                                 error0);
1513                         if (rlen > bestrlen) {
1514                                 bestrlen = rlen;
1515                                 bestrbno = rbno;
1516                                 bestflen = flen;
1517                                 bestfbno = fbno;
1518                                 if (rlen == args->maxlen)
1519                                         break;
1520                         }
1521                 }
1522                 if ((error = xfs_alloc_lookup_eq(cnt_cur, bestfbno, bestflen,
1523                                 &i)))
1524                         goto error0;
1525                 XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);
1526                 rlen = bestrlen;
1527                 rbno = bestrbno;
1528                 flen = bestflen;
1529                 fbno = bestfbno;
1530         }
1531         args->wasfromfl = 0;
1532         /*
1533          * Fix up the length.
1534          */
1535         args->len = rlen;
1536         if (rlen < args->minlen) {
1537                 if (busy) {
1538                         xfs_btree_del_cursor(cnt_cur, XFS_BTREE_NOERROR);
1539                         trace_xfs_alloc_size_busy(args);
1540                         xfs_extent_busy_flush(args->mp, args->pag, busy_gen);
1541                         goto restart;
1542                 }
1543                 goto out_nominleft;
1544         }
1545         xfs_alloc_fix_len(args);
1546 
1547         rlen = args->len;
1548         XFS_WANT_CORRUPTED_GOTO(args->mp, rlen <= flen, error0);
1549         /*
1550          * Allocate and initialize a cursor for the by-block tree.
1551          */
1552         bno_cur = xfs_allocbt_init_cursor(args->mp, args->tp, args->agbp,
1553                 args->agno, XFS_BTNUM_BNO);
1554         if ((error = xfs_alloc_fixup_trees(cnt_cur, bno_cur, fbno, flen,
1555                         rbno, rlen, XFSA_FIXUP_CNT_OK)))
1556                 goto error0;
1557         xfs_btree_del_cursor(cnt_cur, XFS_BTREE_NOERROR);
1558         xfs_btree_del_cursor(bno_cur, XFS_BTREE_NOERROR);
1559         cnt_cur = bno_cur = NULL;
1560         args->len = rlen;
1561         args->agbno = rbno;
1562         XFS_WANT_CORRUPTED_GOTO(args->mp,
1563                 args->agbno + args->len <=
1564                         be32_to_cpu(XFS_BUF_TO_AGF(args->agbp)->agf_length),
1565                 error0);
1566         trace_xfs_alloc_size_done(args);
1567         return 0;
1568 
1569 error0:
1570         trace_xfs_alloc_size_error(args);
1571         if (cnt_cur)
1572                 xfs_btree_del_cursor(cnt_cur, XFS_BTREE_ERROR);
1573         if (bno_cur)
1574                 xfs_btree_del_cursor(bno_cur, XFS_BTREE_ERROR);
1575         return error;
1576 
1577 out_nominleft:
1578         xfs_btree_del_cursor(cnt_cur, XFS_BTREE_NOERROR);
1579         trace_xfs_alloc_size_nominleft(args);
1580         args->agbno = NULLAGBLOCK;
1581         return 0;
1582 }
1583 
1584 /*
1585  * Deal with the case where only small freespaces remain.
1586  * Either return the contents of the last freespace record,
1587  * or allocate space from the freelist if there is nothing in the tree.
1588  */
1589 STATIC int                      /* error */
1590 xfs_alloc_ag_vextent_small(
1591         xfs_alloc_arg_t *args,  /* allocation argument structure */
1592         xfs_btree_cur_t *ccur,  /* by-size cursor */
1593         xfs_agblock_t   *fbnop, /* result block number */
1594         xfs_extlen_t    *flenp, /* result length */
1595         int             *stat)  /* status: 0-freelist, 1-normal/none */
1596 {
1597         struct xfs_owner_info   oinfo;
1598         int             error;
1599         xfs_agblock_t   fbno;
1600         xfs_extlen_t    flen;
1601         int             i;
1602 
1603         if ((error = xfs_btree_decrement(ccur, 0, &i)))
1604                 goto error0;
1605         if (i) {
1606                 if ((error = xfs_alloc_get_rec(ccur, &fbno, &flen, &i)))
1607                         goto error0;
1608                 XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0);
1609         }
1610         /*
1611          * Nothing in the btree, try the freelist.  Make sure
1612          * to respect minleft even when pulling from the
1613          * freelist.
1614          */
1615         else if (args->minlen == 1 && args->alignment == 1 &&
1616                  args->resv != XFS_AG_RESV_AGFL &&
1617                  (be32_to_cpu(XFS_BUF_TO_AGF(args->agbp)->agf_flcount)
1618                   > args->minleft)) {
1619                 error = xfs_alloc_get_freelist(args->tp, args->agbp, &fbno, 0);
1620                 if (error)
1621                         goto error0;
1622                 if (fbno != NULLAGBLOCK) {
1623                         xfs_extent_busy_reuse(args->mp, args->agno, fbno, 1,
1624                               xfs_alloc_allow_busy_reuse(args->datatype));
1625 
1626                         if (xfs_alloc_is_userdata(args->datatype)) {
1627                                 xfs_buf_t       *bp;
1628 
1629                                 bp = xfs_btree_get_bufs(args->mp, args->tp,
1630                                         args->agno, fbno, 0);
1631                                 if (!bp) {
1632                                         error = -EFSCORRUPTED;
1633                                         goto error0;
1634                                 }
1635                                 xfs_trans_binval(args->tp, bp);
1636                         }
1637                         args->len = 1;
1638                         args->agbno = fbno;
1639                         XFS_WANT_CORRUPTED_GOTO(args->mp,
1640                                 args->agbno + args->len <=
1641                                 be32_to_cpu(XFS_BUF_TO_AGF(args->agbp)->agf_length),
1642                                 error0);
1643                         args->wasfromfl = 1;
1644                         trace_xfs_alloc_small_freelist(args);
1645 
1646                         /*
1647                          * If we're feeding an AGFL block to something that
1648                          * doesn't live in the free space, we need to clear
1649                          * out the OWN_AG rmap.
1650                          */
1651                         xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_AG);
1652                         error = xfs_rmap_free(args->tp, args->agbp, args->agno,
1653                                         fbno, 1, &oinfo);
1654                         if (error)
1655                                 goto error0;
1656 
1657                         *stat = 0;
1658                         return 0;
1659                 }
1660                 /*
1661                  * Nothing in the freelist.
1662                  */
1663                 else
1664                         flen = 0;
1665         }
1666         /*
1667          * Can't allocate from the freelist for some reason.
1668          */
1669         else {
1670                 fbno = NULLAGBLOCK;
1671                 flen = 0;
1672         }
1673         /*
1674          * Can't do the allocation, give up.
1675          */
1676         if (flen < args->minlen) {
1677                 args->agbno = NULLAGBLOCK;
1678                 trace_xfs_alloc_small_notenough(args);
1679                 flen = 0;
1680         }
1681         *fbnop = fbno;
1682         *flenp = flen;
1683         *stat = 1;
1684         trace_xfs_alloc_small_done(args);
1685         return 0;
1686 
1687 error0:
1688         trace_xfs_alloc_small_error(args);
1689         return error;
1690 }
1691 
1692 /*
1693  * Free the extent starting at agno/bno for length.
1694  */
1695 STATIC int
1696 xfs_free_ag_extent(
1697         xfs_trans_t             *tp,
1698         xfs_buf_t               *agbp,
1699         xfs_agnumber_t          agno,
1700         xfs_agblock_t           bno,
1701         xfs_extlen_t            len,
1702         struct xfs_owner_info   *oinfo,
1703         enum xfs_ag_resv_type   type)
1704 {
1705         xfs_btree_cur_t *bno_cur;       /* cursor for by-block btree */
1706         xfs_btree_cur_t *cnt_cur;       /* cursor for by-size btree */
1707         int             error;          /* error return value */
1708         xfs_agblock_t   gtbno;          /* start of right neighbor block */
1709         xfs_extlen_t    gtlen;          /* length of right neighbor block */
1710         int             haveleft;       /* have a left neighbor block */
1711         int             haveright;      /* have a right neighbor block */
1712         int             i;              /* temp, result code */
1713         xfs_agblock_t   ltbno;          /* start of left neighbor block */
1714         xfs_extlen_t    ltlen;          /* length of left neighbor block */
1715         xfs_mount_t     *mp;            /* mount point struct for filesystem */
1716         xfs_agblock_t   nbno;           /* new starting block of freespace */
1717         xfs_extlen_t    nlen;           /* new length of freespace */
1718         xfs_perag_t     *pag;           /* per allocation group data */
1719 
1720         bno_cur = cnt_cur = NULL;
1721         mp = tp->t_mountp;
1722 
1723         if (!xfs_rmap_should_skip_owner_update(oinfo)) {
1724                 error = xfs_rmap_free(tp, agbp, agno, bno, len, oinfo);
1725                 if (error)
1726                         goto error0;
1727         }
1728 
1729         /*
1730          * Allocate and initialize a cursor for the by-block btree.
1731          */
1732         bno_cur = xfs_allocbt_init_cursor(mp, tp, agbp, agno, XFS_BTNUM_BNO);
1733         /*
1734          * Look for a neighboring block on the left (lower block numbers)
1735          * that is contiguous with this space.
1736          */
1737         if ((error = xfs_alloc_lookup_le(bno_cur, bno, len, &haveleft)))
1738                 goto error0;
1739         if (haveleft) {
1740                 /*
1741                  * There is a block to our left.
1742                  */
1743                 if ((error = xfs_alloc_get_rec(bno_cur, &ltbno, &ltlen, &i)))
1744                         goto error0;
1745                 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);
1746                 /*
1747                  * It's not contiguous, though.
1748                  */
1749                 if (ltbno + ltlen < bno)
1750                         haveleft = 0;
1751                 else {
1752                         /*
1753                          * If this failure happens the request to free this
1754                          * space was invalid, it's (partly) already free.
1755                          * Very bad.
1756                          */
1757                         XFS_WANT_CORRUPTED_GOTO(mp,
1758                                                 ltbno + ltlen <= bno, error0);
1759                 }
1760         }
1761         /*
1762          * Look for a neighboring block on the right (higher block numbers)
1763          * that is contiguous with this space.
1764          */
1765         if ((error = xfs_btree_increment(bno_cur, 0, &haveright)))
1766                 goto error0;
1767         if (haveright) {
1768                 /*
1769                  * There is a block to our right.
1770                  */
1771                 if ((error = xfs_alloc_get_rec(bno_cur, &gtbno, &gtlen, &i)))
1772                         goto error0;
1773                 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);
1774                 /*
1775                  * It's not contiguous, though.
1776                  */
1777                 if (bno + len < gtbno)
1778                         haveright = 0;
1779                 else {
1780                         /*
1781                          * If this failure happens the request to free this
1782                          * space was invalid, it's (partly) already free.
1783                          * Very bad.
1784                          */
1785                         XFS_WANT_CORRUPTED_GOTO(mp, gtbno >= bno + len, error0);
1786                 }
1787         }
1788         /*
1789          * Now allocate and initialize a cursor for the by-size tree.
1790          */
1791         cnt_cur = xfs_allocbt_init_cursor(mp, tp, agbp, agno, XFS_BTNUM_CNT);
1792         /*
1793          * Have both left and right contiguous neighbors.
1794          * Merge all three into a single free block.
1795          */
1796         if (haveleft && haveright) {
1797                 /*
1798                  * Delete the old by-size entry on the left.
1799                  */
1800                 if ((error = xfs_alloc_lookup_eq(cnt_cur, ltbno, ltlen, &i)))
1801                         goto error0;
1802                 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);
1803                 if ((error = xfs_btree_delete(cnt_cur, &i)))
1804                         goto error0;
1805                 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);
1806                 /*
1807                  * Delete the old by-size entry on the right.
1808                  */
1809                 if ((error = xfs_alloc_lookup_eq(cnt_cur, gtbno, gtlen, &i)))
1810                         goto error0;
1811                 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);
1812                 if ((error = xfs_btree_delete(cnt_cur, &i)))
1813                         goto error0;
1814                 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);
1815                 /*
1816                  * Delete the old by-block entry for the right block.
1817                  */
1818                 if ((error = xfs_btree_delete(bno_cur, &i)))
1819                         goto error0;
1820                 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);
1821                 /*
1822                  * Move the by-block cursor back to the left neighbor.
1823                  */
1824                 if ((error = xfs_btree_decrement(bno_cur, 0, &i)))
1825                         goto error0;
1826                 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);
1827 #ifdef DEBUG
1828                 /*
1829                  * Check that this is the right record: delete didn't
1830                  * mangle the cursor.
1831                  */
1832                 {
1833                         xfs_agblock_t   xxbno;
1834                         xfs_extlen_t    xxlen;
1835 
1836                         if ((error = xfs_alloc_get_rec(bno_cur, &xxbno, &xxlen,
1837                                         &i)))
1838                                 goto error0;
1839                         XFS_WANT_CORRUPTED_GOTO(mp,
1840                                 i == 1 && xxbno == ltbno && xxlen == ltlen,
1841                                 error0);
1842                 }
1843 #endif
1844                 /*
1845                  * Update remaining by-block entry to the new, joined block.
1846                  */
1847                 nbno = ltbno;
1848                 nlen = len + ltlen + gtlen;
1849                 if ((error = xfs_alloc_update(bno_cur, nbno, nlen)))
1850                         goto error0;
1851         }
1852         /*
1853          * Have only a left contiguous neighbor.
1854          * Merge it together with the new freespace.
1855          */
1856         else if (haveleft) {
1857                 /*
1858                  * Delete the old by-size entry on the left.
1859                  */
1860                 if ((error = xfs_alloc_lookup_eq(cnt_cur, ltbno, ltlen, &i)))
1861                         goto error0;
1862                 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);
1863                 if ((error = xfs_btree_delete(cnt_cur, &i)))
1864                         goto error0;
1865                 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);
1866                 /*
1867                  * Back up the by-block cursor to the left neighbor, and
1868                  * update its length.
1869                  */
1870                 if ((error = xfs_btree_decrement(bno_cur, 0, &i)))
1871                         goto error0;
1872                 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);
1873                 nbno = ltbno;
1874                 nlen = len + ltlen;
1875                 if ((error = xfs_alloc_update(bno_cur, nbno, nlen)))
1876                         goto error0;
1877         }
1878         /*
1879          * Have only a right contiguous neighbor.
1880          * Merge it together with the new freespace.
1881          */
1882         else if (haveright) {
1883                 /*
1884                  * Delete the old by-size entry on the right.
1885                  */
1886                 if ((error = xfs_alloc_lookup_eq(cnt_cur, gtbno, gtlen, &i)))
1887                         goto error0;
1888                 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);
1889                 if ((error = xfs_btree_delete(cnt_cur, &i)))
1890                         goto error0;
1891                 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);
1892                 /*
1893                  * Update the starting block and length of the right
1894                  * neighbor in the by-block tree.
1895                  */
1896                 nbno = bno;
1897                 nlen = len + gtlen;
1898                 if ((error = xfs_alloc_update(bno_cur, nbno, nlen)))
1899                         goto error0;
1900         }
1901         /*
1902          * No contiguous neighbors.
1903          * Insert the new freespace into the by-block tree.
1904          */
1905         else {
1906                 nbno = bno;
1907                 nlen = len;
1908                 if ((error = xfs_btree_insert(bno_cur, &i)))
1909                         goto error0;
1910                 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);
1911         }
1912         xfs_btree_del_cursor(bno_cur, XFS_BTREE_NOERROR);
1913         bno_cur = NULL;
1914         /*
1915          * In all cases we need to insert the new freespace in the by-size tree.
1916          */
1917         if ((error = xfs_alloc_lookup_eq(cnt_cur, nbno, nlen, &i)))
1918                 goto error0;
1919         XFS_WANT_CORRUPTED_GOTO(mp, i == 0, error0);
1920         if ((error = xfs_btree_insert(cnt_cur, &i)))
1921                 goto error0;
1922         XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0);
1923         xfs_btree_del_cursor(cnt_cur, XFS_BTREE_NOERROR);
1924         cnt_cur = NULL;
1925 
1926         /*
1927          * Update the freespace totals in the ag and superblock.
1928          */
1929         pag = xfs_perag_get(mp, agno);
1930         error = xfs_alloc_update_counters(tp, pag, agbp, len);
1931         xfs_ag_resv_free_extent(pag, type, tp, len);
1932         xfs_perag_put(pag);
1933         if (error)
1934                 goto error0;
1935 
1936         XFS_STATS_INC(mp, xs_freex);
1937         XFS_STATS_ADD(mp, xs_freeb, len);
1938 
1939         trace_xfs_free_extent(mp, agno, bno, len, type, haveleft, haveright);
1940 
1941         return 0;
1942 
1943  error0:
1944         trace_xfs_free_extent(mp, agno, bno, len, type, -1, -1);
1945         if (bno_cur)
1946                 xfs_btree_del_cursor(bno_cur, XFS_BTREE_ERROR);
1947         if (cnt_cur)
1948                 xfs_btree_del_cursor(cnt_cur, XFS_BTREE_ERROR);
1949         return error;
1950 }
1951 
1952 /*
1953  * Visible (exported) allocation/free functions.
1954  * Some of these are used just by xfs_alloc_btree.c and this file.
1955  */
1956 
1957 /*
1958  * Compute and fill in value of m_ag_maxlevels.
1959  */
1960 void
1961 xfs_alloc_compute_maxlevels(
1962         xfs_mount_t     *mp)    /* file system mount structure */
1963 {
1964         mp->m_ag_maxlevels = xfs_btree_compute_maxlevels(mp->m_alloc_mnr,
1965                         (mp->m_sb.sb_agblocks + 1) / 2);
1966 }
1967 
1968 /*
1969  * Find the length of the longest extent in an AG.  The 'need' parameter
1970  * specifies how much space we're going to need for the AGFL and the
1971  * 'reserved' parameter tells us how many blocks in this AG are reserved for
1972  * other callers.
1973  */
1974 xfs_extlen_t
1975 xfs_alloc_longest_free_extent(
1976         struct xfs_perag        *pag,
1977         xfs_extlen_t            need,
1978         xfs_extlen_t            reserved)
1979 {
1980         xfs_extlen_t            delta = 0;
1981 
1982         /*
1983          * If the AGFL needs a recharge, we'll have to subtract that from the
1984          * longest extent.
1985          */
1986         if (need > pag->pagf_flcount)
1987                 delta = need - pag->pagf_flcount;
1988 
1989         /*
1990          * If we cannot maintain others' reservations with space from the
1991          * not-longest freesp extents, we'll have to subtract /that/ from
1992          * the longest extent too.
1993          */
1994         if (pag->pagf_freeblks - pag->pagf_longest < reserved)
1995                 delta += reserved - (pag->pagf_freeblks - pag->pagf_longest);
1996 
1997         /*
1998          * If the longest extent is long enough to satisfy all the
1999          * reservations and AGFL rules in place, we can return this extent.
2000          */
2001         if (pag->pagf_longest > delta)
2002                 return pag->pagf_longest - delta;
2003 
2004         /* Otherwise, let the caller try for 1 block if there's space. */
2005         return pag->pagf_flcount > 0 || pag->pagf_longest > 0;
2006 }
2007 
2008 unsigned int
2009 xfs_alloc_min_freelist(
2010         struct xfs_mount        *mp,
2011         struct xfs_perag        *pag)
2012 {
2013         unsigned int            min_free;
2014 
2015         /* space needed by-bno freespace btree */
2016         min_free = min_t(unsigned int, pag->pagf_levels[XFS_BTNUM_BNOi] + 1,
2017                                        mp->m_ag_maxlevels);
2018         /* space needed by-size freespace btree */
2019         min_free += min_t(unsigned int, pag->pagf_levels[XFS_BTNUM_CNTi] + 1,
2020                                        mp->m_ag_maxlevels);
2021         /* space needed reverse mapping used space btree */
2022         if (xfs_sb_version_hasrmapbt(&mp->m_sb))
2023                 min_free += min_t(unsigned int,
2024                                   pag->pagf_levels[XFS_BTNUM_RMAPi] + 1,
2025                                   mp->m_rmap_maxlevels);
2026 
2027         return min_free;
2028 }
2029 
2030 /*
2031  * Check if the operation we are fixing up the freelist for should go ahead or
2032  * not. If we are freeing blocks, we always allow it, otherwise the allocation
2033  * is dependent on whether the size and shape of free space available will
2034  * permit the requested allocation to take place.
2035  */
2036 static bool
2037 xfs_alloc_space_available(
2038         struct xfs_alloc_arg    *args,
2039         xfs_extlen_t            min_free,
2040         int                     flags)
2041 {
2042         struct xfs_perag        *pag = args->pag;
2043         xfs_extlen_t            alloc_len, longest;
2044         xfs_extlen_t            reservation; /* blocks that are still reserved */
2045         int                     available;
2046 
2047         if (flags & XFS_ALLOC_FLAG_FREEING)
2048                 return true;
2049 
2050         reservation = xfs_ag_resv_needed(pag, args->resv);
2051 
2052         /* do we have enough contiguous free space for the allocation? */
2053         alloc_len = args->minlen + (args->alignment - 1) + args->minalignslop;
2054         longest = xfs_alloc_longest_free_extent(pag, min_free, reservation);
2055         if (longest < alloc_len)
2056                 return false;
2057 
2058         /* do we have enough free space remaining for the allocation? */
2059         available = (int)(pag->pagf_freeblks + pag->pagf_flcount -
2060                           reservation - min_free - args->minleft);
2061         if (available < (int)max(args->total, alloc_len))
2062                 return false;
2063 
2064         /*
2065          * Clamp maxlen to the amount of free space available for the actual
2066          * extent allocation.
2067          */
2068         if (available < (int)args->maxlen && !(flags & XFS_ALLOC_FLAG_CHECK)) {
2069                 args->maxlen = available;
2070                 ASSERT(args->maxlen > 0);
2071                 ASSERT(args->maxlen >= args->minlen);
2072         }
2073 
2074         return true;
2075 }
2076 
2077 int
2078 xfs_free_agfl_block(
2079         struct xfs_trans        *tp,
2080         xfs_agnumber_t          agno,
2081         xfs_agblock_t           agbno,
2082         struct xfs_buf          *agbp,
2083         struct xfs_owner_info   *oinfo)
2084 {
2085         int                     error;
2086         struct xfs_buf          *bp;
2087 
2088         error = xfs_free_ag_extent(tp, agbp, agno, agbno, 1, oinfo,
2089                                    XFS_AG_RESV_AGFL);
2090         if (error)
2091                 return error;
2092 
2093         bp = xfs_btree_get_bufs(tp->t_mountp, tp, agno, agbno, 0);
2094         if (!bp)
2095                 return -EFSCORRUPTED;
2096         xfs_trans_binval(tp, bp);
2097 
2098         return 0;
2099 }
2100 
2101 /*
2102  * Check the agfl fields of the agf for inconsistency or corruption. The purpose
2103  * is to detect an agfl header padding mismatch between current and early v5
2104  * kernels. This problem manifests as a 1-slot size difference between the
2105  * on-disk flcount and the active [first, last] range of a wrapped agfl. This
2106  * may also catch variants of agfl count corruption unrelated to padding. Either
2107  * way, we'll reset the agfl and warn the user.
2108  *
2109  * Return true if a reset is required before the agfl can be used, false
2110  * otherwise.
2111  */
2112 static bool
2113 xfs_agfl_needs_reset(
2114         struct xfs_mount        *mp,
2115         struct xfs_agf          *agf)
2116 {
2117         uint32_t                f = be32_to_cpu(agf->agf_flfirst);
2118         uint32_t                l = be32_to_cpu(agf->agf_fllast);
2119         uint32_t                c = be32_to_cpu(agf->agf_flcount);
2120         int                     agfl_size = xfs_agfl_size(mp);
2121         int                     active;
2122 
2123         /* no agfl header on v4 supers */
2124         if (!xfs_sb_version_hascrc(&mp->m_sb))
2125                 return false;
2126 
2127         /*
2128          * The agf read verifier catches severe corruption of these fields.
2129          * Repeat some sanity checks to cover a packed -> unpacked mismatch if
2130          * the verifier allows it.
2131          */
2132         if (f >= agfl_size || l >= agfl_size)
2133                 return true;
2134         if (c > agfl_size)
2135                 return true;
2136 
2137         /*
2138          * Check consistency between the on-disk count and the active range. An
2139          * agfl padding mismatch manifests as an inconsistent flcount.
2140          */
2141         if (c && l >= f)
2142                 active = l - f + 1;
2143         else if (c)
2144                 active = agfl_size - f + l + 1;
2145         else
2146                 active = 0;
2147 
2148         return active != c;
2149 }
2150 
2151 /*
2152  * Reset the agfl to an empty state. Ignore/drop any existing blocks since the
2153  * agfl content cannot be trusted. Warn the user that a repair is required to
2154  * recover leaked blocks.
2155  *
2156  * The purpose of this mechanism is to handle filesystems affected by the agfl
2157  * header padding mismatch problem. A reset keeps the filesystem online with a
2158  * relatively minor free space accounting inconsistency rather than suffer the
2159  * inevitable crash from use of an invalid agfl block.
2160  */
2161 static void
2162 xfs_agfl_reset(
2163         struct xfs_trans        *tp,
2164         struct xfs_buf          *agbp,
2165         struct xfs_perag        *pag)
2166 {
2167         struct xfs_mount        *mp = tp->t_mountp;
2168         struct xfs_agf          *agf = XFS_BUF_TO_AGF(agbp);
2169 
2170         ASSERT(pag->pagf_agflreset);
2171         trace_xfs_agfl_reset(mp, agf, 0, _RET_IP_);
2172 
2173         xfs_warn(mp,
2174                "WARNING: Reset corrupted AGFL on AG %u. %d blocks leaked. "
2175                "Please unmount and run xfs_repair.",
2176                  pag->pag_agno, pag->pagf_flcount);
2177 
2178         agf->agf_flfirst = 0;
2179         agf->agf_fllast = cpu_to_be32(xfs_agfl_size(mp) - 1);
2180         agf->agf_flcount = 0;
2181         xfs_alloc_log_agf(tp, agbp, XFS_AGF_FLFIRST | XFS_AGF_FLLAST |
2182                                     XFS_AGF_FLCOUNT);
2183 
2184         pag->pagf_flcount = 0;
2185         pag->pagf_agflreset = false;
2186 }
2187 
2188 /*
2189  * Defer an AGFL block free. This is effectively equivalent to
2190  * xfs_bmap_add_free() with some special handling particular to AGFL blocks.
2191  *
2192  * Deferring AGFL frees helps prevent log reservation overruns due to too many
2193  * allocation operations in a transaction. AGFL frees are prone to this problem
2194  * because for one they are always freed one at a time. Further, an immediate
2195  * AGFL block free can cause a btree join and require another block free before
2196  * the real allocation can proceed. Deferring the free disconnects freeing up
2197  * the AGFL slot from freeing the block.
2198  */
2199 STATIC void
2200 xfs_defer_agfl_block(
2201         struct xfs_mount                *mp,
2202         struct xfs_defer_ops            *dfops,
2203         xfs_agnumber_t                  agno,
2204         xfs_fsblock_t                   agbno,
2205         struct xfs_owner_info           *oinfo)
2206 {
2207         struct xfs_extent_free_item     *new;           /* new element */
2208 
2209         ASSERT(xfs_bmap_free_item_zone != NULL);
2210         ASSERT(oinfo != NULL);
2211 
2212         new = kmem_zone_alloc(xfs_bmap_free_item_zone, KM_SLEEP);
2213         new->xefi_startblock = XFS_AGB_TO_FSB(mp, agno, agbno);
2214         new->xefi_blockcount = 1;
2215         new->xefi_oinfo = *oinfo;
2216 
2217         trace_xfs_agfl_free_defer(mp, agno, 0, agbno, 1);
2218 
2219         xfs_defer_add(dfops, XFS_DEFER_OPS_TYPE_AGFL_FREE, &new->xefi_list);
2220 }
2221 
2222 /*
2223  * Decide whether to use this allocation group for this allocation.
2224  * If so, fix up the btree freelist's size.
2225  */
2226 int                     /* error */
2227 xfs_alloc_fix_freelist(
2228         struct xfs_alloc_arg    *args,  /* allocation argument structure */
2229         int                     flags)  /* XFS_ALLOC_FLAG_... */
2230 {
2231         struct xfs_mount        *mp = args->mp;
2232         struct xfs_perag        *pag = args->pag;
2233         struct xfs_trans        *tp = args->tp;
2234         struct xfs_buf          *agbp = NULL;
2235         struct xfs_buf          *agflbp = NULL;
2236         struct xfs_alloc_arg    targs;  /* local allocation arguments */
2237         xfs_agblock_t           bno;    /* freelist block */
2238         xfs_extlen_t            need;   /* total blocks needed in freelist */
2239         int                     error = 0;
2240 
2241         if (!pag->pagf_init) {
2242                 error = xfs_alloc_read_agf(mp, tp, args->agno, flags, &agbp);
2243                 if (error)
2244                         goto out_no_agbp;
2245                 if (!pag->pagf_init) {
2246                         ASSERT(flags & XFS_ALLOC_FLAG_TRYLOCK);
2247                         ASSERT(!(flags & XFS_ALLOC_FLAG_FREEING));
2248                         goto out_agbp_relse;
2249                 }
2250         }
2251 
2252         /*
2253          * If this is a metadata preferred pag and we are user data then try
2254          * somewhere else if we are not being asked to try harder at this
2255          * point
2256          */
2257         if (pag->pagf_metadata && xfs_alloc_is_userdata(args->datatype) &&
2258             (flags & XFS_ALLOC_FLAG_TRYLOCK)) {
2259                 ASSERT(!(flags & XFS_ALLOC_FLAG_FREEING));
2260                 goto out_agbp_relse;
2261         }
2262 
2263         need = xfs_alloc_min_freelist(mp, pag);
2264         if (!xfs_alloc_space_available(args, need, flags |
2265                         XFS_ALLOC_FLAG_CHECK))
2266                 goto out_agbp_relse;
2267 
2268         /*
2269          * Get the a.g. freespace buffer.
2270          * Can fail if we're not blocking on locks, and it's held.
2271          */
2272         if (!agbp) {
2273                 error = xfs_alloc_read_agf(mp, tp, args->agno, flags, &agbp);
2274                 if (error)
2275                         goto out_no_agbp;
2276                 if (!agbp) {
2277                         ASSERT(flags & XFS_ALLOC_FLAG_TRYLOCK);
2278                         ASSERT(!(flags & XFS_ALLOC_FLAG_FREEING));
2279                         goto out_no_agbp;
2280                 }
2281         }
2282 
2283         /* reset a padding mismatched agfl before final free space check */
2284         if (pag->pagf_agflreset)
2285                 xfs_agfl_reset(tp, agbp, pag);
2286 
2287         /* If there isn't enough total space or single-extent, reject it. */
2288         need = xfs_alloc_min_freelist(mp, pag);
2289         if (!xfs_alloc_space_available(args, need, flags))
2290                 goto out_agbp_relse;
2291 
2292         /*
2293          * Make the freelist shorter if it's too long.
2294          *
2295          * Note that from this point onwards, we will always release the agf and
2296          * agfl buffers on error. This handles the case where we error out and
2297          * the buffers are clean or may not have been joined to the transaction
2298          * and hence need to be released manually. If they have been joined to
2299          * the transaction, then xfs_trans_brelse() will handle them
2300          * appropriately based on the recursion count and dirty state of the
2301          * buffer.
2302          *
2303          * XXX (dgc): When we have lots of free space, does this buy us
2304          * anything other than extra overhead when we need to put more blocks
2305          * back on the free list? Maybe we should only do this when space is
2306          * getting low or the AGFL is more than half full?
2307          *
2308          * The NOSHRINK flag prevents the AGFL from being shrunk if it's too
2309          * big; the NORMAP flag prevents AGFL expand/shrink operations from
2310          * updating the rmapbt.  Both flags are used in xfs_repair while we're
2311          * rebuilding the rmapbt, and neither are used by the kernel.  They're
2312          * both required to ensure that rmaps are correctly recorded for the
2313          * regenerated AGFL, bnobt, and cntbt.  See repair/phase5.c and
2314          * repair/rmap.c in xfsprogs for details.
2315          */
2316         memset(&targs, 0, sizeof(targs));
2317         if (flags & XFS_ALLOC_FLAG_NORMAP)
2318                 xfs_rmap_skip_owner_update(&targs.oinfo);
2319         else
2320                 xfs_rmap_ag_owner(&targs.oinfo, XFS_RMAP_OWN_AG);
2321         while (!(flags & XFS_ALLOC_FLAG_NOSHRINK) && pag->pagf_flcount > need) {
2322                 error = xfs_alloc_get_freelist(tp, agbp, &bno, 0);
2323                 if (error)
2324                         goto out_agbp_relse;
2325 
2326                 /* defer agfl frees if dfops is provided */
2327                 if (tp->t_agfl_dfops) {
2328                         xfs_defer_agfl_block(mp, tp->t_agfl_dfops, args->agno,
2329                                              bno, &targs.oinfo);
2330                 } else {
2331                         error = xfs_free_agfl_block(tp, args->agno, bno, agbp,
2332                                                     &targs.oinfo);
2333                         if (error)
2334                                 goto out_agbp_relse;
2335                 }
2336         }
2337 
2338         targs.tp = tp;
2339         targs.mp = mp;
2340         targs.agbp = agbp;
2341         targs.agno = args->agno;
2342         targs.alignment = targs.minlen = targs.prod = 1;
2343         targs.type = XFS_ALLOCTYPE_THIS_AG;
2344         targs.pag = pag;
2345         error = xfs_alloc_read_agfl(mp, tp, targs.agno, &agflbp);
2346         if (error)
2347                 goto out_agbp_relse;
2348 
2349         /* Make the freelist longer if it's too short. */
2350         while (pag->pagf_flcount < need) {
2351                 targs.agbno = 0;
2352                 targs.maxlen = need - pag->pagf_flcount;
2353                 targs.resv = XFS_AG_RESV_AGFL;
2354 
2355                 /* Allocate as many blocks as possible at once. */
2356                 error = xfs_alloc_ag_vextent(&targs);
2357                 if (error)
2358                         goto out_agflbp_relse;
2359 
2360                 /*
2361                  * Stop if we run out.  Won't happen if callers are obeying
2362                  * the restrictions correctly.  Can happen for free calls
2363                  * on a completely full ag.
2364                  */
2365                 if (targs.agbno == NULLAGBLOCK) {
2366                         if (flags & XFS_ALLOC_FLAG_FREEING)
2367                                 break;
2368                         goto out_agflbp_relse;
2369                 }
2370                 /*
2371                  * Put each allocated block on the list.
2372                  */
2373                 for (bno = targs.agbno; bno < targs.agbno + targs.len; bno++) {
2374                         error = xfs_alloc_put_freelist(tp, agbp,
2375                                                         agflbp, bno, 0);
2376                         if (error)
2377                                 goto out_agflbp_relse;
2378                 }
2379         }
2380         xfs_trans_brelse(tp, agflbp);
2381         args->agbp = agbp;
2382         return 0;
2383 
2384 out_agflbp_relse:
2385         xfs_trans_brelse(tp, agflbp);
2386 out_agbp_relse:
2387         if (agbp)
2388                 xfs_trans_brelse(tp, agbp);
2389 out_no_agbp:
2390         args->agbp = NULL;
2391         return error;
2392 }
2393 
2394 /*
2395  * Get a block from the freelist.
2396  * Returns with the buffer for the block gotten.
2397  */
2398 int                             /* error */
2399 xfs_alloc_get_freelist(
2400         xfs_trans_t     *tp,    /* transaction pointer */
2401         xfs_buf_t       *agbp,  /* buffer containing the agf structure */
2402         xfs_agblock_t   *bnop,  /* block address retrieved from freelist */
2403         int             btreeblk) /* destination is a AGF btree */
2404 {
2405         xfs_agf_t       *agf;   /* a.g. freespace structure */
2406         xfs_buf_t       *agflbp;/* buffer for a.g. freelist structure */
2407         xfs_agblock_t   bno;    /* block number returned */
2408         __be32          *agfl_bno;
2409         int             error;
2410         int             logflags;
2411         xfs_mount_t     *mp = tp->t_mountp;
2412         xfs_perag_t     *pag;   /* per allocation group data */
2413 
2414         /*
2415          * Freelist is empty, give up.
2416          */
2417         agf = XFS_BUF_TO_AGF(agbp);
2418         if (!agf->agf_flcount) {
2419                 *bnop = NULLAGBLOCK;
2420                 return 0;
2421         }
2422         /*
2423          * Read the array of free blocks.
2424          */
2425         error = xfs_alloc_read_agfl(mp, tp, be32_to_cpu(agf->agf_seqno),
2426                                     &agflbp);
2427         if (error)
2428                 return error;
2429 
2430 
2431         /*
2432          * Get the block number and update the data structures.
2433          */
2434         agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, agflbp);
2435         bno = be32_to_cpu(agfl_bno[be32_to_cpu(agf->agf_flfirst)]);
2436         be32_add_cpu(&agf->agf_flfirst, 1);
2437         xfs_trans_brelse(tp, agflbp);
2438         if (be32_to_cpu(agf->agf_flfirst) == xfs_agfl_size(mp))
2439                 agf->agf_flfirst = 0;
2440 
2441         pag = xfs_perag_get(mp, be32_to_cpu(agf->agf_seqno));
2442         ASSERT(!pag->pagf_agflreset);
2443         be32_add_cpu(&agf->agf_flcount, -1);
2444         xfs_trans_agflist_delta(tp, -1);
2445         pag->pagf_flcount--;
2446         xfs_perag_put(pag);
2447 
2448         logflags = XFS_AGF_FLFIRST | XFS_AGF_FLCOUNT;
2449         if (btreeblk) {
2450                 be32_add_cpu(&agf->agf_btreeblks, 1);
2451                 pag->pagf_btreeblks++;
2452                 logflags |= XFS_AGF_BTREEBLKS;
2453         }
2454 
2455         xfs_alloc_log_agf(tp, agbp, logflags);
2456         *bnop = bno;
2457 
2458         return 0;
2459 }
2460 
2461 /*
2462  * Log the given fields from the agf structure.
2463  */
2464 void
2465 xfs_alloc_log_agf(
2466         xfs_trans_t     *tp,    /* transaction pointer */
2467         xfs_buf_t       *bp,    /* buffer for a.g. freelist header */
2468         int             fields) /* mask of fields to be logged (XFS_AGF_...) */
2469 {
2470         int     first;          /* first byte offset */
2471         int     last;           /* last byte offset */
2472         static const short      offsets[] = {
2473                 offsetof(xfs_agf_t, agf_magicnum),
2474                 offsetof(xfs_agf_t, agf_versionnum),
2475                 offsetof(xfs_agf_t, agf_seqno),
2476                 offsetof(xfs_agf_t, agf_length),
2477                 offsetof(xfs_agf_t, agf_roots[0]),
2478                 offsetof(xfs_agf_t, agf_levels[0]),
2479                 offsetof(xfs_agf_t, agf_flfirst),
2480                 offsetof(xfs_agf_t, agf_fllast),
2481                 offsetof(xfs_agf_t, agf_flcount),
2482                 offsetof(xfs_agf_t, agf_freeblks),
2483                 offsetof(xfs_agf_t, agf_longest),
2484                 offsetof(xfs_agf_t, agf_btreeblks),
2485                 offsetof(xfs_agf_t, agf_uuid),
2486                 offsetof(xfs_agf_t, agf_rmap_blocks),
2487                 offsetof(xfs_agf_t, agf_refcount_blocks),
2488                 offsetof(xfs_agf_t, agf_refcount_root),
2489                 offsetof(xfs_agf_t, agf_refcount_level),
2490                 /* needed so that we don't log the whole rest of the structure: */
2491                 offsetof(xfs_agf_t, agf_spare64),
2492                 sizeof(xfs_agf_t)
2493         };
2494 
2495         trace_xfs_agf(tp->t_mountp, XFS_BUF_TO_AGF(bp), fields, _RET_IP_);
2496 
2497         xfs_trans_buf_set_type(tp, bp, XFS_BLFT_AGF_BUF);
2498 
2499         xfs_btree_offsets(fields, offsets, XFS_AGF_NUM_BITS, &first, &last);
2500         xfs_trans_log_buf(tp, bp, (uint)first, (uint)last);
2501 }
2502 
2503 /*
2504  * Interface for inode allocation to force the pag data to be initialized.
2505  */
2506 int                                     /* error */
2507 xfs_alloc_pagf_init(
2508         xfs_mount_t             *mp,    /* file system mount structure */
2509         xfs_trans_t             *tp,    /* transaction pointer */
2510         xfs_agnumber_t          agno,   /* allocation group number */
2511         int                     flags)  /* XFS_ALLOC_FLAGS_... */
2512 {
2513         xfs_buf_t               *bp;
2514         int                     error;
2515 
2516         if ((error = xfs_alloc_read_agf(mp, tp, agno, flags, &bp)))
2517                 return error;
2518         if (bp)
2519                 xfs_trans_brelse(tp, bp);
2520         return 0;
2521 }
2522 
2523 /*
2524  * Put the block on the freelist for the allocation group.
2525  */
2526 int                                     /* error */
2527 xfs_alloc_put_freelist(
2528         xfs_trans_t             *tp,    /* transaction pointer */
2529         xfs_buf_t               *agbp,  /* buffer for a.g. freelist header */
2530         xfs_buf_t               *agflbp,/* buffer for a.g. free block array */
2531         xfs_agblock_t           bno,    /* block being freed */
2532         int                     btreeblk) /* block came from a AGF btree */
2533 {
2534         xfs_agf_t               *agf;   /* a.g. freespace structure */
2535         __be32                  *blockp;/* pointer to array entry */
2536         int                     error;
2537         int                     logflags;
2538         xfs_mount_t             *mp;    /* mount structure */
2539         xfs_perag_t             *pag;   /* per allocation group data */
2540         __be32                  *agfl_bno;
2541         int                     startoff;
2542 
2543         agf = XFS_BUF_TO_AGF(agbp);
2544         mp = tp->t_mountp;
2545 
2546         if (!agflbp && (error = xfs_alloc_read_agfl(mp, tp,
2547                         be32_to_cpu(agf->agf_seqno), &agflbp)))
2548                 return error;
2549         be32_add_cpu(&agf->agf_fllast, 1);
2550         if (be32_to_cpu(agf->agf_fllast) == xfs_agfl_size(mp))
2551                 agf->agf_fllast = 0;
2552 
2553         pag = xfs_perag_get(mp, be32_to_cpu(agf->agf_seqno));
2554         ASSERT(!pag->pagf_agflreset);
2555         be32_add_cpu(&agf->agf_flcount, 1);
2556         xfs_trans_agflist_delta(tp, 1);
2557         pag->pagf_flcount++;
2558 
2559         logflags = XFS_AGF_FLLAST | XFS_AGF_FLCOUNT;
2560         if (btreeblk) {
2561                 be32_add_cpu(&agf->agf_btreeblks, -1);
2562                 pag->pagf_btreeblks--;
2563                 logflags |= XFS_AGF_BTREEBLKS;
2564         }
2565         xfs_perag_put(pag);
2566 
2567         xfs_alloc_log_agf(tp, agbp, logflags);
2568 
2569         ASSERT(be32_to_cpu(agf->agf_flcount) <= xfs_agfl_size(mp));
2570 
2571         agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, agflbp);
2572         blockp = &agfl_bno[be32_to_cpu(agf->agf_fllast)];
2573         *blockp = cpu_to_be32(bno);
2574         startoff = (char *)blockp - (char *)agflbp->b_addr;
2575 
2576         xfs_alloc_log_agf(tp, agbp, logflags);
2577 
2578         xfs_trans_buf_set_type(tp, agflbp, XFS_BLFT_AGFL_BUF);
2579         xfs_trans_log_buf(tp, agflbp, startoff,
2580                           startoff + sizeof(xfs_agblock_t) - 1);
2581         return 0;
2582 }
2583 
2584 static xfs_failaddr_t
2585 xfs_agf_verify(
2586         struct xfs_buf          *bp)
2587 {
2588         struct xfs_mount        *mp = bp->b_target->bt_mount;
2589         struct xfs_agf          *agf = XFS_BUF_TO_AGF(bp);
2590 
2591         if (xfs_sb_version_hascrc(&mp->m_sb)) {
2592                 if (!uuid_equal(&agf->agf_uuid, &mp->m_sb.sb_meta_uuid))
2593                         return __this_address;
2594                 if (!xfs_log_check_lsn(mp,
2595                                 be64_to_cpu(XFS_BUF_TO_AGF(bp)->agf_lsn)))
2596                         return __this_address;
2597         }
2598 
2599         if (!(agf->agf_magicnum == cpu_to_be32(XFS_AGF_MAGIC) &&
2600               XFS_AGF_GOOD_VERSION(be32_to_cpu(agf->agf_versionnum)) &&
2601               be32_to_cpu(agf->agf_freeblks) <= be32_to_cpu(agf->agf_length) &&
2602               be32_to_cpu(agf->agf_flfirst) < xfs_agfl_size(mp) &&
2603               be32_to_cpu(agf->agf_fllast) < xfs_agfl_size(mp) &&
2604               be32_to_cpu(agf->agf_flcount) <= xfs_agfl_size(mp)))
2605                 return __this_address;
2606 
2607         if (be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]) < 1 ||
2608             be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT]) < 1 ||
2609             be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]) > XFS_BTREE_MAXLEVELS ||
2610             be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT]) > XFS_BTREE_MAXLEVELS)
2611                 return __this_address;
2612 
2613         if (xfs_sb_version_hasrmapbt(&mp->m_sb) &&
2614             (be32_to_cpu(agf->agf_levels[XFS_BTNUM_RMAP]) < 1 ||
2615              be32_to_cpu(agf->agf_levels[XFS_BTNUM_RMAP]) > XFS_BTREE_MAXLEVELS))
2616                 return __this_address;
2617 
2618         /*
2619          * during growfs operations, the perag is not fully initialised,
2620          * so we can't use it for any useful checking. growfs ensures we can't
2621          * use it by using uncached buffers that don't have the perag attached
2622          * so we can detect and avoid this problem.
2623          */
2624         if (bp->b_pag && be32_to_cpu(agf->agf_seqno) != bp->b_pag->pag_agno)
2625                 return __this_address;
2626 
2627         if (xfs_sb_version_haslazysbcount(&mp->m_sb) &&
2628             be32_to_cpu(agf->agf_btreeblks) > be32_to_cpu(agf->agf_length))
2629                 return __this_address;
2630 
2631         if (xfs_sb_version_hasreflink(&mp->m_sb) &&
2632             (be32_to_cpu(agf->agf_refcount_level) < 1 ||
2633              be32_to_cpu(agf->agf_refcount_level) > XFS_BTREE_MAXLEVELS))
2634                 return __this_address;
2635 
2636         return NULL;
2637 
2638 }
2639 
2640 static void
2641 xfs_agf_read_verify(
2642         struct xfs_buf  *bp)
2643 {
2644         struct xfs_mount *mp = bp->b_target->bt_mount;
2645         xfs_failaddr_t  fa;
2646 
2647         if (xfs_sb_version_hascrc(&mp->m_sb) &&
2648             !xfs_buf_verify_cksum(bp, XFS_AGF_CRC_OFF))
2649                 xfs_verifier_error(bp, -EFSBADCRC, __this_address);
2650         else {
2651                 fa = xfs_agf_verify(bp);
2652                 if (XFS_TEST_ERROR(fa, mp, XFS_ERRTAG_ALLOC_READ_AGF))
2653                         xfs_verifier_error(bp, -EFSCORRUPTED, fa);
2654         }
2655 }
2656 
2657 static void
2658 xfs_agf_write_verify(
2659         struct xfs_buf  *bp)
2660 {
2661         struct xfs_mount        *mp = bp->b_target->bt_mount;
2662         struct xfs_buf_log_item *bip = bp->b_log_item;
2663         xfs_failaddr_t          fa;
2664 
2665         fa = xfs_agf_verify(bp);
2666         if (fa) {
2667                 xfs_verifier_error(bp, -EFSCORRUPTED, fa);
2668                 return;
2669         }
2670 
2671         if (!xfs_sb_version_hascrc(&mp->m_sb))
2672                 return;
2673 
2674         if (bip)
2675                 XFS_BUF_TO_AGF(bp)->agf_lsn = cpu_to_be64(bip->bli_item.li_lsn);
2676 
2677         xfs_buf_update_cksum(bp, XFS_AGF_CRC_OFF);
2678 }
2679 
2680 const struct xfs_buf_ops xfs_agf_buf_ops = {
2681         .name = "xfs_agf",
2682         .verify_read = xfs_agf_read_verify,
2683         .verify_write = xfs_agf_write_verify,
2684         .verify_struct = xfs_agf_verify,
2685 };
2686 
2687 /*
2688  * Read in the allocation group header (free/alloc section).
2689  */
2690 int                                     /* error */
2691 xfs_read_agf(
2692         struct xfs_mount        *mp,    /* mount point structure */
2693         struct xfs_trans        *tp,    /* transaction pointer */
2694         xfs_agnumber_t          agno,   /* allocation group number */
2695         int                     flags,  /* XFS_BUF_ */
2696         struct xfs_buf          **bpp)  /* buffer for the ag freelist header */
2697 {
2698         int             error;
2699 
2700         trace_xfs_read_agf(mp, agno);
2701 
2702         ASSERT(agno != NULLAGNUMBER);
2703         error = xfs_trans_read_buf(
2704                         mp, tp, mp->m_ddev_targp,
2705                         XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
2706                         XFS_FSS_TO_BB(mp, 1), flags, bpp, &xfs_agf_buf_ops);
2707         if (error)
2708                 return error;
2709         if (!*bpp)
2710                 return 0;
2711 
2712         ASSERT(!(*bpp)->b_error);
2713         xfs_buf_set_ref(*bpp, XFS_AGF_REF);
2714         return 0;
2715 }
2716 
2717 /*
2718  * Read in the allocation group header (free/alloc section).
2719  */
2720 int                                     /* error */
2721 xfs_alloc_read_agf(
2722         struct xfs_mount        *mp,    /* mount point structure */
2723         struct xfs_trans        *tp,    /* transaction pointer */
2724         xfs_agnumber_t          agno,   /* allocation group number */
2725         int                     flags,  /* XFS_ALLOC_FLAG_... */
2726         struct xfs_buf          **bpp)  /* buffer for the ag freelist header */
2727 {
2728         struct xfs_agf          *agf;           /* ag freelist header */
2729         struct xfs_perag        *pag;           /* per allocation group data */
2730         int                     error;
2731 
2732         trace_xfs_alloc_read_agf(mp, agno);
2733 
2734         ASSERT(agno != NULLAGNUMBER);
2735         error = xfs_read_agf(mp, tp, agno,
2736                         (flags & XFS_ALLOC_FLAG_TRYLOCK) ? XBF_TRYLOCK : 0,
2737                         bpp);
2738         if (error)
2739                 return error;
2740         if (!*bpp)
2741                 return 0;
2742         ASSERT(!(*bpp)->b_error);
2743 
2744         agf = XFS_BUF_TO_AGF(*bpp);
2745         pag = xfs_perag_get(mp, agno);
2746         if (!pag->pagf_init) {
2747                 pag->pagf_freeblks = be32_to_cpu(agf->agf_freeblks);
2748                 pag->pagf_btreeblks = be32_to_cpu(agf->agf_btreeblks);
2749                 pag->pagf_flcount = be32_to_cpu(agf->agf_flcount);
2750                 pag->pagf_longest = be32_to_cpu(agf->agf_longest);
2751                 pag->pagf_levels[XFS_BTNUM_BNOi] =
2752                         be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNOi]);
2753                 pag->pagf_levels[XFS_BTNUM_CNTi] =
2754                         be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNTi]);
2755                 pag->pagf_levels[XFS_BTNUM_RMAPi] =
2756                         be32_to_cpu(agf->agf_levels[XFS_BTNUM_RMAPi]);
2757                 pag->pagf_refcount_level = be32_to_cpu(agf->agf_refcount_level);
2758                 spin_lock_init(&pag->pagb_lock);
2759                 pag->pagb_count = 0;
2760                 pag->pagb_tree = RB_ROOT;
2761                 pag->pagf_init = 1;
2762                 pag->pagf_agflreset = xfs_agfl_needs_reset(mp, agf);
2763         }
2764 #ifdef DEBUG
2765         else if (!XFS_FORCED_SHUTDOWN(mp)) {
2766                 ASSERT(pag->pagf_freeblks == be32_to_cpu(agf->agf_freeblks));
2767                 ASSERT(pag->pagf_btreeblks == be32_to_cpu(agf->agf_btreeblks));
2768                 ASSERT(pag->pagf_flcount == be32_to_cpu(agf->agf_flcount));
2769                 ASSERT(pag->pagf_longest == be32_to_cpu(agf->agf_longest));
2770                 ASSERT(pag->pagf_levels[XFS_BTNUM_BNOi] ==
2771                        be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNOi]));
2772                 ASSERT(pag->pagf_levels[XFS_BTNUM_CNTi] ==
2773                        be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNTi]));
2774         }
2775 #endif
2776         xfs_perag_put(pag);
2777         return 0;
2778 }
2779 
2780 /*
2781  * Allocate an extent (variable-size).
2782  * Depending on the allocation type, we either look in a single allocation
2783  * group or loop over the allocation groups to find the result.
2784  */
2785 int                             /* error */
2786 xfs_alloc_vextent(
2787         xfs_alloc_arg_t *args)  /* allocation argument structure */
2788 {
2789         xfs_agblock_t   agsize; /* allocation group size */
2790         int             error;
2791         int             flags;  /* XFS_ALLOC_FLAG_... locking flags */
2792         xfs_mount_t     *mp;    /* mount structure pointer */
2793         xfs_agnumber_t  sagno;  /* starting allocation group number */
2794         xfs_alloctype_t type;   /* input allocation type */
2795         int             bump_rotor = 0;
2796         xfs_agnumber_t  rotorstep = xfs_rotorstep; /* inode32 agf stepper */
2797 
2798         mp = args->mp;
2799         type = args->otype = args->type;
2800         args->agbno = NULLAGBLOCK;
2801         /*
2802          * Just fix this up, for the case where the last a.g. is shorter
2803          * (or there's only one a.g.) and the caller couldn't easily figure
2804          * that out (xfs_bmap_alloc).
2805          */
2806         agsize = mp->m_sb.sb_agblocks;
2807         if (args->maxlen > agsize)
2808                 args->maxlen = agsize;
2809         if (args->alignment == 0)
2810                 args->alignment = 1;
2811         ASSERT(XFS_FSB_TO_AGNO(mp, args->fsbno) < mp->m_sb.sb_agcount);
2812         ASSERT(XFS_FSB_TO_AGBNO(mp, args->fsbno) < agsize);
2813         ASSERT(args->minlen <= args->maxlen);
2814         ASSERT(args->minlen <= agsize);
2815         ASSERT(args->mod < args->prod);
2816         if (XFS_FSB_TO_AGNO(mp, args->fsbno) >= mp->m_sb.sb_agcount ||
2817             XFS_FSB_TO_AGBNO(mp, args->fsbno) >= agsize ||
2818             args->minlen > args->maxlen || args->minlen > agsize ||
2819             args->mod >= args->prod) {
2820                 args->fsbno = NULLFSBLOCK;
2821                 trace_xfs_alloc_vextent_badargs(args);
2822                 return 0;
2823         }
2824 
2825         switch (type) {
2826         case XFS_ALLOCTYPE_THIS_AG:
2827         case XFS_ALLOCTYPE_NEAR_BNO:
2828         case XFS_ALLOCTYPE_THIS_BNO:
2829                 /*
2830                  * These three force us into a single a.g.
2831                  */
2832                 args->agno = XFS_FSB_TO_AGNO(mp, args->fsbno);
2833                 args->pag = xfs_perag_get(mp, args->agno);
2834                 error = xfs_alloc_fix_freelist(args, 0);
2835                 if (error) {
2836                         trace_xfs_alloc_vextent_nofix(args);
2837                         goto error0;
2838                 }
2839                 if (!args->agbp) {
2840                         trace_xfs_alloc_vextent_noagbp(args);
2841                         break;
2842                 }
2843                 args->agbno = XFS_FSB_TO_AGBNO(mp, args->fsbno);
2844                 if ((error = xfs_alloc_ag_vextent(args)))
2845                         goto error0;
2846                 break;
2847         case XFS_ALLOCTYPE_START_BNO:
2848                 /*
2849                  * Try near allocation first, then anywhere-in-ag after
2850                  * the first a.g. fails.
2851                  */
2852                 if ((args->datatype & XFS_ALLOC_INITIAL_USER_DATA) &&
2853                     (mp->m_flags & XFS_MOUNT_32BITINODES)) {
2854                         args->fsbno = XFS_AGB_TO_FSB(mp,
2855                                         ((mp->m_agfrotor / rotorstep) %
2856                                         mp->m_sb.sb_agcount), 0);
2857                         bump_rotor = 1;
2858                 }
2859                 args->agbno = XFS_FSB_TO_AGBNO(mp, args->fsbno);
2860                 args->type = XFS_ALLOCTYPE_NEAR_BNO;
2861                 /* FALLTHROUGH */
2862         case XFS_ALLOCTYPE_FIRST_AG:
2863                 /*
2864                  * Rotate through the allocation groups looking for a winner.
2865                  */
2866                 if (type == XFS_ALLOCTYPE_FIRST_AG) {
2867                         /*
2868                          * Start with allocation group given by bno.
2869                          */
2870                         args->agno = XFS_FSB_TO_AGNO(mp, args->fsbno);
2871                         args->type = XFS_ALLOCTYPE_THIS_AG;
2872                         sagno = 0;
2873                         flags = 0;
2874                 } else {
2875                         /*
2876                          * Start with the given allocation group.
2877                          */
2878                         args->agno = sagno = XFS_FSB_TO_AGNO(mp, args->fsbno);
2879                         flags = XFS_ALLOC_FLAG_TRYLOCK;
2880                 }
2881                 /*
2882                  * Loop over allocation groups twice; first time with
2883                  * trylock set, second time without.
2884                  */
2885                 for (;;) {
2886                         args->pag = xfs_perag_get(mp, args->agno);
2887                         error = xfs_alloc_fix_freelist(args, flags);
2888                         if (error) {
2889                                 trace_xfs_alloc_vextent_nofix(args);
2890                                 goto error0;
2891                         }
2892                         /*
2893                          * If we get a buffer back then the allocation will fly.
2894                          */
2895                         if (args->agbp) {
2896                                 if ((error = xfs_alloc_ag_vextent(args)))
2897                                         goto error0;
2898                                 break;
2899                         }
2900 
2901                         trace_xfs_alloc_vextent_loopfailed(args);
2902 
2903                         /*
2904                          * Didn't work, figure out the next iteration.
2905                          */
2906                         if (args->agno == sagno &&
2907                             type == XFS_ALLOCTYPE_START_BNO)
2908                                 args->type = XFS_ALLOCTYPE_THIS_AG;
2909                         /*
2910                         * For the first allocation, we can try any AG to get
2911                         * space.  However, if we already have allocated a
2912                         * block, we don't want to try AGs whose number is below
2913                         * sagno. Otherwise, we may end up with out-of-order
2914                         * locking of AGF, which might cause deadlock.
2915                         */
2916                         if (++(args->agno) == mp->m_sb.sb_agcount) {
2917                                 if (args->firstblock != NULLFSBLOCK)
2918                                         args->agno = sagno;
2919                                 else
2920                                         args->agno = 0;
2921                         }
2922                         /*
2923                          * Reached the starting a.g., must either be done
2924                          * or switch to non-trylock mode.
2925                          */
2926                         if (args->agno == sagno) {
2927                                 if (flags == 0) {
2928                                         args->agbno = NULLAGBLOCK;
2929                                         trace_xfs_alloc_vextent_allfailed(args);
2930                                         break;
2931                                 }
2932 
2933                                 flags = 0;
2934                                 if (type == XFS_ALLOCTYPE_START_BNO) {
2935                                         args->agbno = XFS_FSB_TO_AGBNO(mp,
2936                                                 args->fsbno);
2937                                         args->type = XFS_ALLOCTYPE_NEAR_BNO;
2938                                 }
2939                         }
2940                         xfs_perag_put(args->pag);
2941                 }
2942                 if (bump_rotor) {
2943                         if (args->agno == sagno)
2944                                 mp->m_agfrotor = (mp->m_agfrotor + 1) %
2945                                         (mp->m_sb.sb_agcount * rotorstep);
2946                         else
2947                                 mp->m_agfrotor = (args->agno * rotorstep + 1) %
2948                                         (mp->m_sb.sb_agcount * rotorstep);
2949                 }
2950                 break;
2951         default:
2952                 ASSERT(0);
2953                 /* NOTREACHED */
2954         }
2955         if (args->agbno == NULLAGBLOCK)
2956                 args->fsbno = NULLFSBLOCK;
2957         else {
2958                 args->fsbno = XFS_AGB_TO_FSB(mp, args->agno, args->agbno);
2959 #ifdef DEBUG
2960                 ASSERT(args->len >= args->minlen);
2961                 ASSERT(args->len <= args->maxlen);
2962                 ASSERT(args->agbno % args->alignment == 0);
2963                 XFS_AG_CHECK_DADDR(mp, XFS_FSB_TO_DADDR(mp, args->fsbno),
2964                         args->len);
2965 #endif
2966 
2967                 /* Zero the extent if we were asked to do so */
2968                 if (args->datatype & XFS_ALLOC_USERDATA_ZERO) {
2969                         error = xfs_zero_extent(args->ip, args->fsbno, args->len);
2970                         if (error)
2971                                 goto error0;
2972                 }
2973 
2974         }
2975         xfs_perag_put(args->pag);
2976         return 0;
2977 error0:
2978         xfs_perag_put(args->pag);
2979         return error;
2980 }
2981 
2982 /* Ensure that the freelist is at full capacity. */
2983 int
2984 xfs_free_extent_fix_freelist(
2985         struct xfs_trans        *tp,
2986         xfs_agnumber_t          agno,
2987         struct xfs_buf          **agbp)
2988 {
2989         struct xfs_alloc_arg    args;
2990         int                     error;
2991 
2992         memset(&args, 0, sizeof(struct xfs_alloc_arg));
2993         args.tp = tp;
2994         args.mp = tp->t_mountp;
2995         args.agno = agno;
2996 
2997         /*
2998          * validate that the block number is legal - the enables us to detect
2999          * and handle a silent filesystem corruption rather than crashing.
3000          */
3001         if (args.agno >= args.mp->m_sb.sb_agcount)
3002                 return -EFSCORRUPTED;
3003 
3004         args.pag = xfs_perag_get(args.mp, args.agno);
3005         ASSERT(args.pag);
3006 
3007         error = xfs_alloc_fix_freelist(&args, XFS_ALLOC_FLAG_FREEING);
3008         if (error)
3009                 goto out;
3010 
3011         *agbp = args.agbp;
3012 out:
3013         xfs_perag_put(args.pag);
3014         return error;
3015 }
3016 
3017 /*
3018  * Free an extent.
3019  * Just break up the extent address and hand off to xfs_free_ag_extent
3020  * after fixing up the freelist.
3021  */
3022 int                             /* error */
3023 __xfs_free_extent(
3024         struct xfs_trans        *tp,    /* transaction pointer */
3025         xfs_fsblock_t           bno,    /* starting block number of extent */
3026         xfs_extlen_t            len,    /* length of extent */
3027         struct xfs_owner_info   *oinfo, /* extent owner */
3028         enum xfs_ag_resv_type   type,   /* block reservation type */
3029         bool                    skip_discard)
3030 {
3031         struct xfs_mount        *mp = tp->t_mountp;
3032         struct xfs_buf          *agbp;
3033         xfs_agnumber_t          agno = XFS_FSB_TO_AGNO(mp, bno);
3034         xfs_agblock_t           agbno = XFS_FSB_TO_AGBNO(mp, bno);
3035         int                     error;
3036         unsigned int            busy_flags = 0;
3037 
3038         ASSERT(len != 0);
3039         ASSERT(type != XFS_AG_RESV_AGFL);
3040 
3041         if (XFS_TEST_ERROR(false, mp,
3042                         XFS_ERRTAG_FREE_EXTENT))
3043                 return -EIO;
3044 
3045         error = xfs_free_extent_fix_freelist(tp, agno, &agbp);
3046         if (error)
3047                 return error;
3048 
3049         XFS_WANT_CORRUPTED_GOTO(mp, agbno < mp->m_sb.sb_agblocks, err);
3050 
3051         /* validate the extent size is legal now we have the agf locked */
3052         XFS_WANT_CORRUPTED_GOTO(mp,
3053                 agbno + len <= be32_to_cpu(XFS_BUF_TO_AGF(agbp)->agf_length),
3054                                 err);
3055 
3056         error = xfs_free_ag_extent(tp, agbp, agno, agbno, len, oinfo, type);
3057         if (error)
3058                 goto err;
3059 
3060         if (skip_discard)
3061                 busy_flags |= XFS_EXTENT_BUSY_SKIP_DISCARD;
3062         xfs_extent_busy_insert(tp, agno, agbno, len, busy_flags);
3063         return 0;
3064 
3065 err:
3066         xfs_trans_brelse(tp, agbp);
3067         return error;
3068 }
3069 
3070 struct xfs_alloc_query_range_info {
3071         xfs_alloc_query_range_fn        fn;
3072         void                            *priv;
3073 };
3074 
3075 /* Format btree record and pass to our callback. */
3076 STATIC int
3077 xfs_alloc_query_range_helper(
3078         struct xfs_btree_cur            *cur,
3079         union xfs_btree_rec             *rec,
3080         void                            *priv)
3081 {
3082         struct xfs_alloc_query_range_info       *query = priv;
3083         struct xfs_alloc_rec_incore             irec;
3084 
3085         irec.ar_startblock = be32_to_cpu(rec->alloc.ar_startblock);
3086         irec.ar_blockcount = be32_to_cpu(rec->alloc.ar_blockcount);
3087         return query->fn(cur, &irec, query->priv);
3088 }
3089 
3090 /* Find all free space within a given range of blocks. */
3091 int
3092 xfs_alloc_query_range(
3093         struct xfs_btree_cur                    *cur,
3094         struct xfs_alloc_rec_incore             *low_rec,
3095         struct xfs_alloc_rec_incore             *high_rec,
3096         xfs_alloc_query_range_fn                fn,
3097         void                                    *priv)
3098 {
3099         union xfs_btree_irec                    low_brec;
3100         union xfs_btree_irec                    high_brec;
3101         struct xfs_alloc_query_range_info       query;
3102 
3103         ASSERT(cur->bc_btnum == XFS_BTNUM_BNO);
3104         low_brec.a = *low_rec;
3105         high_brec.a = *high_rec;
3106         query.priv = priv;
3107         query.fn = fn;
3108         return xfs_btree_query_range(cur, &low_brec, &high_brec,
3109                         xfs_alloc_query_range_helper, &query);
3110 }
3111 
3112 /* Find all free space records. */
3113 int
3114 xfs_alloc_query_all(
3115         struct xfs_btree_cur                    *cur,
3116         xfs_alloc_query_range_fn                fn,
3117         void                                    *priv)
3118 {
3119         struct xfs_alloc_query_range_info       query;
3120 
3121         ASSERT(cur->bc_btnum == XFS_BTNUM_BNO);
3122         query.priv = priv;
3123         query.fn = fn;
3124         return xfs_btree_query_all(cur, xfs_alloc_query_range_helper, &query);
3125 }
3126 
3127 /* Is there a record covering a given extent? */
3128 int
3129 xfs_alloc_has_record(
3130         struct xfs_btree_cur    *cur,
3131         xfs_agblock_t           bno,
3132         xfs_extlen_t            len,
3133         bool                    *exists)
3134 {
3135         union xfs_btree_irec    low;
3136         union xfs_btree_irec    high;
3137 
3138         memset(&low, 0, sizeof(low));
3139         low.a.ar_startblock = bno;
3140         memset(&high, 0xFF, sizeof(high));
3141         high.a.ar_startblock = bno + len - 1;
3142 
3143         return xfs_btree_has_record(cur, &low, &high, exists);
3144 }
3145 
3146 /*
3147  * Walk all the blocks in the AGFL.  The @walk_fn can return any negative
3148  * error code or XFS_BTREE_QUERY_RANGE_ABORT.
3149  */
3150 int
3151 xfs_agfl_walk(
3152         struct xfs_mount        *mp,
3153         struct xfs_agf          *agf,
3154         struct xfs_buf          *agflbp,
3155         xfs_agfl_walk_fn        walk_fn,
3156         void                    *priv)
3157 {
3158         __be32                  *agfl_bno;
3159         unsigned int            i;
3160         int                     error;
3161 
3162         agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, agflbp);
3163         i = be32_to_cpu(agf->agf_flfirst);
3164 
3165         /* Nothing to walk in an empty AGFL. */
3166         if (agf->agf_flcount == cpu_to_be32(0))
3167                 return 0;
3168 
3169         /* Otherwise, walk from first to last, wrapping as needed. */
3170         for (;;) {
3171                 error = walk_fn(mp, be32_to_cpu(agfl_bno[i]), priv);
3172                 if (error)
3173                         return error;
3174                 if (i == be32_to_cpu(agf->agf_fllast))
3175                         break;
3176                 if (++i == xfs_agfl_size(mp))
3177                         i = 0;
3178         }
3179 
3180         return 0;
3181 }
3182 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp