HAMMER 10/many - synchronize miscellaneous work.
[dragonfly.git] / sbin / newfs_hammer / ondisk.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/sbin/newfs_hammer/Attic/ondisk.c,v 1.5 2007/12/14 08:05:37 dillon Exp $
35  */
36
37 #include "newfs_hammer.h"
38
39 static void initbuffer(hammer_alist_t live, hammer_fsbuf_head_t head,
40                         u_int64_t type);
41 static void alloc_new_buffer(struct cluster_info *cluster, hammer_alist_t live,
42                         u_int64_t type, int32_t nelements);
43 #if 0
44 static void readhammerbuf(struct volume_info *vol, void *data,
45                         int64_t offset);
46 #endif
47 static void writehammerbuf(struct volume_info *vol, const void *data,
48                         int64_t offset);
49
50 /*
51  * Lookup the requested information structure and related on-disk buffer.
52  * Except for getvolume(), these functions will create and initialize any
53  * missing info structures.
54  */
55 struct volume_info *
56 get_volume(int32_t vol_no)
57 {
58         struct volume_info *vol;
59         struct hammer_volume_ondisk *ondisk;
60
61         for (vol = VolBase; vol; vol = vol->next) {
62                 if (vol->vol_no == vol_no)
63                         break;
64         }
65         if (vol && vol->ondisk == NULL) {
66                 vol->ondisk = ondisk = malloc(HAMMER_BUFSIZE);
67                 bzero(ondisk, HAMMER_BUFSIZE);
68                 if (UsingSuperClusters) {
69                         vol->clu_alist.config = &Vol_super_alist_config;
70                         vol->clu_alist.meta = ondisk->vol_almeta.super;
71                         vol->clu_alist.info = vol;
72                         hammer_alist_init(&vol->clu_alist);
73                 } else {
74                         vol->clu_alist.config = &Vol_normal_alist_config;
75                         vol->clu_alist.meta = ondisk->vol_almeta.normal;
76                         hammer_alist_init(&vol->clu_alist);
77                 }
78                 vol->buf_alist.config = &Buf_alist_config;
79                 vol->buf_alist.meta = ondisk->head.buf_almeta;
80                 initbuffer(&vol->buf_alist, &ondisk->head, HAMMER_FSBUF_VOLUME);
81         }
82         return(vol);
83 }
84
85 struct supercl_info *
86 get_supercl(struct volume_info *vol, int32_t scl_no)
87 {
88         struct hammer_supercl_ondisk *ondisk;
89         struct supercl_info *scl;
90         int32_t scl_group;
91         int64_t scl_group_size;
92
93         assert(UsingSuperClusters);
94
95         for (scl = vol->supercl_base; scl; scl = scl->next) {
96                 if (scl->scl_no == scl_no)
97                         break;
98         }
99         if (scl == NULL) {
100                 /*
101                  * Allocate the scl
102                  */
103                 scl = malloc(sizeof(*scl));
104                 bzero(scl, sizeof(*scl));
105                 scl->scl_no = scl_no;
106                 scl->next = vol->supercl_base;
107                 scl->volume = vol;
108                 vol->supercl_base = scl;
109
110                 /*
111                  * Calculate the super-cluster's offset in the volume.
112                  *
113                  * The arrangement is [scl * N][N * 32768 clusters], repeat.
114                  * N is typically 16.
115                  */
116                 scl_group = scl_no / HAMMER_VOL_SUPERCLUSTER_GROUP;
117                 scl_group_size = ((int64_t)HAMMER_BUFSIZE *
118                                   HAMMER_VOL_SUPERCLUSTER_GROUP) +
119                                   ((int64_t)HAMMER_VOL_SUPERCLUSTER_GROUP *
120                                   ClusterSize * HAMMER_SCL_MAXCLUSTERS);
121                 scl->scl_offset = vol->ondisk->vol_clo_beg +
122                                   scl_group * scl_group_size +
123                                   (scl_no % HAMMER_VOL_SUPERCLUSTER_GROUP) *
124                                   HAMMER_BUFSIZE;
125         }
126         if (scl->ondisk == NULL) {
127                 scl->ondisk = ondisk = malloc(HAMMER_BUFSIZE);
128                 bzero(ondisk, HAMMER_BUFSIZE);
129                 scl->clu_alist.config = &Supercl_alist_config;
130                 scl->clu_alist.meta = ondisk->scl_meta;
131                 hammer_alist_init(&scl->clu_alist);
132                 scl->buf_alist.config = &Buf_alist_config;
133                 scl->buf_alist.meta = ondisk->head.buf_almeta;
134                 initbuffer(&scl->buf_alist, &ondisk->head, HAMMER_FSBUF_SUPERCL);
135         }
136         return(scl);
137 }
138
139 struct cluster_info *
140 get_cluster(struct volume_info *vol, int32_t clu_no)
141 {
142         struct hammer_cluster_ondisk *ondisk;
143         struct cluster_info *cl;
144         int32_t scl_group;
145         int64_t scl_group_size;
146
147         for (cl = vol->cluster_base; cl; cl = cl->next) {
148                 if (cl->clu_no == clu_no)
149                         break;
150         }
151         if (cl == NULL) {
152                 /*
153                  * Allocate the cluster
154                  */
155                 cl = malloc(sizeof(*cl));
156                 bzero(cl, sizeof(*cl));
157                 cl->clu_no = clu_no;
158                 cl->next = vol->cluster_base;
159                 if (UsingSuperClusters) {
160                         cl->supercl = get_supercl(vol, clu_no / HAMMER_SCL_MAXCLUSTERS);
161                 }
162                 cl->volume = vol;
163                 vol->cluster_base = cl;
164
165                 /*
166                  * Calculate the cluster's offset in the volume
167                  *
168                  * The arrangement is [scl * N][N * 32768 clusters], repeat.
169                  * N is typically 16.
170                  *
171                  * Note that the cluster offset calculation is slightly
172                  * different from the supercluster offset calculation due
173                  * to the way the grouping works.
174                  */
175                 if (UsingSuperClusters) {
176                         scl_group = clu_no / HAMMER_VOL_SUPERCLUSTER_GROUP /
177                                     HAMMER_SCL_MAXCLUSTERS;
178                         scl_group_size = 
179                                 ((int64_t)HAMMER_BUFSIZE *
180                                 HAMMER_VOL_SUPERCLUSTER_GROUP) +
181                                 ((int64_t)HAMMER_VOL_SUPERCLUSTER_GROUP *
182                                 ClusterSize * HAMMER_SCL_MAXCLUSTERS);
183                         scl_group_size += HAMMER_VOL_SUPERCLUSTER_GROUP *
184                                           HAMMER_BUFSIZE;
185                         cl->clu_offset =
186                                 vol->ondisk->vol_clo_beg +
187                                 scl_group * scl_group_size +
188                                 (HAMMER_BUFSIZE * HAMMER_VOL_SUPERCLUSTER_GROUP) +
189                                  ((int64_t)clu_no % ((int64_t)HAMMER_SCL_MAXCLUSTERS * HAMMER_VOL_SUPERCLUSTER_GROUP)) *
190                                  HAMMER_BUFSIZE;
191                 } else {
192                         cl->clu_offset = vol->ondisk->vol_clo_beg +
193                                          (int64_t)clu_no * ClusterSize;
194                 }
195         }
196         if (cl->ondisk == NULL) {
197                 cl->ondisk = ondisk = malloc(HAMMER_BUFSIZE);
198                 bzero(ondisk, HAMMER_BUFSIZE);
199                 cl->alist_master.config = &Clu_master_alist_config;
200                 cl->alist_master.meta = ondisk->clu_master_meta;
201                 hammer_alist_init(&cl->alist_master);
202                 cl->alist_btree.config = &Clu_slave_alist_config;
203                 cl->alist_btree.meta = ondisk->clu_btree_meta;
204                 cl->alist_btree.info = cl;
205                 hammer_alist_init(&cl->alist_btree);
206                 cl->alist_record.config = &Clu_slave_alist_config;
207                 cl->alist_record.meta = ondisk->clu_record_meta;
208                 cl->alist_record.info = cl;
209                 hammer_alist_init(&cl->alist_record);
210                 cl->alist_mdata.config = &Clu_slave_alist_config;
211                 cl->alist_mdata.meta = ondisk->clu_mdata_meta;
212                 cl->alist_mdata.info = cl;
213                 hammer_alist_init(&cl->alist_mdata);
214         }
215         return(cl);
216 }
217
218 struct buffer_info *
219 get_buffer(struct cluster_info *cl, int32_t buf_no, int64_t buf_type)
220 {
221         hammer_fsbuf_ondisk_t ondisk;
222         struct buffer_info *buf;
223
224         /*
225          * Find the buffer.  Note that buffer 0 corresponds to the cluster
226          * header and should never be requested.
227          */
228         assert(buf_no != 0);
229         for (buf = cl->buffer_base; buf; buf = buf->next) {
230                 if (buf->buf_no == buf_no)
231                         break;
232         }
233         if (buf == NULL) {
234                 buf = malloc(sizeof(*buf));
235                 bzero(buf, sizeof(*buf));
236                 buf->buf_no = buf_no;
237                 buf->buf_offset = cl->clu_offset + buf_no * HAMMER_BUFSIZE;
238                 buf->cluster = cl;
239                 buf->volume = cl->volume;
240                 buf->next = cl->buffer_base;
241                 cl->buffer_base = buf;
242         }
243         if (buf->ondisk == NULL) {
244                 buf->ondisk = ondisk = malloc(HAMMER_BUFSIZE);
245                 bzero(ondisk, HAMMER_BUFSIZE);
246                 buf->alist.config = &Buf_alist_config;
247                 buf->alist.meta = ondisk->head.buf_almeta;
248                 initbuffer(&buf->alist, &ondisk->head, buf_type);
249         }
250         return(buf);
251 }
252
253 /*
254  * Allocate HAMMER elements - btree nodes, data storage, and record elements
255  */
256 void *
257 alloc_btree_element(struct cluster_info *cluster, int32_t *offp)
258 {
259         struct buffer_info *buf;
260         hammer_alist_t live;
261         int32_t elm_no;
262         void *item;
263
264         live = &cluster->alist_btree;
265         elm_no = hammer_alist_alloc_fwd(live, 1, cluster->ondisk->idx_index);
266         if (elm_no == HAMMER_ALIST_BLOCK_NONE)
267                 elm_no = hammer_alist_alloc_fwd(live, 1, 0);
268         if (elm_no == HAMMER_ALIST_BLOCK_NONE) {
269                 alloc_new_buffer(cluster, live,
270                                  HAMMER_FSBUF_BTREE, HAMMER_BTREE_NODES);
271                 ++cluster->ondisk->stat_idx_bufs;
272                 ++cluster->volume->ondisk->vol_stat_idx_bufs;
273                 ++cluster->volume->ondisk->vol0_stat_idx_bufs;
274                 elm_no = hammer_alist_alloc(live, 1);
275                 assert(elm_no != HAMMER_ALIST_BLOCK_NONE);
276         }
277         cluster->ondisk->idx_index = elm_no;
278         buf = get_buffer(cluster, elm_no / HAMMER_FSBUF_MAXBLKS, 0);
279         assert(buf->ondisk->head.buf_type != 0);
280         item = &buf->ondisk->btree.nodes[elm_no & HAMMER_FSBUF_BLKMASK];
281         *offp = buf->buf_no * HAMMER_BUFSIZE +
282                 ((char *)item - (char *)buf->ondisk);
283         return(item);
284 }
285
286 void *
287 alloc_data_element(struct cluster_info *cluster, int32_t bytes, int32_t *offp)
288 {
289         struct buffer_info *buf;
290         hammer_alist_t live;
291         int32_t elm_no;
292         int32_t nblks = (bytes + HAMMER_DATA_BLKMASK) & ~HAMMER_DATA_BLKMASK;
293         void *item;
294
295         /*
296          * Try to allocate a btree-node.  If elm_no is HAMMER_ALIST_BLOCK_NONE
297          * and buf is non-NULL we have to initialize a new buffer's a-list.
298          */
299         live = &cluster->alist_mdata;
300         elm_no = hammer_alist_alloc_fwd(live, nblks, cluster->ondisk->idx_data);
301         if (elm_no == HAMMER_ALIST_BLOCK_NONE)
302                 elm_no = hammer_alist_alloc_fwd(live, 1, 0);
303         if (elm_no == HAMMER_ALIST_BLOCK_NONE) {
304                 alloc_new_buffer(cluster, live,
305                                  HAMMER_FSBUF_DATA, HAMMER_DATA_NODES);
306                 ++cluster->ondisk->stat_data_bufs;
307                 ++cluster->volume->ondisk->vol_stat_data_bufs;
308                 ++cluster->volume->ondisk->vol0_stat_data_bufs;
309                 elm_no = hammer_alist_alloc(live, nblks);
310                 assert(elm_no != HAMMER_ALIST_BLOCK_NONE);
311         }
312         cluster->ondisk->idx_index = elm_no;
313         buf = get_buffer(cluster, elm_no / HAMMER_FSBUF_MAXBLKS, 0);
314         assert(buf->ondisk->head.buf_type != 0);
315         item = &buf->ondisk->data.data[elm_no & HAMMER_FSBUF_BLKMASK];
316         *offp = buf->buf_no * HAMMER_BUFSIZE +
317                 ((char *)item - (char *)buf->ondisk);
318         return(item);
319 }
320
321 void *
322 alloc_record_element(struct cluster_info *cluster, int32_t *offp)
323 {
324         struct buffer_info *buf;
325         hammer_alist_t live;
326         int32_t elm_no;
327         void *item;
328
329         live = &cluster->alist_record;
330         elm_no = hammer_alist_alloc_rev(live, 1, cluster->ondisk->idx_record);
331         if (elm_no == HAMMER_ALIST_BLOCK_NONE)
332                 elm_no = hammer_alist_alloc_rev(live, 1,HAMMER_ALIST_BLOCK_MAX);
333         if (elm_no == HAMMER_ALIST_BLOCK_NONE) {
334                 alloc_new_buffer(cluster, live,
335                                  HAMMER_FSBUF_RECORDS, HAMMER_RECORD_NODES);
336                 ++cluster->ondisk->stat_rec_bufs;
337                 ++cluster->volume->ondisk->vol_stat_rec_bufs;
338                 ++cluster->volume->ondisk->vol0_stat_rec_bufs;
339                 elm_no = hammer_alist_alloc_rev(live, 1,HAMMER_ALIST_BLOCK_MAX);
340                 assert(elm_no != HAMMER_ALIST_BLOCK_NONE);
341         }
342         cluster->ondisk->idx_record = elm_no;
343         buf = get_buffer(cluster, elm_no / HAMMER_FSBUF_MAXBLKS, 0);
344         assert(buf->ondisk->head.buf_type != 0);
345         item = &buf->ondisk->record.recs[elm_no & HAMMER_FSBUF_BLKMASK];
346         *offp = buf->buf_no * HAMMER_BUFSIZE +
347                 ((char *)item - (char *)buf->ondisk);
348         return(item);
349 }
350
351 static void
352 alloc_new_buffer(struct cluster_info *cluster, hammer_alist_t live,
353                  u_int64_t type, int32_t nelements)
354 {
355         int32_t buf_no;
356         struct buffer_info *buf;
357
358         if (type == HAMMER_FSBUF_RECORDS) {
359                 buf_no = hammer_alist_alloc_rev(&cluster->alist_master, 1,
360                                                 HAMMER_ALIST_BLOCK_MAX);
361         } else {
362                 buf_no = hammer_alist_alloc_fwd(&cluster->alist_master, 1, 
363                                                 0);
364         }
365         assert(buf_no != HAMMER_ALIST_BLOCK_NONE);
366         buf = get_buffer(cluster, buf_no, type);
367         hammer_alist_free(live, buf_no * HAMMER_FSBUF_MAXBLKS, nelements);
368 }
369
370 /*
371  * Flush various tracking structures to disk
372  */
373
374 /*
375  * Flush various tracking structures to disk
376  */
377 void
378 flush_all_volumes(void)
379 {
380         struct volume_info *vol;
381
382         for (vol = VolBase; vol; vol = vol->next)
383                 flush_volume(vol);
384 }
385
386 void
387 flush_volume(struct volume_info *vol)
388 {
389         struct supercl_info *supercl;
390         struct cluster_info *cl;
391
392         for (supercl = vol->supercl_base; supercl; supercl = supercl->next)
393                 flush_supercl(supercl);
394         for (cl = vol->cluster_base; cl; cl = cl->next)
395                 flush_cluster(cl);
396         writehammerbuf(vol, vol->ondisk, 0);
397 }
398
399 void
400 flush_supercl(struct supercl_info *supercl)
401 {
402         int64_t supercl_offset;
403
404         supercl_offset = supercl->scl_offset;
405         writehammerbuf(supercl->volume, supercl->ondisk, supercl_offset);
406 }
407
408 void
409 flush_cluster(struct cluster_info *cl)
410 {
411         struct buffer_info *buf;
412         int64_t cluster_offset;
413
414         for (buf = cl->buffer_base; buf; buf = buf->next)
415                 flush_buffer(buf);
416         cluster_offset = cl->clu_offset;
417         writehammerbuf(cl->volume, cl->ondisk, cluster_offset);
418 }
419
420 void
421 flush_buffer(struct buffer_info *buf)
422 {
423         writehammerbuf(buf->volume, buf->ondisk, buf->buf_offset);
424 }
425
426 /*
427  * Generic buffer initialization
428  */
429 static void
430 initbuffer(hammer_alist_t live, hammer_fsbuf_head_t head, u_int64_t type)
431 {
432         head->buf_type = type;
433         hammer_alist_init(live);
434 }
435
436 #if 0
437 /*
438  * Core I/O operations
439  */
440 static void
441 readhammerbuf(struct volume_info *vol, void *data, int64_t offset)
442 {
443         ssize_t n;
444
445         n = pread(vol->fd, data, HAMMER_BUFSIZE, offset);
446         if (n != HAMMER_BUFSIZE)
447                 err(1, "Read volume %d (%s)", vol->vol_no, vol->name);
448 }
449
450 #endif
451
452 static void
453 writehammerbuf(struct volume_info *vol, const void *data, int64_t offset)
454 {
455         ssize_t n;
456
457         n = pwrite(vol->fd, data, HAMMER_BUFSIZE, offset);
458         if (n != HAMMER_BUFSIZE)
459                 err(1, "Write volume %d (%s)", vol->vol_no, vol->name);
460 }
461