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