1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2007 Oracle. All rights reserved. 4 */ 5 6 #include <linux/sched.h> 7 #include <linux/sched/mm.h> 8 #include <linux/slab.h> 9 #include <linux/spinlock.h> 10 #include <linux/completion.h> 11 #include <linux/bug.h> 12 #include <crypto/hash.h> 13 14 #include "ctree.h" 15 #include "discard.h" 16 #include "disk-io.h" 17 #include "send.h" 18 #include "transaction.h" 19 #include "sysfs.h" 20 #include "volumes.h" 21 #include "space-info.h" 22 #include "block-group.h" 23 #include "qgroup.h" 24 25 /* 26 * Structure name Path 27 * -------------------------------------------------------------------------- 28 * btrfs_supported_static_feature_attrs /sys/fs/btrfs/features 29 * btrfs_supported_feature_attrs /sys/fs/btrfs/features and 30 * /sys/fs/btrfs/<uuid>/features 31 * btrfs_attrs /sys/fs/btrfs/<uuid> 32 * devid_attrs /sys/fs/btrfs/<uuid>/devinfo/<devid> 33 * allocation_attrs /sys/fs/btrfs/<uuid>/allocation 34 * qgroup_attrs /sys/fs/btrfs/<uuid>/qgroups/<level>_<qgroupid> 35 * space_info_attrs /sys/fs/btrfs/<uuid>/allocation/<bg-type> 36 * raid_attrs /sys/fs/btrfs/<uuid>/allocation/<bg-type>/<bg-profile> 37 * 38 * When built with BTRFS_CONFIG_DEBUG: 39 * 40 * btrfs_debug_feature_attrs /sys/fs/btrfs/debug 41 * btrfs_debug_mount_attrs /sys/fs/btrfs/<uuid>/debug 42 * discard_debug_attrs /sys/fs/btrfs/<uuid>/debug/discard 43 */ 44 45 struct btrfs_feature_attr { 46 struct kobj_attribute kobj_attr; 47 enum btrfs_feature_set feature_set; 48 u64 feature_bit; 49 }; 50 51 /* For raid type sysfs entries */ 52 struct raid_kobject { 53 u64 flags; 54 struct kobject kobj; 55 }; 56 57 #define __INIT_KOBJ_ATTR(_name, _mode, _show, _store) \ 58 { \ 59 .attr = { .name = __stringify(_name), .mode = _mode }, \ 60 .show = _show, \ 61 .store = _store, \ 62 } 63 64 #define BTRFS_ATTR_RW(_prefix, _name, _show, _store) \ 65 static struct kobj_attribute btrfs_attr_##_prefix##_##_name = \ 66 __INIT_KOBJ_ATTR(_name, 0644, _show, _store) 67 68 #define BTRFS_ATTR(_prefix, _name, _show) \ 69 static struct kobj_attribute btrfs_attr_##_prefix##_##_name = \ 70 __INIT_KOBJ_ATTR(_name, 0444, _show, NULL) 71 72 #define BTRFS_ATTR_PTR(_prefix, _name) \ 73 (&btrfs_attr_##_prefix##_##_name.attr) 74 75 #define BTRFS_FEAT_ATTR(_name, _feature_set, _feature_prefix, _feature_bit) \ 76 static struct btrfs_feature_attr btrfs_attr_features_##_name = { \ 77 .kobj_attr = __INIT_KOBJ_ATTR(_name, S_IRUGO, \ 78 btrfs_feature_attr_show, \ 79 btrfs_feature_attr_store), \ 80 .feature_set = _feature_set, \ 81 .feature_bit = _feature_prefix ##_## _feature_bit, \ 82 } 83 #define BTRFS_FEAT_ATTR_PTR(_name) \ 84 (&btrfs_attr_features_##_name.kobj_attr.attr) 85 86 #define BTRFS_FEAT_ATTR_COMPAT(name, feature) \ 87 BTRFS_FEAT_ATTR(name, FEAT_COMPAT, BTRFS_FEATURE_COMPAT, feature) 88 #define BTRFS_FEAT_ATTR_COMPAT_RO(name, feature) \ 89 BTRFS_FEAT_ATTR(name, FEAT_COMPAT_RO, BTRFS_FEATURE_COMPAT_RO, feature) 90 #define BTRFS_FEAT_ATTR_INCOMPAT(name, feature) \ 91 BTRFS_FEAT_ATTR(name, FEAT_INCOMPAT, BTRFS_FEATURE_INCOMPAT, feature) 92 93 static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj); 94 static inline struct btrfs_fs_devices *to_fs_devs(struct kobject *kobj); 95 96 static struct btrfs_feature_attr *to_btrfs_feature_attr(struct kobj_attribute *a) 97 { 98 return container_of(a, struct btrfs_feature_attr, kobj_attr); 99 } 100 101 static struct kobj_attribute *attr_to_btrfs_attr(struct attribute *attr) 102 { 103 return container_of(attr, struct kobj_attribute, attr); 104 } 105 106 static struct btrfs_feature_attr *attr_to_btrfs_feature_attr( 107 struct attribute *attr) 108 { 109 return to_btrfs_feature_attr(attr_to_btrfs_attr(attr)); 110 } 111 112 static u64 get_features(struct btrfs_fs_info *fs_info, 113 enum btrfs_feature_set set) 114 { 115 struct btrfs_super_block *disk_super = fs_info->super_copy; 116 if (set == FEAT_COMPAT) 117 return btrfs_super_compat_flags(disk_super); 118 else if (set == FEAT_COMPAT_RO) 119 return btrfs_super_compat_ro_flags(disk_super); 120 else 121 return btrfs_super_incompat_flags(disk_super); 122 } 123 124 static void set_features(struct btrfs_fs_info *fs_info, 125 enum btrfs_feature_set set, u64 features) 126 { 127 struct btrfs_super_block *disk_super = fs_info->super_copy; 128 if (set == FEAT_COMPAT) 129 btrfs_set_super_compat_flags(disk_super, features); 130 else if (set == FEAT_COMPAT_RO) 131 btrfs_set_super_compat_ro_flags(disk_super, features); 132 else 133 btrfs_set_super_incompat_flags(disk_super, features); 134 } 135 136 static int can_modify_feature(struct btrfs_feature_attr *fa) 137 { 138 int val = 0; 139 u64 set, clear; 140 switch (fa->feature_set) { 141 case FEAT_COMPAT: 142 set = BTRFS_FEATURE_COMPAT_SAFE_SET; 143 clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR; 144 break; 145 case FEAT_COMPAT_RO: 146 set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET; 147 clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR; 148 break; 149 case FEAT_INCOMPAT: 150 set = BTRFS_FEATURE_INCOMPAT_SAFE_SET; 151 clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR; 152 break; 153 default: 154 pr_warn("btrfs: sysfs: unknown feature set %d\n", 155 fa->feature_set); 156 return 0; 157 } 158 159 if (set & fa->feature_bit) 160 val |= 1; 161 if (clear & fa->feature_bit) 162 val |= 2; 163 164 return val; 165 } 166 167 static ssize_t btrfs_feature_attr_show(struct kobject *kobj, 168 struct kobj_attribute *a, char *buf) 169 { 170 int val = 0; 171 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 172 struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a); 173 if (fs_info) { 174 u64 features = get_features(fs_info, fa->feature_set); 175 if (features & fa->feature_bit) 176 val = 1; 177 } else 178 val = can_modify_feature(fa); 179 180 return scnprintf(buf, PAGE_SIZE, "%d\n", val); 181 } 182 183 static ssize_t btrfs_feature_attr_store(struct kobject *kobj, 184 struct kobj_attribute *a, 185 const char *buf, size_t count) 186 { 187 struct btrfs_fs_info *fs_info; 188 struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a); 189 u64 features, set, clear; 190 unsigned long val; 191 int ret; 192 193 fs_info = to_fs_info(kobj); 194 if (!fs_info) 195 return -EPERM; 196 197 if (sb_rdonly(fs_info->sb)) 198 return -EROFS; 199 200 ret = kstrtoul(skip_spaces(buf), 0, &val); 201 if (ret) 202 return ret; 203 204 if (fa->feature_set == FEAT_COMPAT) { 205 set = BTRFS_FEATURE_COMPAT_SAFE_SET; 206 clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR; 207 } else if (fa->feature_set == FEAT_COMPAT_RO) { 208 set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET; 209 clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR; 210 } else { 211 set = BTRFS_FEATURE_INCOMPAT_SAFE_SET; 212 clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR; 213 } 214 215 features = get_features(fs_info, fa->feature_set); 216 217 /* Nothing to do */ 218 if ((val && (features & fa->feature_bit)) || 219 (!val && !(features & fa->feature_bit))) 220 return count; 221 222 if ((val && !(set & fa->feature_bit)) || 223 (!val && !(clear & fa->feature_bit))) { 224 btrfs_info(fs_info, 225 "%sabling feature %s on mounted fs is not supported.", 226 val ? "En" : "Dis", fa->kobj_attr.attr.name); 227 return -EPERM; 228 } 229 230 btrfs_info(fs_info, "%s %s feature flag", 231 val ? "Setting" : "Clearing", fa->kobj_attr.attr.name); 232 233 spin_lock(&fs_info->super_lock); 234 features = get_features(fs_info, fa->feature_set); 235 if (val) 236 features |= fa->feature_bit; 237 else 238 features &= ~fa->feature_bit; 239 set_features(fs_info, fa->feature_set, features); 240 spin_unlock(&fs_info->super_lock); 241 242 /* 243 * We don't want to do full transaction commit from inside sysfs 244 */ 245 btrfs_set_pending(fs_info, COMMIT); 246 wake_up_process(fs_info->transaction_kthread); 247 248 return count; 249 } 250 251 static umode_t btrfs_feature_visible(struct kobject *kobj, 252 struct attribute *attr, int unused) 253 { 254 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 255 umode_t mode = attr->mode; 256 257 if (fs_info) { 258 struct btrfs_feature_attr *fa; 259 u64 features; 260 261 fa = attr_to_btrfs_feature_attr(attr); 262 features = get_features(fs_info, fa->feature_set); 263 264 if (can_modify_feature(fa)) 265 mode |= S_IWUSR; 266 else if (!(features & fa->feature_bit)) 267 mode = 0; 268 } 269 270 return mode; 271 } 272 273 BTRFS_FEAT_ATTR_INCOMPAT(mixed_backref, MIXED_BACKREF); 274 BTRFS_FEAT_ATTR_INCOMPAT(default_subvol, DEFAULT_SUBVOL); 275 BTRFS_FEAT_ATTR_INCOMPAT(mixed_groups, MIXED_GROUPS); 276 BTRFS_FEAT_ATTR_INCOMPAT(compress_lzo, COMPRESS_LZO); 277 BTRFS_FEAT_ATTR_INCOMPAT(compress_zstd, COMPRESS_ZSTD); 278 BTRFS_FEAT_ATTR_INCOMPAT(big_metadata, BIG_METADATA); 279 BTRFS_FEAT_ATTR_INCOMPAT(extended_iref, EXTENDED_IREF); 280 BTRFS_FEAT_ATTR_INCOMPAT(raid56, RAID56); 281 BTRFS_FEAT_ATTR_INCOMPAT(skinny_metadata, SKINNY_METADATA); 282 BTRFS_FEAT_ATTR_INCOMPAT(no_holes, NO_HOLES); 283 BTRFS_FEAT_ATTR_INCOMPAT(metadata_uuid, METADATA_UUID); 284 BTRFS_FEAT_ATTR_COMPAT_RO(free_space_tree, FREE_SPACE_TREE); 285 BTRFS_FEAT_ATTR_INCOMPAT(raid1c34, RAID1C34); 286 /* Remove once support for zoned allocation is feature complete */ 287 #ifdef CONFIG_BTRFS_DEBUG 288 BTRFS_FEAT_ATTR_INCOMPAT(zoned, ZONED); 289 #endif 290 #ifdef CONFIG_FS_VERITY 291 BTRFS_FEAT_ATTR_COMPAT_RO(verity, VERITY); 292 #endif 293 294 /* 295 * Features which depend on feature bits and may differ between each fs. 296 * 297 * /sys/fs/btrfs/features - all available features implemeted by this version 298 * /sys/fs/btrfs/UUID/features - features of the fs which are enabled or 299 * can be changed on a mounted filesystem. 300 */ 301 static struct attribute *btrfs_supported_feature_attrs[] = { 302 BTRFS_FEAT_ATTR_PTR(mixed_backref), 303 BTRFS_FEAT_ATTR_PTR(default_subvol), 304 BTRFS_FEAT_ATTR_PTR(mixed_groups), 305 BTRFS_FEAT_ATTR_PTR(compress_lzo), 306 BTRFS_FEAT_ATTR_PTR(compress_zstd), 307 BTRFS_FEAT_ATTR_PTR(big_metadata), 308 BTRFS_FEAT_ATTR_PTR(extended_iref), 309 BTRFS_FEAT_ATTR_PTR(raid56), 310 BTRFS_FEAT_ATTR_PTR(skinny_metadata), 311 BTRFS_FEAT_ATTR_PTR(no_holes), 312 BTRFS_FEAT_ATTR_PTR(metadata_uuid), 313 BTRFS_FEAT_ATTR_PTR(free_space_tree), 314 BTRFS_FEAT_ATTR_PTR(raid1c34), 315 #ifdef CONFIG_BTRFS_DEBUG 316 BTRFS_FEAT_ATTR_PTR(zoned), 317 #endif 318 #ifdef CONFIG_FS_VERITY 319 BTRFS_FEAT_ATTR_PTR(verity), 320 #endif 321 NULL 322 }; 323 324 static const struct attribute_group btrfs_feature_attr_group = { 325 .name = "features", 326 .is_visible = btrfs_feature_visible, 327 .attrs = btrfs_supported_feature_attrs, 328 }; 329 330 static ssize_t rmdir_subvol_show(struct kobject *kobj, 331 struct kobj_attribute *ka, char *buf) 332 { 333 return scnprintf(buf, PAGE_SIZE, "0\n"); 334 } 335 BTRFS_ATTR(static_feature, rmdir_subvol, rmdir_subvol_show); 336 337 static ssize_t supported_checksums_show(struct kobject *kobj, 338 struct kobj_attribute *a, char *buf) 339 { 340 ssize_t ret = 0; 341 int i; 342 343 for (i = 0; i < btrfs_get_num_csums(); i++) { 344 /* 345 * This "trick" only works as long as 'enum btrfs_csum_type' has 346 * no holes in it 347 */ 348 ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%s%s", 349 (i == 0 ? "" : " "), btrfs_super_csum_name(i)); 350 351 } 352 353 ret += scnprintf(buf + ret, PAGE_SIZE - ret, "\n"); 354 return ret; 355 } 356 BTRFS_ATTR(static_feature, supported_checksums, supported_checksums_show); 357 358 static ssize_t send_stream_version_show(struct kobject *kobj, 359 struct kobj_attribute *ka, char *buf) 360 { 361 return snprintf(buf, PAGE_SIZE, "%d\n", BTRFS_SEND_STREAM_VERSION); 362 } 363 BTRFS_ATTR(static_feature, send_stream_version, send_stream_version_show); 364 365 static const char *rescue_opts[] = { 366 "usebackuproot", 367 "nologreplay", 368 "ignorebadroots", 369 "ignoredatacsums", 370 "all", 371 }; 372 373 static ssize_t supported_rescue_options_show(struct kobject *kobj, 374 struct kobj_attribute *a, 375 char *buf) 376 { 377 ssize_t ret = 0; 378 int i; 379 380 for (i = 0; i < ARRAY_SIZE(rescue_opts); i++) 381 ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%s%s", 382 (i ? " " : ""), rescue_opts[i]); 383 ret += scnprintf(buf + ret, PAGE_SIZE - ret, "\n"); 384 return ret; 385 } 386 BTRFS_ATTR(static_feature, supported_rescue_options, 387 supported_rescue_options_show); 388 389 static ssize_t supported_sectorsizes_show(struct kobject *kobj, 390 struct kobj_attribute *a, 391 char *buf) 392 { 393 ssize_t ret = 0; 394 395 /* 4K sector size is also supported with 64K page size */ 396 if (PAGE_SIZE == SZ_64K) 397 ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%u ", SZ_4K); 398 399 /* Only sectorsize == PAGE_SIZE is now supported */ 400 ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%lu\n", PAGE_SIZE); 401 402 return ret; 403 } 404 BTRFS_ATTR(static_feature, supported_sectorsizes, 405 supported_sectorsizes_show); 406 407 /* 408 * Features which only depend on kernel version. 409 * 410 * These are listed in /sys/fs/btrfs/features along with 411 * btrfs_supported_feature_attrs. 412 */ 413 static struct attribute *btrfs_supported_static_feature_attrs[] = { 414 BTRFS_ATTR_PTR(static_feature, rmdir_subvol), 415 BTRFS_ATTR_PTR(static_feature, supported_checksums), 416 BTRFS_ATTR_PTR(static_feature, send_stream_version), 417 BTRFS_ATTR_PTR(static_feature, supported_rescue_options), 418 BTRFS_ATTR_PTR(static_feature, supported_sectorsizes), 419 NULL 420 }; 421 422 static const struct attribute_group btrfs_static_feature_attr_group = { 423 .name = "features", 424 .attrs = btrfs_supported_static_feature_attrs, 425 }; 426 427 #ifdef CONFIG_BTRFS_DEBUG 428 429 /* 430 * Discard statistics and tunables 431 */ 432 #define discard_to_fs_info(_kobj) to_fs_info((_kobj)->parent->parent) 433 434 static ssize_t btrfs_discardable_bytes_show(struct kobject *kobj, 435 struct kobj_attribute *a, 436 char *buf) 437 { 438 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 439 440 return scnprintf(buf, PAGE_SIZE, "%lld\n", 441 atomic64_read(&fs_info->discard_ctl.discardable_bytes)); 442 } 443 BTRFS_ATTR(discard, discardable_bytes, btrfs_discardable_bytes_show); 444 445 static ssize_t btrfs_discardable_extents_show(struct kobject *kobj, 446 struct kobj_attribute *a, 447 char *buf) 448 { 449 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 450 451 return scnprintf(buf, PAGE_SIZE, "%d\n", 452 atomic_read(&fs_info->discard_ctl.discardable_extents)); 453 } 454 BTRFS_ATTR(discard, discardable_extents, btrfs_discardable_extents_show); 455 456 static ssize_t btrfs_discard_bitmap_bytes_show(struct kobject *kobj, 457 struct kobj_attribute *a, 458 char *buf) 459 { 460 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 461 462 return scnprintf(buf, PAGE_SIZE, "%llu\n", 463 fs_info->discard_ctl.discard_bitmap_bytes); 464 } 465 BTRFS_ATTR(discard, discard_bitmap_bytes, btrfs_discard_bitmap_bytes_show); 466 467 static ssize_t btrfs_discard_bytes_saved_show(struct kobject *kobj, 468 struct kobj_attribute *a, 469 char *buf) 470 { 471 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 472 473 return scnprintf(buf, PAGE_SIZE, "%lld\n", 474 atomic64_read(&fs_info->discard_ctl.discard_bytes_saved)); 475 } 476 BTRFS_ATTR(discard, discard_bytes_saved, btrfs_discard_bytes_saved_show); 477 478 static ssize_t btrfs_discard_extent_bytes_show(struct kobject *kobj, 479 struct kobj_attribute *a, 480 char *buf) 481 { 482 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 483 484 return scnprintf(buf, PAGE_SIZE, "%llu\n", 485 fs_info->discard_ctl.discard_extent_bytes); 486 } 487 BTRFS_ATTR(discard, discard_extent_bytes, btrfs_discard_extent_bytes_show); 488 489 static ssize_t btrfs_discard_iops_limit_show(struct kobject *kobj, 490 struct kobj_attribute *a, 491 char *buf) 492 { 493 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 494 495 return scnprintf(buf, PAGE_SIZE, "%u\n", 496 READ_ONCE(fs_info->discard_ctl.iops_limit)); 497 } 498 499 static ssize_t btrfs_discard_iops_limit_store(struct kobject *kobj, 500 struct kobj_attribute *a, 501 const char *buf, size_t len) 502 { 503 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 504 struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl; 505 u32 iops_limit; 506 int ret; 507 508 ret = kstrtou32(buf, 10, &iops_limit); 509 if (ret) 510 return -EINVAL; 511 512 WRITE_ONCE(discard_ctl->iops_limit, iops_limit); 513 btrfs_discard_calc_delay(discard_ctl); 514 btrfs_discard_schedule_work(discard_ctl, true); 515 return len; 516 } 517 BTRFS_ATTR_RW(discard, iops_limit, btrfs_discard_iops_limit_show, 518 btrfs_discard_iops_limit_store); 519 520 static ssize_t btrfs_discard_kbps_limit_show(struct kobject *kobj, 521 struct kobj_attribute *a, 522 char *buf) 523 { 524 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 525 526 return scnprintf(buf, PAGE_SIZE, "%u\n", 527 READ_ONCE(fs_info->discard_ctl.kbps_limit)); 528 } 529 530 static ssize_t btrfs_discard_kbps_limit_store(struct kobject *kobj, 531 struct kobj_attribute *a, 532 const char *buf, size_t len) 533 { 534 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 535 struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl; 536 u32 kbps_limit; 537 int ret; 538 539 ret = kstrtou32(buf, 10, &kbps_limit); 540 if (ret) 541 return -EINVAL; 542 543 WRITE_ONCE(discard_ctl->kbps_limit, kbps_limit); 544 btrfs_discard_schedule_work(discard_ctl, true); 545 return len; 546 } 547 BTRFS_ATTR_RW(discard, kbps_limit, btrfs_discard_kbps_limit_show, 548 btrfs_discard_kbps_limit_store); 549 550 static ssize_t btrfs_discard_max_discard_size_show(struct kobject *kobj, 551 struct kobj_attribute *a, 552 char *buf) 553 { 554 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 555 556 return scnprintf(buf, PAGE_SIZE, "%llu\n", 557 READ_ONCE(fs_info->discard_ctl.max_discard_size)); 558 } 559 560 static ssize_t btrfs_discard_max_discard_size_store(struct kobject *kobj, 561 struct kobj_attribute *a, 562 const char *buf, size_t len) 563 { 564 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 565 struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl; 566 u64 max_discard_size; 567 int ret; 568 569 ret = kstrtou64(buf, 10, &max_discard_size); 570 if (ret) 571 return -EINVAL; 572 573 WRITE_ONCE(discard_ctl->max_discard_size, max_discard_size); 574 575 return len; 576 } 577 BTRFS_ATTR_RW(discard, max_discard_size, btrfs_discard_max_discard_size_show, 578 btrfs_discard_max_discard_size_store); 579 580 /* 581 * Per-filesystem debugging of discard (when mounted with discard=async). 582 * 583 * Path: /sys/fs/btrfs/<uuid>/debug/discard/ 584 */ 585 static const struct attribute *discard_debug_attrs[] = { 586 BTRFS_ATTR_PTR(discard, discardable_bytes), 587 BTRFS_ATTR_PTR(discard, discardable_extents), 588 BTRFS_ATTR_PTR(discard, discard_bitmap_bytes), 589 BTRFS_ATTR_PTR(discard, discard_bytes_saved), 590 BTRFS_ATTR_PTR(discard, discard_extent_bytes), 591 BTRFS_ATTR_PTR(discard, iops_limit), 592 BTRFS_ATTR_PTR(discard, kbps_limit), 593 BTRFS_ATTR_PTR(discard, max_discard_size), 594 NULL, 595 }; 596 597 /* 598 * Per-filesystem runtime debugging exported via sysfs. 599 * 600 * Path: /sys/fs/btrfs/UUID/debug/ 601 */ 602 static const struct attribute *btrfs_debug_mount_attrs[] = { 603 NULL, 604 }; 605 606 /* 607 * Runtime debugging exported via sysfs, applies to all mounted filesystems. 608 * 609 * Path: /sys/fs/btrfs/debug 610 */ 611 static struct attribute *btrfs_debug_feature_attrs[] = { 612 NULL 613 }; 614 615 static const struct attribute_group btrfs_debug_feature_attr_group = { 616 .name = "debug", 617 .attrs = btrfs_debug_feature_attrs, 618 }; 619 620 #endif 621 622 static ssize_t btrfs_show_u64(u64 *value_ptr, spinlock_t *lock, char *buf) 623 { 624 u64 val; 625 if (lock) 626 spin_lock(lock); 627 val = *value_ptr; 628 if (lock) 629 spin_unlock(lock); 630 return scnprintf(buf, PAGE_SIZE, "%llu\n", val); 631 } 632 633 static ssize_t global_rsv_size_show(struct kobject *kobj, 634 struct kobj_attribute *ka, char *buf) 635 { 636 struct btrfs_fs_info *fs_info = to_fs_info(kobj->parent); 637 struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv; 638 return btrfs_show_u64(&block_rsv->size, &block_rsv->lock, buf); 639 } 640 BTRFS_ATTR(allocation, global_rsv_size, global_rsv_size_show); 641 642 static ssize_t global_rsv_reserved_show(struct kobject *kobj, 643 struct kobj_attribute *a, char *buf) 644 { 645 struct btrfs_fs_info *fs_info = to_fs_info(kobj->parent); 646 struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv; 647 return btrfs_show_u64(&block_rsv->reserved, &block_rsv->lock, buf); 648 } 649 BTRFS_ATTR(allocation, global_rsv_reserved, global_rsv_reserved_show); 650 651 #define to_space_info(_kobj) container_of(_kobj, struct btrfs_space_info, kobj) 652 #define to_raid_kobj(_kobj) container_of(_kobj, struct raid_kobject, kobj) 653 654 static ssize_t raid_bytes_show(struct kobject *kobj, 655 struct kobj_attribute *attr, char *buf); 656 BTRFS_ATTR(raid, total_bytes, raid_bytes_show); 657 BTRFS_ATTR(raid, used_bytes, raid_bytes_show); 658 659 static ssize_t raid_bytes_show(struct kobject *kobj, 660 struct kobj_attribute *attr, char *buf) 661 662 { 663 struct btrfs_space_info *sinfo = to_space_info(kobj->parent); 664 struct btrfs_block_group *block_group; 665 int index = btrfs_bg_flags_to_raid_index(to_raid_kobj(kobj)->flags); 666 u64 val = 0; 667 668 down_read(&sinfo->groups_sem); 669 list_for_each_entry(block_group, &sinfo->block_groups[index], list) { 670 if (&attr->attr == BTRFS_ATTR_PTR(raid, total_bytes)) 671 val += block_group->length; 672 else 673 val += block_group->used; 674 } 675 up_read(&sinfo->groups_sem); 676 return scnprintf(buf, PAGE_SIZE, "%llu\n", val); 677 } 678 679 /* 680 * Allocation information about block group profiles. 681 * 682 * Path: /sys/fs/btrfs/<uuid>/allocation/<bg-type>/<bg-profile>/ 683 */ 684 static struct attribute *raid_attrs[] = { 685 BTRFS_ATTR_PTR(raid, total_bytes), 686 BTRFS_ATTR_PTR(raid, used_bytes), 687 NULL 688 }; 689 ATTRIBUTE_GROUPS(raid); 690 691 static void release_raid_kobj(struct kobject *kobj) 692 { 693 kfree(to_raid_kobj(kobj)); 694 } 695 696 static struct kobj_type btrfs_raid_ktype = { 697 .sysfs_ops = &kobj_sysfs_ops, 698 .release = release_raid_kobj, 699 .default_groups = raid_groups, 700 }; 701 702 #define SPACE_INFO_ATTR(field) \ 703 static ssize_t btrfs_space_info_show_##field(struct kobject *kobj, \ 704 struct kobj_attribute *a, \ 705 char *buf) \ 706 { \ 707 struct btrfs_space_info *sinfo = to_space_info(kobj); \ 708 return btrfs_show_u64(&sinfo->field, &sinfo->lock, buf); \ 709 } \ 710 BTRFS_ATTR(space_info, field, btrfs_space_info_show_##field) 711 712 SPACE_INFO_ATTR(flags); 713 SPACE_INFO_ATTR(total_bytes); 714 SPACE_INFO_ATTR(bytes_used); 715 SPACE_INFO_ATTR(bytes_pinned); 716 SPACE_INFO_ATTR(bytes_reserved); 717 SPACE_INFO_ATTR(bytes_may_use); 718 SPACE_INFO_ATTR(bytes_readonly); 719 SPACE_INFO_ATTR(bytes_zone_unusable); 720 SPACE_INFO_ATTR(disk_used); 721 SPACE_INFO_ATTR(disk_total); 722 723 /* 724 * Allocation information about block group types. 725 * 726 * Path: /sys/fs/btrfs/<uuid>/allocation/<bg-type>/ 727 */ 728 static struct attribute *space_info_attrs[] = { 729 BTRFS_ATTR_PTR(space_info, flags), 730 BTRFS_ATTR_PTR(space_info, total_bytes), 731 BTRFS_ATTR_PTR(space_info, bytes_used), 732 BTRFS_ATTR_PTR(space_info, bytes_pinned), 733 BTRFS_ATTR_PTR(space_info, bytes_reserved), 734 BTRFS_ATTR_PTR(space_info, bytes_may_use), 735 BTRFS_ATTR_PTR(space_info, bytes_readonly), 736 BTRFS_ATTR_PTR(space_info, bytes_zone_unusable), 737 BTRFS_ATTR_PTR(space_info, disk_used), 738 BTRFS_ATTR_PTR(space_info, disk_total), 739 NULL, 740 }; 741 ATTRIBUTE_GROUPS(space_info); 742 743 static void space_info_release(struct kobject *kobj) 744 { 745 struct btrfs_space_info *sinfo = to_space_info(kobj); 746 kfree(sinfo); 747 } 748 749 static struct kobj_type space_info_ktype = { 750 .sysfs_ops = &kobj_sysfs_ops, 751 .release = space_info_release, 752 .default_groups = space_info_groups, 753 }; 754 755 /* 756 * Allocation information about block groups. 757 * 758 * Path: /sys/fs/btrfs/<uuid>/allocation/ 759 */ 760 static const struct attribute *allocation_attrs[] = { 761 BTRFS_ATTR_PTR(allocation, global_rsv_reserved), 762 BTRFS_ATTR_PTR(allocation, global_rsv_size), 763 NULL, 764 }; 765 766 static ssize_t btrfs_label_show(struct kobject *kobj, 767 struct kobj_attribute *a, char *buf) 768 { 769 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 770 char *label = fs_info->super_copy->label; 771 ssize_t ret; 772 773 spin_lock(&fs_info->super_lock); 774 ret = scnprintf(buf, PAGE_SIZE, label[0] ? "%s\n" : "%s", label); 775 spin_unlock(&fs_info->super_lock); 776 777 return ret; 778 } 779 780 static ssize_t btrfs_label_store(struct kobject *kobj, 781 struct kobj_attribute *a, 782 const char *buf, size_t len) 783 { 784 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 785 size_t p_len; 786 787 if (!fs_info) 788 return -EPERM; 789 790 if (sb_rdonly(fs_info->sb)) 791 return -EROFS; 792 793 /* 794 * p_len is the len until the first occurrence of either 795 * '\n' or '\0' 796 */ 797 p_len = strcspn(buf, "\n"); 798 799 if (p_len >= BTRFS_LABEL_SIZE) 800 return -EINVAL; 801 802 spin_lock(&fs_info->super_lock); 803 memset(fs_info->super_copy->label, 0, BTRFS_LABEL_SIZE); 804 memcpy(fs_info->super_copy->label, buf, p_len); 805 spin_unlock(&fs_info->super_lock); 806 807 /* 808 * We don't want to do full transaction commit from inside sysfs 809 */ 810 btrfs_set_pending(fs_info, COMMIT); 811 wake_up_process(fs_info->transaction_kthread); 812 813 return len; 814 } 815 BTRFS_ATTR_RW(, label, btrfs_label_show, btrfs_label_store); 816 817 static ssize_t btrfs_nodesize_show(struct kobject *kobj, 818 struct kobj_attribute *a, char *buf) 819 { 820 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 821 822 return scnprintf(buf, PAGE_SIZE, "%u\n", fs_info->super_copy->nodesize); 823 } 824 825 BTRFS_ATTR(, nodesize, btrfs_nodesize_show); 826 827 static ssize_t btrfs_sectorsize_show(struct kobject *kobj, 828 struct kobj_attribute *a, char *buf) 829 { 830 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 831 832 return scnprintf(buf, PAGE_SIZE, "%u\n", 833 fs_info->super_copy->sectorsize); 834 } 835 836 BTRFS_ATTR(, sectorsize, btrfs_sectorsize_show); 837 838 static ssize_t btrfs_clone_alignment_show(struct kobject *kobj, 839 struct kobj_attribute *a, char *buf) 840 { 841 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 842 843 return scnprintf(buf, PAGE_SIZE, "%u\n", fs_info->super_copy->sectorsize); 844 } 845 846 BTRFS_ATTR(, clone_alignment, btrfs_clone_alignment_show); 847 848 static ssize_t quota_override_show(struct kobject *kobj, 849 struct kobj_attribute *a, char *buf) 850 { 851 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 852 int quota_override; 853 854 quota_override = test_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags); 855 return scnprintf(buf, PAGE_SIZE, "%d\n", quota_override); 856 } 857 858 static ssize_t quota_override_store(struct kobject *kobj, 859 struct kobj_attribute *a, 860 const char *buf, size_t len) 861 { 862 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 863 unsigned long knob; 864 int err; 865 866 if (!fs_info) 867 return -EPERM; 868 869 if (!capable(CAP_SYS_RESOURCE)) 870 return -EPERM; 871 872 err = kstrtoul(buf, 10, &knob); 873 if (err) 874 return err; 875 if (knob > 1) 876 return -EINVAL; 877 878 if (knob) 879 set_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags); 880 else 881 clear_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags); 882 883 return len; 884 } 885 886 BTRFS_ATTR_RW(, quota_override, quota_override_show, quota_override_store); 887 888 static ssize_t btrfs_metadata_uuid_show(struct kobject *kobj, 889 struct kobj_attribute *a, char *buf) 890 { 891 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 892 893 return scnprintf(buf, PAGE_SIZE, "%pU\n", 894 fs_info->fs_devices->metadata_uuid); 895 } 896 897 BTRFS_ATTR(, metadata_uuid, btrfs_metadata_uuid_show); 898 899 static ssize_t btrfs_checksum_show(struct kobject *kobj, 900 struct kobj_attribute *a, char *buf) 901 { 902 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 903 u16 csum_type = btrfs_super_csum_type(fs_info->super_copy); 904 905 return scnprintf(buf, PAGE_SIZE, "%s (%s)\n", 906 btrfs_super_csum_name(csum_type), 907 crypto_shash_driver_name(fs_info->csum_shash)); 908 } 909 910 BTRFS_ATTR(, checksum, btrfs_checksum_show); 911 912 static ssize_t btrfs_exclusive_operation_show(struct kobject *kobj, 913 struct kobj_attribute *a, char *buf) 914 { 915 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 916 const char *str; 917 918 switch (READ_ONCE(fs_info->exclusive_operation)) { 919 case BTRFS_EXCLOP_NONE: 920 str = "none\n"; 921 break; 922 case BTRFS_EXCLOP_BALANCE: 923 str = "balance\n"; 924 break; 925 case BTRFS_EXCLOP_DEV_ADD: 926 str = "device add\n"; 927 break; 928 case BTRFS_EXCLOP_DEV_REMOVE: 929 str = "device remove\n"; 930 break; 931 case BTRFS_EXCLOP_DEV_REPLACE: 932 str = "device replace\n"; 933 break; 934 case BTRFS_EXCLOP_RESIZE: 935 str = "resize\n"; 936 break; 937 case BTRFS_EXCLOP_SWAP_ACTIVATE: 938 str = "swap activate\n"; 939 break; 940 default: 941 str = "UNKNOWN\n"; 942 break; 943 } 944 return scnprintf(buf, PAGE_SIZE, "%s", str); 945 } 946 BTRFS_ATTR(, exclusive_operation, btrfs_exclusive_operation_show); 947 948 static ssize_t btrfs_generation_show(struct kobject *kobj, 949 struct kobj_attribute *a, char *buf) 950 { 951 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 952 953 return scnprintf(buf, PAGE_SIZE, "%llu\n", fs_info->generation); 954 } 955 BTRFS_ATTR(, generation, btrfs_generation_show); 956 957 /* 958 * Look for an exact string @string in @buffer with possible leading or 959 * trailing whitespace 960 */ 961 static bool strmatch(const char *buffer, const char *string) 962 { 963 const size_t len = strlen(string); 964 965 /* Skip leading whitespace */ 966 buffer = skip_spaces(buffer); 967 968 /* Match entire string, check if the rest is whitespace or empty */ 969 if (strncmp(string, buffer, len) == 0 && 970 strlen(skip_spaces(buffer + len)) == 0) 971 return true; 972 973 return false; 974 } 975 976 static const char * const btrfs_read_policy_name[] = { "pid" }; 977 978 static ssize_t btrfs_read_policy_show(struct kobject *kobj, 979 struct kobj_attribute *a, char *buf) 980 { 981 struct btrfs_fs_devices *fs_devices = to_fs_devs(kobj); 982 ssize_t ret = 0; 983 int i; 984 985 for (i = 0; i < BTRFS_NR_READ_POLICY; i++) { 986 if (fs_devices->read_policy == i) 987 ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%s[%s]", 988 (ret == 0 ? "" : " "), 989 btrfs_read_policy_name[i]); 990 else 991 ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%s%s", 992 (ret == 0 ? "" : " "), 993 btrfs_read_policy_name[i]); 994 } 995 996 ret += scnprintf(buf + ret, PAGE_SIZE - ret, "\n"); 997 998 return ret; 999 } 1000 1001 static ssize_t btrfs_read_policy_store(struct kobject *kobj, 1002 struct kobj_attribute *a, 1003 const char *buf, size_t len) 1004 { 1005 struct btrfs_fs_devices *fs_devices = to_fs_devs(kobj); 1006 int i; 1007 1008 for (i = 0; i < BTRFS_NR_READ_POLICY; i++) { 1009 if (strmatch(buf, btrfs_read_policy_name[i])) { 1010 if (i != fs_devices->read_policy) { 1011 fs_devices->read_policy = i; 1012 btrfs_info(fs_devices->fs_info, 1013 "read policy set to '%s'", 1014 btrfs_read_policy_name[i]); 1015 } 1016 return len; 1017 } 1018 } 1019 1020 return -EINVAL; 1021 } 1022 BTRFS_ATTR_RW(, read_policy, btrfs_read_policy_show, btrfs_read_policy_store); 1023 1024 static ssize_t btrfs_bg_reclaim_threshold_show(struct kobject *kobj, 1025 struct kobj_attribute *a, 1026 char *buf) 1027 { 1028 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 1029 ssize_t ret; 1030 1031 ret = scnprintf(buf, PAGE_SIZE, "%d\n", 1032 READ_ONCE(fs_info->bg_reclaim_threshold)); 1033 1034 return ret; 1035 } 1036 1037 static ssize_t btrfs_bg_reclaim_threshold_store(struct kobject *kobj, 1038 struct kobj_attribute *a, 1039 const char *buf, size_t len) 1040 { 1041 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 1042 int thresh; 1043 int ret; 1044 1045 ret = kstrtoint(buf, 10, &thresh); 1046 if (ret) 1047 return ret; 1048 1049 if (thresh != 0 && (thresh <= 50 || thresh > 100)) 1050 return -EINVAL; 1051 1052 WRITE_ONCE(fs_info->bg_reclaim_threshold, thresh); 1053 1054 return len; 1055 } 1056 BTRFS_ATTR_RW(, bg_reclaim_threshold, btrfs_bg_reclaim_threshold_show, 1057 btrfs_bg_reclaim_threshold_store); 1058 1059 /* 1060 * Per-filesystem information and stats. 1061 * 1062 * Path: /sys/fs/btrfs/<uuid>/ 1063 */ 1064 static const struct attribute *btrfs_attrs[] = { 1065 BTRFS_ATTR_PTR(, label), 1066 BTRFS_ATTR_PTR(, nodesize), 1067 BTRFS_ATTR_PTR(, sectorsize), 1068 BTRFS_ATTR_PTR(, clone_alignment), 1069 BTRFS_ATTR_PTR(, quota_override), 1070 BTRFS_ATTR_PTR(, metadata_uuid), 1071 BTRFS_ATTR_PTR(, checksum), 1072 BTRFS_ATTR_PTR(, exclusive_operation), 1073 BTRFS_ATTR_PTR(, generation), 1074 BTRFS_ATTR_PTR(, read_policy), 1075 BTRFS_ATTR_PTR(, bg_reclaim_threshold), 1076 NULL, 1077 }; 1078 1079 static void btrfs_release_fsid_kobj(struct kobject *kobj) 1080 { 1081 struct btrfs_fs_devices *fs_devs = to_fs_devs(kobj); 1082 1083 memset(&fs_devs->fsid_kobj, 0, sizeof(struct kobject)); 1084 complete(&fs_devs->kobj_unregister); 1085 } 1086 1087 static struct kobj_type btrfs_ktype = { 1088 .sysfs_ops = &kobj_sysfs_ops, 1089 .release = btrfs_release_fsid_kobj, 1090 }; 1091 1092 static inline struct btrfs_fs_devices *to_fs_devs(struct kobject *kobj) 1093 { 1094 if (kobj->ktype != &btrfs_ktype) 1095 return NULL; 1096 return container_of(kobj, struct btrfs_fs_devices, fsid_kobj); 1097 } 1098 1099 static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj) 1100 { 1101 if (kobj->ktype != &btrfs_ktype) 1102 return NULL; 1103 return to_fs_devs(kobj)->fs_info; 1104 } 1105 1106 #define NUM_FEATURE_BITS 64 1107 #define BTRFS_FEATURE_NAME_MAX 13 1108 static char btrfs_unknown_feature_names[FEAT_MAX][NUM_FEATURE_BITS][BTRFS_FEATURE_NAME_MAX]; 1109 static struct btrfs_feature_attr btrfs_feature_attrs[FEAT_MAX][NUM_FEATURE_BITS]; 1110 1111 static const u64 supported_feature_masks[FEAT_MAX] = { 1112 [FEAT_COMPAT] = BTRFS_FEATURE_COMPAT_SUPP, 1113 [FEAT_COMPAT_RO] = BTRFS_FEATURE_COMPAT_RO_SUPP, 1114 [FEAT_INCOMPAT] = BTRFS_FEATURE_INCOMPAT_SUPP, 1115 }; 1116 1117 static int addrm_unknown_feature_attrs(struct btrfs_fs_info *fs_info, bool add) 1118 { 1119 int set; 1120 1121 for (set = 0; set < FEAT_MAX; set++) { 1122 int i; 1123 struct attribute *attrs[2]; 1124 struct attribute_group agroup = { 1125 .name = "features", 1126 .attrs = attrs, 1127 }; 1128 u64 features = get_features(fs_info, set); 1129 features &= ~supported_feature_masks[set]; 1130 1131 if (!features) 1132 continue; 1133 1134 attrs[1] = NULL; 1135 for (i = 0; i < NUM_FEATURE_BITS; i++) { 1136 struct btrfs_feature_attr *fa; 1137 1138 if (!(features & (1ULL << i))) 1139 continue; 1140 1141 fa = &btrfs_feature_attrs[set][i]; 1142 attrs[0] = &fa->kobj_attr.attr; 1143 if (add) { 1144 int ret; 1145 ret = sysfs_merge_group(&fs_info->fs_devices->fsid_kobj, 1146 &agroup); 1147 if (ret) 1148 return ret; 1149 } else 1150 sysfs_unmerge_group(&fs_info->fs_devices->fsid_kobj, 1151 &agroup); 1152 } 1153 1154 } 1155 return 0; 1156 } 1157 1158 static void __btrfs_sysfs_remove_fsid(struct btrfs_fs_devices *fs_devs) 1159 { 1160 if (fs_devs->devinfo_kobj) { 1161 kobject_del(fs_devs->devinfo_kobj); 1162 kobject_put(fs_devs->devinfo_kobj); 1163 fs_devs->devinfo_kobj = NULL; 1164 } 1165 1166 if (fs_devs->devices_kobj) { 1167 kobject_del(fs_devs->devices_kobj); 1168 kobject_put(fs_devs->devices_kobj); 1169 fs_devs->devices_kobj = NULL; 1170 } 1171 1172 if (fs_devs->fsid_kobj.state_initialized) { 1173 kobject_del(&fs_devs->fsid_kobj); 1174 kobject_put(&fs_devs->fsid_kobj); 1175 wait_for_completion(&fs_devs->kobj_unregister); 1176 } 1177 } 1178 1179 /* when fs_devs is NULL it will remove all fsid kobject */ 1180 void btrfs_sysfs_remove_fsid(struct btrfs_fs_devices *fs_devs) 1181 { 1182 struct list_head *fs_uuids = btrfs_get_fs_uuids(); 1183 1184 if (fs_devs) { 1185 __btrfs_sysfs_remove_fsid(fs_devs); 1186 return; 1187 } 1188 1189 list_for_each_entry(fs_devs, fs_uuids, fs_list) { 1190 __btrfs_sysfs_remove_fsid(fs_devs); 1191 } 1192 } 1193 1194 static void btrfs_sysfs_remove_fs_devices(struct btrfs_fs_devices *fs_devices) 1195 { 1196 struct btrfs_device *device; 1197 struct btrfs_fs_devices *seed; 1198 1199 list_for_each_entry(device, &fs_devices->devices, dev_list) 1200 btrfs_sysfs_remove_device(device); 1201 1202 list_for_each_entry(seed, &fs_devices->seed_list, seed_list) { 1203 list_for_each_entry(device, &seed->devices, dev_list) 1204 btrfs_sysfs_remove_device(device); 1205 } 1206 } 1207 1208 void btrfs_sysfs_remove_mounted(struct btrfs_fs_info *fs_info) 1209 { 1210 struct kobject *fsid_kobj = &fs_info->fs_devices->fsid_kobj; 1211 1212 sysfs_remove_link(fsid_kobj, "bdi"); 1213 1214 if (fs_info->space_info_kobj) { 1215 sysfs_remove_files(fs_info->space_info_kobj, allocation_attrs); 1216 kobject_del(fs_info->space_info_kobj); 1217 kobject_put(fs_info->space_info_kobj); 1218 } 1219 #ifdef CONFIG_BTRFS_DEBUG 1220 if (fs_info->discard_debug_kobj) { 1221 sysfs_remove_files(fs_info->discard_debug_kobj, 1222 discard_debug_attrs); 1223 kobject_del(fs_info->discard_debug_kobj); 1224 kobject_put(fs_info->discard_debug_kobj); 1225 } 1226 if (fs_info->debug_kobj) { 1227 sysfs_remove_files(fs_info->debug_kobj, btrfs_debug_mount_attrs); 1228 kobject_del(fs_info->debug_kobj); 1229 kobject_put(fs_info->debug_kobj); 1230 } 1231 #endif 1232 addrm_unknown_feature_attrs(fs_info, false); 1233 sysfs_remove_group(fsid_kobj, &btrfs_feature_attr_group); 1234 sysfs_remove_files(fsid_kobj, btrfs_attrs); 1235 btrfs_sysfs_remove_fs_devices(fs_info->fs_devices); 1236 } 1237 1238 static const char * const btrfs_feature_set_names[FEAT_MAX] = { 1239 [FEAT_COMPAT] = "compat", 1240 [FEAT_COMPAT_RO] = "compat_ro", 1241 [FEAT_INCOMPAT] = "incompat", 1242 }; 1243 1244 const char *btrfs_feature_set_name(enum btrfs_feature_set set) 1245 { 1246 return btrfs_feature_set_names[set]; 1247 } 1248 1249 char *btrfs_printable_features(enum btrfs_feature_set set, u64 flags) 1250 { 1251 size_t bufsize = 4096; /* safe max, 64 names * 64 bytes */ 1252 int len = 0; 1253 int i; 1254 char *str; 1255 1256 str = kmalloc(bufsize, GFP_KERNEL); 1257 if (!str) 1258 return str; 1259 1260 for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) { 1261 const char *name; 1262 1263 if (!(flags & (1ULL << i))) 1264 continue; 1265 1266 name = btrfs_feature_attrs[set][i].kobj_attr.attr.name; 1267 len += scnprintf(str + len, bufsize - len, "%s%s", 1268 len ? "," : "", name); 1269 } 1270 1271 return str; 1272 } 1273 1274 static void init_feature_attrs(void) 1275 { 1276 struct btrfs_feature_attr *fa; 1277 int set, i; 1278 1279 BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names) != 1280 ARRAY_SIZE(btrfs_feature_attrs)); 1281 BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names[0]) != 1282 ARRAY_SIZE(btrfs_feature_attrs[0])); 1283 1284 memset(btrfs_feature_attrs, 0, sizeof(btrfs_feature_attrs)); 1285 memset(btrfs_unknown_feature_names, 0, 1286 sizeof(btrfs_unknown_feature_names)); 1287 1288 for (i = 0; btrfs_supported_feature_attrs[i]; i++) { 1289 struct btrfs_feature_attr *sfa; 1290 struct attribute *a = btrfs_supported_feature_attrs[i]; 1291 int bit; 1292 sfa = attr_to_btrfs_feature_attr(a); 1293 bit = ilog2(sfa->feature_bit); 1294 fa = &btrfs_feature_attrs[sfa->feature_set][bit]; 1295 1296 fa->kobj_attr.attr.name = sfa->kobj_attr.attr.name; 1297 } 1298 1299 for (set = 0; set < FEAT_MAX; set++) { 1300 for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) { 1301 char *name = btrfs_unknown_feature_names[set][i]; 1302 fa = &btrfs_feature_attrs[set][i]; 1303 1304 if (fa->kobj_attr.attr.name) 1305 continue; 1306 1307 snprintf(name, BTRFS_FEATURE_NAME_MAX, "%s:%u", 1308 btrfs_feature_set_names[set], i); 1309 1310 fa->kobj_attr.attr.name = name; 1311 fa->kobj_attr.attr.mode = S_IRUGO; 1312 fa->feature_set = set; 1313 fa->feature_bit = 1ULL << i; 1314 } 1315 } 1316 } 1317 1318 /* 1319 * Create a sysfs entry for a given block group type at path 1320 * /sys/fs/btrfs/UUID/allocation/data/TYPE 1321 */ 1322 void btrfs_sysfs_add_block_group_type(struct btrfs_block_group *cache) 1323 { 1324 struct btrfs_fs_info *fs_info = cache->fs_info; 1325 struct btrfs_space_info *space_info = cache->space_info; 1326 struct raid_kobject *rkobj; 1327 const int index = btrfs_bg_flags_to_raid_index(cache->flags); 1328 unsigned int nofs_flag; 1329 int ret; 1330 1331 /* 1332 * Setup a NOFS context because kobject_add(), deep in its call chain, 1333 * does GFP_KERNEL allocations, and we are often called in a context 1334 * where if reclaim is triggered we can deadlock (we are either holding 1335 * a transaction handle or some lock required for a transaction 1336 * commit). 1337 */ 1338 nofs_flag = memalloc_nofs_save(); 1339 1340 rkobj = kzalloc(sizeof(*rkobj), GFP_NOFS); 1341 if (!rkobj) { 1342 memalloc_nofs_restore(nofs_flag); 1343 btrfs_warn(cache->fs_info, 1344 "couldn't alloc memory for raid level kobject"); 1345 return; 1346 } 1347 1348 rkobj->flags = cache->flags; 1349 kobject_init(&rkobj->kobj, &btrfs_raid_ktype); 1350 1351 /* 1352 * We call this either on mount, or if we've created a block group for a 1353 * new index type while running (i.e. when restriping). The running 1354 * case is tricky because we could race with other threads, so we need 1355 * to have this check to make sure we didn't already init the kobject. 1356 * 1357 * We don't have to protect on the free side because it only happens on 1358 * unmount. 1359 */ 1360 spin_lock(&space_info->lock); 1361 if (space_info->block_group_kobjs[index]) { 1362 spin_unlock(&space_info->lock); 1363 kobject_put(&rkobj->kobj); 1364 return; 1365 } else { 1366 space_info->block_group_kobjs[index] = &rkobj->kobj; 1367 } 1368 spin_unlock(&space_info->lock); 1369 1370 ret = kobject_add(&rkobj->kobj, &space_info->kobj, "%s", 1371 btrfs_bg_type_to_raid_name(rkobj->flags)); 1372 memalloc_nofs_restore(nofs_flag); 1373 if (ret) { 1374 spin_lock(&space_info->lock); 1375 space_info->block_group_kobjs[index] = NULL; 1376 spin_unlock(&space_info->lock); 1377 kobject_put(&rkobj->kobj); 1378 btrfs_warn(fs_info, 1379 "failed to add kobject for block cache, ignoring"); 1380 return; 1381 } 1382 } 1383 1384 /* 1385 * Remove sysfs directories for all block group types of a given space info and 1386 * the space info as well 1387 */ 1388 void btrfs_sysfs_remove_space_info(struct btrfs_space_info *space_info) 1389 { 1390 int i; 1391 1392 for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) { 1393 struct kobject *kobj; 1394 1395 kobj = space_info->block_group_kobjs[i]; 1396 space_info->block_group_kobjs[i] = NULL; 1397 if (kobj) { 1398 kobject_del(kobj); 1399 kobject_put(kobj); 1400 } 1401 } 1402 kobject_del(&space_info->kobj); 1403 kobject_put(&space_info->kobj); 1404 } 1405 1406 static const char *alloc_name(u64 flags) 1407 { 1408 switch (flags) { 1409 case BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_DATA: 1410 return "mixed"; 1411 case BTRFS_BLOCK_GROUP_METADATA: 1412 return "metadata"; 1413 case BTRFS_BLOCK_GROUP_DATA: 1414 return "data"; 1415 case BTRFS_BLOCK_GROUP_SYSTEM: 1416 return "system"; 1417 default: 1418 WARN_ON(1); 1419 return "invalid-combination"; 1420 } 1421 } 1422 1423 /* 1424 * Create a sysfs entry for a space info type at path 1425 * /sys/fs/btrfs/UUID/allocation/TYPE 1426 */ 1427 int btrfs_sysfs_add_space_info_type(struct btrfs_fs_info *fs_info, 1428 struct btrfs_space_info *space_info) 1429 { 1430 int ret; 1431 1432 ret = kobject_init_and_add(&space_info->kobj, &space_info_ktype, 1433 fs_info->space_info_kobj, "%s", 1434 alloc_name(space_info->flags)); 1435 if (ret) { 1436 kobject_put(&space_info->kobj); 1437 return ret; 1438 } 1439 1440 return 0; 1441 } 1442 1443 void btrfs_sysfs_remove_device(struct btrfs_device *device) 1444 { 1445 struct kobject *devices_kobj; 1446 1447 /* 1448 * Seed fs_devices devices_kobj aren't used, fetch kobject from the 1449 * fs_info::fs_devices. 1450 */ 1451 devices_kobj = device->fs_info->fs_devices->devices_kobj; 1452 ASSERT(devices_kobj); 1453 1454 if (device->bdev) 1455 sysfs_remove_link(devices_kobj, bdev_kobj(device->bdev)->name); 1456 1457 if (device->devid_kobj.state_initialized) { 1458 kobject_del(&device->devid_kobj); 1459 kobject_put(&device->devid_kobj); 1460 wait_for_completion(&device->kobj_unregister); 1461 } 1462 } 1463 1464 static ssize_t btrfs_devinfo_in_fs_metadata_show(struct kobject *kobj, 1465 struct kobj_attribute *a, 1466 char *buf) 1467 { 1468 int val; 1469 struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1470 devid_kobj); 1471 1472 val = !!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); 1473 1474 return scnprintf(buf, PAGE_SIZE, "%d\n", val); 1475 } 1476 BTRFS_ATTR(devid, in_fs_metadata, btrfs_devinfo_in_fs_metadata_show); 1477 1478 static ssize_t btrfs_devinfo_missing_show(struct kobject *kobj, 1479 struct kobj_attribute *a, char *buf) 1480 { 1481 int val; 1482 struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1483 devid_kobj); 1484 1485 val = !!test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); 1486 1487 return scnprintf(buf, PAGE_SIZE, "%d\n", val); 1488 } 1489 BTRFS_ATTR(devid, missing, btrfs_devinfo_missing_show); 1490 1491 static ssize_t btrfs_devinfo_replace_target_show(struct kobject *kobj, 1492 struct kobj_attribute *a, 1493 char *buf) 1494 { 1495 int val; 1496 struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1497 devid_kobj); 1498 1499 val = !!test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); 1500 1501 return scnprintf(buf, PAGE_SIZE, "%d\n", val); 1502 } 1503 BTRFS_ATTR(devid, replace_target, btrfs_devinfo_replace_target_show); 1504 1505 static ssize_t btrfs_devinfo_scrub_speed_max_show(struct kobject *kobj, 1506 struct kobj_attribute *a, 1507 char *buf) 1508 { 1509 struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1510 devid_kobj); 1511 1512 return scnprintf(buf, PAGE_SIZE, "%llu\n", 1513 READ_ONCE(device->scrub_speed_max)); 1514 } 1515 1516 static ssize_t btrfs_devinfo_scrub_speed_max_store(struct kobject *kobj, 1517 struct kobj_attribute *a, 1518 const char *buf, size_t len) 1519 { 1520 struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1521 devid_kobj); 1522 char *endptr; 1523 unsigned long long limit; 1524 1525 limit = memparse(buf, &endptr); 1526 WRITE_ONCE(device->scrub_speed_max, limit); 1527 return len; 1528 } 1529 BTRFS_ATTR_RW(devid, scrub_speed_max, btrfs_devinfo_scrub_speed_max_show, 1530 btrfs_devinfo_scrub_speed_max_store); 1531 1532 static ssize_t btrfs_devinfo_writeable_show(struct kobject *kobj, 1533 struct kobj_attribute *a, char *buf) 1534 { 1535 int val; 1536 struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1537 devid_kobj); 1538 1539 val = !!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); 1540 1541 return scnprintf(buf, PAGE_SIZE, "%d\n", val); 1542 } 1543 BTRFS_ATTR(devid, writeable, btrfs_devinfo_writeable_show); 1544 1545 static ssize_t btrfs_devinfo_error_stats_show(struct kobject *kobj, 1546 struct kobj_attribute *a, char *buf) 1547 { 1548 struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1549 devid_kobj); 1550 1551 if (!device->dev_stats_valid) 1552 return scnprintf(buf, PAGE_SIZE, "invalid\n"); 1553 1554 /* 1555 * Print all at once so we get a snapshot of all values from the same 1556 * time. Keep them in sync and in order of definition of 1557 * btrfs_dev_stat_values. 1558 */ 1559 return scnprintf(buf, PAGE_SIZE, 1560 "write_errs %d\n" 1561 "read_errs %d\n" 1562 "flush_errs %d\n" 1563 "corruption_errs %d\n" 1564 "generation_errs %d\n", 1565 btrfs_dev_stat_read(device, BTRFS_DEV_STAT_WRITE_ERRS), 1566 btrfs_dev_stat_read(device, BTRFS_DEV_STAT_READ_ERRS), 1567 btrfs_dev_stat_read(device, BTRFS_DEV_STAT_FLUSH_ERRS), 1568 btrfs_dev_stat_read(device, BTRFS_DEV_STAT_CORRUPTION_ERRS), 1569 btrfs_dev_stat_read(device, BTRFS_DEV_STAT_GENERATION_ERRS)); 1570 } 1571 BTRFS_ATTR(devid, error_stats, btrfs_devinfo_error_stats_show); 1572 1573 /* 1574 * Information about one device. 1575 * 1576 * Path: /sys/fs/btrfs/<uuid>/devinfo/<devid>/ 1577 */ 1578 static struct attribute *devid_attrs[] = { 1579 BTRFS_ATTR_PTR(devid, error_stats), 1580 BTRFS_ATTR_PTR(devid, in_fs_metadata), 1581 BTRFS_ATTR_PTR(devid, missing), 1582 BTRFS_ATTR_PTR(devid, replace_target), 1583 BTRFS_ATTR_PTR(devid, scrub_speed_max), 1584 BTRFS_ATTR_PTR(devid, writeable), 1585 NULL 1586 }; 1587 ATTRIBUTE_GROUPS(devid); 1588 1589 static void btrfs_release_devid_kobj(struct kobject *kobj) 1590 { 1591 struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1592 devid_kobj); 1593 1594 memset(&device->devid_kobj, 0, sizeof(struct kobject)); 1595 complete(&device->kobj_unregister); 1596 } 1597 1598 static struct kobj_type devid_ktype = { 1599 .sysfs_ops = &kobj_sysfs_ops, 1600 .default_groups = devid_groups, 1601 .release = btrfs_release_devid_kobj, 1602 }; 1603 1604 int btrfs_sysfs_add_device(struct btrfs_device *device) 1605 { 1606 int ret; 1607 unsigned int nofs_flag; 1608 struct kobject *devices_kobj; 1609 struct kobject *devinfo_kobj; 1610 1611 /* 1612 * Make sure we use the fs_info::fs_devices to fetch the kobjects even 1613 * for the seed fs_devices 1614 */ 1615 devices_kobj = device->fs_info->fs_devices->devices_kobj; 1616 devinfo_kobj = device->fs_info->fs_devices->devinfo_kobj; 1617 ASSERT(devices_kobj); 1618 ASSERT(devinfo_kobj); 1619 1620 nofs_flag = memalloc_nofs_save(); 1621 1622 if (device->bdev) { 1623 struct kobject *disk_kobj = bdev_kobj(device->bdev); 1624 1625 ret = sysfs_create_link(devices_kobj, disk_kobj, disk_kobj->name); 1626 if (ret) { 1627 btrfs_warn(device->fs_info, 1628 "creating sysfs device link for devid %llu failed: %d", 1629 device->devid, ret); 1630 goto out; 1631 } 1632 } 1633 1634 init_completion(&device->kobj_unregister); 1635 ret = kobject_init_and_add(&device->devid_kobj, &devid_ktype, 1636 devinfo_kobj, "%llu", device->devid); 1637 if (ret) { 1638 kobject_put(&device->devid_kobj); 1639 btrfs_warn(device->fs_info, 1640 "devinfo init for devid %llu failed: %d", 1641 device->devid, ret); 1642 } 1643 1644 out: 1645 memalloc_nofs_restore(nofs_flag); 1646 return ret; 1647 } 1648 1649 static int btrfs_sysfs_add_fs_devices(struct btrfs_fs_devices *fs_devices) 1650 { 1651 int ret; 1652 struct btrfs_device *device; 1653 struct btrfs_fs_devices *seed; 1654 1655 list_for_each_entry(device, &fs_devices->devices, dev_list) { 1656 ret = btrfs_sysfs_add_device(device); 1657 if (ret) 1658 goto fail; 1659 } 1660 1661 list_for_each_entry(seed, &fs_devices->seed_list, seed_list) { 1662 list_for_each_entry(device, &seed->devices, dev_list) { 1663 ret = btrfs_sysfs_add_device(device); 1664 if (ret) 1665 goto fail; 1666 } 1667 } 1668 1669 return 0; 1670 1671 fail: 1672 btrfs_sysfs_remove_fs_devices(fs_devices); 1673 return ret; 1674 } 1675 1676 void btrfs_kobject_uevent(struct block_device *bdev, enum kobject_action action) 1677 { 1678 int ret; 1679 1680 ret = kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, action); 1681 if (ret) 1682 pr_warn("BTRFS: Sending event '%d' to kobject: '%s' (%p): failed\n", 1683 action, kobject_name(&disk_to_dev(bdev->bd_disk)->kobj), 1684 &disk_to_dev(bdev->bd_disk)->kobj); 1685 } 1686 1687 void btrfs_sysfs_update_sprout_fsid(struct btrfs_fs_devices *fs_devices) 1688 1689 { 1690 char fsid_buf[BTRFS_UUID_UNPARSED_SIZE]; 1691 1692 /* 1693 * Sprouting changes fsid of the mounted filesystem, rename the fsid 1694 * directory 1695 */ 1696 snprintf(fsid_buf, BTRFS_UUID_UNPARSED_SIZE, "%pU", fs_devices->fsid); 1697 if (kobject_rename(&fs_devices->fsid_kobj, fsid_buf)) 1698 btrfs_warn(fs_devices->fs_info, 1699 "sysfs: failed to create fsid for sprout"); 1700 } 1701 1702 void btrfs_sysfs_update_devid(struct btrfs_device *device) 1703 { 1704 char tmp[24]; 1705 1706 snprintf(tmp, sizeof(tmp), "%llu", device->devid); 1707 1708 if (kobject_rename(&device->devid_kobj, tmp)) 1709 btrfs_warn(device->fs_devices->fs_info, 1710 "sysfs: failed to update devid for %llu", 1711 device->devid); 1712 } 1713 1714 /* /sys/fs/btrfs/ entry */ 1715 static struct kset *btrfs_kset; 1716 1717 /* 1718 * Creates: 1719 * /sys/fs/btrfs/UUID 1720 * 1721 * Can be called by the device discovery thread. 1722 */ 1723 int btrfs_sysfs_add_fsid(struct btrfs_fs_devices *fs_devs) 1724 { 1725 int error; 1726 1727 init_completion(&fs_devs->kobj_unregister); 1728 fs_devs->fsid_kobj.kset = btrfs_kset; 1729 error = kobject_init_and_add(&fs_devs->fsid_kobj, &btrfs_ktype, NULL, 1730 "%pU", fs_devs->fsid); 1731 if (error) { 1732 kobject_put(&fs_devs->fsid_kobj); 1733 return error; 1734 } 1735 1736 fs_devs->devices_kobj = kobject_create_and_add("devices", 1737 &fs_devs->fsid_kobj); 1738 if (!fs_devs->devices_kobj) { 1739 btrfs_err(fs_devs->fs_info, 1740 "failed to init sysfs device interface"); 1741 btrfs_sysfs_remove_fsid(fs_devs); 1742 return -ENOMEM; 1743 } 1744 1745 fs_devs->devinfo_kobj = kobject_create_and_add("devinfo", 1746 &fs_devs->fsid_kobj); 1747 if (!fs_devs->devinfo_kobj) { 1748 btrfs_err(fs_devs->fs_info, 1749 "failed to init sysfs devinfo kobject"); 1750 btrfs_sysfs_remove_fsid(fs_devs); 1751 return -ENOMEM; 1752 } 1753 1754 return 0; 1755 } 1756 1757 int btrfs_sysfs_add_mounted(struct btrfs_fs_info *fs_info) 1758 { 1759 int error; 1760 struct btrfs_fs_devices *fs_devs = fs_info->fs_devices; 1761 struct kobject *fsid_kobj = &fs_devs->fsid_kobj; 1762 1763 error = btrfs_sysfs_add_fs_devices(fs_devs); 1764 if (error) 1765 return error; 1766 1767 error = sysfs_create_files(fsid_kobj, btrfs_attrs); 1768 if (error) { 1769 btrfs_sysfs_remove_fs_devices(fs_devs); 1770 return error; 1771 } 1772 1773 error = sysfs_create_group(fsid_kobj, 1774 &btrfs_feature_attr_group); 1775 if (error) 1776 goto failure; 1777 1778 #ifdef CONFIG_BTRFS_DEBUG 1779 fs_info->debug_kobj = kobject_create_and_add("debug", fsid_kobj); 1780 if (!fs_info->debug_kobj) { 1781 error = -ENOMEM; 1782 goto failure; 1783 } 1784 1785 error = sysfs_create_files(fs_info->debug_kobj, btrfs_debug_mount_attrs); 1786 if (error) 1787 goto failure; 1788 1789 /* Discard directory */ 1790 fs_info->discard_debug_kobj = kobject_create_and_add("discard", 1791 fs_info->debug_kobj); 1792 if (!fs_info->discard_debug_kobj) { 1793 error = -ENOMEM; 1794 goto failure; 1795 } 1796 1797 error = sysfs_create_files(fs_info->discard_debug_kobj, 1798 discard_debug_attrs); 1799 if (error) 1800 goto failure; 1801 #endif 1802 1803 error = addrm_unknown_feature_attrs(fs_info, true); 1804 if (error) 1805 goto failure; 1806 1807 error = sysfs_create_link(fsid_kobj, &fs_info->sb->s_bdi->dev->kobj, "bdi"); 1808 if (error) 1809 goto failure; 1810 1811 fs_info->space_info_kobj = kobject_create_and_add("allocation", 1812 fsid_kobj); 1813 if (!fs_info->space_info_kobj) { 1814 error = -ENOMEM; 1815 goto failure; 1816 } 1817 1818 error = sysfs_create_files(fs_info->space_info_kobj, allocation_attrs); 1819 if (error) 1820 goto failure; 1821 1822 return 0; 1823 failure: 1824 btrfs_sysfs_remove_mounted(fs_info); 1825 return error; 1826 } 1827 1828 static inline struct btrfs_fs_info *qgroup_kobj_to_fs_info(struct kobject *kobj) 1829 { 1830 return to_fs_info(kobj->parent->parent); 1831 } 1832 1833 #define QGROUP_ATTR(_member, _show_name) \ 1834 static ssize_t btrfs_qgroup_show_##_member(struct kobject *qgroup_kobj, \ 1835 struct kobj_attribute *a, \ 1836 char *buf) \ 1837 { \ 1838 struct btrfs_fs_info *fs_info = qgroup_kobj_to_fs_info(qgroup_kobj); \ 1839 struct btrfs_qgroup *qgroup = container_of(qgroup_kobj, \ 1840 struct btrfs_qgroup, kobj); \ 1841 return btrfs_show_u64(&qgroup->_member, &fs_info->qgroup_lock, buf); \ 1842 } \ 1843 BTRFS_ATTR(qgroup, _show_name, btrfs_qgroup_show_##_member) 1844 1845 #define QGROUP_RSV_ATTR(_name, _type) \ 1846 static ssize_t btrfs_qgroup_rsv_show_##_name(struct kobject *qgroup_kobj, \ 1847 struct kobj_attribute *a, \ 1848 char *buf) \ 1849 { \ 1850 struct btrfs_fs_info *fs_info = qgroup_kobj_to_fs_info(qgroup_kobj); \ 1851 struct btrfs_qgroup *qgroup = container_of(qgroup_kobj, \ 1852 struct btrfs_qgroup, kobj); \ 1853 return btrfs_show_u64(&qgroup->rsv.values[_type], \ 1854 &fs_info->qgroup_lock, buf); \ 1855 } \ 1856 BTRFS_ATTR(qgroup, rsv_##_name, btrfs_qgroup_rsv_show_##_name) 1857 1858 QGROUP_ATTR(rfer, referenced); 1859 QGROUP_ATTR(excl, exclusive); 1860 QGROUP_ATTR(max_rfer, max_referenced); 1861 QGROUP_ATTR(max_excl, max_exclusive); 1862 QGROUP_ATTR(lim_flags, limit_flags); 1863 QGROUP_RSV_ATTR(data, BTRFS_QGROUP_RSV_DATA); 1864 QGROUP_RSV_ATTR(meta_pertrans, BTRFS_QGROUP_RSV_META_PERTRANS); 1865 QGROUP_RSV_ATTR(meta_prealloc, BTRFS_QGROUP_RSV_META_PREALLOC); 1866 1867 /* 1868 * Qgroup information. 1869 * 1870 * Path: /sys/fs/btrfs/<uuid>/qgroups/<level>_<qgroupid>/ 1871 */ 1872 static struct attribute *qgroup_attrs[] = { 1873 BTRFS_ATTR_PTR(qgroup, referenced), 1874 BTRFS_ATTR_PTR(qgroup, exclusive), 1875 BTRFS_ATTR_PTR(qgroup, max_referenced), 1876 BTRFS_ATTR_PTR(qgroup, max_exclusive), 1877 BTRFS_ATTR_PTR(qgroup, limit_flags), 1878 BTRFS_ATTR_PTR(qgroup, rsv_data), 1879 BTRFS_ATTR_PTR(qgroup, rsv_meta_pertrans), 1880 BTRFS_ATTR_PTR(qgroup, rsv_meta_prealloc), 1881 NULL 1882 }; 1883 ATTRIBUTE_GROUPS(qgroup); 1884 1885 static void qgroup_release(struct kobject *kobj) 1886 { 1887 struct btrfs_qgroup *qgroup = container_of(kobj, struct btrfs_qgroup, kobj); 1888 1889 memset(&qgroup->kobj, 0, sizeof(*kobj)); 1890 } 1891 1892 static struct kobj_type qgroup_ktype = { 1893 .sysfs_ops = &kobj_sysfs_ops, 1894 .release = qgroup_release, 1895 .default_groups = qgroup_groups, 1896 }; 1897 1898 int btrfs_sysfs_add_one_qgroup(struct btrfs_fs_info *fs_info, 1899 struct btrfs_qgroup *qgroup) 1900 { 1901 struct kobject *qgroups_kobj = fs_info->qgroups_kobj; 1902 int ret; 1903 1904 if (test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state)) 1905 return 0; 1906 if (qgroup->kobj.state_initialized) 1907 return 0; 1908 if (!qgroups_kobj) 1909 return -EINVAL; 1910 1911 ret = kobject_init_and_add(&qgroup->kobj, &qgroup_ktype, qgroups_kobj, 1912 "%hu_%llu", btrfs_qgroup_level(qgroup->qgroupid), 1913 btrfs_qgroup_subvolid(qgroup->qgroupid)); 1914 if (ret < 0) 1915 kobject_put(&qgroup->kobj); 1916 1917 return ret; 1918 } 1919 1920 void btrfs_sysfs_del_qgroups(struct btrfs_fs_info *fs_info) 1921 { 1922 struct btrfs_qgroup *qgroup; 1923 struct btrfs_qgroup *next; 1924 1925 if (test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state)) 1926 return; 1927 1928 rbtree_postorder_for_each_entry_safe(qgroup, next, 1929 &fs_info->qgroup_tree, node) 1930 btrfs_sysfs_del_one_qgroup(fs_info, qgroup); 1931 if (fs_info->qgroups_kobj) { 1932 kobject_del(fs_info->qgroups_kobj); 1933 kobject_put(fs_info->qgroups_kobj); 1934 fs_info->qgroups_kobj = NULL; 1935 } 1936 } 1937 1938 /* Called when qgroups get initialized, thus there is no need for locking */ 1939 int btrfs_sysfs_add_qgroups(struct btrfs_fs_info *fs_info) 1940 { 1941 struct kobject *fsid_kobj = &fs_info->fs_devices->fsid_kobj; 1942 struct btrfs_qgroup *qgroup; 1943 struct btrfs_qgroup *next; 1944 int ret = 0; 1945 1946 if (test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state)) 1947 return 0; 1948 1949 ASSERT(fsid_kobj); 1950 if (fs_info->qgroups_kobj) 1951 return 0; 1952 1953 fs_info->qgroups_kobj = kobject_create_and_add("qgroups", fsid_kobj); 1954 if (!fs_info->qgroups_kobj) { 1955 ret = -ENOMEM; 1956 goto out; 1957 } 1958 rbtree_postorder_for_each_entry_safe(qgroup, next, 1959 &fs_info->qgroup_tree, node) { 1960 ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup); 1961 if (ret < 0) 1962 goto out; 1963 } 1964 1965 out: 1966 if (ret < 0) 1967 btrfs_sysfs_del_qgroups(fs_info); 1968 return ret; 1969 } 1970 1971 void btrfs_sysfs_del_one_qgroup(struct btrfs_fs_info *fs_info, 1972 struct btrfs_qgroup *qgroup) 1973 { 1974 if (test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state)) 1975 return; 1976 1977 if (qgroup->kobj.state_initialized) { 1978 kobject_del(&qgroup->kobj); 1979 kobject_put(&qgroup->kobj); 1980 } 1981 } 1982 1983 /* 1984 * Change per-fs features in /sys/fs/btrfs/UUID/features to match current 1985 * values in superblock. Call after any changes to incompat/compat_ro flags 1986 */ 1987 void btrfs_sysfs_feature_update(struct btrfs_fs_info *fs_info, 1988 u64 bit, enum btrfs_feature_set set) 1989 { 1990 struct btrfs_fs_devices *fs_devs; 1991 struct kobject *fsid_kobj; 1992 u64 __maybe_unused features; 1993 int __maybe_unused ret; 1994 1995 if (!fs_info) 1996 return; 1997 1998 /* 1999 * See 14e46e04958df74 and e410e34fad913dd, feature bit updates are not 2000 * safe when called from some contexts (eg. balance) 2001 */ 2002 features = get_features(fs_info, set); 2003 ASSERT(bit & supported_feature_masks[set]); 2004 2005 fs_devs = fs_info->fs_devices; 2006 fsid_kobj = &fs_devs->fsid_kobj; 2007 2008 if (!fsid_kobj->state_initialized) 2009 return; 2010 2011 /* 2012 * FIXME: this is too heavy to update just one value, ideally we'd like 2013 * to use sysfs_update_group but some refactoring is needed first. 2014 */ 2015 sysfs_remove_group(fsid_kobj, &btrfs_feature_attr_group); 2016 ret = sysfs_create_group(fsid_kobj, &btrfs_feature_attr_group); 2017 } 2018 2019 int __init btrfs_init_sysfs(void) 2020 { 2021 int ret; 2022 2023 btrfs_kset = kset_create_and_add("btrfs", NULL, fs_kobj); 2024 if (!btrfs_kset) 2025 return -ENOMEM; 2026 2027 init_feature_attrs(); 2028 ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_feature_attr_group); 2029 if (ret) 2030 goto out2; 2031 ret = sysfs_merge_group(&btrfs_kset->kobj, 2032 &btrfs_static_feature_attr_group); 2033 if (ret) 2034 goto out_remove_group; 2035 2036 #ifdef CONFIG_BTRFS_DEBUG 2037 ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_debug_feature_attr_group); 2038 if (ret) 2039 goto out2; 2040 #endif 2041 2042 return 0; 2043 2044 out_remove_group: 2045 sysfs_remove_group(&btrfs_kset->kobj, &btrfs_feature_attr_group); 2046 out2: 2047 kset_unregister(btrfs_kset); 2048 2049 return ret; 2050 } 2051 2052 void __cold btrfs_exit_sysfs(void) 2053 { 2054 sysfs_unmerge_group(&btrfs_kset->kobj, 2055 &btrfs_static_feature_attr_group); 2056 sysfs_remove_group(&btrfs_kset->kobj, &btrfs_feature_attr_group); 2057 #ifdef CONFIG_BTRFS_DEBUG 2058 sysfs_remove_group(&btrfs_kset->kobj, &btrfs_debug_feature_attr_group); 2059 #endif 2060 kset_unregister(btrfs_kset); 2061 } 2062 2063