sys.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
  4. * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
  5. */
  6. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  7. #include <linux/sched.h>
  8. #include <linux/cred.h>
  9. #include <linux/spinlock.h>
  10. #include <linux/completion.h>
  11. #include <linux/buffer_head.h>
  12. #include <linux/module.h>
  13. #include <linux/kobject.h>
  14. #include <linux/uaccess.h>
  15. #include <linux/gfs2_ondisk.h>
  16. #include <linux/genhd.h>
  17. #include "gfs2.h"
  18. #include "incore.h"
  19. #include "sys.h"
  20. #include "super.h"
  21. #include "glock.h"
  22. #include "quota.h"
  23. #include "util.h"
  24. #include "glops.h"
  25. #include "recovery.h"
  26. struct gfs2_attr {
  27. struct attribute attr;
  28. ssize_t (*show)(struct gfs2_sbd *, char *);
  29. ssize_t (*store)(struct gfs2_sbd *, const char *, size_t);
  30. };
  31. static ssize_t gfs2_attr_show(struct kobject *kobj, struct attribute *attr,
  32. char *buf)
  33. {
  34. struct gfs2_sbd *sdp = container_of(kobj, struct gfs2_sbd, sd_kobj);
  35. struct gfs2_attr *a = container_of(attr, struct gfs2_attr, attr);
  36. return a->show ? a->show(sdp, buf) : 0;
  37. }
  38. static ssize_t gfs2_attr_store(struct kobject *kobj, struct attribute *attr,
  39. const char *buf, size_t len)
  40. {
  41. struct gfs2_sbd *sdp = container_of(kobj, struct gfs2_sbd, sd_kobj);
  42. struct gfs2_attr *a = container_of(attr, struct gfs2_attr, attr);
  43. return a->store ? a->store(sdp, buf, len) : len;
  44. }
  45. static const struct sysfs_ops gfs2_attr_ops = {
  46. .show = gfs2_attr_show,
  47. .store = gfs2_attr_store,
  48. };
  49. static struct kset *gfs2_kset;
  50. static ssize_t id_show(struct gfs2_sbd *sdp, char *buf)
  51. {
  52. return snprintf(buf, PAGE_SIZE, "%u:%u\n",
  53. MAJOR(sdp->sd_vfs->s_dev), MINOR(sdp->sd_vfs->s_dev));
  54. }
  55. static ssize_t fsname_show(struct gfs2_sbd *sdp, char *buf)
  56. {
  57. return snprintf(buf, PAGE_SIZE, "%s\n", sdp->sd_fsname);
  58. }
  59. static ssize_t uuid_show(struct gfs2_sbd *sdp, char *buf)
  60. {
  61. struct super_block *s = sdp->sd_vfs;
  62. buf[0] = '\0';
  63. if (uuid_is_null(&s->s_uuid))
  64. return 0;
  65. return snprintf(buf, PAGE_SIZE, "%pUB\n", &s->s_uuid);
  66. }
  67. static ssize_t freeze_show(struct gfs2_sbd *sdp, char *buf)
  68. {
  69. struct super_block *sb = sdp->sd_vfs;
  70. int frozen = (sb->s_writers.frozen == SB_UNFROZEN) ? 0 : 1;
  71. return snprintf(buf, PAGE_SIZE, "%d\n", frozen);
  72. }
  73. static ssize_t freeze_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
  74. {
  75. int error, n;
  76. error = kstrtoint(buf, 0, &n);
  77. if (error)
  78. return error;
  79. if (!capable(CAP_SYS_ADMIN))
  80. return -EPERM;
  81. switch (n) {
  82. case 0:
  83. error = thaw_super(sdp->sd_vfs);
  84. break;
  85. case 1:
  86. error = freeze_super(sdp->sd_vfs);
  87. break;
  88. default:
  89. return -EINVAL;
  90. }
  91. if (error) {
  92. fs_warn(sdp, "freeze %d error %d\n", n, error);
  93. return error;
  94. }
  95. return len;
  96. }
  97. static ssize_t withdraw_show(struct gfs2_sbd *sdp, char *buf)
  98. {
  99. unsigned int b = gfs2_withdrawn(sdp);
  100. return snprintf(buf, PAGE_SIZE, "%u\n", b);
  101. }
  102. static ssize_t withdraw_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
  103. {
  104. int error, val;
  105. if (!capable(CAP_SYS_ADMIN))
  106. return -EPERM;
  107. error = kstrtoint(buf, 0, &val);
  108. if (error)
  109. return error;
  110. if (val != 1)
  111. return -EINVAL;
  112. gfs2_lm(sdp, "withdrawing from cluster at user's request\n");
  113. gfs2_withdraw(sdp);
  114. return len;
  115. }
  116. static ssize_t statfs_sync_store(struct gfs2_sbd *sdp, const char *buf,
  117. size_t len)
  118. {
  119. int error, val;
  120. if (!capable(CAP_SYS_ADMIN))
  121. return -EPERM;
  122. error = kstrtoint(buf, 0, &val);
  123. if (error)
  124. return error;
  125. if (val != 1)
  126. return -EINVAL;
  127. gfs2_statfs_sync(sdp->sd_vfs, 0);
  128. return len;
  129. }
  130. static ssize_t quota_sync_store(struct gfs2_sbd *sdp, const char *buf,
  131. size_t len)
  132. {
  133. int error, val;
  134. if (!capable(CAP_SYS_ADMIN))
  135. return -EPERM;
  136. error = kstrtoint(buf, 0, &val);
  137. if (error)
  138. return error;
  139. if (val != 1)
  140. return -EINVAL;
  141. gfs2_quota_sync(sdp->sd_vfs, 0);
  142. return len;
  143. }
  144. static ssize_t quota_refresh_user_store(struct gfs2_sbd *sdp, const char *buf,
  145. size_t len)
  146. {
  147. struct kqid qid;
  148. int error;
  149. u32 id;
  150. if (!capable(CAP_SYS_ADMIN))
  151. return -EPERM;
  152. error = kstrtou32(buf, 0, &id);
  153. if (error)
  154. return error;
  155. qid = make_kqid(current_user_ns(), USRQUOTA, id);
  156. if (!qid_valid(qid))
  157. return -EINVAL;
  158. error = gfs2_quota_refresh(sdp, qid);
  159. return error ? error : len;
  160. }
  161. static ssize_t quota_refresh_group_store(struct gfs2_sbd *sdp, const char *buf,
  162. size_t len)
  163. {
  164. struct kqid qid;
  165. int error;
  166. u32 id;
  167. if (!capable(CAP_SYS_ADMIN))
  168. return -EPERM;
  169. error = kstrtou32(buf, 0, &id);
  170. if (error)
  171. return error;
  172. qid = make_kqid(current_user_ns(), GRPQUOTA, id);
  173. if (!qid_valid(qid))
  174. return -EINVAL;
  175. error = gfs2_quota_refresh(sdp, qid);
  176. return error ? error : len;
  177. }
  178. static ssize_t demote_rq_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
  179. {
  180. struct gfs2_glock *gl;
  181. const struct gfs2_glock_operations *glops;
  182. unsigned int glmode;
  183. unsigned int gltype;
  184. unsigned long long glnum;
  185. char mode[16];
  186. int rv;
  187. if (!capable(CAP_SYS_ADMIN))
  188. return -EPERM;
  189. rv = sscanf(buf, "%u:%llu %15s", &gltype, &glnum,
  190. mode);
  191. if (rv != 3)
  192. return -EINVAL;
  193. if (strcmp(mode, "EX") == 0)
  194. glmode = LM_ST_UNLOCKED;
  195. else if ((strcmp(mode, "CW") == 0) || (strcmp(mode, "DF") == 0))
  196. glmode = LM_ST_DEFERRED;
  197. else if ((strcmp(mode, "PR") == 0) || (strcmp(mode, "SH") == 0))
  198. glmode = LM_ST_SHARED;
  199. else
  200. return -EINVAL;
  201. if (gltype > LM_TYPE_JOURNAL)
  202. return -EINVAL;
  203. if (gltype == LM_TYPE_NONDISK && glnum == GFS2_FREEZE_LOCK)
  204. glops = &gfs2_freeze_glops;
  205. else
  206. glops = gfs2_glops_list[gltype];
  207. if (glops == NULL)
  208. return -EINVAL;
  209. if (!test_and_set_bit(SDF_DEMOTE, &sdp->sd_flags))
  210. fs_info(sdp, "demote interface used\n");
  211. rv = gfs2_glock_get(sdp, glnum, glops, 0, &gl);
  212. if (rv)
  213. return rv;
  214. gfs2_glock_cb(gl, glmode);
  215. gfs2_glock_put(gl);
  216. return len;
  217. }
  218. #define GFS2_ATTR(name, mode, show, store) \
  219. static struct gfs2_attr gfs2_attr_##name = __ATTR(name, mode, show, store)
  220. GFS2_ATTR(id, 0444, id_show, NULL);
  221. GFS2_ATTR(fsname, 0444, fsname_show, NULL);
  222. GFS2_ATTR(uuid, 0444, uuid_show, NULL);
  223. GFS2_ATTR(freeze, 0644, freeze_show, freeze_store);
  224. GFS2_ATTR(withdraw, 0644, withdraw_show, withdraw_store);
  225. GFS2_ATTR(statfs_sync, 0200, NULL, statfs_sync_store);
  226. GFS2_ATTR(quota_sync, 0200, NULL, quota_sync_store);
  227. GFS2_ATTR(quota_refresh_user, 0200, NULL, quota_refresh_user_store);
  228. GFS2_ATTR(quota_refresh_group, 0200, NULL, quota_refresh_group_store);
  229. GFS2_ATTR(demote_rq, 0200, NULL, demote_rq_store);
  230. static struct attribute *gfs2_attrs[] = {
  231. &gfs2_attr_id.attr,
  232. &gfs2_attr_fsname.attr,
  233. &gfs2_attr_uuid.attr,
  234. &gfs2_attr_freeze.attr,
  235. &gfs2_attr_withdraw.attr,
  236. &gfs2_attr_statfs_sync.attr,
  237. &gfs2_attr_quota_sync.attr,
  238. &gfs2_attr_quota_refresh_user.attr,
  239. &gfs2_attr_quota_refresh_group.attr,
  240. &gfs2_attr_demote_rq.attr,
  241. NULL,
  242. };
  243. ATTRIBUTE_GROUPS(gfs2);
  244. static void gfs2_sbd_release(struct kobject *kobj)
  245. {
  246. struct gfs2_sbd *sdp = container_of(kobj, struct gfs2_sbd, sd_kobj);
  247. complete(&sdp->sd_kobj_unregister);
  248. }
  249. static struct kobj_type gfs2_ktype = {
  250. .release = gfs2_sbd_release,
  251. .default_groups = gfs2_groups,
  252. .sysfs_ops = &gfs2_attr_ops,
  253. };
  254. /*
  255. * lock_module. Originally from lock_dlm
  256. */
  257. static ssize_t proto_name_show(struct gfs2_sbd *sdp, char *buf)
  258. {
  259. const struct lm_lockops *ops = sdp->sd_lockstruct.ls_ops;
  260. return sprintf(buf, "%s\n", ops->lm_proto_name);
  261. }
  262. static ssize_t block_show(struct gfs2_sbd *sdp, char *buf)
  263. {
  264. struct lm_lockstruct *ls = &sdp->sd_lockstruct;
  265. ssize_t ret;
  266. int val = 0;
  267. if (test_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags))
  268. val = 1;
  269. ret = sprintf(buf, "%d\n", val);
  270. return ret;
  271. }
  272. static ssize_t block_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
  273. {
  274. struct lm_lockstruct *ls = &sdp->sd_lockstruct;
  275. int ret, val;
  276. ret = kstrtoint(buf, 0, &val);
  277. if (ret)
  278. return ret;
  279. if (val == 1)
  280. set_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags);
  281. else if (val == 0) {
  282. clear_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags);
  283. smp_mb__after_atomic();
  284. gfs2_glock_thaw(sdp);
  285. } else {
  286. return -EINVAL;
  287. }
  288. return len;
  289. }
  290. static ssize_t wdack_show(struct gfs2_sbd *sdp, char *buf)
  291. {
  292. int val = completion_done(&sdp->sd_wdack) ? 1 : 0;
  293. return sprintf(buf, "%d\n", val);
  294. }
  295. static ssize_t wdack_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
  296. {
  297. int ret, val;
  298. ret = kstrtoint(buf, 0, &val);
  299. if (ret)
  300. return ret;
  301. if ((val == 1) &&
  302. !strcmp(sdp->sd_lockstruct.ls_ops->lm_proto_name, "lock_dlm"))
  303. complete(&sdp->sd_wdack);
  304. else
  305. return -EINVAL;
  306. return len;
  307. }
  308. static ssize_t lkfirst_show(struct gfs2_sbd *sdp, char *buf)
  309. {
  310. struct lm_lockstruct *ls = &sdp->sd_lockstruct;
  311. return sprintf(buf, "%d\n", ls->ls_first);
  312. }
  313. static ssize_t lkfirst_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
  314. {
  315. unsigned first;
  316. int rv;
  317. rv = sscanf(buf, "%u", &first);
  318. if (rv != 1 || first > 1)
  319. return -EINVAL;
  320. rv = wait_for_completion_killable(&sdp->sd_locking_init);
  321. if (rv)
  322. return rv;
  323. spin_lock(&sdp->sd_jindex_spin);
  324. rv = -EBUSY;
  325. if (test_bit(SDF_NOJOURNALID, &sdp->sd_flags) == 0)
  326. goto out;
  327. rv = -EINVAL;
  328. if (sdp->sd_args.ar_spectator)
  329. goto out;
  330. if (sdp->sd_lockstruct.ls_ops->lm_mount == NULL)
  331. goto out;
  332. sdp->sd_lockstruct.ls_first = first;
  333. rv = 0;
  334. out:
  335. spin_unlock(&sdp->sd_jindex_spin);
  336. return rv ? rv : len;
  337. }
  338. static ssize_t first_done_show(struct gfs2_sbd *sdp, char *buf)
  339. {
  340. struct lm_lockstruct *ls = &sdp->sd_lockstruct;
  341. return sprintf(buf, "%d\n", !!test_bit(DFL_FIRST_MOUNT_DONE, &ls->ls_recover_flags));
  342. }
  343. int gfs2_recover_set(struct gfs2_sbd *sdp, unsigned jid)
  344. {
  345. struct gfs2_jdesc *jd;
  346. int rv;
  347. /* Wait for our primary journal to be initialized */
  348. wait_for_completion(&sdp->sd_journal_ready);
  349. spin_lock(&sdp->sd_jindex_spin);
  350. rv = -EBUSY;
  351. /**
  352. * If we're a spectator, we use journal0, but it's not really ours.
  353. * So we need to wait for its recovery too. If we skip it we'd never
  354. * queue work to the recovery workqueue, and so its completion would
  355. * never clear the DFL_BLOCK_LOCKS flag, so all our locks would
  356. * permanently stop working.
  357. */
  358. if (!sdp->sd_jdesc)
  359. goto out;
  360. if (sdp->sd_jdesc->jd_jid == jid && !sdp->sd_args.ar_spectator)
  361. goto out;
  362. rv = -ENOENT;
  363. list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
  364. if (jd->jd_jid != jid && !sdp->sd_args.ar_spectator)
  365. continue;
  366. rv = gfs2_recover_journal(jd, false);
  367. break;
  368. }
  369. out:
  370. spin_unlock(&sdp->sd_jindex_spin);
  371. return rv;
  372. }
  373. static ssize_t recover_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
  374. {
  375. unsigned jid;
  376. int rv;
  377. rv = sscanf(buf, "%u", &jid);
  378. if (rv != 1)
  379. return -EINVAL;
  380. if (test_bit(SDF_NORECOVERY, &sdp->sd_flags)) {
  381. rv = -ESHUTDOWN;
  382. goto out;
  383. }
  384. rv = gfs2_recover_set(sdp, jid);
  385. out:
  386. return rv ? rv : len;
  387. }
  388. static ssize_t recover_done_show(struct gfs2_sbd *sdp, char *buf)
  389. {
  390. struct lm_lockstruct *ls = &sdp->sd_lockstruct;
  391. return sprintf(buf, "%d\n", ls->ls_recover_jid_done);
  392. }
  393. static ssize_t recover_status_show(struct gfs2_sbd *sdp, char *buf)
  394. {
  395. struct lm_lockstruct *ls = &sdp->sd_lockstruct;
  396. return sprintf(buf, "%d\n", ls->ls_recover_jid_status);
  397. }
  398. static ssize_t jid_show(struct gfs2_sbd *sdp, char *buf)
  399. {
  400. return sprintf(buf, "%d\n", sdp->sd_lockstruct.ls_jid);
  401. }
  402. static ssize_t jid_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
  403. {
  404. int jid;
  405. int rv;
  406. rv = sscanf(buf, "%d", &jid);
  407. if (rv != 1)
  408. return -EINVAL;
  409. rv = wait_for_completion_killable(&sdp->sd_locking_init);
  410. if (rv)
  411. return rv;
  412. spin_lock(&sdp->sd_jindex_spin);
  413. rv = -EINVAL;
  414. if (sdp->sd_lockstruct.ls_ops->lm_mount == NULL)
  415. goto out;
  416. rv = -EBUSY;
  417. if (test_bit(SDF_NOJOURNALID, &sdp->sd_flags) == 0)
  418. goto out;
  419. rv = 0;
  420. if (sdp->sd_args.ar_spectator && jid > 0)
  421. rv = jid = -EINVAL;
  422. sdp->sd_lockstruct.ls_jid = jid;
  423. clear_bit(SDF_NOJOURNALID, &sdp->sd_flags);
  424. smp_mb__after_atomic();
  425. wake_up_bit(&sdp->sd_flags, SDF_NOJOURNALID);
  426. out:
  427. spin_unlock(&sdp->sd_jindex_spin);
  428. return rv ? rv : len;
  429. }
  430. #define GDLM_ATTR(_name,_mode,_show,_store) \
  431. static struct gfs2_attr gdlm_attr_##_name = __ATTR(_name,_mode,_show,_store)
  432. GDLM_ATTR(proto_name, 0444, proto_name_show, NULL);
  433. GDLM_ATTR(block, 0644, block_show, block_store);
  434. GDLM_ATTR(withdraw, 0644, wdack_show, wdack_store);
  435. GDLM_ATTR(jid, 0644, jid_show, jid_store);
  436. GDLM_ATTR(first, 0644, lkfirst_show, lkfirst_store);
  437. GDLM_ATTR(first_done, 0444, first_done_show, NULL);
  438. GDLM_ATTR(recover, 0600, NULL, recover_store);
  439. GDLM_ATTR(recover_done, 0444, recover_done_show, NULL);
  440. GDLM_ATTR(recover_status, 0444, recover_status_show, NULL);
  441. static struct attribute *lock_module_attrs[] = {
  442. &gdlm_attr_proto_name.attr,
  443. &gdlm_attr_block.attr,
  444. &gdlm_attr_withdraw.attr,
  445. &gdlm_attr_jid.attr,
  446. &gdlm_attr_first.attr,
  447. &gdlm_attr_first_done.attr,
  448. &gdlm_attr_recover.attr,
  449. &gdlm_attr_recover_done.attr,
  450. &gdlm_attr_recover_status.attr,
  451. NULL,
  452. };
  453. /*
  454. * get and set struct gfs2_tune fields
  455. */
  456. static ssize_t quota_scale_show(struct gfs2_sbd *sdp, char *buf)
  457. {
  458. return snprintf(buf, PAGE_SIZE, "%u %u\n",
  459. sdp->sd_tune.gt_quota_scale_num,
  460. sdp->sd_tune.gt_quota_scale_den);
  461. }
  462. static ssize_t quota_scale_store(struct gfs2_sbd *sdp, const char *buf,
  463. size_t len)
  464. {
  465. struct gfs2_tune *gt = &sdp->sd_tune;
  466. unsigned int x, y;
  467. if (!capable(CAP_SYS_ADMIN))
  468. return -EPERM;
  469. if (sscanf(buf, "%u %u", &x, &y) != 2 || !y)
  470. return -EINVAL;
  471. spin_lock(&gt->gt_spin);
  472. gt->gt_quota_scale_num = x;
  473. gt->gt_quota_scale_den = y;
  474. spin_unlock(&gt->gt_spin);
  475. return len;
  476. }
  477. static ssize_t tune_set(struct gfs2_sbd *sdp, unsigned int *field,
  478. int check_zero, const char *buf, size_t len)
  479. {
  480. struct gfs2_tune *gt = &sdp->sd_tune;
  481. unsigned int x;
  482. int error;
  483. if (!capable(CAP_SYS_ADMIN))
  484. return -EPERM;
  485. error = kstrtouint(buf, 0, &x);
  486. if (error)
  487. return error;
  488. if (check_zero && !x)
  489. return -EINVAL;
  490. spin_lock(&gt->gt_spin);
  491. *field = x;
  492. spin_unlock(&gt->gt_spin);
  493. return len;
  494. }
  495. #define TUNE_ATTR_3(name, show, store) \
  496. static struct gfs2_attr tune_attr_##name = __ATTR(name, 0644, show, store)
  497. #define TUNE_ATTR_2(name, store) \
  498. static ssize_t name##_show(struct gfs2_sbd *sdp, char *buf) \
  499. { \
  500. return snprintf(buf, PAGE_SIZE, "%u\n", sdp->sd_tune.gt_##name); \
  501. } \
  502. TUNE_ATTR_3(name, name##_show, store)
  503. #define TUNE_ATTR(name, check_zero) \
  504. static ssize_t name##_store(struct gfs2_sbd *sdp, const char *buf, size_t len)\
  505. { \
  506. return tune_set(sdp, &sdp->sd_tune.gt_##name, check_zero, buf, len); \
  507. } \
  508. TUNE_ATTR_2(name, name##_store)
  509. TUNE_ATTR(quota_warn_period, 0);
  510. TUNE_ATTR(quota_quantum, 0);
  511. TUNE_ATTR(max_readahead, 0);
  512. TUNE_ATTR(complain_secs, 0);
  513. TUNE_ATTR(statfs_slow, 0);
  514. TUNE_ATTR(new_files_jdata, 0);
  515. TUNE_ATTR(statfs_quantum, 1);
  516. TUNE_ATTR_3(quota_scale, quota_scale_show, quota_scale_store);
  517. static struct attribute *tune_attrs[] = {
  518. &tune_attr_quota_warn_period.attr,
  519. &tune_attr_quota_quantum.attr,
  520. &tune_attr_max_readahead.attr,
  521. &tune_attr_complain_secs.attr,
  522. &tune_attr_statfs_slow.attr,
  523. &tune_attr_statfs_quantum.attr,
  524. &tune_attr_quota_scale.attr,
  525. &tune_attr_new_files_jdata.attr,
  526. NULL,
  527. };
  528. static const struct attribute_group tune_group = {
  529. .name = "tune",
  530. .attrs = tune_attrs,
  531. };
  532. static const struct attribute_group lock_module_group = {
  533. .name = "lock_module",
  534. .attrs = lock_module_attrs,
  535. };
  536. int gfs2_sys_fs_add(struct gfs2_sbd *sdp)
  537. {
  538. struct super_block *sb = sdp->sd_vfs;
  539. int error;
  540. char ro[20];
  541. char spectator[20];
  542. char *envp[] = { ro, spectator, NULL };
  543. sprintf(ro, "RDONLY=%d", sb_rdonly(sb));
  544. sprintf(spectator, "SPECTATOR=%d", sdp->sd_args.ar_spectator ? 1 : 0);
  545. init_completion(&sdp->sd_kobj_unregister);
  546. sdp->sd_kobj.kset = gfs2_kset;
  547. error = kobject_init_and_add(&sdp->sd_kobj, &gfs2_ktype, NULL,
  548. "%s", sdp->sd_table_name);
  549. if (error)
  550. goto fail_reg;
  551. error = sysfs_create_group(&sdp->sd_kobj, &tune_group);
  552. if (error)
  553. goto fail_reg;
  554. error = sysfs_create_group(&sdp->sd_kobj, &lock_module_group);
  555. if (error)
  556. goto fail_tune;
  557. error = sysfs_create_link(&sdp->sd_kobj,
  558. &disk_to_dev(sb->s_bdev->bd_disk)->kobj,
  559. "device");
  560. if (error)
  561. goto fail_lock_module;
  562. kobject_uevent_env(&sdp->sd_kobj, KOBJ_ADD, envp);
  563. return 0;
  564. fail_lock_module:
  565. sysfs_remove_group(&sdp->sd_kobj, &lock_module_group);
  566. fail_tune:
  567. sysfs_remove_group(&sdp->sd_kobj, &tune_group);
  568. fail_reg:
  569. fs_err(sdp, "error %d adding sysfs files\n", error);
  570. kobject_put(&sdp->sd_kobj);
  571. wait_for_completion(&sdp->sd_kobj_unregister);
  572. sb->s_fs_info = NULL;
  573. return error;
  574. }
  575. void gfs2_sys_fs_del(struct gfs2_sbd *sdp)
  576. {
  577. sysfs_remove_link(&sdp->sd_kobj, "device");
  578. sysfs_remove_group(&sdp->sd_kobj, &tune_group);
  579. sysfs_remove_group(&sdp->sd_kobj, &lock_module_group);
  580. kobject_put(&sdp->sd_kobj);
  581. wait_for_completion(&sdp->sd_kobj_unregister);
  582. }
  583. static int gfs2_uevent(struct kset *kset, struct kobject *kobj,
  584. struct kobj_uevent_env *env)
  585. {
  586. struct gfs2_sbd *sdp = container_of(kobj, struct gfs2_sbd, sd_kobj);
  587. struct super_block *s = sdp->sd_vfs;
  588. add_uevent_var(env, "LOCKTABLE=%s", sdp->sd_table_name);
  589. add_uevent_var(env, "LOCKPROTO=%s", sdp->sd_proto_name);
  590. if (!test_bit(SDF_NOJOURNALID, &sdp->sd_flags))
  591. add_uevent_var(env, "JOURNALID=%d", sdp->sd_lockstruct.ls_jid);
  592. if (!uuid_is_null(&s->s_uuid))
  593. add_uevent_var(env, "UUID=%pUB", &s->s_uuid);
  594. return 0;
  595. }
  596. static const struct kset_uevent_ops gfs2_uevent_ops = {
  597. .uevent = gfs2_uevent,
  598. };
  599. int gfs2_sys_init(void)
  600. {
  601. gfs2_kset = kset_create_and_add("gfs2", &gfs2_uevent_ops, fs_kobj);
  602. if (!gfs2_kset)
  603. return -ENOMEM;
  604. return 0;
  605. }
  606. void gfs2_sys_uninit(void)
  607. {
  608. kset_unregister(gfs2_kset);
  609. }