HAMMER 12/many - buffer cache sync, buffer cache interactions, misc fixes.
[dragonfly.git] / sys / vfs / hammer / hammer_io.c
1 /*
2  * Copyright (c) 2007 The DragonFly Project.  All rights reserved.
3  * 
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
6  * 
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 
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
16  *    distribution.
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.
20  * 
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
32  * SUCH DAMAGE.
33  * 
34  * $DragonFly: src/sys/vfs/hammer/hammer_io.c,v 1.9 2007/12/30 08:49:20 dillon Exp $
35  */
36 /*
37  * IO Primitives and buffer cache management
38  *
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
42  * HAMMER structures.
43  *
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
46  * later when we can.
47  */
48
49 #include "hammer.h"
50 #include <sys/fcntl.h>
51 #include <sys/nlookup.h>
52 #include <sys/buf.h>
53 #include <sys/buf2.h>
54
55 /*
56  * Helper routine to disassociate a buffer cache buffer from an I/O
57  * structure.
58  */
59 static void
60 hammer_io_disassociate(union hammer_io_structure *io)
61 {
62         struct buf *bp = io->io.bp;
63
64         LIST_INIT(&bp->b_dep);  /* clear the association */
65         bp->b_ops = NULL;
66         io->io.bp = NULL;
67
68         switch(io->io.type) {
69         case HAMMER_STRUCTURE_VOLUME:
70                 io->volume.ondisk = NULL;
71                 io->volume.alist.meta = NULL;
72                 break;
73         case HAMMER_STRUCTURE_SUPERCL:
74                 io->supercl.ondisk = NULL;
75                 io->supercl.alist.meta = NULL;
76                 break;
77         case HAMMER_STRUCTURE_CLUSTER:
78                 io->cluster.ondisk = NULL;
79                 io->cluster.alist_master.meta = NULL;
80                 io->cluster.alist_btree.meta = NULL;
81                 io->cluster.alist_record.meta = NULL;
82                 io->cluster.alist_mdata.meta = NULL;
83                 break;
84         case HAMMER_STRUCTURE_BUFFER:
85                 io->buffer.ondisk = NULL;
86                 io->buffer.alist.meta = NULL;
87                 break;
88         }
89         io->io.modified = 0;
90         io->io.released = 1;
91 }
92
93 /*
94  * Mark a cluster as being closed.  This is done as late as possible,
95  * only when we are asked to flush the cluster
96  */
97 static void
98 hammer_close_cluster(hammer_cluster_t cluster)
99 {
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");
108         }
109 }
110
111
112 /*
113  * Load bp for a HAMMER structure.
114  */
115 int
116 hammer_io_read(struct vnode *devvp, struct hammer_io *io)
117 {
118         struct buf *bp;
119         int error;
120
121         if ((bp = io->bp) == NULL) {
122                 error = bread(devvp, io->offset, HAMMER_BUFSIZE, &io->bp);
123                 if (error == 0) {
124                         bp = io->bp;
125                         bp->b_ops = &hammer_bioops;
126                         LIST_INSERT_HEAD(&bp->b_dep, &io->worklist, node);
127                         BUF_KERNPROC(bp);
128                 }
129                 io->modified = 0;       /* no new modifications yet */
130                 io->released = 0;       /* we hold an active lock on bp */
131         } else {
132                 error = 0;
133         }
134         return(error);
135 }
136
137 /*
138  * Similar to hammer_io_read() but returns a zero'd out buffer instead.
139  * vfs_bio_clrbuf() is kinda nasty, enforce serialization against background
140  * I/O so we can call it.
141  */
142 int
143 hammer_io_new(struct vnode *devvp, struct hammer_io *io)
144 {
145         struct buf *bp;
146
147         if ((bp = io->bp) == NULL) {
148                 io->bp = getblk(devvp, io->offset, HAMMER_BUFSIZE, 0, 0);
149                 bp = io->bp;
150                 bp->b_ops = &hammer_bioops;
151                 LIST_INSERT_HEAD(&bp->b_dep, &io->worklist, node);
152                 io->released = 0;       /* we hold an active lock on bp */
153                 BUF_KERNPROC(bp);
154         } else {
155                 if (io->released) {
156                         regetblk(bp);
157                         io->released = 0;
158                         BUF_KERNPROC(bp);
159                 }
160         }
161         io->modified = 1;
162         vfs_bio_clrbuf(bp);
163         return(0);
164 }
165
166 /*
167  * This routine is called when a buffer within a cluster is modified.  We
168  * mark the cluster open and immediately initiate asynchronous I/O.  Any
169  * related hammer_buffer write I/O blocks until our async write completes.
170  * This guarentees (inasmuch as the OS can) that the cluster recovery code
171  * will see a cluster marked open if a crash occured while the filesystem
172  * still had dirty buffers associated with that cluster.
173  *
174  * XXX
175  */
176 void
177 hammer_io_notify_cluster(hammer_cluster_t cluster)
178 {
179         struct hammer_io *io = &cluster->io;
180
181         if (cluster->state == HAMMER_CLUSTER_IDLE) {
182                 hammer_lock_ex(&cluster->io.lock);
183                 if (cluster->state == HAMMER_CLUSTER_IDLE) {
184                         if (io->released)
185                                 regetblk(io->bp);
186                         io->released = 1;
187                         kprintf("MARK CLUSTER OPEN\n");
188                         cluster->ondisk->clu_flags |= HAMMER_CLUF_OPEN;
189                         cluster->state = HAMMER_CLUSTER_ASYNC;
190                         bawrite(io->bp);
191                         /* leave cluster marked as modified */
192                 }
193                 hammer_unlock(&cluster->io.lock);
194         }
195 }
196
197 /*
198  * This routine is called on the last reference to a hammer structure.  If
199  * flush is non-zero we have to completely disassociate the bp from the
200  * structure (which may involve blocking).  Otherwise we can leave the bp
201  * passively associated with the structure.
202  *
203  * The caller is holding io->lock exclusively.
204  */
205 void
206 hammer_io_release(struct hammer_io *io, int flush)
207 {
208         union hammer_io_structure *iou = (void *)io;
209         hammer_cluster_t cluster;
210         struct buf *bp;
211
212         if ((bp = io->bp) != NULL) {
213                 /*
214                  * If neither we nor the kernel want to flush the bp, we can
215                  * stop here.  Make sure the bp is passively released
216                  * before returning.  Even though we are still holding it,
217                  * we want to be notified when the kernel wishes to flush
218                  * it out so make sure B_DELWRI is properly set if we had
219                  * made modifications.
220                  */
221                 if (flush == 0 && (bp->b_flags & B_LOCKED) == 0) {
222                         if ((bp->b_flags & B_DELWRI) == 0 && io->modified) {
223                                 if (io->released)
224                                         regetblk(bp);
225                                 bdwrite(bp);
226                                 io->released = 1;
227                         } else if (io->released == 0) {
228                                 bqrelse(bp);
229                                 io->released = 1;
230                         }
231                         return;
232                 }
233
234                 /*
235                  * We've been asked to flush the buffer.
236                  *
237                  * If this is a hammer_buffer we may have to wait for the
238                  * cluster header write to complete.
239                  */
240                 if (iou->io.type == HAMMER_STRUCTURE_BUFFER &&
241                     (io->modified || (bp->b_flags & B_DELWRI))) {
242                         cluster = iou->buffer.cluster;
243                         while (cluster->state == HAMMER_CLUSTER_ASYNC)
244                                 tsleep(iou->buffer.cluster, 0, "hmrdep", 0);
245                 }
246
247                 /*
248                  * If we have an open cluster header, close it
249                  */
250                 if (iou->io.type == HAMMER_STRUCTURE_CLUSTER) {
251                         hammer_close_cluster(&iou->cluster);
252                 }
253
254
255                 /*
256                  * Ok the dependancies are all gone.  Check for the simple
257                  * disassociation case.
258                  */
259                 if (io->released && (bp->b_flags & B_LOCKED) == 0 &&
260                     (io->modified == 0 || (bp->b_flags & B_DELWRI))) {
261                         hammer_io_disassociate(iou);
262                         return;
263                 }
264
265                 /*
266                  * Handle the more complex disassociation case.  Acquire the
267                  * buffer, clean up B_LOCKED, and deal with the modified
268                  * flag.
269                  */
270                 if (io->released)
271                         regetblk(bp);
272                 io->released = 1;
273                 bp->b_flags &= ~B_LOCKED;
274                 if (io->modified || (bp->b_flags & B_DELWRI))
275                         bawrite(bp);
276                 else
277                         bqrelse(bp);
278                 hammer_io_disassociate(iou);
279         }
280 }
281
282 /*
283  * Flush dirty data, if any.
284  */
285 void
286 hammer_io_flush(struct hammer_io *io, struct hammer_sync_info *info)
287 {
288         struct buf *bp;
289         int error;
290
291 again:
292         if ((bp = io->bp) == NULL)
293                 return;
294         if (bp->b_flags & B_DELWRI)
295                 io->modified = 1;
296
297         /*
298          * We can't initiate a write while the buffer is being modified
299          * by someone.
300          */
301         while (io->lock.modifying) {
302                 io->lock.wanted = 1;
303                 kprintf("DELAYING IO FLUSH BP %p TYPE %d REFS %d modifying %d\n",
304                         bp, io->type, io->lock.refs, io->lock.modifying);
305                 tsleep(&io->lock, 0, "hmrfls", 0);
306         }
307         hammer_lock_ex(&io->lock);
308         if (io->lock.modifying || io->bp == NULL) {
309                 hammer_unlock(&io->lock);
310                 goto again;
311         }
312
313         /*
314          * Acquire ownership of the buffer cache buffer so we can flush it
315          * out.
316          */
317         if (io->released) {
318                 if (io->modified == 0)
319                         goto done;
320                 regetblk(bp);
321         }
322         io->released = 1;
323
324         /*
325          * Return the bp to the system, issuing I/O if necessary.  The
326          * system will issue a callback to us when it actually wants to
327          * throw the bp away.
328          */
329         if (io->modified == 0) {
330                 bqrelse(bp);
331         } else if (info->waitfor & MNT_WAIT) {
332                 io->modified = 0;
333                 error = bwrite(bp);
334                 if (error)
335                         info->error = error;
336         } else {
337                 io->modified = 0;
338                 bawrite(bp);
339         }
340 done:
341         hammer_unlock(&io->lock);
342 }
343
344 /*
345  * Called prior to any modifications being made to ondisk data.  This
346  * forces the caller to wait for any writes to complete.  We explicitly
347  * avoid the write-modify race.
348  *
349  * This routine is only called on hammer structures which are already
350  * actively referenced.
351  */
352 void
353 hammer_io_intend_modify(struct hammer_io *io)
354 {
355         KKASSERT(io->lock.refs != 0 && io->bp != NULL);
356         if (io->released) {
357                 hammer_lock_ex(&io->lock);
358                 if (io->released) {
359                         regetblk(io->bp);
360                         io->released = 0;
361                         BUF_KERNPROC(io->bp);
362                 }
363                 hammer_unlock(&io->lock);
364         }
365 }
366
367 void
368 hammer_io_modify_done(struct hammer_io *io)
369 {
370         KKASSERT(io->lock.modifying > 0);
371         --io->lock.modifying;
372         if (io->lock.wanted && io->lock.modifying == 0) {
373                 io->lock.wanted = 0;
374                 wakeup(&io->lock);
375         }
376 }
377
378 /*
379  * HAMMER_BIOOPS
380  */
381
382 /*
383  * Pre and post I/O callbacks.
384  */
385 static void hammer_io_deallocate(struct buf *bp);
386
387 static void
388 hammer_io_start(struct buf *bp)
389 {
390 #if 0
391         union hammer_io_structure *io = (void *)LIST_FIRST(&bp->b_dep);
392
393         if (io->io.type == HAMMER_STRUCTURE_BUFFER) {
394                 while (io->buffer.cluster->io_in_progress) {
395                         kprintf("hammer_io_start: wait for cluster\n");
396                         tsleep(io->buffer.cluster, 0, "hmrdep", 0);
397                         kprintf("hammer_io_start: wait for cluster done\n");
398                 }
399         }
400 #endif
401 }
402
403 static void
404 hammer_io_complete(struct buf *bp)
405 {
406         union hammer_io_structure *io = (void *)LIST_FIRST(&bp->b_dep);
407
408         if (io->io.type == HAMMER_STRUCTURE_CLUSTER) {
409                 if (io->cluster.state == HAMMER_CLUSTER_ASYNC) {
410                         io->cluster.state = HAMMER_CLUSTER_OPEN;
411                         wakeup(&io->cluster);
412                 }
413         }
414 }
415
416 /*
417  * Callback from kernel when it wishes to deallocate a passively
418  * associated structure.  This can only occur if the buffer is
419  * passively associated with the structure.  The kernel has locked
420  * the buffer.
421  *
422  * If we cannot disassociate we set B_LOCKED to prevent the buffer
423  * from getting reused.
424  */
425 static void
426 hammer_io_deallocate(struct buf *bp)
427 {
428         union hammer_io_structure *io = (void *)LIST_FIRST(&bp->b_dep);
429
430         /* XXX memory interlock, spinlock to sync cpus */
431
432         /*
433          * Since the kernel is passing us a locked buffer, the HAMMER
434          * structure had better not believe it has a lock on the buffer.
435          */
436         KKASSERT(io->io.released);
437         crit_enter();
438
439         /*
440          * First, ref the structure to prevent either the buffer or the
441          * structure from going away or being unexpectedly flushed.
442          */
443         hammer_ref(&io->io.lock);
444
445         /*
446          * Buffers can have active references from cached hammer_node's,
447          * even if those nodes are themselves passively cached.  Attempt
448          * to clean them out.  This may not succeed.
449          */
450         if (io->io.type == HAMMER_STRUCTURE_BUFFER &&
451             hammer_lock_ex_try(&io->io.lock) == 0) {
452                 hammer_flush_buffer_nodes(&io->buffer);
453                 hammer_unlock(&io->io.lock);
454         }
455
456         if (hammer_islastref(&io->io.lock)) {
457                 /*
458                  * If we are the only ref left we can disassociate the I/O.
459                  * It had better still be in a released state because the
460                  * kernel is holding a lock on the buffer.  Any passive
461                  * modifications should have already been synchronized with
462                  * the buffer.
463                  */
464                 KKASSERT(io->io.released);
465                 hammer_io_disassociate(io);
466                 bp->b_flags &= ~B_LOCKED;
467                 KKASSERT (io->io.modified == 0 || (bp->b_flags & B_DELWRI));
468
469                 /*
470                  * Perform final rights on the structure.  This can cause
471                  * a chain reaction - e.g. last buffer -> last cluster ->
472                  * last supercluster -> last volume.
473                  */
474                 switch(io->io.type) {
475                 case HAMMER_STRUCTURE_VOLUME:
476                         hammer_rel_volume(&io->volume, 1);
477                         break;
478                 case HAMMER_STRUCTURE_SUPERCL:
479                         hammer_rel_supercl(&io->supercl, 1);
480                         break;
481                 case HAMMER_STRUCTURE_CLUSTER:
482                         hammer_rel_cluster(&io->cluster, 1);
483                         break;
484                 case HAMMER_STRUCTURE_BUFFER:
485                         hammer_rel_buffer(&io->buffer, 1);
486                         break;
487                 }
488         } else {
489                 /*
490                  * Otherwise tell the kernel not to destroy the buffer.
491                  * 
492                  * We have to unref the structure without performing any
493                  * final rights to it to avoid a deadlock.
494                  */
495                 bp->b_flags |= B_LOCKED;
496                 hammer_unref(&io->io.lock);
497         }
498
499         crit_exit();
500 }
501
502 static int
503 hammer_io_fsync(struct vnode *vp)
504 {
505         return(0);
506 }
507
508 /*
509  * NOTE: will not be called unless we tell the kernel about the
510  * bioops.  Unused... we use the mount's VFS_SYNC instead.
511  */
512 static int
513 hammer_io_sync(struct mount *mp)
514 {
515         return(0);
516 }
517
518 static void
519 hammer_io_movedeps(struct buf *bp1, struct buf *bp2)
520 {
521 }
522
523 /*
524  * I/O pre-check for reading and writing.  HAMMER only uses this for
525  * B_CACHE buffers so checkread just shouldn't happen, but if it does
526  * allow it.
527  *
528  * Writing is a different case.  We don't want the kernel to try to write
529  * out a buffer that HAMMER may be modifying passively or which has a
530  * dependancy.
531  *
532  * This code enforces the following write ordering: buffers, then cluster
533  * headers, then volume headers.
534  */
535 static int
536 hammer_io_checkread(struct buf *bp)
537 {
538         return(0);
539 }
540
541 static int
542 hammer_io_checkwrite(struct buf *bp)
543 {
544         union hammer_io_structure *iou = (void *)LIST_FIRST(&bp->b_dep);
545
546         if (iou->io.type == HAMMER_STRUCTURE_BUFFER &&
547             iou->buffer.cluster->state == HAMMER_CLUSTER_ASYNC) {
548                 /*
549                  * Cannot write out a cluster buffer if the cluster header
550                  * I/O opening the cluster has not completed.
551                  */
552                 bp->b_flags |= B_LOCKED;
553                 return(-1);
554         } else if (iou->io.lock.refs) {
555                 /*
556                  * Cannot write out a bp if its associated buffer has active
557                  * references.
558                  */
559                 bp->b_flags |= B_LOCKED;
560                 return(-1);
561         } else {
562                 /*
563                  * We're good, but before we can let the kernel proceed we
564                  * may have to make some adjustments.
565                  */
566                 if (iou->io.type == HAMMER_STRUCTURE_CLUSTER)
567                         hammer_close_cluster(&iou->cluster);
568                 KKASSERT(iou->io.released);
569                 hammer_io_disassociate(iou);
570                 return(0);
571         }
572 }
573
574 /*
575  * Return non-zero if the caller should flush the structure associated
576  * with this io sub-structure.
577  */
578 int
579 hammer_io_checkflush(struct hammer_io *io)
580 {
581         if (io->bp == NULL || (io->bp->b_flags & B_LOCKED))
582                 return(1);
583         return(0);
584 }
585
586 /*
587  * Return non-zero if we wish to delay the kernel's attempt to flush
588  * this buffer to disk.
589  */
590 static int
591 hammer_io_countdeps(struct buf *bp, int n)
592 {
593         return(0);
594 }
595
596 struct bio_ops hammer_bioops = {
597         .io_start       = hammer_io_start,
598         .io_complete    = hammer_io_complete,
599         .io_deallocate  = hammer_io_deallocate,
600         .io_fsync       = hammer_io_fsync,
601         .io_sync        = hammer_io_sync,
602         .io_movedeps    = hammer_io_movedeps,
603         .io_countdeps   = hammer_io_countdeps,
604         .io_checkread   = hammer_io_checkread,
605         .io_checkwrite  = hammer_io_checkwrite,
606 };
607