2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
7 * of the GNU General Public License v.2.
10 #include <linux/sched.h>
11 #include <linux/slab.h>
12 #include <linux/spinlock.h>
13 #include <linux/completion.h>
14 #include <linux/buffer_head.h>
15 #include <linux/kthread.h>
16 #include <linux/delay.h>
17 #include <linux/gfs2_ondisk.h>
20 #include "lm_interface.h"
31 /* This uses schedule_timeout() instead of msleep() because it's good for
32 the daemons to wake up more often than the timeout when unmounting so
33 the user's unmount doesn't sit there forever.
35 The kthread functions used to start these daemons block and flush signals. */
38 * gfs2_scand - Look for cached glocks and inodes to toss from memory
39 * @sdp: Pointer to GFS2 superblock
41 * One of these daemons runs, finding candidates to add to sd_reclaim_list.
45 int gfs2_scand(void *data)
47 struct gfs2_sbd *sdp = data;
50 while (!kthread_should_stop()) {
51 gfs2_scand_internal(sdp);
52 t = gfs2_tune_get(sdp, gt_scand_secs) * HZ;
53 schedule_timeout_interruptible(t);
60 * gfs2_glockd - Reclaim unused glock structures
61 * @sdp: Pointer to GFS2 superblock
63 * One or more of these daemons run, reclaiming glocks on sd_reclaim_list.
64 * Number of daemons can be set by user, with num_glockd mount option.
67 int gfs2_glockd(void *data)
69 struct gfs2_sbd *sdp = data;
71 while (!kthread_should_stop()) {
72 while (atomic_read(&sdp->sd_reclaim_count))
73 gfs2_reclaim_glock(sdp);
75 wait_event_interruptible(sdp->sd_reclaim_wq,
76 (atomic_read(&sdp->sd_reclaim_count) ||
77 kthread_should_stop()));
84 * gfs2_recoverd - Recover dead machine's journals
85 * @sdp: Pointer to GFS2 superblock
89 int gfs2_recoverd(void *data)
91 struct gfs2_sbd *sdp = data;
94 while (!kthread_should_stop()) {
95 gfs2_check_journals(sdp);
96 t = gfs2_tune_get(sdp, gt_recoverd_secs) * HZ;
97 schedule_timeout_interruptible(t);
104 * gfs2_logd - Update log tail as Active Items get flushed to in-place blocks
105 * @sdp: Pointer to GFS2 superblock
107 * Also, periodically check to make sure that we're using the most recent
111 int gfs2_logd(void *data)
113 struct gfs2_sbd *sdp = data;
114 struct gfs2_holder ji_gh;
117 while (!kthread_should_stop()) {
118 /* Advance the log tail */
120 t = sdp->sd_log_flush_time +
121 gfs2_tune_get(sdp, gt_log_flush_secs) * HZ;
123 gfs2_ail1_empty(sdp, DIO_ALL);
125 if (time_after_eq(jiffies, t)) {
126 gfs2_log_flush(sdp, NULL);
127 sdp->sd_log_flush_time = jiffies;
130 /* Check for latest journal index */
132 t = sdp->sd_jindex_refresh_time +
133 gfs2_tune_get(sdp, gt_jindex_refresh_secs) * HZ;
135 if (time_after_eq(jiffies, t)) {
136 if (!gfs2_jindex_hold(sdp, &ji_gh))
137 gfs2_glock_dq_uninit(&ji_gh);
138 sdp->sd_jindex_refresh_time = jiffies;
141 t = gfs2_tune_get(sdp, gt_logd_secs) * HZ;
142 schedule_timeout_interruptible(t);
149 * gfs2_quotad - Write cached quota changes into the quota file
150 * @sdp: Pointer to GFS2 superblock
154 int gfs2_quotad(void *data)
156 struct gfs2_sbd *sdp = data;
160 while (!kthread_should_stop()) {
161 /* Update the master statfs file */
163 t = sdp->sd_statfs_sync_time +
164 gfs2_tune_get(sdp, gt_statfs_quantum) * HZ;
166 if (time_after_eq(jiffies, t)) {
167 error = gfs2_statfs_sync(sdp);
170 !test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
171 fs_err(sdp, "quotad: (1) error=%d\n", error);
172 sdp->sd_statfs_sync_time = jiffies;
175 /* Update quota file */
177 t = sdp->sd_quota_sync_time +
178 gfs2_tune_get(sdp, gt_quota_quantum) * HZ;
180 if (time_after_eq(jiffies, t)) {
181 error = gfs2_quota_sync(sdp);
184 !test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
185 fs_err(sdp, "quotad: (2) error=%d\n", error);
186 sdp->sd_quota_sync_time = jiffies;
189 gfs2_quota_scan(sdp);
191 t = gfs2_tune_get(sdp, gt_quotad_secs) * HZ;
192 schedule_timeout_interruptible(t);
199 * gfs2_inoded - Deallocate unlinked inodes
200 * @sdp: Pointer to GFS2 superblock
204 int gfs2_inoded(void *data)
206 struct gfs2_sbd *sdp = data;
210 while (!kthread_should_stop()) {
211 error = gfs2_unlinked_dealloc(sdp);
214 !test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
215 fs_err(sdp, "inoded: error = %d\n", error);
217 t = gfs2_tune_get(sdp, gt_inoded_secs) * HZ;
218 schedule_timeout_interruptible(t);