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