2 * Copyright (c) 2000-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"
28 #include "xfs_dmapi.h"
29 #include "xfs_mount.h"
30 #include "xfs_da_btree.h"
31 #include "xfs_bmap_btree.h"
32 #include "xfs_ialloc_btree.h"
33 #include "xfs_alloc_btree.h"
34 #include "xfs_dir2_sf.h"
35 #include "xfs_attr_sf.h"
36 #include "xfs_dinode.h"
37 #include "xfs_inode.h"
38 #include "xfs_inode_item.h"
39 #include "xfs_btree.h"
40 #include "xfs_alloc.h"
41 #include "xfs_ialloc.h"
42 #include "xfs_quota.h"
43 #include "xfs_error.h"
46 #include "xfs_buf_item.h"
47 #include "xfs_log_priv.h"
48 #include "xfs_dir2_trace.h"
49 #include "xfs_extfree_item.h"
53 #include "xfs_mru_cache.h"
54 #include "xfs_filestream.h"
55 #include "xfs_fsops.h"
56 #include "xfs_vnodeops.h"
57 #include "xfs_vfsops.h"
58 #include "xfs_utils.h"
65 int count
= 0, pincount
;
67 xfs_flush_buftarg(mp
->m_ddev_targp
, 0);
68 xfs_finish_reclaim_all(mp
, 0);
70 /* This loop must run at least twice.
71 * The first instance of the loop will flush
72 * most meta data but that will generate more
73 * meta data (typically directory updates).
74 * Which then must be flushed and logged before
75 * we can write the unmount record.
78 xfs_syncsub(mp
, SYNC_INODE_QUIESCE
, NULL
);
79 pincount
= xfs_flush_buftarg(mp
->m_ddev_targp
, 1);
88 * Second stage of a quiesce. The data is already synced, now we have to take
89 * care of the metadata. New transactions are already blocked, so we need to
90 * wait for any remaining transactions to drain out before proceding.
98 /* wait for all modifications to complete */
99 while (atomic_read(&mp
->m_active_trans
) > 0)
102 /* flush inodes and push all remaining buffers out to disk */
105 ASSERT_ALWAYS(atomic_read(&mp
->m_active_trans
) == 0);
107 /* Push the superblock and write an unmount record */
108 error
= xfs_log_sbcount(mp
, 1);
110 xfs_fs_cmn_err(CE_WARN
, mp
,
111 "xfs_attr_quiesce: failed to log sb changes. "
112 "Frozen image may not be consistent.");
113 xfs_log_unmount_write(mp
);
114 xfs_unmountfs_writesb(mp
);
118 * xfs_unmount_flush implements a set of flush operation on special
119 * inodes, which are needed as a separate set of operations so that
120 * they can be called as part of relocation process.
124 xfs_mount_t
*mp
, /* Mount structure we are getting
126 int relocation
) /* Called from vfs relocation. */
128 xfs_inode_t
*rip
= mp
->m_rootip
;
130 xfs_inode_t
*rsumip
= NULL
;
131 bhv_vnode_t
*rvp
= XFS_ITOV(rip
);
134 xfs_ilock(rip
, XFS_ILOCK_EXCL
| XFS_ILOCK_PARENT
);
138 * Flush out the real time inodes.
140 if ((rbmip
= mp
->m_rbmip
) != NULL
) {
141 xfs_ilock(rbmip
, XFS_ILOCK_EXCL
);
143 error
= xfs_iflush(rbmip
, XFS_IFLUSH_SYNC
);
144 xfs_iunlock(rbmip
, XFS_ILOCK_EXCL
);
146 if (error
== EFSCORRUPTED
)
149 ASSERT(vn_count(XFS_ITOV(rbmip
)) == 1);
151 rsumip
= mp
->m_rsumip
;
152 xfs_ilock(rsumip
, XFS_ILOCK_EXCL
);
154 error
= xfs_iflush(rsumip
, XFS_IFLUSH_SYNC
);
155 xfs_iunlock(rsumip
, XFS_ILOCK_EXCL
);
157 if (error
== EFSCORRUPTED
)
160 ASSERT(vn_count(XFS_ITOV(rsumip
)) == 1);
164 * Synchronously flush root inode to disk
166 error
= xfs_iflush(rip
, XFS_IFLUSH_SYNC
);
167 if (error
== EFSCORRUPTED
)
170 if (vn_count(rvp
) != 1 && !relocation
) {
171 xfs_iunlock(rip
, XFS_ILOCK_EXCL
);
172 return XFS_ERROR(EBUSY
);
176 * Release dquot that rootinode, rbmino and rsumino might be holding,
177 * flush and purge the quota inodes.
179 error
= XFS_QM_UNMOUNT(mp
);
180 if (error
== EFSCORRUPTED
)
188 xfs_iunlock(rip
, XFS_ILOCK_EXCL
);
195 xfs_iunlock(rip
, XFS_ILOCK_EXCL
);
197 return XFS_ERROR(EFSCORRUPTED
);
201 * xfs_sync flushes any pending I/O to file system vfsp.
203 * This routine is called by vfs_sync() to make sure that things make it
204 * out to disk eventually, on sync() system calls to flush out everything,
205 * and when the file system is unmounted. For the vfs_sync() case, all
206 * we really need to do is sync out the log to make all of our meta-data
207 * updates permanent (except for timestamps). For calls from pflushd(),
208 * dirty pages are kept moving by calling pdflush() on the inodes
209 * containing them. We also flush the inodes that we can lock without
210 * sleeping and the superblock if we can lock it without sleeping from
211 * vfs_sync() so that items at the tail of the log are always moving out.
214 * SYNC_BDFLUSH - We're being called from vfs_sync() so we don't want
215 * to sleep if we can help it. All we really need
216 * to do is ensure that the log is synced at least
217 * periodically. We also push the inodes and
218 * superblock if we can lock them without sleeping
219 * and they are not pinned.
220 * SYNC_ATTR - We need to flush the inodes. If SYNC_BDFLUSH is not
221 * set, then we really want to lock each inode and flush
223 * SYNC_WAIT - All the flushes that take place in this call should
225 * SYNC_DELWRI - This tells us to push dirty pages associated with
226 * inodes. SYNC_WAIT and SYNC_BDFLUSH are used to
227 * determine if they should be flushed sync, async, or
229 * SYNC_CLOSE - This flag is passed when the system is being
230 * unmounted. We should sync and invalidate everything.
231 * SYNC_FSDATA - This indicates that the caller would like to make
232 * sure the superblock is safe on disk. We can ensure
233 * this by simply making sure the log gets flushed
234 * if SYNC_BDFLUSH is set, and by actually writing it
236 * SYNC_IOWAIT - The caller wants us to wait for all data I/O to complete
237 * before we return (including direct I/O). Forms the drain
238 * side of the write barrier needed to safely quiesce the
250 * Get the Quota Manager to flush the dquots.
252 * If XFS quota support is not enabled or this filesystem
253 * instance does not use quotas XFS_QM_DQSYNC will always
256 error
= XFS_QM_DQSYNC(mp
, flags
);
259 * If we got an IO error, we will be shutting down.
260 * So, there's nothing more for us to do here.
262 ASSERT(error
!= EIO
|| XFS_FORCED_SHUTDOWN(mp
));
263 if (XFS_FORCED_SHUTDOWN(mp
))
264 return XFS_ERROR(error
);
267 if (flags
& SYNC_IOWAIT
)
268 xfs_filestream_flush(mp
);
270 return xfs_syncsub(mp
, flags
, NULL
);
274 * xfs sync routine for internal use
276 * This routine supports all of the flags defined for the generic vfs_sync
277 * interface as explained above under xfs_sync.
286 xfs_inode_t
*ip
= NULL
;
287 bhv_vnode_t
*vp
= NULL
;
292 uint base_lock_flags
;
293 boolean_t mount_locked
;
294 boolean_t vnode_refed
;
296 xfs_iptr_t
*ipointer
;
298 boolean_t ipointer_in
= B_FALSE
;
300 #define IPOINTER_SET ipointer_in = B_TRUE
301 #define IPOINTER_CLR ipointer_in = B_FALSE
308 /* Insert a marker record into the inode list after inode ip. The list
309 * must be locked when this is called. After the call the list will no
312 #define IPOINTER_INSERT(ip, mp) { \
313 ASSERT(ipointer_in == B_FALSE); \
314 ipointer->ip_mnext = ip->i_mnext; \
315 ipointer->ip_mprev = ip; \
316 ip->i_mnext = (xfs_inode_t *)ipointer; \
317 ipointer->ip_mnext->i_mprev = (xfs_inode_t *)ipointer; \
319 XFS_MOUNT_IUNLOCK(mp); \
320 mount_locked = B_FALSE; \
324 /* Remove the marker from the inode list. If the marker was the only item
325 * in the list then there are no remaining inodes and we should zero out
326 * the whole list. If we are the current head of the list then move the head
329 #define IPOINTER_REMOVE(ip, mp) { \
330 ASSERT(ipointer_in == B_TRUE); \
331 if (ipointer->ip_mnext != (xfs_inode_t *)ipointer) { \
332 ip = ipointer->ip_mnext; \
333 ip->i_mprev = ipointer->ip_mprev; \
334 ipointer->ip_mprev->i_mnext = ip; \
335 if (mp->m_inodes == (xfs_inode_t *)ipointer) { \
339 ASSERT(mp->m_inodes == (xfs_inode_t *)ipointer); \
340 mp->m_inodes = NULL; \
346 #define XFS_PREEMPT_MASK 0x7f
348 ASSERT(!(flags
& SYNC_BDFLUSH
));
352 if (mp
->m_flags
& XFS_MOUNT_RDONLY
)
358 /* Allocate a reference marker */
359 ipointer
= (xfs_iptr_t
*)kmem_zalloc(sizeof(xfs_iptr_t
), KM_SLEEP
);
361 fflag
= XFS_B_ASYNC
; /* default is don't wait */
362 if (flags
& SYNC_DELWRI
)
363 fflag
= XFS_B_DELWRI
;
364 if (flags
& SYNC_WAIT
)
365 fflag
= 0; /* synchronous overrides all */
367 base_lock_flags
= XFS_ILOCK_SHARED
;
368 if (flags
& (SYNC_DELWRI
| SYNC_CLOSE
)) {
370 * We need the I/O lock if we're going to call any of
371 * the flush/inval routines.
373 base_lock_flags
|= XFS_IOLOCK_SHARED
;
380 mount_locked
= B_TRUE
;
381 vnode_refed
= B_FALSE
;
386 ASSERT(ipointer_in
== B_FALSE
);
387 ASSERT(vnode_refed
== B_FALSE
);
389 lock_flags
= base_lock_flags
;
392 * There were no inodes in the list, just break out
400 * We found another sync thread marker - skip it
402 if (ip
->i_mount
== NULL
) {
407 vp
= XFS_ITOV_NULL(ip
);
410 * If the vnode is gone then this is being torn down,
411 * call reclaim if it is flushed, else let regular flush
412 * code deal with it later in the loop.
416 /* Skip ones already in reclaim */
417 if (ip
->i_flags
& XFS_IRECLAIM
) {
421 if (xfs_ilock_nowait(ip
, XFS_ILOCK_EXCL
) == 0) {
423 } else if ((xfs_ipincount(ip
) == 0) &&
424 xfs_iflock_nowait(ip
)) {
425 IPOINTER_INSERT(ip
, mp
);
427 xfs_finish_reclaim(ip
, 1,
428 XFS_IFLUSH_DELWRI_ELSE_ASYNC
);
431 mount_locked
= B_TRUE
;
432 IPOINTER_REMOVE(ip
, mp
);
434 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
445 if (XFS_FORCED_SHUTDOWN(mp
) && !(flags
& SYNC_CLOSE
)) {
446 XFS_MOUNT_IUNLOCK(mp
);
452 * Try to lock without sleeping. We're out of order with
453 * the inode list lock here, so if we fail we need to drop
454 * the mount lock and try again. If we're called from
455 * bdflush() here, then don't bother.
457 * The inode lock here actually coordinates with the
458 * almost spurious inode lock in xfs_ireclaim() to prevent
459 * the vnode we handle here without a reference from
460 * being freed while we reference it. If we lock the inode
461 * while it's on the mount list here, then the spurious inode
462 * lock in xfs_ireclaim() after the inode is pulled from
463 * the mount list will sleep until we release it here.
464 * This keeps the vnode from being freed while we reference
467 if (xfs_ilock_nowait(ip
, lock_flags
) == 0) {
479 IPOINTER_INSERT(ip
, mp
);
480 xfs_ilock(ip
, lock_flags
);
482 ASSERT(vp
== XFS_ITOV(ip
));
483 ASSERT(ip
->i_mount
== mp
);
485 vnode_refed
= B_TRUE
;
488 /* From here on in the loop we may have a marker record
493 * If we have to flush data or wait for I/O completion
494 * we need to drop the ilock that we currently hold.
495 * If we need to drop the lock, insert a marker if we
496 * have not already done so.
498 if ((flags
& (SYNC_CLOSE
|SYNC_IOWAIT
)) ||
499 ((flags
& SYNC_DELWRI
) && VN_DIRTY(vp
))) {
501 IPOINTER_INSERT(ip
, mp
);
503 xfs_iunlock(ip
, XFS_ILOCK_SHARED
);
505 if (flags
& SYNC_CLOSE
) {
506 /* Shutdown case. Flush and invalidate. */
507 if (XFS_FORCED_SHUTDOWN(mp
))
508 xfs_tosspages(ip
, 0, -1,
511 error
= xfs_flushinval_pages(ip
,
513 } else if ((flags
& SYNC_DELWRI
) && VN_DIRTY(vp
)) {
514 error
= xfs_flush_pages(ip
, 0,
519 * When freezing, we need to wait ensure all I/O (including direct
520 * I/O) is complete to ensure no further data modification can take
521 * place after this point
523 if (flags
& SYNC_IOWAIT
)
526 xfs_ilock(ip
, XFS_ILOCK_SHARED
);
529 if ((flags
& SYNC_ATTR
) &&
530 (ip
->i_update_core
||
531 (ip
->i_itemp
&& ip
->i_itemp
->ili_format
.ilf_fields
))) {
533 IPOINTER_INSERT(ip
, mp
);
535 if (flags
& SYNC_WAIT
) {
537 error
= xfs_iflush(ip
, XFS_IFLUSH_SYNC
);
540 * If we can't acquire the flush lock, then the inode
541 * is already being flushed so don't bother waiting.
543 * If we can lock it then do a delwri flush so we can
544 * combine multiple inode flushes in each disk write.
546 } else if (xfs_iflock_nowait(ip
)) {
547 error
= xfs_iflush(ip
, XFS_IFLUSH_DELWRI
);
548 } else if (bypassed
) {
553 if (lock_flags
!= 0) {
554 xfs_iunlock(ip
, lock_flags
);
559 * If we had to take a reference on the vnode
560 * above, then wait until after we've unlocked
561 * the inode to release the reference. This is
562 * because we can be already holding the inode
563 * lock when IRELE() calls xfs_inactive().
565 * Make sure to drop the mount lock before calling
566 * IRELE() so that we don't trip over ourselves if
567 * we have to go for the mount lock again in the
571 IPOINTER_INSERT(ip
, mp
);
576 vnode_refed
= B_FALSE
;
584 * bail out if the filesystem is corrupted.
586 if (error
== EFSCORRUPTED
) {
589 IPOINTER_REMOVE(ip
, mp
);
591 XFS_MOUNT_IUNLOCK(mp
);
592 ASSERT(ipointer_in
== B_FALSE
);
594 return XFS_ERROR(error
);
597 /* Let other threads have a chance at the mount lock
598 * if we have looped many times without dropping the
601 if ((++preempt
& XFS_PREEMPT_MASK
) == 0) {
603 IPOINTER_INSERT(ip
, mp
);
607 if (mount_locked
== B_FALSE
) {
609 mount_locked
= B_TRUE
;
610 IPOINTER_REMOVE(ip
, mp
);
614 ASSERT(ipointer_in
== B_FALSE
);
617 } while (ip
!= mp
->m_inodes
);
619 XFS_MOUNT_IUNLOCK(mp
);
621 ASSERT(ipointer_in
== B_FALSE
);
624 return XFS_ERROR(last_error
);
628 * xfs sync routine for internal use
630 * This routine supports all of the flags defined for the generic vfs_sync
631 * interface as explained above under xfs_sync.
642 uint log_flags
= XFS_LOG_FORCE
;
644 xfs_buf_log_item_t
*bip
;
647 * Sync out the log. This ensures that the log is periodically
648 * flushed even if there is not enough activity to fill it up.
650 if (flags
& SYNC_WAIT
)
651 log_flags
|= XFS_LOG_SYNC
;
653 xfs_log_force(mp
, (xfs_lsn_t
)0, log_flags
);
655 if (flags
& (SYNC_ATTR
|SYNC_DELWRI
)) {
656 if (flags
& SYNC_BDFLUSH
)
657 xfs_finish_reclaim_all(mp
, 1);
659 error
= xfs_sync_inodes(mp
, flags
, bypassed
);
663 * Flushing out dirty data above probably generated more
664 * log activity, so if this isn't vfs_sync() then flush
667 if (flags
& SYNC_DELWRI
) {
668 xfs_log_force(mp
, (xfs_lsn_t
)0, log_flags
);
671 if (flags
& SYNC_FSDATA
) {
673 * If this is vfs_sync() then only sync the superblock
674 * if we can lock it without sleeping and it is not pinned.
676 if (flags
& SYNC_BDFLUSH
) {
677 bp
= xfs_getsb(mp
, XFS_BUF_TRYLOCK
);
679 bip
= XFS_BUF_FSPRIVATE(bp
,xfs_buf_log_item_t
*);
681 xfs_buf_item_dirty(bip
)) {
682 if (!(XFS_BUF_ISPINNED(bp
))) {
684 error
= xfs_bwrite(mp
, bp
);
693 bp
= xfs_getsb(mp
, 0);
695 * If the buffer is pinned then push on the log so
696 * we won't get stuck waiting in the write for
697 * someone, maybe ourselves, to flush the log.
698 * Even though we just pushed the log above, we
699 * did not have the superblock buffer locked at
700 * that point so it can become pinned in between
703 if (XFS_BUF_ISPINNED(bp
))
704 xfs_log_force(mp
, (xfs_lsn_t
)0, XFS_LOG_FORCE
);
705 if (flags
& SYNC_WAIT
)
709 error
= xfs_bwrite(mp
, bp
);
717 * Now check to see if the log needs a "dummy" transaction.
719 if (!(flags
& SYNC_REMOUNT
) && xfs_log_need_covered(mp
)) {
724 * Put a dummy transaction in the log to tell
725 * recovery that all others are OK.
727 tp
= xfs_trans_alloc(mp
, XFS_TRANS_DUMMY1
);
728 if ((error
= xfs_trans_reserve(tp
, 0,
729 XFS_ICHANGE_LOG_RES(mp
),
731 xfs_trans_cancel(tp
, 0);
736 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
738 xfs_trans_ijoin(tp
, ip
, XFS_ILOCK_EXCL
);
739 xfs_trans_ihold(tp
, ip
);
740 xfs_trans_log_inode(tp
, ip
, XFS_ILOG_CORE
);
741 error
= xfs_trans_commit(tp
, 0);
742 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
743 xfs_log_force(mp
, (xfs_lsn_t
)0, log_flags
);
747 * When shutting down, we need to insure that the AIL is pushed
748 * to disk or the filesystem can appear corrupt from the PROM.
750 if ((flags
& (SYNC_CLOSE
|SYNC_WAIT
)) == (SYNC_CLOSE
|SYNC_WAIT
)) {
751 XFS_bflush(mp
->m_ddev_targp
);
752 if (mp
->m_rtdev_targp
) {
753 XFS_bflush(mp
->m_rtdev_targp
);
757 return XFS_ERROR(last_error
);