sysfs.c 48 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (C) 2007 Oracle. All rights reserved.
  4. */
  5. #include <linux/sched.h>
  6. #include <linux/sched/mm.h>
  7. #include <linux/slab.h>
  8. #include <linux/spinlock.h>
  9. #include <linux/completion.h>
  10. #include <linux/bug.h>
  11. #include <crypto/hash.h>
  12. #include "ctree.h"
  13. #include "discard.h"
  14. #include "disk-io.h"
  15. #include "send.h"
  16. #include "transaction.h"
  17. #include "sysfs.h"
  18. #include "volumes.h"
  19. #include "space-info.h"
  20. #include "block-group.h"
  21. #include "qgroup.h"
  22. struct btrfs_feature_attr {
  23. struct kobj_attribute kobj_attr;
  24. enum btrfs_feature_set feature_set;
  25. u64 feature_bit;
  26. };
  27. /* For raid type sysfs entries */
  28. struct raid_kobject {
  29. u64 flags;
  30. struct kobject kobj;
  31. };
  32. #define __INIT_KOBJ_ATTR(_name, _mode, _show, _store) \
  33. { \
  34. .attr = { .name = __stringify(_name), .mode = _mode }, \
  35. .show = _show, \
  36. .store = _store, \
  37. }
  38. #define BTRFS_ATTR_RW(_prefix, _name, _show, _store) \
  39. static struct kobj_attribute btrfs_attr_##_prefix##_##_name = \
  40. __INIT_KOBJ_ATTR(_name, 0644, _show, _store)
  41. #define BTRFS_ATTR(_prefix, _name, _show) \
  42. static struct kobj_attribute btrfs_attr_##_prefix##_##_name = \
  43. __INIT_KOBJ_ATTR(_name, 0444, _show, NULL)
  44. #define BTRFS_ATTR_PTR(_prefix, _name) \
  45. (&btrfs_attr_##_prefix##_##_name.attr)
  46. #define BTRFS_FEAT_ATTR(_name, _feature_set, _feature_prefix, _feature_bit) \
  47. static struct btrfs_feature_attr btrfs_attr_features_##_name = { \
  48. .kobj_attr = __INIT_KOBJ_ATTR(_name, S_IRUGO, \
  49. btrfs_feature_attr_show, \
  50. btrfs_feature_attr_store), \
  51. .feature_set = _feature_set, \
  52. .feature_bit = _feature_prefix ##_## _feature_bit, \
  53. }
  54. #define BTRFS_FEAT_ATTR_PTR(_name) \
  55. (&btrfs_attr_features_##_name.kobj_attr.attr)
  56. #define BTRFS_FEAT_ATTR_COMPAT(name, feature) \
  57. BTRFS_FEAT_ATTR(name, FEAT_COMPAT, BTRFS_FEATURE_COMPAT, feature)
  58. #define BTRFS_FEAT_ATTR_COMPAT_RO(name, feature) \
  59. BTRFS_FEAT_ATTR(name, FEAT_COMPAT_RO, BTRFS_FEATURE_COMPAT_RO, feature)
  60. #define BTRFS_FEAT_ATTR_INCOMPAT(name, feature) \
  61. BTRFS_FEAT_ATTR(name, FEAT_INCOMPAT, BTRFS_FEATURE_INCOMPAT, feature)
  62. static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj);
  63. static inline struct btrfs_fs_devices *to_fs_devs(struct kobject *kobj);
  64. static struct btrfs_feature_attr *to_btrfs_feature_attr(struct kobj_attribute *a)
  65. {
  66. return container_of(a, struct btrfs_feature_attr, kobj_attr);
  67. }
  68. static struct kobj_attribute *attr_to_btrfs_attr(struct attribute *attr)
  69. {
  70. return container_of(attr, struct kobj_attribute, attr);
  71. }
  72. static struct btrfs_feature_attr *attr_to_btrfs_feature_attr(
  73. struct attribute *attr)
  74. {
  75. return to_btrfs_feature_attr(attr_to_btrfs_attr(attr));
  76. }
  77. static u64 get_features(struct btrfs_fs_info *fs_info,
  78. enum btrfs_feature_set set)
  79. {
  80. struct btrfs_super_block *disk_super = fs_info->super_copy;
  81. if (set == FEAT_COMPAT)
  82. return btrfs_super_compat_flags(disk_super);
  83. else if (set == FEAT_COMPAT_RO)
  84. return btrfs_super_compat_ro_flags(disk_super);
  85. else
  86. return btrfs_super_incompat_flags(disk_super);
  87. }
  88. static void set_features(struct btrfs_fs_info *fs_info,
  89. enum btrfs_feature_set set, u64 features)
  90. {
  91. struct btrfs_super_block *disk_super = fs_info->super_copy;
  92. if (set == FEAT_COMPAT)
  93. btrfs_set_super_compat_flags(disk_super, features);
  94. else if (set == FEAT_COMPAT_RO)
  95. btrfs_set_super_compat_ro_flags(disk_super, features);
  96. else
  97. btrfs_set_super_incompat_flags(disk_super, features);
  98. }
  99. static int can_modify_feature(struct btrfs_feature_attr *fa)
  100. {
  101. int val = 0;
  102. u64 set, clear;
  103. switch (fa->feature_set) {
  104. case FEAT_COMPAT:
  105. set = BTRFS_FEATURE_COMPAT_SAFE_SET;
  106. clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR;
  107. break;
  108. case FEAT_COMPAT_RO:
  109. set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET;
  110. clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR;
  111. break;
  112. case FEAT_INCOMPAT:
  113. set = BTRFS_FEATURE_INCOMPAT_SAFE_SET;
  114. clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR;
  115. break;
  116. default:
  117. pr_warn("btrfs: sysfs: unknown feature set %d\n",
  118. fa->feature_set);
  119. return 0;
  120. }
  121. if (set & fa->feature_bit)
  122. val |= 1;
  123. if (clear & fa->feature_bit)
  124. val |= 2;
  125. return val;
  126. }
  127. static ssize_t btrfs_feature_attr_show(struct kobject *kobj,
  128. struct kobj_attribute *a, char *buf)
  129. {
  130. int val = 0;
  131. struct btrfs_fs_info *fs_info = to_fs_info(kobj);
  132. struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a);
  133. if (fs_info) {
  134. u64 features = get_features(fs_info, fa->feature_set);
  135. if (features & fa->feature_bit)
  136. val = 1;
  137. } else
  138. val = can_modify_feature(fa);
  139. return scnprintf(buf, PAGE_SIZE, "%d\n", val);
  140. }
  141. static ssize_t btrfs_feature_attr_store(struct kobject *kobj,
  142. struct kobj_attribute *a,
  143. const char *buf, size_t count)
  144. {
  145. struct btrfs_fs_info *fs_info;
  146. struct btrfs_feature_attr *fa = to_btrfs_feature_attr(a);
  147. u64 features, set, clear;
  148. unsigned long val;
  149. int ret;
  150. fs_info = to_fs_info(kobj);
  151. if (!fs_info)
  152. return -EPERM;
  153. if (sb_rdonly(fs_info->sb))
  154. return -EROFS;
  155. ret = kstrtoul(skip_spaces(buf), 0, &val);
  156. if (ret)
  157. return ret;
  158. if (fa->feature_set == FEAT_COMPAT) {
  159. set = BTRFS_FEATURE_COMPAT_SAFE_SET;
  160. clear = BTRFS_FEATURE_COMPAT_SAFE_CLEAR;
  161. } else if (fa->feature_set == FEAT_COMPAT_RO) {
  162. set = BTRFS_FEATURE_COMPAT_RO_SAFE_SET;
  163. clear = BTRFS_FEATURE_COMPAT_RO_SAFE_CLEAR;
  164. } else {
  165. set = BTRFS_FEATURE_INCOMPAT_SAFE_SET;
  166. clear = BTRFS_FEATURE_INCOMPAT_SAFE_CLEAR;
  167. }
  168. features = get_features(fs_info, fa->feature_set);
  169. /* Nothing to do */
  170. if ((val && (features & fa->feature_bit)) ||
  171. (!val && !(features & fa->feature_bit)))
  172. return count;
  173. if ((val && !(set & fa->feature_bit)) ||
  174. (!val && !(clear & fa->feature_bit))) {
  175. btrfs_info(fs_info,
  176. "%sabling feature %s on mounted fs is not supported.",
  177. val ? "En" : "Dis", fa->kobj_attr.attr.name);
  178. return -EPERM;
  179. }
  180. btrfs_info(fs_info, "%s %s feature flag",
  181. val ? "Setting" : "Clearing", fa->kobj_attr.attr.name);
  182. spin_lock(&fs_info->super_lock);
  183. features = get_features(fs_info, fa->feature_set);
  184. if (val)
  185. features |= fa->feature_bit;
  186. else
  187. features &= ~fa->feature_bit;
  188. set_features(fs_info, fa->feature_set, features);
  189. spin_unlock(&fs_info->super_lock);
  190. /*
  191. * We don't want to do full transaction commit from inside sysfs
  192. */
  193. btrfs_set_pending(fs_info, COMMIT);
  194. wake_up_process(fs_info->transaction_kthread);
  195. return count;
  196. }
  197. static umode_t btrfs_feature_visible(struct kobject *kobj,
  198. struct attribute *attr, int unused)
  199. {
  200. struct btrfs_fs_info *fs_info = to_fs_info(kobj);
  201. umode_t mode = attr->mode;
  202. if (fs_info) {
  203. struct btrfs_feature_attr *fa;
  204. u64 features;
  205. fa = attr_to_btrfs_feature_attr(attr);
  206. features = get_features(fs_info, fa->feature_set);
  207. if (can_modify_feature(fa))
  208. mode |= S_IWUSR;
  209. else if (!(features & fa->feature_bit))
  210. mode = 0;
  211. }
  212. return mode;
  213. }
  214. BTRFS_FEAT_ATTR_INCOMPAT(mixed_backref, MIXED_BACKREF);
  215. BTRFS_FEAT_ATTR_INCOMPAT(default_subvol, DEFAULT_SUBVOL);
  216. BTRFS_FEAT_ATTR_INCOMPAT(mixed_groups, MIXED_GROUPS);
  217. BTRFS_FEAT_ATTR_INCOMPAT(compress_lzo, COMPRESS_LZO);
  218. BTRFS_FEAT_ATTR_INCOMPAT(compress_zstd, COMPRESS_ZSTD);
  219. BTRFS_FEAT_ATTR_INCOMPAT(big_metadata, BIG_METADATA);
  220. BTRFS_FEAT_ATTR_INCOMPAT(extended_iref, EXTENDED_IREF);
  221. BTRFS_FEAT_ATTR_INCOMPAT(raid56, RAID56);
  222. BTRFS_FEAT_ATTR_INCOMPAT(skinny_metadata, SKINNY_METADATA);
  223. BTRFS_FEAT_ATTR_INCOMPAT(no_holes, NO_HOLES);
  224. BTRFS_FEAT_ATTR_INCOMPAT(metadata_uuid, METADATA_UUID);
  225. BTRFS_FEAT_ATTR_COMPAT_RO(free_space_tree, FREE_SPACE_TREE);
  226. BTRFS_FEAT_ATTR_INCOMPAT(raid1c34, RAID1C34);
  227. static struct attribute *btrfs_supported_feature_attrs[] = {
  228. BTRFS_FEAT_ATTR_PTR(mixed_backref),
  229. BTRFS_FEAT_ATTR_PTR(default_subvol),
  230. BTRFS_FEAT_ATTR_PTR(mixed_groups),
  231. BTRFS_FEAT_ATTR_PTR(compress_lzo),
  232. BTRFS_FEAT_ATTR_PTR(compress_zstd),
  233. BTRFS_FEAT_ATTR_PTR(big_metadata),
  234. BTRFS_FEAT_ATTR_PTR(extended_iref),
  235. BTRFS_FEAT_ATTR_PTR(raid56),
  236. BTRFS_FEAT_ATTR_PTR(skinny_metadata),
  237. BTRFS_FEAT_ATTR_PTR(no_holes),
  238. BTRFS_FEAT_ATTR_PTR(metadata_uuid),
  239. BTRFS_FEAT_ATTR_PTR(free_space_tree),
  240. BTRFS_FEAT_ATTR_PTR(raid1c34),
  241. NULL
  242. };
  243. /*
  244. * Features which depend on feature bits and may differ between each fs.
  245. *
  246. * /sys/fs/btrfs/features lists all available features of this kernel while
  247. * /sys/fs/btrfs/UUID/features shows features of the fs which are enabled or
  248. * can be changed online.
  249. */
  250. static const struct attribute_group btrfs_feature_attr_group = {
  251. .name = "features",
  252. .is_visible = btrfs_feature_visible,
  253. .attrs = btrfs_supported_feature_attrs,
  254. };
  255. static ssize_t rmdir_subvol_show(struct kobject *kobj,
  256. struct kobj_attribute *ka, char *buf)
  257. {
  258. return scnprintf(buf, PAGE_SIZE, "0\n");
  259. }
  260. BTRFS_ATTR(static_feature, rmdir_subvol, rmdir_subvol_show);
  261. static ssize_t supported_checksums_show(struct kobject *kobj,
  262. struct kobj_attribute *a, char *buf)
  263. {
  264. ssize_t ret = 0;
  265. int i;
  266. for (i = 0; i < btrfs_get_num_csums(); i++) {
  267. /*
  268. * This "trick" only works as long as 'enum btrfs_csum_type' has
  269. * no holes in it
  270. */
  271. ret += scnprintf(buf + ret, PAGE_SIZE - ret, "%s%s",
  272. (i == 0 ? "" : " "), btrfs_super_csum_name(i));
  273. }
  274. ret += scnprintf(buf + ret, PAGE_SIZE - ret, "\n");
  275. return ret;
  276. }
  277. BTRFS_ATTR(static_feature, supported_checksums, supported_checksums_show);
  278. static ssize_t send_stream_version_show(struct kobject *kobj,
  279. struct kobj_attribute *ka, char *buf)
  280. {
  281. return snprintf(buf, PAGE_SIZE, "%d\n", BTRFS_SEND_STREAM_VERSION);
  282. }
  283. BTRFS_ATTR(static_feature, send_stream_version, send_stream_version_show);
  284. static struct attribute *btrfs_supported_static_feature_attrs[] = {
  285. BTRFS_ATTR_PTR(static_feature, rmdir_subvol),
  286. BTRFS_ATTR_PTR(static_feature, supported_checksums),
  287. BTRFS_ATTR_PTR(static_feature, send_stream_version),
  288. NULL
  289. };
  290. /*
  291. * Features which only depend on kernel version.
  292. *
  293. * These are listed in /sys/fs/btrfs/features along with
  294. * btrfs_feature_attr_group
  295. */
  296. static const struct attribute_group btrfs_static_feature_attr_group = {
  297. .name = "features",
  298. .attrs = btrfs_supported_static_feature_attrs,
  299. };
  300. #ifdef CONFIG_BTRFS_DEBUG
  301. /*
  302. * Discard statistics and tunables
  303. */
  304. #define discard_to_fs_info(_kobj) to_fs_info((_kobj)->parent->parent)
  305. static ssize_t btrfs_discardable_bytes_show(struct kobject *kobj,
  306. struct kobj_attribute *a,
  307. char *buf)
  308. {
  309. struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
  310. return scnprintf(buf, PAGE_SIZE, "%lld\n",
  311. atomic64_read(&fs_info->discard_ctl.discardable_bytes));
  312. }
  313. BTRFS_ATTR(discard, discardable_bytes, btrfs_discardable_bytes_show);
  314. static ssize_t btrfs_discardable_extents_show(struct kobject *kobj,
  315. struct kobj_attribute *a,
  316. char *buf)
  317. {
  318. struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
  319. return scnprintf(buf, PAGE_SIZE, "%d\n",
  320. atomic_read(&fs_info->discard_ctl.discardable_extents));
  321. }
  322. BTRFS_ATTR(discard, discardable_extents, btrfs_discardable_extents_show);
  323. static ssize_t btrfs_discard_bitmap_bytes_show(struct kobject *kobj,
  324. struct kobj_attribute *a,
  325. char *buf)
  326. {
  327. struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
  328. return scnprintf(buf, PAGE_SIZE, "%llu\n",
  329. fs_info->discard_ctl.discard_bitmap_bytes);
  330. }
  331. BTRFS_ATTR(discard, discard_bitmap_bytes, btrfs_discard_bitmap_bytes_show);
  332. static ssize_t btrfs_discard_bytes_saved_show(struct kobject *kobj,
  333. struct kobj_attribute *a,
  334. char *buf)
  335. {
  336. struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
  337. return scnprintf(buf, PAGE_SIZE, "%lld\n",
  338. atomic64_read(&fs_info->discard_ctl.discard_bytes_saved));
  339. }
  340. BTRFS_ATTR(discard, discard_bytes_saved, btrfs_discard_bytes_saved_show);
  341. static ssize_t btrfs_discard_extent_bytes_show(struct kobject *kobj,
  342. struct kobj_attribute *a,
  343. char *buf)
  344. {
  345. struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
  346. return scnprintf(buf, PAGE_SIZE, "%llu\n",
  347. fs_info->discard_ctl.discard_extent_bytes);
  348. }
  349. BTRFS_ATTR(discard, discard_extent_bytes, btrfs_discard_extent_bytes_show);
  350. static ssize_t btrfs_discard_iops_limit_show(struct kobject *kobj,
  351. struct kobj_attribute *a,
  352. char *buf)
  353. {
  354. struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
  355. return scnprintf(buf, PAGE_SIZE, "%u\n",
  356. READ_ONCE(fs_info->discard_ctl.iops_limit));
  357. }
  358. static ssize_t btrfs_discard_iops_limit_store(struct kobject *kobj,
  359. struct kobj_attribute *a,
  360. const char *buf, size_t len)
  361. {
  362. struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
  363. struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl;
  364. u32 iops_limit;
  365. int ret;
  366. ret = kstrtou32(buf, 10, &iops_limit);
  367. if (ret)
  368. return -EINVAL;
  369. WRITE_ONCE(discard_ctl->iops_limit, iops_limit);
  370. return len;
  371. }
  372. BTRFS_ATTR_RW(discard, iops_limit, btrfs_discard_iops_limit_show,
  373. btrfs_discard_iops_limit_store);
  374. static ssize_t btrfs_discard_kbps_limit_show(struct kobject *kobj,
  375. struct kobj_attribute *a,
  376. char *buf)
  377. {
  378. struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
  379. return scnprintf(buf, PAGE_SIZE, "%u\n",
  380. READ_ONCE(fs_info->discard_ctl.kbps_limit));
  381. }
  382. static ssize_t btrfs_discard_kbps_limit_store(struct kobject *kobj,
  383. struct kobj_attribute *a,
  384. const char *buf, size_t len)
  385. {
  386. struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
  387. struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl;
  388. u32 kbps_limit;
  389. int ret;
  390. ret = kstrtou32(buf, 10, &kbps_limit);
  391. if (ret)
  392. return -EINVAL;
  393. WRITE_ONCE(discard_ctl->kbps_limit, kbps_limit);
  394. return len;
  395. }
  396. BTRFS_ATTR_RW(discard, kbps_limit, btrfs_discard_kbps_limit_show,
  397. btrfs_discard_kbps_limit_store);
  398. static ssize_t btrfs_discard_max_discard_size_show(struct kobject *kobj,
  399. struct kobj_attribute *a,
  400. char *buf)
  401. {
  402. struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
  403. return scnprintf(buf, PAGE_SIZE, "%llu\n",
  404. READ_ONCE(fs_info->discard_ctl.max_discard_size));
  405. }
  406. static ssize_t btrfs_discard_max_discard_size_store(struct kobject *kobj,
  407. struct kobj_attribute *a,
  408. const char *buf, size_t len)
  409. {
  410. struct btrfs_fs_info *fs_info = discard_to_fs_info(kobj);
  411. struct btrfs_discard_ctl *discard_ctl = &fs_info->discard_ctl;
  412. u64 max_discard_size;
  413. int ret;
  414. ret = kstrtou64(buf, 10, &max_discard_size);
  415. if (ret)
  416. return -EINVAL;
  417. WRITE_ONCE(discard_ctl->max_discard_size, max_discard_size);
  418. return len;
  419. }
  420. BTRFS_ATTR_RW(discard, max_discard_size, btrfs_discard_max_discard_size_show,
  421. btrfs_discard_max_discard_size_store);
  422. static const struct attribute *discard_debug_attrs[] = {
  423. BTRFS_ATTR_PTR(discard, discardable_bytes),
  424. BTRFS_ATTR_PTR(discard, discardable_extents),
  425. BTRFS_ATTR_PTR(discard, discard_bitmap_bytes),
  426. BTRFS_ATTR_PTR(discard, discard_bytes_saved),
  427. BTRFS_ATTR_PTR(discard, discard_extent_bytes),
  428. BTRFS_ATTR_PTR(discard, iops_limit),
  429. BTRFS_ATTR_PTR(discard, kbps_limit),
  430. BTRFS_ATTR_PTR(discard, max_discard_size),
  431. NULL,
  432. };
  433. /*
  434. * Runtime debugging exported via sysfs
  435. *
  436. * /sys/fs/btrfs/debug - applies to module or all filesystems
  437. * /sys/fs/btrfs/UUID - applies only to the given filesystem
  438. */
  439. static const struct attribute *btrfs_debug_mount_attrs[] = {
  440. NULL,
  441. };
  442. static struct attribute *btrfs_debug_feature_attrs[] = {
  443. NULL
  444. };
  445. static const struct attribute_group btrfs_debug_feature_attr_group = {
  446. .name = "debug",
  447. .attrs = btrfs_debug_feature_attrs,
  448. };
  449. #endif
  450. static ssize_t btrfs_show_u64(u64 *value_ptr, spinlock_t *lock, char *buf)
  451. {
  452. u64 val;
  453. if (lock)
  454. spin_lock(lock);
  455. val = *value_ptr;
  456. if (lock)
  457. spin_unlock(lock);
  458. return scnprintf(buf, PAGE_SIZE, "%llu\n", val);
  459. }
  460. static ssize_t global_rsv_size_show(struct kobject *kobj,
  461. struct kobj_attribute *ka, char *buf)
  462. {
  463. struct btrfs_fs_info *fs_info = to_fs_info(kobj->parent);
  464. struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
  465. return btrfs_show_u64(&block_rsv->size, &block_rsv->lock, buf);
  466. }
  467. BTRFS_ATTR(allocation, global_rsv_size, global_rsv_size_show);
  468. static ssize_t global_rsv_reserved_show(struct kobject *kobj,
  469. struct kobj_attribute *a, char *buf)
  470. {
  471. struct btrfs_fs_info *fs_info = to_fs_info(kobj->parent);
  472. struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
  473. return btrfs_show_u64(&block_rsv->reserved, &block_rsv->lock, buf);
  474. }
  475. BTRFS_ATTR(allocation, global_rsv_reserved, global_rsv_reserved_show);
  476. #define to_space_info(_kobj) container_of(_kobj, struct btrfs_space_info, kobj)
  477. #define to_raid_kobj(_kobj) container_of(_kobj, struct raid_kobject, kobj)
  478. static ssize_t raid_bytes_show(struct kobject *kobj,
  479. struct kobj_attribute *attr, char *buf);
  480. BTRFS_ATTR(raid, total_bytes, raid_bytes_show);
  481. BTRFS_ATTR(raid, used_bytes, raid_bytes_show);
  482. static ssize_t raid_bytes_show(struct kobject *kobj,
  483. struct kobj_attribute *attr, char *buf)
  484. {
  485. struct btrfs_space_info *sinfo = to_space_info(kobj->parent);
  486. struct btrfs_block_group *block_group;
  487. int index = btrfs_bg_flags_to_raid_index(to_raid_kobj(kobj)->flags);
  488. u64 val = 0;
  489. down_read(&sinfo->groups_sem);
  490. list_for_each_entry(block_group, &sinfo->block_groups[index], list) {
  491. if (&attr->attr == BTRFS_ATTR_PTR(raid, total_bytes))
  492. val += block_group->length;
  493. else
  494. val += block_group->used;
  495. }
  496. up_read(&sinfo->groups_sem);
  497. return scnprintf(buf, PAGE_SIZE, "%llu\n", val);
  498. }
  499. static struct attribute *raid_attrs[] = {
  500. BTRFS_ATTR_PTR(raid, total_bytes),
  501. BTRFS_ATTR_PTR(raid, used_bytes),
  502. NULL
  503. };
  504. ATTRIBUTE_GROUPS(raid);
  505. static void release_raid_kobj(struct kobject *kobj)
  506. {
  507. kfree(to_raid_kobj(kobj));
  508. }
  509. static struct kobj_type btrfs_raid_ktype = {
  510. .sysfs_ops = &kobj_sysfs_ops,
  511. .release = release_raid_kobj,
  512. .default_groups = raid_groups,
  513. };
  514. #define SPACE_INFO_ATTR(field) \
  515. static ssize_t btrfs_space_info_show_##field(struct kobject *kobj, \
  516. struct kobj_attribute *a, \
  517. char *buf) \
  518. { \
  519. struct btrfs_space_info *sinfo = to_space_info(kobj); \
  520. return btrfs_show_u64(&sinfo->field, &sinfo->lock, buf); \
  521. } \
  522. BTRFS_ATTR(space_info, field, btrfs_space_info_show_##field)
  523. static ssize_t btrfs_space_info_show_total_bytes_pinned(struct kobject *kobj,
  524. struct kobj_attribute *a,
  525. char *buf)
  526. {
  527. struct btrfs_space_info *sinfo = to_space_info(kobj);
  528. s64 val = percpu_counter_sum(&sinfo->total_bytes_pinned);
  529. return scnprintf(buf, PAGE_SIZE, "%lld\n", val);
  530. }
  531. SPACE_INFO_ATTR(flags);
  532. SPACE_INFO_ATTR(total_bytes);
  533. SPACE_INFO_ATTR(bytes_used);
  534. SPACE_INFO_ATTR(bytes_pinned);
  535. SPACE_INFO_ATTR(bytes_reserved);
  536. SPACE_INFO_ATTR(bytes_may_use);
  537. SPACE_INFO_ATTR(bytes_readonly);
  538. SPACE_INFO_ATTR(disk_used);
  539. SPACE_INFO_ATTR(disk_total);
  540. BTRFS_ATTR(space_info, total_bytes_pinned,
  541. btrfs_space_info_show_total_bytes_pinned);
  542. static struct attribute *space_info_attrs[] = {
  543. BTRFS_ATTR_PTR(space_info, flags),
  544. BTRFS_ATTR_PTR(space_info, total_bytes),
  545. BTRFS_ATTR_PTR(space_info, bytes_used),
  546. BTRFS_ATTR_PTR(space_info, bytes_pinned),
  547. BTRFS_ATTR_PTR(space_info, bytes_reserved),
  548. BTRFS_ATTR_PTR(space_info, bytes_may_use),
  549. BTRFS_ATTR_PTR(space_info, bytes_readonly),
  550. BTRFS_ATTR_PTR(space_info, disk_used),
  551. BTRFS_ATTR_PTR(space_info, disk_total),
  552. BTRFS_ATTR_PTR(space_info, total_bytes_pinned),
  553. NULL,
  554. };
  555. ATTRIBUTE_GROUPS(space_info);
  556. static void space_info_release(struct kobject *kobj)
  557. {
  558. struct btrfs_space_info *sinfo = to_space_info(kobj);
  559. percpu_counter_destroy(&sinfo->total_bytes_pinned);
  560. kfree(sinfo);
  561. }
  562. static struct kobj_type space_info_ktype = {
  563. .sysfs_ops = &kobj_sysfs_ops,
  564. .release = space_info_release,
  565. .default_groups = space_info_groups,
  566. };
  567. static const struct attribute *allocation_attrs[] = {
  568. BTRFS_ATTR_PTR(allocation, global_rsv_reserved),
  569. BTRFS_ATTR_PTR(allocation, global_rsv_size),
  570. NULL,
  571. };
  572. static ssize_t btrfs_label_show(struct kobject *kobj,
  573. struct kobj_attribute *a, char *buf)
  574. {
  575. struct btrfs_fs_info *fs_info = to_fs_info(kobj);
  576. char *label = fs_info->super_copy->label;
  577. ssize_t ret;
  578. spin_lock(&fs_info->super_lock);
  579. ret = scnprintf(buf, PAGE_SIZE, label[0] ? "%s\n" : "%s", label);
  580. spin_unlock(&fs_info->super_lock);
  581. return ret;
  582. }
  583. static ssize_t btrfs_label_store(struct kobject *kobj,
  584. struct kobj_attribute *a,
  585. const char *buf, size_t len)
  586. {
  587. struct btrfs_fs_info *fs_info = to_fs_info(kobj);
  588. size_t p_len;
  589. if (!fs_info)
  590. return -EPERM;
  591. if (sb_rdonly(fs_info->sb))
  592. return -EROFS;
  593. /*
  594. * p_len is the len until the first occurrence of either
  595. * '\n' or '\0'
  596. */
  597. p_len = strcspn(buf, "\n");
  598. if (p_len >= BTRFS_LABEL_SIZE)
  599. return -EINVAL;
  600. spin_lock(&fs_info->super_lock);
  601. memset(fs_info->super_copy->label, 0, BTRFS_LABEL_SIZE);
  602. memcpy(fs_info->super_copy->label, buf, p_len);
  603. spin_unlock(&fs_info->super_lock);
  604. /*
  605. * We don't want to do full transaction commit from inside sysfs
  606. */
  607. btrfs_set_pending(fs_info, COMMIT);
  608. wake_up_process(fs_info->transaction_kthread);
  609. return len;
  610. }
  611. BTRFS_ATTR_RW(, label, btrfs_label_show, btrfs_label_store);
  612. static ssize_t btrfs_nodesize_show(struct kobject *kobj,
  613. struct kobj_attribute *a, char *buf)
  614. {
  615. struct btrfs_fs_info *fs_info = to_fs_info(kobj);
  616. return scnprintf(buf, PAGE_SIZE, "%u\n", fs_info->super_copy->nodesize);
  617. }
  618. BTRFS_ATTR(, nodesize, btrfs_nodesize_show);
  619. static ssize_t btrfs_sectorsize_show(struct kobject *kobj,
  620. struct kobj_attribute *a, char *buf)
  621. {
  622. struct btrfs_fs_info *fs_info = to_fs_info(kobj);
  623. return scnprintf(buf, PAGE_SIZE, "%u\n",
  624. fs_info->super_copy->sectorsize);
  625. }
  626. BTRFS_ATTR(, sectorsize, btrfs_sectorsize_show);
  627. static ssize_t btrfs_clone_alignment_show(struct kobject *kobj,
  628. struct kobj_attribute *a, char *buf)
  629. {
  630. struct btrfs_fs_info *fs_info = to_fs_info(kobj);
  631. return scnprintf(buf, PAGE_SIZE, "%u\n", fs_info->super_copy->sectorsize);
  632. }
  633. BTRFS_ATTR(, clone_alignment, btrfs_clone_alignment_show);
  634. static ssize_t quota_override_show(struct kobject *kobj,
  635. struct kobj_attribute *a, char *buf)
  636. {
  637. struct btrfs_fs_info *fs_info = to_fs_info(kobj);
  638. int quota_override;
  639. quota_override = test_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags);
  640. return scnprintf(buf, PAGE_SIZE, "%d\n", quota_override);
  641. }
  642. static ssize_t quota_override_store(struct kobject *kobj,
  643. struct kobj_attribute *a,
  644. const char *buf, size_t len)
  645. {
  646. struct btrfs_fs_info *fs_info = to_fs_info(kobj);
  647. unsigned long knob;
  648. int err;
  649. if (!fs_info)
  650. return -EPERM;
  651. if (!capable(CAP_SYS_RESOURCE))
  652. return -EPERM;
  653. err = kstrtoul(buf, 10, &knob);
  654. if (err)
  655. return err;
  656. if (knob > 1)
  657. return -EINVAL;
  658. if (knob)
  659. set_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags);
  660. else
  661. clear_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags);
  662. return len;
  663. }
  664. BTRFS_ATTR_RW(, quota_override, quota_override_show, quota_override_store);
  665. static ssize_t btrfs_metadata_uuid_show(struct kobject *kobj,
  666. struct kobj_attribute *a, char *buf)
  667. {
  668. struct btrfs_fs_info *fs_info = to_fs_info(kobj);
  669. return scnprintf(buf, PAGE_SIZE, "%pU\n",
  670. fs_info->fs_devices->metadata_uuid);
  671. }
  672. BTRFS_ATTR(, metadata_uuid, btrfs_metadata_uuid_show);
  673. static ssize_t btrfs_checksum_show(struct kobject *kobj,
  674. struct kobj_attribute *a, char *buf)
  675. {
  676. struct btrfs_fs_info *fs_info = to_fs_info(kobj);
  677. u16 csum_type = btrfs_super_csum_type(fs_info->super_copy);
  678. return scnprintf(buf, PAGE_SIZE, "%s (%s)\n",
  679. btrfs_super_csum_name(csum_type),
  680. crypto_shash_driver_name(fs_info->csum_shash));
  681. }
  682. BTRFS_ATTR(, checksum, btrfs_checksum_show);
  683. static ssize_t btrfs_exclusive_operation_show(struct kobject *kobj,
  684. struct kobj_attribute *a, char *buf)
  685. {
  686. struct btrfs_fs_info *fs_info = to_fs_info(kobj);
  687. const char *str;
  688. switch (READ_ONCE(fs_info->exclusive_operation)) {
  689. case BTRFS_EXCLOP_NONE:
  690. str = "none\n";
  691. break;
  692. case BTRFS_EXCLOP_BALANCE:
  693. str = "balance\n";
  694. break;
  695. case BTRFS_EXCLOP_DEV_ADD:
  696. str = "device add\n";
  697. break;
  698. case BTRFS_EXCLOP_DEV_REMOVE:
  699. str = "device remove\n";
  700. break;
  701. case BTRFS_EXCLOP_DEV_REPLACE:
  702. str = "device replace\n";
  703. break;
  704. case BTRFS_EXCLOP_RESIZE:
  705. str = "resize\n";
  706. break;
  707. case BTRFS_EXCLOP_SWAP_ACTIVATE:
  708. str = "swap activate\n";
  709. break;
  710. default:
  711. str = "UNKNOWN\n";
  712. break;
  713. }
  714. return scnprintf(buf, PAGE_SIZE, "%s", str);
  715. }
  716. BTRFS_ATTR(, exclusive_operation, btrfs_exclusive_operation_show);
  717. static const struct attribute *btrfs_attrs[] = {
  718. BTRFS_ATTR_PTR(, label),
  719. BTRFS_ATTR_PTR(, nodesize),
  720. BTRFS_ATTR_PTR(, sectorsize),
  721. BTRFS_ATTR_PTR(, clone_alignment),
  722. BTRFS_ATTR_PTR(, quota_override),
  723. BTRFS_ATTR_PTR(, metadata_uuid),
  724. BTRFS_ATTR_PTR(, checksum),
  725. BTRFS_ATTR_PTR(, exclusive_operation),
  726. NULL,
  727. };
  728. static void btrfs_release_fsid_kobj(struct kobject *kobj)
  729. {
  730. struct btrfs_fs_devices *fs_devs = to_fs_devs(kobj);
  731. memset(&fs_devs->fsid_kobj, 0, sizeof(struct kobject));
  732. complete(&fs_devs->kobj_unregister);
  733. }
  734. static struct kobj_type btrfs_ktype = {
  735. .sysfs_ops = &kobj_sysfs_ops,
  736. .release = btrfs_release_fsid_kobj,
  737. };
  738. static inline struct btrfs_fs_devices *to_fs_devs(struct kobject *kobj)
  739. {
  740. if (kobj->ktype != &btrfs_ktype)
  741. return NULL;
  742. return container_of(kobj, struct btrfs_fs_devices, fsid_kobj);
  743. }
  744. static inline struct btrfs_fs_info *to_fs_info(struct kobject *kobj)
  745. {
  746. if (kobj->ktype != &btrfs_ktype)
  747. return NULL;
  748. return to_fs_devs(kobj)->fs_info;
  749. }
  750. #define NUM_FEATURE_BITS 64
  751. #define BTRFS_FEATURE_NAME_MAX 13
  752. static char btrfs_unknown_feature_names[FEAT_MAX][NUM_FEATURE_BITS][BTRFS_FEATURE_NAME_MAX];
  753. static struct btrfs_feature_attr btrfs_feature_attrs[FEAT_MAX][NUM_FEATURE_BITS];
  754. static const u64 supported_feature_masks[FEAT_MAX] = {
  755. [FEAT_COMPAT] = BTRFS_FEATURE_COMPAT_SUPP,
  756. [FEAT_COMPAT_RO] = BTRFS_FEATURE_COMPAT_RO_SUPP,
  757. [FEAT_INCOMPAT] = BTRFS_FEATURE_INCOMPAT_SUPP,
  758. };
  759. static int addrm_unknown_feature_attrs(struct btrfs_fs_info *fs_info, bool add)
  760. {
  761. int set;
  762. for (set = 0; set < FEAT_MAX; set++) {
  763. int i;
  764. struct attribute *attrs[2];
  765. struct attribute_group agroup = {
  766. .name = "features",
  767. .attrs = attrs,
  768. };
  769. u64 features = get_features(fs_info, set);
  770. features &= ~supported_feature_masks[set];
  771. if (!features)
  772. continue;
  773. attrs[1] = NULL;
  774. for (i = 0; i < NUM_FEATURE_BITS; i++) {
  775. struct btrfs_feature_attr *fa;
  776. if (!(features & (1ULL << i)))
  777. continue;
  778. fa = &btrfs_feature_attrs[set][i];
  779. attrs[0] = &fa->kobj_attr.attr;
  780. if (add) {
  781. int ret;
  782. ret = sysfs_merge_group(&fs_info->fs_devices->fsid_kobj,
  783. &agroup);
  784. if (ret)
  785. return ret;
  786. } else
  787. sysfs_unmerge_group(&fs_info->fs_devices->fsid_kobj,
  788. &agroup);
  789. }
  790. }
  791. return 0;
  792. }
  793. static void __btrfs_sysfs_remove_fsid(struct btrfs_fs_devices *fs_devs)
  794. {
  795. if (fs_devs->devinfo_kobj) {
  796. kobject_del(fs_devs->devinfo_kobj);
  797. kobject_put(fs_devs->devinfo_kobj);
  798. fs_devs->devinfo_kobj = NULL;
  799. }
  800. if (fs_devs->devices_kobj) {
  801. kobject_del(fs_devs->devices_kobj);
  802. kobject_put(fs_devs->devices_kobj);
  803. fs_devs->devices_kobj = NULL;
  804. }
  805. if (fs_devs->fsid_kobj.state_initialized) {
  806. kobject_del(&fs_devs->fsid_kobj);
  807. kobject_put(&fs_devs->fsid_kobj);
  808. wait_for_completion(&fs_devs->kobj_unregister);
  809. }
  810. }
  811. /* when fs_devs is NULL it will remove all fsid kobject */
  812. void btrfs_sysfs_remove_fsid(struct btrfs_fs_devices *fs_devs)
  813. {
  814. struct list_head *fs_uuids = btrfs_get_fs_uuids();
  815. if (fs_devs) {
  816. __btrfs_sysfs_remove_fsid(fs_devs);
  817. return;
  818. }
  819. list_for_each_entry(fs_devs, fs_uuids, fs_list) {
  820. __btrfs_sysfs_remove_fsid(fs_devs);
  821. }
  822. }
  823. static void btrfs_sysfs_remove_fs_devices(struct btrfs_fs_devices *fs_devices)
  824. {
  825. struct btrfs_device *device;
  826. struct btrfs_fs_devices *seed;
  827. list_for_each_entry(device, &fs_devices->devices, dev_list)
  828. btrfs_sysfs_remove_device(device);
  829. list_for_each_entry(seed, &fs_devices->seed_list, seed_list) {
  830. list_for_each_entry(device, &seed->devices, dev_list)
  831. btrfs_sysfs_remove_device(device);
  832. }
  833. }
  834. void btrfs_sysfs_remove_mounted(struct btrfs_fs_info *fs_info)
  835. {
  836. struct kobject *fsid_kobj = &fs_info->fs_devices->fsid_kobj;
  837. sysfs_remove_link(fsid_kobj, "bdi");
  838. if (fs_info->space_info_kobj) {
  839. sysfs_remove_files(fs_info->space_info_kobj, allocation_attrs);
  840. kobject_del(fs_info->space_info_kobj);
  841. kobject_put(fs_info->space_info_kobj);
  842. }
  843. #ifdef CONFIG_BTRFS_DEBUG
  844. if (fs_info->discard_debug_kobj) {
  845. sysfs_remove_files(fs_info->discard_debug_kobj,
  846. discard_debug_attrs);
  847. kobject_del(fs_info->discard_debug_kobj);
  848. kobject_put(fs_info->discard_debug_kobj);
  849. }
  850. if (fs_info->debug_kobj) {
  851. sysfs_remove_files(fs_info->debug_kobj, btrfs_debug_mount_attrs);
  852. kobject_del(fs_info->debug_kobj);
  853. kobject_put(fs_info->debug_kobj);
  854. }
  855. #endif
  856. addrm_unknown_feature_attrs(fs_info, false);
  857. sysfs_remove_group(fsid_kobj, &btrfs_feature_attr_group);
  858. sysfs_remove_files(fsid_kobj, btrfs_attrs);
  859. btrfs_sysfs_remove_fs_devices(fs_info->fs_devices);
  860. }
  861. static const char * const btrfs_feature_set_names[FEAT_MAX] = {
  862. [FEAT_COMPAT] = "compat",
  863. [FEAT_COMPAT_RO] = "compat_ro",
  864. [FEAT_INCOMPAT] = "incompat",
  865. };
  866. const char *btrfs_feature_set_name(enum btrfs_feature_set set)
  867. {
  868. return btrfs_feature_set_names[set];
  869. }
  870. char *btrfs_printable_features(enum btrfs_feature_set set, u64 flags)
  871. {
  872. size_t bufsize = 4096; /* safe max, 64 names * 64 bytes */
  873. int len = 0;
  874. int i;
  875. char *str;
  876. str = kmalloc(bufsize, GFP_KERNEL);
  877. if (!str)
  878. return str;
  879. for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) {
  880. const char *name;
  881. if (!(flags & (1ULL << i)))
  882. continue;
  883. name = btrfs_feature_attrs[set][i].kobj_attr.attr.name;
  884. len += scnprintf(str + len, bufsize - len, "%s%s",
  885. len ? "," : "", name);
  886. }
  887. return str;
  888. }
  889. static void init_feature_attrs(void)
  890. {
  891. struct btrfs_feature_attr *fa;
  892. int set, i;
  893. BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names) !=
  894. ARRAY_SIZE(btrfs_feature_attrs));
  895. BUILD_BUG_ON(ARRAY_SIZE(btrfs_unknown_feature_names[0]) !=
  896. ARRAY_SIZE(btrfs_feature_attrs[0]));
  897. memset(btrfs_feature_attrs, 0, sizeof(btrfs_feature_attrs));
  898. memset(btrfs_unknown_feature_names, 0,
  899. sizeof(btrfs_unknown_feature_names));
  900. for (i = 0; btrfs_supported_feature_attrs[i]; i++) {
  901. struct btrfs_feature_attr *sfa;
  902. struct attribute *a = btrfs_supported_feature_attrs[i];
  903. int bit;
  904. sfa = attr_to_btrfs_feature_attr(a);
  905. bit = ilog2(sfa->feature_bit);
  906. fa = &btrfs_feature_attrs[sfa->feature_set][bit];
  907. fa->kobj_attr.attr.name = sfa->kobj_attr.attr.name;
  908. }
  909. for (set = 0; set < FEAT_MAX; set++) {
  910. for (i = 0; i < ARRAY_SIZE(btrfs_feature_attrs[set]); i++) {
  911. char *name = btrfs_unknown_feature_names[set][i];
  912. fa = &btrfs_feature_attrs[set][i];
  913. if (fa->kobj_attr.attr.name)
  914. continue;
  915. snprintf(name, BTRFS_FEATURE_NAME_MAX, "%s:%u",
  916. btrfs_feature_set_names[set], i);
  917. fa->kobj_attr.attr.name = name;
  918. fa->kobj_attr.attr.mode = S_IRUGO;
  919. fa->feature_set = set;
  920. fa->feature_bit = 1ULL << i;
  921. }
  922. }
  923. }
  924. /*
  925. * Create a sysfs entry for a given block group type at path
  926. * /sys/fs/btrfs/UUID/allocation/data/TYPE
  927. */
  928. void btrfs_sysfs_add_block_group_type(struct btrfs_block_group *cache)
  929. {
  930. struct btrfs_fs_info *fs_info = cache->fs_info;
  931. struct btrfs_space_info *space_info = cache->space_info;
  932. struct raid_kobject *rkobj;
  933. const int index = btrfs_bg_flags_to_raid_index(cache->flags);
  934. unsigned int nofs_flag;
  935. int ret;
  936. /*
  937. * Setup a NOFS context because kobject_add(), deep in its call chain,
  938. * does GFP_KERNEL allocations, and we are often called in a context
  939. * where if reclaim is triggered we can deadlock (we are either holding
  940. * a transaction handle or some lock required for a transaction
  941. * commit).
  942. */
  943. nofs_flag = memalloc_nofs_save();
  944. rkobj = kzalloc(sizeof(*rkobj), GFP_NOFS);
  945. if (!rkobj) {
  946. memalloc_nofs_restore(nofs_flag);
  947. btrfs_warn(cache->fs_info,
  948. "couldn't alloc memory for raid level kobject");
  949. return;
  950. }
  951. rkobj->flags = cache->flags;
  952. kobject_init(&rkobj->kobj, &btrfs_raid_ktype);
  953. /*
  954. * We call this either on mount, or if we've created a block group for a
  955. * new index type while running (i.e. when restriping). The running
  956. * case is tricky because we could race with other threads, so we need
  957. * to have this check to make sure we didn't already init the kobject.
  958. *
  959. * We don't have to protect on the free side because it only happens on
  960. * unmount.
  961. */
  962. spin_lock(&space_info->lock);
  963. if (space_info->block_group_kobjs[index]) {
  964. spin_unlock(&space_info->lock);
  965. kobject_put(&rkobj->kobj);
  966. return;
  967. } else {
  968. space_info->block_group_kobjs[index] = &rkobj->kobj;
  969. }
  970. spin_unlock(&space_info->lock);
  971. ret = kobject_add(&rkobj->kobj, &space_info->kobj, "%s",
  972. btrfs_bg_type_to_raid_name(rkobj->flags));
  973. memalloc_nofs_restore(nofs_flag);
  974. if (ret) {
  975. spin_lock(&space_info->lock);
  976. space_info->block_group_kobjs[index] = NULL;
  977. spin_unlock(&space_info->lock);
  978. kobject_put(&rkobj->kobj);
  979. btrfs_warn(fs_info,
  980. "failed to add kobject for block cache, ignoring");
  981. return;
  982. }
  983. }
  984. /*
  985. * Remove sysfs directories for all block group types of a given space info and
  986. * the space info as well
  987. */
  988. void btrfs_sysfs_remove_space_info(struct btrfs_space_info *space_info)
  989. {
  990. int i;
  991. for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) {
  992. struct kobject *kobj;
  993. kobj = space_info->block_group_kobjs[i];
  994. space_info->block_group_kobjs[i] = NULL;
  995. if (kobj) {
  996. kobject_del(kobj);
  997. kobject_put(kobj);
  998. }
  999. }
  1000. kobject_del(&space_info->kobj);
  1001. kobject_put(&space_info->kobj);
  1002. }
  1003. static const char *alloc_name(u64 flags)
  1004. {
  1005. switch (flags) {
  1006. case BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_DATA:
  1007. return "mixed";
  1008. case BTRFS_BLOCK_GROUP_METADATA:
  1009. return "metadata";
  1010. case BTRFS_BLOCK_GROUP_DATA:
  1011. return "data";
  1012. case BTRFS_BLOCK_GROUP_SYSTEM:
  1013. return "system";
  1014. default:
  1015. WARN_ON(1);
  1016. return "invalid-combination";
  1017. };
  1018. }
  1019. /*
  1020. * Create a sysfs entry for a space info type at path
  1021. * /sys/fs/btrfs/UUID/allocation/TYPE
  1022. */
  1023. int btrfs_sysfs_add_space_info_type(struct btrfs_fs_info *fs_info,
  1024. struct btrfs_space_info *space_info)
  1025. {
  1026. int ret;
  1027. ret = kobject_init_and_add(&space_info->kobj, &space_info_ktype,
  1028. fs_info->space_info_kobj, "%s",
  1029. alloc_name(space_info->flags));
  1030. if (ret) {
  1031. kobject_put(&space_info->kobj);
  1032. return ret;
  1033. }
  1034. return 0;
  1035. }
  1036. void btrfs_sysfs_remove_device(struct btrfs_device *device)
  1037. {
  1038. struct hd_struct *disk;
  1039. struct kobject *disk_kobj;
  1040. struct kobject *devices_kobj;
  1041. /*
  1042. * Seed fs_devices devices_kobj aren't used, fetch kobject from the
  1043. * fs_info::fs_devices.
  1044. */
  1045. devices_kobj = device->fs_info->fs_devices->devices_kobj;
  1046. ASSERT(devices_kobj);
  1047. if (device->bdev) {
  1048. disk = device->bdev->bd_part;
  1049. disk_kobj = &part_to_dev(disk)->kobj;
  1050. sysfs_remove_link(devices_kobj, disk_kobj->name);
  1051. }
  1052. if (device->devid_kobj.state_initialized) {
  1053. kobject_del(&device->devid_kobj);
  1054. kobject_put(&device->devid_kobj);
  1055. wait_for_completion(&device->kobj_unregister);
  1056. }
  1057. }
  1058. static ssize_t btrfs_devinfo_in_fs_metadata_show(struct kobject *kobj,
  1059. struct kobj_attribute *a,
  1060. char *buf)
  1061. {
  1062. int val;
  1063. struct btrfs_device *device = container_of(kobj, struct btrfs_device,
  1064. devid_kobj);
  1065. val = !!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state);
  1066. return scnprintf(buf, PAGE_SIZE, "%d\n", val);
  1067. }
  1068. BTRFS_ATTR(devid, in_fs_metadata, btrfs_devinfo_in_fs_metadata_show);
  1069. static ssize_t btrfs_devinfo_missing_show(struct kobject *kobj,
  1070. struct kobj_attribute *a, char *buf)
  1071. {
  1072. int val;
  1073. struct btrfs_device *device = container_of(kobj, struct btrfs_device,
  1074. devid_kobj);
  1075. val = !!test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state);
  1076. return scnprintf(buf, PAGE_SIZE, "%d\n", val);
  1077. }
  1078. BTRFS_ATTR(devid, missing, btrfs_devinfo_missing_show);
  1079. static ssize_t btrfs_devinfo_replace_target_show(struct kobject *kobj,
  1080. struct kobj_attribute *a,
  1081. char *buf)
  1082. {
  1083. int val;
  1084. struct btrfs_device *device = container_of(kobj, struct btrfs_device,
  1085. devid_kobj);
  1086. val = !!test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state);
  1087. return scnprintf(buf, PAGE_SIZE, "%d\n", val);
  1088. }
  1089. BTRFS_ATTR(devid, replace_target, btrfs_devinfo_replace_target_show);
  1090. static ssize_t btrfs_devinfo_writeable_show(struct kobject *kobj,
  1091. struct kobj_attribute *a, char *buf)
  1092. {
  1093. int val;
  1094. struct btrfs_device *device = container_of(kobj, struct btrfs_device,
  1095. devid_kobj);
  1096. val = !!test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state);
  1097. return scnprintf(buf, PAGE_SIZE, "%d\n", val);
  1098. }
  1099. BTRFS_ATTR(devid, writeable, btrfs_devinfo_writeable_show);
  1100. static struct attribute *devid_attrs[] = {
  1101. BTRFS_ATTR_PTR(devid, in_fs_metadata),
  1102. BTRFS_ATTR_PTR(devid, missing),
  1103. BTRFS_ATTR_PTR(devid, replace_target),
  1104. BTRFS_ATTR_PTR(devid, writeable),
  1105. NULL
  1106. };
  1107. ATTRIBUTE_GROUPS(devid);
  1108. static void btrfs_release_devid_kobj(struct kobject *kobj)
  1109. {
  1110. struct btrfs_device *device = container_of(kobj, struct btrfs_device,
  1111. devid_kobj);
  1112. memset(&device->devid_kobj, 0, sizeof(struct kobject));
  1113. complete(&device->kobj_unregister);
  1114. }
  1115. static struct kobj_type devid_ktype = {
  1116. .sysfs_ops = &kobj_sysfs_ops,
  1117. .default_groups = devid_groups,
  1118. .release = btrfs_release_devid_kobj,
  1119. };
  1120. int btrfs_sysfs_add_device(struct btrfs_device *device)
  1121. {
  1122. int ret;
  1123. unsigned int nofs_flag;
  1124. struct kobject *devices_kobj;
  1125. struct kobject *devinfo_kobj;
  1126. /*
  1127. * Make sure we use the fs_info::fs_devices to fetch the kobjects even
  1128. * for the seed fs_devices
  1129. */
  1130. devices_kobj = device->fs_info->fs_devices->devices_kobj;
  1131. devinfo_kobj = device->fs_info->fs_devices->devinfo_kobj;
  1132. ASSERT(devices_kobj);
  1133. ASSERT(devinfo_kobj);
  1134. nofs_flag = memalloc_nofs_save();
  1135. if (device->bdev) {
  1136. struct hd_struct *disk;
  1137. struct kobject *disk_kobj;
  1138. disk = device->bdev->bd_part;
  1139. disk_kobj = &part_to_dev(disk)->kobj;
  1140. ret = sysfs_create_link(devices_kobj, disk_kobj, disk_kobj->name);
  1141. if (ret) {
  1142. btrfs_warn(device->fs_info,
  1143. "creating sysfs device link for devid %llu failed: %d",
  1144. device->devid, ret);
  1145. goto out;
  1146. }
  1147. }
  1148. init_completion(&device->kobj_unregister);
  1149. ret = kobject_init_and_add(&device->devid_kobj, &devid_ktype,
  1150. devinfo_kobj, "%llu", device->devid);
  1151. if (ret) {
  1152. kobject_put(&device->devid_kobj);
  1153. btrfs_warn(device->fs_info,
  1154. "devinfo init for devid %llu failed: %d",
  1155. device->devid, ret);
  1156. }
  1157. out:
  1158. memalloc_nofs_restore(nofs_flag);
  1159. return ret;
  1160. }
  1161. static int btrfs_sysfs_add_fs_devices(struct btrfs_fs_devices *fs_devices)
  1162. {
  1163. int ret;
  1164. struct btrfs_device *device;
  1165. struct btrfs_fs_devices *seed;
  1166. list_for_each_entry(device, &fs_devices->devices, dev_list) {
  1167. ret = btrfs_sysfs_add_device(device);
  1168. if (ret)
  1169. goto fail;
  1170. }
  1171. list_for_each_entry(seed, &fs_devices->seed_list, seed_list) {
  1172. list_for_each_entry(device, &seed->devices, dev_list) {
  1173. ret = btrfs_sysfs_add_device(device);
  1174. if (ret)
  1175. goto fail;
  1176. }
  1177. }
  1178. return 0;
  1179. fail:
  1180. btrfs_sysfs_remove_fs_devices(fs_devices);
  1181. return ret;
  1182. }
  1183. void btrfs_kobject_uevent(struct block_device *bdev, enum kobject_action action)
  1184. {
  1185. int ret;
  1186. ret = kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, action);
  1187. if (ret)
  1188. pr_warn("BTRFS: Sending event '%d' to kobject: '%s' (%p): failed\n",
  1189. action, kobject_name(&disk_to_dev(bdev->bd_disk)->kobj),
  1190. &disk_to_dev(bdev->bd_disk)->kobj);
  1191. }
  1192. void btrfs_sysfs_update_sprout_fsid(struct btrfs_fs_devices *fs_devices)
  1193. {
  1194. char fsid_buf[BTRFS_UUID_UNPARSED_SIZE];
  1195. /*
  1196. * Sprouting changes fsid of the mounted filesystem, rename the fsid
  1197. * directory
  1198. */
  1199. snprintf(fsid_buf, BTRFS_UUID_UNPARSED_SIZE, "%pU", fs_devices->fsid);
  1200. if (kobject_rename(&fs_devices->fsid_kobj, fsid_buf))
  1201. btrfs_warn(fs_devices->fs_info,
  1202. "sysfs: failed to create fsid for sprout");
  1203. }
  1204. void btrfs_sysfs_update_devid(struct btrfs_device *device)
  1205. {
  1206. char tmp[24];
  1207. snprintf(tmp, sizeof(tmp), "%llu", device->devid);
  1208. if (kobject_rename(&device->devid_kobj, tmp))
  1209. btrfs_warn(device->fs_devices->fs_info,
  1210. "sysfs: failed to update devid for %llu",
  1211. device->devid);
  1212. }
  1213. /* /sys/fs/btrfs/ entry */
  1214. static struct kset *btrfs_kset;
  1215. /*
  1216. * Creates:
  1217. * /sys/fs/btrfs/UUID
  1218. *
  1219. * Can be called by the device discovery thread.
  1220. */
  1221. int btrfs_sysfs_add_fsid(struct btrfs_fs_devices *fs_devs)
  1222. {
  1223. int error;
  1224. init_completion(&fs_devs->kobj_unregister);
  1225. fs_devs->fsid_kobj.kset = btrfs_kset;
  1226. error = kobject_init_and_add(&fs_devs->fsid_kobj, &btrfs_ktype, NULL,
  1227. "%pU", fs_devs->fsid);
  1228. if (error) {
  1229. kobject_put(&fs_devs->fsid_kobj);
  1230. return error;
  1231. }
  1232. fs_devs->devices_kobj = kobject_create_and_add("devices",
  1233. &fs_devs->fsid_kobj);
  1234. if (!fs_devs->devices_kobj) {
  1235. btrfs_err(fs_devs->fs_info,
  1236. "failed to init sysfs device interface");
  1237. btrfs_sysfs_remove_fsid(fs_devs);
  1238. return -ENOMEM;
  1239. }
  1240. fs_devs->devinfo_kobj = kobject_create_and_add("devinfo",
  1241. &fs_devs->fsid_kobj);
  1242. if (!fs_devs->devinfo_kobj) {
  1243. btrfs_err(fs_devs->fs_info,
  1244. "failed to init sysfs devinfo kobject");
  1245. btrfs_sysfs_remove_fsid(fs_devs);
  1246. return -ENOMEM;
  1247. }
  1248. return 0;
  1249. }
  1250. int btrfs_sysfs_add_mounted(struct btrfs_fs_info *fs_info)
  1251. {
  1252. int error;
  1253. struct btrfs_fs_devices *fs_devs = fs_info->fs_devices;
  1254. struct kobject *fsid_kobj = &fs_devs->fsid_kobj;
  1255. error = btrfs_sysfs_add_fs_devices(fs_devs);
  1256. if (error)
  1257. return error;
  1258. error = sysfs_create_files(fsid_kobj, btrfs_attrs);
  1259. if (error) {
  1260. btrfs_sysfs_remove_fs_devices(fs_devs);
  1261. return error;
  1262. }
  1263. error = sysfs_create_group(fsid_kobj,
  1264. &btrfs_feature_attr_group);
  1265. if (error)
  1266. goto failure;
  1267. #ifdef CONFIG_BTRFS_DEBUG
  1268. fs_info->debug_kobj = kobject_create_and_add("debug", fsid_kobj);
  1269. if (!fs_info->debug_kobj) {
  1270. error = -ENOMEM;
  1271. goto failure;
  1272. }
  1273. error = sysfs_create_files(fs_info->debug_kobj, btrfs_debug_mount_attrs);
  1274. if (error)
  1275. goto failure;
  1276. /* Discard directory */
  1277. fs_info->discard_debug_kobj = kobject_create_and_add("discard",
  1278. fs_info->debug_kobj);
  1279. if (!fs_info->discard_debug_kobj) {
  1280. error = -ENOMEM;
  1281. goto failure;
  1282. }
  1283. error = sysfs_create_files(fs_info->discard_debug_kobj,
  1284. discard_debug_attrs);
  1285. if (error)
  1286. goto failure;
  1287. #endif
  1288. error = addrm_unknown_feature_attrs(fs_info, true);
  1289. if (error)
  1290. goto failure;
  1291. error = sysfs_create_link(fsid_kobj, &fs_info->sb->s_bdi->dev->kobj, "bdi");
  1292. if (error)
  1293. goto failure;
  1294. fs_info->space_info_kobj = kobject_create_and_add("allocation",
  1295. fsid_kobj);
  1296. if (!fs_info->space_info_kobj) {
  1297. error = -ENOMEM;
  1298. goto failure;
  1299. }
  1300. error = sysfs_create_files(fs_info->space_info_kobj, allocation_attrs);
  1301. if (error)
  1302. goto failure;
  1303. return 0;
  1304. failure:
  1305. btrfs_sysfs_remove_mounted(fs_info);
  1306. return error;
  1307. }
  1308. static inline struct btrfs_fs_info *qgroup_kobj_to_fs_info(struct kobject *kobj)
  1309. {
  1310. return to_fs_info(kobj->parent->parent);
  1311. }
  1312. #define QGROUP_ATTR(_member, _show_name) \
  1313. static ssize_t btrfs_qgroup_show_##_member(struct kobject *qgroup_kobj, \
  1314. struct kobj_attribute *a, \
  1315. char *buf) \
  1316. { \
  1317. struct btrfs_fs_info *fs_info = qgroup_kobj_to_fs_info(qgroup_kobj); \
  1318. struct btrfs_qgroup *qgroup = container_of(qgroup_kobj, \
  1319. struct btrfs_qgroup, kobj); \
  1320. return btrfs_show_u64(&qgroup->_member, &fs_info->qgroup_lock, buf); \
  1321. } \
  1322. BTRFS_ATTR(qgroup, _show_name, btrfs_qgroup_show_##_member)
  1323. #define QGROUP_RSV_ATTR(_name, _type) \
  1324. static ssize_t btrfs_qgroup_rsv_show_##_name(struct kobject *qgroup_kobj, \
  1325. struct kobj_attribute *a, \
  1326. char *buf) \
  1327. { \
  1328. struct btrfs_fs_info *fs_info = qgroup_kobj_to_fs_info(qgroup_kobj); \
  1329. struct btrfs_qgroup *qgroup = container_of(qgroup_kobj, \
  1330. struct btrfs_qgroup, kobj); \
  1331. return btrfs_show_u64(&qgroup->rsv.values[_type], \
  1332. &fs_info->qgroup_lock, buf); \
  1333. } \
  1334. BTRFS_ATTR(qgroup, rsv_##_name, btrfs_qgroup_rsv_show_##_name)
  1335. QGROUP_ATTR(rfer, referenced);
  1336. QGROUP_ATTR(excl, exclusive);
  1337. QGROUP_ATTR(max_rfer, max_referenced);
  1338. QGROUP_ATTR(max_excl, max_exclusive);
  1339. QGROUP_ATTR(lim_flags, limit_flags);
  1340. QGROUP_RSV_ATTR(data, BTRFS_QGROUP_RSV_DATA);
  1341. QGROUP_RSV_ATTR(meta_pertrans, BTRFS_QGROUP_RSV_META_PERTRANS);
  1342. QGROUP_RSV_ATTR(meta_prealloc, BTRFS_QGROUP_RSV_META_PREALLOC);
  1343. static struct attribute *qgroup_attrs[] = {
  1344. BTRFS_ATTR_PTR(qgroup, referenced),
  1345. BTRFS_ATTR_PTR(qgroup, exclusive),
  1346. BTRFS_ATTR_PTR(qgroup, max_referenced),
  1347. BTRFS_ATTR_PTR(qgroup, max_exclusive),
  1348. BTRFS_ATTR_PTR(qgroup, limit_flags),
  1349. BTRFS_ATTR_PTR(qgroup, rsv_data),
  1350. BTRFS_ATTR_PTR(qgroup, rsv_meta_pertrans),
  1351. BTRFS_ATTR_PTR(qgroup, rsv_meta_prealloc),
  1352. NULL
  1353. };
  1354. ATTRIBUTE_GROUPS(qgroup);
  1355. static void qgroup_release(struct kobject *kobj)
  1356. {
  1357. struct btrfs_qgroup *qgroup = container_of(kobj, struct btrfs_qgroup, kobj);
  1358. memset(&qgroup->kobj, 0, sizeof(*kobj));
  1359. }
  1360. static struct kobj_type qgroup_ktype = {
  1361. .sysfs_ops = &kobj_sysfs_ops,
  1362. .release = qgroup_release,
  1363. .default_groups = qgroup_groups,
  1364. };
  1365. int btrfs_sysfs_add_one_qgroup(struct btrfs_fs_info *fs_info,
  1366. struct btrfs_qgroup *qgroup)
  1367. {
  1368. struct kobject *qgroups_kobj = fs_info->qgroups_kobj;
  1369. int ret;
  1370. if (test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state))
  1371. return 0;
  1372. if (qgroup->kobj.state_initialized)
  1373. return 0;
  1374. if (!qgroups_kobj)
  1375. return -EINVAL;
  1376. ret = kobject_init_and_add(&qgroup->kobj, &qgroup_ktype, qgroups_kobj,
  1377. "%hu_%llu", btrfs_qgroup_level(qgroup->qgroupid),
  1378. btrfs_qgroup_subvolid(qgroup->qgroupid));
  1379. if (ret < 0)
  1380. kobject_put(&qgroup->kobj);
  1381. return ret;
  1382. }
  1383. void btrfs_sysfs_del_qgroups(struct btrfs_fs_info *fs_info)
  1384. {
  1385. struct btrfs_qgroup *qgroup;
  1386. struct btrfs_qgroup *next;
  1387. if (test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state))
  1388. return;
  1389. rbtree_postorder_for_each_entry_safe(qgroup, next,
  1390. &fs_info->qgroup_tree, node)
  1391. btrfs_sysfs_del_one_qgroup(fs_info, qgroup);
  1392. if (fs_info->qgroups_kobj) {
  1393. kobject_del(fs_info->qgroups_kobj);
  1394. kobject_put(fs_info->qgroups_kobj);
  1395. fs_info->qgroups_kobj = NULL;
  1396. }
  1397. }
  1398. /* Called when qgroups get initialized, thus there is no need for locking */
  1399. int btrfs_sysfs_add_qgroups(struct btrfs_fs_info *fs_info)
  1400. {
  1401. struct kobject *fsid_kobj = &fs_info->fs_devices->fsid_kobj;
  1402. struct btrfs_qgroup *qgroup;
  1403. struct btrfs_qgroup *next;
  1404. int ret = 0;
  1405. if (test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state))
  1406. return 0;
  1407. ASSERT(fsid_kobj);
  1408. if (fs_info->qgroups_kobj)
  1409. return 0;
  1410. fs_info->qgroups_kobj = kobject_create_and_add("qgroups", fsid_kobj);
  1411. if (!fs_info->qgroups_kobj) {
  1412. ret = -ENOMEM;
  1413. goto out;
  1414. }
  1415. rbtree_postorder_for_each_entry_safe(qgroup, next,
  1416. &fs_info->qgroup_tree, node) {
  1417. ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup);
  1418. if (ret < 0)
  1419. goto out;
  1420. }
  1421. out:
  1422. if (ret < 0)
  1423. btrfs_sysfs_del_qgroups(fs_info);
  1424. return ret;
  1425. }
  1426. void btrfs_sysfs_del_one_qgroup(struct btrfs_fs_info *fs_info,
  1427. struct btrfs_qgroup *qgroup)
  1428. {
  1429. if (test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state))
  1430. return;
  1431. if (qgroup->kobj.state_initialized) {
  1432. kobject_del(&qgroup->kobj);
  1433. kobject_put(&qgroup->kobj);
  1434. }
  1435. }
  1436. /*
  1437. * Change per-fs features in /sys/fs/btrfs/UUID/features to match current
  1438. * values in superblock. Call after any changes to incompat/compat_ro flags
  1439. */
  1440. void btrfs_sysfs_feature_update(struct btrfs_fs_info *fs_info,
  1441. u64 bit, enum btrfs_feature_set set)
  1442. {
  1443. struct btrfs_fs_devices *fs_devs;
  1444. struct kobject *fsid_kobj;
  1445. u64 __maybe_unused features;
  1446. int __maybe_unused ret;
  1447. if (!fs_info)
  1448. return;
  1449. /*
  1450. * See 14e46e04958df74 and e410e34fad913dd, feature bit updates are not
  1451. * safe when called from some contexts (eg. balance)
  1452. */
  1453. features = get_features(fs_info, set);
  1454. ASSERT(bit & supported_feature_masks[set]);
  1455. fs_devs = fs_info->fs_devices;
  1456. fsid_kobj = &fs_devs->fsid_kobj;
  1457. if (!fsid_kobj->state_initialized)
  1458. return;
  1459. /*
  1460. * FIXME: this is too heavy to update just one value, ideally we'd like
  1461. * to use sysfs_update_group but some refactoring is needed first.
  1462. */
  1463. sysfs_remove_group(fsid_kobj, &btrfs_feature_attr_group);
  1464. ret = sysfs_create_group(fsid_kobj, &btrfs_feature_attr_group);
  1465. }
  1466. int __init btrfs_init_sysfs(void)
  1467. {
  1468. int ret;
  1469. btrfs_kset = kset_create_and_add("btrfs", NULL, fs_kobj);
  1470. if (!btrfs_kset)
  1471. return -ENOMEM;
  1472. init_feature_attrs();
  1473. ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_feature_attr_group);
  1474. if (ret)
  1475. goto out2;
  1476. ret = sysfs_merge_group(&btrfs_kset->kobj,
  1477. &btrfs_static_feature_attr_group);
  1478. if (ret)
  1479. goto out_remove_group;
  1480. #ifdef CONFIG_BTRFS_DEBUG
  1481. ret = sysfs_create_group(&btrfs_kset->kobj, &btrfs_debug_feature_attr_group);
  1482. if (ret)
  1483. goto out2;
  1484. #endif
  1485. return 0;
  1486. out_remove_group:
  1487. sysfs_remove_group(&btrfs_kset->kobj, &btrfs_feature_attr_group);
  1488. out2:
  1489. kset_unregister(btrfs_kset);
  1490. return ret;
  1491. }
  1492. void __cold btrfs_exit_sysfs(void)
  1493. {
  1494. sysfs_unmerge_group(&btrfs_kset->kobj,
  1495. &btrfs_static_feature_attr_group);
  1496. sysfs_remove_group(&btrfs_kset->kobj, &btrfs_feature_attr_group);
  1497. #ifdef CONFIG_BTRFS_DEBUG
  1498. sysfs_remove_group(&btrfs_kset->kobj, &btrfs_debug_feature_attr_group);
  1499. #endif
  1500. kset_unregister(btrfs_kset);
  1501. }