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->devinfo_kobj) { 905 kobject_del(fs_devs->devinfo_kobj); 906 kobject_put(fs_devs->devinfo_kobj); 907 fs_devs->devinfo_kobj = NULL; 908 } 909 910 if (fs_devs->devices_kobj) { 911 kobject_del(fs_devs->devices_kobj); 912 kobject_put(fs_devs->devices_kobj); 913 fs_devs->devices_kobj = NULL; 914 } 915 916 if (fs_devs->fsid_kobj.state_initialized) { 917 kobject_del(&fs_devs->fsid_kobj); 918 kobject_put(&fs_devs->fsid_kobj); 919 wait_for_completion(&fs_devs->kobj_unregister); 920 } 921 } 922 923 /* when fs_devs is NULL it will remove all fsid kobject */ 924 void btrfs_sysfs_remove_fsid(struct btrfs_fs_devices *fs_devs) 925 { 926 struct list_head *fs_uuids = btrfs_get_fs_uuids(); 927 928 if (fs_devs) { 929 __btrfs_sysfs_remove_fsid(fs_devs); 930 return; 931 } 932 933 list_for_each_entry(fs_devs, fs_uuids, fs_list) { 934 __btrfs_sysfs_remove_fsid(fs_devs); 935 } 936 } 937 938 void btrfs_sysfs_remove_mounted(struct btrfs_fs_info *fs_info) 939 { 940 btrfs_reset_fs_info_ptr(fs_info); 941 942 if (fs_info->space_info_kobj) { 943 sysfs_remove_files(fs_info->space_info_kobj, allocation_attrs); 944 kobject_del(fs_info->space_info_kobj); 945 kobject_put(fs_info->space_info_kobj); 946 } 947 #ifdef CONFIG_BTRFS_DEBUG 948 if (fs_info->discard_debug_kobj) { 949 sysfs_remove_files(fs_info->discard_debug_kobj, 950 discard_debug_attrs); 951 kobject_del(fs_info->discard_debug_kobj); 952 kobject_put(fs_info->discard_debug_kobj); 953 } 954 if (fs_info->debug_kobj) { 955 sysfs_remove_files(fs_info->debug_kobj, btrfs_debug_mount_attrs); 956 kobject_del(fs_info->debug_kobj); 957 kobject_put(fs_info->debug_kobj); 958 } 959 #endif 960 addrm_unknown_feature_attrs(fs_info, false); 961 sysfs_remove_group(&fs_info->fs_devices->fsid_kobj, &btrfs_feature_attr_group); 962 sysfs_remove_files(&fs_info->fs_devices->fsid_kobj, btrfs_attrs); 963 btrfs_sysfs_rm_device_link(fs_info->fs_devices, NULL); 964 } 965 966 static const char * const btrfs_feature_set_names[FEAT_MAX] = { 967 [FEAT_COMPAT] = "compat", 968 [FEAT_COMPAT_RO] = "compat_ro", 969 [FEAT_INCOMPAT] = "incompat", 970 }; 971 972 const char * const btrfs_feature_set_name(enum btrfs_feature_set set) 973 { 974 return btrfs_feature_set_names[set]; 975 } 976 977 char *btrfs_printable_features(enum btrfs_feature_set set, u64 flags) 978 { 979 size_t bufsize = 4096; /* safe max, 64 names * 64 bytes */ 980 int len = 0; 981 int i; 982 char *str; 983 984 str = kmalloc(bufsize, GFP_KERNEL); 985 if (!str) 986 return str; 987 988 for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) { 989 const char *name; 990 991 if (!(flags & (1ULL << i))) 992 continue; 993 994 name = btrfs_feature_attrs[set][i].kobj_attr.attr.name; 995 len += snprintf(str + len, bufsize - len, "%s%s", 996 len ? "," : "", name); 997 } 998 999 return str; 1000 } 1001 1002 static void init_feature_attrs(void) 1003 { 1004 struct btrfs_feature_attr *fa; 1005 int set, i; 1006 1007 BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names) != 1008 ARRAY_SIZE(btrfs_feature_attrs)); 1009 BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names[0]) != 1010 ARRAY_SIZE(btrfs_feature_attrs[0])); 1011 1012 memset(btrfs_feature_attrs, 0, sizeof(btrfs_feature_attrs)); 1013 memset(btrfs_unknown_feature_names, 0, 1014 sizeof(btrfs_unknown_feature_names)); 1015 1016 for (i = 0; btrfs_supported_feature_attrs[i]; i++) { 1017 struct btrfs_feature_attr *sfa; 1018 struct attribute *a = btrfs_supported_feature_attrs[i]; 1019 int bit; 1020 sfa = attr_to_btrfs_feature_attr(a); 1021 bit = ilog2(sfa->feature_bit); 1022 fa = &btrfs_feature_attrs[sfa->feature_set][bit]; 1023 1024 fa->kobj_attr.attr.name = sfa->kobj_attr.attr.name; 1025 } 1026 1027 for (set = 0; set < FEAT_MAX; set++) { 1028 for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) { 1029 char *name = btrfs_unknown_feature_names[set][i]; 1030 fa = &btrfs_feature_attrs[set][i]; 1031 1032 if (fa->kobj_attr.attr.name) 1033 continue; 1034 1035 snprintf(name, BTRFS_FEATURE_NAME_MAX, "%s:%u", 1036 btrfs_feature_set_names[set], i); 1037 1038 fa->kobj_attr.attr.name = name; 1039 fa->kobj_attr.attr.mode = S_IRUGO; 1040 fa->feature_set = set; 1041 fa->feature_bit = 1ULL << i; 1042 } 1043 } 1044 } 1045 1046 /* 1047 * Create a sysfs entry for a given block group type at path 1048 * /sys/fs/btrfs/UUID/allocation/data/TYPE 1049 */ 1050 void btrfs_sysfs_add_block_group_type(struct btrfs_block_group *cache) 1051 { 1052 struct btrfs_fs_info *fs_info = cache->fs_info; 1053 struct btrfs_space_info *space_info = cache->space_info; 1054 struct raid_kobject *rkobj; 1055 const int index = btrfs_bg_flags_to_raid_index(cache->flags); 1056 unsigned int nofs_flag; 1057 int ret; 1058 1059 /* 1060 * Setup a NOFS context because kobject_add(), deep in its call chain, 1061 * does GFP_KERNEL allocations, and we are often called in a context 1062 * where if reclaim is triggered we can deadlock (we are either holding 1063 * a transaction handle or some lock required for a transaction 1064 * commit). 1065 */ 1066 nofs_flag = memalloc_nofs_save(); 1067 1068 rkobj = kzalloc(sizeof(*rkobj), GFP_NOFS); 1069 if (!rkobj) { 1070 memalloc_nofs_restore(nofs_flag); 1071 btrfs_warn(cache->fs_info, 1072 "couldn't alloc memory for raid level kobject"); 1073 return; 1074 } 1075 1076 rkobj->flags = cache->flags; 1077 kobject_init(&rkobj->kobj, &btrfs_raid_ktype); 1078 ret = kobject_add(&rkobj->kobj, &space_info->kobj, "%s", 1079 btrfs_bg_type_to_raid_name(rkobj->flags)); 1080 memalloc_nofs_restore(nofs_flag); 1081 if (ret) { 1082 kobject_put(&rkobj->kobj); 1083 btrfs_warn(fs_info, 1084 "failed to add kobject for block cache, ignoring"); 1085 return; 1086 } 1087 1088 space_info->block_group_kobjs[index] = &rkobj->kobj; 1089 } 1090 1091 /* 1092 * Remove sysfs directories for all block group types of a given space info and 1093 * the space info as well 1094 */ 1095 void btrfs_sysfs_remove_space_info(struct btrfs_space_info *space_info) 1096 { 1097 int i; 1098 1099 for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) { 1100 struct kobject *kobj; 1101 1102 kobj = space_info->block_group_kobjs[i]; 1103 space_info->block_group_kobjs[i] = NULL; 1104 if (kobj) { 1105 kobject_del(kobj); 1106 kobject_put(kobj); 1107 } 1108 } 1109 kobject_del(&space_info->kobj); 1110 kobject_put(&space_info->kobj); 1111 } 1112 1113 static const char *alloc_name(u64 flags) 1114 { 1115 switch (flags) { 1116 case BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_DATA: 1117 return "mixed"; 1118 case BTRFS_BLOCK_GROUP_METADATA: 1119 return "metadata"; 1120 case BTRFS_BLOCK_GROUP_DATA: 1121 return "data"; 1122 case BTRFS_BLOCK_GROUP_SYSTEM: 1123 return "system"; 1124 default: 1125 WARN_ON(1); 1126 return "invalid-combination"; 1127 }; 1128 } 1129 1130 /* 1131 * Create a sysfs entry for a space info type at path 1132 * /sys/fs/btrfs/UUID/allocation/TYPE 1133 */ 1134 int btrfs_sysfs_add_space_info_type(struct btrfs_fs_info *fs_info, 1135 struct btrfs_space_info *space_info) 1136 { 1137 int ret; 1138 1139 ret = kobject_init_and_add(&space_info->kobj, &space_info_ktype, 1140 fs_info->space_info_kobj, "%s", 1141 alloc_name(space_info->flags)); 1142 if (ret) { 1143 kobject_put(&space_info->kobj); 1144 return ret; 1145 } 1146 1147 return 0; 1148 } 1149 1150 /* when one_device is NULL, it removes all device links */ 1151 1152 int btrfs_sysfs_rm_device_link(struct btrfs_fs_devices *fs_devices, 1153 struct btrfs_device *one_device) 1154 { 1155 struct hd_struct *disk; 1156 struct kobject *disk_kobj; 1157 1158 if (!fs_devices->devices_kobj) 1159 return -EINVAL; 1160 1161 if (one_device) { 1162 if (one_device->bdev) { 1163 disk = one_device->bdev->bd_part; 1164 disk_kobj = &part_to_dev(disk)->kobj; 1165 sysfs_remove_link(fs_devices->devices_kobj, 1166 disk_kobj->name); 1167 } 1168 1169 kobject_del(&one_device->devid_kobj); 1170 kobject_put(&one_device->devid_kobj); 1171 1172 wait_for_completion(&one_device->kobj_unregister); 1173 1174 return 0; 1175 } 1176 1177 list_for_each_entry(one_device, &fs_devices->devices, dev_list) { 1178 1179 if (one_device->bdev) { 1180 disk = one_device->bdev->bd_part; 1181 disk_kobj = &part_to_dev(disk)->kobj; 1182 sysfs_remove_link(fs_devices->devices_kobj, 1183 disk_kobj->name); 1184 } 1185 kobject_del(&one_device->devid_kobj); 1186 kobject_put(&one_device->devid_kobj); 1187 1188 wait_for_completion(&one_device->kobj_unregister); 1189 } 1190 1191 return 0; 1192 } 1193 1194 static ssize_t btrfs_devinfo_in_fs_metadata_show(struct kobject *kobj, 1195 struct kobj_attribute *a, 1196 char *buf) 1197 { 1198 int val; 1199 struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1200 devid_kobj); 1201 1202 val = !!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); 1203 1204 return snprintf(buf, PAGE_SIZE, "%d\n", val); 1205 } 1206 BTRFS_ATTR(devid, in_fs_metadata, btrfs_devinfo_in_fs_metadata_show); 1207 1208 static ssize_t btrfs_sysfs_missing_show(struct kobject *kobj, 1209 struct kobj_attribute *a, char *buf) 1210 { 1211 int val; 1212 struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1213 devid_kobj); 1214 1215 val = !!test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); 1216 1217 return snprintf(buf, PAGE_SIZE, "%d\n", val); 1218 } 1219 BTRFS_ATTR(devid, missing, btrfs_sysfs_missing_show); 1220 1221 static ssize_t btrfs_devinfo_replace_target_show(struct kobject *kobj, 1222 struct kobj_attribute *a, 1223 char *buf) 1224 { 1225 int val; 1226 struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1227 devid_kobj); 1228 1229 val = !!test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); 1230 1231 return snprintf(buf, PAGE_SIZE, "%d\n", val); 1232 } 1233 BTRFS_ATTR(devid, replace_target, btrfs_devinfo_replace_target_show); 1234 1235 static ssize_t btrfs_devinfo_writeable_show(struct kobject *kobj, 1236 struct kobj_attribute *a, char *buf) 1237 { 1238 int val; 1239 struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1240 devid_kobj); 1241 1242 val = !!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); 1243 1244 return snprintf(buf, PAGE_SIZE, "%d\n", val); 1245 } 1246 BTRFS_ATTR(devid, writeable, btrfs_devinfo_writeable_show); 1247 1248 static struct attribute *devid_attrs[] = { 1249 BTRFS_ATTR_PTR(devid, in_fs_metadata), 1250 BTRFS_ATTR_PTR(devid, missing), 1251 BTRFS_ATTR_PTR(devid, replace_target), 1252 BTRFS_ATTR_PTR(devid, writeable), 1253 NULL 1254 }; 1255 ATTRIBUTE_GROUPS(devid); 1256 1257 static void btrfs_release_devid_kobj(struct kobject *kobj) 1258 { 1259 struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1260 devid_kobj); 1261 1262 memset(&device->devid_kobj, 0, sizeof(struct kobject)); 1263 complete(&device->kobj_unregister); 1264 } 1265 1266 static struct kobj_type devid_ktype = { 1267 .sysfs_ops = &kobj_sysfs_ops, 1268 .default_groups = devid_groups, 1269 .release = btrfs_release_devid_kobj, 1270 }; 1271 1272 int btrfs_sysfs_add_device_link(struct btrfs_fs_devices *fs_devices, 1273 struct btrfs_device *one_device) 1274 { 1275 int error = 0; 1276 struct btrfs_device *dev; 1277 1278 list_for_each_entry(dev, &fs_devices->devices, dev_list) { 1279 1280 if (one_device && one_device != dev) 1281 continue; 1282 1283 if (dev->bdev) { 1284 struct hd_struct *disk; 1285 struct kobject *disk_kobj; 1286 1287 disk = dev->bdev->bd_part; 1288 disk_kobj = &part_to_dev(disk)->kobj; 1289 1290 error = sysfs_create_link(fs_devices->devices_kobj, 1291 disk_kobj, disk_kobj->name); 1292 if (error) 1293 break; 1294 } 1295 1296 init_completion(&dev->kobj_unregister); 1297 error = kobject_init_and_add(&dev->devid_kobj, &devid_ktype, 1298 fs_devices->devinfo_kobj, "%llu", 1299 dev->devid); 1300 if (error) { 1301 kobject_put(&dev->devid_kobj); 1302 break; 1303 } 1304 } 1305 1306 return error; 1307 } 1308 1309 void btrfs_kobject_uevent(struct block_device *bdev, enum kobject_action action) 1310 { 1311 int ret; 1312 1313 ret = kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, action); 1314 if (ret) 1315 pr_warn("BTRFS: Sending event '%d' to kobject: '%s' (%p): failed\n", 1316 action, kobject_name(&disk_to_dev(bdev->bd_disk)->kobj), 1317 &disk_to_dev(bdev->bd_disk)->kobj); 1318 } 1319 1320 void btrfs_sysfs_update_sprout_fsid(struct btrfs_fs_devices *fs_devices, 1321 const u8 *fsid) 1322 { 1323 char fsid_buf[BTRFS_UUID_UNPARSED_SIZE]; 1324 1325 /* 1326 * Sprouting changes fsid of the mounted filesystem, rename the fsid 1327 * directory 1328 */ 1329 snprintf(fsid_buf, BTRFS_UUID_UNPARSED_SIZE, "%pU", fsid); 1330 if (kobject_rename(&fs_devices->fsid_kobj, fsid_buf)) 1331 btrfs_warn(fs_devices->fs_info, 1332 "sysfs: failed to create fsid for sprout"); 1333 } 1334 1335 void btrfs_sysfs_update_devid(struct btrfs_device *device) 1336 { 1337 char tmp[24]; 1338 1339 snprintf(tmp, sizeof(tmp), "%llu", device->devid); 1340 1341 if (kobject_rename(&device->devid_kobj, tmp)) 1342 btrfs_warn(device->fs_devices->fs_info, 1343 "sysfs: failed to update devid for %llu", 1344 device->devid); 1345 } 1346 1347 /* /sys/fs/btrfs/ entry */ 1348 static struct kset *btrfs_kset; 1349 1350 /* 1351 * Creates: 1352 * /sys/fs/btrfs/UUID 1353 * 1354 * Can be called by the device discovery thread. 1355 */ 1356 int btrfs_sysfs_add_fsid(struct btrfs_fs_devices *fs_devs) 1357 { 1358 int error; 1359 1360 init_completion(&fs_devs->kobj_unregister); 1361 fs_devs->fsid_kobj.kset = btrfs_kset; 1362 error = kobject_init_and_add(&fs_devs->fsid_kobj, &btrfs_ktype, NULL, 1363 "%pU", fs_devs->fsid); 1364 if (error) { 1365 kobject_put(&fs_devs->fsid_kobj); 1366 return error; 1367 } 1368 1369 fs_devs->devices_kobj = kobject_create_and_add("devices", 1370 &fs_devs->fsid_kobj); 1371 if (!fs_devs->devices_kobj) { 1372 btrfs_err(fs_devs->fs_info, 1373 "failed to init sysfs device interface"); 1374 kobject_put(&fs_devs->fsid_kobj); 1375 return -ENOMEM; 1376 } 1377 1378 fs_devs->devinfo_kobj = kobject_create_and_add("devinfo", 1379 &fs_devs->fsid_kobj); 1380 if (!fs_devs->devinfo_kobj) { 1381 btrfs_err(fs_devs->fs_info, 1382 "failed to init sysfs devinfo kobject"); 1383 btrfs_sysfs_remove_fsid(fs_devs); 1384 return -ENOMEM; 1385 } 1386 1387 return 0; 1388 } 1389 1390 int btrfs_sysfs_add_mounted(struct btrfs_fs_info *fs_info) 1391 { 1392 int error; 1393 struct btrfs_fs_devices *fs_devs = fs_info->fs_devices; 1394 struct kobject *fsid_kobj = &fs_devs->fsid_kobj; 1395 1396 btrfs_set_fs_info_ptr(fs_info); 1397 1398 error = btrfs_sysfs_add_device_link(fs_devs, NULL); 1399 if (error) 1400 return error; 1401 1402 error = sysfs_create_files(fsid_kobj, btrfs_attrs); 1403 if (error) { 1404 btrfs_sysfs_rm_device_link(fs_devs, NULL); 1405 return error; 1406 } 1407 1408 error = sysfs_create_group(fsid_kobj, 1409 &btrfs_feature_attr_group); 1410 if (error) 1411 goto failure; 1412 1413 #ifdef CONFIG_BTRFS_DEBUG 1414 fs_info->debug_kobj = kobject_create_and_add("debug", fsid_kobj); 1415 if (!fs_info->debug_kobj) { 1416 error = -ENOMEM; 1417 goto failure; 1418 } 1419 1420 error = sysfs_create_files(fs_info->debug_kobj, btrfs_debug_mount_attrs); 1421 if (error) 1422 goto failure; 1423 1424 /* Discard directory */ 1425 fs_info->discard_debug_kobj = kobject_create_and_add("discard", 1426 fs_info->debug_kobj); 1427 if (!fs_info->discard_debug_kobj) { 1428 error = -ENOMEM; 1429 goto failure; 1430 } 1431 1432 error = sysfs_create_files(fs_info->discard_debug_kobj, 1433 discard_debug_attrs); 1434 if (error) 1435 goto failure; 1436 #endif 1437 1438 error = addrm_unknown_feature_attrs(fs_info, true); 1439 if (error) 1440 goto failure; 1441 1442 fs_info->space_info_kobj = kobject_create_and_add("allocation", 1443 fsid_kobj); 1444 if (!fs_info->space_info_kobj) { 1445 error = -ENOMEM; 1446 goto failure; 1447 } 1448 1449 error = sysfs_create_files(fs_info->space_info_kobj, allocation_attrs); 1450 if (error) 1451 goto failure; 1452 1453 return 0; 1454 failure: 1455 btrfs_sysfs_remove_mounted(fs_info); 1456 return error; 1457 } 1458 1459 1460 /* 1461 * Change per-fs features in /sys/fs/btrfs/UUID/features to match current 1462 * values in superblock. Call after any changes to incompat/compat_ro flags 1463 */ 1464 void btrfs_sysfs_feature_update(struct btrfs_fs_info *fs_info, 1465 u64 bit, enum btrfs_feature_set set) 1466 { 1467 struct btrfs_fs_devices *fs_devs; 1468 struct kobject *fsid_kobj; 1469 u64 features; 1470 int ret; 1471 1472 if (!fs_info) 1473 return; 1474 1475 features = get_features(fs_info, set); 1476 ASSERT(bit & supported_feature_masks[set]); 1477 1478 fs_devs = fs_info->fs_devices; 1479 fsid_kobj = &fs_devs->fsid_kobj; 1480 1481 if (!fsid_kobj->state_initialized) 1482 return; 1483 1484 /* 1485 * FIXME: this is too heavy to update just one value, ideally we'd like 1486 * to use sysfs_update_group but some refactoring is needed first. 1487 */ 1488 sysfs_remove_group(fsid_kobj, &btrfs_feature_attr_group); 1489 ret = sysfs_create_group(fsid_kobj, &btrfs_feature_attr_group); 1490 } 1491 1492 int __init btrfs_init_sysfs(void) 1493 { 1494 int ret; 1495 1496 btrfs_kset = kset_create_and_add("btrfs", NULL, fs_kobj); 1497 if (!btrfs_kset) 1498 return -ENOMEM; 1499 1500 init_feature_attrs(); 1501 ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_feature_attr_group); 1502 if (ret) 1503 goto out2; 1504 ret = sysfs_merge_group(&btrfs_kset->kobj, 1505 &btrfs_static_feature_attr_group); 1506 if (ret) 1507 goto out_remove_group; 1508 1509 #ifdef CONFIG_BTRFS_DEBUG 1510 ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_debug_feature_attr_group); 1511 if (ret) 1512 goto out2; 1513 #endif 1514 1515 return 0; 1516 1517 out_remove_group: 1518 sysfs_remove_group(&btrfs_kset->kobj, &btrfs_feature_attr_group); 1519 out2: 1520 kset_unregister(btrfs_kset); 1521 1522 return ret; 1523 } 1524 1525 void __cold btrfs_exit_sysfs(void) 1526 { 1527 sysfs_unmerge_group(&btrfs_kset->kobj, 1528 &btrfs_static_feature_attr_group); 1529 sysfs_remove_group(&btrfs_kset->kobj, &btrfs_feature_attr_group); 1530 #ifdef CONFIG_BTRFS_DEBUG 1531 sysfs_remove_group(&btrfs_kset->kobj, &btrfs_debug_feature_attr_group); 1532 #endif 1533 kset_unregister(btrfs_kset); 1534 } 1535 1536