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()
194  * After the first stage of log recovery is done, we know where the head and
195  * tail of the log are. We need this log initialisation done before we can
198  * Here we allocate a log ticket to track space usage during a CIL push.  This
199  * ticket is passed to xlog_write() directly so that we don't slowly leak log
200  * space by failing to account for space used by log headers and additional
205 	struct xlog	*log)  in xlog_cil_init_post_recovery()  argument
207 	log->l_cilp->xc_ctx->ticket = xlog_cil_ticket_alloc(log);  in xlog_cil_init_post_recovery()
208 	log->l_cilp->xc_ctx->sequence = 1;  in xlog_cil_init_post_recovery()
209 	xlog_cil_set_iclog_hdr_count(log->l_cilp);  in xlog_cil_init_post_recovery()
222  * Allocate or pin log vector buffers for CIL insertion.
225  * modified items into the log during a push. The biggest problem with this is
237  * xc_ctx_lock, but because the log vector buffers are disposable, that opens
238  * up a TOCTOU race condition w.r.t. the CIL committing and removing the log
240  * log vector buffer within the xc_ctx_lock.
242  * Because the log vector buffer needs to be unchanged during the CIL push
245  * into the log. This means skipping preallocation of buffer space is
250  * log item is committed for the second time, and then to only use this buffer
251  * if necessary. The buffer can remain attached to the log item until such time
258  * This function builds a vector for the changes in each log item in the
259  * transaction. It then works out the length of the buffer needed for each log
260  * item, allocates them and attaches the vector to the log item in preparation
269 	struct xlog		*log,  in xlog_cil_alloc_shadow_bufs()  argument
333 			 * the buffer, only the log vector header and the iovec  in xlog_cil_alloc_shadow_bufs()
369  * Prepare the log item for insertion into the CIL. Calculate the difference in
370  * log space it will consume, and if it is a new item pin it as well.
374 	struct xlog		*log,  in xfs_cil_prepare_item()  argument
401 	/* attach new log vector to log item */  in xfs_cil_prepare_item()
406 	 * CIL, store the sequence number on the log item so we can  in xfs_cil_prepare_item()
411 		lv->lv_item->li_seq = log->l_cilp->xc_ctx->sequence;  in xfs_cil_prepare_item()
415  * Format log item into a flat buffers
418  * changes on the log item. This enables us to relog the item in memory and
422  * This function takes the prepared log vectors attached to each log item, and
423  * formats the changes into the log vector buffer. The buffer it uses is
428  * done lazily either by th enext modification or the freeing of the log item.
444 	struct xlog		*log,  in xlog_cil_insert_format_items()  argument
450 	/* Bail out if we didn't find a log item.  */  in xlog_cil_insert_format_items()
468 		 * the shadow lv on the log item.  in xlog_cil_insert_format_items()
515 		xfs_cil_prepare_item(log, lv, old_lv, diff_len);  in xlog_cil_insert_format_items()
526 	struct xlog	*log,  in xlog_cil_over_hard_limit()  argument
529 	if (waitqueue_active(&log->l_cilp->xc_push_wait))  in xlog_cil_over_hard_limit()
531 	if (space_used >= XLOG_CIL_BLOCKING_SPACE_LIMIT(log))  in xlog_cil_over_hard_limit()
537  * Insert the log items into the CIL and calculate the difference in space
539  * if the change requires additional log metadata. If it does, take that space
545 	struct xlog		*log,  in xlog_cil_insert_items()  argument
549 	struct xfs_cil		*cil = log->l_cilp;  in xlog_cil_insert_items()
565 	xlog_cil_insert_format_items(log, tp, &len);  in xlog_cil_insert_items()
618 	    xlog_cil_over_hard_limit(log, space_used)) {  in xlog_cil_insert_items()
619 		split_res = log->l_iclog_hsize +  in xlog_cil_insert_items()
636 			(XLOG_CIL_SPACE_LIMIT(log) / num_online_cpus())) {  in xlog_cil_insert_items()
645 		if (space_used >= XLOG_CIL_SPACE_LIMIT(log))  in xlog_cil_insert_items()
675 	 * the log items. Shutdown is imminent...  in xlog_cil_insert_items()
679 		xfs_warn(log->l_mp, "Transaction log reservation overrun:");  in xlog_cil_insert_items()
680 		xfs_warn(log->l_mp,  in xlog_cil_insert_items()
681 			 "  log items: %d bytes (iov hdrs: %d bytes)",  in xlog_cil_insert_items()
683 		xfs_warn(log->l_mp, "  split region headers: %d bytes",  in xlog_cil_insert_items()
685 		xfs_warn(log->l_mp, "  ctx ticket: %d bytes", ctx_res);  in xlog_cil_insert_items()
687 		xlog_force_shutdown(log, SHUTDOWN_LOG_IO_ERROR);  in xlog_cil_insert_items()
714  * Take the checkpoint's log vector chain of items and insert the attached log
718  * The AIL tracks log items via the start record LSN of the checkpoint,
727  * The tail of the log cannot be moved to the LSN of commit N when all
729  * start record for N+1 is no longer in the active portion of the log
732  * Hence when all the log items in checkpoint N are written back, the
733  * tail of the log most now only move as far forwards as the start LSN
736  * If we are called with the aborted flag set, it is because a log write during
769 	 * items so that log space checks during insertion will reflect the  in xlog_cil_ail_insert()
785 	 * log before we remove that space from the grant heads. This prevents a  in xlog_cil_ail_insert()
788 	 * the AIL head update accounts in the log tail space.  in xlog_cil_ail_insert()
793 	/* unpin all the log items */  in xlog_cil_ail_insert()
879  * Mark all items committed and clear busy extents. We free the log vector
880  * chains in a separate pass so that we unpin the log items as quickly as
892 	 * Wake any commit waiters before aborting the log items so we don't  in xlog_cil_committed()
893 	 * block async log pushers on callbacks. Async log pushers explicitly do  in xlog_cil_committed()
894 	 * not wait on log force completion because they may be holding locks  in xlog_cil_committed()
956 		 * The LSN we need to pass to the log items on transaction  in xlog_cil_set_ctx_write_state()
957 		 * commit is the LSN reported by the first log vector write, not  in xlog_cil_set_ctx_write_state()
967 		 * Make sure the metadata we are about to overwrite in the log  in xlog_cil_set_ctx_write_state()
999 	 * location in the log.  in xlog_cil_set_ctx_write_state()
1010  * Ensure that the order of log writes follows checkpoint sequence order. This
1011  * relies on the context LSN being zero until the log write has guaranteed the
1012  * LSN that the log write will start at via xlog_state_get_iclog_space().
1068  * Write out the log vector change now attached to the CIL context. This will
1070  * sequence order so that log recovery will always use in-order start LSNs when
1078 	struct xlog		*log = ctx->cil->xc_log;  in xlog_cil_write_chain()  local
1084 	return xlog_write(log, ctx, &ctx->lv_chain, ctx->ticket, chain_len);  in xlog_cil_write_chain()
1089  * running log write. These commit records are strictly ordered in ascending CIL
1090  * sequence order so that log recovery will always replay the checkpoints in the
1097 	struct xlog		*log = ctx->cil->xc_log;  in xlog_cil_write_commit_record()  local
1116 	if (xlog_is_shutdown(log))  in xlog_cil_write_commit_record()
1125 	error = xlog_write(log, ctx, &lv_chain, ctx->ticket, reg.i_len);  in xlog_cil_write_commit_record()
1127 		xlog_force_shutdown(log, SHUTDOWN_LOG_IO_ERROR);  in xlog_cil_write_commit_record()
1143  * log opheaders that indicate the start of a log transaction and wrap the
1144  * transaction header. We keep the start record in it's own log vector rather
1161 	/* Log start record */  in xlog_cil_build_trans_hdr()
1166 	/* log iovec region pointer */  in xlog_cil_build_trans_hdr()
1171 	/* log opheader */  in xlog_cil_build_trans_hdr()
1182 	/* log iovec region pointer */  in xlog_cil_build_trans_hdr()
1198  * the list. This is important for operations like reflink where we log 4 order
1216  * Pull all the log vectors off the items in the CIL, and remove the items from
1220  * If a log item is marked with a whiteout, we do not need to write it to the
1247 		/* we don't write ordered log vectors */  in xlog_cil_build_lv_chain()
1273  * Push the Committed Item List to the log.
1281  * Hence we can allow log forces to run racily and not issue pushes for the
1300 	struct xlog		*log = cil->xc_log;  in xlog_cil_push_work()  local
1313 	new_ctx->ticket = xlog_cil_ticket_alloc(log);  in xlog_cil_push_work()
1387 	 * that the commit records are correctly ordered in the log to ensure  in xlog_cil_push_work()
1388 	 * that we process items during log IO completion in the correct order.  in xlog_cil_push_work()
1391 	 * next (e.g. due to log forces), we do not want the checkpoint with  in xlog_cil_push_work()
1396 	 * in log recovery.  in xlog_cil_push_work()
1405 	 * against the current sequence in log forces without risking  in xlog_cil_push_work()
1414 	 * Sort the log vector chain before we add the transaction headers.  in xlog_cil_push_work()
1421 	 * Build a checkpoint transaction header and write it to the log to  in xlog_cil_push_work()
1433 	 * xlog_cil_write_chain() as it should not be passed to log IO  in xlog_cil_push_work()
1466 	spin_lock(&log->l_icloglock);  in xlog_cil_push_work()
1478 			spin_lock(&log->l_icloglock);  in xlog_cil_push_work()
1501 		xlog_state_switch_iclogs(log, ctx->commit_iclog, 0);  in xlog_cil_push_work()
1503 	xlog_state_release_iclog(log, ctx->commit_iclog, ticket);  in xlog_cil_push_work()
1507 	spin_unlock(&log->l_icloglock);  in xlog_cil_push_work()
1509 	xfs_log_ticket_ungrant(log, ticket);  in xlog_cil_push_work()
1521 	ASSERT(xlog_is_shutdown(log));  in xlog_cil_push_work()
1524 		xfs_log_ticket_ungrant(log, ctx->ticket);  in xlog_cil_push_work()
1529 	spin_lock(&log->l_icloglock);  in xlog_cil_push_work()
1531 	xlog_state_release_iclog(log, ctx->commit_iclog, ticket);  in xlog_cil_push_work()
1533 	spin_unlock(&log->l_icloglock);  in xlog_cil_push_work()
1534 	xfs_log_ticket_ungrant(log, ticket);  in xlog_cil_push_work()
1540  * the log. The limit really is that a checkpoint can't be more than half the
1541  * log (the current checkpoint is not allowed to overwrite the previous
1547 	struct xlog	*log)  in xlog_cil_push_background()  argument
1549 	struct xfs_cil	*cil = log->l_cilp;  in xlog_cil_push_background()
1567 	if (space_used < XLOG_CIL_SPACE_LIMIT(log) ||  in xlog_cil_push_background()
1569 	     space_used < XLOG_CIL_BLOCKING_SPACE_LIMIT(log) &&  in xlog_cil_push_background()
1599 	if (xlog_cil_over_hard_limit(log, space_used)) {  in xlog_cil_push_background()
1600 		trace_xfs_log_cil_wait(log, cil->xc_ctx->ticket);  in xlog_cil_push_background()
1601 		ASSERT(space_used < log->l_logsize);  in xlog_cil_push_background()
1623  * ACTIVE iclog. This then requires another full log force to push to disk,
1630 	struct xlog	*log,  in xlog_cil_push_now()  argument
1634 	struct xfs_cil	*cil = log->l_cilp;  in xlog_cil_push_now()
1673 	struct xlog	*log)  in xlog_cil_empty()  argument
1675 	struct xfs_cil	*cil = log->l_cilp;  in xlog_cil_empty()
1737 	struct xlog		*log,  in xlog_cil_commit()  argument
1742 	struct xfs_cil		*cil = log->l_cilp;  in xlog_cil_commit()
1751 	xlog_cil_alloc_shadow_bufs(log, tp);  in xlog_cil_commit()
1759 	xlog_cil_insert_items(log, tp, released_space);  in xlog_cil_commit()
1761 	if (regrant && !xlog_is_shutdown(log))  in xlog_cil_commit()
1762 		xfs_log_ticket_regrant(log, tp->t_ticket);  in xlog_cil_commit()
1764 		xfs_log_ticket_ungrant(log, tp->t_ticket);  in xlog_cil_commit()
1773 	 * have to update state in the log items and unlock them before they go  in xlog_cil_commit()
1776 	 * the log items. This affects (at least) processing of stale buffers,  in xlog_cil_commit()
1789 	xlog_cil_push_background(log);  in xlog_cil_commit()
1795  * but otherwise is no different to a push done from a log force.
1799 	struct xlog	*log)  in xlog_cil_flush()  argument
1801 	xfs_csn_t	seq = log->l_cilp->xc_current_sequence;  in xlog_cil_flush()
1803 	trace_xfs_log_force(log->l_mp, seq, _RET_IP_);  in xlog_cil_flush()
1804 	xlog_cil_push_now(log, seq, true);  in xlog_cil_flush()
1810 	if (test_bit(XLOG_CIL_EMPTY, &log->l_cilp->xc_flags))  in xlog_cil_flush()
1811 		xfs_log_force(log->l_mp, 0);  in xlog_cil_flush()
1826 	struct xlog	*log,  in xlog_cil_force_seq()  argument
1829 	struct xfs_cil		*cil = log->l_cilp;  in xlog_cil_force_seq()
1837 	trace_xfs_log_force(log->l_mp, sequence, _RET_IP_);  in xlog_cil_force_seq()
1845 	xlog_cil_push_now(log, sequence, false);  in xlog_cil_force_seq()
1860 		if (xlog_is_shutdown(log))  in xlog_cil_force_seq()
1869 			XFS_STATS_INC(log->l_mp, xs_log_force_sleep);  in xlog_cil_force_seq()
1904 	 * We detected a shutdown in progress. We need to trigger the log force  in xlog_cil_force_seq()
1907 	 * NULLCOMMITLSN here as that has special meaning to log forces (i.e.  in xlog_cil_force_seq()
1920 	struct xlog		*log)  in xlog_cil_init()  argument
1932 	 * concurrency the log spinlocks will be exposed to.  in xlog_cil_init()
1936 			4, log->l_mp->m_super->s_id);  in xlog_cil_init()
1940 	cil->xc_log = log;  in xlog_cil_init()
1957 	log->l_cilp = cil;  in xlog_cil_init()
1972 	struct xlog	*log)  in xlog_cil_destroy()  argument
1974 	struct xfs_cil	*cil = log->l_cilp;  in xlog_cil_destroy()