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

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