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_types.h"
24 #include "xfs_trans.h"
27 #include "xfs_mount.h"
28 #include "xfs_trans_priv.h"
29 #include "xfs_bmap_btree.h"
30 #include "xfs_dinode.h"
31 #include "xfs_inode.h"
32 #include "xfs_inode_item.h"
33 #include "xfs_error.h"
34 #include "xfs_trace.h"
37 kmem_zone_t
*xfs_ili_zone
; /* inode log item zone */
39 static inline struct xfs_inode_log_item
*INODE_ITEM(struct xfs_log_item
*lip
)
41 return container_of(lip
, struct xfs_inode_log_item
, ili_item
);
46 * This returns the number of iovecs needed to log the given inode item.
48 * We need one iovec for the inode log format structure, one for the
49 * inode core, and possibly one for the inode data/extents/b-tree root
50 * and one for the inode attribute data/extents/b-tree root.
54 struct xfs_log_item
*lip
)
56 struct xfs_inode_log_item
*iip
= INODE_ITEM(lip
);
57 struct xfs_inode
*ip
= iip
->ili_inode
;
60 switch (ip
->i_d
.di_format
) {
61 case XFS_DINODE_FMT_EXTENTS
:
62 if ((iip
->ili_format
.ilf_fields
& XFS_ILOG_DEXT
) &&
63 ip
->i_d
.di_nextents
> 0 &&
64 ip
->i_df
.if_bytes
> 0)
68 case XFS_DINODE_FMT_BTREE
:
69 if ((iip
->ili_format
.ilf_fields
& XFS_ILOG_DBROOT
) &&
70 ip
->i_df
.if_broot_bytes
> 0)
74 case XFS_DINODE_FMT_LOCAL
:
75 if ((iip
->ili_format
.ilf_fields
& XFS_ILOG_DDATA
) &&
76 ip
->i_df
.if_bytes
> 0)
80 case XFS_DINODE_FMT_DEV
:
81 case XFS_DINODE_FMT_UUID
:
94 * Log any necessary attribute data.
96 switch (ip
->i_d
.di_aformat
) {
97 case XFS_DINODE_FMT_EXTENTS
:
98 if ((iip
->ili_format
.ilf_fields
& XFS_ILOG_AEXT
) &&
99 ip
->i_d
.di_anextents
> 0 &&
100 ip
->i_afp
->if_bytes
> 0)
104 case XFS_DINODE_FMT_BTREE
:
105 if ((iip
->ili_format
.ilf_fields
& XFS_ILOG_ABROOT
) &&
106 ip
->i_afp
->if_broot_bytes
> 0)
110 case XFS_DINODE_FMT_LOCAL
:
111 if ((iip
->ili_format
.ilf_fields
& XFS_ILOG_ADATA
) &&
112 ip
->i_afp
->if_bytes
> 0)
125 * xfs_inode_item_format_extents - convert in-core extents to on-disk form
127 * For either the data or attr fork in extent format, we need to endian convert
128 * the in-core extent as we place them into the on-disk inode. In this case, we
129 * need to do this conversion before we write the extents into the log. Because
130 * we don't have the disk inode to write into here, we allocate a buffer and
131 * format the extents into it via xfs_iextents_copy(). We free the buffer in
132 * the unlock routine after the copy for the log has been made.
134 * In the case of the data fork, the in-core and on-disk fork sizes can be
135 * different due to delayed allocation extents. We only log on-disk extents
136 * here, so always use the physical fork size to determine the size of the
137 * buffer we need to allocate.
140 xfs_inode_item_format_extents(
141 struct xfs_inode
*ip
,
142 struct xfs_log_iovec
*vecp
,
146 xfs_bmbt_rec_t
*ext_buffer
;
148 ext_buffer
= kmem_alloc(XFS_IFORK_SIZE(ip
, whichfork
), KM_SLEEP
);
149 if (whichfork
== XFS_DATA_FORK
)
150 ip
->i_itemp
->ili_extents_buf
= ext_buffer
;
152 ip
->i_itemp
->ili_aextents_buf
= ext_buffer
;
154 vecp
->i_addr
= ext_buffer
;
155 vecp
->i_len
= xfs_iextents_copy(ip
, ext_buffer
, whichfork
);
160 * This is called to fill in the vector of log iovecs for the
161 * given inode log item. It fills the first item with an inode
162 * log format structure, the second with the on-disk inode structure,
163 * and a possible third and/or fourth with the inode data/extents/b-tree
164 * root and inode attributes data/extents/b-tree root.
167 xfs_inode_item_format(
168 struct xfs_log_item
*lip
,
169 struct xfs_log_iovec
*vecp
)
171 struct xfs_inode_log_item
*iip
= INODE_ITEM(lip
);
172 struct xfs_inode
*ip
= iip
->ili_inode
;
177 vecp
->i_addr
= &iip
->ili_format
;
178 vecp
->i_len
= sizeof(xfs_inode_log_format_t
);
179 vecp
->i_type
= XLOG_REG_TYPE_IFORMAT
;
183 vecp
->i_addr
= &ip
->i_d
;
184 vecp
->i_len
= sizeof(struct xfs_icdinode
);
185 vecp
->i_type
= XLOG_REG_TYPE_ICORE
;
188 iip
->ili_format
.ilf_fields
|= XFS_ILOG_CORE
;
191 * If this is really an old format inode, then we need to
192 * log it as such. This means that we have to copy the link
193 * count from the new field to the old. We don't have to worry
194 * about the new fields, because nothing trusts them as long as
195 * the old inode version number is there. If the superblock already
196 * has a new version number, then we don't bother converting back.
199 ASSERT(ip
->i_d
.di_version
== 1 || xfs_sb_version_hasnlink(&mp
->m_sb
));
200 if (ip
->i_d
.di_version
== 1) {
201 if (!xfs_sb_version_hasnlink(&mp
->m_sb
)) {
205 ASSERT(ip
->i_d
.di_nlink
<= XFS_MAXLINK_1
);
206 ip
->i_d
.di_onlink
= ip
->i_d
.di_nlink
;
209 * The superblock version has already been bumped,
210 * so just make the conversion to the new inode
213 ip
->i_d
.di_version
= 2;
214 ip
->i_d
.di_onlink
= 0;
215 memset(&(ip
->i_d
.di_pad
[0]), 0, sizeof(ip
->i_d
.di_pad
));
219 switch (ip
->i_d
.di_format
) {
220 case XFS_DINODE_FMT_EXTENTS
:
221 iip
->ili_format
.ilf_fields
&=
222 ~(XFS_ILOG_DDATA
| XFS_ILOG_DBROOT
|
223 XFS_ILOG_DEV
| XFS_ILOG_UUID
);
225 if ((iip
->ili_format
.ilf_fields
& XFS_ILOG_DEXT
) &&
226 ip
->i_d
.di_nextents
> 0 &&
227 ip
->i_df
.if_bytes
> 0) {
228 ASSERT(ip
->i_df
.if_u1
.if_extents
!= NULL
);
229 ASSERT(ip
->i_df
.if_bytes
/ sizeof(xfs_bmbt_rec_t
) > 0);
230 ASSERT(iip
->ili_extents_buf
== NULL
);
232 #ifdef XFS_NATIVE_HOST
233 if (ip
->i_d
.di_nextents
== ip
->i_df
.if_bytes
/
234 (uint
)sizeof(xfs_bmbt_rec_t
)) {
236 * There are no delayed allocation
237 * extents, so just point to the
238 * real extents array.
240 vecp
->i_addr
= ip
->i_df
.if_u1
.if_extents
;
241 vecp
->i_len
= ip
->i_df
.if_bytes
;
242 vecp
->i_type
= XLOG_REG_TYPE_IEXT
;
246 xfs_inode_item_format_extents(ip
, vecp
,
247 XFS_DATA_FORK
, XLOG_REG_TYPE_IEXT
);
249 ASSERT(vecp
->i_len
<= ip
->i_df
.if_bytes
);
250 iip
->ili_format
.ilf_dsize
= vecp
->i_len
;
254 iip
->ili_format
.ilf_fields
&= ~XFS_ILOG_DEXT
;
258 case XFS_DINODE_FMT_BTREE
:
259 iip
->ili_format
.ilf_fields
&=
260 ~(XFS_ILOG_DDATA
| XFS_ILOG_DEXT
|
261 XFS_ILOG_DEV
| XFS_ILOG_UUID
);
263 if ((iip
->ili_format
.ilf_fields
& XFS_ILOG_DBROOT
) &&
264 ip
->i_df
.if_broot_bytes
> 0) {
265 ASSERT(ip
->i_df
.if_broot
!= NULL
);
266 vecp
->i_addr
= ip
->i_df
.if_broot
;
267 vecp
->i_len
= ip
->i_df
.if_broot_bytes
;
268 vecp
->i_type
= XLOG_REG_TYPE_IBROOT
;
271 iip
->ili_format
.ilf_dsize
= ip
->i_df
.if_broot_bytes
;
273 ASSERT(!(iip
->ili_format
.ilf_fields
&
275 #ifdef XFS_TRANS_DEBUG
276 if (iip
->ili_root_size
> 0) {
277 ASSERT(iip
->ili_root_size
==
278 ip
->i_df
.if_broot_bytes
);
279 ASSERT(memcmp(iip
->ili_orig_root
,
281 iip
->ili_root_size
) == 0);
283 ASSERT(ip
->i_df
.if_broot_bytes
== 0);
286 iip
->ili_format
.ilf_fields
&= ~XFS_ILOG_DBROOT
;
290 case XFS_DINODE_FMT_LOCAL
:
291 iip
->ili_format
.ilf_fields
&=
292 ~(XFS_ILOG_DEXT
| XFS_ILOG_DBROOT
|
293 XFS_ILOG_DEV
| XFS_ILOG_UUID
);
294 if ((iip
->ili_format
.ilf_fields
& XFS_ILOG_DDATA
) &&
295 ip
->i_df
.if_bytes
> 0) {
296 ASSERT(ip
->i_df
.if_u1
.if_data
!= NULL
);
297 ASSERT(ip
->i_d
.di_size
> 0);
299 vecp
->i_addr
= ip
->i_df
.if_u1
.if_data
;
301 * Round i_bytes up to a word boundary.
302 * The underlying memory is guaranteed to
303 * to be there by xfs_idata_realloc().
305 data_bytes
= roundup(ip
->i_df
.if_bytes
, 4);
306 ASSERT((ip
->i_df
.if_real_bytes
== 0) ||
307 (ip
->i_df
.if_real_bytes
== data_bytes
));
308 vecp
->i_len
= (int)data_bytes
;
309 vecp
->i_type
= XLOG_REG_TYPE_ILOCAL
;
312 iip
->ili_format
.ilf_dsize
= (unsigned)data_bytes
;
314 iip
->ili_format
.ilf_fields
&= ~XFS_ILOG_DDATA
;
318 case XFS_DINODE_FMT_DEV
:
319 iip
->ili_format
.ilf_fields
&=
320 ~(XFS_ILOG_DDATA
| XFS_ILOG_DBROOT
|
321 XFS_ILOG_DEXT
| XFS_ILOG_UUID
);
322 if (iip
->ili_format
.ilf_fields
& XFS_ILOG_DEV
) {
323 iip
->ili_format
.ilf_u
.ilfu_rdev
=
324 ip
->i_df
.if_u2
.if_rdev
;
328 case XFS_DINODE_FMT_UUID
:
329 iip
->ili_format
.ilf_fields
&=
330 ~(XFS_ILOG_DDATA
| XFS_ILOG_DBROOT
|
331 XFS_ILOG_DEXT
| XFS_ILOG_DEV
);
332 if (iip
->ili_format
.ilf_fields
& XFS_ILOG_UUID
) {
333 iip
->ili_format
.ilf_u
.ilfu_uuid
=
334 ip
->i_df
.if_u2
.if_uuid
;
344 * If there are no attributes associated with the file, then we're done.
346 if (!XFS_IFORK_Q(ip
)) {
347 iip
->ili_format
.ilf_size
= nvecs
;
348 iip
->ili_format
.ilf_fields
&=
349 ~(XFS_ILOG_ADATA
| XFS_ILOG_ABROOT
| XFS_ILOG_AEXT
);
353 switch (ip
->i_d
.di_aformat
) {
354 case XFS_DINODE_FMT_EXTENTS
:
355 iip
->ili_format
.ilf_fields
&=
356 ~(XFS_ILOG_ADATA
| XFS_ILOG_ABROOT
);
358 if ((iip
->ili_format
.ilf_fields
& XFS_ILOG_AEXT
) &&
359 ip
->i_d
.di_anextents
> 0 &&
360 ip
->i_afp
->if_bytes
> 0) {
361 ASSERT(ip
->i_afp
->if_bytes
/ sizeof(xfs_bmbt_rec_t
) ==
362 ip
->i_d
.di_anextents
);
363 ASSERT(ip
->i_afp
->if_u1
.if_extents
!= NULL
);
364 #ifdef XFS_NATIVE_HOST
366 * There are not delayed allocation extents
367 * for attributes, so just point at the array.
369 vecp
->i_addr
= ip
->i_afp
->if_u1
.if_extents
;
370 vecp
->i_len
= ip
->i_afp
->if_bytes
;
371 vecp
->i_type
= XLOG_REG_TYPE_IATTR_EXT
;
373 ASSERT(iip
->ili_aextents_buf
== NULL
);
374 xfs_inode_item_format_extents(ip
, vecp
,
375 XFS_ATTR_FORK
, XLOG_REG_TYPE_IATTR_EXT
);
377 iip
->ili_format
.ilf_asize
= vecp
->i_len
;
381 iip
->ili_format
.ilf_fields
&= ~XFS_ILOG_AEXT
;
385 case XFS_DINODE_FMT_BTREE
:
386 iip
->ili_format
.ilf_fields
&=
387 ~(XFS_ILOG_ADATA
| XFS_ILOG_AEXT
);
389 if ((iip
->ili_format
.ilf_fields
& XFS_ILOG_ABROOT
) &&
390 ip
->i_afp
->if_broot_bytes
> 0) {
391 ASSERT(ip
->i_afp
->if_broot
!= NULL
);
393 vecp
->i_addr
= ip
->i_afp
->if_broot
;
394 vecp
->i_len
= ip
->i_afp
->if_broot_bytes
;
395 vecp
->i_type
= XLOG_REG_TYPE_IATTR_BROOT
;
398 iip
->ili_format
.ilf_asize
= ip
->i_afp
->if_broot_bytes
;
400 iip
->ili_format
.ilf_fields
&= ~XFS_ILOG_ABROOT
;
404 case XFS_DINODE_FMT_LOCAL
:
405 iip
->ili_format
.ilf_fields
&=
406 ~(XFS_ILOG_AEXT
| XFS_ILOG_ABROOT
);
408 if ((iip
->ili_format
.ilf_fields
& XFS_ILOG_ADATA
) &&
409 ip
->i_afp
->if_bytes
> 0) {
410 ASSERT(ip
->i_afp
->if_u1
.if_data
!= NULL
);
412 vecp
->i_addr
= ip
->i_afp
->if_u1
.if_data
;
414 * Round i_bytes up to a word boundary.
415 * The underlying memory is guaranteed to
416 * to be there by xfs_idata_realloc().
418 data_bytes
= roundup(ip
->i_afp
->if_bytes
, 4);
419 ASSERT((ip
->i_afp
->if_real_bytes
== 0) ||
420 (ip
->i_afp
->if_real_bytes
== data_bytes
));
421 vecp
->i_len
= (int)data_bytes
;
422 vecp
->i_type
= XLOG_REG_TYPE_IATTR_LOCAL
;
425 iip
->ili_format
.ilf_asize
= (unsigned)data_bytes
;
427 iip
->ili_format
.ilf_fields
&= ~XFS_ILOG_ADATA
;
436 iip
->ili_format
.ilf_size
= nvecs
;
441 * This is called to pin the inode associated with the inode log
442 * item in memory so it cannot be written out.
446 struct xfs_log_item
*lip
)
448 struct xfs_inode
*ip
= INODE_ITEM(lip
)->ili_inode
;
450 ASSERT(xfs_isilocked(ip
, XFS_ILOCK_EXCL
));
452 trace_xfs_inode_pin(ip
, _RET_IP_
);
453 atomic_inc(&ip
->i_pincount
);
458 * This is called to unpin the inode associated with the inode log
459 * item which was previously pinned with a call to xfs_inode_item_pin().
461 * Also wake up anyone in xfs_iunpin_wait() if the count goes to 0.
464 xfs_inode_item_unpin(
465 struct xfs_log_item
*lip
,
468 struct xfs_inode
*ip
= INODE_ITEM(lip
)->ili_inode
;
470 trace_xfs_inode_unpin(ip
, _RET_IP_
);
471 ASSERT(atomic_read(&ip
->i_pincount
) > 0);
472 if (atomic_dec_and_test(&ip
->i_pincount
))
473 wake_up_bit(&ip
->i_flags
, __XFS_IPINNED_BIT
);
477 * This is called to attempt to lock the inode associated with this
478 * inode log item, in preparation for the push routine which does the actual
479 * iflush. Don't sleep on the inode lock or the flush lock.
481 * If the flush lock is already held, indicating that the inode has
482 * been or is in the process of being flushed, then (ideally) we'd like to
483 * see if the inode's buffer is still incore, and if so give it a nudge.
484 * We delay doing so until the pushbuf routine, though, to avoid holding
485 * the AIL lock across a call to the blackhole which is the buffer cache.
486 * Also we don't want to sleep in any device strategy routines, which can happen
487 * if we do the subsequent bawrite in here.
490 xfs_inode_item_trylock(
491 struct xfs_log_item
*lip
)
493 struct xfs_inode_log_item
*iip
= INODE_ITEM(lip
);
494 struct xfs_inode
*ip
= iip
->ili_inode
;
496 if (xfs_ipincount(ip
) > 0)
497 return XFS_ITEM_PINNED
;
499 if (!xfs_ilock_nowait(ip
, XFS_ILOCK_SHARED
))
500 return XFS_ITEM_LOCKED
;
502 if (!xfs_iflock_nowait(ip
)) {
504 * inode has already been flushed to the backing buffer,
505 * leave it locked in shared mode, pushbuf routine will
508 return XFS_ITEM_PUSHBUF
;
511 /* Stale items should force out the iclog */
512 if (ip
->i_flags
& XFS_ISTALE
) {
514 xfs_iunlock(ip
, XFS_ILOCK_SHARED
);
515 return XFS_ITEM_PINNED
;
519 if (!XFS_FORCED_SHUTDOWN(ip
->i_mount
)) {
520 ASSERT(iip
->ili_format
.ilf_fields
!= 0);
521 ASSERT(iip
->ili_logged
== 0);
522 ASSERT(lip
->li_flags
& XFS_LI_IN_AIL
);
525 return XFS_ITEM_SUCCESS
;
529 * Unlock the inode associated with the inode log item.
530 * Clear the fields of the inode and inode log item that
531 * are specific to the current transaction. If the
532 * hold flags is set, do not unlock the inode.
535 xfs_inode_item_unlock(
536 struct xfs_log_item
*lip
)
538 struct xfs_inode_log_item
*iip
= INODE_ITEM(lip
);
539 struct xfs_inode
*ip
= iip
->ili_inode
;
540 unsigned short lock_flags
;
542 ASSERT(ip
->i_itemp
!= NULL
);
543 ASSERT(xfs_isilocked(ip
, XFS_ILOCK_EXCL
));
546 * If the inode needed a separate buffer with which to log
547 * its extents, then free it now.
549 if (iip
->ili_extents_buf
!= NULL
) {
550 ASSERT(ip
->i_d
.di_format
== XFS_DINODE_FMT_EXTENTS
);
551 ASSERT(ip
->i_d
.di_nextents
> 0);
552 ASSERT(iip
->ili_format
.ilf_fields
& XFS_ILOG_DEXT
);
553 ASSERT(ip
->i_df
.if_bytes
> 0);
554 kmem_free(iip
->ili_extents_buf
);
555 iip
->ili_extents_buf
= NULL
;
557 if (iip
->ili_aextents_buf
!= NULL
) {
558 ASSERT(ip
->i_d
.di_aformat
== XFS_DINODE_FMT_EXTENTS
);
559 ASSERT(ip
->i_d
.di_anextents
> 0);
560 ASSERT(iip
->ili_format
.ilf_fields
& XFS_ILOG_AEXT
);
561 ASSERT(ip
->i_afp
->if_bytes
> 0);
562 kmem_free(iip
->ili_aextents_buf
);
563 iip
->ili_aextents_buf
= NULL
;
566 lock_flags
= iip
->ili_lock_flags
;
567 iip
->ili_lock_flags
= 0;
569 xfs_iunlock(ip
, lock_flags
);
573 * This is called to find out where the oldest active copy of the inode log
574 * item in the on disk log resides now that the last log write of it completed
575 * at the given lsn. Since we always re-log all dirty data in an inode, the
576 * latest copy in the on disk log is the only one that matters. Therefore,
577 * simply return the given lsn.
579 * If the inode has been marked stale because the cluster is being freed, we
580 * don't want to (re-)insert this inode into the AIL. There is a race condition
581 * where the cluster buffer may be unpinned before the inode is inserted into
582 * the AIL during transaction committed processing. If the buffer is unpinned
583 * before the inode item has been committed and inserted, then it is possible
584 * for the buffer to be written and IO completes before the inode is inserted
585 * into the AIL. In that case, we'd be inserting a clean, stale inode into the
586 * AIL which will never get removed. It will, however, get reclaimed which
587 * triggers an assert in xfs_inode_free() complaining about freein an inode
590 * To avoid this, just unpin the inode directly and return a LSN of -1 so the
591 * transaction committed code knows that it does not need to do any further
592 * processing on the item.
595 xfs_inode_item_committed(
596 struct xfs_log_item
*lip
,
599 struct xfs_inode_log_item
*iip
= INODE_ITEM(lip
);
600 struct xfs_inode
*ip
= iip
->ili_inode
;
602 if (xfs_iflags_test(ip
, XFS_ISTALE
)) {
603 xfs_inode_item_unpin(lip
, 0);
610 * This gets called by xfs_trans_push_ail(), when IOP_TRYLOCK
611 * failed to get the inode flush lock but did get the inode locked SHARED.
612 * Here we're trying to see if the inode buffer is incore, and if so whether it's
613 * marked delayed write. If that's the case, we'll promote it and that will
614 * allow the caller to write the buffer by triggering the xfsbufd to run.
617 xfs_inode_item_pushbuf(
618 struct xfs_log_item
*lip
)
620 struct xfs_inode_log_item
*iip
= INODE_ITEM(lip
);
621 struct xfs_inode
*ip
= iip
->ili_inode
;
625 ASSERT(xfs_isilocked(ip
, XFS_ILOCK_SHARED
));
628 * If a flush is not in progress anymore, chances are that the
629 * inode was taken off the AIL. So, just get out.
631 if (!xfs_isiflocked(ip
) ||
632 !(lip
->li_flags
& XFS_LI_IN_AIL
)) {
633 xfs_iunlock(ip
, XFS_ILOCK_SHARED
);
637 bp
= xfs_incore(ip
->i_mount
->m_ddev_targp
, iip
->ili_format
.ilf_blkno
,
638 iip
->ili_format
.ilf_len
, XBF_TRYLOCK
);
640 xfs_iunlock(ip
, XFS_ILOCK_SHARED
);
643 if (XFS_BUF_ISDELAYWRITE(bp
))
644 xfs_buf_delwri_promote(bp
);
645 if (xfs_buf_ispinned(bp
))
652 * This is called to asynchronously write the inode associated with this
653 * inode log item out to disk. The inode will already have been locked by
654 * a successful call to xfs_inode_item_trylock().
658 struct xfs_log_item
*lip
)
660 struct xfs_inode_log_item
*iip
= INODE_ITEM(lip
);
661 struct xfs_inode
*ip
= iip
->ili_inode
;
663 ASSERT(xfs_isilocked(ip
, XFS_ILOCK_SHARED
));
664 ASSERT(xfs_isiflocked(ip
));
667 * Since we were able to lock the inode's flush lock and
668 * we found it on the AIL, the inode must be dirty. This
669 * is because the inode is removed from the AIL while still
670 * holding the flush lock in xfs_iflush_done(). Thus, if
671 * we found it in the AIL and were able to obtain the flush
672 * lock without sleeping, then there must not have been
673 * anyone in the process of flushing the inode.
675 ASSERT(XFS_FORCED_SHUTDOWN(ip
->i_mount
) ||
676 iip
->ili_format
.ilf_fields
!= 0);
679 * Push the inode to it's backing buffer. This will not remove the
680 * inode from the AIL - a further push will be required to trigger a
681 * buffer push. However, this allows all the dirty inodes to be pushed
682 * to the buffer before it is pushed to disk. The buffer IO completion
683 * will pull the inode from the AIL, mark it clean and unlock the flush
686 (void) xfs_iflush(ip
, SYNC_TRYLOCK
);
687 xfs_iunlock(ip
, XFS_ILOCK_SHARED
);
691 * XXX rcc - this one really has to do something. Probably needs
692 * to stamp in a new field in the incore inode.
695 xfs_inode_item_committing(
696 struct xfs_log_item
*lip
,
699 INODE_ITEM(lip
)->ili_last_lsn
= lsn
;
703 * This is the ops vector shared by all buf log items.
705 static const struct xfs_item_ops xfs_inode_item_ops
= {
706 .iop_size
= xfs_inode_item_size
,
707 .iop_format
= xfs_inode_item_format
,
708 .iop_pin
= xfs_inode_item_pin
,
709 .iop_unpin
= xfs_inode_item_unpin
,
710 .iop_trylock
= xfs_inode_item_trylock
,
711 .iop_unlock
= xfs_inode_item_unlock
,
712 .iop_committed
= xfs_inode_item_committed
,
713 .iop_push
= xfs_inode_item_push
,
714 .iop_pushbuf
= xfs_inode_item_pushbuf
,
715 .iop_committing
= xfs_inode_item_committing
720 * Initialize the inode log item for a newly allocated (in-core) inode.
724 struct xfs_inode
*ip
,
725 struct xfs_mount
*mp
)
727 struct xfs_inode_log_item
*iip
;
729 ASSERT(ip
->i_itemp
== NULL
);
730 iip
= ip
->i_itemp
= kmem_zone_zalloc(xfs_ili_zone
, KM_SLEEP
);
733 xfs_log_item_init(mp
, &iip
->ili_item
, XFS_LI_INODE
,
734 &xfs_inode_item_ops
);
735 iip
->ili_format
.ilf_type
= XFS_LI_INODE
;
736 iip
->ili_format
.ilf_ino
= ip
->i_ino
;
737 iip
->ili_format
.ilf_blkno
= ip
->i_imap
.im_blkno
;
738 iip
->ili_format
.ilf_len
= ip
->i_imap
.im_len
;
739 iip
->ili_format
.ilf_boffset
= ip
->i_imap
.im_boffset
;
743 * Free the inode log item and any memory hanging off of it.
746 xfs_inode_item_destroy(
749 #ifdef XFS_TRANS_DEBUG
750 if (ip
->i_itemp
->ili_root_size
!= 0) {
751 kmem_free(ip
->i_itemp
->ili_orig_root
);
754 kmem_zone_free(xfs_ili_zone
, ip
->i_itemp
);
759 * This is the inode flushing I/O completion routine. It is called
760 * from interrupt level when the buffer containing the inode is
761 * flushed to disk. It is responsible for removing the inode item
762 * from the AIL if it has not been re-logged, and unlocking the inode's
765 * To reduce AIL lock traffic as much as possible, we scan the buffer log item
766 * list for other inodes that will run this function. We remove them from the
767 * buffer list so we can process all the inode IO completions in one AIL lock
773 struct xfs_log_item
*lip
)
775 struct xfs_inode_log_item
*iip
;
776 struct xfs_log_item
*blip
;
777 struct xfs_log_item
*next
;
778 struct xfs_log_item
*prev
;
779 struct xfs_ail
*ailp
= lip
->li_ailp
;
783 * Scan the buffer IO completions for other inodes being completed and
784 * attach them to the current inode log item.
788 while (blip
!= NULL
) {
789 if (lip
->li_cb
!= xfs_iflush_done
) {
791 blip
= blip
->li_bio_list
;
795 /* remove from list */
796 next
= blip
->li_bio_list
;
800 prev
->li_bio_list
= next
;
803 /* add to current list */
804 blip
->li_bio_list
= lip
->li_bio_list
;
805 lip
->li_bio_list
= blip
;
808 * while we have the item, do the unlocked check for needing
811 iip
= INODE_ITEM(blip
);
812 if (iip
->ili_logged
&& blip
->li_lsn
== iip
->ili_flush_lsn
)
818 /* make sure we capture the state of the initial inode. */
819 iip
= INODE_ITEM(lip
);
820 if (iip
->ili_logged
&& lip
->li_lsn
== iip
->ili_flush_lsn
)
824 * We only want to pull the item from the AIL if it is
825 * actually there and its location in the log has not
826 * changed since we started the flush. Thus, we only bother
827 * if the ili_logged flag is set and the inode's lsn has not
828 * changed. First we check the lsn outside
829 * the lock since it's cheaper, and then we recheck while
830 * holding the lock before removing the inode from the AIL.
833 struct xfs_log_item
*log_items
[need_ail
];
835 spin_lock(&ailp
->xa_lock
);
836 for (blip
= lip
; blip
; blip
= blip
->li_bio_list
) {
837 iip
= INODE_ITEM(blip
);
838 if (iip
->ili_logged
&&
839 blip
->li_lsn
== iip
->ili_flush_lsn
) {
840 log_items
[i
++] = blip
;
842 ASSERT(i
<= need_ail
);
844 /* xfs_trans_ail_delete_bulk() drops the AIL lock. */
845 xfs_trans_ail_delete_bulk(ailp
, log_items
, i
);
850 * clean up and unlock the flush lock now we are done. We can clear the
851 * ili_last_fields bits now that we know that the data corresponding to
852 * them is safely on disk.
854 for (blip
= lip
; blip
; blip
= next
) {
855 next
= blip
->li_bio_list
;
856 blip
->li_bio_list
= NULL
;
858 iip
= INODE_ITEM(blip
);
860 iip
->ili_last_fields
= 0;
861 xfs_ifunlock(iip
->ili_inode
);
866 * This is the inode flushing abort routine. It is called
867 * from xfs_iflush when the filesystem is shutting down to clean
868 * up the inode state.
869 * It is responsible for removing the inode item
870 * from the AIL if it has not been re-logged, and unlocking the inode's
877 xfs_inode_log_item_t
*iip
= ip
->i_itemp
;
880 struct xfs_ail
*ailp
= iip
->ili_item
.li_ailp
;
881 if (iip
->ili_item
.li_flags
& XFS_LI_IN_AIL
) {
882 spin_lock(&ailp
->xa_lock
);
883 if (iip
->ili_item
.li_flags
& XFS_LI_IN_AIL
) {
884 /* xfs_trans_ail_delete() drops the AIL lock. */
885 xfs_trans_ail_delete(ailp
, (xfs_log_item_t
*)iip
);
887 spin_unlock(&ailp
->xa_lock
);
891 * Clear the ili_last_fields bits now that we know that the
892 * data corresponding to them is safely on disk.
894 iip
->ili_last_fields
= 0;
896 * Clear the inode logging fields so no more flushes are
899 iip
->ili_format
.ilf_fields
= 0;
902 * Release the inode's flush lock since we're done with it.
910 struct xfs_log_item
*lip
)
912 xfs_iflush_abort(INODE_ITEM(lip
)->ili_inode
);
916 * convert an xfs_inode_log_format struct from either 32 or 64 bit versions
917 * (which can have different field alignments) to the native version
920 xfs_inode_item_format_convert(
921 xfs_log_iovec_t
*buf
,
922 xfs_inode_log_format_t
*in_f
)
924 if (buf
->i_len
== sizeof(xfs_inode_log_format_32_t
)) {
925 xfs_inode_log_format_32_t
*in_f32
= buf
->i_addr
;
927 in_f
->ilf_type
= in_f32
->ilf_type
;
928 in_f
->ilf_size
= in_f32
->ilf_size
;
929 in_f
->ilf_fields
= in_f32
->ilf_fields
;
930 in_f
->ilf_asize
= in_f32
->ilf_asize
;
931 in_f
->ilf_dsize
= in_f32
->ilf_dsize
;
932 in_f
->ilf_ino
= in_f32
->ilf_ino
;
933 /* copy biggest field of ilf_u */
934 memcpy(in_f
->ilf_u
.ilfu_uuid
.__u_bits
,
935 in_f32
->ilf_u
.ilfu_uuid
.__u_bits
,
937 in_f
->ilf_blkno
= in_f32
->ilf_blkno
;
938 in_f
->ilf_len
= in_f32
->ilf_len
;
939 in_f
->ilf_boffset
= in_f32
->ilf_boffset
;
941 } else if (buf
->i_len
== sizeof(xfs_inode_log_format_64_t
)){
942 xfs_inode_log_format_64_t
*in_f64
= buf
->i_addr
;
944 in_f
->ilf_type
= in_f64
->ilf_type
;
945 in_f
->ilf_size
= in_f64
->ilf_size
;
946 in_f
->ilf_fields
= in_f64
->ilf_fields
;
947 in_f
->ilf_asize
= in_f64
->ilf_asize
;
948 in_f
->ilf_dsize
= in_f64
->ilf_dsize
;
949 in_f
->ilf_ino
= in_f64
->ilf_ino
;
950 /* copy biggest field of ilf_u */
951 memcpy(in_f
->ilf_u
.ilfu_uuid
.__u_bits
,
952 in_f64
->ilf_u
.ilfu_uuid
.__u_bits
,
954 in_f
->ilf_blkno
= in_f64
->ilf_blkno
;
955 in_f
->ilf_len
= in_f64
->ilf_len
;
956 in_f
->ilf_boffset
= in_f64
->ilf_boffset
;