35 	struct xlog	*log)  in xlog_cil_ticket_alloc()  argument
39 	tic = xlog_ticket_alloc(log, 0, 1, 0);  in xlog_cil_ticket_alloc()
53 	struct xlog	*log = cil->xc_log;  in xlog_cil_set_iclog_hdr_count()  local
56 		   (XLOG_CIL_BLOCKING_SPACE_LIMIT(log) /  in xlog_cil_set_iclog_hdr_count()
57 			(log->l_iclog_size - log->l_iclog_hsize)));  in xlog_cil_set_iclog_hdr_count()
61  * Check if the current log item was first committed in this sequence.
62  * We can't rely on just the log item being in the CIL, we have to check
78 	 * li_seq is written on the first commit of a log item to record the  in xlog_item_in_current_chkpt()
200  * After the first stage of log recovery is done, we know where the head and
201  * tail of the log are. We need this log initialisation done before we can
204  * Here we allocate a log ticket to track space usage during a CIL push.  This
205  * ticket is passed to xlog_write() directly so that we don't slowly leak log
206  * space by failing to account for space used by log headers and additional
211 	struct xlog	*log)  in xlog_cil_init_post_recovery()  argument
213 	log->l_cilp->xc_ctx->ticket = xlog_cil_ticket_alloc(log);  in xlog_cil_init_post_recovery()
214 	log->l_cilp->xc_ctx->sequence = 1;  in xlog_cil_init_post_recovery()
215 	xlog_cil_set_iclog_hdr_count(log->l_cilp);  in xlog_cil_init_post_recovery()
228  * Allocate or pin log vector buffers for CIL insertion.
231  * modified items into the log during a push. The biggest problem with this is
243  * xc_ctx_lock, but because the log vector buffers are disposable, that opens
244  * up a TOCTOU race condition w.r.t. the CIL committing and removing the log
246  * log vector buffer within the xc_ctx_lock.
248  * Because the log vector buffer needs to be unchanged during the CIL push
251  * into the log. This means skipping preallocation of buffer space is
256  * log item is committed for the second time, and then to only use this buffer
257  * if necessary. The buffer can remain attached to the log item until such time
264  * This function builds a vector for the changes in each log item in the
265  * transaction. It then works out the length of the buffer needed for each log
266  * item, allocates them and attaches the vector to the log item in preparation
275 	struct xlog		*log,  in xlog_cil_alloc_shadow_bufs()  argument
339 			 * the buffer, only the log vector header and the iovec  in xlog_cil_alloc_shadow_bufs()
375  * Prepare the log item for insertion into the CIL. Calculate the difference in
376  * log space it will consume, and if it is a new item pin it as well.
380 	struct xlog		*log,  in xfs_cil_prepare_item()  argument
407 	/* attach new log vector to log item */  in xfs_cil_prepare_item()
412 	 * CIL, store the sequence number on the log item so we can  in xfs_cil_prepare_item()
417 		lv->lv_item->li_seq = log->l_cilp->xc_ctx->sequence;  in xfs_cil_prepare_item()
421  * Format log item into a flat buffers
424  * changes on the log item. This enables us to relog the item in memory and
428  * This function takes the prepared log vectors attached to each log item, and
429  * formats the changes into the log vector buffer. The buffer it uses is
434  * done lazily either by th enext modification or the freeing of the log item.
450 	struct xlog		*log,  in xlog_cil_insert_format_items()  argument
456 	/* Bail out if we didn't find a log item.  */  in xlog_cil_insert_format_items()
474 		 * the shadow lv on the log item.  in xlog_cil_insert_format_items()
521 		xfs_cil_prepare_item(log, lv, old_lv, diff_len);  in xlog_cil_insert_format_items()
532 	struct xlog	*log,  in xlog_cil_over_hard_limit()  argument
535 	if (waitqueue_active(&log->l_cilp->xc_push_wait))  in xlog_cil_over_hard_limit()
537 	if (space_used >= XLOG_CIL_BLOCKING_SPACE_LIMIT(log))  in xlog_cil_over_hard_limit()
543  * Insert the log items into the CIL and calculate the difference in space
545  * if the change requires additional log metadata. If it does, take that space
551 	struct xlog		*log,  in xlog_cil_insert_items()  argument
555 	struct xfs_cil		*cil = log->l_cilp;  in xlog_cil_insert_items()
571 	xlog_cil_insert_format_items(log, tp, &len);  in xlog_cil_insert_items()
624 	    xlog_cil_over_hard_limit(log, space_used)) {  in xlog_cil_insert_items()
625 		split_res = log->l_iclog_hsize +  in xlog_cil_insert_items()
642 			(XLOG_CIL_SPACE_LIMIT(log) / num_online_cpus())) {  in xlog_cil_insert_items()
651 		if (space_used >= XLOG_CIL_SPACE_LIMIT(log))  in xlog_cil_insert_items()
681 	 * the log items. Shutdown is imminent...  in xlog_cil_insert_items()
685 		xfs_warn(log->l_mp, "Transaction log reservation overrun:");  in xlog_cil_insert_items()
686 		xfs_warn(log->l_mp,  in xlog_cil_insert_items()
687 			 "  log items: %d bytes (iov hdrs: %d bytes)",  in xlog_cil_insert_items()
689 		xfs_warn(log->l_mp, "  split region headers: %d bytes",  in xlog_cil_insert_items()
691 		xfs_warn(log->l_mp, "  ctx ticket: %d bytes", ctx_res);  in xlog_cil_insert_items()
693 		xlog_force_shutdown(log, SHUTDOWN_LOG_IO_ERROR);  in xlog_cil_insert_items()
711  * Mark all items committed and clear busy extents. We free the log vector
712  * chains in a separate pass so that we unpin the log items as quickly as
724 	 * Wake any commit waiters before aborting the log items so we don't  in xlog_cil_committed()
725 	 * block async log pushers on callbacks. Async log pushers explicitly do  in xlog_cil_committed()
726 	 * not wait on log force completion because they may be holding locks  in xlog_cil_committed()
790 		 * The LSN we need to pass to the log items on transaction  in xlog_cil_set_ctx_write_state()
791 		 * commit is the LSN reported by the first log vector write, not  in xlog_cil_set_ctx_write_state()
801 		 * Make sure the metadata we are about to overwrite in the log  in xlog_cil_set_ctx_write_state()
833 	 * location in the log.  in xlog_cil_set_ctx_write_state()
844  * Ensure that the order of log writes follows checkpoint sequence order. This
845  * relies on the context LSN being zero until the log write has guaranteed the
846  * LSN that the log write will start at via xlog_state_get_iclog_space().
902  * Write out the log vector change now attached to the CIL context. This will
904  * sequence order so that log recovery will always use in-order start LSNs when
912 	struct xlog		*log = ctx->cil->xc_log;  in xlog_cil_write_chain()  local
918 	return xlog_write(log, ctx, &ctx->lv_chain, ctx->ticket, chain_len);  in xlog_cil_write_chain()
923  * running log write. These commit records are strictly ordered in ascending CIL
924  * sequence order so that log recovery will always replay the checkpoints in the
931 	struct xlog		*log = ctx->cil->xc_log;  in xlog_cil_write_commit_record()  local
950 	if (xlog_is_shutdown(log))  in xlog_cil_write_commit_record()
959 	error = xlog_write(log, ctx, &lv_chain, ctx->ticket, reg.i_len);  in xlog_cil_write_commit_record()
961 		xlog_force_shutdown(log, SHUTDOWN_LOG_IO_ERROR);  in xlog_cil_write_commit_record()
977  * log opheaders that indicate the start of a log transaction and wrap the
978  * transaction header. We keep the start record in it's own log vector rather
995 	/* Log start record */  in xlog_cil_build_trans_hdr()
1000 	/* log iovec region pointer */  in xlog_cil_build_trans_hdr()
1005 	/* log opheader */  in xlog_cil_build_trans_hdr()
1016 	/* log iovec region pointer */  in xlog_cil_build_trans_hdr()
1032  * the list. This is important for operations like reflink where we log 4 order
1050  * Pull all the log vectors off the items in the CIL, and remove the items from
1054  * If a log item is marked with a whiteout, we do not need to write it to the
1081 		/* we don't write ordered log vectors */  in xlog_cil_build_lv_chain()
1107  * Push the Committed Item List to the log.
1115  * Hence we can allow log forces to run racily and not issue pushes for the
1127 	struct xlog		*log = cil->xc_log;  in xlog_cil_push_work()  local
1140 	new_ctx->ticket = xlog_cil_ticket_alloc(log);  in xlog_cil_push_work()
1214 	 * that the commit records are correctly ordered in the log to ensure  in xlog_cil_push_work()
1215 	 * that we process items during log IO completion in the correct order.  in xlog_cil_push_work()
1218 	 * next (e.g. due to log forces), we do not want the checkpoint with  in xlog_cil_push_work()
1223 	 * in log recovery.  in xlog_cil_push_work()
1232 	 * against the current sequence in log forces without risking  in xlog_cil_push_work()
1241 	 * Sort the log vector chain before we add the transaction headers.  in xlog_cil_push_work()
1248 	 * Build a checkpoint transaction header and write it to the log to  in xlog_cil_push_work()
1260 	 * xlog_cil_write_chain() as it should not be passed to log IO  in xlog_cil_push_work()
1293 	spin_lock(&log->l_icloglock);  in xlog_cil_push_work()
1305 			spin_lock(&log->l_icloglock);  in xlog_cil_push_work()
1328 		xlog_state_switch_iclogs(log, ctx->commit_iclog, 0);  in xlog_cil_push_work()
1330 	xlog_state_release_iclog(log, ctx->commit_iclog, ticket);  in xlog_cil_push_work()
1334 	spin_unlock(&log->l_icloglock);  in xlog_cil_push_work()
1336 	xfs_log_ticket_ungrant(log, ticket);  in xlog_cil_push_work()
1346 	ASSERT(xlog_is_shutdown(log));  in xlog_cil_push_work()
1349 		xfs_log_ticket_ungrant(log, ctx->ticket);  in xlog_cil_push_work()
1353 	spin_lock(&log->l_icloglock);  in xlog_cil_push_work()
1355 	xlog_state_release_iclog(log, ctx->commit_iclog, ticket);  in xlog_cil_push_work()
1357 	spin_unlock(&log->l_icloglock);  in xlog_cil_push_work()
1358 	xfs_log_ticket_ungrant(log, ticket);  in xlog_cil_push_work()
1363  * the log. The limit really is that a checkpoint can't be more than half the
1364  * log (the current checkpoint is not allowed to overwrite the previous
1370 	struct xlog	*log) __releases(cil->xc_ctx_lock)  in xlog_cil_push_background()  argument
1372 	struct xfs_cil	*cil = log->l_cilp;  in xlog_cil_push_background()
1390 	if (space_used < XLOG_CIL_SPACE_LIMIT(log) ||  in xlog_cil_push_background()
1392 	     space_used < XLOG_CIL_BLOCKING_SPACE_LIMIT(log) &&  in xlog_cil_push_background()
1422 	if (xlog_cil_over_hard_limit(log, space_used)) {  in xlog_cil_push_background()
1423 		trace_xfs_log_cil_wait(log, cil->xc_ctx->ticket);  in xlog_cil_push_background()
1424 		ASSERT(space_used < log->l_logsize);  in xlog_cil_push_background()
1446  * ACTIVE iclog. This then requires another full log force to push to disk,
1453 	struct xlog	*log,  in xlog_cil_push_now()  argument
1457 	struct xfs_cil	*cil = log->l_cilp;  in xlog_cil_push_now()
1496 	struct xlog	*log)  in xlog_cil_empty()  argument
1498 	struct xfs_cil	*cil = log->l_cilp;  in xlog_cil_empty()
1560 	struct xlog		*log,  in xlog_cil_commit()  argument
1565 	struct xfs_cil		*cil = log->l_cilp;  in xlog_cil_commit()
1574 	xlog_cil_alloc_shadow_bufs(log, tp);  in xlog_cil_commit()
1582 	xlog_cil_insert_items(log, tp, released_space);  in xlog_cil_commit()
1584 	if (regrant && !xlog_is_shutdown(log))  in xlog_cil_commit()
1585 		xfs_log_ticket_regrant(log, tp->t_ticket);  in xlog_cil_commit()
1587 		xfs_log_ticket_ungrant(log, tp->t_ticket);  in xlog_cil_commit()
1596 	 * have to update state in the log items and unlock them before they go  in xlog_cil_commit()
1599 	 * the log items. This affects (at least) processing of stale buffers,  in xlog_cil_commit()
1612 	xlog_cil_push_background(log);  in xlog_cil_commit()
1618  * but otherwise is no different to a push done from a log force.
1622 	struct xlog	*log)  in xlog_cil_flush()  argument
1624 	xfs_csn_t	seq = log->l_cilp->xc_current_sequence;  in xlog_cil_flush()
1626 	trace_xfs_log_force(log->l_mp, seq, _RET_IP_);  in xlog_cil_flush()
1627 	xlog_cil_push_now(log, seq, true);  in xlog_cil_flush()
1633 	if (test_bit(XLOG_CIL_EMPTY, &log->l_cilp->xc_flags))  in xlog_cil_flush()
1634 		xfs_log_force(log->l_mp, 0);  in xlog_cil_flush()
1649 	struct xlog	*log,  in xlog_cil_force_seq()  argument
1652 	struct xfs_cil		*cil = log->l_cilp;  in xlog_cil_force_seq()
1660 	trace_xfs_log_force(log->l_mp, sequence, _RET_IP_);  in xlog_cil_force_seq()
1668 	xlog_cil_push_now(log, sequence, false);  in xlog_cil_force_seq()
1683 		if (xlog_is_shutdown(log))  in xlog_cil_force_seq()
1692 			XFS_STATS_INC(log->l_mp, xs_log_force_sleep);  in xlog_cil_force_seq()
1727 	 * We detected a shutdown in progress. We need to trigger the log force  in xlog_cil_force_seq()
1730 	 * NULLCOMMITLSN here as that has special meaning to log forces (i.e.  in xlog_cil_force_seq()
1743 	struct xlog		*log)  in xlog_cil_init()  argument
1755 	 * concurrency the log spinlocks will be exposed to.  in xlog_cil_init()
1759 			4, log->l_mp->m_super->s_id);  in xlog_cil_init()
1763 	cil->xc_log = log;  in xlog_cil_init()
1780 	log->l_cilp = cil;  in xlog_cil_init()
1795 	struct xlog	*log)  in xlog_cil_destroy()  argument
1797 	struct xfs_cil	*cil = log->l_cilp;  in xlog_cil_destroy()