1
2
3
4
5
6#include "xfs.h"
7#include "xfs_fs.h"
8#include "xfs_format.h"
9#include "xfs_log_format.h"
10#include "xfs_trans_resv.h"
11#include "xfs_bit.h"
12#include "xfs_shared.h"
13#include "xfs_mount.h"
14#include "xfs_defer.h"
15#include "xfs_trans.h"
16#include "xfs_trans_priv.h"
17#include "xfs_extfree_item.h"
18#include "xfs_log.h"
19#include "xfs_btree.h"
20#include "xfs_rmap.h"
21#include "xfs_alloc.h"
22#include "xfs_bmap.h"
23#include "xfs_trace.h"
24#include "xfs_error.h"
25#include "xfs_log_priv.h"
26#include "xfs_log_recover.h"
27
28kmem_zone_t *xfs_efi_zone;
29kmem_zone_t *xfs_efd_zone;
30
31static const struct xfs_item_ops xfs_efi_item_ops;
32
33static inline struct xfs_efi_log_item *EFI_ITEM(struct xfs_log_item *lip)
34{
35 return container_of(lip, struct xfs_efi_log_item, efi_item);
36}
37
38STATIC void
39xfs_efi_item_free(
40 struct xfs_efi_log_item *efip)
41{
42 kmem_free(efip->efi_item.li_lv_shadow);
43 if (efip->efi_format.efi_nextents > XFS_EFI_MAX_FAST_EXTENTS)
44 kmem_free(efip);
45 else
46 kmem_cache_free(xfs_efi_zone, efip);
47}
48
49
50
51
52
53
54
55
56STATIC void
57xfs_efi_release(
58 struct xfs_efi_log_item *efip)
59{
60 ASSERT(atomic_read(&efip->efi_refcount) > 0);
61 if (atomic_dec_and_test(&efip->efi_refcount)) {
62 xfs_trans_ail_delete(&efip->efi_item, SHUTDOWN_LOG_IO_ERROR);
63 xfs_efi_item_free(efip);
64 }
65}
66
67
68
69
70
71
72static inline int
73xfs_efi_item_sizeof(
74 struct xfs_efi_log_item *efip)
75{
76 return sizeof(struct xfs_efi_log_format) +
77 (efip->efi_format.efi_nextents - 1) * sizeof(xfs_extent_t);
78}
79
80STATIC void
81xfs_efi_item_size(
82 struct xfs_log_item *lip,
83 int *nvecs,
84 int *nbytes)
85{
86 *nvecs += 1;
87 *nbytes += xfs_efi_item_sizeof(EFI_ITEM(lip));
88}
89
90
91
92
93
94
95
96
97STATIC void
98xfs_efi_item_format(
99 struct xfs_log_item *lip,
100 struct xfs_log_vec *lv)
101{
102 struct xfs_efi_log_item *efip = EFI_ITEM(lip);
103 struct xfs_log_iovec *vecp = NULL;
104
105 ASSERT(atomic_read(&efip->efi_next_extent) ==
106 efip->efi_format.efi_nextents);
107
108 efip->efi_format.efi_type = XFS_LI_EFI;
109 efip->efi_format.efi_size = 1;
110
111 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_EFI_FORMAT,
112 &efip->efi_format,
113 xfs_efi_item_sizeof(efip));
114}
115
116
117
118
119
120
121
122
123
124
125STATIC void
126xfs_efi_item_unpin(
127 struct xfs_log_item *lip,
128 int remove)
129{
130 struct xfs_efi_log_item *efip = EFI_ITEM(lip);
131 xfs_efi_release(efip);
132}
133
134
135
136
137
138
139STATIC void
140xfs_efi_item_release(
141 struct xfs_log_item *lip)
142{
143 xfs_efi_release(EFI_ITEM(lip));
144}
145
146
147
148
149STATIC struct xfs_efi_log_item *
150xfs_efi_init(
151 struct xfs_mount *mp,
152 uint nextents)
153
154{
155 struct xfs_efi_log_item *efip;
156 uint size;
157
158 ASSERT(nextents > 0);
159 if (nextents > XFS_EFI_MAX_FAST_EXTENTS) {
160 size = (uint)(sizeof(struct xfs_efi_log_item) +
161 ((nextents - 1) * sizeof(xfs_extent_t)));
162 efip = kmem_zalloc(size, 0);
163 } else {
164 efip = kmem_cache_zalloc(xfs_efi_zone,
165 GFP_KERNEL | __GFP_NOFAIL);
166 }
167
168 xfs_log_item_init(mp, &efip->efi_item, XFS_LI_EFI, &xfs_efi_item_ops);
169 efip->efi_format.efi_nextents = nextents;
170 efip->efi_format.efi_id = (uintptr_t)(void *)efip;
171 atomic_set(&efip->efi_next_extent, 0);
172 atomic_set(&efip->efi_refcount, 2);
173
174 return efip;
175}
176
177
178
179
180
181
182
183
184STATIC int
185xfs_efi_copy_format(xfs_log_iovec_t *buf, xfs_efi_log_format_t *dst_efi_fmt)
186{
187 xfs_efi_log_format_t *src_efi_fmt = buf->i_addr;
188 uint i;
189 uint len = sizeof(xfs_efi_log_format_t) +
190 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_t);
191 uint len32 = sizeof(xfs_efi_log_format_32_t) +
192 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_32_t);
193 uint len64 = sizeof(xfs_efi_log_format_64_t) +
194 (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_64_t);
195
196 if (buf->i_len == len) {
197 memcpy((char *)dst_efi_fmt, (char*)src_efi_fmt, len);
198 return 0;
199 } else if (buf->i_len == len32) {
200 xfs_efi_log_format_32_t *src_efi_fmt_32 = buf->i_addr;
201
202 dst_efi_fmt->efi_type = src_efi_fmt_32->efi_type;
203 dst_efi_fmt->efi_size = src_efi_fmt_32->efi_size;
204 dst_efi_fmt->efi_nextents = src_efi_fmt_32->efi_nextents;
205 dst_efi_fmt->efi_id = src_efi_fmt_32->efi_id;
206 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) {
207 dst_efi_fmt->efi_extents[i].ext_start =
208 src_efi_fmt_32->efi_extents[i].ext_start;
209 dst_efi_fmt->efi_extents[i].ext_len =
210 src_efi_fmt_32->efi_extents[i].ext_len;
211 }
212 return 0;
213 } else if (buf->i_len == len64) {
214 xfs_efi_log_format_64_t *src_efi_fmt_64 = buf->i_addr;
215
216 dst_efi_fmt->efi_type = src_efi_fmt_64->efi_type;
217 dst_efi_fmt->efi_size = src_efi_fmt_64->efi_size;
218 dst_efi_fmt->efi_nextents = src_efi_fmt_64->efi_nextents;
219 dst_efi_fmt->efi_id = src_efi_fmt_64->efi_id;
220 for (i = 0; i < dst_efi_fmt->efi_nextents; i++) {
221 dst_efi_fmt->efi_extents[i].ext_start =
222 src_efi_fmt_64->efi_extents[i].ext_start;
223 dst_efi_fmt->efi_extents[i].ext_len =
224 src_efi_fmt_64->efi_extents[i].ext_len;
225 }
226 return 0;
227 }
228 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, NULL);
229 return -EFSCORRUPTED;
230}
231
232static inline struct xfs_efd_log_item *EFD_ITEM(struct xfs_log_item *lip)
233{
234 return container_of(lip, struct xfs_efd_log_item, efd_item);
235}
236
237STATIC void
238xfs_efd_item_free(struct xfs_efd_log_item *efdp)
239{
240 kmem_free(efdp->efd_item.li_lv_shadow);
241 if (efdp->efd_format.efd_nextents > XFS_EFD_MAX_FAST_EXTENTS)
242 kmem_free(efdp);
243 else
244 kmem_cache_free(xfs_efd_zone, efdp);
245}
246
247
248
249
250
251
252static inline int
253xfs_efd_item_sizeof(
254 struct xfs_efd_log_item *efdp)
255{
256 return sizeof(xfs_efd_log_format_t) +
257 (efdp->efd_format.efd_nextents - 1) * sizeof(xfs_extent_t);
258}
259
260STATIC void
261xfs_efd_item_size(
262 struct xfs_log_item *lip,
263 int *nvecs,
264 int *nbytes)
265{
266 *nvecs += 1;
267 *nbytes += xfs_efd_item_sizeof(EFD_ITEM(lip));
268}
269
270
271
272
273
274
275
276
277STATIC void
278xfs_efd_item_format(
279 struct xfs_log_item *lip,
280 struct xfs_log_vec *lv)
281{
282 struct xfs_efd_log_item *efdp = EFD_ITEM(lip);
283 struct xfs_log_iovec *vecp = NULL;
284
285 ASSERT(efdp->efd_next_extent == efdp->efd_format.efd_nextents);
286
287 efdp->efd_format.efd_type = XFS_LI_EFD;
288 efdp->efd_format.efd_size = 1;
289
290 xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_EFD_FORMAT,
291 &efdp->efd_format,
292 xfs_efd_item_sizeof(efdp));
293}
294
295
296
297
298
299STATIC void
300xfs_efd_item_release(
301 struct xfs_log_item *lip)
302{
303 struct xfs_efd_log_item *efdp = EFD_ITEM(lip);
304
305 xfs_efi_release(efdp->efd_efip);
306 xfs_efd_item_free(efdp);
307}
308
309static const struct xfs_item_ops xfs_efd_item_ops = {
310 .flags = XFS_ITEM_RELEASE_WHEN_COMMITTED,
311 .iop_size = xfs_efd_item_size,
312 .iop_format = xfs_efd_item_format,
313 .iop_release = xfs_efd_item_release,
314};
315
316
317
318
319
320
321static struct xfs_efd_log_item *
322xfs_trans_get_efd(
323 struct xfs_trans *tp,
324 struct xfs_efi_log_item *efip,
325 unsigned int nextents)
326{
327 struct xfs_efd_log_item *efdp;
328
329 ASSERT(nextents > 0);
330
331 if (nextents > XFS_EFD_MAX_FAST_EXTENTS) {
332 efdp = kmem_zalloc(sizeof(struct xfs_efd_log_item) +
333 (nextents - 1) * sizeof(struct xfs_extent),
334 0);
335 } else {
336 efdp = kmem_cache_zalloc(xfs_efd_zone,
337 GFP_KERNEL | __GFP_NOFAIL);
338 }
339
340 xfs_log_item_init(tp->t_mountp, &efdp->efd_item, XFS_LI_EFD,
341 &xfs_efd_item_ops);
342 efdp->efd_efip = efip;
343 efdp->efd_format.efd_nextents = nextents;
344 efdp->efd_format.efd_efi_id = efip->efi_format.efi_id;
345
346 xfs_trans_add_item(tp, &efdp->efd_item);
347 return efdp;
348}
349
350
351
352
353
354
355static int
356xfs_trans_free_extent(
357 struct xfs_trans *tp,
358 struct xfs_efd_log_item *efdp,
359 xfs_fsblock_t start_block,
360 xfs_extlen_t ext_len,
361 const struct xfs_owner_info *oinfo,
362 bool skip_discard)
363{
364 struct xfs_mount *mp = tp->t_mountp;
365 struct xfs_extent *extp;
366 uint next_extent;
367 xfs_agnumber_t agno = XFS_FSB_TO_AGNO(mp, start_block);
368 xfs_agblock_t agbno = XFS_FSB_TO_AGBNO(mp,
369 start_block);
370 int error;
371
372 trace_xfs_bmap_free_deferred(tp->t_mountp, agno, 0, agbno, ext_len);
373
374 error = __xfs_free_extent(tp, start_block, ext_len,
375 oinfo, XFS_AG_RESV_NONE, skip_discard);
376
377
378
379
380
381
382
383 tp->t_flags |= XFS_TRANS_DIRTY;
384 set_bit(XFS_LI_DIRTY, &efdp->efd_item.li_flags);
385
386 next_extent = efdp->efd_next_extent;
387 ASSERT(next_extent < efdp->efd_format.efd_nextents);
388 extp = &(efdp->efd_format.efd_extents[next_extent]);
389 extp->ext_start = start_block;
390 extp->ext_len = ext_len;
391 efdp->efd_next_extent++;
392
393 return error;
394}
395
396
397static int
398xfs_extent_free_diff_items(
399 void *priv,
400 const struct list_head *a,
401 const struct list_head *b)
402{
403 struct xfs_mount *mp = priv;
404 struct xfs_extent_free_item *ra;
405 struct xfs_extent_free_item *rb;
406
407 ra = container_of(a, struct xfs_extent_free_item, xefi_list);
408 rb = container_of(b, struct xfs_extent_free_item, xefi_list);
409 return XFS_FSB_TO_AGNO(mp, ra->xefi_startblock) -
410 XFS_FSB_TO_AGNO(mp, rb->xefi_startblock);
411}
412
413
414STATIC void
415xfs_extent_free_log_item(
416 struct xfs_trans *tp,
417 struct xfs_efi_log_item *efip,
418 struct xfs_extent_free_item *free)
419{
420 uint next_extent;
421 struct xfs_extent *extp;
422
423 tp->t_flags |= XFS_TRANS_DIRTY;
424 set_bit(XFS_LI_DIRTY, &efip->efi_item.li_flags);
425
426
427
428
429
430
431 next_extent = atomic_inc_return(&efip->efi_next_extent) - 1;
432 ASSERT(next_extent < efip->efi_format.efi_nextents);
433 extp = &efip->efi_format.efi_extents[next_extent];
434 extp->ext_start = free->xefi_startblock;
435 extp->ext_len = free->xefi_blockcount;
436}
437
438static struct xfs_log_item *
439xfs_extent_free_create_intent(
440 struct xfs_trans *tp,
441 struct list_head *items,
442 unsigned int count,
443 bool sort)
444{
445 struct xfs_mount *mp = tp->t_mountp;
446 struct xfs_efi_log_item *efip = xfs_efi_init(mp, count);
447 struct xfs_extent_free_item *free;
448
449 ASSERT(count > 0);
450
451 xfs_trans_add_item(tp, &efip->efi_item);
452 if (sort)
453 list_sort(mp, items, xfs_extent_free_diff_items);
454 list_for_each_entry(free, items, xefi_list)
455 xfs_extent_free_log_item(tp, efip, free);
456 return &efip->efi_item;
457}
458
459
460static struct xfs_log_item *
461xfs_extent_free_create_done(
462 struct xfs_trans *tp,
463 struct xfs_log_item *intent,
464 unsigned int count)
465{
466 return &xfs_trans_get_efd(tp, EFI_ITEM(intent), count)->efd_item;
467}
468
469
470STATIC int
471xfs_extent_free_finish_item(
472 struct xfs_trans *tp,
473 struct xfs_log_item *done,
474 struct list_head *item,
475 struct xfs_btree_cur **state)
476{
477 struct xfs_extent_free_item *free;
478 int error;
479
480 free = container_of(item, struct xfs_extent_free_item, xefi_list);
481 error = xfs_trans_free_extent(tp, EFD_ITEM(done),
482 free->xefi_startblock,
483 free->xefi_blockcount,
484 &free->xefi_oinfo, free->xefi_skip_discard);
485 kmem_free(free);
486 return error;
487}
488
489
490STATIC void
491xfs_extent_free_abort_intent(
492 struct xfs_log_item *intent)
493{
494 xfs_efi_release(EFI_ITEM(intent));
495}
496
497
498STATIC void
499xfs_extent_free_cancel_item(
500 struct list_head *item)
501{
502 struct xfs_extent_free_item *free;
503
504 free = container_of(item, struct xfs_extent_free_item, xefi_list);
505 kmem_free(free);
506}
507
508const struct xfs_defer_op_type xfs_extent_free_defer_type = {
509 .max_items = XFS_EFI_MAX_FAST_EXTENTS,
510 .create_intent = xfs_extent_free_create_intent,
511 .abort_intent = xfs_extent_free_abort_intent,
512 .create_done = xfs_extent_free_create_done,
513 .finish_item = xfs_extent_free_finish_item,
514 .cancel_item = xfs_extent_free_cancel_item,
515};
516
517
518
519
520
521STATIC int
522xfs_agfl_free_finish_item(
523 struct xfs_trans *tp,
524 struct xfs_log_item *done,
525 struct list_head *item,
526 struct xfs_btree_cur **state)
527{
528 struct xfs_mount *mp = tp->t_mountp;
529 struct xfs_efd_log_item *efdp = EFD_ITEM(done);
530 struct xfs_extent_free_item *free;
531 struct xfs_extent *extp;
532 struct xfs_buf *agbp;
533 int error;
534 xfs_agnumber_t agno;
535 xfs_agblock_t agbno;
536 uint next_extent;
537
538 free = container_of(item, struct xfs_extent_free_item, xefi_list);
539 ASSERT(free->xefi_blockcount == 1);
540 agno = XFS_FSB_TO_AGNO(mp, free->xefi_startblock);
541 agbno = XFS_FSB_TO_AGBNO(mp, free->xefi_startblock);
542
543 trace_xfs_agfl_free_deferred(mp, agno, 0, agbno, free->xefi_blockcount);
544
545 error = xfs_alloc_read_agf(mp, tp, agno, 0, &agbp);
546 if (!error)
547 error = xfs_free_agfl_block(tp, agno, agbno, agbp,
548 &free->xefi_oinfo);
549
550
551
552
553
554
555
556
557 tp->t_flags |= XFS_TRANS_DIRTY;
558 set_bit(XFS_LI_DIRTY, &efdp->efd_item.li_flags);
559
560 next_extent = efdp->efd_next_extent;
561 ASSERT(next_extent < efdp->efd_format.efd_nextents);
562 extp = &(efdp->efd_format.efd_extents[next_extent]);
563 extp->ext_start = free->xefi_startblock;
564 extp->ext_len = free->xefi_blockcount;
565 efdp->efd_next_extent++;
566
567 kmem_free(free);
568 return error;
569}
570
571
572const struct xfs_defer_op_type xfs_agfl_free_defer_type = {
573 .max_items = XFS_EFI_MAX_FAST_EXTENTS,
574 .create_intent = xfs_extent_free_create_intent,
575 .abort_intent = xfs_extent_free_abort_intent,
576 .create_done = xfs_extent_free_create_done,
577 .finish_item = xfs_agfl_free_finish_item,
578 .cancel_item = xfs_extent_free_cancel_item,
579};
580
581
582static inline bool
583xfs_efi_validate_ext(
584 struct xfs_mount *mp,
585 struct xfs_extent *extp)
586{
587 return xfs_verify_fsbext(mp, extp->ext_start, extp->ext_len);
588}
589
590
591
592
593
594STATIC int
595xfs_efi_item_recover(
596 struct xfs_log_item *lip,
597 struct list_head *capture_list)
598{
599 struct xfs_efi_log_item *efip = EFI_ITEM(lip);
600 struct xfs_mount *mp = lip->li_mountp;
601 struct xfs_efd_log_item *efdp;
602 struct xfs_trans *tp;
603 struct xfs_extent *extp;
604 int i;
605 int error = 0;
606
607
608
609
610
611
612 for (i = 0; i < efip->efi_format.efi_nextents; i++) {
613 if (!xfs_efi_validate_ext(mp,
614 &efip->efi_format.efi_extents[i])) {
615 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
616 &efip->efi_format,
617 sizeof(efip->efi_format));
618 return -EFSCORRUPTED;
619 }
620 }
621
622 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
623 if (error)
624 return error;
625 efdp = xfs_trans_get_efd(tp, efip, efip->efi_format.efi_nextents);
626
627 for (i = 0; i < efip->efi_format.efi_nextents; i++) {
628 extp = &efip->efi_format.efi_extents[i];
629 error = xfs_trans_free_extent(tp, efdp, extp->ext_start,
630 extp->ext_len,
631 &XFS_RMAP_OINFO_ANY_OWNER, false);
632 if (error == -EFSCORRUPTED)
633 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
634 extp, sizeof(*extp));
635 if (error)
636 goto abort_error;
637
638 }
639
640 return xfs_defer_ops_capture_and_commit(tp, NULL, capture_list);
641
642abort_error:
643 xfs_trans_cancel(tp);
644 return error;
645}
646
647STATIC bool
648xfs_efi_item_match(
649 struct xfs_log_item *lip,
650 uint64_t intent_id)
651{
652 return EFI_ITEM(lip)->efi_format.efi_id == intent_id;
653}
654
655
656static struct xfs_log_item *
657xfs_efi_item_relog(
658 struct xfs_log_item *intent,
659 struct xfs_trans *tp)
660{
661 struct xfs_efd_log_item *efdp;
662 struct xfs_efi_log_item *efip;
663 struct xfs_extent *extp;
664 unsigned int count;
665
666 count = EFI_ITEM(intent)->efi_format.efi_nextents;
667 extp = EFI_ITEM(intent)->efi_format.efi_extents;
668
669 tp->t_flags |= XFS_TRANS_DIRTY;
670 efdp = xfs_trans_get_efd(tp, EFI_ITEM(intent), count);
671 efdp->efd_next_extent = count;
672 memcpy(efdp->efd_format.efd_extents, extp, count * sizeof(*extp));
673 set_bit(XFS_LI_DIRTY, &efdp->efd_item.li_flags);
674
675 efip = xfs_efi_init(tp->t_mountp, count);
676 memcpy(efip->efi_format.efi_extents, extp, count * sizeof(*extp));
677 atomic_set(&efip->efi_next_extent, count);
678 xfs_trans_add_item(tp, &efip->efi_item);
679 set_bit(XFS_LI_DIRTY, &efip->efi_item.li_flags);
680 return &efip->efi_item;
681}
682
683static const struct xfs_item_ops xfs_efi_item_ops = {
684 .iop_size = xfs_efi_item_size,
685 .iop_format = xfs_efi_item_format,
686 .iop_unpin = xfs_efi_item_unpin,
687 .iop_release = xfs_efi_item_release,
688 .iop_recover = xfs_efi_item_recover,
689 .iop_match = xfs_efi_item_match,
690 .iop_relog = xfs_efi_item_relog,
691};
692
693
694
695
696
697
698
699
700STATIC int
701xlog_recover_efi_commit_pass2(
702 struct xlog *log,
703 struct list_head *buffer_list,
704 struct xlog_recover_item *item,
705 xfs_lsn_t lsn)
706{
707 struct xfs_mount *mp = log->l_mp;
708 struct xfs_efi_log_item *efip;
709 struct xfs_efi_log_format *efi_formatp;
710 int error;
711
712 efi_formatp = item->ri_buf[0].i_addr;
713
714 efip = xfs_efi_init(mp, efi_formatp->efi_nextents);
715 error = xfs_efi_copy_format(&item->ri_buf[0], &efip->efi_format);
716 if (error) {
717 xfs_efi_item_free(efip);
718 return error;
719 }
720 atomic_set(&efip->efi_next_extent, efi_formatp->efi_nextents);
721
722
723
724
725 xfs_trans_ail_insert(log->l_ailp, &efip->efi_item, lsn);
726 xfs_efi_release(efip);
727 return 0;
728}
729
730const struct xlog_recover_item_ops xlog_efi_item_ops = {
731 .item_type = XFS_LI_EFI,
732 .commit_pass2 = xlog_recover_efi_commit_pass2,
733};
734
735
736
737
738
739
740
741
742STATIC int
743xlog_recover_efd_commit_pass2(
744 struct xlog *log,
745 struct list_head *buffer_list,
746 struct xlog_recover_item *item,
747 xfs_lsn_t lsn)
748{
749 struct xfs_efd_log_format *efd_formatp;
750
751 efd_formatp = item->ri_buf[0].i_addr;
752 ASSERT((item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_32_t) +
753 ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_32_t)))) ||
754 (item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_64_t) +
755 ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_64_t)))));
756
757 xlog_recover_release_intent(log, XFS_LI_EFI, efd_formatp->efd_efi_id);
758 return 0;
759}
760
761const struct xlog_recover_item_ops xlog_efd_item_ops = {
762 .item_type = XFS_LI_EFD,
763 .commit_pass2 = xlog_recover_efd_commit_pass2,
764};
765