forked from Mirrors/btrfs-progs
libbtrfsutil: copy in Btrfs UAPI headers
Systems with older kernels won't have these available, and the copies in btrfs-progs aren't quite compatible, so for now, let's just copy these in. We can potentially deduplicate some of this in the future. Signed-off-by: Omar Sandoval <osandov@fb.com> Signed-off-by: David Sterba <dsterba@suse.com>master
Omar Sandoval
David Sterba
parent
71d135ef44
commit
1b2775bdb0
|
|
@ -0,0 +1,840 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
/*
|
||||
* Copyright (C) 2007 Oracle. All rights reserved.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public
|
||||
* License v2 as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public
|
||||
* License along with this program; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||||
* Boston, MA 021110-1307, USA.
|
||||
*/
|
||||
|
||||
#ifndef _LINUX_BTRFS_H
|
||||
#define _LINUX_BTRFS_H
|
||||
#include <linux/types.h>
|
||||
#include <linux/ioctl.h>
|
||||
|
||||
#define BTRFS_IOCTL_MAGIC 0x94
|
||||
#define BTRFS_VOL_NAME_MAX 255
|
||||
#define BTRFS_LABEL_SIZE 256
|
||||
|
||||
/* this should be 4k */
|
||||
#define BTRFS_PATH_NAME_MAX 4087
|
||||
struct btrfs_ioctl_vol_args {
|
||||
__s64 fd;
|
||||
char name[BTRFS_PATH_NAME_MAX + 1];
|
||||
};
|
||||
|
||||
#define BTRFS_DEVICE_PATH_NAME_MAX 1024
|
||||
|
||||
#define BTRFS_DEVICE_SPEC_BY_ID (1ULL << 3)
|
||||
|
||||
#define BTRFS_VOL_ARG_V2_FLAGS_SUPPORTED \
|
||||
(BTRFS_SUBVOL_CREATE_ASYNC | \
|
||||
BTRFS_SUBVOL_RDONLY | \
|
||||
BTRFS_SUBVOL_QGROUP_INHERIT | \
|
||||
BTRFS_DEVICE_SPEC_BY_ID)
|
||||
|
||||
#define BTRFS_FSID_SIZE 16
|
||||
#define BTRFS_UUID_SIZE 16
|
||||
#define BTRFS_UUID_UNPARSED_SIZE 37
|
||||
|
||||
/*
|
||||
* flags definition for qgroup limits
|
||||
*
|
||||
* Used by:
|
||||
* struct btrfs_qgroup_limit.flags
|
||||
* struct btrfs_qgroup_limit_item.flags
|
||||
*/
|
||||
#define BTRFS_QGROUP_LIMIT_MAX_RFER (1ULL << 0)
|
||||
#define BTRFS_QGROUP_LIMIT_MAX_EXCL (1ULL << 1)
|
||||
#define BTRFS_QGROUP_LIMIT_RSV_RFER (1ULL << 2)
|
||||
#define BTRFS_QGROUP_LIMIT_RSV_EXCL (1ULL << 3)
|
||||
#define BTRFS_QGROUP_LIMIT_RFER_CMPR (1ULL << 4)
|
||||
#define BTRFS_QGROUP_LIMIT_EXCL_CMPR (1ULL << 5)
|
||||
|
||||
struct btrfs_qgroup_limit {
|
||||
__u64 flags;
|
||||
__u64 max_rfer;
|
||||
__u64 max_excl;
|
||||
__u64 rsv_rfer;
|
||||
__u64 rsv_excl;
|
||||
};
|
||||
|
||||
/*
|
||||
* flags definition for qgroup inheritance
|
||||
*
|
||||
* Used by:
|
||||
* struct btrfs_qgroup_inherit.flags
|
||||
*/
|
||||
#define BTRFS_QGROUP_INHERIT_SET_LIMITS (1ULL << 0)
|
||||
|
||||
struct btrfs_qgroup_inherit {
|
||||
__u64 flags;
|
||||
__u64 num_qgroups;
|
||||
__u64 num_ref_copies;
|
||||
__u64 num_excl_copies;
|
||||
struct btrfs_qgroup_limit lim;
|
||||
__u64 qgroups[0];
|
||||
};
|
||||
|
||||
struct btrfs_ioctl_qgroup_limit_args {
|
||||
__u64 qgroupid;
|
||||
struct btrfs_qgroup_limit lim;
|
||||
};
|
||||
|
||||
/*
|
||||
* 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
|
||||
*/
|
||||
#define BTRFS_SUBVOL_CREATE_ASYNC (1ULL << 0)
|
||||
#define BTRFS_SUBVOL_RDONLY (1ULL << 1)
|
||||
#define BTRFS_SUBVOL_QGROUP_INHERIT (1ULL << 2)
|
||||
|
||||
#define BTRFS_SUBVOL_NAME_MAX 4039
|
||||
struct btrfs_ioctl_vol_args_v2 {
|
||||
__s64 fd;
|
||||
__u64 transid;
|
||||
__u64 flags;
|
||||
union {
|
||||
struct {
|
||||
__u64 size;
|
||||
struct btrfs_qgroup_inherit *qgroup_inherit;
|
||||
};
|
||||
__u64 unused[4];
|
||||
};
|
||||
union {
|
||||
char name[BTRFS_SUBVOL_NAME_MAX + 1];
|
||||
__u64 devid;
|
||||
};
|
||||
};
|
||||
|
||||
/*
|
||||
* structure to report errors and progress to userspace, either as a
|
||||
* result of a finished scrub, a canceled scrub or a progress inquiry
|
||||
*/
|
||||
struct btrfs_scrub_progress {
|
||||
__u64 data_extents_scrubbed; /* # of data extents scrubbed */
|
||||
__u64 tree_extents_scrubbed; /* # of tree extents scrubbed */
|
||||
__u64 data_bytes_scrubbed; /* # of data bytes scrubbed */
|
||||
__u64 tree_bytes_scrubbed; /* # of tree bytes scrubbed */
|
||||
__u64 read_errors; /* # of read errors encountered (EIO) */
|
||||
__u64 csum_errors; /* # of failed csum checks */
|
||||
__u64 verify_errors; /* # of occurences, where the metadata
|
||||
* of a tree block did not match the
|
||||
* expected values, like generation or
|
||||
* logical */
|
||||
__u64 no_csum; /* # of 4k data block for which no csum
|
||||
* is present, probably the result of
|
||||
* data written with nodatasum */
|
||||
__u64 csum_discards; /* # of csum for which no data was found
|
||||
* in the extent tree. */
|
||||
__u64 super_errors; /* # of bad super blocks encountered */
|
||||
__u64 malloc_errors; /* # of internal kmalloc errors. These
|
||||
* will likely cause an incomplete
|
||||
* scrub */
|
||||
__u64 uncorrectable_errors; /* # of errors where either no intact
|
||||
* copy was found or the writeback
|
||||
* failed */
|
||||
__u64 corrected_errors; /* # of errors corrected */
|
||||
__u64 last_physical; /* last physical address scrubbed. In
|
||||
* case a scrub was aborted, this can
|
||||
* be used to restart the scrub */
|
||||
__u64 unverified_errors; /* # of occurences where a read for a
|
||||
* full (64k) bio failed, but the re-
|
||||
* check succeeded for each 4k piece.
|
||||
* Intermittent error. */
|
||||
};
|
||||
|
||||
#define BTRFS_SCRUB_READONLY 1
|
||||
struct btrfs_ioctl_scrub_args {
|
||||
__u64 devid; /* in */
|
||||
__u64 start; /* in */
|
||||
__u64 end; /* in */
|
||||
__u64 flags; /* in */
|
||||
struct btrfs_scrub_progress progress; /* out */
|
||||
/* pad to 1k */
|
||||
__u64 unused[(1024-32-sizeof(struct btrfs_scrub_progress))/8];
|
||||
};
|
||||
|
||||
#define BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_ALWAYS 0
|
||||
#define BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_AVOID 1
|
||||
struct btrfs_ioctl_dev_replace_start_params {
|
||||
__u64 srcdevid; /* in, if 0, use srcdev_name instead */
|
||||
__u64 cont_reading_from_srcdev_mode; /* in, see #define
|
||||
* above */
|
||||
__u8 srcdev_name[BTRFS_DEVICE_PATH_NAME_MAX + 1]; /* in */
|
||||
__u8 tgtdev_name[BTRFS_DEVICE_PATH_NAME_MAX + 1]; /* in */
|
||||
};
|
||||
|
||||
#define BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED 0
|
||||
#define BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED 1
|
||||
#define BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED 2
|
||||
#define BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED 3
|
||||
#define BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED 4
|
||||
struct btrfs_ioctl_dev_replace_status_params {
|
||||
__u64 replace_state; /* out, see #define above */
|
||||
__u64 progress_1000; /* out, 0 <= x <= 1000 */
|
||||
__u64 time_started; /* out, seconds since 1-Jan-1970 */
|
||||
__u64 time_stopped; /* out, seconds since 1-Jan-1970 */
|
||||
__u64 num_write_errors; /* out */
|
||||
__u64 num_uncorrectable_read_errors; /* out */
|
||||
};
|
||||
|
||||
#define BTRFS_IOCTL_DEV_REPLACE_CMD_START 0
|
||||
#define BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS 1
|
||||
#define BTRFS_IOCTL_DEV_REPLACE_CMD_CANCEL 2
|
||||
#define BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR 0
|
||||
#define BTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTED 1
|
||||
#define BTRFS_IOCTL_DEV_REPLACE_RESULT_ALREADY_STARTED 2
|
||||
#define BTRFS_IOCTL_DEV_REPLACE_RESULT_SCRUB_INPROGRESS 3
|
||||
struct btrfs_ioctl_dev_replace_args {
|
||||
__u64 cmd; /* in */
|
||||
__u64 result; /* out */
|
||||
|
||||
union {
|
||||
struct btrfs_ioctl_dev_replace_start_params start;
|
||||
struct btrfs_ioctl_dev_replace_status_params status;
|
||||
}; /* in/out */
|
||||
|
||||
__u64 spare[64];
|
||||
};
|
||||
|
||||
struct btrfs_ioctl_dev_info_args {
|
||||
__u64 devid; /* in/out */
|
||||
__u8 uuid[BTRFS_UUID_SIZE]; /* in/out */
|
||||
__u64 bytes_used; /* out */
|
||||
__u64 total_bytes; /* out */
|
||||
__u64 unused[379]; /* pad to 4k */
|
||||
__u8 path[BTRFS_DEVICE_PATH_NAME_MAX]; /* out */
|
||||
};
|
||||
|
||||
struct btrfs_ioctl_fs_info_args {
|
||||
__u64 max_id; /* out */
|
||||
__u64 num_devices; /* out */
|
||||
__u8 fsid[BTRFS_FSID_SIZE]; /* out */
|
||||
__u32 nodesize; /* out */
|
||||
__u32 sectorsize; /* out */
|
||||
__u32 clone_alignment; /* out */
|
||||
__u32 reserved32;
|
||||
__u64 reserved[122]; /* pad to 1k */
|
||||
};
|
||||
|
||||
/*
|
||||
* feature flags
|
||||
*
|
||||
* Used by:
|
||||
* struct btrfs_ioctl_feature_flags
|
||||
*/
|
||||
#define BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE (1ULL << 0)
|
||||
/*
|
||||
* Older kernels (< 4.9) on big-endian systems produced broken free space tree
|
||||
* bitmaps, and btrfs-progs also used to corrupt the free space tree (versions
|
||||
* < 4.7.3). If this bit is clear, then the free space tree cannot be trusted.
|
||||
* btrfs-progs can also intentionally clear this bit to ask the kernel to
|
||||
* rebuild the free space tree, however this might not work on older kernels
|
||||
* that do not know about this bit. If not sure, clear the cache manually on
|
||||
* first mount when booting older kernel versions.
|
||||
*/
|
||||
#define BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID (1ULL << 1)
|
||||
|
||||
#define BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF (1ULL << 0)
|
||||
#define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL (1ULL << 1)
|
||||
#define BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS (1ULL << 2)
|
||||
#define BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO (1ULL << 3)
|
||||
#define BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD (1ULL << 4)
|
||||
|
||||
/*
|
||||
* older kernels tried to do bigger metadata blocks, but the
|
||||
* code was pretty buggy. Lets not let them try anymore.
|
||||
*/
|
||||
#define BTRFS_FEATURE_INCOMPAT_BIG_METADATA (1ULL << 5)
|
||||
|
||||
#define BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF (1ULL << 6)
|
||||
#define BTRFS_FEATURE_INCOMPAT_RAID56 (1ULL << 7)
|
||||
#define BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA (1ULL << 8)
|
||||
#define BTRFS_FEATURE_INCOMPAT_NO_HOLES (1ULL << 9)
|
||||
|
||||
struct btrfs_ioctl_feature_flags {
|
||||
__u64 compat_flags;
|
||||
__u64 compat_ro_flags;
|
||||
__u64 incompat_flags;
|
||||
};
|
||||
|
||||
/* balance control ioctl modes */
|
||||
#define BTRFS_BALANCE_CTL_PAUSE 1
|
||||
#define BTRFS_BALANCE_CTL_CANCEL 2
|
||||
|
||||
/*
|
||||
* this is packed, because it should be exactly the same as its disk
|
||||
* byte order counterpart (struct btrfs_disk_balance_args)
|
||||
*/
|
||||
struct btrfs_balance_args {
|
||||
__u64 profiles;
|
||||
union {
|
||||
__u64 usage;
|
||||
struct {
|
||||
__u32 usage_min;
|
||||
__u32 usage_max;
|
||||
};
|
||||
};
|
||||
__u64 devid;
|
||||
__u64 pstart;
|
||||
__u64 pend;
|
||||
__u64 vstart;
|
||||
__u64 vend;
|
||||
|
||||
__u64 target;
|
||||
|
||||
__u64 flags;
|
||||
|
||||
/*
|
||||
* BTRFS_BALANCE_ARGS_LIMIT with value 'limit'
|
||||
* BTRFS_BALANCE_ARGS_LIMIT_RANGE - the extend version can use minimum
|
||||
* and maximum
|
||||
*/
|
||||
union {
|
||||
__u64 limit; /* limit number of processed chunks */
|
||||
struct {
|
||||
__u32 limit_min;
|
||||
__u32 limit_max;
|
||||
};
|
||||
};
|
||||
|
||||
/*
|
||||
* Process chunks that cross stripes_min..stripes_max devices,
|
||||
* BTRFS_BALANCE_ARGS_STRIPES_RANGE
|
||||
*/
|
||||
__u32 stripes_min;
|
||||
__u32 stripes_max;
|
||||
|
||||
__u64 unused[6];
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
/* report balance progress to userspace */
|
||||
struct btrfs_balance_progress {
|
||||
__u64 expected; /* estimated # of chunks that will be
|
||||
* relocated to fulfill the request */
|
||||
__u64 considered; /* # of chunks we have considered so far */
|
||||
__u64 completed; /* # of chunks relocated so far */
|
||||
};
|
||||
|
||||
/*
|
||||
* flags definition for balance
|
||||
*
|
||||
* Restriper's general type filter
|
||||
*
|
||||
* Used by:
|
||||
* btrfs_ioctl_balance_args.flags
|
||||
* btrfs_balance_control.flags (internal)
|
||||
*/
|
||||
#define BTRFS_BALANCE_DATA (1ULL << 0)
|
||||
#define BTRFS_BALANCE_SYSTEM (1ULL << 1)
|
||||
#define BTRFS_BALANCE_METADATA (1ULL << 2)
|
||||
|
||||
#define BTRFS_BALANCE_TYPE_MASK (BTRFS_BALANCE_DATA | \
|
||||
BTRFS_BALANCE_SYSTEM | \
|
||||
BTRFS_BALANCE_METADATA)
|
||||
|
||||
#define BTRFS_BALANCE_FORCE (1ULL << 3)
|
||||
#define BTRFS_BALANCE_RESUME (1ULL << 4)
|
||||
|
||||
/*
|
||||
* flags definitions for per-type balance args
|
||||
*
|
||||
* Balance filters
|
||||
*
|
||||
* Used by:
|
||||
* struct btrfs_balance_args
|
||||
*/
|
||||
#define BTRFS_BALANCE_ARGS_PROFILES (1ULL << 0)
|
||||
#define BTRFS_BALANCE_ARGS_USAGE (1ULL << 1)
|
||||
#define BTRFS_BALANCE_ARGS_DEVID (1ULL << 2)
|
||||
#define BTRFS_BALANCE_ARGS_DRANGE (1ULL << 3)
|
||||
#define BTRFS_BALANCE_ARGS_VRANGE (1ULL << 4)
|
||||
#define BTRFS_BALANCE_ARGS_LIMIT (1ULL << 5)
|
||||
#define BTRFS_BALANCE_ARGS_LIMIT_RANGE (1ULL << 6)
|
||||
#define BTRFS_BALANCE_ARGS_STRIPES_RANGE (1ULL << 7)
|
||||
#define BTRFS_BALANCE_ARGS_USAGE_RANGE (1ULL << 10)
|
||||
|
||||
#define BTRFS_BALANCE_ARGS_MASK \
|
||||
(BTRFS_BALANCE_ARGS_PROFILES | \
|
||||
BTRFS_BALANCE_ARGS_USAGE | \
|
||||
BTRFS_BALANCE_ARGS_DEVID | \
|
||||
BTRFS_BALANCE_ARGS_DRANGE | \
|
||||
BTRFS_BALANCE_ARGS_VRANGE | \
|
||||
BTRFS_BALANCE_ARGS_LIMIT | \
|
||||
BTRFS_BALANCE_ARGS_LIMIT_RANGE | \
|
||||
BTRFS_BALANCE_ARGS_STRIPES_RANGE | \
|
||||
BTRFS_BALANCE_ARGS_USAGE_RANGE)
|
||||
|
||||
/*
|
||||
* Profile changing flags. When SOFT is set we won't relocate chunk if
|
||||
* it already has the target profile (even though it may be
|
||||
* half-filled).
|
||||
*/
|
||||
#define BTRFS_BALANCE_ARGS_CONVERT (1ULL << 8)
|
||||
#define BTRFS_BALANCE_ARGS_SOFT (1ULL << 9)
|
||||
|
||||
|
||||
/*
|
||||
* flags definition for balance state
|
||||
*
|
||||
* Used by:
|
||||
* struct btrfs_ioctl_balance_args.state
|
||||
*/
|
||||
#define BTRFS_BALANCE_STATE_RUNNING (1ULL << 0)
|
||||
#define BTRFS_BALANCE_STATE_PAUSE_REQ (1ULL << 1)
|
||||
#define BTRFS_BALANCE_STATE_CANCEL_REQ (1ULL << 2)
|
||||
|
||||
struct btrfs_ioctl_balance_args {
|
||||
__u64 flags; /* in/out */
|
||||
__u64 state; /* out */
|
||||
|
||||
struct btrfs_balance_args data; /* in/out */
|
||||
struct btrfs_balance_args meta; /* in/out */
|
||||
struct btrfs_balance_args sys; /* in/out */
|
||||
|
||||
struct btrfs_balance_progress stat; /* out */
|
||||
|
||||
__u64 unused[72]; /* pad to 1k */
|
||||
};
|
||||
|
||||
#define BTRFS_INO_LOOKUP_PATH_MAX 4080
|
||||
struct btrfs_ioctl_ino_lookup_args {
|
||||
__u64 treeid;
|
||||
__u64 objectid;
|
||||
char name[BTRFS_INO_LOOKUP_PATH_MAX];
|
||||
};
|
||||
|
||||
/* Search criteria for the btrfs SEARCH ioctl family. */
|
||||
struct btrfs_ioctl_search_key {
|
||||
/*
|
||||
* The tree we're searching in. 1 is the tree of tree roots, 2 is the
|
||||
* extent tree, etc...
|
||||
*
|
||||
* A special tree_id value of 0 will cause a search in the subvolume
|
||||
* tree that the inode which is passed to the ioctl is part of.
|
||||
*/
|
||||
__u64 tree_id; /* in */
|
||||
|
||||
/*
|
||||
* When doing a tree search, we're actually taking a slice from a
|
||||
* linear search space of 136-bit keys.
|
||||
*
|
||||
* A full 136-bit tree key is composed as:
|
||||
* (objectid << 72) + (type << 64) + offset
|
||||
*
|
||||
* The individual min and max values for objectid, type and offset
|
||||
* define the min_key and max_key values for the search range. All
|
||||
* metadata items with a key in the interval [min_key, max_key] will be
|
||||
* returned.
|
||||
*
|
||||
* Additionally, we can filter the items returned on transaction id of
|
||||
* the metadata block they're stored in by specifying a transid range.
|
||||
* Be aware that this transaction id only denotes when the metadata
|
||||
* page that currently contains the item got written the last time as
|
||||
* result of a COW operation. The number does not have any meaning
|
||||
* related to the transaction in which an individual item that is being
|
||||
* returned was created or changed.
|
||||
*/
|
||||
__u64 min_objectid; /* in */
|
||||
__u64 max_objectid; /* in */
|
||||
__u64 min_offset; /* in */
|
||||
__u64 max_offset; /* in */
|
||||
__u64 min_transid; /* in */
|
||||
__u64 max_transid; /* in */
|
||||
__u32 min_type; /* in */
|
||||
__u32 max_type; /* in */
|
||||
|
||||
/*
|
||||
* input: The maximum amount of results desired.
|
||||
* output: The actual amount of items returned, restricted by any of:
|
||||
* - reaching the upper bound of the search range
|
||||
* - reaching the input nr_items amount of items
|
||||
* - completely filling the supplied memory buffer
|
||||
*/
|
||||
__u32 nr_items; /* in/out */
|
||||
|
||||
/* align to 64 bits */
|
||||
__u32 unused;
|
||||
|
||||
/* some extra for later */
|
||||
__u64 unused1;
|
||||
__u64 unused2;
|
||||
__u64 unused3;
|
||||
__u64 unused4;
|
||||
};
|
||||
|
||||
struct btrfs_ioctl_search_header {
|
||||
__u64 transid;
|
||||
__u64 objectid;
|
||||
__u64 offset;
|
||||
__u32 type;
|
||||
__u32 len;
|
||||
};
|
||||
|
||||
#define BTRFS_SEARCH_ARGS_BUFSIZE (4096 - sizeof(struct 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
|
||||
*/
|
||||
struct btrfs_ioctl_search_args {
|
||||
struct btrfs_ioctl_search_key key;
|
||||
char buf[BTRFS_SEARCH_ARGS_BUFSIZE];
|
||||
};
|
||||
|
||||
struct btrfs_ioctl_search_args_v2 {
|
||||
struct btrfs_ioctl_search_key key; /* in/out - search parameters */
|
||||
__u64 buf_size; /* in - size of buffer
|
||||
* out - on EOVERFLOW: needed size
|
||||
* to store item */
|
||||
__u64 buf[0]; /* out - found items */
|
||||
};
|
||||
|
||||
struct btrfs_ioctl_clone_range_args {
|
||||
__s64 src_fd;
|
||||
__u64 src_offset, src_length;
|
||||
__u64 dest_offset;
|
||||
};
|
||||
|
||||
/*
|
||||
* flags definition for the defrag range ioctl
|
||||
*
|
||||
* Used by:
|
||||
* struct btrfs_ioctl_defrag_range_args.flags
|
||||
*/
|
||||
#define BTRFS_DEFRAG_RANGE_COMPRESS 1
|
||||
#define BTRFS_DEFRAG_RANGE_START_IO 2
|
||||
struct btrfs_ioctl_defrag_range_args {
|
||||
/* start of the defrag operation */
|
||||
__u64 start;
|
||||
|
||||
/* number of bytes to defrag, use (u64)-1 to say all */
|
||||
__u64 len;
|
||||
|
||||
/*
|
||||
* flags for the operation, which can include turning
|
||||
* on compression for this one defrag
|
||||
*/
|
||||
__u64 flags;
|
||||
|
||||
/*
|
||||
* 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
|
||||
*/
|
||||
__u32 extent_thresh;
|
||||
|
||||
/*
|
||||
* which compression method to use if turning on compression
|
||||
* for this defrag operation. If unspecified, zlib will
|
||||
* be used
|
||||
*/
|
||||
__u32 compress_type;
|
||||
|
||||
/* spare for later */
|
||||
__u32 unused[4];
|
||||
};
|
||||
|
||||
|
||||
#define BTRFS_SAME_DATA_DIFFERS 1
|
||||
/* For extent-same ioctl */
|
||||
struct btrfs_ioctl_same_extent_info {
|
||||
__s64 fd; /* in - destination file */
|
||||
__u64 logical_offset; /* in - start of extent in destination */
|
||||
__u64 bytes_deduped; /* out - total # of bytes we were able
|
||||
* to dedupe from this file */
|
||||
/* status of this dedupe operation:
|
||||
* 0 if dedup succeeds
|
||||
* < 0 for error
|
||||
* == BTRFS_SAME_DATA_DIFFERS if data differs
|
||||
*/
|
||||
__s32 status; /* out - see above description */
|
||||
__u32 reserved;
|
||||
};
|
||||
|
||||
struct btrfs_ioctl_same_args {
|
||||
__u64 logical_offset; /* in - start of extent in source */
|
||||
__u64 length; /* in - length of extent */
|
||||
__u16 dest_count; /* in - total elements in info array */
|
||||
__u16 reserved1;
|
||||
__u32 reserved2;
|
||||
struct btrfs_ioctl_same_extent_info info[0];
|
||||
};
|
||||
|
||||
struct btrfs_ioctl_space_info {
|
||||
__u64 flags;
|
||||
__u64 total_bytes;
|
||||
__u64 used_bytes;
|
||||
};
|
||||
|
||||
struct btrfs_ioctl_space_args {
|
||||
__u64 space_slots;
|
||||
__u64 total_spaces;
|
||||
struct btrfs_ioctl_space_info spaces[0];
|
||||
};
|
||||
|
||||
struct btrfs_data_container {
|
||||
__u32 bytes_left; /* out -- bytes not needed to deliver output */
|
||||
__u32 bytes_missing; /* out -- additional bytes needed for result */
|
||||
__u32 elem_cnt; /* out */
|
||||
__u32 elem_missed; /* out */
|
||||
__u64 val[0]; /* out */
|
||||
};
|
||||
|
||||
struct btrfs_ioctl_ino_path_args {
|
||||
__u64 inum; /* in */
|
||||
__u64 size; /* in */
|
||||
__u64 reserved[4];
|
||||
/* struct btrfs_data_container *fspath; out */
|
||||
__u64 fspath; /* out */
|
||||
};
|
||||
|
||||
struct btrfs_ioctl_logical_ino_args {
|
||||
__u64 logical; /* in */
|
||||
__u64 size; /* in */
|
||||
__u64 reserved[4];
|
||||
/* struct btrfs_data_container *inodes; out */
|
||||
__u64 inodes;
|
||||
};
|
||||
|
||||
enum btrfs_dev_stat_values {
|
||||
/* disk I/O failure stats */
|
||||
BTRFS_DEV_STAT_WRITE_ERRS, /* 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 */
|
||||
BTRFS_DEV_STAT_CORRUPTION_ERRS, /* 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_GENERATION_ERRS, /* an indication that blocks have not
|
||||
* been written */
|
||||
|
||||
BTRFS_DEV_STAT_VALUES_MAX
|
||||
};
|
||||
|
||||
/* Reset statistics after reading; needs SYS_ADMIN capability */
|
||||
#define BTRFS_DEV_STATS_RESET (1ULL << 0)
|
||||
|
||||
struct btrfs_ioctl_get_dev_stats {
|
||||
__u64 devid; /* in */
|
||||
__u64 nr_items; /* in/out */
|
||||
__u64 flags; /* in/out */
|
||||
|
||||
/* out values: */
|
||||
__u64 values[BTRFS_DEV_STAT_VALUES_MAX];
|
||||
|
||||
__u64 unused[128 - 2 - BTRFS_DEV_STAT_VALUES_MAX]; /* pad to 1k */
|
||||
};
|
||||
|
||||
#define BTRFS_QUOTA_CTL_ENABLE 1
|
||||
#define BTRFS_QUOTA_CTL_DISABLE 2
|
||||
#define BTRFS_QUOTA_CTL_RESCAN__NOTUSED 3
|
||||
struct btrfs_ioctl_quota_ctl_args {
|
||||
__u64 cmd;
|
||||
__u64 status;
|
||||
};
|
||||
|
||||
struct btrfs_ioctl_quota_rescan_args {
|
||||
__u64 flags;
|
||||
__u64 progress;
|
||||
__u64 reserved[6];
|
||||
};
|
||||
|
||||
struct btrfs_ioctl_qgroup_assign_args {
|
||||
__u64 assign;
|
||||
__u64 src;
|
||||
__u64 dst;
|
||||
};
|
||||
|
||||
struct btrfs_ioctl_qgroup_create_args {
|
||||
__u64 create;
|
||||
__u64 qgroupid;
|
||||
};
|
||||
struct btrfs_ioctl_timespec {
|
||||
__u64 sec;
|
||||
__u32 nsec;
|
||||
};
|
||||
|
||||
struct btrfs_ioctl_received_subvol_args {
|
||||
char uuid[BTRFS_UUID_SIZE]; /* in */
|
||||
__u64 stransid; /* in */
|
||||
__u64 rtransid; /* out */
|
||||
struct btrfs_ioctl_timespec stime; /* in */
|
||||
struct btrfs_ioctl_timespec rtime; /* out */
|
||||
__u64 flags; /* in */
|
||||
__u64 reserved[16]; /* in */
|
||||
};
|
||||
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
#define BTRFS_SEND_FLAG_NO_FILE_DATA 0x1
|
||||
|
||||
/*
|
||||
* Do not add the leading stream header. Used when multiple snapshots
|
||||
* are sent back to back.
|
||||
*/
|
||||
#define 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.
|
||||
*/
|
||||
#define BTRFS_SEND_FLAG_OMIT_END_CMD 0x4
|
||||
|
||||
#define BTRFS_SEND_FLAG_MASK \
|
||||
(BTRFS_SEND_FLAG_NO_FILE_DATA | \
|
||||
BTRFS_SEND_FLAG_OMIT_STREAM_HEADER | \
|
||||
BTRFS_SEND_FLAG_OMIT_END_CMD)
|
||||
|
||||
struct btrfs_ioctl_send_args {
|
||||
__s64 send_fd; /* in */
|
||||
__u64 clone_sources_count; /* in */
|
||||
__u64 *clone_sources; /* in */
|
||||
__u64 parent_root; /* in */
|
||||
__u64 flags; /* in */
|
||||
__u64 reserved[4]; /* in */
|
||||
};
|
||||
|
||||
/* Error codes as returned by the kernel */
|
||||
enum btrfs_err_code {
|
||||
BTRFS_ERROR_DEV_RAID1_MIN_NOT_MET = 1,
|
||||
BTRFS_ERROR_DEV_RAID10_MIN_NOT_MET,
|
||||
BTRFS_ERROR_DEV_RAID5_MIN_NOT_MET,
|
||||
BTRFS_ERROR_DEV_RAID6_MIN_NOT_MET,
|
||||
BTRFS_ERROR_DEV_TGT_REPLACE,
|
||||
BTRFS_ERROR_DEV_MISSING_NOT_FOUND,
|
||||
BTRFS_ERROR_DEV_ONLY_WRITABLE,
|
||||
BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS
|
||||
};
|
||||
|
||||
#define BTRFS_IOC_SNAP_CREATE _IOW(BTRFS_IOCTL_MAGIC, 1, \
|
||||
struct btrfs_ioctl_vol_args)
|
||||
#define BTRFS_IOC_DEFRAG _IOW(BTRFS_IOCTL_MAGIC, 2, \
|
||||
struct btrfs_ioctl_vol_args)
|
||||
#define BTRFS_IOC_RESIZE _IOW(BTRFS_IOCTL_MAGIC, 3, \
|
||||
struct btrfs_ioctl_vol_args)
|
||||
#define BTRFS_IOC_SCAN_DEV _IOW(BTRFS_IOCTL_MAGIC, 4, \
|
||||
struct btrfs_ioctl_vol_args)
|
||||
/* trans start and trans end are dangerous, and only for
|
||||
* use by applications that know how to avoid the
|
||||
* resulting deadlocks
|
||||
*/
|
||||
#define BTRFS_IOC_TRANS_START _IO(BTRFS_IOCTL_MAGIC, 6)
|
||||
#define BTRFS_IOC_TRANS_END _IO(BTRFS_IOCTL_MAGIC, 7)
|
||||
#define BTRFS_IOC_SYNC _IO(BTRFS_IOCTL_MAGIC, 8)
|
||||
|
||||
#define BTRFS_IOC_CLONE _IOW(BTRFS_IOCTL_MAGIC, 9, int)
|
||||
#define BTRFS_IOC_ADD_DEV _IOW(BTRFS_IOCTL_MAGIC, 10, \
|
||||
struct btrfs_ioctl_vol_args)
|
||||
#define BTRFS_IOC_RM_DEV _IOW(BTRFS_IOCTL_MAGIC, 11, \
|
||||
struct btrfs_ioctl_vol_args)
|
||||
#define BTRFS_IOC_BALANCE _IOW(BTRFS_IOCTL_MAGIC, 12, \
|
||||
struct btrfs_ioctl_vol_args)
|
||||
|
||||
#define BTRFS_IOC_CLONE_RANGE _IOW(BTRFS_IOCTL_MAGIC, 13, \
|
||||
struct btrfs_ioctl_clone_range_args)
|
||||
|
||||
#define BTRFS_IOC_SUBVOL_CREATE _IOW(BTRFS_IOCTL_MAGIC, 14, \
|
||||
struct btrfs_ioctl_vol_args)
|
||||
#define BTRFS_IOC_SNAP_DESTROY _IOW(BTRFS_IOCTL_MAGIC, 15, \
|
||||
struct btrfs_ioctl_vol_args)
|
||||
#define BTRFS_IOC_DEFRAG_RANGE _IOW(BTRFS_IOCTL_MAGIC, 16, \
|
||||
struct btrfs_ioctl_defrag_range_args)
|
||||
#define BTRFS_IOC_TREE_SEARCH _IOWR(BTRFS_IOCTL_MAGIC, 17, \
|
||||
struct btrfs_ioctl_search_args)
|
||||
#define BTRFS_IOC_TREE_SEARCH_V2 _IOWR(BTRFS_IOCTL_MAGIC, 17, \
|
||||
struct btrfs_ioctl_search_args_v2)
|
||||
#define BTRFS_IOC_INO_LOOKUP _IOWR(BTRFS_IOCTL_MAGIC, 18, \
|
||||
struct btrfs_ioctl_ino_lookup_args)
|
||||
#define BTRFS_IOC_DEFAULT_SUBVOL _IOW(BTRFS_IOCTL_MAGIC, 19, __u64)
|
||||
#define BTRFS_IOC_SPACE_INFO _IOWR(BTRFS_IOCTL_MAGIC, 20, \
|
||||
struct btrfs_ioctl_space_args)
|
||||
#define BTRFS_IOC_START_SYNC _IOR(BTRFS_IOCTL_MAGIC, 24, __u64)
|
||||
#define BTRFS_IOC_WAIT_SYNC _IOW(BTRFS_IOCTL_MAGIC, 22, __u64)
|
||||
#define BTRFS_IOC_SNAP_CREATE_V2 _IOW(BTRFS_IOCTL_MAGIC, 23, \
|
||||
struct btrfs_ioctl_vol_args_v2)
|
||||
#define BTRFS_IOC_SUBVOL_CREATE_V2 _IOW(BTRFS_IOCTL_MAGIC, 24, \
|
||||
struct btrfs_ioctl_vol_args_v2)
|
||||
#define BTRFS_IOC_SUBVOL_GETFLAGS _IOR(BTRFS_IOCTL_MAGIC, 25, __u64)
|
||||
#define BTRFS_IOC_SUBVOL_SETFLAGS _IOW(BTRFS_IOCTL_MAGIC, 26, __u64)
|
||||
#define BTRFS_IOC_SCRUB _IOWR(BTRFS_IOCTL_MAGIC, 27, \
|
||||
struct btrfs_ioctl_scrub_args)
|
||||
#define BTRFS_IOC_SCRUB_CANCEL _IO(BTRFS_IOCTL_MAGIC, 28)
|
||||
#define BTRFS_IOC_SCRUB_PROGRESS _IOWR(BTRFS_IOCTL_MAGIC, 29, \
|
||||
struct btrfs_ioctl_scrub_args)
|
||||
#define BTRFS_IOC_DEV_INFO _IOWR(BTRFS_IOCTL_MAGIC, 30, \
|
||||
struct btrfs_ioctl_dev_info_args)
|
||||
#define BTRFS_IOC_FS_INFO _IOR(BTRFS_IOCTL_MAGIC, 31, \
|
||||
struct btrfs_ioctl_fs_info_args)
|
||||
#define BTRFS_IOC_BALANCE_V2 _IOWR(BTRFS_IOCTL_MAGIC, 32, \
|
||||
struct btrfs_ioctl_balance_args)
|
||||
#define BTRFS_IOC_BALANCE_CTL _IOW(BTRFS_IOCTL_MAGIC, 33, int)
|
||||
#define BTRFS_IOC_BALANCE_PROGRESS _IOR(BTRFS_IOCTL_MAGIC, 34, \
|
||||
struct btrfs_ioctl_balance_args)
|
||||
#define BTRFS_IOC_INO_PATHS _IOWR(BTRFS_IOCTL_MAGIC, 35, \
|
||||
struct btrfs_ioctl_ino_path_args)
|
||||
#define BTRFS_IOC_LOGICAL_INO _IOWR(BTRFS_IOCTL_MAGIC, 36, \
|
||||
struct btrfs_ioctl_logical_ino_args)
|
||||
#define BTRFS_IOC_SET_RECEIVED_SUBVOL _IOWR(BTRFS_IOCTL_MAGIC, 37, \
|
||||
struct btrfs_ioctl_received_subvol_args)
|
||||
#define BTRFS_IOC_SEND _IOW(BTRFS_IOCTL_MAGIC, 38, struct btrfs_ioctl_send_args)
|
||||
#define BTRFS_IOC_DEVICES_READY _IOR(BTRFS_IOCTL_MAGIC, 39, \
|
||||
struct btrfs_ioctl_vol_args)
|
||||
#define BTRFS_IOC_QUOTA_CTL _IOWR(BTRFS_IOCTL_MAGIC, 40, \
|
||||
struct btrfs_ioctl_quota_ctl_args)
|
||||
#define BTRFS_IOC_QGROUP_ASSIGN _IOW(BTRFS_IOCTL_MAGIC, 41, \
|
||||
struct btrfs_ioctl_qgroup_assign_args)
|
||||
#define BTRFS_IOC_QGROUP_CREATE _IOW(BTRFS_IOCTL_MAGIC, 42, \
|
||||
struct btrfs_ioctl_qgroup_create_args)
|
||||
#define BTRFS_IOC_QGROUP_LIMIT _IOR(BTRFS_IOCTL_MAGIC, 43, \
|
||||
struct btrfs_ioctl_qgroup_limit_args)
|
||||
#define BTRFS_IOC_QUOTA_RESCAN _IOW(BTRFS_IOCTL_MAGIC, 44, \
|
||||
struct btrfs_ioctl_quota_rescan_args)
|
||||
#define BTRFS_IOC_QUOTA_RESCAN_STATUS _IOR(BTRFS_IOCTL_MAGIC, 45, \
|
||||
struct btrfs_ioctl_quota_rescan_args)
|
||||
#define BTRFS_IOC_QUOTA_RESCAN_WAIT _IO(BTRFS_IOCTL_MAGIC, 46)
|
||||
#define BTRFS_IOC_GET_FSLABEL _IOR(BTRFS_IOCTL_MAGIC, 49, \
|
||||
char[BTRFS_LABEL_SIZE])
|
||||
#define BTRFS_IOC_SET_FSLABEL _IOW(BTRFS_IOCTL_MAGIC, 50, \
|
||||
char[BTRFS_LABEL_SIZE])
|
||||
#define BTRFS_IOC_GET_DEV_STATS _IOWR(BTRFS_IOCTL_MAGIC, 52, \
|
||||
struct btrfs_ioctl_get_dev_stats)
|
||||
#define BTRFS_IOC_DEV_REPLACE _IOWR(BTRFS_IOCTL_MAGIC, 53, \
|
||||
struct btrfs_ioctl_dev_replace_args)
|
||||
#define BTRFS_IOC_FILE_EXTENT_SAME _IOWR(BTRFS_IOCTL_MAGIC, 54, \
|
||||
struct btrfs_ioctl_same_args)
|
||||
#define BTRFS_IOC_GET_FEATURES _IOR(BTRFS_IOCTL_MAGIC, 57, \
|
||||
struct btrfs_ioctl_feature_flags)
|
||||
#define BTRFS_IOC_SET_FEATURES _IOW(BTRFS_IOCTL_MAGIC, 57, \
|
||||
struct btrfs_ioctl_feature_flags[2])
|
||||
#define BTRFS_IOC_GET_SUPPORTED_FEATURES _IOR(BTRFS_IOCTL_MAGIC, 57, \
|
||||
struct btrfs_ioctl_feature_flags[3])
|
||||
#define BTRFS_IOC_RM_DEV_V2 _IOW(BTRFS_IOCTL_MAGIC, 58, \
|
||||
struct btrfs_ioctl_vol_args_v2)
|
||||
|
||||
#endif /* _LINUX_BTRFS_H */
|
||||
|
|
@ -0,0 +1,970 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
#ifndef _BTRFS_CTREE_H_
|
||||
#define _BTRFS_CTREE_H_
|
||||
|
||||
#include "btrfs.h"
|
||||
#include <linux/types.h>
|
||||
|
||||
/*
|
||||
* 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 */
|
||||
#define BTRFS_ROOT_TREE_OBJECTID 1ULL
|
||||
|
||||
/* stores information about which extents are in use, and reference counts */
|
||||
#define BTRFS_EXTENT_TREE_OBJECTID 2ULL
|
||||
|
||||
/*
|
||||
* chunk tree stores translations from logical -> physical block numbering
|
||||
* the super block points to the chunk tree
|
||||
*/
|
||||
#define BTRFS_CHUNK_TREE_OBJECTID 3ULL
|
||||
|
||||
/*
|
||||
* 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
|
||||
*/
|
||||
#define BTRFS_DEV_TREE_OBJECTID 4ULL
|
||||
|
||||
/* one per subvolume, storing files and directories */
|
||||
#define BTRFS_FS_TREE_OBJECTID 5ULL
|
||||
|
||||
/* directory objectid inside the root tree */
|
||||
#define BTRFS_ROOT_TREE_DIR_OBJECTID 6ULL
|
||||
|
||||
/* holds checksums of all the data extents */
|
||||
#define BTRFS_CSUM_TREE_OBJECTID 7ULL
|
||||
|
||||
/* holds quota configuration and tracking */
|
||||
#define BTRFS_QUOTA_TREE_OBJECTID 8ULL
|
||||
|
||||
/* for storing items that use the BTRFS_UUID_KEY* types */
|
||||
#define BTRFS_UUID_TREE_OBJECTID 9ULL
|
||||
|
||||
/* tracks free space in block groups. */
|
||||
#define BTRFS_FREE_SPACE_TREE_OBJECTID 10ULL
|
||||
|
||||
/* device stats in the device tree */
|
||||
#define BTRFS_DEV_STATS_OBJECTID 0ULL
|
||||
|
||||
/* for storing balance parameters in the root tree */
|
||||
#define BTRFS_BALANCE_OBJECTID -4ULL
|
||||
|
||||
/* orhpan objectid for tracking unlinked/truncated files */
|
||||
#define BTRFS_ORPHAN_OBJECTID -5ULL
|
||||
|
||||
/* does write ahead logging to speed up fsyncs */
|
||||
#define BTRFS_TREE_LOG_OBJECTID -6ULL
|
||||
#define BTRFS_TREE_LOG_FIXUP_OBJECTID -7ULL
|
||||
|
||||
/* for space balancing */
|
||||
#define BTRFS_TREE_RELOC_OBJECTID -8ULL
|
||||
#define BTRFS_DATA_RELOC_TREE_OBJECTID -9ULL
|
||||
|
||||
/*
|
||||
* extent checksums all have this objectid
|
||||
* this allows them to share the logging tree
|
||||
* for fsyncs
|
||||
*/
|
||||
#define BTRFS_EXTENT_CSUM_OBJECTID -10ULL
|
||||
|
||||
/* For storing free space cache */
|
||||
#define BTRFS_FREE_SPACE_OBJECTID -11ULL
|
||||
|
||||
/*
|
||||
* The inode number assigned to the special inode for storing
|
||||
* free ino cache
|
||||
*/
|
||||
#define BTRFS_FREE_INO_OBJECTID -12ULL
|
||||
|
||||
/* dummy objectid represents multiple objectids */
|
||||
#define BTRFS_MULTIPLE_OBJECTIDS -255ULL
|
||||
|
||||
/*
|
||||
* All files have objectids in this range.
|
||||
*/
|
||||
#define BTRFS_FIRST_FREE_OBJECTID 256ULL
|
||||
#define BTRFS_LAST_FREE_OBJECTID -256ULL
|
||||
#define BTRFS_FIRST_CHUNK_TREE_OBJECTID 256ULL
|
||||
|
||||
|
||||
/*
|
||||
* the device items go into the chunk tree. The key is in the form
|
||||
* [ 1 BTRFS_DEV_ITEM_KEY device_id ]
|
||||
*/
|
||||
#define BTRFS_DEV_ITEMS_OBJECTID 1ULL
|
||||
|
||||
#define BTRFS_BTREE_INODE_OBJECTID 1
|
||||
|
||||
#define BTRFS_EMPTY_SUBVOL_DIR_OBJECTID 2
|
||||
|
||||
#define BTRFS_DEV_REPLACE_DEVID 0ULL
|
||||
|
||||
/*
|
||||
* 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
|
||||
*/
|
||||
#define BTRFS_INODE_ITEM_KEY 1
|
||||
#define BTRFS_INODE_REF_KEY 12
|
||||
#define BTRFS_INODE_EXTREF_KEY 13
|
||||
#define BTRFS_XATTR_ITEM_KEY 24
|
||||
#define BTRFS_ORPHAN_ITEM_KEY 48
|
||||
/* 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.
|
||||
*/
|
||||
#define BTRFS_DIR_LOG_ITEM_KEY 60
|
||||
#define BTRFS_DIR_LOG_INDEX_KEY 72
|
||||
#define BTRFS_DIR_ITEM_KEY 84
|
||||
#define BTRFS_DIR_INDEX_KEY 96
|
||||
/*
|
||||
* extent data is for file data
|
||||
*/
|
||||
#define BTRFS_EXTENT_DATA_KEY 108
|
||||
|
||||
/*
|
||||
* extent csums are stored in a separate tree and hold csums for
|
||||
* an entire extent on disk.
|
||||
*/
|
||||
#define BTRFS_EXTENT_CSUM_KEY 128
|
||||
|
||||
/*
|
||||
* root items point to tree roots. They are typically in the root
|
||||
* tree used by the super block to find all the other trees
|
||||
*/
|
||||
#define BTRFS_ROOT_ITEM_KEY 132
|
||||
|
||||
/*
|
||||
* root backrefs tie subvols and snapshots to the directory entries that
|
||||
* reference them
|
||||
*/
|
||||
#define BTRFS_ROOT_BACKREF_KEY 144
|
||||
|
||||
/*
|
||||
* 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
|
||||
*/
|
||||
#define BTRFS_ROOT_REF_KEY 156
|
||||
|
||||
/*
|
||||
* extent items are in the extent map tree. These record which blocks
|
||||
* are used, and how many references there are to each block
|
||||
*/
|
||||
#define BTRFS_EXTENT_ITEM_KEY 168
|
||||
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
#define BTRFS_METADATA_ITEM_KEY 169
|
||||
|
||||
#define BTRFS_TREE_BLOCK_REF_KEY 176
|
||||
|
||||
#define BTRFS_EXTENT_DATA_REF_KEY 178
|
||||
|
||||
#define BTRFS_EXTENT_REF_V0_KEY 180
|
||||
|
||||
#define BTRFS_SHARED_BLOCK_REF_KEY 182
|
||||
|
||||
#define BTRFS_SHARED_DATA_REF_KEY 184
|
||||
|
||||
/*
|
||||
* block groups give us hints into the extent allocation trees. Which
|
||||
* blocks are free etc etc
|
||||
*/
|
||||
#define BTRFS_BLOCK_GROUP_ITEM_KEY 192
|
||||
|
||||
/*
|
||||
* 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).
|
||||
*/
|
||||
#define BTRFS_FREE_SPACE_INFO_KEY 198
|
||||
|
||||
/*
|
||||
* 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).
|
||||
*/
|
||||
#define BTRFS_FREE_SPACE_EXTENT_KEY 199
|
||||
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
#define BTRFS_FREE_SPACE_BITMAP_KEY 200
|
||||
|
||||
#define BTRFS_DEV_EXTENT_KEY 204
|
||||
#define BTRFS_DEV_ITEM_KEY 216
|
||||
#define BTRFS_CHUNK_ITEM_KEY 228
|
||||
|
||||
/*
|
||||
* Records the overall state of the qgroups.
|
||||
* There's only one instance of this key present,
|
||||
* (0, BTRFS_QGROUP_STATUS_KEY, 0)
|
||||
*/
|
||||
#define BTRFS_QGROUP_STATUS_KEY 240
|
||||
/*
|
||||
* Records the currently used space of the qgroup.
|
||||
* One key per qgroup, (0, BTRFS_QGROUP_INFO_KEY, qgroupid).
|
||||
*/
|
||||
#define BTRFS_QGROUP_INFO_KEY 242
|
||||
/*
|
||||
* Contains the user configured limits for the qgroup.
|
||||
* One key per qgroup, (0, BTRFS_QGROUP_LIMIT_KEY, qgroupid).
|
||||
*/
|
||||
#define BTRFS_QGROUP_LIMIT_KEY 244
|
||||
/*
|
||||
* 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)
|
||||
*/
|
||||
#define BTRFS_QGROUP_RELATION_KEY 246
|
||||
|
||||
/*
|
||||
* Obsolete name, see BTRFS_TEMPORARY_ITEM_KEY.
|
||||
*/
|
||||
#define BTRFS_BALANCE_ITEM_KEY 248
|
||||
|
||||
/*
|
||||
* 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)
|
||||
*/
|
||||
#define BTRFS_TEMPORARY_ITEM_KEY 248
|
||||
|
||||
/*
|
||||
* Obsolete name, see BTRFS_PERSISTENT_ITEM_KEY
|
||||
*/
|
||||
#define BTRFS_DEV_STATS_KEY 249
|
||||
|
||||
/*
|
||||
* 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)
|
||||
*/
|
||||
#define BTRFS_PERSISTENT_ITEM_KEY 249
|
||||
|
||||
/*
|
||||
* Persistantly stores the device replace state in the device tree.
|
||||
* The key is built like this: (0, BTRFS_DEV_REPLACE_KEY, 0).
|
||||
*/
|
||||
#define BTRFS_DEV_REPLACE_KEY 250
|
||||
|
||||
/*
|
||||
* 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).
|
||||
*/
|
||||
#if BTRFS_UUID_SIZE != 16
|
||||
#error "UUID items require BTRFS_UUID_SIZE == 16!"
|
||||
#endif
|
||||
#define BTRFS_UUID_KEY_SUBVOL 251 /* for UUIDs assigned to subvols */
|
||||
#define BTRFS_UUID_KEY_RECEIVED_SUBVOL 252 /* for UUIDs assigned to
|
||||
* received subvols */
|
||||
|
||||
/*
|
||||
* string items are for debugging. They just store a short string of
|
||||
* data in the FS
|
||||
*/
|
||||
#define BTRFS_STRING_ITEM_KEY 253
|
||||
|
||||
|
||||
|
||||
/* 32 bytes in various csum fields */
|
||||
#define BTRFS_CSUM_SIZE 32
|
||||
|
||||
/* csum types */
|
||||
#define BTRFS_CSUM_TYPE_CRC32 0
|
||||
|
||||
/*
|
||||
* flags definitions for directory entry item type
|
||||
*
|
||||
* Used by:
|
||||
* struct btrfs_dir_item.type
|
||||
*/
|
||||
#define BTRFS_FT_UNKNOWN 0
|
||||
#define BTRFS_FT_REG_FILE 1
|
||||
#define BTRFS_FT_DIR 2
|
||||
#define BTRFS_FT_CHRDEV 3
|
||||
#define BTRFS_FT_BLKDEV 4
|
||||
#define BTRFS_FT_FIFO 5
|
||||
#define BTRFS_FT_SOCK 6
|
||||
#define BTRFS_FT_SYMLINK 7
|
||||
#define BTRFS_FT_XATTR 8
|
||||
#define BTRFS_FT_MAX 9
|
||||
|
||||
/*
|
||||
* 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)
|
||||
*/
|
||||
struct btrfs_disk_key {
|
||||
__le64 objectid;
|
||||
__u8 type;
|
||||
__le64 offset;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_key {
|
||||
__u64 objectid;
|
||||
__u8 type;
|
||||
__u64 offset;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_dev_item {
|
||||
/* the internal btrfs device id */
|
||||
__le64 devid;
|
||||
|
||||
/* size of the device */
|
||||
__le64 total_bytes;
|
||||
|
||||
/* bytes used */
|
||||
__le64 bytes_used;
|
||||
|
||||
/* optimal io alignment for this device */
|
||||
__le32 io_align;
|
||||
|
||||
/* optimal io width for this device */
|
||||
__le32 io_width;
|
||||
|
||||
/* minimal io size for this device */
|
||||
__le32 sector_size;
|
||||
|
||||
/* type and info about this device */
|
||||
__le64 type;
|
||||
|
||||
/* expected generation for this device */
|
||||
__le64 generation;
|
||||
|
||||
/*
|
||||
* starting byte of this partition on the device,
|
||||
* to allow for stripe alignment in the future
|
||||
*/
|
||||
__le64 start_offset;
|
||||
|
||||
/* grouping information for allocation decisions */
|
||||
__le32 dev_group;
|
||||
|
||||
/* seek speed 0-100 where 100 is fastest */
|
||||
__u8 seek_speed;
|
||||
|
||||
/* bandwidth 0-100 where 100 is fastest */
|
||||
__u8 bandwidth;
|
||||
|
||||
/* btrfs generated uuid for this device */
|
||||
__u8 uuid[BTRFS_UUID_SIZE];
|
||||
|
||||
/* uuid of FS who owns this device */
|
||||
__u8 fsid[BTRFS_UUID_SIZE];
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_stripe {
|
||||
__le64 devid;
|
||||
__le64 offset;
|
||||
__u8 dev_uuid[BTRFS_UUID_SIZE];
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_chunk {
|
||||
/* size of this chunk in bytes */
|
||||
__le64 length;
|
||||
|
||||
/* objectid of the root referencing this chunk */
|
||||
__le64 owner;
|
||||
|
||||
__le64 stripe_len;
|
||||
__le64 type;
|
||||
|
||||
/* optimal io alignment for this chunk */
|
||||
__le32 io_align;
|
||||
|
||||
/* optimal io width for this chunk */
|
||||
__le32 io_width;
|
||||
|
||||
/* minimal io size for this chunk */
|
||||
__le32 sector_size;
|
||||
|
||||
/* 2^16 stripes is quite a lot, a second limit is the size of a single
|
||||
* item in the btree
|
||||
*/
|
||||
__le16 num_stripes;
|
||||
|
||||
/* sub stripes only matter for raid10 */
|
||||
__le16 sub_stripes;
|
||||
struct btrfs_stripe stripe;
|
||||
/* additional stripes go here */
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
#define BTRFS_FREE_SPACE_EXTENT 1
|
||||
#define BTRFS_FREE_SPACE_BITMAP 2
|
||||
|
||||
struct btrfs_free_space_entry {
|
||||
__le64 offset;
|
||||
__le64 bytes;
|
||||
__u8 type;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_free_space_header {
|
||||
struct btrfs_disk_key location;
|
||||
__le64 generation;
|
||||
__le64 num_entries;
|
||||
__le64 num_bitmaps;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
#define BTRFS_HEADER_FLAG_WRITTEN (1ULL << 0)
|
||||
#define BTRFS_HEADER_FLAG_RELOC (1ULL << 1)
|
||||
|
||||
/* Super block flags */
|
||||
/* Errors detected */
|
||||
#define BTRFS_SUPER_FLAG_ERROR (1ULL << 2)
|
||||
|
||||
#define BTRFS_SUPER_FLAG_SEEDING (1ULL << 32)
|
||||
#define BTRFS_SUPER_FLAG_METADUMP (1ULL << 33)
|
||||
|
||||
|
||||
/*
|
||||
* items in the extent btree are used to record the objectid of the
|
||||
* owner of the block and the number of references
|
||||
*/
|
||||
|
||||
struct btrfs_extent_item {
|
||||
__le64 refs;
|
||||
__le64 generation;
|
||||
__le64 flags;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_extent_item_v0 {
|
||||
__le32 refs;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
|
||||
#define BTRFS_EXTENT_FLAG_DATA (1ULL << 0)
|
||||
#define BTRFS_EXTENT_FLAG_TREE_BLOCK (1ULL << 1)
|
||||
|
||||
/* following flags only apply to tree blocks */
|
||||
|
||||
/* use full backrefs for extent pointers in the block */
|
||||
#define BTRFS_BLOCK_FLAG_FULL_BACKREF (1ULL << 8)
|
||||
|
||||
/*
|
||||
* this flag is only used internally by scrub and may be changed at any time
|
||||
* it is only declared here to avoid collisions
|
||||
*/
|
||||
#define BTRFS_EXTENT_FLAG_SUPER (1ULL << 48)
|
||||
|
||||
struct btrfs_tree_block_info {
|
||||
struct btrfs_disk_key key;
|
||||
__u8 level;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_extent_data_ref {
|
||||
__le64 root;
|
||||
__le64 objectid;
|
||||
__le64 offset;
|
||||
__le32 count;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_shared_data_ref {
|
||||
__le32 count;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_extent_inline_ref {
|
||||
__u8 type;
|
||||
__le64 offset;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
/* old style backrefs item */
|
||||
struct btrfs_extent_ref_v0 {
|
||||
__le64 root;
|
||||
__le64 generation;
|
||||
__le64 objectid;
|
||||
__le32 count;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
|
||||
/* 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
|
||||
*/
|
||||
struct btrfs_dev_extent {
|
||||
__le64 chunk_tree;
|
||||
__le64 chunk_objectid;
|
||||
__le64 chunk_offset;
|
||||
__le64 length;
|
||||
__u8 chunk_tree_uuid[BTRFS_UUID_SIZE];
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_inode_ref {
|
||||
__le64 index;
|
||||
__le16 name_len;
|
||||
/* name goes here */
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_inode_extref {
|
||||
__le64 parent_objectid;
|
||||
__le64 index;
|
||||
__le16 name_len;
|
||||
__u8 name[0];
|
||||
/* name goes here */
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_timespec {
|
||||
__le64 sec;
|
||||
__le32 nsec;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_inode_item {
|
||||
/* nfs style generation number */
|
||||
__le64 generation;
|
||||
/* transid that last touched this inode */
|
||||
__le64 transid;
|
||||
__le64 size;
|
||||
__le64 nbytes;
|
||||
__le64 block_group;
|
||||
__le32 nlink;
|
||||
__le32 uid;
|
||||
__le32 gid;
|
||||
__le32 mode;
|
||||
__le64 rdev;
|
||||
__le64 flags;
|
||||
|
||||
/* modification sequence number for NFS */
|
||||
__le64 sequence;
|
||||
|
||||
/*
|
||||
* a little future expansion, for more than this we can
|
||||
* just grow the inode item and version it
|
||||
*/
|
||||
__le64 reserved[4];
|
||||
struct btrfs_timespec atime;
|
||||
struct btrfs_timespec ctime;
|
||||
struct btrfs_timespec mtime;
|
||||
struct btrfs_timespec otime;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_dir_log_item {
|
||||
__le64 end;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_dir_item {
|
||||
struct btrfs_disk_key location;
|
||||
__le64 transid;
|
||||
__le16 data_len;
|
||||
__le16 name_len;
|
||||
__u8 type;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
#define BTRFS_ROOT_SUBVOL_RDONLY (1ULL << 0)
|
||||
|
||||
/*
|
||||
* Internal in-memory flag that a subvolume has been marked for deletion but
|
||||
* still visible as a directory
|
||||
*/
|
||||
#define BTRFS_ROOT_SUBVOL_DEAD (1ULL << 48)
|
||||
|
||||
struct btrfs_root_item {
|
||||
struct btrfs_inode_item inode;
|
||||
__le64 generation;
|
||||
__le64 root_dirid;
|
||||
__le64 bytenr;
|
||||
__le64 byte_limit;
|
||||
__le64 bytes_used;
|
||||
__le64 last_snapshot;
|
||||
__le64 flags;
|
||||
__le32 refs;
|
||||
struct btrfs_disk_key drop_progress;
|
||||
__u8 drop_level;
|
||||
__u8 level;
|
||||
|
||||
/*
|
||||
* The following fields appear after subvol_uuids+subvol_times
|
||||
* were introduced.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This generation number is used to test if the new fields are valid
|
||||
* and up to date while reading the root item. Every time the root item
|
||||
* is written out, the "generation" field is copied into this field. If
|
||||
* anyone ever mounted the fs with an older kernel, we will have
|
||||
* mismatching generation values here and thus must invalidate the
|
||||
* new fields. See btrfs_update_root and btrfs_find_last_root for
|
||||
* details.
|
||||
* the offset of generation_v2 is also used as the start for the memset
|
||||
* when invalidating the fields.
|
||||
*/
|
||||
__le64 generation_v2;
|
||||
__u8 uuid[BTRFS_UUID_SIZE];
|
||||
__u8 parent_uuid[BTRFS_UUID_SIZE];
|
||||
__u8 received_uuid[BTRFS_UUID_SIZE];
|
||||
__le64 ctransid; /* updated when an inode changes */
|
||||
__le64 otransid; /* trans when created */
|
||||
__le64 stransid; /* trans when sent. non-zero for received subvol */
|
||||
__le64 rtransid; /* trans when received. non-zero for received subvol */
|
||||
struct btrfs_timespec ctime;
|
||||
struct btrfs_timespec otime;
|
||||
struct btrfs_timespec stime;
|
||||
struct btrfs_timespec rtime;
|
||||
__le64 reserved[8]; /* for future */
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
/*
|
||||
* this is used for both forward and backward root refs
|
||||
*/
|
||||
struct btrfs_root_ref {
|
||||
__le64 dirid;
|
||||
__le64 sequence;
|
||||
__le16 name_len;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_disk_balance_args {
|
||||
/*
|
||||
* profiles to operate on, single is denoted by
|
||||
* BTRFS_AVAIL_ALLOC_BIT_SINGLE
|
||||
*/
|
||||
__le64 profiles;
|
||||
|
||||
/*
|
||||
* usage filter
|
||||
* BTRFS_BALANCE_ARGS_USAGE with a single value means '0..N'
|
||||
* BTRFS_BALANCE_ARGS_USAGE_RANGE - range syntax, min..max
|
||||
*/
|
||||
union {
|
||||
__le64 usage;
|
||||
struct {
|
||||
__le32 usage_min;
|
||||
__le32 usage_max;
|
||||
};
|
||||
};
|
||||
|
||||
/* devid filter */
|
||||
__le64 devid;
|
||||
|
||||
/* devid subset filter [pstart..pend) */
|
||||
__le64 pstart;
|
||||
__le64 pend;
|
||||
|
||||
/* btrfs virtual address space subset filter [vstart..vend) */
|
||||
__le64 vstart;
|
||||
__le64 vend;
|
||||
|
||||
/*
|
||||
* profile to convert to, single is denoted by
|
||||
* BTRFS_AVAIL_ALLOC_BIT_SINGLE
|
||||
*/
|
||||
__le64 target;
|
||||
|
||||
/* BTRFS_BALANCE_ARGS_* */
|
||||
__le64 flags;
|
||||
|
||||
/*
|
||||
* BTRFS_BALANCE_ARGS_LIMIT with value 'limit'
|
||||
* BTRFS_BALANCE_ARGS_LIMIT_RANGE - the extend version can use minimum
|
||||
* and maximum
|
||||
*/
|
||||
union {
|
||||
__le64 limit;
|
||||
struct {
|
||||
__le32 limit_min;
|
||||
__le32 limit_max;
|
||||
};
|
||||
};
|
||||
|
||||
/*
|
||||
* Process chunks that cross stripes_min..stripes_max devices,
|
||||
* BTRFS_BALANCE_ARGS_STRIPES_RANGE
|
||||
*/
|
||||
__le32 stripes_min;
|
||||
__le32 stripes_max;
|
||||
|
||||
__le64 unused[6];
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
/*
|
||||
* store balance parameters to disk so that balance can be properly
|
||||
* resumed after crash or unmount
|
||||
*/
|
||||
struct btrfs_balance_item {
|
||||
/* BTRFS_BALANCE_* */
|
||||
__le64 flags;
|
||||
|
||||
struct btrfs_disk_balance_args data;
|
||||
struct btrfs_disk_balance_args meta;
|
||||
struct btrfs_disk_balance_args sys;
|
||||
|
||||
__le64 unused[4];
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
#define BTRFS_FILE_EXTENT_INLINE 0
|
||||
#define BTRFS_FILE_EXTENT_REG 1
|
||||
#define BTRFS_FILE_EXTENT_PREALLOC 2
|
||||
|
||||
struct btrfs_file_extent_item {
|
||||
/*
|
||||
* transaction id that created this extent
|
||||
*/
|
||||
__le64 generation;
|
||||
/*
|
||||
* max number of bytes to hold this extent in ram
|
||||
* when we split a compressed extent we can't know how big
|
||||
* each of the resulting pieces will be. So, this is
|
||||
* an upper limit on the size of the extent in ram instead of
|
||||
* an exact limit.
|
||||
*/
|
||||
__le64 ram_bytes;
|
||||
|
||||
/*
|
||||
* 32 bits for the various ways we might encode the data,
|
||||
* including compression and encryption. If any of these
|
||||
* are set to something a given disk format doesn't understand
|
||||
* it is treated like an incompat flag for reading and writing,
|
||||
* but not for stat.
|
||||
*/
|
||||
__u8 compression;
|
||||
__u8 encryption;
|
||||
__le16 other_encoding; /* spare for later use */
|
||||
|
||||
/* are we __inline__ data or a real extent? */
|
||||
__u8 type;
|
||||
|
||||
/*
|
||||
* disk space consumed by the extent, checksum blocks are included
|
||||
* in these numbers
|
||||
*
|
||||
* At this offset in the structure, the __inline__ extent data start.
|
||||
*/
|
||||
__le64 disk_bytenr;
|
||||
__le64 disk_num_bytes;
|
||||
/*
|
||||
* the logical offset in file blocks (no csums)
|
||||
* this extent record is for. This allows a file extent to point
|
||||
* into the middle of an existing extent on disk, sharing it
|
||||
* between two snapshots (useful if some bytes in the middle of the
|
||||
* extent have changed
|
||||
*/
|
||||
__le64 offset;
|
||||
/*
|
||||
* the logical number of file blocks (no csums included). This
|
||||
* always reflects the size uncompressed and without encoding.
|
||||
*/
|
||||
__le64 num_bytes;
|
||||
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_csum_item {
|
||||
__u8 csum;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_dev_stats_item {
|
||||
/*
|
||||
* grow this item struct at the end for future enhancements and keep
|
||||
* the existing values unchanged
|
||||
*/
|
||||
__le64 values[BTRFS_DEV_STAT_VALUES_MAX];
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
#define BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_ALWAYS 0
|
||||
#define BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_AVOID 1
|
||||
#define BTRFS_DEV_REPLACE_ITEM_STATE_NEVER_STARTED 0
|
||||
#define BTRFS_DEV_REPLACE_ITEM_STATE_STARTED 1
|
||||
#define BTRFS_DEV_REPLACE_ITEM_STATE_SUSPENDED 2
|
||||
#define BTRFS_DEV_REPLACE_ITEM_STATE_FINISHED 3
|
||||
#define BTRFS_DEV_REPLACE_ITEM_STATE_CANCELED 4
|
||||
|
||||
struct btrfs_dev_replace_item {
|
||||
/*
|
||||
* grow this item struct at the end for future enhancements and keep
|
||||
* the existing values unchanged
|
||||
*/
|
||||
__le64 src_devid;
|
||||
__le64 cursor_left;
|
||||
__le64 cursor_right;
|
||||
__le64 cont_reading_from_srcdev_mode;
|
||||
|
||||
__le64 replace_state;
|
||||
__le64 time_started;
|
||||
__le64 time_stopped;
|
||||
__le64 num_write_errors;
|
||||
__le64 num_uncorrectable_read_errors;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
/* different types of block groups (and chunks) */
|
||||
#define BTRFS_BLOCK_GROUP_DATA (1ULL << 0)
|
||||
#define BTRFS_BLOCK_GROUP_SYSTEM (1ULL << 1)
|
||||
#define BTRFS_BLOCK_GROUP_METADATA (1ULL << 2)
|
||||
#define BTRFS_BLOCK_GROUP_RAID0 (1ULL << 3)
|
||||
#define BTRFS_BLOCK_GROUP_RAID1 (1ULL << 4)
|
||||
#define BTRFS_BLOCK_GROUP_DUP (1ULL << 5)
|
||||
#define BTRFS_BLOCK_GROUP_RAID10 (1ULL << 6)
|
||||
#define BTRFS_BLOCK_GROUP_RAID5 (1ULL << 7)
|
||||
#define BTRFS_BLOCK_GROUP_RAID6 (1ULL << 8)
|
||||
#define BTRFS_BLOCK_GROUP_RESERVED (BTRFS_AVAIL_ALLOC_BIT_SINGLE | \
|
||||
BTRFS_SPACE_INFO_GLOBAL_RSV)
|
||||
|
||||
enum btrfs_raid_types {
|
||||
BTRFS_RAID_RAID10,
|
||||
BTRFS_RAID_RAID1,
|
||||
BTRFS_RAID_DUP,
|
||||
BTRFS_RAID_RAID0,
|
||||
BTRFS_RAID_SINGLE,
|
||||
BTRFS_RAID_RAID5,
|
||||
BTRFS_RAID_RAID6,
|
||||
BTRFS_NR_RAID_TYPES
|
||||
};
|
||||
|
||||
#define BTRFS_BLOCK_GROUP_TYPE_MASK (BTRFS_BLOCK_GROUP_DATA | \
|
||||
BTRFS_BLOCK_GROUP_SYSTEM | \
|
||||
BTRFS_BLOCK_GROUP_METADATA)
|
||||
|
||||
#define BTRFS_BLOCK_GROUP_PROFILE_MASK (BTRFS_BLOCK_GROUP_RAID0 | \
|
||||
BTRFS_BLOCK_GROUP_RAID1 | \
|
||||
BTRFS_BLOCK_GROUP_RAID5 | \
|
||||
BTRFS_BLOCK_GROUP_RAID6 | \
|
||||
BTRFS_BLOCK_GROUP_DUP | \
|
||||
BTRFS_BLOCK_GROUP_RAID10)
|
||||
#define BTRFS_BLOCK_GROUP_RAID56_MASK (BTRFS_BLOCK_GROUP_RAID5 | \
|
||||
BTRFS_BLOCK_GROUP_RAID6)
|
||||
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
#define BTRFS_AVAIL_ALLOC_BIT_SINGLE (1ULL << 48)
|
||||
|
||||
/*
|
||||
* A fake block group type that is used to communicate global block reserve
|
||||
* size to userspace via the SPACE_INFO ioctl.
|
||||
*/
|
||||
#define BTRFS_SPACE_INFO_GLOBAL_RSV (1ULL << 49)
|
||||
|
||||
#define BTRFS_EXTENDED_PROFILE_MASK (BTRFS_BLOCK_GROUP_PROFILE_MASK | \
|
||||
BTRFS_AVAIL_ALLOC_BIT_SINGLE)
|
||||
|
||||
static __inline__ __u64 chunk_to_extended(__u64 flags)
|
||||
{
|
||||
if ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0)
|
||||
flags |= BTRFS_AVAIL_ALLOC_BIT_SINGLE;
|
||||
|
||||
return flags;
|
||||
}
|
||||
static __inline__ __u64 extended_to_chunk(__u64 flags)
|
||||
{
|
||||
return flags & ~BTRFS_AVAIL_ALLOC_BIT_SINGLE;
|
||||
}
|
||||
|
||||
struct btrfs_block_group_item {
|
||||
__le64 used;
|
||||
__le64 chunk_objectid;
|
||||
__le64 flags;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_free_space_info {
|
||||
__le32 extent_count;
|
||||
__le32 flags;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
#define BTRFS_FREE_SPACE_USING_BITMAPS (1ULL << 0)
|
||||
|
||||
#define BTRFS_QGROUP_LEVEL_SHIFT 48
|
||||
static __inline__ __u64 btrfs_qgroup_level(__u64 qgroupid)
|
||||
{
|
||||
return qgroupid >> BTRFS_QGROUP_LEVEL_SHIFT;
|
||||
}
|
||||
|
||||
/*
|
||||
* is subvolume quota turned on?
|
||||
*/
|
||||
#define BTRFS_QGROUP_STATUS_FLAG_ON (1ULL << 0)
|
||||
/*
|
||||
* RESCAN is set during the initialization phase
|
||||
*/
|
||||
#define BTRFS_QGROUP_STATUS_FLAG_RESCAN (1ULL << 1)
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
#define BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT (1ULL << 2)
|
||||
|
||||
#define BTRFS_QGROUP_STATUS_VERSION 1
|
||||
|
||||
struct btrfs_qgroup_status_item {
|
||||
__le64 version;
|
||||
/*
|
||||
* the generation is updated during every commit. As older
|
||||
* versions of btrfs are not aware of qgroups, it will be
|
||||
* possible to detect inconsistencies by checking the
|
||||
* generation on mount time
|
||||
*/
|
||||
__le64 generation;
|
||||
|
||||
/* flag definitions see above */
|
||||
__le64 flags;
|
||||
|
||||
/*
|
||||
* only used during scanning to record the progress
|
||||
* of the scan. It contains a logical address
|
||||
*/
|
||||
__le64 rescan;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_qgroup_info_item {
|
||||
__le64 generation;
|
||||
__le64 rfer;
|
||||
__le64 rfer_cmpr;
|
||||
__le64 excl;
|
||||
__le64 excl_cmpr;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct btrfs_qgroup_limit_item {
|
||||
/*
|
||||
* only updated when any of the other values change
|
||||
*/
|
||||
__le64 flags;
|
||||
__le64 max_rfer;
|
||||
__le64 max_excl;
|
||||
__le64 rsv_rfer;
|
||||
__le64 rsv_excl;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
#endif /* _BTRFS_CTREE_H_ */
|
||||
|
|
@ -23,6 +23,8 @@
|
|||
#include <asm/byteorder.h>
|
||||
|
||||
#include "btrfsutil.h"
|
||||
#include "btrfs.h"
|
||||
#include "btrfs_tree.h"
|
||||
|
||||
#define PUBLIC __attribute__((visibility("default")))
|
||||
|
||||
|
|
|
|||
|
|
@ -21,7 +21,6 @@
|
|||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <linux/btrfs.h>
|
||||
|
||||
#include "btrfsutil_internal.h"
|
||||
|
||||
|
|
|
|||
|
|
@ -21,7 +21,6 @@
|
|||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <linux/btrfs.h>
|
||||
|
||||
#include "btrfsutil_internal.h"
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue