Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0
2 : /*
3 : * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
4 : * Copyright (c) 2008 Dave Chinner
5 : * All Rights Reserved.
6 : */
7 : #include "xfs.h"
8 : #include "xfs_fs.h"
9 : #include "xfs_shared.h"
10 : #include "xfs_format.h"
11 : #include "xfs_log_format.h"
12 : #include "xfs_trans_resv.h"
13 : #include "xfs_mount.h"
14 : #include "xfs_trans.h"
15 : #include "xfs_trans_priv.h"
16 : #include "xfs_trace.h"
17 : #include "xfs_errortag.h"
18 : #include "xfs_error.h"
19 : #include "xfs_log.h"
20 : #include "xfs_log_priv.h"
21 :
22 : #ifdef DEBUG
23 : /*
24 : * Check that the list is sorted as it should be.
25 : *
26 : * Called with the ail lock held, but we don't want to assert fail with it
27 : * held otherwise we'll lock everything up and won't be able to debug the
28 : * cause. Hence we sample and check the state under the AIL lock and return if
29 : * everything is fine, otherwise we drop the lock and run the ASSERT checks.
30 : * Asserts may not be fatal, so pick the lock back up and continue onwards.
31 : */
32 : STATIC void
33 1373316311 : xfs_ail_check(
34 : struct xfs_ail *ailp,
35 : struct xfs_log_item *lip)
36 : __must_hold(&ailp->ail_lock)
37 : {
38 1373316311 : struct xfs_log_item *prev_lip;
39 1373316311 : struct xfs_log_item *next_lip;
40 1373316311 : xfs_lsn_t prev_lsn = NULLCOMMITLSN;
41 1373316311 : xfs_lsn_t next_lsn = NULLCOMMITLSN;
42 1373316311 : xfs_lsn_t lsn;
43 1373316311 : bool in_ail;
44 :
45 :
46 1373316311 : if (list_empty(&ailp->ail_head))
47 : return;
48 :
49 : /*
50 : * Sample then check the next and previous entries are valid.
51 : */
52 1373316311 : in_ail = test_bit(XFS_LI_IN_AIL, &lip->li_flags);
53 1373316311 : prev_lip = list_entry(lip->li_ail.prev, struct xfs_log_item, li_ail);
54 1373316311 : if (&prev_lip->li_ail != &ailp->ail_head)
55 1363421953 : prev_lsn = prev_lip->li_lsn;
56 1373316311 : next_lip = list_entry(lip->li_ail.next, struct xfs_log_item, li_ail);
57 1373316311 : if (&next_lip->li_ail != &ailp->ail_head)
58 1366103120 : next_lsn = next_lip->li_lsn;
59 1373316311 : lsn = lip->li_lsn;
60 :
61 1373316311 : if (in_ail &&
62 1373316311 : (prev_lsn == NULLCOMMITLSN || XFS_LSN_CMP(prev_lsn, lsn) <= 0) &&
63 : (next_lsn == NULLCOMMITLSN || XFS_LSN_CMP(next_lsn, lsn) >= 0))
64 : return;
65 :
66 0 : spin_unlock(&ailp->ail_lock);
67 0 : ASSERT(in_ail);
68 0 : ASSERT(prev_lsn == NULLCOMMITLSN || XFS_LSN_CMP(prev_lsn, lsn) <= 0);
69 0 : ASSERT(next_lsn == NULLCOMMITLSN || XFS_LSN_CMP(next_lsn, lsn) >= 0);
70 0 : spin_lock(&ailp->ail_lock);
71 : }
72 : #else /* !DEBUG */
73 : #define xfs_ail_check(a,l)
74 : #endif /* DEBUG */
75 :
76 : /*
77 : * Return a pointer to the last item in the AIL. If the AIL is empty, then
78 : * return NULL.
79 : */
80 : static struct xfs_log_item *
81 : xfs_ail_max(
82 : struct xfs_ail *ailp)
83 : {
84 1814979 : if (list_empty(&ailp->ail_head))
85 : return NULL;
86 :
87 962046 : return list_entry(ailp->ail_head.prev, struct xfs_log_item, li_ail);
88 : }
89 :
90 : /*
91 : * Return a pointer to the item which follows the given item in the AIL. If
92 : * the given item is the last item in the list, then return NULL.
93 : */
94 : static struct xfs_log_item *
95 : xfs_ail_next(
96 : struct xfs_ail *ailp,
97 : struct xfs_log_item *lip)
98 : {
99 348758820 : if (lip->li_ail.next == &ailp->ail_head)
100 714220 : return NULL;
101 :
102 : return list_first_entry(&lip->li_ail, struct xfs_log_item, li_ail);
103 : }
104 :
105 : /*
106 : * This is called by the log manager code to determine the LSN of the tail of
107 : * the log. This is exactly the LSN of the first item in the AIL. If the AIL
108 : * is empty, then this function returns 0.
109 : *
110 : * We need the AIL lock in order to get a coherent read of the lsn of the last
111 : * item in the AIL.
112 : */
113 : static xfs_lsn_t
114 : __xfs_ail_min_lsn(
115 : struct xfs_ail *ailp)
116 : {
117 4796733 : struct xfs_log_item *lip = xfs_ail_min(ailp);
118 :
119 4454893 : if (lip)
120 4454893 : return lip->li_lsn;
121 : return 0;
122 : }
123 :
124 : xfs_lsn_t
125 502457 : xfs_ail_min_lsn(
126 : struct xfs_ail *ailp)
127 : {
128 502457 : xfs_lsn_t lsn;
129 :
130 502457 : spin_lock(&ailp->ail_lock);
131 502457 : lsn = __xfs_ail_min_lsn(ailp);
132 502457 : spin_unlock(&ailp->ail_lock);
133 :
134 502457 : return lsn;
135 : }
136 :
137 : /*
138 : * Return the maximum lsn held in the AIL, or zero if the AIL is empty.
139 : */
140 : static xfs_lsn_t
141 272270 : xfs_ail_max_lsn(
142 : struct xfs_ail *ailp)
143 : {
144 272270 : xfs_lsn_t lsn = 0;
145 272270 : struct xfs_log_item *lip;
146 :
147 272270 : spin_lock(&ailp->ail_lock);
148 272500 : lip = xfs_ail_max(ailp);
149 197573 : if (lip)
150 197573 : lsn = lip->li_lsn;
151 272500 : spin_unlock(&ailp->ail_lock);
152 :
153 272496 : return lsn;
154 : }
155 :
156 : /*
157 : * The cursor keeps track of where our current traversal is up to by tracking
158 : * the next item in the list for us. However, for this to be safe, removing an
159 : * object from the AIL needs to invalidate any cursor that points to it. hence
160 : * the traversal cursor needs to be linked to the struct xfs_ail so that
161 : * deletion can search all the active cursors for invalidation.
162 : */
163 : STATIC void
164 13670197 : xfs_trans_ail_cursor_init(
165 : struct xfs_ail *ailp,
166 : struct xfs_ail_cursor *cur)
167 : {
168 13670197 : cur->item = NULL;
169 13670197 : list_add_tail(&cur->list, &ailp->ail_cursors);
170 13670110 : }
171 :
172 : /*
173 : * Get the next item in the traversal and advance the cursor. If the cursor
174 : * was invalidated (indicated by a lip of 1), restart the traversal.
175 : */
176 : struct xfs_log_item *
177 342571302 : xfs_trans_ail_cursor_next(
178 : struct xfs_ail *ailp,
179 : struct xfs_ail_cursor *cur)
180 : {
181 342571302 : struct xfs_log_item *lip = cur->item;
182 :
183 342571302 : if ((uintptr_t)lip & 1)
184 40538 : lip = xfs_ail_min(ailp);
185 342571237 : if (lip)
186 342404780 : cur->item = xfs_ail_next(ailp, lip);
187 342571302 : return lip;
188 : }
189 :
190 : /*
191 : * When the traversal is complete, we need to remove the cursor from the list
192 : * of traversing cursors.
193 : */
194 : void
195 7027694 : xfs_trans_ail_cursor_done(
196 : struct xfs_ail_cursor *cur)
197 : {
198 13670269 : cur->item = NULL;
199 7027694 : list_del_init(&cur->list);
200 7027694 : }
201 :
202 : /*
203 : * Invalidate any cursor that is pointing to this item. This is called when an
204 : * item is removed from the AIL. Any cursor pointing to this object is now
205 : * invalid and the traversal needs to be terminated so it doesn't reference a
206 : * freed object. We set the low bit of the cursor item pointer so we can
207 : * distinguish between an invalidation and the end of the list when getting the
208 : * next item from the cursor.
209 : */
210 : STATIC void
211 1373316311 : xfs_trans_ail_cursor_clear(
212 : struct xfs_ail *ailp,
213 : struct xfs_log_item *lip)
214 : {
215 1373316311 : struct xfs_ail_cursor *cur;
216 :
217 2255925082 : list_for_each_entry(cur, &ailp->ail_cursors, list) {
218 882608771 : if (cur->item == lip)
219 4541345 : cur->item = (struct xfs_log_item *)
220 4541345 : ((uintptr_t)cur->item | 1);
221 : }
222 1373316311 : }
223 :
224 : /*
225 : * Find the first item in the AIL with the given @lsn by searching in ascending
226 : * LSN order and initialise the cursor to point to the next item for a
227 : * ascending traversal. Pass a @lsn of zero to initialise the cursor to the
228 : * first item in the AIL. Returns NULL if the list is empty.
229 : */
230 : struct xfs_log_item *
231 6822628 : xfs_trans_ail_cursor_first(
232 : struct xfs_ail *ailp,
233 : struct xfs_ail_cursor *cur,
234 : xfs_lsn_t lsn)
235 : {
236 6822628 : struct xfs_log_item *lip;
237 :
238 6822628 : xfs_trans_ail_cursor_init(ailp, cur);
239 :
240 6822526 : if (lsn == 0) {
241 6784694 : lip = xfs_ail_min(ailp);
242 6695924 : goto out;
243 : }
244 :
245 2971415 : list_for_each_entry(lip, &ailp->ail_head, li_ail) {
246 2971228 : if (XFS_LSN_CMP(lip->li_lsn, lsn) >= 0)
247 37645 : goto out;
248 : }
249 : return NULL;
250 :
251 6733569 : out:
252 6822339 : if (lip)
253 7068260 : cur->item = xfs_ail_next(ailp, lip);
254 : return lip;
255 : }
256 :
257 : static struct xfs_log_item *
258 11907411 : __xfs_trans_ail_cursor_last(
259 : struct xfs_ail *ailp,
260 : xfs_lsn_t lsn)
261 : {
262 11907411 : struct xfs_log_item *lip;
263 :
264 14577551 : list_for_each_entry_reverse(lip, &ailp->ail_head, li_ail) {
265 13424089 : if (XFS_LSN_CMP(lip->li_lsn, lsn) <= 0)
266 10753949 : return lip;
267 : }
268 : return NULL;
269 : }
270 :
271 : /*
272 : * Find the last item in the AIL with the given @lsn by searching in descending
273 : * LSN order and initialise the cursor to point to that item. If there is no
274 : * item with the value of @lsn, then it sets the cursor to the last item with an
275 : * LSN lower than @lsn. Returns NULL if the list is empty.
276 : */
277 : struct xfs_log_item *
278 6847602 : xfs_trans_ail_cursor_last(
279 : struct xfs_ail *ailp,
280 : struct xfs_ail_cursor *cur,
281 : xfs_lsn_t lsn)
282 : {
283 6847602 : xfs_trans_ail_cursor_init(ailp, cur);
284 6847602 : cur->item = __xfs_trans_ail_cursor_last(ailp, lsn);
285 6847602 : return cur->item;
286 : }
287 :
288 : /*
289 : * Splice the log item list into the AIL at the given LSN. We splice to the
290 : * tail of the given LSN to maintain insert order for push traversals. The
291 : * cursor is optional, allowing repeated updates to the same LSN to avoid
292 : * repeated traversals. This should not be called with an empty list.
293 : */
294 : static void
295 47082154 : xfs_ail_splice(
296 : struct xfs_ail *ailp,
297 : struct xfs_ail_cursor *cur,
298 : struct list_head *list,
299 : xfs_lsn_t lsn)
300 : {
301 47082154 : struct xfs_log_item *lip;
302 :
303 47082154 : ASSERT(!list_empty(list));
304 :
305 : /*
306 : * Use the cursor to determine the insertion point if one is
307 : * provided. If not, or if the one we got is not valid,
308 : * find the place in the AIL where the items belong.
309 : */
310 47082154 : lip = cur ? cur->item : NULL;
311 46911021 : if (!lip || (uintptr_t)lip & 1)
312 5059809 : lip = __xfs_trans_ail_cursor_last(ailp, lsn);
313 :
314 : /*
315 : * If a cursor is provided, we know we're processing the AIL
316 : * in lsn order, and future items to be spliced in will
317 : * follow the last one being inserted now. Update the
318 : * cursor to point to that last item, now while we have a
319 : * reliable pointer to it.
320 : */
321 47082154 : if (cur)
322 46911021 : cur->item = list_entry(list->prev, struct xfs_log_item, li_ail);
323 :
324 : /*
325 : * Finally perform the splice. Unless the AIL was empty,
326 : * lip points to the item in the AIL _after_ which the new
327 : * items should go. If lip is null the AIL was empty, so
328 : * the new items go at the head of the AIL.
329 : */
330 47082154 : if (lip)
331 46328071 : list_splice(list, &lip->li_ail);
332 : else
333 754083 : list_splice(list, &ailp->ail_head);
334 47082154 : }
335 :
336 : /*
337 : * Delete the given item from the AIL. Return a pointer to the item.
338 : */
339 : static void
340 1373316312 : xfs_ail_delete(
341 : struct xfs_ail *ailp,
342 : struct xfs_log_item *lip)
343 : {
344 1373316312 : xfs_ail_check(ailp, lip);
345 1373316311 : list_del(&lip->li_ail);
346 1373316312 : xfs_trans_ail_cursor_clear(ailp, lip);
347 1373316310 : }
348 :
349 : /*
350 : * Requeue a failed buffer for writeback.
351 : *
352 : * We clear the log item failed state here as well, but we have to be careful
353 : * about reference counts because the only active reference counts on the buffer
354 : * may be the failed log items. Hence if we clear the log item failed state
355 : * before queuing the buffer for IO we can release all active references to
356 : * the buffer and free it, leading to use after free problems in
357 : * xfs_buf_delwri_queue. It makes no difference to the buffer or log items which
358 : * order we process them in - the buffer is locked, and we own the buffer list
359 : * so nothing on them is going to change while we are performing this action.
360 : *
361 : * Hence we can safely queue the buffer for IO before we clear the failed log
362 : * item state, therefore always having an active reference to the buffer and
363 : * avoiding the transient zero-reference state that leads to use-after-free.
364 : */
365 : static inline int
366 310 : xfsaild_resubmit_item(
367 : struct xfs_log_item *lip,
368 : struct list_head *buffer_list)
369 : {
370 310 : struct xfs_buf *bp = lip->li_buf;
371 :
372 310 : if (!xfs_buf_trylock(bp))
373 : return XFS_ITEM_LOCKED;
374 :
375 310 : if (!xfs_buf_delwri_queue(bp, buffer_list)) {
376 0 : xfs_buf_unlock(bp);
377 0 : return XFS_ITEM_FLUSHING;
378 : }
379 :
380 : /* protected by ail_lock */
381 799 : list_for_each_entry(lip, &bp->b_li_list, li_bio_list) {
382 489 : if (bp->b_flags & _XBF_INODES)
383 358 : clear_bit(XFS_LI_FAILED, &lip->li_flags);
384 : else
385 131 : xfs_clear_li_failed(lip);
386 : }
387 :
388 310 : xfs_buf_unlock(bp);
389 310 : return XFS_ITEM_SUCCESS;
390 : }
391 :
392 : static inline uint
393 342632472 : xfsaild_push_item(
394 : struct xfs_ail *ailp,
395 : struct xfs_log_item *lip)
396 : {
397 : /*
398 : * If log item pinning is enabled, skip the push and track the item as
399 : * pinned. This can help induce head-behind-tail conditions.
400 : */
401 342632472 : if (XFS_TEST_ERROR(false, ailp->ail_log->l_mp, XFS_ERRTAG_LOG_ITEM_PIN))
402 : return XFS_ITEM_PINNED;
403 :
404 : /*
405 : * Consider the item pinned if a push callback is not defined so the
406 : * caller will force the log. This should only happen for intent items
407 : * as they are unpinned once the associated done item is committed to
408 : * the on-disk log.
409 : */
410 342617123 : if (!lip->li_ops->iop_push)
411 : return XFS_ITEM_PINNED;
412 684574094 : if (test_bit(XFS_LI_FAILED, &lip->li_flags))
413 310 : return xfsaild_resubmit_item(lip, &ailp->ail_buf_list);
414 342286737 : return lip->li_ops->iop_push(lip, &ailp->ail_buf_list);
415 : }
416 :
417 : static long
418 6642513 : xfsaild_push(
419 : struct xfs_ail *ailp)
420 : {
421 6642513 : struct xfs_mount *mp = ailp->ail_log->l_mp;
422 6642513 : struct xfs_ail_cursor cur;
423 6642513 : struct xfs_log_item *lip;
424 6642513 : xfs_lsn_t lsn;
425 6642513 : xfs_lsn_t target = NULLCOMMITLSN;
426 6642513 : long tout;
427 6642513 : int stuck = 0;
428 6642513 : int flushing = 0;
429 6642513 : int count = 0;
430 :
431 : /*
432 : * If we encountered pinned items or did not finish writing out all
433 : * buffers the last time we ran, force a background CIL push to get the
434 : * items unpinned in the near future. We do not wait on the CIL push as
435 : * that could stall us for seconds if there is enough background IO
436 : * load. Stalling for that long when the tail of the log is pinned and
437 : * needs flushing will hard stop the transaction subsystem when log
438 : * space runs out.
439 : */
440 6642513 : if (ailp->ail_log_flush && ailp->ail_last_pushed_lsn == 0 &&
441 456417 : (!list_empty_careful(&ailp->ail_buf_list) ||
442 163882 : xfs_ail_min_lsn(ailp))) {
443 292506 : ailp->ail_log_flush = 0;
444 :
445 292506 : XFS_STATS_INC(mp, xs_push_ail_flush);
446 292506 : xlog_cil_flush(ailp->ail_log);
447 : }
448 :
449 6642513 : spin_lock(&ailp->ail_lock);
450 :
451 : /*
452 : * If we have a sync push waiter, we always have to push till the AIL is
453 : * empty. Update the target to point to the end of the AIL so that
454 : * capture updates that occur after the sync push waiter has gone to
455 : * sleep.
456 : */
457 6642539 : if (waitqueue_active(&ailp->ail_empty)) {
458 389214 : lip = xfs_ail_max(ailp);
459 389214 : if (lip)
460 389214 : target = lip->li_lsn;
461 : } else {
462 : /* barrier matches the ail_target update in xfs_ail_push() */
463 6253325 : smp_rmb();
464 6253327 : target = ailp->ail_target;
465 6253327 : ailp->ail_target_prev = target;
466 : }
467 :
468 : /* we're done if the AIL is empty or our push has reached the end */
469 6642541 : lip = xfs_trans_ail_cursor_first(ailp, &cur, ailp->ail_last_pushed_lsn);
470 6642549 : if (!lip)
471 77015 : goto out_done;
472 :
473 6565534 : XFS_STATS_INC(mp, xs_push_ail);
474 :
475 6565567 : ASSERT(target != NULLCOMMITLSN);
476 :
477 6565567 : lsn = lip->li_lsn;
478 348556179 : while ((XFS_LSN_CMP(lip->li_lsn, target) <= 0)) {
479 342632463 : int lock_result;
480 :
481 : /*
482 : * Note that iop_push may unlock and reacquire the AIL lock. We
483 : * rely on the AIL cursor implementation to be able to deal with
484 : * the dropped lock.
485 : */
486 342632463 : lock_result = xfsaild_push_item(ailp, lip);
487 342632475 : switch (lock_result) {
488 180135124 : case XFS_ITEM_SUCCESS:
489 180135124 : XFS_STATS_INC(mp, xs_push_ail_success);
490 180135124 : trace_xfs_ail_push(lip);
491 :
492 180135124 : ailp->ail_last_pushed_lsn = lsn;
493 180135124 : break;
494 :
495 147872479 : case XFS_ITEM_FLUSHING:
496 : /*
497 : * The item or its backing buffer is already being
498 : * flushed. The typical reason for that is that an
499 : * inode buffer is locked because we already pushed the
500 : * updates to it as part of inode clustering.
501 : *
502 : * We do not want to stop flushing just because lots
503 : * of items are already being flushed, but we need to
504 : * re-try the flushing relatively soon if most of the
505 : * AIL is being flushed.
506 : */
507 147872479 : XFS_STATS_INC(mp, xs_push_ail_flushing);
508 147872479 : trace_xfs_ail_flushing(lip);
509 :
510 147872479 : flushing++;
511 147872479 : ailp->ail_last_pushed_lsn = lsn;
512 147872479 : break;
513 :
514 13108167 : case XFS_ITEM_PINNED:
515 13108167 : XFS_STATS_INC(mp, xs_push_ail_pinned);
516 13108167 : trace_xfs_ail_pinned(lip);
517 :
518 13108167 : stuck++;
519 13108167 : ailp->ail_log_flush++;
520 13108167 : break;
521 1516705 : case XFS_ITEM_LOCKED:
522 1516705 : XFS_STATS_INC(mp, xs_push_ail_locked);
523 1516705 : trace_xfs_ail_locked(lip);
524 :
525 1516705 : stuck++;
526 1516705 : break;
527 0 : default:
528 0 : ASSERT(0);
529 0 : break;
530 : }
531 :
532 342632475 : count++;
533 :
534 : /*
535 : * Are there too many items we can't do anything with?
536 : *
537 : * If we are skipping too many items because we can't flush
538 : * them or they are already being flushed, we back off and
539 : * given them time to complete whatever operation is being
540 : * done. i.e. remove pressure from the AIL while we can't make
541 : * progress so traversals don't slow down further inserts and
542 : * removals to/from the AIL.
543 : *
544 : * The value of 100 is an arbitrary magic number based on
545 : * observation.
546 : */
547 342632475 : if (stuck > 100)
548 : break;
549 :
550 342534591 : lip = xfs_trans_ail_cursor_next(ailp, &cur);
551 342534572 : if (lip == NULL)
552 : break;
553 341990612 : lsn = lip->li_lsn;
554 : }
555 :
556 641844 : out_done:
557 6642575 : xfs_trans_ail_cursor_done(&cur);
558 6642574 : spin_unlock(&ailp->ail_lock);
559 :
560 6642577 : if (xfs_buf_delwri_submit_nowait(&ailp->ail_buf_list))
561 147802 : ailp->ail_log_flush++;
562 :
563 6642346 : if (!count || XFS_LSN_CMP(lsn, target) >= 0) {
564 : /*
565 : * We reached the target or the AIL is empty, so wait a bit
566 : * longer for I/O to complete and remove pushed items from the
567 : * AIL before we start the next scan from the start of the AIL.
568 : */
569 6532646 : tout = 50;
570 6532646 : ailp->ail_last_pushed_lsn = 0;
571 109700 : } else if (((stuck + flushing) * 100) / count > 90) {
572 : /*
573 : * Either there is a lot of contention on the AIL or we are
574 : * stuck due to operations in progress. "Stuck" in this case
575 : * is defined as >90% of the items we tried to push were stuck.
576 : *
577 : * Backoff a bit more to allow some I/O to complete before
578 : * restarting from the start of the AIL. This prevents us from
579 : * spinning on the same items, and if they are pinned will all
580 : * the restart to issue a log force to unpin the stuck items.
581 : */
582 71327 : tout = 20;
583 71327 : ailp->ail_last_pushed_lsn = 0;
584 : } else {
585 : /*
586 : * Assume we have more work to do in a short while.
587 : */
588 : tout = 10;
589 : }
590 :
591 6642346 : return tout;
592 : }
593 :
594 : static int
595 66856 : xfsaild(
596 : void *data)
597 : {
598 66856 : struct xfs_ail *ailp = data;
599 66856 : long tout = 0; /* milliseconds */
600 66856 : unsigned int noreclaim_flag;
601 :
602 66856 : noreclaim_flag = memalloc_noreclaim_save();
603 66856 : set_freezable();
604 :
605 6810144 : while (1) {
606 6810144 : if (tout && tout <= 20)
607 109700 : set_current_state(TASK_KILLABLE|TASK_FREEZABLE);
608 : else
609 6700444 : set_current_state(TASK_INTERRUPTIBLE|TASK_FREEZABLE);
610 :
611 : /*
612 : * Check kthread_should_stop() after we set the task state to
613 : * guarantee that we either see the stop bit and exit or the
614 : * task state is reset to runnable such that it's not scheduled
615 : * out indefinitely and detects the stop bit at next iteration.
616 : * A memory barrier is included in above task state set to
617 : * serialize again kthread_stop().
618 : */
619 6810391 : if (kthread_should_stop()) {
620 66867 : __set_current_state(TASK_RUNNING);
621 :
622 : /*
623 : * The caller forces out the AIL before stopping the
624 : * thread in the common case, which means the delwri
625 : * queue is drained. In the shutdown case, the queue may
626 : * still hold relogged buffers that haven't been
627 : * submitted because they were pinned since added to the
628 : * queue.
629 : *
630 : * Log I/O error processing stales the underlying buffer
631 : * and clears the delwri state, expecting the buf to be
632 : * removed on the next submission attempt. That won't
633 : * happen if we're shutting down, so this is the last
634 : * opportunity to release such buffers from the queue.
635 : */
636 66867 : ASSERT(list_empty(&ailp->ail_buf_list) ||
637 : xlog_is_shutdown(ailp->ail_log));
638 66867 : xfs_buf_delwri_cancel(&ailp->ail_buf_list);
639 66867 : break;
640 : }
641 :
642 6743389 : spin_lock(&ailp->ail_lock);
643 :
644 : /*
645 : * Idle if the AIL is empty and we are not racing with a target
646 : * update. We check the AIL after we set the task to a sleep
647 : * state to guarantee that we either catch an ail_target update
648 : * or that a wake_up resets the state to TASK_RUNNING.
649 : * Otherwise, we run the risk of sleeping indefinitely.
650 : *
651 : * The barrier matches the ail_target update in xfs_ail_push().
652 : */
653 6743402 : smp_rmb();
654 6743401 : if (!xfs_ail_min(ailp) &&
655 101020 : ailp->ail_target == ailp->ail_target_prev &&
656 101020 : list_empty(&ailp->ail_buf_list)) {
657 100941 : spin_unlock(&ailp->ail_lock);
658 100942 : schedule();
659 100954 : tout = 0;
660 100954 : continue;
661 : }
662 6642460 : spin_unlock(&ailp->ail_lock);
663 :
664 6642445 : if (tout)
665 13108974 : schedule_timeout(msecs_to_jiffies(tout));
666 :
667 6642522 : __set_current_state(TASK_RUNNING);
668 :
669 6642522 : try_to_freeze();
670 :
671 6642513 : tout = xfsaild_push(ailp);
672 : }
673 :
674 66867 : memalloc_noreclaim_restore(noreclaim_flag);
675 66867 : return 0;
676 : }
677 :
678 : /*
679 : * This routine is called to move the tail of the AIL forward. It does this by
680 : * trying to flush items in the AIL whose lsns are below the given
681 : * threshold_lsn.
682 : *
683 : * The push is run asynchronously in a workqueue, which means the caller needs
684 : * to handle waiting on the async flush for space to become available.
685 : * We don't want to interrupt any push that is in progress, hence we only queue
686 : * work if we set the pushing bit appropriately.
687 : *
688 : * We do this unlocked - we only need to know whether there is anything in the
689 : * AIL at the time we are called. We don't need to access the contents of
690 : * any of the objects, so the lock is not needed.
691 : */
692 : void
693 54090889 : xfs_ail_push(
694 : struct xfs_ail *ailp,
695 : xfs_lsn_t threshold_lsn)
696 : {
697 54090889 : struct xfs_log_item *lip;
698 :
699 54090889 : lip = xfs_ail_min(ailp);
700 106427596 : if (!lip || xlog_is_shutdown(ailp->ail_log) ||
701 53213788 : XFS_LSN_CMP(threshold_lsn, ailp->ail_target) <= 0)
702 : return;
703 :
704 : /*
705 : * Ensure that the new target is noticed in push code before it clears
706 : * the XFS_AIL_PUSHING_BIT.
707 : */
708 216734 : smp_wmb();
709 216725 : xfs_trans_ail_copy_lsn(ailp, &ailp->ail_target, &threshold_lsn);
710 216725 : smp_wmb();
711 :
712 216682 : wake_up_process(ailp->ail_task);
713 : }
714 :
715 : /*
716 : * Push out all items in the AIL immediately
717 : */
718 : void
719 272370 : xfs_ail_push_all(
720 : struct xfs_ail *ailp)
721 : {
722 272370 : xfs_lsn_t threshold_lsn = xfs_ail_max_lsn(ailp);
723 :
724 272496 : if (threshold_lsn)
725 197569 : xfs_ail_push(ailp, threshold_lsn);
726 272476 : }
727 :
728 : /*
729 : * Push out all items in the AIL immediately and wait until the AIL is empty.
730 : */
731 : void
732 778006 : xfs_ail_push_all_sync(
733 : struct xfs_ail *ailp)
734 : {
735 778006 : DEFINE_WAIT(wait);
736 :
737 778006 : spin_lock(&ailp->ail_lock);
738 1153265 : while (xfs_ail_max(ailp) != NULL) {
739 375259 : prepare_to_wait(&ailp->ail_empty, &wait, TASK_UNINTERRUPTIBLE);
740 375259 : wake_up_process(ailp->ail_task);
741 375259 : spin_unlock(&ailp->ail_lock);
742 375259 : schedule();
743 375259 : spin_lock(&ailp->ail_lock);
744 : }
745 778006 : spin_unlock(&ailp->ail_lock);
746 :
747 778006 : finish_wait(&ailp->ail_empty, &wait);
748 778006 : }
749 :
750 : void
751 296433997 : xfs_ail_update_finish(
752 : struct xfs_ail *ailp,
753 : xfs_lsn_t old_lsn) __releases(ailp->ail_lock)
754 : {
755 296433997 : struct xlog *log = ailp->ail_log;
756 :
757 : /* if the tail lsn hasn't changed, don't do updates or wakeups. */
758 301230730 : if (!old_lsn || old_lsn == __xfs_ail_min_lsn(ailp)) {
759 295083096 : spin_unlock(&ailp->ail_lock);
760 295083096 : return;
761 : }
762 :
763 2701802 : if (!xlog_is_shutdown(log))
764 1301305 : xlog_assign_tail_lsn_locked(log->l_mp);
765 :
766 1350901 : if (list_empty(&ailp->ail_head))
767 507018 : wake_up_all(&ailp->ail_empty);
768 1350901 : spin_unlock(&ailp->ail_lock);
769 1350901 : xfs_log_space_wake(log->l_mp);
770 : }
771 :
772 : /*
773 : * xfs_trans_ail_update - bulk AIL insertion operation.
774 : *
775 : * @xfs_trans_ail_update takes an array of log items that all need to be
776 : * positioned at the same LSN in the AIL. If an item is not in the AIL, it will
777 : * be added. Otherwise, it will be repositioned by removing it and re-adding
778 : * it to the AIL. If we move the first item in the AIL, update the log tail to
779 : * match the new minimum LSN in the AIL.
780 : *
781 : * This function takes the AIL lock once to execute the update operations on
782 : * all the items in the array, and as such should not be called with the AIL
783 : * lock held. As a result, once we have the AIL lock, we need to check each log
784 : * item LSN to confirm it needs to be moved forward in the AIL.
785 : *
786 : * To optimise the insert operation, we delete all the items from the AIL in
787 : * the first pass, moving them into a temporary list, then splice the temporary
788 : * list into the correct position in the AIL. This avoids needing to do an
789 : * insert operation on every item.
790 : *
791 : * This function must be called with the AIL lock held. The lock is dropped
792 : * before returning.
793 : */
794 : void
795 47085018 : xfs_trans_ail_update_bulk(
796 : struct xfs_ail *ailp,
797 : struct xfs_ail_cursor *cur,
798 : struct xfs_log_item **log_items,
799 : int nr_items,
800 : xfs_lsn_t lsn) __releases(ailp->ail_lock)
801 : {
802 47085018 : struct xfs_log_item *mlip;
803 47085018 : xfs_lsn_t tail_lsn = 0;
804 47085018 : int i;
805 47085018 : LIST_HEAD(tmp);
806 :
807 47085018 : ASSERT(nr_items > 0); /* Not required, but true. */
808 47085018 : mlip = xfs_ail_min(ailp);
809 :
810 1420566934 : for (i = 0; i < nr_items; i++) {
811 1373481916 : struct xfs_log_item *lip = log_items[i];
812 1373481916 : if (test_and_set_bit(XFS_LI_IN_AIL, &lip->li_flags)) {
813 : /* check if we really need to move the item */
814 817382603 : if (XFS_LSN_CMP(lsn, lip->li_lsn) <= 0)
815 165801 : continue;
816 :
817 817216802 : trace_xfs_ail_move(lip, lip->li_lsn, lsn);
818 817216802 : if (mlip == lip && !tail_lsn)
819 653564 : tail_lsn = lip->li_lsn;
820 :
821 817216802 : xfs_ail_delete(ailp, lip);
822 : } else {
823 556099313 : trace_xfs_ail_insert(lip, 0, lsn);
824 : }
825 1373316115 : lip->li_lsn = lsn;
826 1373316115 : list_add_tail(&lip->li_ail, &tmp);
827 : }
828 :
829 47085018 : if (!list_empty(&tmp))
830 47082154 : xfs_ail_splice(ailp, cur, &tmp, lsn);
831 :
832 47085018 : xfs_ail_update_finish(ailp, tail_lsn);
833 47085018 : }
834 :
835 : /* Insert a log item into the AIL. */
836 : void
837 171133 : xfs_trans_ail_insert(
838 : struct xfs_ail *ailp,
839 : struct xfs_log_item *lip,
840 : xfs_lsn_t lsn)
841 : {
842 171133 : spin_lock(&ailp->ail_lock);
843 171133 : xfs_trans_ail_update_bulk(ailp, NULL, &lip, 1, lsn);
844 171133 : }
845 :
846 : /*
847 : * Delete one log item from the AIL.
848 : *
849 : * If this item was at the tail of the AIL, return the LSN of the log item so
850 : * that we can use it to check if the LSN of the tail of the log has moved
851 : * when finishing up the AIL delete process in xfs_ail_update_finish().
852 : */
853 : xfs_lsn_t
854 556099510 : xfs_ail_delete_one(
855 : struct xfs_ail *ailp,
856 : struct xfs_log_item *lip)
857 : {
858 556099510 : struct xfs_log_item *mlip = xfs_ail_min(ailp);
859 556099510 : xfs_lsn_t lsn = lip->li_lsn;
860 :
861 556099510 : trace_xfs_ail_delete(lip, mlip->li_lsn, lip->li_lsn);
862 556099510 : xfs_ail_delete(ailp, lip);
863 556099508 : clear_bit(XFS_LI_IN_AIL, &lip->li_flags);
864 556099511 : lip->li_lsn = 0;
865 :
866 556099511 : if (mlip == lip)
867 7673450 : return lsn;
868 : return 0;
869 : }
870 :
871 : void
872 1873619793 : xfs_trans_ail_delete(
873 : struct xfs_log_item *lip,
874 : int shutdown_type)
875 : {
876 1873619793 : struct xfs_ail *ailp = lip->li_ailp;
877 1873619793 : struct xlog *log = ailp->ail_log;
878 1873619793 : xfs_lsn_t tail_lsn;
879 :
880 1873619793 : spin_lock(&ailp->ail_lock);
881 1873804473 : if (!test_bit(XFS_LI_IN_AIL, &lip->li_flags)) {
882 1713055579 : spin_unlock(&ailp->ail_lock);
883 1713096432 : if (shutdown_type && !xlog_is_shutdown(log)) {
884 0 : xfs_alert_tag(log->l_mp, XFS_PTAG_AILDELETE,
885 : "%s: attempting to delete a log item that is not in the AIL",
886 : __func__);
887 0 : xlog_force_shutdown(log, shutdown_type);
888 : }
889 1712983869 : return;
890 : }
891 :
892 : /* xfs_ail_update_finish() drops the AIL lock */
893 160748894 : xfs_clear_li_failed(lip);
894 160748893 : tail_lsn = xfs_ail_delete_one(ailp, lip);
895 160748894 : xfs_ail_update_finish(ailp, tail_lsn);
896 : }
897 :
898 : int
899 66856 : xfs_trans_ail_init(
900 : xfs_mount_t *mp)
901 : {
902 66856 : struct xfs_ail *ailp;
903 :
904 66856 : ailp = kmem_zalloc(sizeof(struct xfs_ail), KM_MAYFAIL);
905 66856 : if (!ailp)
906 : return -ENOMEM;
907 :
908 66856 : ailp->ail_log = mp->m_log;
909 66856 : INIT_LIST_HEAD(&ailp->ail_head);
910 66856 : INIT_LIST_HEAD(&ailp->ail_cursors);
911 66856 : spin_lock_init(&ailp->ail_lock);
912 66856 : INIT_LIST_HEAD(&ailp->ail_buf_list);
913 66856 : init_waitqueue_head(&ailp->ail_empty);
914 :
915 66856 : ailp->ail_task = kthread_run(xfsaild, ailp, "xfsaild/%s",
916 : mp->m_super->s_id);
917 66856 : if (IS_ERR(ailp->ail_task))
918 0 : goto out_free_ailp;
919 :
920 66856 : mp->m_ail = ailp;
921 66856 : return 0;
922 :
923 : out_free_ailp:
924 0 : kmem_free(ailp);
925 0 : return -ENOMEM;
926 : }
927 :
928 : void
929 66867 : xfs_trans_ail_destroy(
930 : xfs_mount_t *mp)
931 : {
932 66867 : struct xfs_ail *ailp = mp->m_ail;
933 :
934 66867 : kthread_stop(ailp->ail_task);
935 66867 : kmem_free(ailp);
936 66867 : }
|
