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