1 /* 2 * Copyright (C) 2007 Oracle. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public 6 * License v2 as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 * General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public 14 * License along with this program; if not, write to the 15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 16 * Boston, MA 021110-1307, USA. 17 */ 18 19 #include <linux/sched.h> 20 #include <linux/slab.h> 21 #include <linux/spinlock.h> 22 #include <linux/completion.h> 23 #include <linux/buffer_head.h> 24 #include <linux/kobject.h> 25 #include <linux/bug.h> 26 #include <linux/genhd.h> 27 #include <linux/debugfs.h> 28 29 #include "ctree.h" 30 #include "disk-io.h" 31 #include "transaction.h" 32 #include "sysfs.h" 33 #include "volumes.h" 34 35 static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj); 36 static inline struct btrfs_fs_devices *to_fs_devs(struct kobject *kobj); 37 38 static u64 get_features(struct btrfs_fs_info *fs_info, 39 enum btrfs_feature_set set) 40 { 41 struct btrfs_super_block *disk_super = fs_info->super_copy; 42 if (set == FEAT_COMPAT) 43 return btrfs_super_compat_flags(disk_super); 44 else if (set == FEAT_COMPAT_RO) 45 return btrfs_super_compat_ro_flags(disk_super); 46 else 47 return btrfs_super_incompat_flags(disk_super); 48 } 49 50 static void set_features(struct btrfs_fs_info *fs_info, 51 enum btrfs_feature_set set, u64 features) 52 { 53 struct btrfs_super_block *disk_super = fs_info->super_copy; 54 if (set == FEAT_COMPAT) 55 btrfs_set_super_compat_flags(disk_super, features); 56 else if (set == FEAT_COMPAT_RO) 57 btrfs_set_super_compat_ro_flags(disk_super, features); 58 else 59 btrfs_set_super_incompat_flags(disk_super, features); 60 } 61 62 static int can_modify_feature(struct btrfs_feature_attr *fa) 63 { 64 int val = 0; 65 u64 set, clear; 66 switch (fa->feature_set) { 67 case FEAT_COMPAT: 68 set = BTRFS_FEATURE_COMPAT_SAFE_SET; 69 clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR; 70 break; 71 case FEAT_COMPAT_RO: 72 set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET; 73 clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR; 74 break; 75 case FEAT_INCOMPAT: 76 set = BTRFS_FEATURE_INCOMPAT_SAFE_SET; 77 clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR; 78 break; 79 default: 80 printk(KERN_WARNING "btrfs: sysfs: unknown feature set %d\n", 81 fa->feature_set); 82 return 0; 83 } 84 85 if (set & fa->feature_bit) 86 val |= 1; 87 if (clear & fa->feature_bit) 88 val |= 2; 89 90 return val; 91 } 92 93 static ssize_t btrfs_feature_attr_show(struct kobject *kobj, 94 struct kobj_attribute *a, char *buf) 95 { 96 int val = 0; 97 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 98 struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a); 99 if (fs_info) { 100 u64 features = get_features(fs_info, fa->feature_set); 101 if (features & fa->feature_bit) 102 val = 1; 103 } else 104 val = can_modify_feature(fa); 105 106 return snprintf(buf, PAGE_SIZE, "%d\n", val); 107 } 108 109 static ssize_t btrfs_feature_attr_store(struct kobject *kobj, 110 struct kobj_attribute *a, 111 const char *buf, size_t count) 112 { 113 struct btrfs_fs_info *fs_info; 114 struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a); 115 u64 features, set, clear; 116 unsigned long val; 117 int ret; 118 119 fs_info = to_fs_info(kobj); 120 if (!fs_info) 121 return -EPERM; 122 123 ret = kstrtoul(skip_spaces(buf), 0, &val); 124 if (ret) 125 return ret; 126 127 if (fa->feature_set == FEAT_COMPAT) { 128 set = BTRFS_FEATURE_COMPAT_SAFE_SET; 129 clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR; 130 } else if (fa->feature_set == FEAT_COMPAT_RO) { 131 set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET; 132 clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR; 133 } else { 134 set = BTRFS_FEATURE_INCOMPAT_SAFE_SET; 135 clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR; 136 } 137 138 features = get_features(fs_info, fa->feature_set); 139 140 /* Nothing to do */ 141 if ((val && (features & fa->feature_bit)) || 142 (!val && !(features & fa->feature_bit))) 143 return count; 144 145 if ((val && !(set & fa->feature_bit)) || 146 (!val && !(clear & fa->feature_bit))) { 147 btrfs_info(fs_info, 148 "%sabling feature %s on mounted fs is not supported.", 149 val ? "En" : "Dis", fa->kobj_attr.attr.name); 150 return -EPERM; 151 } 152 153 btrfs_info(fs_info, "%s %s feature flag", 154 val ? "Setting" : "Clearing", fa->kobj_attr.attr.name); 155 156 spin_lock(&fs_info->super_lock); 157 features = get_features(fs_info, fa->feature_set); 158 if (val) 159 features |= fa->feature_bit; 160 else 161 features &= ~fa->feature_bit; 162 set_features(fs_info, fa->feature_set, features); 163 spin_unlock(&fs_info->super_lock); 164 165 /* 166 * We don't want to do full transaction commit from inside sysfs 167 */ 168 btrfs_set_pending(fs_info, COMMIT); 169 wake_up_process(fs_info->transaction_kthread); 170 171 return count; 172 } 173 174 static umode_t btrfs_feature_visible(struct kobject *kobj, 175 struct attribute *attr, int unused) 176 { 177 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 178 umode_t mode = attr->mode; 179 180 if (fs_info) { 181 struct btrfs_feature_attr *fa; 182 u64 features; 183 184 fa = attr_to_btrfs_feature_attr(attr); 185 features = get_features(fs_info, fa->feature_set); 186 187 if (can_modify_feature(fa)) 188 mode |= S_IWUSR; 189 else if (!(features & fa->feature_bit)) 190 mode = 0; 191 } 192 193 return mode; 194 } 195 196 BTRFS_FEAT_ATTR_INCOMPAT(mixed_backref, MIXED_BACKREF); 197 BTRFS_FEAT_ATTR_INCOMPAT(default_subvol, DEFAULT_SUBVOL); 198 BTRFS_FEAT_ATTR_INCOMPAT(mixed_groups, MIXED_GROUPS); 199 BTRFS_FEAT_ATTR_INCOMPAT(compress_lzo, COMPRESS_LZO); 200 BTRFS_FEAT_ATTR_INCOMPAT(big_metadata, BIG_METADATA); 201 BTRFS_FEAT_ATTR_INCOMPAT(extended_iref, EXTENDED_IREF); 202 BTRFS_FEAT_ATTR_INCOMPAT(raid56, RAID56); 203 BTRFS_FEAT_ATTR_INCOMPAT(skinny_metadata, SKINNY_METADATA); 204 BTRFS_FEAT_ATTR_INCOMPAT(no_holes, NO_HOLES); 205 BTRFS_FEAT_ATTR_COMPAT_RO(free_space_tree, FREE_SPACE_TREE); 206 207 static struct attribute *btrfs_supported_feature_attrs[] = { 208 BTRFS_FEAT_ATTR_PTR(mixed_backref), 209 BTRFS_FEAT_ATTR_PTR(default_subvol), 210 BTRFS_FEAT_ATTR_PTR(mixed_groups), 211 BTRFS_FEAT_ATTR_PTR(compress_lzo), 212 BTRFS_FEAT_ATTR_PTR(big_metadata), 213 BTRFS_FEAT_ATTR_PTR(extended_iref), 214 BTRFS_FEAT_ATTR_PTR(raid56), 215 BTRFS_FEAT_ATTR_PTR(skinny_metadata), 216 BTRFS_FEAT_ATTR_PTR(no_holes), 217 BTRFS_FEAT_ATTR_PTR(free_space_tree), 218 NULL 219 }; 220 221 static const struct attribute_group btrfs_feature_attr_group = { 222 .name = "features", 223 .is_visible = btrfs_feature_visible, 224 .attrs = btrfs_supported_feature_attrs, 225 }; 226 227 static ssize_t btrfs_show_u64(u64 *value_ptr, spinlock_t *lock, char *buf) 228 { 229 u64 val; 230 if (lock) 231 spin_lock(lock); 232 val = *value_ptr; 233 if (lock) 234 spin_unlock(lock); 235 return snprintf(buf, PAGE_SIZE, "%llu\n", val); 236 } 237 238 static ssize_t global_rsv_size_show(struct kobject *kobj, 239 struct kobj_attribute *ka, char *buf) 240 { 241 struct btrfs_fs_info *fs_info = to_fs_info(kobj->parent); 242 struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv; 243 return btrfs_show_u64(&block_rsv->size, &block_rsv->lock, buf); 244 } 245 BTRFS_ATTR(global_rsv_size, global_rsv_size_show); 246 247 static ssize_t global_rsv_reserved_show(struct kobject *kobj, 248 struct kobj_attribute *a, char *buf) 249 { 250 struct btrfs_fs_info *fs_info = to_fs_info(kobj->parent); 251 struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv; 252 return btrfs_show_u64(&block_rsv->reserved, &block_rsv->lock, buf); 253 } 254 BTRFS_ATTR(global_rsv_reserved, global_rsv_reserved_show); 255 256 #define to_space_info(_kobj) container_of(_kobj, struct btrfs_space_info, kobj) 257 #define to_raid_kobj(_kobj) container_of(_kobj, struct raid_kobject, kobj) 258 259 static ssize_t raid_bytes_show(struct kobject *kobj, 260 struct kobj_attribute *attr, char *buf); 261 BTRFS_RAID_ATTR(total_bytes, raid_bytes_show); 262 BTRFS_RAID_ATTR(used_bytes, raid_bytes_show); 263 264 static ssize_t raid_bytes_show(struct kobject *kobj, 265 struct kobj_attribute *attr, char *buf) 266 267 { 268 struct btrfs_space_info *sinfo = to_space_info(kobj->parent); 269 struct btrfs_block_group_cache *block_group; 270 int index = to_raid_kobj(kobj)->raid_type; 271 u64 val = 0; 272 273 down_read(&sinfo->groups_sem); 274 list_for_each_entry(block_group, &sinfo->block_groups[index], list) { 275 if (&attr->attr == BTRFS_RAID_ATTR_PTR(total_bytes)) 276 val += block_group->key.offset; 277 else 278 val += btrfs_block_group_used(&block_group->item); 279 } 280 up_read(&sinfo->groups_sem); 281 return snprintf(buf, PAGE_SIZE, "%llu\n", val); 282 } 283 284 static struct attribute *raid_attributes[] = { 285 BTRFS_RAID_ATTR_PTR(total_bytes), 286 BTRFS_RAID_ATTR_PTR(used_bytes), 287 NULL 288 }; 289 290 static void release_raid_kobj(struct kobject *kobj) 291 { 292 kfree(to_raid_kobj(kobj)); 293 } 294 295 struct kobj_type btrfs_raid_ktype = { 296 .sysfs_ops = &kobj_sysfs_ops, 297 .release = release_raid_kobj, 298 .default_attrs = raid_attributes, 299 }; 300 301 #define SPACE_INFO_ATTR(field) \ 302 static ssize_t btrfs_space_info_show_##field(struct kobject *kobj, \ 303 struct kobj_attribute *a, \ 304 char *buf) \ 305 { \ 306 struct btrfs_space_info *sinfo = to_space_info(kobj); \ 307 return btrfs_show_u64(&sinfo->field, &sinfo->lock, buf); \ 308 } \ 309 BTRFS_ATTR(field, btrfs_space_info_show_##field) 310 311 static ssize_t btrfs_space_info_show_total_bytes_pinned(struct kobject *kobj, 312 struct kobj_attribute *a, 313 char *buf) 314 { 315 struct btrfs_space_info *sinfo = to_space_info(kobj); 316 s64 val = percpu_counter_sum(&sinfo->total_bytes_pinned); 317 return snprintf(buf, PAGE_SIZE, "%lld\n", val); 318 } 319 320 SPACE_INFO_ATTR(flags); 321 SPACE_INFO_ATTR(total_bytes); 322 SPACE_INFO_ATTR(bytes_used); 323 SPACE_INFO_ATTR(bytes_pinned); 324 SPACE_INFO_ATTR(bytes_reserved); 325 SPACE_INFO_ATTR(bytes_may_use); 326 SPACE_INFO_ATTR(disk_used); 327 SPACE_INFO_ATTR(disk_total); 328 BTRFS_ATTR(total_bytes_pinned, btrfs_space_info_show_total_bytes_pinned); 329 330 static struct attribute *space_info_attrs[] = { 331 BTRFS_ATTR_PTR(flags), 332 BTRFS_ATTR_PTR(total_bytes), 333 BTRFS_ATTR_PTR(bytes_used), 334 BTRFS_ATTR_PTR(bytes_pinned), 335 BTRFS_ATTR_PTR(bytes_reserved), 336 BTRFS_ATTR_PTR(bytes_may_use), 337 BTRFS_ATTR_PTR(disk_used), 338 BTRFS_ATTR_PTR(disk_total), 339 BTRFS_ATTR_PTR(total_bytes_pinned), 340 NULL, 341 }; 342 343 static void space_info_release(struct kobject *kobj) 344 { 345 struct btrfs_space_info *sinfo = to_space_info(kobj); 346 percpu_counter_destroy(&sinfo->total_bytes_pinned); 347 kfree(sinfo); 348 } 349 350 struct kobj_type space_info_ktype = { 351 .sysfs_ops = &kobj_sysfs_ops, 352 .release = space_info_release, 353 .default_attrs = space_info_attrs, 354 }; 355 356 static const struct attribute *allocation_attrs[] = { 357 BTRFS_ATTR_PTR(global_rsv_reserved), 358 BTRFS_ATTR_PTR(global_rsv_size), 359 NULL, 360 }; 361 362 static ssize_t btrfs_label_show(struct kobject *kobj, 363 struct kobj_attribute *a, char *buf) 364 { 365 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 366 char *label = fs_info->super_copy->label; 367 return snprintf(buf, PAGE_SIZE, label[0] ? "%s\n" : "%s", label); 368 } 369 370 static ssize_t btrfs_label_store(struct kobject *kobj, 371 struct kobj_attribute *a, 372 const char *buf, size_t len) 373 { 374 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 375 size_t p_len; 376 377 if (fs_info->sb->s_flags & MS_RDONLY) 378 return -EROFS; 379 380 /* 381 * p_len is the len until the first occurrence of either 382 * '\n' or '\0' 383 */ 384 p_len = strcspn(buf, "\n"); 385 386 if (p_len >= BTRFS_LABEL_SIZE) 387 return -EINVAL; 388 389 spin_lock(&fs_info->super_lock); 390 memset(fs_info->super_copy->label, 0, BTRFS_LABEL_SIZE); 391 memcpy(fs_info->super_copy->label, buf, p_len); 392 spin_unlock(&fs_info->super_lock); 393 394 /* 395 * We don't want to do full transaction commit from inside sysfs 396 */ 397 btrfs_set_pending(fs_info, COMMIT); 398 wake_up_process(fs_info->transaction_kthread); 399 400 return len; 401 } 402 BTRFS_ATTR_RW(label, btrfs_label_show, btrfs_label_store); 403 404 static ssize_t btrfs_nodesize_show(struct kobject *kobj, 405 struct kobj_attribute *a, char *buf) 406 { 407 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 408 409 return snprintf(buf, PAGE_SIZE, "%u\n", fs_info->super_copy->nodesize); 410 } 411 412 BTRFS_ATTR(nodesize, btrfs_nodesize_show); 413 414 static ssize_t btrfs_sectorsize_show(struct kobject *kobj, 415 struct kobj_attribute *a, char *buf) 416 { 417 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 418 419 return snprintf(buf, PAGE_SIZE, "%u\n", fs_info->super_copy->sectorsize); 420 } 421 422 BTRFS_ATTR(sectorsize, btrfs_sectorsize_show); 423 424 static ssize_t btrfs_clone_alignment_show(struct kobject *kobj, 425 struct kobj_attribute *a, char *buf) 426 { 427 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 428 429 return snprintf(buf, PAGE_SIZE, "%u\n", fs_info->super_copy->sectorsize); 430 } 431 432 BTRFS_ATTR(clone_alignment, btrfs_clone_alignment_show); 433 434 static const struct attribute *btrfs_attrs[] = { 435 BTRFS_ATTR_PTR(label), 436 BTRFS_ATTR_PTR(nodesize), 437 BTRFS_ATTR_PTR(sectorsize), 438 BTRFS_ATTR_PTR(clone_alignment), 439 NULL, 440 }; 441 442 static void btrfs_release_fsid_kobj(struct kobject *kobj) 443 { 444 struct btrfs_fs_devices *fs_devs = to_fs_devs(kobj); 445 446 memset(&fs_devs->fsid_kobj, 0, sizeof(struct kobject)); 447 complete(&fs_devs->kobj_unregister); 448 } 449 450 static struct kobj_type btrfs_ktype = { 451 .sysfs_ops = &kobj_sysfs_ops, 452 .release = btrfs_release_fsid_kobj, 453 }; 454 455 static inline struct btrfs_fs_devices *to_fs_devs(struct kobject *kobj) 456 { 457 if (kobj->ktype != &btrfs_ktype) 458 return NULL; 459 return container_of(kobj, struct btrfs_fs_devices, fsid_kobj); 460 } 461 462 static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj) 463 { 464 if (kobj->ktype != &btrfs_ktype) 465 return NULL; 466 return to_fs_devs(kobj)->fs_info; 467 } 468 469 #define NUM_FEATURE_BITS 64 470 static char btrfs_unknown_feature_names[3][NUM_FEATURE_BITS][13]; 471 static struct btrfs_feature_attr btrfs_feature_attrs[3][NUM_FEATURE_BITS]; 472 473 static const u64 supported_feature_masks[3] = { 474 [FEAT_COMPAT] = BTRFS_FEATURE_COMPAT_SUPP, 475 [FEAT_COMPAT_RO] = BTRFS_FEATURE_COMPAT_RO_SUPP, 476 [FEAT_INCOMPAT] = BTRFS_FEATURE_INCOMPAT_SUPP, 477 }; 478 479 static int addrm_unknown_feature_attrs(struct btrfs_fs_info *fs_info, bool add) 480 { 481 int set; 482 483 for (set = 0; set < FEAT_MAX; set++) { 484 int i; 485 struct attribute *attrs[2]; 486 struct attribute_group agroup = { 487 .name = "features", 488 .attrs = attrs, 489 }; 490 u64 features = get_features(fs_info, set); 491 features &= ~supported_feature_masks[set]; 492 493 if (!features) 494 continue; 495 496 attrs[1] = NULL; 497 for (i = 0; i < NUM_FEATURE_BITS; i++) { 498 struct btrfs_feature_attr *fa; 499 500 if (!(features & (1ULL << i))) 501 continue; 502 503 fa = &btrfs_feature_attrs[set][i]; 504 attrs[0] = &fa->kobj_attr.attr; 505 if (add) { 506 int ret; 507 ret = sysfs_merge_group(&fs_info->fs_devices->fsid_kobj, 508 &agroup); 509 if (ret) 510 return ret; 511 } else 512 sysfs_unmerge_group(&fs_info->fs_devices->fsid_kobj, 513 &agroup); 514 } 515 516 } 517 return 0; 518 } 519 520 static void __btrfs_sysfs_remove_fsid(struct btrfs_fs_devices *fs_devs) 521 { 522 if (fs_devs->device_dir_kobj) { 523 kobject_del(fs_devs->device_dir_kobj); 524 kobject_put(fs_devs->device_dir_kobj); 525 fs_devs->device_dir_kobj = NULL; 526 } 527 528 if (fs_devs->fsid_kobj.state_initialized) { 529 kobject_del(&fs_devs->fsid_kobj); 530 kobject_put(&fs_devs->fsid_kobj); 531 wait_for_completion(&fs_devs->kobj_unregister); 532 } 533 } 534 535 /* when fs_devs is NULL it will remove all fsid kobject */ 536 void btrfs_sysfs_remove_fsid(struct btrfs_fs_devices *fs_devs) 537 { 538 struct list_head *fs_uuids = btrfs_get_fs_uuids(); 539 540 if (fs_devs) { 541 __btrfs_sysfs_remove_fsid(fs_devs); 542 return; 543 } 544 545 list_for_each_entry(fs_devs, fs_uuids, list) { 546 __btrfs_sysfs_remove_fsid(fs_devs); 547 } 548 } 549 550 void btrfs_sysfs_remove_mounted(struct btrfs_fs_info *fs_info) 551 { 552 btrfs_reset_fs_info_ptr(fs_info); 553 554 if (fs_info->space_info_kobj) { 555 sysfs_remove_files(fs_info->space_info_kobj, allocation_attrs); 556 kobject_del(fs_info->space_info_kobj); 557 kobject_put(fs_info->space_info_kobj); 558 } 559 addrm_unknown_feature_attrs(fs_info, false); 560 sysfs_remove_group(&fs_info->fs_devices->fsid_kobj, &btrfs_feature_attr_group); 561 sysfs_remove_files(&fs_info->fs_devices->fsid_kobj, btrfs_attrs); 562 btrfs_sysfs_rm_device_link(fs_info->fs_devices, NULL); 563 } 564 565 const char * const btrfs_feature_set_names[3] = { 566 [FEAT_COMPAT] = "compat", 567 [FEAT_COMPAT_RO] = "compat_ro", 568 [FEAT_INCOMPAT] = "incompat", 569 }; 570 571 char *btrfs_printable_features(enum btrfs_feature_set set, u64 flags) 572 { 573 size_t bufsize = 4096; /* safe max, 64 names * 64 bytes */ 574 int len = 0; 575 int i; 576 char *str; 577 578 str = kmalloc(bufsize, GFP_KERNEL); 579 if (!str) 580 return str; 581 582 for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) { 583 const char *name; 584 585 if (!(flags & (1ULL << i))) 586 continue; 587 588 name = btrfs_feature_attrs[set][i].kobj_attr.attr.name; 589 len += snprintf(str + len, bufsize - len, "%s%s", 590 len ? "," : "", name); 591 } 592 593 return str; 594 } 595 596 static void init_feature_attrs(void) 597 { 598 struct btrfs_feature_attr *fa; 599 int set, i; 600 601 BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names) != 602 ARRAY_SIZE(btrfs_feature_attrs)); 603 BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names[0]) != 604 ARRAY_SIZE(btrfs_feature_attrs[0])); 605 606 memset(btrfs_feature_attrs, 0, sizeof(btrfs_feature_attrs)); 607 memset(btrfs_unknown_feature_names, 0, 608 sizeof(btrfs_unknown_feature_names)); 609 610 for (i = 0; btrfs_supported_feature_attrs[i]; i++) { 611 struct btrfs_feature_attr *sfa; 612 struct attribute *a = btrfs_supported_feature_attrs[i]; 613 int bit; 614 sfa = attr_to_btrfs_feature_attr(a); 615 bit = ilog2(sfa->feature_bit); 616 fa = &btrfs_feature_attrs[sfa->feature_set][bit]; 617 618 fa->kobj_attr.attr.name = sfa->kobj_attr.attr.name; 619 } 620 621 for (set = 0; set < FEAT_MAX; set++) { 622 for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) { 623 char *name = btrfs_unknown_feature_names[set][i]; 624 fa = &btrfs_feature_attrs[set][i]; 625 626 if (fa->kobj_attr.attr.name) 627 continue; 628 629 snprintf(name, 13, "%s:%u", 630 btrfs_feature_set_names[set], i); 631 632 fa->kobj_attr.attr.name = name; 633 fa->kobj_attr.attr.mode = S_IRUGO; 634 fa->feature_set = set; 635 fa->feature_bit = 1ULL << i; 636 } 637 } 638 } 639 640 /* when one_device is NULL, it removes all device links */ 641 642 int btrfs_sysfs_rm_device_link(struct btrfs_fs_devices *fs_devices, 643 struct btrfs_device *one_device) 644 { 645 struct hd_struct *disk; 646 struct kobject *disk_kobj; 647 648 if (!fs_devices->device_dir_kobj) 649 return -EINVAL; 650 651 if (one_device && one_device->bdev) { 652 disk = one_device->bdev->bd_part; 653 disk_kobj = &part_to_dev(disk)->kobj; 654 655 sysfs_remove_link(fs_devices->device_dir_kobj, 656 disk_kobj->name); 657 } 658 659 if (one_device) 660 return 0; 661 662 list_for_each_entry(one_device, 663 &fs_devices->devices, dev_list) { 664 if (!one_device->bdev) 665 continue; 666 disk = one_device->bdev->bd_part; 667 disk_kobj = &part_to_dev(disk)->kobj; 668 669 sysfs_remove_link(fs_devices->device_dir_kobj, 670 disk_kobj->name); 671 } 672 673 return 0; 674 } 675 676 int btrfs_sysfs_add_device(struct btrfs_fs_devices *fs_devs) 677 { 678 if (!fs_devs->device_dir_kobj) 679 fs_devs->device_dir_kobj = kobject_create_and_add("devices", 680 &fs_devs->fsid_kobj); 681 682 if (!fs_devs->device_dir_kobj) 683 return -ENOMEM; 684 685 return 0; 686 } 687 688 int btrfs_sysfs_add_device_link(struct btrfs_fs_devices *fs_devices, 689 struct btrfs_device *one_device) 690 { 691 int error = 0; 692 struct btrfs_device *dev; 693 694 list_for_each_entry(dev, &fs_devices->devices, dev_list) { 695 struct hd_struct *disk; 696 struct kobject *disk_kobj; 697 698 if (!dev->bdev) 699 continue; 700 701 if (one_device && one_device != dev) 702 continue; 703 704 disk = dev->bdev->bd_part; 705 disk_kobj = &part_to_dev(disk)->kobj; 706 707 error = sysfs_create_link(fs_devices->device_dir_kobj, 708 disk_kobj, disk_kobj->name); 709 if (error) 710 break; 711 } 712 713 return error; 714 } 715 716 /* /sys/fs/btrfs/ entry */ 717 static struct kset *btrfs_kset; 718 719 /* /sys/kernel/debug/btrfs */ 720 static struct dentry *btrfs_debugfs_root_dentry; 721 722 /* Debugging tunables and exported data */ 723 u64 btrfs_debugfs_test; 724 725 /* 726 * Can be called by the device discovery thread. 727 * And parent can be specified for seed device 728 */ 729 int btrfs_sysfs_add_fsid(struct btrfs_fs_devices *fs_devs, 730 struct kobject *parent) 731 { 732 int error; 733 734 init_completion(&fs_devs->kobj_unregister); 735 fs_devs->fsid_kobj.kset = btrfs_kset; 736 error = kobject_init_and_add(&fs_devs->fsid_kobj, 737 &btrfs_ktype, parent, "%pU", fs_devs->fsid); 738 return error; 739 } 740 741 int btrfs_sysfs_add_mounted(struct btrfs_fs_info *fs_info) 742 { 743 int error; 744 struct btrfs_fs_devices *fs_devs = fs_info->fs_devices; 745 struct kobject *fsid_kobj = &fs_devs->fsid_kobj; 746 747 btrfs_set_fs_info_ptr(fs_info); 748 749 error = btrfs_sysfs_add_device_link(fs_devs, NULL); 750 if (error) 751 return error; 752 753 error = sysfs_create_files(fsid_kobj, btrfs_attrs); 754 if (error) { 755 btrfs_sysfs_rm_device_link(fs_devs, NULL); 756 return error; 757 } 758 759 error = sysfs_create_group(fsid_kobj, 760 &btrfs_feature_attr_group); 761 if (error) 762 goto failure; 763 764 error = addrm_unknown_feature_attrs(fs_info, true); 765 if (error) 766 goto failure; 767 768 fs_info->space_info_kobj = kobject_create_and_add("allocation", 769 fsid_kobj); 770 if (!fs_info->space_info_kobj) { 771 error = -ENOMEM; 772 goto failure; 773 } 774 775 error = sysfs_create_files(fs_info->space_info_kobj, allocation_attrs); 776 if (error) 777 goto failure; 778 779 return 0; 780 failure: 781 btrfs_sysfs_remove_mounted(fs_info); 782 return error; 783 } 784 785 786 /* 787 * Change per-fs features in /sys/fs/btrfs/UUID/features to match current 788 * values in superblock. Call after any changes to incompat/compat_ro flags 789 */ 790 void btrfs_sysfs_feature_update(struct btrfs_fs_info *fs_info, 791 u64 bit, enum btrfs_feature_set set) 792 { 793 struct btrfs_fs_devices *fs_devs; 794 struct kobject *fsid_kobj; 795 u64 features; 796 int ret; 797 798 if (!fs_info) 799 return; 800 801 features = get_features(fs_info, set); 802 ASSERT(bit & supported_feature_masks[set]); 803 804 fs_devs = fs_info->fs_devices; 805 fsid_kobj = &fs_devs->fsid_kobj; 806 807 if (!fsid_kobj->state_initialized) 808 return; 809 810 /* 811 * FIXME: this is too heavy to update just one value, ideally we'd like 812 * to use sysfs_update_group but some refactoring is needed first. 813 */ 814 sysfs_remove_group(fsid_kobj, &btrfs_feature_attr_group); 815 ret = sysfs_create_group(fsid_kobj, &btrfs_feature_attr_group); 816 } 817 818 static int btrfs_init_debugfs(void) 819 { 820 #ifdef CONFIG_DEBUG_FS 821 btrfs_debugfs_root_dentry = debugfs_create_dir("btrfs", NULL); 822 if (!btrfs_debugfs_root_dentry) 823 return -ENOMEM; 824 825 debugfs_create_u64("test", S_IRUGO | S_IWUGO, btrfs_debugfs_root_dentry, 826 &btrfs_debugfs_test); 827 #endif 828 return 0; 829 } 830 831 int btrfs_init_sysfs(void) 832 { 833 int ret; 834 835 btrfs_kset = kset_create_and_add("btrfs", NULL, fs_kobj); 836 if (!btrfs_kset) 837 return -ENOMEM; 838 839 ret = btrfs_init_debugfs(); 840 if (ret) 841 goto out1; 842 843 init_feature_attrs(); 844 ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_feature_attr_group); 845 if (ret) 846 goto out2; 847 848 return 0; 849 out2: 850 debugfs_remove_recursive(btrfs_debugfs_root_dentry); 851 out1: 852 kset_unregister(btrfs_kset); 853 854 return ret; 855 } 856 857 void btrfs_exit_sysfs(void) 858 { 859 sysfs_remove_group(&btrfs_kset->kobj, &btrfs_feature_attr_group); 860 kset_unregister(btrfs_kset); 861 debugfs_remove_recursive(btrfs_debugfs_root_dentry); 862 } 863 864