btrfs_tree_h.go

package btrfs

/*
 * This header contains the structure definitions and constants used
 * by file system objects that can be retrieved using
 * the _BTRFS_IOC_SEARCH_TREE ioctl.  That means basically anything that
 * is needed to describe a leaf node's key or item contents.
 */

/* holds pointers to all of the tree roots */

/* stores information about which extents are in use, and reference counts */

/*
 * chunk tree stores translations from logical -> physical block numbering
 * the super block points to the chunk tree
 */

/*
 * stores information about which areas of a given device are in use.
 * one per device.  The tree of tree roots points to the device tree
 */

/* one per subvolume, storing files and directories */

/* directory objectid inside the root tree */

/* holds checksums of all the data extents */

/* holds quota configuration and tracking */

/* for storing items that use the _BTRFS_UUID_KEY* types */

/* tracks free space in block groups. */

/* device stats in the device tree */

/* for storing balance parameters in the root tree */

/* orhpan objectid for tracking unlinked/truncated files */

/* does write ahead logging to speed up fsyncs */

/* for space balancing */

/*
 * extent checksums all have this objectid
 * this allows them to share the logging tree
 * for fsyncs
 */

/* For storing free space cache */

/*
 * The inode number assigned to the special inode for storing
 * free ino cache
 */

/* dummy objectid represents multiple objectids */

/*
 * All files have objectids in this range.
 */

/*
 * the device items go into the chunk tree.  The key is in the form
 * [ 1 _BTRFS_DEV_ITEM_KEY device_id ]
 */

/*
 * inode items have the data typically returned from stat and store other
 * info about object characteristics.  There is one for every file and dir in
 * the FS
 */

/* reserve 2-15 close to the inode for later flexibility */

/*
 * dir items are the name -> inode pointers in a directory.  There is one
 * for every name in a directory.
 */

/*
 * extent data is for file data
 */

/*
 * extent csums are stored in a separate tree and hold csums for
 * an entire extent on disk.
 */

/*
 * root items point to tree roots.  They are typically in the root
 * tree used by the super block to find all the other trees
 */

/*
 * root backrefs tie subvols and snapshots to the directory entries that
 * reference them
 */

/*
 * root refs make a fast index for listing all of the snapshots and
 * subvolumes referenced by a given root.  They point directly to the
 * directory item in the root that references the subvol
 */

/*
 * extent items are in the extent map tree.  These record which blocks
 * are used, and how many references there are to each block
 */

/*
 * The same as the _BTRFS_EXTENT_ITEM_KEY, except it's metadata we already know
 * the length, so we save the level in key->offset instead of the length.
 */

/*
 * block groups give us hints into the extent allocation trees.  Which
 * blocks are free etc etc
 */

/*
 * Every block group is represented in the free space tree by a free space info
 * item, which stores some accounting information. It is keyed on
 * (block_group_start, FREE_SPACE_INFO, block_group_length).
 */

/*
 * A free space extent tracks an extent of space that is free in a block group.
 * It is keyed on (start, FREE_SPACE_EXTENT, length).
 */

/*
 * When a block group becomes very fragmented, we convert it to use bitmaps
 * instead of extents. A free space bitmap is keyed on
 * (start, FREE_SPACE_BITMAP, length); the corresponding item is a bitmap with
 * (length / sectorsize) bits.
 */

/*
 * Records the overall state of the qgroups.
 * There's only one instance of this key present,
 * (0, _BTRFS_QGROUP_STATUS_KEY, 0)
 */

/*
 * Records the currently used space of the qgroup.
 * One key per qgroup, (0, _BTRFS_QGROUP_INFO_KEY, qgroupid).
 */

/*
 * Contains the user configured limits for the qgroup.
 * One key per qgroup, (0, _BTRFS_QGROUP_LIMIT_KEY, qgroupid).
 */

/*
 * Records the child-parent relationship of qgroups. For
 * each relation, 2 keys are present:
 * (childid, _BTRFS_QGROUP_RELATION_KEY, parentid)
 * (parentid, _BTRFS_QGROUP_RELATION_KEY, childid)
 */

/*
 * Obsolete name, see _BTRFS_TEMPORARY_ITEM_KEY.
 */

