2 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 #include "xfs_format.h"
21 #include "xfs_log_format.h"
22 #include "xfs_trans_resv.h"
24 #include "xfs_mount.h"
25 #include "xfs_inode.h"
26 #include "xfs_trans.h"
27 #include "xfs_inode_item.h"
28 #include "xfs_error.h"
29 #include "xfs_trace.h"
30 #include "xfs_trans_priv.h"
34 kmem_zone_t
*xfs_ili_zone
; /* inode log item zone */
36 static inline struct xfs_inode_log_item
*INODE_ITEM(struct xfs_log_item
*lip
)
38 return container_of(lip
, struct xfs_inode_log_item
, ili_item
);
42 xfs_inode_item_data_fork_size(
43 struct xfs_inode_log_item
*iip
,
47 struct xfs_inode
*ip
= iip
->ili_inode
;
49 switch (ip
->i_d
.di_format
) {
50 case XFS_DINODE_FMT_EXTENTS
:
51 if ((iip
->ili_fields
& XFS_ILOG_DEXT
) &&
52 ip
->i_d
.di_nextents
> 0 &&
53 ip
->i_df
.if_bytes
> 0) {
54 /* worst case, doesn't subtract delalloc extents */
55 *nbytes
+= XFS_IFORK_DSIZE(ip
);
59 case XFS_DINODE_FMT_BTREE
:
60 if ((iip
->ili_fields
& XFS_ILOG_DBROOT
) &&
61 ip
->i_df
.if_broot_bytes
> 0) {
62 *nbytes
+= ip
->i_df
.if_broot_bytes
;
66 case XFS_DINODE_FMT_LOCAL
:
67 if ((iip
->ili_fields
& XFS_ILOG_DDATA
) &&
68 ip
->i_df
.if_bytes
> 0) {
69 *nbytes
+= roundup(ip
->i_df
.if_bytes
, 4);
74 case XFS_DINODE_FMT_DEV
:
75 case XFS_DINODE_FMT_UUID
:
84 xfs_inode_item_attr_fork_size(
85 struct xfs_inode_log_item
*iip
,
89 struct xfs_inode
*ip
= iip
->ili_inode
;
91 switch (ip
->i_d
.di_aformat
) {
92 case XFS_DINODE_FMT_EXTENTS
:
93 if ((iip
->ili_fields
& XFS_ILOG_AEXT
) &&
94 ip
->i_d
.di_anextents
> 0 &&
95 ip
->i_afp
->if_bytes
> 0) {
96 /* worst case, doesn't subtract unused space */
97 *nbytes
+= XFS_IFORK_ASIZE(ip
);
101 case XFS_DINODE_FMT_BTREE
:
102 if ((iip
->ili_fields
& XFS_ILOG_ABROOT
) &&
103 ip
->i_afp
->if_broot_bytes
> 0) {
104 *nbytes
+= ip
->i_afp
->if_broot_bytes
;
108 case XFS_DINODE_FMT_LOCAL
:
109 if ((iip
->ili_fields
& XFS_ILOG_ADATA
) &&
110 ip
->i_afp
->if_bytes
> 0) {
111 *nbytes
+= roundup(ip
->i_afp
->if_bytes
, 4);
122 * This returns the number of iovecs needed to log the given inode item.
124 * We need one iovec for the inode log format structure, one for the
125 * inode core, and possibly one for the inode data/extents/b-tree root
126 * and one for the inode attribute data/extents/b-tree root.
130 struct xfs_log_item
*lip
,
134 struct xfs_inode_log_item
*iip
= INODE_ITEM(lip
);
135 struct xfs_inode
*ip
= iip
->ili_inode
;
138 *nbytes
+= sizeof(struct xfs_inode_log_format
) +
139 xfs_icdinode_size(ip
->i_d
.di_version
);
141 xfs_inode_item_data_fork_size(iip
, nvecs
, nbytes
);
143 xfs_inode_item_attr_fork_size(iip
, nvecs
, nbytes
);
147 xfs_inode_item_format_data_fork(
148 struct xfs_inode_log_item
*iip
,
149 struct xfs_inode_log_format
*ilf
,
150 struct xfs_log_vec
*lv
,
151 struct xfs_log_iovec
**vecp
)
153 struct xfs_inode
*ip
= iip
->ili_inode
;
156 switch (ip
->i_d
.di_format
) {
157 case XFS_DINODE_FMT_EXTENTS
:
159 ~(XFS_ILOG_DDATA
| XFS_ILOG_DBROOT
|
160 XFS_ILOG_DEV
| XFS_ILOG_UUID
);
162 if ((iip
->ili_fields
& XFS_ILOG_DEXT
) &&
163 ip
->i_d
.di_nextents
> 0 &&
164 ip
->i_df
.if_bytes
> 0) {
165 struct xfs_bmbt_rec
*p
;
167 ASSERT(ip
->i_df
.if_u1
.if_extents
!= NULL
);
168 ASSERT(ip
->i_df
.if_bytes
/ sizeof(xfs_bmbt_rec_t
) > 0);
170 p
= xlog_prepare_iovec(lv
, vecp
, XLOG_REG_TYPE_IEXT
);
171 data_bytes
= xfs_iextents_copy(ip
, p
, XFS_DATA_FORK
);
172 xlog_finish_iovec(lv
, *vecp
, data_bytes
);
174 ASSERT(data_bytes
<= ip
->i_df
.if_bytes
);
176 ilf
->ilf_dsize
= data_bytes
;
179 iip
->ili_fields
&= ~XFS_ILOG_DEXT
;
182 case XFS_DINODE_FMT_BTREE
:
184 ~(XFS_ILOG_DDATA
| XFS_ILOG_DEXT
|
185 XFS_ILOG_DEV
| XFS_ILOG_UUID
);
187 if ((iip
->ili_fields
& XFS_ILOG_DBROOT
) &&
188 ip
->i_df
.if_broot_bytes
> 0) {
189 ASSERT(ip
->i_df
.if_broot
!= NULL
);
190 xlog_copy_iovec(lv
, vecp
, XLOG_REG_TYPE_IBROOT
,
192 ip
->i_df
.if_broot_bytes
);
193 ilf
->ilf_dsize
= ip
->i_df
.if_broot_bytes
;
196 ASSERT(!(iip
->ili_fields
&
198 iip
->ili_fields
&= ~XFS_ILOG_DBROOT
;
201 case XFS_DINODE_FMT_LOCAL
:
203 ~(XFS_ILOG_DEXT
| XFS_ILOG_DBROOT
|
204 XFS_ILOG_DEV
| XFS_ILOG_UUID
);
205 if ((iip
->ili_fields
& XFS_ILOG_DDATA
) &&
206 ip
->i_df
.if_bytes
> 0) {
208 * Round i_bytes up to a word boundary.
209 * The underlying memory is guaranteed to
210 * to be there by xfs_idata_realloc().
212 data_bytes
= roundup(ip
->i_df
.if_bytes
, 4);
213 ASSERT(ip
->i_df
.if_real_bytes
== 0 ||
214 ip
->i_df
.if_real_bytes
== data_bytes
);
215 ASSERT(ip
->i_df
.if_u1
.if_data
!= NULL
);
216 ASSERT(ip
->i_d
.di_size
> 0);
217 xlog_copy_iovec(lv
, vecp
, XLOG_REG_TYPE_ILOCAL
,
218 ip
->i_df
.if_u1
.if_data
, data_bytes
);
219 ilf
->ilf_dsize
= (unsigned)data_bytes
;
222 iip
->ili_fields
&= ~XFS_ILOG_DDATA
;
225 case XFS_DINODE_FMT_DEV
:
227 ~(XFS_ILOG_DDATA
| XFS_ILOG_DBROOT
|
228 XFS_ILOG_DEXT
| XFS_ILOG_UUID
);
229 if (iip
->ili_fields
& XFS_ILOG_DEV
)
230 ilf
->ilf_u
.ilfu_rdev
= ip
->i_df
.if_u2
.if_rdev
;
232 case XFS_DINODE_FMT_UUID
:
234 ~(XFS_ILOG_DDATA
| XFS_ILOG_DBROOT
|
235 XFS_ILOG_DEXT
| XFS_ILOG_DEV
);
236 if (iip
->ili_fields
& XFS_ILOG_UUID
)
237 ilf
->ilf_u
.ilfu_uuid
= ip
->i_df
.if_u2
.if_uuid
;
246 xfs_inode_item_format_attr_fork(
247 struct xfs_inode_log_item
*iip
,
248 struct xfs_inode_log_format
*ilf
,
249 struct xfs_log_vec
*lv
,
250 struct xfs_log_iovec
**vecp
)
252 struct xfs_inode
*ip
= iip
->ili_inode
;
255 switch (ip
->i_d
.di_aformat
) {
256 case XFS_DINODE_FMT_EXTENTS
:
258 ~(XFS_ILOG_ADATA
| XFS_ILOG_ABROOT
);
260 if ((iip
->ili_fields
& XFS_ILOG_AEXT
) &&
261 ip
->i_d
.di_anextents
> 0 &&
262 ip
->i_afp
->if_bytes
> 0) {
263 struct xfs_bmbt_rec
*p
;
265 ASSERT(ip
->i_afp
->if_bytes
/ sizeof(xfs_bmbt_rec_t
) ==
266 ip
->i_d
.di_anextents
);
267 ASSERT(ip
->i_afp
->if_u1
.if_extents
!= NULL
);
269 p
= xlog_prepare_iovec(lv
, vecp
, XLOG_REG_TYPE_IATTR_EXT
);
270 data_bytes
= xfs_iextents_copy(ip
, p
, XFS_ATTR_FORK
);
271 xlog_finish_iovec(lv
, *vecp
, data_bytes
);
273 ilf
->ilf_asize
= data_bytes
;
276 iip
->ili_fields
&= ~XFS_ILOG_AEXT
;
279 case XFS_DINODE_FMT_BTREE
:
281 ~(XFS_ILOG_ADATA
| XFS_ILOG_AEXT
);
283 if ((iip
->ili_fields
& XFS_ILOG_ABROOT
) &&
284 ip
->i_afp
->if_broot_bytes
> 0) {
285 ASSERT(ip
->i_afp
->if_broot
!= NULL
);
287 xlog_copy_iovec(lv
, vecp
, XLOG_REG_TYPE_IATTR_BROOT
,
289 ip
->i_afp
->if_broot_bytes
);
290 ilf
->ilf_asize
= ip
->i_afp
->if_broot_bytes
;
293 iip
->ili_fields
&= ~XFS_ILOG_ABROOT
;
296 case XFS_DINODE_FMT_LOCAL
:
298 ~(XFS_ILOG_AEXT
| XFS_ILOG_ABROOT
);
300 if ((iip
->ili_fields
& XFS_ILOG_ADATA
) &&
301 ip
->i_afp
->if_bytes
> 0) {
303 * Round i_bytes up to a word boundary.
304 * The underlying memory is guaranteed to
305 * to be there by xfs_idata_realloc().
307 data_bytes
= roundup(ip
->i_afp
->if_bytes
, 4);
308 ASSERT(ip
->i_afp
->if_real_bytes
== 0 ||
309 ip
->i_afp
->if_real_bytes
== data_bytes
);
310 ASSERT(ip
->i_afp
->if_u1
.if_data
!= NULL
);
311 xlog_copy_iovec(lv
, vecp
, XLOG_REG_TYPE_IATTR_LOCAL
,
312 ip
->i_afp
->if_u1
.if_data
,
314 ilf
->ilf_asize
= (unsigned)data_bytes
;
317 iip
->ili_fields
&= ~XFS_ILOG_ADATA
;
327 * This is called to fill in the vector of log iovecs for the given inode
328 * log item. It fills the first item with an inode log format structure,
329 * the second with the on-disk inode structure, and a possible third and/or
330 * fourth with the inode data/extents/b-tree root and inode attributes
331 * data/extents/b-tree root.
334 xfs_inode_item_format(
335 struct xfs_log_item
*lip
,
336 struct xfs_log_vec
*lv
)
338 struct xfs_inode_log_item
*iip
= INODE_ITEM(lip
);
339 struct xfs_inode
*ip
= iip
->ili_inode
;
340 struct xfs_inode_log_format
*ilf
;
341 struct xfs_log_iovec
*vecp
= NULL
;
343 ASSERT(ip
->i_d
.di_version
> 1);
345 ilf
= xlog_prepare_iovec(lv
, &vecp
, XLOG_REG_TYPE_IFORMAT
);
346 ilf
->ilf_type
= XFS_LI_INODE
;
347 ilf
->ilf_ino
= ip
->i_ino
;
348 ilf
->ilf_blkno
= ip
->i_imap
.im_blkno
;
349 ilf
->ilf_len
= ip
->i_imap
.im_len
;
350 ilf
->ilf_boffset
= ip
->i_imap
.im_boffset
;
351 ilf
->ilf_fields
= XFS_ILOG_CORE
;
352 ilf
->ilf_size
= 2; /* format + core */
353 xlog_finish_iovec(lv
, vecp
, sizeof(struct xfs_inode_log_format
));
355 xlog_copy_iovec(lv
, &vecp
, XLOG_REG_TYPE_ICORE
,
357 xfs_icdinode_size(ip
->i_d
.di_version
));
359 xfs_inode_item_format_data_fork(iip
, ilf
, lv
, &vecp
);
360 if (XFS_IFORK_Q(ip
)) {
361 xfs_inode_item_format_attr_fork(iip
, ilf
, lv
, &vecp
);
364 ~(XFS_ILOG_ADATA
| XFS_ILOG_ABROOT
| XFS_ILOG_AEXT
);
367 /* update the format with the exact fields we actually logged */
368 ilf
->ilf_fields
|= (iip
->ili_fields
& ~XFS_ILOG_TIMESTAMP
);
372 * This is called to pin the inode associated with the inode log
373 * item in memory so it cannot be written out.
377 struct xfs_log_item
*lip
)
379 struct xfs_inode
*ip
= INODE_ITEM(lip
)->ili_inode
;
381 ASSERT(xfs_isilocked(ip
, XFS_ILOCK_EXCL
));
383 trace_xfs_inode_pin(ip
, _RET_IP_
);
384 atomic_inc(&ip
->i_pincount
);
389 * This is called to unpin the inode associated with the inode log
390 * item which was previously pinned with a call to xfs_inode_item_pin().
392 * Also wake up anyone in xfs_iunpin_wait() if the count goes to 0.
395 xfs_inode_item_unpin(
396 struct xfs_log_item
*lip
,
399 struct xfs_inode
*ip
= INODE_ITEM(lip
)->ili_inode
;
401 trace_xfs_inode_unpin(ip
, _RET_IP_
);
402 ASSERT(atomic_read(&ip
->i_pincount
) > 0);
403 if (atomic_dec_and_test(&ip
->i_pincount
))
404 wake_up_bit(&ip
->i_flags
, __XFS_IPINNED_BIT
);
409 struct xfs_log_item
*lip
,
410 struct list_head
*buffer_list
)
412 struct xfs_inode_log_item
*iip
= INODE_ITEM(lip
);
413 struct xfs_inode
*ip
= iip
->ili_inode
;
414 struct xfs_buf
*bp
= NULL
;
415 uint rval
= XFS_ITEM_SUCCESS
;
418 if (xfs_ipincount(ip
) > 0)
419 return XFS_ITEM_PINNED
;
421 if (!xfs_ilock_nowait(ip
, XFS_ILOCK_SHARED
))
422 return XFS_ITEM_LOCKED
;
425 * Re-check the pincount now that we stabilized the value by
428 if (xfs_ipincount(ip
) > 0) {
429 rval
= XFS_ITEM_PINNED
;
434 * Stale inode items should force out the iclog.
436 if (ip
->i_flags
& XFS_ISTALE
) {
437 rval
= XFS_ITEM_PINNED
;
442 * Someone else is already flushing the inode. Nothing we can do
443 * here but wait for the flush to finish and remove the item from
446 if (!xfs_iflock_nowait(ip
)) {
447 rval
= XFS_ITEM_FLUSHING
;
451 ASSERT(iip
->ili_fields
!= 0 || XFS_FORCED_SHUTDOWN(ip
->i_mount
));
452 ASSERT(iip
->ili_logged
== 0 || XFS_FORCED_SHUTDOWN(ip
->i_mount
));
454 spin_unlock(&lip
->li_ailp
->xa_lock
);
456 error
= xfs_iflush(ip
, &bp
);
458 if (!xfs_buf_delwri_queue(bp
, buffer_list
))
459 rval
= XFS_ITEM_FLUSHING
;
463 spin_lock(&lip
->li_ailp
->xa_lock
);
465 xfs_iunlock(ip
, XFS_ILOCK_SHARED
);
470 * Unlock the inode associated with the inode log item.
471 * Clear the fields of the inode and inode log item that
472 * are specific to the current transaction. If the
473 * hold flags is set, do not unlock the inode.
476 xfs_inode_item_unlock(
477 struct xfs_log_item
*lip
)
479 struct xfs_inode_log_item
*iip
= INODE_ITEM(lip
);
480 struct xfs_inode
*ip
= iip
->ili_inode
;
481 unsigned short lock_flags
;
483 ASSERT(ip
->i_itemp
!= NULL
);
484 ASSERT(xfs_isilocked(ip
, XFS_ILOCK_EXCL
));
486 lock_flags
= iip
->ili_lock_flags
;
487 iip
->ili_lock_flags
= 0;
489 xfs_iunlock(ip
, lock_flags
);
493 * This is called to find out where the oldest active copy of the inode log
494 * item in the on disk log resides now that the last log write of it completed
495 * at the given lsn. Since we always re-log all dirty data in an inode, the
496 * latest copy in the on disk log is the only one that matters. Therefore,
497 * simply return the given lsn.
499 * If the inode has been marked stale because the cluster is being freed, we
500 * don't want to (re-)insert this inode into the AIL. There is a race condition
501 * where the cluster buffer may be unpinned before the inode is inserted into
502 * the AIL during transaction committed processing. If the buffer is unpinned
503 * before the inode item has been committed and inserted, then it is possible
504 * for the buffer to be written and IO completes before the inode is inserted
505 * into the AIL. In that case, we'd be inserting a clean, stale inode into the
506 * AIL which will never get removed. It will, however, get reclaimed which
507 * triggers an assert in xfs_inode_free() complaining about freein an inode
510 * To avoid this, just unpin the inode directly and return a LSN of -1 so the
511 * transaction committed code knows that it does not need to do any further
512 * processing on the item.
515 xfs_inode_item_committed(
516 struct xfs_log_item
*lip
,
519 struct xfs_inode_log_item
*iip
= INODE_ITEM(lip
);
520 struct xfs_inode
*ip
= iip
->ili_inode
;
522 if (xfs_iflags_test(ip
, XFS_ISTALE
)) {
523 xfs_inode_item_unpin(lip
, 0);
530 * XXX rcc - this one really has to do something. Probably needs
531 * to stamp in a new field in the incore inode.
534 xfs_inode_item_committing(
535 struct xfs_log_item
*lip
,
538 INODE_ITEM(lip
)->ili_last_lsn
= lsn
;
542 * This is the ops vector shared by all buf log items.
544 static const struct xfs_item_ops xfs_inode_item_ops
= {
545 .iop_size
= xfs_inode_item_size
,
546 .iop_format
= xfs_inode_item_format
,
547 .iop_pin
= xfs_inode_item_pin
,
548 .iop_unpin
= xfs_inode_item_unpin
,
549 .iop_unlock
= xfs_inode_item_unlock
,
550 .iop_committed
= xfs_inode_item_committed
,
551 .iop_push
= xfs_inode_item_push
,
552 .iop_committing
= xfs_inode_item_committing
557 * Initialize the inode log item for a newly allocated (in-core) inode.
561 struct xfs_inode
*ip
,
562 struct xfs_mount
*mp
)
564 struct xfs_inode_log_item
*iip
;
566 ASSERT(ip
->i_itemp
== NULL
);
567 iip
= ip
->i_itemp
= kmem_zone_zalloc(xfs_ili_zone
, KM_SLEEP
);
570 xfs_log_item_init(mp
, &iip
->ili_item
, XFS_LI_INODE
,
571 &xfs_inode_item_ops
);
575 * Free the inode log item and any memory hanging off of it.
578 xfs_inode_item_destroy(
581 kmem_zone_free(xfs_ili_zone
, ip
->i_itemp
);
586 * This is the inode flushing I/O completion routine. It is called
587 * from interrupt level when the buffer containing the inode is
588 * flushed to disk. It is responsible for removing the inode item
589 * from the AIL if it has not been re-logged, and unlocking the inode's
592 * To reduce AIL lock traffic as much as possible, we scan the buffer log item
593 * list for other inodes that will run this function. We remove them from the
594 * buffer list so we can process all the inode IO completions in one AIL lock
600 struct xfs_log_item
*lip
)
602 struct xfs_inode_log_item
*iip
;
603 struct xfs_log_item
*blip
;
604 struct xfs_log_item
*next
;
605 struct xfs_log_item
*prev
;
606 struct xfs_ail
*ailp
= lip
->li_ailp
;
610 * Scan the buffer IO completions for other inodes being completed and
611 * attach them to the current inode log item.
615 while (blip
!= NULL
) {
616 if (blip
->li_cb
!= xfs_iflush_done
) {
618 blip
= blip
->li_bio_list
;
622 /* remove from list */
623 next
= blip
->li_bio_list
;
627 prev
->li_bio_list
= next
;
630 /* add to current list */
631 blip
->li_bio_list
= lip
->li_bio_list
;
632 lip
->li_bio_list
= blip
;
635 * while we have the item, do the unlocked check for needing
638 iip
= INODE_ITEM(blip
);
639 if (iip
->ili_logged
&& blip
->li_lsn
== iip
->ili_flush_lsn
)
645 /* make sure we capture the state of the initial inode. */
646 iip
= INODE_ITEM(lip
);
647 if (iip
->ili_logged
&& lip
->li_lsn
== iip
->ili_flush_lsn
)
651 * We only want to pull the item from the AIL if it is
652 * actually there and its location in the log has not
653 * changed since we started the flush. Thus, we only bother
654 * if the ili_logged flag is set and the inode's lsn has not
655 * changed. First we check the lsn outside
656 * the lock since it's cheaper, and then we recheck while
657 * holding the lock before removing the inode from the AIL.
660 struct xfs_log_item
*log_items
[need_ail
];
662 spin_lock(&ailp
->xa_lock
);
663 for (blip
= lip
; blip
; blip
= blip
->li_bio_list
) {
664 iip
= INODE_ITEM(blip
);
665 if (iip
->ili_logged
&&
666 blip
->li_lsn
== iip
->ili_flush_lsn
) {
667 log_items
[i
++] = blip
;
669 ASSERT(i
<= need_ail
);
671 /* xfs_trans_ail_delete_bulk() drops the AIL lock. */
672 xfs_trans_ail_delete_bulk(ailp
, log_items
, i
,
673 SHUTDOWN_CORRUPT_INCORE
);
678 * clean up and unlock the flush lock now we are done. We can clear the
679 * ili_last_fields bits now that we know that the data corresponding to
680 * them is safely on disk.
682 for (blip
= lip
; blip
; blip
= next
) {
683 next
= blip
->li_bio_list
;
684 blip
->li_bio_list
= NULL
;
686 iip
= INODE_ITEM(blip
);
688 iip
->ili_last_fields
= 0;
689 xfs_ifunlock(iip
->ili_inode
);
694 * This is the inode flushing abort routine. It is called from xfs_iflush when
695 * the filesystem is shutting down to clean up the inode state. It is
696 * responsible for removing the inode item from the AIL if it has not been
697 * re-logged, and unlocking the inode's flush lock.
704 xfs_inode_log_item_t
*iip
= ip
->i_itemp
;
707 struct xfs_ail
*ailp
= iip
->ili_item
.li_ailp
;
708 if (iip
->ili_item
.li_flags
& XFS_LI_IN_AIL
) {
709 spin_lock(&ailp
->xa_lock
);
710 if (iip
->ili_item
.li_flags
& XFS_LI_IN_AIL
) {
711 /* xfs_trans_ail_delete() drops the AIL lock. */
712 xfs_trans_ail_delete(ailp
, &iip
->ili_item
,
714 SHUTDOWN_LOG_IO_ERROR
:
715 SHUTDOWN_CORRUPT_INCORE
);
717 spin_unlock(&ailp
->xa_lock
);
721 * Clear the ili_last_fields bits now that we know that the
722 * data corresponding to them is safely on disk.
724 iip
->ili_last_fields
= 0;
726 * Clear the inode logging fields so no more flushes are
732 * Release the inode's flush lock since we're done with it.
740 struct xfs_log_item
*lip
)
742 xfs_iflush_abort(INODE_ITEM(lip
)->ili_inode
, true);
746 * convert an xfs_inode_log_format struct from either 32 or 64 bit versions
747 * (which can have different field alignments) to the native version
750 xfs_inode_item_format_convert(
751 xfs_log_iovec_t
*buf
,
752 xfs_inode_log_format_t
*in_f
)
754 if (buf
->i_len
== sizeof(xfs_inode_log_format_32_t
)) {
755 xfs_inode_log_format_32_t
*in_f32
= buf
->i_addr
;
757 in_f
->ilf_type
= in_f32
->ilf_type
;
758 in_f
->ilf_size
= in_f32
->ilf_size
;
759 in_f
->ilf_fields
= in_f32
->ilf_fields
;
760 in_f
->ilf_asize
= in_f32
->ilf_asize
;
761 in_f
->ilf_dsize
= in_f32
->ilf_dsize
;
762 in_f
->ilf_ino
= in_f32
->ilf_ino
;
763 /* copy biggest field of ilf_u */
764 memcpy(in_f
->ilf_u
.ilfu_uuid
.__u_bits
,
765 in_f32
->ilf_u
.ilfu_uuid
.__u_bits
,
767 in_f
->ilf_blkno
= in_f32
->ilf_blkno
;
768 in_f
->ilf_len
= in_f32
->ilf_len
;
769 in_f
->ilf_boffset
= in_f32
->ilf_boffset
;
771 } else if (buf
->i_len
== sizeof(xfs_inode_log_format_64_t
)){
772 xfs_inode_log_format_64_t
*in_f64
= buf
->i_addr
;
774 in_f
->ilf_type
= in_f64
->ilf_type
;
775 in_f
->ilf_size
= in_f64
->ilf_size
;
776 in_f
->ilf_fields
= in_f64
->ilf_fields
;
777 in_f
->ilf_asize
= in_f64
->ilf_asize
;
778 in_f
->ilf_dsize
= in_f64
->ilf_dsize
;
779 in_f
->ilf_ino
= in_f64
->ilf_ino
;
780 /* copy biggest field of ilf_u */
781 memcpy(in_f
->ilf_u
.ilfu_uuid
.__u_bits
,
782 in_f64
->ilf_u
.ilfu_uuid
.__u_bits
,
784 in_f
->ilf_blkno
= in_f64
->ilf_blkno
;
785 in_f
->ilf_len
= in_f64
->ilf_len
;
786 in_f
->ilf_boffset
= in_f64
->ilf_boffset
;
789 return -EFSCORRUPTED
;