RepoMirrors/btrfs
1
0
Fork 1
mirror of https://github.com/dennwc/btrfs synced 2025-01-10 00:59:23 +00:00
Code Issues Packages Projects Releases Wiki Activity
f03fa748e7
btrfs/ioctl_h.go

776 lines
26 KiB
Go
Raw Blame History

package btrfs
import (
"encoding/binary"
"encoding/hex"
"github.com/dennwc/btrfs/ioctl"
"os"
"unsafe"
)
var order = binary.LittleEndian
const ioctlMagic = 0x94
const devicePathNameMax = 1024
const (
FSIDSize = 16
UUIDSize = 16
)
var zeroUUID UUID
type UUID [UUIDSize]byte
func (id UUID) String() string {
if id == zeroUUID {
return "<zero>"
}
buf := make([]byte, UUIDSize*2+4)
i := 0
i += hex.Encode(buf[i:], id[:4])
buf[i] = '-'
i++
i += hex.Encode(buf[i:], id[4:6])
buf[i] = '-'
i++
i += hex.Encode(buf[i:], id[6:8])
buf[i] = '-'
i++
i += hex.Encode(buf[i:], id[8:10])
buf[i] = '-'
i++
i += hex.Encode(buf[i:], id[10:])
return string(buf)
}
type FSID [FSIDSize]byte
func (id FSID) String() string { return hex.EncodeToString(id[:]) }
const volNameMax = 4087
// this should be 4k
type btrfs_ioctl_vol_args struct {
fd int64
name [volNameMax + 1]byte
}
type btrfs_qgroup_limit struct {
flags uint64
max_referenced uint64
max_exclusive uint64
rsv_referenced uint64
rsv_exclusive uint64
}
type btrfs_qgroup_inherit struct {
flags uint64
num_qgroups uint64
num_ref_copies uint64
num_excl_copies uint64
lim btrfs_qgroup_limit
//qgroups [0]uint64
}
type btrfs_ioctl_qgroup_limit_args struct {
qgroupid uint64
lim btrfs_qgroup_limit
}
type btrfs_ioctl_vol_args_v2_u1 struct {
size uint64
qgroup_inherit *btrfs_qgroup_inherit
}
const subvolNameMax = 4039
type subvolFlags uint64
// flags for subvolumes
//
// Used by:
// struct btrfs_ioctl_vol_args_v2.flags
//
// BTRFS_SUBVOL_RDONLY is also provided/consumed by the following ioctls:
// - BTRFS_IOC_SUBVOL_GETFLAGS
// - BTRFS_IOC_SUBVOL_SETFLAGS
const (
subvolCreateAsync = subvolFlags(1 << 0)
subvolReadOnly = subvolFlags(1 << 1)
subvolQGroupInherit = subvolFlags(1 << 2)
)
type btrfs_ioctl_vol_args_v2 struct {
fd int64
transid uint64
flags subvolFlags
btrfs_ioctl_vol_args_v2_u1
unused [2]uint64
name [subvolNameMax + 1]byte
}
// structure to report errors and progress to userspace, either as a
// result of a finished scrub, a canceled scrub or a progress inquiry
type btrfs_scrub_progress struct {
data_extents_scrubbed uint64 // # of data extents scrubbed
tree_extents_scrubbed uint64 // # of tree extents scrubbed
data_bytes_scrubbed uint64 // # of data bytes scrubbed
tree_bytes_scrubbed uint64 // # of tree bytes scrubbed
read_errors uint64 // # of read errors encountered (EIO)
csum_errors uint64 // # of failed csum checks
// # of occurences, where the metadata of a tree block did not match the expected values, like generation or logical
verify_errors uint64
// # of 4k data block for which no csum is present, probably the result of data written with nodatasum
no_csum uint64
csum_discards uint64 // # of csum for which no data was found in the extent tree.
super_errors uint64 // # of bad super blocks encountered
malloc_errors uint64 // # of internal kmalloc errors. These will likely cause an incomplete scrub
uncorrectable_errors uint64 // # of errors where either no intact copy was found or the writeback failed
corrected_errors uint64 // # of errors corrected
// last physical address scrubbed. In case a scrub was aborted, this can be used to restart the scrub
last_physical uint64
// # of occurences where a read for a full (64k) bio failed, but the re-
// check succeeded for each 4k piece. Intermittent error.
unverified_errors uint64
}
type btrfs_ioctl_scrub_args struct {
devid uint64 // in
start uint64 // in
end uint64 // in
flags uint64 // in
progress btrfs_scrub_progress // out
// pad to 1k
_ [1024 - 4*8 - unsafe.Sizeof(btrfs_scrub_progress{})]byte
}
type contReadingFromSrcdevMode uint64
const (
_BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_ALWAYS contReadingFromSrcdevMode = 0
_BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_AVOID contReadingFromSrcdevMode = 1
)
type btrfs_ioctl_dev_replace_start_params struct {
srcdevid uint64 // in, if 0, use srcdev_name instead
cont_reading_from_srcdev_mode contReadingFromSrcdevMode // in
srcdev_name [devicePathNameMax + 1]byte // in
tgtdev_name [devicePathNameMax + 1]byte // in
}
type devReplaceState uint64
const (
_BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED devReplaceState = 0
_BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED devReplaceState = 1
_BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED devReplaceState = 2
_BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED devReplaceState = 3
_BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED devReplaceState = 4
)
type btrfs_ioctl_dev_replace_status_params struct {
replace_state devReplaceState // out
progress_1000 uint64 // out, 0 <= x <= 1000
time_started uint64 // out, seconds since 1-Jan-1970
time_stopped uint64 // out, seconds since 1-Jan-1970
num_write_errors uint64 // out
num_uncorrectable_read_errors uint64 // out
}
type btrfs_ioctl_dev_replace_args_u1 struct {
cmd uint64 // in
result uint64 // out
start btrfs_ioctl_dev_replace_start_params // in
spare [64]uint64
}
type btrfs_ioctl_dev_replace_args_u2 struct {
cmd uint64 // in
result uint64 // out
status btrfs_ioctl_dev_replace_status_params // out
_ [unsafe.Sizeof(btrfs_ioctl_dev_replace_start_params{}) - unsafe.Sizeof(btrfs_ioctl_dev_replace_status_params{})]byte
spare [64]uint64
}
type btrfs_ioctl_dev_info_args struct {
devid uint64 // in/out
uuid UUID // in/out
bytes_used uint64 // out
total_bytes uint64 // out
_ [379]uint64 // pad to 4k
path [devicePathNameMax]byte // out
}
type btrfs_ioctl_fs_info_args struct {
max_id uint64 // out
num_devices uint64 // out
fsid FSID // out
nodesize uint32 // out
sectorsize uint32 // out
clone_alignment uint32 // out
_ [122*8 + 4]byte // pad to 1k
}
type btrfs_ioctl_feature_flags struct {
compat_flags FeatureFlags
compat_ro_flags FeatureFlags
incompat_flags IncompatFeatures
}
type argRange [8]byte
func (u argRange) asN() uint64 {
return order.Uint64(u[:])
}
func (u argRange) asMinMax() (min, max uint32) {
return order.Uint32(u[:4]), order.Uint32(u[4:])
}
// balance control ioctl modes
//#define BTRFS_BALANCE_CTL_PAUSE 1
//#define BTRFS_BALANCE_CTL_CANCEL 2
//#define BTRFS_BALANCE_CTL_RESUME 3
// this is packed, because it should be exactly the same as its disk
// byte order counterpart (struct btrfs_disk_balance_args)
type btrfs_balance_args struct {
profiles uint64
// usage filter
// BTRFS_BALANCE_ARGS_USAGE with a single value means '0..N'
// BTRFS_BALANCE_ARGS_USAGE_RANGE - range syntax, min..max
usage argRange
devid uint64
pstart uint64
pend uint64
vstart uint64
vend uint64
target uint64
flags uint64
// BTRFS_BALANCE_ARGS_LIMIT with value 'limit' (limit number of processed chunks)
// BTRFS_BALANCE_ARGS_LIMIT_RANGE - the extend version can use minimum and maximum
limit argRange
stripes_min uint32
stripes_max uint32
_ [48]byte
}
// report balance progress to userspace
type btrfs_balance_progress struct {
expected uint64 // estimated # of chunks that will be relocated to fulfill the request
considered uint64 // # of chunks we have considered so far
completed uint64 // # of chunks relocated so far
}
type balanceState uint64
const (
_BTRFS_BALANCE_STATE_RUNNING balanceState = (1 << 0)
_BTRFS_BALANCE_STATE_PAUSE_REQ balanceState = (1 << 1)
_BTRFS_BALANCE_STATE_CANCEL_REQ balanceState = (1 << 2)
)
type btrfs_ioctl_balance_args struct {
flags uint64 // in/out
state balanceState // out
data btrfs_balance_args // in/out
meta btrfs_balance_args // in/out
sys btrfs_balance_args // in/out
stat btrfs_balance_progress // out
_ [72 * 8]byte // pad to 1k
}
const _BTRFS_INO_LOOKUP_PATH_MAX = 4080
type btrfs_ioctl_ino_lookup_args struct {
treeid uint64
objectid uint64
name [_BTRFS_INO_LOOKUP_PATH_MAX]byte
}
type btrfs_ioctl_search_key struct {
tree_id uint64 // which root are we searching. 0 is the tree of tree roots
// keys returned will be >= min and <= max
min_objectid uint64
max_objectid uint64
// keys returned will be >= min and <= max
min_offset uint64
max_offset uint64
// max and min transids to search for
min_transid uint64
max_transid uint64
// keys returned will be >= min and <= max
min_type uint32
max_type uint32
// how many items did userland ask for, and how many are we returning
nr_items uint32
_ [36]byte
}
type btrfs_ioctl_search_header struct {
transid uint64
objectid uint64
offset uint64
typ uint32
len uint32
}
const _BTRFS_SEARCH_ARGS_BUFSIZE = (4096 - unsafe.Sizeof(btrfs_ioctl_search_key{}))
// the buf is an array of search headers where
// each header is followed by the actual item
// the type field is expanded to 32 bits for alignment
type btrfs_ioctl_search_args struct {
key btrfs_ioctl_search_key
buf [_BTRFS_SEARCH_ARGS_BUFSIZE]byte
}
// Extended version of TREE_SEARCH ioctl that can return more than 4k of bytes.
// The allocated size of the buffer is set in buf_size.
type btrfs_ioctl_search_args_v2 struct {
key btrfs_ioctl_search_key // in/out - search parameters
buf_size uint64 // in - size of buffer; out - on EOVERFLOW: needed size to store item
//buf [0]uint64 // out - found items
}
// With a @src_length of zero, the range from @src_offset->EOF is cloned!
type btrfs_ioctl_clone_range_args struct {
src_fd int64
src_offset uint64
src_length uint64
dest_offset uint64
}
// flags for the defrag range ioctl
type defragRange uint64
const (
_BTRFS_DEFRAG_RANGE_COMPRESS defragRange = 1
_BTRFS_DEFRAG_RANGE_START_IO defragRange = 2
)
const _BTRFS_SAME_DATA_DIFFERS = 1
// For extent-same ioctl
type btrfs_ioctl_same_extent_info struct {
fd int64 // in - destination file
logical_offset uint64 // in - start of extent in destination
bytes_deduped uint64 // out - total # of bytes we were able to dedupe from this file
// out; status of this dedupe operation:
// 0 if dedup succeeds
// < 0 for error
// == BTRFS_SAME_DATA_DIFFERS if data differs
status int32
reserved uint32
}
type btrfs_ioctl_same_args struct {
logical_offset uint64 // in - start of extent in source
length uint64 // in - length of extent
dest_count uint16 // in - total elements in info array
_ [6]byte
//info [0]btrfs_ioctl_same_extent_info
}
type btrfs_ioctl_defrag_range_args struct {
start uint64 // start of the defrag operation
len uint64 // number of bytes to defrag, use (u64)-1 to say all
// flags for the operation, which can include turning
// on compression for this one defrag
flags uint64
// any extent bigger than this will be considered
// already defragged. Use 0 to take the kernel default
// Use 1 to say every single extent must be rewritten
extent_thresh uint32
// which compression method to use if turning on compression
// for this defrag operation. If unspecified, zlib will be used
compress_type uint32
_ [16]byte // spare for later
}
type btrfs_ioctl_space_info struct {
flags uint64
total_bytes uint64
used_bytes uint64
}
type btrfs_ioctl_space_args struct {
space_slots uint64
total_spaces uint64
//spaces [0]btrfs_ioctl_space_info
}
type btrfs_data_container struct {
bytes_left uint32 // out -- bytes not needed to deliver output
bytes_missing uint32 // out -- additional bytes needed for result
elem_cnt uint32 // out
elem_missed uint32 // out
//val [0]uint64
}
type btrfs_ioctl_ino_path_args struct {
inum uint64 // in
size uint64 // in
_ [32]byte
// struct btrfs_data_container *fspath; out
fspath uint64 // out
}
type btrfs_ioctl_logical_ino_args struct {
logical uint64 // in
size uint64 // in
_ [32]byte
// struct btrfs_data_container *inodes; out
inodes uint64
}
// disk I/O failure stats
const (
_BTRFS_DEV_STAT_WRITE_ERRS = iota // EIO or EREMOTEIO from lower layers
_BTRFS_DEV_STAT_READ_ERRS // EIO or EREMOTEIO from lower layers
_BTRFS_DEV_STAT_FLUSH_ERRS // EIO or EREMOTEIO from lower layers
// stats for indirect indications for I/O failures
// checksum error, bytenr error or contents is illegal: this is an
// indication that the block was damaged during read or write, or written to
// wrong location or read from wrong location
_BTRFS_DEV_STAT_CORRUPTION_ERRS
_BTRFS_DEV_STAT_GENERATION_ERRS // an indication that blocks have not been written
_BTRFS_DEV_STAT_VALUES_MAX
)
// Reset statistics after reading; needs SYS_ADMIN capability
const _BTRFS_DEV_STATS_RESET = (1 << 0)
type btrfs_ioctl_get_dev_stats struct {
devid uint64 // in
nr_items uint64 // in/out
flags uint64 // in/out
values [_BTRFS_DEV_STAT_VALUES_MAX]uint64 // out values
_ [128 - 2 - _BTRFS_DEV_STAT_VALUES_MAX]uint64 // pad to 1k
}
const (
_BTRFS_QUOTA_CTL_ENABLE = 1
_BTRFS_QUOTA_CTL_DISABLE = 2
// 3 has formerly been reserved for BTRFS_QUOTA_CTL_RESCAN
)
type btrfs_ioctl_quota_ctl_args struct {
cmd uint64
status uint64
}
type btrfs_ioctl_quota_rescan_args struct {
flags uint64
progress uint64
_ [6]uint64
}
type btrfs_ioctl_qgroup_assign_args struct {
assign uint64
src uint64
dst uint64
}
type btrfs_ioctl_qgroup_create_args struct {
create uint64
qgroupid uint64
}
type btrfs_ioctl_timespec struct {
sec uint64
nsec uint32
}
type btrfs_ioctl_received_subvol_args struct {
uuid UUID // in
stransid uint64 // in
rtransid uint64 // out
stime btrfs_ioctl_timespec // in
rtime btrfs_ioctl_timespec // out
flags uint64 // in
_ [16]uint64 // in
}
const (
// Caller doesn't want file data in the send stream, even if the
// search of clone sources doesn't find an extent. UPDATE_EXTENT
// commands will be sent instead of WRITE commands.
_BTRFS_SEND_FLAG_NO_FILE_DATA = 0x1
// Do not add the leading stream header. Used when multiple snapshots
// are sent back to back.
_BTRFS_SEND_FLAG_OMIT_STREAM_HEADER = 0x2
// Omit the command at the end of the stream that indicated the end
// of the stream. This option is used when multiple snapshots are
// sent back to back.
_BTRFS_SEND_FLAG_OMIT_END_CMD = 0x4
_BTRFS_SEND_FLAG_MASK = _BTRFS_SEND_FLAG_NO_FILE_DATA |
_BTRFS_SEND_FLAG_OMIT_STREAM_HEADER |
_BTRFS_SEND_FLAG_OMIT_END_CMD
)
type btrfs_ioctl_send_args struct {
send_fd int64 // in
clone_sources_count uint64 // in
clone_sources *uint64 // in
parent_root uint64 // in
flags uint64 // in
_ [4]uint64 // in
}
var (
_BTRFS_IOC_SNAP_CREATE = ioctl.IOW(ioctlMagic, 1, unsafe.Sizeof(btrfs_ioctl_vol_args{}))
_BTRFS_IOC_DEFRAG = ioctl.IOW(ioctlMagic, 2, unsafe.Sizeof(btrfs_ioctl_vol_args{}))
_BTRFS_IOC_RESIZE = ioctl.IOW(ioctlMagic, 3, unsafe.Sizeof(btrfs_ioctl_vol_args{}))
_BTRFS_IOC_SCAN_DEV = ioctl.IOW(ioctlMagic, 4, unsafe.Sizeof(btrfs_ioctl_vol_args{}))
_BTRFS_IOC_TRANS_START = ioctl.IO(ioctlMagic, 6)
_BTRFS_IOC_TRANS_END = ioctl.IO(ioctlMagic, 7)
_BTRFS_IOC_SYNC = ioctl.IO(ioctlMagic, 8)
_BTRFS_IOC_CLONE = ioctl.IOW(ioctlMagic, 9, 4) // int32
_BTRFS_IOC_ADD_DEV = ioctl.IOW(ioctlMagic, 10, unsafe.Sizeof(btrfs_ioctl_vol_args{}))
_BTRFS_IOC_RM_DEV = ioctl.IOW(ioctlMagic, 11, unsafe.Sizeof(btrfs_ioctl_vol_args{}))
_BTRFS_IOC_BALANCE = ioctl.IOW(ioctlMagic, 12, unsafe.Sizeof(btrfs_ioctl_vol_args{}))
_BTRFS_IOC_CLONE_RANGE = ioctl.IOW(ioctlMagic, 13, unsafe.Sizeof(btrfs_ioctl_clone_range_args{}))
_BTRFS_IOC_SUBVOL_CREATE = ioctl.IOW(ioctlMagic, 14, unsafe.Sizeof(btrfs_ioctl_vol_args{}))
_BTRFS_IOC_SNAP_DESTROY = ioctl.IOW(ioctlMagic, 15, unsafe.Sizeof(btrfs_ioctl_vol_args{}))
_BTRFS_IOC_DEFRAG_RANGE = ioctl.IOW(ioctlMagic, 16, unsafe.Sizeof(btrfs_ioctl_defrag_range_args{}))
_BTRFS_IOC_TREE_SEARCH = ioctl.IOWR(ioctlMagic, 17, unsafe.Sizeof(btrfs_ioctl_search_args{}))
_BTRFS_IOC_INO_LOOKUP = ioctl.IOWR(ioctlMagic, 18, unsafe.Sizeof(btrfs_ioctl_ino_lookup_args{}))
_BTRFS_IOC_DEFAULT_SUBVOL = ioctl.IOW(ioctlMagic, 19, 8) // uint64
_BTRFS_IOC_SPACE_INFO = ioctl.IOWR(ioctlMagic, 20, unsafe.Sizeof(btrfs_ioctl_space_args{}))
_BTRFS_IOC_START_SYNC = ioctl.IOR(ioctlMagic, 24, 8) // uint64
_BTRFS_IOC_WAIT_SYNC = ioctl.IOW(ioctlMagic, 22, 8) // uint64
_BTRFS_IOC_SNAP_CREATE_V2 = ioctl.IOW(ioctlMagic, 23, unsafe.Sizeof(btrfs_ioctl_vol_args_v2{}))
_BTRFS_IOC_SUBVOL_CREATE_V2 = ioctl.IOW(ioctlMagic, 24, unsafe.Sizeof(btrfs_ioctl_vol_args_v2{}))
_BTRFS_IOC_SUBVOL_GETFLAGS = ioctl.IOR(ioctlMagic, 25, 8) // uint64
_BTRFS_IOC_SUBVOL_SETFLAGS = ioctl.IOW(ioctlMagic, 26, 8) // uint64
_BTRFS_IOC_SCRUB = ioctl.IOWR(ioctlMagic, 27, unsafe.Sizeof(btrfs_ioctl_scrub_args{}))
_BTRFS_IOC_SCRUB_CANCEL = ioctl.IO(ioctlMagic, 28)
_BTRFS_IOC_SCRUB_PROGRESS = ioctl.IOWR(ioctlMagic, 29, unsafe.Sizeof(btrfs_ioctl_scrub_args{}))
_BTRFS_IOC_DEV_INFO = ioctl.IOWR(ioctlMagic, 30, unsafe.Sizeof(btrfs_ioctl_dev_info_args{}))
_BTRFS_IOC_FS_INFO = ioctl.IOR(ioctlMagic, 31, unsafe.Sizeof(btrfs_ioctl_fs_info_args{}))
_BTRFS_IOC_BALANCE_CTL = ioctl.IOW(ioctlMagic, 33, 4) // int32
_BTRFS_IOC_BALANCE_PROGRESS = ioctl.IOR(ioctlMagic, 34, unsafe.Sizeof(btrfs_ioctl_balance_args{}))
_BTRFS_IOC_INO_PATHS = ioctl.IOWR(ioctlMagic, 35, unsafe.Sizeof(btrfs_ioctl_ino_path_args{}))
_BTRFS_IOC_LOGICAL_INO = ioctl.IOWR(ioctlMagic, 36, unsafe.Sizeof(btrfs_ioctl_ino_path_args{}))
_BTRFS_IOC_SET_RECEIVED_SUBVOL = ioctl.IOWR(ioctlMagic, 37, unsafe.Sizeof(btrfs_ioctl_received_subvol_args{}))
_BTRFS_IOC_SEND = ioctl.IOW(ioctlMagic, 38, unsafe.Sizeof(btrfs_ioctl_send_args{}))
_BTRFS_IOC_DEVICES_READY = ioctl.IOR(ioctlMagic, 39, unsafe.Sizeof(btrfs_ioctl_vol_args{}))
_BTRFS_IOC_QUOTA_CTL = ioctl.IOWR(ioctlMagic, 40, unsafe.Sizeof(btrfs_ioctl_quota_ctl_args{}))
_BTRFS_IOC_QGROUP_ASSIGN = ioctl.IOW(ioctlMagic, 41, unsafe.Sizeof(btrfs_ioctl_qgroup_assign_args{}))
_BTRFS_IOC_QGROUP_CREATE = ioctl.IOW(ioctlMagic, 42, unsafe.Sizeof(btrfs_ioctl_qgroup_create_args{}))
_BTRFS_IOC_QGROUP_LIMIT = ioctl.IOR(ioctlMagic, 43, unsafe.Sizeof(btrfs_ioctl_qgroup_limit_args{}))
_BTRFS_IOC_QUOTA_RESCAN = ioctl.IOW(ioctlMagic, 44, unsafe.Sizeof(btrfs_ioctl_quota_rescan_args{}))
_BTRFS_IOC_QUOTA_RESCAN_STATUS = ioctl.IOR(ioctlMagic, 45, unsafe.Sizeof(btrfs_ioctl_quota_rescan_args{}))
_BTRFS_IOC_QUOTA_RESCAN_WAIT = ioctl.IO(ioctlMagic, 46)
_BTRFS_IOC_GET_FSLABEL = ioctl.IOR(ioctlMagic, 49, BTRFS_LABEL_SIZE)
_BTRFS_IOC_SET_FSLABEL = ioctl.IOW(ioctlMagic, 50, BTRFS_LABEL_SIZE)
_BTRFS_IOC_GET_DEV_STATS = ioctl.IOWR(ioctlMagic, 52, unsafe.Sizeof(btrfs_ioctl_get_dev_stats{}))
_BTRFS_IOC_DEV_REPLACE = ioctl.IOWR(ioctlMagic, 53, unsafe.Sizeof(btrfs_ioctl_dev_replace_args_u1{}))
_BTRFS_IOC_FILE_EXTENT_SAME = ioctl.IOWR(ioctlMagic, 54, unsafe.Sizeof(btrfs_ioctl_same_args{}))
_BTRFS_IOC_GET_FEATURES = ioctl.IOR(ioctlMagic, 57, unsafe.Sizeof(btrfs_ioctl_feature_flags{}))
_BTRFS_IOC_SET_FEATURES = ioctl.IOW(ioctlMagic, 57, unsafe.Sizeof([2]btrfs_ioctl_feature_flags{}))
_BTRFS_IOC_GET_SUPPORTED_FEATURES = ioctl.IOR(ioctlMagic, 57, unsafe.Sizeof([3]btrfs_ioctl_feature_flags{}))
)
func iocSnapCreate(f *os.File, in *btrfs_ioctl_vol_args) error {
return ioctl.Do(f, _BTRFS_IOC_SNAP_CREATE, in)
}
func iocSnapCreateV2(f *os.File, in *btrfs_ioctl_vol_args_v2) error {
return ioctl.Do(f, _BTRFS_IOC_SNAP_CREATE_V2, in)
}
func iocDefrag(f *os.File, out *btrfs_ioctl_vol_args) error {
return ioctl.Do(f, _BTRFS_IOC_DEFRAG, out)
}
func iocResize(f *os.File, out *btrfs_ioctl_vol_args) error {
return ioctl.Do(f, _BTRFS_IOC_RESIZE, out)
}
func iocScanDev(f *os.File, out *btrfs_ioctl_vol_args) error {
return ioctl.Do(f, _BTRFS_IOC_SCAN_DEV, out)
}
func iocTransStart(f *os.File) error {
return ioctl.Do(f, _BTRFS_IOC_TRANS_START, nil)
}
func iocTransEnd(f *os.File) error {
return ioctl.Do(f, _BTRFS_IOC_TRANS_END, nil)
}
func iocSync(f *os.File) error {
return ioctl.Do(f, _BTRFS_IOC_SYNC, nil)
}
func iocClone(f *os.File, out *int32) error {
return ioctl.Do(f, _BTRFS_IOC_CLONE, out)
}
func iocAddDev(f *os.File, out *btrfs_ioctl_vol_args) error {
return ioctl.Do(f, _BTRFS_IOC_ADD_DEV, out)
}
func iocRmDev(f *os.File, out *btrfs_ioctl_vol_args) error {
return ioctl.Do(f, _BTRFS_IOC_RM_DEV, out)
}
func iocBalance(f *os.File, out *btrfs_ioctl_vol_args) error {
return ioctl.Do(f, _BTRFS_IOC_BALANCE, out)
}
func iocCloneRange(f *os.File, out *btrfs_ioctl_clone_range_args) error {
return ioctl.Do(f, _BTRFS_IOC_CLONE_RANGE, out)
}
func iocSubvolCreate(f *os.File, in *btrfs_ioctl_vol_args) error {
return ioctl.Do(f, _BTRFS_IOC_SUBVOL_CREATE, in)
}
func iocSubvolCreateV2(f *os.File, in *btrfs_ioctl_vol_args_v2) error {
return ioctl.Do(f, _BTRFS_IOC_SUBVOL_CREATE, in)
}
func iocSnapDestroy(f *os.File, in *btrfs_ioctl_vol_args) error {
return ioctl.Do(f, _BTRFS_IOC_SNAP_DESTROY, in)
}
func iocDefragRange(f *os.File, out *btrfs_ioctl_defrag_range_args) error {
return ioctl.Do(f, _BTRFS_IOC_DEFRAG_RANGE, out)
}
func iocTreeSearch(f *os.File, out *btrfs_ioctl_search_args) error {
return ioctl.Do(f, _BTRFS_IOC_TREE_SEARCH, out)
}
func iocInoLookup(f *os.File, out *btrfs_ioctl_ino_lookup_args) error {
return ioctl.Do(f, _BTRFS_IOC_INO_LOOKUP, out)
}
func iocDefaultSubvol(f *os.File, out *uint64) error {
return ioctl.Do(f, _BTRFS_IOC_DEFAULT_SUBVOL, out)
}
func iocSpaceInfo(f *os.File, out *btrfs_ioctl_space_args) error {
return ioctl.Do(f, _BTRFS_IOC_SPACE_INFO, out)
}
func iocStartSync(f *os.File, out *uint64) error {
return ioctl.Do(f, _BTRFS_IOC_START_SYNC, out)
}
func iocWaitSync(f *os.File, out *uint64) error {
return ioctl.Do(f, _BTRFS_IOC_WAIT_SYNC, out)
}
func iocSubvolGetflags(f *os.File, out *uint64) error {
return ioctl.Do(f, _BTRFS_IOC_SUBVOL_GETFLAGS, out)
}
func iocSubvolSetflags(f *os.File, out *uint64) error {
return ioctl.Do(f, _BTRFS_IOC_SUBVOL_SETFLAGS, out)
}
func iocScrub(f *os.File, out *btrfs_ioctl_scrub_args) error {
return ioctl.Do(f, _BTRFS_IOC_SCRUB, out)
}
func iocScrubCancel(f *os.File) error {
return ioctl.Do(f, _BTRFS_IOC_SCRUB_CANCEL, nil)
}
func iocScrubProgress(f *os.File, out *btrfs_ioctl_scrub_args) error {
return ioctl.Do(f, _BTRFS_IOC_SCRUB_PROGRESS, out)
}
func iocDevInfo(f *os.File, out *btrfs_ioctl_dev_info_args) error {
return ioctl.Do(f, _BTRFS_IOC_DEV_INFO, out)
}
func iocBalanceCtl(f *os.File, out *int32) error {
return ioctl.Do(f, _BTRFS_IOC_BALANCE_CTL, out)
}
func iocBalanceProgress(f *os.File, out *btrfs_ioctl_balance_args) error {
return ioctl.Do(f, _BTRFS_IOC_BALANCE_PROGRESS, out)
}
func iocInoPaths(f *os.File, out *btrfs_ioctl_ino_path_args) error {
return ioctl.Do(f, _BTRFS_IOC_INO_PATHS, out)
}
func iocLogicalIno(f *os.File, out *btrfs_ioctl_ino_path_args) error {
return ioctl.Do(f, _BTRFS_IOC_LOGICAL_INO, out)
}
func iocSetReceivedSubvol(f *os.File, out *btrfs_ioctl_received_subvol_args) error {
return ioctl.Do(f, _BTRFS_IOC_SET_RECEIVED_SUBVOL, out)
}
func iocSend(f *os.File, out *btrfs_ioctl_send_args) error {
return ioctl.Do(f, _BTRFS_IOC_SEND, out)
}
func iocDevicesReady(f *os.File, out *btrfs_ioctl_vol_args) error {
return ioctl.Do(f, _BTRFS_IOC_DEVICES_READY, out)
}
func iocQuotaCtl(f *os.File, out *btrfs_ioctl_quota_ctl_args) error {
return ioctl.Do(f, _BTRFS_IOC_QUOTA_CTL, out)
}
func iocQgroupAssign(f *os.File, out *btrfs_ioctl_qgroup_assign_args) error {
return ioctl.Do(f, _BTRFS_IOC_QGROUP_ASSIGN, out)
}
func iocQgroupCreate(f *os.File, out *btrfs_ioctl_qgroup_create_args) error {
return ioctl.Do(f, _BTRFS_IOC_QGROUP_CREATE, out)
}
func iocQgroupLimit(f *os.File, out *btrfs_ioctl_qgroup_limit_args) error {
return ioctl.Do(f, _BTRFS_IOC_QGROUP_LIMIT, out)
}
func iocQuotaRescan(f *os.File, out *btrfs_ioctl_quota_rescan_args) error {
return ioctl.Do(f, _BTRFS_IOC_QUOTA_RESCAN, out)
}
func iocQuotaRescanStatus(f *os.File, out *btrfs_ioctl_quota_rescan_args) error {
return ioctl.Do(f, _BTRFS_IOC_QUOTA_RESCAN_STATUS, out)
}
func iocQuotaRescanWait(f *os.File) error {
return ioctl.Do(f, _BTRFS_IOC_QUOTA_RESCAN_WAIT, nil)
}
func iocGetFslabel(f *os.File, out *[BTRFS_LABEL_SIZE]byte) error {
return ioctl.Do(f, _BTRFS_IOC_GET_FSLABEL, out)
}
func iocSetFslabel(f *os.File, out *[BTRFS_LABEL_SIZE]byte) error {
return ioctl.Do(f, _BTRFS_IOC_SET_FSLABEL, out)
}
func iocGetDevStats(f *os.File, out *btrfs_ioctl_get_dev_stats) error {
return ioctl.Do(f, _BTRFS_IOC_GET_DEV_STATS, out)
}
//func iocDevReplace(f *os.File, out *btrfs_ioctl_dev_replace_args) error {
// return ioctl.Do(f, _BTRFS_IOC_DEV_REPLACE, out)
//}
func iocFileExtentSame(f *os.File, out *btrfs_ioctl_same_args) error {
return ioctl.Do(f, _BTRFS_IOC_FILE_EXTENT_SAME, out)
}
func iocSetFeatures(f *os.File, out *[2]btrfs_ioctl_feature_flags) error {
return ioctl.Do(f, _BTRFS_IOC_SET_FEATURES, out)
}
Reference in New Issue View Git Blame Copy Permalink