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(volume_info_t volume);
41 static void get_buffer_readahead(buffer_info_t base);
42 static __inline int readhammervol(volume_info_t volume);
43 static __inline int readhammerbuf(buffer_info_t buffer);
44 static __inline int writehammervol(volume_info_t volume);
45 static __inline int writehammerbuf(buffer_info_t 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;
69 find_buffer(hammer_off_t zone2_offset)
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)
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 check_volume(volume);
103 volume->ondisk = calloc(1, HAMMER_BUFSIZE);
105 for (i = 0; i < HAMMER_BUFLISTS; ++i)
106 TAILQ_INIT(&volume->buffer_lists[i]);
112 __add_volume(const volume_info_t volume)
115 struct stat st1, st2;
117 if (fstat(volume->fd, &st1) != 0) {
118 errx(1, "add_volume: %s: Failed to stat", volume->name);
122 TAILQ_FOREACH(scan, &VolList, entry) {
123 if (scan->vol_no == volume->vol_no) {
124 errx(1, "add_volume: %s: Duplicate volume number %d "
126 volume->name, volume->vol_no, scan->name);
129 if (fstat(scan->fd, &st2) != 0) {
130 errx(1, "add_volume: %s: Failed to stat %s",
131 volume->name, scan->name);
134 if ((st1.st_ino == st2.st_ino) && (st1.st_dev == st2.st_dev)) {
135 errx(1, "add_volume: %s: Specified more than once",
141 TAILQ_INSERT_TAIL(&VolList, volume, entry);
145 __verify_volume(const volume_info_t volume)
147 hammer_volume_ondisk_t ondisk = volume->ondisk;
149 if (ondisk->vol_signature != HAMMER_FSBUF_VOLUME) {
150 errx(1, "verify_volume: Invalid volume signature %016jx",
151 ondisk->vol_signature);
154 if (ondisk->vol_rootvol != HAMMER_ROOT_VOLNO) {
155 errx(1, "verify_volume: Invalid root volume# %d",
156 ondisk->vol_rootvol);
159 if (bcmp(&Hammer_FSType, &ondisk->vol_fstype, sizeof(Hammer_FSType))) {
160 errx(1, "verify_volume: %s: Header does not indicate "
161 "that this is a HAMMER volume", volume->name);
164 if (bcmp(&Hammer_FSId, &ondisk->vol_fsid, sizeof(Hammer_FSId))) {
165 errx(1, "verify_volume: %s: FSId does not match other volumes!",
169 if (ondisk->vol_version < HAMMER_VOL_VERSION_MIN ||
170 ondisk->vol_version >= HAMMER_VOL_VERSION_WIP) {
171 errx(1, "verify_volume: %s: Invalid volume version %u",
172 volume->name, ondisk->vol_version);
178 * Initialize a volume structure and ondisk vol_no field.
181 init_volume(const char *filename, int oflags, int32_t vol_no)
183 volume_info_t volume;
185 volume = __alloc_volume(filename, oflags);
186 volume->vol_no = volume->ondisk->vol_no = vol_no;
188 __add_volume(volume);
194 * Initialize a volume structure and read ondisk volume header.
197 load_volume(const char *filename, int oflags, int verify_volume)
199 volume_info_t volume;
202 volume = __alloc_volume(filename, oflags);
204 n = readhammervol(volume);
206 err(1, "load_volume: %s: Read failed at offset 0",
210 volume->vol_no = volume->ondisk->vol_no;
211 HammerVersion = volume->ondisk->vol_version;
213 if (valid_hammer_volumes++ == 0)
214 Hammer_FSId = volume->ondisk->vol_fsid;
216 __verify_volume(volume);
218 __add_volume(volume);
224 * Check basic volume characteristics.
227 check_volume(volume_info_t volume)
229 struct partinfo pinfo;
233 * Allow the formatting of block devices or regular files
235 if (ioctl(volume->fd, DIOCGPART, &pinfo) < 0) {
236 if (fstat(volume->fd, &st) < 0) {
237 err(1, "Unable to stat %s", volume->name);
240 if (S_ISREG(st.st_mode)) {
241 volume->size = st.st_size;
242 volume->type = "REGFILE";
244 errx(1, "Unsupported file type for %s", volume->name);
249 * When formatting a block device as a HAMMER volume the
250 * sector size must be compatible. HAMMER uses 16384 byte
251 * filesystem buffers.
253 if (pinfo.reserved_blocks) {
254 errx(1, "HAMMER cannot be placed in a partition "
255 "which overlaps the disklabel or MBR");
258 if (pinfo.media_blksize > HAMMER_BUFSIZE ||
259 HAMMER_BUFSIZE % pinfo.media_blksize) {
260 errx(1, "A media sector size of %d is not supported",
261 pinfo.media_blksize);
265 volume->size = pinfo.media_size;
266 volume->device_offset = pinfo.media_offset;
267 volume->type = "DEVICE";
272 is_regfile(const volume_info_t volume)
274 return(strcmp(volume->type, "REGFILE") ? 0 : 1);
278 assert_volume_offset(const volume_info_t volume)
280 assert(hammer_is_zone_raw_buffer(volume->vol_free_off));
281 assert(hammer_is_zone_raw_buffer(volume->vol_free_end));
282 if (volume->vol_free_off >= volume->vol_free_end) {
283 errx(1, "Ran out of room, filesystem too small");
289 get_volume(int32_t vol_no)
291 volume_info_t volume;
293 TAILQ_FOREACH(volume, &VolList, entry) {
294 if (volume->vol_no == vol_no)
302 get_root_volume(void)
304 return(get_volume(HAMMER_ROOT_VOLNO));
308 __blockmap_xlate_to_zone2(hammer_off_t buf_offset)
310 hammer_off_t zone2_offset;
313 if (hammer_is_zone_raw_buffer(buf_offset))
314 zone2_offset = buf_offset;
316 zone2_offset = blockmap_lookup(buf_offset, &error);
319 return(HAMMER_OFF_BAD);
320 assert(hammer_is_zone_raw_buffer(zone2_offset));
322 return(zone2_offset);
326 __alloc_buffer(hammer_off_t zone2_offset, int isnew)
328 volume_info_t volume;
329 buffer_info_t buffer;
332 volume = get_volume(HAMMER_VOL_DECODE(zone2_offset));
333 assert(volume != NULL);
335 buffer = calloc(1, sizeof(*buffer));
336 buffer->zone2_offset = zone2_offset;
337 buffer->raw_offset = hammer_xlate_to_phys(volume->ondisk, zone2_offset);
338 buffer->volume = volume;
339 buffer->ondisk = calloc(1, HAMMER_BUFSIZE);
342 if (readhammerbuf(buffer) == -1) {
343 err(1, "Failed to read %s:%016jx at %016jx",
345 (intmax_t)buffer->zone2_offset,
346 (intmax_t)buffer->raw_offset);
351 hi = buffer_hash(zone2_offset);
352 TAILQ_INSERT_TAIL(&volume->buffer_lists[hi], buffer, entry);
353 hammer_cache_add(&buffer->cache);
359 * Acquire the 16KB buffer for specified zone offset.
362 get_buffer(hammer_off_t buf_offset, int isnew)
364 buffer_info_t buffer;
365 hammer_off_t zone2_offset;
368 zone2_offset = __blockmap_xlate_to_zone2(buf_offset);
369 if (zone2_offset == HAMMER_OFF_BAD)
372 zone2_offset &= ~HAMMER_BUFMASK64;
373 buffer = find_buffer(zone2_offset);
375 if (buffer == NULL) {
376 buffer = __alloc_buffer(zone2_offset, isnew);
380 hammer_cache_used(&buffer->cache);
382 assert(buffer->ondisk != NULL);
384 ++buffer->cache.refs;
385 hammer_cache_flush();
388 assert(buffer->cache.modified == 0);
389 bzero(buffer->ondisk, HAMMER_BUFSIZE);
390 buffer->cache.modified = 1;
393 get_buffer_readahead(buffer);
398 get_buffer_readahead(const buffer_info_t base)
400 buffer_info_t buffer;
401 volume_info_t volume;
402 hammer_off_t zone2_offset;
404 int ri = UseReadBehind;
405 int re = UseReadAhead;
407 raw_offset = base->raw_offset + ri * HAMMER_BUFSIZE;
408 volume = base->volume;
411 if (raw_offset >= volume->ondisk->vol_buf_end)
413 if (raw_offset < volume->ondisk->vol_buf_beg || ri == 0) {
415 raw_offset += HAMMER_BUFSIZE;
418 zone2_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no,
419 raw_offset - volume->ondisk->vol_buf_beg);
420 buffer = find_buffer(zone2_offset);
421 if (buffer == NULL) {
422 /* call with -1 to prevent another readahead */
423 buffer = get_buffer(zone2_offset, -1);
427 raw_offset += HAMMER_BUFSIZE;
432 rel_buffer(buffer_info_t buffer)
434 volume_info_t volume;
439 assert(buffer->cache.refs > 0);
440 if (--buffer->cache.refs == 0) {
441 if (buffer->cache.delete) {
442 hi = buffer_hash(buffer->zone2_offset);
443 volume = buffer->volume;
444 if (buffer->cache.modified)
445 flush_buffer(buffer);
446 TAILQ_REMOVE(&volume->buffer_lists[hi], buffer, entry);
447 hammer_cache_del(&buffer->cache);
448 free(buffer->ondisk);
455 * Retrieve a pointer to a buffer data given a buffer offset. The underlying
456 * bufferp is freed if isnew or the offset is out of range of the cached data.
457 * If bufferp is freed a referenced buffer is loaded into it.
460 get_buffer_data(hammer_off_t buf_offset, buffer_info_t *bufferp, int isnew)
464 if (*bufferp != NULL) {
465 /* XXX xor is always non zero for indirect zones */
466 xor = HAMMER_OFF_LONG_ENCODE(buf_offset) ^
467 HAMMER_OFF_LONG_ENCODE((*bufferp)->zone2_offset);
468 if (isnew > 0 || (xor & ~HAMMER_BUFMASK64)) {
469 rel_buffer(*bufferp);
474 if (*bufferp == NULL) {
475 *bufferp = get_buffer(buf_offset, isnew);
476 if (*bufferp == NULL)
480 return(((char *)(*bufferp)->ondisk) +
481 ((int32_t)buf_offset & HAMMER_BUFMASK));
485 * Allocate HAMMER elements - B-Tree nodes
488 alloc_btree_node(hammer_off_t *offp, buffer_info_t *data_bufferp)
490 hammer_node_ondisk_t node;
492 node = alloc_blockmap(HAMMER_ZONE_BTREE_INDEX, sizeof(*node),
494 bzero(node, sizeof(*node));
499 * Allocate HAMMER elements - meta data (inode, direntry, PFS, etc)
502 alloc_meta_element(hammer_off_t *offp, int32_t data_len,
503 buffer_info_t *data_bufferp)
507 data = alloc_blockmap(HAMMER_ZONE_META_INDEX, data_len,
509 bzero(data, data_len);
514 * Format a new blockmap. This is mostly a degenerate case because
515 * all allocations are now actually done from the freemap.
518 format_blockmap(volume_info_t root_vol, int zone, hammer_off_t offset)
520 hammer_blockmap_t blockmap;
521 hammer_off_t zone_base;
523 /* Only root volume needs formatting */
524 assert(root_vol->vol_no == HAMMER_ROOT_VOLNO);
526 assert(hammer_is_index_record(zone));
528 blockmap = &root_vol->ondisk->vol0_blockmap[zone];
529 zone_base = HAMMER_ZONE_ENCODE(zone, offset);
531 bzero(blockmap, sizeof(*blockmap));
532 blockmap->phys_offset = 0;
533 blockmap->first_offset = zone_base;
534 blockmap->next_offset = zone_base;
535 blockmap->alloc_offset = HAMMER_ENCODE(zone, 255, -1);
536 hammer_crc_set_blockmap(HammerVersion, blockmap);
540 * Format a new freemap. Set all layer1 entries to UNAVAIL. The initialize
541 * code will load each volume's freemap.
544 format_freemap(volume_info_t root_vol)
546 buffer_info_t buffer = NULL;
547 hammer_off_t layer1_offset;
548 hammer_blockmap_t blockmap;
549 hammer_blockmap_layer1_t layer1;
552 /* Only root volume needs formatting */
553 assert(root_vol->vol_no == HAMMER_ROOT_VOLNO);
555 layer1_offset = bootstrap_bigblock(root_vol);
556 for (i = 0; i < HAMMER_BIGBLOCK_SIZE; i += sizeof(*layer1)) {
557 isnew = ((i % HAMMER_BUFSIZE) == 0);
558 layer1 = get_buffer_data(layer1_offset + i, &buffer, isnew);
559 bzero(layer1, sizeof(*layer1));
560 layer1->phys_offset = HAMMER_BLOCKMAP_UNAVAIL;
561 layer1->blocks_free = 0;
562 hammer_crc_set_layer1(HammerVersion, layer1);
564 assert(i == HAMMER_BIGBLOCK_SIZE);
567 blockmap = &root_vol->ondisk->vol0_blockmap[HAMMER_ZONE_FREEMAP_INDEX];
568 bzero(blockmap, sizeof(*blockmap));
569 blockmap->phys_offset = layer1_offset;
570 blockmap->first_offset = 0;
571 blockmap->next_offset = HAMMER_ENCODE_RAW_BUFFER(0, 0);
572 blockmap->alloc_offset = HAMMER_ENCODE_RAW_BUFFER(255, -1);
573 hammer_crc_set_blockmap(HammerVersion, blockmap);
577 * Load the volume's remaining free space into the freemap.
579 * Returns the number of big-blocks available.
582 initialize_freemap(volume_info_t volume)
584 volume_info_t root_vol;
585 buffer_info_t buffer1 = NULL;
586 buffer_info_t buffer2 = NULL;
587 hammer_blockmap_layer1_t layer1;
588 hammer_blockmap_layer2_t layer2;
589 hammer_off_t layer1_offset;
590 hammer_off_t layer2_offset;
591 hammer_off_t phys_offset;
592 hammer_off_t block_offset;
593 hammer_off_t aligned_vol_free_end;
594 hammer_blockmap_t freemap;
596 int64_t layer1_count = 0;
598 root_vol = get_root_volume();
600 assert_volume_offset(volume);
601 aligned_vol_free_end = HAMMER_BLOCKMAP_LAYER2_DOALIGN(volume->vol_free_end);
603 printf("initialize freemap volume %d\n", volume->vol_no);
606 * Initialize the freemap. First preallocate the big-blocks required
607 * to implement layer2. This preallocation is a bootstrap allocation
608 * using blocks from the target volume.
610 freemap = &root_vol->ondisk->vol0_blockmap[HAMMER_ZONE_FREEMAP_INDEX];
612 for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);
613 phys_offset < aligned_vol_free_end;
614 phys_offset += HAMMER_BLOCKMAP_LAYER2) {
615 layer1_offset = freemap->phys_offset +
616 HAMMER_BLOCKMAP_LAYER1_OFFSET(phys_offset);
617 layer1 = get_buffer_data(layer1_offset, &buffer1, 0);
618 if (layer1->phys_offset == HAMMER_BLOCKMAP_UNAVAIL) {
619 layer1->phys_offset = bootstrap_bigblock(volume);
620 layer1->blocks_free = 0;
621 buffer1->cache.modified = 1;
622 hammer_crc_set_layer1(HammerVersion, layer1);
627 * Now fill everything in.
629 for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);
630 phys_offset < aligned_vol_free_end;
631 phys_offset += HAMMER_BLOCKMAP_LAYER2) {
633 layer1_offset = freemap->phys_offset +
634 HAMMER_BLOCKMAP_LAYER1_OFFSET(phys_offset);
635 layer1 = get_buffer_data(layer1_offset, &buffer1, 0);
636 assert(layer1->phys_offset != HAMMER_BLOCKMAP_UNAVAIL);
638 for (block_offset = 0;
639 block_offset < HAMMER_BLOCKMAP_LAYER2;
640 block_offset += HAMMER_BIGBLOCK_SIZE) {
641 layer2_offset = layer1->phys_offset +
642 HAMMER_BLOCKMAP_LAYER2_OFFSET(block_offset);
643 layer2 = get_buffer_data(layer2_offset, &buffer2, 0);
644 bzero(layer2, sizeof(*layer2));
646 if (phys_offset + block_offset < volume->vol_free_off) {
648 * Big-blocks already allocated as part
649 * of the freemap bootstrap.
651 layer2->zone = HAMMER_ZONE_FREEMAP_INDEX;
652 layer2->append_off = HAMMER_BIGBLOCK_SIZE;
653 layer2->bytes_free = 0;
654 } else if (phys_offset + block_offset < volume->vol_free_end) {
656 layer2->append_off = 0;
657 layer2->bytes_free = HAMMER_BIGBLOCK_SIZE;
661 layer2->zone = HAMMER_ZONE_UNAVAIL_INDEX;
662 layer2->append_off = HAMMER_BIGBLOCK_SIZE;
663 layer2->bytes_free = 0;
665 hammer_crc_set_layer2(HammerVersion, layer2);
666 buffer2->cache.modified = 1;
669 layer1->blocks_free += layer1_count;
670 hammer_crc_set_layer1(HammerVersion, layer1);
671 buffer1->cache.modified = 1;
680 * Returns the number of big-blocks available for filesystem data and undos
681 * without formatting.
684 count_freemap(const volume_info_t volume)
686 hammer_off_t phys_offset;
687 hammer_off_t vol_free_off;
688 hammer_off_t aligned_vol_free_end;
691 vol_free_off = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);
693 assert_volume_offset(volume);
694 aligned_vol_free_end = HAMMER_BLOCKMAP_LAYER2_DOALIGN(volume->vol_free_end);
696 if (volume->vol_no == HAMMER_ROOT_VOLNO)
697 vol_free_off += HAMMER_BIGBLOCK_SIZE;
699 for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);
700 phys_offset < aligned_vol_free_end;
701 phys_offset += HAMMER_BLOCKMAP_LAYER2) {
702 vol_free_off += HAMMER_BIGBLOCK_SIZE;
705 for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);
706 phys_offset < aligned_vol_free_end;
707 phys_offset += HAMMER_BIGBLOCK_SIZE) {
708 if (phys_offset < vol_free_off)
710 else if (phys_offset < volume->vol_free_end)
718 * Format the undomap for the root volume.
721 format_undomap(volume_info_t root_vol, int64_t *undo_buffer_size)
723 hammer_off_t undo_limit;
724 hammer_blockmap_t blockmap;
725 hammer_volume_ondisk_t ondisk;
726 buffer_info_t buffer = NULL;
732 /* Only root volume needs formatting */
733 assert(root_vol->vol_no == HAMMER_ROOT_VOLNO);
734 ondisk = root_vol->ondisk;
737 * Size the undo buffer in multiples of HAMMER_BIGBLOCK_SIZE,
738 * up to HAMMER_MAX_UNDO_BIGBLOCKS big-blocks.
739 * Size to approximately 0.1% of the disk.
741 * The minimum UNDO fifo size is 512MB, or approximately 1% of
742 * the recommended 50G disk.
744 * Changing this minimum is rather dangerous as complex filesystem
745 * operations can cause the UNDO FIFO to fill up otherwise.
747 undo_limit = *undo_buffer_size;
748 if (undo_limit == 0) {
749 undo_limit = HAMMER_VOL_BUF_SIZE(ondisk) / 1000;
750 if (undo_limit < HAMMER_BIGBLOCK_SIZE * HAMMER_MIN_UNDO_BIGBLOCKS)
751 undo_limit = HAMMER_BIGBLOCK_SIZE * HAMMER_MIN_UNDO_BIGBLOCKS;
753 undo_limit = HAMMER_BIGBLOCK_DOALIGN(undo_limit);
754 if (undo_limit < HAMMER_BIGBLOCK_SIZE)
755 undo_limit = HAMMER_BIGBLOCK_SIZE;
756 if (undo_limit > HAMMER_BIGBLOCK_SIZE * HAMMER_MAX_UNDO_BIGBLOCKS)
757 undo_limit = HAMMER_BIGBLOCK_SIZE * HAMMER_MAX_UNDO_BIGBLOCKS;
758 *undo_buffer_size = undo_limit;
760 blockmap = &ondisk->vol0_blockmap[HAMMER_ZONE_UNDO_INDEX];
761 bzero(blockmap, sizeof(*blockmap));
762 blockmap->phys_offset = HAMMER_BLOCKMAP_UNAVAIL;
763 blockmap->first_offset = HAMMER_ENCODE_UNDO(0);
764 blockmap->next_offset = blockmap->first_offset;
765 blockmap->alloc_offset = HAMMER_ENCODE_UNDO(undo_limit);
766 hammer_crc_set_blockmap(HammerVersion, blockmap);
768 limit_index = undo_limit / HAMMER_BIGBLOCK_SIZE;
769 assert(limit_index <= HAMMER_MAX_UNDO_BIGBLOCKS);
771 for (n = 0; n < limit_index; ++n)
772 ondisk->vol0_undo_array[n] = alloc_undo_bigblock(root_vol);
773 while (n < HAMMER_MAX_UNDO_BIGBLOCKS)
774 ondisk->vol0_undo_array[n++] = HAMMER_BLOCKMAP_UNAVAIL;
777 * Pre-initialize the UNDO blocks (HAMMER version 4+)
779 printf("initializing the undo map (%jd MB)\n",
780 (intmax_t)HAMMER_OFF_LONG_ENCODE(blockmap->alloc_offset) /
783 scan = blockmap->first_offset;
786 while (scan < blockmap->alloc_offset) {
787 hammer_fifo_head_t head;
788 hammer_fifo_tail_t tail;
790 int bytes = HAMMER_UNDO_ALIGN;
792 isnew = ((scan & HAMMER_BUFMASK64) == 0);
793 head = get_buffer_data(scan, &buffer, isnew);
794 buffer->cache.modified = 1;
795 tail = (void *)((char *)head + bytes - sizeof(*tail));
798 head->hdr_signature = HAMMER_HEAD_SIGNATURE;
799 head->hdr_type = HAMMER_HEAD_TYPE_DUMMY;
800 head->hdr_size = bytes;
801 head->hdr_seq = seqno++;
803 tail->tail_signature = HAMMER_TAIL_SIGNATURE;
804 tail->tail_type = HAMMER_HEAD_TYPE_DUMMY;
805 tail->tail_size = bytes;
807 hammer_crc_set_fifo_head(HammerVersion, head, bytes);
814 const char *zone_labels[] = {
816 "raw_volume", /* 1 */
817 "raw_buffer", /* 2 */
825 "large_data", /* 10 */
826 "small_data", /* 11 */
834 print_blockmap(const volume_info_t volume)
836 hammer_blockmap_t blockmap;
837 hammer_volume_ondisk_t ondisk;
842 ondisk = volume->ondisk;
843 printf(INDENT"vol_label\t%s\n", ondisk->vol_label);
844 printf(INDENT"vol_count\t%d\n", ondisk->vol_count);
845 printf(INDENT"vol_bot_beg\t%s\n", sizetostr(ondisk->vol_bot_beg));
846 printf(INDENT"vol_mem_beg\t%s\n", sizetostr(ondisk->vol_mem_beg));
847 printf(INDENT"vol_buf_beg\t%s\n", sizetostr(ondisk->vol_buf_beg));
848 printf(INDENT"vol_buf_end\t%s\n", sizetostr(ondisk->vol_buf_end));
849 printf(INDENT"vol0_next_tid\t%016jx\n",
850 (uintmax_t)ondisk->vol0_next_tid);
852 blockmap = &ondisk->vol0_blockmap[HAMMER_ZONE_UNDO_INDEX];
853 size = HAMMER_OFF_LONG_ENCODE(blockmap->alloc_offset);
854 if (blockmap->first_offset <= blockmap->next_offset)
855 used = blockmap->next_offset - blockmap->first_offset;
857 used = blockmap->alloc_offset - blockmap->first_offset +
858 HAMMER_OFF_LONG_ENCODE(blockmap->next_offset);
859 printf(INDENT"undo_size\t%s\n", sizetostr(size));
860 printf(INDENT"undo_used\t%s\n", sizetostr(used));
862 printf(INDENT"zone # "
863 "phys first next alloc\n");
864 for (i = 0; i < HAMMER_MAX_ZONES; i++) {
865 blockmap = &ondisk->vol0_blockmap[i];
866 printf(INDENT"zone %-2d %-10s %016jx %016jx %016jx %016jx\n",
868 (uintmax_t)blockmap->phys_offset,
869 (uintmax_t)blockmap->first_offset,
870 (uintmax_t)blockmap->next_offset,
871 (uintmax_t)blockmap->alloc_offset);
876 * Flush various tracking structures to disk
879 flush_all_volumes(void)
881 volume_info_t volume;
883 TAILQ_FOREACH(volume, &VolList, entry)
884 flush_volume(volume);
888 flush_volume(volume_info_t volume)
890 buffer_info_t buffer;
893 for (i = 0; i < HAMMER_BUFLISTS; ++i) {
894 TAILQ_FOREACH(buffer, &volume->buffer_lists[i], entry)
895 flush_buffer(buffer);
897 if (writehammervol(volume) == -1) {
898 err(1, "Write volume %d (%s)", volume->vol_no, volume->name);
904 flush_buffer(buffer_info_t buffer)
906 volume_info_t volume;
908 volume = buffer->volume;
909 if (writehammerbuf(buffer) == -1) {
910 err(1, "Write volume %d (%s)", volume->vol_no, volume->name);
913 buffer->cache.modified = 0;
917 * Core I/O operations
920 __read(volume_info_t volume, void *data, int64_t offset, int size)
924 n = pread(volume->fd, data, size, offset);
931 readhammervol(volume_info_t volume)
933 return(__read(volume, volume->ondisk, 0, HAMMER_BUFSIZE));
937 readhammerbuf(buffer_info_t buffer)
939 return(__read(buffer->volume, buffer->ondisk, buffer->raw_offset,
944 __write(volume_info_t volume, const void *data, int64_t offset, int size)
951 n = pwrite(volume->fd, data, size, offset);
958 writehammervol(volume_info_t volume)
960 return(__write(volume, volume->ondisk, 0, HAMMER_BUFSIZE));
964 writehammerbuf(buffer_info_t buffer)
966 return(__write(buffer->volume, buffer->ondisk, buffer->raw_offset,
970 int64_t init_boot_area_size(int64_t value, off_t avg_vol_size)
973 value = HAMMER_BOOT_NOMBYTES;
974 while (value > avg_vol_size / HAMMER_MAX_VOLUMES)
978 if (value < HAMMER_BOOT_MINBYTES)
979 value = HAMMER_BOOT_MINBYTES;
980 else if (value > HAMMER_BOOT_MAXBYTES)
981 value = HAMMER_BOOT_MAXBYTES;
986 int64_t init_memory_log_size(int64_t value, off_t avg_vol_size)
989 value = HAMMER_MEM_NOMBYTES;
990 while (value > avg_vol_size / HAMMER_MAX_VOLUMES)
994 if (value < HAMMER_MEM_MINBYTES)
995 value = HAMMER_MEM_MINBYTES;
996 else if (value > HAMMER_MEM_MAXBYTES)
997 value = HAMMER_MEM_MAXBYTES;