Annotation of sys/kern/vfs_sync.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: vfs_sync.c,v 1.43 2007/06/01 23:47:56 deraadt Exp $ */
2:
3: /*
4: * Portions of this code are:
5: *
6: * Copyright (c) 1989, 1993
7: * The Regents of the University of California. All rights reserved.
8: * (c) UNIX System Laboratories, Inc.
9: * All or some portions of this file are derived from material licensed
10: * to the University of California by American Telephone and Telegraph
11: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
12: * the permission of UNIX System Laboratories, Inc.
13: *
14: * Redistribution and use in source and binary forms, with or without
15: * modification, are permitted provided that the following conditions
16: * are met:
17: * 1. Redistributions of source code must retain the above copyright
18: * notice, this list of conditions and the following disclaimer.
19: * 2. Redistributions in binary form must reproduce the above copyright
20: * notice, this list of conditions and the following disclaimer in the
21: * documentation and/or other materials provided with the distribution.
22: * 3. Neither the name of the University nor the names of its contributors
23: * may be used to endorse or promote products derived from this software
24: * without specific prior written permission.
25: *
26: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36: * SUCH DAMAGE.
37: */
38:
39: /*
40: * Syncer daemon
41: */
42:
43: #include <sys/queue.h>
44: #include <sys/param.h>
45: #include <sys/systm.h>
46: #include <sys/proc.h>
47: #include <sys/mount.h>
48: #include <sys/vnode.h>
49: #include <sys/buf.h>
50: #include <sys/malloc.h>
51:
52: #include <sys/kernel.h>
53: #include <sys/sched.h>
54:
55: #ifdef FFS_SOFTUPDATES
56: int softdep_process_worklist(struct mount *);
57: #endif
58:
59: /*
60: * The workitem queue.
61: */
62: #define SYNCER_MAXDELAY 32 /* maximum sync delay time */
63: #define SYNCER_DEFAULT 30 /* default sync delay time */
64: int syncer_maxdelay = SYNCER_MAXDELAY; /* maximum delay time */
65: time_t syncdelay = SYNCER_DEFAULT; /* time to delay syncing vnodes */
66:
67: int rushjob = 0; /* number of slots to run ASAP */
68: int stat_rush_requests = 0; /* number of rush requests */
69:
70: static int syncer_delayno = 0;
71: static long syncer_mask;
72: LIST_HEAD(synclist, vnode);
73: static struct synclist *syncer_workitem_pending;
74:
75: struct proc *syncerproc;
76:
77: /*
78: * The workitem queue.
79: *
80: * It is useful to delay writes of file data and filesystem metadata
81: * for tens of seconds so that quickly created and deleted files need
82: * not waste disk bandwidth being created and removed. To realize this,
83: * we append vnodes to a "workitem" queue. When running with a soft
84: * updates implementation, most pending metadata dependencies should
85: * not wait for more than a few seconds. Thus, mounted block devices
86: * are delayed only about half the time that file data is delayed.
87: * Similarly, directory updates are more critical, so are only delayed
88: * about a third the time that file data is delayed. Thus, there are
89: * SYNCER_MAXDELAY queues that are processed round-robin at a rate of
90: * one each second (driven off the filesystem syncer process). The
91: * syncer_delayno variable indicates the next queue that is to be processed.
92: * Items that need to be processed soon are placed in this queue:
93: *
94: * syncer_workitem_pending[syncer_delayno]
95: *
96: * A delay of fifteen seconds is done by placing the request fifteen
97: * entries later in the queue:
98: *
99: * syncer_workitem_pending[(syncer_delayno + 15) & syncer_mask]
100: *
101: */
102:
103: void
104: vn_initialize_syncerd(void)
105: {
106: syncer_workitem_pending = hashinit(syncer_maxdelay, M_VNODE, M_WAITOK,
107: &syncer_mask);
108: syncer_maxdelay = syncer_mask + 1;
109: }
110:
111: /*
112: * Add an item to the syncer work queue.
113: */
114: void
115: vn_syncer_add_to_worklist(struct vnode *vp, int delay)
116: {
117: int s, slot;
118:
119: if (delay > syncer_maxdelay - 2)
120: delay = syncer_maxdelay - 2;
121: slot = (syncer_delayno + delay) & syncer_mask;
122:
123: s = splbio();
124: if (vp->v_bioflag & VBIOONSYNCLIST)
125: LIST_REMOVE(vp, v_synclist);
126:
127: vp->v_bioflag |= VBIOONSYNCLIST;
128: LIST_INSERT_HEAD(&syncer_workitem_pending[slot], vp, v_synclist);
129: splx(s);
130: }
131:
132: /*
133: * System filesystem synchronizer daemon.
134: */
135: void
136: sched_sync(struct proc *p)
137: {
138: struct synclist *slp;
139: struct vnode *vp;
140: long starttime;
141: int s;
142:
143: syncerproc = curproc;
144:
145: for (;;) {
146: starttime = time_second;
147:
148: /*
149: * Push files whose dirty time has expired.
150: */
151: s = splbio();
152: slp = &syncer_workitem_pending[syncer_delayno];
153:
154: syncer_delayno += 1;
155: if (syncer_delayno == syncer_maxdelay)
156: syncer_delayno = 0;
157:
158: while ((vp = LIST_FIRST(slp)) != NULL) {
159: if (vget(vp, LK_EXCLUSIVE | LK_NOWAIT, p)) {
160: /*
161: * If we fail to get the lock, we move this
162: * vnode one second ahead in time.
163: * XXX - no good, but the best we can do.
164: */
165: vn_syncer_add_to_worklist(vp, 1);
166: continue;
167: }
168: splx(s);
169: (void) VOP_FSYNC(vp, p->p_ucred, MNT_LAZY, p);
170: vput(vp);
171: s = splbio();
172: if (LIST_FIRST(slp) == vp) {
173: /*
174: * Note: disk vps can remain on the
175: * worklist too with no dirty blocks, but
176: * since sync_fsync() moves it to a different
177: * slot we are safe.
178: */
179: #ifdef DIAGNOSTIC
180: if (LIST_FIRST(&vp->v_dirtyblkhd) == NULL &&
181: vp->v_type != VBLK) {
182: vprint("fsync failed", vp);
183: if (vp->v_mount != NULL)
184: printf("mounted on: %s\n",
185: vp->v_mount->mnt_stat.f_mntonname);
186: panic("sched_sync: fsync failed");
187: }
188: #endif /* DIAGNOSTIC */
189: /*
190: * Put us back on the worklist. The worklist
191: * routine will remove us from our current
192: * position and then add us back in at a later
193: * position.
194: */
195: vn_syncer_add_to_worklist(vp, syncdelay);
196: }
197: }
198:
199: splx(s);
200:
201: #ifdef FFS_SOFTUPDATES
202: /*
203: * Do soft update processing.
204: */
205: softdep_process_worklist(NULL);
206: #endif
207:
208: /*
209: * The variable rushjob allows the kernel to speed up the
210: * processing of the filesystem syncer process. A rushjob
211: * value of N tells the filesystem syncer to process the next
212: * N seconds worth of work on its queue ASAP. Currently rushjob
213: * is used by the soft update code to speed up the filesystem
214: * syncer process when the incore state is getting so far
215: * ahead of the disk that the kernel memory pool is being
216: * threatened with exhaustion.
217: */
218: if (rushjob > 0) {
219: rushjob -= 1;
220: continue;
221: }
222: /*
223: * If it has taken us less than a second to process the
224: * current work, then wait. Otherwise start right over
225: * again. We can still lose time if any single round
226: * takes more than two seconds, but it does not really
227: * matter as we are just trying to generally pace the
228: * filesystem activity.
229: */
230: if (time_second == starttime)
231: tsleep(&lbolt, PPAUSE, "syncer", 0);
232: }
233: }
234:
235: /*
236: * Request the syncer daemon to speed up its work.
237: * We never push it to speed up more than half of its
238: * normal turn time, otherwise it could take over the cpu.
239: */
240: int
241: speedup_syncer(void)
242: {
243: int s;
244:
245: SCHED_LOCK(s);
246: if (syncerproc && syncerproc->p_wchan == &lbolt)
247: setrunnable(syncerproc);
248: SCHED_UNLOCK(s);
249: if (rushjob < syncdelay / 2) {
250: rushjob += 1;
251: stat_rush_requests += 1;
252: return 1;
253: }
254: return 0;
255: }
256:
257: /*
258: * Routine to create and manage a filesystem syncer vnode.
259: */
260: #define sync_close nullop
261: int sync_fsync(void *);
262: int sync_inactive(void *);
263: #define sync_reclaim nullop
264: #define sync_lock vop_generic_lock
265: #define sync_unlock vop_generic_unlock
266: int sync_print(void *);
267: #define sync_islocked vop_generic_islocked
268:
269: int (**sync_vnodeop_p)(void *);
270: struct vnodeopv_entry_desc sync_vnodeop_entries[] = {
271: { &vop_default_desc, vn_default_error },
272: { &vop_close_desc, sync_close }, /* close */
273: { &vop_fsync_desc, sync_fsync }, /* fsync */
274: { &vop_inactive_desc, sync_inactive }, /* inactive */
275: { &vop_reclaim_desc, sync_reclaim }, /* reclaim */
276: { &vop_lock_desc, sync_lock }, /* lock */
277: { &vop_unlock_desc, sync_unlock }, /* unlock */
278: { &vop_print_desc, sync_print }, /* print */
279: { &vop_islocked_desc, sync_islocked }, /* islocked */
280: { (struct vnodeop_desc*)NULL, (int(*)(void *))NULL }
281: };
282: struct vnodeopv_desc sync_vnodeop_opv_desc = {
283: &sync_vnodeop_p, sync_vnodeop_entries
284: };
285:
286: /*
287: * Create a new filesystem syncer vnode for the specified mount point.
288: */
289: int
290: vfs_allocate_syncvnode(struct mount *mp)
291: {
292: struct vnode *vp;
293: static long start, incr, next;
294: int error;
295:
296: /* Allocate a new vnode */
297: if ((error = getnewvnode(VT_VFS, mp, sync_vnodeop_p, &vp)) != 0) {
298: mp->mnt_syncer = NULL;
299: return (error);
300: }
301: vp->v_writecount = 1;
302: vp->v_type = VNON;
303: /*
304: * Place the vnode onto the syncer worklist. We attempt to
305: * scatter them about on the list so that they will go off
306: * at evenly distributed times even if all the filesystems
307: * are mounted at once.
308: */
309: next += incr;
310: if (next == 0 || next > syncer_maxdelay) {
311: start /= 2;
312: incr /= 2;
313: if (start == 0) {
314: start = syncer_maxdelay / 2;
315: incr = syncer_maxdelay;
316: }
317: next = start;
318: }
319: vn_syncer_add_to_worklist(vp, next);
320: mp->mnt_syncer = vp;
321: return (0);
322: }
323:
324: /*
325: * Do a lazy sync of the filesystem.
326: */
327: int
328: sync_fsync(void *v)
329: {
330: struct vop_fsync_args *ap = v;
331: struct vnode *syncvp = ap->a_vp;
332: struct mount *mp = syncvp->v_mount;
333: int asyncflag;
334:
335: /*
336: * We only need to do something if this is a lazy evaluation.
337: */
338: if (ap->a_waitfor != MNT_LAZY)
339: return (0);
340:
341: /*
342: * Move ourselves to the back of the sync list.
343: */
344: vn_syncer_add_to_worklist(syncvp, syncdelay);
345:
346: /*
347: * Walk the list of vnodes pushing all that are dirty and
348: * not already on the sync list.
349: */
350: if (vfs_busy(mp, VB_READ|VB_NOWAIT) == 0) {
351: asyncflag = mp->mnt_flag & MNT_ASYNC;
352: mp->mnt_flag &= ~MNT_ASYNC;
353: VFS_SYNC(mp, MNT_LAZY, ap->a_cred, ap->a_p);
354: if (asyncflag)
355: mp->mnt_flag |= MNT_ASYNC;
356: vfs_unbusy(mp);
357: }
358:
359: return (0);
360: }
361:
362: /*
363: * The syncer vnode is no longer needed and is being decommissioned.
364: */
365: int
366: sync_inactive(void *v)
367: {
368: struct vop_inactive_args *ap = v;
369:
370: struct vnode *vp = ap->a_vp;
371: int s;
372:
373: if (vp->v_usecount == 0) {
374: VOP_UNLOCK(vp, 0, ap->a_p);
375: return (0);
376: }
377:
378: vp->v_mount->mnt_syncer = NULL;
379:
380: s = splbio();
381:
382: LIST_REMOVE(vp, v_synclist);
383: vp->v_bioflag &= ~VBIOONSYNCLIST;
384:
385: splx(s);
386:
387: vp->v_writecount = 0;
388: vput(vp);
389:
390: return (0);
391: }
392:
393: /*
394: * Print out a syncer vnode.
395: */
396: int
397: sync_print(void *v)
398: {
399: printf("syncer vnode\n");
400:
401: return (0);
402: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to vfs_sync.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern