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_sb.h"
24#include "xfs_ag.h"
25#include "xfs_mount.h"
26#include "xfs_trans_priv.h"
27#include "xfs_bmap_btree.h"
28#include "xfs_dinode.h"
29#include "xfs_inode.h"
30#include "xfs_inode_item.h"
31#include "xfs_error.h"
32#include "xfs_trace.h"
33
34
35kmem_zone_t *xfs_ili_zone;
36
37static inline struct xfs_inode_log_item *INODE_ITEM(struct xfs_log_item *lip)
38{
39 return container_of(lip, struct xfs_inode_log_item, ili_item);
40}
41
42
43
44
45
46
47
48
49
50STATIC uint
51xfs_inode_item_size(
52 struct xfs_log_item *lip)
53{
54 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
55 struct xfs_inode *ip = iip->ili_inode;
56 uint nvecs = 2;
57
58 switch (ip->i_d.di_format) {
59 case XFS_DINODE_FMT_EXTENTS:
60 if ((iip->ili_fields & XFS_ILOG_DEXT) &&
61 ip->i_d.di_nextents > 0 &&
62 ip->i_df.if_bytes > 0)
63 nvecs++;
64 break;
65
66 case XFS_DINODE_FMT_BTREE:
67 if ((iip->ili_fields & XFS_ILOG_DBROOT) &&
68 ip->i_df.if_broot_bytes > 0)
69 nvecs++;
70 break;
71
72 case XFS_DINODE_FMT_LOCAL:
73 if ((iip->ili_fields & XFS_ILOG_DDATA) &&
74 ip->i_df.if_bytes > 0)
75 nvecs++;
76 break;
77
78 case XFS_DINODE_FMT_DEV:
79 case XFS_DINODE_FMT_UUID:
80 break;
81
82 default:
83 ASSERT(0);
84 break;
85 }
86
87 if (!XFS_IFORK_Q(ip))
88 return nvecs;
89
90
91
92
93
94 switch (ip->i_d.di_aformat) {
95 case XFS_DINODE_FMT_EXTENTS:
96 if ((iip->ili_fields & XFS_ILOG_AEXT) &&
97 ip->i_d.di_anextents > 0 &&
98 ip->i_afp->if_bytes > 0)
99 nvecs++;
100 break;
101
102 case XFS_DINODE_FMT_BTREE:
103 if ((iip->ili_fields & XFS_ILOG_ABROOT) &&
104 ip->i_afp->if_broot_bytes > 0)
105 nvecs++;
106 break;
107
108 case XFS_DINODE_FMT_LOCAL:
109 if ((iip->ili_fields & XFS_ILOG_ADATA) &&
110 ip->i_afp->if_bytes > 0)
111 nvecs++;
112 break;
113
114 default:
115 ASSERT(0);
116 break;
117 }
118
119 return nvecs;
120}
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137STATIC void
138xfs_inode_item_format_extents(
139 struct xfs_inode *ip,
140 struct xfs_log_iovec *vecp,
141 int whichfork,
142 int type)
143{
144 xfs_bmbt_rec_t *ext_buffer;
145
146 ext_buffer = kmem_alloc(XFS_IFORK_SIZE(ip, whichfork), KM_SLEEP);
147 if (whichfork == XFS_DATA_FORK)
148 ip->i_itemp->ili_extents_buf = ext_buffer;
149 else
150 ip->i_itemp->ili_aextents_buf = ext_buffer;
151
152 vecp->i_addr = ext_buffer;
153 vecp->i_len = xfs_iextents_copy(ip, ext_buffer, whichfork);
154 vecp->i_type = type;
155}
156
157
158
159
160
161
162
163
164STATIC void
165xfs_inode_item_format(
166 struct xfs_log_item *lip,
167 struct xfs_log_iovec *vecp)
168{
169 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
170 struct xfs_inode *ip = iip->ili_inode;
171 uint nvecs;
172 size_t data_bytes;
173 xfs_mount_t *mp;
174
175 vecp->i_addr = &iip->ili_format;
176 vecp->i_len = sizeof(xfs_inode_log_format_t);
177 vecp->i_type = XLOG_REG_TYPE_IFORMAT;
178 vecp++;
179 nvecs = 1;
180
181 vecp->i_addr = &ip->i_d;
182 vecp->i_len = xfs_icdinode_size(ip->i_d.di_version);
183 vecp->i_type = XLOG_REG_TYPE_ICORE;
184 vecp++;
185 nvecs++;
186
187
188
189
190
191
192
193
194
195 mp = ip->i_mount;
196 ASSERT(ip->i_d.di_version == 1 || xfs_sb_version_hasnlink(&mp->m_sb));
197 if (ip->i_d.di_version == 1) {
198 if (!xfs_sb_version_hasnlink(&mp->m_sb)) {
199
200
201
202 ASSERT(ip->i_d.di_nlink <= XFS_MAXLINK_1);
203 ip->i_d.di_onlink = ip->i_d.di_nlink;
204 } else {
205
206
207
208
209
210 ip->i_d.di_version = 2;
211 ip->i_d.di_onlink = 0;
212 memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
213 }
214 }
215
216 switch (ip->i_d.di_format) {
217 case XFS_DINODE_FMT_EXTENTS:
218 iip->ili_fields &=
219 ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT |
220 XFS_ILOG_DEV | XFS_ILOG_UUID);
221
222 if ((iip->ili_fields & XFS_ILOG_DEXT) &&
223 ip->i_d.di_nextents > 0 &&
224 ip->i_df.if_bytes > 0) {
225 ASSERT(ip->i_df.if_u1.if_extents != NULL);
226 ASSERT(ip->i_df.if_bytes / sizeof(xfs_bmbt_rec_t) > 0);
227 ASSERT(iip->ili_extents_buf == NULL);
228
229#ifdef XFS_NATIVE_HOST
230 if (ip->i_d.di_nextents == ip->i_df.if_bytes /
231 (uint)sizeof(xfs_bmbt_rec_t)) {
232
233
234
235
236
237 vecp->i_addr = ip->i_df.if_u1.if_extents;
238 vecp->i_len = ip->i_df.if_bytes;
239 vecp->i_type = XLOG_REG_TYPE_IEXT;
240 } else
241#endif
242 {
243 xfs_inode_item_format_extents(ip, vecp,
244 XFS_DATA_FORK, XLOG_REG_TYPE_IEXT);
245 }
246 ASSERT(vecp->i_len <= ip->i_df.if_bytes);
247 iip->ili_format.ilf_dsize = vecp->i_len;
248 vecp++;
249 nvecs++;
250 } else {
251 iip->ili_fields &= ~XFS_ILOG_DEXT;
252 }
253 break;
254
255 case XFS_DINODE_FMT_BTREE:
256 iip->ili_fields &=
257 ~(XFS_ILOG_DDATA | XFS_ILOG_DEXT |
258 XFS_ILOG_DEV | XFS_ILOG_UUID);
259
260 if ((iip->ili_fields & XFS_ILOG_DBROOT) &&
261 ip->i_df.if_broot_bytes > 0) {
262 ASSERT(ip->i_df.if_broot != NULL);
263 vecp->i_addr = ip->i_df.if_broot;
264 vecp->i_len = ip->i_df.if_broot_bytes;
265 vecp->i_type = XLOG_REG_TYPE_IBROOT;
266 vecp++;
267 nvecs++;
268 iip->ili_format.ilf_dsize = ip->i_df.if_broot_bytes;
269 } else {
270 ASSERT(!(iip->ili_fields &
271 XFS_ILOG_DBROOT));
272 iip->ili_fields &= ~XFS_ILOG_DBROOT;
273 }
274 break;
275
276 case XFS_DINODE_FMT_LOCAL:
277 iip->ili_fields &=
278 ~(XFS_ILOG_DEXT | XFS_ILOG_DBROOT |
279 XFS_ILOG_DEV | XFS_ILOG_UUID);
280 if ((iip->ili_fields & XFS_ILOG_DDATA) &&
281 ip->i_df.if_bytes > 0) {
282 ASSERT(ip->i_df.if_u1.if_data != NULL);
283 ASSERT(ip->i_d.di_size > 0);
284
285 vecp->i_addr = ip->i_df.if_u1.if_data;
286
287
288
289
290
291 data_bytes = roundup(ip->i_df.if_bytes, 4);
292 ASSERT((ip->i_df.if_real_bytes == 0) ||
293 (ip->i_df.if_real_bytes == data_bytes));
294 vecp->i_len = (int)data_bytes;
295 vecp->i_type = XLOG_REG_TYPE_ILOCAL;
296 vecp++;
297 nvecs++;
298 iip->ili_format.ilf_dsize = (unsigned)data_bytes;
299 } else {
300 iip->ili_fields &= ~XFS_ILOG_DDATA;
301 }
302 break;
303
304 case XFS_DINODE_FMT_DEV:
305 iip->ili_fields &=
306 ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT |
307 XFS_ILOG_DEXT | XFS_ILOG_UUID);
308 if (iip->ili_fields & XFS_ILOG_DEV) {
309 iip->ili_format.ilf_u.ilfu_rdev =
310 ip->i_df.if_u2.if_rdev;
311 }
312 break;
313
314 case XFS_DINODE_FMT_UUID:
315 iip->ili_fields &=
316 ~(XFS_ILOG_DDATA | XFS_ILOG_DBROOT |
317 XFS_ILOG_DEXT | XFS_ILOG_DEV);
318 if (iip->ili_fields & XFS_ILOG_UUID) {
319 iip->ili_format.ilf_u.ilfu_uuid =
320 ip->i_df.if_u2.if_uuid;
321 }
322 break;
323
324 default:
325 ASSERT(0);
326 break;
327 }
328
329
330
331
332 if (!XFS_IFORK_Q(ip)) {
333 iip->ili_fields &=
334 ~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT | XFS_ILOG_AEXT);
335 goto out;
336 }
337
338 switch (ip->i_d.di_aformat) {
339 case XFS_DINODE_FMT_EXTENTS:
340 iip->ili_fields &=
341 ~(XFS_ILOG_ADATA | XFS_ILOG_ABROOT);
342
343 if ((iip->ili_fields & XFS_ILOG_AEXT) &&
344 ip->i_d.di_anextents > 0 &&
345 ip->i_afp->if_bytes > 0) {
346 ASSERT(ip->i_afp->if_bytes / sizeof(xfs_bmbt_rec_t) ==
347 ip->i_d.di_anextents);
348 ASSERT(ip->i_afp->if_u1.if_extents != NULL);
349#ifdef XFS_NATIVE_HOST
350
351
352
353
354 vecp->i_addr = ip->i_afp->if_u1.if_extents;
355 vecp->i_len = ip->i_afp->if_bytes;
356 vecp->i_type = XLOG_REG_TYPE_IATTR_EXT;
357#else
358 ASSERT(iip->ili_aextents_buf == NULL);
359 xfs_inode_item_format_extents(ip, vecp,
360 XFS_ATTR_FORK, XLOG_REG_TYPE_IATTR_EXT);
361#endif
362 iip->ili_format.ilf_asize = vecp->i_len;
363 vecp++;
364 nvecs++;
365 } else {
366 iip->ili_fields &= ~XFS_ILOG_AEXT;
367 }
368 break;
369
370 case XFS_DINODE_FMT_BTREE:
371 iip->ili_fields &=
372 ~(XFS_ILOG_ADATA | XFS_ILOG_AEXT);
373
374 if ((iip->ili_fields & XFS_ILOG_ABROOT) &&
375 ip->i_afp->if_broot_bytes > 0) {
376 ASSERT(ip->i_afp->if_broot != NULL);
377
378 vecp->i_addr = ip->i_afp->if_broot;
379 vecp->i_len = ip->i_afp->if_broot_bytes;
380 vecp->i_type = XLOG_REG_TYPE_IATTR_BROOT;
381 vecp++;
382 nvecs++;
383 iip->ili_format.ilf_asize = ip->i_afp->if_broot_bytes;
384 } else {
385 iip->ili_fields &= ~XFS_ILOG_ABROOT;
386 }
387 break;
388
389 case XFS_DINODE_FMT_LOCAL:
390 iip->ili_fields &=
391 ~(XFS_ILOG_AEXT | XFS_ILOG_ABROOT);
392
393 if ((iip->ili_fields & XFS_ILOG_ADATA) &&
394 ip->i_afp->if_bytes > 0) {
395 ASSERT(ip->i_afp->if_u1.if_data != NULL);
396
397 vecp->i_addr = ip->i_afp->if_u1.if_data;
398
399
400
401
402
403 data_bytes = roundup(ip->i_afp->if_bytes, 4);
404 ASSERT((ip->i_afp->if_real_bytes == 0) ||
405 (ip->i_afp->if_real_bytes == data_bytes));
406 vecp->i_len = (int)data_bytes;
407 vecp->i_type = XLOG_REG_TYPE_IATTR_LOCAL;
408 vecp++;
409 nvecs++;
410 iip->ili_format.ilf_asize = (unsigned)data_bytes;
411 } else {
412 iip->ili_fields &= ~XFS_ILOG_ADATA;
413 }
414 break;
415
416 default:
417 ASSERT(0);
418 break;
419 }
420
421out:
422
423
424
425
426
427
428 iip->ili_format.ilf_fields = XFS_ILOG_CORE |
429 (iip->ili_fields & ~XFS_ILOG_TIMESTAMP);
430 iip->ili_format.ilf_size = nvecs;
431}
432
433
434
435
436
437
438STATIC void
439xfs_inode_item_pin(
440 struct xfs_log_item *lip)
441{
442 struct xfs_inode *ip = INODE_ITEM(lip)->ili_inode;
443
444 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
445
446 trace_xfs_inode_pin(ip, _RET_IP_);
447 atomic_inc(&ip->i_pincount);
448}
449
450
451
452
453
454
455
456
457STATIC void
458xfs_inode_item_unpin(
459 struct xfs_log_item *lip,
460 int remove)
461{
462 struct xfs_inode *ip = INODE_ITEM(lip)->ili_inode;
463
464 trace_xfs_inode_unpin(ip, _RET_IP_);
465 ASSERT(atomic_read(&ip->i_pincount) > 0);
466 if (atomic_dec_and_test(&ip->i_pincount))
467 wake_up_bit(&ip->i_flags, __XFS_IPINNED_BIT);
468}
469
470STATIC uint
471xfs_inode_item_push(
472 struct xfs_log_item *lip,
473 struct list_head *buffer_list)
474{
475 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
476 struct xfs_inode *ip = iip->ili_inode;
477 struct xfs_buf *bp = NULL;
478 uint rval = XFS_ITEM_SUCCESS;
479 int error;
480
481 if (xfs_ipincount(ip) > 0)
482 return XFS_ITEM_PINNED;
483
484 if (!xfs_ilock_nowait(ip, XFS_ILOCK_SHARED))
485 return XFS_ITEM_LOCKED;
486
487
488
489
490
491 if (xfs_ipincount(ip) > 0) {
492 rval = XFS_ITEM_PINNED;
493 goto out_unlock;
494 }
495
496
497
498
499 if (ip->i_flags & XFS_ISTALE) {
500 rval = XFS_ITEM_PINNED;
501 goto out_unlock;
502 }
503
504
505
506
507
508
509 if (!xfs_iflock_nowait(ip)) {
510 rval = XFS_ITEM_FLUSHING;
511 goto out_unlock;
512 }
513
514 ASSERT(iip->ili_fields != 0 || XFS_FORCED_SHUTDOWN(ip->i_mount));
515 ASSERT(iip->ili_logged == 0 || XFS_FORCED_SHUTDOWN(ip->i_mount));
516
517 spin_unlock(&lip->li_ailp->xa_lock);
518
519 error = xfs_iflush(ip, &bp);
520 if (!error) {
521 if (!xfs_buf_delwri_queue(bp, buffer_list))
522 rval = XFS_ITEM_FLUSHING;
523 xfs_buf_relse(bp);
524 }
525
526 spin_lock(&lip->li_ailp->xa_lock);
527out_unlock:
528 xfs_iunlock(ip, XFS_ILOCK_SHARED);
529 return rval;
530}
531
532
533
534
535
536
537
538STATIC void
539xfs_inode_item_unlock(
540 struct xfs_log_item *lip)
541{
542 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
543 struct xfs_inode *ip = iip->ili_inode;
544 unsigned short lock_flags;
545
546 ASSERT(ip->i_itemp != NULL);
547 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
548
549
550
551
552
553 if (iip->ili_extents_buf != NULL) {
554 ASSERT(ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS);
555 ASSERT(ip->i_d.di_nextents > 0);
556 ASSERT(iip->ili_fields & XFS_ILOG_DEXT);
557 ASSERT(ip->i_df.if_bytes > 0);
558 kmem_free(iip->ili_extents_buf);
559 iip->ili_extents_buf = NULL;
560 }
561 if (iip->ili_aextents_buf != NULL) {
562 ASSERT(ip->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS);
563 ASSERT(ip->i_d.di_anextents > 0);
564 ASSERT(iip->ili_fields & XFS_ILOG_AEXT);
565 ASSERT(ip->i_afp->if_bytes > 0);
566 kmem_free(iip->ili_aextents_buf);
567 iip->ili_aextents_buf = NULL;
568 }
569
570 lock_flags = iip->ili_lock_flags;
571 iip->ili_lock_flags = 0;
572 if (lock_flags)
573 xfs_iunlock(ip, lock_flags);
574}
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598STATIC xfs_lsn_t
599xfs_inode_item_committed(
600 struct xfs_log_item *lip,
601 xfs_lsn_t lsn)
602{
603 struct xfs_inode_log_item *iip = INODE_ITEM(lip);
604 struct xfs_inode *ip = iip->ili_inode;
605
606 if (xfs_iflags_test(ip, XFS_ISTALE)) {
607 xfs_inode_item_unpin(lip, 0);
608 return -1;
609 }
610 return lsn;
611}
612
613
614
615
616
617STATIC void
618xfs_inode_item_committing(
619 struct xfs_log_item *lip,
620 xfs_lsn_t lsn)
621{
622 INODE_ITEM(lip)->ili_last_lsn = lsn;
623}
624
625
626
627
628static const struct xfs_item_ops xfs_inode_item_ops = {
629 .iop_size = xfs_inode_item_size,
630 .iop_format = xfs_inode_item_format,
631 .iop_pin = xfs_inode_item_pin,
632 .iop_unpin = xfs_inode_item_unpin,
633 .iop_unlock = xfs_inode_item_unlock,
634 .iop_committed = xfs_inode_item_committed,
635 .iop_push = xfs_inode_item_push,
636 .iop_committing = xfs_inode_item_committing
637};
638
639
640
641
642
643void
644xfs_inode_item_init(
645 struct xfs_inode *ip,
646 struct xfs_mount *mp)
647{
648 struct xfs_inode_log_item *iip;
649
650 ASSERT(ip->i_itemp == NULL);
651 iip = ip->i_itemp = kmem_zone_zalloc(xfs_ili_zone, KM_SLEEP);
652
653 iip->ili_inode = ip;
654 xfs_log_item_init(mp, &iip->ili_item, XFS_LI_INODE,
655 &xfs_inode_item_ops);
656 iip->ili_format.ilf_type = XFS_LI_INODE;
657 iip->ili_format.ilf_ino = ip->i_ino;
658 iip->ili_format.ilf_blkno = ip->i_imap.im_blkno;
659 iip->ili_format.ilf_len = ip->i_imap.im_len;
660 iip->ili_format.ilf_boffset = ip->i_imap.im_boffset;
661}
662
663
664
665
666void
667xfs_inode_item_destroy(
668 xfs_inode_t *ip)
669{
670 kmem_zone_free(xfs_ili_zone, ip->i_itemp);
671}
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686void
687xfs_iflush_done(
688 struct xfs_buf *bp,
689 struct xfs_log_item *lip)
690{
691 struct xfs_inode_log_item *iip;
692 struct xfs_log_item *blip;
693 struct xfs_log_item *next;
694 struct xfs_log_item *prev;
695 struct xfs_ail *ailp = lip->li_ailp;
696 int need_ail = 0;
697
698
699
700
701
702 blip = bp->b_fspriv;
703 prev = NULL;
704 while (blip != NULL) {
705 if (lip->li_cb != xfs_iflush_done) {
706 prev = blip;
707 blip = blip->li_bio_list;
708 continue;
709 }
710
711
712 next = blip->li_bio_list;
713 if (!prev) {
714 bp->b_fspriv = next;
715 } else {
716 prev->li_bio_list = next;
717 }
718
719
720 blip->li_bio_list = lip->li_bio_list;
721 lip->li_bio_list = blip;
722
723
724
725
726
727 iip = INODE_ITEM(blip);
728 if (iip->ili_logged && blip->li_lsn == iip->ili_flush_lsn)
729 need_ail++;
730
731 blip = next;
732 }
733
734
735 iip = INODE_ITEM(lip);
736 if (iip->ili_logged && lip->li_lsn == iip->ili_flush_lsn)
737 need_ail++;
738
739
740
741
742
743
744
745
746
747
748 if (need_ail) {
749 struct xfs_log_item *log_items[need_ail];
750 int i = 0;
751 spin_lock(&ailp->xa_lock);
752 for (blip = lip; blip; blip = blip->li_bio_list) {
753 iip = INODE_ITEM(blip);
754 if (iip->ili_logged &&
755 blip->li_lsn == iip->ili_flush_lsn) {
756 log_items[i++] = blip;
757 }
758 ASSERT(i <= need_ail);
759 }
760
761 xfs_trans_ail_delete_bulk(ailp, log_items, i,
762 SHUTDOWN_CORRUPT_INCORE);
763 }
764
765
766
767
768
769
770
771 for (blip = lip; blip; blip = next) {
772 next = blip->li_bio_list;
773 blip->li_bio_list = NULL;
774
775 iip = INODE_ITEM(blip);
776 iip->ili_logged = 0;
777 iip->ili_last_fields = 0;
778 xfs_ifunlock(iip->ili_inode);
779 }
780}
781
782
783
784
785
786
787
788void
789xfs_iflush_abort(
790 xfs_inode_t *ip,
791 bool stale)
792{
793 xfs_inode_log_item_t *iip = ip->i_itemp;
794
795 if (iip) {
796 struct xfs_ail *ailp = iip->ili_item.li_ailp;
797 if (iip->ili_item.li_flags & XFS_LI_IN_AIL) {
798 spin_lock(&ailp->xa_lock);
799 if (iip->ili_item.li_flags & XFS_LI_IN_AIL) {
800
801 xfs_trans_ail_delete(ailp, &iip->ili_item,
802 stale ?
803 SHUTDOWN_LOG_IO_ERROR :
804 SHUTDOWN_CORRUPT_INCORE);
805 } else
806 spin_unlock(&ailp->xa_lock);
807 }
808 iip->ili_logged = 0;
809
810
811
812
813 iip->ili_last_fields = 0;
814
815
816
817
818 iip->ili_fields = 0;
819 }
820
821
822
823 xfs_ifunlock(ip);
824}
825
826void
827xfs_istale_done(
828 struct xfs_buf *bp,
829 struct xfs_log_item *lip)
830{
831 xfs_iflush_abort(INODE_ITEM(lip)->ili_inode, true);
832}
833
834
835
836
837
838int
839xfs_inode_item_format_convert(
840 xfs_log_iovec_t *buf,
841 xfs_inode_log_format_t *in_f)
842{
843 if (buf->i_len == sizeof(xfs_inode_log_format_32_t)) {
844 xfs_inode_log_format_32_t *in_f32 = buf->i_addr;
845
846 in_f->ilf_type = in_f32->ilf_type;
847 in_f->ilf_size = in_f32->ilf_size;
848 in_f->ilf_fields = in_f32->ilf_fields;
849 in_f->ilf_asize = in_f32->ilf_asize;
850 in_f->ilf_dsize = in_f32->ilf_dsize;
851 in_f->ilf_ino = in_f32->ilf_ino;
852
853 memcpy(in_f->ilf_u.ilfu_uuid.__u_bits,
854 in_f32->ilf_u.ilfu_uuid.__u_bits,
855 sizeof(uuid_t));
856 in_f->ilf_blkno = in_f32->ilf_blkno;
857 in_f->ilf_len = in_f32->ilf_len;
858 in_f->ilf_boffset = in_f32->ilf_boffset;
859 return 0;
860 } else if (buf->i_len == sizeof(xfs_inode_log_format_64_t)){
861 xfs_inode_log_format_64_t *in_f64 = buf->i_addr;
862
863 in_f->ilf_type = in_f64->ilf_type;
864 in_f->ilf_size = in_f64->ilf_size;
865 in_f->ilf_fields = in_f64->ilf_fields;
866 in_f->ilf_asize = in_f64->ilf_asize;
867 in_f->ilf_dsize = in_f64->ilf_dsize;
868 in_f->ilf_ino = in_f64->ilf_ino;
869
870 memcpy(in_f->ilf_u.ilfu_uuid.__u_bits,
871 in_f64->ilf_u.ilfu_uuid.__u_bits,
872 sizeof(uuid_t));
873 in_f->ilf_blkno = in_f64->ilf_blkno;
874 in_f->ilf_len = in_f64->ilf_len;
875 in_f->ilf_boffset = in_f64->ilf_boffset;
876 return 0;
877 }
878 return EFSCORRUPTED;
879}
880