fs/bcachefs/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 #include "bkey_types.h"
   9
  10 /*
  11  * Flags common to multiple ioctls:
  12  */
  13 #define BCH_FORCE_IF_DATA_LOST          (1 << 0)
  14 #define BCH_FORCE_IF_METADATA_LOST      (1 << 1)
  15 #define BCH_FORCE_IF_DATA_DEGRADED      (1 << 2)
  16 #define BCH_FORCE_IF_METADATA_DEGRADED  (1 << 3)
  17
  18 #define BCH_FORCE_IF_LOST                       \
  19         (BCH_FORCE_IF_DATA_LOST|                \
  20          BCH_FORCE_IF_METADATA_LOST)
  21 #define BCH_FORCE_IF_DEGRADED                   \
  22         (BCH_FORCE_IF_DATA_DEGRADED|            \
  23          BCH_FORCE_IF_METADATA_DEGRADED)
  24
  25 /*
  26  * If cleared, ioctl that refer to a device pass it as a pointer to a pathname
  27  * (e.g. /dev/sda1); if set, the dev field is the device's index within the
  28  * filesystem:
  29  */
  30 #define BCH_BY_INDEX                    (1 << 4)
  31
  32 /*
  33  * For BCH_IOCTL_READ_SUPER: get superblock of a specific device, not filesystem
  34  * wide superblock:
  35  */
  36 #define BCH_READ_DEV                    (1 << 5)
  37
  38 /* global control dev: */
  39
  40 /* These are currently broken, and probably unnecessary: */
  41 #if 0
  42 #define BCH_IOCTL_ASSEMBLE      _IOW(0xbc, 1, struct bch_ioctl_assemble)
  43 #define BCH_IOCTL_INCREMENTAL   _IOW(0xbc, 2, struct bch_ioctl_incremental)
  44
  45 struct bch_ioctl_assemble {
  46         __u32                   flags;
  47         __u32                   nr_devs;
  48         __u64                   pad;
  49         __u64                   devs[];
  50 };
  51
  52 struct bch_ioctl_incremental {
  53         __u32                   flags;
  54         __u64                   pad;
  55         __u64                   dev;
  56 };
  57 #endif
  58
  59 /* filesystem ioctls: */
  60
  61 #define BCH_IOCTL_QUERY_UUID    _IOR(0xbc,      1,  struct bch_ioctl_query_uuid)
  62
  63 /* These only make sense when we also have incremental assembly */
  64 #if 0
  65 #define BCH_IOCTL_START         _IOW(0xbc,      2,  struct bch_ioctl_start)
  66 #define BCH_IOCTL_STOP          _IO(0xbc,       3)
  67 #endif
  68
  69 #define BCH_IOCTL_DISK_ADD      _IOW(0xbc,      4,  struct bch_ioctl_disk)
  70 #define BCH_IOCTL_DISK_REMOVE   _IOW(0xbc,      5,  struct bch_ioctl_disk)
  71 #define BCH_IOCTL_DISK_ONLINE   _IOW(0xbc,      6,  struct bch_ioctl_disk)
  72 #define BCH_IOCTL_DISK_OFFLINE  _IOW(0xbc,      7,  struct bch_ioctl_disk)
  73 #define BCH_IOCTL_DISK_SET_STATE _IOW(0xbc,     8,  struct bch_ioctl_disk_set_state)
  74 #define BCH_IOCTL_DATA          _IOW(0xbc,      10, struct bch_ioctl_data)
  75 #define BCH_IOCTL_FS_USAGE      _IOWR(0xbc,     11, struct bch_ioctl_fs_usage)
  76 #define BCH_IOCTL_DEV_USAGE     _IOWR(0xbc,     11, struct bch_ioctl_dev_usage)
  77 #define BCH_IOCTL_READ_SUPER    _IOW(0xbc,      12, struct bch_ioctl_read_super)
  78 #define BCH_IOCTL_DISK_GET_IDX  _IOW(0xbc,      13,  struct bch_ioctl_disk_get_idx)
  79 #define BCH_IOCTL_DISK_RESIZE   _IOW(0xbc,      14,  struct bch_ioctl_disk_resize)
  80 #define BCH_IOCTL_DISK_RESIZE_JOURNAL _IOW(0xbc,15,  struct bch_ioctl_disk_resize_journal)
  81
  82 #define BCH_IOCTL_SUBVOLUME_CREATE _IOW(0xbc,   16,  struct bch_ioctl_subvolume)
  83 #define BCH_IOCTL_SUBVOLUME_DESTROY _IOW(0xbc,  17,  struct bch_ioctl_subvolume)
  84
  85 #define BCH_IOCTL_DEV_USAGE_V2  _IOWR(0xbc,     18, struct bch_ioctl_dev_usage_v2)
  86
  87 #define BCH_IOCTL_FSCK_OFFLINE  _IOW(0xbc,      19,  struct bch_ioctl_fsck_offline)
  88 #define BCH_IOCTL_FSCK_ONLINE   _IOW(0xbc,      20,  struct bch_ioctl_fsck_online)
  89 #define BCH_IOCTL_QUERY_ACCOUNTING _IOW(0xbc,   21,  struct bch_ioctl_query_accounting)
  90
  91 /* ioctl below act on a particular file, not the filesystem as a whole: */
  92
  93 #define BCHFS_IOC_REINHERIT_ATTRS       _IOR(0xbc, 64, const char __user *)
  94
  95 /*
  96  * BCH_IOCTL_QUERY_UUID: get filesystem UUID
  97  *
  98  * Returns user visible UUID, not internal UUID (which may not ever be changed);
  99  * the filesystem's sysfs directory may be found under /sys/fs/bcachefs with
 100  * this UUID.
 101  */
 102 struct bch_ioctl_query_uuid {
 103         __uuid_t                uuid;
 104 };
 105
 106 #if 0
 107 struct bch_ioctl_start {
 108         __u32                   flags;
 109         __u32                   pad;
 110 };
 111 #endif
 112
 113 /*
 114  * BCH_IOCTL_DISK_ADD: add a new device to an existing filesystem
 115  *
 116  * The specified device must not be open or in use. On success, the new device
 117  * will be an online member of the filesystem just like any other member.
 118  *
 119  * The device must first be prepared by userspace by formatting with a bcachefs
 120  * superblock, which is only used for passing in superblock options/parameters
 121  * for that device (in struct bch_member). The new device's superblock should
 122  * not claim to be a member of any existing filesystem - UUIDs on it will be
 123  * ignored.
 124  */
 125
 126 /*
 127  * BCH_IOCTL_DISK_REMOVE: permanently remove a member device from a filesystem
 128  *
 129  * Any data present on @dev will be permanently deleted, and @dev will be
 130  * removed from its slot in the filesystem's list of member devices. The device
 131  * may be either offline or offline.
 132  *
 133  * Will fail removing @dev would leave us with insufficient read write devices
 134  * or degraded/unavailable data, unless the approprate BCH_FORCE_IF_* flags are
 135  * set.
 136  */
 137
 138 /*
 139  * BCH_IOCTL_DISK_ONLINE: given a disk that is already a member of a filesystem
 140  * but is not open (e.g. because we started in degraded mode), bring it online
 141  *
 142  * all existing data on @dev will be available once the device is online,
 143  * exactly as if @dev was present when the filesystem was first mounted
 144  */
 145
 146 /*
 147  * BCH_IOCTL_DISK_OFFLINE: offline a disk, causing the kernel to close that
 148  * block device, without removing it from the filesystem (so it can be brought
 149  * back online later)
 150  *
 151  * Data present on @dev will be unavailable while @dev is offline (unless
 152  * replicated), but will still be intact and untouched if @dev is brought back
 153  * online
 154  *
 155  * Will fail (similarly to BCH_IOCTL_DISK_SET_STATE) if offlining @dev would
 156  * leave us with insufficient read write devices or degraded/unavailable data,
 157  * unless the approprate BCH_FORCE_IF_* flags are set.
 158  */
 159
 160 struct bch_ioctl_disk {
 161         __u32                   flags;
 162         __u32                   pad;
 163         __u64                   dev;
 164 };
 165
 166 /*
 167  * BCH_IOCTL_DISK_SET_STATE: modify state of a member device of a filesystem
 168  *
 169  * @new_state           - one of the bch_member_state states (rw, ro, failed,
 170  *                        spare)
 171  *
 172  * Will refuse to change member state if we would then have insufficient devices
 173  * to write to, or if it would result in degraded data (when @new_state is
 174  * failed or spare) unless the appropriate BCH_FORCE_IF_* flags are set.
 175  */
 176 struct bch_ioctl_disk_set_state {
 177         __u32                   flags;
 178         __u8                    new_state;
 179         __u8                    pad[3];
 180         __u64                   dev;
 181 };
 182
 183 #define BCH_DATA_OPS()                  \
 184         x(scrub,                0)      \
 185         x(rereplicate,          1)      \
 186         x(migrate,              2)      \
 187         x(rewrite_old_nodes,    3)      \
 188         x(drop_extra_replicas,  4)
 189
 190 enum bch_data_ops {
 191 #define x(t, n) BCH_DATA_OP_##t = n,
 192         BCH_DATA_OPS()
 193 #undef x
 194         BCH_DATA_OP_NR
 195 };
 196
 197 /*
 198  * BCH_IOCTL_DATA: operations that walk and manipulate filesystem data (e.g.
 199  * scrub, rereplicate, migrate).
 200  *
 201  * This ioctl kicks off a job in the background, and returns a file descriptor.
 202  * Reading from the file descriptor returns a struct bch_ioctl_data_event,
 203  * indicating current progress, and closing the file descriptor will stop the
 204  * job. The file descriptor is O_CLOEXEC.
 205  */
 206 struct bch_ioctl_data {
 207         __u16                   op;
 208         __u8                    start_btree;
 209         __u8                    end_btree;
 210         __u32                   flags;
 211
 212         struct bpos             start_pos;
 213         struct bpos             end_pos;
 214
 215         union {
 216         struct {
 217                 __u32           dev;
 218                 __u32           pad;
 219         }                       migrate;
 220         struct {
 221                 __u64           pad[8];
 222         };
 223         };
 224 } __packed __aligned(8);
 225
 226 enum bch_data_event {
 227         BCH_DATA_EVENT_PROGRESS = 0,
 228         /* XXX: add an event for reporting errors */
 229         BCH_DATA_EVENT_NR       = 1,
 230 };
 231
 232 struct bch_ioctl_data_progress {
 233         __u8                    data_type;
 234         __u8                    btree_id;
 235         __u8                    pad[2];
 236         struct bpos             pos;
 237
 238         __u64                   sectors_done;
 239         __u64                   sectors_total;
 240 } __packed __aligned(8);
 241
 242 struct bch_ioctl_data_event {
 243         __u8                    type;
 244         __u8                    pad[7];
 245         union {
 246         struct bch_ioctl_data_progress p;
 247         __u64                   pad2[15];
 248         };
 249 } __packed __aligned(8);
 250
 251 struct bch_replicas_usage {
 252         __u64                   sectors;
 253         struct bch_replicas_entry_v1 r;
 254 } __packed;
 255
 256 static inline unsigned replicas_usage_bytes(struct bch_replicas_usage *u)
 257 {
 258         return offsetof(struct bch_replicas_usage, r) + replicas_entry_bytes(&u->r);
 259 }
 260
 261 static inline struct bch_replicas_usage *
 262 replicas_usage_next(struct bch_replicas_usage *u)
 263 {
 264         return (void *) u + replicas_usage_bytes(u);
 265 }
 266
 267 /* Obsolete */
 268 /*
 269  * BCH_IOCTL_FS_USAGE: query filesystem disk space usage
 270  *
 271  * Returns disk space usage broken out by data type, number of replicas, and
 272  * by component device
 273  *
 274  * @replica_entries_bytes - size, in bytes, allocated for replica usage entries
 275  *
 276  * On success, @replica_entries_bytes will be changed to indicate the number of
 277  * bytes actually used.
 278  *
 279  * Returns -ERANGE if @replica_entries_bytes was too small
 280  */
 281 struct bch_ioctl_fs_usage {
 282         __u64                   capacity;
 283         __u64                   used;
 284         __u64                   online_reserved;
 285         __u64                   persistent_reserved[BCH_REPLICAS_MAX];
 286
 287         __u32                   replica_entries_bytes;
 288         __u32                   pad;
 289
 290         struct bch_replicas_usage replicas[];
 291 };
 292
 293 /* Obsolete */
 294 /*
 295  * BCH_IOCTL_DEV_USAGE: query device disk space usage
 296  *
 297  * Returns disk space usage broken out by data type - both by buckets and
 298  * sectors.
 299  */
 300 struct bch_ioctl_dev_usage {
 301         __u64                   dev;
 302         __u32                   flags;
 303         __u8                    state;
 304         __u8                    pad[7];
 305
 306         __u32                   bucket_size;
 307         __u64                   nr_buckets;
 308
 309         __u64                   buckets_ec;
 310
 311         struct bch_ioctl_dev_usage_type {
 312                 __u64           buckets;
 313                 __u64           sectors;
 314                 __u64           fragmented;
 315         }                       d[10];
 316 };
 317
 318 /* Obsolete */
 319 struct bch_ioctl_dev_usage_v2 {
 320         __u64                   dev;
 321         __u32                   flags;
 322         __u8                    state;
 323         __u8                    nr_data_types;
 324         __u8                    pad[6];
 325
 326         __u32                   bucket_size;
 327         __u64                   nr_buckets;
 328
 329         struct bch_ioctl_dev_usage_type d[];
 330 };
 331
 332 /*
 333  * BCH_IOCTL_READ_SUPER: read filesystem superblock
 334  *
 335  * Equivalent to reading the superblock directly from the block device, except
 336  * avoids racing with the kernel writing the superblock or having to figure out
 337  * which block device to read
 338  *
 339  * @sb          - buffer to read into
 340  * @size        - size of userspace allocated buffer
 341  * @dev         - device to read superblock for, if BCH_READ_DEV flag is
 342  *                specified
 343  *
 344  * Returns -ERANGE if buffer provided is too small
 345  */
 346 struct bch_ioctl_read_super {
 347         __u32                   flags;
 348         __u32                   pad;
 349         __u64                   dev;
 350         __u64                   size;
 351         __u64                   sb;
 352 };
 353
 354 /*
 355  * BCH_IOCTL_DISK_GET_IDX: give a path to a block device, query filesystem to
 356  * determine if disk is a (online) member - if so, returns device's index
 357  *
 358  * Returns -ENOENT if not found
 359  */
 360 struct bch_ioctl_disk_get_idx {
 361         __u64                   dev;
 362 };
 363
 364 /*
 365  * BCH_IOCTL_DISK_RESIZE: resize filesystem on a device
 366  *
 367  * @dev         - member to resize
 368  * @nbuckets    - new number of buckets
 369  */
 370 struct bch_ioctl_disk_resize {
 371         __u32                   flags;
 372         __u32                   pad;
 373         __u64                   dev;
 374         __u64                   nbuckets;
 375 };
 376
 377 /*
 378  * BCH_IOCTL_DISK_RESIZE_JOURNAL: resize journal on a device
 379  *
 380  * @dev         - member to resize
 381  * @nbuckets    - new number of buckets
 382  */
 383 struct bch_ioctl_disk_resize_journal {
 384         __u32                   flags;
 385         __u32                   pad;
 386         __u64                   dev;
 387         __u64                   nbuckets;
 388 };
 389
 390 struct bch_ioctl_subvolume {
 391         __u32                   flags;
 392         __u32                   dirfd;
 393         __u16                   mode;
 394         __u16                   pad[3];
 395         __u64                   dst_ptr;
 396         __u64                   src_ptr;
 397 };
 398
 399 #define BCH_SUBVOL_SNAPSHOT_CREATE      (1U << 0)
 400 #define BCH_SUBVOL_SNAPSHOT_RO          (1U << 1)
 401
 402 /*
 403  * BCH_IOCTL_FSCK_OFFLINE: run fsck from the 'bcachefs fsck' userspace command,
 404  * but with the kernel's implementation of fsck:
 405  */
 406 struct bch_ioctl_fsck_offline {
 407         __u64                   flags;
 408         __u64                   opts;           /* string */
 409         __u64                   nr_devs;
 410         __u64                   devs[] __counted_by(nr_devs);
 411 };
 412
 413 /*
 414  * BCH_IOCTL_FSCK_ONLINE: run fsck from the 'bcachefs fsck' userspace command,
 415  * but with the kernel's implementation of fsck:
 416  */
 417 struct bch_ioctl_fsck_online {
 418         __u64                   flags;
 419         __u64                   opts;           /* string */
 420 };
 421
 422 /*
 423  * BCH_IOCTL_QUERY_ACCOUNTING: query filesystem disk accounting
 424  *
 425  * Returns disk space usage broken out by data type, number of replicas, and
 426  * by component device
 427  *
 428  * @replica_entries_bytes - size, in bytes, allocated for replica usage entries
 429  *
 430  * On success, @replica_entries_bytes will be changed to indicate the number of
 431  * bytes actually used.
 432  *
 433  * Returns -ERANGE if @replica_entries_bytes was too small
 434  */
 435 struct bch_ioctl_query_accounting {
 436         __u64                   capacity;
 437         __u64                   used;
 438         __u64                   online_reserved;
 439
 440         __u32                   accounting_u64s; /* input parameter */
 441         __u32                   accounting_types_mask; /* input parameter */
 442
 443         struct bkey_i_accounting accounting[];
 444 };
 445
 446 #endif /* _BCACHEFS_IOCTL_H */