GNU Linux-libre 5.19-rc6-gnu
[releases.git] / fs / xfs / xfs_iwalk.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright (C) 2019 Oracle.  All Rights Reserved.
4  * Author: Darrick J. Wong <darrick.wong@oracle.com>
5  */
6 #include "xfs.h"
7 #include "xfs_fs.h"
8 #include "xfs_shared.h"
9 #include "xfs_format.h"
10 #include "xfs_log_format.h"
11 #include "xfs_trans_resv.h"
12 #include "xfs_mount.h"
13 #include "xfs_inode.h"
14 #include "xfs_btree.h"
15 #include "xfs_ialloc.h"
16 #include "xfs_ialloc_btree.h"
17 #include "xfs_iwalk.h"
18 #include "xfs_error.h"
19 #include "xfs_trace.h"
20 #include "xfs_icache.h"
21 #include "xfs_health.h"
22 #include "xfs_trans.h"
23 #include "xfs_pwork.h"
24 #include "xfs_ag.h"
25
26 /*
27  * Walking Inodes in the Filesystem
28  * ================================
29  *
30  * This iterator function walks a subset of filesystem inodes in increasing
31  * order from @startino until there are no more inodes.  For each allocated
32  * inode it finds, it calls a walk function with the relevant inode number and
33  * a pointer to caller-provided data.  The walk function can return the usual
34  * negative error code to stop the iteration; 0 to continue the iteration; or
35  * -ECANCELED to stop the iteration.  This return value is returned to the
36  * caller.
37  *
38  * Internally, we allow the walk function to do anything, which means that we
39  * cannot maintain the inobt cursor or our lock on the AGI buffer.  We
40  * therefore cache the inobt records in kernel memory and only call the walk
41  * function when our memory buffer is full.  @nr_recs is the number of records
42  * that we've cached, and @sz_recs is the size of our cache.
43  *
44  * It is the responsibility of the walk function to ensure it accesses
45  * allocated inodes, as the inobt records may be stale by the time they are
46  * acted upon.
47  */
48
49 struct xfs_iwalk_ag {
50         /* parallel work control data; will be null if single threaded */
51         struct xfs_pwork                pwork;
52
53         struct xfs_mount                *mp;
54         struct xfs_trans                *tp;
55         struct xfs_perag                *pag;
56
57         /* Where do we start the traversal? */
58         xfs_ino_t                       startino;
59
60         /* What was the last inode number we saw when iterating the inobt? */
61         xfs_ino_t                       lastino;
62
63         /* Array of inobt records we cache. */
64         struct xfs_inobt_rec_incore     *recs;
65
66         /* Number of entries allocated for the @recs array. */
67         unsigned int                    sz_recs;
68
69         /* Number of entries in the @recs array that are in use. */
70         unsigned int                    nr_recs;
71
72         /* Inode walk function and data pointer. */
73         xfs_iwalk_fn                    iwalk_fn;
74         xfs_inobt_walk_fn               inobt_walk_fn;
75         void                            *data;
76
77         /*
78          * Make it look like the inodes up to startino are free so that
79          * bulkstat can start its inode iteration at the correct place without
80          * needing to special case everywhere.
81          */
82         unsigned int                    trim_start:1;
83
84         /* Skip empty inobt records? */
85         unsigned int                    skip_empty:1;
86
87         /* Drop the (hopefully empty) transaction when calling iwalk_fn. */
88         unsigned int                    drop_trans:1;
89 };
90
91 /*
92  * Loop over all clusters in a chunk for a given incore inode allocation btree
93  * record.  Do a readahead if there are any allocated inodes in that cluster.
94  */
95 STATIC void
96 xfs_iwalk_ichunk_ra(
97         struct xfs_mount                *mp,
98         struct xfs_perag                *pag,
99         struct xfs_inobt_rec_incore     *irec)
100 {
101         struct xfs_ino_geometry         *igeo = M_IGEO(mp);
102         xfs_agblock_t                   agbno;
103         struct blk_plug                 plug;
104         int                             i;      /* inode chunk index */
105
106         agbno = XFS_AGINO_TO_AGBNO(mp, irec->ir_startino);
107
108         blk_start_plug(&plug);
109         for (i = 0; i < XFS_INODES_PER_CHUNK; i += igeo->inodes_per_cluster) {
110                 xfs_inofree_t   imask;
111
112                 imask = xfs_inobt_maskn(i, igeo->inodes_per_cluster);
113                 if (imask & ~irec->ir_free) {
114                         xfs_btree_reada_bufs(mp, pag->pag_agno, agbno,
115                                         igeo->blocks_per_cluster,
116                                         &xfs_inode_buf_ops);
117                 }
118                 agbno += igeo->blocks_per_cluster;
119         }
120         blk_finish_plug(&plug);
121 }
122
123 /*
124  * Set the bits in @irec's free mask that correspond to the inodes before
125  * @agino so that we skip them.  This is how we restart an inode walk that was
126  * interrupted in the middle of an inode record.
127  */
128 STATIC void
129 xfs_iwalk_adjust_start(
130         xfs_agino_t                     agino,  /* starting inode of chunk */
131         struct xfs_inobt_rec_incore     *irec)  /* btree record */
132 {
133         int                             idx;    /* index into inode chunk */
134         int                             i;
135
136         idx = agino - irec->ir_startino;
137
138         /*
139          * We got a right chunk with some left inodes allocated at it.  Grab
140          * the chunk record.  Mark all the uninteresting inodes free because
141          * they're before our start point.
142          */
143         for (i = 0; i < idx; i++) {
144                 if (XFS_INOBT_MASK(i) & ~irec->ir_free)
145                         irec->ir_freecount++;
146         }
147
148         irec->ir_free |= xfs_inobt_maskn(0, idx);
149 }
150
151 /* Allocate memory for a walk. */
152 STATIC int
153 xfs_iwalk_alloc(
154         struct xfs_iwalk_ag     *iwag)
155 {
156         size_t                  size;
157
158         ASSERT(iwag->recs == NULL);
159         iwag->nr_recs = 0;
160
161         /* Allocate a prefetch buffer for inobt records. */
162         size = iwag->sz_recs * sizeof(struct xfs_inobt_rec_incore);
163         iwag->recs = kmem_alloc(size, KM_MAYFAIL);
164         if (iwag->recs == NULL)
165                 return -ENOMEM;
166
167         return 0;
168 }
169
170 /* Free memory we allocated for a walk. */
171 STATIC void
172 xfs_iwalk_free(
173         struct xfs_iwalk_ag     *iwag)
174 {
175         kmem_free(iwag->recs);
176         iwag->recs = NULL;
177 }
178
179 /* For each inuse inode in each cached inobt record, call our function. */
180 STATIC int
181 xfs_iwalk_ag_recs(
182         struct xfs_iwalk_ag     *iwag)
183 {
184         struct xfs_mount        *mp = iwag->mp;
185         struct xfs_trans        *tp = iwag->tp;
186         struct xfs_perag        *pag = iwag->pag;
187         xfs_ino_t               ino;
188         unsigned int            i, j;
189         int                     error;
190
191         for (i = 0; i < iwag->nr_recs; i++) {
192                 struct xfs_inobt_rec_incore     *irec = &iwag->recs[i];
193
194                 trace_xfs_iwalk_ag_rec(mp, pag->pag_agno, irec);
195
196                 if (xfs_pwork_want_abort(&iwag->pwork))
197                         return 0;
198
199                 if (iwag->inobt_walk_fn) {
200                         error = iwag->inobt_walk_fn(mp, tp, pag->pag_agno, irec,
201                                         iwag->data);
202                         if (error)
203                                 return error;
204                 }
205
206                 if (!iwag->iwalk_fn)
207                         continue;
208
209                 for (j = 0; j < XFS_INODES_PER_CHUNK; j++) {
210                         if (xfs_pwork_want_abort(&iwag->pwork))
211                                 return 0;
212
213                         /* Skip if this inode is free */
214                         if (XFS_INOBT_MASK(j) & irec->ir_free)
215                                 continue;
216
217                         /* Otherwise call our function. */
218                         ino = XFS_AGINO_TO_INO(mp, pag->pag_agno,
219                                                 irec->ir_startino + j);
220                         error = iwag->iwalk_fn(mp, tp, ino, iwag->data);
221                         if (error)
222                                 return error;
223                 }
224         }
225
226         return 0;
227 }
228
229 /* Delete cursor and let go of AGI. */
230 static inline void
231 xfs_iwalk_del_inobt(
232         struct xfs_trans        *tp,
233         struct xfs_btree_cur    **curpp,
234         struct xfs_buf          **agi_bpp,
235         int                     error)
236 {
237         if (*curpp) {
238                 xfs_btree_del_cursor(*curpp, error);
239                 *curpp = NULL;
240         }
241         if (*agi_bpp) {
242                 xfs_trans_brelse(tp, *agi_bpp);
243                 *agi_bpp = NULL;
244         }
245 }
246
247 /*
248  * Set ourselves up for walking inobt records starting from a given point in
249  * the filesystem.
250  *
251  * If caller passed in a nonzero start inode number, load the record from the
252  * inobt and make the record look like all the inodes before agino are free so
253  * that we skip them, and then move the cursor to the next inobt record.  This
254  * is how we support starting an iwalk in the middle of an inode chunk.
255  *
256  * If the caller passed in a start number of zero, move the cursor to the first
257  * inobt record.
258  *
259  * The caller is responsible for cleaning up the cursor and buffer pointer
260  * regardless of the error status.
261  */
262 STATIC int
263 xfs_iwalk_ag_start(
264         struct xfs_iwalk_ag     *iwag,
265         xfs_agino_t             agino,
266         struct xfs_btree_cur    **curpp,
267         struct xfs_buf          **agi_bpp,
268         int                     *has_more)
269 {
270         struct xfs_mount        *mp = iwag->mp;
271         struct xfs_trans        *tp = iwag->tp;
272         struct xfs_perag        *pag = iwag->pag;
273         struct xfs_inobt_rec_incore *irec;
274         int                     error;
275
276         /* Set up a fresh cursor and empty the inobt cache. */
277         iwag->nr_recs = 0;
278         error = xfs_inobt_cur(mp, tp, pag, XFS_BTNUM_INO, curpp, agi_bpp);
279         if (error)
280                 return error;
281
282         /* Starting at the beginning of the AG?  That's easy! */
283         if (agino == 0)
284                 return xfs_inobt_lookup(*curpp, 0, XFS_LOOKUP_GE, has_more);
285
286         /*
287          * Otherwise, we have to grab the inobt record where we left off, stuff
288          * the record into our cache, and then see if there are more records.
289          * We require a lookup cache of at least two elements so that the
290          * caller doesn't have to deal with tearing down the cursor to walk the
291          * records.
292          */
293         error = xfs_inobt_lookup(*curpp, agino, XFS_LOOKUP_LE, has_more);
294         if (error)
295                 return error;
296
297         /*
298          * If the LE lookup at @agino yields no records, jump ahead to the
299          * inobt cursor increment to see if there are more records to process.
300          */
301         if (!*has_more)
302                 goto out_advance;
303
304         /* Get the record, should always work */
305         irec = &iwag->recs[iwag->nr_recs];
306         error = xfs_inobt_get_rec(*curpp, irec, has_more);
307         if (error)
308                 return error;
309         if (XFS_IS_CORRUPT(mp, *has_more != 1))
310                 return -EFSCORRUPTED;
311
312         iwag->lastino = XFS_AGINO_TO_INO(mp, pag->pag_agno,
313                                 irec->ir_startino + XFS_INODES_PER_CHUNK - 1);
314
315         /*
316          * If the LE lookup yielded an inobt record before the cursor position,
317          * skip it and see if there's another one after it.
318          */
319         if (irec->ir_startino + XFS_INODES_PER_CHUNK <= agino)
320                 goto out_advance;
321
322         /*
323          * If agino fell in the middle of the inode record, make it look like
324          * the inodes up to agino are free so that we don't return them again.
325          */
326         if (iwag->trim_start)
327                 xfs_iwalk_adjust_start(agino, irec);
328
329         /*
330          * The prefetch calculation is supposed to give us a large enough inobt
331          * record cache that grab_ichunk can stage a partial first record and
332          * the loop body can cache a record without having to check for cache
333          * space until after it reads an inobt record.
334          */
335         iwag->nr_recs++;
336         ASSERT(iwag->nr_recs < iwag->sz_recs);
337
338 out_advance:
339         return xfs_btree_increment(*curpp, 0, has_more);
340 }
341
342 /*
343  * The inobt record cache is full, so preserve the inobt cursor state and
344  * run callbacks on the cached inobt records.  When we're done, restore the
345  * cursor state to wherever the cursor would have been had the cache not been
346  * full (and therefore we could've just incremented the cursor) if *@has_more
347  * is true.  On exit, *@has_more will indicate whether or not the caller should
348  * try for more inode records.
349  */
350 STATIC int
351 xfs_iwalk_run_callbacks(
352         struct xfs_iwalk_ag             *iwag,
353         struct xfs_btree_cur            **curpp,
354         struct xfs_buf                  **agi_bpp,
355         int                             *has_more)
356 {
357         struct xfs_mount                *mp = iwag->mp;
358         struct xfs_inobt_rec_incore     *irec;
359         xfs_agino_t                     next_agino;
360         int                             error;
361
362         next_agino = XFS_INO_TO_AGINO(mp, iwag->lastino) + 1;
363
364         ASSERT(iwag->nr_recs > 0);
365
366         /* Delete cursor but remember the last record we cached... */
367         xfs_iwalk_del_inobt(iwag->tp, curpp, agi_bpp, 0);
368         irec = &iwag->recs[iwag->nr_recs - 1];
369         ASSERT(next_agino >= irec->ir_startino + XFS_INODES_PER_CHUNK);
370
371         if (iwag->drop_trans) {
372                 xfs_trans_cancel(iwag->tp);
373                 iwag->tp = NULL;
374         }
375
376         error = xfs_iwalk_ag_recs(iwag);
377         if (error)
378                 return error;
379
380         /* ...empty the cache... */
381         iwag->nr_recs = 0;
382
383         if (!has_more)
384                 return 0;
385
386         if (iwag->drop_trans) {
387                 error = xfs_trans_alloc_empty(mp, &iwag->tp);
388                 if (error)
389                         return error;
390         }
391
392         /* ...and recreate the cursor just past where we left off. */
393         error = xfs_inobt_cur(mp, iwag->tp, iwag->pag, XFS_BTNUM_INO, curpp,
394                         agi_bpp);
395         if (error)
396                 return error;
397
398         return xfs_inobt_lookup(*curpp, next_agino, XFS_LOOKUP_GE, has_more);
399 }
400
401 /* Walk all inodes in a single AG, from @iwag->startino to the end of the AG. */
402 STATIC int
403 xfs_iwalk_ag(
404         struct xfs_iwalk_ag             *iwag)
405 {
406         struct xfs_mount                *mp = iwag->mp;
407         struct xfs_perag                *pag = iwag->pag;
408         struct xfs_buf                  *agi_bp = NULL;
409         struct xfs_btree_cur            *cur = NULL;
410         xfs_agino_t                     agino;
411         int                             has_more;
412         int                             error = 0;
413
414         /* Set up our cursor at the right place in the inode btree. */
415         ASSERT(pag->pag_agno == XFS_INO_TO_AGNO(mp, iwag->startino));
416         agino = XFS_INO_TO_AGINO(mp, iwag->startino);
417         error = xfs_iwalk_ag_start(iwag, agino, &cur, &agi_bp, &has_more);
418
419         while (!error && has_more) {
420                 struct xfs_inobt_rec_incore     *irec;
421                 xfs_ino_t                       rec_fsino;
422
423                 cond_resched();
424                 if (xfs_pwork_want_abort(&iwag->pwork))
425                         goto out;
426
427                 /* Fetch the inobt record. */
428                 irec = &iwag->recs[iwag->nr_recs];
429                 error = xfs_inobt_get_rec(cur, irec, &has_more);
430                 if (error || !has_more)
431                         break;
432
433                 /* Make sure that we always move forward. */
434                 rec_fsino = XFS_AGINO_TO_INO(mp, pag->pag_agno, irec->ir_startino);
435                 if (iwag->lastino != NULLFSINO &&
436                     XFS_IS_CORRUPT(mp, iwag->lastino >= rec_fsino)) {
437                         error = -EFSCORRUPTED;
438                         goto out;
439                 }
440                 iwag->lastino = rec_fsino + XFS_INODES_PER_CHUNK - 1;
441
442                 /* No allocated inodes in this chunk; skip it. */
443                 if (iwag->skip_empty && irec->ir_freecount == irec->ir_count) {
444                         error = xfs_btree_increment(cur, 0, &has_more);
445                         if (error)
446                                 break;
447                         continue;
448                 }
449
450                 /*
451                  * Start readahead for this inode chunk in anticipation of
452                  * walking the inodes.
453                  */
454                 if (iwag->iwalk_fn)
455                         xfs_iwalk_ichunk_ra(mp, pag, irec);
456
457                 /*
458                  * If there's space in the buffer for more records, increment
459                  * the btree cursor and grab more.
460                  */
461                 if (++iwag->nr_recs < iwag->sz_recs) {
462                         error = xfs_btree_increment(cur, 0, &has_more);
463                         if (error || !has_more)
464                                 break;
465                         continue;
466                 }
467
468                 /*
469                  * Otherwise, we need to save cursor state and run the callback
470                  * function on the cached records.  The run_callbacks function
471                  * is supposed to return a cursor pointing to the record where
472                  * we would be if we had been able to increment like above.
473                  */
474                 ASSERT(has_more);
475                 error = xfs_iwalk_run_callbacks(iwag, &cur, &agi_bp, &has_more);
476         }
477
478         if (iwag->nr_recs == 0 || error)
479                 goto out;
480
481         /* Walk the unprocessed records in the cache. */
482         error = xfs_iwalk_run_callbacks(iwag, &cur, &agi_bp, &has_more);
483
484 out:
485         xfs_iwalk_del_inobt(iwag->tp, &cur, &agi_bp, error);
486         return error;
487 }
488
489 /*
490  * We experimentally determined that the reduction in ioctl call overhead
491  * diminishes when userspace asks for more than 2048 inodes, so we'll cap
492  * prefetch at this point.
493  */
494 #define IWALK_MAX_INODE_PREFETCH        (2048U)
495
496 /*
497  * Given the number of inodes to prefetch, set the number of inobt records that
498  * we cache in memory, which controls the number of inodes we try to read
499  * ahead.  Set the maximum if @inodes == 0.
500  */
501 static inline unsigned int
502 xfs_iwalk_prefetch(
503         unsigned int            inodes)
504 {
505         unsigned int            inobt_records;
506
507         /*
508          * If the caller didn't tell us the number of inodes they wanted,
509          * assume the maximum prefetch possible for best performance.
510          * Otherwise, cap prefetch at that maximum so that we don't start an
511          * absurd amount of prefetch.
512          */
513         if (inodes == 0)
514                 inodes = IWALK_MAX_INODE_PREFETCH;
515         inodes = min(inodes, IWALK_MAX_INODE_PREFETCH);
516
517         /* Round the inode count up to a full chunk. */
518         inodes = round_up(inodes, XFS_INODES_PER_CHUNK);
519
520         /*
521          * In order to convert the number of inodes to prefetch into an
522          * estimate of the number of inobt records to cache, we require a
523          * conversion factor that reflects our expectations of the average
524          * loading factor of an inode chunk.  Based on data gathered, most
525          * (but not all) filesystems manage to keep the inode chunks totally
526          * full, so we'll underestimate slightly so that our readahead will
527          * still deliver the performance we want on aging filesystems:
528          *
529          * inobt = inodes / (INODES_PER_CHUNK * (4 / 5));
530          *
531          * The funny math is to avoid integer division.
532          */
533         inobt_records = (inodes * 5) / (4 * XFS_INODES_PER_CHUNK);
534
535         /*
536          * Allocate enough space to prefetch at least two inobt records so that
537          * we can cache both the record where the iwalk started and the next
538          * record.  This simplifies the AG inode walk loop setup code.
539          */
540         return max(inobt_records, 2U);
541 }
542
543 /*
544  * Walk all inodes in the filesystem starting from @startino.  The @iwalk_fn
545  * will be called for each allocated inode, being passed the inode's number and
546  * @data.  @max_prefetch controls how many inobt records' worth of inodes we
547  * try to readahead.
548  */
549 int
550 xfs_iwalk(
551         struct xfs_mount        *mp,
552         struct xfs_trans        *tp,
553         xfs_ino_t               startino,
554         unsigned int            flags,
555         xfs_iwalk_fn            iwalk_fn,
556         unsigned int            inode_records,
557         void                    *data)
558 {
559         struct xfs_iwalk_ag     iwag = {
560                 .mp             = mp,
561                 .tp             = tp,
562                 .iwalk_fn       = iwalk_fn,
563                 .data           = data,
564                 .startino       = startino,
565                 .sz_recs        = xfs_iwalk_prefetch(inode_records),
566                 .trim_start     = 1,
567                 .skip_empty     = 1,
568                 .pwork          = XFS_PWORK_SINGLE_THREADED,
569                 .lastino        = NULLFSINO,
570         };
571         struct xfs_perag        *pag;
572         xfs_agnumber_t          agno = XFS_INO_TO_AGNO(mp, startino);
573         int                     error;
574
575         ASSERT(agno < mp->m_sb.sb_agcount);
576         ASSERT(!(flags & ~XFS_IWALK_FLAGS_ALL));
577
578         error = xfs_iwalk_alloc(&iwag);
579         if (error)
580                 return error;
581
582         for_each_perag_from(mp, agno, pag) {
583                 iwag.pag = pag;
584                 error = xfs_iwalk_ag(&iwag);
585                 if (error)
586                         break;
587                 iwag.startino = XFS_AGINO_TO_INO(mp, agno + 1, 0);
588                 if (flags & XFS_INOBT_WALK_SAME_AG)
589                         break;
590                 iwag.pag = NULL;
591         }
592
593         if (iwag.pag)
594                 xfs_perag_put(pag);
595         xfs_iwalk_free(&iwag);
596         return error;
597 }
598
599 /* Run per-thread iwalk work. */
600 static int
601 xfs_iwalk_ag_work(
602         struct xfs_mount        *mp,
603         struct xfs_pwork        *pwork)
604 {
605         struct xfs_iwalk_ag     *iwag;
606         int                     error = 0;
607
608         iwag = container_of(pwork, struct xfs_iwalk_ag, pwork);
609         if (xfs_pwork_want_abort(pwork))
610                 goto out;
611
612         error = xfs_iwalk_alloc(iwag);
613         if (error)
614                 goto out;
615         /*
616          * Grab an empty transaction so that we can use its recursive buffer
617          * locking abilities to detect cycles in the inobt without deadlocking.
618          */
619         error = xfs_trans_alloc_empty(mp, &iwag->tp);
620         if (error)
621                 goto out;
622         iwag->drop_trans = 1;
623
624         error = xfs_iwalk_ag(iwag);
625         if (iwag->tp)
626                 xfs_trans_cancel(iwag->tp);
627         xfs_iwalk_free(iwag);
628 out:
629         xfs_perag_put(iwag->pag);
630         kmem_free(iwag);
631         return error;
632 }
633
634 /*
635  * Walk all the inodes in the filesystem using multiple threads to process each
636  * AG.
637  */
638 int
639 xfs_iwalk_threaded(
640         struct xfs_mount        *mp,
641         xfs_ino_t               startino,
642         unsigned int            flags,
643         xfs_iwalk_fn            iwalk_fn,
644         unsigned int            inode_records,
645         bool                    polled,
646         void                    *data)
647 {
648         struct xfs_pwork_ctl    pctl;
649         struct xfs_perag        *pag;
650         xfs_agnumber_t          agno = XFS_INO_TO_AGNO(mp, startino);
651         int                     error;
652
653         ASSERT(agno < mp->m_sb.sb_agcount);
654         ASSERT(!(flags & ~XFS_IWALK_FLAGS_ALL));
655
656         error = xfs_pwork_init(mp, &pctl, xfs_iwalk_ag_work, "xfs_iwalk");
657         if (error)
658                 return error;
659
660         for_each_perag_from(mp, agno, pag) {
661                 struct xfs_iwalk_ag     *iwag;
662
663                 if (xfs_pwork_ctl_want_abort(&pctl))
664                         break;
665
666                 iwag = kmem_zalloc(sizeof(struct xfs_iwalk_ag), 0);
667                 iwag->mp = mp;
668
669                 /*
670                  * perag is being handed off to async work, so take another
671                  * reference for the async work to release.
672                  */
673                 atomic_inc(&pag->pag_ref);
674                 iwag->pag = pag;
675                 iwag->iwalk_fn = iwalk_fn;
676                 iwag->data = data;
677                 iwag->startino = startino;
678                 iwag->sz_recs = xfs_iwalk_prefetch(inode_records);
679                 iwag->lastino = NULLFSINO;
680                 xfs_pwork_queue(&pctl, &iwag->pwork);
681                 startino = XFS_AGINO_TO_INO(mp, pag->pag_agno + 1, 0);
682                 if (flags & XFS_INOBT_WALK_SAME_AG)
683                         break;
684         }
685         if (pag)
686                 xfs_perag_put(pag);
687         if (polled)
688                 xfs_pwork_poll(&pctl);
689         return xfs_pwork_destroy(&pctl);
690 }
691
692 /*
693  * Allow callers to cache up to a page's worth of inobt records.  This reflects
694  * the existing inumbers prefetching behavior.  Since the inobt walk does not
695  * itself do anything with the inobt records, we can set a fairly high limit
696  * here.
697  */
698 #define MAX_INOBT_WALK_PREFETCH \
699         (PAGE_SIZE / sizeof(struct xfs_inobt_rec_incore))
700
701 /*
702  * Given the number of records that the user wanted, set the number of inobt
703  * records that we buffer in memory.  Set the maximum if @inobt_records == 0.
704  */
705 static inline unsigned int
706 xfs_inobt_walk_prefetch(
707         unsigned int            inobt_records)
708 {
709         /*
710          * If the caller didn't tell us the number of inobt records they
711          * wanted, assume the maximum prefetch possible for best performance.
712          */
713         if (inobt_records == 0)
714                 inobt_records = MAX_INOBT_WALK_PREFETCH;
715
716         /*
717          * Allocate enough space to prefetch at least two inobt records so that
718          * we can cache both the record where the iwalk started and the next
719          * record.  This simplifies the AG inode walk loop setup code.
720          */
721         inobt_records = max(inobt_records, 2U);
722
723         /*
724          * Cap prefetch at that maximum so that we don't use an absurd amount
725          * of memory.
726          */
727         return min_t(unsigned int, inobt_records, MAX_INOBT_WALK_PREFETCH);
728 }
729
730 /*
731  * Walk all inode btree records in the filesystem starting from @startino.  The
732  * @inobt_walk_fn will be called for each btree record, being passed the incore
733  * record and @data.  @max_prefetch controls how many inobt records we try to
734  * cache ahead of time.
735  */
736 int
737 xfs_inobt_walk(
738         struct xfs_mount        *mp,
739         struct xfs_trans        *tp,
740         xfs_ino_t               startino,
741         unsigned int            flags,
742         xfs_inobt_walk_fn       inobt_walk_fn,
743         unsigned int            inobt_records,
744         void                    *data)
745 {
746         struct xfs_iwalk_ag     iwag = {
747                 .mp             = mp,
748                 .tp             = tp,
749                 .inobt_walk_fn  = inobt_walk_fn,
750                 .data           = data,
751                 .startino       = startino,
752                 .sz_recs        = xfs_inobt_walk_prefetch(inobt_records),
753                 .pwork          = XFS_PWORK_SINGLE_THREADED,
754                 .lastino        = NULLFSINO,
755         };
756         struct xfs_perag        *pag;
757         xfs_agnumber_t          agno = XFS_INO_TO_AGNO(mp, startino);
758         int                     error;
759
760         ASSERT(agno < mp->m_sb.sb_agcount);
761         ASSERT(!(flags & ~XFS_INOBT_WALK_FLAGS_ALL));
762
763         error = xfs_iwalk_alloc(&iwag);
764         if (error)
765                 return error;
766
767         for_each_perag_from(mp, agno, pag) {
768                 iwag.pag = pag;
769                 error = xfs_iwalk_ag(&iwag);
770                 if (error)
771                         break;
772                 iwag.startino = XFS_AGINO_TO_INO(mp, pag->pag_agno + 1, 0);
773                 if (flags & XFS_INOBT_WALK_SAME_AG)
774                         break;
775                 iwag.pag = NULL;
776         }
777
778         if (iwag.pag)
779                 xfs_perag_put(pag);
780         xfs_iwalk_free(&iwag);
781         return error;
782 }