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 "transaction.h" 18 #include "sysfs.h" 19 #include "volumes.h" 20 #include "space-info.h" 21 #include "block-group.h" 22 23 struct btrfs_feature_attr { 24 struct kobj_attribute kobj_attr; 25 enum btrfs_feature_set feature_set; 26 u64 feature_bit; 27 }; 28 29 /* For raid type sysfs entries */ 30 struct raid_kobject { 31 u64 flags; 32 struct kobject kobj; 33 }; 34 35 #define __INIT_KOBJ_ATTR(_name, _mode, _show, _store) \ 36 { \ 37 .attr = { .name = __stringify(_name), .mode = _mode }, \ 38 .show = _show, \ 39 .store = _store, \ 40 } 41 42 #define BTRFS_ATTR_RW(_prefix, _name, _show, _store) \ 43 static struct kobj_attribute btrfs_attr_##_prefix##_##_name = \ 44 __INIT_KOBJ_ATTR(_name, 0644, _show, _store) 45 46 #define BTRFS_ATTR(_prefix, _name, _show) \ 47 static struct kobj_attribute btrfs_attr_##_prefix##_##_name = \ 48 __INIT_KOBJ_ATTR(_name, 0444, _show, NULL) 49 50 #define BTRFS_ATTR_PTR(_prefix, _name) \ 51 (&btrfs_attr_##_prefix##_##_name.attr) 52 53 #define BTRFS_FEAT_ATTR(_name, _feature_set, _feature_prefix, _feature_bit) \ 54 static struct btrfs_feature_attr btrfs_attr_features_##_name = { \ 55 .kobj_attr = __INIT_KOBJ_ATTR(_name, S_IRUGO, \ 56 btrfs_feature_attr_show, \ 57 btrfs_feature_attr_store), \ 58 .feature_set = _feature_set, \ 59 .feature_bit = _feature_prefix ##_## _feature_bit, \ 60 } 61 #define BTRFS_FEAT_ATTR_PTR(_name) \ 62 (&btrfs_attr_features_##_name.kobj_attr.attr) 63 64 #define BTRFS_FEAT_ATTR_COMPAT(name, feature) \ 65 BTRFS_FEAT_ATTR(name, FEAT_COMPAT, BTRFS_FEATURE_COMPAT, feature) 66 #define BTRFS_FEAT_ATTR_COMPAT_RO(name, feature) \ 67 BTRFS_FEAT_ATTR(name, FEAT_COMPAT_RO, BTRFS_FEATURE_COMPAT_RO, feature) 68 #define BTRFS_FEAT_ATTR_INCOMPAT(name, feature) \ 69 BTRFS_FEAT_ATTR(name, FEAT_INCOMPAT, BTRFS_FEATURE_INCOMPAT, feature) 70 71 static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj); 72 static inline struct btrfs_fs_devices *to_fs_devs(struct kobject *kobj); 73 74 static struct btrfs_feature_attr *to_btrfs_feature_attr(struct kobj_attribute *a) 75 { 76 return container_of(a, struct btrfs_feature_attr, kobj_attr); 77 } 78 79 static struct kobj_attribute *attr_to_btrfs_attr(struct attribute *attr) 80 { 81 return container_of(attr, struct kobj_attribute, attr); 82 } 83 84 static struct btrfs_feature_attr *attr_to_btrfs_feature_attr( 85 struct attribute *attr) 86 { 87 return to_btrfs_feature_attr(attr_to_btrfs_attr(attr)); 88 } 89 90 static u64 get_features(struct btrfs_fs_info *fs_info, 91 enum btrfs_feature_set set) 92 { 93 struct btrfs_super_block *disk_super = fs_info->super_copy; 94 if (set == FEAT_COMPAT) 95 return btrfs_super_compat_flags(disk_super); 96 else if (set == FEAT_COMPAT_RO) 97 return btrfs_super_compat_ro_flags(disk_super); 98 else 99 return btrfs_super_incompat_flags(disk_super); 100 } 101 102 static void set_features(struct btrfs_fs_info *fs_info, 103 enum btrfs_feature_set set, u64 features) 104 { 105 struct btrfs_super_block *disk_super = fs_info->super_copy; 106 if (set == FEAT_COMPAT) 107 btrfs_set_super_compat_flags(disk_super, features); 108 else if (set == FEAT_COMPAT_RO) 109 btrfs_set_super_compat_ro_flags(disk_super, features); 110 else 111 btrfs_set_super_incompat_flags(disk_super, features); 112 } 113 114 static int can_modify_feature(struct btrfs_feature_attr *fa) 115 { 116 int val = 0; 117 u64 set, clear; 118 switch (fa->feature_set) { 119 case FEAT_COMPAT: 120 set = BTRFS_FEATURE_COMPAT_SAFE_SET; 121 clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR; 122 break; 123 case FEAT_COMPAT_RO: 124 set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET; 125 clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR; 126 break; 127 case FEAT_INCOMPAT: 128 set = BTRFS_FEATURE_INCOMPAT_SAFE_SET; 129 clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR; 130 break; 131 default: 132 pr_warn("btrfs: sysfs: unknown feature set %d\n", 133 fa->feature_set); 134 return 0; 135 } 136 137 if (set & fa->feature_bit) 138 val |= 1; 139 if (clear & fa->feature_bit) 140 val |= 2; 141 142 return val; 143 } 144 145 static ssize_t btrfs_feature_attr_show(struct kobject *kobj, 146 struct kobj_attribute *a, char *buf) 147 { 148 int val = 0; 149 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 150 struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a); 151 if (fs_info) { 152 u64 features = get_features(fs_info, fa->feature_set); 153 if (features & fa->feature_bit) 154 val = 1; 155 } else 156 val = can_modify_feature(fa); 157 158 return snprintf(buf, PAGE_SIZE, "%d\n", val); 159 } 160 161 static ssize_t btrfs_feature_attr_store(struct kobject *kobj, 162 struct kobj_attribute *a, 163 const char *buf, size_t count) 164 { 165 struct btrfs_fs_info *fs_info; 166 struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a); 167 u64 features, set, clear; 168 unsigned long val; 169 int ret; 170 171 fs_info = to_fs_info(kobj); 172 if (!fs_info) 173 return -EPERM; 174 175 if (sb_rdonly(fs_info->sb)) 176 return -EROFS; 177 178 ret = kstrtoul(skip_spaces(buf), 0, &val); 179 if (ret) 180 return ret; 181 182 if (fa->feature_set == FEAT_COMPAT) { 183 set = BTRFS_FEATURE_COMPAT_SAFE_SET; 184 clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR; 185 } else if (fa->feature_set == FEAT_COMPAT_RO) { 186 set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET; 187 clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR; 188 } else { 189 set = BTRFS_FEATURE_INCOMPAT_SAFE_SET; 190 clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR; 191 } 192 193 features = get_features(fs_info, fa->feature_set); 194 195 /* Nothing to do */ 196 if ((val && (features & fa->feature_bit)) || 197 (!val && !(features & fa->feature_bit))) 198 return count; 199 200 if ((val && !(set & fa->feature_bit)) || 201 (!val && !(clear & fa->feature_bit))) { 202 btrfs_info(fs_info, 203 "%sabling feature %s on mounted fs is not supported.", 204 val ? "En" : "Dis", fa->kobj_attr.attr.name); 205 return -EPERM; 206 } 207 208 btrfs_info(fs_info, "%s %s feature flag", 209 val ? "Setting" : "Clearing", fa->kobj_attr.attr.name); 210 211 spin_lock(&fs_info->super_lock); 212 features = get_features(fs_info, fa->feature_set); 213 if (val) 214 features |= fa->feature_bit; 215 else 216 features &= ~fa->feature_bit; 217 set_features(fs_info, fa->feature_set, features); 218 spin_unlock(&fs_info->super_lock); 219 220 /* 221 * We don't want to do full transaction commit from inside sysfs 222 */ 223 btrfs_set_pending(fs_info, COMMIT); 224 wake_up_process(fs_info->transaction_kthread); 225 226 return count; 227 } 228 229 static umode_t btrfs_feature_visible(struct kobject *kobj, 230 struct attribute *attr, int unused) 231 { 232 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 233 umode_t mode = attr->mode; 234 235 if (fs_info) { 236 struct btrfs_feature_attr *fa; 237 u64 features; 238 239 fa = attr_to_btrfs_feature_attr(attr); 240 features = get_features(fs_info, fa->feature_set); 241 242 if (can_modify_feature(fa)) 243 mode |= S_IWUSR; 244 else if (!(features & fa->feature_bit)) 245 mode = 0; 246 } 247 248 return mode; 249 } 250 251 BTRFS_FEAT_ATTR_INCOMPAT(mixed_backref, MIXED_BACKREF); 252 BTRFS_FEAT_ATTR_INCOMPAT(default_subvol, DEFAULT_SUBVOL); 253 BTRFS_FEAT_ATTR_INCOMPAT(mixed_groups, MIXED_GROUPS); 254 BTRFS_FEAT_ATTR_INCOMPAT(compress_lzo, COMPRESS_LZO); 255 BTRFS_FEAT_ATTR_INCOMPAT(compress_zstd, COMPRESS_ZSTD); 256 BTRFS_FEAT_ATTR_INCOMPAT(big_metadata, BIG_METADATA); 257 BTRFS_FEAT_ATTR_INCOMPAT(extended_iref, EXTENDED_IREF); 258 BTRFS_FEAT_ATTR_INCOMPAT(raid56, RAID56); 259 BTRFS_FEAT_ATTR_INCOMPAT(skinny_metadata, SKINNY_METADATA); 260 BTRFS_FEAT_ATTR_INCOMPAT(no_holes, NO_HOLES); 261 BTRFS_FEAT_ATTR_INCOMPAT(metadata_uuid, METADATA_UUID); 262 BTRFS_FEAT_ATTR_COMPAT_RO(free_space_tree, FREE_SPACE_TREE); 263 BTRFS_FEAT_ATTR_INCOMPAT(raid1c34, RAID1C34); 264 265 static struct attribute *btrfs_supported_feature_attrs[] = { 266 BTRFS_FEAT_ATTR_PTR(mixed_backref), 267 BTRFS_FEAT_ATTR_PTR(default_subvol), 268 BTRFS_FEAT_ATTR_PTR(mixed_groups), 269 BTRFS_FEAT_ATTR_PTR(compress_lzo), 270 BTRFS_FEAT_ATTR_PTR(compress_zstd), 271 BTRFS_FEAT_ATTR_PTR(big_metadata), 272 BTRFS_FEAT_ATTR_PTR(extended_iref), 273 BTRFS_FEAT_ATTR_PTR(raid56), 274 BTRFS_FEAT_ATTR_PTR(skinny_metadata), 275 BTRFS_FEAT_ATTR_PTR(no_holes), 276 BTRFS_FEAT_ATTR_PTR(metadata_uuid), 277 BTRFS_FEAT_ATTR_PTR(free_space_tree), 278 BTRFS_FEAT_ATTR_PTR(raid1c34), 279 NULL 280 }; 281 282 /* 283 * Features which depend on feature bits and may differ between each fs. 284 * 285 * /sys/fs/btrfs/features lists all available features of this kernel while 286 * /sys/fs/btrfs/UUID/features shows features of the fs which are enabled or 287 * can be changed online. 288 */ 289 static const struct attribute_group btrfs_feature_attr_group = { 290 .name = "features", 291 .is_visible = btrfs_feature_visible, 292 .attrs = btrfs_supported_feature_attrs, 293 }; 294 295 static ssize_t rmdir_subvol_show(struct kobject *kobj, 296 struct kobj_attribute *ka, char *buf) 297 { 298 return snprintf(buf, PAGE_SIZE, "0\n"); 299 } 300 BTRFS_ATTR(static_feature, rmdir_subvol, rmdir_subvol_show); 301 302 static ssize_t supported_checksums_show(struct kobject *kobj, 303 struct kobj_attribute *a, char *buf) 304 { 305 ssize_t ret = 0; 306 int i; 307 308 for (i = 0; i < btrfs_get_num_csums(); i++) { 309 /* 310 * This "trick" only works as long as 'enum btrfs_csum_type' has 311 * no holes in it 312 */ 313 ret += snprintf(buf + ret, PAGE_SIZE - ret, "%s%s", 314 (i == 0 ? "" : " "), btrfs_super_csum_name(i)); 315 316 } 317 318 ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n"); 319 return ret; 320 } 321 BTRFS_ATTR(static_feature, supported_checksums, supported_checksums_show); 322 323 static struct attribute *btrfs_supported_static_feature_attrs[] = { 324 BTRFS_ATTR_PTR(static_feature, rmdir_subvol), 325 BTRFS_ATTR_PTR(static_feature, supported_checksums), 326 NULL 327 }; 328 329 /* 330 * Features which only depend on kernel version. 331 * 332 * These are listed in /sys/fs/btrfs/features along with 333 * btrfs_feature_attr_group 334 */ 335 static const struct attribute_group btrfs_static_feature_attr_group = { 336 .name = "features", 337 .attrs = btrfs_supported_static_feature_attrs, 338 }; 339 340 #ifdef CONFIG_BTRFS_DEBUG 341 342 /* 343 * Discard statistics and tunables 344 */ 345 #define discard_to_fs_info(_kobj) to_fs_info((_kobj)->parent->parent) 346 347 static ssize_t btrfs_discardable_bytes_show(struct kobject *kobj, 348 struct kobj_attribute *a, 349 char *buf) 350 { 351 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 352 353 return snprintf(buf, PAGE_SIZE, "%lld\n", 354 atomic64_read(&fs_info->discard_ctl.discardable_bytes)); 355 } 356 BTRFS_ATTR(discard, discardable_bytes, btrfs_discardable_bytes_show); 357 358 static ssize_t btrfs_discardable_extents_show(struct kobject *kobj, 359 struct kobj_attribute *a, 360 char *buf) 361 { 362 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 363 364 return snprintf(buf, PAGE_SIZE, "%d\n", 365 atomic_read(&fs_info->discard_ctl.discardable_extents)); 366 } 367 BTRFS_ATTR(discard, discardable_extents, btrfs_discardable_extents_show); 368 369 static ssize_t btrfs_discard_bitmap_bytes_show(struct kobject *kobj, 370 struct kobj_attribute *a, 371 char *buf) 372 { 373 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 374 375 return snprintf(buf, PAGE_SIZE, "%lld\n", 376 fs_info->discard_ctl.discard_bitmap_bytes); 377 } 378 BTRFS_ATTR(discard, discard_bitmap_bytes, btrfs_discard_bitmap_bytes_show); 379 380 static ssize_t btrfs_discard_bytes_saved_show(struct kobject *kobj, 381 struct kobj_attribute *a, 382 char *buf) 383 { 384 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 385 386 return snprintf(buf, PAGE_SIZE, "%lld\n", 387 atomic64_read(&fs_info->discard_ctl.discard_bytes_saved)); 388 } 389 BTRFS_ATTR(discard, discard_bytes_saved, btrfs_discard_bytes_saved_show); 390 391 static ssize_t btrfs_discard_extent_bytes_show(struct kobject *kobj, 392 struct kobj_attribute *a, 393 char *buf) 394 { 395 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 396 397 return snprintf(buf, PAGE_SIZE, "%lld\n", 398 fs_info->discard_ctl.discard_extent_bytes); 399 } 400 BTRFS_ATTR(discard, discard_extent_bytes, btrfs_discard_extent_bytes_show); 401 402 static ssize_t btrfs_discard_iops_limit_show(struct kobject *kobj, 403 struct kobj_attribute *a, 404 char *buf) 405 { 406 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 407 408 return snprintf(buf, PAGE_SIZE, "%u\n", 409 READ_ONCE(fs_info->discard_ctl.iops_limit)); 410 } 411 412 static ssize_t btrfs_discard_iops_limit_store(struct kobject *kobj, 413 struct kobj_attribute *a, 414 const char *buf, size_t len) 415 { 416 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 417 struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl; 418 u32 iops_limit; 419 int ret; 420 421 ret = kstrtou32(buf, 10, &iops_limit); 422 if (ret) 423 return -EINVAL; 424 425 WRITE_ONCE(discard_ctl->iops_limit, iops_limit); 426 427 return len; 428 } 429 BTRFS_ATTR_RW(discard, iops_limit, btrfs_discard_iops_limit_show, 430 btrfs_discard_iops_limit_store); 431 432 static ssize_t btrfs_discard_kbps_limit_show(struct kobject *kobj, 433 struct kobj_attribute *a, 434 char *buf) 435 { 436 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 437 438 return snprintf(buf, PAGE_SIZE, "%u\n", 439 READ_ONCE(fs_info->discard_ctl.kbps_limit)); 440 } 441 442 static ssize_t btrfs_discard_kbps_limit_store(struct kobject *kobj, 443 struct kobj_attribute *a, 444 const char *buf, size_t len) 445 { 446 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 447 struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl; 448 u32 kbps_limit; 449 int ret; 450 451 ret = kstrtou32(buf, 10, &kbps_limit); 452 if (ret) 453 return -EINVAL; 454 455 WRITE_ONCE(discard_ctl->kbps_limit, kbps_limit); 456 457 return len; 458 } 459 BTRFS_ATTR_RW(discard, kbps_limit, btrfs_discard_kbps_limit_show, 460 btrfs_discard_kbps_limit_store); 461 462 static ssize_t btrfs_discard_max_discard_size_show(struct kobject *kobj, 463 struct kobj_attribute *a, 464 char *buf) 465 { 466 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 467 468 return snprintf(buf, PAGE_SIZE, "%llu\n", 469 READ_ONCE(fs_info->discard_ctl.max_discard_size)); 470 } 471 472 static ssize_t btrfs_discard_max_discard_size_store(struct kobject *kobj, 473 struct kobj_attribute *a, 474 const char *buf, size_t len) 475 { 476 struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 477 struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl; 478 u64 max_discard_size; 479 int ret; 480 481 ret = kstrtou64(buf, 10, &max_discard_size); 482 if (ret) 483 return -EINVAL; 484 485 WRITE_ONCE(discard_ctl->max_discard_size, max_discard_size); 486 487 return len; 488 } 489 BTRFS_ATTR_RW(discard, max_discard_size, btrfs_discard_max_discard_size_show, 490 btrfs_discard_max_discard_size_store); 491 492 static const struct attribute *discard_debug_attrs[] = { 493 BTRFS_ATTR_PTR(discard, discardable_bytes), 494 BTRFS_ATTR_PTR(discard, discardable_extents), 495 BTRFS_ATTR_PTR(discard, discard_bitmap_bytes), 496 BTRFS_ATTR_PTR(discard, discard_bytes_saved), 497 BTRFS_ATTR_PTR(discard, discard_extent_bytes), 498 BTRFS_ATTR_PTR(discard, iops_limit), 499 BTRFS_ATTR_PTR(discard, kbps_limit), 500 BTRFS_ATTR_PTR(discard, max_discard_size), 501 NULL, 502 }; 503 504 /* 505 * Runtime debugging exported via sysfs 506 * 507 * /sys/fs/btrfs/debug - applies to module or all filesystems 508 * /sys/fs/btrfs/UUID - applies only to the given filesystem 509 */ 510 static const struct attribute *btrfs_debug_mount_attrs[] = { 511 NULL, 512 }; 513 514 static struct attribute *btrfs_debug_feature_attrs[] = { 515 NULL 516 }; 517 518 static const struct attribute_group btrfs_debug_feature_attr_group = { 519 .name = "debug", 520 .attrs = btrfs_debug_feature_attrs, 521 }; 522 523 #endif 524 525 static ssize_t btrfs_show_u64(u64 *value_ptr, spinlock_t *lock, char *buf) 526 { 527 u64 val; 528 if (lock) 529 spin_lock(lock); 530 val = *value_ptr; 531 if (lock) 532 spin_unlock(lock); 533 return snprintf(buf, PAGE_SIZE, "%llu\n", val); 534 } 535 536 static ssize_t global_rsv_size_show(struct kobject *kobj, 537 struct kobj_attribute *ka, char *buf) 538 { 539 struct btrfs_fs_info *fs_info = to_fs_info(kobj->parent); 540 struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv; 541 return btrfs_show_u64(&block_rsv->size, &block_rsv->lock, buf); 542 } 543 BTRFS_ATTR(allocation, global_rsv_size, global_rsv_size_show); 544 545 static ssize_t global_rsv_reserved_show(struct kobject *kobj, 546 struct kobj_attribute *a, char *buf) 547 { 548 struct btrfs_fs_info *fs_info = to_fs_info(kobj->parent); 549 struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv; 550 return btrfs_show_u64(&block_rsv->reserved, &block_rsv->lock, buf); 551 } 552 BTRFS_ATTR(allocation, global_rsv_reserved, global_rsv_reserved_show); 553 554 #define to_space_info(_kobj) container_of(_kobj, struct btrfs_space_info, kobj) 555 #define to_raid_kobj(_kobj) container_of(_kobj, struct raid_kobject, kobj) 556 557 static ssize_t raid_bytes_show(struct kobject *kobj, 558 struct kobj_attribute *attr, char *buf); 559 BTRFS_ATTR(raid, total_bytes, raid_bytes_show); 560 BTRFS_ATTR(raid, used_bytes, raid_bytes_show); 561 562 static ssize_t raid_bytes_show(struct kobject *kobj, 563 struct kobj_attribute *attr, char *buf) 564 565 { 566 struct btrfs_space_info *sinfo = to_space_info(kobj->parent); 567 struct btrfs_block_group *block_group; 568 int index = btrfs_bg_flags_to_raid_index(to_raid_kobj(kobj)->flags); 569 u64 val = 0; 570 571 down_read(&sinfo->groups_sem); 572 list_for_each_entry(block_group, &sinfo->block_groups[index], list) { 573 if (&attr->attr == BTRFS_ATTR_PTR(raid, total_bytes)) 574 val += block_group->length; 575 else 576 val += block_group->used; 577 } 578 up_read(&sinfo->groups_sem); 579 return snprintf(buf, PAGE_SIZE, "%llu\n", val); 580 } 581 582 static struct attribute *raid_attrs[] = { 583 BTRFS_ATTR_PTR(raid, total_bytes), 584 BTRFS_ATTR_PTR(raid, used_bytes), 585 NULL 586 }; 587 ATTRIBUTE_GROUPS(raid); 588 589 static void release_raid_kobj(struct kobject *kobj) 590 { 591 kfree(to_raid_kobj(kobj)); 592 } 593 594 static struct kobj_type btrfs_raid_ktype = { 595 .sysfs_ops = &kobj_sysfs_ops, 596 .release = release_raid_kobj, 597 .default_groups = raid_groups, 598 }; 599 600 #define SPACE_INFO_ATTR(field) \ 601 static ssize_t btrfs_space_info_show_##field(struct kobject *kobj, \ 602 struct kobj_attribute *a, \ 603 char *buf) \ 604 { \ 605 struct btrfs_space_info *sinfo = to_space_info(kobj); \ 606 return btrfs_show_u64(&sinfo->field, &sinfo->lock, buf); \ 607 } \ 608 BTRFS_ATTR(space_info, field, btrfs_space_info_show_##field) 609 610 static ssize_t btrfs_space_info_show_total_bytes_pinned(struct kobject *kobj, 611 struct kobj_attribute *a, 612 char *buf) 613 { 614 struct btrfs_space_info *sinfo = to_space_info(kobj); 615 s64 val = percpu_counter_sum(&sinfo->total_bytes_pinned); 616 return snprintf(buf, PAGE_SIZE, "%lld\n", val); 617 } 618 619 SPACE_INFO_ATTR(flags); 620 SPACE_INFO_ATTR(total_bytes); 621 SPACE_INFO_ATTR(bytes_used); 622 SPACE_INFO_ATTR(bytes_pinned); 623 SPACE_INFO_ATTR(bytes_reserved); 624 SPACE_INFO_ATTR(bytes_may_use); 625 SPACE_INFO_ATTR(bytes_readonly); 626 SPACE_INFO_ATTR(disk_used); 627 SPACE_INFO_ATTR(disk_total); 628 BTRFS_ATTR(space_info, total_bytes_pinned, 629 btrfs_space_info_show_total_bytes_pinned); 630 631 static struct attribute *space_info_attrs[] = { 632 BTRFS_ATTR_PTR(space_info, flags), 633 BTRFS_ATTR_PTR(space_info, total_bytes), 634 BTRFS_ATTR_PTR(space_info, bytes_used), 635 BTRFS_ATTR_PTR(space_info, bytes_pinned), 636 BTRFS_ATTR_PTR(space_info, bytes_reserved), 637 BTRFS_ATTR_PTR(space_info, bytes_may_use), 638 BTRFS_ATTR_PTR(space_info, bytes_readonly), 639 BTRFS_ATTR_PTR(space_info, disk_used), 640 BTRFS_ATTR_PTR(space_info, disk_total), 641 BTRFS_ATTR_PTR(space_info, total_bytes_pinned), 642 NULL, 643 }; 644 ATTRIBUTE_GROUPS(space_info); 645 646 static void space_info_release(struct kobject *kobj) 647 { 648 struct btrfs_space_info *sinfo = to_space_info(kobj); 649 percpu_counter_destroy(&sinfo->total_bytes_pinned); 650 kfree(sinfo); 651 } 652 653 static struct kobj_type space_info_ktype = { 654 .sysfs_ops = &kobj_sysfs_ops, 655 .release = space_info_release, 656 .default_groups = space_info_groups, 657 }; 658 659 static const struct attribute *allocation_attrs[] = { 660 BTRFS_ATTR_PTR(allocation, global_rsv_reserved), 661 BTRFS_ATTR_PTR(allocation, global_rsv_size), 662 NULL, 663 }; 664 665 static ssize_t btrfs_label_show(struct kobject *kobj, 666 struct kobj_attribute *a, char *buf) 667 { 668 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 669 char *label = fs_info->super_copy->label; 670 ssize_t ret; 671 672 spin_lock(&fs_info->super_lock); 673 ret = snprintf(buf, PAGE_SIZE, label[0] ? "%s\n" : "%s", label); 674 spin_unlock(&fs_info->super_lock); 675 676 return ret; 677 } 678 679 static ssize_t btrfs_label_store(struct kobject *kobj, 680 struct kobj_attribute *a, 681 const char *buf, size_t len) 682 { 683 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 684 size_t p_len; 685 686 if (!fs_info) 687 return -EPERM; 688 689 if (sb_rdonly(fs_info->sb)) 690 return -EROFS; 691 692 /* 693 * p_len is the len until the first occurrence of either 694 * '\n' or '\0' 695 */ 696 p_len = strcspn(buf, "\n"); 697 698 if (p_len >= BTRFS_LABEL_SIZE) 699 return -EINVAL; 700 701 spin_lock(&fs_info->super_lock); 702 memset(fs_info->super_copy->label, 0, BTRFS_LABEL_SIZE); 703 memcpy(fs_info->super_copy->label, buf, p_len); 704 spin_unlock(&fs_info->super_lock); 705 706 /* 707 * We don't want to do full transaction commit from inside sysfs 708 */ 709 btrfs_set_pending(fs_info, COMMIT); 710 wake_up_process(fs_info->transaction_kthread); 711 712 return len; 713 } 714 BTRFS_ATTR_RW(, label, btrfs_label_show, btrfs_label_store); 715 716 static ssize_t btrfs_nodesize_show(struct kobject *kobj, 717 struct kobj_attribute *a, char *buf) 718 { 719 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 720 721 return snprintf(buf, PAGE_SIZE, "%u\n", fs_info->super_copy->nodesize); 722 } 723 724 BTRFS_ATTR(, nodesize, btrfs_nodesize_show); 725 726 static ssize_t btrfs_sectorsize_show(struct kobject *kobj, 727 struct kobj_attribute *a, char *buf) 728 { 729 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 730 731 return snprintf(buf, PAGE_SIZE, "%u\n", 732 fs_info->super_copy->sectorsize); 733 } 734 735 BTRFS_ATTR(, sectorsize, btrfs_sectorsize_show); 736 737 static ssize_t btrfs_clone_alignment_show(struct kobject *kobj, 738 struct kobj_attribute *a, char *buf) 739 { 740 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 741 742 return snprintf(buf, PAGE_SIZE, "%u\n", 743 fs_info->super_copy->sectorsize); 744 } 745 746 BTRFS_ATTR(, clone_alignment, btrfs_clone_alignment_show); 747 748 static ssize_t quota_override_show(struct kobject *kobj, 749 struct kobj_attribute *a, char *buf) 750 { 751 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 752 int quota_override; 753 754 quota_override = test_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags); 755 return snprintf(buf, PAGE_SIZE, "%d\n", quota_override); 756 } 757 758 static ssize_t quota_override_store(struct kobject *kobj, 759 struct kobj_attribute *a, 760 const char *buf, size_t len) 761 { 762 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 763 unsigned long knob; 764 int err; 765 766 if (!fs_info) 767 return -EPERM; 768 769 if (!capable(CAP_SYS_RESOURCE)) 770 return -EPERM; 771 772 err = kstrtoul(buf, 10, &knob); 773 if (err) 774 return err; 775 if (knob > 1) 776 return -EINVAL; 777 778 if (knob) 779 set_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags); 780 else 781 clear_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags); 782 783 return len; 784 } 785 786 BTRFS_ATTR_RW(, quota_override, quota_override_show, quota_override_store); 787 788 static ssize_t btrfs_metadata_uuid_show(struct kobject *kobj, 789 struct kobj_attribute *a, char *buf) 790 { 791 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 792 793 return snprintf(buf, PAGE_SIZE, "%pU\n", 794 fs_info->fs_devices->metadata_uuid); 795 } 796 797 BTRFS_ATTR(, metadata_uuid, btrfs_metadata_uuid_show); 798 799 static ssize_t btrfs_checksum_show(struct kobject *kobj, 800 struct kobj_attribute *a, char *buf) 801 { 802 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 803 u16 csum_type = btrfs_super_csum_type(fs_info->super_copy); 804 805 return snprintf(buf, PAGE_SIZE, "%s (%s)\n", 806 btrfs_super_csum_name(csum_type), 807 crypto_shash_driver_name(fs_info->csum_shash)); 808 } 809 810 BTRFS_ATTR(, checksum, btrfs_checksum_show); 811 812 static const struct attribute *btrfs_attrs[] = { 813 BTRFS_ATTR_PTR(, label), 814 BTRFS_ATTR_PTR(, nodesize), 815 BTRFS_ATTR_PTR(, sectorsize), 816 BTRFS_ATTR_PTR(, clone_alignment), 817 BTRFS_ATTR_PTR(, quota_override), 818 BTRFS_ATTR_PTR(, metadata_uuid), 819 BTRFS_ATTR_PTR(, checksum), 820 NULL, 821 }; 822 823 static void btrfs_release_fsid_kobj(struct kobject *kobj) 824 { 825 struct btrfs_fs_devices *fs_devs = to_fs_devs(kobj); 826 827 memset(&fs_devs->fsid_kobj, 0, sizeof(struct kobject)); 828 complete(&fs_devs->kobj_unregister); 829 } 830 831 static struct kobj_type btrfs_ktype = { 832 .sysfs_ops = &kobj_sysfs_ops, 833 .release = btrfs_release_fsid_kobj, 834 }; 835 836 static inline struct btrfs_fs_devices *to_fs_devs(struct kobject *kobj) 837 { 838 if (kobj->ktype != &btrfs_ktype) 839 return NULL; 840 return container_of(kobj, struct btrfs_fs_devices, fsid_kobj); 841 } 842 843 static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj) 844 { 845 if (kobj->ktype != &btrfs_ktype) 846 return NULL; 847 return to_fs_devs(kobj)->fs_info; 848 } 849 850 #define NUM_FEATURE_BITS 64 851 #define BTRFS_FEATURE_NAME_MAX 13 852 static char btrfs_unknown_feature_names[FEAT_MAX][NUM_FEATURE_BITS][BTRFS_FEATURE_NAME_MAX]; 853 static struct btrfs_feature_attr btrfs_feature_attrs[FEAT_MAX][NUM_FEATURE_BITS]; 854 855 static const u64 supported_feature_masks[FEAT_MAX] = { 856 [FEAT_COMPAT] = BTRFS_FEATURE_COMPAT_SUPP, 857 [FEAT_COMPAT_RO] = BTRFS_FEATURE_COMPAT_RO_SUPP, 858 [FEAT_INCOMPAT] = BTRFS_FEATURE_INCOMPAT_SUPP, 859 }; 860 861 static int addrm_unknown_feature_attrs(struct btrfs_fs_info *fs_info, bool add) 862 { 863 int set; 864 865 for (set = 0; set < FEAT_MAX; set++) { 866 int i; 867 struct attribute *attrs[2]; 868 struct attribute_group agroup = { 869 .name = "features", 870 .attrs = attrs, 871 }; 872 u64 features = get_features(fs_info, set); 873 features &= ~supported_feature_masks[set]; 874 875 if (!features) 876 continue; 877 878 attrs[1] = NULL; 879 for (i = 0; i < NUM_FEATURE_BITS; i++) { 880 struct btrfs_feature_attr *fa; 881 882 if (!(features & (1ULL << i))) 883 continue; 884 885 fa = &btrfs_feature_attrs[set][i]; 886 attrs[0] = &fa->kobj_attr.attr; 887 if (add) { 888 int ret; 889 ret = sysfs_merge_group(&fs_info->fs_devices->fsid_kobj, 890 &agroup); 891 if (ret) 892 return ret; 893 } else 894 sysfs_unmerge_group(&fs_info->fs_devices->fsid_kobj, 895 &agroup); 896 } 897 898 } 899 return 0; 900 } 901 902 static void __btrfs_sysfs_remove_fsid(struct btrfs_fs_devices *fs_devs) 903 { 904 if (fs_devs->devices_kobj) { 905 kobject_del(fs_devs->devices_kobj); 906 kobject_put(fs_devs->devices_kobj); 907 fs_devs->devices_kobj = NULL; 908 } 909 910 if (fs_devs->fsid_kobj.state_initialized) { 911 kobject_del(&fs_devs->fsid_kobj); 912 kobject_put(&fs_devs->fsid_kobj); 913 wait_for_completion(&fs_devs->kobj_unregister); 914 } 915 } 916 917 /* when fs_devs is NULL it will remove all fsid kobject */ 918 void btrfs_sysfs_remove_fsid(struct btrfs_fs_devices *fs_devs) 919 { 920 struct list_head *fs_uuids = btrfs_get_fs_uuids(); 921 922 if (fs_devs) { 923 __btrfs_sysfs_remove_fsid(fs_devs); 924 return; 925 } 926 927 list_for_each_entry(fs_devs, fs_uuids, fs_list) { 928 __btrfs_sysfs_remove_fsid(fs_devs); 929 } 930 } 931 932 void btrfs_sysfs_remove_mounted(struct btrfs_fs_info *fs_info) 933 { 934 btrfs_reset_fs_info_ptr(fs_info); 935 936 if (fs_info->space_info_kobj) { 937 sysfs_remove_files(fs_info->space_info_kobj, allocation_attrs); 938 kobject_del(fs_info->space_info_kobj); 939 kobject_put(fs_info->space_info_kobj); 940 } 941 #ifdef CONFIG_BTRFS_DEBUG 942 if (fs_info->discard_debug_kobj) { 943 sysfs_remove_files(fs_info->discard_debug_kobj, 944 discard_debug_attrs); 945 kobject_del(fs_info->discard_debug_kobj); 946 kobject_put(fs_info->discard_debug_kobj); 947 } 948 if (fs_info->debug_kobj) { 949 sysfs_remove_files(fs_info->debug_kobj, btrfs_debug_mount_attrs); 950 kobject_del(fs_info->debug_kobj); 951 kobject_put(fs_info->debug_kobj); 952 } 953 #endif 954 addrm_unknown_feature_attrs(fs_info, false); 955 sysfs_remove_group(&fs_info->fs_devices->fsid_kobj, &btrfs_feature_attr_group); 956 sysfs_remove_files(&fs_info->fs_devices->fsid_kobj, btrfs_attrs); 957 btrfs_sysfs_rm_device_link(fs_info->fs_devices, NULL); 958 } 959 960 static const char * const btrfs_feature_set_names[FEAT_MAX] = { 961 [FEAT_COMPAT] = "compat", 962 [FEAT_COMPAT_RO] = "compat_ro", 963 [FEAT_INCOMPAT] = "incompat", 964 }; 965 966 const char * const btrfs_feature_set_name(enum btrfs_feature_set set) 967 { 968 return btrfs_feature_set_names[set]; 969 } 970 971 char *btrfs_printable_features(enum btrfs_feature_set set, u64 flags) 972 { 973 size_t bufsize = 4096; /* safe max, 64 names * 64 bytes */ 974 int len = 0; 975 int i; 976 char *str; 977 978 str = kmalloc(bufsize, GFP_KERNEL); 979 if (!str) 980 return str; 981 982 for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) { 983 const char *name; 984 985 if (!(flags & (1ULL << i))) 986 continue; 987 988 name = btrfs_feature_attrs[set][i].kobj_attr.attr.name; 989 len += snprintf(str + len, bufsize - len, "%s%s", 990 len ? "," : "", name); 991 } 992 993 return str; 994 } 995 996 static void init_feature_attrs(void) 997 { 998 struct btrfs_feature_attr *fa; 999 int set, i; 1000 1001 BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names) != 1002 ARRAY_SIZE(btrfs_feature_attrs)); 1003 BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names[0]) != 1004 ARRAY_SIZE(btrfs_feature_attrs[0])); 1005 1006 memset(btrfs_feature_attrs, 0, sizeof(btrfs_feature_attrs)); 1007 memset(btrfs_unknown_feature_names, 0, 1008 sizeof(btrfs_unknown_feature_names)); 1009 1010 for (i = 0; btrfs_supported_feature_attrs[i]; i++) { 1011 struct btrfs_feature_attr *sfa; 1012 struct attribute *a = btrfs_supported_feature_attrs[i]; 1013 int bit; 1014 sfa = attr_to_btrfs_feature_attr(a); 1015 bit = ilog2(sfa->feature_bit); 1016 fa = &btrfs_feature_attrs[sfa->feature_set][bit]; 1017 1018 fa->kobj_attr.attr.name = sfa->kobj_attr.attr.name; 1019 } 1020 1021 for (set = 0; set < FEAT_MAX; set++) { 1022 for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) { 1023 char *name = btrfs_unknown_feature_names[set][i]; 1024 fa = &btrfs_feature_attrs[set][i]; 1025 1026 if (fa->kobj_attr.attr.name) 1027 continue; 1028 1029 snprintf(name, BTRFS_FEATURE_NAME_MAX, "%s:%u", 1030 btrfs_feature_set_names[set], i); 1031 1032 fa->kobj_attr.attr.name = name; 1033 fa->kobj_attr.attr.mode = S_IRUGO; 1034 fa->feature_set = set; 1035 fa->feature_bit = 1ULL << i; 1036 } 1037 } 1038 } 1039 1040 /* 1041 * Create a sysfs entry for a given block group type at path 1042 * /sys/fs/btrfs/UUID/allocation/data/TYPE 1043 */ 1044 void btrfs_sysfs_add_block_group_type(struct btrfs_block_group *cache) 1045 { 1046 struct btrfs_fs_info *fs_info = cache->fs_info; 1047 struct btrfs_space_info *space_info = cache->space_info; 1048 struct raid_kobject *rkobj; 1049 const int index = btrfs_bg_flags_to_raid_index(cache->flags); 1050 unsigned int nofs_flag; 1051 int ret; 1052 1053 /* 1054 * Setup a NOFS context because kobject_add(), deep in its call chain, 1055 * does GFP_KERNEL allocations, and we are often called in a context 1056 * where if reclaim is triggered we can deadlock (we are either holding 1057 * a transaction handle or some lock required for a transaction 1058 * commit). 1059 */ 1060 nofs_flag = memalloc_nofs_save(); 1061 1062 rkobj = kzalloc(sizeof(*rkobj), GFP_NOFS); 1063 if (!rkobj) { 1064 memalloc_nofs_restore(nofs_flag); 1065 btrfs_warn(cache->fs_info, 1066 "couldn't alloc memory for raid level kobject"); 1067 return; 1068 } 1069 1070 rkobj->flags = cache->flags; 1071 kobject_init(&rkobj->kobj, &btrfs_raid_ktype); 1072 ret = kobject_add(&rkobj->kobj, &space_info->kobj, "%s", 1073 btrfs_bg_type_to_raid_name(rkobj->flags)); 1074 memalloc_nofs_restore(nofs_flag); 1075 if (ret) { 1076 kobject_put(&rkobj->kobj); 1077 btrfs_warn(fs_info, 1078 "failed to add kobject for block cache, ignoring"); 1079 return; 1080 } 1081 1082 space_info->block_group_kobjs[index] = &rkobj->kobj; 1083 } 1084 1085 /* 1086 * Remove sysfs directories for all block group types of a given space info and 1087 * the space info as well 1088 */ 1089 void btrfs_sysfs_remove_space_info(struct btrfs_space_info *space_info) 1090 { 1091 int i; 1092 1093 for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) { 1094 struct kobject *kobj; 1095 1096 kobj = space_info->block_group_kobjs[i]; 1097 space_info->block_group_kobjs[i] = NULL; 1098 if (kobj) { 1099 kobject_del(kobj); 1100 kobject_put(kobj); 1101 } 1102 } 1103 kobject_del(&space_info->kobj); 1104 kobject_put(&space_info->kobj); 1105 } 1106 1107 static const char *alloc_name(u64 flags) 1108 { 1109 switch (flags) { 1110 case BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_DATA: 1111 return "mixed"; 1112 case BTRFS_BLOCK_GROUP_METADATA: 1113 return "metadata"; 1114 case BTRFS_BLOCK_GROUP_DATA: 1115 return "data"; 1116 case BTRFS_BLOCK_GROUP_SYSTEM: 1117 return "system"; 1118 default: 1119 WARN_ON(1); 1120 return "invalid-combination"; 1121 }; 1122 } 1123 1124 /* 1125 * Create a sysfs entry for a space info type at path 1126 * /sys/fs/btrfs/UUID/allocation/TYPE 1127 */ 1128 int btrfs_sysfs_add_space_info_type(struct btrfs_fs_info *fs_info, 1129 struct btrfs_space_info *space_info) 1130 { 1131 int ret; 1132 1133 ret = kobject_init_and_add(&space_info->kobj, &space_info_ktype, 1134 fs_info->space_info_kobj, "%s", 1135 alloc_name(space_info->flags)); 1136 if (ret) { 1137 kobject_put(&space_info->kobj); 1138 return ret; 1139 } 1140 1141 return 0; 1142 } 1143 1144 /* when one_device is NULL, it removes all device links */ 1145 1146 int btrfs_sysfs_rm_device_link(struct btrfs_fs_devices *fs_devices, 1147 struct btrfs_device *one_device) 1148 { 1149 struct hd_struct *disk; 1150 struct kobject *disk_kobj; 1151 1152 if (!fs_devices->devices_kobj) 1153 return -EINVAL; 1154 1155 if (one_device) { 1156 if (one_device->bdev) { 1157 disk = one_device->bdev->bd_part; 1158 disk_kobj = &part_to_dev(disk)->kobj; 1159 sysfs_remove_link(fs_devices->devices_kobj, 1160 disk_kobj->name); 1161 } 1162 1163 kobject_del(&one_device->devid_kobj); 1164 kobject_put(&one_device->devid_kobj); 1165 1166 wait_for_completion(&one_device->kobj_unregister); 1167 1168 return 0; 1169 } 1170 1171 list_for_each_entry(one_device, &fs_devices->devices, dev_list) { 1172 1173 if (one_device->bdev) { 1174 disk = one_device->bdev->bd_part; 1175 disk_kobj = &part_to_dev(disk)->kobj; 1176 sysfs_remove_link(fs_devices->devices_kobj, 1177 disk_kobj->name); 1178 } 1179 kobject_del(&one_device->devid_kobj); 1180 kobject_put(&one_device->devid_kobj); 1181 1182 wait_for_completion(&one_device->kobj_unregister); 1183 } 1184 1185 return 0; 1186 } 1187 1188 static ssize_t btrfs_devinfo_in_fs_metadata_show(struct kobject *kobj, 1189 struct kobj_attribute *a, 1190 char *buf) 1191 { 1192 int val; 1193 struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1194 devid_kobj); 1195 1196 val = !!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); 1197 1198 return snprintf(buf, PAGE_SIZE, "%d\n", val); 1199 } 1200 BTRFS_ATTR(devid, in_fs_metadata, btrfs_devinfo_in_fs_metadata_show); 1201 1202 static ssize_t btrfs_sysfs_missing_show(struct kobject *kobj, 1203 struct kobj_attribute *a, char *buf) 1204 { 1205 int val; 1206 struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1207 devid_kobj); 1208 1209 val = !!test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); 1210 1211 return snprintf(buf, PAGE_SIZE, "%d\n", val); 1212 } 1213 BTRFS_ATTR(devid, missing, btrfs_sysfs_missing_show); 1214 1215 static ssize_t btrfs_devinfo_replace_target_show(struct kobject *kobj, 1216 struct kobj_attribute *a, 1217 char *buf) 1218 { 1219 int val; 1220 struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1221 devid_kobj); 1222 1223 val = !!test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); 1224 1225 return snprintf(buf, PAGE_SIZE, "%d\n", val); 1226 } 1227 BTRFS_ATTR(devid, replace_target, btrfs_devinfo_replace_target_show); 1228 1229 static ssize_t btrfs_devinfo_writeable_show(struct kobject *kobj, 1230 struct kobj_attribute *a, char *buf) 1231 { 1232 int val; 1233 struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1234 devid_kobj); 1235 1236 val = !!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); 1237 1238 return snprintf(buf, PAGE_SIZE, "%d\n", val); 1239 } 1240 BTRFS_ATTR(devid, writeable, btrfs_devinfo_writeable_show); 1241 1242 static struct attribute *devid_attrs[] = { 1243 BTRFS_ATTR_PTR(devid, in_fs_metadata), 1244 BTRFS_ATTR_PTR(devid, missing), 1245 BTRFS_ATTR_PTR(devid, replace_target), 1246 BTRFS_ATTR_PTR(devid, writeable), 1247 NULL 1248 }; 1249 ATTRIBUTE_GROUPS(devid); 1250 1251 static void btrfs_release_devid_kobj(struct kobject *kobj) 1252 { 1253 struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1254 devid_kobj); 1255 1256 memset(&device->devid_kobj, 0, sizeof(struct kobject)); 1257 complete(&device->kobj_unregister); 1258 } 1259 1260 static struct kobj_type devid_ktype = { 1261 .sysfs_ops = &kobj_sysfs_ops, 1262 .default_groups = devid_groups, 1263 .release = btrfs_release_devid_kobj, 1264 }; 1265 1266 int btrfs_sysfs_add_device_link(struct btrfs_fs_devices *fs_devices, 1267 struct btrfs_device *one_device) 1268 { 1269 int error = 0; 1270 struct btrfs_device *dev; 1271 1272 list_for_each_entry(dev, &fs_devices->devices, dev_list) { 1273 1274 if (one_device && one_device != dev) 1275 continue; 1276 1277 if (dev->bdev) { 1278 struct hd_struct *disk; 1279 struct kobject *disk_kobj; 1280 1281 disk = dev->bdev->bd_part; 1282 disk_kobj = &part_to_dev(disk)->kobj; 1283 1284 error = sysfs_create_link(fs_devices->devices_kobj, 1285 disk_kobj, disk_kobj->name); 1286 if (error) 1287 break; 1288 } 1289 1290 init_completion(&dev->kobj_unregister); 1291 error = kobject_init_and_add(&dev->devid_kobj, &devid_ktype, 1292 fs_devices->devices_kobj, "%llu", 1293 dev->devid); 1294 if (error) { 1295 kobject_put(&dev->devid_kobj); 1296 break; 1297 } 1298 } 1299 1300 return error; 1301 } 1302 1303 void btrfs_kobject_uevent(struct block_device *bdev, enum kobject_action action) 1304 { 1305 int ret; 1306 1307 ret = kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, action); 1308 if (ret) 1309 pr_warn("BTRFS: Sending event '%d' to kobject: '%s' (%p): failed\n", 1310 action, kobject_name(&disk_to_dev(bdev->bd_disk)->kobj), 1311 &disk_to_dev(bdev->bd_disk)->kobj); 1312 } 1313 1314 void btrfs_sysfs_update_sprout_fsid(struct btrfs_fs_devices *fs_devices, 1315 const u8 *fsid) 1316 { 1317 char fsid_buf[BTRFS_UUID_UNPARSED_SIZE]; 1318 1319 /* 1320 * Sprouting changes fsid of the mounted filesystem, rename the fsid 1321 * directory 1322 */ 1323 snprintf(fsid_buf, BTRFS_UUID_UNPARSED_SIZE, "%pU", fsid); 1324 if (kobject_rename(&fs_devices->fsid_kobj, fsid_buf)) 1325 btrfs_warn(fs_devices->fs_info, 1326 "sysfs: failed to create fsid for sprout"); 1327 } 1328 1329 void btrfs_sysfs_update_devid(struct btrfs_device *device) 1330 { 1331 char tmp[24]; 1332 1333 snprintf(tmp, sizeof(tmp), "%llu", device->devid); 1334 1335 if (kobject_rename(&device->devid_kobj, tmp)) 1336 btrfs_warn(device->fs_devices->fs_info, 1337 "sysfs: failed to update devid for %llu", 1338 device->devid); 1339 } 1340 1341 /* /sys/fs/btrfs/ entry */ 1342 static struct kset *btrfs_kset; 1343 1344 /* 1345 * Creates: 1346 * /sys/fs/btrfs/UUID 1347 * 1348 * Can be called by the device discovery thread. 1349 */ 1350 int btrfs_sysfs_add_fsid(struct btrfs_fs_devices *fs_devs) 1351 { 1352 int error; 1353 1354 init_completion(&fs_devs->kobj_unregister); 1355 fs_devs->fsid_kobj.kset = btrfs_kset; 1356 error = kobject_init_and_add(&fs_devs->fsid_kobj, &btrfs_ktype, NULL, 1357 "%pU", fs_devs->fsid); 1358 if (error) { 1359 kobject_put(&fs_devs->fsid_kobj); 1360 return error; 1361 } 1362 1363 fs_devs->devices_kobj = kobject_create_and_add("devices", 1364 &fs_devs->fsid_kobj); 1365 if (!fs_devs->devices_kobj) { 1366 btrfs_err(fs_devs->fs_info, 1367 "failed to init sysfs device interface"); 1368 kobject_put(&fs_devs->fsid_kobj); 1369 return -ENOMEM; 1370 } 1371 1372 return 0; 1373 } 1374 1375 int btrfs_sysfs_add_mounted(struct btrfs_fs_info *fs_info) 1376 { 1377 int error; 1378 struct btrfs_fs_devices *fs_devs = fs_info->fs_devices; 1379 struct kobject *fsid_kobj = &fs_devs->fsid_kobj; 1380 1381 btrfs_set_fs_info_ptr(fs_info); 1382 1383 error = btrfs_sysfs_add_device_link(fs_devs, NULL); 1384 if (error) 1385 return error; 1386 1387 error = sysfs_create_files(fsid_kobj, btrfs_attrs); 1388 if (error) { 1389 btrfs_sysfs_rm_device_link(fs_devs, NULL); 1390 return error; 1391 } 1392 1393 error = sysfs_create_group(fsid_kobj, 1394 &btrfs_feature_attr_group); 1395 if (error) 1396 goto failure; 1397 1398 #ifdef CONFIG_BTRFS_DEBUG 1399 fs_info->debug_kobj = kobject_create_and_add("debug", fsid_kobj); 1400 if (!fs_info->debug_kobj) { 1401 error = -ENOMEM; 1402 goto failure; 1403 } 1404 1405 error = sysfs_create_files(fs_info->debug_kobj, btrfs_debug_mount_attrs); 1406 if (error) 1407 goto failure; 1408 1409 /* Discard directory */ 1410 fs_info->discard_debug_kobj = kobject_create_and_add("discard", 1411 fs_info->debug_kobj); 1412 if (!fs_info->discard_debug_kobj) { 1413 error = -ENOMEM; 1414 goto failure; 1415 } 1416 1417 error = sysfs_create_files(fs_info->discard_debug_kobj, 1418 discard_debug_attrs); 1419 if (error) 1420 goto failure; 1421 #endif 1422 1423 error = addrm_unknown_feature_attrs(fs_info, true); 1424 if (error) 1425 goto failure; 1426 1427 fs_info->space_info_kobj = kobject_create_and_add("allocation", 1428 fsid_kobj); 1429 if (!fs_info->space_info_kobj) { 1430 error = -ENOMEM; 1431 goto failure; 1432 } 1433 1434 error = sysfs_create_files(fs_info->space_info_kobj, allocation_attrs); 1435 if (error) 1436 goto failure; 1437 1438 return 0; 1439 failure: 1440 btrfs_sysfs_remove_mounted(fs_info); 1441 return error; 1442 } 1443 1444 1445 /* 1446 * Change per-fs features in /sys/fs/btrfs/UUID/features to match current 1447 * values in superblock. Call after any changes to incompat/compat_ro flags 1448 */ 1449 void btrfs_sysfs_feature_update(struct btrfs_fs_info *fs_info, 1450 u64 bit, enum btrfs_feature_set set) 1451 { 1452 struct btrfs_fs_devices *fs_devs; 1453 struct kobject *fsid_kobj; 1454 u64 features; 1455 int ret; 1456 1457 if (!fs_info) 1458 return; 1459 1460 features = get_features(fs_info, set); 1461 ASSERT(bit & supported_feature_masks[set]); 1462 1463 fs_devs = fs_info->fs_devices; 1464 fsid_kobj = &fs_devs->fsid_kobj; 1465 1466 if (!fsid_kobj->state_initialized) 1467 return; 1468 1469 /* 1470 * FIXME: this is too heavy to update just one value, ideally we'd like 1471 * to use sysfs_update_group but some refactoring is needed first. 1472 */ 1473 sysfs_remove_group(fsid_kobj, &btrfs_feature_attr_group); 1474 ret = sysfs_create_group(fsid_kobj, &btrfs_feature_attr_group); 1475 } 1476 1477 int __init btrfs_init_sysfs(void) 1478 { 1479 int ret; 1480 1481 btrfs_kset = kset_create_and_add("btrfs", NULL, fs_kobj); 1482 if (!btrfs_kset) 1483 return -ENOMEM; 1484 1485 init_feature_attrs(); 1486 ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_feature_attr_group); 1487 if (ret) 1488 goto out2; 1489 ret = sysfs_merge_group(&btrfs_kset->kobj, 1490 &btrfs_static_feature_attr_group); 1491 if (ret) 1492 goto out_remove_group; 1493 1494 #ifdef CONFIG_BTRFS_DEBUG 1495 ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_debug_feature_attr_group); 1496 if (ret) 1497 goto out2; 1498 #endif 1499 1500 return 0; 1501 1502 out_remove_group: 1503 sysfs_remove_group(&btrfs_kset->kobj, &btrfs_feature_attr_group); 1504 out2: 1505 kset_unregister(btrfs_kset); 1506 1507 return ret; 1508 } 1509 1510 void __cold btrfs_exit_sysfs(void) 1511 { 1512 sysfs_unmerge_group(&btrfs_kset->kobj, 1513 &btrfs_static_feature_attr_group); 1514 sysfs_remove_group(&btrfs_kset->kobj, &btrfs_feature_attr_group); 1515 #ifdef CONFIG_BTRFS_DEBUG 1516 sysfs_remove_group(&btrfs_kset->kobj, &btrfs_debug_feature_attr_group); 1517 #endif 1518 kset_unregister(btrfs_kset); 1519 } 1520 1521