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"
23 #include "xfs_mount.h"
24 #include "xfs_inode.h"
25 #include "xfs_trans.h"
26 #include "xfs_inode_item.h"
27 #include "xfs_error.h"
28 #include "xfs_trace.h"
29 #include "xfs_trans_priv.h"
30 #include "xfs_buf_item.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_log_dinode_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(xfs_iext_count(&ip
->i_df
) > 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(xfs_iext_count(ip
->i_afp
) ==
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 xfs_inode_to_log_dinode(
328 struct xfs_inode
*ip
,
329 struct xfs_log_dinode
*to
,
332 struct xfs_icdinode
*from
= &ip
->i_d
;
333 struct inode
*inode
= VFS_I(ip
);
335 to
->di_magic
= XFS_DINODE_MAGIC
;
337 to
->di_version
= from
->di_version
;
338 to
->di_format
= from
->di_format
;
339 to
->di_uid
= from
->di_uid
;
340 to
->di_gid
= from
->di_gid
;
341 to
->di_projid_lo
= from
->di_projid_lo
;
342 to
->di_projid_hi
= from
->di_projid_hi
;
344 memset(to
->di_pad
, 0, sizeof(to
->di_pad
));
345 memset(to
->di_pad3
, 0, sizeof(to
->di_pad3
));
346 to
->di_atime
.t_sec
= inode
->i_atime
.tv_sec
;
347 to
->di_atime
.t_nsec
= inode
->i_atime
.tv_nsec
;
348 to
->di_mtime
.t_sec
= inode
->i_mtime
.tv_sec
;
349 to
->di_mtime
.t_nsec
= inode
->i_mtime
.tv_nsec
;
350 to
->di_ctime
.t_sec
= inode
->i_ctime
.tv_sec
;
351 to
->di_ctime
.t_nsec
= inode
->i_ctime
.tv_nsec
;
352 to
->di_nlink
= inode
->i_nlink
;
353 to
->di_gen
= inode
->i_generation
;
354 to
->di_mode
= inode
->i_mode
;
356 to
->di_size
= from
->di_size
;
357 to
->di_nblocks
= from
->di_nblocks
;
358 to
->di_extsize
= from
->di_extsize
;
359 to
->di_nextents
= from
->di_nextents
;
360 to
->di_anextents
= from
->di_anextents
;
361 to
->di_forkoff
= from
->di_forkoff
;
362 to
->di_aformat
= from
->di_aformat
;
363 to
->di_dmevmask
= from
->di_dmevmask
;
364 to
->di_dmstate
= from
->di_dmstate
;
365 to
->di_flags
= from
->di_flags
;
367 if (from
->di_version
== 3) {
368 to
->di_changecount
= inode
->i_version
;
369 to
->di_crtime
.t_sec
= from
->di_crtime
.t_sec
;
370 to
->di_crtime
.t_nsec
= from
->di_crtime
.t_nsec
;
371 to
->di_flags2
= from
->di_flags2
;
372 to
->di_cowextsize
= from
->di_cowextsize
;
373 to
->di_ino
= ip
->i_ino
;
375 memset(to
->di_pad2
, 0, sizeof(to
->di_pad2
));
376 uuid_copy(&to
->di_uuid
, &ip
->i_mount
->m_sb
.sb_meta_uuid
);
377 to
->di_flushiter
= 0;
379 to
->di_flushiter
= from
->di_flushiter
;
384 * Format the inode core. Current timestamp data is only in the VFS inode
385 * fields, so we need to grab them from there. Hence rather than just copying
386 * the XFS inode core structure, format the fields directly into the iovec.
389 xfs_inode_item_format_core(
390 struct xfs_inode
*ip
,
391 struct xfs_log_vec
*lv
,
392 struct xfs_log_iovec
**vecp
)
394 struct xfs_log_dinode
*dic
;
396 dic
= xlog_prepare_iovec(lv
, vecp
, XLOG_REG_TYPE_ICORE
);
397 xfs_inode_to_log_dinode(ip
, dic
, ip
->i_itemp
->ili_item
.li_lsn
);
398 xlog_finish_iovec(lv
, *vecp
, xfs_log_dinode_size(ip
->i_d
.di_version
));
402 * This is called to fill in the vector of log iovecs for the given inode
403 * log item. It fills the first item with an inode log format structure,
404 * the second with the on-disk inode structure, and a possible third and/or
405 * fourth with the inode data/extents/b-tree root and inode attributes
406 * data/extents/b-tree root.
409 xfs_inode_item_format(
410 struct xfs_log_item
*lip
,
411 struct xfs_log_vec
*lv
)
413 struct xfs_inode_log_item
*iip
= INODE_ITEM(lip
);
414 struct xfs_inode
*ip
= iip
->ili_inode
;
415 struct xfs_inode_log_format
*ilf
;
416 struct xfs_log_iovec
*vecp
= NULL
;
418 ASSERT(ip
->i_d
.di_version
> 1);
420 ilf
= xlog_prepare_iovec(lv
, &vecp
, XLOG_REG_TYPE_IFORMAT
);
421 ilf
->ilf_type
= XFS_LI_INODE
;
422 ilf
->ilf_ino
= ip
->i_ino
;
423 ilf
->ilf_blkno
= ip
->i_imap
.im_blkno
;
424 ilf
->ilf_len
= ip
->i_imap
.im_len
;
425 ilf
->ilf_boffset
= ip
->i_imap
.im_boffset
;
426 ilf
->ilf_fields
= XFS_ILOG_CORE
;
427 ilf
->ilf_size
= 2; /* format + core */
428 xlog_finish_iovec(lv
, vecp
, sizeof(struct xfs_inode_log_format
));
430 xfs_inode_item_format_core(ip
, lv
, &vecp
);
431 xfs_inode_item_format_data_fork(iip
, ilf
, lv
, &vecp
);
432 if (XFS_IFORK_Q(ip
)) {
433 xfs_inode_item_format_attr_fork(iip
, ilf
, lv
, &vecp
);
436 ~(XFS_ILOG_ADATA
| XFS_ILOG_ABROOT
| XFS_ILOG_AEXT
);
439 /* update the format with the exact fields we actually logged */
440 ilf
->ilf_fields
|= (iip
->ili_fields
& ~XFS_ILOG_TIMESTAMP
);
444 * This is called to pin the inode associated with the inode log
445 * item in memory so it cannot be written out.
449 struct xfs_log_item
*lip
)
451 struct xfs_inode
*ip
= INODE_ITEM(lip
)->ili_inode
;
453 ASSERT(xfs_isilocked(ip
, XFS_ILOCK_EXCL
));
455 trace_xfs_inode_pin(ip
, _RET_IP_
);
456 atomic_inc(&ip
->i_pincount
);
461 * This is called to unpin the inode associated with the inode log
462 * item which was previously pinned with a call to xfs_inode_item_pin().
464 * Also wake up anyone in xfs_iunpin_wait() if the count goes to 0.
467 xfs_inode_item_unpin(
468 struct xfs_log_item
*lip
,
471 struct xfs_inode
*ip
= INODE_ITEM(lip
)->ili_inode
;
473 trace_xfs_inode_unpin(ip
, _RET_IP_
);
474 ASSERT(atomic_read(&ip
->i_pincount
) > 0);
475 if (atomic_dec_and_test(&ip
->i_pincount
))
476 wake_up_bit(&ip
->i_flags
, __XFS_IPINNED_BIT
);
480 * Callback used to mark a buffer with XFS_LI_FAILED when items in the buffer
481 * have been failed during writeback
483 * This informs the AIL that the inode is already flush locked on the next push,
484 * and acquires a hold on the buffer to ensure that it isn't reclaimed before
485 * dirty data makes it to disk.
488 xfs_inode_item_error(
489 struct xfs_log_item
*lip
,
492 ASSERT(xfs_isiflocked(INODE_ITEM(lip
)->ili_inode
));
493 xfs_set_li_failed(lip
, bp
);
498 struct xfs_log_item
*lip
,
499 struct list_head
*buffer_list
)
500 __releases(&lip
->li_ailp
->xa_lock
)
501 __acquires(&lip
->li_ailp
->xa_lock
)
503 struct xfs_inode_log_item
*iip
= INODE_ITEM(lip
);
504 struct xfs_inode
*ip
= iip
->ili_inode
;
505 struct xfs_buf
*bp
= lip
->li_buf
;
506 uint rval
= XFS_ITEM_SUCCESS
;
509 if (xfs_ipincount(ip
) > 0)
510 return XFS_ITEM_PINNED
;
513 * The buffer containing this item failed to be written back
514 * previously. Resubmit the buffer for IO.
516 if (lip
->li_flags
& XFS_LI_FAILED
) {
517 if (!xfs_buf_trylock(bp
))
518 return XFS_ITEM_LOCKED
;
520 if (!xfs_buf_resubmit_failed_buffers(bp
, lip
, buffer_list
))
521 rval
= XFS_ITEM_FLUSHING
;
527 if (!xfs_ilock_nowait(ip
, XFS_ILOCK_SHARED
))
528 return XFS_ITEM_LOCKED
;
531 * Re-check the pincount now that we stabilized the value by
534 if (xfs_ipincount(ip
) > 0) {
535 rval
= XFS_ITEM_PINNED
;
540 * Stale inode items should force out the iclog.
542 if (ip
->i_flags
& XFS_ISTALE
) {
543 rval
= XFS_ITEM_PINNED
;
548 * Someone else is already flushing the inode. Nothing we can do
549 * here but wait for the flush to finish and remove the item from
552 if (!xfs_iflock_nowait(ip
)) {
553 rval
= XFS_ITEM_FLUSHING
;
557 ASSERT(iip
->ili_fields
!= 0 || XFS_FORCED_SHUTDOWN(ip
->i_mount
));
558 ASSERT(iip
->ili_logged
== 0 || XFS_FORCED_SHUTDOWN(ip
->i_mount
));
560 spin_unlock(&lip
->li_ailp
->xa_lock
);
562 error
= xfs_iflush(ip
, &bp
);
564 if (!xfs_buf_delwri_queue(bp
, buffer_list
))
565 rval
= XFS_ITEM_FLUSHING
;
569 spin_lock(&lip
->li_ailp
->xa_lock
);
571 xfs_iunlock(ip
, XFS_ILOCK_SHARED
);
576 * Unlock the inode associated with the inode log item.
577 * Clear the fields of the inode and inode log item that
578 * are specific to the current transaction. If the
579 * hold flags is set, do not unlock the inode.
582 xfs_inode_item_unlock(
583 struct xfs_log_item
*lip
)
585 struct xfs_inode_log_item
*iip
= INODE_ITEM(lip
);
586 struct xfs_inode
*ip
= iip
->ili_inode
;
587 unsigned short lock_flags
;
589 ASSERT(ip
->i_itemp
!= NULL
);
590 ASSERT(xfs_isilocked(ip
, XFS_ILOCK_EXCL
));
592 lock_flags
= iip
->ili_lock_flags
;
593 iip
->ili_lock_flags
= 0;
595 xfs_iunlock(ip
, lock_flags
);
599 * This is called to find out where the oldest active copy of the inode log
600 * item in the on disk log resides now that the last log write of it completed
601 * at the given lsn. Since we always re-log all dirty data in an inode, the
602 * latest copy in the on disk log is the only one that matters. Therefore,
603 * simply return the given lsn.
605 * If the inode has been marked stale because the cluster is being freed, we
606 * don't want to (re-)insert this inode into the AIL. There is a race condition
607 * where the cluster buffer may be unpinned before the inode is inserted into
608 * the AIL during transaction committed processing. If the buffer is unpinned
609 * before the inode item has been committed and inserted, then it is possible
610 * for the buffer to be written and IO completes before the inode is inserted
611 * into the AIL. In that case, we'd be inserting a clean, stale inode into the
612 * AIL which will never get removed. It will, however, get reclaimed which
613 * triggers an assert in xfs_inode_free() complaining about freein an inode
616 * To avoid this, just unpin the inode directly and return a LSN of -1 so the
617 * transaction committed code knows that it does not need to do any further
618 * processing on the item.
621 xfs_inode_item_committed(
622 struct xfs_log_item
*lip
,
625 struct xfs_inode_log_item
*iip
= INODE_ITEM(lip
);
626 struct xfs_inode
*ip
= iip
->ili_inode
;
628 if (xfs_iflags_test(ip
, XFS_ISTALE
)) {
629 xfs_inode_item_unpin(lip
, 0);
636 * XXX rcc - this one really has to do something. Probably needs
637 * to stamp in a new field in the incore inode.
640 xfs_inode_item_committing(
641 struct xfs_log_item
*lip
,
644 INODE_ITEM(lip
)->ili_last_lsn
= lsn
;
648 * This is the ops vector shared by all buf log items.
650 static const struct xfs_item_ops xfs_inode_item_ops
= {
651 .iop_size
= xfs_inode_item_size
,
652 .iop_format
= xfs_inode_item_format
,
653 .iop_pin
= xfs_inode_item_pin
,
654 .iop_unpin
= xfs_inode_item_unpin
,
655 .iop_unlock
= xfs_inode_item_unlock
,
656 .iop_committed
= xfs_inode_item_committed
,
657 .iop_push
= xfs_inode_item_push
,
658 .iop_committing
= xfs_inode_item_committing
,
659 .iop_error
= xfs_inode_item_error
664 * Initialize the inode log item for a newly allocated (in-core) inode.
668 struct xfs_inode
*ip
,
669 struct xfs_mount
*mp
)
671 struct xfs_inode_log_item
*iip
;
673 ASSERT(ip
->i_itemp
== NULL
);
674 iip
= ip
->i_itemp
= kmem_zone_zalloc(xfs_ili_zone
, KM_SLEEP
);
677 xfs_log_item_init(mp
, &iip
->ili_item
, XFS_LI_INODE
,
678 &xfs_inode_item_ops
);
682 * Free the inode log item and any memory hanging off of it.
685 xfs_inode_item_destroy(
688 kmem_free(ip
->i_itemp
->ili_item
.li_lv_shadow
);
689 kmem_zone_free(xfs_ili_zone
, ip
->i_itemp
);
694 * This is the inode flushing I/O completion routine. It is called
695 * from interrupt level when the buffer containing the inode is
696 * flushed to disk. It is responsible for removing the inode item
697 * from the AIL if it has not been re-logged, and unlocking the inode's
700 * To reduce AIL lock traffic as much as possible, we scan the buffer log item
701 * list for other inodes that will run this function. We remove them from the
702 * buffer list so we can process all the inode IO completions in one AIL lock
708 struct xfs_log_item
*lip
)
710 struct xfs_inode_log_item
*iip
;
711 struct xfs_log_item
*blip
;
712 struct xfs_log_item
*next
;
713 struct xfs_log_item
*prev
;
714 struct xfs_ail
*ailp
= lip
->li_ailp
;
718 * Scan the buffer IO completions for other inodes being completed and
719 * attach them to the current inode log item.
723 while (blip
!= NULL
) {
724 if (blip
->li_cb
!= xfs_iflush_done
) {
726 blip
= blip
->li_bio_list
;
730 /* remove from list */
731 next
= blip
->li_bio_list
;
735 prev
->li_bio_list
= next
;
738 /* add to current list */
739 blip
->li_bio_list
= lip
->li_bio_list
;
740 lip
->li_bio_list
= blip
;
743 * while we have the item, do the unlocked check for needing
746 iip
= INODE_ITEM(blip
);
747 if ((iip
->ili_logged
&& blip
->li_lsn
== iip
->ili_flush_lsn
) ||
748 (blip
->li_flags
& XFS_LI_FAILED
))
754 /* make sure we capture the state of the initial inode. */
755 iip
= INODE_ITEM(lip
);
756 if ((iip
->ili_logged
&& lip
->li_lsn
== iip
->ili_flush_lsn
) ||
757 lip
->li_flags
& XFS_LI_FAILED
)
761 * We only want to pull the item from the AIL if it is
762 * actually there and its location in the log has not
763 * changed since we started the flush. Thus, we only bother
764 * if the ili_logged flag is set and the inode's lsn has not
765 * changed. First we check the lsn outside
766 * the lock since it's cheaper, and then we recheck while
767 * holding the lock before removing the inode from the AIL.
770 bool mlip_changed
= false;
772 /* this is an opencoded batch version of xfs_trans_ail_delete */
773 spin_lock(&ailp
->xa_lock
);
774 for (blip
= lip
; blip
; blip
= blip
->li_bio_list
) {
775 if (INODE_ITEM(blip
)->ili_logged
&&
776 blip
->li_lsn
== INODE_ITEM(blip
)->ili_flush_lsn
)
777 mlip_changed
|= xfs_ail_delete_one(ailp
, blip
);
779 xfs_clear_li_failed(blip
);
784 if (!XFS_FORCED_SHUTDOWN(ailp
->xa_mount
))
785 xlog_assign_tail_lsn_locked(ailp
->xa_mount
);
786 if (list_empty(&ailp
->xa_ail
))
787 wake_up_all(&ailp
->xa_empty
);
789 spin_unlock(&ailp
->xa_lock
);
792 xfs_log_space_wake(ailp
->xa_mount
);
796 * clean up and unlock the flush lock now we are done. We can clear the
797 * ili_last_fields bits now that we know that the data corresponding to
798 * them is safely on disk.
800 for (blip
= lip
; blip
; blip
= next
) {
801 next
= blip
->li_bio_list
;
802 blip
->li_bio_list
= NULL
;
804 iip
= INODE_ITEM(blip
);
806 iip
->ili_last_fields
= 0;
807 xfs_ifunlock(iip
->ili_inode
);
812 * This is the inode flushing abort routine. It is called from xfs_iflush when
813 * the filesystem is shutting down to clean up the inode state. It is
814 * responsible for removing the inode item from the AIL if it has not been
815 * re-logged, and unlocking the inode's flush lock.
822 xfs_inode_log_item_t
*iip
= ip
->i_itemp
;
825 if (iip
->ili_item
.li_flags
& XFS_LI_IN_AIL
) {
826 xfs_trans_ail_remove(&iip
->ili_item
,
827 stale
? SHUTDOWN_LOG_IO_ERROR
:
828 SHUTDOWN_CORRUPT_INCORE
);
832 * Clear the ili_last_fields bits now that we know that the
833 * data corresponding to them is safely on disk.
835 iip
->ili_last_fields
= 0;
837 * Clear the inode logging fields so no more flushes are
841 iip
->ili_fsync_fields
= 0;
844 * Release the inode's flush lock since we're done with it.
852 struct xfs_log_item
*lip
)
854 xfs_iflush_abort(INODE_ITEM(lip
)->ili_inode
, true);
858 * convert an xfs_inode_log_format struct from either 32 or 64 bit versions
859 * (which can have different field alignments) to the native version
862 xfs_inode_item_format_convert(
863 xfs_log_iovec_t
*buf
,
864 xfs_inode_log_format_t
*in_f
)
866 if (buf
->i_len
== sizeof(xfs_inode_log_format_32_t
)) {
867 xfs_inode_log_format_32_t
*in_f32
= buf
->i_addr
;
869 in_f
->ilf_type
= in_f32
->ilf_type
;
870 in_f
->ilf_size
= in_f32
->ilf_size
;
871 in_f
->ilf_fields
= in_f32
->ilf_fields
;
872 in_f
->ilf_asize
= in_f32
->ilf_asize
;
873 in_f
->ilf_dsize
= in_f32
->ilf_dsize
;
874 in_f
->ilf_ino
= in_f32
->ilf_ino
;
875 /* copy biggest field of ilf_u */
876 uuid_copy(&in_f
->ilf_u
.ilfu_uuid
, &in_f32
->ilf_u
.ilfu_uuid
);
877 in_f
->ilf_blkno
= in_f32
->ilf_blkno
;
878 in_f
->ilf_len
= in_f32
->ilf_len
;
879 in_f
->ilf_boffset
= in_f32
->ilf_boffset
;
881 } else if (buf
->i_len
== sizeof(xfs_inode_log_format_64_t
)){
882 xfs_inode_log_format_64_t
*in_f64
= buf
->i_addr
;
884 in_f
->ilf_type
= in_f64
->ilf_type
;
885 in_f
->ilf_size
= in_f64
->ilf_size
;
886 in_f
->ilf_fields
= in_f64
->ilf_fields
;
887 in_f
->ilf_asize
= in_f64
->ilf_asize
;
888 in_f
->ilf_dsize
= in_f64
->ilf_dsize
;
889 in_f
->ilf_ino
= in_f64
->ilf_ino
;
890 /* copy biggest field of ilf_u */
891 uuid_copy(&in_f
->ilf_u
.ilfu_uuid
, &in_f64
->ilf_u
.ilfu_uuid
);
892 in_f
->ilf_blkno
= in_f64
->ilf_blkno
;
893 in_f
->ilf_len
= in_f64
->ilf_len
;
894 in_f
->ilf_boffset
= in_f64
->ilf_boffset
;
897 return -EFSCORRUPTED
;