2 * Copyright (c) 2007 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * $DragonFly: src/sys/vfs/hammer/hammer_io.c,v 1.12 2008/01/03 06:48:49 dillon Exp $
37 * IO Primitives and buffer cache management
39 * All major data-tracking structures in HAMMER contain a struct hammer_io
40 * which is used to manage their backing store. We use filesystem buffers
41 * for backing store and we leave them passively associated with their
44 * If the kernel tries to release a passively associated buf which we cannot
45 * yet let go we set B_LOCKED in the buffer and then actively released it
50 #include <sys/fcntl.h>
51 #include <sys/nlookup.h>
56 * Helper routine to disassociate a buffer cache buffer from an I/O
60 hammer_io_disassociate(union hammer_io_structure *io)
62 struct buf *bp = io->io.bp;
64 KKASSERT(io->io.released && io->io.modified == 0);
65 LIST_INIT(&bp->b_dep); /* clear the association */
68 bp->b_flags &= ~B_LOCKED;
71 case HAMMER_STRUCTURE_VOLUME:
72 io->volume.ondisk = NULL;
73 io->volume.alist.meta = NULL;
75 case HAMMER_STRUCTURE_SUPERCL:
76 io->supercl.ondisk = NULL;
77 io->supercl.alist.meta = NULL;
79 case HAMMER_STRUCTURE_CLUSTER:
80 io->cluster.ondisk = NULL;
81 io->cluster.alist_master.meta = NULL;
82 io->cluster.alist_btree.meta = NULL;
83 io->cluster.alist_record.meta = NULL;
84 io->cluster.alist_mdata.meta = NULL;
86 case HAMMER_STRUCTURE_BUFFER:
87 io->buffer.ondisk = NULL;
88 io->buffer.alist.meta = NULL;
94 * Mark a cluster as being closed. This is done as late as possible,
95 * only when we are asked to flush the cluster
98 hammer_close_cluster(hammer_cluster_t cluster)
100 while (cluster->state == HAMMER_CLUSTER_ASYNC)
101 tsleep(cluster, 0, "hmrdep", 0);
102 if (cluster->state == HAMMER_CLUSTER_OPEN) {
103 cluster->state = HAMMER_CLUSTER_IDLE;
104 hammer_modify_cluster(cluster);
105 cluster->ondisk->clu_flags &= ~HAMMER_CLUF_OPEN;
106 hammer_modify_cluster_done(cluster);
107 kprintf("CLOSE CLUSTER\n");
112 * Hack XXX - called from kernel syncer via hammer_io_checkwrite() when it
113 * wants to flush buffer.
116 hammer_close_cluster_quick(hammer_cluster_t cluster)
118 if (cluster->state == HAMMER_CLUSTER_OPEN) {
119 cluster->state = HAMMER_CLUSTER_IDLE;
120 cluster->io.modified = 1;
121 cluster->ondisk->clu_flags &= ~HAMMER_CLUF_OPEN;
122 kprintf("CLOSE CLUSTER ON KERNEL WRITE\n");
128 * Load bp for a HAMMER structure.
131 hammer_io_read(struct vnode *devvp, struct hammer_io *io)
136 if ((bp = io->bp) == NULL) {
137 error = bread(devvp, io->offset, HAMMER_BUFSIZE, &io->bp);
140 bp->b_ops = &hammer_bioops;
141 LIST_INSERT_HEAD(&bp->b_dep, &io->worklist, node);
144 io->modified = 0; /* no new modifications yet */
145 io->released = 0; /* we hold an active lock on bp */
153 * Similar to hammer_io_read() but returns a zero'd out buffer instead.
154 * vfs_bio_clrbuf() is kinda nasty, enforce serialization against background
155 * I/O so we can call it.
158 hammer_io_new(struct vnode *devvp, struct hammer_io *io)
162 if ((bp = io->bp) == NULL) {
163 io->bp = getblk(devvp, io->offset, HAMMER_BUFSIZE, 0, 0);
165 bp->b_ops = &hammer_bioops;
166 LIST_INSERT_HEAD(&bp->b_dep, &io->worklist, node);
167 io->released = 0; /* we hold an active lock on bp */
182 * This routine is called when a buffer within a cluster is modified. We
183 * mark the cluster open and immediately initiate asynchronous I/O. Any
184 * related hammer_buffer write I/O blocks until our async write completes.
185 * This guarentees (inasmuch as the OS can) that the cluster recovery code
186 * will see a cluster marked open if a crash occured while the filesystem
187 * still had dirty buffers associated with that cluster.
192 hammer_io_notify_cluster(hammer_cluster_t cluster)
194 struct hammer_io *io = &cluster->io;
196 if (cluster->state == HAMMER_CLUSTER_IDLE) {
197 hammer_lock_ex(&cluster->io.lock);
198 if (cluster->state == HAMMER_CLUSTER_IDLE) {
203 kprintf("MARK CLUSTER OPEN\n");
204 cluster->ondisk->clu_flags |= HAMMER_CLUF_OPEN;
205 cluster->state = HAMMER_CLUSTER_ASYNC;
206 cluster->io.modified = 1;
209 hammer_unlock(&cluster->io.lock);
214 * This routine is called on the last reference to a hammer structure.
215 * Regardless of the state io->modified must be cleared when we return.
217 * If flush is non-zero we have to completely disassociate the bp from the
218 * structure (which may involve blocking). Otherwise we can leave the bp
219 * passively associated with the structure.
221 * The caller is holding io->lock exclusively.
224 hammer_io_release(struct hammer_io *io, int flush)
226 union hammer_io_structure *iou = (void *)io;
227 hammer_cluster_t cluster;
231 if ((bp = io->bp) != NULL) {
233 * If neither we nor the kernel want to flush the bp, we can
234 * stop here. Make sure the bp is passively released
235 * before returning. Even though we are still holding it,
236 * we want to be notified when the kernel wishes to flush
237 * it out so make sure B_DELWRI is properly set if we had
238 * made modifications.
240 if (flush == 0 && (bp->b_flags & B_LOCKED) == 0) {
241 if ((bp->b_flags & B_DELWRI) == 0 && io->modified) {
248 } else if (io->released == 0) {
249 /* buffer write state already synchronized */
254 /* buffer write state already synchronized */
261 * Either we want to flush the buffer or the kernel tried.
263 * If this is a hammer_buffer we may have to wait for the
264 * cluster header write to complete.
266 if (iou->io.type == HAMMER_STRUCTURE_BUFFER &&
267 (io->modified || (bp->b_flags & B_DELWRI))) {
268 cluster = iou->buffer.cluster;
269 while (cluster->state == HAMMER_CLUSTER_ASYNC)
270 tsleep(iou->buffer.cluster, 0, "hmrdep", 0);
274 * If we have an open cluster header, close it
276 if (iou->io.type == HAMMER_STRUCTURE_CLUSTER) {
277 hammer_close_cluster(&iou->cluster);
281 * Gain ownership of the buffer. Nothing can take it away
282 * from the io structure while we have it locked, so we
285 * Once our thread owns the buffer we can disassociate it
286 * from the io structure.
292 modified = io->modified;
294 hammer_io_disassociate(iou);
297 * Now dispose of the buffer. Someone tried to flush, so
298 * issue the I/O immediately.
300 if (modified || (bp->b_flags & B_DELWRI))
308 * Flush dirty data, if any.
311 hammer_io_flush(struct hammer_io *io, struct hammer_sync_info *info)
317 if ((bp = io->bp) == NULL)
319 if (bp->b_flags & B_DELWRI)
323 * We can't initiate a write while the buffer is being modified
326 while (io->lock.modifying) {
328 kprintf("DELAYING IO FLUSH BP %p TYPE %d REFS %d modifying %d\n",
329 bp, io->type, io->lock.refs, io->lock.modifying);
330 tsleep(&io->lock, 0, "hmrfls", 0);
332 hammer_lock_ex(&io->lock);
333 if (io->lock.modifying || io->bp == NULL) {
334 hammer_unlock(&io->lock);
339 * Acquire ownership of the buffer cache buffer so we can flush it
343 if (io->modified == 0)
351 * Return the bp to the system, issuing I/O if necessary. The
352 * system will issue a callback to us when it actually wants to
355 if (io->modified == 0) {
357 } else if (info->waitfor & MNT_WAIT) {
367 hammer_unlock(&io->lock);
371 * Called prior to any modifications being made to ondisk data. This
372 * forces the caller to wait for any writes to complete. We explicitly
373 * avoid the write-modify race.
375 * This routine is only called on hammer structures which are already
376 * actively referenced.
379 hammer_io_intend_modify(struct hammer_io *io)
381 KKASSERT(io->lock.refs != 0 && io->bp != NULL);
383 hammer_lock_ex(&io->lock);
386 BUF_KERNPROC(io->bp);
389 hammer_unlock(&io->lock);
394 hammer_io_modify_done(struct hammer_io *io)
396 KKASSERT(io->lock.modifying > 0);
397 --io->lock.modifying;
398 if (io->lock.wanted && io->lock.modifying == 0) {
405 * Mark an entity as not being dirty any more -- usually occurs when
406 * the governing a-list has freed the entire entity.
409 hammer_io_clear_modify(struct hammer_io *io)
414 if ((bp = io->bp) != NULL) {
419 if (io->modified == 0) {
420 kprintf("hammer_io_clear_modify: cleared %p\n", io);
434 * Pre and post I/O callbacks.
436 static void hammer_io_deallocate(struct buf *bp);
439 hammer_io_start(struct buf *bp)
442 union hammer_io_structure *io = (void *)LIST_FIRST(&bp->b_dep);
444 if (io->io.type == HAMMER_STRUCTURE_BUFFER) {
445 while (io->buffer.cluster->io_in_progress) {
446 kprintf("hammer_io_start: wait for cluster\n");
447 tsleep(io->buffer.cluster, 0, "hmrdep", 0);
448 kprintf("hammer_io_start: wait for cluster done\n");
455 hammer_io_complete(struct buf *bp)
457 union hammer_io_structure *io = (void *)LIST_FIRST(&bp->b_dep);
459 if (io->io.type == HAMMER_STRUCTURE_CLUSTER) {
460 if (io->cluster.state == HAMMER_CLUSTER_ASYNC) {
461 io->cluster.state = HAMMER_CLUSTER_OPEN;
462 wakeup(&io->cluster);
468 * Callback from kernel when it wishes to deallocate a passively
469 * associated structure. This can only occur if the buffer is
470 * passively associated with the structure. The kernel has locked
473 * If we cannot disassociate we set B_LOCKED to prevent the buffer
474 * from getting reused.
477 hammer_io_deallocate(struct buf *bp)
479 union hammer_io_structure *io = (void *)LIST_FIRST(&bp->b_dep);
481 /* XXX memory interlock, spinlock to sync cpus */
484 * Since the kernel is passing us a locked buffer, the HAMMER
485 * structure had better not believe it has a lock on the buffer.
487 KKASSERT(io->io.released);
491 * First, ref the structure to prevent either the buffer or the
492 * structure from going away or being unexpectedly flushed.
494 hammer_ref(&io->io.lock);
497 * Buffers can have active references from cached hammer_node's,
498 * even if those nodes are themselves passively cached. Attempt
499 * to clean them out. This may not succeed.
501 * We have to do some magic with io.released because
502 * hammer_io_intend_modify() can be called indirectly from the
503 * flush code, otherwise we might panic with a recursive bp lock.
505 if (io->io.type == HAMMER_STRUCTURE_BUFFER &&
506 hammer_lock_ex_try(&io->io.lock) == 0) {
508 hammer_flush_buffer_nodes(&io->buffer);
509 KKASSERT(io->io.released == 0);
511 hammer_unlock(&io->io.lock);
514 if (hammer_islastref(&io->io.lock)) {
516 * If we are the only ref left we can disassociate the I/O.
517 * It had better still be in a released state because the
518 * kernel is holding a lock on the buffer. Any passive
519 * modifications should have already been synchronized with
522 KKASSERT(io->io.modified == 0);
523 hammer_io_disassociate(io);
526 * Perform final rights on the structure. This can cause
527 * a chain reaction - e.g. last buffer -> last cluster ->
528 * last supercluster -> last volume.
530 switch(io->io.type) {
531 case HAMMER_STRUCTURE_VOLUME:
532 hammer_rel_volume(&io->volume, 1);
534 case HAMMER_STRUCTURE_SUPERCL:
535 hammer_rel_supercl(&io->supercl, 1);
537 case HAMMER_STRUCTURE_CLUSTER:
538 hammer_rel_cluster(&io->cluster, 1);
540 case HAMMER_STRUCTURE_BUFFER:
541 hammer_rel_buffer(&io->buffer, 1);
546 * Otherwise tell the kernel not to destroy the buffer.
548 * We have to unref the structure without performing any
549 * final rights to it to avoid a deadlock.
551 bp->b_flags |= B_LOCKED;
552 hammer_unref(&io->io.lock);
558 hammer_io_fsync(struct vnode *vp)
564 * NOTE: will not be called unless we tell the kernel about the
565 * bioops. Unused... we use the mount's VFS_SYNC instead.
568 hammer_io_sync(struct mount *mp)
574 hammer_io_movedeps(struct buf *bp1, struct buf *bp2)
579 * I/O pre-check for reading and writing. HAMMER only uses this for
580 * B_CACHE buffers so checkread just shouldn't happen, but if it does
583 * Writing is a different case. We don't want the kernel to try to write
584 * out a buffer that HAMMER may be modifying passively or which has a
587 * This code enforces the following write ordering: buffers, then cluster
588 * headers, then volume headers.
591 hammer_io_checkread(struct buf *bp)
597 hammer_io_checkwrite(struct buf *bp)
599 union hammer_io_structure *iou = (void *)LIST_FIRST(&bp->b_dep);
601 if (iou->io.type == HAMMER_STRUCTURE_BUFFER &&
602 iou->buffer.cluster->state == HAMMER_CLUSTER_ASYNC) {
604 * Cannot write out a cluster buffer if the cluster header
605 * I/O opening the cluster has not completed.
607 bp->b_flags |= B_LOCKED;
609 } else if (iou->io.lock.refs) {
611 * Cannot write out a bp if its associated buffer has active
614 bp->b_flags |= B_LOCKED;
618 * We're good, but before we can let the kernel proceed we
619 * may have to make some adjustments.
621 * Since there are no refs on the io structure, HAMMER must
622 * have already synchronized its modify state with the bp
623 * so iou->io.modified should be 0.
625 if (iou->io.type == HAMMER_STRUCTURE_CLUSTER)
626 hammer_close_cluster_quick(&iou->cluster);
627 hammer_io_disassociate(iou);
633 * Return non-zero if the caller should flush the structure associated
634 * with this io sub-structure.
637 hammer_io_checkflush(struct hammer_io *io)
639 if (io->bp == NULL || (io->bp->b_flags & B_LOCKED))
645 * Return non-zero if we wish to delay the kernel's attempt to flush
646 * this buffer to disk.
649 hammer_io_countdeps(struct buf *bp, int n)
654 struct bio_ops hammer_bioops = {
655 .io_start = hammer_io_start,
656 .io_complete = hammer_io_complete,
657 .io_deallocate = hammer_io_deallocate,
658 .io_fsync = hammer_io_fsync,
659 .io_sync = hammer_io_sync,
660 .io_movedeps = hammer_io_movedeps,
661 .io_countdeps = hammer_io_countdeps,
662 .io_checkread = hammer_io_checkread,
663 .io_checkwrite = hammer_io_checkwrite,