HAMMER 40F/Many: UNDO cleanup & stabilization.
[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.12 2008/05/04 09:06:45 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                 kprintf("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                 kprintf("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         hammer_done_transaction(&trans);
207 }
208
209 /*
210  * If the UNDO area gets over half full we have to flush it.  We can't
211  * afford the UNDO area becoming completely full as that would break
212  * the crash recovery atomicy.
213  */
214 static
215 int
216 hammer_must_finalize_undo(hammer_mount_t hmp)
217 {
218         if (hammer_undo_space(hmp) < hammer_undo_max(hmp) / 2) {
219                 kprintf("*");
220                 return(1);
221         } else {
222                 return(0);
223         }
224 }
225
226 /*
227  * To finalize the flush we finish flushing all undo and data buffers
228  * still present, then we update the volume header and flush it,
229  * then we flush out the mata-data (that can now be undone).
230  *
231  * Note that as long as the undo fifo's start and end points do not
232  * match, we always must at least update the volume header.
233  *
234  * The sync_lock is used by other threads to issue modifying operations
235  * to HAMMER media without crossing a synchronization boundary or messing
236  * up the media synchronization operation.  Specifically, the pruning
237  * the reblocking ioctls, and allowing the frontend strategy code to
238  * allocate media data space.
239  */
240 static
241 void
242 hammer_flusher_finalize(hammer_transaction_t trans)
243 {
244         hammer_mount_t hmp = trans->hmp;
245         hammer_volume_t root_volume = trans->rootvol;
246         hammer_blockmap_t rootmap;
247         const int bmsize = sizeof(root_volume->ondisk->vol0_blockmap);
248         hammer_io_t io;
249         int count;
250
251         hammer_lock_ex(&hmp->sync_lock);
252         rootmap = &hmp->blockmap[HAMMER_ZONE_UNDO_INDEX];
253
254         /*
255          * Sync the blockmap to the root volume ondisk buffer and generate
256          * the appropriate undo record.  We have to generate the UNDO even
257          * though we flush the volume header along with the UNDO fifo update
258          * because the meta-data (including the volume header) is flushed
259          * after the fifo update, not before, and may have to be undone.
260          *
261          * No UNDOs can be created after this point until we finish the
262          * flush.
263          */
264         if (root_volume->io.modified &&
265             bcmp(hmp->blockmap, root_volume->ondisk->vol0_blockmap, bmsize)) {
266                 hammer_modify_volume(trans, root_volume,
267                             &root_volume->ondisk->vol0_blockmap,
268                             bmsize);
269                 bcopy(hmp->blockmap, root_volume->ondisk->vol0_blockmap,
270                       bmsize);
271                 hammer_modify_volume_done(root_volume);
272         }
273
274         /*
275          * Flush the undo bufs, clear the undo cache.
276          */
277         hammer_clear_undo_history(hmp);
278
279         count = 0;
280         while ((io = TAILQ_FIRST(&hmp->undo_list)) != NULL) {
281                 KKASSERT(io->modify_refs == 0);
282                 hammer_ref(&io->lock);
283                 KKASSERT(io->type != HAMMER_STRUCTURE_VOLUME);
284                 hammer_io_flush(io);
285                 hammer_rel_buffer((hammer_buffer_t)io, 1);
286                 ++count;
287         }
288         if (count)
289                 kprintf("X%d", count);
290
291         /*
292          * Flush data bufs
293          */
294         count = 0;
295         while ((io = TAILQ_FIRST(&hmp->data_list)) != NULL) {
296                 KKASSERT(io->modify_refs == 0);
297                 hammer_ref(&io->lock);
298                 KKASSERT(io->type != HAMMER_STRUCTURE_VOLUME);
299                 hammer_io_flush(io);
300                 hammer_rel_buffer((hammer_buffer_t)io, 1);
301                 ++count;
302         }
303         if (count)
304                 kprintf("Y%d", count);
305
306         /*
307          * Wait for I/O to complete
308          */
309         crit_enter();
310         while (hmp->io_running_count)
311                 tsleep(&hmp->io_running_count, 0, "hmrfl1", 0);
312         crit_exit();
313
314         /*
315          * Update the root volume's next_tid field.  This field is updated
316          * without any related undo.
317          */
318         if (root_volume->ondisk->vol0_next_tid != hmp->next_tid) {
319                 hammer_modify_volume(NULL, root_volume, NULL, 0);
320                 root_volume->ondisk->vol0_next_tid = hmp->next_tid;
321                 hammer_modify_volume_done(root_volume);
322         }
323
324         /*
325          * Update the UNDO FIFO's first_offset.  Same deal.
326          */
327         if (rootmap->first_offset != hmp->flusher_undo_start) {
328                 hammer_modify_volume(NULL, root_volume, NULL, 0);
329                 rootmap->first_offset = hmp->flusher_undo_start;
330                 root_volume->ondisk->vol0_blockmap[HAMMER_ZONE_UNDO_INDEX].first_offset = rootmap->first_offset;
331                 hammer_modify_volume_done(root_volume);
332         }
333         trans->hmp->flusher_undo_start = rootmap->next_offset;
334
335         /*
336          * Flush the root volume header.
337          *
338          * If a crash occurs while the root volume header is being written
339          * we just have to hope that the undo range has been updated.  It
340          * should be done in one I/O but XXX this won't be perfect.
341          */
342         if (root_volume->io.modified)
343                 hammer_io_flush(&root_volume->io);
344
345         /*
346          * Wait for I/O to complete
347          */
348         crit_enter();
349         while (hmp->io_running_count)
350                 tsleep(&hmp->io_running_count, 0, "hmrfl2", 0);
351         crit_exit();
352
353         /*
354          * Flush meta-data.  The meta-data will be undone if we crash
355          * so we can safely flush it asynchronously.
356          */
357         count = 0;
358         while ((io = TAILQ_FIRST(&hmp->meta_list)) != NULL) {
359                 KKASSERT(io->modify_refs == 0);
360                 hammer_ref(&io->lock);
361                 KKASSERT(io->type != HAMMER_STRUCTURE_VOLUME);
362                 hammer_io_flush(io);
363                 hammer_rel_buffer((hammer_buffer_t)io, 1);
364                 ++count;
365         }
366         hammer_unlock(&hmp->sync_lock);
367         if (count)
368                 kprintf("Z%d", count);
369 }
370