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