/*
 * The key type for tree items that are stored persistently, but do not need to
 * exist for extended period of time. The items can exist in any tree.
 *
 * [subtype, _BTRFS_TEMPORARY_ITEM_KEY, data]
 *
 * Existing items:
 *
 * - balance status item
 *   (_BTRFS_BALANCE_OBJECTID, _BTRFS_TEMPORARY_ITEM_KEY, 0)
 */

/*
 * Obsolete name, see _BTRFS_PERSISTENT_ITEM_KEY
 */

/*
 * The key type for tree items that are stored persistently and usually exist
 * for a long period, eg. filesystem lifetime. The item kinds can be status
 * information, stats or preference values. The item can exist in any tree.
 *
 * [subtype, _BTRFS_PERSISTENT_ITEM_KEY, data]
 *
 * Existing items:
 *
 * - device statistics, store IO stats in the device tree, one key for all
 *   stats
 *   (_BTRFS_DEV_STATS_OBJECTID, _BTRFS_DEV_STATS_KEY, 0)
 */

/*
 * Persistantly stores the device replace state in the device tree.
 * The key is built like this: (0, _BTRFS_DEV_REPLACE_KEY, 0).
 */

/*
 * Stores items that allow to quickly map UUIDs to something else.
 * These items are part of the filesystem UUID tree.
 * The key is built like this:
 * (UUID_upper_64_bits, _BTRFS_UUID_KEY*, UUID_lower_64_bits).
 */

/* for UUIDs assigned to * received subvols */

/*
 * string items are for debugging.  They just store a short string of
 * data in the FS
 */

/* 32 bytes in various csum fields */

/* csum types */

/*
 * flags definitions for directory entry item type
 *
 * Used by:
 * struct btrfs_dir_item.type
 */

/*
 * The key defines the order in the tree, and so it also defines (optimal)
 * block layout.
 *
 * objectid corresponds to the inode number.
 *
 * type tells us things about the object, and is a kind of stream selector.
 * so for a given inode, keys with type of 1 might refer to the inode data,
 * type of 2 may point to file data in the btree and type == 3 may point to
 * extents.
 *
 * offset is the starting byte offset for this key in the stream.
 *
 * btrfs_disk_key is in disk byte order.  struct btrfs_key is always
 * in cpu native order.  Otherwise they are identical and their sizes
 * should be the same (ie both packed)
 */
type btrfs_disk_key struct {
	objectid uint64
	type_    uint8
	offset   uint64
}

type btrfs_key struct {
	objectid uint64
	type_    uint8
	offset   uint64
}

type btrfs_dev_item struct {
	devid        uint64
	total_bytes  uint64
	bytes_used   uint64
	io_align     uint32
	io_width     uint32
	sector_size  uint32
	type_        uint64
	generation   uint64
	start_offset uint64
	dev_group    uint32
	seek_speed   uint8
	bandwidth    uint8
	uuid         UUID
	fsid         FSID
}

type btrfs_stripe struct {
	devid    uint64
	offset   uint64
	dev_uuid UUID
}

type btrfs_chunk struct {
	length      uint64
	owner       uint64
	stripe_len  uint64
	type_       uint64
	io_align    uint32
	io_width    uint32
	sector_size uint32
	num_stripes uint16
	sub_stripes uint16
	stripe      struct {
		devid    uint64
		offset   uint64
		dev_uuid UUID
	}
}

/* additional stripes go here */
type btrfs_free_space_entry struct {
	offset uint64
	bytes  uint64
	type_  uint8
}

type btrfs_free_space_header struct {
	location struct {
		objectid uint64
		type_    uint8
		offset   uint64
	}
	generation  uint64
	num_entries uint64
	num_bitmaps uint64
}

/* Super block flags */
/* Errors detected */

/*
 * items in the extent btree are used to record the objectid of the
 * owner of the block and the number of references
 */
type btrfs_extent_item struct {
	refs       uint64
	generation uint64
	flags      uint64
}

type btrfs_extent_item_v0 struct {
	refs uint32
}

/* following flags only apply to tree blocks */

/* use full backrefs for extent pointers in the block */

/*
 * this flag is only used internally by scrub and may be changed at any time
 * it is only declared here to avoid collisions
 */
type btrfs_tree_block_info struct {
	key struct {
		objectid uint64
		type_    uint8
		offset   uint64
	}
	level uint8
}

type btrfs_extent_data_ref struct {
	root     uint64
	objectid uint64
	offset   uint64
	count    uint32
}

