1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
4 * All Rights Reserved.
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_inode.h"
14 #include "xfs_trans.h"
15 #include "xfs_inode_item.h"
16 #include "xfs_trace.h"
17 #include "xfs_trans_priv.h"
18 #include "xfs_buf_item.h"
19 #include "xfs_log.h"
20 #include "xfs_error.h"
21 #include "xfs_log_priv.h"
22 #include "xfs_log_recover.h"
23 #include "xfs_icache.h"
24 #include "xfs_bmap_btree.h"
25 #include "xfs_rtrmap_btree.h"
26 #include "xfs_rtrefcount_btree.h"
27
28 STATIC void
xlog_recover_inode_ra_pass2(struct xlog * log,struct xlog_recover_item * item)29 xlog_recover_inode_ra_pass2(
30 struct xlog *log,
31 struct xlog_recover_item *item)
32 {
33 if (item->ri_buf[0].i_len == sizeof(struct xfs_inode_log_format)) {
34 struct xfs_inode_log_format *ilfp = item->ri_buf[0].i_addr;
35
36 xlog_buf_readahead(log, ilfp->ilf_blkno, ilfp->ilf_len,
37 &xfs_inode_buf_ra_ops);
38 } else {
39 struct xfs_inode_log_format_32 *ilfp = item->ri_buf[0].i_addr;
40
41 xlog_buf_readahead(log, ilfp->ilf_blkno, ilfp->ilf_len,
42 &xfs_inode_buf_ra_ops);
43 }
44 }
45
46 /*
47 * Inode fork owner changes
48 *
49 * If we have been told that we have to reparent the inode fork, it's because an
50 * extent swap operation on a CRC enabled filesystem has been done and we are
51 * replaying it. We need to walk the BMBT of the appropriate fork and change the
52 * owners of it.
53 *
54 * The complexity here is that we don't have an inode context to work with, so
55 * after we've replayed the inode we need to instantiate one. This is where the
56 * fun begins.
57 *
58 * We are in the middle of log recovery, so we can't run transactions. That
59 * means we cannot use cache coherent inode instantiation via xfs_iget(), as
60 * that will result in the corresponding iput() running the inode through
61 * xfs_inactive(). If we've just replayed an inode core that changes the link
62 * count to zero (i.e. it's been unlinked), then xfs_inactive() will run
63 * transactions (bad!).
64 *
65 * So, to avoid this, we instantiate an inode directly from the inode core we've
66 * just recovered. We have the buffer still locked, and all we really need to
67 * instantiate is the inode core and the forks being modified. We can do this
68 * manually, then run the inode btree owner change, and then tear down the
69 * xfs_inode without having to run any transactions at all.
70 *
71 * Also, because we don't have a transaction context available here but need to
72 * gather all the buffers we modify for writeback so we pass the buffer_list
73 * instead for the operation to use.
74 */
75
76 STATIC int
xfs_recover_inode_owner_change(struct xfs_mount * mp,struct xfs_dinode * dip,struct xfs_inode_log_format * in_f,struct list_head * buffer_list)77 xfs_recover_inode_owner_change(
78 struct xfs_mount *mp,
79 struct xfs_dinode *dip,
80 struct xfs_inode_log_format *in_f,
81 struct list_head *buffer_list)
82 {
83 struct xfs_inode *ip;
84 int error;
85
86 ASSERT(in_f->ilf_fields & (XFS_ILOG_DOWNER|XFS_ILOG_AOWNER));
87
88 ip = xfs_inode_alloc(mp, in_f->ilf_ino);
89 if (!ip)
90 return -ENOMEM;
91
92 /* instantiate the inode */
93 ASSERT(dip->di_version >= 3);
94
95 error = xfs_inode_from_disk(ip, dip);
96 if (error)
97 goto out_free_ip;
98
99 if (in_f->ilf_fields & XFS_ILOG_DOWNER) {
100 ASSERT(in_f->ilf_fields & XFS_ILOG_DBROOT);
101 error = xfs_bmbt_change_owner(NULL, ip, XFS_DATA_FORK,
102 ip->i_ino, buffer_list);
103 if (error)
104 goto out_free_ip;
105 }
106
107 if (in_f->ilf_fields & XFS_ILOG_AOWNER) {
108 ASSERT(in_f->ilf_fields & XFS_ILOG_ABROOT);
109 error = xfs_bmbt_change_owner(NULL, ip, XFS_ATTR_FORK,
110 ip->i_ino, buffer_list);
111 if (error)
112 goto out_free_ip;
113 }
114
115 out_free_ip:
116 xfs_inode_free(ip);
117 return error;
118 }
119
xfs_log_dinode_has_bigtime(const struct xfs_log_dinode * ld)120 static inline bool xfs_log_dinode_has_bigtime(const struct xfs_log_dinode *ld)
121 {
122 return ld->di_version >= 3 &&
123 (ld->di_flags2 & XFS_DIFLAG2_BIGTIME);
124 }
125
126 /* Convert a log timestamp to an ondisk timestamp. */
127 static inline xfs_timestamp_t
xfs_log_dinode_to_disk_ts(struct xfs_log_dinode * from,const xfs_log_timestamp_t its)128 xfs_log_dinode_to_disk_ts(
129 struct xfs_log_dinode *from,
130 const xfs_log_timestamp_t its)
131 {
132 struct xfs_legacy_timestamp *lts;
133 struct xfs_log_legacy_timestamp *lits;
134 xfs_timestamp_t ts;
135
136 if (xfs_log_dinode_has_bigtime(from))
137 return cpu_to_be64(its);
138
139 lts = (struct xfs_legacy_timestamp *)&ts;
140 lits = (struct xfs_log_legacy_timestamp *)&its;
141 lts->t_sec = cpu_to_be32(lits->t_sec);
142 lts->t_nsec = cpu_to_be32(lits->t_nsec);
143
144 return ts;
145 }
146
xfs_log_dinode_has_large_extent_counts(const struct xfs_log_dinode * ld)147 static inline bool xfs_log_dinode_has_large_extent_counts(
148 const struct xfs_log_dinode *ld)
149 {
150 return ld->di_version >= 3 &&
151 (ld->di_flags2 & XFS_DIFLAG2_NREXT64);
152 }
153
154 static inline void
xfs_log_dinode_to_disk_iext_counters(struct xfs_log_dinode * from,struct xfs_dinode * to)155 xfs_log_dinode_to_disk_iext_counters(
156 struct xfs_log_dinode *from,
157 struct xfs_dinode *to)
158 {
159 if (xfs_log_dinode_has_large_extent_counts(from)) {
160 to->di_big_nextents = cpu_to_be64(from->di_big_nextents);
161 to->di_big_anextents = cpu_to_be32(from->di_big_anextents);
162 to->di_nrext64_pad = cpu_to_be16(from->di_nrext64_pad);
163 } else {
164 to->di_nextents = cpu_to_be32(from->di_nextents);
165 to->di_anextents = cpu_to_be16(from->di_anextents);
166 }
167
168 }
169
170 STATIC void
xfs_log_dinode_to_disk(struct xfs_log_dinode * from,struct xfs_dinode * to,xfs_lsn_t lsn)171 xfs_log_dinode_to_disk(
172 struct xfs_log_dinode *from,
173 struct xfs_dinode *to,
174 xfs_lsn_t lsn)
175 {
176 to->di_magic = cpu_to_be16(from->di_magic);
177 to->di_mode = cpu_to_be16(from->di_mode);
178 to->di_version = from->di_version;
179 to->di_format = from->di_format;
180 to->di_metatype = cpu_to_be16(from->di_metatype);
181 to->di_uid = cpu_to_be32(from->di_uid);
182 to->di_gid = cpu_to_be32(from->di_gid);
183 to->di_nlink = cpu_to_be32(from->di_nlink);
184 to->di_projid_lo = cpu_to_be16(from->di_projid_lo);
185 to->di_projid_hi = cpu_to_be16(from->di_projid_hi);
186
187 to->di_atime = xfs_log_dinode_to_disk_ts(from, from->di_atime);
188 to->di_mtime = xfs_log_dinode_to_disk_ts(from, from->di_mtime);
189 to->di_ctime = xfs_log_dinode_to_disk_ts(from, from->di_ctime);
190
191 to->di_size = cpu_to_be64(from->di_size);
192 to->di_nblocks = cpu_to_be64(from->di_nblocks);
193 to->di_extsize = cpu_to_be32(from->di_extsize);
194 to->di_forkoff = from->di_forkoff;
195 to->di_aformat = from->di_aformat;
196 to->di_dmevmask = cpu_to_be32(from->di_dmevmask);
197 to->di_dmstate = cpu_to_be16(from->di_dmstate);
198 to->di_flags = cpu_to_be16(from->di_flags);
199 to->di_gen = cpu_to_be32(from->di_gen);
200
201 if (from->di_version == 3) {
202 to->di_changecount = cpu_to_be64(from->di_changecount);
203 to->di_crtime = xfs_log_dinode_to_disk_ts(from,
204 from->di_crtime);
205 to->di_flags2 = cpu_to_be64(from->di_flags2);
206 to->di_cowextsize = cpu_to_be32(from->di_cowextsize);
207 to->di_ino = cpu_to_be64(from->di_ino);
208 to->di_lsn = cpu_to_be64(lsn);
209 memset(to->di_pad2, 0, sizeof(to->di_pad2));
210 uuid_copy(&to->di_uuid, &from->di_uuid);
211 to->di_v3_pad = 0;
212 } else {
213 to->di_flushiter = cpu_to_be16(from->di_flushiter);
214 memset(to->di_v2_pad, 0, sizeof(to->di_v2_pad));
215 }
216
217 xfs_log_dinode_to_disk_iext_counters(from, to);
218 }
219
220 STATIC int
xlog_dinode_verify_extent_counts(struct xfs_mount * mp,struct xfs_log_dinode * ldip)221 xlog_dinode_verify_extent_counts(
222 struct xfs_mount *mp,
223 struct xfs_log_dinode *ldip)
224 {
225 xfs_extnum_t nextents;
226 xfs_aextnum_t anextents;
227
228 if (xfs_log_dinode_has_large_extent_counts(ldip)) {
229 if (!xfs_has_large_extent_counts(mp) ||
230 (ldip->di_nrext64_pad != 0)) {
231 XFS_CORRUPTION_ERROR(
232 "Bad log dinode large extent count format",
233 XFS_ERRLEVEL_LOW, mp, ldip, sizeof(*ldip));
234 xfs_alert(mp,
235 "Bad inode 0x%llx, large extent counts %d, padding 0x%x",
236 ldip->di_ino, xfs_has_large_extent_counts(mp),
237 ldip->di_nrext64_pad);
238 return -EFSCORRUPTED;
239 }
240
241 nextents = ldip->di_big_nextents;
242 anextents = ldip->di_big_anextents;
243 } else {
244 if (ldip->di_version == 3 && ldip->di_v3_pad != 0) {
245 XFS_CORRUPTION_ERROR(
246 "Bad log dinode di_v3_pad",
247 XFS_ERRLEVEL_LOW, mp, ldip, sizeof(*ldip));
248 xfs_alert(mp,
249 "Bad inode 0x%llx, di_v3_pad 0x%llx",
250 ldip->di_ino, ldip->di_v3_pad);
251 return -EFSCORRUPTED;
252 }
253
254 nextents = ldip->di_nextents;
255 anextents = ldip->di_anextents;
256 }
257
258 if (unlikely(nextents + anextents > ldip->di_nblocks)) {
259 XFS_CORRUPTION_ERROR("Bad log dinode extent counts",
260 XFS_ERRLEVEL_LOW, mp, ldip, sizeof(*ldip));
261 xfs_alert(mp,
262 "Bad inode 0x%llx, large extent counts %d, nextents 0x%llx, anextents 0x%x, nblocks 0x%llx",
263 ldip->di_ino, xfs_has_large_extent_counts(mp), nextents,
264 anextents, ldip->di_nblocks);
265 return -EFSCORRUPTED;
266 }
267
268 return 0;
269 }
270
271 static inline int
xlog_recover_inode_dbroot(struct xfs_mount * mp,void * src,unsigned int len,struct xfs_dinode * dip)272 xlog_recover_inode_dbroot(
273 struct xfs_mount *mp,
274 void *src,
275 unsigned int len,
276 struct xfs_dinode *dip)
277 {
278 void *dfork = XFS_DFORK_DPTR(dip);
279 unsigned int dsize = XFS_DFORK_DSIZE(dip, mp);
280
281 switch (dip->di_format) {
282 case XFS_DINODE_FMT_BTREE:
283 xfs_bmbt_to_bmdr(mp, src, len, dfork, dsize);
284 break;
285 case XFS_DINODE_FMT_META_BTREE:
286 switch (be16_to_cpu(dip->di_metatype)) {
287 case XFS_METAFILE_RTRMAP:
288 xfs_rtrmapbt_to_disk(mp, src, len, dfork, dsize);
289 return 0;
290 case XFS_METAFILE_RTREFCOUNT:
291 xfs_rtrefcountbt_to_disk(mp, src, len, dfork, dsize);
292 return 0;
293 default:
294 ASSERT(0);
295 return -EFSCORRUPTED;
296 }
297 break;
298 default:
299 ASSERT(0);
300 return -EFSCORRUPTED;
301 }
302
303 return 0;
304 }
305
306 STATIC int
xlog_recover_inode_commit_pass2(struct xlog * log,struct list_head * buffer_list,struct xlog_recover_item * item,xfs_lsn_t current_lsn)307 xlog_recover_inode_commit_pass2(
308 struct xlog *log,
309 struct list_head *buffer_list,
310 struct xlog_recover_item *item,
311 xfs_lsn_t current_lsn)
312 {
313 struct xfs_inode_log_format *in_f;
314 struct xfs_mount *mp = log->l_mp;
315 struct xfs_buf *bp;
316 struct xfs_dinode *dip;
317 int len;
318 char *src;
319 char *dest;
320 int error;
321 int attr_index;
322 uint fields;
323 struct xfs_log_dinode *ldip;
324 uint isize;
325 int need_free = 0;
326 xfs_failaddr_t fa;
327
328 if (item->ri_buf[0].i_len == sizeof(struct xfs_inode_log_format)) {
329 in_f = item->ri_buf[0].i_addr;
330 } else {
331 in_f = kmalloc(sizeof(struct xfs_inode_log_format),
332 GFP_KERNEL | __GFP_NOFAIL);
333 need_free = 1;
334 error = xfs_inode_item_format_convert(&item->ri_buf[0], in_f);
335 if (error)
336 goto error;
337 }
338
339 /*
340 * Inode buffers can be freed, look out for it,
341 * and do not replay the inode.
342 */
343 if (xlog_is_buffer_cancelled(log, in_f->ilf_blkno, in_f->ilf_len)) {
344 error = 0;
345 trace_xfs_log_recover_inode_cancel(log, in_f);
346 goto error;
347 }
348 trace_xfs_log_recover_inode_recover(log, in_f);
349
350 error = xfs_buf_read(mp->m_ddev_targp, in_f->ilf_blkno, in_f->ilf_len,
351 0, &bp, &xfs_inode_buf_ops);
352 if (error)
353 goto error;
354 ASSERT(in_f->ilf_fields & XFS_ILOG_CORE);
355 dip = xfs_buf_offset(bp, in_f->ilf_boffset);
356
357 /*
358 * Make sure the place we're flushing out to really looks
359 * like an inode!
360 */
361 if (XFS_IS_CORRUPT(mp, !xfs_verify_magic16(bp, dip->di_magic))) {
362 xfs_alert(mp,
363 "%s: Bad inode magic number, dip = "PTR_FMT", dino bp = "PTR_FMT", ino = %lld",
364 __func__, dip, bp, in_f->ilf_ino);
365 error = -EFSCORRUPTED;
366 goto out_release;
367 }
368 ldip = item->ri_buf[1].i_addr;
369 if (XFS_IS_CORRUPT(mp, ldip->di_magic != XFS_DINODE_MAGIC)) {
370 xfs_alert(mp,
371 "%s: Bad inode log record, rec ptr "PTR_FMT", ino %lld",
372 __func__, item, in_f->ilf_ino);
373 error = -EFSCORRUPTED;
374 goto out_release;
375 }
376
377 /*
378 * If the inode has an LSN in it, recover the inode only if the on-disk
379 * inode's LSN is older than the lsn of the transaction we are
380 * replaying. We can have multiple checkpoints with the same start LSN,
381 * so the current LSN being equal to the on-disk LSN doesn't necessarily
382 * mean that the on-disk inode is more recent than the change being
383 * replayed.
384 *
385 * We must check the current_lsn against the on-disk inode
386 * here because the we can't trust the log dinode to contain a valid LSN
387 * (see comment below before replaying the log dinode for details).
388 *
389 * Note: we still need to replay an owner change even though the inode
390 * is more recent than the transaction as there is no guarantee that all
391 * the btree blocks are more recent than this transaction, too.
392 */
393 if (dip->di_version >= 3) {
394 xfs_lsn_t lsn = be64_to_cpu(dip->di_lsn);
395
396 if (lsn && lsn != -1 && XFS_LSN_CMP(lsn, current_lsn) > 0) {
397 trace_xfs_log_recover_inode_skip(log, in_f);
398 error = 0;
399 goto out_owner_change;
400 }
401 }
402
403 /*
404 * di_flushiter is only valid for v1/2 inodes. All changes for v3 inodes
405 * are transactional and if ordering is necessary we can determine that
406 * more accurately by the LSN field in the V3 inode core. Don't trust
407 * the inode versions we might be changing them here - use the
408 * superblock flag to determine whether we need to look at di_flushiter
409 * to skip replay when the on disk inode is newer than the log one
410 */
411 if (!xfs_has_v3inodes(mp)) {
412 if (ldip->di_flushiter < be16_to_cpu(dip->di_flushiter)) {
413 /*
414 * Deal with the wrap case, DI_MAX_FLUSH is less
415 * than smaller numbers
416 */
417 if (be16_to_cpu(dip->di_flushiter) == DI_MAX_FLUSH &&
418 ldip->di_flushiter < (DI_MAX_FLUSH >> 1)) {
419 /* do nothing */
420 } else {
421 trace_xfs_log_recover_inode_skip(log, in_f);
422 error = 0;
423 goto out_release;
424 }
425 }
426
427 /* Take the opportunity to reset the flush iteration count */
428 ldip->di_flushiter = 0;
429 }
430
431
432 if (unlikely(S_ISREG(ldip->di_mode))) {
433 if (ldip->di_format != XFS_DINODE_FMT_EXTENTS &&
434 ldip->di_format != XFS_DINODE_FMT_BTREE &&
435 ldip->di_format != XFS_DINODE_FMT_META_BTREE) {
436 XFS_CORRUPTION_ERROR(
437 "Bad log dinode data fork format for regular file",
438 XFS_ERRLEVEL_LOW, mp, ldip, sizeof(*ldip));
439 xfs_alert(mp,
440 "Bad inode 0x%llx, data fork format 0x%x",
441 in_f->ilf_ino, ldip->di_format);
442 error = -EFSCORRUPTED;
443 goto out_release;
444 }
445 } else if (unlikely(S_ISDIR(ldip->di_mode))) {
446 if ((ldip->di_format != XFS_DINODE_FMT_EXTENTS) &&
447 (ldip->di_format != XFS_DINODE_FMT_BTREE) &&
448 (ldip->di_format != XFS_DINODE_FMT_LOCAL)) {
449 XFS_CORRUPTION_ERROR(
450 "Bad log dinode data fork format for directory",
451 XFS_ERRLEVEL_LOW, mp, ldip, sizeof(*ldip));
452 xfs_alert(mp,
453 "Bad inode 0x%llx, data fork format 0x%x",
454 in_f->ilf_ino, ldip->di_format);
455 error = -EFSCORRUPTED;
456 goto out_release;
457 }
458 }
459
460 error = xlog_dinode_verify_extent_counts(mp, ldip);
461 if (error)
462 goto out_release;
463
464 if (unlikely(ldip->di_forkoff > mp->m_sb.sb_inodesize)) {
465 XFS_CORRUPTION_ERROR("Bad log dinode fork offset",
466 XFS_ERRLEVEL_LOW, mp, ldip, sizeof(*ldip));
467 xfs_alert(mp,
468 "Bad inode 0x%llx, di_forkoff 0x%x",
469 in_f->ilf_ino, ldip->di_forkoff);
470 error = -EFSCORRUPTED;
471 goto out_release;
472 }
473 isize = xfs_log_dinode_size(mp);
474 if (unlikely(item->ri_buf[1].i_len > isize)) {
475 XFS_CORRUPTION_ERROR("Bad log dinode size", XFS_ERRLEVEL_LOW,
476 mp, ldip, sizeof(*ldip));
477 xfs_alert(mp,
478 "Bad inode 0x%llx log dinode size 0x%x",
479 in_f->ilf_ino, item->ri_buf[1].i_len);
480 error = -EFSCORRUPTED;
481 goto out_release;
482 }
483
484 /*
485 * Recover the log dinode inode into the on disk inode.
486 *
487 * The LSN in the log dinode is garbage - it can be zero or reflect
488 * stale in-memory runtime state that isn't coherent with the changes
489 * logged in this transaction or the changes written to the on-disk
490 * inode. Hence we write the current lSN into the inode because that
491 * matches what xfs_iflush() would write inode the inode when flushing
492 * the changes in this transaction.
493 */
494 xfs_log_dinode_to_disk(ldip, dip, current_lsn);
495
496 fields = in_f->ilf_fields;
497 if (fields & XFS_ILOG_DEV)
498 xfs_dinode_put_rdev(dip, in_f->ilf_u.ilfu_rdev);
499
500 if (in_f->ilf_size == 2)
501 goto out_owner_change;
502 len = item->ri_buf[2].i_len;
503 src = item->ri_buf[2].i_addr;
504 ASSERT(in_f->ilf_size <= 4);
505 ASSERT((in_f->ilf_size == 3) || (fields & XFS_ILOG_AFORK));
506 ASSERT(!(fields & XFS_ILOG_DFORK) ||
507 (len == xlog_calc_iovec_len(in_f->ilf_dsize)));
508
509 switch (fields & XFS_ILOG_DFORK) {
510 case XFS_ILOG_DDATA:
511 case XFS_ILOG_DEXT:
512 memcpy(XFS_DFORK_DPTR(dip), src, len);
513 break;
514
515 case XFS_ILOG_DBROOT:
516 error = xlog_recover_inode_dbroot(mp, src, len, dip);
517 if (error)
518 goto out_release;
519 break;
520
521 default:
522 /*
523 * There are no data fork flags set.
524 */
525 ASSERT((fields & XFS_ILOG_DFORK) == 0);
526 break;
527 }
528
529 /*
530 * If we logged any attribute data, recover it. There may or
531 * may not have been any other non-core data logged in this
532 * transaction.
533 */
534 if (in_f->ilf_fields & XFS_ILOG_AFORK) {
535 if (in_f->ilf_fields & XFS_ILOG_DFORK) {
536 attr_index = 3;
537 } else {
538 attr_index = 2;
539 }
540 len = item->ri_buf[attr_index].i_len;
541 src = item->ri_buf[attr_index].i_addr;
542 ASSERT(len == xlog_calc_iovec_len(in_f->ilf_asize));
543
544 switch (in_f->ilf_fields & XFS_ILOG_AFORK) {
545 case XFS_ILOG_ADATA:
546 case XFS_ILOG_AEXT:
547 dest = XFS_DFORK_APTR(dip);
548 ASSERT(len <= XFS_DFORK_ASIZE(dip, mp));
549 memcpy(dest, src, len);
550 break;
551
552 case XFS_ILOG_ABROOT:
553 dest = XFS_DFORK_APTR(dip);
554 xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src,
555 len, (struct xfs_bmdr_block *)dest,
556 XFS_DFORK_ASIZE(dip, mp));
557 break;
558
559 default:
560 xfs_warn(log->l_mp, "%s: Invalid flag", __func__);
561 ASSERT(0);
562 error = -EFSCORRUPTED;
563 goto out_release;
564 }
565 }
566
567 out_owner_change:
568 /* Recover the swapext owner change unless inode has been deleted */
569 if ((in_f->ilf_fields & (XFS_ILOG_DOWNER|XFS_ILOG_AOWNER)) &&
570 (dip->di_mode != 0))
571 error = xfs_recover_inode_owner_change(mp, dip, in_f,
572 buffer_list);
573 /* re-generate the checksum and validate the recovered inode. */
574 xfs_dinode_calc_crc(log->l_mp, dip);
575 fa = xfs_dinode_verify(log->l_mp, in_f->ilf_ino, dip);
576 if (fa) {
577 XFS_CORRUPTION_ERROR(
578 "Bad dinode after recovery",
579 XFS_ERRLEVEL_LOW, mp, dip, sizeof(*dip));
580 xfs_alert(mp,
581 "Metadata corruption detected at %pS, inode 0x%llx",
582 fa, in_f->ilf_ino);
583 error = -EFSCORRUPTED;
584 goto out_release;
585 }
586
587 ASSERT(bp->b_mount == mp);
588 bp->b_flags |= _XBF_LOGRECOVERY;
589 xfs_buf_delwri_queue(bp, buffer_list);
590
591 out_release:
592 xfs_buf_relse(bp);
593 error:
594 if (need_free)
595 kfree(in_f);
596 return error;
597 }
598
599 const struct xlog_recover_item_ops xlog_inode_item_ops = {
600 .item_type = XFS_LI_INODE,
601 .ra_pass2 = xlog_recover_inode_ra_pass2,
602 .commit_pass2 = xlog_recover_inode_commit_pass2,
603 };
604