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