1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include "xfs.h"
19#include "xfs_fs.h"
20#include "xfs_types.h"
21#include "xfs_log.h"
22#include "xfs_trans.h"
23#include "xfs_trans_priv.h"
24#include "xfs_log_priv.h"
25#include "xfs_sb.h"
26#include "xfs_ag.h"
27#include "xfs_mount.h"
28#include "xfs_error.h"
29#include "xfs_alloc.h"
30#include "xfs_extent_busy.h"
31#include "xfs_discard.h"
32
33
34
35
36
37
38
39
40
41
42
43
44
45static struct xlog_ticket *
46xlog_cil_ticket_alloc(
47 struct xlog *log)
48{
49 struct xlog_ticket *tic;
50
51 tic = xlog_ticket_alloc(log, 0, 1, XFS_TRANSACTION, 0,
52 KM_SLEEP|KM_NOFS);
53 tic->t_trans_type = XFS_TRANS_CHECKPOINT;
54
55
56
57
58
59 tic->t_curr_res = 0;
60 return tic;
61}
62
63
64
65
66
67
68
69
70
71
72
73void
74xlog_cil_init_post_recovery(
75 struct xlog *log)
76{
77 log->l_cilp->xc_ctx->ticket = xlog_cil_ticket_alloc(log);
78 log->l_cilp->xc_ctx->sequence = 1;
79 log->l_cilp->xc_ctx->commit_lsn = xlog_assign_lsn(log->l_curr_cycle,
80 log->l_curr_block);
81}
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109static struct xfs_log_vec *
110xlog_cil_prepare_log_vecs(
111 struct xfs_trans *tp)
112{
113 struct xfs_log_item_desc *lidp;
114 struct xfs_log_vec *lv = NULL;
115 struct xfs_log_vec *ret_lv = NULL;
116
117
118
119 if (list_empty(&tp->t_items)) {
120 ASSERT(0);
121 return NULL;
122 }
123
124 list_for_each_entry(lidp, &tp->t_items, lid_trans) {
125 struct xfs_log_vec *new_lv;
126 void *ptr;
127 int index;
128 int len = 0;
129 uint niovecs;
130
131
132 if (!(lidp->lid_flags & XFS_LID_DIRTY))
133 continue;
134
135
136 niovecs = IOP_SIZE(lidp->lid_item);
137 if (!niovecs)
138 continue;
139
140 new_lv = kmem_zalloc(sizeof(*new_lv) +
141 niovecs * sizeof(struct xfs_log_iovec),
142 KM_SLEEP);
143
144
145 new_lv->lv_iovecp = (struct xfs_log_iovec *)&new_lv[1];
146 new_lv->lv_niovecs = niovecs;
147 new_lv->lv_item = lidp->lid_item;
148
149
150 IOP_FORMAT(new_lv->lv_item, new_lv->lv_iovecp);
151 for (index = 0; index < new_lv->lv_niovecs; index++)
152 len += new_lv->lv_iovecp[index].i_len;
153
154 new_lv->lv_buf_len = len;
155 new_lv->lv_buf = kmem_alloc(new_lv->lv_buf_len,
156 KM_SLEEP|KM_NOFS);
157 ptr = new_lv->lv_buf;
158
159 for (index = 0; index < new_lv->lv_niovecs; index++) {
160 struct xfs_log_iovec *vec = &new_lv->lv_iovecp[index];
161
162 memcpy(ptr, vec->i_addr, vec->i_len);
163 vec->i_addr = ptr;
164 ptr += vec->i_len;
165 }
166 ASSERT(ptr == new_lv->lv_buf + new_lv->lv_buf_len);
167
168 if (!ret_lv)
169 ret_lv = new_lv;
170 else
171 lv->lv_next = new_lv;
172 lv = new_lv;
173 }
174
175 return ret_lv;
176}
177
178
179
180
181
182
183STATIC void
184xfs_cil_prepare_item(
185 struct xlog *log,
186 struct xfs_log_vec *lv,
187 int *len,
188 int *diff_iovecs)
189{
190 struct xfs_log_vec *old = lv->lv_item->li_lv;
191
192 if (old) {
193
194 ASSERT(!list_empty(&lv->lv_item->li_cil));
195 ASSERT(old->lv_buf && old->lv_buf_len && old->lv_niovecs);
196
197 *len += lv->lv_buf_len - old->lv_buf_len;
198 *diff_iovecs += lv->lv_niovecs - old->lv_niovecs;
199 kmem_free(old->lv_buf);
200 kmem_free(old);
201 } else {
202
203 ASSERT(!lv->lv_item->li_lv);
204 ASSERT(list_empty(&lv->lv_item->li_cil));
205
206 *len += lv->lv_buf_len;
207 *diff_iovecs += lv->lv_niovecs;
208 IOP_PIN(lv->lv_item);
209
210 }
211
212
213 lv->lv_item->li_lv = lv;
214
215
216
217
218
219
220
221 if (!lv->lv_item->li_seq)
222 lv->lv_item->li_seq = log->l_cilp->xc_ctx->sequence;
223}
224
225
226
227
228
229
230
231
232static void
233xlog_cil_insert_items(
234 struct xlog *log,
235 struct xfs_log_vec *log_vector,
236 struct xlog_ticket *ticket)
237{
238 struct xfs_cil *cil = log->l_cilp;
239 struct xfs_cil_ctx *ctx = cil->xc_ctx;
240 struct xfs_log_vec *lv;
241 int len = 0;
242 int diff_iovecs = 0;
243 int iclog_space;
244
245 ASSERT(log_vector);
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262 for (lv = log_vector; lv; lv = lv->lv_next)
263 xfs_cil_prepare_item(log, lv, &len, &diff_iovecs);
264
265
266 len += diff_iovecs * sizeof(xlog_op_header_t);
267
268 spin_lock(&cil->xc_cil_lock);
269
270
271 for (lv = log_vector; lv; lv = lv->lv_next)
272 list_move_tail(&lv->lv_item->li_cil, &cil->xc_cil);
273
274 ctx->nvecs += diff_iovecs;
275
276
277
278
279
280
281
282
283 if (ctx->ticket->t_curr_res == 0) {
284
285 ASSERT(ticket->t_curr_res >= ctx->ticket->t_unit_res + len);
286 ctx->ticket->t_curr_res = ctx->ticket->t_unit_res;
287 ticket->t_curr_res -= ctx->ticket->t_unit_res;
288 }
289
290
291 iclog_space = log->l_iclog_size - log->l_iclog_hsize;
292 if (len > 0 && (ctx->space_used / iclog_space !=
293 (ctx->space_used + len) / iclog_space)) {
294 int hdrs;
295
296 hdrs = (len + iclog_space - 1) / iclog_space;
297
298 hdrs *= log->l_iclog_hsize + sizeof(struct xlog_op_header);
299 ctx->ticket->t_unit_res += hdrs;
300 ctx->ticket->t_curr_res += hdrs;
301 ticket->t_curr_res -= hdrs;
302 ASSERT(ticket->t_curr_res >= len);
303 }
304 ticket->t_curr_res -= len;
305 ctx->space_used += len;
306
307 spin_unlock(&cil->xc_cil_lock);
308}
309
310static void
311xlog_cil_free_logvec(
312 struct xfs_log_vec *log_vector)
313{
314 struct xfs_log_vec *lv;
315
316 for (lv = log_vector; lv; ) {
317 struct xfs_log_vec *next = lv->lv_next;
318 kmem_free(lv->lv_buf);
319 kmem_free(lv);
320 lv = next;
321 }
322}
323
324
325
326
327
328
329static void
330xlog_cil_committed(
331 void *args,
332 int abort)
333{
334 struct xfs_cil_ctx *ctx = args;
335 struct xfs_mount *mp = ctx->cil->xc_log->l_mp;
336
337 xfs_trans_committed_bulk(ctx->cil->xc_log->l_ailp, ctx->lv_chain,
338 ctx->start_lsn, abort);
339
340 xfs_extent_busy_sort(&ctx->busy_extents);
341 xfs_extent_busy_clear(mp, &ctx->busy_extents,
342 (mp->m_flags & XFS_MOUNT_DISCARD) && !abort);
343
344 spin_lock(&ctx->cil->xc_cil_lock);
345 list_del(&ctx->committing);
346 spin_unlock(&ctx->cil->xc_cil_lock);
347
348 xlog_cil_free_logvec(ctx->lv_chain);
349
350 if (!list_empty(&ctx->busy_extents)) {
351 ASSERT(mp->m_flags & XFS_MOUNT_DISCARD);
352
353 xfs_discard_extents(mp, &ctx->busy_extents);
354 xfs_extent_busy_clear(mp, &ctx->busy_extents, false);
355 }
356
357 kmem_free(ctx);
358}
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374STATIC int
375xlog_cil_push(
376 struct xlog *log)
377{
378 struct xfs_cil *cil = log->l_cilp;
379 struct xfs_log_vec *lv;
380 struct xfs_cil_ctx *ctx;
381 struct xfs_cil_ctx *new_ctx;
382 struct xlog_in_core *commit_iclog;
383 struct xlog_ticket *tic;
384 int num_lv;
385 int num_iovecs;
386 int len;
387 int error = 0;
388 struct xfs_trans_header thdr;
389 struct xfs_log_iovec lhdr;
390 struct xfs_log_vec lvhdr = { NULL };
391 xfs_lsn_t commit_lsn;
392 xfs_lsn_t push_seq;
393
394 if (!cil)
395 return 0;
396
397 new_ctx = kmem_zalloc(sizeof(*new_ctx), KM_SLEEP|KM_NOFS);
398 new_ctx->ticket = xlog_cil_ticket_alloc(log);
399
400 down_write(&cil->xc_ctx_lock);
401 ctx = cil->xc_ctx;
402
403 spin_lock(&cil->xc_cil_lock);
404 push_seq = cil->xc_push_seq;
405 ASSERT(push_seq <= ctx->sequence);
406
407
408
409
410
411
412 if (list_empty(&cil->xc_cil)) {
413 cil->xc_push_seq = 0;
414 spin_unlock(&cil->xc_cil_lock);
415 goto out_skip;
416 }
417 spin_unlock(&cil->xc_cil_lock);
418
419
420
421 if (push_seq < cil->xc_ctx->sequence)
422 goto out_skip;
423
424
425
426
427
428
429
430 lv = NULL;
431 num_lv = 0;
432 num_iovecs = 0;
433 len = 0;
434 while (!list_empty(&cil->xc_cil)) {
435 struct xfs_log_item *item;
436 int i;
437
438 item = list_first_entry(&cil->xc_cil,
439 struct xfs_log_item, li_cil);
440 list_del_init(&item->li_cil);
441 if (!ctx->lv_chain)
442 ctx->lv_chain = item->li_lv;
443 else
444 lv->lv_next = item->li_lv;
445 lv = item->li_lv;
446 item->li_lv = NULL;
447
448 num_lv++;
449 num_iovecs += lv->lv_niovecs;
450 for (i = 0; i < lv->lv_niovecs; i++)
451 len += lv->lv_iovecp[i].i_len;
452 }
453
454
455
456
457
458
459
460 INIT_LIST_HEAD(&new_ctx->committing);
461 INIT_LIST_HEAD(&new_ctx->busy_extents);
462 new_ctx->sequence = ctx->sequence + 1;
463 new_ctx->cil = cil;
464 cil->xc_ctx = new_ctx;
465
466
467
468
469
470
471 cil->xc_current_sequence = new_ctx->sequence;
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492 spin_lock(&cil->xc_cil_lock);
493 list_add(&ctx->committing, &cil->xc_committing);
494 spin_unlock(&cil->xc_cil_lock);
495 up_write(&cil->xc_ctx_lock);
496
497
498
499
500
501
502
503
504
505
506 tic = ctx->ticket;
507 thdr.th_magic = XFS_TRANS_HEADER_MAGIC;
508 thdr.th_type = XFS_TRANS_CHECKPOINT;
509 thdr.th_tid = tic->t_tid;
510 thdr.th_num_items = num_iovecs;
511 lhdr.i_addr = &thdr;
512 lhdr.i_len = sizeof(xfs_trans_header_t);
513 lhdr.i_type = XLOG_REG_TYPE_TRANSHDR;
514 tic->t_curr_res -= lhdr.i_len + sizeof(xlog_op_header_t);
515
516 lvhdr.lv_niovecs = 1;
517 lvhdr.lv_iovecp = &lhdr;
518 lvhdr.lv_next = ctx->lv_chain;
519
520 error = xlog_write(log, &lvhdr, tic, &ctx->start_lsn, NULL, 0);
521 if (error)
522 goto out_abort_free_ticket;
523
524
525
526
527
528restart:
529 spin_lock(&cil->xc_cil_lock);
530 list_for_each_entry(new_ctx, &cil->xc_committing, committing) {
531
532
533
534
535 if (new_ctx->sequence >= ctx->sequence)
536 continue;
537 if (!new_ctx->commit_lsn) {
538
539
540
541
542 xlog_wait(&cil->xc_commit_wait, &cil->xc_cil_lock);
543 goto restart;
544 }
545 }
546 spin_unlock(&cil->xc_cil_lock);
547
548
549 commit_lsn = xfs_log_done(log->l_mp, tic, &commit_iclog, 0);
550 if (commit_lsn == -1)
551 goto out_abort;
552
553
554 ctx->log_cb.cb_func = xlog_cil_committed;
555 ctx->log_cb.cb_arg = ctx;
556 error = xfs_log_notify(log->l_mp, commit_iclog, &ctx->log_cb);
557 if (error)
558 goto out_abort;
559
560
561
562
563
564
565 spin_lock(&cil->xc_cil_lock);
566 ctx->commit_lsn = commit_lsn;
567 wake_up_all(&cil->xc_commit_wait);
568 spin_unlock(&cil->xc_cil_lock);
569
570
571 return xfs_log_release_iclog(log->l_mp, commit_iclog);
572
573out_skip:
574 up_write(&cil->xc_ctx_lock);
575 xfs_log_ticket_put(new_ctx->ticket);
576 kmem_free(new_ctx);
577 return 0;
578
579out_abort_free_ticket:
580 xfs_log_ticket_put(tic);
581out_abort:
582 xlog_cil_committed(ctx, XFS_LI_ABORTED);
583 return XFS_ERROR(EIO);
584}
585
586static void
587xlog_cil_push_work(
588 struct work_struct *work)
589{
590 struct xfs_cil *cil = container_of(work, struct xfs_cil,
591 xc_push_work);
592 xlog_cil_push(cil->xc_log);
593}
594
595
596
597
598
599
600
601
602static void
603xlog_cil_push_background(
604 struct xlog *log)
605{
606 struct xfs_cil *cil = log->l_cilp;
607
608
609
610
611
612 ASSERT(!list_empty(&cil->xc_cil));
613
614
615
616
617
618 if (cil->xc_ctx->space_used < XLOG_CIL_SPACE_LIMIT(log))
619 return;
620
621 spin_lock(&cil->xc_cil_lock);
622 if (cil->xc_push_seq < cil->xc_current_sequence) {
623 cil->xc_push_seq = cil->xc_current_sequence;
624 queue_work(log->l_mp->m_cil_workqueue, &cil->xc_push_work);
625 }
626 spin_unlock(&cil->xc_cil_lock);
627
628}
629
630static void
631xlog_cil_push_foreground(
632 struct xlog *log,
633 xfs_lsn_t push_seq)
634{
635 struct xfs_cil *cil = log->l_cilp;
636
637 if (!cil)
638 return;
639
640 ASSERT(push_seq && push_seq <= cil->xc_current_sequence);
641
642
643 flush_work(&cil->xc_push_work);
644
645
646
647
648
649 spin_lock(&cil->xc_cil_lock);
650 if (list_empty(&cil->xc_cil) || push_seq <= cil->xc_push_seq) {
651 spin_unlock(&cil->xc_cil_lock);
652 return;
653 }
654
655 cil->xc_push_seq = push_seq;
656 spin_unlock(&cil->xc_cil_lock);
657
658
659 xlog_cil_push(log);
660}
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679int
680xfs_log_commit_cil(
681 struct xfs_mount *mp,
682 struct xfs_trans *tp,
683 xfs_lsn_t *commit_lsn,
684 int flags)
685{
686 struct xlog *log = mp->m_log;
687 int log_flags = 0;
688 struct xfs_log_vec *log_vector;
689
690 if (flags & XFS_TRANS_RELEASE_LOG_RES)
691 log_flags = XFS_LOG_REL_PERM_RESERV;
692
693
694
695
696
697
698
699 log_vector = xlog_cil_prepare_log_vecs(tp);
700 if (!log_vector)
701 return ENOMEM;
702
703
704 down_read(&log->l_cilp->xc_ctx_lock);
705 if (commit_lsn)
706 *commit_lsn = log->l_cilp->xc_ctx->sequence;
707
708 xlog_cil_insert_items(log, log_vector, tp->t_ticket);
709
710
711 if (tp->t_ticket->t_curr_res < 0)
712 xlog_print_tic_res(log->l_mp, tp->t_ticket);
713
714
715 if (!list_empty(&tp->t_busy)) {
716 spin_lock(&log->l_cilp->xc_cil_lock);
717 list_splice_init(&tp->t_busy,
718 &log->l_cilp->xc_ctx->busy_extents);
719 spin_unlock(&log->l_cilp->xc_cil_lock);
720 }
721
722 tp->t_commit_lsn = *commit_lsn;
723 xfs_log_done(mp, tp->t_ticket, NULL, log_flags);
724 xfs_trans_unreserve_and_mod_sb(tp);
725
726
727
728
729
730
731
732
733
734
735
736
737 xfs_trans_free_items(tp, *commit_lsn, 0);
738
739 xlog_cil_push_background(log);
740
741 up_read(&log->l_cilp->xc_ctx_lock);
742 return 0;
743}
744
745
746
747
748
749
750
751
752
753
754
755xfs_lsn_t
756xlog_cil_force_lsn(
757 struct xlog *log,
758 xfs_lsn_t sequence)
759{
760 struct xfs_cil *cil = log->l_cilp;
761 struct xfs_cil_ctx *ctx;
762 xfs_lsn_t commit_lsn = NULLCOMMITLSN;
763
764 ASSERT(sequence <= cil->xc_current_sequence);
765
766
767
768
769
770
771 xlog_cil_push_foreground(log, sequence);
772
773
774
775
776
777
778
779restart:
780 spin_lock(&cil->xc_cil_lock);
781 list_for_each_entry(ctx, &cil->xc_committing, committing) {
782 if (ctx->sequence > sequence)
783 continue;
784 if (!ctx->commit_lsn) {
785
786
787
788
789 xlog_wait(&cil->xc_commit_wait, &cil->xc_cil_lock);
790 goto restart;
791 }
792 if (ctx->sequence != sequence)
793 continue;
794
795 commit_lsn = ctx->commit_lsn;
796 }
797 spin_unlock(&cil->xc_cil_lock);
798 return commit_lsn;
799}
800
801
802
803
804
805
806
807
808
809
810bool
811xfs_log_item_in_current_chkpt(
812 struct xfs_log_item *lip)
813{
814 struct xfs_cil_ctx *ctx;
815
816 if (list_empty(&lip->li_cil))
817 return false;
818
819 ctx = lip->li_mountp->m_log->l_cilp->xc_ctx;
820
821
822
823
824
825
826 if (XFS_LSN_CMP(lip->li_seq, ctx->sequence) != 0)
827 return false;
828 return true;
829}
830
831
832
833
834int
835xlog_cil_init(
836 struct xlog *log)
837{
838 struct xfs_cil *cil;
839 struct xfs_cil_ctx *ctx;
840
841 cil = kmem_zalloc(sizeof(*cil), KM_SLEEP|KM_MAYFAIL);
842 if (!cil)
843 return ENOMEM;
844
845 ctx = kmem_zalloc(sizeof(*ctx), KM_SLEEP|KM_MAYFAIL);
846 if (!ctx) {
847 kmem_free(cil);
848 return ENOMEM;
849 }
850
851 INIT_WORK(&cil->xc_push_work, xlog_cil_push_work);
852 INIT_LIST_HEAD(&cil->xc_cil);
853 INIT_LIST_HEAD(&cil->xc_committing);
854 spin_lock_init(&cil->xc_cil_lock);
855 init_rwsem(&cil->xc_ctx_lock);
856 init_waitqueue_head(&cil->xc_commit_wait);
857
858 INIT_LIST_HEAD(&ctx->committing);
859 INIT_LIST_HEAD(&ctx->busy_extents);
860 ctx->sequence = 1;
861 ctx->cil = cil;
862 cil->xc_ctx = ctx;
863 cil->xc_current_sequence = ctx->sequence;
864
865 cil->xc_log = log;
866 log->l_cilp = cil;
867 return 0;
868}
869
870void
871xlog_cil_destroy(
872 struct xlog *log)
873{
874 if (log->l_cilp->xc_ctx) {
875 if (log->l_cilp->xc_ctx->ticket)
876 xfs_log_ticket_put(log->l_cilp->xc_ctx->ticket);
877 kmem_free(log->l_cilp->xc_ctx);
878 }
879
880 ASSERT(list_empty(&log->l_cilp->xc_cil));
881 kmem_free(log->l_cilp);
882}
883
884