Merge from vendor branch TNFTP:
[dragonfly.git] / sys / vfs / hammer / hammer_flusher.c
1 /*
2  * Copyright (c) 2008 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_flusher.c,v 1.16 2008/05/15 03:36:40 dillon Exp $
35  */
36 /*
37  * HAMMER dependancy flusher thread
38  *
39  * Meta data updates create buffer dependancies which are arranged as a
40  * hierarchy of lists.
41  */
42
43 #include "hammer.h"
44
45 static void hammer_flusher_thread(void *arg);
46 static void hammer_flusher_clean_loose_ios(hammer_mount_t hmp);
47 static void hammer_flusher_flush(hammer_mount_t hmp);
48 static int hammer_must_finalize_undo(hammer_mount_t hmp);
49 static void hammer_flusher_finalize(hammer_transaction_t trans);
50
51 #define HAMMER_FLUSHER_IMMEDIATE        16
52
53 void
54 hammer_flusher_sync(hammer_mount_t hmp)
55 {
56         int seq;
57
58         if (hmp->flusher_td) {
59                 seq = hmp->flusher_next;
60                 if (hmp->flusher_signal == 0) {
61                         hmp->flusher_signal = HAMMER_FLUSHER_IMMEDIATE;
62                         wakeup(&hmp->flusher_signal);
63                 }
64                 while ((int)(seq - hmp->flusher_done) > 0)
65                         tsleep(&hmp->flusher_done, 0, "hmrfls", 0);
66         }
67 }
68
69 void
70 hammer_flusher_async(hammer_mount_t hmp)
71 {
72         if (hmp->flusher_td) {
73                 if (hmp->flusher_signal++ == 0)
74                         wakeup(&hmp->flusher_signal);
75         }
76 }
77
78 void
79 hammer_flusher_create(hammer_mount_t hmp)
80 {
81         hmp->flusher_signal = 0;
82         hmp->flusher_act = 0;
83         hmp->flusher_done = 0;
84         hmp->flusher_next = 1;
85         lwkt_create(hammer_flusher_thread, hmp, &hmp->flusher_td, NULL,
86                     0, -1, "hammer");
87 }
88
89 void
90 hammer_flusher_destroy(hammer_mount_t hmp)
91 {
92         if (hmp->flusher_td) {
93                 hmp->flusher_exiting = 1;
94                 while (hmp->flusher_td) {
95                         hmp->flusher_signal = HAMMER_FLUSHER_IMMEDIATE;
96                         wakeup(&hmp->flusher_signal);
97                         tsleep(&hmp->flusher_exiting, 0, "hmrwex", 0);
98                 }
99         }
100 }
101
102 static void
103 hammer_flusher_thread(void *arg)
104 {
105         hammer_mount_t hmp = arg;
106
107         for (;;) {
108                 while (hmp->flusher_lock)
109                         tsleep(&hmp->flusher_lock, 0, "hmrhld", 0);
110                 hmp->flusher_act = hmp->flusher_next;
111                 ++hmp->flusher_next;
112                 hkprintf("F");
113                 hammer_flusher_clean_loose_ios(hmp);
114                 hammer_flusher_flush(hmp);
115                 hammer_flusher_clean_loose_ios(hmp);
116                 hmp->flusher_done = hmp->flusher_act;
117
118                 wakeup(&hmp->flusher_done);
119
120                 /*
121                  * Wait for activity.
122                  */
123                 if (hmp->flusher_exiting && TAILQ_EMPTY(&hmp->flush_list))
124                         break;
125                 hkprintf("E");
126
127                 /*
128                  * This is a hack until we can dispose of frontend buffer
129                  * cache buffers on the frontend.
130                  */
131                 if (hmp->flusher_signal &&
132                     hmp->flusher_signal < HAMMER_FLUSHER_IMMEDIATE) {
133                         --hmp->flusher_signal;
134                         tsleep(&hmp->flusher_signal, 0, "hmrqwk", hz / 10);
135                 } else {
136                         while (hmp->flusher_signal == 0 &&
137                                TAILQ_EMPTY(&hmp->flush_list)) {
138                                 tsleep(&hmp->flusher_signal, 0, "hmrwwa", 0);
139                         }
140                         hmp->flusher_signal = 0;
141                 }
142         }
143         hmp->flusher_td = NULL;
144         wakeup(&hmp->flusher_exiting);
145         lwkt_exit();
146 }
147
148 static void
149 hammer_flusher_clean_loose_ios(hammer_mount_t hmp)
150 {
151         hammer_buffer_t buffer;
152         hammer_io_t io;
153
154         /*
155          * loose ends - buffers without bp's aren't tracked by the kernel
156          * and can build up, so clean them out.  This can occur when an
157          * IO completes on a buffer with no references left.
158          */
159         while ((io = TAILQ_FIRST(&hmp->lose_list)) != NULL) {
160                 KKASSERT(io->mod_list == &hmp->lose_list);
161                 TAILQ_REMOVE(io->mod_list, io, mod_entry);
162                 io->mod_list = NULL;
163                 hammer_ref(&io->lock);
164                 buffer = (void *)io;
165                 hammer_rel_buffer(buffer, 0);
166         }
167 }
168
169 /*
170  * Flush stuff
171  */
172 static void
173 hammer_flusher_flush(hammer_mount_t hmp)
174 {
175         struct hammer_transaction trans;
176         hammer_blockmap_t rootmap;
177         hammer_inode_t ip;
178
179         hammer_start_transaction_fls(&trans, hmp);
180         rootmap = &hmp->blockmap[HAMMER_ZONE_UNDO_INDEX];
181
182         while ((ip = TAILQ_FIRST(&hmp->flush_list)) != NULL) {
183                 /*
184                  * Stop when we hit a different flush group
185                  */
186                 if (ip->flush_group != hmp->flusher_act)
187                         break;
188
189                 /*
190                  * Remove the inode from the flush list and inherit
191                  * its reference, sync, and clean-up.
192                  */
193                 TAILQ_REMOVE(&hmp->flush_list, ip, flush_entry);
194                 ip->error = hammer_sync_inode(ip);
195                 hammer_flush_inode_done(ip);
196
197                 /*
198                  * XXX this breaks atomicy
199                  */
200                 if (hammer_must_finalize_undo(hmp)) {
201                         Debugger("Too many undos!!");
202                         hammer_flusher_finalize(&trans);
203                 }
204         }
205         hammer_flusher_finalize(&trans);
206         hmp->flusher_tid = trans.tid;
207         hammer_done_transaction(&trans);
208 }
209
210 /*
211  * If the UNDO area gets over half full we have to flush it.  We can't
212  * afford the UNDO area becoming completely full as that would break
213  * the crash recovery atomicy.
214  */
215 static
216 int
217 hammer_must_finalize_undo(hammer_mount_t hmp)
218 {
219         if (hammer_undo_space(hmp) < hammer_undo_max(hmp) / 2) {
220                 hkprintf("*");
221                 return(1);
222         } else {
223                 return(0);
224         }
225 }
226
227 /*
228  * To finalize the flush we finish flushing all undo and data buffers
229  * still present, then we update the volume header and flush it,
230  * then we flush out the mata-data (that can now be undone).
231  *
232  * Note that as long as the undo fifo's start and end points do not
233  * match, we always must at least update the volume header.
234  *
235  * The sync_lock is used by other threads to issue modifying operations
236  * to HAMMER media without crossing a synchronization boundary or messing
237  * up the media synchronization operation.  Specifically, the pruning
238  * the reblocking ioctls, and allowing the frontend strategy code to
239  * allocate media data space.
240  */
241 static
242 void
243 hammer_flusher_finalize(hammer_transaction_t trans)
244 {
245         hammer_mount_t hmp = trans->hmp;
246         hammer_volume_t root_volume = trans->rootvol;
247         hammer_blockmap_t rootmap;
248         const int bmsize = sizeof(root_volume->ondisk->vol0_blockmap);
249         hammer_io_t io;
250         int count;
251         int i;
252
253         hammer_lock_ex(&hmp->sync_lock);
254         rootmap = &hmp->blockmap[HAMMER_ZONE_UNDO_INDEX];
255
256         /*
257          * Sync the blockmap to the root volume ondisk buffer and generate
258          * the appropriate undo record.  We have to generate the UNDO even
259          * though we flush the volume header along with the UNDO fifo update
260          * because the meta-data (including the volume header) is flushed
261          * after the fifo update, not before, and may have to be undone.
262          *
263          * No UNDOs can be created after this point until we finish the
264          * flush.
265          */
266         if (root_volume->io.modified &&
267             bcmp(hmp->blockmap, root_volume->ondisk->vol0_blockmap, bmsize)) {
268                 hammer_modify_volume(trans, root_volume,
269                             &root_volume->ondisk->vol0_blockmap,
270                             bmsize);
271                 for (i = 0; i < HAMMER_MAX_ZONES; ++i)
272                         hammer_crc_set_blockmap(&hmp->blockmap[i]);
273                 bcopy(hmp->blockmap, root_volume->ondisk->vol0_blockmap,
274                       bmsize);
275                 hammer_modify_volume_done(root_volume);
276         }
277
278         /*
279          * Flush the undo bufs, clear the undo cache.
280          */
281         hammer_clear_undo_history(hmp);
282
283         count = 0;
284         while ((io = TAILQ_FIRST(&hmp->undo_list)) != NULL) {
285                 KKASSERT(io->modify_refs == 0);
286                 hammer_ref(&io->lock);
287                 KKASSERT(io->type != HAMMER_STRUCTURE_VOLUME);
288                 hammer_io_flush(io);
289                 hammer_rel_buffer((hammer_buffer_t)io, 0);
290                 ++count;
291         }
292         if (count)
293                 hkprintf("X%d", count);
294
295         /*
296          * Flush data bufs
297          */
298         count = 0;
299         while ((io = TAILQ_FIRST(&hmp->data_list)) != NULL) {
300                 KKASSERT(io->modify_refs == 0);
301                 hammer_ref(&io->lock);
302                 KKASSERT(io->type != HAMMER_STRUCTURE_VOLUME);
303                 hammer_io_flush(io);
304                 hammer_rel_buffer((hammer_buffer_t)io, 0);
305                 ++count;
306         }
307         if (count)
308                 hkprintf("Y%d", count);
309
310         /*
311          * Wait for I/O to complete
312          */
313         crit_enter();
314         while (hmp->io_running_count)
315                 tsleep(&hmp->io_running_count, 0, "hmrfl1", 0);
316         crit_exit();
317
318         /*
319          * Update the root volume's next_tid field.  This field is updated
320          * without any related undo.
321          */
322         if (root_volume->ondisk->vol0_next_tid != hmp->next_tid) {
323                 hammer_modify_volume(NULL, root_volume, NULL, 0);
324                 root_volume->ondisk->vol0_next_tid = hmp->next_tid;
325                 hammer_modify_volume_done(root_volume);
326         }
327
328         if (hammer_debug_recover_faults > 0) {
329                 if (--hammer_debug_recover_faults == 0) {
330                         Debugger("hammer_debug_recover_faults");
331                 }
332         }
333
334
335         /*
336          * Update the UNDO FIFO's first_offset.  Same deal.
337          */
338         if (rootmap->first_offset != hmp->flusher_undo_start) {
339                 hammer_modify_volume(NULL, root_volume, NULL, 0);
340                 rootmap->first_offset = hmp->flusher_undo_start;
341                 root_volume->ondisk->vol0_blockmap[HAMMER_ZONE_UNDO_INDEX].first_offset = rootmap->first_offset;
342                 hammer_crc_set_blockmap(&root_volume->ondisk->vol0_blockmap[HAMMER_ZONE_UNDO_INDEX]);
343                 hammer_modify_volume_done(root_volume);
344         }
345         hmp->flusher_undo_start = rootmap->next_offset;
346
347         /*
348          * Flush the root volume header.
349          *
350          * If a crash occurs while the root volume header is being written
351          * we just have to hope that the undo range has been updated.  It
352          * should be done in one I/O but XXX this won't be perfect.
353          */
354         if (root_volume->io.modified) {
355                 hammer_crc_set_volume(root_volume->ondisk);
356                 hammer_io_flush(&root_volume->io);
357         }
358
359         /*
360          * Wait for I/O to complete
361          */
362         crit_enter();
363         while (hmp->io_running_count)
364                 tsleep(&hmp->io_running_count, 0, "hmrfl2", 0);
365         crit_exit();
366
367         /*
368          * Flush meta-data.  The meta-data will be undone if we crash
369          * so we can safely flush it asynchronously.
370          */
371         count = 0;
372         while ((io = TAILQ_FIRST(&hmp->meta_list)) != NULL) {
373                 KKASSERT(io->modify_refs == 0);
374                 hammer_ref(&io->lock);
375                 KKASSERT(io->type != HAMMER_STRUCTURE_VOLUME);
376                 hammer_io_flush(io);
377                 hammer_rel_buffer((hammer_buffer_t)io, 0);
378                 ++count;
379         }
380         hammer_unlock(&hmp->sync_lock);
381         if (count)
382                 hkprintf("Z%d", count);
383 }
384