struct Header

Creates headers representing structures with the given information. FVM allows for growth, so

the "growable" variants takes the initial size as well as the max size that the metadata tables

can represent to allow for future growth up until that limit. FromDiskSize()/FromSliceCount()

will not necessarily allow for future growth (table padding up to a block boundary may allow

some growth).

The partition and slice tables will end up both being one larger than the number of usable

entries passed in to this function. So don't pass even numbers to make the tables

nicely aligned, pass one less.

TODO(https://fxbug.dev/42138108) make table_size == usable_count.

Currently the partition table size is fixed, so usable_partitions must be kMaxUsablePartitions

or it will assert.

TODO(https://fxbug.dev/42116137): Allow usable partitions to vary.

Sets the number of slices.

0

<

= usable_slices

<

= GetAllocationTableAllocatedEntryCount();

This will update the pslice_count as well as the fvm_partition_size accordingly.

Validates the header. This does NOT check the hash because that covers the entire metadata

which is not available to just the header class.

The disk size is passed to validate that the specified disk image does not overflow the device.

To disable checking, pass std::numeric_limits

<uint64

_t>::max() for the disk_size.

The underlying device's disk_block_size is passed to ensure that it is a multiple of of the

slice size. To disable checking this, pass fvm::kBlockSize for the device block size.

A description of the error (if present) will be placed into the given output parameter

(required).

Like IsValid but perfoms the minimal possible validation only on the partition and allocation

table sizes. This does not check any other data, even the signature.

This function is useful when reading the primary superblock and we need to find the secondary

superblock. The secondary header is located after the allocation and partition tables, so the

primary header must have valid sizes for these tables before we can consider which variant is

valid.

The partition table always starts at a block offset, and is always a multiple of blocks

long in bytes.

Partition IDs count from 1 but the partition table is indexed from 0, leaving an unused

VPartitionEntry at the beginning of this table. The "entry count" is therefore one less than

the size of the table.

Returns the offset of the given VPartitionEntry struct from the beginning of the Header. The

valid input range is:

0

<

index

<

= GetPartitionTableEntryCount()

The allocation table begins on a block boundary after the partition table. It has a "used"

portion which are available for use by partitions (though they may not be used yet). Then it

has a potentially-larger "allocated" portion which allows FVM to grow assuming the underlying

device has room.

Computes the number of allocation table entries that are needed for the given disk size,

capping it at the maximum number representable using the current allocation table size.

This is used when growing the FVM partition.

Byte offset from the beginning of the Header to the allocation table entry (SliceEntry struct)

with the given ID. Physical slice IDs are 1-based so valid input is:

1

<

= pslice

<

= pslice_count

To get the actual slice data, see GetSliceOffset().

The metadata counts the header, partition table, and allocation table. The allocation table

may contain unused entries (allowing FVM to grow as long as there is space on the underlying

device), in which case the used bytes will be less than the allocated bytes.

When the Header is default-initialized and the disk or slice size is 0, the metadata size

is defined to be 0.

Returns the offset in bytes of the given superblock from the beginning of the device.

Returns the offset in the device (counting both copies of the metadata) where the first slice

data starts.

Byte offset from the beginning of the device to the slice data. Physical slice IDs are 1-based

so valid input is:

1

<

= pslice

<

= pslice_count

This gets the actual slice data. To get the slice's allocation table entry, see

GetSliceEntryOffset().

Returns a multi-line stringified representation of the header, useful for debugging. See also

"operator<<" for a more compact representation.