2 * Copyright (c) 2007 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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
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.
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
35 #include <sys/diskslice.h>
36 #include <sys/diskmbr.h>
38 #include "hammer_util.h"
40 static void check_volume(struct volume_info *volume);
41 static void get_buffer_readahead(struct buffer_info *base);
42 static __inline int readhammervol(struct volume_info *volume);
43 static __inline int readhammerbuf(struct buffer_info *buffer);
44 static __inline int writehammervol(struct volume_info *volume);
45 static __inline int writehammerbuf(struct buffer_info *buffer);
49 int UseReadBehind = -4;
52 uint32_t HammerVersion = -1;
54 TAILQ_HEAD(volume_list, volume_info);
55 static struct volume_list VolList = TAILQ_HEAD_INITIALIZER(VolList);
56 static int valid_hammer_volumes;
60 buffer_hash(hammer_off_t zone2_offset)
64 hi = (int)(zone2_offset / HAMMER_BUFSIZE) & HAMMER_BUFLISTMASK;
68 static struct buffer_info*
69 find_buffer(hammer_off_t zone2_offset)
71 struct volume_info *volume;
72 struct buffer_info *buffer;
75 volume = get_volume(HAMMER_VOL_DECODE(zone2_offset));
78 hi = buffer_hash(zone2_offset);
79 TAILQ_FOREACH(buffer, &volume->buffer_lists[hi], entry)
80 if (buffer->zone2_offset == zone2_offset)
87 __alloc_volume(const char *volname, int oflags)
89 struct volume_info *volume;
92 volume = calloc(1, sizeof(*volume));
94 volume->rdonly = (oflags == O_RDONLY);
95 volume->name = strdup(volname);
96 volume->fd = open(volume->name, oflags);
98 err(1, "alloc_volume: Failed to open %s", volume->name);
101 volume->ondisk = calloc(1, HAMMER_BUFSIZE);
103 for (i = 0; i < HAMMER_BUFLISTS; ++i)
104 TAILQ_INIT(&volume->buffer_lists[i]);
110 __add_volume(struct volume_info *volume)
112 struct volume_info *scan;
113 struct stat st1, st2;
115 if (fstat(volume->fd, &st1) != 0)
116 errx(1, "add_volume: %s: Failed to stat", volume->name);
118 TAILQ_FOREACH(scan, &VolList, entry) {
119 if (scan->vol_no == volume->vol_no) {
120 errx(1, "add_volume: %s: Duplicate volume number %d "
122 volume->name, volume->vol_no, scan->name);
124 if (fstat(scan->fd, &st2) != 0) {
125 errx(1, "add_volume: %s: Failed to stat %s",
126 volume->name, scan->name);
128 if ((st1.st_ino == st2.st_ino) && (st1.st_dev == st2.st_dev)) {
129 errx(1, "add_volume: %s: Specified more than once",
134 TAILQ_INSERT_TAIL(&VolList, volume, entry);
138 __verify_volume(struct volume_info *volume)
140 hammer_volume_ondisk_t ondisk = volume->ondisk;
142 if (ondisk->vol_signature != HAMMER_FSBUF_VOLUME) {
143 errx(1, "verify_volume: Invalid volume signature %016jx",
144 ondisk->vol_signature);
146 if (ondisk->vol_rootvol != HAMMER_ROOT_VOLNO) {
147 errx(1, "verify_volume: Invalid root volume# %d",
148 ondisk->vol_rootvol);
150 if (bcmp(&Hammer_FSType, &ondisk->vol_fstype, sizeof(Hammer_FSType))) {
151 errx(1, "verify_volume: %s: Header does not indicate "
152 "that this is a HAMMER volume", volume->name);
154 if (bcmp(&Hammer_FSId, &ondisk->vol_fsid, sizeof(Hammer_FSId))) {
155 errx(1, "verify_volume: %s: FSId does not match other volumes!",
161 * Initialize a volume structure and ondisk vol_no field.
164 init_volume(const char *filename, int oflags, int32_t vol_no)
166 struct volume_info *volume;
168 volume = __alloc_volume(filename, oflags);
169 volume->vol_no = volume->ondisk->vol_no = vol_no;
171 __add_volume(volume);
177 * Initialize a volume structure and read ondisk volume header.
180 load_volume(const char *filename, int oflags, int verify)
182 struct volume_info *volume;
185 volume = __alloc_volume(filename, oflags);
187 n = readhammervol(volume);
189 err(1, "load_volume: %s: Read failed at offset 0",
192 volume->vol_no = volume->ondisk->vol_no;
193 HammerVersion = volume->ondisk->vol_version;
195 if (valid_hammer_volumes++ == 0)
196 Hammer_FSId = volume->ondisk->vol_fsid;
198 __verify_volume(volume);
200 __add_volume(volume);
206 * Check basic volume characteristics.
209 check_volume(struct volume_info *volume)
211 struct partinfo pinfo;
215 * Allow the formatting of block devices or regular files
217 if (ioctl(volume->fd, DIOCGPART, &pinfo) < 0) {
218 if (fstat(volume->fd, &st) < 0)
219 err(1, "Unable to stat %s", volume->name);
220 if (S_ISREG(st.st_mode)) {
221 volume->size = st.st_size;
222 volume->type = "REGFILE";
224 errx(1, "Unsupported file type for %s", volume->name);
229 * When formatting a block device as a HAMMER volume the
230 * sector size must be compatible. HAMMER uses 16384 byte
231 * filesystem buffers.
233 if (pinfo.reserved_blocks) {
234 errx(1, "HAMMER cannot be placed in a partition "
235 "which overlaps the disklabel or MBR");
237 if (pinfo.media_blksize > HAMMER_BUFSIZE ||
238 HAMMER_BUFSIZE % pinfo.media_blksize) {
239 errx(1, "A media sector size of %d is not supported",
240 pinfo.media_blksize);
243 volume->size = pinfo.media_size;
244 volume->device_offset = pinfo.media_offset;
245 volume->type = "DEVICE";
250 is_regfile(struct volume_info *volume)
252 return(strcmp(volume->type, "REGFILE") ? 0 : 1);
256 assert_volume_offset(struct volume_info *volume)
258 assert(hammer_is_zone_raw_buffer(volume->vol_free_off));
259 assert(hammer_is_zone_raw_buffer(volume->vol_free_end));
260 if (volume->vol_free_off >= volume->vol_free_end)
261 errx(1, "Ran out of room, filesystem too small");
265 get_volume(int32_t vol_no)
267 struct volume_info *volume;
269 TAILQ_FOREACH(volume, &VolList, entry) {
270 if (volume->vol_no == vol_no)
278 get_root_volume(void)
280 return(get_volume(HAMMER_ROOT_VOLNO));
284 __blockmap_xlate_to_zone2(hammer_off_t buf_offset)
286 hammer_off_t zone2_offset;
289 if (hammer_is_zone_raw_buffer(buf_offset))
290 zone2_offset = buf_offset;
292 zone2_offset = blockmap_lookup(buf_offset, &error);
295 return(HAMMER_OFF_BAD);
296 assert(hammer_is_zone_raw_buffer(zone2_offset));
298 return(zone2_offset);
301 static struct buffer_info *
302 __alloc_buffer(hammer_off_t zone2_offset, int isnew)
304 struct volume_info *volume;
305 struct buffer_info *buffer;
308 volume = get_volume(HAMMER_VOL_DECODE(zone2_offset));
309 assert(volume != NULL);
311 buffer = calloc(1, sizeof(*buffer));
312 buffer->zone2_offset = zone2_offset;
313 buffer->raw_offset = hammer_xlate_to_phys(volume->ondisk, zone2_offset);
314 buffer->volume = volume;
315 buffer->ondisk = calloc(1, HAMMER_BUFSIZE);
318 if (readhammerbuf(buffer) == -1) {
319 err(1, "Failed to read %s:%016jx at %016jx",
321 (intmax_t)buffer->zone2_offset,
322 (intmax_t)buffer->raw_offset);
326 hi = buffer_hash(zone2_offset);
327 TAILQ_INSERT_TAIL(&volume->buffer_lists[hi], buffer, entry);
328 hammer_cache_add(&buffer->cache);
334 * Acquire the 16KB buffer for specified zone offset.
336 static struct buffer_info *
337 get_buffer(hammer_off_t buf_offset, int isnew)
339 struct buffer_info *buffer;
340 hammer_off_t zone2_offset;
343 zone2_offset = __blockmap_xlate_to_zone2(buf_offset);
344 if (zone2_offset == HAMMER_OFF_BAD)
347 zone2_offset &= ~HAMMER_BUFMASK64;
348 buffer = find_buffer(zone2_offset);
350 if (buffer == NULL) {
351 buffer = __alloc_buffer(zone2_offset, isnew);
355 hammer_cache_used(&buffer->cache);
357 assert(buffer->ondisk != NULL);
359 ++buffer->cache.refs;
360 hammer_cache_flush();
363 assert(buffer->cache.modified == 0);
364 bzero(buffer->ondisk, HAMMER_BUFSIZE);
365 buffer->cache.modified = 1;
368 get_buffer_readahead(buffer);
373 get_buffer_readahead(struct buffer_info *base)
375 struct buffer_info *buffer;
376 struct volume_info *volume;
377 hammer_off_t zone2_offset;
379 int ri = UseReadBehind;
380 int re = UseReadAhead;
382 raw_offset = base->raw_offset + ri * HAMMER_BUFSIZE;
383 volume = base->volume;
386 if (raw_offset >= volume->ondisk->vol_buf_end)
388 if (raw_offset < volume->ondisk->vol_buf_beg || ri == 0) {
390 raw_offset += HAMMER_BUFSIZE;
393 zone2_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no,
394 raw_offset - volume->ondisk->vol_buf_beg);
395 buffer = find_buffer(zone2_offset);
396 if (buffer == NULL) {
397 /* call with -1 to prevent another readahead */
398 buffer = get_buffer(zone2_offset, -1);
402 raw_offset += HAMMER_BUFSIZE;
407 rel_buffer(struct buffer_info *buffer)
409 struct volume_info *volume;
414 assert(buffer->cache.refs > 0);
415 if (--buffer->cache.refs == 0) {
416 if (buffer->cache.delete) {
417 hi = buffer_hash(buffer->zone2_offset);
418 volume = buffer->volume;
419 if (buffer->cache.modified)
420 flush_buffer(buffer);
421 TAILQ_REMOVE(&volume->buffer_lists[hi], buffer, entry);
422 hammer_cache_del(&buffer->cache);
423 free(buffer->ondisk);
430 * Retrieve a pointer to a buffer data given a buffer offset. The underlying
431 * bufferp is freed if isnew or the offset is out of range of the cached data.
432 * If bufferp is freed a referenced buffer is loaded into it.
435 get_buffer_data(hammer_off_t buf_offset, struct buffer_info **bufferp,
440 if (*bufferp != NULL) {
441 /* XXX xor is always non zero for indirect zones */
442 xor = HAMMER_OFF_LONG_ENCODE(buf_offset) ^
443 HAMMER_OFF_LONG_ENCODE((*bufferp)->zone2_offset);
444 if (isnew > 0 || (xor & ~HAMMER_BUFMASK64)) {
445 rel_buffer(*bufferp);
450 if (*bufferp == NULL) {
451 *bufferp = get_buffer(buf_offset, isnew);
452 if (*bufferp == NULL)
456 return(((char *)(*bufferp)->ondisk) +
457 ((int32_t)buf_offset & HAMMER_BUFMASK));
461 * Allocate HAMMER elements - B-Tree nodes
464 alloc_btree_node(hammer_off_t *offp, struct buffer_info **data_bufferp)
466 hammer_node_ondisk_t node;
468 node = alloc_blockmap(HAMMER_ZONE_BTREE_INDEX, sizeof(*node),
470 bzero(node, sizeof(*node));
475 * Allocate HAMMER elements - meta data (inode, direntry, PFS, etc)
478 alloc_meta_element(hammer_off_t *offp, int32_t data_len,
479 struct buffer_info **data_bufferp)
483 data = alloc_blockmap(HAMMER_ZONE_META_INDEX, data_len,
485 bzero(data, data_len);
490 * Format a new blockmap. This is mostly a degenerate case because
491 * all allocations are now actually done from the freemap.
494 format_blockmap(struct volume_info *root_vol, int zone, hammer_off_t offset)
496 hammer_blockmap_t blockmap;
497 hammer_off_t zone_base;
499 /* Only root volume needs formatting */
500 assert(root_vol->vol_no == HAMMER_ROOT_VOLNO);
502 assert(hammer_is_index_record(zone));
504 blockmap = &root_vol->ondisk->vol0_blockmap[zone];
505 zone_base = HAMMER_ZONE_ENCODE(zone, offset);
507 bzero(blockmap, sizeof(*blockmap));
508 blockmap->phys_offset = 0;
509 blockmap->first_offset = zone_base;
510 blockmap->next_offset = zone_base;
511 blockmap->alloc_offset = HAMMER_ENCODE(zone, 255, -1);
512 hammer_crc_set_blockmap(HammerVersion, blockmap);
516 * Format a new freemap. Set all layer1 entries to UNAVAIL. The initialize
517 * code will load each volume's freemap.
520 format_freemap(struct volume_info *root_vol)
522 struct buffer_info *buffer = NULL;
523 hammer_off_t layer1_offset;
524 hammer_blockmap_t blockmap;
525 hammer_blockmap_layer1_t layer1;
528 /* Only root volume needs formatting */
529 assert(root_vol->vol_no == HAMMER_ROOT_VOLNO);
531 layer1_offset = bootstrap_bigblock(root_vol);
532 for (i = 0; i < HAMMER_BIGBLOCK_SIZE; i += sizeof(*layer1)) {
533 isnew = ((i % HAMMER_BUFSIZE) == 0);
534 layer1 = get_buffer_data(layer1_offset + i, &buffer, isnew);
535 bzero(layer1, sizeof(*layer1));
536 layer1->phys_offset = HAMMER_BLOCKMAP_UNAVAIL;
537 layer1->blocks_free = 0;
538 hammer_crc_set_layer1(HammerVersion, layer1);
540 assert(i == HAMMER_BIGBLOCK_SIZE);
543 blockmap = &root_vol->ondisk->vol0_blockmap[HAMMER_ZONE_FREEMAP_INDEX];
544 bzero(blockmap, sizeof(*blockmap));
545 blockmap->phys_offset = layer1_offset;
546 blockmap->first_offset = 0;
547 blockmap->next_offset = HAMMER_ENCODE_RAW_BUFFER(0, 0);
548 blockmap->alloc_offset = HAMMER_ENCODE_RAW_BUFFER(255, -1);
549 hammer_crc_set_blockmap(HammerVersion, blockmap);
553 * Load the volume's remaining free space into the freemap.
555 * Returns the number of big-blocks available.
558 initialize_freemap(struct volume_info *volume)
560 struct volume_info *root_vol;
561 struct buffer_info *buffer1 = NULL;
562 struct buffer_info *buffer2 = NULL;
563 hammer_blockmap_layer1_t layer1;
564 hammer_blockmap_layer2_t layer2;
565 hammer_off_t layer1_offset;
566 hammer_off_t layer2_offset;
567 hammer_off_t phys_offset;
568 hammer_off_t block_offset;
569 hammer_off_t aligned_vol_free_end;
570 hammer_blockmap_t freemap;
572 int64_t layer1_count = 0;
574 root_vol = get_root_volume();
576 assert_volume_offset(volume);
577 aligned_vol_free_end = HAMMER_BLOCKMAP_LAYER2_DOALIGN(volume->vol_free_end);
579 printf("initialize freemap volume %d\n", volume->vol_no);
582 * Initialize the freemap. First preallocate the big-blocks required
583 * to implement layer2. This preallocation is a bootstrap allocation
584 * using blocks from the target volume.
586 freemap = &root_vol->ondisk->vol0_blockmap[HAMMER_ZONE_FREEMAP_INDEX];
588 for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);
589 phys_offset < aligned_vol_free_end;
590 phys_offset += HAMMER_BLOCKMAP_LAYER2) {
591 layer1_offset = freemap->phys_offset +
592 HAMMER_BLOCKMAP_LAYER1_OFFSET(phys_offset);
593 layer1 = get_buffer_data(layer1_offset, &buffer1, 0);
594 if (layer1->phys_offset == HAMMER_BLOCKMAP_UNAVAIL) {
595 layer1->phys_offset = bootstrap_bigblock(volume);
596 layer1->blocks_free = 0;
597 buffer1->cache.modified = 1;
598 hammer_crc_set_layer1(HammerVersion, layer1);
603 * Now fill everything in.
605 for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);
606 phys_offset < aligned_vol_free_end;
607 phys_offset += HAMMER_BLOCKMAP_LAYER2) {
609 layer1_offset = freemap->phys_offset +
610 HAMMER_BLOCKMAP_LAYER1_OFFSET(phys_offset);
611 layer1 = get_buffer_data(layer1_offset, &buffer1, 0);
612 assert(layer1->phys_offset != HAMMER_BLOCKMAP_UNAVAIL);
614 for (block_offset = 0;
615 block_offset < HAMMER_BLOCKMAP_LAYER2;
616 block_offset += HAMMER_BIGBLOCK_SIZE) {
617 layer2_offset = layer1->phys_offset +
618 HAMMER_BLOCKMAP_LAYER2_OFFSET(block_offset);
619 layer2 = get_buffer_data(layer2_offset, &buffer2, 0);
620 bzero(layer2, sizeof(*layer2));
622 if (phys_offset + block_offset < volume->vol_free_off) {
624 * Big-blocks already allocated as part
625 * of the freemap bootstrap.
627 layer2->zone = HAMMER_ZONE_FREEMAP_INDEX;
628 layer2->append_off = HAMMER_BIGBLOCK_SIZE;
629 layer2->bytes_free = 0;
630 } else if (phys_offset + block_offset < volume->vol_free_end) {
632 layer2->append_off = 0;
633 layer2->bytes_free = HAMMER_BIGBLOCK_SIZE;
637 layer2->zone = HAMMER_ZONE_UNAVAIL_INDEX;
638 layer2->append_off = HAMMER_BIGBLOCK_SIZE;
639 layer2->bytes_free = 0;
641 hammer_crc_set_layer2(HammerVersion, layer2);
642 buffer2->cache.modified = 1;
645 layer1->blocks_free += layer1_count;
646 hammer_crc_set_layer1(HammerVersion, layer1);
647 buffer1->cache.modified = 1;
656 * Returns the number of big-blocks available for filesystem data and undos
657 * without formatting.
660 count_freemap(struct volume_info *volume)
662 hammer_off_t phys_offset;
663 hammer_off_t vol_free_off;
664 hammer_off_t aligned_vol_free_end;
667 vol_free_off = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);
669 assert_volume_offset(volume);
670 aligned_vol_free_end = HAMMER_BLOCKMAP_LAYER2_DOALIGN(volume->vol_free_end);
672 if (volume->vol_no == HAMMER_ROOT_VOLNO)
673 vol_free_off += HAMMER_BIGBLOCK_SIZE;
675 for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);
676 phys_offset < aligned_vol_free_end;
677 phys_offset += HAMMER_BLOCKMAP_LAYER2) {
678 vol_free_off += HAMMER_BIGBLOCK_SIZE;
681 for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);
682 phys_offset < aligned_vol_free_end;
683 phys_offset += HAMMER_BIGBLOCK_SIZE) {
684 if (phys_offset < vol_free_off)
686 else if (phys_offset < volume->vol_free_end)
694 * Format the undomap for the root volume.
697 format_undomap(struct volume_info *root_vol, int64_t *undo_buffer_size)
699 hammer_off_t undo_limit;
700 hammer_blockmap_t blockmap;
701 hammer_volume_ondisk_t ondisk;
702 struct buffer_info *buffer = NULL;
708 /* Only root volume needs formatting */
709 assert(root_vol->vol_no == HAMMER_ROOT_VOLNO);
710 ondisk = root_vol->ondisk;
713 * Size the undo buffer in multiples of HAMMER_BIGBLOCK_SIZE,
714 * up to HAMMER_MAX_UNDO_BIGBLOCKS big-blocks.
715 * Size to approximately 0.1% of the disk.
717 * The minimum UNDO fifo size is 512MB, or approximately 1% of
718 * the recommended 50G disk.
720 * Changing this minimum is rather dangerous as complex filesystem
721 * operations can cause the UNDO FIFO to fill up otherwise.
723 undo_limit = *undo_buffer_size;
724 if (undo_limit == 0) {
725 undo_limit = HAMMER_VOL_BUF_SIZE(ondisk) / 1000;
726 if (undo_limit < HAMMER_BIGBLOCK_SIZE * HAMMER_MIN_UNDO_BIGBLOCKS)
727 undo_limit = HAMMER_BIGBLOCK_SIZE * HAMMER_MIN_UNDO_BIGBLOCKS;
729 undo_limit = HAMMER_BIGBLOCK_DOALIGN(undo_limit);
730 if (undo_limit < HAMMER_BIGBLOCK_SIZE)
731 undo_limit = HAMMER_BIGBLOCK_SIZE;
732 if (undo_limit > HAMMER_BIGBLOCK_SIZE * HAMMER_MAX_UNDO_BIGBLOCKS)
733 undo_limit = HAMMER_BIGBLOCK_SIZE * HAMMER_MAX_UNDO_BIGBLOCKS;
734 *undo_buffer_size = undo_limit;
736 blockmap = &ondisk->vol0_blockmap[HAMMER_ZONE_UNDO_INDEX];
737 bzero(blockmap, sizeof(*blockmap));
738 blockmap->phys_offset = HAMMER_BLOCKMAP_UNAVAIL;
739 blockmap->first_offset = HAMMER_ENCODE_UNDO(0);
740 blockmap->next_offset = blockmap->first_offset;
741 blockmap->alloc_offset = HAMMER_ENCODE_UNDO(undo_limit);
742 hammer_crc_set_blockmap(HammerVersion, blockmap);
744 limit_index = undo_limit / HAMMER_BIGBLOCK_SIZE;
745 assert(limit_index <= HAMMER_MAX_UNDO_BIGBLOCKS);
747 for (n = 0; n < limit_index; ++n)
748 ondisk->vol0_undo_array[n] = alloc_undo_bigblock(root_vol);
749 while (n < HAMMER_MAX_UNDO_BIGBLOCKS)
750 ondisk->vol0_undo_array[n++] = HAMMER_BLOCKMAP_UNAVAIL;
753 * Pre-initialize the UNDO blocks (HAMMER version 4+)
755 printf("initializing the undo map (%jd MB)\n",
756 (intmax_t)HAMMER_OFF_LONG_ENCODE(blockmap->alloc_offset) /
759 scan = blockmap->first_offset;
762 while (scan < blockmap->alloc_offset) {
763 hammer_fifo_head_t head;
764 hammer_fifo_tail_t tail;
766 int bytes = HAMMER_UNDO_ALIGN;
768 isnew = ((scan & HAMMER_BUFMASK64) == 0);
769 head = get_buffer_data(scan, &buffer, isnew);
770 buffer->cache.modified = 1;
771 tail = (void *)((char *)head + bytes - sizeof(*tail));
774 head->hdr_signature = HAMMER_HEAD_SIGNATURE;
775 head->hdr_type = HAMMER_HEAD_TYPE_DUMMY;
776 head->hdr_size = bytes;
777 head->hdr_seq = seqno++;
779 tail->tail_signature = HAMMER_TAIL_SIGNATURE;
780 tail->tail_type = HAMMER_HEAD_TYPE_DUMMY;
781 tail->tail_size = bytes;
783 hammer_crc_set_fifo_head(HammerVersion, head, bytes);
790 const char *zone_labels[] = {
792 "raw_volume", /* 1 */
793 "raw_buffer", /* 2 */
801 "large_data", /* 10 */
802 "small_data", /* 11 */
810 print_blockmap(const struct volume_info *volume)
812 hammer_blockmap_t blockmap;
813 hammer_volume_ondisk_t ondisk;
818 ondisk = volume->ondisk;
819 printf(INDENT"vol_label\t%s\n", ondisk->vol_label);
820 printf(INDENT"vol_count\t%d\n", ondisk->vol_count);
821 printf(INDENT"vol_bot_beg\t%s\n", sizetostr(ondisk->vol_bot_beg));
822 printf(INDENT"vol_mem_beg\t%s\n", sizetostr(ondisk->vol_mem_beg));
823 printf(INDENT"vol_buf_beg\t%s\n", sizetostr(ondisk->vol_buf_beg));
824 printf(INDENT"vol_buf_end\t%s\n", sizetostr(ondisk->vol_buf_end));
825 printf(INDENT"vol0_next_tid\t%016jx\n",
826 (uintmax_t)ondisk->vol0_next_tid);
828 blockmap = &ondisk->vol0_blockmap[HAMMER_ZONE_UNDO_INDEX];
829 size = HAMMER_OFF_LONG_ENCODE(blockmap->alloc_offset);
830 if (blockmap->first_offset <= blockmap->next_offset)
831 used = blockmap->next_offset - blockmap->first_offset;
833 used = blockmap->alloc_offset - blockmap->first_offset +
834 HAMMER_OFF_LONG_ENCODE(blockmap->next_offset);
835 printf(INDENT"undo_size\t%s\n", sizetostr(size));
836 printf(INDENT"undo_used\t%s\n", sizetostr(used));
838 printf(INDENT"zone # "
839 "phys first next alloc\n");
840 for (i = 0; i < HAMMER_MAX_ZONES; i++) {
841 blockmap = &ondisk->vol0_blockmap[i];
842 printf(INDENT"zone %-2d %-10s %016jx %016jx %016jx %016jx\n",
844 (uintmax_t)blockmap->phys_offset,
845 (uintmax_t)blockmap->first_offset,
846 (uintmax_t)blockmap->next_offset,
847 (uintmax_t)blockmap->alloc_offset);
852 * Flush various tracking structures to disk
855 flush_all_volumes(void)
857 struct volume_info *volume;
859 TAILQ_FOREACH(volume, &VolList, entry)
860 flush_volume(volume);
864 flush_volume(struct volume_info *volume)
866 struct buffer_info *buffer;
869 for (i = 0; i < HAMMER_BUFLISTS; ++i) {
870 TAILQ_FOREACH(buffer, &volume->buffer_lists[i], entry)
871 flush_buffer(buffer);
873 if (writehammervol(volume) == -1)
874 err(1, "Write volume %d (%s)", volume->vol_no, volume->name);
878 flush_buffer(struct buffer_info *buffer)
880 struct volume_info *volume;
882 volume = buffer->volume;
883 if (writehammerbuf(buffer) == -1)
884 err(1, "Write volume %d (%s)", volume->vol_no, volume->name);
885 buffer->cache.modified = 0;
889 * Core I/O operations
892 __read(struct volume_info *volume, void *data, int64_t offset, int size)
896 n = pread(volume->fd, data, size, offset);
903 readhammervol(struct volume_info *volume)
905 return(__read(volume, volume->ondisk, 0, HAMMER_BUFSIZE));
909 readhammerbuf(struct buffer_info *buffer)
911 return(__read(buffer->volume, buffer->ondisk, buffer->raw_offset,
916 __write(struct volume_info *volume, const void *data, int64_t offset, int size)
923 n = pwrite(volume->fd, data, size, offset);
930 writehammervol(struct volume_info *volume)
932 return(__write(volume, volume->ondisk, 0, HAMMER_BUFSIZE));
936 writehammerbuf(struct buffer_info *buffer)
938 return(__write(buffer->volume, buffer->ondisk, buffer->raw_offset,
942 int64_t init_boot_area_size(int64_t value, off_t avg_vol_size)
945 value = HAMMER_BOOT_NOMBYTES;
946 while (value > avg_vol_size / HAMMER_MAX_VOLUMES)
950 if (value < HAMMER_BOOT_MINBYTES)
951 value = HAMMER_BOOT_MINBYTES;
952 else if (value > HAMMER_BOOT_MAXBYTES)
953 value = HAMMER_BOOT_MAXBYTES;
958 int64_t init_memory_log_size(int64_t value, off_t avg_vol_size)
961 value = HAMMER_MEM_NOMBYTES;
962 while (value > avg_vol_size / HAMMER_MAX_VOLUMES)
966 if (value < HAMMER_MEM_MINBYTES)
967 value = HAMMER_MEM_MINBYTES;
968 else if (value > HAMMER_MEM_MAXBYTES)
969 value = HAMMER_MEM_MAXBYTES;