git.sesse.net Git - bcachefs-tools-debian/blob - libbcachefs/bcachefs_ioctl.h

   1 #ifndef _BCACHEFS_IOCTL_H
   2 #define _BCACHEFS_IOCTL_H
   3
   4 #include <linux/uuid.h>
   5 #include <asm/ioctl.h>
   6 #include "bcachefs_format.h"
   7
   8 /*
   9  * Flags common to multiple ioctls:
  10  */
  11 #define BCH_FORCE_IF_DATA_LOST          (1 << 0)
  12 #define BCH_FORCE_IF_METADATA_LOST      (1 << 1)
  13 #define BCH_FORCE_IF_DATA_DEGRADED      (1 << 2)
  14 #define BCH_FORCE_IF_METADATA_DEGRADED  (1 << 3)
  15
  16 #define BCH_FORCE_IF_DEGRADED                   \
  17         (BCH_FORCE_IF_DATA_DEGRADED|            \
  18          BCH_FORCE_IF_METADATA_DEGRADED)
  19
  20 /*
  21  * If cleared, ioctl that refer to a device pass it as a pointer to a pathname
  22  * (e.g. /dev/sda1); if set, the dev field is the device's index within the
  23  * filesystem:
  24  */
  25 #define BCH_BY_INDEX                    (1 << 4)
  26
  27 /*
  28  * For BCH_IOCTL_READ_SUPER: get superblock of a specific device, not filesystem
  29  * wide superblock:
  30  */
  31 #define BCH_READ_DEV                    (1 << 5)
  32
  33 /* global control dev: */
  34
  35 /* These are currently broken, and probably unnecessary: */
  36 #if 0
  37 #define BCH_IOCTL_ASSEMBLE      _IOW(0xbc, 1, struct bch_ioctl_assemble)
  38 #define BCH_IOCTL_INCREMENTAL   _IOW(0xbc, 2, struct bch_ioctl_incremental)
  39
  40 struct bch_ioctl_assemble {
  41         __u32                   flags;
  42         __u32                   nr_devs;
  43         __u64                   pad;
  44         __u64                   devs[];
  45 };
  46
  47 struct bch_ioctl_incremental {
  48         __u32                   flags;
  49         __u64                   pad;
  50         __u64                   dev;
  51 };
  52 #endif
  53
  54 /* filesystem ioctls: */
  55
  56 #define BCH_IOCTL_QUERY_UUID    _IOR(0xbc,      1,  struct bch_ioctl_query_uuid)
  57
  58 /* These only make sense when we also have incremental assembly */
  59 #if 0
  60 #define BCH_IOCTL_START         _IOW(0xbc,      2,  struct bch_ioctl_start)
  61 #define BCH_IOCTL_STOP          _IO(0xbc,       3)
  62 #endif
  63
  64 #define BCH_IOCTL_DISK_ADD      _IOW(0xbc,      4,  struct bch_ioctl_disk)
  65 #define BCH_IOCTL_DISK_REMOVE   _IOW(0xbc,      5,  struct bch_ioctl_disk)
  66 #define BCH_IOCTL_DISK_ONLINE   _IOW(0xbc,      6,  struct bch_ioctl_disk)
  67 #define BCH_IOCTL_DISK_OFFLINE  _IOW(0xbc,      7,  struct bch_ioctl_disk)
  68 #define BCH_IOCTL_DISK_SET_STATE _IOW(0xbc,     8,  struct bch_ioctl_disk_set_state)
  69 #define BCH_IOCTL_DATA          _IOW(0xbc,      10, struct bch_ioctl_data)
  70 #define BCH_IOCTL_USAGE         _IOWR(0xbc,     11, struct bch_ioctl_usage)
  71 #define BCH_IOCTL_READ_SUPER    _IOW(0xbc,      12, struct bch_ioctl_read_super)
  72 #define BCH_IOCTL_DISK_GET_IDX  _IOW(0xbc,      13,  struct bch_ioctl_disk_get_idx)
  73 #define BCH_IOCTL_DISK_RESIZE   _IOW(0xbc,      13,  struct bch_ioctl_disk_resize)
  74
  75 /*
  76  * BCH_IOCTL_QUERY_UUID: get filesystem UUID
  77  *
  78  * Returns user visible UUID, not internal UUID (which may not ever be changed);
  79  * the filesystem's sysfs directory may be found under /sys/fs/bcachefs with
  80  * this UUID.
  81  */
  82 struct bch_ioctl_query_uuid {
  83         uuid_le                 uuid;
  84 };
  85
  86 #if 0
  87 struct bch_ioctl_start {
  88         __u32                   flags;
  89         __u32                   pad;
  90 };
  91 #endif
  92
  93 /*
  94  * BCH_IOCTL_DISK_ADD: add a new device to an existing filesystem
  95  *
  96  * The specified device must not be open or in use. On success, the new device
  97  * will be an online member of the filesystem just like any other member.
  98  *
  99  * The device must first be prepared by userspace by formatting with a bcachefs
 100  * superblock, which is only used for passing in superblock options/parameters
 101  * for that device (in struct bch_member). The new device's superblock should
 102  * not claim to be a member of any existing filesystem - UUIDs on it will be
 103  * ignored.
 104  */
 105
 106 /*
 107  * BCH_IOCTL_DISK_REMOVE: permanently remove a member device from a filesystem
 108  *
 109  * Any data present on @dev will be permanently deleted, and @dev will be
 110  * removed from its slot in the filesystem's list of member devices. The device
 111  * may be either offline or offline.
 112  *
 113  * Will fail removing @dev would leave us with insufficient read write devices
 114  * or degraded/unavailable data, unless the approprate BCH_FORCE_IF_* flags are
 115  * set.
 116  */
 117
 118 /*
 119  * BCH_IOCTL_DISK_ONLINE: given a disk that is already a member of a filesystem
 120  * but is not open (e.g. because we started in degraded mode), bring it online
 121  *
 122  * all existing data on @dev will be available once the device is online,
 123  * exactly as if @dev was present when the filesystem was first mounted
 124  */
 125
 126 /*
 127  * BCH_IOCTL_DISK_OFFLINE: offline a disk, causing the kernel to close that
 128  * block device, without removing it from the filesystem (so it can be brought
 129  * back online later)
 130  *
 131  * Data present on @dev will be unavailable while @dev is offline (unless
 132  * replicated), but will still be intact and untouched if @dev is brought back
 133  * online
 134  *
 135  * Will fail (similarly to BCH_IOCTL_DISK_SET_STATE) if offlining @dev would
 136  * leave us with insufficient read write devices or degraded/unavailable data,
 137  * unless the approprate BCH_FORCE_IF_* flags are set.
 138  */
 139
 140 struct bch_ioctl_disk {
 141         __u32                   flags;
 142         __u32                   pad;
 143         __u64                   dev;
 144 };
 145
 146 /*
 147  * BCH_IOCTL_DISK_SET_STATE: modify state of a member device of a filesystem
 148  *
 149  * @new_state           - one of the bch_member_state states (rw, ro, failed,
 150  *                        spare)
 151  *
 152  * Will refuse to change member state if we would then have insufficient devices
 153  * to write to, or if it would result in degraded data (when @new_state is
 154  * failed or spare) unless the appropriate BCH_FORCE_IF_* flags are set.
 155  */
 156 struct bch_ioctl_disk_set_state {
 157         __u32                   flags;
 158         __u8                    new_state;
 159         __u8                    pad[3];
 160         __u64                   dev;
 161 };
 162
 163 enum bch_data_ops {
 164         BCH_DATA_OP_SCRUB       = 0,
 165         BCH_DATA_OP_REREPLICATE = 1,
 166         BCH_DATA_OP_MIGRATE     = 2,
 167         BCH_DATA_OP_NR          = 3,
 168 };
 169
 170 /*
 171  * BCH_IOCTL_DATA: operations that walk and manipulate filesystem data (e.g.
 172  * scrub, rereplicate, migrate).
 173  *
 174  * This ioctl kicks off a job in the background, and returns a file descriptor.
 175  * Reading from the file descriptor returns a struct bch_ioctl_data_event,
 176  * indicating current progress, and closing the file descriptor will stop the
 177  * job. The file descriptor is O_CLOEXEC.
 178  */
 179 struct bch_ioctl_data {
 180         __u32                   op;
 181         __u32                   flags;
 182
 183         struct bpos             start;
 184         struct bpos             end;
 185
 186         union {
 187         struct {
 188                 __u32           dev;
 189                 __u32           pad;
 190         }                       migrate;
 191         struct {
 192                 __u64           pad[8];
 193         };
 194         };
 195 } __attribute__((packed, aligned(8)));
 196
 197 enum bch_data_event {
 198         BCH_DATA_EVENT_PROGRESS = 0,
 199         /* XXX: add an event for reporting errors */
 200         BCH_DATA_EVENT_NR       = 1,
 201 };
 202
 203 struct bch_ioctl_data_progress {
 204         __u8                    data_type;
 205         __u8                    btree_id;
 206         __u8                    pad[2];
 207         struct bpos             pos;
 208
 209         __u64                   sectors_done;
 210         __u64                   sectors_total;
 211 } __attribute__((packed, aligned(8)));
 212
 213 struct bch_ioctl_data_event {
 214         __u8                    type;
 215         __u8                    pad[7];
 216         union {
 217         struct bch_ioctl_data_progress p;
 218         __u64                   pad2[15];
 219         };
 220 } __attribute__((packed, aligned(8)));
 221
 222 struct bch_ioctl_dev_usage {
 223         __u8                    state;
 224         __u8                    alive;
 225         __u8                    pad[6];
 226         __u32                   dev;
 227
 228         __u32                   bucket_size;
 229         __u64                   nr_buckets;
 230
 231         __u64                   buckets[BCH_DATA_NR];
 232         __u64                   sectors[BCH_DATA_NR];
 233 };
 234
 235 struct bch_ioctl_fs_usage {
 236         __u64                   capacity;
 237         __u64                   used;
 238         __u64                   online_reserved;
 239         __u64                   persistent_reserved[BCH_REPLICAS_MAX];
 240         __u64                   sectors[BCH_DATA_NR][BCH_REPLICAS_MAX];
 241 };
 242
 243 /*
 244  * BCH_IOCTL_USAGE: query filesystem disk space usage
 245  *
 246  * Returns disk space usage broken out by data type, number of replicas, and
 247  * by component device
 248  *
 249  * @nr_devices  - number of devices userspace allocated space for in @devs
 250  *
 251  * On success, @fs and @devs will be filled out appropriately and devs[i].alive
 252  * will indicate if a device was present in that slot
 253  *
 254  * Returns -ERANGE if @nr_devices was too small
 255  */
 256 struct bch_ioctl_usage {
 257         __u16                   nr_devices;
 258         __u16                   pad[3];
 259
 260         struct bch_ioctl_fs_usage fs;
 261         struct bch_ioctl_dev_usage devs[0];
 262 };
 263
 264 /*
 265  * BCH_IOCTL_READ_SUPER: read filesystem superblock
 266  *
 267  * Equivalent to reading the superblock directly from the block device, except
 268  * avoids racing with the kernel writing the superblock or having to figure out
 269  * which block device to read
 270  *
 271  * @sb          - buffer to read into
 272  * @size        - size of userspace allocated buffer
 273  * @dev         - device to read superblock for, if BCH_READ_DEV flag is
 274  *                specified
 275  *
 276  * Returns -ERANGE if buffer provided is too small
 277  */
 278 struct bch_ioctl_read_super {
 279         __u32                   flags;
 280         __u32                   pad;
 281         __u64                   dev;
 282         __u64                   size;
 283         __u64                   sb;
 284 };
 285
 286 /*
 287  * BCH_IOCTL_DISK_GET_IDX: give a path to a block device, query filesystem to
 288  * determine if disk is a (online) member - if so, returns device's index
 289  *
 290  * Returns -ENOENT if not found
 291  */
 292 struct bch_ioctl_disk_get_idx {
 293         __u64                   dev;
 294 };
 295
 296 /*
 297  * BCH_IOCTL_DISK_RESIZE: resize filesystem on a device
 298  *
 299  * @dev         - member to resize
 300  * @nbuckets    - new number of buckets
 301  */
 302 struct bch_ioctl_disk_resize {
 303         __u32                   flags;
 304         __u32                   pad;
 305         __u64                   dev;
 306         __u64                   nbuckets;
 307 };
 308
 309 #endif /* _BCACHEFS_IOCTL_H */