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 */
374 ASSERT_ALWAYS(atomic_read(&mp
->m_active_trans
) == 0);
376 /* Push the superblock and write an unmount record */
377 error
= xfs_log_sbcount(mp
, 1);
379 xfs_fs_cmn_err(CE_WARN
, mp
,
380 "xfs_attr_quiesce: failed to log sb changes. "
381 "Frozen image may not be consistent.");
382 xfs_log_unmount_write(mp
);
383 xfs_unmountfs_writesb(mp
);
387 * Enqueue a work item to be picked up by the vfs xfssyncd thread.
388 * Doing this has two advantages:
389 * - It saves on stack space, which is tight in certain situations
390 * - It can be used (with care) as a mechanism to avoid deadlocks.
391 * Flushing while allocating in a full filesystem requires both.
394 xfs_syncd_queue_work(
395 struct xfs_mount
*mp
,
397 void (*syncer
)(struct xfs_mount
*, void *))
399 struct bhv_vfs_sync_work
*work
;
401 work
= kmem_alloc(sizeof(struct bhv_vfs_sync_work
), KM_SLEEP
);
402 INIT_LIST_HEAD(&work
->w_list
);
403 work
->w_syncer
= syncer
;
406 spin_lock(&mp
->m_sync_lock
);
407 list_add_tail(&work
->w_list
, &mp
->m_sync_list
);
408 spin_unlock(&mp
->m_sync_lock
);
409 wake_up_process(mp
->m_sync_task
);
413 * Flush delayed allocate data, attempting to free up reserved space
414 * from existing allocations. At this point a new allocation attempt
415 * has failed with ENOSPC and we are in the process of scratching our
416 * heads, looking about for more room...
419 xfs_flush_inode_work(
420 struct xfs_mount
*mp
,
423 struct inode
*inode
= arg
;
424 filemap_flush(inode
->i_mapping
);
432 struct inode
*inode
= VFS_I(ip
);
435 xfs_syncd_queue_work(ip
->i_mount
, inode
, xfs_flush_inode_work
);
436 delay(msecs_to_jiffies(500));
440 * This is the "bigger hammer" version of xfs_flush_inode_work...
441 * (IOW, "If at first you don't succeed, use a Bigger Hammer").
444 xfs_flush_device_work(
445 struct xfs_mount
*mp
,
448 struct inode
*inode
= arg
;
449 sync_blockdev(mp
->m_super
->s_bdev
);
457 struct inode
*inode
= VFS_I(ip
);
460 xfs_syncd_queue_work(ip
->i_mount
, inode
, xfs_flush_device_work
);
461 delay(msecs_to_jiffies(500));
462 xfs_log_force(ip
->i_mount
, (xfs_lsn_t
)0, XFS_LOG_FORCE
|XFS_LOG_SYNC
);
466 * Every sync period we need to unpin all items, reclaim inodes, sync
467 * quota and write out the superblock. We might need to cover the log
468 * to indicate it is idle.
472 struct xfs_mount
*mp
,
477 if (!(mp
->m_flags
& XFS_MOUNT_RDONLY
)) {
478 xfs_log_force(mp
, (xfs_lsn_t
)0, XFS_LOG_FORCE
);
479 xfs_reclaim_inodes(mp
, 0, XFS_IFLUSH_DELWRI_ELSE_ASYNC
);
480 /* dgc: errors ignored here */
481 error
= XFS_QM_DQSYNC(mp
, SYNC_BDFLUSH
);
482 error
= xfs_sync_fsdata(mp
, SYNC_BDFLUSH
);
483 if (xfs_log_need_covered(mp
))
484 error
= xfs_commit_dummy_trans(mp
, XFS_LOG_FORCE
);
487 wake_up(&mp
->m_wait_single_sync_task
);
494 struct xfs_mount
*mp
= arg
;
496 bhv_vfs_sync_work_t
*work
, *n
;
500 timeleft
= xfs_syncd_centisecs
* msecs_to_jiffies(10);
502 timeleft
= schedule_timeout_interruptible(timeleft
);
505 if (kthread_should_stop() && list_empty(&mp
->m_sync_list
))
508 spin_lock(&mp
->m_sync_lock
);
510 * We can get woken by laptop mode, to do a sync -
511 * that's the (only!) case where the list would be
512 * empty with time remaining.
514 if (!timeleft
|| list_empty(&mp
->m_sync_list
)) {
516 timeleft
= xfs_syncd_centisecs
*
517 msecs_to_jiffies(10);
518 INIT_LIST_HEAD(&mp
->m_sync_work
.w_list
);
519 list_add_tail(&mp
->m_sync_work
.w_list
,
522 list_for_each_entry_safe(work
, n
, &mp
->m_sync_list
, w_list
)
523 list_move(&work
->w_list
, &tmp
);
524 spin_unlock(&mp
->m_sync_lock
);
526 list_for_each_entry_safe(work
, n
, &tmp
, w_list
) {
527 (*work
->w_syncer
)(mp
, work
->w_data
);
528 list_del(&work
->w_list
);
529 if (work
== &mp
->m_sync_work
)
540 struct xfs_mount
*mp
)
542 mp
->m_sync_work
.w_syncer
= xfs_sync_worker
;
543 mp
->m_sync_work
.w_mount
= mp
;
544 mp
->m_sync_task
= kthread_run(xfssyncd
, mp
, "xfssyncd");
545 if (IS_ERR(mp
->m_sync_task
))
546 return -PTR_ERR(mp
->m_sync_task
);
552 struct xfs_mount
*mp
)
554 kthread_stop(mp
->m_sync_task
);
563 xfs_perag_t
*pag
= xfs_get_perag(ip
->i_mount
, ip
->i_ino
);
565 /* The hash lock here protects a thread in xfs_iget_core from
566 * racing with us on linking the inode back with a vnode.
567 * Once we have the XFS_IRECLAIM flag set it will not touch
570 write_lock(&pag
->pag_ici_lock
);
571 spin_lock(&ip
->i_flags_lock
);
572 if (__xfs_iflags_test(ip
, XFS_IRECLAIM
) ||
573 !__xfs_iflags_test(ip
, XFS_IRECLAIMABLE
)) {
574 spin_unlock(&ip
->i_flags_lock
);
575 write_unlock(&pag
->pag_ici_lock
);
578 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
582 __xfs_iflags_set(ip
, XFS_IRECLAIM
);
583 spin_unlock(&ip
->i_flags_lock
);
584 write_unlock(&pag
->pag_ici_lock
);
585 xfs_put_perag(ip
->i_mount
, pag
);
588 * If the inode is still dirty, then flush it out. If the inode
589 * is not in the AIL, then it will be OK to flush it delwri as
590 * long as xfs_iflush() does not keep any references to the inode.
591 * We leave that decision up to xfs_iflush() since it has the
592 * knowledge of whether it's OK to simply do a delwri flush of
593 * the inode or whether we need to wait until the inode is
594 * pulled from the AIL.
595 * We get the flush lock regardless, though, just to make sure
596 * we don't free it while it is being flushed.
599 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
604 * In the case of a forced shutdown we rely on xfs_iflush() to
605 * wait for the inode to be unpinned before returning an error.
607 if (!is_bad_inode(VFS_I(ip
)) && xfs_iflush(ip
, sync_mode
) == 0) {
608 /* synchronize with xfs_iflush_done */
613 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
619 * We set the inode flag atomically with the radix tree tag.
620 * Once we get tag lookups on the radix tree, this inode flag
624 xfs_inode_set_reclaim_tag(
627 xfs_mount_t
*mp
= ip
->i_mount
;
628 xfs_perag_t
*pag
= xfs_get_perag(mp
, ip
->i_ino
);
630 read_lock(&pag
->pag_ici_lock
);
631 spin_lock(&ip
->i_flags_lock
);
632 radix_tree_tag_set(&pag
->pag_ici_root
,
633 XFS_INO_TO_AGINO(mp
, ip
->i_ino
), XFS_ICI_RECLAIM_TAG
);
634 __xfs_iflags_set(ip
, XFS_IRECLAIMABLE
);
635 spin_unlock(&ip
->i_flags_lock
);
636 read_unlock(&pag
->pag_ici_lock
);
637 xfs_put_perag(mp
, pag
);
641 __xfs_inode_clear_reclaim_tag(
646 radix_tree_tag_clear(&pag
->pag_ici_root
,
647 XFS_INO_TO_AGINO(mp
, ip
->i_ino
), XFS_ICI_RECLAIM_TAG
);
651 xfs_inode_clear_reclaim_tag(
654 xfs_mount_t
*mp
= ip
->i_mount
;
655 xfs_perag_t
*pag
= xfs_get_perag(mp
, ip
->i_ino
);
657 read_lock(&pag
->pag_ici_lock
);
658 spin_lock(&ip
->i_flags_lock
);
659 __xfs_inode_clear_reclaim_tag(mp
, pag
, ip
);
660 spin_unlock(&ip
->i_flags_lock
);
661 read_unlock(&pag
->pag_ici_lock
);
662 xfs_put_perag(mp
, pag
);
667 xfs_reclaim_inodes_ag(
673 xfs_inode_t
*ip
= NULL
;
674 xfs_perag_t
*pag
= &mp
->m_perag
[ag
];
676 uint32_t first_index
;
684 * use a gang lookup to find the next inode in the tree
685 * as the tree is sparse and a gang lookup walks to find
686 * the number of objects requested.
688 read_lock(&pag
->pag_ici_lock
);
689 nr_found
= radix_tree_gang_lookup_tag(&pag
->pag_ici_root
,
690 (void**)&ip
, first_index
, 1,
691 XFS_ICI_RECLAIM_TAG
);
694 read_unlock(&pag
->pag_ici_lock
);
699 * Update the index for the next lookup. Catch overflows
700 * into the next AG range which can occur if we have inodes
701 * in the last block of the AG and we are currently
702 * pointing to the last inode.
704 first_index
= XFS_INO_TO_AGINO(mp
, ip
->i_ino
+ 1);
705 if (first_index
< XFS_INO_TO_AGINO(mp
, ip
->i_ino
)) {
706 read_unlock(&pag
->pag_ici_lock
);
710 /* ignore if already under reclaim */
711 if (xfs_iflags_test(ip
, XFS_IRECLAIM
)) {
712 read_unlock(&pag
->pag_ici_lock
);
717 if (!xfs_ilock_nowait(ip
, XFS_ILOCK_EXCL
)) {
718 read_unlock(&pag
->pag_ici_lock
);
721 if (xfs_ipincount(ip
) ||
722 !xfs_iflock_nowait(ip
)) {
723 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
724 read_unlock(&pag
->pag_ici_lock
);
728 read_unlock(&pag
->pag_ici_lock
);
731 * hmmm - this is an inode already in reclaim. Do
732 * we even bother catching it here?
734 if (xfs_reclaim_inode(ip
, noblock
, mode
))
754 for (i
= 0; i
< mp
->m_sb
.sb_agcount
; i
++) {
755 if (!mp
->m_perag
[i
].pag_ici_init
)
757 xfs_reclaim_inodes_ag(mp
, i
, noblock
, mode
);