Commit | Line | Data |
---|---|---|
0b61f8a4 | 1 | // SPDX-License-Identifier: GPL-2.0 |
efc27b52 DC |
2 | /* |
3 | * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc. | |
4 | * Copyright (c) 2010 David Chinner. | |
5 | * Copyright (c) 2011 Christoph Hellwig. | |
6 | * All Rights Reserved. | |
efc27b52 DC |
7 | */ |
8 | #include "xfs.h" | |
9 | #include "xfs_fs.h" | |
70a9883c | 10 | #include "xfs_format.h" |
239880ef | 11 | #include "xfs_log_format.h" |
70a9883c | 12 | #include "xfs_shared.h" |
239880ef | 13 | #include "xfs_trans_resv.h" |
efc27b52 | 14 | #include "xfs_mount.h" |
efc27b52 | 15 | #include "xfs_alloc.h" |
efc27b52 DC |
16 | #include "xfs_extent_busy.h" |
17 | #include "xfs_trace.h" | |
239880ef DC |
18 | #include "xfs_trans.h" |
19 | #include "xfs_log.h" | |
9bbafc71 | 20 | #include "xfs_ag.h" |
efc27b52 | 21 | |
89cfa899 DC |
22 | static void |
23 | xfs_extent_busy_insert_list( | |
45d06621 | 24 | struct xfs_perag *pag, |
efc27b52 DC |
25 | xfs_agblock_t bno, |
26 | xfs_extlen_t len, | |
89cfa899 DC |
27 | unsigned int flags, |
28 | struct list_head *busy_list) | |
efc27b52 | 29 | { |
4ecbfe63 DC |
30 | struct xfs_extent_busy *new; |
31 | struct xfs_extent_busy *busyp; | |
efc27b52 DC |
32 | struct rb_node **rbp; |
33 | struct rb_node *parent = NULL; | |
34 | ||
707e0dda | 35 | new = kmem_zalloc(sizeof(struct xfs_extent_busy), 0); |
45d06621 | 36 | new->agno = pag->pag_agno; |
efc27b52 DC |
37 | new->bno = bno; |
38 | new->length = len; | |
39 | INIT_LIST_HEAD(&new->list); | |
40 | new->flags = flags; | |
41 | ||
42 | /* trace before insert to be able to see failed inserts */ | |
89cfa899 | 43 | trace_xfs_extent_busy(pag->pag_mount, pag->pag_agno, bno, len); |
efc27b52 | 44 | |
efc27b52 DC |
45 | spin_lock(&pag->pagb_lock); |
46 | rbp = &pag->pagb_tree.rb_node; | |
47 | while (*rbp) { | |
48 | parent = *rbp; | |
4ecbfe63 | 49 | busyp = rb_entry(parent, struct xfs_extent_busy, rb_node); |
efc27b52 DC |
50 | |
51 | if (new->bno < busyp->bno) { | |
52 | rbp = &(*rbp)->rb_left; | |
53 | ASSERT(new->bno + new->length <= busyp->bno); | |
54 | } else if (new->bno > busyp->bno) { | |
55 | rbp = &(*rbp)->rb_right; | |
56 | ASSERT(bno >= busyp->bno + busyp->length); | |
57 | } else { | |
58 | ASSERT(0); | |
59 | } | |
60 | } | |
61 | ||
62 | rb_link_node(&new->rb_node, parent, rbp); | |
63 | rb_insert_color(&new->rb_node, &pag->pagb_tree); | |
64 | ||
442177be DW |
65 | /* always process discard lists in fifo order */ |
66 | list_add_tail(&new->list, busy_list); | |
efc27b52 | 67 | spin_unlock(&pag->pagb_lock); |
efc27b52 DC |
68 | } |
69 | ||
89cfa899 DC |
70 | void |
71 | xfs_extent_busy_insert( | |
72 | struct xfs_trans *tp, | |
73 | struct xfs_perag *pag, | |
74 | xfs_agblock_t bno, | |
75 | xfs_extlen_t len, | |
76 | unsigned int flags) | |
77 | { | |
78 | xfs_extent_busy_insert_list(pag, bno, len, flags, &tp->t_busy); | |
79 | } | |
80 | ||
81 | void | |
82 | xfs_extent_busy_insert_discard( | |
83 | struct xfs_perag *pag, | |
84 | xfs_agblock_t bno, | |
85 | xfs_extlen_t len, | |
86 | struct list_head *busy_list) | |
87 | { | |
88 | xfs_extent_busy_insert_list(pag, bno, len, XFS_EXTENT_BUSY_DISCARDED, | |
89 | busy_list); | |
90 | } | |
91 | ||
efc27b52 DC |
92 | /* |
93 | * Search for a busy extent within the range of the extent we are about to | |
94 | * allocate. You need to be holding the busy extent tree lock when calling | |
4ecbfe63 | 95 | * xfs_extent_busy_search(). This function returns 0 for no overlapping busy |
efc27b52 DC |
96 | * extent, -1 for an overlapping but not exact busy extent, and 1 for an exact |
97 | * match. This is done so that a non-zero return indicates an overlap that | |
98 | * will require a synchronous transaction, but it can still be | |
99 | * used to distinguish between a partial or exact match. | |
100 | */ | |
101 | int | |
4ecbfe63 | 102 | xfs_extent_busy_search( |
efc27b52 | 103 | struct xfs_mount *mp, |
45d06621 | 104 | struct xfs_perag *pag, |
efc27b52 DC |
105 | xfs_agblock_t bno, |
106 | xfs_extlen_t len) | |
107 | { | |
efc27b52 | 108 | struct rb_node *rbp; |
4ecbfe63 | 109 | struct xfs_extent_busy *busyp; |
efc27b52 DC |
110 | int match = 0; |
111 | ||
45d06621 | 112 | /* find closest start bno overlap */ |
efc27b52 | 113 | spin_lock(&pag->pagb_lock); |
efc27b52 | 114 | rbp = pag->pagb_tree.rb_node; |
efc27b52 | 115 | while (rbp) { |
4ecbfe63 | 116 | busyp = rb_entry(rbp, struct xfs_extent_busy, rb_node); |
efc27b52 DC |
117 | if (bno < busyp->bno) { |
118 | /* may overlap, but exact start block is lower */ | |
119 | if (bno + len > busyp->bno) | |
120 | match = -1; | |
121 | rbp = rbp->rb_left; | |
122 | } else if (bno > busyp->bno) { | |
123 | /* may overlap, but exact start block is higher */ | |
124 | if (bno < busyp->bno + busyp->length) | |
125 | match = -1; | |
126 | rbp = rbp->rb_right; | |
127 | } else { | |
128 | /* bno matches busyp, length determines exact match */ | |
129 | match = (busyp->length == len) ? 1 : -1; | |
130 | break; | |
131 | } | |
132 | } | |
133 | spin_unlock(&pag->pagb_lock); | |
efc27b52 DC |
134 | return match; |
135 | } | |
136 | ||
137 | /* | |
138 | * The found free extent [fbno, fend] overlaps part or all of the given busy | |
139 | * extent. If the overlap covers the beginning, the end, or all of the busy | |
140 | * extent, the overlapping portion can be made unbusy and used for the | |
141 | * allocation. We can't split a busy extent because we can't modify a | |
b3c49634 | 142 | * transaction/CIL context busy list, but we can update an entry's block |
efc27b52 DC |
143 | * number or length. |
144 | * | |
145 | * Returns true if the extent can safely be reused, or false if the search | |
146 | * needs to be restarted. | |
147 | */ | |
148 | STATIC bool | |
4ecbfe63 | 149 | xfs_extent_busy_update_extent( |
efc27b52 DC |
150 | struct xfs_mount *mp, |
151 | struct xfs_perag *pag, | |
4ecbfe63 | 152 | struct xfs_extent_busy *busyp, |
efc27b52 DC |
153 | xfs_agblock_t fbno, |
154 | xfs_extlen_t flen, | |
a30b0367 DC |
155 | bool userdata) __releases(&pag->pagb_lock) |
156 | __acquires(&pag->pagb_lock) | |
efc27b52 DC |
157 | { |
158 | xfs_agblock_t fend = fbno + flen; | |
159 | xfs_agblock_t bbno = busyp->bno; | |
160 | xfs_agblock_t bend = bbno + busyp->length; | |
161 | ||
162 | /* | |
163 | * This extent is currently being discarded. Give the thread | |
164 | * performing the discard a chance to mark the extent unbusy | |
165 | * and retry. | |
166 | */ | |
4ecbfe63 | 167 | if (busyp->flags & XFS_EXTENT_BUSY_DISCARDED) { |
efc27b52 DC |
168 | spin_unlock(&pag->pagb_lock); |
169 | delay(1); | |
170 | spin_lock(&pag->pagb_lock); | |
171 | return false; | |
172 | } | |
173 | ||
174 | /* | |
175 | * If there is a busy extent overlapping a user allocation, we have | |
176 | * no choice but to force the log and retry the search. | |
177 | * | |
178 | * Fortunately this does not happen during normal operation, but | |
179 | * only if the filesystem is very low on space and has to dip into | |
180 | * the AGFL for normal allocations. | |
181 | */ | |
182 | if (userdata) | |
183 | goto out_force_log; | |
184 | ||
185 | if (bbno < fbno && bend > fend) { | |
186 | /* | |
187 | * Case 1: | |
188 | * bbno bend | |
189 | * +BBBBBBBBBBBBBBBBB+ | |
190 | * +---------+ | |
191 | * fbno fend | |
192 | */ | |
193 | ||
194 | /* | |
195 | * We would have to split the busy extent to be able to track | |
196 | * it correct, which we cannot do because we would have to | |
197 | * modify the list of busy extents attached to the transaction | |
198 | * or CIL context, which is immutable. | |
199 | * | |
200 | * Force out the log to clear the busy extent and retry the | |
201 | * search. | |
202 | */ | |
203 | goto out_force_log; | |
204 | } else if (bbno >= fbno && bend <= fend) { | |
205 | /* | |
206 | * Case 2: | |
207 | * bbno bend | |
208 | * +BBBBBBBBBBBBBBBBB+ | |
209 | * +-----------------+ | |
210 | * fbno fend | |
211 | * | |
212 | * Case 3: | |
213 | * bbno bend | |
214 | * +BBBBBBBBBBBBBBBBB+ | |
215 | * +--------------------------+ | |
216 | * fbno fend | |
217 | * | |
218 | * Case 4: | |
219 | * bbno bend | |
220 | * +BBBBBBBBBBBBBBBBB+ | |
221 | * +--------------------------+ | |
222 | * fbno fend | |
223 | * | |
224 | * Case 5: | |
225 | * bbno bend | |
226 | * +BBBBBBBBBBBBBBBBB+ | |
227 | * +-----------------------------------+ | |
228 | * fbno fend | |
229 | * | |
230 | */ | |
231 | ||
232 | /* | |
233 | * The busy extent is fully covered by the extent we are | |
234 | * allocating, and can simply be removed from the rbtree. | |
235 | * However we cannot remove it from the immutable list | |
236 | * tracking busy extents in the transaction or CIL context, | |
237 | * so set the length to zero to mark it invalid. | |
238 | * | |
239 | * We also need to restart the busy extent search from the | |
240 | * tree root, because erasing the node can rearrange the | |
241 | * tree topology. | |
242 | */ | |
243 | rb_erase(&busyp->rb_node, &pag->pagb_tree); | |
244 | busyp->length = 0; | |
245 | return false; | |
246 | } else if (fend < bend) { | |
247 | /* | |
248 | * Case 6: | |
249 | * bbno bend | |
250 | * +BBBBBBBBBBBBBBBBB+ | |
251 | * +---------+ | |
252 | * fbno fend | |
253 | * | |
254 | * Case 7: | |
255 | * bbno bend | |
256 | * +BBBBBBBBBBBBBBBBB+ | |
257 | * +------------------+ | |
258 | * fbno fend | |
259 | * | |
260 | */ | |
261 | busyp->bno = fend; | |
601a27ea | 262 | busyp->length = bend - fend; |
efc27b52 DC |
263 | } else if (bbno < fbno) { |
264 | /* | |
265 | * Case 8: | |
266 | * bbno bend | |
267 | * +BBBBBBBBBBBBBBBBB+ | |
268 | * +-------------+ | |
269 | * fbno fend | |
270 | * | |
271 | * Case 9: | |
272 | * bbno bend | |
273 | * +BBBBBBBBBBBBBBBBB+ | |
274 | * +----------------------+ | |
275 | * fbno fend | |
276 | */ | |
277 | busyp->length = fbno - busyp->bno; | |
278 | } else { | |
279 | ASSERT(0); | |
280 | } | |
281 | ||
4ecbfe63 | 282 | trace_xfs_extent_busy_reuse(mp, pag->pag_agno, fbno, flen); |
efc27b52 DC |
283 | return true; |
284 | ||
285 | out_force_log: | |
286 | spin_unlock(&pag->pagb_lock); | |
287 | xfs_log_force(mp, XFS_LOG_SYNC); | |
4ecbfe63 | 288 | trace_xfs_extent_busy_force(mp, pag->pag_agno, fbno, flen); |
efc27b52 DC |
289 | spin_lock(&pag->pagb_lock); |
290 | return false; | |
291 | } | |
292 | ||
293 | ||
294 | /* | |
295 | * For a given extent [fbno, flen], make sure we can reuse it safely. | |
296 | */ | |
297 | void | |
4ecbfe63 | 298 | xfs_extent_busy_reuse( |
efc27b52 | 299 | struct xfs_mount *mp, |
45d06621 | 300 | struct xfs_perag *pag, |
efc27b52 DC |
301 | xfs_agblock_t fbno, |
302 | xfs_extlen_t flen, | |
303 | bool userdata) | |
304 | { | |
efc27b52 DC |
305 | struct rb_node *rbp; |
306 | ||
307 | ASSERT(flen > 0); | |
efc27b52 DC |
308 | spin_lock(&pag->pagb_lock); |
309 | restart: | |
310 | rbp = pag->pagb_tree.rb_node; | |
311 | while (rbp) { | |
4ecbfe63 DC |
312 | struct xfs_extent_busy *busyp = |
313 | rb_entry(rbp, struct xfs_extent_busy, rb_node); | |
efc27b52 DC |
314 | xfs_agblock_t bbno = busyp->bno; |
315 | xfs_agblock_t bend = bbno + busyp->length; | |
316 | ||
317 | if (fbno + flen <= bbno) { | |
318 | rbp = rbp->rb_left; | |
319 | continue; | |
320 | } else if (fbno >= bend) { | |
321 | rbp = rbp->rb_right; | |
322 | continue; | |
323 | } | |
324 | ||
4ecbfe63 | 325 | if (!xfs_extent_busy_update_extent(mp, pag, busyp, fbno, flen, |
efc27b52 DC |
326 | userdata)) |
327 | goto restart; | |
328 | } | |
329 | spin_unlock(&pag->pagb_lock); | |
efc27b52 DC |
330 | } |
331 | ||
332 | /* | |
333 | * For a given extent [fbno, flen], search the busy extent list to find a | |
334 | * subset of the extent that is not busy. If *rlen is smaller than | |
335 | * args->minlen no suitable extent could be found, and the higher level | |
336 | * code needs to force out the log and retry the allocation. | |
ebf55872 CH |
337 | * |
338 | * Return the current busy generation for the AG if the extent is busy. This | |
339 | * value can be used to wait for at least one of the currently busy extents | |
340 | * to be cleared. Note that the busy list is not guaranteed to be empty after | |
341 | * the gen is woken. The state of a specific extent must always be confirmed | |
342 | * with another call to xfs_extent_busy_trim() before it can be used. | |
efc27b52 | 343 | */ |
ebf55872 | 344 | bool |
4ecbfe63 | 345 | xfs_extent_busy_trim( |
efc27b52 | 346 | struct xfs_alloc_arg *args, |
ebf55872 CH |
347 | xfs_agblock_t *bno, |
348 | xfs_extlen_t *len, | |
349 | unsigned *busy_gen) | |
efc27b52 DC |
350 | { |
351 | xfs_agblock_t fbno; | |
352 | xfs_extlen_t flen; | |
353 | struct rb_node *rbp; | |
ebf55872 | 354 | bool ret = false; |
efc27b52 | 355 | |
353fe445 | 356 | ASSERT(*len > 0); |
efc27b52 DC |
357 | |
358 | spin_lock(&args->pag->pagb_lock); | |
ebf55872 CH |
359 | fbno = *bno; |
360 | flen = *len; | |
efc27b52 DC |
361 | rbp = args->pag->pagb_tree.rb_node; |
362 | while (rbp && flen >= args->minlen) { | |
4ecbfe63 DC |
363 | struct xfs_extent_busy *busyp = |
364 | rb_entry(rbp, struct xfs_extent_busy, rb_node); | |
efc27b52 DC |
365 | xfs_agblock_t fend = fbno + flen; |
366 | xfs_agblock_t bbno = busyp->bno; | |
367 | xfs_agblock_t bend = bbno + busyp->length; | |
368 | ||
369 | if (fend <= bbno) { | |
370 | rbp = rbp->rb_left; | |
371 | continue; | |
372 | } else if (fbno >= bend) { | |
373 | rbp = rbp->rb_right; | |
374 | continue; | |
375 | } | |
376 | ||
efc27b52 DC |
377 | if (bbno <= fbno) { |
378 | /* start overlap */ | |
379 | ||
380 | /* | |
381 | * Case 1: | |
382 | * bbno bend | |
383 | * +BBBBBBBBBBBBBBBBB+ | |
384 | * +---------+ | |
385 | * fbno fend | |
386 | * | |
387 | * Case 2: | |
388 | * bbno bend | |
389 | * +BBBBBBBBBBBBBBBBB+ | |
390 | * +-------------+ | |
391 | * fbno fend | |
392 | * | |
393 | * Case 3: | |
394 | * bbno bend | |
395 | * +BBBBBBBBBBBBBBBBB+ | |
396 | * +-------------+ | |
397 | * fbno fend | |
398 | * | |
399 | * Case 4: | |
400 | * bbno bend | |
401 | * +BBBBBBBBBBBBBBBBB+ | |
402 | * +-----------------+ | |
403 | * fbno fend | |
404 | * | |
405 | * No unbusy region in extent, return failure. | |
406 | */ | |
407 | if (fend <= bend) | |
408 | goto fail; | |
409 | ||
410 | /* | |
411 | * Case 5: | |
412 | * bbno bend | |
413 | * +BBBBBBBBBBBBBBBBB+ | |
414 | * +----------------------+ | |
415 | * fbno fend | |
416 | * | |
417 | * Case 6: | |
418 | * bbno bend | |
419 | * +BBBBBBBBBBBBBBBBB+ | |
420 | * +--------------------------+ | |
421 | * fbno fend | |
422 | * | |
423 | * Needs to be trimmed to: | |
424 | * +-------+ | |
425 | * fbno fend | |
426 | */ | |
427 | fbno = bend; | |
428 | } else if (bend >= fend) { | |
429 | /* end overlap */ | |
430 | ||
431 | /* | |
432 | * Case 7: | |
433 | * bbno bend | |
434 | * +BBBBBBBBBBBBBBBBB+ | |
435 | * +------------------+ | |
436 | * fbno fend | |
437 | * | |
438 | * Case 8: | |
439 | * bbno bend | |
440 | * +BBBBBBBBBBBBBBBBB+ | |
441 | * +--------------------------+ | |
442 | * fbno fend | |
443 | * | |
444 | * Needs to be trimmed to: | |
445 | * +-------+ | |
446 | * fbno fend | |
447 | */ | |
448 | fend = bbno; | |
449 | } else { | |
450 | /* middle overlap */ | |
451 | ||
452 | /* | |
453 | * Case 9: | |
454 | * bbno bend | |
455 | * +BBBBBBBBBBBBBBBBB+ | |
456 | * +-----------------------------------+ | |
457 | * fbno fend | |
458 | * | |
459 | * Can be trimmed to: | |
460 | * +-------+ OR +-------+ | |
461 | * fbno fend fbno fend | |
462 | * | |
463 | * Backward allocation leads to significant | |
464 | * fragmentation of directories, which degrades | |
465 | * directory performance, therefore we always want to | |
466 | * choose the option that produces forward allocation | |
467 | * patterns. | |
468 | * Preferring the lower bno extent will make the next | |
469 | * request use "fend" as the start of the next | |
470 | * allocation; if the segment is no longer busy at | |
471 | * that point, we'll get a contiguous allocation, but | |
472 | * even if it is still busy, we will get a forward | |
473 | * allocation. | |
474 | * We try to avoid choosing the segment at "bend", | |
475 | * because that can lead to the next allocation | |
476 | * taking the segment at "fbno", which would be a | |
477 | * backward allocation. We only use the segment at | |
478 | * "fbno" if it is much larger than the current | |
479 | * requested size, because in that case there's a | |
480 | * good chance subsequent allocations will be | |
481 | * contiguous. | |
482 | */ | |
483 | if (bbno - fbno >= args->maxlen) { | |
484 | /* left candidate fits perfect */ | |
485 | fend = bbno; | |
486 | } else if (fend - bend >= args->maxlen * 4) { | |
487 | /* right candidate has enough free space */ | |
488 | fbno = bend; | |
489 | } else if (bbno - fbno >= args->minlen) { | |
490 | /* left candidate fits minimum requirement */ | |
491 | fend = bbno; | |
492 | } else { | |
493 | goto fail; | |
494 | } | |
495 | } | |
496 | ||
497 | flen = fend - fbno; | |
498 | } | |
ebf55872 | 499 | out: |
efc27b52 | 500 | |
ebf55872 CH |
501 | if (fbno != *bno || flen != *len) { |
502 | trace_xfs_extent_busy_trim(args->mp, args->agno, *bno, *len, | |
efc27b52 | 503 | fbno, flen); |
ebf55872 CH |
504 | *bno = fbno; |
505 | *len = flen; | |
506 | *busy_gen = args->pag->pagb_gen; | |
507 | ret = true; | |
efc27b52 | 508 | } |
ebf55872 CH |
509 | spin_unlock(&args->pag->pagb_lock); |
510 | return ret; | |
efc27b52 DC |
511 | fail: |
512 | /* | |
513 | * Return a zero extent length as failure indications. All callers | |
514 | * re-check if the trimmed extent satisfies the minlen requirement. | |
515 | */ | |
ebf55872 CH |
516 | flen = 0; |
517 | goto out; | |
efc27b52 DC |
518 | } |
519 | ||
4ecbfe63 DC |
520 | STATIC void |
521 | xfs_extent_busy_clear_one( | |
efc27b52 DC |
522 | struct xfs_mount *mp, |
523 | struct xfs_perag *pag, | |
4ecbfe63 | 524 | struct xfs_extent_busy *busyp) |
efc27b52 DC |
525 | { |
526 | if (busyp->length) { | |
4ecbfe63 | 527 | trace_xfs_extent_busy_clear(mp, busyp->agno, busyp->bno, |
efc27b52 DC |
528 | busyp->length); |
529 | rb_erase(&busyp->rb_node, &pag->pagb_tree); | |
530 | } | |
531 | ||
532 | list_del_init(&busyp->list); | |
533 | kmem_free(busyp); | |
534 | } | |
535 | ||
ebf55872 CH |
536 | static void |
537 | xfs_extent_busy_put_pag( | |
538 | struct xfs_perag *pag, | |
539 | bool wakeup) | |
540 | __releases(pag->pagb_lock) | |
541 | { | |
542 | if (wakeup) { | |
543 | pag->pagb_gen++; | |
544 | wake_up_all(&pag->pagb_wait); | |
545 | } | |
546 | ||
547 | spin_unlock(&pag->pagb_lock); | |
548 | xfs_perag_put(pag); | |
549 | } | |
550 | ||
efc27b52 DC |
551 | /* |
552 | * Remove all extents on the passed in list from the busy extents tree. | |
553 | * If do_discard is set skip extents that need to be discarded, and mark | |
554 | * these as undergoing a discard operation instead. | |
555 | */ | |
556 | void | |
4ecbfe63 | 557 | xfs_extent_busy_clear( |
efc27b52 DC |
558 | struct xfs_mount *mp, |
559 | struct list_head *list, | |
560 | bool do_discard) | |
561 | { | |
4ecbfe63 | 562 | struct xfs_extent_busy *busyp, *n; |
efc27b52 DC |
563 | struct xfs_perag *pag = NULL; |
564 | xfs_agnumber_t agno = NULLAGNUMBER; | |
ebf55872 | 565 | bool wakeup = false; |
efc27b52 DC |
566 | |
567 | list_for_each_entry_safe(busyp, n, list, list) { | |
568 | if (busyp->agno != agno) { | |
ebf55872 CH |
569 | if (pag) |
570 | xfs_extent_busy_put_pag(pag, wakeup); | |
efc27b52 | 571 | agno = busyp->agno; |
ebf55872 CH |
572 | pag = xfs_perag_get(mp, agno); |
573 | spin_lock(&pag->pagb_lock); | |
574 | wakeup = false; | |
efc27b52 DC |
575 | } |
576 | ||
577 | if (do_discard && busyp->length && | |
ebf55872 | 578 | !(busyp->flags & XFS_EXTENT_BUSY_SKIP_DISCARD)) { |
4ecbfe63 | 579 | busyp->flags = XFS_EXTENT_BUSY_DISCARDED; |
ebf55872 | 580 | } else { |
4ecbfe63 | 581 | xfs_extent_busy_clear_one(mp, pag, busyp); |
ebf55872 CH |
582 | wakeup = true; |
583 | } | |
efc27b52 DC |
584 | } |
585 | ||
ebf55872 CH |
586 | if (pag) |
587 | xfs_extent_busy_put_pag(pag, wakeup); | |
588 | } | |
589 | ||
590 | /* | |
591 | * Flush out all busy extents for this AG. | |
8ebbf262 DC |
592 | * |
593 | * If the current transaction is holding busy extents, the caller may not want | |
594 | * to wait for committed busy extents to resolve. If we are being told just to | |
595 | * try a flush or progress has been made since we last skipped a busy extent, | |
596 | * return immediately to allow the caller to try again. | |
597 | * | |
598 | * If we are freeing extents, we might actually be holding the only free extents | |
599 | * in the transaction busy list and the log force won't resolve that situation. | |
600 | * In this case, we must return -EAGAIN to avoid a deadlock by informing the | |
601 | * caller it needs to commit the busy extents it holds before retrying the | |
602 | * extent free operation. | |
ebf55872 | 603 | */ |
8ebbf262 | 604 | int |
ebf55872 | 605 | xfs_extent_busy_flush( |
8ebbf262 | 606 | struct xfs_trans *tp, |
ebf55872 | 607 | struct xfs_perag *pag, |
6a2a9d77 DC |
608 | unsigned busy_gen, |
609 | uint32_t alloc_flags) | |
ebf55872 CH |
610 | { |
611 | DEFINE_WAIT (wait); | |
2b56c285 | 612 | int error; |
ebf55872 | 613 | |
8ebbf262 | 614 | error = xfs_log_force(tp->t_mountp, XFS_LOG_SYNC); |
ebf55872 | 615 | if (error) |
8ebbf262 DC |
616 | return error; |
617 | ||
618 | /* Avoid deadlocks on uncommitted busy extents. */ | |
619 | if (!list_empty(&tp->t_busy)) { | |
620 | if (alloc_flags & XFS_ALLOC_FLAG_TRYFLUSH) | |
621 | return 0; | |
622 | ||
623 | if (busy_gen != READ_ONCE(pag->pagb_gen)) | |
624 | return 0; | |
625 | ||
626 | if (alloc_flags & XFS_ALLOC_FLAG_FREEING) | |
627 | return -EAGAIN; | |
628 | } | |
ebf55872 | 629 | |
8ebbf262 | 630 | /* Wait for committed busy extents to resolve. */ |
ebf55872 CH |
631 | do { |
632 | prepare_to_wait(&pag->pagb_wait, &wait, TASK_KILLABLE); | |
633 | if (busy_gen != READ_ONCE(pag->pagb_gen)) | |
634 | break; | |
635 | schedule(); | |
636 | } while (1); | |
637 | ||
638 | finish_wait(&pag->pagb_wait, &wait); | |
8ebbf262 | 639 | return 0; |
ebf55872 CH |
640 | } |
641 | ||
642 | void | |
643 | xfs_extent_busy_wait_all( | |
644 | struct xfs_mount *mp) | |
645 | { | |
f250eedc | 646 | struct xfs_perag *pag; |
ebf55872 CH |
647 | DEFINE_WAIT (wait); |
648 | xfs_agnumber_t agno; | |
649 | ||
f250eedc | 650 | for_each_perag(mp, agno, pag) { |
ebf55872 CH |
651 | do { |
652 | prepare_to_wait(&pag->pagb_wait, &wait, TASK_KILLABLE); | |
653 | if (RB_EMPTY_ROOT(&pag->pagb_tree)) | |
654 | break; | |
655 | schedule(); | |
656 | } while (1); | |
657 | finish_wait(&pag->pagb_wait, &wait); | |
efc27b52 DC |
658 | } |
659 | } | |
660 | ||
661 | /* | |
662 | * Callback for list_sort to sort busy extents by the AG they reside in. | |
663 | */ | |
664 | int | |
4ecbfe63 | 665 | xfs_extent_busy_ag_cmp( |
efc27b52 | 666 | void *priv, |
4f0f586b ST |
667 | const struct list_head *l1, |
668 | const struct list_head *l2) | |
efc27b52 | 669 | { |
46694129 CH |
670 | struct xfs_extent_busy *b1 = |
671 | container_of(l1, struct xfs_extent_busy, list); | |
672 | struct xfs_extent_busy *b2 = | |
673 | container_of(l2, struct xfs_extent_busy, list); | |
674 | s32 diff; | |
675 | ||
676 | diff = b1->agno - b2->agno; | |
677 | if (!diff) | |
678 | diff = b1->bno - b2->bno; | |
679 | return diff; | |
efc27b52 | 680 | } |