lfs_bio.c revision 1.11.6.2 1 /* $NetBSD: lfs_bio.c,v 1.11.6.2 1999/12/27 18:36:39 wrstuden Exp $ */
2
3 /*-
4 * Copyright (c) 1999 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Konrad E. Schroder <perseant (at) hhhh.org>.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. All advertising materials mentioning features or use of this software
19 * must display the following acknowledgement:
20 * This product includes software developed by the NetBSD
21 * Foundation, Inc. and its contributors.
22 * 4. Neither the name of The NetBSD Foundation nor the names of its
23 * contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 * POSSIBILITY OF SUCH DAMAGE.
37 */
38 /*
39 * Copyright (c) 1991, 1993
40 * The Regents of the University of California. All rights reserved.
41 *
42 * Redistribution and use in source and binary forms, with or without
43 * modification, are permitted provided that the following conditions
44 * are met:
45 * 1. Redistributions of source code must retain the above copyright
46 * notice, this list of conditions and the following disclaimer.
47 * 2. Redistributions in binary form must reproduce the above copyright
48 * notice, this list of conditions and the following disclaimer in the
49 * documentation and/or other materials provided with the distribution.
50 * 3. All advertising materials mentioning features or use of this software
51 * must display the following acknowledgement:
52 * This product includes software developed by the University of
53 * California, Berkeley and its contributors.
54 * 4. Neither the name of the University nor the names of its contributors
55 * may be used to endorse or promote products derived from this software
56 * without specific prior written permission.
57 *
58 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
59 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
60 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
61 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
62 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
63 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
64 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
65 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
66 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
67 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
68 * SUCH DAMAGE.
69 *
70 * @(#)lfs_bio.c 8.10 (Berkeley) 6/10/95
71 */
72
73 #include <sys/param.h>
74 #include <sys/systm.h>
75 #include <sys/proc.h>
76 #include <sys/buf.h>
77 #include <sys/vnode.h>
78 #include <sys/resourcevar.h>
79 #include <sys/mount.h>
80 #include <sys/kernel.h>
81
82 #include <ufs/ufs/quota.h>
83 #include <ufs/ufs/inode.h>
84 #include <ufs/ufs/ufsmount.h>
85 #include <ufs/ufs/ufs_extern.h>
86
87 #include <sys/malloc.h>
88 #include <ufs/lfs/lfs.h>
89 #include <ufs/lfs/lfs_extern.h>
90
91 /* Macros to clear/set/test flags. */
92 # define SET(t, f) (t) |= (f)
93 # define CLR(t, f) (t) &= ~(f)
94 # define ISSET(t, f) ((t) & (f))
95
96 /*
97 * LFS block write function.
98 *
99 * XXX
100 * No write cost accounting is done.
101 * This is almost certainly wrong for synchronous operations and NFS.
102 */
103 int lfs_allclean_wakeup; /* Cleaner wakeup address. */
104 int locked_queue_count = 0; /* XXX Count of locked-down buffers. */
105 long locked_queue_bytes = 0L; /* XXX Total size of locked buffers. */
106 int lfs_writing = 0; /* Set if already kicked off a writer
107 because of buffer space */
108 extern int lfs_dostats;
109
110
111 /*
112 * #define WRITE_THRESHHOLD ((nbuf >> 1) - 10)
113 * #define WAIT_THRESHHOLD (nbuf - (nbuf >> 2) - 10)
114 */
115 #define LFS_MAX_BUFS ((nbuf >> 2) - 10)
116 #define LFS_WAIT_BUFS ((nbuf >> 1) - (nbuf >> 3) - 10)
117 /* These are new ... is LFS taking up too much memory in its buffers? */
118 #define LFS_MAX_BYTES (((bufpages >> 2) - 10) * NBPG)
119 #define LFS_WAIT_BYTES (((bufpages >> 1) - (bufpages >> 3) - 10) * NBPG)
120 #define LFS_BUFWAIT 2
121 /*
122 *
123 * XXX we don't let meta-data writes run out of space because they can
124 * come from the segment writer. We need to make sure that there is
125 * enough space reserved so that there's room to write meta-data
126 * blocks.
127 *
128 * Also, we don't let blocks that have come to us from the cleaner
129 * run out of space.
130 */
131 #define CANT_WAIT(BP,F) (IS_IFILE((BP)) || (BP)->b_lblkno<0 || ((F) & BW_CLEAN))
132
133 int
134 lfs_bwrite(v)
135 void *v;
136 {
137 struct vop_bwrite_args /* {
138 struct buf *a_bp;
139 } */ *ap = v;
140 register struct buf *bp = ap->a_bp;
141
142 #ifdef DIAGNOSTIC
143 if(VTOI(bp->b_vp)->i_lfs->lfs_ronly == 0
144 && (bp->b_flags & B_ASYNC)) {
145 panic("bawrite LFS buffer");
146 }
147 #endif /* DIAGNOSTIC */
148 return lfs_bwrite_ext(bp,0);
149 }
150
151 /*
152 * Determine if there is enough room currently available to write db
153 * disk blocks. We need enough blocks for the new blocks, the current
154 * inode blocks, a summary block, plus potentially the ifile inode and
155 * the segment usage table, plus an ifile page.
156 */
157 inline static int lfs_fits(struct lfs *fs, int db)
158 {
159 if(((db + (fs->lfs_uinodes + INOPB((fs))) /
160 INOPB(fs) + fsbtodb(fs, 1) +
161 (LFS_SUMMARY_SIZE / DEF_BSIZE) +
162 fs->lfs_segtabsz)) >= fs->lfs_avail)
163 {
164 return 0;
165 }
166
167 /*
168 * Also check the number of segments available for writing.
169 * If you don't do this here, it is possible for the *cleaner* to
170 * cause us to become starved of segments, by flushing the pending
171 * block list.
172 *
173 * XXX the old lfs_markv did not have this problem.
174 */
175 if (fs->lfs_nclean <= MIN_FREE_SEGS)
176 return 0;
177
178 return 1;
179 }
180
181 int
182 lfs_bwrite_ext(bp, flags)
183 struct buf *bp;
184 int flags;
185 {
186 struct lfs *fs;
187 struct inode *ip;
188 int db, error, s;
189
190 /*
191 * Don't write *any* blocks if we're mounted read-only.
192 * In particular the cleaner can't write blocks either.
193 */
194 if(VTOI(bp->b_vp)->i_lfs->lfs_ronly) {
195 bp->b_flags &= ~(B_DELWRI|B_LOCKED|B_READ|B_ERROR);
196 if(bp->b_flags & B_CALL)
197 bp->b_flags &= ~B_BUSY;
198 else
199 brelse(bp);
200 return EROFS;
201 }
202
203 /*
204 * Set the delayed write flag and use reassignbuf to move the buffer
205 * from the clean list to the dirty one.
206 *
207 * Set the B_LOCKED flag and unlock the buffer, causing brelse to move
208 * the buffer onto the LOCKED free list. This is necessary, otherwise
209 * getnewbuf() would try to reclaim the buffers using bawrite, which
210 * isn't going to work.
211 *
212 * XXX we don't let meta-data writes run out of space because they can
213 * come from the segment writer. We need to make sure that there is
214 * enough space reserved so that there's room to write meta-data
215 * blocks.
216 */
217 if (!(bp->b_flags & B_LOCKED)) {
218 fs = VFSTOUFS(bp->b_vp->v_mount)->um_lfs;
219 db = fragstodb(fs, numfrags(fs, bp->b_bcount));
220 #ifdef DEBUG_LFS
221 if(CANT_WAIT(bp,flags)) {
222 if(((db + (fs->lfs_uinodes + INOPB((fs))) / INOPB(fs)
223 + fsbtodb(fs, 1)
224 + LFS_SUMMARY_SIZE / DEF_BSIZE
225 + fs->lfs_segtabsz)) >= fs->lfs_avail)
226 {
227 printf("A");
228 }
229 if (fs->lfs_nclean <= MIN_FREE_SEGS-1)
230 printf("M");
231 }
232 #endif
233 while (!lfs_fits(fs, db) && !CANT_WAIT(bp,flags)) {
234 /* Out of space, need cleaner to run */
235
236 wakeup(&lfs_allclean_wakeup);
237 wakeup(&fs->lfs_nextseg);
238 error = tsleep(&fs->lfs_avail, PCATCH | PUSER, "cleaner", NULL);
239 if (error) {
240 /* printf("lfs_bwrite: error in tsleep"); */
241 brelse(bp);
242 return (error);
243 }
244 }
245
246 ip = VTOI(bp->b_vp);
247 if (bp->b_flags & B_CALL)
248 {
249 if(!(ip->i_flag & IN_CLEANING))
250 ++fs->lfs_uinodes;
251 ip->i_flag |= IN_CLEANING;
252 } else {
253 if(!(ip->i_flag & IN_MODIFIED))
254 ++fs->lfs_uinodes;
255 ip->i_flag |= IN_CHANGE | IN_MODIFIED | IN_UPDATE;
256 }
257 fs->lfs_avail -= db;
258 ++locked_queue_count;
259 locked_queue_bytes += bp->b_bufsize;
260 s = splbio();
261 bp->b_flags |= B_DELWRI | B_LOCKED;
262 bp->b_flags &= ~(B_READ | B_ERROR);
263 reassignbuf(bp, bp->b_vp);
264 splx(s);
265
266 }
267
268 if(bp->b_flags & B_CALL)
269 bp->b_flags &= ~B_BUSY;
270 else
271 brelse(bp);
272
273 return (0);
274 }
275
276 void lfs_flush_fs(mp, flags)
277 struct mount *mp;
278 int flags;
279 {
280 struct lfs *lfsp;
281
282 lfsp = ((struct ufsmount *)mp->mnt_data)->ufsmount_u.lfs;
283 if((mp->mnt_flag & MNT_RDONLY) == 0 &&
284 lfsp->lfs_dirops==0)
285 {
286 /* disallow dirops during flush */
287 lfsp->lfs_writer++;
288
289 /*
290 * We set the queue to 0 here because we
291 * are about to write all the dirty
292 * buffers we have. If more come in
293 * while we're writing the segment, they
294 * may not get written, so we want the
295 * count to reflect these new writes
296 * after the segwrite completes.
297 */
298 if(lfs_dostats)
299 ++lfs_stats.flush_invoked;
300 lfs_segwrite(mp, flags);
301
302 /* XXX KS - allow dirops again */
303 if(--lfsp->lfs_writer==0)
304 wakeup(&lfsp->lfs_dirops);
305 }
306 }
307
308 /*
309 * XXX
310 * This routine flushes buffers out of the B_LOCKED queue when LFS has too
311 * many locked down. Eventually the pageout daemon will simply call LFS
312 * when pages need to be reclaimed. Note, we have one static count of locked
313 * buffers, so we can't have more than a single file system. To make this
314 * work for multiple file systems, put the count into the mount structure.
315 */
316 void
317 lfs_flush(fs, flags)
318 struct lfs *fs;
319 int flags;
320 {
321 register struct mount *mp, *nmp;
322
323 if(lfs_dostats)
324 ++lfs_stats.write_exceeded;
325 if (lfs_writing && flags==0) {/* XXX flags */
326 #ifdef DEBUG_LFS
327 printf("lfs_flush: not flushing because another flush is active\n");
328 #endif
329 return;
330 }
331 lfs_writing = 1;
332
333 simple_lock(&mountlist_slock);
334 for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) {
335 if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock)) {
336 nmp = mp->mnt_list.cqe_next;
337 continue;
338 }
339 if (strncmp(&mp->mnt_stat.f_fstypename[0], MOUNT_LFS, MFSNAMELEN)==0)
340 lfs_flush_fs(mp, flags);
341 simple_lock(&mountlist_slock);
342 nmp = mp->mnt_list.cqe_next;
343 vfs_unbusy(mp);
344 }
345 simple_unlock(&mountlist_slock);
346
347 lfs_countlocked(&locked_queue_count,&locked_queue_bytes);
348 wakeup(&locked_queue_count);
349
350 lfs_writing = 0;
351 }
352
353 int
354 lfs_check(vp, blkno, flags)
355 struct vnode *vp;
356 ufs_daddr_t blkno;
357 int flags;
358 {
359 int error;
360 struct lfs *fs;
361 extern int lfs_dirvcount;
362
363 error = 0;
364
365 /* If out of buffers, wait on writer */
366 /* XXX KS - if it's the Ifile, we're probably the cleaner! */
367 if (VTOI(vp)->i_number == LFS_IFILE_INUM)
368 return 0;
369
370 /* If dirops are active, can't flush. Wait for SET_ENDOP */
371 fs = VTOI(vp)->i_lfs;
372 if (fs->lfs_dirops)
373 return 0;
374
375 if (locked_queue_count > LFS_MAX_BUFS
376 || locked_queue_bytes > LFS_MAX_BYTES
377 || lfs_dirvcount > LFS_MAXDIROP
378 || fs->lfs_diropwait > 0)
379 {
380 ++fs->lfs_writer;
381 lfs_flush(fs, flags);
382 if(--fs->lfs_writer==0)
383 wakeup(&fs->lfs_dirops);
384 }
385
386 while (locked_queue_count > LFS_WAIT_BUFS
387 || locked_queue_bytes > LFS_WAIT_BYTES)
388 {
389 if(lfs_dostats)
390 ++lfs_stats.wait_exceeded;
391 #ifdef DEBUG_LFS
392 printf("lfs_check: waiting: count=%d, bytes=%ld\n",
393 locked_queue_count, locked_queue_bytes);
394 #endif
395 error = tsleep(&locked_queue_count, PCATCH | PUSER,
396 "buffers", hz * LFS_BUFWAIT);
397 }
398 return (error);
399 }
400
401 /*
402 * Allocate a new buffer header.
403 */
404 struct buf *
405 lfs_newbuf(vp, daddr, size)
406 struct vnode *vp;
407 ufs_daddr_t daddr;
408 size_t size;
409 {
410 struct buf *bp;
411 size_t nbytes;
412 int s;
413
414 nbytes = roundup(size, DEF_BSIZE);
415
416 bp = malloc(sizeof(struct buf), M_SEGMENT, M_WAITOK);
417 bzero(bp, sizeof(struct buf));
418 if (nbytes)
419 bp->b_data = malloc(nbytes, M_SEGMENT, M_WAITOK);
420 if(nbytes) {
421 bzero(bp->b_data, nbytes);
422 }
423 #ifdef DIAGNOSTIC
424 if(vp==NULL)
425 panic("vp is NULL in lfs_newbuf");
426 if(bp==NULL)
427 panic("bp is NULL after malloc in lfs_newbuf");
428 #endif
429 s = splbio();
430 bgetvp(vp, bp);
431 splx(s);
432
433 bp->b_bufsize = size;
434 bp->b_bcount = size;
435 bp->b_lblkno = daddr;
436 bp->b_blkno = daddr;
437 bp->b_error = 0;
438 bp->b_resid = 0;
439 bp->b_iodone = lfs_callback;
440 bp->b_flags |= B_BUSY | B_CALL | B_NOCACHE;
441
442 return (bp);
443 }
444
445 void
446 lfs_freebuf(bp)
447 struct buf *bp;
448 {
449 int s;
450
451 s = splbio();
452 if(bp->b_vp)
453 brelvp(bp);
454 splx(s);
455 if (!(bp->b_flags & B_INVAL)) { /* B_INVAL indicates a "fake" buffer */
456 free(bp->b_data, M_SEGMENT);
457 bp->b_data = NULL;
458 }
459 free(bp, M_SEGMENT);
460 }
461
462 /*
463 * Definitions for the buffer free lists.
464 */
465 #define BQUEUES 4 /* number of free buffer queues */
466
467 #define BQ_LOCKED 0 /* super-blocks &c */
468 #define BQ_LRU 1 /* lru, useful buffers */
469 #define BQ_AGE 2 /* rubbish */
470 #define BQ_EMPTY 3 /* buffer headers with no memory */
471
472 extern TAILQ_HEAD(bqueues, buf) bufqueues[BQUEUES];
473
474 /*
475 * Return a count of buffers on the "locked" queue.
476 */
477 void
478 lfs_countlocked(count, bytes)
479 int *count;
480 long *bytes;
481 {
482 register struct buf *bp;
483 register int n = 0;
484 register long int size = 0L;
485
486 for (bp = bufqueues[BQ_LOCKED].tqh_first; bp;
487 bp = bp->b_freelist.tqe_next) {
488 n++;
489 size += bp->b_bufsize;
490 }
491 *count = n;
492 *bytes = size;
493 return;
494 }
495