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_bmap_btree.h"
31 #include "xfs_alloc_btree.h"
32 #include "xfs_ialloc_btree.h"
33 #include "xfs_btree.h"
34 #include "xfs_dir2_sf.h"
35 #include "xfs_attr_sf.h"
36 #include "xfs_inode.h"
37 #include "xfs_dinode.h"
38 #include "xfs_error.h"
39 #include "xfs_mru_cache.h"
40 #include "xfs_filestream.h"
41 #include "xfs_vnodeops.h"
42 #include "xfs_utils.h"
43 #include "xfs_buf_item.h"
44 #include "xfs_inode_item.h"
47 #include <linux/kthread.h>
48 #include <linux/freezer.h>
51 * Sync all the inodes in the given AG according to the
52 * direction given by the flags.
60 xfs_perag_t
*pag
= &mp
->m_perag
[ag
];
62 uint32_t first_index
= 0;
65 int fflag
= XFS_B_ASYNC
;
67 if (flags
& SYNC_DELWRI
)
69 if (flags
& SYNC_WAIT
)
70 fflag
= 0; /* synchronous overrides all */
74 xfs_inode_t
*ip
= NULL
;
75 int lock_flags
= XFS_ILOCK_SHARED
;
78 * use a gang lookup to find the next inode in the tree
79 * as the tree is sparse and a gang lookup walks to find
80 * the number of objects requested.
82 read_lock(&pag
->pag_ici_lock
);
83 nr_found
= radix_tree_gang_lookup(&pag
->pag_ici_root
,
84 (void**)&ip
, first_index
, 1);
87 read_unlock(&pag
->pag_ici_lock
);
92 * Update the index for the next lookup. Catch overflows
93 * into the next AG range which can occur if we have inodes
94 * in the last block of the AG and we are currently
95 * pointing to the last inode.
97 first_index
= XFS_INO_TO_AGINO(mp
, ip
->i_ino
+ 1);
98 if (first_index
< XFS_INO_TO_AGINO(mp
, ip
->i_ino
)) {
99 read_unlock(&pag
->pag_ici_lock
);
103 /* nothing to sync during shutdown */
104 if (XFS_FORCED_SHUTDOWN(mp
)) {
105 read_unlock(&pag
->pag_ici_lock
);
110 * If we can't get a reference on the inode, it must be
111 * in reclaim. Leave it for the reclaim code to flush.
115 read_unlock(&pag
->pag_ici_lock
);
118 read_unlock(&pag
->pag_ici_lock
);
120 /* avoid new or bad inodes */
121 if (is_bad_inode(inode
) ||
122 xfs_iflags_test(ip
, XFS_INEW
)) {
128 * If we have to flush data or wait for I/O completion
129 * we need to hold the iolock.
131 if ((flags
& SYNC_DELWRI
) && VN_DIRTY(inode
)) {
132 xfs_ilock(ip
, XFS_IOLOCK_SHARED
);
133 lock_flags
|= XFS_IOLOCK_SHARED
;
134 error
= xfs_flush_pages(ip
, 0, -1, fflag
, FI_NONE
);
135 if (flags
& SYNC_IOWAIT
)
138 xfs_ilock(ip
, XFS_ILOCK_SHARED
);
140 if ((flags
& SYNC_ATTR
) && !xfs_inode_clean(ip
)) {
141 if (flags
& SYNC_WAIT
) {
143 if (!xfs_inode_clean(ip
))
144 error
= xfs_iflush(ip
, XFS_IFLUSH_SYNC
);
147 } else if (xfs_iflock_nowait(ip
)) {
148 if (!xfs_inode_clean(ip
))
149 error
= xfs_iflush(ip
, XFS_IFLUSH_DELWRI
);
154 xfs_iput(ip
, lock_flags
);
159 * bail out if the filesystem is corrupted.
161 if (error
== EFSCORRUPTED
)
162 return XFS_ERROR(error
);
177 int lflags
= XFS_LOG_FORCE
;
179 if (mp
->m_flags
& XFS_MOUNT_RDONLY
)
184 if (flags
& SYNC_WAIT
)
185 lflags
|= XFS_LOG_SYNC
;
187 for (i
= 0; i
< mp
->m_sb
.sb_agcount
; i
++) {
188 if (!mp
->m_perag
[i
].pag_ici_init
)
190 error
= xfs_sync_inodes_ag(mp
, i
, flags
);
193 if (error
== EFSCORRUPTED
)
196 if (flags
& SYNC_DELWRI
)
197 xfs_log_force(mp
, 0, lflags
);
199 return XFS_ERROR(last_error
);
203 xfs_commit_dummy_trans(
204 struct xfs_mount
*mp
,
207 struct xfs_inode
*ip
= mp
->m_rootip
;
208 struct xfs_trans
*tp
;
212 * Put a dummy transaction in the log to tell recovery
213 * that all others are OK.
215 tp
= xfs_trans_alloc(mp
, XFS_TRANS_DUMMY1
);
216 error
= xfs_trans_reserve(tp
, 0, XFS_ICHANGE_LOG_RES(mp
), 0, 0, 0);
218 xfs_trans_cancel(tp
, 0);
222 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
224 xfs_trans_ijoin(tp
, ip
, XFS_ILOCK_EXCL
);
225 xfs_trans_ihold(tp
, ip
);
226 xfs_trans_log_inode(tp
, ip
, XFS_ILOG_CORE
);
227 /* XXX(hch): ignoring the error here.. */
228 error
= xfs_trans_commit(tp
, 0);
230 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
232 xfs_log_force(mp
, 0, log_flags
);
238 struct xfs_mount
*mp
,
242 struct xfs_buf_log_item
*bip
;
246 * If this is xfssyncd() then only sync the superblock if we can
247 * lock it without sleeping and it is not pinned.
249 if (flags
& SYNC_BDFLUSH
) {
250 ASSERT(!(flags
& SYNC_WAIT
));
252 bp
= xfs_getsb(mp
, XFS_BUF_TRYLOCK
);
256 bip
= XFS_BUF_FSPRIVATE(bp
, struct xfs_buf_log_item
*);
257 if (!bip
|| !xfs_buf_item_dirty(bip
) || XFS_BUF_ISPINNED(bp
))
260 bp
= xfs_getsb(mp
, 0);
263 * If the buffer is pinned then push on the log so we won't
264 * get stuck waiting in the write for someone, maybe
265 * ourselves, to flush the log.
267 * Even though we just pushed the log above, we did not have
268 * the superblock buffer locked at that point so it can
269 * become pinned in between there and here.
271 if (XFS_BUF_ISPINNED(bp
))
272 xfs_log_force(mp
, 0, XFS_LOG_FORCE
);
276 if (flags
& SYNC_WAIT
)
281 return xfs_bwrite(mp
, bp
);
290 * When remounting a filesystem read-only or freezing the filesystem, we have
291 * two phases to execute. This first phase is syncing the data before we
292 * quiesce the filesystem, and the second is flushing all the inodes out after
293 * we've waited for all the transactions created by the first phase to
294 * complete. The second phase ensures that the inodes are written to their
295 * location on disk rather than just existing in transactions in the log. This
296 * means after a quiesce there is no log replay required to write the inodes to
297 * disk (this is the main difference between a sync and a quiesce).
300 * First stage of freeze - no writers will make progress now we are here,
301 * so we flush delwri and delalloc buffers here, then wait for all I/O to
302 * complete. Data is frozen at that point. Metadata is not frozen,
303 * transactions can still occur here so don't bother flushing the buftarg
304 * because it'll just get dirty again.
308 struct xfs_mount
*mp
)
312 /* push non-blocking */
313 xfs_sync_inodes(mp
, SYNC_DELWRI
|SYNC_BDFLUSH
);
314 XFS_QM_DQSYNC(mp
, SYNC_BDFLUSH
);
315 xfs_filestream_flush(mp
);
318 xfs_sync_inodes(mp
, SYNC_DELWRI
|SYNC_WAIT
|SYNC_IOWAIT
);
319 XFS_QM_DQSYNC(mp
, SYNC_WAIT
);
321 /* write superblock and hoover up shutdown errors */
322 error
= xfs_sync_fsdata(mp
, 0);
324 /* flush data-only devices */
325 if (mp
->m_rtdev_targp
)
326 XFS_bflush(mp
->m_rtdev_targp
);
333 struct xfs_mount
*mp
)
335 int count
= 0, pincount
;
337 xfs_flush_buftarg(mp
->m_ddev_targp
, 0);
338 xfs_reclaim_inodes(mp
, 0, XFS_IFLUSH_DELWRI_ELSE_ASYNC
);
341 * This loop must run at least twice. The first instance of the loop
342 * will flush most meta data but that will generate more meta data
343 * (typically directory updates). Which then must be flushed and
344 * logged before we can write the unmount record.
347 xfs_sync_inodes(mp
, SYNC_ATTR
|SYNC_WAIT
);
348 pincount
= xfs_flush_buftarg(mp
->m_ddev_targp
, 1);
357 * Second stage of a quiesce. The data is already synced, now we have to take
358 * care of the metadata. New transactions are already blocked, so we need to
359 * wait for any remaining transactions to drain out before proceding.
363 struct xfs_mount
*mp
)
367 /* wait for all modifications to complete */
368 while (atomic_read(&mp
->m_active_trans
) > 0)
371 /* flush inodes and push all remaining buffers out to disk */
375 * Just warn here till VFS can correctly support
376 * read-only remount without racing.
378 WARN_ON(atomic_read(&mp
->m_active_trans
) != 0);
380 /* Push the superblock and write an unmount record */
381 error
= xfs_log_sbcount(mp
, 1);
383 xfs_fs_cmn_err(CE_WARN
, mp
,
384 "xfs_attr_quiesce: failed to log sb changes. "
385 "Frozen image may not be consistent.");
386 xfs_log_unmount_write(mp
);
387 xfs_unmountfs_writesb(mp
);
391 * Enqueue a work item to be picked up by the vfs xfssyncd thread.
392 * Doing this has two advantages:
393 * - It saves on stack space, which is tight in certain situations
394 * - It can be used (with care) as a mechanism to avoid deadlocks.
395 * Flushing while allocating in a full filesystem requires both.
398 xfs_syncd_queue_work(
399 struct xfs_mount
*mp
,
401 void (*syncer
)(struct xfs_mount
*, void *))
403 struct bhv_vfs_sync_work
*work
;
405 work
= kmem_alloc(sizeof(struct bhv_vfs_sync_work
), KM_SLEEP
);
406 INIT_LIST_HEAD(&work
->w_list
);
407 work
->w_syncer
= syncer
;
410 spin_lock(&mp
->m_sync_lock
);
411 list_add_tail(&work
->w_list
, &mp
->m_sync_list
);
412 spin_unlock(&mp
->m_sync_lock
);
413 wake_up_process(mp
->m_sync_task
);
417 * Flush delayed allocate data, attempting to free up reserved space
418 * from existing allocations. At this point a new allocation attempt
419 * has failed with ENOSPC and we are in the process of scratching our
420 * heads, looking about for more room...
423 xfs_flush_inode_work(
424 struct xfs_mount
*mp
,
427 struct inode
*inode
= arg
;
428 filemap_flush(inode
->i_mapping
);
436 struct inode
*inode
= VFS_I(ip
);
439 xfs_syncd_queue_work(ip
->i_mount
, inode
, xfs_flush_inode_work
);
440 delay(msecs_to_jiffies(500));
444 * This is the "bigger hammer" version of xfs_flush_inode_work...
445 * (IOW, "If at first you don't succeed, use a Bigger Hammer").
448 xfs_flush_device_work(
449 struct xfs_mount
*mp
,
452 struct inode
*inode
= arg
;
453 sync_blockdev(mp
->m_super
->s_bdev
);
461 struct inode
*inode
= VFS_I(ip
);
464 xfs_syncd_queue_work(ip
->i_mount
, inode
, xfs_flush_device_work
);
465 delay(msecs_to_jiffies(500));
466 xfs_log_force(ip
->i_mount
, (xfs_lsn_t
)0, XFS_LOG_FORCE
|XFS_LOG_SYNC
);
470 * Every sync period we need to unpin all items, reclaim inodes, sync
471 * quota and write out the superblock. We might need to cover the log
472 * to indicate it is idle.
476 struct xfs_mount
*mp
,
481 if (!(mp
->m_flags
& XFS_MOUNT_RDONLY
)) {
482 xfs_log_force(mp
, (xfs_lsn_t
)0, XFS_LOG_FORCE
);
483 xfs_reclaim_inodes(mp
, 0, XFS_IFLUSH_DELWRI_ELSE_ASYNC
);
484 /* dgc: errors ignored here */
485 error
= XFS_QM_DQSYNC(mp
, SYNC_BDFLUSH
);
486 error
= xfs_sync_fsdata(mp
, SYNC_BDFLUSH
);
487 if (xfs_log_need_covered(mp
))
488 error
= xfs_commit_dummy_trans(mp
, XFS_LOG_FORCE
);
491 wake_up(&mp
->m_wait_single_sync_task
);
498 struct xfs_mount
*mp
= arg
;
500 bhv_vfs_sync_work_t
*work
, *n
;
504 timeleft
= xfs_syncd_centisecs
* msecs_to_jiffies(10);
506 timeleft
= schedule_timeout_interruptible(timeleft
);
509 if (kthread_should_stop() && list_empty(&mp
->m_sync_list
))
512 spin_lock(&mp
->m_sync_lock
);
514 * We can get woken by laptop mode, to do a sync -
515 * that's the (only!) case where the list would be
516 * empty with time remaining.
518 if (!timeleft
|| list_empty(&mp
->m_sync_list
)) {
520 timeleft
= xfs_syncd_centisecs
*
521 msecs_to_jiffies(10);
522 INIT_LIST_HEAD(&mp
->m_sync_work
.w_list
);
523 list_add_tail(&mp
->m_sync_work
.w_list
,
526 list_for_each_entry_safe(work
, n
, &mp
->m_sync_list
, w_list
)
527 list_move(&work
->w_list
, &tmp
);
528 spin_unlock(&mp
->m_sync_lock
);
530 list_for_each_entry_safe(work
, n
, &tmp
, w_list
) {
531 (*work
->w_syncer
)(mp
, work
->w_data
);
532 list_del(&work
->w_list
);
533 if (work
== &mp
->m_sync_work
)
544 struct xfs_mount
*mp
)
546 mp
->m_sync_work
.w_syncer
= xfs_sync_worker
;
547 mp
->m_sync_work
.w_mount
= mp
;
548 mp
->m_sync_task
= kthread_run(xfssyncd
, mp
, "xfssyncd");
549 if (IS_ERR(mp
->m_sync_task
))
550 return -PTR_ERR(mp
->m_sync_task
);
556 struct xfs_mount
*mp
)
558 kthread_stop(mp
->m_sync_task
);
567 xfs_perag_t
*pag
= xfs_get_perag(ip
->i_mount
, ip
->i_ino
);
569 /* The hash lock here protects a thread in xfs_iget_core from
570 * racing with us on linking the inode back with a vnode.
571 * Once we have the XFS_IRECLAIM flag set it will not touch
574 write_lock(&pag
->pag_ici_lock
);
575 spin_lock(&ip
->i_flags_lock
);
576 if (__xfs_iflags_test(ip
, XFS_IRECLAIM
) ||
577 !__xfs_iflags_test(ip
, XFS_IRECLAIMABLE
)) {
578 spin_unlock(&ip
->i_flags_lock
);
579 write_unlock(&pag
->pag_ici_lock
);
582 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
586 __xfs_iflags_set(ip
, XFS_IRECLAIM
);
587 spin_unlock(&ip
->i_flags_lock
);
588 write_unlock(&pag
->pag_ici_lock
);
589 xfs_put_perag(ip
->i_mount
, pag
);
592 * If the inode is still dirty, then flush it out. If the inode
593 * is not in the AIL, then it will be OK to flush it delwri as
594 * long as xfs_iflush() does not keep any references to the inode.
595 * We leave that decision up to xfs_iflush() since it has the
596 * knowledge of whether it's OK to simply do a delwri flush of
597 * the inode or whether we need to wait until the inode is
598 * pulled from the AIL.
599 * We get the flush lock regardless, though, just to make sure
600 * we don't free it while it is being flushed.
603 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
608 * In the case of a forced shutdown we rely on xfs_iflush() to
609 * wait for the inode to be unpinned before returning an error.
611 if (!is_bad_inode(VFS_I(ip
)) && xfs_iflush(ip
, sync_mode
) == 0) {
612 /* synchronize with xfs_iflush_done */
617 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
623 * We set the inode flag atomically with the radix tree tag.
624 * Once we get tag lookups on the radix tree, this inode flag
628 xfs_inode_set_reclaim_tag(
631 xfs_mount_t
*mp
= ip
->i_mount
;
632 xfs_perag_t
*pag
= xfs_get_perag(mp
, ip
->i_ino
);
634 read_lock(&pag
->pag_ici_lock
);
635 spin_lock(&ip
->i_flags_lock
);
636 radix_tree_tag_set(&pag
->pag_ici_root
,
637 XFS_INO_TO_AGINO(mp
, ip
->i_ino
), XFS_ICI_RECLAIM_TAG
);
638 __xfs_iflags_set(ip
, XFS_IRECLAIMABLE
);
639 spin_unlock(&ip
->i_flags_lock
);
640 read_unlock(&pag
->pag_ici_lock
);
641 xfs_put_perag(mp
, pag
);
645 __xfs_inode_clear_reclaim_tag(
650 radix_tree_tag_clear(&pag
->pag_ici_root
,
651 XFS_INO_TO_AGINO(mp
, ip
->i_ino
), XFS_ICI_RECLAIM_TAG
);
655 xfs_inode_clear_reclaim_tag(
658 xfs_mount_t
*mp
= ip
->i_mount
;
659 xfs_perag_t
*pag
= xfs_get_perag(mp
, ip
->i_ino
);
661 read_lock(&pag
->pag_ici_lock
);
662 spin_lock(&ip
->i_flags_lock
);
663 __xfs_inode_clear_reclaim_tag(mp
, pag
, ip
);
664 spin_unlock(&ip
->i_flags_lock
);
665 read_unlock(&pag
->pag_ici_lock
);
666 xfs_put_perag(mp
, pag
);
671 xfs_reclaim_inodes_ag(
677 xfs_inode_t
*ip
= NULL
;
678 xfs_perag_t
*pag
= &mp
->m_perag
[ag
];
680 uint32_t first_index
;
688 * use a gang lookup to find the next inode in the tree
689 * as the tree is sparse and a gang lookup walks to find
690 * the number of objects requested.
692 read_lock(&pag
->pag_ici_lock
);
693 nr_found
= radix_tree_gang_lookup_tag(&pag
->pag_ici_root
,
694 (void**)&ip
, first_index
, 1,
695 XFS_ICI_RECLAIM_TAG
);
698 read_unlock(&pag
->pag_ici_lock
);
703 * Update the index for the next lookup. Catch overflows
704 * into the next AG range which can occur if we have inodes
705 * in the last block of the AG and we are currently
706 * pointing to the last inode.
708 first_index
= XFS_INO_TO_AGINO(mp
, ip
->i_ino
+ 1);
709 if (first_index
< XFS_INO_TO_AGINO(mp
, ip
->i_ino
)) {
710 read_unlock(&pag
->pag_ici_lock
);
714 /* ignore if already under reclaim */
715 if (xfs_iflags_test(ip
, XFS_IRECLAIM
)) {
716 read_unlock(&pag
->pag_ici_lock
);
721 if (!xfs_ilock_nowait(ip
, XFS_ILOCK_EXCL
)) {
722 read_unlock(&pag
->pag_ici_lock
);
725 if (xfs_ipincount(ip
) ||
726 !xfs_iflock_nowait(ip
)) {
727 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
728 read_unlock(&pag
->pag_ici_lock
);
732 read_unlock(&pag
->pag_ici_lock
);
735 * hmmm - this is an inode already in reclaim. Do
736 * we even bother catching it here?
738 if (xfs_reclaim_inode(ip
, noblock
, mode
))
758 for (i
= 0; i
< mp
->m_sb
.sb_agcount
; i
++) {
759 if (!mp
->m_perag
[i
].pag_ici_init
)
761 xfs_reclaim_inodes_ag(mp
, i
, noblock
, mode
);