2 * Copyright (c) 2010 Red Hat, Inc. All Rights Reserved.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation.
8 * This program is distributed in the hope that it would be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write the Free Software Foundation,
15 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 #include "xfs_log_format.h"
21 #include "xfs_shared.h"
22 #include "xfs_trans_resv.h"
25 #include "xfs_mount.h"
26 #include "xfs_error.h"
27 #include "xfs_alloc.h"
28 #include "xfs_extent_busy.h"
29 #include "xfs_discard.h"
30 #include "xfs_trans.h"
31 #include "xfs_trans_priv.h"
33 #include "xfs_log_priv.h"
36 * Allocate a new ticket. Failing to get a new ticket makes it really hard to
37 * recover, so we don't allow failure here. Also, we allocate in a context that
38 * we don't want to be issuing transactions from, so we need to tell the
39 * allocation code this as well.
41 * We don't reserve any space for the ticket - we are going to steal whatever
42 * space we require from transactions as they commit. To ensure we reserve all
43 * the space required, we need to set the current reservation of the ticket to
44 * zero so that we know to steal the initial transaction overhead from the
45 * first transaction commit.
47 static struct xlog_ticket
*
48 xlog_cil_ticket_alloc(
51 struct xlog_ticket
*tic
;
53 tic
= xlog_ticket_alloc(log
, 0, 1, XFS_TRANSACTION
, 0,
55 tic
->t_trans_type
= XFS_TRANS_CHECKPOINT
;
58 * set the current reservation to zero so we know to steal the basic
59 * transaction overhead reservation from the first transaction commit.
66 * After the first stage of log recovery is done, we know where the head and
67 * tail of the log are. We need this log initialisation done before we can
68 * initialise the first CIL checkpoint context.
70 * Here we allocate a log ticket to track space usage during a CIL push. This
71 * ticket is passed to xlog_write() directly so that we don't slowly leak log
72 * space by failing to account for space used by log headers and additional
73 * region headers for split regions.
76 xlog_cil_init_post_recovery(
79 log
->l_cilp
->xc_ctx
->ticket
= xlog_cil_ticket_alloc(log
);
80 log
->l_cilp
->xc_ctx
->sequence
= 1;
81 log
->l_cilp
->xc_ctx
->commit_lsn
= xlog_assign_lsn(log
->l_curr_cycle
,
86 * Prepare the log item for insertion into the CIL. Calculate the difference in
87 * log space and vectors it will consume, and if it is a new item pin it as
93 struct xfs_log_vec
*lv
,
94 struct xfs_log_vec
*old_lv
,
98 /* Account for the new LV being passed in */
99 if (lv
->lv_buf_len
!= XFS_LOG_VEC_ORDERED
) {
100 *diff_len
+= lv
->lv_buf_len
;
101 *diff_iovecs
+= lv
->lv_niovecs
;
105 * If there is no old LV, this is the first time we've seen the item in
106 * this CIL context and so we need to pin it. If we are replacing the
107 * old_lv, then remove the space it accounts for and free it.
110 lv
->lv_item
->li_ops
->iop_pin(lv
->lv_item
);
111 else if (old_lv
!= lv
) {
112 ASSERT(lv
->lv_buf_len
!= XFS_LOG_VEC_ORDERED
);
114 *diff_len
-= old_lv
->lv_buf_len
;
115 *diff_iovecs
-= old_lv
->lv_niovecs
;
119 /* attach new log vector to log item */
120 lv
->lv_item
->li_lv
= lv
;
123 * If this is the first time the item is being committed to the
124 * CIL, store the sequence number on the log item so we can
125 * tell in future commits whether this is the first checkpoint
126 * the item is being committed into.
128 if (!lv
->lv_item
->li_seq
)
129 lv
->lv_item
->li_seq
= log
->l_cilp
->xc_ctx
->sequence
;
133 * Format log item into a flat buffers
135 * For delayed logging, we need to hold a formatted buffer containing all the
136 * changes on the log item. This enables us to relog the item in memory and
137 * write it out asynchronously without needing to relock the object that was
138 * modified at the time it gets written into the iclog.
140 * This function builds a vector for the changes in each log item in the
141 * transaction. It then works out the length of the buffer needed for each log
142 * item, allocates them and formats the vector for the item into the buffer.
143 * The buffer is then attached to the log item are then inserted into the
144 * Committed Item List for tracking until the next checkpoint is written out.
146 * We don't set up region headers during this process; we simply copy the
147 * regions into the flat buffer. We can do this because we still have to do a
148 * formatting step to write the regions into the iclog buffer. Writing the
149 * ophdrs during the iclog write means that we can support splitting large
150 * regions across iclog boundares without needing a change in the format of the
151 * item/region encapsulation.
153 * Hence what we need to do now is change the rewrite the vector array to point
154 * to the copied region inside the buffer we just allocated. This allows us to
155 * format the regions into the iclog as though they are being formatted
156 * directly out of the objects themselves.
159 xlog_cil_insert_format_items(
161 struct xfs_trans
*tp
,
165 struct xfs_log_item_desc
*lidp
;
168 /* Bail out if we didn't find a log item. */
169 if (list_empty(&tp
->t_items
)) {
174 list_for_each_entry(lidp
, &tp
->t_items
, lid_trans
) {
175 struct xfs_log_item
*lip
= lidp
->lid_item
;
176 struct xfs_log_vec
*lv
;
177 struct xfs_log_vec
*old_lv
;
181 bool ordered
= false;
183 /* Skip items which aren't dirty in this transaction. */
184 if (!(lidp
->lid_flags
& XFS_LID_DIRTY
))
187 /* get number of vecs and size of data to be stored */
188 lip
->li_ops
->iop_size(lip
, &niovecs
, &nbytes
);
190 /* Skip items that do not have any vectors for writing */
195 * Ordered items need to be tracked but we do not wish to write
196 * them. We need a logvec to track the object, but we do not
197 * need an iovec or buffer to be allocated for copying data.
199 if (niovecs
== XFS_LOG_VEC_ORDERED
) {
206 * We 64-bit align the length of each iovec so that the start
207 * of the next one is naturally aligned. We'll need to
208 * account for that slack space here. Then round nbytes up
209 * to 64-bit alignment so that the initial buffer alignment is
210 * easy to calculate and verify.
212 nbytes
+= niovecs
* sizeof(uint64_t);
213 nbytes
= round_up(nbytes
, sizeof(uint64_t));
215 /* grab the old item if it exists for reservation accounting */
219 * The data buffer needs to start 64-bit aligned, so round up
220 * that space to ensure we can align it appropriately and not
221 * overrun the buffer.
224 round_up((sizeof(struct xfs_log_vec
) +
225 niovecs
* sizeof(struct xfs_log_iovec
)),
228 /* compare to existing item size */
229 if (lip
->li_lv
&& buf_size
<= lip
->li_lv
->lv_size
) {
230 /* same or smaller, optimise common overwrite case */
238 * set the item up as though it is a new insertion so
239 * that the space reservation accounting is correct.
241 *diff_iovecs
-= lv
->lv_niovecs
;
242 *diff_len
-= lv
->lv_buf_len
;
244 /* allocate new data chunk */
245 lv
= kmem_zalloc(buf_size
, KM_SLEEP
|KM_NOFS
);
247 lv
->lv_size
= buf_size
;
249 /* track as an ordered logvec */
250 ASSERT(lip
->li_lv
== NULL
);
251 lv
->lv_buf_len
= XFS_LOG_VEC_ORDERED
;
254 lv
->lv_iovecp
= (struct xfs_log_iovec
*)&lv
[1];
257 /* Ensure the lv is set up according to ->iop_size */
258 lv
->lv_niovecs
= niovecs
;
260 /* The allocated data region lies beyond the iovec region */
262 lv
->lv_buf
= (char *)lv
+ buf_size
- nbytes
;
263 ASSERT(IS_ALIGNED((unsigned long)lv
->lv_buf
, sizeof(uint64_t)));
265 lip
->li_ops
->iop_format(lip
, lv
);
267 ASSERT(lv
->lv_buf_len
<= nbytes
);
268 xfs_cil_prepare_item(log
, lv
, old_lv
, diff_len
, diff_iovecs
);
273 * Insert the log items into the CIL and calculate the difference in space
274 * consumed by the item. Add the space to the checkpoint ticket and calculate
275 * if the change requires additional log metadata. If it does, take that space
276 * as well. Remove the amount of space we added to the checkpoint ticket from
277 * the current transaction ticket so that the accounting works out correctly.
280 xlog_cil_insert_items(
282 struct xfs_trans
*tp
)
284 struct xfs_cil
*cil
= log
->l_cilp
;
285 struct xfs_cil_ctx
*ctx
= cil
->xc_ctx
;
286 struct xfs_log_item_desc
*lidp
;
294 * We can do this safely because the context can't checkpoint until we
295 * are done so it doesn't matter exactly how we update the CIL.
297 xlog_cil_insert_format_items(log
, tp
, &len
, &diff_iovecs
);
300 * Now (re-)position everything modified at the tail of the CIL.
301 * We do this here so we only need to take the CIL lock once during
302 * the transaction commit.
304 spin_lock(&cil
->xc_cil_lock
);
305 list_for_each_entry(lidp
, &tp
->t_items
, lid_trans
) {
306 struct xfs_log_item
*lip
= lidp
->lid_item
;
308 /* Skip items which aren't dirty in this transaction. */
309 if (!(lidp
->lid_flags
& XFS_LID_DIRTY
))
312 list_move_tail(&lip
->li_cil
, &cil
->xc_cil
);
315 /* account for space used by new iovec headers */
316 len
+= diff_iovecs
* sizeof(xlog_op_header_t
);
317 ctx
->nvecs
+= diff_iovecs
;
319 /* attach the transaction to the CIL if it has any busy extents */
320 if (!list_empty(&tp
->t_busy
))
321 list_splice_init(&tp
->t_busy
, &ctx
->busy_extents
);
324 * Now transfer enough transaction reservation to the context ticket
325 * for the checkpoint. The context ticket is special - the unit
326 * reservation has to grow as well as the current reservation as we
327 * steal from tickets so we can correctly determine the space used
328 * during the transaction commit.
330 if (ctx
->ticket
->t_curr_res
== 0) {
331 ctx
->ticket
->t_curr_res
= ctx
->ticket
->t_unit_res
;
332 tp
->t_ticket
->t_curr_res
-= ctx
->ticket
->t_unit_res
;
335 /* do we need space for more log record headers? */
336 iclog_space
= log
->l_iclog_size
- log
->l_iclog_hsize
;
337 if (len
> 0 && (ctx
->space_used
/ iclog_space
!=
338 (ctx
->space_used
+ len
) / iclog_space
)) {
341 hdrs
= (len
+ iclog_space
- 1) / iclog_space
;
342 /* need to take into account split region headers, too */
343 hdrs
*= log
->l_iclog_hsize
+ sizeof(struct xlog_op_header
);
344 ctx
->ticket
->t_unit_res
+= hdrs
;
345 ctx
->ticket
->t_curr_res
+= hdrs
;
346 tp
->t_ticket
->t_curr_res
-= hdrs
;
347 ASSERT(tp
->t_ticket
->t_curr_res
>= len
);
349 tp
->t_ticket
->t_curr_res
-= len
;
350 ctx
->space_used
+= len
;
352 spin_unlock(&cil
->xc_cil_lock
);
356 xlog_cil_free_logvec(
357 struct xfs_log_vec
*log_vector
)
359 struct xfs_log_vec
*lv
;
361 for (lv
= log_vector
; lv
; ) {
362 struct xfs_log_vec
*next
= lv
->lv_next
;
369 * Mark all items committed and clear busy extents. We free the log vector
370 * chains in a separate pass so that we unpin the log items as quickly as
378 struct xfs_cil_ctx
*ctx
= args
;
379 struct xfs_mount
*mp
= ctx
->cil
->xc_log
->l_mp
;
381 xfs_trans_committed_bulk(ctx
->cil
->xc_log
->l_ailp
, ctx
->lv_chain
,
382 ctx
->start_lsn
, abort
);
384 xfs_extent_busy_sort(&ctx
->busy_extents
);
385 xfs_extent_busy_clear(mp
, &ctx
->busy_extents
,
386 (mp
->m_flags
& XFS_MOUNT_DISCARD
) && !abort
);
389 * If we are aborting the commit, wake up anyone waiting on the
390 * committing list. If we don't, then a shutdown we can leave processes
391 * waiting in xlog_cil_force_lsn() waiting on a sequence commit that
392 * will never happen because we aborted it.
394 spin_lock(&ctx
->cil
->xc_push_lock
);
396 wake_up_all(&ctx
->cil
->xc_commit_wait
);
397 list_del(&ctx
->committing
);
398 spin_unlock(&ctx
->cil
->xc_push_lock
);
400 xlog_cil_free_logvec(ctx
->lv_chain
);
402 if (!list_empty(&ctx
->busy_extents
)) {
403 ASSERT(mp
->m_flags
& XFS_MOUNT_DISCARD
);
405 xfs_discard_extents(mp
, &ctx
->busy_extents
);
406 xfs_extent_busy_clear(mp
, &ctx
->busy_extents
, false);
413 * Push the Committed Item List to the log. If @push_seq flag is zero, then it
414 * is a background flush and so we can chose to ignore it. Otherwise, if the
415 * current sequence is the same as @push_seq we need to do a flush. If
416 * @push_seq is less than the current sequence, then it has already been
417 * flushed and we don't need to do anything - the caller will wait for it to
418 * complete if necessary.
420 * @push_seq is a value rather than a flag because that allows us to do an
421 * unlocked check of the sequence number for a match. Hence we can allows log
422 * forces to run racily and not issue pushes for the same sequence twice. If we
423 * get a race between multiple pushes for the same sequence they will block on
424 * the first one and then abort, hence avoiding needless pushes.
430 struct xfs_cil
*cil
= log
->l_cilp
;
431 struct xfs_log_vec
*lv
;
432 struct xfs_cil_ctx
*ctx
;
433 struct xfs_cil_ctx
*new_ctx
;
434 struct xlog_in_core
*commit_iclog
;
435 struct xlog_ticket
*tic
;
438 struct xfs_trans_header thdr
;
439 struct xfs_log_iovec lhdr
;
440 struct xfs_log_vec lvhdr
= { NULL
};
441 xfs_lsn_t commit_lsn
;
447 new_ctx
= kmem_zalloc(sizeof(*new_ctx
), KM_SLEEP
|KM_NOFS
);
448 new_ctx
->ticket
= xlog_cil_ticket_alloc(log
);
450 down_write(&cil
->xc_ctx_lock
);
453 spin_lock(&cil
->xc_push_lock
);
454 push_seq
= cil
->xc_push_seq
;
455 ASSERT(push_seq
<= ctx
->sequence
);
458 * Check if we've anything to push. If there is nothing, then we don't
459 * move on to a new sequence number and so we have to be able to push
460 * this sequence again later.
462 if (list_empty(&cil
->xc_cil
)) {
463 cil
->xc_push_seq
= 0;
464 spin_unlock(&cil
->xc_push_lock
);
467 spin_unlock(&cil
->xc_push_lock
);
470 /* check for a previously pushed seqeunce */
471 if (push_seq
< cil
->xc_ctx
->sequence
)
475 * pull all the log vectors off the items in the CIL, and
476 * remove the items from the CIL. We don't need the CIL lock
477 * here because it's only needed on the transaction commit
478 * side which is currently locked out by the flush lock.
482 while (!list_empty(&cil
->xc_cil
)) {
483 struct xfs_log_item
*item
;
485 item
= list_first_entry(&cil
->xc_cil
,
486 struct xfs_log_item
, li_cil
);
487 list_del_init(&item
->li_cil
);
489 ctx
->lv_chain
= item
->li_lv
;
491 lv
->lv_next
= item
->li_lv
;
494 num_iovecs
+= lv
->lv_niovecs
;
498 * initialise the new context and attach it to the CIL. Then attach
499 * the current context to the CIL committing lsit so it can be found
500 * during log forces to extract the commit lsn of the sequence that
501 * needs to be forced.
503 INIT_LIST_HEAD(&new_ctx
->committing
);
504 INIT_LIST_HEAD(&new_ctx
->busy_extents
);
505 new_ctx
->sequence
= ctx
->sequence
+ 1;
507 cil
->xc_ctx
= new_ctx
;
510 * The switch is now done, so we can drop the context lock and move out
511 * of a shared context. We can't just go straight to the commit record,
512 * though - we need to synchronise with previous and future commits so
513 * that the commit records are correctly ordered in the log to ensure
514 * that we process items during log IO completion in the correct order.
516 * For example, if we get an EFI in one checkpoint and the EFD in the
517 * next (e.g. due to log forces), we do not want the checkpoint with
518 * the EFD to be committed before the checkpoint with the EFI. Hence
519 * we must strictly order the commit records of the checkpoints so
520 * that: a) the checkpoint callbacks are attached to the iclogs in the
521 * correct order; and b) the checkpoints are replayed in correct order
524 * Hence we need to add this context to the committing context list so
525 * that higher sequences will wait for us to write out a commit record
528 * xfs_log_force_lsn requires us to mirror the new sequence into the cil
529 * structure atomically with the addition of this sequence to the
530 * committing list. This also ensures that we can do unlocked checks
531 * against the current sequence in log forces without risking
532 * deferencing a freed context pointer.
534 spin_lock(&cil
->xc_push_lock
);
535 cil
->xc_current_sequence
= new_ctx
->sequence
;
536 list_add(&ctx
->committing
, &cil
->xc_committing
);
537 spin_unlock(&cil
->xc_push_lock
);
538 up_write(&cil
->xc_ctx_lock
);
541 * Build a checkpoint transaction header and write it to the log to
542 * begin the transaction. We need to account for the space used by the
543 * transaction header here as it is not accounted for in xlog_write().
545 * The LSN we need to pass to the log items on transaction commit is
546 * the LSN reported by the first log vector write. If we use the commit
547 * record lsn then we can move the tail beyond the grant write head.
550 thdr
.th_magic
= XFS_TRANS_HEADER_MAGIC
;
551 thdr
.th_type
= XFS_TRANS_CHECKPOINT
;
552 thdr
.th_tid
= tic
->t_tid
;
553 thdr
.th_num_items
= num_iovecs
;
555 lhdr
.i_len
= sizeof(xfs_trans_header_t
);
556 lhdr
.i_type
= XLOG_REG_TYPE_TRANSHDR
;
557 tic
->t_curr_res
-= lhdr
.i_len
+ sizeof(xlog_op_header_t
);
559 lvhdr
.lv_niovecs
= 1;
560 lvhdr
.lv_iovecp
= &lhdr
;
561 lvhdr
.lv_next
= ctx
->lv_chain
;
563 error
= xlog_write(log
, &lvhdr
, tic
, &ctx
->start_lsn
, NULL
, 0);
565 goto out_abort_free_ticket
;
568 * now that we've written the checkpoint into the log, strictly
569 * order the commit records so replay will get them in the right order.
572 spin_lock(&cil
->xc_push_lock
);
573 list_for_each_entry(new_ctx
, &cil
->xc_committing
, committing
) {
575 * Avoid getting stuck in this loop because we were woken by the
576 * shutdown, but then went back to sleep once already in the
579 if (XLOG_FORCED_SHUTDOWN(log
)) {
580 spin_unlock(&cil
->xc_push_lock
);
581 goto out_abort_free_ticket
;
585 * Higher sequences will wait for this one so skip them.
586 * Don't wait for our own sequence, either.
588 if (new_ctx
->sequence
>= ctx
->sequence
)
590 if (!new_ctx
->commit_lsn
) {
592 * It is still being pushed! Wait for the push to
593 * complete, then start again from the beginning.
595 xlog_wait(&cil
->xc_commit_wait
, &cil
->xc_push_lock
);
599 spin_unlock(&cil
->xc_push_lock
);
601 /* xfs_log_done always frees the ticket on error. */
602 commit_lsn
= xfs_log_done(log
->l_mp
, tic
, &commit_iclog
, 0);
603 if (commit_lsn
== -1)
606 /* attach all the transactions w/ busy extents to iclog */
607 ctx
->log_cb
.cb_func
= xlog_cil_committed
;
608 ctx
->log_cb
.cb_arg
= ctx
;
609 error
= xfs_log_notify(log
->l_mp
, commit_iclog
, &ctx
->log_cb
);
614 * now the checkpoint commit is complete and we've attached the
615 * callbacks to the iclog we can assign the commit LSN to the context
616 * and wake up anyone who is waiting for the commit to complete.
618 spin_lock(&cil
->xc_push_lock
);
619 ctx
->commit_lsn
= commit_lsn
;
620 wake_up_all(&cil
->xc_commit_wait
);
621 spin_unlock(&cil
->xc_push_lock
);
623 /* release the hounds! */
624 return xfs_log_release_iclog(log
->l_mp
, commit_iclog
);
627 up_write(&cil
->xc_ctx_lock
);
628 xfs_log_ticket_put(new_ctx
->ticket
);
632 out_abort_free_ticket
:
633 xfs_log_ticket_put(tic
);
635 xlog_cil_committed(ctx
, XFS_LI_ABORTED
);
636 return XFS_ERROR(EIO
);
641 struct work_struct
*work
)
643 struct xfs_cil
*cil
= container_of(work
, struct xfs_cil
,
645 xlog_cil_push(cil
->xc_log
);
649 * We need to push CIL every so often so we don't cache more than we can fit in
650 * the log. The limit really is that a checkpoint can't be more than half the
651 * log (the current checkpoint is not allowed to overwrite the previous
652 * checkpoint), but commit latency and memory usage limit this to a smaller
656 xlog_cil_push_background(
659 struct xfs_cil
*cil
= log
->l_cilp
;
662 * The cil won't be empty because we are called while holding the
663 * context lock so whatever we added to the CIL will still be there
665 ASSERT(!list_empty(&cil
->xc_cil
));
668 * don't do a background push if we haven't used up all the
669 * space available yet.
671 if (cil
->xc_ctx
->space_used
< XLOG_CIL_SPACE_LIMIT(log
))
674 spin_lock(&cil
->xc_push_lock
);
675 if (cil
->xc_push_seq
< cil
->xc_current_sequence
) {
676 cil
->xc_push_seq
= cil
->xc_current_sequence
;
677 queue_work(log
->l_mp
->m_cil_workqueue
, &cil
->xc_push_work
);
679 spin_unlock(&cil
->xc_push_lock
);
684 * xlog_cil_push_now() is used to trigger an immediate CIL push to the sequence
685 * number that is passed. When it returns, the work will be queued for
686 * @push_seq, but it won't be completed. The caller is expected to do any
687 * waiting for push_seq to complete if it is required.
694 struct xfs_cil
*cil
= log
->l_cilp
;
699 ASSERT(push_seq
&& push_seq
<= cil
->xc_current_sequence
);
701 /* start on any pending background push to minimise wait time on it */
702 flush_work(&cil
->xc_push_work
);
705 * If the CIL is empty or we've already pushed the sequence then
706 * there's no work we need to do.
708 spin_lock(&cil
->xc_push_lock
);
709 if (list_empty(&cil
->xc_cil
) || push_seq
<= cil
->xc_push_seq
) {
710 spin_unlock(&cil
->xc_push_lock
);
714 cil
->xc_push_seq
= push_seq
;
715 queue_work(log
->l_mp
->m_cil_workqueue
, &cil
->xc_push_work
);
716 spin_unlock(&cil
->xc_push_lock
);
723 struct xfs_cil
*cil
= log
->l_cilp
;
726 spin_lock(&cil
->xc_push_lock
);
727 if (list_empty(&cil
->xc_cil
))
729 spin_unlock(&cil
->xc_push_lock
);
734 * Commit a transaction with the given vector to the Committed Item List.
736 * To do this, we need to format the item, pin it in memory if required and
737 * account for the space used by the transaction. Once we have done that we
738 * need to release the unused reservation for the transaction, attach the
739 * transaction to the checkpoint context so we carry the busy extents through
740 * to checkpoint completion, and then unlock all the items in the transaction.
742 * Called with the context lock already held in read mode to lock out
743 * background commit, returns without it held once background commits are
748 struct xfs_mount
*mp
,
749 struct xfs_trans
*tp
,
750 xfs_lsn_t
*commit_lsn
,
753 struct xlog
*log
= mp
->m_log
;
754 struct xfs_cil
*cil
= log
->l_cilp
;
757 if (flags
& XFS_TRANS_RELEASE_LOG_RES
)
758 log_flags
= XFS_LOG_REL_PERM_RESERV
;
760 /* lock out background commit */
761 down_read(&cil
->xc_ctx_lock
);
763 xlog_cil_insert_items(log
, tp
);
765 /* check we didn't blow the reservation */
766 if (tp
->t_ticket
->t_curr_res
< 0)
767 xlog_print_tic_res(mp
, tp
->t_ticket
);
769 tp
->t_commit_lsn
= cil
->xc_ctx
->sequence
;
771 *commit_lsn
= tp
->t_commit_lsn
;
773 xfs_log_done(mp
, tp
->t_ticket
, NULL
, log_flags
);
774 xfs_trans_unreserve_and_mod_sb(tp
);
777 * Once all the items of the transaction have been copied to the CIL,
778 * the items can be unlocked and freed.
780 * This needs to be done before we drop the CIL context lock because we
781 * have to update state in the log items and unlock them before they go
782 * to disk. If we don't, then the CIL checkpoint can race with us and
783 * we can run checkpoint completion before we've updated and unlocked
784 * the log items. This affects (at least) processing of stale buffers,
787 xfs_trans_free_items(tp
, tp
->t_commit_lsn
, 0);
789 xlog_cil_push_background(log
);
791 up_read(&cil
->xc_ctx_lock
);
795 * Conditionally push the CIL based on the sequence passed in.
797 * We only need to push if we haven't already pushed the sequence
798 * number given. Hence the only time we will trigger a push here is
799 * if the push sequence is the same as the current context.
801 * We return the current commit lsn to allow the callers to determine if a
802 * iclog flush is necessary following this call.
809 struct xfs_cil
*cil
= log
->l_cilp
;
810 struct xfs_cil_ctx
*ctx
;
811 xfs_lsn_t commit_lsn
= NULLCOMMITLSN
;
813 ASSERT(sequence
<= cil
->xc_current_sequence
);
816 * check to see if we need to force out the current context.
817 * xlog_cil_push() handles racing pushes for the same sequence,
818 * so no need to deal with it here.
821 xlog_cil_push_now(log
, sequence
);
824 * See if we can find a previous sequence still committing.
825 * We need to wait for all previous sequence commits to complete
826 * before allowing the force of push_seq to go ahead. Hence block
827 * on commits for those as well.
829 spin_lock(&cil
->xc_push_lock
);
830 list_for_each_entry(ctx
, &cil
->xc_committing
, committing
) {
832 * Avoid getting stuck in this loop because we were woken by the
833 * shutdown, but then went back to sleep once already in the
836 if (XLOG_FORCED_SHUTDOWN(log
))
838 if (ctx
->sequence
> sequence
)
840 if (!ctx
->commit_lsn
) {
842 * It is still being pushed! Wait for the push to
843 * complete, then start again from the beginning.
845 xlog_wait(&cil
->xc_commit_wait
, &cil
->xc_push_lock
);
848 if (ctx
->sequence
!= sequence
)
851 commit_lsn
= ctx
->commit_lsn
;
855 * The call to xlog_cil_push_now() executes the push in the background.
856 * Hence by the time we have got here it our sequence may not have been
857 * pushed yet. This is true if the current sequence still matches the
858 * push sequence after the above wait loop and the CIL still contains
861 * When the push occurs, it will empty the CIL and atomically increment
862 * the currect sequence past the push sequence and move it into the
863 * committing list. Of course, if the CIL is clean at the time of the
864 * push, it won't have pushed the CIL at all, so in that case we should
865 * try the push for this sequence again from the start just in case.
867 if (sequence
== cil
->xc_current_sequence
&&
868 !list_empty(&cil
->xc_cil
)) {
869 spin_unlock(&cil
->xc_push_lock
);
873 spin_unlock(&cil
->xc_push_lock
);
877 * We detected a shutdown in progress. We need to trigger the log force
878 * to pass through it's iclog state machine error handling, even though
879 * we are already in a shutdown state. Hence we can't return
880 * NULLCOMMITLSN here as that has special meaning to log forces (i.e.
881 * LSN is already stable), so we return a zero LSN instead.
884 spin_unlock(&cil
->xc_push_lock
);
889 * Check if the current log item was first committed in this sequence.
890 * We can't rely on just the log item being in the CIL, we have to check
891 * the recorded commit sequence number.
893 * Note: for this to be used in a non-racy manner, it has to be called with
894 * CIL flushing locked out. As a result, it should only be used during the
895 * transaction commit process when deciding what to format into the item.
898 xfs_log_item_in_current_chkpt(
899 struct xfs_log_item
*lip
)
901 struct xfs_cil_ctx
*ctx
;
903 if (list_empty(&lip
->li_cil
))
906 ctx
= lip
->li_mountp
->m_log
->l_cilp
->xc_ctx
;
909 * li_seq is written on the first commit of a log item to record the
910 * first checkpoint it is written to. Hence if it is different to the
911 * current sequence, we're in a new checkpoint.
913 if (XFS_LSN_CMP(lip
->li_seq
, ctx
->sequence
) != 0)
919 * Perform initial CIL structure initialisation.
926 struct xfs_cil_ctx
*ctx
;
928 cil
= kmem_zalloc(sizeof(*cil
), KM_SLEEP
|KM_MAYFAIL
);
932 ctx
= kmem_zalloc(sizeof(*ctx
), KM_SLEEP
|KM_MAYFAIL
);
938 INIT_WORK(&cil
->xc_push_work
, xlog_cil_push_work
);
939 INIT_LIST_HEAD(&cil
->xc_cil
);
940 INIT_LIST_HEAD(&cil
->xc_committing
);
941 spin_lock_init(&cil
->xc_cil_lock
);
942 spin_lock_init(&cil
->xc_push_lock
);
943 init_rwsem(&cil
->xc_ctx_lock
);
944 init_waitqueue_head(&cil
->xc_commit_wait
);
946 INIT_LIST_HEAD(&ctx
->committing
);
947 INIT_LIST_HEAD(&ctx
->busy_extents
);
951 cil
->xc_current_sequence
= ctx
->sequence
;
962 if (log
->l_cilp
->xc_ctx
) {
963 if (log
->l_cilp
->xc_ctx
->ticket
)
964 xfs_log_ticket_put(log
->l_cilp
->xc_ctx
->ticket
);
965 kmem_free(log
->l_cilp
->xc_ctx
);
968 ASSERT(list_empty(&log
->l_cilp
->xc_cil
));
969 kmem_free(log
->l_cilp
);