36 	struct xlog	*log)  in xlog_cil_ticket_alloc()  argument
40 	tic = xlog_ticket_alloc(log, 0, 1, 0);  in xlog_cil_ticket_alloc()
54 	struct xlog	*log = cil->xc_log;  in xlog_cil_set_iclog_hdr_count()  local
57 		   (XLOG_CIL_BLOCKING_SPACE_LIMIT(log) /  in xlog_cil_set_iclog_hdr_count()
58 			(log->l_iclog_size - log->l_iclog_hsize)));  in xlog_cil_set_iclog_hdr_count()
62  * Check if the current log item was first committed in this sequence.
63  * We can't rely on just the log item being in the CIL, we have to check
79 	 * li_seq is written on the first commit of a log item to record the  in xlog_item_in_current_chkpt()
195  * After the first stage of log recovery is done, we know where the head and
196  * tail of the log are. We need this log initialisation done before we can
199  * Here we allocate a log ticket to track space usage during a CIL push.  This
200  * ticket is passed to xlog_write() directly so that we don't slowly leak log
201  * space by failing to account for space used by log headers and additional
206 	struct xlog	*log)  in xlog_cil_init_post_recovery()  argument
208 	log->l_cilp->xc_ctx->ticket = xlog_cil_ticket_alloc(log);  in xlog_cil_init_post_recovery()
209 	log->l_cilp->xc_ctx->sequence = 1;  in xlog_cil_init_post_recovery()
210 	xlog_cil_set_iclog_hdr_count(log->l_cilp);  in xlog_cil_init_post_recovery()
223  * Allocate or pin log vector buffers for CIL insertion.
226  * modified items into the log during a push. The biggest problem with this is
238  * xc_ctx_lock, but because the log vector buffers are disposable, that opens
239  * up a TOCTOU race condition w.r.t. the CIL committing and removing the log
241  * log vector buffer within the xc_ctx_lock.
243  * Because the log vector buffer needs to be unchanged during the CIL push
246  * into the log. This means skipping preallocation of buffer space is
251  * log item is committed for the second time, and then to only use this buffer
252  * if necessary. The buffer can remain attached to the log item until such time
259  * This function builds a vector for the changes in each log item in the
260  * transaction. It then works out the length of the buffer needed for each log
261  * item, allocates them and attaches the vector to the log item in preparation
270 	struct xlog		*log,  in xlog_cil_alloc_shadow_bufs()  argument
334 			 * the buffer, only the log vector header and the iovec  in xlog_cil_alloc_shadow_bufs()
370  * Prepare the log item for insertion into the CIL. Calculate the difference in
371  * log space it will consume, and if it is a new item pin it as well.
375 	struct xlog		*log,  in xfs_cil_prepare_item()  argument
402 	/* attach new log vector to log item */  in xfs_cil_prepare_item()
407 	 * CIL, store the sequence number on the log item so we can  in xfs_cil_prepare_item()
412 		lv->lv_item->li_seq = log->l_cilp->xc_ctx->sequence;  in xfs_cil_prepare_item()
416  * Format log item into a flat buffers
419  * changes on the log item. This enables us to relog the item in memory and
423  * This function takes the prepared log vectors attached to each log item, and
424  * formats the changes into the log vector buffer. The buffer it uses is
429  * done lazily either by th enext modification or the freeing of the log item.
445 	struct xlog		*log,  in xlog_cil_insert_format_items()  argument
451 	/* Bail out if we didn't find a log item.  */  in xlog_cil_insert_format_items()
469 		 * the shadow lv on the log item.  in xlog_cil_insert_format_items()
516 		xfs_cil_prepare_item(log, lv, old_lv, diff_len);  in xlog_cil_insert_format_items()
527 	struct xlog	*log,  in xlog_cil_over_hard_limit()  argument
530 	if (waitqueue_active(&log->l_cilp->xc_push_wait))  in xlog_cil_over_hard_limit()
532 	if (space_used >= XLOG_CIL_BLOCKING_SPACE_LIMIT(log))  in xlog_cil_over_hard_limit()
538  * Insert the log items into the CIL and calculate the difference in space
540  * if the change requires additional log metadata. If it does, take that space
546 	struct xlog		*log,  in xlog_cil_insert_items()  argument
550 	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()
613 	    xlog_cil_over_hard_limit(log, space_used)) {  in xlog_cil_insert_items()
614 		split_res = log->l_iclog_hsize +  in xlog_cil_insert_items()
631 			(XLOG_CIL_SPACE_LIMIT(log) / num_online_cpus())) {  in xlog_cil_insert_items()
640 		if (space_used >= XLOG_CIL_SPACE_LIMIT(log))  in xlog_cil_insert_items()
670 	 * the log items. Shutdown is imminent...  in xlog_cil_insert_items()
674 		xfs_warn(log->l_mp, "Transaction log reservation overrun:");  in xlog_cil_insert_items()
675 		xfs_warn(log->l_mp,  in xlog_cil_insert_items()
676 			 "  log items: %d bytes (iov hdrs: %d bytes)",  in xlog_cil_insert_items()
678 		xfs_warn(log->l_mp, "  split region headers: %d bytes",  in xlog_cil_insert_items()
680 		xfs_warn(log->l_mp, "  ctx ticket: %d bytes", ctx_res);  in xlog_cil_insert_items()
682 		xlog_force_shutdown(log, SHUTDOWN_LOG_IO_ERROR);  in xlog_cil_insert_items()
770  * Mark all items committed and clear busy extents. We free the log vector
771  * chains in a separate pass so that we unpin the log items as quickly as
783 	 * Wake any commit waiters before aborting the log items so we don't  in xlog_cil_committed()
784 	 * block async log pushers on callbacks. Async log pushers explicitly do  in xlog_cil_committed()
785 	 * not wait on log force completion because they may be holding locks  in xlog_cil_committed()
845 		 * The LSN we need to pass to the log items on transaction  in xlog_cil_set_ctx_write_state()
846 		 * commit is the LSN reported by the first log vector write, not  in xlog_cil_set_ctx_write_state()
856 		 * Make sure the metadata we are about to overwrite in the log  in xlog_cil_set_ctx_write_state()
888 	 * location in the log.  in xlog_cil_set_ctx_write_state()
899  * Ensure that the order of log writes follows checkpoint sequence order. This
900  * relies on the context LSN being zero until the log write has guaranteed the
901  * LSN that the log write will start at via xlog_state_get_iclog_space().
957  * Write out the log vector change now attached to the CIL context. This will
959  * sequence order so that log recovery will always use in-order start LSNs when
967 	struct xlog		*log = ctx->cil->xc_log;  in xlog_cil_write_chain()  local
973 	return xlog_write(log, ctx, &ctx->lv_chain, ctx->ticket, chain_len);  in xlog_cil_write_chain()
978  * running log write. These commit records are strictly ordered in ascending CIL
979  * sequence order so that log recovery will always replay the checkpoints in the
986 	struct xlog		*log = ctx->cil->xc_log;  in xlog_cil_write_commit_record()  local
1005 	if (xlog_is_shutdown(log))  in xlog_cil_write_commit_record()
1014 	error = xlog_write(log, ctx, &lv_chain, ctx->ticket, reg.i_len);  in xlog_cil_write_commit_record()
1016 		xlog_force_shutdown(log, SHUTDOWN_LOG_IO_ERROR);  in xlog_cil_write_commit_record()
1032  * log opheaders that indicate the start of a log transaction and wrap the
1033  * transaction header. We keep the start record in it's own log vector rather
1050 	/* Log start record */  in xlog_cil_build_trans_hdr()
1055 	/* log iovec region pointer */  in xlog_cil_build_trans_hdr()
1060 	/* log opheader */  in xlog_cil_build_trans_hdr()
1071 	/* log iovec region pointer */  in xlog_cil_build_trans_hdr()
1087  * the list. This is important for operations like reflink where we log 4 order
1105  * Pull all the log vectors off the items in the CIL, and remove the items from
1109  * If a log item is marked with a whiteout, we do not need to write it to the
1136 		/* we don't write ordered log vectors */  in xlog_cil_build_lv_chain()
1162  * Push the Committed Item List to the log.
1170  * Hence we can allow log forces to run racily and not issue pushes for the
1182 	struct xlog		*log = cil->xc_log;  in xlog_cil_push_work()  local
1195 	new_ctx->ticket = xlog_cil_ticket_alloc(log);  in xlog_cil_push_work()
1269 	 * that the commit records are correctly ordered in the log to ensure  in xlog_cil_push_work()
1270 	 * that we process items during log IO completion in the correct order.  in xlog_cil_push_work()
1273 	 * next (e.g. due to log forces), we do not want the checkpoint with  in xlog_cil_push_work()
1278 	 * in log recovery.  in xlog_cil_push_work()
1287 	 * against the current sequence in log forces without risking  in xlog_cil_push_work()
1296 	 * Sort the log vector chain before we add the transaction headers.  in xlog_cil_push_work()
1303 	 * Build a checkpoint transaction header and write it to the log to  in xlog_cil_push_work()
1315 	 * xlog_cil_write_chain() as it should not be passed to log IO  in xlog_cil_push_work()
1348 	spin_lock(&log->l_icloglock);  in xlog_cil_push_work()
1360 			spin_lock(&log->l_icloglock);  in xlog_cil_push_work()
1383 		xlog_state_switch_iclogs(log, ctx->commit_iclog, 0);  in xlog_cil_push_work()
1385 	xlog_state_release_iclog(log, ctx->commit_iclog, ticket);  in xlog_cil_push_work()
1389 	spin_unlock(&log->l_icloglock);  in xlog_cil_push_work()
1391 	xfs_log_ticket_ungrant(log, ticket);  in xlog_cil_push_work()
1401 	ASSERT(xlog_is_shutdown(log));  in xlog_cil_push_work()
1404 		xfs_log_ticket_ungrant(log, ctx->ticket);  in xlog_cil_push_work()
1408 	spin_lock(&log->l_icloglock);  in xlog_cil_push_work()
1410 	xlog_state_release_iclog(log, ctx->commit_iclog, ticket);  in xlog_cil_push_work()
1412 	spin_unlock(&log->l_icloglock);  in xlog_cil_push_work()
1413 	xfs_log_ticket_ungrant(log, ticket);  in xlog_cil_push_work()
1418  * the log. The limit really is that a checkpoint can't be more than half the
1419  * log (the current checkpoint is not allowed to overwrite the previous
1425 	struct xlog	*log) __releases(cil->xc_ctx_lock)  in xlog_cil_push_background()  argument
1427 	struct xfs_cil	*cil = log->l_cilp;  in xlog_cil_push_background()
1445 	if (space_used < XLOG_CIL_SPACE_LIMIT(log) ||  in xlog_cil_push_background()
1447 	     space_used < XLOG_CIL_BLOCKING_SPACE_LIMIT(log) &&  in xlog_cil_push_background()
1477 	if (xlog_cil_over_hard_limit(log, space_used)) {  in xlog_cil_push_background()
1478 		trace_xfs_log_cil_wait(log, cil->xc_ctx->ticket);  in xlog_cil_push_background()
1479 		ASSERT(space_used < log->l_logsize);  in xlog_cil_push_background()
1501  * ACTIVE iclog. This then requires another full log force to push to disk,
1508 	struct xlog	*log,  in xlog_cil_push_now()  argument
1512 	struct xfs_cil	*cil = log->l_cilp;  in xlog_cil_push_now()
1551 	struct xlog	*log)  in xlog_cil_empty()  argument
1553 	struct xfs_cil	*cil = log->l_cilp;  in xlog_cil_empty()
1615 	struct xlog		*log,  in xlog_cil_commit()  argument
1620 	struct xfs_cil		*cil = log->l_cilp;  in xlog_cil_commit()
1629 	xlog_cil_alloc_shadow_bufs(log, tp);  in xlog_cil_commit()
1637 	xlog_cil_insert_items(log, tp, released_space);  in xlog_cil_commit()
1639 	if (regrant && !xlog_is_shutdown(log))  in xlog_cil_commit()
1640 		xfs_log_ticket_regrant(log, tp->t_ticket);  in xlog_cil_commit()
1642 		xfs_log_ticket_ungrant(log, tp->t_ticket);  in xlog_cil_commit()
1651 	 * have to update state in the log items and unlock them before they go  in xlog_cil_commit()
1654 	 * the log items. This affects (at least) processing of stale buffers,  in xlog_cil_commit()
1667 	xlog_cil_push_background(log);  in xlog_cil_commit()
1673  * but otherwise is no different to a push done from a log force.
1677 	struct xlog	*log)  in xlog_cil_flush()  argument
1679 	xfs_csn_t	seq = log->l_cilp->xc_current_sequence;  in xlog_cil_flush()
1681 	trace_xfs_log_force(log->l_mp, seq, _RET_IP_);  in xlog_cil_flush()
1682 	xlog_cil_push_now(log, seq, true);  in xlog_cil_flush()
1688 	if (test_bit(XLOG_CIL_EMPTY, &log->l_cilp->xc_flags))  in xlog_cil_flush()
1689 		xfs_log_force(log->l_mp, 0);  in xlog_cil_flush()
1704 	struct xlog	*log,  in xlog_cil_force_seq()  argument
1707 	struct xfs_cil		*cil = log->l_cilp;  in xlog_cil_force_seq()
1715 	trace_xfs_log_force(log->l_mp, sequence, _RET_IP_);  in xlog_cil_force_seq()
1723 	xlog_cil_push_now(log, sequence, false);  in xlog_cil_force_seq()
1738 		if (xlog_is_shutdown(log))  in xlog_cil_force_seq()
1747 			XFS_STATS_INC(log->l_mp, xs_log_force_sleep);  in xlog_cil_force_seq()
1782 	 * We detected a shutdown in progress. We need to trigger the log force  in xlog_cil_force_seq()
1785 	 * NULLCOMMITLSN here as that has special meaning to log forces (i.e.  in xlog_cil_force_seq()
1803 	struct xlog		*log,  in xlog_cil_pcp_dead()  argument
1806 	struct xfs_cil		*cil = log->l_cilp;  in xlog_cil_pcp_dead()
1830 	struct xlog		*log)  in xlog_cil_init()  argument
1842 	 * concurrency the log spinlocks will be exposed to.  in xlog_cil_init()
1846 			4, log->l_mp->m_super->s_id);  in xlog_cil_init()
1850 	cil->xc_log = log;  in xlog_cil_init()
1867 	log->l_cilp = cil;  in xlog_cil_init()
1882 	struct xlog	*log)  in xlog_cil_destroy()  argument
1884 	struct xfs_cil	*cil = log->l_cilp;  in xlog_cil_destroy()