HAMMER 39/Many: Parallel operations optimizations
[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.7 2008/04/29 01:10:37 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_mount_t hmp,
50                     hammer_volume_t root_volume, hammer_off_t start_offset);
51
52 void
53 hammer_flusher_sync(hammer_mount_t hmp)
54 {
55         int seq;
56
57         if (hmp->flusher_td) {
58                 seq = ++hmp->flusher_seq;
59                 wakeup(&hmp->flusher_seq);
60                 while ((int)(seq - hmp->flusher_act) > 0)
61                         tsleep(&hmp->flusher_act, 0, "hmrfls", 0);
62         }
63 }
64
65 void
66 hammer_flusher_async(hammer_mount_t hmp)
67 {
68         if (hmp->flusher_td) {
69                 ++hmp->flusher_seq;
70                 wakeup(&hmp->flusher_seq);
71         }
72 }
73
74 void
75 hammer_flusher_create(hammer_mount_t hmp)
76 {
77         lwkt_create(hammer_flusher_thread, hmp, &hmp->flusher_td, NULL,
78                     0, -1, "hammer");
79 }
80
81 void
82 hammer_flusher_destroy(hammer_mount_t hmp)
83 {
84         if (hmp->flusher_td) {
85                 hmp->flusher_exiting = 1;
86                 ++hmp->flusher_seq;
87                 wakeup(&hmp->flusher_seq);
88                 while (hmp->flusher_td)
89                         tsleep(&hmp->flusher_exiting, 0, "hmrwex", 0);
90         }
91 }
92
93 static void
94 hammer_flusher_thread(void *arg)
95 {
96         hammer_mount_t hmp = arg;
97         int seq;
98
99         hmp->flusher_demark = kmalloc(sizeof(struct hammer_inode),
100                                       M_HAMMER, M_WAITOK | M_ZERO);
101         TAILQ_INSERT_TAIL(&hmp->flush_list, hmp->flusher_demark, flush_entry);
102
103         for (;;) {
104                 seq = hmp->flusher_seq;
105                 hammer_flusher_clean_loose_ios(hmp);
106                 hammer_flusher_flush(hmp);
107                 hammer_flusher_clean_loose_ios(hmp);
108                 hmp->flusher_act = seq;
109                 wakeup(&hmp->flusher_act);
110                 if (hmp->flusher_exiting)
111                         break;
112                 while (hmp->flusher_seq == hmp->flusher_act)
113                         tsleep(&hmp->flusher_seq, 0, "hmrwwa", 0);
114         }
115         TAILQ_REMOVE(&hmp->flush_list, hmp->flusher_demark, flush_entry);
116         kfree(hmp->flusher_demark, M_HAMMER);
117         hmp->flusher_demark = NULL;
118         hmp->flusher_td = NULL;
119         wakeup(&hmp->flusher_exiting);
120         lwkt_exit();
121 }
122
123 static void
124 hammer_flusher_clean_loose_ios(hammer_mount_t hmp)
125 {
126         hammer_buffer_t buffer;
127         hammer_io_t io;
128
129         /*
130          * loose ends - buffers without bp's aren't tracked by the kernel
131          * and can build up, so clean them out.  This can occur when an
132          * IO completes on a buffer with no references left.
133          */
134         while ((io = TAILQ_FIRST(&hmp->lose_list)) != NULL) {
135                 KKASSERT(io->mod_list == &hmp->lose_list);
136                 TAILQ_REMOVE(io->mod_list, io, mod_entry);
137                 io->mod_list = NULL;
138                 hammer_ref(&io->lock);
139                 buffer = (void *)io;
140                 hammer_rel_buffer(buffer, 0);
141         }
142 }
143
144 /*
145  * Flush stuff
146  */
147 static void
148 hammer_flusher_flush(hammer_mount_t hmp)
149 {
150         hammer_volume_t root_volume;
151         hammer_blockmap_t rootmap;
152         hammer_inode_t ip;
153         hammer_off_t start_offset;
154         int error;
155
156         root_volume = hammer_get_root_volume(hmp, &error);
157         rootmap = &hmp->blockmap[HAMMER_ZONE_UNDO_INDEX];
158         start_offset = rootmap->next_offset;
159
160         if (hammer_debug_general & 0x00010000)
161                 kprintf("x");
162
163         TAILQ_REMOVE(&hmp->flush_list, hmp->flusher_demark, flush_entry);
164         TAILQ_INSERT_TAIL(&hmp->flush_list, hmp->flusher_demark, flush_entry);
165
166         while ((ip = TAILQ_FIRST(&hmp->flush_list)) != hmp->flusher_demark) {
167                 TAILQ_REMOVE(&hmp->flush_list, ip, flush_entry);
168
169                 /*
170                  * We inherit the inode ref from the flush list
171                  */
172                 ip->error = hammer_sync_inode(ip, (ip->vp ? 0 : 1));
173                 hammer_flush_inode_done(ip);
174                 if (hmp->locked_dirty_count > 64 ||
175                     hammer_must_finalize_undo(hmp)) {
176                         hammer_flusher_finalize(hmp, root_volume, start_offset);
177                         start_offset = rootmap->next_offset;
178                 }
179         }
180         hammer_flusher_finalize(hmp, root_volume, start_offset);
181         hammer_rel_volume(root_volume, 0);
182 }
183
184 /*
185  * If the UNDO area gets over half full we have to flush it.  We can't
186  * afford the UNDO area becoming completely full as that would break
187  * the crash recovery atomicy.
188  */
189 static
190 int
191 hammer_must_finalize_undo(hammer_mount_t hmp)
192 {
193         hammer_blockmap_t rootmap;
194         int bytes;
195         int max_bytes;
196
197         rootmap = &hmp->blockmap[HAMMER_ZONE_UNDO_INDEX];
198
199         if (rootmap->first_offset <= rootmap->next_offset) {
200                 bytes = (int)(rootmap->next_offset - rootmap->first_offset);
201         } else {
202                 bytes = (int)(rootmap->alloc_offset - rootmap->first_offset +
203                               rootmap->next_offset);
204         }
205         max_bytes = (int)(rootmap->alloc_offset & HAMMER_OFF_SHORT_MASK);
206         if (bytes > max_bytes / 2)
207                 kprintf("*");
208         return (bytes > max_bytes / 2);
209 }
210
211 /*
212  * To finalize the flush we finish flushing all undo and data buffers
213  * still present, then we update the volume header and flush it,
214  * then we flush out the mata-data (that can now be undone).
215  *
216  * Note that as long as the undo fifo's start and end points do not
217  * match, we always must at least update the volume header.
218  *
219  * The sync_lock is used by other threads to issue modifying operations
220  * to HAMMER media without crossing a synchronization boundary or messing
221  * up the media synchronization operation.  Specifically, the pruning
222  * the reblocking ioctls, and allowing the frontend strategy code to
223  * allocate media data space.
224  */
225 static
226 void
227 hammer_flusher_finalize(hammer_mount_t hmp, hammer_volume_t root_volume,
228                         hammer_off_t start_offset)
229 {
230         hammer_blockmap_t rootmap;
231         hammer_io_t io;
232
233         hammer_lock_ex(&hmp->sync_lock);
234
235         /*
236          * Flush undo bufs
237          */
238         while ((io = TAILQ_FIRST(&hmp->undo_list)) != NULL) {
239                 KKASSERT(io->modify_refs == 0);
240                 hammer_ref(&io->lock);
241                 KKASSERT(io->type != HAMMER_STRUCTURE_VOLUME);
242                 hammer_io_flush(io);
243                 hammer_rel_buffer((hammer_buffer_t)io, 1);
244         }
245
246         /*
247          * Flush data bufs
248          */
249         while ((io = TAILQ_FIRST(&hmp->data_list)) != NULL) {
250                 KKASSERT(io->modify_refs == 0);
251                 hammer_ref(&io->lock);
252                 KKASSERT(io->type != HAMMER_STRUCTURE_VOLUME);
253                 hammer_io_flush(io);
254                 hammer_rel_buffer((hammer_buffer_t)io, 1);
255         }
256
257         /*
258          * Wait for I/O to complete
259          */
260         crit_enter();
261         while (hmp->io_running_count) {
262                 kprintf("W[%d]", hmp->io_running_count);
263                 tsleep(&hmp->io_running_count, 0, "hmrfl1", 0);
264         }
265         crit_exit();
266
267         /*
268          * Update the volume header
269          */
270         rootmap = &hmp->blockmap[HAMMER_ZONE_UNDO_INDEX];
271         if (rootmap->first_offset != start_offset) {
272                 hammer_modify_volume(NULL, root_volume, NULL, 0);
273                 rootmap->first_offset = start_offset;
274                 hammer_modify_volume_done(root_volume);
275         }
276         if (root_volume->ondisk->vol0_next_tid != hmp->next_tid) {
277                 hammer_modify_volume(NULL, root_volume, NULL, 0);
278                 root_volume->ondisk->vol0_next_tid = hmp->next_tid;
279                 hammer_modify_volume_done(root_volume);
280         }
281
282         /*
283          * Sync our cached blockmap array with the one in the root
284          * volume header.
285          */
286         if (root_volume->io.modified) {
287                 bcopy(hmp->blockmap, root_volume->ondisk->vol0_blockmap,
288                       sizeof(hmp->blockmap));
289                 hammer_io_flush(&root_volume->io);
290         }
291
292         /*
293          * Wait for I/O to complete
294          */
295         crit_enter();
296         while (hmp->io_running_count) {
297                 tsleep(&hmp->io_running_count, 0, "hmrfl2", 0);
298         }
299         crit_exit();
300
301         /*
302          * Flush meta-data
303          */
304         while ((io = TAILQ_FIRST(&hmp->meta_list)) != NULL) {
305                 KKASSERT(io->modify_refs == 0);
306                 hammer_ref(&io->lock);
307                 KKASSERT(io->type != HAMMER_STRUCTURE_VOLUME);
308                 hammer_io_flush(io);
309                 hammer_rel_buffer((hammer_buffer_t)io, 1);
310         }
311         hammer_unlock(&hmp->sync_lock);
312 }
313