1c1d7c514SDavid Sterba // SPDX-License-Identifier: GPL-2.0 26cbd5570SChris Mason /* 36cbd5570SChris Mason * Copyright (C) 2007 Oracle. All rights reserved. 46cbd5570SChris Mason */ 56cbd5570SChris Mason 658176a96SJosef Bacik #include <linux/sched.h> 732a9991fSDavid Sterba #include <linux/sched/mm.h> 858176a96SJosef Bacik #include <linux/slab.h> 958176a96SJosef Bacik #include <linux/spinlock.h> 1058176a96SJosef Bacik #include <linux/completion.h> 1179da4fa4SJeff Mahoney #include <linux/bug.h> 1241e6d2a8SJohannes Thumshirn #include <crypto/hash.h> 1358176a96SJosef Bacik 14bae45de0SChris Mason #include "ctree.h" 15dfb79ddbSDennis Zhou #include "discard.h" 16bae45de0SChris Mason #include "disk-io.h" 177573df55SOmar Sandoval #include "send.h" 18bae45de0SChris Mason #include "transaction.h" 19079b72bcSJeff Mahoney #include "sysfs.h" 2029e5be24SJeff Mahoney #include "volumes.h" 218719aaaeSJosef Bacik #include "space-info.h" 22aac0023cSJosef Bacik #include "block-group.h" 2349e5fb46SQu Wenruo #include "qgroup.h" 24079b72bcSJeff Mahoney 259188db61SDavid Sterba struct btrfs_feature_attr { 269188db61SDavid Sterba struct kobj_attribute kobj_attr; 279188db61SDavid Sterba enum btrfs_feature_set feature_set; 289188db61SDavid Sterba u64 feature_bit; 299188db61SDavid Sterba }; 309188db61SDavid Sterba 319188db61SDavid Sterba /* For raid type sysfs entries */ 329188db61SDavid Sterba struct raid_kobject { 339188db61SDavid Sterba u64 flags; 349188db61SDavid Sterba struct kobject kobj; 359188db61SDavid Sterba }; 369188db61SDavid Sterba 379188db61SDavid Sterba #define __INIT_KOBJ_ATTR(_name, _mode, _show, _store) \ 389188db61SDavid Sterba { \ 399188db61SDavid Sterba .attr = { .name = __stringify(_name), .mode = _mode }, \ 409188db61SDavid Sterba .show = _show, \ 419188db61SDavid Sterba .store = _store, \ 429188db61SDavid Sterba } 439188db61SDavid Sterba 449188db61SDavid Sterba #define BTRFS_ATTR_RW(_prefix, _name, _show, _store) \ 459188db61SDavid Sterba static struct kobj_attribute btrfs_attr_##_prefix##_##_name = \ 469188db61SDavid Sterba __INIT_KOBJ_ATTR(_name, 0644, _show, _store) 479188db61SDavid Sterba 489188db61SDavid Sterba #define BTRFS_ATTR(_prefix, _name, _show) \ 499188db61SDavid Sterba static struct kobj_attribute btrfs_attr_##_prefix##_##_name = \ 509188db61SDavid Sterba __INIT_KOBJ_ATTR(_name, 0444, _show, NULL) 519188db61SDavid Sterba 529188db61SDavid Sterba #define BTRFS_ATTR_PTR(_prefix, _name) \ 539188db61SDavid Sterba (&btrfs_attr_##_prefix##_##_name.attr) 549188db61SDavid Sterba 559188db61SDavid Sterba #define BTRFS_FEAT_ATTR(_name, _feature_set, _feature_prefix, _feature_bit) \ 569188db61SDavid Sterba static struct btrfs_feature_attr btrfs_attr_features_##_name = { \ 579188db61SDavid Sterba .kobj_attr = __INIT_KOBJ_ATTR(_name, S_IRUGO, \ 589188db61SDavid Sterba btrfs_feature_attr_show, \ 599188db61SDavid Sterba btrfs_feature_attr_store), \ 609188db61SDavid Sterba .feature_set = _feature_set, \ 619188db61SDavid Sterba .feature_bit = _feature_prefix ##_## _feature_bit, \ 629188db61SDavid Sterba } 639188db61SDavid Sterba #define BTRFS_FEAT_ATTR_PTR(_name) \ 649188db61SDavid Sterba (&btrfs_attr_features_##_name.kobj_attr.attr) 659188db61SDavid Sterba 669188db61SDavid Sterba #define BTRFS_FEAT_ATTR_COMPAT(name, feature) \ 679188db61SDavid Sterba BTRFS_FEAT_ATTR(name, FEAT_COMPAT, BTRFS_FEATURE_COMPAT, feature) 689188db61SDavid Sterba #define BTRFS_FEAT_ATTR_COMPAT_RO(name, feature) \ 699188db61SDavid Sterba BTRFS_FEAT_ATTR(name, FEAT_COMPAT_RO, BTRFS_FEATURE_COMPAT_RO, feature) 709188db61SDavid Sterba #define BTRFS_FEAT_ATTR_INCOMPAT(name, feature) \ 719188db61SDavid Sterba BTRFS_FEAT_ATTR(name, FEAT_INCOMPAT, BTRFS_FEATURE_INCOMPAT, feature) 729188db61SDavid Sterba 73510d7360SJeff Mahoney static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj); 742e7910d6SAnand Jain static inline struct btrfs_fs_devices *to_fs_devs(struct kobject *kobj); 755ac1d209SJeff Mahoney 768f52316cSDavid Sterba static struct btrfs_feature_attr *to_btrfs_feature_attr(struct kobj_attribute *a) 778f52316cSDavid Sterba { 788f52316cSDavid Sterba return container_of(a, struct btrfs_feature_attr, kobj_attr); 798f52316cSDavid Sterba } 808f52316cSDavid Sterba 818f52316cSDavid Sterba static struct kobj_attribute *attr_to_btrfs_attr(struct attribute *attr) 828f52316cSDavid Sterba { 838f52316cSDavid Sterba return container_of(attr, struct kobj_attribute, attr); 848f52316cSDavid Sterba } 858f52316cSDavid Sterba 868f52316cSDavid Sterba static struct btrfs_feature_attr *attr_to_btrfs_feature_attr( 878f52316cSDavid Sterba struct attribute *attr) 888f52316cSDavid Sterba { 898f52316cSDavid Sterba return to_btrfs_feature_attr(attr_to_btrfs_attr(attr)); 908f52316cSDavid Sterba } 918f52316cSDavid Sterba 92510d7360SJeff Mahoney static u64 get_features(struct btrfs_fs_info *fs_info, 93510d7360SJeff Mahoney enum btrfs_feature_set set) 945ac1d209SJeff Mahoney { 95510d7360SJeff Mahoney struct btrfs_super_block *disk_super = fs_info->super_copy; 96510d7360SJeff Mahoney if (set == FEAT_COMPAT) 97510d7360SJeff Mahoney return btrfs_super_compat_flags(disk_super); 98510d7360SJeff Mahoney else if (set == FEAT_COMPAT_RO) 99510d7360SJeff Mahoney return btrfs_super_compat_ro_flags(disk_super); 100510d7360SJeff Mahoney else 101510d7360SJeff Mahoney return btrfs_super_incompat_flags(disk_super); 1025ac1d209SJeff Mahoney } 1035ac1d209SJeff Mahoney 104ba631941SJeff Mahoney static void set_features(struct btrfs_fs_info *fs_info, 105ba631941SJeff Mahoney enum btrfs_feature_set set, u64 features) 106ba631941SJeff Mahoney { 107ba631941SJeff Mahoney struct btrfs_super_block *disk_super = fs_info->super_copy; 108ba631941SJeff Mahoney if (set == FEAT_COMPAT) 109ba631941SJeff Mahoney btrfs_set_super_compat_flags(disk_super, features); 110ba631941SJeff Mahoney else if (set == FEAT_COMPAT_RO) 111ba631941SJeff Mahoney btrfs_set_super_compat_ro_flags(disk_super, features); 112ba631941SJeff Mahoney else 113ba631941SJeff Mahoney btrfs_set_super_incompat_flags(disk_super, features); 114ba631941SJeff Mahoney } 115ba631941SJeff Mahoney 116ba631941SJeff Mahoney static int can_modify_feature(struct btrfs_feature_attr *fa) 117ba631941SJeff Mahoney { 118ba631941SJeff Mahoney int val = 0; 119ba631941SJeff Mahoney u64 set, clear; 120ba631941SJeff Mahoney switch (fa->feature_set) { 121ba631941SJeff Mahoney case FEAT_COMPAT: 122ba631941SJeff Mahoney set = BTRFS_FEATURE_COMPAT_SAFE_SET; 123ba631941SJeff Mahoney clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR; 124ba631941SJeff Mahoney break; 125ba631941SJeff Mahoney case FEAT_COMPAT_RO: 126ba631941SJeff Mahoney set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET; 127ba631941SJeff Mahoney clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR; 128ba631941SJeff Mahoney break; 129ba631941SJeff Mahoney case FEAT_INCOMPAT: 130ba631941SJeff Mahoney set = BTRFS_FEATURE_INCOMPAT_SAFE_SET; 131ba631941SJeff Mahoney clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR; 132ba631941SJeff Mahoney break; 133ba631941SJeff Mahoney default: 13462e85577SJeff Mahoney pr_warn("btrfs: sysfs: unknown feature set %d\n", 135cc37bb04SDavid Sterba fa->feature_set); 136cc37bb04SDavid Sterba return 0; 137ba631941SJeff Mahoney } 138ba631941SJeff Mahoney 139ba631941SJeff Mahoney if (set & fa->feature_bit) 140ba631941SJeff Mahoney val |= 1; 141ba631941SJeff Mahoney if (clear & fa->feature_bit) 142ba631941SJeff Mahoney val |= 2; 143ba631941SJeff Mahoney 144ba631941SJeff Mahoney return val; 145ba631941SJeff Mahoney } 146ba631941SJeff Mahoney 147079b72bcSJeff Mahoney static ssize_t btrfs_feature_attr_show(struct kobject *kobj, 148079b72bcSJeff Mahoney struct kobj_attribute *a, char *buf) 149079b72bcSJeff Mahoney { 150510d7360SJeff Mahoney int val = 0; 151510d7360SJeff Mahoney struct btrfs_fs_info *fs_info = to_fs_info(kobj); 152510d7360SJeff Mahoney struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a); 153ba631941SJeff Mahoney if (fs_info) { 154510d7360SJeff Mahoney u64 features = get_features(fs_info, fa->feature_set); 155510d7360SJeff Mahoney if (features & fa->feature_bit) 156510d7360SJeff Mahoney val = 1; 157ba631941SJeff Mahoney } else 158ba631941SJeff Mahoney val = can_modify_feature(fa); 159510d7360SJeff Mahoney 160abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%d\n", val); 161510d7360SJeff Mahoney } 162510d7360SJeff Mahoney 163ba631941SJeff Mahoney static ssize_t btrfs_feature_attr_store(struct kobject *kobj, 164ba631941SJeff Mahoney struct kobj_attribute *a, 165ba631941SJeff Mahoney const char *buf, size_t count) 166ba631941SJeff Mahoney { 167ba631941SJeff Mahoney struct btrfs_fs_info *fs_info; 168ba631941SJeff Mahoney struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a); 169ba631941SJeff Mahoney u64 features, set, clear; 170ba631941SJeff Mahoney unsigned long val; 171ba631941SJeff Mahoney int ret; 172ba631941SJeff Mahoney 173ba631941SJeff Mahoney fs_info = to_fs_info(kobj); 174ba631941SJeff Mahoney if (!fs_info) 175ba631941SJeff Mahoney return -EPERM; 176ba631941SJeff Mahoney 177bc98a42cSDavid Howells if (sb_rdonly(fs_info->sb)) 178ee611138SDavid Sterba return -EROFS; 179ee611138SDavid Sterba 180ba631941SJeff Mahoney ret = kstrtoul(skip_spaces(buf), 0, &val); 181ba631941SJeff Mahoney if (ret) 182ba631941SJeff Mahoney return ret; 183ba631941SJeff Mahoney 184ba631941SJeff Mahoney if (fa->feature_set == FEAT_COMPAT) { 185ba631941SJeff Mahoney set = BTRFS_FEATURE_COMPAT_SAFE_SET; 186ba631941SJeff Mahoney clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR; 187ba631941SJeff Mahoney } else if (fa->feature_set == FEAT_COMPAT_RO) { 188ba631941SJeff Mahoney set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET; 189ba631941SJeff Mahoney clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR; 190ba631941SJeff Mahoney } else { 191ba631941SJeff Mahoney set = BTRFS_FEATURE_INCOMPAT_SAFE_SET; 192ba631941SJeff Mahoney clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR; 193ba631941SJeff Mahoney } 194ba631941SJeff Mahoney 195ba631941SJeff Mahoney features = get_features(fs_info, fa->feature_set); 196ba631941SJeff Mahoney 197ba631941SJeff Mahoney /* Nothing to do */ 198ba631941SJeff Mahoney if ((val && (features & fa->feature_bit)) || 199ba631941SJeff Mahoney (!val && !(features & fa->feature_bit))) 200ba631941SJeff Mahoney return count; 201ba631941SJeff Mahoney 202ba631941SJeff Mahoney if ((val && !(set & fa->feature_bit)) || 203ba631941SJeff Mahoney (!val && !(clear & fa->feature_bit))) { 204ba631941SJeff Mahoney btrfs_info(fs_info, 205ba631941SJeff Mahoney "%sabling feature %s on mounted fs is not supported.", 206ba631941SJeff Mahoney val ? "En" : "Dis", fa->kobj_attr.attr.name); 207ba631941SJeff Mahoney return -EPERM; 208ba631941SJeff Mahoney } 209ba631941SJeff Mahoney 210ba631941SJeff Mahoney btrfs_info(fs_info, "%s %s feature flag", 211ba631941SJeff Mahoney val ? "Setting" : "Clearing", fa->kobj_attr.attr.name); 212ba631941SJeff Mahoney 213ba631941SJeff Mahoney spin_lock(&fs_info->super_lock); 214ba631941SJeff Mahoney features = get_features(fs_info, fa->feature_set); 215ba631941SJeff Mahoney if (val) 216ba631941SJeff Mahoney features |= fa->feature_bit; 217ba631941SJeff Mahoney else 218ba631941SJeff Mahoney features &= ~fa->feature_bit; 219ba631941SJeff Mahoney set_features(fs_info, fa->feature_set, features); 220ba631941SJeff Mahoney spin_unlock(&fs_info->super_lock); 221ba631941SJeff Mahoney 2220eae2747SDavid Sterba /* 2230eae2747SDavid Sterba * We don't want to do full transaction commit from inside sysfs 2240eae2747SDavid Sterba */ 2250eae2747SDavid Sterba btrfs_set_pending(fs_info, COMMIT); 2260eae2747SDavid Sterba wake_up_process(fs_info->transaction_kthread); 227ba631941SJeff Mahoney 228ba631941SJeff Mahoney return count; 229ba631941SJeff Mahoney } 230ba631941SJeff Mahoney 231510d7360SJeff Mahoney static umode_t btrfs_feature_visible(struct kobject *kobj, 232510d7360SJeff Mahoney struct attribute *attr, int unused) 233510d7360SJeff Mahoney { 234510d7360SJeff Mahoney struct btrfs_fs_info *fs_info = to_fs_info(kobj); 235510d7360SJeff Mahoney umode_t mode = attr->mode; 236510d7360SJeff Mahoney 237510d7360SJeff Mahoney if (fs_info) { 238510d7360SJeff Mahoney struct btrfs_feature_attr *fa; 239510d7360SJeff Mahoney u64 features; 240510d7360SJeff Mahoney 241510d7360SJeff Mahoney fa = attr_to_btrfs_feature_attr(attr); 242510d7360SJeff Mahoney features = get_features(fs_info, fa->feature_set); 243510d7360SJeff Mahoney 244ba631941SJeff Mahoney if (can_modify_feature(fa)) 245ba631941SJeff Mahoney mode |= S_IWUSR; 246ba631941SJeff Mahoney else if (!(features & fa->feature_bit)) 247510d7360SJeff Mahoney mode = 0; 248510d7360SJeff Mahoney } 249510d7360SJeff Mahoney 250510d7360SJeff Mahoney return mode; 251079b72bcSJeff Mahoney } 252079b72bcSJeff Mahoney 253079b72bcSJeff Mahoney BTRFS_FEAT_ATTR_INCOMPAT(mixed_backref, MIXED_BACKREF); 254079b72bcSJeff Mahoney BTRFS_FEAT_ATTR_INCOMPAT(default_subvol, DEFAULT_SUBVOL); 255079b72bcSJeff Mahoney BTRFS_FEAT_ATTR_INCOMPAT(mixed_groups, MIXED_GROUPS); 256079b72bcSJeff Mahoney BTRFS_FEAT_ATTR_INCOMPAT(compress_lzo, COMPRESS_LZO); 2575c1aab1dSNick Terrell BTRFS_FEAT_ATTR_INCOMPAT(compress_zstd, COMPRESS_ZSTD); 258079b72bcSJeff Mahoney BTRFS_FEAT_ATTR_INCOMPAT(big_metadata, BIG_METADATA); 259079b72bcSJeff Mahoney BTRFS_FEAT_ATTR_INCOMPAT(extended_iref, EXTENDED_IREF); 260079b72bcSJeff Mahoney BTRFS_FEAT_ATTR_INCOMPAT(raid56, RAID56); 261079b72bcSJeff Mahoney BTRFS_FEAT_ATTR_INCOMPAT(skinny_metadata, SKINNY_METADATA); 262c736c095SDavid Sterba BTRFS_FEAT_ATTR_INCOMPAT(no_holes, NO_HOLES); 26356f20f40SNikolay Borisov BTRFS_FEAT_ATTR_INCOMPAT(metadata_uuid, METADATA_UUID); 2643b5bb73bSDavid Sterba BTRFS_FEAT_ATTR_COMPAT_RO(free_space_tree, FREE_SPACE_TREE); 265cfbb825cSDavid Sterba BTRFS_FEAT_ATTR_INCOMPAT(raid1c34, RAID1C34); 2667b3d5a90SNaohiro Aota /* Remove once support for zoned allocation is feature complete */ 2677b3d5a90SNaohiro Aota #ifdef CONFIG_BTRFS_DEBUG 2687b3d5a90SNaohiro Aota BTRFS_FEAT_ATTR_INCOMPAT(zoned, ZONED); 2697b3d5a90SNaohiro Aota #endif 270079b72bcSJeff Mahoney 271079b72bcSJeff Mahoney static struct attribute *btrfs_supported_feature_attrs[] = { 272079b72bcSJeff Mahoney BTRFS_FEAT_ATTR_PTR(mixed_backref), 273079b72bcSJeff Mahoney BTRFS_FEAT_ATTR_PTR(default_subvol), 274079b72bcSJeff Mahoney BTRFS_FEAT_ATTR_PTR(mixed_groups), 275079b72bcSJeff Mahoney BTRFS_FEAT_ATTR_PTR(compress_lzo), 2765c1aab1dSNick Terrell BTRFS_FEAT_ATTR_PTR(compress_zstd), 277079b72bcSJeff Mahoney BTRFS_FEAT_ATTR_PTR(big_metadata), 278079b72bcSJeff Mahoney BTRFS_FEAT_ATTR_PTR(extended_iref), 279079b72bcSJeff Mahoney BTRFS_FEAT_ATTR_PTR(raid56), 280079b72bcSJeff Mahoney BTRFS_FEAT_ATTR_PTR(skinny_metadata), 281c736c095SDavid Sterba BTRFS_FEAT_ATTR_PTR(no_holes), 28256f20f40SNikolay Borisov BTRFS_FEAT_ATTR_PTR(metadata_uuid), 2833b5bb73bSDavid Sterba BTRFS_FEAT_ATTR_PTR(free_space_tree), 284cfbb825cSDavid Sterba BTRFS_FEAT_ATTR_PTR(raid1c34), 2857b3d5a90SNaohiro Aota #ifdef CONFIG_BTRFS_DEBUG 2867b3d5a90SNaohiro Aota BTRFS_FEAT_ATTR_PTR(zoned), 2877b3d5a90SNaohiro Aota #endif 288079b72bcSJeff Mahoney NULL 289079b72bcSJeff Mahoney }; 290079b72bcSJeff Mahoney 291f902bd3aSMisono Tomohiro /* 292f902bd3aSMisono Tomohiro * Features which depend on feature bits and may differ between each fs. 293f902bd3aSMisono Tomohiro * 294f902bd3aSMisono Tomohiro * /sys/fs/btrfs/features lists all available features of this kernel while 295f902bd3aSMisono Tomohiro * /sys/fs/btrfs/UUID/features shows features of the fs which are enabled or 296f902bd3aSMisono Tomohiro * can be changed online. 297f902bd3aSMisono Tomohiro */ 298079b72bcSJeff Mahoney static const struct attribute_group btrfs_feature_attr_group = { 299079b72bcSJeff Mahoney .name = "features", 300510d7360SJeff Mahoney .is_visible = btrfs_feature_visible, 301079b72bcSJeff Mahoney .attrs = btrfs_supported_feature_attrs, 302079b72bcSJeff Mahoney }; 30358176a96SJosef Bacik 304f902bd3aSMisono Tomohiro static ssize_t rmdir_subvol_show(struct kobject *kobj, 305f902bd3aSMisono Tomohiro struct kobj_attribute *ka, char *buf) 306f902bd3aSMisono Tomohiro { 307abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "0\n"); 308f902bd3aSMisono Tomohiro } 309f902bd3aSMisono Tomohiro BTRFS_ATTR(static_feature, rmdir_subvol, rmdir_subvol_show); 310f902bd3aSMisono Tomohiro 311f7cea56cSDavid Sterba static ssize_t supported_checksums_show(struct kobject *kobj, 312f7cea56cSDavid Sterba struct kobj_attribute *a, char *buf) 313f7cea56cSDavid Sterba { 314f7cea56cSDavid Sterba ssize_t ret = 0; 315f7cea56cSDavid Sterba int i; 316f7cea56cSDavid Sterba 317f7cea56cSDavid Sterba for (i = 0; i < btrfs_get_num_csums(); i++) { 318f7cea56cSDavid Sterba /* 319f7cea56cSDavid Sterba * This "trick" only works as long as 'enum btrfs_csum_type' has 320f7cea56cSDavid Sterba * no holes in it 321f7cea56cSDavid Sterba */ 322abdd9febSTakashi Iwai ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%s%s", 323f7cea56cSDavid Sterba (i == 0 ? "" : " "), btrfs_super_csum_name(i)); 324f7cea56cSDavid Sterba 325f7cea56cSDavid Sterba } 326f7cea56cSDavid Sterba 327abdd9febSTakashi Iwai ret += scnprintf(buf + ret, PAGE_SIZE - ret, "\n"); 328f7cea56cSDavid Sterba return ret; 329f7cea56cSDavid Sterba } 330f7cea56cSDavid Sterba BTRFS_ATTR(static_feature, supported_checksums, supported_checksums_show); 331f7cea56cSDavid Sterba 3327573df55SOmar Sandoval static ssize_t send_stream_version_show(struct kobject *kobj, 3337573df55SOmar Sandoval struct kobj_attribute *ka, char *buf) 3347573df55SOmar Sandoval { 3357573df55SOmar Sandoval return snprintf(buf, PAGE_SIZE, "%d\n", BTRFS_SEND_STREAM_VERSION); 3367573df55SOmar Sandoval } 3377573df55SOmar Sandoval BTRFS_ATTR(static_feature, send_stream_version, send_stream_version_show); 3387573df55SOmar Sandoval 339ceafe3ccSJosef Bacik static const char *rescue_opts[] = { 340ceafe3ccSJosef Bacik "usebackuproot", 341ceafe3ccSJosef Bacik "nologreplay", 34242437a63SJosef Bacik "ignorebadroots", 343882dbe0cSJosef Bacik "ignoredatacsums", 3449037d3cbSJosef Bacik "all", 345ceafe3ccSJosef Bacik }; 346ceafe3ccSJosef Bacik 347ceafe3ccSJosef Bacik static ssize_t supported_rescue_options_show(struct kobject *kobj, 348ceafe3ccSJosef Bacik struct kobj_attribute *a, 349ceafe3ccSJosef Bacik char *buf) 350ceafe3ccSJosef Bacik { 351ceafe3ccSJosef Bacik ssize_t ret = 0; 352ceafe3ccSJosef Bacik int i; 353ceafe3ccSJosef Bacik 354ceafe3ccSJosef Bacik for (i = 0; i < ARRAY_SIZE(rescue_opts); i++) 355ceafe3ccSJosef Bacik ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%s%s", 356ceafe3ccSJosef Bacik (i ? " " : ""), rescue_opts[i]); 357ceafe3ccSJosef Bacik ret += scnprintf(buf + ret, PAGE_SIZE - ret, "\n"); 358ceafe3ccSJosef Bacik return ret; 359ceafe3ccSJosef Bacik } 360ceafe3ccSJosef Bacik BTRFS_ATTR(static_feature, supported_rescue_options, 361ceafe3ccSJosef Bacik supported_rescue_options_show); 362ceafe3ccSJosef Bacik 363fc57ad8dSQu Wenruo static ssize_t supported_sectorsizes_show(struct kobject *kobj, 364fc57ad8dSQu Wenruo struct kobj_attribute *a, 365fc57ad8dSQu Wenruo char *buf) 366fc57ad8dSQu Wenruo { 367fc57ad8dSQu Wenruo ssize_t ret = 0; 368fc57ad8dSQu Wenruo 369fc57ad8dSQu Wenruo /* Only sectorsize == PAGE_SIZE is now supported */ 370fc57ad8dSQu Wenruo ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%lu\n", PAGE_SIZE); 371fc57ad8dSQu Wenruo 372fc57ad8dSQu Wenruo return ret; 373fc57ad8dSQu Wenruo } 374fc57ad8dSQu Wenruo BTRFS_ATTR(static_feature, supported_sectorsizes, 375fc57ad8dSQu Wenruo supported_sectorsizes_show); 376fc57ad8dSQu Wenruo 377f902bd3aSMisono Tomohiro static struct attribute *btrfs_supported_static_feature_attrs[] = { 378f902bd3aSMisono Tomohiro BTRFS_ATTR_PTR(static_feature, rmdir_subvol), 379f7cea56cSDavid Sterba BTRFS_ATTR_PTR(static_feature, supported_checksums), 3807573df55SOmar Sandoval BTRFS_ATTR_PTR(static_feature, send_stream_version), 381ceafe3ccSJosef Bacik BTRFS_ATTR_PTR(static_feature, supported_rescue_options), 382fc57ad8dSQu Wenruo BTRFS_ATTR_PTR(static_feature, supported_sectorsizes), 383f902bd3aSMisono Tomohiro NULL 384f902bd3aSMisono Tomohiro }; 385f902bd3aSMisono Tomohiro 386f902bd3aSMisono Tomohiro /* 387f902bd3aSMisono Tomohiro * Features which only depend on kernel version. 388f902bd3aSMisono Tomohiro * 389f902bd3aSMisono Tomohiro * These are listed in /sys/fs/btrfs/features along with 390f902bd3aSMisono Tomohiro * btrfs_feature_attr_group 391f902bd3aSMisono Tomohiro */ 392f902bd3aSMisono Tomohiro static const struct attribute_group btrfs_static_feature_attr_group = { 393f902bd3aSMisono Tomohiro .name = "features", 394f902bd3aSMisono Tomohiro .attrs = btrfs_supported_static_feature_attrs, 395f902bd3aSMisono Tomohiro }; 396f902bd3aSMisono Tomohiro 3976e369febSDavid Sterba #ifdef CONFIG_BTRFS_DEBUG 3986e369febSDavid Sterba 3996e369febSDavid Sterba /* 400e4faab84SDennis Zhou * Discard statistics and tunables 401e4faab84SDennis Zhou */ 402dfb79ddbSDennis Zhou #define discard_to_fs_info(_kobj) to_fs_info((_kobj)->parent->parent) 403dfb79ddbSDennis Zhou 4045dc7c10bSDennis Zhou static ssize_t btrfs_discardable_bytes_show(struct kobject *kobj, 4055dc7c10bSDennis Zhou struct kobj_attribute *a, 4065dc7c10bSDennis Zhou char *buf) 4075dc7c10bSDennis Zhou { 4085dc7c10bSDennis Zhou struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 4095dc7c10bSDennis Zhou 410abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%lld\n", 4115dc7c10bSDennis Zhou atomic64_read(&fs_info->discard_ctl.discardable_bytes)); 4125dc7c10bSDennis Zhou } 4135dc7c10bSDennis Zhou BTRFS_ATTR(discard, discardable_bytes, btrfs_discardable_bytes_show); 4145dc7c10bSDennis Zhou 415dfb79ddbSDennis Zhou static ssize_t btrfs_discardable_extents_show(struct kobject *kobj, 416dfb79ddbSDennis Zhou struct kobj_attribute *a, 417dfb79ddbSDennis Zhou char *buf) 418dfb79ddbSDennis Zhou { 419dfb79ddbSDennis Zhou struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 420dfb79ddbSDennis Zhou 421abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%d\n", 422dfb79ddbSDennis Zhou atomic_read(&fs_info->discard_ctl.discardable_extents)); 423dfb79ddbSDennis Zhou } 424dfb79ddbSDennis Zhou BTRFS_ATTR(discard, discardable_extents, btrfs_discardable_extents_show); 425dfb79ddbSDennis Zhou 4269ddf648fSDennis Zhou static ssize_t btrfs_discard_bitmap_bytes_show(struct kobject *kobj, 4279ddf648fSDennis Zhou struct kobj_attribute *a, 4289ddf648fSDennis Zhou char *buf) 4299ddf648fSDennis Zhou { 4309ddf648fSDennis Zhou struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 4319ddf648fSDennis Zhou 4328c5ec995SDavid Sterba return scnprintf(buf, PAGE_SIZE, "%llu\n", 4339ddf648fSDennis Zhou fs_info->discard_ctl.discard_bitmap_bytes); 4349ddf648fSDennis Zhou } 4359ddf648fSDennis Zhou BTRFS_ATTR(discard, discard_bitmap_bytes, btrfs_discard_bitmap_bytes_show); 4369ddf648fSDennis Zhou 4379ddf648fSDennis Zhou static ssize_t btrfs_discard_bytes_saved_show(struct kobject *kobj, 4389ddf648fSDennis Zhou struct kobj_attribute *a, 4399ddf648fSDennis Zhou char *buf) 4409ddf648fSDennis Zhou { 4419ddf648fSDennis Zhou struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 4429ddf648fSDennis Zhou 443abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%lld\n", 4449ddf648fSDennis Zhou atomic64_read(&fs_info->discard_ctl.discard_bytes_saved)); 4459ddf648fSDennis Zhou } 4469ddf648fSDennis Zhou BTRFS_ATTR(discard, discard_bytes_saved, btrfs_discard_bytes_saved_show); 4479ddf648fSDennis Zhou 4489ddf648fSDennis Zhou static ssize_t btrfs_discard_extent_bytes_show(struct kobject *kobj, 4499ddf648fSDennis Zhou struct kobj_attribute *a, 4509ddf648fSDennis Zhou char *buf) 4519ddf648fSDennis Zhou { 4529ddf648fSDennis Zhou struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 4539ddf648fSDennis Zhou 4548c5ec995SDavid Sterba return scnprintf(buf, PAGE_SIZE, "%llu\n", 4559ddf648fSDennis Zhou fs_info->discard_ctl.discard_extent_bytes); 4569ddf648fSDennis Zhou } 4579ddf648fSDennis Zhou BTRFS_ATTR(discard, discard_extent_bytes, btrfs_discard_extent_bytes_show); 4589ddf648fSDennis Zhou 459a2309300SDennis Zhou static ssize_t btrfs_discard_iops_limit_show(struct kobject *kobj, 460a2309300SDennis Zhou struct kobj_attribute *a, 461a2309300SDennis Zhou char *buf) 462a2309300SDennis Zhou { 463a2309300SDennis Zhou struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 464a2309300SDennis Zhou 465abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%u\n", 466a2309300SDennis Zhou READ_ONCE(fs_info->discard_ctl.iops_limit)); 467a2309300SDennis Zhou } 468a2309300SDennis Zhou 469a2309300SDennis Zhou static ssize_t btrfs_discard_iops_limit_store(struct kobject *kobj, 470a2309300SDennis Zhou struct kobj_attribute *a, 471a2309300SDennis Zhou const char *buf, size_t len) 472a2309300SDennis Zhou { 473a2309300SDennis Zhou struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 474a2309300SDennis Zhou struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl; 475a2309300SDennis Zhou u32 iops_limit; 476a2309300SDennis Zhou int ret; 477a2309300SDennis Zhou 478a2309300SDennis Zhou ret = kstrtou32(buf, 10, &iops_limit); 479a2309300SDennis Zhou if (ret) 480a2309300SDennis Zhou return -EINVAL; 481a2309300SDennis Zhou 482a2309300SDennis Zhou WRITE_ONCE(discard_ctl->iops_limit, iops_limit); 4833e48d8d2SPavel Begunkov btrfs_discard_calc_delay(discard_ctl); 4843e48d8d2SPavel Begunkov btrfs_discard_schedule_work(discard_ctl, true); 485a2309300SDennis Zhou return len; 486a2309300SDennis Zhou } 487a2309300SDennis Zhou BTRFS_ATTR_RW(discard, iops_limit, btrfs_discard_iops_limit_show, 488a2309300SDennis Zhou btrfs_discard_iops_limit_store); 489a2309300SDennis Zhou 490e93591bbSDennis Zhou static ssize_t btrfs_discard_kbps_limit_show(struct kobject *kobj, 491e93591bbSDennis Zhou struct kobj_attribute *a, 492e93591bbSDennis Zhou char *buf) 493e93591bbSDennis Zhou { 494e93591bbSDennis Zhou struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 495e93591bbSDennis Zhou 496abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%u\n", 497e93591bbSDennis Zhou READ_ONCE(fs_info->discard_ctl.kbps_limit)); 498e93591bbSDennis Zhou } 499e93591bbSDennis Zhou 500e93591bbSDennis Zhou static ssize_t btrfs_discard_kbps_limit_store(struct kobject *kobj, 501e93591bbSDennis Zhou struct kobj_attribute *a, 502e93591bbSDennis Zhou const char *buf, size_t len) 503e93591bbSDennis Zhou { 504e93591bbSDennis Zhou struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 505e93591bbSDennis Zhou struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl; 506e93591bbSDennis Zhou u32 kbps_limit; 507e93591bbSDennis Zhou int ret; 508e93591bbSDennis Zhou 509e93591bbSDennis Zhou ret = kstrtou32(buf, 10, &kbps_limit); 510e93591bbSDennis Zhou if (ret) 511e93591bbSDennis Zhou return -EINVAL; 512e93591bbSDennis Zhou 513e93591bbSDennis Zhou WRITE_ONCE(discard_ctl->kbps_limit, kbps_limit); 5143e48d8d2SPavel Begunkov btrfs_discard_schedule_work(discard_ctl, true); 515e93591bbSDennis Zhou return len; 516e93591bbSDennis Zhou } 517e93591bbSDennis Zhou BTRFS_ATTR_RW(discard, kbps_limit, btrfs_discard_kbps_limit_show, 518e93591bbSDennis Zhou btrfs_discard_kbps_limit_store); 519e93591bbSDennis Zhou 52019b2a2c7SDennis Zhou static ssize_t btrfs_discard_max_discard_size_show(struct kobject *kobj, 52119b2a2c7SDennis Zhou struct kobj_attribute *a, 52219b2a2c7SDennis Zhou char *buf) 52319b2a2c7SDennis Zhou { 52419b2a2c7SDennis Zhou struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 52519b2a2c7SDennis Zhou 526abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%llu\n", 52719b2a2c7SDennis Zhou READ_ONCE(fs_info->discard_ctl.max_discard_size)); 52819b2a2c7SDennis Zhou } 52919b2a2c7SDennis Zhou 53019b2a2c7SDennis Zhou static ssize_t btrfs_discard_max_discard_size_store(struct kobject *kobj, 53119b2a2c7SDennis Zhou struct kobj_attribute *a, 53219b2a2c7SDennis Zhou const char *buf, size_t len) 53319b2a2c7SDennis Zhou { 53419b2a2c7SDennis Zhou struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj); 53519b2a2c7SDennis Zhou struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl; 53619b2a2c7SDennis Zhou u64 max_discard_size; 53719b2a2c7SDennis Zhou int ret; 53819b2a2c7SDennis Zhou 53919b2a2c7SDennis Zhou ret = kstrtou64(buf, 10, &max_discard_size); 54019b2a2c7SDennis Zhou if (ret) 54119b2a2c7SDennis Zhou return -EINVAL; 54219b2a2c7SDennis Zhou 54319b2a2c7SDennis Zhou WRITE_ONCE(discard_ctl->max_discard_size, max_discard_size); 54419b2a2c7SDennis Zhou 54519b2a2c7SDennis Zhou return len; 54619b2a2c7SDennis Zhou } 54719b2a2c7SDennis Zhou BTRFS_ATTR_RW(discard, max_discard_size, btrfs_discard_max_discard_size_show, 54819b2a2c7SDennis Zhou btrfs_discard_max_discard_size_store); 54919b2a2c7SDennis Zhou 550e4faab84SDennis Zhou static const struct attribute *discard_debug_attrs[] = { 5515dc7c10bSDennis Zhou BTRFS_ATTR_PTR(discard, discardable_bytes), 552dfb79ddbSDennis Zhou BTRFS_ATTR_PTR(discard, discardable_extents), 5539ddf648fSDennis Zhou BTRFS_ATTR_PTR(discard, discard_bitmap_bytes), 5549ddf648fSDennis Zhou BTRFS_ATTR_PTR(discard, discard_bytes_saved), 5559ddf648fSDennis Zhou BTRFS_ATTR_PTR(discard, discard_extent_bytes), 556a2309300SDennis Zhou BTRFS_ATTR_PTR(discard, iops_limit), 557e93591bbSDennis Zhou BTRFS_ATTR_PTR(discard, kbps_limit), 55819b2a2c7SDennis Zhou BTRFS_ATTR_PTR(discard, max_discard_size), 559e4faab84SDennis Zhou NULL, 560e4faab84SDennis Zhou }; 561e4faab84SDennis Zhou 562e4faab84SDennis Zhou /* 5636e369febSDavid Sterba * Runtime debugging exported via sysfs 5646e369febSDavid Sterba * 5656e369febSDavid Sterba * /sys/fs/btrfs/debug - applies to module or all filesystems 5666e369febSDavid Sterba * /sys/fs/btrfs/UUID - applies only to the given filesystem 5676e369febSDavid Sterba */ 56893945cb4SDennis Zhou static const struct attribute *btrfs_debug_mount_attrs[] = { 56993945cb4SDennis Zhou NULL, 57093945cb4SDennis Zhou }; 57193945cb4SDennis Zhou 5726e369febSDavid Sterba static struct attribute *btrfs_debug_feature_attrs[] = { 5736e369febSDavid Sterba NULL 5746e369febSDavid Sterba }; 5756e369febSDavid Sterba 5766e369febSDavid Sterba static const struct attribute_group btrfs_debug_feature_attr_group = { 5776e369febSDavid Sterba .name = "debug", 5786e369febSDavid Sterba .attrs = btrfs_debug_feature_attrs, 5796e369febSDavid Sterba }; 5806e369febSDavid Sterba 5816e369febSDavid Sterba #endif 5826e369febSDavid Sterba 5836ab0a202SJeff Mahoney static ssize_t btrfs_show_u64(u64 *value_ptr, spinlock_t *lock, char *buf) 5846ab0a202SJeff Mahoney { 5856ab0a202SJeff Mahoney u64 val; 5866ab0a202SJeff Mahoney if (lock) 5876ab0a202SJeff Mahoney spin_lock(lock); 5886ab0a202SJeff Mahoney val = *value_ptr; 5896ab0a202SJeff Mahoney if (lock) 5906ab0a202SJeff Mahoney spin_unlock(lock); 591abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%llu\n", val); 5926ab0a202SJeff Mahoney } 5936ab0a202SJeff Mahoney 5946ab0a202SJeff Mahoney static ssize_t global_rsv_size_show(struct kobject *kobj, 5956ab0a202SJeff Mahoney struct kobj_attribute *ka, char *buf) 5966ab0a202SJeff Mahoney { 5976ab0a202SJeff Mahoney struct btrfs_fs_info *fs_info = to_fs_info(kobj->parent); 5986ab0a202SJeff Mahoney struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv; 5996ab0a202SJeff Mahoney return btrfs_show_u64(&block_rsv->size, &block_rsv->lock, buf); 6006ab0a202SJeff Mahoney } 601a969f4ccSHans van Kranenburg BTRFS_ATTR(allocation, global_rsv_size, global_rsv_size_show); 6026ab0a202SJeff Mahoney 6036ab0a202SJeff Mahoney static ssize_t global_rsv_reserved_show(struct kobject *kobj, 6046ab0a202SJeff Mahoney struct kobj_attribute *a, char *buf) 6056ab0a202SJeff Mahoney { 6066ab0a202SJeff Mahoney struct btrfs_fs_info *fs_info = to_fs_info(kobj->parent); 6076ab0a202SJeff Mahoney struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv; 6086ab0a202SJeff Mahoney return btrfs_show_u64(&block_rsv->reserved, &block_rsv->lock, buf); 6096ab0a202SJeff Mahoney } 610a969f4ccSHans van Kranenburg BTRFS_ATTR(allocation, global_rsv_reserved, global_rsv_reserved_show); 6116ab0a202SJeff Mahoney 6126ab0a202SJeff Mahoney #define to_space_info(_kobj) container_of(_kobj, struct btrfs_space_info, kobj) 613c1895442SJeff Mahoney #define to_raid_kobj(_kobj) container_of(_kobj, struct raid_kobject, kobj) 6146ab0a202SJeff Mahoney 6156ab0a202SJeff Mahoney static ssize_t raid_bytes_show(struct kobject *kobj, 6166ab0a202SJeff Mahoney struct kobj_attribute *attr, char *buf); 617a969f4ccSHans van Kranenburg BTRFS_ATTR(raid, total_bytes, raid_bytes_show); 618a969f4ccSHans van Kranenburg BTRFS_ATTR(raid, used_bytes, raid_bytes_show); 6196ab0a202SJeff Mahoney 6206ab0a202SJeff Mahoney static ssize_t raid_bytes_show(struct kobject *kobj, 6216ab0a202SJeff Mahoney struct kobj_attribute *attr, char *buf) 6226ab0a202SJeff Mahoney 6236ab0a202SJeff Mahoney { 6246ab0a202SJeff Mahoney struct btrfs_space_info *sinfo = to_space_info(kobj->parent); 62532da5386SDavid Sterba struct btrfs_block_group *block_group; 62675cb379dSJeff Mahoney int index = btrfs_bg_flags_to_raid_index(to_raid_kobj(kobj)->flags); 6276ab0a202SJeff Mahoney u64 val = 0; 6286ab0a202SJeff Mahoney 6296ab0a202SJeff Mahoney down_read(&sinfo->groups_sem); 6306ab0a202SJeff Mahoney list_for_each_entry(block_group, &sinfo->block_groups[index], list) { 631a969f4ccSHans van Kranenburg if (&attr->attr == BTRFS_ATTR_PTR(raid, total_bytes)) 632b3470b5dSDavid Sterba val += block_group->length; 6336ab0a202SJeff Mahoney else 634bf38be65SDavid Sterba val += block_group->used; 6356ab0a202SJeff Mahoney } 6366ab0a202SJeff Mahoney up_read(&sinfo->groups_sem); 637abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%llu\n", val); 6386ab0a202SJeff Mahoney } 6396ab0a202SJeff Mahoney 6407c7e3014SKimberly Brown static struct attribute *raid_attrs[] = { 641a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(raid, total_bytes), 642a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(raid, used_bytes), 6436ab0a202SJeff Mahoney NULL 6446ab0a202SJeff Mahoney }; 6457c7e3014SKimberly Brown ATTRIBUTE_GROUPS(raid); 6466ab0a202SJeff Mahoney 6476ab0a202SJeff Mahoney static void release_raid_kobj(struct kobject *kobj) 6486ab0a202SJeff Mahoney { 649c1895442SJeff Mahoney kfree(to_raid_kobj(kobj)); 6506ab0a202SJeff Mahoney } 6516ab0a202SJeff Mahoney 652536ea45cSDavid Sterba static struct kobj_type btrfs_raid_ktype = { 6536ab0a202SJeff Mahoney .sysfs_ops = &kobj_sysfs_ops, 6546ab0a202SJeff Mahoney .release = release_raid_kobj, 6557c7e3014SKimberly Brown .default_groups = raid_groups, 6566ab0a202SJeff Mahoney }; 6576ab0a202SJeff Mahoney 6586ab0a202SJeff Mahoney #define SPACE_INFO_ATTR(field) \ 6596ab0a202SJeff Mahoney static ssize_t btrfs_space_info_show_##field(struct kobject *kobj, \ 6606ab0a202SJeff Mahoney struct kobj_attribute *a, \ 6616ab0a202SJeff Mahoney char *buf) \ 6626ab0a202SJeff Mahoney { \ 6636ab0a202SJeff Mahoney struct btrfs_space_info *sinfo = to_space_info(kobj); \ 6646ab0a202SJeff Mahoney return btrfs_show_u64(&sinfo->field, &sinfo->lock, buf); \ 6656ab0a202SJeff Mahoney } \ 666a969f4ccSHans van Kranenburg BTRFS_ATTR(space_info, field, btrfs_space_info_show_##field) 6676ab0a202SJeff Mahoney 6686ab0a202SJeff Mahoney static ssize_t btrfs_space_info_show_total_bytes_pinned(struct kobject *kobj, 6696ab0a202SJeff Mahoney struct kobj_attribute *a, 6706ab0a202SJeff Mahoney char *buf) 6716ab0a202SJeff Mahoney { 6726ab0a202SJeff Mahoney struct btrfs_space_info *sinfo = to_space_info(kobj); 6736ab0a202SJeff Mahoney s64 val = percpu_counter_sum(&sinfo->total_bytes_pinned); 674abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%lld\n", val); 6756ab0a202SJeff Mahoney } 6766ab0a202SJeff Mahoney 6776ab0a202SJeff Mahoney SPACE_INFO_ATTR(flags); 6786ab0a202SJeff Mahoney SPACE_INFO_ATTR(total_bytes); 6796ab0a202SJeff Mahoney SPACE_INFO_ATTR(bytes_used); 6806ab0a202SJeff Mahoney SPACE_INFO_ATTR(bytes_pinned); 6816ab0a202SJeff Mahoney SPACE_INFO_ATTR(bytes_reserved); 6826ab0a202SJeff Mahoney SPACE_INFO_ATTR(bytes_may_use); 683c1fd5c30SWang Xiaoguang SPACE_INFO_ATTR(bytes_readonly); 684169e0da9SNaohiro Aota SPACE_INFO_ATTR(bytes_zone_unusable); 6856ab0a202SJeff Mahoney SPACE_INFO_ATTR(disk_used); 6866ab0a202SJeff Mahoney SPACE_INFO_ATTR(disk_total); 687a969f4ccSHans van Kranenburg BTRFS_ATTR(space_info, total_bytes_pinned, 688a969f4ccSHans van Kranenburg btrfs_space_info_show_total_bytes_pinned); 6896ab0a202SJeff Mahoney 6906ab0a202SJeff Mahoney static struct attribute *space_info_attrs[] = { 691a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(space_info, flags), 692a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(space_info, total_bytes), 693a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(space_info, bytes_used), 694a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(space_info, bytes_pinned), 695a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(space_info, bytes_reserved), 696a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(space_info, bytes_may_use), 697a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(space_info, bytes_readonly), 698169e0da9SNaohiro Aota BTRFS_ATTR_PTR(space_info, bytes_zone_unusable), 699a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(space_info, disk_used), 700a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(space_info, disk_total), 701a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(space_info, total_bytes_pinned), 7026ab0a202SJeff Mahoney NULL, 7036ab0a202SJeff Mahoney }; 7047c7e3014SKimberly Brown ATTRIBUTE_GROUPS(space_info); 7056ab0a202SJeff Mahoney 7066ab0a202SJeff Mahoney static void space_info_release(struct kobject *kobj) 7076ab0a202SJeff Mahoney { 7086ab0a202SJeff Mahoney struct btrfs_space_info *sinfo = to_space_info(kobj); 7096ab0a202SJeff Mahoney percpu_counter_destroy(&sinfo->total_bytes_pinned); 7106ab0a202SJeff Mahoney kfree(sinfo); 7116ab0a202SJeff Mahoney } 7126ab0a202SJeff Mahoney 71327992d01SDavid Sterba static struct kobj_type space_info_ktype = { 7146ab0a202SJeff Mahoney .sysfs_ops = &kobj_sysfs_ops, 7156ab0a202SJeff Mahoney .release = space_info_release, 7167c7e3014SKimberly Brown .default_groups = space_info_groups, 7176ab0a202SJeff Mahoney }; 7186ab0a202SJeff Mahoney 7196ab0a202SJeff Mahoney static const struct attribute *allocation_attrs[] = { 720a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(allocation, global_rsv_reserved), 721a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(allocation, global_rsv_size), 7226ab0a202SJeff Mahoney NULL, 7236ab0a202SJeff Mahoney }; 7246ab0a202SJeff Mahoney 725f8ba9c11SJeff Mahoney static ssize_t btrfs_label_show(struct kobject *kobj, 726f8ba9c11SJeff Mahoney struct kobj_attribute *a, char *buf) 727f8ba9c11SJeff Mahoney { 728f8ba9c11SJeff Mahoney struct btrfs_fs_info *fs_info = to_fs_info(kobj); 72948fcc3ffSSatoru Takeuchi char *label = fs_info->super_copy->label; 730ee17fc80SDavid Sterba ssize_t ret; 731ee17fc80SDavid Sterba 732ee17fc80SDavid Sterba spin_lock(&fs_info->super_lock); 733abdd9febSTakashi Iwai ret = scnprintf(buf, PAGE_SIZE, label[0] ? "%s\n" : "%s", label); 734ee17fc80SDavid Sterba spin_unlock(&fs_info->super_lock); 735ee17fc80SDavid Sterba 736ee17fc80SDavid Sterba return ret; 737f8ba9c11SJeff Mahoney } 738f8ba9c11SJeff Mahoney 739f8ba9c11SJeff Mahoney static ssize_t btrfs_label_store(struct kobject *kobj, 740f8ba9c11SJeff Mahoney struct kobj_attribute *a, 741f8ba9c11SJeff Mahoney const char *buf, size_t len) 742f8ba9c11SJeff Mahoney { 743f8ba9c11SJeff Mahoney struct btrfs_fs_info *fs_info = to_fs_info(kobj); 74448fcc3ffSSatoru Takeuchi size_t p_len; 745f8ba9c11SJeff Mahoney 74666ac9fe7SDavid Sterba if (!fs_info) 74766ac9fe7SDavid Sterba return -EPERM; 74866ac9fe7SDavid Sterba 749bc98a42cSDavid Howells if (sb_rdonly(fs_info->sb)) 75079aec2b8SAnand Jain return -EROFS; 75179aec2b8SAnand Jain 75248fcc3ffSSatoru Takeuchi /* 75348fcc3ffSSatoru Takeuchi * p_len is the len until the first occurrence of either 75448fcc3ffSSatoru Takeuchi * '\n' or '\0' 75548fcc3ffSSatoru Takeuchi */ 75648fcc3ffSSatoru Takeuchi p_len = strcspn(buf, "\n"); 75748fcc3ffSSatoru Takeuchi 75848fcc3ffSSatoru Takeuchi if (p_len >= BTRFS_LABEL_SIZE) 759f8ba9c11SJeff Mahoney return -EINVAL; 760f8ba9c11SJeff Mahoney 761a6f69dc8SDavid Sterba spin_lock(&fs_info->super_lock); 76248fcc3ffSSatoru Takeuchi memset(fs_info->super_copy->label, 0, BTRFS_LABEL_SIZE); 76348fcc3ffSSatoru Takeuchi memcpy(fs_info->super_copy->label, buf, p_len); 764a6f69dc8SDavid Sterba spin_unlock(&fs_info->super_lock); 765f8ba9c11SJeff Mahoney 766a6f69dc8SDavid Sterba /* 767a6f69dc8SDavid Sterba * We don't want to do full transaction commit from inside sysfs 768a6f69dc8SDavid Sterba */ 769a6f69dc8SDavid Sterba btrfs_set_pending(fs_info, COMMIT); 770a6f69dc8SDavid Sterba wake_up_process(fs_info->transaction_kthread); 771a6f69dc8SDavid Sterba 772f8ba9c11SJeff Mahoney return len; 773f8ba9c11SJeff Mahoney } 774a969f4ccSHans van Kranenburg BTRFS_ATTR_RW(, label, btrfs_label_show, btrfs_label_store); 775f8ba9c11SJeff Mahoney 776df93589aSDavid Sterba static ssize_t btrfs_nodesize_show(struct kobject *kobj, 777df93589aSDavid Sterba struct kobj_attribute *a, char *buf) 778df93589aSDavid Sterba { 779df93589aSDavid Sterba struct btrfs_fs_info *fs_info = to_fs_info(kobj); 780df93589aSDavid Sterba 781abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%u\n", fs_info->super_copy->nodesize); 782df93589aSDavid Sterba } 783df93589aSDavid Sterba 784a969f4ccSHans van Kranenburg BTRFS_ATTR(, nodesize, btrfs_nodesize_show); 785df93589aSDavid Sterba 786df93589aSDavid Sterba static ssize_t btrfs_sectorsize_show(struct kobject *kobj, 787df93589aSDavid Sterba struct kobj_attribute *a, char *buf) 788df93589aSDavid Sterba { 789df93589aSDavid Sterba struct btrfs_fs_info *fs_info = to_fs_info(kobj); 790df93589aSDavid Sterba 791abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%u\n", 792093e037cSDavid Sterba fs_info->super_copy->sectorsize); 793df93589aSDavid Sterba } 794df93589aSDavid Sterba 795a969f4ccSHans van Kranenburg BTRFS_ATTR(, sectorsize, btrfs_sectorsize_show); 796df93589aSDavid Sterba 797df93589aSDavid Sterba static ssize_t btrfs_clone_alignment_show(struct kobject *kobj, 798df93589aSDavid Sterba struct kobj_attribute *a, char *buf) 799df93589aSDavid Sterba { 800df93589aSDavid Sterba struct btrfs_fs_info *fs_info = to_fs_info(kobj); 801df93589aSDavid Sterba 802abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%u\n", fs_info->super_copy->sectorsize); 803df93589aSDavid Sterba } 804df93589aSDavid Sterba 805a969f4ccSHans van Kranenburg BTRFS_ATTR(, clone_alignment, btrfs_clone_alignment_show); 806df93589aSDavid Sterba 8072723480aSSargun Dhillon static ssize_t quota_override_show(struct kobject *kobj, 8082723480aSSargun Dhillon struct kobj_attribute *a, char *buf) 8092723480aSSargun Dhillon { 8102723480aSSargun Dhillon struct btrfs_fs_info *fs_info = to_fs_info(kobj); 8112723480aSSargun Dhillon int quota_override; 8122723480aSSargun Dhillon 8132723480aSSargun Dhillon quota_override = test_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags); 814abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%d\n", quota_override); 8152723480aSSargun Dhillon } 8162723480aSSargun Dhillon 8172723480aSSargun Dhillon static ssize_t quota_override_store(struct kobject *kobj, 8182723480aSSargun Dhillon struct kobj_attribute *a, 8192723480aSSargun Dhillon const char *buf, size_t len) 8202723480aSSargun Dhillon { 8212723480aSSargun Dhillon struct btrfs_fs_info *fs_info = to_fs_info(kobj); 8222723480aSSargun Dhillon unsigned long knob; 8232723480aSSargun Dhillon int err; 8242723480aSSargun Dhillon 8252723480aSSargun Dhillon if (!fs_info) 8262723480aSSargun Dhillon return -EPERM; 8272723480aSSargun Dhillon 8282723480aSSargun Dhillon if (!capable(CAP_SYS_RESOURCE)) 8292723480aSSargun Dhillon return -EPERM; 8302723480aSSargun Dhillon 8312723480aSSargun Dhillon err = kstrtoul(buf, 10, &knob); 8322723480aSSargun Dhillon if (err) 8332723480aSSargun Dhillon return err; 8342723480aSSargun Dhillon if (knob > 1) 8352723480aSSargun Dhillon return -EINVAL; 8362723480aSSargun Dhillon 8372723480aSSargun Dhillon if (knob) 8382723480aSSargun Dhillon set_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags); 8392723480aSSargun Dhillon else 8402723480aSSargun Dhillon clear_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags); 8412723480aSSargun Dhillon 8422723480aSSargun Dhillon return len; 8432723480aSSargun Dhillon } 8442723480aSSargun Dhillon 845a969f4ccSHans van Kranenburg BTRFS_ATTR_RW(, quota_override, quota_override_show, quota_override_store); 8462723480aSSargun Dhillon 84756f20f40SNikolay Borisov static ssize_t btrfs_metadata_uuid_show(struct kobject *kobj, 84856f20f40SNikolay Borisov struct kobj_attribute *a, char *buf) 84956f20f40SNikolay Borisov { 85056f20f40SNikolay Borisov struct btrfs_fs_info *fs_info = to_fs_info(kobj); 85156f20f40SNikolay Borisov 852abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%pU\n", 85356f20f40SNikolay Borisov fs_info->fs_devices->metadata_uuid); 85456f20f40SNikolay Borisov } 85556f20f40SNikolay Borisov 85656f20f40SNikolay Borisov BTRFS_ATTR(, metadata_uuid, btrfs_metadata_uuid_show); 85756f20f40SNikolay Borisov 85841e6d2a8SJohannes Thumshirn static ssize_t btrfs_checksum_show(struct kobject *kobj, 85941e6d2a8SJohannes Thumshirn struct kobj_attribute *a, char *buf) 86041e6d2a8SJohannes Thumshirn { 86141e6d2a8SJohannes Thumshirn struct btrfs_fs_info *fs_info = to_fs_info(kobj); 86241e6d2a8SJohannes Thumshirn u16 csum_type = btrfs_super_csum_type(fs_info->super_copy); 86341e6d2a8SJohannes Thumshirn 864abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%s (%s)\n", 86541e6d2a8SJohannes Thumshirn btrfs_super_csum_name(csum_type), 86641e6d2a8SJohannes Thumshirn crypto_shash_driver_name(fs_info->csum_shash)); 86741e6d2a8SJohannes Thumshirn } 86841e6d2a8SJohannes Thumshirn 86941e6d2a8SJohannes Thumshirn BTRFS_ATTR(, checksum, btrfs_checksum_show); 87041e6d2a8SJohannes Thumshirn 87166a2823cSGoldwyn Rodrigues static ssize_t btrfs_exclusive_operation_show(struct kobject *kobj, 87266a2823cSGoldwyn Rodrigues struct kobj_attribute *a, char *buf) 87366a2823cSGoldwyn Rodrigues { 87466a2823cSGoldwyn Rodrigues struct btrfs_fs_info *fs_info = to_fs_info(kobj); 87566a2823cSGoldwyn Rodrigues const char *str; 87666a2823cSGoldwyn Rodrigues 87766a2823cSGoldwyn Rodrigues switch (READ_ONCE(fs_info->exclusive_operation)) { 87866a2823cSGoldwyn Rodrigues case BTRFS_EXCLOP_NONE: 87966a2823cSGoldwyn Rodrigues str = "none\n"; 88066a2823cSGoldwyn Rodrigues break; 88166a2823cSGoldwyn Rodrigues case BTRFS_EXCLOP_BALANCE: 88266a2823cSGoldwyn Rodrigues str = "balance\n"; 88366a2823cSGoldwyn Rodrigues break; 88466a2823cSGoldwyn Rodrigues case BTRFS_EXCLOP_DEV_ADD: 88566a2823cSGoldwyn Rodrigues str = "device add\n"; 88666a2823cSGoldwyn Rodrigues break; 88766a2823cSGoldwyn Rodrigues case BTRFS_EXCLOP_DEV_REMOVE: 88866a2823cSGoldwyn Rodrigues str = "device remove\n"; 88966a2823cSGoldwyn Rodrigues break; 89066a2823cSGoldwyn Rodrigues case BTRFS_EXCLOP_DEV_REPLACE: 89166a2823cSGoldwyn Rodrigues str = "device replace\n"; 89266a2823cSGoldwyn Rodrigues break; 89366a2823cSGoldwyn Rodrigues case BTRFS_EXCLOP_RESIZE: 89466a2823cSGoldwyn Rodrigues str = "resize\n"; 89566a2823cSGoldwyn Rodrigues break; 89666a2823cSGoldwyn Rodrigues case BTRFS_EXCLOP_SWAP_ACTIVATE: 89766a2823cSGoldwyn Rodrigues str = "swap activate\n"; 89866a2823cSGoldwyn Rodrigues break; 89966a2823cSGoldwyn Rodrigues default: 90066a2823cSGoldwyn Rodrigues str = "UNKNOWN\n"; 90166a2823cSGoldwyn Rodrigues break; 90266a2823cSGoldwyn Rodrigues } 90366a2823cSGoldwyn Rodrigues return scnprintf(buf, PAGE_SIZE, "%s", str); 90466a2823cSGoldwyn Rodrigues } 90566a2823cSGoldwyn Rodrigues BTRFS_ATTR(, exclusive_operation, btrfs_exclusive_operation_show); 90666a2823cSGoldwyn Rodrigues 907089c8b05SAnand Jain static ssize_t btrfs_generation_show(struct kobject *kobj, 908089c8b05SAnand Jain struct kobj_attribute *a, char *buf) 909089c8b05SAnand Jain { 910089c8b05SAnand Jain struct btrfs_fs_info *fs_info = to_fs_info(kobj); 911089c8b05SAnand Jain 912089c8b05SAnand Jain return scnprintf(buf, PAGE_SIZE, "%llu\n", fs_info->generation); 913089c8b05SAnand Jain } 914089c8b05SAnand Jain BTRFS_ATTR(, generation, btrfs_generation_show); 915089c8b05SAnand Jain 916aaefed20SAnand Jain /* 917aaefed20SAnand Jain * Look for an exact string @string in @buffer with possible leading or 918aaefed20SAnand Jain * trailing whitespace 919aaefed20SAnand Jain */ 920aaefed20SAnand Jain static bool strmatch(const char *buffer, const char *string) 921aaefed20SAnand Jain { 922aaefed20SAnand Jain const size_t len = strlen(string); 923aaefed20SAnand Jain 924aaefed20SAnand Jain /* Skip leading whitespace */ 925aaefed20SAnand Jain buffer = skip_spaces(buffer); 926aaefed20SAnand Jain 927aaefed20SAnand Jain /* Match entire string, check if the rest is whitespace or empty */ 928aaefed20SAnand Jain if (strncmp(string, buffer, len) == 0 && 929aaefed20SAnand Jain strlen(skip_spaces(buffer + len)) == 0) 930aaefed20SAnand Jain return true; 931aaefed20SAnand Jain 932aaefed20SAnand Jain return false; 933aaefed20SAnand Jain } 934aaefed20SAnand Jain 9353d8cc17aSAnand Jain static const char * const btrfs_read_policy_name[] = { "pid" }; 9363d8cc17aSAnand Jain 9373d8cc17aSAnand Jain static ssize_t btrfs_read_policy_show(struct kobject *kobj, 9383d8cc17aSAnand Jain struct kobj_attribute *a, char *buf) 9393d8cc17aSAnand Jain { 9403d8cc17aSAnand Jain struct btrfs_fs_devices *fs_devices = to_fs_devs(kobj); 9413d8cc17aSAnand Jain ssize_t ret = 0; 9423d8cc17aSAnand Jain int i; 9433d8cc17aSAnand Jain 9443d8cc17aSAnand Jain for (i = 0; i < BTRFS_NR_READ_POLICY; i++) { 9453d8cc17aSAnand Jain if (fs_devices->read_policy == i) 9463d8cc17aSAnand Jain ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%s[%s]", 9473d8cc17aSAnand Jain (ret == 0 ? "" : " "), 9483d8cc17aSAnand Jain btrfs_read_policy_name[i]); 9493d8cc17aSAnand Jain else 9503d8cc17aSAnand Jain ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%s%s", 9513d8cc17aSAnand Jain (ret == 0 ? "" : " "), 9523d8cc17aSAnand Jain btrfs_read_policy_name[i]); 9533d8cc17aSAnand Jain } 9543d8cc17aSAnand Jain 9553d8cc17aSAnand Jain ret += scnprintf(buf + ret, PAGE_SIZE - ret, "\n"); 9563d8cc17aSAnand Jain 9573d8cc17aSAnand Jain return ret; 9583d8cc17aSAnand Jain } 9593d8cc17aSAnand Jain 9603d8cc17aSAnand Jain static ssize_t btrfs_read_policy_store(struct kobject *kobj, 9613d8cc17aSAnand Jain struct kobj_attribute *a, 9623d8cc17aSAnand Jain const char *buf, size_t len) 9633d8cc17aSAnand Jain { 9643d8cc17aSAnand Jain struct btrfs_fs_devices *fs_devices = to_fs_devs(kobj); 9653d8cc17aSAnand Jain int i; 9663d8cc17aSAnand Jain 9673d8cc17aSAnand Jain for (i = 0; i < BTRFS_NR_READ_POLICY; i++) { 9683d8cc17aSAnand Jain if (strmatch(buf, btrfs_read_policy_name[i])) { 9693d8cc17aSAnand Jain if (i != fs_devices->read_policy) { 9703d8cc17aSAnand Jain fs_devices->read_policy = i; 9713d8cc17aSAnand Jain btrfs_info(fs_devices->fs_info, 9723d8cc17aSAnand Jain "read policy set to '%s'", 9733d8cc17aSAnand Jain btrfs_read_policy_name[i]); 9743d8cc17aSAnand Jain } 9753d8cc17aSAnand Jain return len; 9763d8cc17aSAnand Jain } 9773d8cc17aSAnand Jain } 9783d8cc17aSAnand Jain 9793d8cc17aSAnand Jain return -EINVAL; 9803d8cc17aSAnand Jain } 9813d8cc17aSAnand Jain BTRFS_ATTR_RW(, read_policy, btrfs_read_policy_show, btrfs_read_policy_store); 9823d8cc17aSAnand Jain 98318bb8bbfSJohannes Thumshirn static ssize_t btrfs_bg_reclaim_threshold_show(struct kobject *kobj, 98418bb8bbfSJohannes Thumshirn struct kobj_attribute *a, 98518bb8bbfSJohannes Thumshirn char *buf) 98618bb8bbfSJohannes Thumshirn { 98718bb8bbfSJohannes Thumshirn struct btrfs_fs_info *fs_info = to_fs_info(kobj); 98818bb8bbfSJohannes Thumshirn ssize_t ret; 98918bb8bbfSJohannes Thumshirn 99018bb8bbfSJohannes Thumshirn ret = scnprintf(buf, PAGE_SIZE, "%d\n", fs_info->bg_reclaim_threshold); 99118bb8bbfSJohannes Thumshirn 99218bb8bbfSJohannes Thumshirn return ret; 99318bb8bbfSJohannes Thumshirn } 99418bb8bbfSJohannes Thumshirn 99518bb8bbfSJohannes Thumshirn static ssize_t btrfs_bg_reclaim_threshold_store(struct kobject *kobj, 99618bb8bbfSJohannes Thumshirn struct kobj_attribute *a, 99718bb8bbfSJohannes Thumshirn const char *buf, size_t len) 99818bb8bbfSJohannes Thumshirn { 99918bb8bbfSJohannes Thumshirn struct btrfs_fs_info *fs_info = to_fs_info(kobj); 100018bb8bbfSJohannes Thumshirn int thresh; 100118bb8bbfSJohannes Thumshirn int ret; 100218bb8bbfSJohannes Thumshirn 100318bb8bbfSJohannes Thumshirn ret = kstrtoint(buf, 10, &thresh); 100418bb8bbfSJohannes Thumshirn if (ret) 100518bb8bbfSJohannes Thumshirn return ret; 100618bb8bbfSJohannes Thumshirn 100718bb8bbfSJohannes Thumshirn if (thresh <= 50 || thresh > 100) 100818bb8bbfSJohannes Thumshirn return -EINVAL; 100918bb8bbfSJohannes Thumshirn 101018bb8bbfSJohannes Thumshirn fs_info->bg_reclaim_threshold = thresh; 101118bb8bbfSJohannes Thumshirn 101218bb8bbfSJohannes Thumshirn return len; 101318bb8bbfSJohannes Thumshirn } 101418bb8bbfSJohannes Thumshirn BTRFS_ATTR_RW(, bg_reclaim_threshold, btrfs_bg_reclaim_threshold_show, 101518bb8bbfSJohannes Thumshirn btrfs_bg_reclaim_threshold_store); 101618bb8bbfSJohannes Thumshirn 10170dd2906fSAnand Jain static const struct attribute *btrfs_attrs[] = { 1018a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(, label), 1019a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(, nodesize), 1020a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(, sectorsize), 1021a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(, clone_alignment), 1022a969f4ccSHans van Kranenburg BTRFS_ATTR_PTR(, quota_override), 102356f20f40SNikolay Borisov BTRFS_ATTR_PTR(, metadata_uuid), 102441e6d2a8SJohannes Thumshirn BTRFS_ATTR_PTR(, checksum), 102566a2823cSGoldwyn Rodrigues BTRFS_ATTR_PTR(, exclusive_operation), 1026089c8b05SAnand Jain BTRFS_ATTR_PTR(, generation), 10273d8cc17aSAnand Jain BTRFS_ATTR_PTR(, read_policy), 102818bb8bbfSJohannes Thumshirn BTRFS_ATTR_PTR(, bg_reclaim_threshold), 1029f8ba9c11SJeff Mahoney NULL, 1030f8ba9c11SJeff Mahoney }; 1031f8ba9c11SJeff Mahoney 1032c1b7e474SAnand Jain static void btrfs_release_fsid_kobj(struct kobject *kobj) 1033510d7360SJeff Mahoney { 10342e7910d6SAnand Jain struct btrfs_fs_devices *fs_devs = to_fs_devs(kobj); 1035248d200dSAnand Jain 1036c1b7e474SAnand Jain memset(&fs_devs->fsid_kobj, 0, sizeof(struct kobject)); 10372e7910d6SAnand Jain complete(&fs_devs->kobj_unregister); 1038510d7360SJeff Mahoney } 1039510d7360SJeff Mahoney 1040510d7360SJeff Mahoney static struct kobj_type btrfs_ktype = { 1041510d7360SJeff Mahoney .sysfs_ops = &kobj_sysfs_ops, 1042c1b7e474SAnand Jain .release = btrfs_release_fsid_kobj, 1043510d7360SJeff Mahoney }; 1044510d7360SJeff Mahoney 10452e7910d6SAnand Jain static inline struct btrfs_fs_devices *to_fs_devs(struct kobject *kobj) 10462e7910d6SAnand Jain { 10472e7910d6SAnand Jain if (kobj->ktype != &btrfs_ktype) 10482e7910d6SAnand Jain return NULL; 1049c1b7e474SAnand Jain return container_of(kobj, struct btrfs_fs_devices, fsid_kobj); 10502e7910d6SAnand Jain } 10512e7910d6SAnand Jain 1052510d7360SJeff Mahoney static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj) 1053510d7360SJeff Mahoney { 1054510d7360SJeff Mahoney if (kobj->ktype != &btrfs_ktype) 1055510d7360SJeff Mahoney return NULL; 10562e7910d6SAnand Jain return to_fs_devs(kobj)->fs_info; 1057510d7360SJeff Mahoney } 105858176a96SJosef Bacik 1059e453d989SJeff Mahoney #define NUM_FEATURE_BITS 64 10606c52157fSTomohiro Misono #define BTRFS_FEATURE_NAME_MAX 13 10616c52157fSTomohiro Misono static char btrfs_unknown_feature_names[FEAT_MAX][NUM_FEATURE_BITS][BTRFS_FEATURE_NAME_MAX]; 10626c52157fSTomohiro Misono static struct btrfs_feature_attr btrfs_feature_attrs[FEAT_MAX][NUM_FEATURE_BITS]; 1063e453d989SJeff Mahoney 10646c52157fSTomohiro Misono static const u64 supported_feature_masks[FEAT_MAX] = { 1065e453d989SJeff Mahoney [FEAT_COMPAT] = BTRFS_FEATURE_COMPAT_SUPP, 1066e453d989SJeff Mahoney [FEAT_COMPAT_RO] = BTRFS_FEATURE_COMPAT_RO_SUPP, 1067e453d989SJeff Mahoney [FEAT_INCOMPAT] = BTRFS_FEATURE_INCOMPAT_SUPP, 1068e453d989SJeff Mahoney }; 1069e453d989SJeff Mahoney 1070e453d989SJeff Mahoney static int addrm_unknown_feature_attrs(struct btrfs_fs_info *fs_info, bool add) 10715ac1d209SJeff Mahoney { 1072e453d989SJeff Mahoney int set; 1073e453d989SJeff Mahoney 1074e453d989SJeff Mahoney for (set = 0; set < FEAT_MAX; set++) { 1075e453d989SJeff Mahoney int i; 1076e453d989SJeff Mahoney struct attribute *attrs[2]; 1077e453d989SJeff Mahoney struct attribute_group agroup = { 1078e453d989SJeff Mahoney .name = "features", 1079e453d989SJeff Mahoney .attrs = attrs, 1080e453d989SJeff Mahoney }; 1081e453d989SJeff Mahoney u64 features = get_features(fs_info, set); 1082e453d989SJeff Mahoney features &= ~supported_feature_masks[set]; 1083e453d989SJeff Mahoney 1084e453d989SJeff Mahoney if (!features) 1085e453d989SJeff Mahoney continue; 1086e453d989SJeff Mahoney 1087e453d989SJeff Mahoney attrs[1] = NULL; 1088e453d989SJeff Mahoney for (i = 0; i < NUM_FEATURE_BITS; i++) { 1089e453d989SJeff Mahoney struct btrfs_feature_attr *fa; 1090e453d989SJeff Mahoney 1091e453d989SJeff Mahoney if (!(features & (1ULL << i))) 1092e453d989SJeff Mahoney continue; 1093e453d989SJeff Mahoney 1094e453d989SJeff Mahoney fa = &btrfs_feature_attrs[set][i]; 1095e453d989SJeff Mahoney attrs[0] = &fa->kobj_attr.attr; 1096e453d989SJeff Mahoney if (add) { 1097e453d989SJeff Mahoney int ret; 1098c1b7e474SAnand Jain ret = sysfs_merge_group(&fs_info->fs_devices->fsid_kobj, 1099e453d989SJeff Mahoney &agroup); 1100e453d989SJeff Mahoney if (ret) 1101e453d989SJeff Mahoney return ret; 1102e453d989SJeff Mahoney } else 1103c1b7e474SAnand Jain sysfs_unmerge_group(&fs_info->fs_devices->fsid_kobj, 1104e453d989SJeff Mahoney &agroup); 1105e453d989SJeff Mahoney } 1106e453d989SJeff Mahoney 1107e453d989SJeff Mahoney } 1108e453d989SJeff Mahoney return 0; 1109e453d989SJeff Mahoney } 1110e453d989SJeff Mahoney 11112e3e1281SAnand Jain static void __btrfs_sysfs_remove_fsid(struct btrfs_fs_devices *fs_devs) 1112e453d989SJeff Mahoney { 1113a013d141SAnand Jain if (fs_devs->devinfo_kobj) { 1114a013d141SAnand Jain kobject_del(fs_devs->devinfo_kobj); 1115a013d141SAnand Jain kobject_put(fs_devs->devinfo_kobj); 1116a013d141SAnand Jain fs_devs->devinfo_kobj = NULL; 1117a013d141SAnand Jain } 1118a013d141SAnand Jain 1119b5501504SAnand Jain if (fs_devs->devices_kobj) { 1120b5501504SAnand Jain kobject_del(fs_devs->devices_kobj); 1121b5501504SAnand Jain kobject_put(fs_devs->devices_kobj); 1122b5501504SAnand Jain fs_devs->devices_kobj = NULL; 1123aaf13305SAnand Jain } 1124aaf13305SAnand Jain 1125c1b7e474SAnand Jain if (fs_devs->fsid_kobj.state_initialized) { 1126c1b7e474SAnand Jain kobject_del(&fs_devs->fsid_kobj); 1127c1b7e474SAnand Jain kobject_put(&fs_devs->fsid_kobj); 11282e7910d6SAnand Jain wait_for_completion(&fs_devs->kobj_unregister); 11295ac1d209SJeff Mahoney } 1130f90fc547SAnand Jain } 11315ac1d209SJeff Mahoney 11322e3e1281SAnand Jain /* when fs_devs is NULL it will remove all fsid kobject */ 11331d1c1be3SAnand Jain void btrfs_sysfs_remove_fsid(struct btrfs_fs_devices *fs_devs) 11342e3e1281SAnand Jain { 11352e3e1281SAnand Jain struct list_head *fs_uuids = btrfs_get_fs_uuids(); 11362e3e1281SAnand Jain 11372e3e1281SAnand Jain if (fs_devs) { 11382e3e1281SAnand Jain __btrfs_sysfs_remove_fsid(fs_devs); 11392e3e1281SAnand Jain return; 11402e3e1281SAnand Jain } 11412e3e1281SAnand Jain 1142c4babc5eSAnand Jain list_for_each_entry(fs_devs, fs_uuids, fs_list) { 11432e3e1281SAnand Jain __btrfs_sysfs_remove_fsid(fs_devs); 11442e3e1281SAnand Jain } 11452e3e1281SAnand Jain } 11462e3e1281SAnand Jain 114753f8a74cSAnand Jain static void btrfs_sysfs_remove_fs_devices(struct btrfs_fs_devices *fs_devices) 114853f8a74cSAnand Jain { 114953f8a74cSAnand Jain struct btrfs_device *device; 115030b0e4e0SAnand Jain struct btrfs_fs_devices *seed; 115153f8a74cSAnand Jain 115253f8a74cSAnand Jain list_for_each_entry(device, &fs_devices->devices, dev_list) 115353f8a74cSAnand Jain btrfs_sysfs_remove_device(device); 115430b0e4e0SAnand Jain 115530b0e4e0SAnand Jain list_for_each_entry(seed, &fs_devices->seed_list, seed_list) { 115630b0e4e0SAnand Jain list_for_each_entry(device, &seed->devices, dev_list) 115730b0e4e0SAnand Jain btrfs_sysfs_remove_device(device); 115830b0e4e0SAnand Jain } 115953f8a74cSAnand Jain } 116053f8a74cSAnand Jain 11616618a59bSAnand Jain void btrfs_sysfs_remove_mounted(struct btrfs_fs_info *fs_info) 1162e453d989SJeff Mahoney { 11633092c68fSNikolay Borisov struct kobject *fsid_kobj = &fs_info->fs_devices->fsid_kobj; 11643092c68fSNikolay Borisov 11653092c68fSNikolay Borisov sysfs_remove_link(fsid_kobj, "bdi"); 11663092c68fSNikolay Borisov 1167e453d989SJeff Mahoney if (fs_info->space_info_kobj) { 1168e453d989SJeff Mahoney sysfs_remove_files(fs_info->space_info_kobj, allocation_attrs); 1169e453d989SJeff Mahoney kobject_del(fs_info->space_info_kobj); 1170e453d989SJeff Mahoney kobject_put(fs_info->space_info_kobj); 1171e453d989SJeff Mahoney } 117271e8978eSDennis Zhou #ifdef CONFIG_BTRFS_DEBUG 1173e4faab84SDennis Zhou if (fs_info->discard_debug_kobj) { 1174e4faab84SDennis Zhou sysfs_remove_files(fs_info->discard_debug_kobj, 1175e4faab84SDennis Zhou discard_debug_attrs); 1176e4faab84SDennis Zhou kobject_del(fs_info->discard_debug_kobj); 1177e4faab84SDennis Zhou kobject_put(fs_info->discard_debug_kobj); 1178e4faab84SDennis Zhou } 117993945cb4SDennis Zhou if (fs_info->debug_kobj) { 118093945cb4SDennis Zhou sysfs_remove_files(fs_info->debug_kobj, btrfs_debug_mount_attrs); 118193945cb4SDennis Zhou kobject_del(fs_info->debug_kobj); 118293945cb4SDennis Zhou kobject_put(fs_info->debug_kobj); 118393945cb4SDennis Zhou } 118471e8978eSDennis Zhou #endif 1185e453d989SJeff Mahoney addrm_unknown_feature_attrs(fs_info, false); 11863092c68fSNikolay Borisov sysfs_remove_group(fsid_kobj, &btrfs_feature_attr_group); 11873092c68fSNikolay Borisov sysfs_remove_files(fsid_kobj, btrfs_attrs); 118853f8a74cSAnand Jain btrfs_sysfs_remove_fs_devices(fs_info->fs_devices); 1189e453d989SJeff Mahoney } 1190e453d989SJeff Mahoney 1191f10152bcSDavid Sterba static const char * const btrfs_feature_set_names[FEAT_MAX] = { 119279da4fa4SJeff Mahoney [FEAT_COMPAT] = "compat", 119379da4fa4SJeff Mahoney [FEAT_COMPAT_RO] = "compat_ro", 119479da4fa4SJeff Mahoney [FEAT_INCOMPAT] = "incompat", 119579da4fa4SJeff Mahoney }; 119679da4fa4SJeff Mahoney 11979e6df7ceSDavid Sterba const char *btrfs_feature_set_name(enum btrfs_feature_set set) 1198f10152bcSDavid Sterba { 1199f10152bcSDavid Sterba return btrfs_feature_set_names[set]; 1200f10152bcSDavid Sterba } 1201f10152bcSDavid Sterba 12023b02a68aSJeff Mahoney char *btrfs_printable_features(enum btrfs_feature_set set, u64 flags) 12033b02a68aSJeff Mahoney { 12043b02a68aSJeff Mahoney size_t bufsize = 4096; /* safe max, 64 names * 64 bytes */ 12053b02a68aSJeff Mahoney int len = 0; 12063b02a68aSJeff Mahoney int i; 12073b02a68aSJeff Mahoney char *str; 12083b02a68aSJeff Mahoney 12093b02a68aSJeff Mahoney str = kmalloc(bufsize, GFP_KERNEL); 12103b02a68aSJeff Mahoney if (!str) 12113b02a68aSJeff Mahoney return str; 12123b02a68aSJeff Mahoney 12133b02a68aSJeff Mahoney for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) { 12143b02a68aSJeff Mahoney const char *name; 12153b02a68aSJeff Mahoney 12163b02a68aSJeff Mahoney if (!(flags & (1ULL << i))) 12173b02a68aSJeff Mahoney continue; 12183b02a68aSJeff Mahoney 12193b02a68aSJeff Mahoney name = btrfs_feature_attrs[set][i].kobj_attr.attr.name; 1220abdd9febSTakashi Iwai len += scnprintf(str + len, bufsize - len, "%s%s", 12213b02a68aSJeff Mahoney len ? "," : "", name); 12223b02a68aSJeff Mahoney } 12233b02a68aSJeff Mahoney 12243b02a68aSJeff Mahoney return str; 12253b02a68aSJeff Mahoney } 12263b02a68aSJeff Mahoney 122779da4fa4SJeff Mahoney static void init_feature_attrs(void) 122879da4fa4SJeff Mahoney { 122979da4fa4SJeff Mahoney struct btrfs_feature_attr *fa; 123079da4fa4SJeff Mahoney int set, i; 123179da4fa4SJeff Mahoney 123279da4fa4SJeff Mahoney BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names) != 123379da4fa4SJeff Mahoney ARRAY_SIZE(btrfs_feature_attrs)); 123479da4fa4SJeff Mahoney BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names[0]) != 123579da4fa4SJeff Mahoney ARRAY_SIZE(btrfs_feature_attrs[0])); 123679da4fa4SJeff Mahoney 12373b02a68aSJeff Mahoney memset(btrfs_feature_attrs, 0, sizeof(btrfs_feature_attrs)); 12383b02a68aSJeff Mahoney memset(btrfs_unknown_feature_names, 0, 12393b02a68aSJeff Mahoney sizeof(btrfs_unknown_feature_names)); 12403b02a68aSJeff Mahoney 124179da4fa4SJeff Mahoney for (i = 0; btrfs_supported_feature_attrs[i]; i++) { 124279da4fa4SJeff Mahoney struct btrfs_feature_attr *sfa; 124379da4fa4SJeff Mahoney struct attribute *a = btrfs_supported_feature_attrs[i]; 12443b02a68aSJeff Mahoney int bit; 124579da4fa4SJeff Mahoney sfa = attr_to_btrfs_feature_attr(a); 12463b02a68aSJeff Mahoney bit = ilog2(sfa->feature_bit); 12473b02a68aSJeff Mahoney fa = &btrfs_feature_attrs[sfa->feature_set][bit]; 124879da4fa4SJeff Mahoney 124979da4fa4SJeff Mahoney fa->kobj_attr.attr.name = sfa->kobj_attr.attr.name; 125079da4fa4SJeff Mahoney } 125179da4fa4SJeff Mahoney 125279da4fa4SJeff Mahoney for (set = 0; set < FEAT_MAX; set++) { 125379da4fa4SJeff Mahoney for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) { 125479da4fa4SJeff Mahoney char *name = btrfs_unknown_feature_names[set][i]; 125579da4fa4SJeff Mahoney fa = &btrfs_feature_attrs[set][i]; 125679da4fa4SJeff Mahoney 125779da4fa4SJeff Mahoney if (fa->kobj_attr.attr.name) 125879da4fa4SJeff Mahoney continue; 125979da4fa4SJeff Mahoney 12606c52157fSTomohiro Misono snprintf(name, BTRFS_FEATURE_NAME_MAX, "%s:%u", 126179da4fa4SJeff Mahoney btrfs_feature_set_names[set], i); 126279da4fa4SJeff Mahoney 126379da4fa4SJeff Mahoney fa->kobj_attr.attr.name = name; 126479da4fa4SJeff Mahoney fa->kobj_attr.attr.mode = S_IRUGO; 126579da4fa4SJeff Mahoney fa->feature_set = set; 126679da4fa4SJeff Mahoney fa->feature_bit = 1ULL << i; 126779da4fa4SJeff Mahoney } 126879da4fa4SJeff Mahoney } 126979da4fa4SJeff Mahoney } 127079da4fa4SJeff Mahoney 127132a9991fSDavid Sterba /* 127232a9991fSDavid Sterba * Create a sysfs entry for a given block group type at path 127332a9991fSDavid Sterba * /sys/fs/btrfs/UUID/allocation/data/TYPE 127432a9991fSDavid Sterba */ 127532da5386SDavid Sterba void btrfs_sysfs_add_block_group_type(struct btrfs_block_group *cache) 127632a9991fSDavid Sterba { 127732a9991fSDavid Sterba struct btrfs_fs_info *fs_info = cache->fs_info; 127832a9991fSDavid Sterba struct btrfs_space_info *space_info = cache->space_info; 127932a9991fSDavid Sterba struct raid_kobject *rkobj; 128032a9991fSDavid Sterba const int index = btrfs_bg_flags_to_raid_index(cache->flags); 128132a9991fSDavid Sterba unsigned int nofs_flag; 128232a9991fSDavid Sterba int ret; 128332a9991fSDavid Sterba 128432a9991fSDavid Sterba /* 128532a9991fSDavid Sterba * Setup a NOFS context because kobject_add(), deep in its call chain, 128632a9991fSDavid Sterba * does GFP_KERNEL allocations, and we are often called in a context 128732a9991fSDavid Sterba * where if reclaim is triggered we can deadlock (we are either holding 128832a9991fSDavid Sterba * a transaction handle or some lock required for a transaction 128932a9991fSDavid Sterba * commit). 129032a9991fSDavid Sterba */ 129132a9991fSDavid Sterba nofs_flag = memalloc_nofs_save(); 129232a9991fSDavid Sterba 129332a9991fSDavid Sterba rkobj = kzalloc(sizeof(*rkobj), GFP_NOFS); 129432a9991fSDavid Sterba if (!rkobj) { 129532a9991fSDavid Sterba memalloc_nofs_restore(nofs_flag); 129632a9991fSDavid Sterba btrfs_warn(cache->fs_info, 129732a9991fSDavid Sterba "couldn't alloc memory for raid level kobject"); 129832a9991fSDavid Sterba return; 129932a9991fSDavid Sterba } 130032a9991fSDavid Sterba 130132a9991fSDavid Sterba rkobj->flags = cache->flags; 130232a9991fSDavid Sterba kobject_init(&rkobj->kobj, &btrfs_raid_ktype); 130349ea112dSJosef Bacik 130449ea112dSJosef Bacik /* 130549ea112dSJosef Bacik * We call this either on mount, or if we've created a block group for a 130649ea112dSJosef Bacik * new index type while running (i.e. when restriping). The running 130749ea112dSJosef Bacik * case is tricky because we could race with other threads, so we need 130849ea112dSJosef Bacik * to have this check to make sure we didn't already init the kobject. 130949ea112dSJosef Bacik * 131049ea112dSJosef Bacik * We don't have to protect on the free side because it only happens on 131149ea112dSJosef Bacik * unmount. 131249ea112dSJosef Bacik */ 131349ea112dSJosef Bacik spin_lock(&space_info->lock); 131449ea112dSJosef Bacik if (space_info->block_group_kobjs[index]) { 131549ea112dSJosef Bacik spin_unlock(&space_info->lock); 131649ea112dSJosef Bacik kobject_put(&rkobj->kobj); 131749ea112dSJosef Bacik return; 131849ea112dSJosef Bacik } else { 131949ea112dSJosef Bacik space_info->block_group_kobjs[index] = &rkobj->kobj; 132049ea112dSJosef Bacik } 132149ea112dSJosef Bacik spin_unlock(&space_info->lock); 132249ea112dSJosef Bacik 132332a9991fSDavid Sterba ret = kobject_add(&rkobj->kobj, &space_info->kobj, "%s", 132432a9991fSDavid Sterba btrfs_bg_type_to_raid_name(rkobj->flags)); 132532a9991fSDavid Sterba memalloc_nofs_restore(nofs_flag); 132632a9991fSDavid Sterba if (ret) { 132749ea112dSJosef Bacik spin_lock(&space_info->lock); 132849ea112dSJosef Bacik space_info->block_group_kobjs[index] = NULL; 132949ea112dSJosef Bacik spin_unlock(&space_info->lock); 133032a9991fSDavid Sterba kobject_put(&rkobj->kobj); 133132a9991fSDavid Sterba btrfs_warn(fs_info, 133232a9991fSDavid Sterba "failed to add kobject for block cache, ignoring"); 133332a9991fSDavid Sterba return; 133432a9991fSDavid Sterba } 133532a9991fSDavid Sterba } 133632a9991fSDavid Sterba 1337b5865babSDavid Sterba /* 1338b5865babSDavid Sterba * Remove sysfs directories for all block group types of a given space info and 1339b5865babSDavid Sterba * the space info as well 1340b5865babSDavid Sterba */ 1341b5865babSDavid Sterba void btrfs_sysfs_remove_space_info(struct btrfs_space_info *space_info) 1342b5865babSDavid Sterba { 1343b5865babSDavid Sterba int i; 1344b5865babSDavid Sterba 1345b5865babSDavid Sterba for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) { 1346b5865babSDavid Sterba struct kobject *kobj; 1347b5865babSDavid Sterba 1348b5865babSDavid Sterba kobj = space_info->block_group_kobjs[i]; 1349b5865babSDavid Sterba space_info->block_group_kobjs[i] = NULL; 1350b5865babSDavid Sterba if (kobj) { 1351b5865babSDavid Sterba kobject_del(kobj); 1352b5865babSDavid Sterba kobject_put(kobj); 1353b5865babSDavid Sterba } 1354b5865babSDavid Sterba } 1355b5865babSDavid Sterba kobject_del(&space_info->kobj); 1356b5865babSDavid Sterba kobject_put(&space_info->kobj); 1357b5865babSDavid Sterba } 1358b5865babSDavid Sterba 1359b882327aSDavid Sterba static const char *alloc_name(u64 flags) 1360b882327aSDavid Sterba { 1361b882327aSDavid Sterba switch (flags) { 1362b882327aSDavid Sterba case BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_DATA: 1363b882327aSDavid Sterba return "mixed"; 1364b882327aSDavid Sterba case BTRFS_BLOCK_GROUP_METADATA: 1365b882327aSDavid Sterba return "metadata"; 1366b882327aSDavid Sterba case BTRFS_BLOCK_GROUP_DATA: 1367b882327aSDavid Sterba return "data"; 1368b882327aSDavid Sterba case BTRFS_BLOCK_GROUP_SYSTEM: 1369b882327aSDavid Sterba return "system"; 1370b882327aSDavid Sterba default: 1371b882327aSDavid Sterba WARN_ON(1); 1372b882327aSDavid Sterba return "invalid-combination"; 1373445d8ab5STom Rix } 1374b882327aSDavid Sterba } 1375b882327aSDavid Sterba 1376b882327aSDavid Sterba /* 1377b882327aSDavid Sterba * Create a sysfs entry for a space info type at path 1378b882327aSDavid Sterba * /sys/fs/btrfs/UUID/allocation/TYPE 1379b882327aSDavid Sterba */ 1380b882327aSDavid Sterba int btrfs_sysfs_add_space_info_type(struct btrfs_fs_info *fs_info, 1381b882327aSDavid Sterba struct btrfs_space_info *space_info) 1382b882327aSDavid Sterba { 1383b882327aSDavid Sterba int ret; 1384b882327aSDavid Sterba 1385b882327aSDavid Sterba ret = kobject_init_and_add(&space_info->kobj, &space_info_ktype, 1386b882327aSDavid Sterba fs_info->space_info_kobj, "%s", 1387b882327aSDavid Sterba alloc_name(space_info->flags)); 1388b882327aSDavid Sterba if (ret) { 1389b882327aSDavid Sterba kobject_put(&space_info->kobj); 1390b882327aSDavid Sterba return ret; 1391b882327aSDavid Sterba } 1392b882327aSDavid Sterba 1393b882327aSDavid Sterba return 0; 1394b882327aSDavid Sterba } 1395b882327aSDavid Sterba 139653f8a74cSAnand Jain void btrfs_sysfs_remove_device(struct btrfs_device *device) 139799994cdeSAnand Jain { 1398985e233eSAnand Jain struct kobject *devices_kobj; 139999994cdeSAnand Jain 1400985e233eSAnand Jain /* 1401985e233eSAnand Jain * Seed fs_devices devices_kobj aren't used, fetch kobject from the 1402985e233eSAnand Jain * fs_info::fs_devices. 1403985e233eSAnand Jain */ 1404985e233eSAnand Jain devices_kobj = device->fs_info->fs_devices->devices_kobj; 1405985e233eSAnand Jain ASSERT(devices_kobj); 140699994cdeSAnand Jain 14078d65269fSChristoph Hellwig if (device->bdev) 14088d65269fSChristoph Hellwig sysfs_remove_link(devices_kobj, bdev_kobj(device->bdev)->name); 140999994cdeSAnand Jain 1410985e233eSAnand Jain if (device->devid_kobj.state_initialized) { 1411985e233eSAnand Jain kobject_del(&device->devid_kobj); 1412985e233eSAnand Jain kobject_put(&device->devid_kobj); 1413985e233eSAnand Jain wait_for_completion(&device->kobj_unregister); 1414985e233eSAnand Jain } 1415b5ddcffaSAnand Jain } 1416668e48afSAnand Jain 1417668e48afSAnand Jain static ssize_t btrfs_devinfo_in_fs_metadata_show(struct kobject *kobj, 1418668e48afSAnand Jain struct kobj_attribute *a, 1419668e48afSAnand Jain char *buf) 1420668e48afSAnand Jain { 1421668e48afSAnand Jain int val; 1422668e48afSAnand Jain struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1423668e48afSAnand Jain devid_kobj); 1424668e48afSAnand Jain 1425668e48afSAnand Jain val = !!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); 1426668e48afSAnand Jain 1427abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%d\n", val); 1428668e48afSAnand Jain } 1429668e48afSAnand Jain BTRFS_ATTR(devid, in_fs_metadata, btrfs_devinfo_in_fs_metadata_show); 1430668e48afSAnand Jain 143125864778SAnand Jain static ssize_t btrfs_devinfo_missing_show(struct kobject *kobj, 1432668e48afSAnand Jain struct kobj_attribute *a, char *buf) 1433668e48afSAnand Jain { 1434668e48afSAnand Jain int val; 1435668e48afSAnand Jain struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1436668e48afSAnand Jain devid_kobj); 1437668e48afSAnand Jain 1438668e48afSAnand Jain val = !!test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state); 1439668e48afSAnand Jain 1440abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%d\n", val); 1441668e48afSAnand Jain } 144225864778SAnand Jain BTRFS_ATTR(devid, missing, btrfs_devinfo_missing_show); 1443668e48afSAnand Jain 1444668e48afSAnand Jain static ssize_t btrfs_devinfo_replace_target_show(struct kobject *kobj, 1445668e48afSAnand Jain struct kobj_attribute *a, 1446668e48afSAnand Jain char *buf) 1447668e48afSAnand Jain { 1448668e48afSAnand Jain int val; 1449668e48afSAnand Jain struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1450668e48afSAnand Jain devid_kobj); 1451668e48afSAnand Jain 1452668e48afSAnand Jain val = !!test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); 1453668e48afSAnand Jain 1454abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%d\n", val); 1455668e48afSAnand Jain } 1456668e48afSAnand Jain BTRFS_ATTR(devid, replace_target, btrfs_devinfo_replace_target_show); 1457668e48afSAnand Jain 1458eb3b5053SDavid Sterba static ssize_t btrfs_devinfo_scrub_speed_max_show(struct kobject *kobj, 1459eb3b5053SDavid Sterba struct kobj_attribute *a, 1460eb3b5053SDavid Sterba char *buf) 1461eb3b5053SDavid Sterba { 1462eb3b5053SDavid Sterba struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1463eb3b5053SDavid Sterba devid_kobj); 1464eb3b5053SDavid Sterba 1465eb3b5053SDavid Sterba return scnprintf(buf, PAGE_SIZE, "%llu\n", 1466eb3b5053SDavid Sterba READ_ONCE(device->scrub_speed_max)); 1467eb3b5053SDavid Sterba } 1468eb3b5053SDavid Sterba 1469eb3b5053SDavid Sterba static ssize_t btrfs_devinfo_scrub_speed_max_store(struct kobject *kobj, 1470eb3b5053SDavid Sterba struct kobj_attribute *a, 1471eb3b5053SDavid Sterba const char *buf, size_t len) 1472eb3b5053SDavid Sterba { 1473eb3b5053SDavid Sterba struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1474eb3b5053SDavid Sterba devid_kobj); 1475eb3b5053SDavid Sterba char *endptr; 1476eb3b5053SDavid Sterba unsigned long long limit; 1477eb3b5053SDavid Sterba 1478eb3b5053SDavid Sterba limit = memparse(buf, &endptr); 1479eb3b5053SDavid Sterba WRITE_ONCE(device->scrub_speed_max, limit); 1480eb3b5053SDavid Sterba return len; 1481eb3b5053SDavid Sterba } 1482eb3b5053SDavid Sterba BTRFS_ATTR_RW(devid, scrub_speed_max, btrfs_devinfo_scrub_speed_max_show, 1483eb3b5053SDavid Sterba btrfs_devinfo_scrub_speed_max_store); 1484eb3b5053SDavid Sterba 1485668e48afSAnand Jain static ssize_t btrfs_devinfo_writeable_show(struct kobject *kobj, 1486668e48afSAnand Jain struct kobj_attribute *a, char *buf) 1487668e48afSAnand Jain { 1488668e48afSAnand Jain int val; 1489668e48afSAnand Jain struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1490668e48afSAnand Jain devid_kobj); 1491668e48afSAnand Jain 1492668e48afSAnand Jain val = !!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); 1493668e48afSAnand Jain 1494abdd9febSTakashi Iwai return scnprintf(buf, PAGE_SIZE, "%d\n", val); 1495668e48afSAnand Jain } 1496668e48afSAnand Jain BTRFS_ATTR(devid, writeable, btrfs_devinfo_writeable_show); 1497668e48afSAnand Jain 1498*da658b57SDavid Sterba static ssize_t btrfs_devinfo_error_stats_show(struct kobject *kobj, 1499*da658b57SDavid Sterba struct kobj_attribute *a, char *buf) 1500*da658b57SDavid Sterba { 1501*da658b57SDavid Sterba struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1502*da658b57SDavid Sterba devid_kobj); 1503*da658b57SDavid Sterba 1504*da658b57SDavid Sterba if (!device->dev_stats_valid) 1505*da658b57SDavid Sterba return scnprintf(buf, PAGE_SIZE, "invalid\n"); 1506*da658b57SDavid Sterba 1507*da658b57SDavid Sterba /* 1508*da658b57SDavid Sterba * Print all at once so we get a snapshot of all values from the same 1509*da658b57SDavid Sterba * time. Keep them in sync and in order of definition of 1510*da658b57SDavid Sterba * btrfs_dev_stat_values. 1511*da658b57SDavid Sterba */ 1512*da658b57SDavid Sterba return scnprintf(buf, PAGE_SIZE, 1513*da658b57SDavid Sterba "write_errs %d\n" 1514*da658b57SDavid Sterba "read_errs %d\n" 1515*da658b57SDavid Sterba "flush_errs %d\n" 1516*da658b57SDavid Sterba "corruption_errs %d\n" 1517*da658b57SDavid Sterba "generation_errs %d\n", 1518*da658b57SDavid Sterba btrfs_dev_stat_read(device, BTRFS_DEV_STAT_WRITE_ERRS), 1519*da658b57SDavid Sterba btrfs_dev_stat_read(device, BTRFS_DEV_STAT_READ_ERRS), 1520*da658b57SDavid Sterba btrfs_dev_stat_read(device, BTRFS_DEV_STAT_FLUSH_ERRS), 1521*da658b57SDavid Sterba btrfs_dev_stat_read(device, BTRFS_DEV_STAT_CORRUPTION_ERRS), 1522*da658b57SDavid Sterba btrfs_dev_stat_read(device, BTRFS_DEV_STAT_GENERATION_ERRS)); 1523*da658b57SDavid Sterba } 1524*da658b57SDavid Sterba BTRFS_ATTR(devid, error_stats, btrfs_devinfo_error_stats_show); 1525*da658b57SDavid Sterba 1526668e48afSAnand Jain static struct attribute *devid_attrs[] = { 1527*da658b57SDavid Sterba BTRFS_ATTR_PTR(devid, error_stats), 1528668e48afSAnand Jain BTRFS_ATTR_PTR(devid, in_fs_metadata), 1529668e48afSAnand Jain BTRFS_ATTR_PTR(devid, missing), 1530668e48afSAnand Jain BTRFS_ATTR_PTR(devid, replace_target), 1531eb3b5053SDavid Sterba BTRFS_ATTR_PTR(devid, scrub_speed_max), 1532668e48afSAnand Jain BTRFS_ATTR_PTR(devid, writeable), 1533668e48afSAnand Jain NULL 1534668e48afSAnand Jain }; 1535668e48afSAnand Jain ATTRIBUTE_GROUPS(devid); 1536668e48afSAnand Jain 1537668e48afSAnand Jain static void btrfs_release_devid_kobj(struct kobject *kobj) 1538668e48afSAnand Jain { 1539668e48afSAnand Jain struct btrfs_device *device = container_of(kobj, struct btrfs_device, 1540668e48afSAnand Jain devid_kobj); 1541668e48afSAnand Jain 1542668e48afSAnand Jain memset(&device->devid_kobj, 0, sizeof(struct kobject)); 1543668e48afSAnand Jain complete(&device->kobj_unregister); 1544668e48afSAnand Jain } 1545668e48afSAnand Jain 1546668e48afSAnand Jain static struct kobj_type devid_ktype = { 1547668e48afSAnand Jain .sysfs_ops = &kobj_sysfs_ops, 1548668e48afSAnand Jain .default_groups = devid_groups, 1549668e48afSAnand Jain .release = btrfs_release_devid_kobj, 1550668e48afSAnand Jain }; 1551668e48afSAnand Jain 1552cd36da2eSAnand Jain int btrfs_sysfs_add_device(struct btrfs_device *device) 155329e5be24SJeff Mahoney { 1554178a16c9SAnand Jain int ret; 1555a47bd78dSJosef Bacik unsigned int nofs_flag; 1556178a16c9SAnand Jain struct kobject *devices_kobj; 1557178a16c9SAnand Jain struct kobject *devinfo_kobj; 1558178a16c9SAnand Jain 1559178a16c9SAnand Jain /* 1560178a16c9SAnand Jain * Make sure we use the fs_info::fs_devices to fetch the kobjects even 1561178a16c9SAnand Jain * for the seed fs_devices 1562178a16c9SAnand Jain */ 1563178a16c9SAnand Jain devices_kobj = device->fs_info->fs_devices->devices_kobj; 1564178a16c9SAnand Jain devinfo_kobj = device->fs_info->fs_devices->devinfo_kobj; 1565178a16c9SAnand Jain ASSERT(devices_kobj); 1566178a16c9SAnand Jain ASSERT(devinfo_kobj); 156729e5be24SJeff Mahoney 1568a47bd78dSJosef Bacik nofs_flag = memalloc_nofs_save(); 1569f085381eSAnand Jain 1570178a16c9SAnand Jain if (device->bdev) { 15718d65269fSChristoph Hellwig struct kobject *disk_kobj = bdev_kobj(device->bdev); 157229e5be24SJeff Mahoney 1573178a16c9SAnand Jain ret = sysfs_create_link(devices_kobj, disk_kobj, disk_kobj->name); 1574178a16c9SAnand Jain if (ret) { 1575178a16c9SAnand Jain btrfs_warn(device->fs_info, 1576178a16c9SAnand Jain "creating sysfs device link for devid %llu failed: %d", 1577178a16c9SAnand Jain device->devid, ret); 1578178a16c9SAnand Jain goto out; 1579178a16c9SAnand Jain } 158029e5be24SJeff Mahoney } 158129e5be24SJeff Mahoney 1582178a16c9SAnand Jain init_completion(&device->kobj_unregister); 1583178a16c9SAnand Jain ret = kobject_init_and_add(&device->devid_kobj, &devid_ktype, 1584178a16c9SAnand Jain devinfo_kobj, "%llu", device->devid); 1585178a16c9SAnand Jain if (ret) { 1586178a16c9SAnand Jain kobject_put(&device->devid_kobj); 1587178a16c9SAnand Jain btrfs_warn(device->fs_info, 1588178a16c9SAnand Jain "devinfo init for devid %llu failed: %d", 1589178a16c9SAnand Jain device->devid, ret); 1590668e48afSAnand Jain } 1591178a16c9SAnand Jain 1592178a16c9SAnand Jain out: 1593a47bd78dSJosef Bacik memalloc_nofs_restore(nofs_flag); 1594178a16c9SAnand Jain return ret; 1595178a16c9SAnand Jain } 1596668e48afSAnand Jain 1597cd36da2eSAnand Jain static int btrfs_sysfs_add_fs_devices(struct btrfs_fs_devices *fs_devices) 1598178a16c9SAnand Jain { 1599178a16c9SAnand Jain int ret; 1600cd36da2eSAnand Jain struct btrfs_device *device; 160130b0e4e0SAnand Jain struct btrfs_fs_devices *seed; 1602178a16c9SAnand Jain 1603178a16c9SAnand Jain list_for_each_entry(device, &fs_devices->devices, dev_list) { 1604178a16c9SAnand Jain ret = btrfs_sysfs_add_device(device); 1605178a16c9SAnand Jain if (ret) 16067ad3912aSAnand Jain goto fail; 1607178a16c9SAnand Jain } 1608178a16c9SAnand Jain 160930b0e4e0SAnand Jain list_for_each_entry(seed, &fs_devices->seed_list, seed_list) { 161030b0e4e0SAnand Jain list_for_each_entry(device, &seed->devices, dev_list) { 161130b0e4e0SAnand Jain ret = btrfs_sysfs_add_device(device); 161230b0e4e0SAnand Jain if (ret) 16137ad3912aSAnand Jain goto fail; 161430b0e4e0SAnand Jain } 161530b0e4e0SAnand Jain } 161630b0e4e0SAnand Jain 1617178a16c9SAnand Jain return 0; 16187ad3912aSAnand Jain 16197ad3912aSAnand Jain fail: 16207ad3912aSAnand Jain btrfs_sysfs_remove_fs_devices(fs_devices); 16217ad3912aSAnand Jain return ret; 162229e5be24SJeff Mahoney } 162329e5be24SJeff Mahoney 16245b28692eSDavid Sterba void btrfs_kobject_uevent(struct block_device *bdev, enum kobject_action action) 16255b28692eSDavid Sterba { 16265b28692eSDavid Sterba int ret; 16275b28692eSDavid Sterba 16285b28692eSDavid Sterba ret = kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, action); 16295b28692eSDavid Sterba if (ret) 16305b28692eSDavid Sterba pr_warn("BTRFS: Sending event '%d' to kobject: '%s' (%p): failed\n", 16315b28692eSDavid Sterba action, kobject_name(&disk_to_dev(bdev->bd_disk)->kobj), 16325b28692eSDavid Sterba &disk_to_dev(bdev->bd_disk)->kobj); 16335b28692eSDavid Sterba } 16345b28692eSDavid Sterba 16358e560081SNikolay Borisov void btrfs_sysfs_update_sprout_fsid(struct btrfs_fs_devices *fs_devices) 16368e560081SNikolay Borisov 1637f93c3997SDavid Sterba { 1638f93c3997SDavid Sterba char fsid_buf[BTRFS_UUID_UNPARSED_SIZE]; 1639f93c3997SDavid Sterba 1640f93c3997SDavid Sterba /* 1641f93c3997SDavid Sterba * Sprouting changes fsid of the mounted filesystem, rename the fsid 1642f93c3997SDavid Sterba * directory 1643f93c3997SDavid Sterba */ 16448e560081SNikolay Borisov snprintf(fsid_buf, BTRFS_UUID_UNPARSED_SIZE, "%pU", fs_devices->fsid); 1645f93c3997SDavid Sterba if (kobject_rename(&fs_devices->fsid_kobj, fsid_buf)) 1646f93c3997SDavid Sterba btrfs_warn(fs_devices->fs_info, 1647f93c3997SDavid Sterba "sysfs: failed to create fsid for sprout"); 1648f93c3997SDavid Sterba } 1649f93c3997SDavid Sterba 1650668e48afSAnand Jain void btrfs_sysfs_update_devid(struct btrfs_device *device) 1651668e48afSAnand Jain { 1652668e48afSAnand Jain char tmp[24]; 1653668e48afSAnand Jain 1654668e48afSAnand Jain snprintf(tmp, sizeof(tmp), "%llu", device->devid); 1655668e48afSAnand Jain 1656668e48afSAnand Jain if (kobject_rename(&device->devid_kobj, tmp)) 1657668e48afSAnand Jain btrfs_warn(device->fs_devices->fs_info, 1658668e48afSAnand Jain "sysfs: failed to update devid for %llu", 1659668e48afSAnand Jain device->devid); 1660668e48afSAnand Jain } 1661668e48afSAnand Jain 1662510d7360SJeff Mahoney /* /sys/fs/btrfs/ entry */ 1663510d7360SJeff Mahoney static struct kset *btrfs_kset; 1664510d7360SJeff Mahoney 166572059215SAnand Jain /* 1666c6761a9eSAnand Jain * Creates: 1667c6761a9eSAnand Jain * /sys/fs/btrfs/UUID 1668c6761a9eSAnand Jain * 166972059215SAnand Jain * Can be called by the device discovery thread. 167072059215SAnand Jain */ 1671c6761a9eSAnand Jain int btrfs_sysfs_add_fsid(struct btrfs_fs_devices *fs_devs) 16725ac1d209SJeff Mahoney { 16735ac1d209SJeff Mahoney int error; 16745ac1d209SJeff Mahoney 16752e7910d6SAnand Jain init_completion(&fs_devs->kobj_unregister); 1676c1b7e474SAnand Jain fs_devs->fsid_kobj.kset = btrfs_kset; 1677c6761a9eSAnand Jain error = kobject_init_and_add(&fs_devs->fsid_kobj, &btrfs_ktype, NULL, 1678c6761a9eSAnand Jain "%pU", fs_devs->fsid); 1679e3277335STobin C. Harding if (error) { 1680e3277335STobin C. Harding kobject_put(&fs_devs->fsid_kobj); 168172059215SAnand Jain return error; 168272059215SAnand Jain } 168372059215SAnand Jain 1684bc036bb3SAnand Jain fs_devs->devices_kobj = kobject_create_and_add("devices", 1685bc036bb3SAnand Jain &fs_devs->fsid_kobj); 1686bc036bb3SAnand Jain if (!fs_devs->devices_kobj) { 1687bc036bb3SAnand Jain btrfs_err(fs_devs->fs_info, 1688bc036bb3SAnand Jain "failed to init sysfs device interface"); 16891f6087e6SAnand Jain btrfs_sysfs_remove_fsid(fs_devs); 1690bc036bb3SAnand Jain return -ENOMEM; 1691bc036bb3SAnand Jain } 1692bc036bb3SAnand Jain 1693a013d141SAnand Jain fs_devs->devinfo_kobj = kobject_create_and_add("devinfo", 1694a013d141SAnand Jain &fs_devs->fsid_kobj); 1695a013d141SAnand Jain if (!fs_devs->devinfo_kobj) { 1696a013d141SAnand Jain btrfs_err(fs_devs->fs_info, 1697a013d141SAnand Jain "failed to init sysfs devinfo kobject"); 1698a013d141SAnand Jain btrfs_sysfs_remove_fsid(fs_devs); 1699a013d141SAnand Jain return -ENOMEM; 1700a013d141SAnand Jain } 1701a013d141SAnand Jain 1702e3277335STobin C. Harding return 0; 1703e3277335STobin C. Harding } 1704e3277335STobin C. Harding 170596f3136eSAnand Jain int btrfs_sysfs_add_mounted(struct btrfs_fs_info *fs_info) 170672059215SAnand Jain { 170772059215SAnand Jain int error; 17082e7910d6SAnand Jain struct btrfs_fs_devices *fs_devs = fs_info->fs_devices; 1709c1b7e474SAnand Jain struct kobject *fsid_kobj = &fs_devs->fsid_kobj; 171072059215SAnand Jain 1711cd36da2eSAnand Jain error = btrfs_sysfs_add_fs_devices(fs_devs); 1712e453d989SJeff Mahoney if (error) 1713e453d989SJeff Mahoney return error; 1714510d7360SJeff Mahoney 1715c1b7e474SAnand Jain error = sysfs_create_files(fsid_kobj, btrfs_attrs); 1716e453d989SJeff Mahoney if (error) { 171753f8a74cSAnand Jain btrfs_sysfs_remove_fs_devices(fs_devs); 1718e453d989SJeff Mahoney return error; 1719e453d989SJeff Mahoney } 172079da4fa4SJeff Mahoney 1721c1b7e474SAnand Jain error = sysfs_create_group(fsid_kobj, 17220dd2906fSAnand Jain &btrfs_feature_attr_group); 17230dd2906fSAnand Jain if (error) 17240dd2906fSAnand Jain goto failure; 17250dd2906fSAnand Jain 17266e369febSDavid Sterba #ifdef CONFIG_BTRFS_DEBUG 172793945cb4SDennis Zhou fs_info->debug_kobj = kobject_create_and_add("debug", fsid_kobj); 172893945cb4SDennis Zhou if (!fs_info->debug_kobj) { 172993945cb4SDennis Zhou error = -ENOMEM; 173093945cb4SDennis Zhou goto failure; 173193945cb4SDennis Zhou } 173293945cb4SDennis Zhou 173393945cb4SDennis Zhou error = sysfs_create_files(fs_info->debug_kobj, btrfs_debug_mount_attrs); 17346e369febSDavid Sterba if (error) 17356e369febSDavid Sterba goto failure; 1736e4faab84SDennis Zhou 1737e4faab84SDennis Zhou /* Discard directory */ 1738e4faab84SDennis Zhou fs_info->discard_debug_kobj = kobject_create_and_add("discard", 1739e4faab84SDennis Zhou fs_info->debug_kobj); 1740e4faab84SDennis Zhou if (!fs_info->discard_debug_kobj) { 1741e4faab84SDennis Zhou error = -ENOMEM; 1742e4faab84SDennis Zhou goto failure; 1743e4faab84SDennis Zhou } 1744e4faab84SDennis Zhou 1745e4faab84SDennis Zhou error = sysfs_create_files(fs_info->discard_debug_kobj, 1746e4faab84SDennis Zhou discard_debug_attrs); 1747e4faab84SDennis Zhou if (error) 1748e4faab84SDennis Zhou goto failure; 17496e369febSDavid Sterba #endif 17506e369febSDavid Sterba 1751e453d989SJeff Mahoney error = addrm_unknown_feature_attrs(fs_info, true); 175279da4fa4SJeff Mahoney if (error) 175379da4fa4SJeff Mahoney goto failure; 175479da4fa4SJeff Mahoney 17553092c68fSNikolay Borisov error = sysfs_create_link(fsid_kobj, &fs_info->sb->s_bdi->dev->kobj, "bdi"); 17563092c68fSNikolay Borisov if (error) 17573092c68fSNikolay Borisov goto failure; 17583092c68fSNikolay Borisov 17596ab0a202SJeff Mahoney fs_info->space_info_kobj = kobject_create_and_add("allocation", 1760c1b7e474SAnand Jain fsid_kobj); 17616ab0a202SJeff Mahoney if (!fs_info->space_info_kobj) { 17626ab0a202SJeff Mahoney error = -ENOMEM; 17636ab0a202SJeff Mahoney goto failure; 17646ab0a202SJeff Mahoney } 17656ab0a202SJeff Mahoney 17666ab0a202SJeff Mahoney error = sysfs_create_files(fs_info->space_info_kobj, allocation_attrs); 17676ab0a202SJeff Mahoney if (error) 17686ab0a202SJeff Mahoney goto failure; 17696ab0a202SJeff Mahoney 177079da4fa4SJeff Mahoney return 0; 177179da4fa4SJeff Mahoney failure: 17726618a59bSAnand Jain btrfs_sysfs_remove_mounted(fs_info); 17735ac1d209SJeff Mahoney return error; 17745ac1d209SJeff Mahoney } 17755ac1d209SJeff Mahoney 177649e5fb46SQu Wenruo static inline struct btrfs_fs_info *qgroup_kobj_to_fs_info(struct kobject *kobj) 177749e5fb46SQu Wenruo { 177849e5fb46SQu Wenruo return to_fs_info(kobj->parent->parent); 177949e5fb46SQu Wenruo } 178049e5fb46SQu Wenruo 178149e5fb46SQu Wenruo #define QGROUP_ATTR(_member, _show_name) \ 178249e5fb46SQu Wenruo static ssize_t btrfs_qgroup_show_##_member(struct kobject *qgroup_kobj, \ 178349e5fb46SQu Wenruo struct kobj_attribute *a, \ 178449e5fb46SQu Wenruo char *buf) \ 178549e5fb46SQu Wenruo { \ 178649e5fb46SQu Wenruo struct btrfs_fs_info *fs_info = qgroup_kobj_to_fs_info(qgroup_kobj); \ 178749e5fb46SQu Wenruo struct btrfs_qgroup *qgroup = container_of(qgroup_kobj, \ 178849e5fb46SQu Wenruo struct btrfs_qgroup, kobj); \ 178949e5fb46SQu Wenruo return btrfs_show_u64(&qgroup->_member, &fs_info->qgroup_lock, buf); \ 179049e5fb46SQu Wenruo } \ 179149e5fb46SQu Wenruo BTRFS_ATTR(qgroup, _show_name, btrfs_qgroup_show_##_member) 179249e5fb46SQu Wenruo 179349e5fb46SQu Wenruo #define QGROUP_RSV_ATTR(_name, _type) \ 179449e5fb46SQu Wenruo static ssize_t btrfs_qgroup_rsv_show_##_name(struct kobject *qgroup_kobj, \ 179549e5fb46SQu Wenruo struct kobj_attribute *a, \ 179649e5fb46SQu Wenruo char *buf) \ 179749e5fb46SQu Wenruo { \ 179849e5fb46SQu Wenruo struct btrfs_fs_info *fs_info = qgroup_kobj_to_fs_info(qgroup_kobj); \ 179949e5fb46SQu Wenruo struct btrfs_qgroup *qgroup = container_of(qgroup_kobj, \ 180049e5fb46SQu Wenruo struct btrfs_qgroup, kobj); \ 180149e5fb46SQu Wenruo return btrfs_show_u64(&qgroup->rsv.values[_type], \ 180249e5fb46SQu Wenruo &fs_info->qgroup_lock, buf); \ 180349e5fb46SQu Wenruo } \ 180449e5fb46SQu Wenruo BTRFS_ATTR(qgroup, rsv_##_name, btrfs_qgroup_rsv_show_##_name) 180549e5fb46SQu Wenruo 180649e5fb46SQu Wenruo QGROUP_ATTR(rfer, referenced); 180749e5fb46SQu Wenruo QGROUP_ATTR(excl, exclusive); 180849e5fb46SQu Wenruo QGROUP_ATTR(max_rfer, max_referenced); 180949e5fb46SQu Wenruo QGROUP_ATTR(max_excl, max_exclusive); 181049e5fb46SQu Wenruo QGROUP_ATTR(lim_flags, limit_flags); 181149e5fb46SQu Wenruo QGROUP_RSV_ATTR(data, BTRFS_QGROUP_RSV_DATA); 181249e5fb46SQu Wenruo QGROUP_RSV_ATTR(meta_pertrans, BTRFS_QGROUP_RSV_META_PERTRANS); 181349e5fb46SQu Wenruo QGROUP_RSV_ATTR(meta_prealloc, BTRFS_QGROUP_RSV_META_PREALLOC); 181449e5fb46SQu Wenruo 181549e5fb46SQu Wenruo static struct attribute *qgroup_attrs[] = { 181649e5fb46SQu Wenruo BTRFS_ATTR_PTR(qgroup, referenced), 181749e5fb46SQu Wenruo BTRFS_ATTR_PTR(qgroup, exclusive), 181849e5fb46SQu Wenruo BTRFS_ATTR_PTR(qgroup, max_referenced), 181949e5fb46SQu Wenruo BTRFS_ATTR_PTR(qgroup, max_exclusive), 182049e5fb46SQu Wenruo BTRFS_ATTR_PTR(qgroup, limit_flags), 182149e5fb46SQu Wenruo BTRFS_ATTR_PTR(qgroup, rsv_data), 182249e5fb46SQu Wenruo BTRFS_ATTR_PTR(qgroup, rsv_meta_pertrans), 182349e5fb46SQu Wenruo BTRFS_ATTR_PTR(qgroup, rsv_meta_prealloc), 182449e5fb46SQu Wenruo NULL 182549e5fb46SQu Wenruo }; 182649e5fb46SQu Wenruo ATTRIBUTE_GROUPS(qgroup); 182749e5fb46SQu Wenruo 182849e5fb46SQu Wenruo static void qgroup_release(struct kobject *kobj) 182949e5fb46SQu Wenruo { 183049e5fb46SQu Wenruo struct btrfs_qgroup *qgroup = container_of(kobj, struct btrfs_qgroup, kobj); 183149e5fb46SQu Wenruo 183249e5fb46SQu Wenruo memset(&qgroup->kobj, 0, sizeof(*kobj)); 183349e5fb46SQu Wenruo } 183449e5fb46SQu Wenruo 183549e5fb46SQu Wenruo static struct kobj_type qgroup_ktype = { 183649e5fb46SQu Wenruo .sysfs_ops = &kobj_sysfs_ops, 183749e5fb46SQu Wenruo .release = qgroup_release, 183849e5fb46SQu Wenruo .default_groups = qgroup_groups, 183949e5fb46SQu Wenruo }; 184049e5fb46SQu Wenruo 184149e5fb46SQu Wenruo int btrfs_sysfs_add_one_qgroup(struct btrfs_fs_info *fs_info, 184249e5fb46SQu Wenruo struct btrfs_qgroup *qgroup) 184349e5fb46SQu Wenruo { 184449e5fb46SQu Wenruo struct kobject *qgroups_kobj = fs_info->qgroups_kobj; 184549e5fb46SQu Wenruo int ret; 184649e5fb46SQu Wenruo 184749e5fb46SQu Wenruo if (test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state)) 184849e5fb46SQu Wenruo return 0; 184949e5fb46SQu Wenruo if (qgroup->kobj.state_initialized) 185049e5fb46SQu Wenruo return 0; 185149e5fb46SQu Wenruo if (!qgroups_kobj) 185249e5fb46SQu Wenruo return -EINVAL; 185349e5fb46SQu Wenruo 185449e5fb46SQu Wenruo ret = kobject_init_and_add(&qgroup->kobj, &qgroup_ktype, qgroups_kobj, 185549e5fb46SQu Wenruo "%hu_%llu", btrfs_qgroup_level(qgroup->qgroupid), 185649e5fb46SQu Wenruo btrfs_qgroup_subvolid(qgroup->qgroupid)); 185749e5fb46SQu Wenruo if (ret < 0) 185849e5fb46SQu Wenruo kobject_put(&qgroup->kobj); 185949e5fb46SQu Wenruo 186049e5fb46SQu Wenruo return ret; 186149e5fb46SQu Wenruo } 186249e5fb46SQu Wenruo 186349e5fb46SQu Wenruo void btrfs_sysfs_del_qgroups(struct btrfs_fs_info *fs_info) 186449e5fb46SQu Wenruo { 186549e5fb46SQu Wenruo struct btrfs_qgroup *qgroup; 186649e5fb46SQu Wenruo struct btrfs_qgroup *next; 186749e5fb46SQu Wenruo 186849e5fb46SQu Wenruo if (test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state)) 186949e5fb46SQu Wenruo return; 187049e5fb46SQu Wenruo 187149e5fb46SQu Wenruo rbtree_postorder_for_each_entry_safe(qgroup, next, 187249e5fb46SQu Wenruo &fs_info->qgroup_tree, node) 187349e5fb46SQu Wenruo btrfs_sysfs_del_one_qgroup(fs_info, qgroup); 187462ab2cc0SQu Wenruo if (fs_info->qgroups_kobj) { 187549e5fb46SQu Wenruo kobject_del(fs_info->qgroups_kobj); 187649e5fb46SQu Wenruo kobject_put(fs_info->qgroups_kobj); 187749e5fb46SQu Wenruo fs_info->qgroups_kobj = NULL; 187849e5fb46SQu Wenruo } 187962ab2cc0SQu Wenruo } 188049e5fb46SQu Wenruo 188149e5fb46SQu Wenruo /* Called when qgroups get initialized, thus there is no need for locking */ 188249e5fb46SQu Wenruo int btrfs_sysfs_add_qgroups(struct btrfs_fs_info *fs_info) 188349e5fb46SQu Wenruo { 188449e5fb46SQu Wenruo struct kobject *fsid_kobj = &fs_info->fs_devices->fsid_kobj; 188549e5fb46SQu Wenruo struct btrfs_qgroup *qgroup; 188649e5fb46SQu Wenruo struct btrfs_qgroup *next; 188749e5fb46SQu Wenruo int ret = 0; 188849e5fb46SQu Wenruo 188949e5fb46SQu Wenruo if (test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state)) 189049e5fb46SQu Wenruo return 0; 189149e5fb46SQu Wenruo 189249e5fb46SQu Wenruo ASSERT(fsid_kobj); 189349e5fb46SQu Wenruo if (fs_info->qgroups_kobj) 189449e5fb46SQu Wenruo return 0; 189549e5fb46SQu Wenruo 189649e5fb46SQu Wenruo fs_info->qgroups_kobj = kobject_create_and_add("qgroups", fsid_kobj); 189749e5fb46SQu Wenruo if (!fs_info->qgroups_kobj) { 189849e5fb46SQu Wenruo ret = -ENOMEM; 189949e5fb46SQu Wenruo goto out; 190049e5fb46SQu Wenruo } 190149e5fb46SQu Wenruo rbtree_postorder_for_each_entry_safe(qgroup, next, 190249e5fb46SQu Wenruo &fs_info->qgroup_tree, node) { 190349e5fb46SQu Wenruo ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup); 190449e5fb46SQu Wenruo if (ret < 0) 190549e5fb46SQu Wenruo goto out; 190649e5fb46SQu Wenruo } 190749e5fb46SQu Wenruo 190849e5fb46SQu Wenruo out: 190949e5fb46SQu Wenruo if (ret < 0) 191049e5fb46SQu Wenruo btrfs_sysfs_del_qgroups(fs_info); 191149e5fb46SQu Wenruo return ret; 191249e5fb46SQu Wenruo } 191349e5fb46SQu Wenruo 191449e5fb46SQu Wenruo void btrfs_sysfs_del_one_qgroup(struct btrfs_fs_info *fs_info, 191549e5fb46SQu Wenruo struct btrfs_qgroup *qgroup) 191649e5fb46SQu Wenruo { 191749e5fb46SQu Wenruo if (test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state)) 191849e5fb46SQu Wenruo return; 191949e5fb46SQu Wenruo 192049e5fb46SQu Wenruo if (qgroup->kobj.state_initialized) { 192149e5fb46SQu Wenruo kobject_del(&qgroup->kobj); 192249e5fb46SQu Wenruo kobject_put(&qgroup->kobj); 192349e5fb46SQu Wenruo } 192449e5fb46SQu Wenruo } 1925444e7516SDavid Sterba 1926444e7516SDavid Sterba /* 1927444e7516SDavid Sterba * Change per-fs features in /sys/fs/btrfs/UUID/features to match current 1928444e7516SDavid Sterba * values in superblock. Call after any changes to incompat/compat_ro flags 1929444e7516SDavid Sterba */ 1930444e7516SDavid Sterba void btrfs_sysfs_feature_update(struct btrfs_fs_info *fs_info, 1931444e7516SDavid Sterba u64 bit, enum btrfs_feature_set set) 1932444e7516SDavid Sterba { 1933444e7516SDavid Sterba struct btrfs_fs_devices *fs_devs; 1934444e7516SDavid Sterba struct kobject *fsid_kobj; 193524646481SLeon Romanovsky u64 __maybe_unused features; 193624646481SLeon Romanovsky int __maybe_unused ret; 1937444e7516SDavid Sterba 1938444e7516SDavid Sterba if (!fs_info) 1939444e7516SDavid Sterba return; 1940444e7516SDavid Sterba 194124646481SLeon Romanovsky /* 194224646481SLeon Romanovsky * See 14e46e04958df74 and e410e34fad913dd, feature bit updates are not 194324646481SLeon Romanovsky * safe when called from some contexts (eg. balance) 194424646481SLeon Romanovsky */ 1945444e7516SDavid Sterba features = get_features(fs_info, set); 1946444e7516SDavid Sterba ASSERT(bit & supported_feature_masks[set]); 1947444e7516SDavid Sterba 1948444e7516SDavid Sterba fs_devs = fs_info->fs_devices; 1949444e7516SDavid Sterba fsid_kobj = &fs_devs->fsid_kobj; 1950444e7516SDavid Sterba 1951bf609206SDavid Sterba if (!fsid_kobj->state_initialized) 1952bf609206SDavid Sterba return; 1953bf609206SDavid Sterba 1954444e7516SDavid Sterba /* 1955444e7516SDavid Sterba * FIXME: this is too heavy to update just one value, ideally we'd like 1956444e7516SDavid Sterba * to use sysfs_update_group but some refactoring is needed first. 1957444e7516SDavid Sterba */ 1958444e7516SDavid Sterba sysfs_remove_group(fsid_kobj, &btrfs_feature_attr_group); 1959444e7516SDavid Sterba ret = sysfs_create_group(fsid_kobj, &btrfs_feature_attr_group); 1960444e7516SDavid Sterba } 1961444e7516SDavid Sterba 1962f5c29bd9SLiu Bo int __init btrfs_init_sysfs(void) 196358176a96SJosef Bacik { 1964079b72bcSJeff Mahoney int ret; 19651bae3098SDavid Sterba 1966e3fe4e71SGreg KH btrfs_kset = kset_create_and_add("btrfs", NULL, fs_kobj); 1967e3fe4e71SGreg KH if (!btrfs_kset) 1968e3fe4e71SGreg KH return -ENOMEM; 1969079b72bcSJeff Mahoney 19701bae3098SDavid Sterba init_feature_attrs(); 19711bae3098SDavid Sterba ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_feature_attr_group); 1972001a648dSFilipe Manana if (ret) 1973001a648dSFilipe Manana goto out2; 1974f902bd3aSMisono Tomohiro ret = sysfs_merge_group(&btrfs_kset->kobj, 1975f902bd3aSMisono Tomohiro &btrfs_static_feature_attr_group); 1976f902bd3aSMisono Tomohiro if (ret) 1977f902bd3aSMisono Tomohiro goto out_remove_group; 1978001a648dSFilipe Manana 19796e369febSDavid Sterba #ifdef CONFIG_BTRFS_DEBUG 19806e369febSDavid Sterba ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_debug_feature_attr_group); 19816e369febSDavid Sterba if (ret) 19826e369febSDavid Sterba goto out2; 19836e369febSDavid Sterba #endif 19846e369febSDavid Sterba 1985001a648dSFilipe Manana return 0; 1986f902bd3aSMisono Tomohiro 1987f902bd3aSMisono Tomohiro out_remove_group: 1988f902bd3aSMisono Tomohiro sysfs_remove_group(&btrfs_kset->kobj, &btrfs_feature_attr_group); 1989001a648dSFilipe Manana out2: 1990001a648dSFilipe Manana kset_unregister(btrfs_kset); 19911bae3098SDavid Sterba 19921bae3098SDavid Sterba return ret; 199358176a96SJosef Bacik } 199458176a96SJosef Bacik 1995e67c718bSDavid Sterba void __cold btrfs_exit_sysfs(void) 199658176a96SJosef Bacik { 1997f902bd3aSMisono Tomohiro sysfs_unmerge_group(&btrfs_kset->kobj, 1998f902bd3aSMisono Tomohiro &btrfs_static_feature_attr_group); 1999079b72bcSJeff Mahoney sysfs_remove_group(&btrfs_kset->kobj, &btrfs_feature_attr_group); 200071e8978eSDennis Zhou #ifdef CONFIG_BTRFS_DEBUG 200171e8978eSDennis Zhou sysfs_remove_group(&btrfs_kset->kobj, &btrfs_debug_feature_attr_group); 200271e8978eSDennis Zhou #endif 2003e3fe4e71SGreg KH kset_unregister(btrfs_kset); 200458176a96SJosef Bacik } 200555d47414SChris Mason 2006