/* SPDX-License-Identifier: GPL-2.0 */ #ifndef _BCACHEFS_IOCTL_H #define _BCACHEFS_IOCTL_H #include <linux/uuid.h> #include <asm/ioctl.h> #include "bcachefs_format.h" #include "bkey_types.h" /* * Flags common to multiple ioctls: */ #define BCH_FORCE_IF_DATA_LOST … #define BCH_FORCE_IF_METADATA_LOST … #define BCH_FORCE_IF_DATA_DEGRADED … #define BCH_FORCE_IF_METADATA_DEGRADED … #define BCH_FORCE_IF_LOST … #define BCH_FORCE_IF_DEGRADED … /* * If cleared, ioctl that refer to a device pass it as a pointer to a pathname * (e.g. /dev/sda1); if set, the dev field is the device's index within the * filesystem: */ #define BCH_BY_INDEX … /* * For BCH_IOCTL_READ_SUPER: get superblock of a specific device, not filesystem * wide superblock: */ #define BCH_READ_DEV … /* global control dev: */ /* These are currently broken, and probably unnecessary: */ #if 0 #define BCH_IOCTL_ASSEMBLE … #define BCH_IOCTL_INCREMENTAL … struct bch_ioctl_assemble { __u32 flags; __u32 nr_devs; __u64 pad; __u64 devs[]; }; struct bch_ioctl_incremental { __u32 flags; __u64 pad; __u64 dev; }; #endif /* filesystem ioctls: */ #define BCH_IOCTL_QUERY_UUID … /* These only make sense when we also have incremental assembly */ #if 0 #define BCH_IOCTL_START … #define BCH_IOCTL_STOP … #endif #define BCH_IOCTL_DISK_ADD … #define BCH_IOCTL_DISK_REMOVE … #define BCH_IOCTL_DISK_ONLINE … #define BCH_IOCTL_DISK_OFFLINE … #define BCH_IOCTL_DISK_SET_STATE … #define BCH_IOCTL_DATA … #define BCH_IOCTL_FS_USAGE … #define BCH_IOCTL_DEV_USAGE … #define BCH_IOCTL_READ_SUPER … #define BCH_IOCTL_DISK_GET_IDX … #define BCH_IOCTL_DISK_RESIZE … #define BCH_IOCTL_DISK_RESIZE_JOURNAL … #define BCH_IOCTL_SUBVOLUME_CREATE … #define BCH_IOCTL_SUBVOLUME_DESTROY … #define BCH_IOCTL_DEV_USAGE_V2 … #define BCH_IOCTL_FSCK_OFFLINE … #define BCH_IOCTL_FSCK_ONLINE … #define BCH_IOCTL_QUERY_ACCOUNTING … /* ioctl below act on a particular file, not the filesystem as a whole: */ #define BCHFS_IOC_REINHERIT_ATTRS … /* * BCH_IOCTL_QUERY_UUID: get filesystem UUID * * Returns user visible UUID, not internal UUID (which may not ever be changed); * the filesystem's sysfs directory may be found under /sys/fs/bcachefs with * this UUID. */ struct bch_ioctl_query_uuid { … }; #if 0 struct bch_ioctl_start { __u32 flags; __u32 pad; }; #endif /* * BCH_IOCTL_DISK_ADD: add a new device to an existing filesystem * * The specified device must not be open or in use. On success, the new device * will be an online member of the filesystem just like any other member. * * The device must first be prepared by userspace by formatting with a bcachefs * superblock, which is only used for passing in superblock options/parameters * for that device (in struct bch_member). The new device's superblock should * not claim to be a member of any existing filesystem - UUIDs on it will be * ignored. */ /* * BCH_IOCTL_DISK_REMOVE: permanently remove a member device from a filesystem * * Any data present on @dev will be permanently deleted, and @dev will be * removed from its slot in the filesystem's list of member devices. The device * may be either offline or offline. * * Will fail removing @dev would leave us with insufficient read write devices * or degraded/unavailable data, unless the approprate BCH_FORCE_IF_* flags are * set. */ /* * BCH_IOCTL_DISK_ONLINE: given a disk that is already a member of a filesystem * but is not open (e.g. because we started in degraded mode), bring it online * * all existing data on @dev will be available once the device is online, * exactly as if @dev was present when the filesystem was first mounted */ /* * BCH_IOCTL_DISK_OFFLINE: offline a disk, causing the kernel to close that * block device, without removing it from the filesystem (so it can be brought * back online later) * * Data present on @dev will be unavailable while @dev is offline (unless * replicated), but will still be intact and untouched if @dev is brought back * online * * Will fail (similarly to BCH_IOCTL_DISK_SET_STATE) if offlining @dev would * leave us with insufficient read write devices or degraded/unavailable data, * unless the approprate BCH_FORCE_IF_* flags are set. */ struct bch_ioctl_disk { … }; /* * BCH_IOCTL_DISK_SET_STATE: modify state of a member device of a filesystem * * @new_state - one of the bch_member_state states (rw, ro, failed, * spare) * * Will refuse to change member state if we would then have insufficient devices * to write to, or if it would result in degraded data (when @new_state is * failed or spare) unless the appropriate BCH_FORCE_IF_* flags are set. */ struct bch_ioctl_disk_set_state { … }; #define BCH_DATA_OPS() … enum bch_data_ops { … }; /* * BCH_IOCTL_DATA: operations that walk and manipulate filesystem data (e.g. * scrub, rereplicate, migrate). * * This ioctl kicks off a job in the background, and returns a file descriptor. * Reading from the file descriptor returns a struct bch_ioctl_data_event, * indicating current progress, and closing the file descriptor will stop the * job. The file descriptor is O_CLOEXEC. */ struct bch_ioctl_data { … } __packed __aligned(…); enum bch_data_event { … }; struct bch_ioctl_data_progress { … } __packed __aligned(…); struct bch_ioctl_data_event { … } __packed __aligned(…); struct bch_replicas_usage { … } __packed; static inline unsigned replicas_usage_bytes(struct bch_replicas_usage *u) { … } static inline struct bch_replicas_usage * replicas_usage_next(struct bch_replicas_usage *u) { … } /* Obsolete */ /* * BCH_IOCTL_FS_USAGE: query filesystem disk space usage * * Returns disk space usage broken out by data type, number of replicas, and * by component device * * @replica_entries_bytes - size, in bytes, allocated for replica usage entries * * On success, @replica_entries_bytes will be changed to indicate the number of * bytes actually used. * * Returns -ERANGE if @replica_entries_bytes was too small */ struct bch_ioctl_fs_usage { … }; /* Obsolete */ /* * BCH_IOCTL_DEV_USAGE: query device disk space usage * * Returns disk space usage broken out by data type - both by buckets and * sectors. */ struct bch_ioctl_dev_usage { … }; /* Obsolete */ struct bch_ioctl_dev_usage_v2 { … }; /* * BCH_IOCTL_READ_SUPER: read filesystem superblock * * Equivalent to reading the superblock directly from the block device, except * avoids racing with the kernel writing the superblock or having to figure out * which block device to read * * @sb - buffer to read into * @size - size of userspace allocated buffer * @dev - device to read superblock for, if BCH_READ_DEV flag is * specified * * Returns -ERANGE if buffer provided is too small */ struct bch_ioctl_read_super { … }; /* * BCH_IOCTL_DISK_GET_IDX: give a path to a block device, query filesystem to * determine if disk is a (online) member - if so, returns device's index * * Returns -ENOENT if not found */ struct bch_ioctl_disk_get_idx { … }; /* * BCH_IOCTL_DISK_RESIZE: resize filesystem on a device * * @dev - member to resize * @nbuckets - new number of buckets */ struct bch_ioctl_disk_resize { … }; /* * BCH_IOCTL_DISK_RESIZE_JOURNAL: resize journal on a device * * @dev - member to resize * @nbuckets - new number of buckets */ struct bch_ioctl_disk_resize_journal { … }; struct bch_ioctl_subvolume { … }; #define BCH_SUBVOL_SNAPSHOT_CREATE … #define BCH_SUBVOL_SNAPSHOT_RO … /* * BCH_IOCTL_FSCK_OFFLINE: run fsck from the 'bcachefs fsck' userspace command, * but with the kernel's implementation of fsck: */ struct bch_ioctl_fsck_offline { … }; /* * BCH_IOCTL_FSCK_ONLINE: run fsck from the 'bcachefs fsck' userspace command, * but with the kernel's implementation of fsck: */ struct bch_ioctl_fsck_online { … }; /* * BCH_IOCTL_QUERY_ACCOUNTING: query filesystem disk accounting * * Returns disk space usage broken out by data type, number of replicas, and * by component device * * @replica_entries_bytes - size, in bytes, allocated for replica usage entries * * On success, @replica_entries_bytes will be changed to indicate the number of * bytes actually used. * * Returns -ERANGE if @replica_entries_bytes was too small */ struct bch_ioctl_query_accounting { … }; #endif /* _BCACHEFS_IOCTL_H */
Codebase Browser
linux