Lines Matching defs:log
35 struct xlog *log)
39 tic = xlog_ticket_alloc(log, 0, 1, 0);
53 struct xlog *log = cil->xc_log;
56 (XLOG_CIL_BLOCKING_SPACE_LIMIT(log) /
57 (log->l_iclog_size - log->l_iclog_hsize)));
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
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)
213 log->l_cilp->xc_ctx->ticket = xlog_cil_ticket_alloc(log);
214 log->l_cilp->xc_ctx->sequence = 1;
215 xlog_cil_set_iclog_hdr_count(log->l_cilp);
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,
339 * the buffer, only the log vector header and the iovec
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,
407 /* attach new log vector to log item */
412 * CIL, store the sequence number on the log item so we can
417 lv->lv_item->li_seq = log->l_cilp->xc_ctx->sequence;
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,
456 /* Bail out if we didn't find a log item. */
474 * the shadow lv on the log item.
521 xfs_cil_prepare_item(log, lv, old_lv, diff_len);
532 struct xlog *log,
535 if (waitqueue_active(&log->l_cilp->xc_push_wait))
537 if (space_used >= XLOG_CIL_BLOCKING_SPACE_LIMIT(log))
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,
555 struct xfs_cil *cil = log->l_cilp;
571 xlog_cil_insert_format_items(log, tp, &len);
624 xlog_cil_over_hard_limit(log, space_used)) {
625 split_res = log->l_iclog_hsize +
642 (XLOG_CIL_SPACE_LIMIT(log) / num_online_cpus())) {
651 if (space_used >= XLOG_CIL_SPACE_LIMIT(log))
681 * the log items. Shutdown is imminent...
685 xfs_warn(log->l_mp, "Transaction log reservation overrun:");
686 xfs_warn(log->l_mp,
687 " log items: %d bytes (iov hdrs: %d bytes)",
689 xfs_warn(log->l_mp, " split region headers: %d bytes",
691 xfs_warn(log->l_mp, " ctx ticket: %d bytes", ctx_res);
693 xlog_force_shutdown(log, SHUTDOWN_LOG_IO_ERROR);
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
725 * block async log pushers on callbacks. Async log pushers explicitly do
726 * not wait on log force completion because they may be holding locks
790 * The LSN we need to pass to the log items on transaction
791 * commit is the LSN reported by the first log vector write, not
801 * Make sure the metadata we are about to overwrite in the log
833 * location in the log.
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;
918 return xlog_write(log, ctx, &ctx->lv_chain, ctx->ticket, chain_len);
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;
950 if (xlog_is_shutdown(log))
959 error = xlog_write(log, ctx, &lv_chain, ctx->ticket, reg.i_len);
961 xlog_force_shutdown(log, SHUTDOWN_LOG_IO_ERROR);
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
1000 /* log iovec region pointer */
1005 /* log opheader */
1016 /* log iovec region pointer */
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 */
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;
1140 new_ctx->ticket = xlog_cil_ticket_alloc(log);
1214 * that the commit records are correctly ordered in the log to ensure
1215 * that we process items during log IO completion in the correct order.
1218 * next (e.g. due to log forces), we do not want the checkpoint with
1223 * in log recovery.
1232 * against the current sequence in log forces without risking
1241 * Sort the log vector chain before we add the transaction headers.
1248 * Build a checkpoint transaction header and write it to the log to
1260 * xlog_cil_write_chain() as it should not be passed to log IO
1293 spin_lock(&log->l_icloglock);
1305 spin_lock(&log->l_icloglock);
1328 xlog_state_switch_iclogs(log, ctx->commit_iclog, 0);
1330 xlog_state_release_iclog(log, ctx->commit_iclog, ticket);
1334 spin_unlock(&log->l_icloglock);
1336 xfs_log_ticket_ungrant(log, ticket);
1346 ASSERT(xlog_is_shutdown(log));
1349 xfs_log_ticket_ungrant(log, ctx->ticket);
1353 spin_lock(&log->l_icloglock);
1355 xlog_state_release_iclog(log, ctx->commit_iclog, ticket);
1357 spin_unlock(&log->l_icloglock);
1358 xfs_log_ticket_ungrant(log, ticket);
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)
1372 struct xfs_cil *cil = log->l_cilp;
1390 if (space_used < XLOG_CIL_SPACE_LIMIT(log) ||
1392 space_used < XLOG_CIL_BLOCKING_SPACE_LIMIT(log) &&
1422 if (xlog_cil_over_hard_limit(log, space_used)) {
1423 trace_xfs_log_cil_wait(log, cil->xc_ctx->ticket);
1424 ASSERT(space_used < log->l_logsize);
1446 * ACTIVE iclog. This then requires another full log force to push to disk,
1453 struct xlog *log,
1457 struct xfs_cil *cil = log->l_cilp;
1496 struct xlog *log)
1498 struct xfs_cil *cil = log->l_cilp;
1560 struct xlog *log,
1565 struct xfs_cil *cil = log->l_cilp;
1574 xlog_cil_alloc_shadow_bufs(log, tp);
1582 xlog_cil_insert_items(log, tp, released_space);
1584 if (regrant && !xlog_is_shutdown(log))
1585 xfs_log_ticket_regrant(log, tp->t_ticket);
1587 xfs_log_ticket_ungrant(log, tp->t_ticket);
1596 * have to update state in the log items and unlock them before they go
1599 * the log items. This affects (at least) processing of stale buffers,
1612 xlog_cil_push_background(log);
1618 * but otherwise is no different to a push done from a log force.
1622 struct xlog *log)
1624 xfs_csn_t seq = log->l_cilp->xc_current_sequence;
1626 trace_xfs_log_force(log->l_mp, seq, _RET_IP_);
1627 xlog_cil_push_now(log, seq, true);
1633 if (test_bit(XLOG_CIL_EMPTY, &log->l_cilp->xc_flags))
1634 xfs_log_force(log->l_mp, 0);
1649 struct xlog *log,
1652 struct xfs_cil *cil = log->l_cilp;
1660 trace_xfs_log_force(log->l_mp, sequence, _RET_IP_);
1668 xlog_cil_push_now(log, sequence, false);
1683 if (xlog_is_shutdown(log))
1692 XFS_STATS_INC(log->l_mp, xs_log_force_sleep);
1727 * We detected a shutdown in progress. We need to trigger the log force
1730 * NULLCOMMITLSN here as that has special meaning to log forces (i.e.
1743 struct xlog *log)
1755 * concurrency the log spinlocks will be exposed to.
1759 4, log->l_mp->m_super->s_id);
1763 cil->xc_log = log;
1780 log->l_cilp = cil;
1795 struct xlog *log)
1797 struct xfs_cil *cil = log->l_cilp;