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