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