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(bytes_readonly); 330 SPACE_INFO_ATTR(disk_used); 331 SPACE_INFO_ATTR(disk_total); 332 BTRFS_ATTR(total_bytes_pinned, btrfs_space_info_show_total_bytes_pinned); 333 334 static struct attribute *space_info_attrs[] = { 335 BTRFS_ATTR_PTR(flags), 336 BTRFS_ATTR_PTR(total_bytes), 337 BTRFS_ATTR_PTR(bytes_used), 338 BTRFS_ATTR_PTR(bytes_pinned), 339 BTRFS_ATTR_PTR(bytes_reserved), 340 BTRFS_ATTR_PTR(bytes_may_use), 341 BTRFS_ATTR_PTR(bytes_readonly), 342 BTRFS_ATTR_PTR(disk_used), 343 BTRFS_ATTR_PTR(disk_total), 344 BTRFS_ATTR_PTR(total_bytes_pinned), 345 NULL, 346 }; 347 348 static void space_info_release(struct kobject *kobj) 349 { 350 struct btrfs_space_info *sinfo = to_space_info(kobj); 351 percpu_counter_destroy(&sinfo->total_bytes_pinned); 352 kfree(sinfo); 353 } 354 355 struct kobj_type space_info_ktype = { 356 .sysfs_ops = &kobj_sysfs_ops, 357 .release = space_info_release, 358 .default_attrs = space_info_attrs, 359 }; 360 361 static const struct attribute *allocation_attrs[] = { 362 BTRFS_ATTR_PTR(global_rsv_reserved), 363 BTRFS_ATTR_PTR(global_rsv_size), 364 NULL, 365 }; 366 367 static ssize_t btrfs_label_show(struct kobject *kobj, 368 struct kobj_attribute *a, char *buf) 369 { 370 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 371 char *label = fs_info->super_copy->label; 372 ssize_t ret; 373 374 spin_lock(&fs_info->super_lock); 375 ret = snprintf(buf, PAGE_SIZE, label[0] ? "%s\n" : "%s", label); 376 spin_unlock(&fs_info->super_lock); 377 378 return ret; 379 } 380 381 static ssize_t btrfs_label_store(struct kobject *kobj, 382 struct kobj_attribute *a, 383 const char *buf, size_t len) 384 { 385 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 386 size_t p_len; 387 388 if (!fs_info) 389 return -EPERM; 390 391 if (fs_info->sb->s_flags & MS_RDONLY) 392 return -EROFS; 393 394 /* 395 * p_len is the len until the first occurrence of either 396 * '\n' or '\0' 397 */ 398 p_len = strcspn(buf, "\n"); 399 400 if (p_len >= BTRFS_LABEL_SIZE) 401 return -EINVAL; 402 403 spin_lock(&fs_info->super_lock); 404 memset(fs_info->super_copy->label, 0, BTRFS_LABEL_SIZE); 405 memcpy(fs_info->super_copy->label, buf, p_len); 406 spin_unlock(&fs_info->super_lock); 407 408 /* 409 * We don't want to do full transaction commit from inside sysfs 410 */ 411 btrfs_set_pending(fs_info, COMMIT); 412 wake_up_process(fs_info->transaction_kthread); 413 414 return len; 415 } 416 BTRFS_ATTR_RW(label, btrfs_label_show, btrfs_label_store); 417 418 static ssize_t btrfs_nodesize_show(struct kobject *kobj, 419 struct kobj_attribute *a, char *buf) 420 { 421 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 422 423 return snprintf(buf, PAGE_SIZE, "%u\n", fs_info->super_copy->nodesize); 424 } 425 426 BTRFS_ATTR(nodesize, btrfs_nodesize_show); 427 428 static ssize_t btrfs_sectorsize_show(struct kobject *kobj, 429 struct kobj_attribute *a, char *buf) 430 { 431 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 432 433 return snprintf(buf, PAGE_SIZE, "%u\n", fs_info->super_copy->sectorsize); 434 } 435 436 BTRFS_ATTR(sectorsize, btrfs_sectorsize_show); 437 438 static ssize_t btrfs_clone_alignment_show(struct kobject *kobj, 439 struct kobj_attribute *a, char *buf) 440 { 441 struct btrfs_fs_info *fs_info = to_fs_info(kobj); 442 443 return snprintf(buf, PAGE_SIZE, "%u\n", fs_info->super_copy->sectorsize); 444 } 445 446 BTRFS_ATTR(clone_alignment, btrfs_clone_alignment_show); 447 448 static const struct attribute *btrfs_attrs[] = { 449 BTRFS_ATTR_PTR(label), 450 BTRFS_ATTR_PTR(nodesize), 451 BTRFS_ATTR_PTR(sectorsize), 452 BTRFS_ATTR_PTR(clone_alignment), 453 NULL, 454 }; 455 456 static void btrfs_release_fsid_kobj(struct kobject *kobj) 457 { 458 struct btrfs_fs_devices *fs_devs = to_fs_devs(kobj); 459 460 memset(&fs_devs->fsid_kobj, 0, sizeof(struct kobject)); 461 complete(&fs_devs->kobj_unregister); 462 } 463 464 static struct kobj_type btrfs_ktype = { 465 .sysfs_ops = &kobj_sysfs_ops, 466 .release = btrfs_release_fsid_kobj, 467 }; 468 469 static inline struct btrfs_fs_devices *to_fs_devs(struct kobject *kobj) 470 { 471 if (kobj->ktype != &btrfs_ktype) 472 return NULL; 473 return container_of(kobj, struct btrfs_fs_devices, fsid_kobj); 474 } 475 476 static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj) 477 { 478 if (kobj->ktype != &btrfs_ktype) 479 return NULL; 480 return to_fs_devs(kobj)->fs_info; 481 } 482 483 #define NUM_FEATURE_BITS 64 484 static char btrfs_unknown_feature_names[3][NUM_FEATURE_BITS][13]; 485 static struct btrfs_feature_attr btrfs_feature_attrs[3][NUM_FEATURE_BITS]; 486 487 static const u64 supported_feature_masks[3] = { 488 [FEAT_COMPAT] = BTRFS_FEATURE_COMPAT_SUPP, 489 [FEAT_COMPAT_RO] = BTRFS_FEATURE_COMPAT_RO_SUPP, 490 [FEAT_INCOMPAT] = BTRFS_FEATURE_INCOMPAT_SUPP, 491 }; 492 493 static int addrm_unknown_feature_attrs(struct btrfs_fs_info *fs_info, bool add) 494 { 495 int set; 496 497 for (set = 0; set < FEAT_MAX; set++) { 498 int i; 499 struct attribute *attrs[2]; 500 struct attribute_group agroup = { 501 .name = "features", 502 .attrs = attrs, 503 }; 504 u64 features = get_features(fs_info, set); 505 features &= ~supported_feature_masks[set]; 506 507 if (!features) 508 continue; 509 510 attrs[1] = NULL; 511 for (i = 0; i < NUM_FEATURE_BITS; i++) { 512 struct btrfs_feature_attr *fa; 513 514 if (!(features & (1ULL << i))) 515 continue; 516 517 fa = &btrfs_feature_attrs[set][i]; 518 attrs[0] = &fa->kobj_attr.attr; 519 if (add) { 520 int ret; 521 ret = sysfs_merge_group(&fs_info->fs_devices->fsid_kobj, 522 &agroup); 523 if (ret) 524 return ret; 525 } else 526 sysfs_unmerge_group(&fs_info->fs_devices->fsid_kobj, 527 &agroup); 528 } 529 530 } 531 return 0; 532 } 533 534 static void __btrfs_sysfs_remove_fsid(struct btrfs_fs_devices *fs_devs) 535 { 536 if (fs_devs->device_dir_kobj) { 537 kobject_del(fs_devs->device_dir_kobj); 538 kobject_put(fs_devs->device_dir_kobj); 539 fs_devs->device_dir_kobj = NULL; 540 } 541 542 if (fs_devs->fsid_kobj.state_initialized) { 543 kobject_del(&fs_devs->fsid_kobj); 544 kobject_put(&fs_devs->fsid_kobj); 545 wait_for_completion(&fs_devs->kobj_unregister); 546 } 547 } 548 549 /* when fs_devs is NULL it will remove all fsid kobject */ 550 void btrfs_sysfs_remove_fsid(struct btrfs_fs_devices *fs_devs) 551 { 552 struct list_head *fs_uuids = btrfs_get_fs_uuids(); 553 554 if (fs_devs) { 555 __btrfs_sysfs_remove_fsid(fs_devs); 556 return; 557 } 558 559 list_for_each_entry(fs_devs, fs_uuids, list) { 560 __btrfs_sysfs_remove_fsid(fs_devs); 561 } 562 } 563 564 void btrfs_sysfs_remove_mounted(struct btrfs_fs_info *fs_info) 565 { 566 btrfs_reset_fs_info_ptr(fs_info); 567 568 if (fs_info->space_info_kobj) { 569 sysfs_remove_files(fs_info->space_info_kobj, allocation_attrs); 570 kobject_del(fs_info->space_info_kobj); 571 kobject_put(fs_info->space_info_kobj); 572 } 573 addrm_unknown_feature_attrs(fs_info, false); 574 sysfs_remove_group(&fs_info->fs_devices->fsid_kobj, &btrfs_feature_attr_group); 575 sysfs_remove_files(&fs_info->fs_devices->fsid_kobj, btrfs_attrs); 576 btrfs_sysfs_rm_device_link(fs_info->fs_devices, NULL); 577 } 578 579 const char * const btrfs_feature_set_names[3] = { 580 [FEAT_COMPAT] = "compat", 581 [FEAT_COMPAT_RO] = "compat_ro", 582 [FEAT_INCOMPAT] = "incompat", 583 }; 584 585 char *btrfs_printable_features(enum btrfs_feature_set set, u64 flags) 586 { 587 size_t bufsize = 4096; /* safe max, 64 names * 64 bytes */ 588 int len = 0; 589 int i; 590 char *str; 591 592 str = kmalloc(bufsize, GFP_KERNEL); 593 if (!str) 594 return str; 595 596 for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) { 597 const char *name; 598 599 if (!(flags & (1ULL << i))) 600 continue; 601 602 name = btrfs_feature_attrs[set][i].kobj_attr.attr.name; 603 len += snprintf(str + len, bufsize - len, "%s%s", 604 len ? "," : "", name); 605 } 606 607 return str; 608 } 609 610 static void init_feature_attrs(void) 611 { 612 struct btrfs_feature_attr *fa; 613 int set, i; 614 615 BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names) != 616 ARRAY_SIZE(btrfs_feature_attrs)); 617 BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names[0]) != 618 ARRAY_SIZE(btrfs_feature_attrs[0])); 619 620 memset(btrfs_feature_attrs, 0, sizeof(btrfs_feature_attrs)); 621 memset(btrfs_unknown_feature_names, 0, 622 sizeof(btrfs_unknown_feature_names)); 623 624 for (i = 0; btrfs_supported_feature_attrs[i]; i++) { 625 struct btrfs_feature_attr *sfa; 626 struct attribute *a = btrfs_supported_feature_attrs[i]; 627 int bit; 628 sfa = attr_to_btrfs_feature_attr(a); 629 bit = ilog2(sfa->feature_bit); 630 fa = &btrfs_feature_attrs[sfa->feature_set][bit]; 631 632 fa->kobj_attr.attr.name = sfa->kobj_attr.attr.name; 633 } 634 635 for (set = 0; set < FEAT_MAX; set++) { 636 for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) { 637 char *name = btrfs_unknown_feature_names[set][i]; 638 fa = &btrfs_feature_attrs[set][i]; 639 640 if (fa->kobj_attr.attr.name) 641 continue; 642 643 snprintf(name, 13, "%s:%u", 644 btrfs_feature_set_names[set], i); 645 646 fa->kobj_attr.attr.name = name; 647 fa->kobj_attr.attr.mode = S_IRUGO; 648 fa->feature_set = set; 649 fa->feature_bit = 1ULL << i; 650 } 651 } 652 } 653 654 /* when one_device is NULL, it removes all device links */ 655 656 int btrfs_sysfs_rm_device_link(struct btrfs_fs_devices *fs_devices, 657 struct btrfs_device *one_device) 658 { 659 struct hd_struct *disk; 660 struct kobject *disk_kobj; 661 662 if (!fs_devices->device_dir_kobj) 663 return -EINVAL; 664 665 if (one_device && one_device->bdev) { 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 if (one_device) 674 return 0; 675 676 list_for_each_entry(one_device, 677 &fs_devices->devices, dev_list) { 678 if (!one_device->bdev) 679 continue; 680 disk = one_device->bdev->bd_part; 681 disk_kobj = &part_to_dev(disk)->kobj; 682 683 sysfs_remove_link(fs_devices->device_dir_kobj, 684 disk_kobj->name); 685 } 686 687 return 0; 688 } 689 690 int btrfs_sysfs_add_device(struct btrfs_fs_devices *fs_devs) 691 { 692 if (!fs_devs->device_dir_kobj) 693 fs_devs->device_dir_kobj = kobject_create_and_add("devices", 694 &fs_devs->fsid_kobj); 695 696 if (!fs_devs->device_dir_kobj) 697 return -ENOMEM; 698 699 return 0; 700 } 701 702 int btrfs_sysfs_add_device_link(struct btrfs_fs_devices *fs_devices, 703 struct btrfs_device *one_device) 704 { 705 int error = 0; 706 struct btrfs_device *dev; 707 708 list_for_each_entry(dev, &fs_devices->devices, dev_list) { 709 struct hd_struct *disk; 710 struct kobject *disk_kobj; 711 712 if (!dev->bdev) 713 continue; 714 715 if (one_device && one_device != dev) 716 continue; 717 718 disk = dev->bdev->bd_part; 719 disk_kobj = &part_to_dev(disk)->kobj; 720 721 error = sysfs_create_link(fs_devices->device_dir_kobj, 722 disk_kobj, disk_kobj->name); 723 if (error) 724 break; 725 } 726 727 return error; 728 } 729 730 /* /sys/fs/btrfs/ entry */ 731 static struct kset *btrfs_kset; 732 733 /* /sys/kernel/debug/btrfs */ 734 static struct dentry *btrfs_debugfs_root_dentry; 735 736 /* Debugging tunables and exported data */ 737 u64 btrfs_debugfs_test; 738 739 /* 740 * Can be called by the device discovery thread. 741 * And parent can be specified for seed device 742 */ 743 int btrfs_sysfs_add_fsid(struct btrfs_fs_devices *fs_devs, 744 struct kobject *parent) 745 { 746 int error; 747 748 init_completion(&fs_devs->kobj_unregister); 749 fs_devs->fsid_kobj.kset = btrfs_kset; 750 error = kobject_init_and_add(&fs_devs->fsid_kobj, 751 &btrfs_ktype, parent, "%pU", fs_devs->fsid); 752 return error; 753 } 754 755 int btrfs_sysfs_add_mounted(struct btrfs_fs_info *fs_info) 756 { 757 int error; 758 struct btrfs_fs_devices *fs_devs = fs_info->fs_devices; 759 struct kobject *fsid_kobj = &fs_devs->fsid_kobj; 760 761 btrfs_set_fs_info_ptr(fs_info); 762 763 error = btrfs_sysfs_add_device_link(fs_devs, NULL); 764 if (error) 765 return error; 766 767 error = sysfs_create_files(fsid_kobj, btrfs_attrs); 768 if (error) { 769 btrfs_sysfs_rm_device_link(fs_devs, NULL); 770 return error; 771 } 772 773 error = sysfs_create_group(fsid_kobj, 774 &btrfs_feature_attr_group); 775 if (error) 776 goto failure; 777 778 error = addrm_unknown_feature_attrs(fs_info, true); 779 if (error) 780 goto failure; 781 782 fs_info->space_info_kobj = kobject_create_and_add("allocation", 783 fsid_kobj); 784 if (!fs_info->space_info_kobj) { 785 error = -ENOMEM; 786 goto failure; 787 } 788 789 error = sysfs_create_files(fs_info->space_info_kobj, allocation_attrs); 790 if (error) 791 goto failure; 792 793 return 0; 794 failure: 795 btrfs_sysfs_remove_mounted(fs_info); 796 return error; 797 } 798 799 800 /* 801 * Change per-fs features in /sys/fs/btrfs/UUID/features to match current 802 * values in superblock. Call after any changes to incompat/compat_ro flags 803 */ 804 void btrfs_sysfs_feature_update(struct btrfs_fs_info *fs_info, 805 u64 bit, enum btrfs_feature_set set) 806 { 807 struct btrfs_fs_devices *fs_devs; 808 struct kobject *fsid_kobj; 809 u64 features; 810 int ret; 811 812 if (!fs_info) 813 return; 814 815 features = get_features(fs_info, set); 816 ASSERT(bit & supported_feature_masks[set]); 817 818 fs_devs = fs_info->fs_devices; 819 fsid_kobj = &fs_devs->fsid_kobj; 820 821 if (!fsid_kobj->state_initialized) 822 return; 823 824 /* 825 * FIXME: this is too heavy to update just one value, ideally we'd like 826 * to use sysfs_update_group but some refactoring is needed first. 827 */ 828 sysfs_remove_group(fsid_kobj, &btrfs_feature_attr_group); 829 ret = sysfs_create_group(fsid_kobj, &btrfs_feature_attr_group); 830 } 831 832 static int btrfs_init_debugfs(void) 833 { 834 #ifdef CONFIG_DEBUG_FS 835 btrfs_debugfs_root_dentry = debugfs_create_dir("btrfs", NULL); 836 if (!btrfs_debugfs_root_dentry) 837 return -ENOMEM; 838 839 debugfs_create_u64("test", S_IRUGO | S_IWUGO, btrfs_debugfs_root_dentry, 840 &btrfs_debugfs_test); 841 #endif 842 return 0; 843 } 844 845 int btrfs_init_sysfs(void) 846 { 847 int ret; 848 849 btrfs_kset = kset_create_and_add("btrfs", NULL, fs_kobj); 850 if (!btrfs_kset) 851 return -ENOMEM; 852 853 ret = btrfs_init_debugfs(); 854 if (ret) 855 goto out1; 856 857 init_feature_attrs(); 858 ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_feature_attr_group); 859 if (ret) 860 goto out2; 861 862 return 0; 863 out2: 864 debugfs_remove_recursive(btrfs_debugfs_root_dentry); 865 out1: 866 kset_unregister(btrfs_kset); 867 868 return ret; 869 } 870 871 void btrfs_exit_sysfs(void) 872 { 873 sysfs_remove_group(&btrfs_kset->kobj, &btrfs_feature_attr_group); 874 kset_unregister(btrfs_kset); 875 debugfs_remove_recursive(btrfs_debugfs_root_dentry); 876 } 877 878