1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include "xfs.h"
19#include "xfs_fs.h"
20#include "xfs_types.h"
21#include "xfs_log.h"
22#include "xfs_trans.h"
23#include "xfs_sb.h"
24#include "xfs_ag.h"
25#include "xfs_mount.h"
26#include "xfs_error.h"
27#include "xfs_log_priv.h"
28#include "xfs_buf_item.h"
29#include "xfs_bmap_btree.h"
30#include "xfs_alloc_btree.h"
31#include "xfs_ialloc_btree.h"
32#include "xfs_log_recover.h"
33#include "xfs_trans_priv.h"
34#include "xfs_dinode.h"
35#include "xfs_inode.h"
36#include "xfs_trace.h"
37#include "xfs_fsops.h"
38#include "xfs_cksum.h"
39
40kmem_zone_t *xfs_log_ticket_zone;
41
42
43STATIC int
44xlog_commit_record(
45 struct xlog *log,
46 struct xlog_ticket *ticket,
47 struct xlog_in_core **iclog,
48 xfs_lsn_t *commitlsnp);
49
50STATIC struct xlog *
51xlog_alloc_log(
52 struct xfs_mount *mp,
53 struct xfs_buftarg *log_target,
54 xfs_daddr_t blk_offset,
55 int num_bblks);
56STATIC int
57xlog_space_left(
58 struct xlog *log,
59 atomic64_t *head);
60STATIC int
61xlog_sync(
62 struct xlog *log,
63 struct xlog_in_core *iclog);
64STATIC void
65xlog_dealloc_log(
66 struct xlog *log);
67
68
69STATIC void xlog_state_done_syncing(xlog_in_core_t *iclog, int);
70STATIC void
71xlog_state_do_callback(
72 struct xlog *log,
73 int aborted,
74 struct xlog_in_core *iclog);
75STATIC int
76xlog_state_get_iclog_space(
77 struct xlog *log,
78 int len,
79 struct xlog_in_core **iclog,
80 struct xlog_ticket *ticket,
81 int *continued_write,
82 int *logoffsetp);
83STATIC int
84xlog_state_release_iclog(
85 struct xlog *log,
86 struct xlog_in_core *iclog);
87STATIC void
88xlog_state_switch_iclogs(
89 struct xlog *log,
90 struct xlog_in_core *iclog,
91 int eventual_size);
92STATIC void
93xlog_state_want_sync(
94 struct xlog *log,
95 struct xlog_in_core *iclog);
96
97STATIC void
98xlog_grant_push_ail(
99 struct xlog *log,
100 int need_bytes);
101STATIC void
102xlog_regrant_reserve_log_space(
103 struct xlog *log,
104 struct xlog_ticket *ticket);
105STATIC void
106xlog_ungrant_log_space(
107 struct xlog *log,
108 struct xlog_ticket *ticket);
109
110#if defined(DEBUG)
111STATIC void
112xlog_verify_dest_ptr(
113 struct xlog *log,
114 char *ptr);
115STATIC void
116xlog_verify_grant_tail(
117 struct xlog *log);
118STATIC void
119xlog_verify_iclog(
120 struct xlog *log,
121 struct xlog_in_core *iclog,
122 int count,
123 bool syncing);
124STATIC void
125xlog_verify_tail_lsn(
126 struct xlog *log,
127 struct xlog_in_core *iclog,
128 xfs_lsn_t tail_lsn);
129#else
130#define xlog_verify_dest_ptr(a,b)
131#define xlog_verify_grant_tail(a)
132#define xlog_verify_iclog(a,b,c,d)
133#define xlog_verify_tail_lsn(a,b,c)
134#endif
135
136STATIC int
137xlog_iclogs_empty(
138 struct xlog *log);
139
140static void
141xlog_grant_sub_space(
142 struct xlog *log,
143 atomic64_t *head,
144 int bytes)
145{
146 int64_t head_val = atomic64_read(head);
147 int64_t new, old;
148
149 do {
150 int cycle, space;
151
152 xlog_crack_grant_head_val(head_val, &cycle, &space);
153
154 space -= bytes;
155 if (space < 0) {
156 space += log->l_logsize;
157 cycle--;
158 }
159
160 old = head_val;
161 new = xlog_assign_grant_head_val(cycle, space);
162 head_val = atomic64_cmpxchg(head, old, new);
163 } while (head_val != old);
164}
165
166static void
167xlog_grant_add_space(
168 struct xlog *log,
169 atomic64_t *head,
170 int bytes)
171{
172 int64_t head_val = atomic64_read(head);
173 int64_t new, old;
174
175 do {
176 int tmp;
177 int cycle, space;
178
179 xlog_crack_grant_head_val(head_val, &cycle, &space);
180
181 tmp = log->l_logsize - space;
182 if (tmp > bytes)
183 space += bytes;
184 else {
185 space = bytes - tmp;
186 cycle++;
187 }
188
189 old = head_val;
190 new = xlog_assign_grant_head_val(cycle, space);
191 head_val = atomic64_cmpxchg(head, old, new);
192 } while (head_val != old);
193}
194
195STATIC void
196xlog_grant_head_init(
197 struct xlog_grant_head *head)
198{
199 xlog_assign_grant_head(&head->grant, 1, 0);
200 INIT_LIST_HEAD(&head->waiters);
201 spin_lock_init(&head->lock);
202}
203
204STATIC void
205xlog_grant_head_wake_all(
206 struct xlog_grant_head *head)
207{
208 struct xlog_ticket *tic;
209
210 spin_lock(&head->lock);
211 list_for_each_entry(tic, &head->waiters, t_queue)
212 wake_up_process(tic->t_task);
213 spin_unlock(&head->lock);
214}
215
216static inline int
217xlog_ticket_reservation(
218 struct xlog *log,
219 struct xlog_grant_head *head,
220 struct xlog_ticket *tic)
221{
222 if (head == &log->l_write_head) {
223 ASSERT(tic->t_flags & XLOG_TIC_PERM_RESERV);
224 return tic->t_unit_res;
225 } else {
226 if (tic->t_flags & XLOG_TIC_PERM_RESERV)
227 return tic->t_unit_res * tic->t_cnt;
228 else
229 return tic->t_unit_res;
230 }
231}
232
233STATIC bool
234xlog_grant_head_wake(
235 struct xlog *log,
236 struct xlog_grant_head *head,
237 int *free_bytes)
238{
239 struct xlog_ticket *tic;
240 int need_bytes;
241
242 list_for_each_entry(tic, &head->waiters, t_queue) {
243 need_bytes = xlog_ticket_reservation(log, head, tic);
244 if (*free_bytes < need_bytes)
245 return false;
246
247 *free_bytes -= need_bytes;
248 trace_xfs_log_grant_wake_up(log, tic);
249 wake_up_process(tic->t_task);
250 }
251
252 return true;
253}
254
255STATIC int
256xlog_grant_head_wait(
257 struct xlog *log,
258 struct xlog_grant_head *head,
259 struct xlog_ticket *tic,
260 int need_bytes) __releases(&head->lock)
261 __acquires(&head->lock)
262{
263 list_add_tail(&tic->t_queue, &head->waiters);
264
265 do {
266 if (XLOG_FORCED_SHUTDOWN(log))
267 goto shutdown;
268 xlog_grant_push_ail(log, need_bytes);
269
270 __set_current_state(TASK_UNINTERRUPTIBLE);
271 spin_unlock(&head->lock);
272
273 XFS_STATS_INC(xs_sleep_logspace);
274
275 trace_xfs_log_grant_sleep(log, tic);
276 schedule();
277 trace_xfs_log_grant_wake(log, tic);
278
279 spin_lock(&head->lock);
280 if (XLOG_FORCED_SHUTDOWN(log))
281 goto shutdown;
282 } while (xlog_space_left(log, &head->grant) < need_bytes);
283
284 list_del_init(&tic->t_queue);
285 return 0;
286shutdown:
287 list_del_init(&tic->t_queue);
288 return XFS_ERROR(EIO);
289}
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308STATIC int
309xlog_grant_head_check(
310 struct xlog *log,
311 struct xlog_grant_head *head,
312 struct xlog_ticket *tic,
313 int *need_bytes)
314{
315 int free_bytes;
316 int error = 0;
317
318 ASSERT(!(log->l_flags & XLOG_ACTIVE_RECOVERY));
319
320
321
322
323
324
325
326 *need_bytes = xlog_ticket_reservation(log, head, tic);
327 free_bytes = xlog_space_left(log, &head->grant);
328 if (!list_empty_careful(&head->waiters)) {
329 spin_lock(&head->lock);
330 if (!xlog_grant_head_wake(log, head, &free_bytes) ||
331 free_bytes < *need_bytes) {
332 error = xlog_grant_head_wait(log, head, tic,
333 *need_bytes);
334 }
335 spin_unlock(&head->lock);
336 } else if (free_bytes < *need_bytes) {
337 spin_lock(&head->lock);
338 error = xlog_grant_head_wait(log, head, tic, *need_bytes);
339 spin_unlock(&head->lock);
340 }
341
342 return error;
343}
344
345static void
346xlog_tic_reset_res(xlog_ticket_t *tic)
347{
348 tic->t_res_num = 0;
349 tic->t_res_arr_sum = 0;
350 tic->t_res_num_ophdrs = 0;
351}
352
353static void
354xlog_tic_add_region(xlog_ticket_t *tic, uint len, uint type)
355{
356 if (tic->t_res_num == XLOG_TIC_LEN_MAX) {
357
358 tic->t_res_o_flow += tic->t_res_arr_sum;
359 tic->t_res_num = 0;
360 tic->t_res_arr_sum = 0;
361 }
362
363 tic->t_res_arr[tic->t_res_num].r_len = len;
364 tic->t_res_arr[tic->t_res_num].r_type = type;
365 tic->t_res_arr_sum += len;
366 tic->t_res_num++;
367}
368
369
370
371
372int
373xfs_log_regrant(
374 struct xfs_mount *mp,
375 struct xlog_ticket *tic)
376{
377 struct xlog *log = mp->m_log;
378 int need_bytes;
379 int error = 0;
380
381 if (XLOG_FORCED_SHUTDOWN(log))
382 return XFS_ERROR(EIO);
383
384 XFS_STATS_INC(xs_try_logspace);
385
386
387
388
389
390
391
392 tic->t_tid++;
393
394 xlog_grant_push_ail(log, tic->t_unit_res);
395
396 tic->t_curr_res = tic->t_unit_res;
397 xlog_tic_reset_res(tic);
398
399 if (tic->t_cnt > 0)
400 return 0;
401
402 trace_xfs_log_regrant(log, tic);
403
404 error = xlog_grant_head_check(log, &log->l_write_head, tic,
405 &need_bytes);
406 if (error)
407 goto out_error;
408
409 xlog_grant_add_space(log, &log->l_write_head.grant, need_bytes);
410 trace_xfs_log_regrant_exit(log, tic);
411 xlog_verify_grant_tail(log);
412 return 0;
413
414out_error:
415
416
417
418
419
420 tic->t_curr_res = 0;
421 tic->t_cnt = 0;
422 return error;
423}
424
425
426
427
428
429
430
431
432
433int
434xfs_log_reserve(
435 struct xfs_mount *mp,
436 int unit_bytes,
437 int cnt,
438 struct xlog_ticket **ticp,
439 __uint8_t client,
440 bool permanent,
441 uint t_type)
442{
443 struct xlog *log = mp->m_log;
444 struct xlog_ticket *tic;
445 int need_bytes;
446 int error = 0;
447
448 ASSERT(client == XFS_TRANSACTION || client == XFS_LOG);
449
450 if (XLOG_FORCED_SHUTDOWN(log))
451 return XFS_ERROR(EIO);
452
453 XFS_STATS_INC(xs_try_logspace);
454
455 ASSERT(*ticp == NULL);
456 tic = xlog_ticket_alloc(log, unit_bytes, cnt, client, permanent,
457 KM_SLEEP | KM_MAYFAIL);
458 if (!tic)
459 return XFS_ERROR(ENOMEM);
460
461 tic->t_trans_type = t_type;
462 *ticp = tic;
463
464 xlog_grant_push_ail(log, tic->t_cnt ? tic->t_unit_res * tic->t_cnt
465 : tic->t_unit_res);
466
467 trace_xfs_log_reserve(log, tic);
468
469 error = xlog_grant_head_check(log, &log->l_reserve_head, tic,
470 &need_bytes);
471 if (error)
472 goto out_error;
473
474 xlog_grant_add_space(log, &log->l_reserve_head.grant, need_bytes);
475 xlog_grant_add_space(log, &log->l_write_head.grant, need_bytes);
476 trace_xfs_log_reserve_exit(log, tic);
477 xlog_verify_grant_tail(log);
478 return 0;
479
480out_error:
481
482
483
484
485
486 tic->t_curr_res = 0;
487 tic->t_cnt = 0;
488 return error;
489}
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513xfs_lsn_t
514xfs_log_done(
515 struct xfs_mount *mp,
516 struct xlog_ticket *ticket,
517 struct xlog_in_core **iclog,
518 uint flags)
519{
520 struct xlog *log = mp->m_log;
521 xfs_lsn_t lsn = 0;
522
523 if (XLOG_FORCED_SHUTDOWN(log) ||
524
525
526
527
528 (((ticket->t_flags & XLOG_TIC_INITED) == 0) &&
529 (xlog_commit_record(log, ticket, iclog, &lsn)))) {
530 lsn = (xfs_lsn_t) -1;
531 if (ticket->t_flags & XLOG_TIC_PERM_RESERV) {
532 flags |= XFS_LOG_REL_PERM_RESERV;
533 }
534 }
535
536
537 if ((ticket->t_flags & XLOG_TIC_PERM_RESERV) == 0 ||
538 (flags & XFS_LOG_REL_PERM_RESERV)) {
539 trace_xfs_log_done_nonperm(log, ticket);
540
541
542
543
544
545 xlog_ungrant_log_space(log, ticket);
546 xfs_log_ticket_put(ticket);
547 } else {
548 trace_xfs_log_done_perm(log, ticket);
549
550 xlog_regrant_reserve_log_space(log, ticket);
551
552
553
554
555 ticket->t_flags |= XLOG_TIC_INITED;
556 }
557
558 return lsn;
559}
560
561
562
563
564
565
566
567int
568xfs_log_notify(
569 struct xfs_mount *mp,
570 struct xlog_in_core *iclog,
571 xfs_log_callback_t *cb)
572{
573 int abortflg;
574
575 spin_lock(&iclog->ic_callback_lock);
576 abortflg = (iclog->ic_state & XLOG_STATE_IOERROR);
577 if (!abortflg) {
578 ASSERT_ALWAYS((iclog->ic_state == XLOG_STATE_ACTIVE) ||
579 (iclog->ic_state == XLOG_STATE_WANT_SYNC));
580 cb->cb_next = NULL;
581 *(iclog->ic_callback_tail) = cb;
582 iclog->ic_callback_tail = &(cb->cb_next);
583 }
584 spin_unlock(&iclog->ic_callback_lock);
585 return abortflg;
586}
587
588int
589xfs_log_release_iclog(
590 struct xfs_mount *mp,
591 struct xlog_in_core *iclog)
592{
593 if (xlog_state_release_iclog(mp->m_log, iclog)) {
594 xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
595 return EIO;
596 }
597
598 return 0;
599}
600
601
602
603
604
605
606
607
608
609
610
611int
612xfs_log_mount(
613 xfs_mount_t *mp,
614 xfs_buftarg_t *log_target,
615 xfs_daddr_t blk_offset,
616 int num_bblks)
617{
618 int error = 0;
619 int min_logfsbs;
620
621 if (!(mp->m_flags & XFS_MOUNT_NORECOVERY))
622 xfs_notice(mp, "Mounting Filesystem");
623 else {
624 xfs_notice(mp,
625"Mounting filesystem in no-recovery mode. Filesystem will be inconsistent.");
626 ASSERT(mp->m_flags & XFS_MOUNT_RDONLY);
627 }
628
629 mp->m_log = xlog_alloc_log(mp, log_target, blk_offset, num_bblks);
630 if (IS_ERR(mp->m_log)) {
631 error = -PTR_ERR(mp->m_log);
632 goto out;
633 }
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649 min_logfsbs = xfs_log_calc_minimum_size(mp);
650
651 if (mp->m_sb.sb_logblocks < min_logfsbs) {
652 xfs_warn(mp,
653 "Log size %d blocks too small, minimum size is %d blocks",
654 mp->m_sb.sb_logblocks, min_logfsbs);
655 error = EINVAL;
656 } else if (mp->m_sb.sb_logblocks > XFS_MAX_LOG_BLOCKS) {
657 xfs_warn(mp,
658 "Log size %d blocks too large, maximum size is %lld blocks",
659 mp->m_sb.sb_logblocks, XFS_MAX_LOG_BLOCKS);
660 error = EINVAL;
661 } else if (XFS_FSB_TO_B(mp, mp->m_sb.sb_logblocks) > XFS_MAX_LOG_BYTES) {
662 xfs_warn(mp,
663 "log size %lld bytes too large, maximum size is %lld bytes",
664 XFS_FSB_TO_B(mp, mp->m_sb.sb_logblocks),
665 XFS_MAX_LOG_BYTES);
666 error = EINVAL;
667 }
668 if (error) {
669 if (xfs_sb_version_hascrc(&mp->m_sb)) {
670 xfs_crit(mp, "AAIEEE! Log failed size checks. Abort!");
671 ASSERT(0);
672 goto out_free_log;
673 }
674 xfs_crit(mp,
675"Log size out of supported range. Continuing onwards, but if log hangs are\n"
676"experienced then please report this message in the bug report.");
677 }
678
679
680
681
682 error = xfs_trans_ail_init(mp);
683 if (error) {
684 xfs_warn(mp, "AIL initialisation failed: error %d", error);
685 goto out_free_log;
686 }
687 mp->m_log->l_ailp = mp->m_ail;
688
689
690
691
692
693 if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) {
694 int readonly = (mp->m_flags & XFS_MOUNT_RDONLY);
695
696 if (readonly)
697 mp->m_flags &= ~XFS_MOUNT_RDONLY;
698
699 error = xlog_recover(mp->m_log);
700
701 if (readonly)
702 mp->m_flags |= XFS_MOUNT_RDONLY;
703 if (error) {
704 xfs_warn(mp, "log mount/recovery failed: error %d",
705 error);
706 goto out_destroy_ail;
707 }
708 }
709
710
711 mp->m_log->l_flags &= ~XLOG_ACTIVE_RECOVERY;
712
713
714
715
716
717
718 xlog_cil_init_post_recovery(mp->m_log);
719
720 return 0;
721
722out_destroy_ail:
723 xfs_trans_ail_destroy(mp);
724out_free_log:
725 xlog_dealloc_log(mp->m_log);
726out:
727 return error;
728}
729
730
731
732
733
734
735
736
737
738
739
740int
741xfs_log_mount_finish(xfs_mount_t *mp)
742{
743 int error = 0;
744
745 if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) {
746 error = xlog_recover_finish(mp->m_log);
747 if (!error)
748 xfs_log_work_queue(mp);
749 } else {
750 ASSERT(mp->m_flags & XFS_MOUNT_RDONLY);
751 }
752
753
754 return error;
755}
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773int
774xfs_log_unmount_write(xfs_mount_t *mp)
775{
776 struct xlog *log = mp->m_log;
777 xlog_in_core_t *iclog;
778#ifdef DEBUG
779 xlog_in_core_t *first_iclog;
780#endif
781 xlog_ticket_t *tic = NULL;
782 xfs_lsn_t lsn;
783 int error;
784
785
786
787
788
789 if (mp->m_flags & XFS_MOUNT_RDONLY)
790 return 0;
791
792 error = _xfs_log_force(mp, XFS_LOG_SYNC, NULL);
793 ASSERT(error || !(XLOG_FORCED_SHUTDOWN(log)));
794
795#ifdef DEBUG
796 first_iclog = iclog = log->l_iclog;
797 do {
798 if (!(iclog->ic_state & XLOG_STATE_IOERROR)) {
799 ASSERT(iclog->ic_state & XLOG_STATE_ACTIVE);
800 ASSERT(iclog->ic_offset == 0);
801 }
802 iclog = iclog->ic_next;
803 } while (iclog != first_iclog);
804#endif
805 if (! (XLOG_FORCED_SHUTDOWN(log))) {
806 error = xfs_log_reserve(mp, 600, 1, &tic,
807 XFS_LOG, 0, XLOG_UNMOUNT_REC_TYPE);
808 if (!error) {
809
810 struct {
811 __uint16_t magic;
812 __uint16_t pad1;
813 __uint32_t pad2;
814 } magic = {
815 .magic = XLOG_UNMOUNT_TYPE,
816 };
817 struct xfs_log_iovec reg = {
818 .i_addr = &magic,
819 .i_len = sizeof(magic),
820 .i_type = XLOG_REG_TYPE_UNMOUNT,
821 };
822 struct xfs_log_vec vec = {
823 .lv_niovecs = 1,
824 .lv_iovecp = ®,
825 };
826
827
828 tic->t_flags = 0;
829 tic->t_curr_res -= sizeof(magic);
830 error = xlog_write(log, &vec, tic, &lsn,
831 NULL, XLOG_UNMOUNT_TRANS);
832
833
834
835
836
837 }
838
839 if (error)
840 xfs_alert(mp, "%s: unmount record failed", __func__);
841
842
843 spin_lock(&log->l_icloglock);
844 iclog = log->l_iclog;
845 atomic_inc(&iclog->ic_refcnt);
846 xlog_state_want_sync(log, iclog);
847 spin_unlock(&log->l_icloglock);
848 error = xlog_state_release_iclog(log, iclog);
849
850 spin_lock(&log->l_icloglock);
851 if (!(iclog->ic_state == XLOG_STATE_ACTIVE ||
852 iclog->ic_state == XLOG_STATE_DIRTY)) {
853 if (!XLOG_FORCED_SHUTDOWN(log)) {
854 xlog_wait(&iclog->ic_force_wait,
855 &log->l_icloglock);
856 } else {
857 spin_unlock(&log->l_icloglock);
858 }
859 } else {
860 spin_unlock(&log->l_icloglock);
861 }
862 if (tic) {
863 trace_xfs_log_umount_write(log, tic);
864 xlog_ungrant_log_space(log, tic);
865 xfs_log_ticket_put(tic);
866 }
867 } else {
868
869
870
871
872
873
874
875
876
877
878
879
880
881 spin_lock(&log->l_icloglock);
882 iclog = log->l_iclog;
883 atomic_inc(&iclog->ic_refcnt);
884
885 xlog_state_want_sync(log, iclog);
886 spin_unlock(&log->l_icloglock);
887 error = xlog_state_release_iclog(log, iclog);
888
889 spin_lock(&log->l_icloglock);
890
891 if ( ! ( iclog->ic_state == XLOG_STATE_ACTIVE
892 || iclog->ic_state == XLOG_STATE_DIRTY
893 || iclog->ic_state == XLOG_STATE_IOERROR) ) {
894
895 xlog_wait(&iclog->ic_force_wait,
896 &log->l_icloglock);
897 } else {
898 spin_unlock(&log->l_icloglock);
899 }
900 }
901
902 return error;
903}
904
905
906
907
908
909
910
911
912
913
914void
915xfs_log_quiesce(
916 struct xfs_mount *mp)
917{
918 cancel_delayed_work_sync(&mp->m_log->l_work);
919 xfs_log_force(mp, XFS_LOG_SYNC);
920
921
922
923
924
925
926
927
928 xfs_ail_push_all_sync(mp->m_ail);
929 xfs_wait_buftarg(mp->m_ddev_targp);
930 xfs_buf_lock(mp->m_sb_bp);
931 xfs_buf_unlock(mp->m_sb_bp);
932
933 xfs_log_unmount_write(mp);
934}
935
936
937
938
939
940
941
942
943void
944xfs_log_unmount(
945 struct xfs_mount *mp)
946{
947 xfs_log_quiesce(mp);
948
949 xfs_trans_ail_destroy(mp);
950 xlog_dealloc_log(mp->m_log);
951}
952
953void
954xfs_log_item_init(
955 struct xfs_mount *mp,
956 struct xfs_log_item *item,
957 int type,
958 const struct xfs_item_ops *ops)
959{
960 item->li_mountp = mp;
961 item->li_ailp = mp->m_ail;
962 item->li_type = type;
963 item->li_ops = ops;
964 item->li_lv = NULL;
965
966 INIT_LIST_HEAD(&item->li_ail);
967 INIT_LIST_HEAD(&item->li_cil);
968}
969
970
971
972
973void
974xfs_log_space_wake(
975 struct xfs_mount *mp)
976{
977 struct xlog *log = mp->m_log;
978 int free_bytes;
979
980 if (XLOG_FORCED_SHUTDOWN(log))
981 return;
982
983 if (!list_empty_careful(&log->l_write_head.waiters)) {
984 ASSERT(!(log->l_flags & XLOG_ACTIVE_RECOVERY));
985
986 spin_lock(&log->l_write_head.lock);
987 free_bytes = xlog_space_left(log, &log->l_write_head.grant);
988 xlog_grant_head_wake(log, &log->l_write_head, &free_bytes);
989 spin_unlock(&log->l_write_head.lock);
990 }
991
992 if (!list_empty_careful(&log->l_reserve_head.waiters)) {
993 ASSERT(!(log->l_flags & XLOG_ACTIVE_RECOVERY));
994
995 spin_lock(&log->l_reserve_head.lock);
996 free_bytes = xlog_space_left(log, &log->l_reserve_head.grant);
997 xlog_grant_head_wake(log, &log->l_reserve_head, &free_bytes);
998 spin_unlock(&log->l_reserve_head.lock);
999 }
1000}
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015int
1016xfs_log_need_covered(xfs_mount_t *mp)
1017{
1018 int needed = 0;
1019 struct xlog *log = mp->m_log;
1020
1021 if (!xfs_fs_writable(mp))
1022 return 0;
1023
1024 spin_lock(&log->l_icloglock);
1025 switch (log->l_covered_state) {
1026 case XLOG_STATE_COVER_DONE:
1027 case XLOG_STATE_COVER_DONE2:
1028 case XLOG_STATE_COVER_IDLE:
1029 break;
1030 case XLOG_STATE_COVER_NEED:
1031 case XLOG_STATE_COVER_NEED2:
1032 if (!xfs_ail_min_lsn(log->l_ailp) &&
1033 xlog_iclogs_empty(log)) {
1034 if (log->l_covered_state == XLOG_STATE_COVER_NEED)
1035 log->l_covered_state = XLOG_STATE_COVER_DONE;
1036 else
1037 log->l_covered_state = XLOG_STATE_COVER_DONE2;
1038 }
1039
1040 default:
1041 needed = 1;
1042 break;
1043 }
1044 spin_unlock(&log->l_icloglock);
1045 return needed;
1046}
1047
1048
1049
1050
1051xfs_lsn_t
1052xlog_assign_tail_lsn_locked(
1053 struct xfs_mount *mp)
1054{
1055 struct xlog *log = mp->m_log;
1056 struct xfs_log_item *lip;
1057 xfs_lsn_t tail_lsn;
1058
1059 assert_spin_locked(&mp->m_ail->xa_lock);
1060
1061
1062
1063
1064
1065
1066 lip = xfs_ail_min(mp->m_ail);
1067 if (lip)
1068 tail_lsn = lip->li_lsn;
1069 else
1070 tail_lsn = atomic64_read(&log->l_last_sync_lsn);
1071 atomic64_set(&log->l_tail_lsn, tail_lsn);
1072 return tail_lsn;
1073}
1074
1075xfs_lsn_t
1076xlog_assign_tail_lsn(
1077 struct xfs_mount *mp)
1078{
1079 xfs_lsn_t tail_lsn;
1080
1081 spin_lock(&mp->m_ail->xa_lock);
1082 tail_lsn = xlog_assign_tail_lsn_locked(mp);
1083 spin_unlock(&mp->m_ail->xa_lock);
1084
1085 return tail_lsn;
1086}
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102STATIC int
1103xlog_space_left(
1104 struct xlog *log,
1105 atomic64_t *head)
1106{
1107 int free_bytes;
1108 int tail_bytes;
1109 int tail_cycle;
1110 int head_cycle;
1111 int head_bytes;
1112
1113 xlog_crack_grant_head(head, &head_cycle, &head_bytes);
1114 xlog_crack_atomic_lsn(&log->l_tail_lsn, &tail_cycle, &tail_bytes);
1115 tail_bytes = BBTOB(tail_bytes);
1116 if (tail_cycle == head_cycle && head_bytes >= tail_bytes)
1117 free_bytes = log->l_logsize - (head_bytes - tail_bytes);
1118 else if (tail_cycle + 1 < head_cycle)
1119 return 0;
1120 else if (tail_cycle < head_cycle) {
1121 ASSERT(tail_cycle == (head_cycle - 1));
1122 free_bytes = tail_bytes - head_bytes;
1123 } else {
1124
1125
1126
1127
1128
1129 xfs_alert(log->l_mp,
1130 "xlog_space_left: head behind tail\n"
1131 " tail_cycle = %d, tail_bytes = %d\n"
1132 " GH cycle = %d, GH bytes = %d",
1133 tail_cycle, tail_bytes, head_cycle, head_bytes);
1134 ASSERT(0);
1135 free_bytes = log->l_logsize;
1136 }
1137 return free_bytes;
1138}
1139
1140
1141
1142
1143
1144
1145
1146
1147void
1148xlog_iodone(xfs_buf_t *bp)
1149{
1150 struct xlog_in_core *iclog = bp->b_fspriv;
1151 struct xlog *l = iclog->ic_log;
1152 int aborted = 0;
1153
1154
1155
1156
1157 if (XFS_TEST_ERROR((xfs_buf_geterror(bp)), l->l_mp,
1158 XFS_ERRTAG_IODONE_IOERR, XFS_RANDOM_IODONE_IOERR)) {
1159 xfs_buf_ioerror_alert(bp, __func__);
1160 xfs_buf_stale(bp);
1161 xfs_force_shutdown(l->l_mp, SHUTDOWN_LOG_IO_ERROR);
1162
1163
1164
1165
1166
1167 aborted = XFS_LI_ABORTED;
1168 } else if (iclog->ic_state & XLOG_STATE_IOERROR) {
1169 aborted = XFS_LI_ABORTED;
1170 }
1171
1172
1173 ASSERT(XFS_BUF_ISASYNC(bp));
1174 xlog_state_done_syncing(iclog, aborted);
1175
1176
1177
1178
1179
1180}
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191STATIC void
1192xlog_get_iclog_buffer_size(
1193 struct xfs_mount *mp,
1194 struct xlog *log)
1195{
1196 int size;
1197 int xhdrs;
1198
1199 if (mp->m_logbufs <= 0)
1200 log->l_iclog_bufs = XLOG_MAX_ICLOGS;
1201 else
1202 log->l_iclog_bufs = mp->m_logbufs;
1203
1204
1205
1206
1207 if (mp->m_logbsize > 0) {
1208 size = log->l_iclog_size = mp->m_logbsize;
1209 log->l_iclog_size_log = 0;
1210 while (size != 1) {
1211 log->l_iclog_size_log++;
1212 size >>= 1;
1213 }
1214
1215 if (xfs_sb_version_haslogv2(&mp->m_sb)) {
1216
1217
1218
1219
1220 xhdrs = mp->m_logbsize / XLOG_HEADER_CYCLE_SIZE;
1221 if (mp->m_logbsize % XLOG_HEADER_CYCLE_SIZE)
1222 xhdrs++;
1223 log->l_iclog_hsize = xhdrs << BBSHIFT;
1224 log->l_iclog_heads = xhdrs;
1225 } else {
1226 ASSERT(mp->m_logbsize <= XLOG_BIG_RECORD_BSIZE);
1227 log->l_iclog_hsize = BBSIZE;
1228 log->l_iclog_heads = 1;
1229 }
1230 goto done;
1231 }
1232
1233
1234 log->l_iclog_size = XLOG_BIG_RECORD_BSIZE;
1235 log->l_iclog_size_log = XLOG_BIG_RECORD_BSHIFT;
1236
1237
1238 log->l_iclog_hsize = BBSIZE;
1239 log->l_iclog_heads = 1;
1240
1241done:
1242
1243 if (mp->m_logbufs == 0)
1244 mp->m_logbufs = log->l_iclog_bufs;
1245 if (mp->m_logbsize == 0)
1246 mp->m_logbsize = log->l_iclog_size;
1247}
1248
1249
1250void
1251xfs_log_work_queue(
1252 struct xfs_mount *mp)
1253{
1254 queue_delayed_work(mp->m_log_workqueue, &mp->m_log->l_work,
1255 msecs_to_jiffies(xfs_syncd_centisecs * 10));
1256}
1257
1258
1259
1260
1261
1262
1263void
1264xfs_log_worker(
1265 struct work_struct *work)
1266{
1267 struct xlog *log = container_of(to_delayed_work(work),
1268 struct xlog, l_work);
1269 struct xfs_mount *mp = log->l_mp;
1270
1271
1272 if (xfs_log_need_covered(mp))
1273 xfs_fs_log_dummy(mp);
1274 else
1275 xfs_log_force(mp, 0);
1276
1277
1278 xfs_ail_push_all(mp->m_ail);
1279
1280
1281 xfs_log_work_queue(mp);
1282}
1283
1284
1285
1286
1287
1288
1289STATIC struct xlog *
1290xlog_alloc_log(
1291 struct xfs_mount *mp,
1292 struct xfs_buftarg *log_target,
1293 xfs_daddr_t blk_offset,
1294 int num_bblks)
1295{
1296 struct xlog *log;
1297 xlog_rec_header_t *head;
1298 xlog_in_core_t **iclogp;
1299 xlog_in_core_t *iclog, *prev_iclog=NULL;
1300 xfs_buf_t *bp;
1301 int i;
1302 int error = ENOMEM;
1303 uint log2_size = 0;
1304
1305 log = kmem_zalloc(sizeof(struct xlog), KM_MAYFAIL);
1306 if (!log) {
1307 xfs_warn(mp, "Log allocation failed: No memory!");
1308 goto out;
1309 }
1310
1311 log->l_mp = mp;
1312 log->l_targ = log_target;
1313 log->l_logsize = BBTOB(num_bblks);
1314 log->l_logBBstart = blk_offset;
1315 log->l_logBBsize = num_bblks;
1316 log->l_covered_state = XLOG_STATE_COVER_IDLE;
1317 log->l_flags |= XLOG_ACTIVE_RECOVERY;
1318 INIT_DELAYED_WORK(&log->l_work, xfs_log_worker);
1319
1320 log->l_prev_block = -1;
1321
1322 xlog_assign_atomic_lsn(&log->l_tail_lsn, 1, 0);
1323 xlog_assign_atomic_lsn(&log->l_last_sync_lsn, 1, 0);
1324 log->l_curr_cycle = 1;
1325
1326 xlog_grant_head_init(&log->l_reserve_head);
1327 xlog_grant_head_init(&log->l_write_head);
1328
1329 error = EFSCORRUPTED;
1330 if (xfs_sb_version_hassector(&mp->m_sb)) {
1331 log2_size = mp->m_sb.sb_logsectlog;
1332 if (log2_size < BBSHIFT) {
1333 xfs_warn(mp, "Log sector size too small (0x%x < 0x%x)",
1334 log2_size, BBSHIFT);
1335 goto out_free_log;
1336 }
1337
1338 log2_size -= BBSHIFT;
1339 if (log2_size > mp->m_sectbb_log) {
1340 xfs_warn(mp, "Log sector size too large (0x%x > 0x%x)",
1341 log2_size, mp->m_sectbb_log);
1342 goto out_free_log;
1343 }
1344
1345
1346 if (log2_size && log->l_logBBstart > 0 &&
1347 !xfs_sb_version_haslogv2(&mp->m_sb)) {
1348 xfs_warn(mp,
1349 "log sector size (0x%x) invalid for configuration.",
1350 log2_size);
1351 goto out_free_log;
1352 }
1353 }
1354 log->l_sectBBsize = 1 << log2_size;
1355
1356 xlog_get_iclog_buffer_size(mp, log);
1357
1358 error = ENOMEM;
1359 bp = xfs_buf_alloc(mp->m_logdev_targp, 0, BTOBB(log->l_iclog_size), 0);
1360 if (!bp)
1361 goto out_free_log;
1362 bp->b_iodone = xlog_iodone;
1363 ASSERT(xfs_buf_islocked(bp));
1364 log->l_xbuf = bp;
1365
1366 spin_lock_init(&log->l_icloglock);
1367 init_waitqueue_head(&log->l_flush_wait);
1368
1369 iclogp = &log->l_iclog;
1370
1371
1372
1373
1374
1375
1376
1377 ASSERT(log->l_iclog_size >= 4096);
1378 for (i=0; i < log->l_iclog_bufs; i++) {
1379 *iclogp = kmem_zalloc(sizeof(xlog_in_core_t), KM_MAYFAIL);
1380 if (!*iclogp)
1381 goto out_free_iclog;
1382
1383 iclog = *iclogp;
1384 iclog->ic_prev = prev_iclog;
1385 prev_iclog = iclog;
1386
1387 bp = xfs_buf_get_uncached(mp->m_logdev_targp,
1388 BTOBB(log->l_iclog_size), 0);
1389 if (!bp)
1390 goto out_free_iclog;
1391
1392 bp->b_iodone = xlog_iodone;
1393 iclog->ic_bp = bp;
1394 iclog->ic_data = bp->b_addr;
1395#ifdef DEBUG
1396 log->l_iclog_bak[i] = (xfs_caddr_t)&(iclog->ic_header);
1397#endif
1398 head = &iclog->ic_header;
1399 memset(head, 0, sizeof(xlog_rec_header_t));
1400 head->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
1401 head->h_version = cpu_to_be32(
1402 xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);
1403 head->h_size = cpu_to_be32(log->l_iclog_size);
1404
1405 head->h_fmt = cpu_to_be32(XLOG_FMT);
1406 memcpy(&head->h_fs_uuid, &mp->m_sb.sb_uuid, sizeof(uuid_t));
1407
1408 iclog->ic_size = BBTOB(bp->b_length) - log->l_iclog_hsize;
1409 iclog->ic_state = XLOG_STATE_ACTIVE;
1410 iclog->ic_log = log;
1411 atomic_set(&iclog->ic_refcnt, 0);
1412 spin_lock_init(&iclog->ic_callback_lock);
1413 iclog->ic_callback_tail = &(iclog->ic_callback);
1414 iclog->ic_datap = (char *)iclog->ic_data + log->l_iclog_hsize;
1415
1416 ASSERT(xfs_buf_islocked(iclog->ic_bp));
1417 init_waitqueue_head(&iclog->ic_force_wait);
1418 init_waitqueue_head(&iclog->ic_write_wait);
1419
1420 iclogp = &iclog->ic_next;
1421 }
1422 *iclogp = log->l_iclog;
1423 log->l_iclog->ic_prev = prev_iclog;
1424
1425 error = xlog_cil_init(log);
1426 if (error)
1427 goto out_free_iclog;
1428 return log;
1429
1430out_free_iclog:
1431 for (iclog = log->l_iclog; iclog; iclog = prev_iclog) {
1432 prev_iclog = iclog->ic_next;
1433 if (iclog->ic_bp)
1434 xfs_buf_free(iclog->ic_bp);
1435 kmem_free(iclog);
1436 }
1437 spinlock_destroy(&log->l_icloglock);
1438 xfs_buf_free(log->l_xbuf);
1439out_free_log:
1440 kmem_free(log);
1441out:
1442 return ERR_PTR(-error);
1443}
1444
1445
1446
1447
1448
1449
1450STATIC int
1451xlog_commit_record(
1452 struct xlog *log,
1453 struct xlog_ticket *ticket,
1454 struct xlog_in_core **iclog,
1455 xfs_lsn_t *commitlsnp)
1456{
1457 struct xfs_mount *mp = log->l_mp;
1458 int error;
1459 struct xfs_log_iovec reg = {
1460 .i_addr = NULL,
1461 .i_len = 0,
1462 .i_type = XLOG_REG_TYPE_COMMIT,
1463 };
1464 struct xfs_log_vec vec = {
1465 .lv_niovecs = 1,
1466 .lv_iovecp = ®,
1467 };
1468
1469 ASSERT_ALWAYS(iclog);
1470 error = xlog_write(log, &vec, ticket, commitlsnp, iclog,
1471 XLOG_COMMIT_TRANS);
1472 if (error)
1473 xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
1474 return error;
1475}
1476
1477
1478
1479
1480
1481
1482
1483
1484STATIC void
1485xlog_grant_push_ail(
1486 struct xlog *log,
1487 int need_bytes)
1488{
1489 xfs_lsn_t threshold_lsn = 0;
1490 xfs_lsn_t last_sync_lsn;
1491 int free_blocks;
1492 int free_bytes;
1493 int threshold_block;
1494 int threshold_cycle;
1495 int free_threshold;
1496
1497 ASSERT(BTOBB(need_bytes) < log->l_logBBsize);
1498
1499 free_bytes = xlog_space_left(log, &log->l_reserve_head.grant);
1500 free_blocks = BTOBBT(free_bytes);
1501
1502
1503
1504
1505
1506
1507 free_threshold = BTOBB(need_bytes);
1508 free_threshold = MAX(free_threshold, (log->l_logBBsize >> 2));
1509 free_threshold = MAX(free_threshold, 256);
1510 if (free_blocks >= free_threshold)
1511 return;
1512
1513 xlog_crack_atomic_lsn(&log->l_tail_lsn, &threshold_cycle,
1514 &threshold_block);
1515 threshold_block += free_threshold;
1516 if (threshold_block >= log->l_logBBsize) {
1517 threshold_block -= log->l_logBBsize;
1518 threshold_cycle += 1;
1519 }
1520 threshold_lsn = xlog_assign_lsn(threshold_cycle,
1521 threshold_block);
1522
1523
1524
1525
1526
1527 last_sync_lsn = atomic64_read(&log->l_last_sync_lsn);
1528 if (XFS_LSN_CMP(threshold_lsn, last_sync_lsn) > 0)
1529 threshold_lsn = last_sync_lsn;
1530
1531
1532
1533
1534
1535
1536 if (!XLOG_FORCED_SHUTDOWN(log))
1537 xfs_ail_push(log->l_ailp, threshold_lsn);
1538}
1539
1540
1541
1542
1543STATIC void
1544xlog_pack_data(
1545 struct xlog *log,
1546 struct xlog_in_core *iclog,
1547 int roundoff)
1548{
1549 int i, j, k;
1550 int size = iclog->ic_offset + roundoff;
1551 __be32 cycle_lsn;
1552 xfs_caddr_t dp;
1553
1554 cycle_lsn = CYCLE_LSN_DISK(iclog->ic_header.h_lsn);
1555
1556 dp = iclog->ic_datap;
1557 for (i = 0; i < BTOBB(size); i++) {
1558 if (i >= (XLOG_HEADER_CYCLE_SIZE / BBSIZE))
1559 break;
1560 iclog->ic_header.h_cycle_data[i] = *(__be32 *)dp;
1561 *(__be32 *)dp = cycle_lsn;
1562 dp += BBSIZE;
1563 }
1564
1565 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
1566 xlog_in_core_2_t *xhdr = iclog->ic_data;
1567
1568 for ( ; i < BTOBB(size); i++) {
1569 j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
1570 k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
1571 xhdr[j].hic_xheader.xh_cycle_data[k] = *(__be32 *)dp;
1572 *(__be32 *)dp = cycle_lsn;
1573 dp += BBSIZE;
1574 }
1575
1576 for (i = 1; i < log->l_iclog_heads; i++)
1577 xhdr[i].hic_xheader.xh_cycle = cycle_lsn;
1578 }
1579}
1580
1581
1582
1583
1584
1585
1586
1587__le32
1588xlog_cksum(
1589 struct xlog *log,
1590 struct xlog_rec_header *rhead,
1591 char *dp,
1592 int size)
1593{
1594 __uint32_t crc;
1595
1596
1597 crc = xfs_start_cksum((char *)rhead,
1598 sizeof(struct xlog_rec_header),
1599 offsetof(struct xlog_rec_header, h_crc));
1600
1601
1602 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
1603 union xlog_in_core2 *xhdr = (union xlog_in_core2 *)rhead;
1604 int i;
1605
1606 for (i = 1; i < log->l_iclog_heads; i++) {
1607 crc = crc32c(crc, &xhdr[i].hic_xheader,
1608 sizeof(struct xlog_rec_ext_header));
1609 }
1610 }
1611
1612
1613 crc = crc32c(crc, dp, size);
1614
1615 return xfs_end_cksum(crc);
1616}
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626STATIC int
1627xlog_bdstrat(
1628 struct xfs_buf *bp)
1629{
1630 struct xlog_in_core *iclog = bp->b_fspriv;
1631
1632 if (iclog->ic_state & XLOG_STATE_IOERROR) {
1633 xfs_buf_ioerror(bp, EIO);
1634 xfs_buf_stale(bp);
1635 xfs_buf_ioend(bp, 0);
1636
1637
1638
1639
1640
1641 return 0;
1642 }
1643
1644 xfs_buf_iorequest(bp);
1645 return 0;
1646}
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673STATIC int
1674xlog_sync(
1675 struct xlog *log,
1676 struct xlog_in_core *iclog)
1677{
1678 xfs_buf_t *bp;
1679 int i;
1680 uint count;
1681 uint count_init;
1682 int roundoff;
1683 int split = 0;
1684 int error;
1685 int v2 = xfs_sb_version_haslogv2(&log->l_mp->m_sb);
1686 int size;
1687
1688 XFS_STATS_INC(xs_log_writes);
1689 ASSERT(atomic_read(&iclog->ic_refcnt) == 0);
1690
1691
1692 count_init = log->l_iclog_hsize + iclog->ic_offset;
1693
1694
1695 if (v2 && log->l_mp->m_sb.sb_logsunit > 1) {
1696
1697 count = XLOG_LSUNITTOB(log, XLOG_BTOLSUNIT(log, count_init));
1698 } else {
1699 count = BBTOB(BTOBB(count_init));
1700 }
1701 roundoff = count - count_init;
1702 ASSERT(roundoff >= 0);
1703 ASSERT((v2 && log->l_mp->m_sb.sb_logsunit > 1 &&
1704 roundoff < log->l_mp->m_sb.sb_logsunit)
1705 ||
1706 (log->l_mp->m_sb.sb_logsunit <= 1 &&
1707 roundoff < BBTOB(1)));
1708
1709
1710 xlog_grant_add_space(log, &log->l_reserve_head.grant, roundoff);
1711 xlog_grant_add_space(log, &log->l_write_head.grant, roundoff);
1712
1713
1714 xlog_pack_data(log, iclog, roundoff);
1715
1716
1717 size = iclog->ic_offset;
1718 if (v2)
1719 size += roundoff;
1720 iclog->ic_header.h_len = cpu_to_be32(size);
1721
1722 bp = iclog->ic_bp;
1723 XFS_BUF_SET_ADDR(bp, BLOCK_LSN(be64_to_cpu(iclog->ic_header.h_lsn)));
1724
1725 XFS_STATS_ADD(xs_log_blocks, BTOBB(count));
1726
1727
1728 if (XFS_BUF_ADDR(bp) + BTOBB(count) > log->l_logBBsize) {
1729 char *dptr;
1730
1731 split = count - (BBTOB(log->l_logBBsize - XFS_BUF_ADDR(bp)));
1732 count = BBTOB(log->l_logBBsize - XFS_BUF_ADDR(bp));
1733 iclog->ic_bwritecnt = 2;
1734
1735
1736
1737
1738
1739
1740
1741
1742 dptr = (char *)&iclog->ic_header + count;
1743 for (i = 0; i < split; i += BBSIZE) {
1744 __uint32_t cycle = be32_to_cpu(*(__be32 *)dptr);
1745 if (++cycle == XLOG_HEADER_MAGIC_NUM)
1746 cycle++;
1747 *(__be32 *)dptr = cpu_to_be32(cycle);
1748
1749 dptr += BBSIZE;
1750 }
1751 } else {
1752 iclog->ic_bwritecnt = 1;
1753 }
1754
1755
1756 iclog->ic_header.h_crc = xlog_cksum(log, &iclog->ic_header,
1757 iclog->ic_datap, size);
1758
1759 bp->b_io_length = BTOBB(count);
1760 bp->b_fspriv = iclog;
1761 XFS_BUF_ZEROFLAGS(bp);
1762 XFS_BUF_ASYNC(bp);
1763 bp->b_flags |= XBF_SYNCIO;
1764
1765 if (log->l_mp->m_flags & XFS_MOUNT_BARRIER) {
1766 bp->b_flags |= XBF_FUA;
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777 if (log->l_mp->m_logdev_targp != log->l_mp->m_ddev_targp)
1778 xfs_blkdev_issue_flush(log->l_mp->m_ddev_targp);
1779 else
1780 bp->b_flags |= XBF_FLUSH;
1781 }
1782
1783 ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1);
1784 ASSERT(XFS_BUF_ADDR(bp) + BTOBB(count) <= log->l_logBBsize);
1785
1786 xlog_verify_iclog(log, iclog, count, true);
1787
1788
1789 XFS_BUF_SET_ADDR(bp, XFS_BUF_ADDR(bp) + log->l_logBBstart);
1790
1791
1792
1793
1794 XFS_BUF_WRITE(bp);
1795
1796 error = xlog_bdstrat(bp);
1797 if (error) {
1798 xfs_buf_ioerror_alert(bp, "xlog_sync");
1799 return error;
1800 }
1801 if (split) {
1802 bp = iclog->ic_log->l_xbuf;
1803 XFS_BUF_SET_ADDR(bp, 0);
1804 xfs_buf_associate_memory(bp,
1805 (char *)&iclog->ic_header + count, split);
1806 bp->b_fspriv = iclog;
1807 XFS_BUF_ZEROFLAGS(bp);
1808 XFS_BUF_ASYNC(bp);
1809 bp->b_flags |= XBF_SYNCIO;
1810 if (log->l_mp->m_flags & XFS_MOUNT_BARRIER)
1811 bp->b_flags |= XBF_FUA;
1812
1813 ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1);
1814 ASSERT(XFS_BUF_ADDR(bp) + BTOBB(count) <= log->l_logBBsize);
1815
1816
1817 XFS_BUF_SET_ADDR(bp, XFS_BUF_ADDR(bp) + log->l_logBBstart);
1818 XFS_BUF_WRITE(bp);
1819 error = xlog_bdstrat(bp);
1820 if (error) {
1821 xfs_buf_ioerror_alert(bp, "xlog_sync (split)");
1822 return error;
1823 }
1824 }
1825 return 0;
1826}
1827
1828
1829
1830
1831STATIC void
1832xlog_dealloc_log(
1833 struct xlog *log)
1834{
1835 xlog_in_core_t *iclog, *next_iclog;
1836 int i;
1837
1838 xlog_cil_destroy(log);
1839
1840
1841
1842
1843
1844 xfs_buf_set_empty(log->l_xbuf, BTOBB(log->l_iclog_size));
1845 xfs_buf_free(log->l_xbuf);
1846
1847 iclog = log->l_iclog;
1848 for (i=0; i<log->l_iclog_bufs; i++) {
1849 xfs_buf_free(iclog->ic_bp);
1850 next_iclog = iclog->ic_next;
1851 kmem_free(iclog);
1852 iclog = next_iclog;
1853 }
1854 spinlock_destroy(&log->l_icloglock);
1855
1856 log->l_mp->m_log = NULL;
1857 kmem_free(log);
1858}
1859
1860
1861
1862
1863
1864static inline void
1865xlog_state_finish_copy(
1866 struct xlog *log,
1867 struct xlog_in_core *iclog,
1868 int record_cnt,
1869 int copy_bytes)
1870{
1871 spin_lock(&log->l_icloglock);
1872
1873 be32_add_cpu(&iclog->ic_header.h_num_logops, record_cnt);
1874 iclog->ic_offset += copy_bytes;
1875
1876 spin_unlock(&log->l_icloglock);
1877}
1878
1879
1880
1881
1882
1883
1884
1885
1886void
1887xlog_print_tic_res(
1888 struct xfs_mount *mp,
1889 struct xlog_ticket *ticket)
1890{
1891 uint i;
1892 uint ophdr_spc = ticket->t_res_num_ophdrs * (uint)sizeof(xlog_op_header_t);
1893
1894
1895 static char *res_type_str[XLOG_REG_TYPE_MAX] = {
1896 "bformat",
1897 "bchunk",
1898 "efi_format",
1899 "efd_format",
1900 "iformat",
1901 "icore",
1902 "iext",
1903 "ibroot",
1904 "ilocal",
1905 "iattr_ext",
1906 "iattr_broot",
1907 "iattr_local",
1908 "qformat",
1909 "dquot",
1910 "quotaoff",
1911 "LR header",
1912 "unmount",
1913 "commit",
1914 "trans header"
1915 };
1916 static char *trans_type_str[XFS_TRANS_TYPE_MAX] = {
1917 "SETATTR_NOT_SIZE",
1918 "SETATTR_SIZE",
1919 "INACTIVE",
1920 "CREATE",
1921 "CREATE_TRUNC",
1922 "TRUNCATE_FILE",
1923 "REMOVE",
1924 "LINK",
1925 "RENAME",
1926 "MKDIR",
1927 "RMDIR",
1928 "SYMLINK",
1929 "SET_DMATTRS",
1930 "GROWFS",
1931 "STRAT_WRITE",
1932 "DIOSTRAT",
1933 "WRITE_SYNC",
1934 "WRITEID",
1935 "ADDAFORK",
1936 "ATTRINVAL",
1937 "ATRUNCATE",
1938 "ATTR_SET",
1939 "ATTR_RM",
1940 "ATTR_FLAG",
1941 "CLEAR_AGI_BUCKET",
1942 "QM_SBCHANGE",
1943 "DUMMY1",
1944 "DUMMY2",
1945 "QM_QUOTAOFF",
1946 "QM_DQALLOC",
1947 "QM_SETQLIM",
1948 "QM_DQCLUSTER",
1949 "QM_QINOCREATE",
1950 "QM_QUOTAOFF_END",
1951 "SB_UNIT",
1952 "FSYNC_TS",
1953 "GROWFSRT_ALLOC",
1954 "GROWFSRT_ZERO",
1955 "GROWFSRT_FREE",
1956 "SWAPEXT"
1957 };
1958
1959 xfs_warn(mp,
1960 "xlog_write: reservation summary:\n"
1961 " trans type = %s (%u)\n"
1962 " unit res = %d bytes\n"
1963 " current res = %d bytes\n"
1964 " total reg = %u bytes (o/flow = %u bytes)\n"
1965 " ophdrs = %u (ophdr space = %u bytes)\n"
1966 " ophdr + reg = %u bytes\n"
1967 " num regions = %u\n",
1968 ((ticket->t_trans_type <= 0 ||
1969 ticket->t_trans_type > XFS_TRANS_TYPE_MAX) ?
1970 "bad-trans-type" : trans_type_str[ticket->t_trans_type-1]),
1971 ticket->t_trans_type,
1972 ticket->t_unit_res,
1973 ticket->t_curr_res,
1974 ticket->t_res_arr_sum, ticket->t_res_o_flow,
1975 ticket->t_res_num_ophdrs, ophdr_spc,
1976 ticket->t_res_arr_sum +
1977 ticket->t_res_o_flow + ophdr_spc,
1978 ticket->t_res_num);
1979
1980 for (i = 0; i < ticket->t_res_num; i++) {
1981 uint r_type = ticket->t_res_arr[i].r_type;
1982 xfs_warn(mp, "region[%u]: %s - %u bytes\n", i,
1983 ((r_type <= 0 || r_type > XLOG_REG_TYPE_MAX) ?
1984 "bad-rtype" : res_type_str[r_type-1]),
1985 ticket->t_res_arr[i].r_len);
1986 }
1987
1988 xfs_alert_tag(mp, XFS_PTAG_LOGRES,
1989 "xlog_write: reservation ran out. Need to up reservation");
1990 xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
1991}
1992
1993
1994
1995
1996
1997static int
1998xlog_write_calc_vec_length(
1999 struct xlog_ticket *ticket,
2000 struct xfs_log_vec *log_vector)
2001{
2002 struct xfs_log_vec *lv;
2003 int headers = 0;
2004 int len = 0;
2005 int i;
2006
2007
2008 if (ticket->t_flags & XLOG_TIC_INITED)
2009 headers++;
2010
2011 for (lv = log_vector; lv; lv = lv->lv_next) {
2012
2013 if (lv->lv_buf_len == XFS_LOG_VEC_ORDERED)
2014 continue;
2015
2016 headers += lv->lv_niovecs;
2017
2018 for (i = 0; i < lv->lv_niovecs; i++) {
2019 struct xfs_log_iovec *vecp = &lv->lv_iovecp[i];
2020
2021 len += vecp->i_len;
2022 xlog_tic_add_region(ticket, vecp->i_len, vecp->i_type);
2023 }
2024 }
2025
2026 ticket->t_res_num_ophdrs += headers;
2027 len += headers * sizeof(struct xlog_op_header);
2028
2029 return len;
2030}
2031
2032
2033
2034
2035
2036static int
2037xlog_write_start_rec(
2038 struct xlog_op_header *ophdr,
2039 struct xlog_ticket *ticket)
2040{
2041 if (!(ticket->t_flags & XLOG_TIC_INITED))
2042 return 0;
2043
2044 ophdr->oh_tid = cpu_to_be32(ticket->t_tid);
2045 ophdr->oh_clientid = ticket->t_clientid;
2046 ophdr->oh_len = 0;
2047 ophdr->oh_flags = XLOG_START_TRANS;
2048 ophdr->oh_res2 = 0;
2049
2050 ticket->t_flags &= ~XLOG_TIC_INITED;
2051
2052 return sizeof(struct xlog_op_header);
2053}
2054
2055static xlog_op_header_t *
2056xlog_write_setup_ophdr(
2057 struct xlog *log,
2058 struct xlog_op_header *ophdr,
2059 struct xlog_ticket *ticket,
2060 uint flags)
2061{
2062 ophdr->oh_tid = cpu_to_be32(ticket->t_tid);
2063 ophdr->oh_clientid = ticket->t_clientid;
2064 ophdr->oh_res2 = 0;
2065
2066
2067 ophdr->oh_flags = flags;
2068
2069
2070
2071
2072
2073
2074 switch (ophdr->oh_clientid) {
2075 case XFS_TRANSACTION:
2076 case XFS_VOLUME:
2077 case XFS_LOG:
2078 break;
2079 default:
2080 xfs_warn(log->l_mp,
2081 "Bad XFS transaction clientid 0x%x in ticket 0x%p",
2082 ophdr->oh_clientid, ticket);
2083 return NULL;
2084 }
2085
2086 return ophdr;
2087}
2088
2089
2090
2091
2092
2093
2094
2095static int
2096xlog_write_setup_copy(
2097 struct xlog_ticket *ticket,
2098 struct xlog_op_header *ophdr,
2099 int space_available,
2100 int space_required,
2101 int *copy_off,
2102 int *copy_len,
2103 int *last_was_partial_copy,
2104 int *bytes_consumed)
2105{
2106 int still_to_copy;
2107
2108 still_to_copy = space_required - *bytes_consumed;
2109 *copy_off = *bytes_consumed;
2110
2111 if (still_to_copy <= space_available) {
2112
2113 *copy_len = still_to_copy;
2114 ophdr->oh_len = cpu_to_be32(*copy_len);
2115 if (*last_was_partial_copy)
2116 ophdr->oh_flags |= (XLOG_END_TRANS|XLOG_WAS_CONT_TRANS);
2117 *last_was_partial_copy = 0;
2118 *bytes_consumed = 0;
2119 return 0;
2120 }
2121
2122
2123 *copy_len = space_available;
2124 ophdr->oh_len = cpu_to_be32(*copy_len);
2125 ophdr->oh_flags |= XLOG_CONTINUE_TRANS;
2126 if (*last_was_partial_copy)
2127 ophdr->oh_flags |= XLOG_WAS_CONT_TRANS;
2128 *bytes_consumed += *copy_len;
2129 (*last_was_partial_copy)++;
2130
2131
2132 ticket->t_curr_res -= sizeof(struct xlog_op_header);
2133 ticket->t_res_num_ophdrs++;
2134
2135 return sizeof(struct xlog_op_header);
2136}
2137
2138static int
2139xlog_write_copy_finish(
2140 struct xlog *log,
2141 struct xlog_in_core *iclog,
2142 uint flags,
2143 int *record_cnt,
2144 int *data_cnt,
2145 int *partial_copy,
2146 int *partial_copy_len,
2147 int log_offset,
2148 struct xlog_in_core **commit_iclog)
2149{
2150 if (*partial_copy) {
2151
2152
2153
2154
2155 xlog_state_finish_copy(log, iclog, *record_cnt, *data_cnt);
2156 *record_cnt = 0;
2157 *data_cnt = 0;
2158 return xlog_state_release_iclog(log, iclog);
2159 }
2160
2161 *partial_copy = 0;
2162 *partial_copy_len = 0;
2163
2164 if (iclog->ic_size - log_offset <= sizeof(xlog_op_header_t)) {
2165
2166 xlog_state_finish_copy(log, iclog, *record_cnt, *data_cnt);
2167 *record_cnt = 0;
2168 *data_cnt = 0;
2169
2170 spin_lock(&log->l_icloglock);
2171 xlog_state_want_sync(log, iclog);
2172 spin_unlock(&log->l_icloglock);
2173
2174 if (!commit_iclog)
2175 return xlog_state_release_iclog(log, iclog);
2176 ASSERT(flags & XLOG_COMMIT_TRANS);
2177 *commit_iclog = iclog;
2178 }
2179
2180 return 0;
2181}
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223int
2224xlog_write(
2225 struct xlog *log,
2226 struct xfs_log_vec *log_vector,
2227 struct xlog_ticket *ticket,
2228 xfs_lsn_t *start_lsn,
2229 struct xlog_in_core **commit_iclog,
2230 uint flags)
2231{
2232 struct xlog_in_core *iclog = NULL;
2233 struct xfs_log_iovec *vecp;
2234 struct xfs_log_vec *lv;
2235 int len;
2236 int index;
2237 int partial_copy = 0;
2238 int partial_copy_len = 0;
2239 int contwr = 0;
2240 int record_cnt = 0;
2241 int data_cnt = 0;
2242 int error;
2243
2244 *start_lsn = 0;
2245
2246 len = xlog_write_calc_vec_length(ticket, log_vector);
2247
2248
2249
2250
2251
2252
2253 if (ticket->t_flags & XLOG_TIC_INITED)
2254 ticket->t_curr_res -= sizeof(xlog_op_header_t);
2255
2256
2257
2258
2259
2260 if (flags & (XLOG_COMMIT_TRANS | XLOG_UNMOUNT_TRANS))
2261 ticket->t_curr_res -= sizeof(xlog_op_header_t);
2262
2263 if (ticket->t_curr_res < 0)
2264 xlog_print_tic_res(log->l_mp, ticket);
2265
2266 index = 0;
2267 lv = log_vector;
2268 vecp = lv->lv_iovecp;
2269 while (lv && (!lv->lv_niovecs || index < lv->lv_niovecs)) {
2270 void *ptr;
2271 int log_offset;
2272
2273 error = xlog_state_get_iclog_space(log, len, &iclog, ticket,
2274 &contwr, &log_offset);
2275 if (error)
2276 return error;
2277
2278 ASSERT(log_offset <= iclog->ic_size - 1);
2279 ptr = iclog->ic_datap + log_offset;
2280
2281
2282 if (!*start_lsn)
2283 *start_lsn = be64_to_cpu(iclog->ic_header.h_lsn);
2284
2285
2286
2287
2288
2289 while (lv && (!lv->lv_niovecs || index < lv->lv_niovecs)) {
2290 struct xfs_log_iovec *reg;
2291 struct xlog_op_header *ophdr;
2292 int start_rec_copy;
2293 int copy_len;
2294 int copy_off;
2295 bool ordered = false;
2296
2297
2298 if (lv->lv_buf_len == XFS_LOG_VEC_ORDERED) {
2299 ASSERT(lv->lv_niovecs == 0);
2300 ordered = true;
2301 goto next_lv;
2302 }
2303
2304 reg = &vecp[index];
2305 ASSERT(reg->i_len % sizeof(__int32_t) == 0);
2306 ASSERT((unsigned long)ptr % sizeof(__int32_t) == 0);
2307
2308 start_rec_copy = xlog_write_start_rec(ptr, ticket);
2309 if (start_rec_copy) {
2310 record_cnt++;
2311 xlog_write_adv_cnt(&ptr, &len, &log_offset,
2312 start_rec_copy);
2313 }
2314
2315 ophdr = xlog_write_setup_ophdr(log, ptr, ticket, flags);
2316 if (!ophdr)
2317 return XFS_ERROR(EIO);
2318
2319 xlog_write_adv_cnt(&ptr, &len, &log_offset,
2320 sizeof(struct xlog_op_header));
2321
2322 len += xlog_write_setup_copy(ticket, ophdr,
2323 iclog->ic_size-log_offset,
2324 reg->i_len,
2325 ©_off, ©_len,
2326 &partial_copy,
2327 &partial_copy_len);
2328 xlog_verify_dest_ptr(log, ptr);
2329
2330
2331 ASSERT(copy_len >= 0);
2332 memcpy(ptr, reg->i_addr + copy_off, copy_len);
2333 xlog_write_adv_cnt(&ptr, &len, &log_offset, copy_len);
2334
2335 copy_len += start_rec_copy + sizeof(xlog_op_header_t);
2336 record_cnt++;
2337 data_cnt += contwr ? copy_len : 0;
2338
2339 error = xlog_write_copy_finish(log, iclog, flags,
2340 &record_cnt, &data_cnt,
2341 &partial_copy,
2342 &partial_copy_len,
2343 log_offset,
2344 commit_iclog);
2345 if (error)
2346 return error;
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360 if (partial_copy)
2361 break;
2362
2363 if (++index == lv->lv_niovecs) {
2364next_lv:
2365 lv = lv->lv_next;
2366 index = 0;
2367 if (lv)
2368 vecp = lv->lv_iovecp;
2369 }
2370 if (record_cnt == 0 && ordered == false) {
2371 if (!lv)
2372 return 0;
2373 break;
2374 }
2375 }
2376 }
2377
2378 ASSERT(len == 0);
2379
2380 xlog_state_finish_copy(log, iclog, record_cnt, data_cnt);
2381 if (!commit_iclog)
2382 return xlog_state_release_iclog(log, iclog);
2383
2384 ASSERT(flags & XLOG_COMMIT_TRANS);
2385 *commit_iclog = iclog;
2386 return 0;
2387}
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405STATIC void
2406xlog_state_clean_log(
2407 struct xlog *log)
2408{
2409 xlog_in_core_t *iclog;
2410 int changed = 0;
2411
2412 iclog = log->l_iclog;
2413 do {
2414 if (iclog->ic_state == XLOG_STATE_DIRTY) {
2415 iclog->ic_state = XLOG_STATE_ACTIVE;
2416 iclog->ic_offset = 0;
2417 ASSERT(iclog->ic_callback == NULL);
2418
2419
2420
2421
2422
2423
2424
2425
2426 if (!changed &&
2427 (be32_to_cpu(iclog->ic_header.h_num_logops) ==
2428 XLOG_COVER_OPS)) {
2429 changed = 1;
2430 } else {
2431
2432
2433
2434
2435
2436 changed = 2;
2437 }
2438 iclog->ic_header.h_num_logops = 0;
2439 memset(iclog->ic_header.h_cycle_data, 0,
2440 sizeof(iclog->ic_header.h_cycle_data));
2441 iclog->ic_header.h_lsn = 0;
2442 } else if (iclog->ic_state == XLOG_STATE_ACTIVE)
2443 ;
2444 else
2445 break;
2446 iclog = iclog->ic_next;
2447 } while (iclog != log->l_iclog);
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457 if (changed) {
2458 switch (log->l_covered_state) {
2459 case XLOG_STATE_COVER_IDLE:
2460 case XLOG_STATE_COVER_NEED:
2461 case XLOG_STATE_COVER_NEED2:
2462 log->l_covered_state = XLOG_STATE_COVER_NEED;
2463 break;
2464
2465 case XLOG_STATE_COVER_DONE:
2466 if (changed == 1)
2467 log->l_covered_state = XLOG_STATE_COVER_NEED2;
2468 else
2469 log->l_covered_state = XLOG_STATE_COVER_NEED;
2470 break;
2471
2472 case XLOG_STATE_COVER_DONE2:
2473 if (changed == 1)
2474 log->l_covered_state = XLOG_STATE_COVER_IDLE;
2475 else
2476 log->l_covered_state = XLOG_STATE_COVER_NEED;
2477 break;
2478
2479 default:
2480 ASSERT(0);
2481 }
2482 }
2483}
2484
2485STATIC xfs_lsn_t
2486xlog_get_lowest_lsn(
2487 struct xlog *log)
2488{
2489 xlog_in_core_t *lsn_log;
2490 xfs_lsn_t lowest_lsn, lsn;
2491
2492 lsn_log = log->l_iclog;
2493 lowest_lsn = 0;
2494 do {
2495 if (!(lsn_log->ic_state & (XLOG_STATE_ACTIVE|XLOG_STATE_DIRTY))) {
2496 lsn = be64_to_cpu(lsn_log->ic_header.h_lsn);
2497 if ((lsn && !lowest_lsn) ||
2498 (XFS_LSN_CMP(lsn, lowest_lsn) < 0)) {
2499 lowest_lsn = lsn;
2500 }
2501 }
2502 lsn_log = lsn_log->ic_next;
2503 } while (lsn_log != log->l_iclog);
2504 return lowest_lsn;
2505}
2506
2507
2508STATIC void
2509xlog_state_do_callback(
2510 struct xlog *log,
2511 int aborted,
2512 struct xlog_in_core *ciclog)
2513{
2514 xlog_in_core_t *iclog;
2515 xlog_in_core_t *first_iclog;
2516
2517 xfs_log_callback_t *cb, *cb_next;
2518 int flushcnt = 0;
2519 xfs_lsn_t lowest_lsn;
2520 int ioerrors;
2521 int loopdidcallbacks;
2522 int funcdidcallbacks;
2523 int repeats;
2524
2525 int wake = 0;
2526
2527 spin_lock(&log->l_icloglock);
2528 first_iclog = iclog = log->l_iclog;
2529 ioerrors = 0;
2530 funcdidcallbacks = 0;
2531 repeats = 0;
2532
2533 do {
2534
2535
2536
2537
2538
2539
2540
2541
2542 first_iclog = log->l_iclog;
2543 iclog = log->l_iclog;
2544 loopdidcallbacks = 0;
2545 repeats++;
2546
2547 do {
2548
2549
2550 if (iclog->ic_state &
2551 (XLOG_STATE_ACTIVE|XLOG_STATE_DIRTY)) {
2552 iclog = iclog->ic_next;
2553 continue;
2554 }
2555
2556
2557
2558
2559
2560
2561
2562
2563 if (!(iclog->ic_state & XLOG_STATE_IOERROR)) {
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574 if (!(iclog->ic_state &
2575 (XLOG_STATE_DONE_SYNC |
2576 XLOG_STATE_DO_CALLBACK))) {
2577 if (ciclog && (ciclog->ic_state ==
2578 XLOG_STATE_DONE_SYNC)) {
2579 ciclog->ic_state = XLOG_STATE_DO_CALLBACK;
2580 }
2581 break;
2582 }
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597 lowest_lsn = xlog_get_lowest_lsn(log);
2598 if (lowest_lsn &&
2599 XFS_LSN_CMP(lowest_lsn,
2600 be64_to_cpu(iclog->ic_header.h_lsn)) < 0) {
2601 iclog = iclog->ic_next;
2602 continue;
2603
2604 }
2605
2606 iclog->ic_state = XLOG_STATE_CALLBACK;
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626 ASSERT(XFS_LSN_CMP(atomic64_read(&log->l_last_sync_lsn),
2627 be64_to_cpu(iclog->ic_header.h_lsn)) <= 0);
2628 if (iclog->ic_callback)
2629 atomic64_set(&log->l_last_sync_lsn,
2630 be64_to_cpu(iclog->ic_header.h_lsn));
2631
2632 } else
2633 ioerrors++;
2634
2635 spin_unlock(&log->l_icloglock);
2636
2637
2638
2639
2640
2641
2642
2643
2644 spin_lock(&iclog->ic_callback_lock);
2645 cb = iclog->ic_callback;
2646 while (cb) {
2647 iclog->ic_callback_tail = &(iclog->ic_callback);
2648 iclog->ic_callback = NULL;
2649 spin_unlock(&iclog->ic_callback_lock);
2650
2651
2652 for (; cb; cb = cb_next) {
2653 cb_next = cb->cb_next;
2654 cb->cb_func(cb->cb_arg, aborted);
2655 }
2656 spin_lock(&iclog->ic_callback_lock);
2657 cb = iclog->ic_callback;
2658 }
2659
2660 loopdidcallbacks++;
2661 funcdidcallbacks++;
2662
2663 spin_lock(&log->l_icloglock);
2664 ASSERT(iclog->ic_callback == NULL);
2665 spin_unlock(&iclog->ic_callback_lock);
2666 if (!(iclog->ic_state & XLOG_STATE_IOERROR))
2667 iclog->ic_state = XLOG_STATE_DIRTY;
2668
2669
2670
2671
2672
2673 xlog_state_clean_log(log);
2674
2675
2676 wake_up_all(&iclog->ic_force_wait);
2677
2678 iclog = iclog->ic_next;
2679 } while (first_iclog != iclog);
2680
2681 if (repeats > 5000) {
2682 flushcnt += repeats;
2683 repeats = 0;
2684 xfs_warn(log->l_mp,
2685 "%s: possible infinite loop (%d iterations)",
2686 __func__, flushcnt);
2687 }
2688 } while (!ioerrors && loopdidcallbacks);
2689
2690
2691
2692
2693
2694#ifdef DEBUG
2695 if (funcdidcallbacks) {
2696 first_iclog = iclog = log->l_iclog;
2697 do {
2698 ASSERT(iclog->ic_state != XLOG_STATE_DO_CALLBACK);
2699
2700
2701
2702
2703
2704
2705
2706
2707
2708 if (iclog->ic_state == XLOG_STATE_WANT_SYNC ||
2709 iclog->ic_state == XLOG_STATE_SYNCING ||
2710 iclog->ic_state == XLOG_STATE_DONE_SYNC ||
2711 iclog->ic_state == XLOG_STATE_IOERROR )
2712 break;
2713 iclog = iclog->ic_next;
2714 } while (first_iclog != iclog);
2715 }
2716#endif
2717
2718 if (log->l_iclog->ic_state & (XLOG_STATE_ACTIVE|XLOG_STATE_IOERROR))
2719 wake = 1;
2720 spin_unlock(&log->l_icloglock);
2721
2722 if (wake)
2723 wake_up_all(&log->l_flush_wait);
2724}
2725
2726
2727
2728
2729
2730
2731
2732
2733
2734
2735
2736
2737
2738
2739
2740STATIC void
2741xlog_state_done_syncing(
2742 xlog_in_core_t *iclog,
2743 int aborted)
2744{
2745 struct xlog *log = iclog->ic_log;
2746
2747 spin_lock(&log->l_icloglock);
2748
2749 ASSERT(iclog->ic_state == XLOG_STATE_SYNCING ||
2750 iclog->ic_state == XLOG_STATE_IOERROR);
2751 ASSERT(atomic_read(&iclog->ic_refcnt) == 0);
2752 ASSERT(iclog->ic_bwritecnt == 1 || iclog->ic_bwritecnt == 2);
2753
2754
2755
2756
2757
2758
2759
2760
2761 if (iclog->ic_state != XLOG_STATE_IOERROR) {
2762 if (--iclog->ic_bwritecnt == 1) {
2763 spin_unlock(&log->l_icloglock);
2764 return;
2765 }
2766 iclog->ic_state = XLOG_STATE_DONE_SYNC;
2767 }
2768
2769
2770
2771
2772
2773
2774 wake_up_all(&iclog->ic_write_wait);
2775 spin_unlock(&log->l_icloglock);
2776 xlog_state_do_callback(log, aborted, iclog);
2777}
2778
2779
2780
2781
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793
2794
2795
2796
2797
2798STATIC int
2799xlog_state_get_iclog_space(
2800 struct xlog *log,
2801 int len,
2802 struct xlog_in_core **iclogp,
2803 struct xlog_ticket *ticket,
2804 int *continued_write,
2805 int *logoffsetp)
2806{
2807 int log_offset;
2808 xlog_rec_header_t *head;
2809 xlog_in_core_t *iclog;
2810 int error;
2811
2812restart:
2813 spin_lock(&log->l_icloglock);
2814 if (XLOG_FORCED_SHUTDOWN(log)) {
2815 spin_unlock(&log->l_icloglock);
2816 return XFS_ERROR(EIO);
2817 }
2818
2819 iclog = log->l_iclog;
2820 if (iclog->ic_state != XLOG_STATE_ACTIVE) {
2821 XFS_STATS_INC(xs_log_noiclogs);
2822
2823
2824 xlog_wait(&log->l_flush_wait, &log->l_icloglock);
2825 goto restart;
2826 }
2827
2828 head = &iclog->ic_header;
2829
2830 atomic_inc(&iclog->ic_refcnt);
2831 log_offset = iclog->ic_offset;
2832
2833
2834
2835
2836
2837
2838 if (log_offset == 0) {
2839 ticket->t_curr_res -= log->l_iclog_hsize;
2840 xlog_tic_add_region(ticket,
2841 log->l_iclog_hsize,
2842 XLOG_REG_TYPE_LRHEADER);
2843 head->h_cycle = cpu_to_be32(log->l_curr_cycle);
2844 head->h_lsn = cpu_to_be64(
2845 xlog_assign_lsn(log->l_curr_cycle, log->l_curr_block));
2846 ASSERT(log->l_curr_block >= 0);
2847 }
2848
2849
2850
2851
2852
2853
2854
2855
2856
2857
2858 if (iclog->ic_size - iclog->ic_offset < 2*sizeof(xlog_op_header_t)) {
2859 xlog_state_switch_iclogs(log, iclog, iclog->ic_size);
2860
2861
2862
2863
2864
2865
2866
2867
2868 if (!atomic_add_unless(&iclog->ic_refcnt, -1, 1)) {
2869
2870 spin_unlock(&log->l_icloglock);
2871 error = xlog_state_release_iclog(log, iclog);
2872 if (error)
2873 return error;
2874 } else {
2875 spin_unlock(&log->l_icloglock);
2876 }
2877 goto restart;
2878 }
2879
2880
2881
2882
2883
2884
2885
2886 if (len <= iclog->ic_size - iclog->ic_offset) {
2887 *continued_write = 0;
2888 iclog->ic_offset += len;
2889 } else {
2890 *continued_write = 1;
2891 xlog_state_switch_iclogs(log, iclog, iclog->ic_size);
2892 }
2893 *iclogp = iclog;
2894
2895 ASSERT(iclog->ic_offset <= iclog->ic_size);
2896 spin_unlock(&log->l_icloglock);
2897
2898 *logoffsetp = log_offset;
2899 return 0;
2900}
2901
2902
2903
2904
2905
2906
2907
2908
2909STATIC void
2910xlog_regrant_reserve_log_space(
2911 struct xlog *log,
2912 struct xlog_ticket *ticket)
2913{
2914 trace_xfs_log_regrant_reserve_enter(log, ticket);
2915
2916 if (ticket->t_cnt > 0)
2917 ticket->t_cnt--;
2918
2919 xlog_grant_sub_space(log, &log->l_reserve_head.grant,
2920 ticket->t_curr_res);
2921 xlog_grant_sub_space(log, &log->l_write_head.grant,
2922 ticket->t_curr_res);
2923 ticket->t_curr_res = ticket->t_unit_res;
2924 xlog_tic_reset_res(ticket);
2925
2926 trace_xfs_log_regrant_reserve_sub(log, ticket);
2927
2928
2929 if (ticket->t_cnt > 0)
2930 return;
2931
2932 xlog_grant_add_space(log, &log->l_reserve_head.grant,
2933 ticket->t_unit_res);
2934
2935 trace_xfs_log_regrant_reserve_exit(log, ticket);
2936
2937 ticket->t_curr_res = ticket->t_unit_res;
2938 xlog_tic_reset_res(ticket);
2939}
2940
2941
2942
2943
2944
2945
2946
2947
2948
2949
2950
2951
2952
2953
2954
2955
2956STATIC void
2957xlog_ungrant_log_space(
2958 struct xlog *log,
2959 struct xlog_ticket *ticket)
2960{
2961 int bytes;
2962
2963 if (ticket->t_cnt > 0)
2964 ticket->t_cnt--;
2965
2966 trace_xfs_log_ungrant_enter(log, ticket);
2967 trace_xfs_log_ungrant_sub(log, ticket);
2968
2969
2970
2971
2972
2973 bytes = ticket->t_curr_res;
2974 if (ticket->t_cnt > 0) {
2975 ASSERT(ticket->t_flags & XLOG_TIC_PERM_RESERV);
2976 bytes += ticket->t_unit_res*ticket->t_cnt;
2977 }
2978
2979 xlog_grant_sub_space(log, &log->l_reserve_head.grant, bytes);
2980 xlog_grant_sub_space(log, &log->l_write_head.grant, bytes);
2981
2982 trace_xfs_log_ungrant_exit(log, ticket);
2983
2984 xfs_log_space_wake(log->l_mp);
2985}
2986
2987
2988
2989
2990
2991
2992
2993
2994
2995
2996STATIC int
2997xlog_state_release_iclog(
2998 struct xlog *log,
2999 struct xlog_in_core *iclog)
3000{
3001 int sync = 0;
3002
3003 if (iclog->ic_state & XLOG_STATE_IOERROR)
3004 return XFS_ERROR(EIO);
3005
3006 ASSERT(atomic_read(&iclog->ic_refcnt) > 0);
3007 if (!atomic_dec_and_lock(&iclog->ic_refcnt, &log->l_icloglock))
3008 return 0;
3009
3010 if (iclog->ic_state & XLOG_STATE_IOERROR) {
3011 spin_unlock(&log->l_icloglock);
3012 return XFS_ERROR(EIO);
3013 }
3014 ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE ||
3015 iclog->ic_state == XLOG_STATE_WANT_SYNC);
3016
3017 if (iclog->ic_state == XLOG_STATE_WANT_SYNC) {
3018
3019 xfs_lsn_t tail_lsn = xlog_assign_tail_lsn(log->l_mp);
3020 sync++;
3021 iclog->ic_state = XLOG_STATE_SYNCING;
3022 iclog->ic_header.h_tail_lsn = cpu_to_be64(tail_lsn);
3023 xlog_verify_tail_lsn(log, iclog, tail_lsn);
3024
3025 }
3026 spin_unlock(&log->l_icloglock);
3027
3028
3029
3030
3031
3032
3033
3034
3035 if (sync)
3036 return xlog_sync(log, iclog);
3037 return 0;
3038}
3039
3040
3041
3042
3043
3044
3045
3046
3047
3048STATIC void
3049xlog_state_switch_iclogs(
3050 struct xlog *log,
3051 struct xlog_in_core *iclog,
3052 int eventual_size)
3053{
3054 ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE);
3055 if (!eventual_size)
3056 eventual_size = iclog->ic_offset;
3057 iclog->ic_state = XLOG_STATE_WANT_SYNC;
3058 iclog->ic_header.h_prev_block = cpu_to_be32(log->l_prev_block);
3059 log->l_prev_block = log->l_curr_block;
3060 log->l_prev_cycle = log->l_curr_cycle;
3061
3062
3063 log->l_curr_block += BTOBB(eventual_size)+BTOBB(log->l_iclog_hsize);
3064
3065
3066 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb) &&
3067 log->l_mp->m_sb.sb_logsunit > 1) {
3068 __uint32_t sunit_bb = BTOBB(log->l_mp->m_sb.sb_logsunit);
3069 log->l_curr_block = roundup(log->l_curr_block, sunit_bb);
3070 }
3071
3072 if (log->l_curr_block >= log->l_logBBsize) {
3073 log->l_curr_cycle++;
3074 if (log->l_curr_cycle == XLOG_HEADER_MAGIC_NUM)
3075 log->l_curr_cycle++;
3076 log->l_curr_block -= log->l_logBBsize;
3077 ASSERT(log->l_curr_block >= 0);
3078 }
3079 ASSERT(iclog == log->l_iclog);
3080 log->l_iclog = iclog->ic_next;
3081}
3082
3083
3084
3085
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099
3100
3101
3102
3103
3104
3105
3106
3107
3108
3109
3110int
3111_xfs_log_force(
3112 struct xfs_mount *mp,
3113 uint flags,
3114 int *log_flushed)
3115{
3116 struct xlog *log = mp->m_log;
3117 struct xlog_in_core *iclog;
3118 xfs_lsn_t lsn;
3119
3120 XFS_STATS_INC(xs_log_force);
3121
3122 xlog_cil_force(log);
3123
3124 spin_lock(&log->l_icloglock);
3125
3126 iclog = log->l_iclog;
3127 if (iclog->ic_state & XLOG_STATE_IOERROR) {
3128 spin_unlock(&log->l_icloglock);
3129 return XFS_ERROR(EIO);
3130 }
3131
3132
3133
3134
3135 if (iclog->ic_state == XLOG_STATE_ACTIVE ||
3136 iclog->ic_state == XLOG_STATE_DIRTY) {
3137
3138
3139
3140
3141
3142
3143
3144 if (iclog->ic_state == XLOG_STATE_DIRTY ||
3145 (atomic_read(&iclog->ic_refcnt) == 0
3146 && iclog->ic_offset == 0)) {
3147 iclog = iclog->ic_prev;
3148 if (iclog->ic_state == XLOG_STATE_ACTIVE ||
3149 iclog->ic_state == XLOG_STATE_DIRTY)
3150 goto no_sleep;
3151 else
3152 goto maybe_sleep;
3153 } else {
3154 if (atomic_read(&iclog->ic_refcnt) == 0) {
3155
3156
3157
3158
3159
3160
3161 atomic_inc(&iclog->ic_refcnt);
3162 lsn = be64_to_cpu(iclog->ic_header.h_lsn);
3163 xlog_state_switch_iclogs(log, iclog, 0);
3164 spin_unlock(&log->l_icloglock);
3165
3166 if (xlog_state_release_iclog(log, iclog))
3167 return XFS_ERROR(EIO);
3168
3169 if (log_flushed)
3170 *log_flushed = 1;
3171 spin_lock(&log->l_icloglock);
3172 if (be64_to_cpu(iclog->ic_header.h_lsn) == lsn &&
3173 iclog->ic_state != XLOG_STATE_DIRTY)
3174 goto maybe_sleep;
3175 else
3176 goto no_sleep;
3177 } else {
3178
3179
3180
3181
3182
3183 xlog_state_switch_iclogs(log, iclog, 0);
3184 goto maybe_sleep;
3185 }
3186 }
3187 }
3188
3189
3190
3191
3192
3193maybe_sleep:
3194 if (flags & XFS_LOG_SYNC) {
3195
3196
3197
3198
3199
3200
3201 if (iclog->ic_state & XLOG_STATE_IOERROR) {
3202 spin_unlock(&log->l_icloglock);
3203 return XFS_ERROR(EIO);
3204 }
3205 XFS_STATS_INC(xs_log_force_sleep);
3206 xlog_wait(&iclog->ic_force_wait, &log->l_icloglock);
3207
3208
3209
3210
3211
3212 if (iclog->ic_state & XLOG_STATE_IOERROR)
3213 return XFS_ERROR(EIO);
3214 if (log_flushed)
3215 *log_flushed = 1;
3216 } else {
3217
3218no_sleep:
3219 spin_unlock(&log->l_icloglock);
3220 }
3221 return 0;
3222}
3223
3224
3225
3226
3227
3228
3229void
3230xfs_log_force(
3231 xfs_mount_t *mp,
3232 uint flags)
3233{
3234 int error;
3235
3236 trace_xfs_log_force(mp, 0);
3237 error = _xfs_log_force(mp, flags, NULL);
3238 if (error)
3239 xfs_warn(mp, "%s: error %d returned.", __func__, error);
3240}
3241
3242
3243
3244
3245
3246
3247
3248
3249
3250
3251
3252
3253
3254
3255
3256
3257int
3258_xfs_log_force_lsn(
3259 struct xfs_mount *mp,
3260 xfs_lsn_t lsn,
3261 uint flags,
3262 int *log_flushed)
3263{
3264 struct xlog *log = mp->m_log;
3265 struct xlog_in_core *iclog;
3266 int already_slept = 0;
3267
3268 ASSERT(lsn != 0);
3269
3270 XFS_STATS_INC(xs_log_force);
3271
3272 lsn = xlog_cil_force_lsn(log, lsn);
3273 if (lsn == NULLCOMMITLSN)
3274 return 0;
3275
3276try_again:
3277 spin_lock(&log->l_icloglock);
3278 iclog = log->l_iclog;
3279 if (iclog->ic_state & XLOG_STATE_IOERROR) {
3280 spin_unlock(&log->l_icloglock);
3281 return XFS_ERROR(EIO);
3282 }
3283
3284 do {
3285 if (be64_to_cpu(iclog->ic_header.h_lsn) != lsn) {
3286 iclog = iclog->ic_next;
3287 continue;
3288 }
3289
3290 if (iclog->ic_state == XLOG_STATE_DIRTY) {
3291 spin_unlock(&log->l_icloglock);
3292 return 0;
3293 }
3294
3295 if (iclog->ic_state == XLOG_STATE_ACTIVE) {
3296
3297
3298
3299
3300
3301
3302
3303
3304
3305
3306
3307
3308
3309
3310
3311
3312
3313
3314 if (!already_slept &&
3315 (iclog->ic_prev->ic_state &
3316 (XLOG_STATE_WANT_SYNC | XLOG_STATE_SYNCING))) {
3317 ASSERT(!(iclog->ic_state & XLOG_STATE_IOERROR));
3318
3319 XFS_STATS_INC(xs_log_force_sleep);
3320
3321 xlog_wait(&iclog->ic_prev->ic_write_wait,
3322 &log->l_icloglock);
3323 if (log_flushed)
3324 *log_flushed = 1;
3325 already_slept = 1;
3326 goto try_again;
3327 }
3328 atomic_inc(&iclog->ic_refcnt);
3329 xlog_state_switch_iclogs(log, iclog, 0);
3330 spin_unlock(&log->l_icloglock);
3331 if (xlog_state_release_iclog(log, iclog))
3332 return XFS_ERROR(EIO);
3333 if (log_flushed)
3334 *log_flushed = 1;
3335 spin_lock(&log->l_icloglock);
3336 }
3337
3338 if ((flags & XFS_LOG_SYNC) &&
3339 !(iclog->ic_state &
3340 (XLOG_STATE_ACTIVE | XLOG_STATE_DIRTY))) {
3341
3342
3343
3344
3345 if (iclog->ic_state & XLOG_STATE_IOERROR) {
3346 spin_unlock(&log->l_icloglock);
3347 return XFS_ERROR(EIO);
3348 }
3349 XFS_STATS_INC(xs_log_force_sleep);
3350 xlog_wait(&iclog->ic_force_wait, &log->l_icloglock);
3351
3352
3353
3354
3355
3356 if (iclog->ic_state & XLOG_STATE_IOERROR)
3357 return XFS_ERROR(EIO);
3358
3359 if (log_flushed)
3360 *log_flushed = 1;
3361 } else {
3362 spin_unlock(&log->l_icloglock);
3363 }
3364
3365 return 0;
3366 } while (iclog != log->l_iclog);
3367
3368 spin_unlock(&log->l_icloglock);
3369 return 0;
3370}
3371
3372
3373
3374
3375
3376
3377void
3378xfs_log_force_lsn(
3379 xfs_mount_t *mp,
3380 xfs_lsn_t lsn,
3381 uint flags)
3382{
3383 int error;
3384
3385 trace_xfs_log_force(mp, lsn);
3386 error = _xfs_log_force_lsn(mp, lsn, flags, NULL);
3387 if (error)
3388 xfs_warn(mp, "%s: error %d returned.", __func__, error);
3389}
3390
3391
3392
3393
3394
3395STATIC void
3396xlog_state_want_sync(
3397 struct xlog *log,
3398 struct xlog_in_core *iclog)
3399{
3400 assert_spin_locked(&log->l_icloglock);
3401
3402 if (iclog->ic_state == XLOG_STATE_ACTIVE) {
3403 xlog_state_switch_iclogs(log, iclog, 0);
3404 } else {
3405 ASSERT(iclog->ic_state &
3406 (XLOG_STATE_WANT_SYNC|XLOG_STATE_IOERROR));
3407 }
3408}
3409
3410
3411
3412
3413
3414
3415
3416
3417
3418
3419
3420
3421void
3422xfs_log_ticket_put(
3423 xlog_ticket_t *ticket)
3424{
3425 ASSERT(atomic_read(&ticket->t_ref) > 0);
3426 if (atomic_dec_and_test(&ticket->t_ref))
3427 kmem_zone_free(xfs_log_ticket_zone, ticket);
3428}
3429
3430xlog_ticket_t *
3431xfs_log_ticket_get(
3432 xlog_ticket_t *ticket)
3433{
3434 ASSERT(atomic_read(&ticket->t_ref) > 0);
3435 atomic_inc(&ticket->t_ref);
3436 return ticket;
3437}
3438
3439
3440
3441
3442
3443int
3444xfs_log_calc_unit_res(
3445 struct xfs_mount *mp,
3446 int unit_bytes)
3447{
3448 struct xlog *log = mp->m_log;
3449 int iclog_space;
3450 uint num_headers;
3451
3452
3453
3454
3455
3456
3457
3458
3459
3460
3461
3462
3463
3464
3465
3466
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477
3478
3479
3480
3481
3482
3483
3484 unit_bytes += sizeof(xlog_op_header_t);
3485 unit_bytes += sizeof(xfs_trans_header_t);
3486
3487
3488 unit_bytes += sizeof(xlog_op_header_t);
3489
3490
3491
3492
3493
3494
3495
3496
3497
3498
3499
3500
3501
3502
3503
3504
3505
3506
3507 iclog_space = log->l_iclog_size - log->l_iclog_hsize;
3508 num_headers = howmany(unit_bytes, iclog_space);
3509
3510
3511 unit_bytes += sizeof(xlog_op_header_t) * num_headers;
3512
3513
3514 while (!num_headers ||
3515 howmany(unit_bytes, iclog_space) > num_headers) {
3516 unit_bytes += sizeof(xlog_op_header_t);
3517 num_headers++;
3518 }
3519 unit_bytes += log->l_iclog_hsize * num_headers;
3520
3521
3522 unit_bytes += log->l_iclog_hsize;
3523
3524
3525 if (xfs_sb_version_haslogv2(&mp->m_sb) && mp->m_sb.sb_logsunit > 1) {
3526
3527 unit_bytes += 2 * mp->m_sb.sb_logsunit;
3528 } else {
3529
3530 unit_bytes += 2 * BBSIZE;
3531 }
3532
3533 return unit_bytes;
3534}
3535
3536
3537
3538
3539struct xlog_ticket *
3540xlog_ticket_alloc(
3541 struct xlog *log,
3542 int unit_bytes,
3543 int cnt,
3544 char client,
3545 bool permanent,
3546 xfs_km_flags_t alloc_flags)
3547{
3548 struct xlog_ticket *tic;
3549 int unit_res;
3550
3551 tic = kmem_zone_zalloc(xfs_log_ticket_zone, alloc_flags);
3552 if (!tic)
3553 return NULL;
3554
3555 unit_res = xfs_log_calc_unit_res(log->l_mp, unit_bytes);
3556
3557 atomic_set(&tic->t_ref, 1);
3558 tic->t_task = current;
3559 INIT_LIST_HEAD(&tic->t_queue);
3560 tic->t_unit_res = unit_res;
3561 tic->t_curr_res = unit_res;
3562 tic->t_cnt = cnt;
3563 tic->t_ocnt = cnt;
3564 tic->t_tid = prandom_u32();
3565 tic->t_clientid = client;
3566 tic->t_flags = XLOG_TIC_INITED;
3567 tic->t_trans_type = 0;
3568 if (permanent)
3569 tic->t_flags |= XLOG_TIC_PERM_RESERV;
3570
3571 xlog_tic_reset_res(tic);
3572
3573 return tic;
3574}
3575
3576
3577
3578
3579
3580
3581
3582
3583#if defined(DEBUG)
3584
3585
3586
3587
3588
3589void
3590xlog_verify_dest_ptr(
3591 struct xlog *log,
3592 char *ptr)
3593{
3594 int i;
3595 int good_ptr = 0;
3596
3597 for (i = 0; i < log->l_iclog_bufs; i++) {
3598 if (ptr >= log->l_iclog_bak[i] &&
3599 ptr <= log->l_iclog_bak[i] + log->l_iclog_size)
3600 good_ptr++;
3601 }
3602
3603 if (!good_ptr)
3604 xfs_emerg(log->l_mp, "%s: invalid ptr", __func__);
3605}
3606
3607
3608
3609
3610
3611
3612
3613
3614
3615
3616
3617
3618STATIC void
3619xlog_verify_grant_tail(
3620 struct xlog *log)
3621{
3622 int tail_cycle, tail_blocks;
3623 int cycle, space;
3624
3625 xlog_crack_grant_head(&log->l_write_head.grant, &cycle, &space);
3626 xlog_crack_atomic_lsn(&log->l_tail_lsn, &tail_cycle, &tail_blocks);
3627 if (tail_cycle != cycle) {
3628 if (cycle - 1 != tail_cycle &&
3629 !(log->l_flags & XLOG_TAIL_WARN)) {
3630 xfs_alert_tag(log->l_mp, XFS_PTAG_LOGRES,
3631 "%s: cycle - 1 != tail_cycle", __func__);
3632 log->l_flags |= XLOG_TAIL_WARN;
3633 }
3634
3635 if (space > BBTOB(tail_blocks) &&
3636 !(log->l_flags & XLOG_TAIL_WARN)) {
3637 xfs_alert_tag(log->l_mp, XFS_PTAG_LOGRES,
3638 "%s: space > BBTOB(tail_blocks)", __func__);
3639 log->l_flags |= XLOG_TAIL_WARN;
3640 }
3641 }
3642}
3643
3644
3645STATIC void
3646xlog_verify_tail_lsn(
3647 struct xlog *log,
3648 struct xlog_in_core *iclog,
3649 xfs_lsn_t tail_lsn)
3650{
3651 int blocks;
3652
3653 if (CYCLE_LSN(tail_lsn) == log->l_prev_cycle) {
3654 blocks =
3655 log->l_logBBsize - (log->l_prev_block - BLOCK_LSN(tail_lsn));
3656 if (blocks < BTOBB(iclog->ic_offset)+BTOBB(log->l_iclog_hsize))
3657 xfs_emerg(log->l_mp, "%s: ran out of log space", __func__);
3658 } else {
3659 ASSERT(CYCLE_LSN(tail_lsn)+1 == log->l_prev_cycle);
3660
3661 if (BLOCK_LSN(tail_lsn) == log->l_prev_block)
3662 xfs_emerg(log->l_mp, "%s: tail wrapped", __func__);
3663
3664 blocks = BLOCK_LSN(tail_lsn) - log->l_prev_block;
3665 if (blocks < BTOBB(iclog->ic_offset) + 1)
3666 xfs_emerg(log->l_mp, "%s: ran out of log space", __func__);
3667 }
3668}
3669
3670
3671
3672
3673
3674
3675
3676
3677
3678
3679
3680
3681
3682
3683
3684
3685STATIC void
3686xlog_verify_iclog(
3687 struct xlog *log,
3688 struct xlog_in_core *iclog,
3689 int count,
3690 bool syncing)
3691{
3692 xlog_op_header_t *ophead;
3693 xlog_in_core_t *icptr;
3694 xlog_in_core_2_t *xhdr;
3695 xfs_caddr_t ptr;
3696 xfs_caddr_t base_ptr;
3697 __psint_t field_offset;
3698 __uint8_t clientid;
3699 int len, i, j, k, op_len;
3700 int idx;
3701
3702
3703 spin_lock(&log->l_icloglock);
3704 icptr = log->l_iclog;
3705 for (i=0; i < log->l_iclog_bufs; i++) {
3706 if (icptr == NULL)
3707 xfs_emerg(log->l_mp, "%s: invalid ptr", __func__);
3708 icptr = icptr->ic_next;
3709 }
3710 if (icptr != log->l_iclog)
3711 xfs_emerg(log->l_mp, "%s: corrupt iclog ring", __func__);
3712 spin_unlock(&log->l_icloglock);
3713
3714
3715 if (iclog->ic_header.h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM))
3716 xfs_emerg(log->l_mp, "%s: invalid magic num", __func__);
3717
3718 ptr = (xfs_caddr_t) &iclog->ic_header;
3719 for (ptr += BBSIZE; ptr < ((xfs_caddr_t)&iclog->ic_header) + count;
3720 ptr += BBSIZE) {
3721 if (*(__be32 *)ptr == cpu_to_be32(XLOG_HEADER_MAGIC_NUM))
3722 xfs_emerg(log->l_mp, "%s: unexpected magic num",
3723 __func__);
3724 }
3725
3726
3727 len = be32_to_cpu(iclog->ic_header.h_num_logops);
3728 ptr = iclog->ic_datap;
3729 base_ptr = ptr;
3730 ophead = (xlog_op_header_t *)ptr;
3731 xhdr = iclog->ic_data;
3732 for (i = 0; i < len; i++) {
3733 ophead = (xlog_op_header_t *)ptr;
3734
3735
3736 field_offset = (__psint_t)
3737 ((xfs_caddr_t)&(ophead->oh_clientid) - base_ptr);
3738 if (!syncing || (field_offset & 0x1ff)) {
3739 clientid = ophead->oh_clientid;
3740 } else {
3741 idx = BTOBBT((xfs_caddr_t)&(ophead->oh_clientid) - iclog->ic_datap);
3742 if (idx >= (XLOG_HEADER_CYCLE_SIZE / BBSIZE)) {
3743 j = idx / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3744 k = idx % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3745 clientid = xlog_get_client_id(
3746 xhdr[j].hic_xheader.xh_cycle_data[k]);
3747 } else {
3748 clientid = xlog_get_client_id(
3749 iclog->ic_header.h_cycle_data[idx]);
3750 }
3751 }
3752 if (clientid != XFS_TRANSACTION && clientid != XFS_LOG)
3753 xfs_warn(log->l_mp,
3754 "%s: invalid clientid %d op 0x%p offset 0x%lx",
3755 __func__, clientid, ophead,
3756 (unsigned long)field_offset);
3757
3758
3759 field_offset = (__psint_t)
3760 ((xfs_caddr_t)&(ophead->oh_len) - base_ptr);
3761 if (!syncing || (field_offset & 0x1ff)) {
3762 op_len = be32_to_cpu(ophead->oh_len);
3763 } else {
3764 idx = BTOBBT((__psint_t)&ophead->oh_len -
3765 (__psint_t)iclog->ic_datap);
3766 if (idx >= (XLOG_HEADER_CYCLE_SIZE / BBSIZE)) {
3767 j = idx / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3768 k = idx % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3769 op_len = be32_to_cpu(xhdr[j].hic_xheader.xh_cycle_data[k]);
3770 } else {
3771 op_len = be32_to_cpu(iclog->ic_header.h_cycle_data[idx]);
3772 }
3773 }
3774 ptr += sizeof(xlog_op_header_t) + op_len;
3775 }
3776}
3777#endif
3778
3779
3780
3781
3782STATIC int
3783xlog_state_ioerror(
3784 struct xlog *log)
3785{
3786 xlog_in_core_t *iclog, *ic;
3787
3788 iclog = log->l_iclog;
3789 if (! (iclog->ic_state & XLOG_STATE_IOERROR)) {
3790
3791
3792
3793
3794 ic = iclog;
3795 do {
3796 ic->ic_state = XLOG_STATE_IOERROR;
3797 ic = ic->ic_next;
3798 } while (ic != iclog);
3799 return 0;
3800 }
3801
3802
3803
3804 return 1;
3805}
3806
3807
3808
3809
3810
3811
3812
3813
3814
3815
3816
3817
3818
3819
3820
3821
3822
3823
3824int
3825xfs_log_force_umount(
3826 struct xfs_mount *mp,
3827 int logerror)
3828{
3829 struct xlog *log;
3830 int retval;
3831
3832 log = mp->m_log;
3833
3834
3835
3836
3837
3838 if (!log ||
3839 log->l_flags & XLOG_ACTIVE_RECOVERY) {
3840 mp->m_flags |= XFS_MOUNT_FS_SHUTDOWN;
3841 if (mp->m_sb_bp)
3842 XFS_BUF_DONE(mp->m_sb_bp);
3843 return 0;
3844 }
3845
3846
3847
3848
3849
3850 if (logerror && log->l_iclog->ic_state & XLOG_STATE_IOERROR) {
3851 ASSERT(XLOG_FORCED_SHUTDOWN(log));
3852 return 1;
3853 }
3854 retval = 0;
3855
3856
3857
3858
3859
3860
3861
3862 if (!logerror)
3863 xlog_cil_force(log);
3864
3865
3866
3867
3868
3869 spin_lock(&log->l_icloglock);
3870 mp->m_flags |= XFS_MOUNT_FS_SHUTDOWN;
3871 if (mp->m_sb_bp)
3872 XFS_BUF_DONE(mp->m_sb_bp);
3873
3874
3875
3876
3877
3878
3879 log->l_flags |= XLOG_IO_ERROR;
3880
3881
3882
3883
3884
3885 if (logerror)
3886 retval = xlog_state_ioerror(log);
3887 spin_unlock(&log->l_icloglock);
3888
3889
3890
3891
3892
3893
3894
3895
3896 xlog_grant_head_wake_all(&log->l_reserve_head);
3897 xlog_grant_head_wake_all(&log->l_write_head);
3898
3899 if (!(log->l_iclog->ic_state & XLOG_STATE_IOERROR)) {
3900 ASSERT(!logerror);
3901
3902
3903
3904
3905 _xfs_log_force(mp, XFS_LOG_SYNC, NULL);
3906
3907 spin_lock(&log->l_icloglock);
3908 retval = xlog_state_ioerror(log);
3909 spin_unlock(&log->l_icloglock);
3910 }
3911
3912
3913
3914
3915
3916 xlog_state_do_callback(log, XFS_LI_ABORTED, NULL);
3917
3918#ifdef XFSERRORDEBUG
3919 {
3920 xlog_in_core_t *iclog;
3921
3922 spin_lock(&log->l_icloglock);
3923 iclog = log->l_iclog;
3924 do {
3925 ASSERT(iclog->ic_callback == 0);
3926 iclog = iclog->ic_next;
3927 } while (iclog != log->l_iclog);
3928 spin_unlock(&log->l_icloglock);
3929 }
3930#endif
3931
3932 return retval;
3933}
3934
3935STATIC int
3936xlog_iclogs_empty(
3937 struct xlog *log)
3938{
3939 xlog_in_core_t *iclog;
3940
3941 iclog = log->l_iclog;
3942 do {
3943
3944
3945
3946 if (iclog->ic_header.h_num_logops)
3947 return 0;
3948 iclog = iclog->ic_next;
3949 } while (iclog != log->l_iclog);
3950 return 1;
3951}
3952
3953