sys.c 20 KB

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