type btrfs_shared_data_ref struct {
	count uint32
}

type btrfs_extent_inline_ref struct {
	type_  uint8
	offset uint64
}

/* old style backrefs item */
type btrfs_extent_ref_v0 struct {
	root       uint64
	generation uint64
	objectid   uint64
	count      uint32
}

/* dev extents record free space on individual devices.  The owner
 * field points back to the chunk allocation mapping tree that allocated
 * the extent.  The chunk tree uuid field is a way to double check the owner
 */
type btrfs_dev_extent struct {
	chunk_tree      uint64
	chunk_objectid  uint64
	chunk_offset    uint64
	length          uint64
	chunk_tree_uuid UUID
}

type btrfs_inode_ref struct {
	index    uint64
	name_len uint16
}

/* name goes here */
type btrfs_inode_extref struct {
	parent_objectid uint64
	index           uint64
	name_len        uint16
	//name            [0]uint8
}

/* name goes here */
type btrfs_timespec struct {
	sec  uint64
	nsec uint32
}

type btrfs_inode_item struct {
	generation  uint64
	transid     uint64
	size        uint64
	nbytes      uint64
	block_group uint64
	nlink       uint32
	uid         uint32
	gid         uint32
	mode        uint32
	rdev        uint64
	flags       uint64
	sequence    uint64
	reserved    [4]uint64
	atime       struct {
		sec  uint64
		nsec uint32
	}
	ctime struct {
		sec  uint64
		nsec uint32
	}
	mtime struct {
		sec  uint64
		nsec uint32
	}
	otime struct {
		sec  uint64
		nsec uint32
	}
}

type btrfs_dir_log_item struct {
	end uint64
}

type btrfs_dir_item struct {
	location struct {
		objectid uint64
		type_    uint8
		offset   uint64
	}
	transid  uint64
	data_len uint16
	name_len uint16
	type_    uint8
}

/*
 * Internal in-memory flag that a subvolume has been marked for deletion but
 * still visible as a directory
 */
type btrfs_root_item struct {
	inode struct {
		generation  uint64
		transid     uint64
		size        uint64
		nbytes      uint64
		block_group uint64
		nlink       uint32
		uid         uint32
		gid         uint32
		mode        uint32
		rdev        uint64
		flags       uint64
		sequence    uint64
		reserved    [4]uint64
		atime       struct {
			sec  uint64
			nsec uint32
		}
		ctime struct {
			sec  uint64
			nsec uint32
		}
		mtime struct {
			sec  uint64
			nsec uint32
		}
		otime struct {
			sec  uint64
			nsec uint32
		}
	}
	generation    uint64
	root_dirid    uint64
	bytenr        uint64
	byte_limit    uint64
	bytes_used    uint64
	last_snapshot uint64
	flags         uint64
	refs          uint32
	drop_progress struct {
		objectid uint64
		type_    uint8
		offset   uint64
	}
	drop_level    uint8
	level         uint8
	generation_v2 uint64
	uuid          UUID
	parent_uuid   UUID
	received_uuid UUID
	ctransid      uint64
	otransid      uint64
	stransid      uint64
	rtransid      uint64
	ctime         struct {
		sec  uint64
		nsec uint32
	}
	otime struct {
		sec  uint64
		nsec uint32
	}
	stime struct {
		sec  uint64
		nsec uint32
	}
	rtime struct {
		sec  uint64
		nsec uint32
	}
	reserved [8]uint64
}

/*
 * this is used for both forward and backward root refs
 */
type btrfs_root_ref struct {
	dirid    uint64
	sequence uint64
	name_len uint16
}

type btrfs_disk_balance_args struct {
	profiles    uint64
	usage       uint64
	usage_min   uint32
	usage_max   uint32
	devid       uint64
	pstart      uint64
	pend        uint64
	vstart      uint64
	vend        uint64
	target      uint64
	flags       uint64
	limit       uint64
	limit_min   uint32
	limit_max   uint32
	stripes_min uint32
	stripes_max uint32
	unused      [6]uint64
}

/*
 * store balance parameters to disk so that balance can be properly
 * resumed after crash or unmount
 */
