xref: /openbmc/linux/fs/xfs/xfs_log.c (revision 5d0e4d78)
1 /*
2  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18 #include "xfs.h"
19 #include "xfs_fs.h"
20 #include "xfs_shared.h"
21 #include "xfs_format.h"
22 #include "xfs_log_format.h"
23 #include "xfs_trans_resv.h"
24 #include "xfs_mount.h"
25 #include "xfs_error.h"
26 #include "xfs_trans.h"
27 #include "xfs_trans_priv.h"
28 #include "xfs_log.h"
29 #include "xfs_log_priv.h"
30 #include "xfs_log_recover.h"
31 #include "xfs_inode.h"
32 #include "xfs_trace.h"
33 #include "xfs_fsops.h"
34 #include "xfs_cksum.h"
35 #include "xfs_sysfs.h"
36 #include "xfs_sb.h"
37 
38 kmem_zone_t	*xfs_log_ticket_zone;
39 
40 /* Local miscellaneous function prototypes */
41 STATIC int
42 xlog_commit_record(
43 	struct xlog		*log,
44 	struct xlog_ticket	*ticket,
45 	struct xlog_in_core	**iclog,
46 	xfs_lsn_t		*commitlsnp);
47 
48 STATIC struct xlog *
49 xlog_alloc_log(
50 	struct xfs_mount	*mp,
51 	struct xfs_buftarg	*log_target,
52 	xfs_daddr_t		blk_offset,
53 	int			num_bblks);
54 STATIC int
55 xlog_space_left(
56 	struct xlog		*log,
57 	atomic64_t		*head);
58 STATIC int
59 xlog_sync(
60 	struct xlog		*log,
61 	struct xlog_in_core	*iclog);
62 STATIC void
63 xlog_dealloc_log(
64 	struct xlog		*log);
65 
66 /* local state machine functions */
67 STATIC void xlog_state_done_syncing(xlog_in_core_t *iclog, int);
68 STATIC void
69 xlog_state_do_callback(
70 	struct xlog		*log,
71 	int			aborted,
72 	struct xlog_in_core	*iclog);
73 STATIC int
74 xlog_state_get_iclog_space(
75 	struct xlog		*log,
76 	int			len,
77 	struct xlog_in_core	**iclog,
78 	struct xlog_ticket	*ticket,
79 	int			*continued_write,
80 	int			*logoffsetp);
81 STATIC int
82 xlog_state_release_iclog(
83 	struct xlog		*log,
84 	struct xlog_in_core	*iclog);
85 STATIC void
86 xlog_state_switch_iclogs(
87 	struct xlog		*log,
88 	struct xlog_in_core	*iclog,
89 	int			eventual_size);
90 STATIC void
91 xlog_state_want_sync(
92 	struct xlog		*log,
93 	struct xlog_in_core	*iclog);
94 
95 STATIC void
96 xlog_grant_push_ail(
97 	struct xlog		*log,
98 	int			need_bytes);
99 STATIC void
100 xlog_regrant_reserve_log_space(
101 	struct xlog		*log,
102 	struct xlog_ticket	*ticket);
103 STATIC void
104 xlog_ungrant_log_space(
105 	struct xlog		*log,
106 	struct xlog_ticket	*ticket);
107 
108 #if defined(DEBUG)
109 STATIC void
110 xlog_verify_dest_ptr(
111 	struct xlog		*log,
112 	void			*ptr);
113 STATIC void
114 xlog_verify_grant_tail(
115 	struct xlog *log);
116 STATIC void
117 xlog_verify_iclog(
118 	struct xlog		*log,
119 	struct xlog_in_core	*iclog,
120 	int			count,
121 	bool                    syncing);
122 STATIC void
123 xlog_verify_tail_lsn(
124 	struct xlog		*log,
125 	struct xlog_in_core	*iclog,
126 	xfs_lsn_t		tail_lsn);
127 #else
128 #define xlog_verify_dest_ptr(a,b)
129 #define xlog_verify_grant_tail(a)
130 #define xlog_verify_iclog(a,b,c,d)
131 #define xlog_verify_tail_lsn(a,b,c)
132 #endif
133 
134 STATIC int
135 xlog_iclogs_empty(
136 	struct xlog		*log);
137 
138 static void
139 xlog_grant_sub_space(
140 	struct xlog		*log,
141 	atomic64_t		*head,
142 	int			bytes)
143 {
144 	int64_t	head_val = atomic64_read(head);
145 	int64_t new, old;
146 
147 	do {
148 		int	cycle, space;
149 
150 		xlog_crack_grant_head_val(head_val, &cycle, &space);
151 
152 		space -= bytes;
153 		if (space < 0) {
154 			space += log->l_logsize;
155 			cycle--;
156 		}
157 
158 		old = head_val;
159 		new = xlog_assign_grant_head_val(cycle, space);
160 		head_val = atomic64_cmpxchg(head, old, new);
161 	} while (head_val != old);
162 }
163 
164 static void
165 xlog_grant_add_space(
166 	struct xlog		*log,
167 	atomic64_t		*head,
168 	int			bytes)
169 {
170 	int64_t	head_val = atomic64_read(head);
171 	int64_t new, old;
172 
173 	do {
174 		int		tmp;
175 		int		cycle, space;
176 
177 		xlog_crack_grant_head_val(head_val, &cycle, &space);
178 
179 		tmp = log->l_logsize - space;
180 		if (tmp > bytes)
181 			space += bytes;
182 		else {
183 			space = bytes - tmp;
184 			cycle++;
185 		}
186 
187 		old = head_val;
188 		new = xlog_assign_grant_head_val(cycle, space);
189 		head_val = atomic64_cmpxchg(head, old, new);
190 	} while (head_val != old);
191 }
192 
193 STATIC void
194 xlog_grant_head_init(
195 	struct xlog_grant_head	*head)
196 {
197 	xlog_assign_grant_head(&head->grant, 1, 0);
198 	INIT_LIST_HEAD(&head->waiters);
199 	spin_lock_init(&head->lock);
200 }
201 
202 STATIC void
203 xlog_grant_head_wake_all(
204 	struct xlog_grant_head	*head)
205 {
206 	struct xlog_ticket	*tic;
207 
208 	spin_lock(&head->lock);
209 	list_for_each_entry(tic, &head->waiters, t_queue)
210 		wake_up_process(tic->t_task);
211 	spin_unlock(&head->lock);
212 }
213 
214 static inline int
215 xlog_ticket_reservation(
216 	struct xlog		*log,
217 	struct xlog_grant_head	*head,
218 	struct xlog_ticket	*tic)
219 {
220 	if (head == &log->l_write_head) {
221 		ASSERT(tic->t_flags & XLOG_TIC_PERM_RESERV);
222 		return tic->t_unit_res;
223 	} else {
224 		if (tic->t_flags & XLOG_TIC_PERM_RESERV)
225 			return tic->t_unit_res * tic->t_cnt;
226 		else
227 			return tic->t_unit_res;
228 	}
229 }
230 
231 STATIC bool
232 xlog_grant_head_wake(
233 	struct xlog		*log,
234 	struct xlog_grant_head	*head,
235 	int			*free_bytes)
236 {
237 	struct xlog_ticket	*tic;
238 	int			need_bytes;
239 
240 	list_for_each_entry(tic, &head->waiters, t_queue) {
241 		need_bytes = xlog_ticket_reservation(log, head, tic);
242 		if (*free_bytes < need_bytes)
243 			return false;
244 
245 		*free_bytes -= need_bytes;
246 		trace_xfs_log_grant_wake_up(log, tic);
247 		wake_up_process(tic->t_task);
248 	}
249 
250 	return true;
251 }
252 
253 STATIC int
254 xlog_grant_head_wait(
255 	struct xlog		*log,
256 	struct xlog_grant_head	*head,
257 	struct xlog_ticket	*tic,
258 	int			need_bytes) __releases(&head->lock)
259 					    __acquires(&head->lock)
260 {
261 	list_add_tail(&tic->t_queue, &head->waiters);
262 
263 	do {
264 		if (XLOG_FORCED_SHUTDOWN(log))
265 			goto shutdown;
266 		xlog_grant_push_ail(log, need_bytes);
267 
268 		__set_current_state(TASK_UNINTERRUPTIBLE);
269 		spin_unlock(&head->lock);
270 
271 		XFS_STATS_INC(log->l_mp, xs_sleep_logspace);
272 
273 		trace_xfs_log_grant_sleep(log, tic);
274 		schedule();
275 		trace_xfs_log_grant_wake(log, tic);
276 
277 		spin_lock(&head->lock);
278 		if (XLOG_FORCED_SHUTDOWN(log))
279 			goto shutdown;
280 	} while (xlog_space_left(log, &head->grant) < need_bytes);
281 
282 	list_del_init(&tic->t_queue);
283 	return 0;
284 shutdown:
285 	list_del_init(&tic->t_queue);
286 	return -EIO;
287 }
288 
289 /*
290  * Atomically get the log space required for a log ticket.
291  *
292  * Once a ticket gets put onto head->waiters, it will only return after the
293  * needed reservation is satisfied.
294  *
295  * This function is structured so that it has a lock free fast path. This is
296  * necessary because every new transaction reservation will come through this
297  * path. Hence any lock will be globally hot if we take it unconditionally on
298  * every pass.
299  *
300  * As tickets are only ever moved on and off head->waiters under head->lock, we
301  * only need to take that lock if we are going to add the ticket to the queue
302  * and sleep. We can avoid taking the lock if the ticket was never added to
303  * head->waiters because the t_queue list head will be empty and we hold the
304  * only reference to it so it can safely be checked unlocked.
305  */
306 STATIC int
307 xlog_grant_head_check(
308 	struct xlog		*log,
309 	struct xlog_grant_head	*head,
310 	struct xlog_ticket	*tic,
311 	int			*need_bytes)
312 {
313 	int			free_bytes;
314 	int			error = 0;
315 
316 	ASSERT(!(log->l_flags & XLOG_ACTIVE_RECOVERY));
317 
318 	/*
319 	 * If there are other waiters on the queue then give them a chance at
320 	 * logspace before us.  Wake up the first waiters, if we do not wake
321 	 * up all the waiters then go to sleep waiting for more free space,
322 	 * otherwise try to get some space for this transaction.
323 	 */
324 	*need_bytes = xlog_ticket_reservation(log, head, tic);
325 	free_bytes = xlog_space_left(log, &head->grant);
326 	if (!list_empty_careful(&head->waiters)) {
327 		spin_lock(&head->lock);
328 		if (!xlog_grant_head_wake(log, head, &free_bytes) ||
329 		    free_bytes < *need_bytes) {
330 			error = xlog_grant_head_wait(log, head, tic,
331 						     *need_bytes);
332 		}
333 		spin_unlock(&head->lock);
334 	} else if (free_bytes < *need_bytes) {
335 		spin_lock(&head->lock);
336 		error = xlog_grant_head_wait(log, head, tic, *need_bytes);
337 		spin_unlock(&head->lock);
338 	}
339 
340 	return error;
341 }
342 
343 static void
344 xlog_tic_reset_res(xlog_ticket_t *tic)
345 {
346 	tic->t_res_num = 0;
347 	tic->t_res_arr_sum = 0;
348 	tic->t_res_num_ophdrs = 0;
349 }
350 
351 static void
352 xlog_tic_add_region(xlog_ticket_t *tic, uint len, uint type)
353 {
354 	if (tic->t_res_num == XLOG_TIC_LEN_MAX) {
355 		/* add to overflow and start again */
356 		tic->t_res_o_flow += tic->t_res_arr_sum;
357 		tic->t_res_num = 0;
358 		tic->t_res_arr_sum = 0;
359 	}
360 
361 	tic->t_res_arr[tic->t_res_num].r_len = len;
362 	tic->t_res_arr[tic->t_res_num].r_type = type;
363 	tic->t_res_arr_sum += len;
364 	tic->t_res_num++;
365 }
366 
367 /*
368  * Replenish the byte reservation required by moving the grant write head.
369  */
370 int
371 xfs_log_regrant(
372 	struct xfs_mount	*mp,
373 	struct xlog_ticket	*tic)
374 {
375 	struct xlog		*log = mp->m_log;
376 	int			need_bytes;
377 	int			error = 0;
378 
379 	if (XLOG_FORCED_SHUTDOWN(log))
380 		return -EIO;
381 
382 	XFS_STATS_INC(mp, xs_try_logspace);
383 
384 	/*
385 	 * This is a new transaction on the ticket, so we need to change the
386 	 * transaction ID so that the next transaction has a different TID in
387 	 * the log. Just add one to the existing tid so that we can see chains
388 	 * of rolling transactions in the log easily.
389 	 */
390 	tic->t_tid++;
391 
392 	xlog_grant_push_ail(log, tic->t_unit_res);
393 
394 	tic->t_curr_res = tic->t_unit_res;
395 	xlog_tic_reset_res(tic);
396 
397 	if (tic->t_cnt > 0)
398 		return 0;
399 
400 	trace_xfs_log_regrant(log, tic);
401 
402 	error = xlog_grant_head_check(log, &log->l_write_head, tic,
403 				      &need_bytes);
404 	if (error)
405 		goto out_error;
406 
407 	xlog_grant_add_space(log, &log->l_write_head.grant, need_bytes);
408 	trace_xfs_log_regrant_exit(log, tic);
409 	xlog_verify_grant_tail(log);
410 	return 0;
411 
412 out_error:
413 	/*
414 	 * If we are failing, make sure the ticket doesn't have any current
415 	 * reservations.  We don't want to add this back when the ticket/
416 	 * transaction gets cancelled.
417 	 */
418 	tic->t_curr_res = 0;
419 	tic->t_cnt = 0;	/* ungrant will give back unit_res * t_cnt. */
420 	return error;
421 }
422 
423 /*
424  * Reserve log space and return a ticket corresponding the reservation.
425  *
426  * Each reservation is going to reserve extra space for a log record header.
427  * When writes happen to the on-disk log, we don't subtract the length of the
428  * log record header from any reservation.  By wasting space in each
429  * reservation, we prevent over allocation problems.
430  */
431 int
432 xfs_log_reserve(
433 	struct xfs_mount	*mp,
434 	int		 	unit_bytes,
435 	int		 	cnt,
436 	struct xlog_ticket	**ticp,
437 	uint8_t		 	client,
438 	bool			permanent)
439 {
440 	struct xlog		*log = mp->m_log;
441 	struct xlog_ticket	*tic;
442 	int			need_bytes;
443 	int			error = 0;
444 
445 	ASSERT(client == XFS_TRANSACTION || client == XFS_LOG);
446 
447 	if (XLOG_FORCED_SHUTDOWN(log))
448 		return -EIO;
449 
450 	XFS_STATS_INC(mp, xs_try_logspace);
451 
452 	ASSERT(*ticp == NULL);
453 	tic = xlog_ticket_alloc(log, unit_bytes, cnt, client, permanent,
454 				KM_SLEEP | KM_MAYFAIL);
455 	if (!tic)
456 		return -ENOMEM;
457 
458 	*ticp = tic;
459 
460 	xlog_grant_push_ail(log, tic->t_cnt ? tic->t_unit_res * tic->t_cnt
461 					    : tic->t_unit_res);
462 
463 	trace_xfs_log_reserve(log, tic);
464 
465 	error = xlog_grant_head_check(log, &log->l_reserve_head, tic,
466 				      &need_bytes);
467 	if (error)
468 		goto out_error;
469 
470 	xlog_grant_add_space(log, &log->l_reserve_head.grant, need_bytes);
471 	xlog_grant_add_space(log, &log->l_write_head.grant, need_bytes);
472 	trace_xfs_log_reserve_exit(log, tic);
473 	xlog_verify_grant_tail(log);
474 	return 0;
475 
476 out_error:
477 	/*
478 	 * If we are failing, make sure the ticket doesn't have any current
479 	 * reservations.  We don't want to add this back when the ticket/
480 	 * transaction gets cancelled.
481 	 */
482 	tic->t_curr_res = 0;
483 	tic->t_cnt = 0;	/* ungrant will give back unit_res * t_cnt. */
484 	return error;
485 }
486 
487 
488 /*
489  * NOTES:
490  *
491  *	1. currblock field gets updated at startup and after in-core logs
492  *		marked as with WANT_SYNC.
493  */
494 
495 /*
496  * This routine is called when a user of a log manager ticket is done with
497  * the reservation.  If the ticket was ever used, then a commit record for
498  * the associated transaction is written out as a log operation header with
499  * no data.  The flag XLOG_TIC_INITED is set when the first write occurs with
500  * a given ticket.  If the ticket was one with a permanent reservation, then
501  * a few operations are done differently.  Permanent reservation tickets by
502  * default don't release the reservation.  They just commit the current
503  * transaction with the belief that the reservation is still needed.  A flag
504  * must be passed in before permanent reservations are actually released.
505  * When these type of tickets are not released, they need to be set into
506  * the inited state again.  By doing this, a start record will be written
507  * out when the next write occurs.
508  */
509 xfs_lsn_t
510 xfs_log_done(
511 	struct xfs_mount	*mp,
512 	struct xlog_ticket	*ticket,
513 	struct xlog_in_core	**iclog,
514 	bool			regrant)
515 {
516 	struct xlog		*log = mp->m_log;
517 	xfs_lsn_t		lsn = 0;
518 
519 	if (XLOG_FORCED_SHUTDOWN(log) ||
520 	    /*
521 	     * If nothing was ever written, don't write out commit record.
522 	     * If we get an error, just continue and give back the log ticket.
523 	     */
524 	    (((ticket->t_flags & XLOG_TIC_INITED) == 0) &&
525 	     (xlog_commit_record(log, ticket, iclog, &lsn)))) {
526 		lsn = (xfs_lsn_t) -1;
527 		regrant = false;
528 	}
529 
530 
531 	if (!regrant) {
532 		trace_xfs_log_done_nonperm(log, ticket);
533 
534 		/*
535 		 * Release ticket if not permanent reservation or a specific
536 		 * request has been made to release a permanent reservation.
537 		 */
538 		xlog_ungrant_log_space(log, ticket);
539 	} else {
540 		trace_xfs_log_done_perm(log, ticket);
541 
542 		xlog_regrant_reserve_log_space(log, ticket);
543 		/* If this ticket was a permanent reservation and we aren't
544 		 * trying to release it, reset the inited flags; so next time
545 		 * we write, a start record will be written out.
546 		 */
547 		ticket->t_flags |= XLOG_TIC_INITED;
548 	}
549 
550 	xfs_log_ticket_put(ticket);
551 	return lsn;
552 }
553 
554 /*
555  * Attaches a new iclog I/O completion callback routine during
556  * transaction commit.  If the log is in error state, a non-zero
557  * return code is handed back and the caller is responsible for
558  * executing the callback at an appropriate time.
559  */
560 int
561 xfs_log_notify(
562 	struct xfs_mount	*mp,
563 	struct xlog_in_core	*iclog,
564 	xfs_log_callback_t	*cb)
565 {
566 	int	abortflg;
567 
568 	spin_lock(&iclog->ic_callback_lock);
569 	abortflg = (iclog->ic_state & XLOG_STATE_IOERROR);
570 	if (!abortflg) {
571 		ASSERT_ALWAYS((iclog->ic_state == XLOG_STATE_ACTIVE) ||
572 			      (iclog->ic_state == XLOG_STATE_WANT_SYNC));
573 		cb->cb_next = NULL;
574 		*(iclog->ic_callback_tail) = cb;
575 		iclog->ic_callback_tail = &(cb->cb_next);
576 	}
577 	spin_unlock(&iclog->ic_callback_lock);
578 	return abortflg;
579 }
580 
581 int
582 xfs_log_release_iclog(
583 	struct xfs_mount	*mp,
584 	struct xlog_in_core	*iclog)
585 {
586 	if (xlog_state_release_iclog(mp->m_log, iclog)) {
587 		xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
588 		return -EIO;
589 	}
590 
591 	return 0;
592 }
593 
594 /*
595  * Mount a log filesystem
596  *
597  * mp		- ubiquitous xfs mount point structure
598  * log_target	- buftarg of on-disk log device
599  * blk_offset	- Start block # where block size is 512 bytes (BBSIZE)
600  * num_bblocks	- Number of BBSIZE blocks in on-disk log
601  *
602  * Return error or zero.
603  */
604 int
605 xfs_log_mount(
606 	xfs_mount_t	*mp,
607 	xfs_buftarg_t	*log_target,
608 	xfs_daddr_t	blk_offset,
609 	int		num_bblks)
610 {
611 	int		error = 0;
612 	int		min_logfsbs;
613 
614 	if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) {
615 		xfs_notice(mp, "Mounting V%d Filesystem",
616 			   XFS_SB_VERSION_NUM(&mp->m_sb));
617 	} else {
618 		xfs_notice(mp,
619 "Mounting V%d filesystem in no-recovery mode. Filesystem will be inconsistent.",
620 			   XFS_SB_VERSION_NUM(&mp->m_sb));
621 		ASSERT(mp->m_flags & XFS_MOUNT_RDONLY);
622 	}
623 
624 	mp->m_log = xlog_alloc_log(mp, log_target, blk_offset, num_bblks);
625 	if (IS_ERR(mp->m_log)) {
626 		error = PTR_ERR(mp->m_log);
627 		goto out;
628 	}
629 
630 	/*
631 	 * Validate the given log space and drop a critical message via syslog
632 	 * if the log size is too small that would lead to some unexpected
633 	 * situations in transaction log space reservation stage.
634 	 *
635 	 * Note: we can't just reject the mount if the validation fails.  This
636 	 * would mean that people would have to downgrade their kernel just to
637 	 * remedy the situation as there is no way to grow the log (short of
638 	 * black magic surgery with xfs_db).
639 	 *
640 	 * We can, however, reject mounts for CRC format filesystems, as the
641 	 * mkfs binary being used to make the filesystem should never create a
642 	 * filesystem with a log that is too small.
643 	 */
644 	min_logfsbs = xfs_log_calc_minimum_size(mp);
645 
646 	if (mp->m_sb.sb_logblocks < min_logfsbs) {
647 		xfs_warn(mp,
648 		"Log size %d blocks too small, minimum size is %d blocks",
649 			 mp->m_sb.sb_logblocks, min_logfsbs);
650 		error = -EINVAL;
651 	} else if (mp->m_sb.sb_logblocks > XFS_MAX_LOG_BLOCKS) {
652 		xfs_warn(mp,
653 		"Log size %d blocks too large, maximum size is %lld blocks",
654 			 mp->m_sb.sb_logblocks, XFS_MAX_LOG_BLOCKS);
655 		error = -EINVAL;
656 	} else if (XFS_FSB_TO_B(mp, mp->m_sb.sb_logblocks) > XFS_MAX_LOG_BYTES) {
657 		xfs_warn(mp,
658 		"log size %lld bytes too large, maximum size is %lld bytes",
659 			 XFS_FSB_TO_B(mp, mp->m_sb.sb_logblocks),
660 			 XFS_MAX_LOG_BYTES);
661 		error = -EINVAL;
662 	}
663 	if (error) {
664 		if (xfs_sb_version_hascrc(&mp->m_sb)) {
665 			xfs_crit(mp, "AAIEEE! Log failed size checks. Abort!");
666 			ASSERT(0);
667 			goto out_free_log;
668 		}
669 		xfs_crit(mp, "Log size out of supported range.");
670 		xfs_crit(mp,
671 "Continuing onwards, but if log hangs are experienced then please report this message in the bug report.");
672 	}
673 
674 	/*
675 	 * Initialize the AIL now we have a log.
676 	 */
677 	error = xfs_trans_ail_init(mp);
678 	if (error) {
679 		xfs_warn(mp, "AIL initialisation failed: error %d", error);
680 		goto out_free_log;
681 	}
682 	mp->m_log->l_ailp = mp->m_ail;
683 
684 	/*
685 	 * skip log recovery on a norecovery mount.  pretend it all
686 	 * just worked.
687 	 */
688 	if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) {
689 		int	readonly = (mp->m_flags & XFS_MOUNT_RDONLY);
690 
691 		if (readonly)
692 			mp->m_flags &= ~XFS_MOUNT_RDONLY;
693 
694 		error = xlog_recover(mp->m_log);
695 
696 		if (readonly)
697 			mp->m_flags |= XFS_MOUNT_RDONLY;
698 		if (error) {
699 			xfs_warn(mp, "log mount/recovery failed: error %d",
700 				error);
701 			xlog_recover_cancel(mp->m_log);
702 			goto out_destroy_ail;
703 		}
704 	}
705 
706 	error = xfs_sysfs_init(&mp->m_log->l_kobj, &xfs_log_ktype, &mp->m_kobj,
707 			       "log");
708 	if (error)
709 		goto out_destroy_ail;
710 
711 	/* Normal transactions can now occur */
712 	mp->m_log->l_flags &= ~XLOG_ACTIVE_RECOVERY;
713 
714 	/*
715 	 * Now the log has been fully initialised and we know were our
716 	 * space grant counters are, we can initialise the permanent ticket
717 	 * needed for delayed logging to work.
718 	 */
719 	xlog_cil_init_post_recovery(mp->m_log);
720 
721 	return 0;
722 
723 out_destroy_ail:
724 	xfs_trans_ail_destroy(mp);
725 out_free_log:
726 	xlog_dealloc_log(mp->m_log);
727 out:
728 	return error;
729 }
730 
731 /*
732  * Finish the recovery of the file system.  This is separate from the
733  * xfs_log_mount() call, because it depends on the code in xfs_mountfs() to read
734  * in the root and real-time bitmap inodes between calling xfs_log_mount() and
735  * here.
736  *
737  * If we finish recovery successfully, start the background log work. If we are
738  * not doing recovery, then we have a RO filesystem and we don't need to start
739  * it.
740  */
741 int
742 xfs_log_mount_finish(
743 	struct xfs_mount	*mp)
744 {
745 	int	error = 0;
746 
747 	if (mp->m_flags & XFS_MOUNT_NORECOVERY) {
748 		ASSERT(mp->m_flags & XFS_MOUNT_RDONLY);
749 		return 0;
750 	}
751 
752 	error = xlog_recover_finish(mp->m_log);
753 	if (!error)
754 		xfs_log_work_queue(mp);
755 
756 	return error;
757 }
758 
759 /*
760  * The mount has failed. Cancel the recovery if it hasn't completed and destroy
761  * the log.
762  */
763 int
764 xfs_log_mount_cancel(
765 	struct xfs_mount	*mp)
766 {
767 	int			error;
768 
769 	error = xlog_recover_cancel(mp->m_log);
770 	xfs_log_unmount(mp);
771 
772 	return error;
773 }
774 
775 /*
776  * Final log writes as part of unmount.
777  *
778  * Mark the filesystem clean as unmount happens.  Note that during relocation
779  * this routine needs to be executed as part of source-bag while the
780  * deallocation must not be done until source-end.
781  */
782 
783 /*
784  * Unmount record used to have a string "Unmount filesystem--" in the
785  * data section where the "Un" was really a magic number (XLOG_UNMOUNT_TYPE).
786  * We just write the magic number now since that particular field isn't
787  * currently architecture converted and "Unmount" is a bit foo.
788  * As far as I know, there weren't any dependencies on the old behaviour.
789  */
790 
791 static int
792 xfs_log_unmount_write(xfs_mount_t *mp)
793 {
794 	struct xlog	 *log = mp->m_log;
795 	xlog_in_core_t	 *iclog;
796 #ifdef DEBUG
797 	xlog_in_core_t	 *first_iclog;
798 #endif
799 	xlog_ticket_t	*tic = NULL;
800 	xfs_lsn_t	 lsn;
801 	int		 error;
802 
803 	/*
804 	 * Don't write out unmount record on read-only mounts.
805 	 * Or, if we are doing a forced umount (typically because of IO errors).
806 	 */
807 	if (mp->m_flags & XFS_MOUNT_RDONLY)
808 		return 0;
809 
810 	error = _xfs_log_force(mp, XFS_LOG_SYNC, NULL);
811 	ASSERT(error || !(XLOG_FORCED_SHUTDOWN(log)));
812 
813 #ifdef DEBUG
814 	first_iclog = iclog = log->l_iclog;
815 	do {
816 		if (!(iclog->ic_state & XLOG_STATE_IOERROR)) {
817 			ASSERT(iclog->ic_state & XLOG_STATE_ACTIVE);
818 			ASSERT(iclog->ic_offset == 0);
819 		}
820 		iclog = iclog->ic_next;
821 	} while (iclog != first_iclog);
822 #endif
823 	if (! (XLOG_FORCED_SHUTDOWN(log))) {
824 		error = xfs_log_reserve(mp, 600, 1, &tic, XFS_LOG, 0);
825 		if (!error) {
826 			/* the data section must be 32 bit size aligned */
827 			struct {
828 			    uint16_t magic;
829 			    uint16_t pad1;
830 			    uint32_t pad2; /* may as well make it 64 bits */
831 			} magic = {
832 				.magic = XLOG_UNMOUNT_TYPE,
833 			};
834 			struct xfs_log_iovec reg = {
835 				.i_addr = &magic,
836 				.i_len = sizeof(magic),
837 				.i_type = XLOG_REG_TYPE_UNMOUNT,
838 			};
839 			struct xfs_log_vec vec = {
840 				.lv_niovecs = 1,
841 				.lv_iovecp = &reg,
842 			};
843 
844 			/* remove inited flag, and account for space used */
845 			tic->t_flags = 0;
846 			tic->t_curr_res -= sizeof(magic);
847 			error = xlog_write(log, &vec, tic, &lsn,
848 					   NULL, XLOG_UNMOUNT_TRANS);
849 			/*
850 			 * At this point, we're umounting anyway,
851 			 * so there's no point in transitioning log state
852 			 * to IOERROR. Just continue...
853 			 */
854 		}
855 
856 		if (error)
857 			xfs_alert(mp, "%s: unmount record failed", __func__);
858 
859 
860 		spin_lock(&log->l_icloglock);
861 		iclog = log->l_iclog;
862 		atomic_inc(&iclog->ic_refcnt);
863 		xlog_state_want_sync(log, iclog);
864 		spin_unlock(&log->l_icloglock);
865 		error = xlog_state_release_iclog(log, iclog);
866 
867 		spin_lock(&log->l_icloglock);
868 		if (!(iclog->ic_state == XLOG_STATE_ACTIVE ||
869 		      iclog->ic_state == XLOG_STATE_DIRTY)) {
870 			if (!XLOG_FORCED_SHUTDOWN(log)) {
871 				xlog_wait(&iclog->ic_force_wait,
872 							&log->l_icloglock);
873 			} else {
874 				spin_unlock(&log->l_icloglock);
875 			}
876 		} else {
877 			spin_unlock(&log->l_icloglock);
878 		}
879 		if (tic) {
880 			trace_xfs_log_umount_write(log, tic);
881 			xlog_ungrant_log_space(log, tic);
882 			xfs_log_ticket_put(tic);
883 		}
884 	} else {
885 		/*
886 		 * We're already in forced_shutdown mode, couldn't
887 		 * even attempt to write out the unmount transaction.
888 		 *
889 		 * Go through the motions of sync'ing and releasing
890 		 * the iclog, even though no I/O will actually happen,
891 		 * we need to wait for other log I/Os that may already
892 		 * be in progress.  Do this as a separate section of
893 		 * code so we'll know if we ever get stuck here that
894 		 * we're in this odd situation of trying to unmount
895 		 * a file system that went into forced_shutdown as
896 		 * the result of an unmount..
897 		 */
898 		spin_lock(&log->l_icloglock);
899 		iclog = log->l_iclog;
900 		atomic_inc(&iclog->ic_refcnt);
901 
902 		xlog_state_want_sync(log, iclog);
903 		spin_unlock(&log->l_icloglock);
904 		error =  xlog_state_release_iclog(log, iclog);
905 
906 		spin_lock(&log->l_icloglock);
907 
908 		if ( ! (   iclog->ic_state == XLOG_STATE_ACTIVE
909 			|| iclog->ic_state == XLOG_STATE_DIRTY
910 			|| iclog->ic_state == XLOG_STATE_IOERROR) ) {
911 
912 				xlog_wait(&iclog->ic_force_wait,
913 							&log->l_icloglock);
914 		} else {
915 			spin_unlock(&log->l_icloglock);
916 		}
917 	}
918 
919 	return error;
920 }	/* xfs_log_unmount_write */
921 
922 /*
923  * Empty the log for unmount/freeze.
924  *
925  * To do this, we first need to shut down the background log work so it is not
926  * trying to cover the log as we clean up. We then need to unpin all objects in
927  * the log so we can then flush them out. Once they have completed their IO and
928  * run the callbacks removing themselves from the AIL, we can write the unmount
929  * record.
930  */
931 void
932 xfs_log_quiesce(
933 	struct xfs_mount	*mp)
934 {
935 	cancel_delayed_work_sync(&mp->m_log->l_work);
936 	xfs_log_force(mp, XFS_LOG_SYNC);
937 
938 	/*
939 	 * The superblock buffer is uncached and while xfs_ail_push_all_sync()
940 	 * will push it, xfs_wait_buftarg() will not wait for it. Further,
941 	 * xfs_buf_iowait() cannot be used because it was pushed with the
942 	 * XBF_ASYNC flag set, so we need to use a lock/unlock pair to wait for
943 	 * the IO to complete.
944 	 */
945 	xfs_ail_push_all_sync(mp->m_ail);
946 	xfs_wait_buftarg(mp->m_ddev_targp);
947 	xfs_buf_lock(mp->m_sb_bp);
948 	xfs_buf_unlock(mp->m_sb_bp);
949 
950 	xfs_log_unmount_write(mp);
951 }
952 
953 /*
954  * Shut down and release the AIL and Log.
955  *
956  * During unmount, we need to ensure we flush all the dirty metadata objects
957  * from the AIL so that the log is empty before we write the unmount record to
958  * the log. Once this is done, we can tear down the AIL and the log.
959  */
960 void
961 xfs_log_unmount(
962 	struct xfs_mount	*mp)
963 {
964 	xfs_log_quiesce(mp);
965 
966 	xfs_trans_ail_destroy(mp);
967 
968 	xfs_sysfs_del(&mp->m_log->l_kobj);
969 
970 	xlog_dealloc_log(mp->m_log);
971 }
972 
973 void
974 xfs_log_item_init(
975 	struct xfs_mount	*mp,
976 	struct xfs_log_item	*item,
977 	int			type,
978 	const struct xfs_item_ops *ops)
979 {
980 	item->li_mountp = mp;
981 	item->li_ailp = mp->m_ail;
982 	item->li_type = type;
983 	item->li_ops = ops;
984 	item->li_lv = NULL;
985 
986 	INIT_LIST_HEAD(&item->li_ail);
987 	INIT_LIST_HEAD(&item->li_cil);
988 }
989 
990 /*
991  * Wake up processes waiting for log space after we have moved the log tail.
992  */
993 void
994 xfs_log_space_wake(
995 	struct xfs_mount	*mp)
996 {
997 	struct xlog		*log = mp->m_log;
998 	int			free_bytes;
999 
1000 	if (XLOG_FORCED_SHUTDOWN(log))
1001 		return;
1002 
1003 	if (!list_empty_careful(&log->l_write_head.waiters)) {
1004 		ASSERT(!(log->l_flags & XLOG_ACTIVE_RECOVERY));
1005 
1006 		spin_lock(&log->l_write_head.lock);
1007 		free_bytes = xlog_space_left(log, &log->l_write_head.grant);
1008 		xlog_grant_head_wake(log, &log->l_write_head, &free_bytes);
1009 		spin_unlock(&log->l_write_head.lock);
1010 	}
1011 
1012 	if (!list_empty_careful(&log->l_reserve_head.waiters)) {
1013 		ASSERT(!(log->l_flags & XLOG_ACTIVE_RECOVERY));
1014 
1015 		spin_lock(&log->l_reserve_head.lock);
1016 		free_bytes = xlog_space_left(log, &log->l_reserve_head.grant);
1017 		xlog_grant_head_wake(log, &log->l_reserve_head, &free_bytes);
1018 		spin_unlock(&log->l_reserve_head.lock);
1019 	}
1020 }
1021 
1022 /*
1023  * Determine if we have a transaction that has gone to disk that needs to be
1024  * covered. To begin the transition to the idle state firstly the log needs to
1025  * be idle. That means the CIL, the AIL and the iclogs needs to be empty before
1026  * we start attempting to cover the log.
1027  *
1028  * Only if we are then in a state where covering is needed, the caller is
1029  * informed that dummy transactions are required to move the log into the idle
1030  * state.
1031  *
1032  * If there are any items in the AIl or CIL, then we do not want to attempt to
1033  * cover the log as we may be in a situation where there isn't log space
1034  * available to run a dummy transaction and this can lead to deadlocks when the
1035  * tail of the log is pinned by an item that is modified in the CIL.  Hence
1036  * there's no point in running a dummy transaction at this point because we
1037  * can't start trying to idle the log until both the CIL and AIL are empty.
1038  */
1039 static int
1040 xfs_log_need_covered(xfs_mount_t *mp)
1041 {
1042 	struct xlog	*log = mp->m_log;
1043 	int		needed = 0;
1044 
1045 	if (!xfs_fs_writable(mp, SB_FREEZE_WRITE))
1046 		return 0;
1047 
1048 	if (!xlog_cil_empty(log))
1049 		return 0;
1050 
1051 	spin_lock(&log->l_icloglock);
1052 	switch (log->l_covered_state) {
1053 	case XLOG_STATE_COVER_DONE:
1054 	case XLOG_STATE_COVER_DONE2:
1055 	case XLOG_STATE_COVER_IDLE:
1056 		break;
1057 	case XLOG_STATE_COVER_NEED:
1058 	case XLOG_STATE_COVER_NEED2:
1059 		if (xfs_ail_min_lsn(log->l_ailp))
1060 			break;
1061 		if (!xlog_iclogs_empty(log))
1062 			break;
1063 
1064 		needed = 1;
1065 		if (log->l_covered_state == XLOG_STATE_COVER_NEED)
1066 			log->l_covered_state = XLOG_STATE_COVER_DONE;
1067 		else
1068 			log->l_covered_state = XLOG_STATE_COVER_DONE2;
1069 		break;
1070 	default:
1071 		needed = 1;
1072 		break;
1073 	}
1074 	spin_unlock(&log->l_icloglock);
1075 	return needed;
1076 }
1077 
1078 /*
1079  * We may be holding the log iclog lock upon entering this routine.
1080  */
1081 xfs_lsn_t
1082 xlog_assign_tail_lsn_locked(
1083 	struct xfs_mount	*mp)
1084 {
1085 	struct xlog		*log = mp->m_log;
1086 	struct xfs_log_item	*lip;
1087 	xfs_lsn_t		tail_lsn;
1088 
1089 	assert_spin_locked(&mp->m_ail->xa_lock);
1090 
1091 	/*
1092 	 * To make sure we always have a valid LSN for the log tail we keep
1093 	 * track of the last LSN which was committed in log->l_last_sync_lsn,
1094 	 * and use that when the AIL was empty.
1095 	 */
1096 	lip = xfs_ail_min(mp->m_ail);
1097 	if (lip)
1098 		tail_lsn = lip->li_lsn;
1099 	else
1100 		tail_lsn = atomic64_read(&log->l_last_sync_lsn);
1101 	trace_xfs_log_assign_tail_lsn(log, tail_lsn);
1102 	atomic64_set(&log->l_tail_lsn, tail_lsn);
1103 	return tail_lsn;
1104 }
1105 
1106 xfs_lsn_t
1107 xlog_assign_tail_lsn(
1108 	struct xfs_mount	*mp)
1109 {
1110 	xfs_lsn_t		tail_lsn;
1111 
1112 	spin_lock(&mp->m_ail->xa_lock);
1113 	tail_lsn = xlog_assign_tail_lsn_locked(mp);
1114 	spin_unlock(&mp->m_ail->xa_lock);
1115 
1116 	return tail_lsn;
1117 }
1118 
1119 /*
1120  * Return the space in the log between the tail and the head.  The head
1121  * is passed in the cycle/bytes formal parms.  In the special case where
1122  * the reserve head has wrapped passed the tail, this calculation is no
1123  * longer valid.  In this case, just return 0 which means there is no space
1124  * in the log.  This works for all places where this function is called
1125  * with the reserve head.  Of course, if the write head were to ever
1126  * wrap the tail, we should blow up.  Rather than catch this case here,
1127  * we depend on other ASSERTions in other parts of the code.   XXXmiken
1128  *
1129  * This code also handles the case where the reservation head is behind
1130  * the tail.  The details of this case are described below, but the end
1131  * result is that we return the size of the log as the amount of space left.
1132  */
1133 STATIC int
1134 xlog_space_left(
1135 	struct xlog	*log,
1136 	atomic64_t	*head)
1137 {
1138 	int		free_bytes;
1139 	int		tail_bytes;
1140 	int		tail_cycle;
1141 	int		head_cycle;
1142 	int		head_bytes;
1143 
1144 	xlog_crack_grant_head(head, &head_cycle, &head_bytes);
1145 	xlog_crack_atomic_lsn(&log->l_tail_lsn, &tail_cycle, &tail_bytes);
1146 	tail_bytes = BBTOB(tail_bytes);
1147 	if (tail_cycle == head_cycle && head_bytes >= tail_bytes)
1148 		free_bytes = log->l_logsize - (head_bytes - tail_bytes);
1149 	else if (tail_cycle + 1 < head_cycle)
1150 		return 0;
1151 	else if (tail_cycle < head_cycle) {
1152 		ASSERT(tail_cycle == (head_cycle - 1));
1153 		free_bytes = tail_bytes - head_bytes;
1154 	} else {
1155 		/*
1156 		 * The reservation head is behind the tail.
1157 		 * In this case we just want to return the size of the
1158 		 * log as the amount of space left.
1159 		 */
1160 		xfs_alert(log->l_mp, "xlog_space_left: head behind tail");
1161 		xfs_alert(log->l_mp,
1162 			  "  tail_cycle = %d, tail_bytes = %d",
1163 			  tail_cycle, tail_bytes);
1164 		xfs_alert(log->l_mp,
1165 			  "  GH   cycle = %d, GH   bytes = %d",
1166 			  head_cycle, head_bytes);
1167 		ASSERT(0);
1168 		free_bytes = log->l_logsize;
1169 	}
1170 	return free_bytes;
1171 }
1172 
1173 
1174 /*
1175  * Log function which is called when an io completes.
1176  *
1177  * The log manager needs its own routine, in order to control what
1178  * happens with the buffer after the write completes.
1179  */
1180 static void
1181 xlog_iodone(xfs_buf_t *bp)
1182 {
1183 	struct xlog_in_core	*iclog = bp->b_fspriv;
1184 	struct xlog		*l = iclog->ic_log;
1185 	int			aborted = 0;
1186 
1187 	/*
1188 	 * Race to shutdown the filesystem if we see an error or the iclog is in
1189 	 * IOABORT state. The IOABORT state is only set in DEBUG mode to inject
1190 	 * CRC errors into log recovery.
1191 	 */
1192 	if (XFS_TEST_ERROR(bp->b_error, l->l_mp, XFS_ERRTAG_IODONE_IOERR) ||
1193 	    iclog->ic_state & XLOG_STATE_IOABORT) {
1194 		if (iclog->ic_state & XLOG_STATE_IOABORT)
1195 			iclog->ic_state &= ~XLOG_STATE_IOABORT;
1196 
1197 		xfs_buf_ioerror_alert(bp, __func__);
1198 		xfs_buf_stale(bp);
1199 		xfs_force_shutdown(l->l_mp, SHUTDOWN_LOG_IO_ERROR);
1200 		/*
1201 		 * This flag will be propagated to the trans-committed
1202 		 * callback routines to let them know that the log-commit
1203 		 * didn't succeed.
1204 		 */
1205 		aborted = XFS_LI_ABORTED;
1206 	} else if (iclog->ic_state & XLOG_STATE_IOERROR) {
1207 		aborted = XFS_LI_ABORTED;
1208 	}
1209 
1210 	/* log I/O is always issued ASYNC */
1211 	ASSERT(bp->b_flags & XBF_ASYNC);
1212 	xlog_state_done_syncing(iclog, aborted);
1213 
1214 	/*
1215 	 * drop the buffer lock now that we are done. Nothing references
1216 	 * the buffer after this, so an unmount waiting on this lock can now
1217 	 * tear it down safely. As such, it is unsafe to reference the buffer
1218 	 * (bp) after the unlock as we could race with it being freed.
1219 	 */
1220 	xfs_buf_unlock(bp);
1221 }
1222 
1223 /*
1224  * Return size of each in-core log record buffer.
1225  *
1226  * All machines get 8 x 32kB buffers by default, unless tuned otherwise.
1227  *
1228  * If the filesystem blocksize is too large, we may need to choose a
1229  * larger size since the directory code currently logs entire blocks.
1230  */
1231 
1232 STATIC void
1233 xlog_get_iclog_buffer_size(
1234 	struct xfs_mount	*mp,
1235 	struct xlog		*log)
1236 {
1237 	int size;
1238 	int xhdrs;
1239 
1240 	if (mp->m_logbufs <= 0)
1241 		log->l_iclog_bufs = XLOG_MAX_ICLOGS;
1242 	else
1243 		log->l_iclog_bufs = mp->m_logbufs;
1244 
1245 	/*
1246 	 * Buffer size passed in from mount system call.
1247 	 */
1248 	if (mp->m_logbsize > 0) {
1249 		size = log->l_iclog_size = mp->m_logbsize;
1250 		log->l_iclog_size_log = 0;
1251 		while (size != 1) {
1252 			log->l_iclog_size_log++;
1253 			size >>= 1;
1254 		}
1255 
1256 		if (xfs_sb_version_haslogv2(&mp->m_sb)) {
1257 			/* # headers = size / 32k
1258 			 * one header holds cycles from 32k of data
1259 			 */
1260 
1261 			xhdrs = mp->m_logbsize / XLOG_HEADER_CYCLE_SIZE;
1262 			if (mp->m_logbsize % XLOG_HEADER_CYCLE_SIZE)
1263 				xhdrs++;
1264 			log->l_iclog_hsize = xhdrs << BBSHIFT;
1265 			log->l_iclog_heads = xhdrs;
1266 		} else {
1267 			ASSERT(mp->m_logbsize <= XLOG_BIG_RECORD_BSIZE);
1268 			log->l_iclog_hsize = BBSIZE;
1269 			log->l_iclog_heads = 1;
1270 		}
1271 		goto done;
1272 	}
1273 
1274 	/* All machines use 32kB buffers by default. */
1275 	log->l_iclog_size = XLOG_BIG_RECORD_BSIZE;
1276 	log->l_iclog_size_log = XLOG_BIG_RECORD_BSHIFT;
1277 
1278 	/* the default log size is 16k or 32k which is one header sector */
1279 	log->l_iclog_hsize = BBSIZE;
1280 	log->l_iclog_heads = 1;
1281 
1282 done:
1283 	/* are we being asked to make the sizes selected above visible? */
1284 	if (mp->m_logbufs == 0)
1285 		mp->m_logbufs = log->l_iclog_bufs;
1286 	if (mp->m_logbsize == 0)
1287 		mp->m_logbsize = log->l_iclog_size;
1288 }	/* xlog_get_iclog_buffer_size */
1289 
1290 
1291 void
1292 xfs_log_work_queue(
1293 	struct xfs_mount        *mp)
1294 {
1295 	queue_delayed_work(mp->m_sync_workqueue, &mp->m_log->l_work,
1296 				msecs_to_jiffies(xfs_syncd_centisecs * 10));
1297 }
1298 
1299 /*
1300  * Every sync period we need to unpin all items in the AIL and push them to
1301  * disk. If there is nothing dirty, then we might need to cover the log to
1302  * indicate that the filesystem is idle.
1303  */
1304 static void
1305 xfs_log_worker(
1306 	struct work_struct	*work)
1307 {
1308 	struct xlog		*log = container_of(to_delayed_work(work),
1309 						struct xlog, l_work);
1310 	struct xfs_mount	*mp = log->l_mp;
1311 
1312 	/* dgc: errors ignored - not fatal and nowhere to report them */
1313 	if (xfs_log_need_covered(mp)) {
1314 		/*
1315 		 * Dump a transaction into the log that contains no real change.
1316 		 * This is needed to stamp the current tail LSN into the log
1317 		 * during the covering operation.
1318 		 *
1319 		 * We cannot use an inode here for this - that will push dirty
1320 		 * state back up into the VFS and then periodic inode flushing
1321 		 * will prevent log covering from making progress. Hence we
1322 		 * synchronously log the superblock instead to ensure the
1323 		 * superblock is immediately unpinned and can be written back.
1324 		 */
1325 		xfs_sync_sb(mp, true);
1326 	} else
1327 		xfs_log_force(mp, 0);
1328 
1329 	/* start pushing all the metadata that is currently dirty */
1330 	xfs_ail_push_all(mp->m_ail);
1331 
1332 	/* queue us up again */
1333 	xfs_log_work_queue(mp);
1334 }
1335 
1336 /*
1337  * This routine initializes some of the log structure for a given mount point.
1338  * Its primary purpose is to fill in enough, so recovery can occur.  However,
1339  * some other stuff may be filled in too.
1340  */
1341 STATIC struct xlog *
1342 xlog_alloc_log(
1343 	struct xfs_mount	*mp,
1344 	struct xfs_buftarg	*log_target,
1345 	xfs_daddr_t		blk_offset,
1346 	int			num_bblks)
1347 {
1348 	struct xlog		*log;
1349 	xlog_rec_header_t	*head;
1350 	xlog_in_core_t		**iclogp;
1351 	xlog_in_core_t		*iclog, *prev_iclog=NULL;
1352 	xfs_buf_t		*bp;
1353 	int			i;
1354 	int			error = -ENOMEM;
1355 	uint			log2_size = 0;
1356 
1357 	log = kmem_zalloc(sizeof(struct xlog), KM_MAYFAIL);
1358 	if (!log) {
1359 		xfs_warn(mp, "Log allocation failed: No memory!");
1360 		goto out;
1361 	}
1362 
1363 	log->l_mp	   = mp;
1364 	log->l_targ	   = log_target;
1365 	log->l_logsize     = BBTOB(num_bblks);
1366 	log->l_logBBstart  = blk_offset;
1367 	log->l_logBBsize   = num_bblks;
1368 	log->l_covered_state = XLOG_STATE_COVER_IDLE;
1369 	log->l_flags	   |= XLOG_ACTIVE_RECOVERY;
1370 	INIT_DELAYED_WORK(&log->l_work, xfs_log_worker);
1371 
1372 	log->l_prev_block  = -1;
1373 	/* log->l_tail_lsn = 0x100000000LL; cycle = 1; current block = 0 */
1374 	xlog_assign_atomic_lsn(&log->l_tail_lsn, 1, 0);
1375 	xlog_assign_atomic_lsn(&log->l_last_sync_lsn, 1, 0);
1376 	log->l_curr_cycle  = 1;	    /* 0 is bad since this is initial value */
1377 
1378 	xlog_grant_head_init(&log->l_reserve_head);
1379 	xlog_grant_head_init(&log->l_write_head);
1380 
1381 	error = -EFSCORRUPTED;
1382 	if (xfs_sb_version_hassector(&mp->m_sb)) {
1383 	        log2_size = mp->m_sb.sb_logsectlog;
1384 		if (log2_size < BBSHIFT) {
1385 			xfs_warn(mp, "Log sector size too small (0x%x < 0x%x)",
1386 				log2_size, BBSHIFT);
1387 			goto out_free_log;
1388 		}
1389 
1390 	        log2_size -= BBSHIFT;
1391 		if (log2_size > mp->m_sectbb_log) {
1392 			xfs_warn(mp, "Log sector size too large (0x%x > 0x%x)",
1393 				log2_size, mp->m_sectbb_log);
1394 			goto out_free_log;
1395 		}
1396 
1397 		/* for larger sector sizes, must have v2 or external log */
1398 		if (log2_size && log->l_logBBstart > 0 &&
1399 			    !xfs_sb_version_haslogv2(&mp->m_sb)) {
1400 			xfs_warn(mp,
1401 		"log sector size (0x%x) invalid for configuration.",
1402 				log2_size);
1403 			goto out_free_log;
1404 		}
1405 	}
1406 	log->l_sectBBsize = 1 << log2_size;
1407 
1408 	xlog_get_iclog_buffer_size(mp, log);
1409 
1410 	/*
1411 	 * Use a NULL block for the extra log buffer used during splits so that
1412 	 * it will trigger errors if we ever try to do IO on it without first
1413 	 * having set it up properly.
1414 	 */
1415 	error = -ENOMEM;
1416 	bp = xfs_buf_alloc(mp->m_logdev_targp, XFS_BUF_DADDR_NULL,
1417 			   BTOBB(log->l_iclog_size), XBF_NO_IOACCT);
1418 	if (!bp)
1419 		goto out_free_log;
1420 
1421 	/*
1422 	 * The iclogbuf buffer locks are held over IO but we are not going to do
1423 	 * IO yet.  Hence unlock the buffer so that the log IO path can grab it
1424 	 * when appropriately.
1425 	 */
1426 	ASSERT(xfs_buf_islocked(bp));
1427 	xfs_buf_unlock(bp);
1428 
1429 	/* use high priority wq for log I/O completion */
1430 	bp->b_ioend_wq = mp->m_log_workqueue;
1431 	bp->b_iodone = xlog_iodone;
1432 	log->l_xbuf = bp;
1433 
1434 	spin_lock_init(&log->l_icloglock);
1435 	init_waitqueue_head(&log->l_flush_wait);
1436 
1437 	iclogp = &log->l_iclog;
1438 	/*
1439 	 * The amount of memory to allocate for the iclog structure is
1440 	 * rather funky due to the way the structure is defined.  It is
1441 	 * done this way so that we can use different sizes for machines
1442 	 * with different amounts of memory.  See the definition of
1443 	 * xlog_in_core_t in xfs_log_priv.h for details.
1444 	 */
1445 	ASSERT(log->l_iclog_size >= 4096);
1446 	for (i=0; i < log->l_iclog_bufs; i++) {
1447 		*iclogp = kmem_zalloc(sizeof(xlog_in_core_t), KM_MAYFAIL);
1448 		if (!*iclogp)
1449 			goto out_free_iclog;
1450 
1451 		iclog = *iclogp;
1452 		iclog->ic_prev = prev_iclog;
1453 		prev_iclog = iclog;
1454 
1455 		bp = xfs_buf_get_uncached(mp->m_logdev_targp,
1456 					  BTOBB(log->l_iclog_size),
1457 					  XBF_NO_IOACCT);
1458 		if (!bp)
1459 			goto out_free_iclog;
1460 
1461 		ASSERT(xfs_buf_islocked(bp));
1462 		xfs_buf_unlock(bp);
1463 
1464 		/* use high priority wq for log I/O completion */
1465 		bp->b_ioend_wq = mp->m_log_workqueue;
1466 		bp->b_iodone = xlog_iodone;
1467 		iclog->ic_bp = bp;
1468 		iclog->ic_data = bp->b_addr;
1469 #ifdef DEBUG
1470 		log->l_iclog_bak[i] = &iclog->ic_header;
1471 #endif
1472 		head = &iclog->ic_header;
1473 		memset(head, 0, sizeof(xlog_rec_header_t));
1474 		head->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
1475 		head->h_version = cpu_to_be32(
1476 			xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);
1477 		head->h_size = cpu_to_be32(log->l_iclog_size);
1478 		/* new fields */
1479 		head->h_fmt = cpu_to_be32(XLOG_FMT);
1480 		memcpy(&head->h_fs_uuid, &mp->m_sb.sb_uuid, sizeof(uuid_t));
1481 
1482 		iclog->ic_size = BBTOB(bp->b_length) - log->l_iclog_hsize;
1483 		iclog->ic_state = XLOG_STATE_ACTIVE;
1484 		iclog->ic_log = log;
1485 		atomic_set(&iclog->ic_refcnt, 0);
1486 		spin_lock_init(&iclog->ic_callback_lock);
1487 		iclog->ic_callback_tail = &(iclog->ic_callback);
1488 		iclog->ic_datap = (char *)iclog->ic_data + log->l_iclog_hsize;
1489 
1490 		init_waitqueue_head(&iclog->ic_force_wait);
1491 		init_waitqueue_head(&iclog->ic_write_wait);
1492 
1493 		iclogp = &iclog->ic_next;
1494 	}
1495 	*iclogp = log->l_iclog;			/* complete ring */
1496 	log->l_iclog->ic_prev = prev_iclog;	/* re-write 1st prev ptr */
1497 
1498 	error = xlog_cil_init(log);
1499 	if (error)
1500 		goto out_free_iclog;
1501 	return log;
1502 
1503 out_free_iclog:
1504 	for (iclog = log->l_iclog; iclog; iclog = prev_iclog) {
1505 		prev_iclog = iclog->ic_next;
1506 		if (iclog->ic_bp)
1507 			xfs_buf_free(iclog->ic_bp);
1508 		kmem_free(iclog);
1509 	}
1510 	spinlock_destroy(&log->l_icloglock);
1511 	xfs_buf_free(log->l_xbuf);
1512 out_free_log:
1513 	kmem_free(log);
1514 out:
1515 	return ERR_PTR(error);
1516 }	/* xlog_alloc_log */
1517 
1518 
1519 /*
1520  * Write out the commit record of a transaction associated with the given
1521  * ticket.  Return the lsn of the commit record.
1522  */
1523 STATIC int
1524 xlog_commit_record(
1525 	struct xlog		*log,
1526 	struct xlog_ticket	*ticket,
1527 	struct xlog_in_core	**iclog,
1528 	xfs_lsn_t		*commitlsnp)
1529 {
1530 	struct xfs_mount *mp = log->l_mp;
1531 	int	error;
1532 	struct xfs_log_iovec reg = {
1533 		.i_addr = NULL,
1534 		.i_len = 0,
1535 		.i_type = XLOG_REG_TYPE_COMMIT,
1536 	};
1537 	struct xfs_log_vec vec = {
1538 		.lv_niovecs = 1,
1539 		.lv_iovecp = &reg,
1540 	};
1541 
1542 	ASSERT_ALWAYS(iclog);
1543 	error = xlog_write(log, &vec, ticket, commitlsnp, iclog,
1544 					XLOG_COMMIT_TRANS);
1545 	if (error)
1546 		xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
1547 	return error;
1548 }
1549 
1550 /*
1551  * Push on the buffer cache code if we ever use more than 75% of the on-disk
1552  * log space.  This code pushes on the lsn which would supposedly free up
1553  * the 25% which we want to leave free.  We may need to adopt a policy which
1554  * pushes on an lsn which is further along in the log once we reach the high
1555  * water mark.  In this manner, we would be creating a low water mark.
1556  */
1557 STATIC void
1558 xlog_grant_push_ail(
1559 	struct xlog	*log,
1560 	int		need_bytes)
1561 {
1562 	xfs_lsn_t	threshold_lsn = 0;
1563 	xfs_lsn_t	last_sync_lsn;
1564 	int		free_blocks;
1565 	int		free_bytes;
1566 	int		threshold_block;
1567 	int		threshold_cycle;
1568 	int		free_threshold;
1569 
1570 	ASSERT(BTOBB(need_bytes) < log->l_logBBsize);
1571 
1572 	free_bytes = xlog_space_left(log, &log->l_reserve_head.grant);
1573 	free_blocks = BTOBBT(free_bytes);
1574 
1575 	/*
1576 	 * Set the threshold for the minimum number of free blocks in the
1577 	 * log to the maximum of what the caller needs, one quarter of the
1578 	 * log, and 256 blocks.
1579 	 */
1580 	free_threshold = BTOBB(need_bytes);
1581 	free_threshold = MAX(free_threshold, (log->l_logBBsize >> 2));
1582 	free_threshold = MAX(free_threshold, 256);
1583 	if (free_blocks >= free_threshold)
1584 		return;
1585 
1586 	xlog_crack_atomic_lsn(&log->l_tail_lsn, &threshold_cycle,
1587 						&threshold_block);
1588 	threshold_block += free_threshold;
1589 	if (threshold_block >= log->l_logBBsize) {
1590 		threshold_block -= log->l_logBBsize;
1591 		threshold_cycle += 1;
1592 	}
1593 	threshold_lsn = xlog_assign_lsn(threshold_cycle,
1594 					threshold_block);
1595 	/*
1596 	 * Don't pass in an lsn greater than the lsn of the last
1597 	 * log record known to be on disk. Use a snapshot of the last sync lsn
1598 	 * so that it doesn't change between the compare and the set.
1599 	 */
1600 	last_sync_lsn = atomic64_read(&log->l_last_sync_lsn);
1601 	if (XFS_LSN_CMP(threshold_lsn, last_sync_lsn) > 0)
1602 		threshold_lsn = last_sync_lsn;
1603 
1604 	/*
1605 	 * Get the transaction layer to kick the dirty buffers out to
1606 	 * disk asynchronously. No point in trying to do this if
1607 	 * the filesystem is shutting down.
1608 	 */
1609 	if (!XLOG_FORCED_SHUTDOWN(log))
1610 		xfs_ail_push(log->l_ailp, threshold_lsn);
1611 }
1612 
1613 /*
1614  * Stamp cycle number in every block
1615  */
1616 STATIC void
1617 xlog_pack_data(
1618 	struct xlog		*log,
1619 	struct xlog_in_core	*iclog,
1620 	int			roundoff)
1621 {
1622 	int			i, j, k;
1623 	int			size = iclog->ic_offset + roundoff;
1624 	__be32			cycle_lsn;
1625 	char			*dp;
1626 
1627 	cycle_lsn = CYCLE_LSN_DISK(iclog->ic_header.h_lsn);
1628 
1629 	dp = iclog->ic_datap;
1630 	for (i = 0; i < BTOBB(size); i++) {
1631 		if (i >= (XLOG_HEADER_CYCLE_SIZE / BBSIZE))
1632 			break;
1633 		iclog->ic_header.h_cycle_data[i] = *(__be32 *)dp;
1634 		*(__be32 *)dp = cycle_lsn;
1635 		dp += BBSIZE;
1636 	}
1637 
1638 	if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
1639 		xlog_in_core_2_t *xhdr = iclog->ic_data;
1640 
1641 		for ( ; i < BTOBB(size); i++) {
1642 			j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
1643 			k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
1644 			xhdr[j].hic_xheader.xh_cycle_data[k] = *(__be32 *)dp;
1645 			*(__be32 *)dp = cycle_lsn;
1646 			dp += BBSIZE;
1647 		}
1648 
1649 		for (i = 1; i < log->l_iclog_heads; i++)
1650 			xhdr[i].hic_xheader.xh_cycle = cycle_lsn;
1651 	}
1652 }
1653 
1654 /*
1655  * Calculate the checksum for a log buffer.
1656  *
1657  * This is a little more complicated than it should be because the various
1658  * headers and the actual data are non-contiguous.
1659  */
1660 __le32
1661 xlog_cksum(
1662 	struct xlog		*log,
1663 	struct xlog_rec_header	*rhead,
1664 	char			*dp,
1665 	int			size)
1666 {
1667 	uint32_t		crc;
1668 
1669 	/* first generate the crc for the record header ... */
1670 	crc = xfs_start_cksum_update((char *)rhead,
1671 			      sizeof(struct xlog_rec_header),
1672 			      offsetof(struct xlog_rec_header, h_crc));
1673 
1674 	/* ... then for additional cycle data for v2 logs ... */
1675 	if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
1676 		union xlog_in_core2 *xhdr = (union xlog_in_core2 *)rhead;
1677 		int		i;
1678 		int		xheads;
1679 
1680 		xheads = size / XLOG_HEADER_CYCLE_SIZE;
1681 		if (size % XLOG_HEADER_CYCLE_SIZE)
1682 			xheads++;
1683 
1684 		for (i = 1; i < xheads; i++) {
1685 			crc = crc32c(crc, &xhdr[i].hic_xheader,
1686 				     sizeof(struct xlog_rec_ext_header));
1687 		}
1688 	}
1689 
1690 	/* ... and finally for the payload */
1691 	crc = crc32c(crc, dp, size);
1692 
1693 	return xfs_end_cksum(crc);
1694 }
1695 
1696 /*
1697  * The bdstrat callback function for log bufs. This gives us a central
1698  * place to trap bufs in case we get hit by a log I/O error and need to
1699  * shutdown. Actually, in practice, even when we didn't get a log error,
1700  * we transition the iclogs to IOERROR state *after* flushing all existing
1701  * iclogs to disk. This is because we don't want anymore new transactions to be
1702  * started or completed afterwards.
1703  *
1704  * We lock the iclogbufs here so that we can serialise against IO completion
1705  * during unmount. We might be processing a shutdown triggered during unmount,
1706  * and that can occur asynchronously to the unmount thread, and hence we need to
1707  * ensure that completes before tearing down the iclogbufs. Hence we need to
1708  * hold the buffer lock across the log IO to acheive that.
1709  */
1710 STATIC int
1711 xlog_bdstrat(
1712 	struct xfs_buf		*bp)
1713 {
1714 	struct xlog_in_core	*iclog = bp->b_fspriv;
1715 
1716 	xfs_buf_lock(bp);
1717 	if (iclog->ic_state & XLOG_STATE_IOERROR) {
1718 		xfs_buf_ioerror(bp, -EIO);
1719 		xfs_buf_stale(bp);
1720 		xfs_buf_ioend(bp);
1721 		/*
1722 		 * It would seem logical to return EIO here, but we rely on
1723 		 * the log state machine to propagate I/O errors instead of
1724 		 * doing it here. Similarly, IO completion will unlock the
1725 		 * buffer, so we don't do it here.
1726 		 */
1727 		return 0;
1728 	}
1729 
1730 	xfs_buf_submit(bp);
1731 	return 0;
1732 }
1733 
1734 /*
1735  * Flush out the in-core log (iclog) to the on-disk log in an asynchronous
1736  * fashion.  Previously, we should have moved the current iclog
1737  * ptr in the log to point to the next available iclog.  This allows further
1738  * write to continue while this code syncs out an iclog ready to go.
1739  * Before an in-core log can be written out, the data section must be scanned
1740  * to save away the 1st word of each BBSIZE block into the header.  We replace
1741  * it with the current cycle count.  Each BBSIZE block is tagged with the
1742  * cycle count because there in an implicit assumption that drives will
1743  * guarantee that entire 512 byte blocks get written at once.  In other words,
1744  * we can't have part of a 512 byte block written and part not written.  By
1745  * tagging each block, we will know which blocks are valid when recovering
1746  * after an unclean shutdown.
1747  *
1748  * This routine is single threaded on the iclog.  No other thread can be in
1749  * this routine with the same iclog.  Changing contents of iclog can there-
1750  * fore be done without grabbing the state machine lock.  Updating the global
1751  * log will require grabbing the lock though.
1752  *
1753  * The entire log manager uses a logical block numbering scheme.  Only
1754  * log_sync (and then only bwrite()) know about the fact that the log may
1755  * not start with block zero on a given device.  The log block start offset
1756  * is added immediately before calling bwrite().
1757  */
1758 
1759 STATIC int
1760 xlog_sync(
1761 	struct xlog		*log,
1762 	struct xlog_in_core	*iclog)
1763 {
1764 	xfs_buf_t	*bp;
1765 	int		i;
1766 	uint		count;		/* byte count of bwrite */
1767 	uint		count_init;	/* initial count before roundup */
1768 	int		roundoff;       /* roundoff to BB or stripe */
1769 	int		split = 0;	/* split write into two regions */
1770 	int		error;
1771 	int		v2 = xfs_sb_version_haslogv2(&log->l_mp->m_sb);
1772 	int		size;
1773 
1774 	XFS_STATS_INC(log->l_mp, xs_log_writes);
1775 	ASSERT(atomic_read(&iclog->ic_refcnt) == 0);
1776 
1777 	/* Add for LR header */
1778 	count_init = log->l_iclog_hsize + iclog->ic_offset;
1779 
1780 	/* Round out the log write size */
1781 	if (v2 && log->l_mp->m_sb.sb_logsunit > 1) {
1782 		/* we have a v2 stripe unit to use */
1783 		count = XLOG_LSUNITTOB(log, XLOG_BTOLSUNIT(log, count_init));
1784 	} else {
1785 		count = BBTOB(BTOBB(count_init));
1786 	}
1787 	roundoff = count - count_init;
1788 	ASSERT(roundoff >= 0);
1789 	ASSERT((v2 && log->l_mp->m_sb.sb_logsunit > 1 &&
1790                 roundoff < log->l_mp->m_sb.sb_logsunit)
1791 		||
1792 		(log->l_mp->m_sb.sb_logsunit <= 1 &&
1793 		 roundoff < BBTOB(1)));
1794 
1795 	/* move grant heads by roundoff in sync */
1796 	xlog_grant_add_space(log, &log->l_reserve_head.grant, roundoff);
1797 	xlog_grant_add_space(log, &log->l_write_head.grant, roundoff);
1798 
1799 	/* put cycle number in every block */
1800 	xlog_pack_data(log, iclog, roundoff);
1801 
1802 	/* real byte length */
1803 	size = iclog->ic_offset;
1804 	if (v2)
1805 		size += roundoff;
1806 	iclog->ic_header.h_len = cpu_to_be32(size);
1807 
1808 	bp = iclog->ic_bp;
1809 	XFS_BUF_SET_ADDR(bp, BLOCK_LSN(be64_to_cpu(iclog->ic_header.h_lsn)));
1810 
1811 	XFS_STATS_ADD(log->l_mp, xs_log_blocks, BTOBB(count));
1812 
1813 	/* Do we need to split this write into 2 parts? */
1814 	if (XFS_BUF_ADDR(bp) + BTOBB(count) > log->l_logBBsize) {
1815 		char		*dptr;
1816 
1817 		split = count - (BBTOB(log->l_logBBsize - XFS_BUF_ADDR(bp)));
1818 		count = BBTOB(log->l_logBBsize - XFS_BUF_ADDR(bp));
1819 		iclog->ic_bwritecnt = 2;
1820 
1821 		/*
1822 		 * Bump the cycle numbers at the start of each block in the
1823 		 * part of the iclog that ends up in the buffer that gets
1824 		 * written to the start of the log.
1825 		 *
1826 		 * Watch out for the header magic number case, though.
1827 		 */
1828 		dptr = (char *)&iclog->ic_header + count;
1829 		for (i = 0; i < split; i += BBSIZE) {
1830 			uint32_t cycle = be32_to_cpu(*(__be32 *)dptr);
1831 			if (++cycle == XLOG_HEADER_MAGIC_NUM)
1832 				cycle++;
1833 			*(__be32 *)dptr = cpu_to_be32(cycle);
1834 
1835 			dptr += BBSIZE;
1836 		}
1837 	} else {
1838 		iclog->ic_bwritecnt = 1;
1839 	}
1840 
1841 	/* calculcate the checksum */
1842 	iclog->ic_header.h_crc = xlog_cksum(log, &iclog->ic_header,
1843 					    iclog->ic_datap, size);
1844 	/*
1845 	 * Intentionally corrupt the log record CRC based on the error injection
1846 	 * frequency, if defined. This facilitates testing log recovery in the
1847 	 * event of torn writes. Hence, set the IOABORT state to abort the log
1848 	 * write on I/O completion and shutdown the fs. The subsequent mount
1849 	 * detects the bad CRC and attempts to recover.
1850 	 */
1851 	if (XFS_TEST_ERROR(false, log->l_mp, XFS_ERRTAG_LOG_BAD_CRC)) {
1852 		iclog->ic_header.h_crc &= cpu_to_le32(0xAAAAAAAA);
1853 		iclog->ic_state |= XLOG_STATE_IOABORT;
1854 		xfs_warn(log->l_mp,
1855 	"Intentionally corrupted log record at LSN 0x%llx. Shutdown imminent.",
1856 			 be64_to_cpu(iclog->ic_header.h_lsn));
1857 	}
1858 
1859 	bp->b_io_length = BTOBB(count);
1860 	bp->b_fspriv = iclog;
1861 	bp->b_flags &= ~XBF_FLUSH;
1862 	bp->b_flags |= (XBF_ASYNC | XBF_SYNCIO | XBF_WRITE | XBF_FUA);
1863 
1864 	/*
1865 	 * Flush the data device before flushing the log to make sure all meta
1866 	 * data written back from the AIL actually made it to disk before
1867 	 * stamping the new log tail LSN into the log buffer.  For an external
1868 	 * log we need to issue the flush explicitly, and unfortunately
1869 	 * synchronously here; for an internal log we can simply use the block
1870 	 * layer state machine for preflushes.
1871 	 */
1872 	if (log->l_mp->m_logdev_targp != log->l_mp->m_ddev_targp)
1873 		xfs_blkdev_issue_flush(log->l_mp->m_ddev_targp);
1874 	else
1875 		bp->b_flags |= XBF_FLUSH;
1876 
1877 	ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1);
1878 	ASSERT(XFS_BUF_ADDR(bp) + BTOBB(count) <= log->l_logBBsize);
1879 
1880 	xlog_verify_iclog(log, iclog, count, true);
1881 
1882 	/* account for log which doesn't start at block #0 */
1883 	XFS_BUF_SET_ADDR(bp, XFS_BUF_ADDR(bp) + log->l_logBBstart);
1884 
1885 	/*
1886 	 * Don't call xfs_bwrite here. We do log-syncs even when the filesystem
1887 	 * is shutting down.
1888 	 */
1889 	error = xlog_bdstrat(bp);
1890 	if (error) {
1891 		xfs_buf_ioerror_alert(bp, "xlog_sync");
1892 		return error;
1893 	}
1894 	if (split) {
1895 		bp = iclog->ic_log->l_xbuf;
1896 		XFS_BUF_SET_ADDR(bp, 0);	     /* logical 0 */
1897 		xfs_buf_associate_memory(bp,
1898 				(char *)&iclog->ic_header + count, split);
1899 		bp->b_fspriv = iclog;
1900 		bp->b_flags &= ~XBF_FLUSH;
1901 		bp->b_flags |= (XBF_ASYNC | XBF_SYNCIO | XBF_WRITE | XBF_FUA);
1902 
1903 		ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1);
1904 		ASSERT(XFS_BUF_ADDR(bp) + BTOBB(count) <= log->l_logBBsize);
1905 
1906 		/* account for internal log which doesn't start at block #0 */
1907 		XFS_BUF_SET_ADDR(bp, XFS_BUF_ADDR(bp) + log->l_logBBstart);
1908 		error = xlog_bdstrat(bp);
1909 		if (error) {
1910 			xfs_buf_ioerror_alert(bp, "xlog_sync (split)");
1911 			return error;
1912 		}
1913 	}
1914 	return 0;
1915 }	/* xlog_sync */
1916 
1917 /*
1918  * Deallocate a log structure
1919  */
1920 STATIC void
1921 xlog_dealloc_log(
1922 	struct xlog	*log)
1923 {
1924 	xlog_in_core_t	*iclog, *next_iclog;
1925 	int		i;
1926 
1927 	xlog_cil_destroy(log);
1928 
1929 	/*
1930 	 * Cycle all the iclogbuf locks to make sure all log IO completion
1931 	 * is done before we tear down these buffers.
1932 	 */
1933 	iclog = log->l_iclog;
1934 	for (i = 0; i < log->l_iclog_bufs; i++) {
1935 		xfs_buf_lock(iclog->ic_bp);
1936 		xfs_buf_unlock(iclog->ic_bp);
1937 		iclog = iclog->ic_next;
1938 	}
1939 
1940 	/*
1941 	 * Always need to ensure that the extra buffer does not point to memory
1942 	 * owned by another log buffer before we free it. Also, cycle the lock
1943 	 * first to ensure we've completed IO on it.
1944 	 */
1945 	xfs_buf_lock(log->l_xbuf);
1946 	xfs_buf_unlock(log->l_xbuf);
1947 	xfs_buf_set_empty(log->l_xbuf, BTOBB(log->l_iclog_size));
1948 	xfs_buf_free(log->l_xbuf);
1949 
1950 	iclog = log->l_iclog;
1951 	for (i = 0; i < log->l_iclog_bufs; i++) {
1952 		xfs_buf_free(iclog->ic_bp);
1953 		next_iclog = iclog->ic_next;
1954 		kmem_free(iclog);
1955 		iclog = next_iclog;
1956 	}
1957 	spinlock_destroy(&log->l_icloglock);
1958 
1959 	log->l_mp->m_log = NULL;
1960 	kmem_free(log);
1961 }	/* xlog_dealloc_log */
1962 
1963 /*
1964  * Update counters atomically now that memcpy is done.
1965  */
1966 /* ARGSUSED */
1967 static inline void
1968 xlog_state_finish_copy(
1969 	struct xlog		*log,
1970 	struct xlog_in_core	*iclog,
1971 	int			record_cnt,
1972 	int			copy_bytes)
1973 {
1974 	spin_lock(&log->l_icloglock);
1975 
1976 	be32_add_cpu(&iclog->ic_header.h_num_logops, record_cnt);
1977 	iclog->ic_offset += copy_bytes;
1978 
1979 	spin_unlock(&log->l_icloglock);
1980 }	/* xlog_state_finish_copy */
1981 
1982 
1983 
1984 
1985 /*
1986  * print out info relating to regions written which consume
1987  * the reservation
1988  */
1989 void
1990 xlog_print_tic_res(
1991 	struct xfs_mount	*mp,
1992 	struct xlog_ticket	*ticket)
1993 {
1994 	uint i;
1995 	uint ophdr_spc = ticket->t_res_num_ophdrs * (uint)sizeof(xlog_op_header_t);
1996 
1997 	/* match with XLOG_REG_TYPE_* in xfs_log.h */
1998 #define REG_TYPE_STR(type, str)	[XLOG_REG_TYPE_##type] = str
1999 	static char *res_type_str[XLOG_REG_TYPE_MAX + 1] = {
2000 	    REG_TYPE_STR(BFORMAT, "bformat"),
2001 	    REG_TYPE_STR(BCHUNK, "bchunk"),
2002 	    REG_TYPE_STR(EFI_FORMAT, "efi_format"),
2003 	    REG_TYPE_STR(EFD_FORMAT, "efd_format"),
2004 	    REG_TYPE_STR(IFORMAT, "iformat"),
2005 	    REG_TYPE_STR(ICORE, "icore"),
2006 	    REG_TYPE_STR(IEXT, "iext"),
2007 	    REG_TYPE_STR(IBROOT, "ibroot"),
2008 	    REG_TYPE_STR(ILOCAL, "ilocal"),
2009 	    REG_TYPE_STR(IATTR_EXT, "iattr_ext"),
2010 	    REG_TYPE_STR(IATTR_BROOT, "iattr_broot"),
2011 	    REG_TYPE_STR(IATTR_LOCAL, "iattr_local"),
2012 	    REG_TYPE_STR(QFORMAT, "qformat"),
2013 	    REG_TYPE_STR(DQUOT, "dquot"),
2014 	    REG_TYPE_STR(QUOTAOFF, "quotaoff"),
2015 	    REG_TYPE_STR(LRHEADER, "LR header"),
2016 	    REG_TYPE_STR(UNMOUNT, "unmount"),
2017 	    REG_TYPE_STR(COMMIT, "commit"),
2018 	    REG_TYPE_STR(TRANSHDR, "trans header"),
2019 	    REG_TYPE_STR(ICREATE, "inode create")
2020 	};
2021 #undef REG_TYPE_STR
2022 
2023 	xfs_warn(mp, "ticket reservation summary:");
2024 	xfs_warn(mp, "  unit res    = %d bytes",
2025 		 ticket->t_unit_res);
2026 	xfs_warn(mp, "  current res = %d bytes",
2027 		 ticket->t_curr_res);
2028 	xfs_warn(mp, "  total reg   = %u bytes (o/flow = %u bytes)",
2029 		 ticket->t_res_arr_sum, ticket->t_res_o_flow);
2030 	xfs_warn(mp, "  ophdrs      = %u (ophdr space = %u bytes)",
2031 		 ticket->t_res_num_ophdrs, ophdr_spc);
2032 	xfs_warn(mp, "  ophdr + reg = %u bytes",
2033 		 ticket->t_res_arr_sum + ticket->t_res_o_flow + ophdr_spc);
2034 	xfs_warn(mp, "  num regions = %u",
2035 		 ticket->t_res_num);
2036 
2037 	for (i = 0; i < ticket->t_res_num; i++) {
2038 		uint r_type = ticket->t_res_arr[i].r_type;
2039 		xfs_warn(mp, "region[%u]: %s - %u bytes", i,
2040 			    ((r_type <= 0 || r_type > XLOG_REG_TYPE_MAX) ?
2041 			    "bad-rtype" : res_type_str[r_type]),
2042 			    ticket->t_res_arr[i].r_len);
2043 	}
2044 }
2045 
2046 /*
2047  * Print a summary of the transaction.
2048  */
2049 void
2050 xlog_print_trans(
2051 	struct xfs_trans		*tp)
2052 {
2053 	struct xfs_mount		*mp = tp->t_mountp;
2054 	struct xfs_log_item_desc	*lidp;
2055 
2056 	/* dump core transaction and ticket info */
2057 	xfs_warn(mp, "transaction summary:");
2058 	xfs_warn(mp, "  flags	= 0x%x", tp->t_flags);
2059 
2060 	xlog_print_tic_res(mp, tp->t_ticket);
2061 
2062 	/* dump each log item */
2063 	list_for_each_entry(lidp, &tp->t_items, lid_trans) {
2064 		struct xfs_log_item	*lip = lidp->lid_item;
2065 		struct xfs_log_vec	*lv = lip->li_lv;
2066 		struct xfs_log_iovec	*vec;
2067 		int			i;
2068 
2069 		xfs_warn(mp, "log item: ");
2070 		xfs_warn(mp, "  type	= 0x%x", lip->li_type);
2071 		xfs_warn(mp, "  flags	= 0x%x", lip->li_flags);
2072 		if (!lv)
2073 			continue;
2074 		xfs_warn(mp, "  niovecs	= %d", lv->lv_niovecs);
2075 		xfs_warn(mp, "  size	= %d", lv->lv_size);
2076 		xfs_warn(mp, "  bytes	= %d", lv->lv_bytes);
2077 		xfs_warn(mp, "  buf len	= %d", lv->lv_buf_len);
2078 
2079 		/* dump each iovec for the log item */
2080 		vec = lv->lv_iovecp;
2081 		for (i = 0; i < lv->lv_niovecs; i++) {
2082 			int dumplen = min(vec->i_len, 32);
2083 
2084 			xfs_warn(mp, "  iovec[%d]", i);
2085 			xfs_warn(mp, "    type	= 0x%x", vec->i_type);
2086 			xfs_warn(mp, "    len	= %d", vec->i_len);
2087 			xfs_warn(mp, "    first %d bytes of iovec[%d]:", dumplen, i);
2088 			xfs_hex_dump(vec->i_addr, dumplen);
2089 
2090 			vec++;
2091 		}
2092 	}
2093 }
2094 
2095 /*
2096  * Calculate the potential space needed by the log vector.  Each region gets
2097  * its own xlog_op_header_t and may need to be double word aligned.
2098  */
2099 static int
2100 xlog_write_calc_vec_length(
2101 	struct xlog_ticket	*ticket,
2102 	struct xfs_log_vec	*log_vector)
2103 {
2104 	struct xfs_log_vec	*lv;
2105 	int			headers = 0;
2106 	int			len = 0;
2107 	int			i;
2108 
2109 	/* acct for start rec of xact */
2110 	if (ticket->t_flags & XLOG_TIC_INITED)
2111 		headers++;
2112 
2113 	for (lv = log_vector; lv; lv = lv->lv_next) {
2114 		/* we don't write ordered log vectors */
2115 		if (lv->lv_buf_len == XFS_LOG_VEC_ORDERED)
2116 			continue;
2117 
2118 		headers += lv->lv_niovecs;
2119 
2120 		for (i = 0; i < lv->lv_niovecs; i++) {
2121 			struct xfs_log_iovec	*vecp = &lv->lv_iovecp[i];
2122 
2123 			len += vecp->i_len;
2124 			xlog_tic_add_region(ticket, vecp->i_len, vecp->i_type);
2125 		}
2126 	}
2127 
2128 	ticket->t_res_num_ophdrs += headers;
2129 	len += headers * sizeof(struct xlog_op_header);
2130 
2131 	return len;
2132 }
2133 
2134 /*
2135  * If first write for transaction, insert start record  We can't be trying to
2136  * commit if we are inited.  We can't have any "partial_copy" if we are inited.
2137  */
2138 static int
2139 xlog_write_start_rec(
2140 	struct xlog_op_header	*ophdr,
2141 	struct xlog_ticket	*ticket)
2142 {
2143 	if (!(ticket->t_flags & XLOG_TIC_INITED))
2144 		return 0;
2145 
2146 	ophdr->oh_tid	= cpu_to_be32(ticket->t_tid);
2147 	ophdr->oh_clientid = ticket->t_clientid;
2148 	ophdr->oh_len = 0;
2149 	ophdr->oh_flags = XLOG_START_TRANS;
2150 	ophdr->oh_res2 = 0;
2151 
2152 	ticket->t_flags &= ~XLOG_TIC_INITED;
2153 
2154 	return sizeof(struct xlog_op_header);
2155 }
2156 
2157 static xlog_op_header_t *
2158 xlog_write_setup_ophdr(
2159 	struct xlog		*log,
2160 	struct xlog_op_header	*ophdr,
2161 	struct xlog_ticket	*ticket,
2162 	uint			flags)
2163 {
2164 	ophdr->oh_tid = cpu_to_be32(ticket->t_tid);
2165 	ophdr->oh_clientid = ticket->t_clientid;
2166 	ophdr->oh_res2 = 0;
2167 
2168 	/* are we copying a commit or unmount record? */
2169 	ophdr->oh_flags = flags;
2170 
2171 	/*
2172 	 * We've seen logs corrupted with bad transaction client ids.  This
2173 	 * makes sure that XFS doesn't generate them on.  Turn this into an EIO
2174 	 * and shut down the filesystem.
2175 	 */
2176 	switch (ophdr->oh_clientid)  {
2177 	case XFS_TRANSACTION:
2178 	case XFS_VOLUME:
2179 	case XFS_LOG:
2180 		break;
2181 	default:
2182 		xfs_warn(log->l_mp,
2183 			"Bad XFS transaction clientid 0x%x in ticket 0x%p",
2184 			ophdr->oh_clientid, ticket);
2185 		return NULL;
2186 	}
2187 
2188 	return ophdr;
2189 }
2190 
2191 /*
2192  * Set up the parameters of the region copy into the log. This has
2193  * to handle region write split across multiple log buffers - this
2194  * state is kept external to this function so that this code can
2195  * be written in an obvious, self documenting manner.
2196  */
2197 static int
2198 xlog_write_setup_copy(
2199 	struct xlog_ticket	*ticket,
2200 	struct xlog_op_header	*ophdr,
2201 	int			space_available,
2202 	int			space_required,
2203 	int			*copy_off,
2204 	int			*copy_len,
2205 	int			*last_was_partial_copy,
2206 	int			*bytes_consumed)
2207 {
2208 	int			still_to_copy;
2209 
2210 	still_to_copy = space_required - *bytes_consumed;
2211 	*copy_off = *bytes_consumed;
2212 
2213 	if (still_to_copy <= space_available) {
2214 		/* write of region completes here */
2215 		*copy_len = still_to_copy;
2216 		ophdr->oh_len = cpu_to_be32(*copy_len);
2217 		if (*last_was_partial_copy)
2218 			ophdr->oh_flags |= (XLOG_END_TRANS|XLOG_WAS_CONT_TRANS);
2219 		*last_was_partial_copy = 0;
2220 		*bytes_consumed = 0;
2221 		return 0;
2222 	}
2223 
2224 	/* partial write of region, needs extra log op header reservation */
2225 	*copy_len = space_available;
2226 	ophdr->oh_len = cpu_to_be32(*copy_len);
2227 	ophdr->oh_flags |= XLOG_CONTINUE_TRANS;
2228 	if (*last_was_partial_copy)
2229 		ophdr->oh_flags |= XLOG_WAS_CONT_TRANS;
2230 	*bytes_consumed += *copy_len;
2231 	(*last_was_partial_copy)++;
2232 
2233 	/* account for new log op header */
2234 	ticket->t_curr_res -= sizeof(struct xlog_op_header);
2235 	ticket->t_res_num_ophdrs++;
2236 
2237 	return sizeof(struct xlog_op_header);
2238 }
2239 
2240 static int
2241 xlog_write_copy_finish(
2242 	struct xlog		*log,
2243 	struct xlog_in_core	*iclog,
2244 	uint			flags,
2245 	int			*record_cnt,
2246 	int			*data_cnt,
2247 	int			*partial_copy,
2248 	int			*partial_copy_len,
2249 	int			log_offset,
2250 	struct xlog_in_core	**commit_iclog)
2251 {
2252 	if (*partial_copy) {
2253 		/*
2254 		 * This iclog has already been marked WANT_SYNC by
2255 		 * xlog_state_get_iclog_space.
2256 		 */
2257 		xlog_state_finish_copy(log, iclog, *record_cnt, *data_cnt);
2258 		*record_cnt = 0;
2259 		*data_cnt = 0;
2260 		return xlog_state_release_iclog(log, iclog);
2261 	}
2262 
2263 	*partial_copy = 0;
2264 	*partial_copy_len = 0;
2265 
2266 	if (iclog->ic_size - log_offset <= sizeof(xlog_op_header_t)) {
2267 		/* no more space in this iclog - push it. */
2268 		xlog_state_finish_copy(log, iclog, *record_cnt, *data_cnt);
2269 		*record_cnt = 0;
2270 		*data_cnt = 0;
2271 
2272 		spin_lock(&log->l_icloglock);
2273 		xlog_state_want_sync(log, iclog);
2274 		spin_unlock(&log->l_icloglock);
2275 
2276 		if (!commit_iclog)
2277 			return xlog_state_release_iclog(log, iclog);
2278 		ASSERT(flags & XLOG_COMMIT_TRANS);
2279 		*commit_iclog = iclog;
2280 	}
2281 
2282 	return 0;
2283 }
2284 
2285 /*
2286  * Write some region out to in-core log
2287  *
2288  * This will be called when writing externally provided regions or when
2289  * writing out a commit record for a given transaction.
2290  *
2291  * General algorithm:
2292  *	1. Find total length of this write.  This may include adding to the
2293  *		lengths passed in.
2294  *	2. Check whether we violate the tickets reservation.
2295  *	3. While writing to this iclog
2296  *	    A. Reserve as much space in this iclog as can get
2297  *	    B. If this is first write, save away start lsn
2298  *	    C. While writing this region:
2299  *		1. If first write of transaction, write start record
2300  *		2. Write log operation header (header per region)
2301  *		3. Find out if we can fit entire region into this iclog
2302  *		4. Potentially, verify destination memcpy ptr
2303  *		5. Memcpy (partial) region
2304  *		6. If partial copy, release iclog; otherwise, continue
2305  *			copying more regions into current iclog
2306  *	4. Mark want sync bit (in simulation mode)
2307  *	5. Release iclog for potential flush to on-disk log.
2308  *
2309  * ERRORS:
2310  * 1.	Panic if reservation is overrun.  This should never happen since
2311  *	reservation amounts are generated internal to the filesystem.
2312  * NOTES:
2313  * 1. Tickets are single threaded data structures.
2314  * 2. The XLOG_END_TRANS & XLOG_CONTINUE_TRANS flags are passed down to the
2315  *	syncing routine.  When a single log_write region needs to span
2316  *	multiple in-core logs, the XLOG_CONTINUE_TRANS bit should be set
2317  *	on all log operation writes which don't contain the end of the
2318  *	region.  The XLOG_END_TRANS bit is used for the in-core log
2319  *	operation which contains the end of the continued log_write region.
2320  * 3. When xlog_state_get_iclog_space() grabs the rest of the current iclog,
2321  *	we don't really know exactly how much space will be used.  As a result,
2322  *	we don't update ic_offset until the end when we know exactly how many
2323  *	bytes have been written out.
2324  */
2325 int
2326 xlog_write(
2327 	struct xlog		*log,
2328 	struct xfs_log_vec	*log_vector,
2329 	struct xlog_ticket	*ticket,
2330 	xfs_lsn_t		*start_lsn,
2331 	struct xlog_in_core	**commit_iclog,
2332 	uint			flags)
2333 {
2334 	struct xlog_in_core	*iclog = NULL;
2335 	struct xfs_log_iovec	*vecp;
2336 	struct xfs_log_vec	*lv;
2337 	int			len;
2338 	int			index;
2339 	int			partial_copy = 0;
2340 	int			partial_copy_len = 0;
2341 	int			contwr = 0;
2342 	int			record_cnt = 0;
2343 	int			data_cnt = 0;
2344 	int			error;
2345 
2346 	*start_lsn = 0;
2347 
2348 	len = xlog_write_calc_vec_length(ticket, log_vector);
2349 
2350 	/*
2351 	 * Region headers and bytes are already accounted for.
2352 	 * We only need to take into account start records and
2353 	 * split regions in this function.
2354 	 */
2355 	if (ticket->t_flags & XLOG_TIC_INITED)
2356 		ticket->t_curr_res -= sizeof(xlog_op_header_t);
2357 
2358 	/*
2359 	 * Commit record headers need to be accounted for. These
2360 	 * come in as separate writes so are easy to detect.
2361 	 */
2362 	if (flags & (XLOG_COMMIT_TRANS | XLOG_UNMOUNT_TRANS))
2363 		ticket->t_curr_res -= sizeof(xlog_op_header_t);
2364 
2365 	if (ticket->t_curr_res < 0) {
2366 		xfs_alert_tag(log->l_mp, XFS_PTAG_LOGRES,
2367 		     "ctx ticket reservation ran out. Need to up reservation");
2368 		xlog_print_tic_res(log->l_mp, ticket);
2369 		xfs_force_shutdown(log->l_mp, SHUTDOWN_LOG_IO_ERROR);
2370 	}
2371 
2372 	index = 0;
2373 	lv = log_vector;
2374 	vecp = lv->lv_iovecp;
2375 	while (lv && (!lv->lv_niovecs || index < lv->lv_niovecs)) {
2376 		void		*ptr;
2377 		int		log_offset;
2378 
2379 		error = xlog_state_get_iclog_space(log, len, &iclog, ticket,
2380 						   &contwr, &log_offset);
2381 		if (error)
2382 			return error;
2383 
2384 		ASSERT(log_offset <= iclog->ic_size - 1);
2385 		ptr = iclog->ic_datap + log_offset;
2386 
2387 		/* start_lsn is the first lsn written to. That's all we need. */
2388 		if (!*start_lsn)
2389 			*start_lsn = be64_to_cpu(iclog->ic_header.h_lsn);
2390 
2391 		/*
2392 		 * This loop writes out as many regions as can fit in the amount
2393 		 * of space which was allocated by xlog_state_get_iclog_space().
2394 		 */
2395 		while (lv && (!lv->lv_niovecs || index < lv->lv_niovecs)) {
2396 			struct xfs_log_iovec	*reg;
2397 			struct xlog_op_header	*ophdr;
2398 			int			start_rec_copy;
2399 			int			copy_len;
2400 			int			copy_off;
2401 			bool			ordered = false;
2402 
2403 			/* ordered log vectors have no regions to write */
2404 			if (lv->lv_buf_len == XFS_LOG_VEC_ORDERED) {
2405 				ASSERT(lv->lv_niovecs == 0);
2406 				ordered = true;
2407 				goto next_lv;
2408 			}
2409 
2410 			reg = &vecp[index];
2411 			ASSERT(reg->i_len % sizeof(int32_t) == 0);
2412 			ASSERT((unsigned long)ptr % sizeof(int32_t) == 0);
2413 
2414 			start_rec_copy = xlog_write_start_rec(ptr, ticket);
2415 			if (start_rec_copy) {
2416 				record_cnt++;
2417 				xlog_write_adv_cnt(&ptr, &len, &log_offset,
2418 						   start_rec_copy);
2419 			}
2420 
2421 			ophdr = xlog_write_setup_ophdr(log, ptr, ticket, flags);
2422 			if (!ophdr)
2423 				return -EIO;
2424 
2425 			xlog_write_adv_cnt(&ptr, &len, &log_offset,
2426 					   sizeof(struct xlog_op_header));
2427 
2428 			len += xlog_write_setup_copy(ticket, ophdr,
2429 						     iclog->ic_size-log_offset,
2430 						     reg->i_len,
2431 						     &copy_off, &copy_len,
2432 						     &partial_copy,
2433 						     &partial_copy_len);
2434 			xlog_verify_dest_ptr(log, ptr);
2435 
2436 			/*
2437 			 * Copy region.
2438 			 *
2439 			 * Unmount records just log an opheader, so can have
2440 			 * empty payloads with no data region to copy. Hence we
2441 			 * only copy the payload if the vector says it has data
2442 			 * to copy.
2443 			 */
2444 			ASSERT(copy_len >= 0);
2445 			if (copy_len > 0) {
2446 				memcpy(ptr, reg->i_addr + copy_off, copy_len);
2447 				xlog_write_adv_cnt(&ptr, &len, &log_offset,
2448 						   copy_len);
2449 			}
2450 			copy_len += start_rec_copy + sizeof(xlog_op_header_t);
2451 			record_cnt++;
2452 			data_cnt += contwr ? copy_len : 0;
2453 
2454 			error = xlog_write_copy_finish(log, iclog, flags,
2455 						       &record_cnt, &data_cnt,
2456 						       &partial_copy,
2457 						       &partial_copy_len,
2458 						       log_offset,
2459 						       commit_iclog);
2460 			if (error)
2461 				return error;
2462 
2463 			/*
2464 			 * if we had a partial copy, we need to get more iclog
2465 			 * space but we don't want to increment the region
2466 			 * index because there is still more is this region to
2467 			 * write.
2468 			 *
2469 			 * If we completed writing this region, and we flushed
2470 			 * the iclog (indicated by resetting of the record
2471 			 * count), then we also need to get more log space. If
2472 			 * this was the last record, though, we are done and
2473 			 * can just return.
2474 			 */
2475 			if (partial_copy)
2476 				break;
2477 
2478 			if (++index == lv->lv_niovecs) {
2479 next_lv:
2480 				lv = lv->lv_next;
2481 				index = 0;
2482 				if (lv)
2483 					vecp = lv->lv_iovecp;
2484 			}
2485 			if (record_cnt == 0 && ordered == false) {
2486 				if (!lv)
2487 					return 0;
2488 				break;
2489 			}
2490 		}
2491 	}
2492 
2493 	ASSERT(len == 0);
2494 
2495 	xlog_state_finish_copy(log, iclog, record_cnt, data_cnt);
2496 	if (!commit_iclog)
2497 		return xlog_state_release_iclog(log, iclog);
2498 
2499 	ASSERT(flags & XLOG_COMMIT_TRANS);
2500 	*commit_iclog = iclog;
2501 	return 0;
2502 }
2503 
2504 
2505 /*****************************************************************************
2506  *
2507  *		State Machine functions
2508  *
2509  *****************************************************************************
2510  */
2511 
2512 /* Clean iclogs starting from the head.  This ordering must be
2513  * maintained, so an iclog doesn't become ACTIVE beyond one that
2514  * is SYNCING.  This is also required to maintain the notion that we use
2515  * a ordered wait queue to hold off would be writers to the log when every
2516  * iclog is trying to sync to disk.
2517  *
2518  * State Change: DIRTY -> ACTIVE
2519  */
2520 STATIC void
2521 xlog_state_clean_log(
2522 	struct xlog *log)
2523 {
2524 	xlog_in_core_t	*iclog;
2525 	int changed = 0;
2526 
2527 	iclog = log->l_iclog;
2528 	do {
2529 		if (iclog->ic_state == XLOG_STATE_DIRTY) {
2530 			iclog->ic_state	= XLOG_STATE_ACTIVE;
2531 			iclog->ic_offset       = 0;
2532 			ASSERT(iclog->ic_callback == NULL);
2533 			/*
2534 			 * If the number of ops in this iclog indicate it just
2535 			 * contains the dummy transaction, we can
2536 			 * change state into IDLE (the second time around).
2537 			 * Otherwise we should change the state into
2538 			 * NEED a dummy.
2539 			 * We don't need to cover the dummy.
2540 			 */
2541 			if (!changed &&
2542 			   (be32_to_cpu(iclog->ic_header.h_num_logops) ==
2543 			   		XLOG_COVER_OPS)) {
2544 				changed = 1;
2545 			} else {
2546 				/*
2547 				 * We have two dirty iclogs so start over
2548 				 * This could also be num of ops indicates
2549 				 * this is not the dummy going out.
2550 				 */
2551 				changed = 2;
2552 			}
2553 			iclog->ic_header.h_num_logops = 0;
2554 			memset(iclog->ic_header.h_cycle_data, 0,
2555 			      sizeof(iclog->ic_header.h_cycle_data));
2556 			iclog->ic_header.h_lsn = 0;
2557 		} else if (iclog->ic_state == XLOG_STATE_ACTIVE)
2558 			/* do nothing */;
2559 		else
2560 			break;	/* stop cleaning */
2561 		iclog = iclog->ic_next;
2562 	} while (iclog != log->l_iclog);
2563 
2564 	/* log is locked when we are called */
2565 	/*
2566 	 * Change state for the dummy log recording.
2567 	 * We usually go to NEED. But we go to NEED2 if the changed indicates
2568 	 * we are done writing the dummy record.
2569 	 * If we are done with the second dummy recored (DONE2), then
2570 	 * we go to IDLE.
2571 	 */
2572 	if (changed) {
2573 		switch (log->l_covered_state) {
2574 		case XLOG_STATE_COVER_IDLE:
2575 		case XLOG_STATE_COVER_NEED:
2576 		case XLOG_STATE_COVER_NEED2:
2577 			log->l_covered_state = XLOG_STATE_COVER_NEED;
2578 			break;
2579 
2580 		case XLOG_STATE_COVER_DONE:
2581 			if (changed == 1)
2582 				log->l_covered_state = XLOG_STATE_COVER_NEED2;
2583 			else
2584 				log->l_covered_state = XLOG_STATE_COVER_NEED;
2585 			break;
2586 
2587 		case XLOG_STATE_COVER_DONE2:
2588 			if (changed == 1)
2589 				log->l_covered_state = XLOG_STATE_COVER_IDLE;
2590 			else
2591 				log->l_covered_state = XLOG_STATE_COVER_NEED;
2592 			break;
2593 
2594 		default:
2595 			ASSERT(0);
2596 		}
2597 	}
2598 }	/* xlog_state_clean_log */
2599 
2600 STATIC xfs_lsn_t
2601 xlog_get_lowest_lsn(
2602 	struct xlog	*log)
2603 {
2604 	xlog_in_core_t  *lsn_log;
2605 	xfs_lsn_t	lowest_lsn, lsn;
2606 
2607 	lsn_log = log->l_iclog;
2608 	lowest_lsn = 0;
2609 	do {
2610 	    if (!(lsn_log->ic_state & (XLOG_STATE_ACTIVE|XLOG_STATE_DIRTY))) {
2611 		lsn = be64_to_cpu(lsn_log->ic_header.h_lsn);
2612 		if ((lsn && !lowest_lsn) ||
2613 		    (XFS_LSN_CMP(lsn, lowest_lsn) < 0)) {
2614 			lowest_lsn = lsn;
2615 		}
2616 	    }
2617 	    lsn_log = lsn_log->ic_next;
2618 	} while (lsn_log != log->l_iclog);
2619 	return lowest_lsn;
2620 }
2621 
2622 
2623 STATIC void
2624 xlog_state_do_callback(
2625 	struct xlog		*log,
2626 	int			aborted,
2627 	struct xlog_in_core	*ciclog)
2628 {
2629 	xlog_in_core_t	   *iclog;
2630 	xlog_in_core_t	   *first_iclog;	/* used to know when we've
2631 						 * processed all iclogs once */
2632 	xfs_log_callback_t *cb, *cb_next;
2633 	int		   flushcnt = 0;
2634 	xfs_lsn_t	   lowest_lsn;
2635 	int		   ioerrors;	/* counter: iclogs with errors */
2636 	int		   loopdidcallbacks; /* flag: inner loop did callbacks*/
2637 	int		   funcdidcallbacks; /* flag: function did callbacks */
2638 	int		   repeats;	/* for issuing console warnings if
2639 					 * looping too many times */
2640 	int		   wake = 0;
2641 
2642 	spin_lock(&log->l_icloglock);
2643 	first_iclog = iclog = log->l_iclog;
2644 	ioerrors = 0;
2645 	funcdidcallbacks = 0;
2646 	repeats = 0;
2647 
2648 	do {
2649 		/*
2650 		 * Scan all iclogs starting with the one pointed to by the
2651 		 * log.  Reset this starting point each time the log is
2652 		 * unlocked (during callbacks).
2653 		 *
2654 		 * Keep looping through iclogs until one full pass is made
2655 		 * without running any callbacks.
2656 		 */
2657 		first_iclog = log->l_iclog;
2658 		iclog = log->l_iclog;
2659 		loopdidcallbacks = 0;
2660 		repeats++;
2661 
2662 		do {
2663 
2664 			/* skip all iclogs in the ACTIVE & DIRTY states */
2665 			if (iclog->ic_state &
2666 			    (XLOG_STATE_ACTIVE|XLOG_STATE_DIRTY)) {
2667 				iclog = iclog->ic_next;
2668 				continue;
2669 			}
2670 
2671 			/*
2672 			 * Between marking a filesystem SHUTDOWN and stopping
2673 			 * the log, we do flush all iclogs to disk (if there
2674 			 * wasn't a log I/O error). So, we do want things to
2675 			 * go smoothly in case of just a SHUTDOWN  w/o a
2676 			 * LOG_IO_ERROR.
2677 			 */
2678 			if (!(iclog->ic_state & XLOG_STATE_IOERROR)) {
2679 				/*
2680 				 * Can only perform callbacks in order.  Since
2681 				 * this iclog is not in the DONE_SYNC/
2682 				 * DO_CALLBACK state, we skip the rest and
2683 				 * just try to clean up.  If we set our iclog
2684 				 * to DO_CALLBACK, we will not process it when
2685 				 * we retry since a previous iclog is in the
2686 				 * CALLBACK and the state cannot change since
2687 				 * we are holding the l_icloglock.
2688 				 */
2689 				if (!(iclog->ic_state &
2690 					(XLOG_STATE_DONE_SYNC |
2691 						 XLOG_STATE_DO_CALLBACK))) {
2692 					if (ciclog && (ciclog->ic_state ==
2693 							XLOG_STATE_DONE_SYNC)) {
2694 						ciclog->ic_state = XLOG_STATE_DO_CALLBACK;
2695 					}
2696 					break;
2697 				}
2698 				/*
2699 				 * We now have an iclog that is in either the
2700 				 * DO_CALLBACK or DONE_SYNC states. The other
2701 				 * states (WANT_SYNC, SYNCING, or CALLBACK were
2702 				 * caught by the above if and are going to
2703 				 * clean (i.e. we aren't doing their callbacks)
2704 				 * see the above if.
2705 				 */
2706 
2707 				/*
2708 				 * We will do one more check here to see if we
2709 				 * have chased our tail around.
2710 				 */
2711 
2712 				lowest_lsn = xlog_get_lowest_lsn(log);
2713 				if (lowest_lsn &&
2714 				    XFS_LSN_CMP(lowest_lsn,
2715 						be64_to_cpu(iclog->ic_header.h_lsn)) < 0) {
2716 					iclog = iclog->ic_next;
2717 					continue; /* Leave this iclog for
2718 						   * another thread */
2719 				}
2720 
2721 				iclog->ic_state = XLOG_STATE_CALLBACK;
2722 
2723 
2724 				/*
2725 				 * Completion of a iclog IO does not imply that
2726 				 * a transaction has completed, as transactions
2727 				 * can be large enough to span many iclogs. We
2728 				 * cannot change the tail of the log half way
2729 				 * through a transaction as this may be the only
2730 				 * transaction in the log and moving th etail to
2731 				 * point to the middle of it will prevent
2732 				 * recovery from finding the start of the
2733 				 * transaction. Hence we should only update the
2734 				 * last_sync_lsn if this iclog contains
2735 				 * transaction completion callbacks on it.
2736 				 *
2737 				 * We have to do this before we drop the
2738 				 * icloglock to ensure we are the only one that
2739 				 * can update it.
2740 				 */
2741 				ASSERT(XFS_LSN_CMP(atomic64_read(&log->l_last_sync_lsn),
2742 					be64_to_cpu(iclog->ic_header.h_lsn)) <= 0);
2743 				if (iclog->ic_callback)
2744 					atomic64_set(&log->l_last_sync_lsn,
2745 						be64_to_cpu(iclog->ic_header.h_lsn));
2746 
2747 			} else
2748 				ioerrors++;
2749 
2750 			spin_unlock(&log->l_icloglock);
2751 
2752 			/*
2753 			 * Keep processing entries in the callback list until
2754 			 * we come around and it is empty.  We need to
2755 			 * atomically see that the list is empty and change the
2756 			 * state to DIRTY so that we don't miss any more
2757 			 * callbacks being added.
2758 			 */
2759 			spin_lock(&iclog->ic_callback_lock);
2760 			cb = iclog->ic_callback;
2761 			while (cb) {
2762 				iclog->ic_callback_tail = &(iclog->ic_callback);
2763 				iclog->ic_callback = NULL;
2764 				spin_unlock(&iclog->ic_callback_lock);
2765 
2766 				/* perform callbacks in the order given */
2767 				for (; cb; cb = cb_next) {
2768 					cb_next = cb->cb_next;
2769 					cb->cb_func(cb->cb_arg, aborted);
2770 				}
2771 				spin_lock(&iclog->ic_callback_lock);
2772 				cb = iclog->ic_callback;
2773 			}
2774 
2775 			loopdidcallbacks++;
2776 			funcdidcallbacks++;
2777 
2778 			spin_lock(&log->l_icloglock);
2779 			ASSERT(iclog->ic_callback == NULL);
2780 			spin_unlock(&iclog->ic_callback_lock);
2781 			if (!(iclog->ic_state & XLOG_STATE_IOERROR))
2782 				iclog->ic_state = XLOG_STATE_DIRTY;
2783 
2784 			/*
2785 			 * Transition from DIRTY to ACTIVE if applicable.
2786 			 * NOP if STATE_IOERROR.
2787 			 */
2788 			xlog_state_clean_log(log);
2789 
2790 			/* wake up threads waiting in xfs_log_force() */
2791 			wake_up_all(&iclog->ic_force_wait);
2792 
2793 			iclog = iclog->ic_next;
2794 		} while (first_iclog != iclog);
2795 
2796 		if (repeats > 5000) {
2797 			flushcnt += repeats;
2798 			repeats = 0;
2799 			xfs_warn(log->l_mp,
2800 				"%s: possible infinite loop (%d iterations)",
2801 				__func__, flushcnt);
2802 		}
2803 	} while (!ioerrors && loopdidcallbacks);
2804 
2805 #ifdef DEBUG
2806 	/*
2807 	 * Make one last gasp attempt to see if iclogs are being left in limbo.
2808 	 * If the above loop finds an iclog earlier than the current iclog and
2809 	 * in one of the syncing states, the current iclog is put into
2810 	 * DO_CALLBACK and the callbacks are deferred to the completion of the
2811 	 * earlier iclog. Walk the iclogs in order and make sure that no iclog
2812 	 * is in DO_CALLBACK unless an earlier iclog is in one of the syncing
2813 	 * states.
2814 	 *
2815 	 * Note that SYNCING|IOABORT is a valid state so we cannot just check
2816 	 * for ic_state == SYNCING.
2817 	 */
2818 	if (funcdidcallbacks) {
2819 		first_iclog = iclog = log->l_iclog;
2820 		do {
2821 			ASSERT(iclog->ic_state != XLOG_STATE_DO_CALLBACK);
2822 			/*
2823 			 * Terminate the loop if iclogs are found in states
2824 			 * which will cause other threads to clean up iclogs.
2825 			 *
2826 			 * SYNCING - i/o completion will go through logs
2827 			 * DONE_SYNC - interrupt thread should be waiting for
2828 			 *              l_icloglock
2829 			 * IOERROR - give up hope all ye who enter here
2830 			 */
2831 			if (iclog->ic_state == XLOG_STATE_WANT_SYNC ||
2832 			    iclog->ic_state & XLOG_STATE_SYNCING ||
2833 			    iclog->ic_state == XLOG_STATE_DONE_SYNC ||
2834 			    iclog->ic_state == XLOG_STATE_IOERROR )
2835 				break;
2836 			iclog = iclog->ic_next;
2837 		} while (first_iclog != iclog);
2838 	}
2839 #endif
2840 
2841 	if (log->l_iclog->ic_state & (XLOG_STATE_ACTIVE|XLOG_STATE_IOERROR))
2842 		wake = 1;
2843 	spin_unlock(&log->l_icloglock);
2844 
2845 	if (wake)
2846 		wake_up_all(&log->l_flush_wait);
2847 }
2848 
2849 
2850 /*
2851  * Finish transitioning this iclog to the dirty state.
2852  *
2853  * Make sure that we completely execute this routine only when this is
2854  * the last call to the iclog.  There is a good chance that iclog flushes,
2855  * when we reach the end of the physical log, get turned into 2 separate
2856  * calls to bwrite.  Hence, one iclog flush could generate two calls to this
2857  * routine.  By using the reference count bwritecnt, we guarantee that only
2858  * the second completion goes through.
2859  *
2860  * Callbacks could take time, so they are done outside the scope of the
2861  * global state machine log lock.
2862  */
2863 STATIC void
2864 xlog_state_done_syncing(
2865 	xlog_in_core_t	*iclog,
2866 	int		aborted)
2867 {
2868 	struct xlog	   *log = iclog->ic_log;
2869 
2870 	spin_lock(&log->l_icloglock);
2871 
2872 	ASSERT(iclog->ic_state == XLOG_STATE_SYNCING ||
2873 	       iclog->ic_state == XLOG_STATE_IOERROR);
2874 	ASSERT(atomic_read(&iclog->ic_refcnt) == 0);
2875 	ASSERT(iclog->ic_bwritecnt == 1 || iclog->ic_bwritecnt == 2);
2876 
2877 
2878 	/*
2879 	 * If we got an error, either on the first buffer, or in the case of
2880 	 * split log writes, on the second, we mark ALL iclogs STATE_IOERROR,
2881 	 * and none should ever be attempted to be written to disk
2882 	 * again.
2883 	 */
2884 	if (iclog->ic_state != XLOG_STATE_IOERROR) {
2885 		if (--iclog->ic_bwritecnt == 1) {
2886 			spin_unlock(&log->l_icloglock);
2887 			return;
2888 		}
2889 		iclog->ic_state = XLOG_STATE_DONE_SYNC;
2890 	}
2891 
2892 	/*
2893 	 * Someone could be sleeping prior to writing out the next
2894 	 * iclog buffer, we wake them all, one will get to do the
2895 	 * I/O, the others get to wait for the result.
2896 	 */
2897 	wake_up_all(&iclog->ic_write_wait);
2898 	spin_unlock(&log->l_icloglock);
2899 	xlog_state_do_callback(log, aborted, iclog);	/* also cleans log */
2900 }	/* xlog_state_done_syncing */
2901 
2902 
2903 /*
2904  * If the head of the in-core log ring is not (ACTIVE or DIRTY), then we must
2905  * sleep.  We wait on the flush queue on the head iclog as that should be
2906  * the first iclog to complete flushing. Hence if all iclogs are syncing,
2907  * we will wait here and all new writes will sleep until a sync completes.
2908  *
2909  * The in-core logs are used in a circular fashion. They are not used
2910  * out-of-order even when an iclog past the head is free.
2911  *
2912  * return:
2913  *	* log_offset where xlog_write() can start writing into the in-core
2914  *		log's data space.
2915  *	* in-core log pointer to which xlog_write() should write.
2916  *	* boolean indicating this is a continued write to an in-core log.
2917  *		If this is the last write, then the in-core log's offset field
2918  *		needs to be incremented, depending on the amount of data which
2919  *		is copied.
2920  */
2921 STATIC int
2922 xlog_state_get_iclog_space(
2923 	struct xlog		*log,
2924 	int			len,
2925 	struct xlog_in_core	**iclogp,
2926 	struct xlog_ticket	*ticket,
2927 	int			*continued_write,
2928 	int			*logoffsetp)
2929 {
2930 	int		  log_offset;
2931 	xlog_rec_header_t *head;
2932 	xlog_in_core_t	  *iclog;
2933 	int		  error;
2934 
2935 restart:
2936 	spin_lock(&log->l_icloglock);
2937 	if (XLOG_FORCED_SHUTDOWN(log)) {
2938 		spin_unlock(&log->l_icloglock);
2939 		return -EIO;
2940 	}
2941 
2942 	iclog = log->l_iclog;
2943 	if (iclog->ic_state != XLOG_STATE_ACTIVE) {
2944 		XFS_STATS_INC(log->l_mp, xs_log_noiclogs);
2945 
2946 		/* Wait for log writes to have flushed */
2947 		xlog_wait(&log->l_flush_wait, &log->l_icloglock);
2948 		goto restart;
2949 	}
2950 
2951 	head = &iclog->ic_header;
2952 
2953 	atomic_inc(&iclog->ic_refcnt);	/* prevents sync */
2954 	log_offset = iclog->ic_offset;
2955 
2956 	/* On the 1st write to an iclog, figure out lsn.  This works
2957 	 * if iclogs marked XLOG_STATE_WANT_SYNC always write out what they are
2958 	 * committing to.  If the offset is set, that's how many blocks
2959 	 * must be written.
2960 	 */
2961 	if (log_offset == 0) {
2962 		ticket->t_curr_res -= log->l_iclog_hsize;
2963 		xlog_tic_add_region(ticket,
2964 				    log->l_iclog_hsize,
2965 				    XLOG_REG_TYPE_LRHEADER);
2966 		head->h_cycle = cpu_to_be32(log->l_curr_cycle);
2967 		head->h_lsn = cpu_to_be64(
2968 			xlog_assign_lsn(log->l_curr_cycle, log->l_curr_block));
2969 		ASSERT(log->l_curr_block >= 0);
2970 	}
2971 
2972 	/* If there is enough room to write everything, then do it.  Otherwise,
2973 	 * claim the rest of the region and make sure the XLOG_STATE_WANT_SYNC
2974 	 * bit is on, so this will get flushed out.  Don't update ic_offset
2975 	 * until you know exactly how many bytes get copied.  Therefore, wait
2976 	 * until later to update ic_offset.
2977 	 *
2978 	 * xlog_write() algorithm assumes that at least 2 xlog_op_header_t's
2979 	 * can fit into remaining data section.
2980 	 */
2981 	if (iclog->ic_size - iclog->ic_offset < 2*sizeof(xlog_op_header_t)) {
2982 		xlog_state_switch_iclogs(log, iclog, iclog->ic_size);
2983 
2984 		/*
2985 		 * If I'm the only one writing to this iclog, sync it to disk.
2986 		 * We need to do an atomic compare and decrement here to avoid
2987 		 * racing with concurrent atomic_dec_and_lock() calls in
2988 		 * xlog_state_release_iclog() when there is more than one
2989 		 * reference to the iclog.
2990 		 */
2991 		if (!atomic_add_unless(&iclog->ic_refcnt, -1, 1)) {
2992 			/* we are the only one */
2993 			spin_unlock(&log->l_icloglock);
2994 			error = xlog_state_release_iclog(log, iclog);
2995 			if (error)
2996 				return error;
2997 		} else {
2998 			spin_unlock(&log->l_icloglock);
2999 		}
3000 		goto restart;
3001 	}
3002 
3003 	/* Do we have enough room to write the full amount in the remainder
3004 	 * of this iclog?  Or must we continue a write on the next iclog and
3005 	 * mark this iclog as completely taken?  In the case where we switch
3006 	 * iclogs (to mark it taken), this particular iclog will release/sync
3007 	 * to disk in xlog_write().
3008 	 */
3009 	if (len <= iclog->ic_size - iclog->ic_offset) {
3010 		*continued_write = 0;
3011 		iclog->ic_offset += len;
3012 	} else {
3013 		*continued_write = 1;
3014 		xlog_state_switch_iclogs(log, iclog, iclog->ic_size);
3015 	}
3016 	*iclogp = iclog;
3017 
3018 	ASSERT(iclog->ic_offset <= iclog->ic_size);
3019 	spin_unlock(&log->l_icloglock);
3020 
3021 	*logoffsetp = log_offset;
3022 	return 0;
3023 }	/* xlog_state_get_iclog_space */
3024 
3025 /* The first cnt-1 times through here we don't need to
3026  * move the grant write head because the permanent
3027  * reservation has reserved cnt times the unit amount.
3028  * Release part of current permanent unit reservation and
3029  * reset current reservation to be one units worth.  Also
3030  * move grant reservation head forward.
3031  */
3032 STATIC void
3033 xlog_regrant_reserve_log_space(
3034 	struct xlog		*log,
3035 	struct xlog_ticket	*ticket)
3036 {
3037 	trace_xfs_log_regrant_reserve_enter(log, ticket);
3038 
3039 	if (ticket->t_cnt > 0)
3040 		ticket->t_cnt--;
3041 
3042 	xlog_grant_sub_space(log, &log->l_reserve_head.grant,
3043 					ticket->t_curr_res);
3044 	xlog_grant_sub_space(log, &log->l_write_head.grant,
3045 					ticket->t_curr_res);
3046 	ticket->t_curr_res = ticket->t_unit_res;
3047 	xlog_tic_reset_res(ticket);
3048 
3049 	trace_xfs_log_regrant_reserve_sub(log, ticket);
3050 
3051 	/* just return if we still have some of the pre-reserved space */
3052 	if (ticket->t_cnt > 0)
3053 		return;
3054 
3055 	xlog_grant_add_space(log, &log->l_reserve_head.grant,
3056 					ticket->t_unit_res);
3057 
3058 	trace_xfs_log_regrant_reserve_exit(log, ticket);
3059 
3060 	ticket->t_curr_res = ticket->t_unit_res;
3061 	xlog_tic_reset_res(ticket);
3062 }	/* xlog_regrant_reserve_log_space */
3063 
3064 
3065 /*
3066  * Give back the space left from a reservation.
3067  *
3068  * All the information we need to make a correct determination of space left
3069  * is present.  For non-permanent reservations, things are quite easy.  The
3070  * count should have been decremented to zero.  We only need to deal with the
3071  * space remaining in the current reservation part of the ticket.  If the
3072  * ticket contains a permanent reservation, there may be left over space which
3073  * needs to be released.  A count of N means that N-1 refills of the current
3074  * reservation can be done before we need to ask for more space.  The first
3075  * one goes to fill up the first current reservation.  Once we run out of
3076  * space, the count will stay at zero and the only space remaining will be
3077  * in the current reservation field.
3078  */
3079 STATIC void
3080 xlog_ungrant_log_space(
3081 	struct xlog		*log,
3082 	struct xlog_ticket	*ticket)
3083 {
3084 	int	bytes;
3085 
3086 	if (ticket->t_cnt > 0)
3087 		ticket->t_cnt--;
3088 
3089 	trace_xfs_log_ungrant_enter(log, ticket);
3090 	trace_xfs_log_ungrant_sub(log, ticket);
3091 
3092 	/*
3093 	 * If this is a permanent reservation ticket, we may be able to free
3094 	 * up more space based on the remaining count.
3095 	 */
3096 	bytes = ticket->t_curr_res;
3097 	if (ticket->t_cnt > 0) {
3098 		ASSERT(ticket->t_flags & XLOG_TIC_PERM_RESERV);
3099 		bytes += ticket->t_unit_res*ticket->t_cnt;
3100 	}
3101 
3102 	xlog_grant_sub_space(log, &log->l_reserve_head.grant, bytes);
3103 	xlog_grant_sub_space(log, &log->l_write_head.grant, bytes);
3104 
3105 	trace_xfs_log_ungrant_exit(log, ticket);
3106 
3107 	xfs_log_space_wake(log->l_mp);
3108 }
3109 
3110 /*
3111  * Flush iclog to disk if this is the last reference to the given iclog and
3112  * the WANT_SYNC bit is set.
3113  *
3114  * When this function is entered, the iclog is not necessarily in the
3115  * WANT_SYNC state.  It may be sitting around waiting to get filled.
3116  *
3117  *
3118  */
3119 STATIC int
3120 xlog_state_release_iclog(
3121 	struct xlog		*log,
3122 	struct xlog_in_core	*iclog)
3123 {
3124 	int		sync = 0;	/* do we sync? */
3125 
3126 	if (iclog->ic_state & XLOG_STATE_IOERROR)
3127 		return -EIO;
3128 
3129 	ASSERT(atomic_read(&iclog->ic_refcnt) > 0);
3130 	if (!atomic_dec_and_lock(&iclog->ic_refcnt, &log->l_icloglock))
3131 		return 0;
3132 
3133 	if (iclog->ic_state & XLOG_STATE_IOERROR) {
3134 		spin_unlock(&log->l_icloglock);
3135 		return -EIO;
3136 	}
3137 	ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE ||
3138 	       iclog->ic_state == XLOG_STATE_WANT_SYNC);
3139 
3140 	if (iclog->ic_state == XLOG_STATE_WANT_SYNC) {
3141 		/* update tail before writing to iclog */
3142 		xfs_lsn_t tail_lsn = xlog_assign_tail_lsn(log->l_mp);
3143 		sync++;
3144 		iclog->ic_state = XLOG_STATE_SYNCING;
3145 		iclog->ic_header.h_tail_lsn = cpu_to_be64(tail_lsn);
3146 		xlog_verify_tail_lsn(log, iclog, tail_lsn);
3147 		/* cycle incremented when incrementing curr_block */
3148 	}
3149 	spin_unlock(&log->l_icloglock);
3150 
3151 	/*
3152 	 * We let the log lock go, so it's possible that we hit a log I/O
3153 	 * error or some other SHUTDOWN condition that marks the iclog
3154 	 * as XLOG_STATE_IOERROR before the bwrite. However, we know that
3155 	 * this iclog has consistent data, so we ignore IOERROR
3156 	 * flags after this point.
3157 	 */
3158 	if (sync)
3159 		return xlog_sync(log, iclog);
3160 	return 0;
3161 }	/* xlog_state_release_iclog */
3162 
3163 
3164 /*
3165  * This routine will mark the current iclog in the ring as WANT_SYNC
3166  * and move the current iclog pointer to the next iclog in the ring.
3167  * When this routine is called from xlog_state_get_iclog_space(), the
3168  * exact size of the iclog has not yet been determined.  All we know is
3169  * that every data block.  We have run out of space in this log record.
3170  */
3171 STATIC void
3172 xlog_state_switch_iclogs(
3173 	struct xlog		*log,
3174 	struct xlog_in_core	*iclog,
3175 	int			eventual_size)
3176 {
3177 	ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE);
3178 	if (!eventual_size)
3179 		eventual_size = iclog->ic_offset;
3180 	iclog->ic_state = XLOG_STATE_WANT_SYNC;
3181 	iclog->ic_header.h_prev_block = cpu_to_be32(log->l_prev_block);
3182 	log->l_prev_block = log->l_curr_block;
3183 	log->l_prev_cycle = log->l_curr_cycle;
3184 
3185 	/* roll log?: ic_offset changed later */
3186 	log->l_curr_block += BTOBB(eventual_size)+BTOBB(log->l_iclog_hsize);
3187 
3188 	/* Round up to next log-sunit */
3189 	if (xfs_sb_version_haslogv2(&log->l_mp->m_sb) &&
3190 	    log->l_mp->m_sb.sb_logsunit > 1) {
3191 		uint32_t sunit_bb = BTOBB(log->l_mp->m_sb.sb_logsunit);
3192 		log->l_curr_block = roundup(log->l_curr_block, sunit_bb);
3193 	}
3194 
3195 	if (log->l_curr_block >= log->l_logBBsize) {
3196 		/*
3197 		 * Rewind the current block before the cycle is bumped to make
3198 		 * sure that the combined LSN never transiently moves forward
3199 		 * when the log wraps to the next cycle. This is to support the
3200 		 * unlocked sample of these fields from xlog_valid_lsn(). Most
3201 		 * other cases should acquire l_icloglock.
3202 		 */
3203 		log->l_curr_block -= log->l_logBBsize;
3204 		ASSERT(log->l_curr_block >= 0);
3205 		smp_wmb();
3206 		log->l_curr_cycle++;
3207 		if (log->l_curr_cycle == XLOG_HEADER_MAGIC_NUM)
3208 			log->l_curr_cycle++;
3209 	}
3210 	ASSERT(iclog == log->l_iclog);
3211 	log->l_iclog = iclog->ic_next;
3212 }	/* xlog_state_switch_iclogs */
3213 
3214 /*
3215  * Write out all data in the in-core log as of this exact moment in time.
3216  *
3217  * Data may be written to the in-core log during this call.  However,
3218  * we don't guarantee this data will be written out.  A change from past
3219  * implementation means this routine will *not* write out zero length LRs.
3220  *
3221  * Basically, we try and perform an intelligent scan of the in-core logs.
3222  * If we determine there is no flushable data, we just return.  There is no
3223  * flushable data if:
3224  *
3225  *	1. the current iclog is active and has no data; the previous iclog
3226  *		is in the active or dirty state.
3227  *	2. the current iclog is drity, and the previous iclog is in the
3228  *		active or dirty state.
3229  *
3230  * We may sleep if:
3231  *
3232  *	1. the current iclog is not in the active nor dirty state.
3233  *	2. the current iclog dirty, and the previous iclog is not in the
3234  *		active nor dirty state.
3235  *	3. the current iclog is active, and there is another thread writing
3236  *		to this particular iclog.
3237  *	4. a) the current iclog is active and has no other writers
3238  *	   b) when we return from flushing out this iclog, it is still
3239  *		not in the active nor dirty state.
3240  */
3241 int
3242 _xfs_log_force(
3243 	struct xfs_mount	*mp,
3244 	uint			flags,
3245 	int			*log_flushed)
3246 {
3247 	struct xlog		*log = mp->m_log;
3248 	struct xlog_in_core	*iclog;
3249 	xfs_lsn_t		lsn;
3250 
3251 	XFS_STATS_INC(mp, xs_log_force);
3252 
3253 	xlog_cil_force(log);
3254 
3255 	spin_lock(&log->l_icloglock);
3256 
3257 	iclog = log->l_iclog;
3258 	if (iclog->ic_state & XLOG_STATE_IOERROR) {
3259 		spin_unlock(&log->l_icloglock);
3260 		return -EIO;
3261 	}
3262 
3263 	/* If the head iclog is not active nor dirty, we just attach
3264 	 * ourselves to the head and go to sleep.
3265 	 */
3266 	if (iclog->ic_state == XLOG_STATE_ACTIVE ||
3267 	    iclog->ic_state == XLOG_STATE_DIRTY) {
3268 		/*
3269 		 * If the head is dirty or (active and empty), then
3270 		 * we need to look at the previous iclog.  If the previous
3271 		 * iclog is active or dirty we are done.  There is nothing
3272 		 * to sync out.  Otherwise, we attach ourselves to the
3273 		 * previous iclog and go to sleep.
3274 		 */
3275 		if (iclog->ic_state == XLOG_STATE_DIRTY ||
3276 		    (atomic_read(&iclog->ic_refcnt) == 0
3277 		     && iclog->ic_offset == 0)) {
3278 			iclog = iclog->ic_prev;
3279 			if (iclog->ic_state == XLOG_STATE_ACTIVE ||
3280 			    iclog->ic_state == XLOG_STATE_DIRTY)
3281 				goto no_sleep;
3282 			else
3283 				goto maybe_sleep;
3284 		} else {
3285 			if (atomic_read(&iclog->ic_refcnt) == 0) {
3286 				/* We are the only one with access to this
3287 				 * iclog.  Flush it out now.  There should
3288 				 * be a roundoff of zero to show that someone
3289 				 * has already taken care of the roundoff from
3290 				 * the previous sync.
3291 				 */
3292 				atomic_inc(&iclog->ic_refcnt);
3293 				lsn = be64_to_cpu(iclog->ic_header.h_lsn);
3294 				xlog_state_switch_iclogs(log, iclog, 0);
3295 				spin_unlock(&log->l_icloglock);
3296 
3297 				if (xlog_state_release_iclog(log, iclog))
3298 					return -EIO;
3299 
3300 				if (log_flushed)
3301 					*log_flushed = 1;
3302 				spin_lock(&log->l_icloglock);
3303 				if (be64_to_cpu(iclog->ic_header.h_lsn) == lsn &&
3304 				    iclog->ic_state != XLOG_STATE_DIRTY)
3305 					goto maybe_sleep;
3306 				else
3307 					goto no_sleep;
3308 			} else {
3309 				/* Someone else is writing to this iclog.
3310 				 * Use its call to flush out the data.  However,
3311 				 * the other thread may not force out this LR,
3312 				 * so we mark it WANT_SYNC.
3313 				 */
3314 				xlog_state_switch_iclogs(log, iclog, 0);
3315 				goto maybe_sleep;
3316 			}
3317 		}
3318 	}
3319 
3320 	/* By the time we come around again, the iclog could've been filled
3321 	 * which would give it another lsn.  If we have a new lsn, just
3322 	 * return because the relevant data has been flushed.
3323 	 */
3324 maybe_sleep:
3325 	if (flags & XFS_LOG_SYNC) {
3326 		/*
3327 		 * We must check if we're shutting down here, before
3328 		 * we wait, while we're holding the l_icloglock.
3329 		 * Then we check again after waking up, in case our
3330 		 * sleep was disturbed by a bad news.
3331 		 */
3332 		if (iclog->ic_state & XLOG_STATE_IOERROR) {
3333 			spin_unlock(&log->l_icloglock);
3334 			return -EIO;
3335 		}
3336 		XFS_STATS_INC(mp, xs_log_force_sleep);
3337 		xlog_wait(&iclog->ic_force_wait, &log->l_icloglock);
3338 		/*
3339 		 * No need to grab the log lock here since we're
3340 		 * only deciding whether or not to return EIO
3341 		 * and the memory read should be atomic.
3342 		 */
3343 		if (iclog->ic_state & XLOG_STATE_IOERROR)
3344 			return -EIO;
3345 		if (log_flushed)
3346 			*log_flushed = 1;
3347 	} else {
3348 
3349 no_sleep:
3350 		spin_unlock(&log->l_icloglock);
3351 	}
3352 	return 0;
3353 }
3354 
3355 /*
3356  * Wrapper for _xfs_log_force(), to be used when caller doesn't care
3357  * about errors or whether the log was flushed or not. This is the normal
3358  * interface to use when trying to unpin items or move the log forward.
3359  */
3360 void
3361 xfs_log_force(
3362 	xfs_mount_t	*mp,
3363 	uint		flags)
3364 {
3365 	trace_xfs_log_force(mp, 0, _RET_IP_);
3366 	_xfs_log_force(mp, flags, NULL);
3367 }
3368 
3369 /*
3370  * Force the in-core log to disk for a specific LSN.
3371  *
3372  * Find in-core log with lsn.
3373  *	If it is in the DIRTY state, just return.
3374  *	If it is in the ACTIVE state, move the in-core log into the WANT_SYNC
3375  *		state and go to sleep or return.
3376  *	If it is in any other state, go to sleep or return.
3377  *
3378  * Synchronous forces are implemented with a signal variable. All callers
3379  * to force a given lsn to disk will wait on a the sv attached to the
3380  * specific in-core log.  When given in-core log finally completes its
3381  * write to disk, that thread will wake up all threads waiting on the
3382  * sv.
3383  */
3384 int
3385 _xfs_log_force_lsn(
3386 	struct xfs_mount	*mp,
3387 	xfs_lsn_t		lsn,
3388 	uint			flags,
3389 	int			*log_flushed)
3390 {
3391 	struct xlog		*log = mp->m_log;
3392 	struct xlog_in_core	*iclog;
3393 	int			already_slept = 0;
3394 
3395 	ASSERT(lsn != 0);
3396 
3397 	XFS_STATS_INC(mp, xs_log_force);
3398 
3399 	lsn = xlog_cil_force_lsn(log, lsn);
3400 	if (lsn == NULLCOMMITLSN)
3401 		return 0;
3402 
3403 try_again:
3404 	spin_lock(&log->l_icloglock);
3405 	iclog = log->l_iclog;
3406 	if (iclog->ic_state & XLOG_STATE_IOERROR) {
3407 		spin_unlock(&log->l_icloglock);
3408 		return -EIO;
3409 	}
3410 
3411 	do {
3412 		if (be64_to_cpu(iclog->ic_header.h_lsn) != lsn) {
3413 			iclog = iclog->ic_next;
3414 			continue;
3415 		}
3416 
3417 		if (iclog->ic_state == XLOG_STATE_DIRTY) {
3418 			spin_unlock(&log->l_icloglock);
3419 			return 0;
3420 		}
3421 
3422 		if (iclog->ic_state == XLOG_STATE_ACTIVE) {
3423 			/*
3424 			 * We sleep here if we haven't already slept (e.g.
3425 			 * this is the first time we've looked at the correct
3426 			 * iclog buf) and the buffer before us is going to
3427 			 * be sync'ed. The reason for this is that if we
3428 			 * are doing sync transactions here, by waiting for
3429 			 * the previous I/O to complete, we can allow a few
3430 			 * more transactions into this iclog before we close
3431 			 * it down.
3432 			 *
3433 			 * Otherwise, we mark the buffer WANT_SYNC, and bump
3434 			 * up the refcnt so we can release the log (which
3435 			 * drops the ref count).  The state switch keeps new
3436 			 * transaction commits from using this buffer.  When
3437 			 * the current commits finish writing into the buffer,
3438 			 * the refcount will drop to zero and the buffer will
3439 			 * go out then.
3440 			 */
3441 			if (!already_slept &&
3442 			    (iclog->ic_prev->ic_state &
3443 			     (XLOG_STATE_WANT_SYNC | XLOG_STATE_SYNCING))) {
3444 				ASSERT(!(iclog->ic_state & XLOG_STATE_IOERROR));
3445 
3446 				XFS_STATS_INC(mp, xs_log_force_sleep);
3447 
3448 				xlog_wait(&iclog->ic_prev->ic_write_wait,
3449 							&log->l_icloglock);
3450 				if (log_flushed)
3451 					*log_flushed = 1;
3452 				already_slept = 1;
3453 				goto try_again;
3454 			}
3455 			atomic_inc(&iclog->ic_refcnt);
3456 			xlog_state_switch_iclogs(log, iclog, 0);
3457 			spin_unlock(&log->l_icloglock);
3458 			if (xlog_state_release_iclog(log, iclog))
3459 				return -EIO;
3460 			if (log_flushed)
3461 				*log_flushed = 1;
3462 			spin_lock(&log->l_icloglock);
3463 		}
3464 
3465 		if ((flags & XFS_LOG_SYNC) && /* sleep */
3466 		    !(iclog->ic_state &
3467 		      (XLOG_STATE_ACTIVE | XLOG_STATE_DIRTY))) {
3468 			/*
3469 			 * Don't wait on completion if we know that we've
3470 			 * gotten a log write error.
3471 			 */
3472 			if (iclog->ic_state & XLOG_STATE_IOERROR) {
3473 				spin_unlock(&log->l_icloglock);
3474 				return -EIO;
3475 			}
3476 			XFS_STATS_INC(mp, xs_log_force_sleep);
3477 			xlog_wait(&iclog->ic_force_wait, &log->l_icloglock);
3478 			/*
3479 			 * No need to grab the log lock here since we're
3480 			 * only deciding whether or not to return EIO
3481 			 * and the memory read should be atomic.
3482 			 */
3483 			if (iclog->ic_state & XLOG_STATE_IOERROR)
3484 				return -EIO;
3485 
3486 			if (log_flushed)
3487 				*log_flushed = 1;
3488 		} else {		/* just return */
3489 			spin_unlock(&log->l_icloglock);
3490 		}
3491 
3492 		return 0;
3493 	} while (iclog != log->l_iclog);
3494 
3495 	spin_unlock(&log->l_icloglock);
3496 	return 0;
3497 }
3498 
3499 /*
3500  * Wrapper for _xfs_log_force_lsn(), to be used when caller doesn't care
3501  * about errors or whether the log was flushed or not. This is the normal
3502  * interface to use when trying to unpin items or move the log forward.
3503  */
3504 void
3505 xfs_log_force_lsn(
3506 	xfs_mount_t	*mp,
3507 	xfs_lsn_t	lsn,
3508 	uint		flags)
3509 {
3510 	trace_xfs_log_force(mp, lsn, _RET_IP_);
3511 	_xfs_log_force_lsn(mp, lsn, flags, NULL);
3512 }
3513 
3514 /*
3515  * Called when we want to mark the current iclog as being ready to sync to
3516  * disk.
3517  */
3518 STATIC void
3519 xlog_state_want_sync(
3520 	struct xlog		*log,
3521 	struct xlog_in_core	*iclog)
3522 {
3523 	assert_spin_locked(&log->l_icloglock);
3524 
3525 	if (iclog->ic_state == XLOG_STATE_ACTIVE) {
3526 		xlog_state_switch_iclogs(log, iclog, 0);
3527 	} else {
3528 		ASSERT(iclog->ic_state &
3529 			(XLOG_STATE_WANT_SYNC|XLOG_STATE_IOERROR));
3530 	}
3531 }
3532 
3533 
3534 /*****************************************************************************
3535  *
3536  *		TICKET functions
3537  *
3538  *****************************************************************************
3539  */
3540 
3541 /*
3542  * Free a used ticket when its refcount falls to zero.
3543  */
3544 void
3545 xfs_log_ticket_put(
3546 	xlog_ticket_t	*ticket)
3547 {
3548 	ASSERT(atomic_read(&ticket->t_ref) > 0);
3549 	if (atomic_dec_and_test(&ticket->t_ref))
3550 		kmem_zone_free(xfs_log_ticket_zone, ticket);
3551 }
3552 
3553 xlog_ticket_t *
3554 xfs_log_ticket_get(
3555 	xlog_ticket_t	*ticket)
3556 {
3557 	ASSERT(atomic_read(&ticket->t_ref) > 0);
3558 	atomic_inc(&ticket->t_ref);
3559 	return ticket;
3560 }
3561 
3562 /*
3563  * Figure out the total log space unit (in bytes) that would be
3564  * required for a log ticket.
3565  */
3566 int
3567 xfs_log_calc_unit_res(
3568 	struct xfs_mount	*mp,
3569 	int			unit_bytes)
3570 {
3571 	struct xlog		*log = mp->m_log;
3572 	int			iclog_space;
3573 	uint			num_headers;
3574 
3575 	/*
3576 	 * Permanent reservations have up to 'cnt'-1 active log operations
3577 	 * in the log.  A unit in this case is the amount of space for one
3578 	 * of these log operations.  Normal reservations have a cnt of 1
3579 	 * and their unit amount is the total amount of space required.
3580 	 *
3581 	 * The following lines of code account for non-transaction data
3582 	 * which occupy space in the on-disk log.
3583 	 *
3584 	 * Normal form of a transaction is:
3585 	 * <oph><trans-hdr><start-oph><reg1-oph><reg1><reg2-oph>...<commit-oph>
3586 	 * and then there are LR hdrs, split-recs and roundoff at end of syncs.
3587 	 *
3588 	 * We need to account for all the leadup data and trailer data
3589 	 * around the transaction data.
3590 	 * And then we need to account for the worst case in terms of using
3591 	 * more space.
3592 	 * The worst case will happen if:
3593 	 * - the placement of the transaction happens to be such that the
3594 	 *   roundoff is at its maximum
3595 	 * - the transaction data is synced before the commit record is synced
3596 	 *   i.e. <transaction-data><roundoff> | <commit-rec><roundoff>
3597 	 *   Therefore the commit record is in its own Log Record.
3598 	 *   This can happen as the commit record is called with its
3599 	 *   own region to xlog_write().
3600 	 *   This then means that in the worst case, roundoff can happen for
3601 	 *   the commit-rec as well.
3602 	 *   The commit-rec is smaller than padding in this scenario and so it is
3603 	 *   not added separately.
3604 	 */
3605 
3606 	/* for trans header */
3607 	unit_bytes += sizeof(xlog_op_header_t);
3608 	unit_bytes += sizeof(xfs_trans_header_t);
3609 
3610 	/* for start-rec */
3611 	unit_bytes += sizeof(xlog_op_header_t);
3612 
3613 	/*
3614 	 * for LR headers - the space for data in an iclog is the size minus
3615 	 * the space used for the headers. If we use the iclog size, then we
3616 	 * undercalculate the number of headers required.
3617 	 *
3618 	 * Furthermore - the addition of op headers for split-recs might
3619 	 * increase the space required enough to require more log and op
3620 	 * headers, so take that into account too.
3621 	 *
3622 	 * IMPORTANT: This reservation makes the assumption that if this
3623 	 * transaction is the first in an iclog and hence has the LR headers
3624 	 * accounted to it, then the remaining space in the iclog is
3625 	 * exclusively for this transaction.  i.e. if the transaction is larger
3626 	 * than the iclog, it will be the only thing in that iclog.
3627 	 * Fundamentally, this means we must pass the entire log vector to
3628 	 * xlog_write to guarantee this.
3629 	 */
3630 	iclog_space = log->l_iclog_size - log->l_iclog_hsize;
3631 	num_headers = howmany(unit_bytes, iclog_space);
3632 
3633 	/* for split-recs - ophdrs added when data split over LRs */
3634 	unit_bytes += sizeof(xlog_op_header_t) * num_headers;
3635 
3636 	/* add extra header reservations if we overrun */
3637 	while (!num_headers ||
3638 	       howmany(unit_bytes, iclog_space) > num_headers) {
3639 		unit_bytes += sizeof(xlog_op_header_t);
3640 		num_headers++;
3641 	}
3642 	unit_bytes += log->l_iclog_hsize * num_headers;
3643 
3644 	/* for commit-rec LR header - note: padding will subsume the ophdr */
3645 	unit_bytes += log->l_iclog_hsize;
3646 
3647 	/* for roundoff padding for transaction data and one for commit record */
3648 	if (xfs_sb_version_haslogv2(&mp->m_sb) && mp->m_sb.sb_logsunit > 1) {
3649 		/* log su roundoff */
3650 		unit_bytes += 2 * mp->m_sb.sb_logsunit;
3651 	} else {
3652 		/* BB roundoff */
3653 		unit_bytes += 2 * BBSIZE;
3654         }
3655 
3656 	return unit_bytes;
3657 }
3658 
3659 /*
3660  * Allocate and initialise a new log ticket.
3661  */
3662 struct xlog_ticket *
3663 xlog_ticket_alloc(
3664 	struct xlog		*log,
3665 	int			unit_bytes,
3666 	int			cnt,
3667 	char			client,
3668 	bool			permanent,
3669 	xfs_km_flags_t		alloc_flags)
3670 {
3671 	struct xlog_ticket	*tic;
3672 	int			unit_res;
3673 
3674 	tic = kmem_zone_zalloc(xfs_log_ticket_zone, alloc_flags);
3675 	if (!tic)
3676 		return NULL;
3677 
3678 	unit_res = xfs_log_calc_unit_res(log->l_mp, unit_bytes);
3679 
3680 	atomic_set(&tic->t_ref, 1);
3681 	tic->t_task		= current;
3682 	INIT_LIST_HEAD(&tic->t_queue);
3683 	tic->t_unit_res		= unit_res;
3684 	tic->t_curr_res		= unit_res;
3685 	tic->t_cnt		= cnt;
3686 	tic->t_ocnt		= cnt;
3687 	tic->t_tid		= prandom_u32();
3688 	tic->t_clientid		= client;
3689 	tic->t_flags		= XLOG_TIC_INITED;
3690 	if (permanent)
3691 		tic->t_flags |= XLOG_TIC_PERM_RESERV;
3692 
3693 	xlog_tic_reset_res(tic);
3694 
3695 	return tic;
3696 }
3697 
3698 
3699 /******************************************************************************
3700  *
3701  *		Log debug routines
3702  *
3703  ******************************************************************************
3704  */
3705 #if defined(DEBUG)
3706 /*
3707  * Make sure that the destination ptr is within the valid data region of
3708  * one of the iclogs.  This uses backup pointers stored in a different
3709  * part of the log in case we trash the log structure.
3710  */
3711 void
3712 xlog_verify_dest_ptr(
3713 	struct xlog	*log,
3714 	void		*ptr)
3715 {
3716 	int i;
3717 	int good_ptr = 0;
3718 
3719 	for (i = 0; i < log->l_iclog_bufs; i++) {
3720 		if (ptr >= log->l_iclog_bak[i] &&
3721 		    ptr <= log->l_iclog_bak[i] + log->l_iclog_size)
3722 			good_ptr++;
3723 	}
3724 
3725 	if (!good_ptr)
3726 		xfs_emerg(log->l_mp, "%s: invalid ptr", __func__);
3727 }
3728 
3729 /*
3730  * Check to make sure the grant write head didn't just over lap the tail.  If
3731  * the cycles are the same, we can't be overlapping.  Otherwise, make sure that
3732  * the cycles differ by exactly one and check the byte count.
3733  *
3734  * This check is run unlocked, so can give false positives. Rather than assert
3735  * on failures, use a warn-once flag and a panic tag to allow the admin to
3736  * determine if they want to panic the machine when such an error occurs. For
3737  * debug kernels this will have the same effect as using an assert but, unlinke
3738  * an assert, it can be turned off at runtime.
3739  */
3740 STATIC void
3741 xlog_verify_grant_tail(
3742 	struct xlog	*log)
3743 {
3744 	int		tail_cycle, tail_blocks;
3745 	int		cycle, space;
3746 
3747 	xlog_crack_grant_head(&log->l_write_head.grant, &cycle, &space);
3748 	xlog_crack_atomic_lsn(&log->l_tail_lsn, &tail_cycle, &tail_blocks);
3749 	if (tail_cycle != cycle) {
3750 		if (cycle - 1 != tail_cycle &&
3751 		    !(log->l_flags & XLOG_TAIL_WARN)) {
3752 			xfs_alert_tag(log->l_mp, XFS_PTAG_LOGRES,
3753 				"%s: cycle - 1 != tail_cycle", __func__);
3754 			log->l_flags |= XLOG_TAIL_WARN;
3755 		}
3756 
3757 		if (space > BBTOB(tail_blocks) &&
3758 		    !(log->l_flags & XLOG_TAIL_WARN)) {
3759 			xfs_alert_tag(log->l_mp, XFS_PTAG_LOGRES,
3760 				"%s: space > BBTOB(tail_blocks)", __func__);
3761 			log->l_flags |= XLOG_TAIL_WARN;
3762 		}
3763 	}
3764 }
3765 
3766 /* check if it will fit */
3767 STATIC void
3768 xlog_verify_tail_lsn(
3769 	struct xlog		*log,
3770 	struct xlog_in_core	*iclog,
3771 	xfs_lsn_t		tail_lsn)
3772 {
3773     int blocks;
3774 
3775     if (CYCLE_LSN(tail_lsn) == log->l_prev_cycle) {
3776 	blocks =
3777 	    log->l_logBBsize - (log->l_prev_block - BLOCK_LSN(tail_lsn));
3778 	if (blocks < BTOBB(iclog->ic_offset)+BTOBB(log->l_iclog_hsize))
3779 		xfs_emerg(log->l_mp, "%s: ran out of log space", __func__);
3780     } else {
3781 	ASSERT(CYCLE_LSN(tail_lsn)+1 == log->l_prev_cycle);
3782 
3783 	if (BLOCK_LSN(tail_lsn) == log->l_prev_block)
3784 		xfs_emerg(log->l_mp, "%s: tail wrapped", __func__);
3785 
3786 	blocks = BLOCK_LSN(tail_lsn) - log->l_prev_block;
3787 	if (blocks < BTOBB(iclog->ic_offset) + 1)
3788 		xfs_emerg(log->l_mp, "%s: ran out of log space", __func__);
3789     }
3790 }	/* xlog_verify_tail_lsn */
3791 
3792 /*
3793  * Perform a number of checks on the iclog before writing to disk.
3794  *
3795  * 1. Make sure the iclogs are still circular
3796  * 2. Make sure we have a good magic number
3797  * 3. Make sure we don't have magic numbers in the data
3798  * 4. Check fields of each log operation header for:
3799  *	A. Valid client identifier
3800  *	B. tid ptr value falls in valid ptr space (user space code)
3801  *	C. Length in log record header is correct according to the
3802  *		individual operation headers within record.
3803  * 5. When a bwrite will occur within 5 blocks of the front of the physical
3804  *	log, check the preceding blocks of the physical log to make sure all
3805  *	the cycle numbers agree with the current cycle number.
3806  */
3807 STATIC void
3808 xlog_verify_iclog(
3809 	struct xlog		*log,
3810 	struct xlog_in_core	*iclog,
3811 	int			count,
3812 	bool                    syncing)
3813 {
3814 	xlog_op_header_t	*ophead;
3815 	xlog_in_core_t		*icptr;
3816 	xlog_in_core_2_t	*xhdr;
3817 	void			*base_ptr, *ptr, *p;
3818 	ptrdiff_t		field_offset;
3819 	uint8_t			clientid;
3820 	int			len, i, j, k, op_len;
3821 	int			idx;
3822 
3823 	/* check validity of iclog pointers */
3824 	spin_lock(&log->l_icloglock);
3825 	icptr = log->l_iclog;
3826 	for (i = 0; i < log->l_iclog_bufs; i++, icptr = icptr->ic_next)
3827 		ASSERT(icptr);
3828 
3829 	if (icptr != log->l_iclog)
3830 		xfs_emerg(log->l_mp, "%s: corrupt iclog ring", __func__);
3831 	spin_unlock(&log->l_icloglock);
3832 
3833 	/* check log magic numbers */
3834 	if (iclog->ic_header.h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM))
3835 		xfs_emerg(log->l_mp, "%s: invalid magic num", __func__);
3836 
3837 	base_ptr = ptr = &iclog->ic_header;
3838 	p = &iclog->ic_header;
3839 	for (ptr += BBSIZE; ptr < base_ptr + count; ptr += BBSIZE) {
3840 		if (*(__be32 *)ptr == cpu_to_be32(XLOG_HEADER_MAGIC_NUM))
3841 			xfs_emerg(log->l_mp, "%s: unexpected magic num",
3842 				__func__);
3843 	}
3844 
3845 	/* check fields */
3846 	len = be32_to_cpu(iclog->ic_header.h_num_logops);
3847 	base_ptr = ptr = iclog->ic_datap;
3848 	ophead = ptr;
3849 	xhdr = iclog->ic_data;
3850 	for (i = 0; i < len; i++) {
3851 		ophead = ptr;
3852 
3853 		/* clientid is only 1 byte */
3854 		p = &ophead->oh_clientid;
3855 		field_offset = p - base_ptr;
3856 		if (!syncing || (field_offset & 0x1ff)) {
3857 			clientid = ophead->oh_clientid;
3858 		} else {
3859 			idx = BTOBBT((char *)&ophead->oh_clientid - iclog->ic_datap);
3860 			if (idx >= (XLOG_HEADER_CYCLE_SIZE / BBSIZE)) {
3861 				j = idx / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3862 				k = idx % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3863 				clientid = xlog_get_client_id(
3864 					xhdr[j].hic_xheader.xh_cycle_data[k]);
3865 			} else {
3866 				clientid = xlog_get_client_id(
3867 					iclog->ic_header.h_cycle_data[idx]);
3868 			}
3869 		}
3870 		if (clientid != XFS_TRANSACTION && clientid != XFS_LOG)
3871 			xfs_warn(log->l_mp,
3872 				"%s: invalid clientid %d op 0x%p offset 0x%lx",
3873 				__func__, clientid, ophead,
3874 				(unsigned long)field_offset);
3875 
3876 		/* check length */
3877 		p = &ophead->oh_len;
3878 		field_offset = p - base_ptr;
3879 		if (!syncing || (field_offset & 0x1ff)) {
3880 			op_len = be32_to_cpu(ophead->oh_len);
3881 		} else {
3882 			idx = BTOBBT((uintptr_t)&ophead->oh_len -
3883 				    (uintptr_t)iclog->ic_datap);
3884 			if (idx >= (XLOG_HEADER_CYCLE_SIZE / BBSIZE)) {
3885 				j = idx / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3886 				k = idx % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3887 				op_len = be32_to_cpu(xhdr[j].hic_xheader.xh_cycle_data[k]);
3888 			} else {
3889 				op_len = be32_to_cpu(iclog->ic_header.h_cycle_data[idx]);
3890 			}
3891 		}
3892 		ptr += sizeof(xlog_op_header_t) + op_len;
3893 	}
3894 }	/* xlog_verify_iclog */
3895 #endif
3896 
3897 /*
3898  * Mark all iclogs IOERROR. l_icloglock is held by the caller.
3899  */
3900 STATIC int
3901 xlog_state_ioerror(
3902 	struct xlog	*log)
3903 {
3904 	xlog_in_core_t	*iclog, *ic;
3905 
3906 	iclog = log->l_iclog;
3907 	if (! (iclog->ic_state & XLOG_STATE_IOERROR)) {
3908 		/*
3909 		 * Mark all the incore logs IOERROR.
3910 		 * From now on, no log flushes will result.
3911 		 */
3912 		ic = iclog;
3913 		do {
3914 			ic->ic_state = XLOG_STATE_IOERROR;
3915 			ic = ic->ic_next;
3916 		} while (ic != iclog);
3917 		return 0;
3918 	}
3919 	/*
3920 	 * Return non-zero, if state transition has already happened.
3921 	 */
3922 	return 1;
3923 }
3924 
3925 /*
3926  * This is called from xfs_force_shutdown, when we're forcibly
3927  * shutting down the filesystem, typically because of an IO error.
3928  * Our main objectives here are to make sure that:
3929  *	a. if !logerror, flush the logs to disk. Anything modified
3930  *	   after this is ignored.
3931  *	b. the filesystem gets marked 'SHUTDOWN' for all interested
3932  *	   parties to find out, 'atomically'.
3933  *	c. those who're sleeping on log reservations, pinned objects and
3934  *	    other resources get woken up, and be told the bad news.
3935  *	d. nothing new gets queued up after (b) and (c) are done.
3936  *
3937  * Note: for the !logerror case we need to flush the regions held in memory out
3938  * to disk first. This needs to be done before the log is marked as shutdown,
3939  * otherwise the iclog writes will fail.
3940  */
3941 int
3942 xfs_log_force_umount(
3943 	struct xfs_mount	*mp,
3944 	int			logerror)
3945 {
3946 	struct xlog	*log;
3947 	int		retval;
3948 
3949 	log = mp->m_log;
3950 
3951 	/*
3952 	 * If this happens during log recovery, don't worry about
3953 	 * locking; the log isn't open for business yet.
3954 	 */
3955 	if (!log ||
3956 	    log->l_flags & XLOG_ACTIVE_RECOVERY) {
3957 		mp->m_flags |= XFS_MOUNT_FS_SHUTDOWN;
3958 		if (mp->m_sb_bp)
3959 			mp->m_sb_bp->b_flags |= XBF_DONE;
3960 		return 0;
3961 	}
3962 
3963 	/*
3964 	 * Somebody could've already done the hard work for us.
3965 	 * No need to get locks for this.
3966 	 */
3967 	if (logerror && log->l_iclog->ic_state & XLOG_STATE_IOERROR) {
3968 		ASSERT(XLOG_FORCED_SHUTDOWN(log));
3969 		return 1;
3970 	}
3971 
3972 	/*
3973 	 * Flush all the completed transactions to disk before marking the log
3974 	 * being shut down. We need to do it in this order to ensure that
3975 	 * completed operations are safely on disk before we shut down, and that
3976 	 * we don't have to issue any buffer IO after the shutdown flags are set
3977 	 * to guarantee this.
3978 	 */
3979 	if (!logerror)
3980 		_xfs_log_force(mp, XFS_LOG_SYNC, NULL);
3981 
3982 	/*
3983 	 * mark the filesystem and the as in a shutdown state and wake
3984 	 * everybody up to tell them the bad news.
3985 	 */
3986 	spin_lock(&log->l_icloglock);
3987 	mp->m_flags |= XFS_MOUNT_FS_SHUTDOWN;
3988 	if (mp->m_sb_bp)
3989 		mp->m_sb_bp->b_flags |= XBF_DONE;
3990 
3991 	/*
3992 	 * Mark the log and the iclogs with IO error flags to prevent any
3993 	 * further log IO from being issued or completed.
3994 	 */
3995 	log->l_flags |= XLOG_IO_ERROR;
3996 	retval = xlog_state_ioerror(log);
3997 	spin_unlock(&log->l_icloglock);
3998 
3999 	/*
4000 	 * We don't want anybody waiting for log reservations after this. That
4001 	 * means we have to wake up everybody queued up on reserveq as well as
4002 	 * writeq.  In addition, we make sure in xlog_{re}grant_log_space that
4003 	 * we don't enqueue anything once the SHUTDOWN flag is set, and this
4004 	 * action is protected by the grant locks.
4005 	 */
4006 	xlog_grant_head_wake_all(&log->l_reserve_head);
4007 	xlog_grant_head_wake_all(&log->l_write_head);
4008 
4009 	/*
4010 	 * Wake up everybody waiting on xfs_log_force. Wake the CIL push first
4011 	 * as if the log writes were completed. The abort handling in the log
4012 	 * item committed callback functions will do this again under lock to
4013 	 * avoid races.
4014 	 */
4015 	wake_up_all(&log->l_cilp->xc_commit_wait);
4016 	xlog_state_do_callback(log, XFS_LI_ABORTED, NULL);
4017 
4018 #ifdef XFSERRORDEBUG
4019 	{
4020 		xlog_in_core_t	*iclog;
4021 
4022 		spin_lock(&log->l_icloglock);
4023 		iclog = log->l_iclog;
4024 		do {
4025 			ASSERT(iclog->ic_callback == 0);
4026 			iclog = iclog->ic_next;
4027 		} while (iclog != log->l_iclog);
4028 		spin_unlock(&log->l_icloglock);
4029 	}
4030 #endif
4031 	/* return non-zero if log IOERROR transition had already happened */
4032 	return retval;
4033 }
4034 
4035 STATIC int
4036 xlog_iclogs_empty(
4037 	struct xlog	*log)
4038 {
4039 	xlog_in_core_t	*iclog;
4040 
4041 	iclog = log->l_iclog;
4042 	do {
4043 		/* endianness does not matter here, zero is zero in
4044 		 * any language.
4045 		 */
4046 		if (iclog->ic_header.h_num_logops)
4047 			return 0;
4048 		iclog = iclog->ic_next;
4049 	} while (iclog != log->l_iclog);
4050 	return 1;
4051 }
4052 
4053 /*
4054  * Verify that an LSN stamped into a piece of metadata is valid. This is
4055  * intended for use in read verifiers on v5 superblocks.
4056  */
4057 bool
4058 xfs_log_check_lsn(
4059 	struct xfs_mount	*mp,
4060 	xfs_lsn_t		lsn)
4061 {
4062 	struct xlog		*log = mp->m_log;
4063 	bool			valid;
4064 
4065 	/*
4066 	 * norecovery mode skips mount-time log processing and unconditionally
4067 	 * resets the in-core LSN. We can't validate in this mode, but
4068 	 * modifications are not allowed anyways so just return true.
4069 	 */
4070 	if (mp->m_flags & XFS_MOUNT_NORECOVERY)
4071 		return true;
4072 
4073 	/*
4074 	 * Some metadata LSNs are initialized to NULL (e.g., the agfl). This is
4075 	 * handled by recovery and thus safe to ignore here.
4076 	 */
4077 	if (lsn == NULLCOMMITLSN)
4078 		return true;
4079 
4080 	valid = xlog_valid_lsn(mp->m_log, lsn);
4081 
4082 	/* warn the user about what's gone wrong before verifier failure */
4083 	if (!valid) {
4084 		spin_lock(&log->l_icloglock);
4085 		xfs_warn(mp,
4086 "Corruption warning: Metadata has LSN (%d:%d) ahead of current LSN (%d:%d). "
4087 "Please unmount and run xfs_repair (>= v4.3) to resolve.",
4088 			 CYCLE_LSN(lsn), BLOCK_LSN(lsn),
4089 			 log->l_curr_cycle, log->l_curr_block);
4090 		spin_unlock(&log->l_icloglock);
4091 	}
4092 
4093 	return valid;
4094 }
4095