Line data Source code
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 1757120151 : xfs_iwalk_ichunk_ra(
97 : struct xfs_mount *mp,
98 : struct xfs_perag *pag,
99 : struct xfs_inobt_rec_incore *irec)
100 : {
101 1757120151 : struct xfs_ino_geometry *igeo = M_IGEO(mp);
102 1757120151 : xfs_agblock_t agbno;
103 1757120151 : struct blk_plug plug;
104 1757120151 : int i; /* inode chunk index */
105 :
106 1757120151 : agbno = XFS_AGINO_TO_AGBNO(mp, irec->ir_startino);
107 :
108 1757120151 : blk_start_plug(&plug);
109 7028511421 : for (i = 0; i < XFS_INODES_PER_CHUNK; i += igeo->inodes_per_cluster) {
110 3514021237 : xfs_inofree_t imask;
111 :
112 3514021237 : imask = xfs_inobt_maskn(i, igeo->inodes_per_cluster);
113 3513675429 : if (imask & ~irec->ir_free) {
114 2671982865 : xfs_btree_reada_bufs(mp, pag->pag_agno, agbno,
115 : igeo->blocks_per_cluster,
116 : &xfs_inode_buf_ops);
117 : }
118 3514262186 : agbno += igeo->blocks_per_cluster;
119 : }
120 1757370033 : blk_finish_plug(&plug);
121 1757312368 : }
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 363748876 : xfs_iwalk_adjust_start(
130 : xfs_agino_t agino, /* starting inode of chunk */
131 : struct xfs_inobt_rec_incore *irec) /* btree record */
132 : {
133 363748876 : int idx; /* index into inode chunk */
134 363748876 : int i;
135 :
136 363748876 : 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 11766601785 : for (i = 0; i < idx; i++) {
144 11402852909 : if (XFS_INOBT_MASK(i) & ~irec->ir_free)
145 9496469904 : irec->ir_freecount++;
146 : }
147 :
148 363748876 : irec->ir_free |= xfs_inobt_maskn(0, idx);
149 363748876 : }
150 :
151 : /* Allocate memory for a walk. */
152 : STATIC int
153 381465182 : xfs_iwalk_alloc(
154 : struct xfs_iwalk_ag *iwag)
155 : {
156 381465182 : size_t size;
157 :
158 381465182 : ASSERT(iwag->recs == NULL);
159 381465182 : iwag->nr_recs = 0;
160 :
161 : /* Allocate a prefetch buffer for inobt records. */
162 381465182 : size = iwag->sz_recs * sizeof(struct xfs_inobt_rec_incore);
163 381465182 : iwag->recs = kmem_alloc(size, KM_MAYFAIL);
164 381418287 : if (iwag->recs == NULL)
165 0 : return -ENOMEM;
166 :
167 : return 0;
168 : }
169 :
170 : /* Free memory we allocated for a walk. */
171 : STATIC void
172 381439390 : xfs_iwalk_free(
173 : struct xfs_iwalk_ag *iwag)
174 : {
175 381439390 : kmem_free(iwag->recs);
176 381446061 : iwag->recs = NULL;
177 381446061 : }
178 :
179 : /* For each inuse inode in each cached inobt record, call our function. */
180 : STATIC int
181 486543676 : xfs_iwalk_ag_recs(
182 : struct xfs_iwalk_ag *iwag)
183 : {
184 486543676 : struct xfs_mount *mp = iwag->mp;
185 486543676 : struct xfs_trans *tp = iwag->tp;
186 486543676 : struct xfs_perag *pag = iwag->pag;
187 486543676 : xfs_ino_t ino;
188 486543676 : unsigned int i, j;
189 486543676 : int error;
190 :
191 1582973126 : for (i = 0; i < iwag->nr_recs; i++) {
192 1472761836 : struct xfs_inobt_rec_incore *irec = &iwag->recs[i];
193 :
194 1472761836 : trace_xfs_iwalk_ag_rec(mp, pag->pag_agno, irec);
195 :
196 2944465378 : if (xfs_pwork_want_abort(&iwag->pwork))
197 : return 0;
198 :
199 1472232689 : if (iwag->inobt_walk_fn) {
200 15526382 : error = iwag->inobt_walk_fn(mp, tp, pag->pag_agno, irec,
201 : iwag->data);
202 15534528 : if (error)
203 9992256 : return error;
204 : }
205 :
206 1462248579 : if (!iwag->iwalk_fn)
207 5540184 : continue;
208 :
209 81064016201 : for (j = 0; j < XFS_INODES_PER_CHUNK; j++) {
210 >15994*10^7 : if (xfs_pwork_want_abort(&iwag->pwork))
211 : return 0;
212 :
213 : /* Skip if this inode is free */
214 79973126935 : if (XFS_INOBT_MASK(j) & irec->ir_free)
215 28180869413 : continue;
216 :
217 : /* Otherwise call our function. */
218 51792257522 : ino = XFS_AGINO_TO_INO(mp, pag->pag_agno,
219 : irec->ir_startino + j);
220 51792257522 : error = iwag->iwalk_fn(mp, tp, ino, iwag->data);
221 51792731202 : if (error)
222 366292809 : return error;
223 : }
224 : }
225 :
226 : return 0;
227 : }
228 :
229 : /* Delete cursor and let go of AGI. */
230 : static inline void
231 874086247 : 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 874086247 : if (*curpp) {
238 497899341 : xfs_btree_del_cursor(*curpp, error);
239 497940814 : *curpp = NULL;
240 : }
241 874127720 : if (*agi_bpp) {
242 497940383 : xfs_trans_brelse(tp, *agi_bpp);
243 497965066 : *agi_bpp = NULL;
244 : }
245 874152403 : }
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 387534058 : 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 387534058 : struct xfs_mount *mp = iwag->mp;
271 387534058 : struct xfs_trans *tp = iwag->tp;
272 387534058 : struct xfs_perag *pag = iwag->pag;
273 387534058 : struct xfs_inobt_rec_incore *irec;
274 387534058 : int error;
275 :
276 : /* Set up a fresh cursor and empty the inobt cache. */
277 387534058 : iwag->nr_recs = 0;
278 387534058 : error = xfs_inobt_cur(pag, tp, XFS_BTNUM_INO, curpp, agi_bpp);
279 387687298 : if (error)
280 : return error;
281 :
282 : /* Starting at the beginning of the AG? That's easy! */
283 387686761 : if (agino == 0)
284 9472840 : 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 378213921 : error = xfs_inobt_lookup(*curpp, agino, XFS_LOOKUP_LE, has_more);
294 378226081 : 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 378226026 : if (!*has_more)
302 40 : goto out_advance;
303 :
304 : /* Get the record, should always work */
305 378225986 : irec = &iwag->recs[iwag->nr_recs];
306 378225986 : error = xfs_inobt_get_rec(*curpp, irec, has_more);
307 378172469 : if (error)
308 : return error;
309 378172469 : if (XFS_IS_CORRUPT(mp, *has_more != 1))
310 0 : return -EFSCORRUPTED;
311 :
312 378172469 : 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 378172469 : if (irec->ir_startino + XFS_INODES_PER_CHUNK <= agino)
320 7410882 : 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 370761587 : if (iwag->trim_start)
327 363755570 : 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 370790368 : iwag->nr_recs++;
336 370790368 : ASSERT(iwag->nr_recs < iwag->sz_recs);
337 :
338 370790368 : out_advance:
339 378201290 : 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 486544455 : 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 486544455 : struct xfs_mount *mp = iwag->mp;
358 486544455 : struct xfs_inobt_rec_incore *irec;
359 486544455 : xfs_agino_t next_agino;
360 486544455 : int error;
361 :
362 486544455 : next_agino = XFS_INO_TO_AGINO(mp, iwag->lastino) + 1;
363 :
364 486544455 : ASSERT(iwag->nr_recs > 0);
365 :
366 : /* Delete cursor but remember the last record we cached... */
367 486544455 : xfs_iwalk_del_inobt(iwag->tp, curpp, agi_bpp, 0);
368 486565773 : irec = &iwag->recs[iwag->nr_recs - 1];
369 486565773 : ASSERT(next_agino >= irec->ir_startino + XFS_INODES_PER_CHUNK);
370 :
371 486565773 : if (iwag->drop_trans) {
372 7256 : xfs_trans_cancel(iwag->tp);
373 7256 : iwag->tp = NULL;
374 : }
375 :
376 486565773 : error = xfs_iwalk_ag_recs(iwag);
377 486444742 : if (error)
378 : return error;
379 :
380 : /* ...empty the cache... */
381 110208818 : iwag->nr_recs = 0;
382 :
383 110208818 : if (!has_more)
384 : return 0;
385 :
386 110208818 : if (iwag->drop_trans) {
387 7256 : error = xfs_trans_alloc_empty(mp, &iwag->tp);
388 7256 : if (error)
389 : return error;
390 : }
391 :
392 : /* ...and recreate the cursor just past where we left off. */
393 110208818 : error = xfs_inobt_cur(iwag->pag, iwag->tp, XFS_BTNUM_INO, curpp,
394 : agi_bpp);
395 110210560 : if (error)
396 : return error;
397 :
398 110205903 : 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 387651711 : xfs_iwalk_ag(
404 : struct xfs_iwalk_ag *iwag)
405 : {
406 387651711 : struct xfs_mount *mp = iwag->mp;
407 387651711 : struct xfs_perag *pag = iwag->pag;
408 387651711 : struct xfs_buf *agi_bp = NULL;
409 387651711 : struct xfs_btree_cur *cur = NULL;
410 387651711 : xfs_agino_t agino;
411 387651711 : int has_more;
412 387651711 : int error = 0;
413 :
414 : /* Set up our cursor at the right place in the inode btree. */
415 387651711 : ASSERT(pag->pag_agno == XFS_INO_TO_AGNO(mp, iwag->startino));
416 387651711 : agino = XFS_INO_TO_AGINO(mp, iwag->startino);
417 387651711 : error = xfs_iwalk_ag_start(iwag, agino, &cur, &agi_bp, &has_more);
418 :
419 2155374627 : while (!error && has_more) {
420 1775250480 : struct xfs_inobt_rec_incore *irec;
421 1775250480 : xfs_ino_t rec_fsino;
422 :
423 1775250480 : cond_resched();
424 3550497082 : if (xfs_pwork_want_abort(&iwag->pwork))
425 0 : goto out;
426 :
427 : /* Fetch the inobt record. */
428 1775248541 : irec = &iwag->recs[iwag->nr_recs];
429 1775248541 : error = xfs_inobt_get_rec(cur, irec, &has_more);
430 1775230121 : if (error || !has_more)
431 : break;
432 :
433 : /* Make sure that we always move forward. */
434 1775230121 : rec_fsino = XFS_AGINO_TO_INO(mp, pag->pag_agno, irec->ir_startino);
435 1775230121 : if (iwag->lastino != NULLFSINO &&
436 1773176892 : XFS_IS_CORRUPT(mp, iwag->lastino >= rec_fsino)) {
437 0 : error = -EFSCORRUPTED;
438 0 : goto out;
439 : }
440 1775230121 : iwag->lastino = rec_fsino + XFS_INODES_PER_CHUNK - 1;
441 :
442 : /* No allocated inodes in this chunk; skip it. */
443 1775230121 : if (iwag->skip_empty && irec->ir_freecount == irec->ir_count) {
444 0 : error = xfs_btree_increment(cur, 0, &has_more);
445 0 : if (error)
446 : break;
447 0 : continue;
448 : }
449 :
450 : /*
451 : * Start readahead for this inode chunk in anticipation of
452 : * walking the inodes.
453 : */
454 1775230121 : if (iwag->iwalk_fn)
455 1757183440 : 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 1775444192 : if (++iwag->nr_recs < iwag->sz_recs) {
462 1301364392 : error = xfs_btree_increment(cur, 0, &has_more);
463 1301321154 : if (error || !has_more)
464 : break;
465 1293882064 : 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 474079800 : ASSERT(has_more);
475 474079800 : error = xfs_iwalk_run_callbacks(iwag, &cur, &agi_bp, &has_more);
476 : }
477 :
478 387619612 : if (iwag->nr_recs == 0 || error)
479 375140537 : goto out;
480 :
481 : /* Walk the unprocessed records in the cache. */
482 12479075 : error = xfs_iwalk_run_callbacks(iwag, &cur, &agi_bp, &has_more);
483 :
484 387618886 : out:
485 387618886 : xfs_iwalk_del_inobt(iwag->tp, &cur, &agi_bp, error);
486 387575026 : 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 369348482 : 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 369348482 : if (inodes == 0)
514 57723 : inodes = IWALK_MAX_INODE_PREFETCH;
515 369348482 : inodes = min(inodes, IWALK_MAX_INODE_PREFETCH);
516 :
517 : /* Round the inode count up to a full chunk. */
518 369348482 : 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 369348482 : 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 369348482 : 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 369290759 : 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 369290759 : 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 369290759 : struct xfs_perag *pag;
572 369290759 : xfs_agnumber_t agno = XFS_INO_TO_AGNO(mp, startino);
573 369290759 : int error;
574 :
575 369290759 : ASSERT(agno < mp->m_sb.sb_agcount);
576 369290759 : ASSERT(!(flags & ~XFS_IWALK_FLAGS_ALL));
577 :
578 369290759 : error = xfs_iwalk_alloc(&iwag);
579 369343371 : if (error)
580 : return error;
581 :
582 378621945 : for_each_perag_from(mp, agno, pag) {
583 375552925 : iwag.pag = pag;
584 375552925 : error = xfs_iwalk_ag(&iwag);
585 375486230 : if (error)
586 : break;
587 9260581 : iwag.startino = XFS_AGINO_TO_INO(mp, agno + 1, 0);
588 9260581 : if (flags & XFS_INOBT_WALK_SAME_AG)
589 : break;
590 9255653 : iwag.pag = NULL;
591 : }
592 :
593 369325170 : if (iwag.pag)
594 366227622 : xfs_perag_rele(pag);
595 369358229 : xfs_iwalk_free(&iwag);
596 369358229 : return error;
597 : }
598 :
599 : /* Run per-thread iwalk work. */
600 : static int
601 57723 : xfs_iwalk_ag_work(
602 : struct xfs_mount *mp,
603 : struct xfs_pwork *pwork)
604 : {
605 57723 : struct xfs_iwalk_ag *iwag;
606 57723 : int error = 0;
607 :
608 57723 : iwag = container_of(pwork, struct xfs_iwalk_ag, pwork);
609 115446 : if (xfs_pwork_want_abort(pwork))
610 0 : goto out;
611 :
612 57723 : error = xfs_iwalk_alloc(iwag);
613 57721 : if (error)
614 0 : 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 57721 : error = xfs_trans_alloc_empty(mp, &iwag->tp);
620 57714 : if (error)
621 0 : goto out;
622 57714 : iwag->drop_trans = 1;
623 :
624 57714 : error = xfs_iwalk_ag(iwag);
625 57704 : if (iwag->tp)
626 57704 : xfs_trans_cancel(iwag->tp);
627 57648 : xfs_iwalk_free(iwag);
628 57624 : out:
629 57624 : xfs_perag_put(iwag->pag);
630 57698 : kmem_free(iwag);
631 57684 : 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 7054 : 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 7054 : struct xfs_pwork_ctl pctl;
649 7054 : struct xfs_perag *pag;
650 7054 : xfs_agnumber_t agno = XFS_INO_TO_AGNO(mp, startino);
651 7054 : int error;
652 :
653 7054 : ASSERT(agno < mp->m_sb.sb_agcount);
654 7054 : ASSERT(!(flags & ~XFS_IWALK_FLAGS_ALL));
655 :
656 7054 : error = xfs_pwork_init(mp, &pctl, xfs_iwalk_ag_work, "xfs_iwalk");
657 7054 : if (error)
658 : return error;
659 :
660 64777 : for_each_perag_from(mp, agno, pag) {
661 57723 : struct xfs_iwalk_ag *iwag;
662 :
663 115446 : if (xfs_pwork_ctl_want_abort(&pctl))
664 : break;
665 :
666 57723 : iwag = kmem_zalloc(sizeof(struct xfs_iwalk_ag), 0);
667 57723 : iwag->mp = mp;
668 :
669 : /*
670 : * perag is being handed off to async work, so take a passive
671 : * reference for the async work to release.
672 : */
673 57723 : iwag->pag = xfs_perag_hold(pag);
674 57723 : iwag->iwalk_fn = iwalk_fn;
675 57723 : iwag->data = data;
676 57723 : iwag->startino = startino;
677 57723 : iwag->sz_recs = xfs_iwalk_prefetch(inode_records);
678 57723 : iwag->lastino = NULLFSINO;
679 57723 : xfs_pwork_queue(&pctl, &iwag->pwork);
680 57723 : startino = XFS_AGINO_TO_INO(mp, pag->pag_agno + 1, 0);
681 57723 : if (flags & XFS_INOBT_WALK_SAME_AG)
682 : break;
683 : }
684 7054 : if (pag)
685 0 : xfs_perag_rele(pag);
686 7054 : if (polled)
687 7054 : xfs_pwork_poll(&pctl);
688 7054 : return xfs_pwork_destroy(&pctl);
689 : }
690 :
691 : /*
692 : * Allow callers to cache up to a page's worth of inobt records. This reflects
693 : * the existing inumbers prefetching behavior. Since the inobt walk does not
694 : * itself do anything with the inobt records, we can set a fairly high limit
695 : * here.
696 : */
697 : #define MAX_INOBT_WALK_PREFETCH \
698 : (PAGE_SIZE / sizeof(struct xfs_inobt_rec_incore))
699 :
700 : /*
701 : * Given the number of records that the user wanted, set the number of inobt
702 : * records that we buffer in memory. Set the maximum if @inobt_records == 0.
703 : */
704 : static inline unsigned int
705 : xfs_inobt_walk_prefetch(
706 : unsigned int inobt_records)
707 : {
708 : /*
709 : * If the caller didn't tell us the number of inobt records they
710 : * wanted, assume the maximum prefetch possible for best performance.
711 : */
712 12020021 : if (inobt_records == 0)
713 0 : inobt_records = MAX_INOBT_WALK_PREFETCH;
714 :
715 : /*
716 : * Allocate enough space to prefetch at least two inobt records so that
717 : * we can cache both the record where the iwalk started and the next
718 : * record. This simplifies the AG inode walk loop setup code.
719 : */
720 12020021 : inobt_records = max(inobt_records, 2U);
721 :
722 : /*
723 : * Cap prefetch at that maximum so that we don't use an absurd amount
724 : * of memory.
725 : */
726 12020021 : return min_t(unsigned int, inobt_records, MAX_INOBT_WALK_PREFETCH);
727 : }
728 :
729 : /*
730 : * Walk all inode btree records in the filesystem starting from @startino. The
731 : * @inobt_walk_fn will be called for each btree record, being passed the incore
732 : * record and @data. @max_prefetch controls how many inobt records we try to
733 : * cache ahead of time.
734 : */
735 : int
736 12020021 : xfs_inobt_walk(
737 : struct xfs_mount *mp,
738 : struct xfs_trans *tp,
739 : xfs_ino_t startino,
740 : unsigned int flags,
741 : xfs_inobt_walk_fn inobt_walk_fn,
742 : unsigned int inobt_records,
743 : void *data)
744 : {
745 12020021 : struct xfs_iwalk_ag iwag = {
746 : .mp = mp,
747 : .tp = tp,
748 : .inobt_walk_fn = inobt_walk_fn,
749 : .data = data,
750 : .startino = startino,
751 : .sz_recs = xfs_inobt_walk_prefetch(inobt_records),
752 : .pwork = XFS_PWORK_SINGLE_THREADED,
753 : .lastino = NULLFSINO,
754 : };
755 12020021 : struct xfs_perag *pag;
756 12020021 : xfs_agnumber_t agno = XFS_INO_TO_AGNO(mp, startino);
757 12020021 : int error;
758 :
759 12020021 : ASSERT(agno < mp->m_sb.sb_agcount);
760 12020021 : ASSERT(!(flags & ~XFS_INOBT_WALK_FLAGS_ALL));
761 :
762 12020021 : error = xfs_iwalk_alloc(&iwag);
763 12027669 : if (error)
764 : return error;
765 :
766 12067271 : for_each_perag_from(mp, agno, pag) {
767 12080714 : iwag.pag = pag;
768 12080714 : error = xfs_iwalk_ag(&iwag);
769 12066860 : if (error)
770 : break;
771 2074310 : iwag.startino = XFS_AGINO_TO_INO(mp, pag->pag_agno + 1, 0);
772 2074310 : if (flags & XFS_INOBT_WALK_SAME_AG)
773 : break;
774 44376 : iwag.pag = NULL;
775 : }
776 :
777 12029968 : if (iwag.pag)
778 12015990 : xfs_perag_rele(pag);
779 12039977 : xfs_iwalk_free(&iwag);
780 12039977 : return error;
781 : }
|