type btrfs_balance_item struct {
	flags uint64
	data  struct {
		profiles    uint64
		usage       uint64
		usage_min   uint32
		usage_max   uint32
		devid       uint64
		pstart      uint64
		pend        uint64
		vstart      uint64
		vend        uint64
		target      uint64
		flags       uint64
		limit       uint64
		limit_min   uint32
		limit_max   uint32
		stripes_min uint32
		stripes_max uint32
		unused      [6]uint64
	}
	meta struct {
		profiles    uint64
		usage       uint64
		usage_min   uint32
		usage_max   uint32
		devid       uint64
		pstart      uint64
		pend        uint64
		vstart      uint64
		vend        uint64
		target      uint64
		flags       uint64
		limit       uint64
		limit_min   uint32
		limit_max   uint32
		stripes_min uint32
		stripes_max uint32
		unused      [6]uint64
	}
	sys struct {
		profiles    uint64
		usage       uint64
		usage_min   uint32
		usage_max   uint32
		devid       uint64
		pstart      uint64
		pend        uint64
		vstart      uint64
		vend        uint64
		target      uint64
		flags       uint64
		limit       uint64
		limit_min   uint32
		limit_max   uint32
		stripes_min uint32
		stripes_max uint32
		unused      [6]uint64
	}
	unused [4]uint64
}

type btrfs_file_extent_item struct {
	generation     uint64
	ram_bytes      uint64
	compression    uint8
	encryption     uint8
	other_encoding uint16
	type_          uint8
	disk_bytenr    uint64
	disk_num_bytes uint64
	offset         uint64
	num_bytes      uint64
}

type btrfs_csum_item struct {
	csum uint8
}

type btrfs_dev_stats_item struct {
	values [_BTRFS_DEV_STAT_VALUES_MAX]uint64
}

type btrfs_dev_replace_item struct {
	src_devid                     uint64
	cursor_left                   uint64
	cursor_right                  uint64
	cont_reading_from_srcdev_mode uint64
	replace_state                 uint64
	time_started                  uint64
	time_stopped                  uint64
	num_write_errors              uint64
	num_uncorrectable_read_errors uint64
}

/* different types of block groups (and chunks) */
const (
	_BTRFS_RAID_RAID10 = iota
	_BTRFS_RAID_RAID1
	_BTRFS_RAID_DUP
	_BTRFS_RAID_RAID0
	_BTRFS_RAID_SINGLE
	_BTRFS_RAID_RAID5
	_BTRFS_RAID_RAID6
	_BTRFS_NR_RAID_TYPES
)

/*
 * We need a bit for restriper to be able to tell when chunks of type
 * SINGLE are available.  This "extended" profile format is used in
 * fs_info->avail_*_alloc_bits (in-memory) and balance item fields
 * (on-disk).  The corresponding on-disk bit in chunk.type is reserved
 * to avoid remappings between two formats in future.
 */

/*
 * A fake block group type that is used to communicate global block reserve
 * size to userspace via the SPACE_INFO ioctl.
 */
func chunk_to_extended(flags uint64) uint64 {
	if flags&uint64(_BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0 {
		flags |= uint64(availAllocBitSingle)
	}

	return flags
}

func extended_to_chunk(flags uint64) uint64 {
	return flags &^ uint64(availAllocBitSingle)
}

type btrfs_block_group_item struct {
	used           uint64
	chunk_objectid uint64
	flags          uint64
}

type btrfs_free_space_info struct {
	extent_count uint32
	flags        uint32
}

func btrfs_qgroup_level(qgroupid uint64) uint64 {
	return qgroupid >> uint32(qgroupLevelShift)
}

/*
 * is subvolume quota turned on?
 */

/*
 * RESCAN is set during the initialization phase
 */

/*
 * Some qgroup entries are known to be out of date,
 * either because the configuration has changed in a way that
 * makes a rescan necessary, or because the fs has been mounted
 * with a non-qgroup-aware version.
 * Turning qouta off and on again makes it inconsistent, too.
 */
type btrfs_qgroup_status_item struct {
	version    uint64
	generation uint64
	flags      uint64
	rescan     uint64
}

type btrfs_qgroup_info_item struct {
	generation uint64
	rfer       uint64
	rfer_cmpr  uint64
	excl       uint64
	excl_cmpr  uint64
}

type btrfs_qgroup_limit_item struct {
	flags    uint64
	max_rfer uint64
	max_excl uint64
	rsv_rfer uint64
	rsv_excl uint64
}