sys.c

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