2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
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.
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12 #include <linux/sched.h>
13 #include <linux/cred.h>
14 #include <linux/spinlock.h>
15 #include <linux/completion.h>
16 #include <linux/buffer_head.h>
17 #include <linux/module.h>
18 #include <linux/kobject.h>
19 #include <linux/uaccess.h>
20 #include <linux/gfs2_ondisk.h>
21 #include <linux/genhd.h>
34 struct attribute attr
;
35 ssize_t (*show
)(struct gfs2_sbd
*, char *);
36 ssize_t (*store
)(struct gfs2_sbd
*, const char *, size_t);
39 static ssize_t
gfs2_attr_show(struct kobject
*kobj
, struct attribute
*attr
,
42 struct gfs2_sbd
*sdp
= container_of(kobj
, struct gfs2_sbd
, sd_kobj
);
43 struct gfs2_attr
*a
= container_of(attr
, struct gfs2_attr
, attr
);
44 return a
->show
? a
->show(sdp
, buf
) : 0;
47 static ssize_t
gfs2_attr_store(struct kobject
*kobj
, struct attribute
*attr
,
48 const char *buf
, size_t len
)
50 struct gfs2_sbd
*sdp
= container_of(kobj
, struct gfs2_sbd
, sd_kobj
);
51 struct gfs2_attr
*a
= container_of(attr
, struct gfs2_attr
, attr
);
52 return a
->store
? a
->store(sdp
, buf
, len
) : len
;
55 static const struct sysfs_ops gfs2_attr_ops
= {
56 .show
= gfs2_attr_show
,
57 .store
= gfs2_attr_store
,
61 static struct kset
*gfs2_kset
;
63 static ssize_t
id_show(struct gfs2_sbd
*sdp
, char *buf
)
65 return snprintf(buf
, PAGE_SIZE
, "%u:%u\n",
66 MAJOR(sdp
->sd_vfs
->s_dev
), MINOR(sdp
->sd_vfs
->s_dev
));
69 static ssize_t
fsname_show(struct gfs2_sbd
*sdp
, char *buf
)
71 return snprintf(buf
, PAGE_SIZE
, "%s\n", sdp
->sd_fsname
);
74 static int gfs2_uuid_valid(const u8
*uuid
)
78 for (i
= 0; i
< 16; i
++) {
85 static ssize_t
uuid_show(struct gfs2_sbd
*sdp
, char *buf
)
87 struct super_block
*s
= sdp
->sd_vfs
;
88 const u8
*uuid
= s
->s_uuid
;
90 if (!gfs2_uuid_valid(uuid
))
92 return snprintf(buf
, PAGE_SIZE
, "%pUB\n", uuid
);
95 static ssize_t
freeze_show(struct gfs2_sbd
*sdp
, char *buf
)
97 struct super_block
*sb
= sdp
->sd_vfs
;
98 int frozen
= (sb
->s_writers
.frozen
== SB_UNFROZEN
) ? 0 : 1;
100 return snprintf(buf
, PAGE_SIZE
, "%d\n", frozen
);
103 static ssize_t
freeze_store(struct gfs2_sbd
*sdp
, const char *buf
, size_t len
)
107 error
= kstrtoint(buf
, 0, &n
);
111 if (!capable(CAP_SYS_ADMIN
))
116 error
= thaw_super(sdp
->sd_vfs
);
119 error
= freeze_super(sdp
->sd_vfs
);
126 fs_warn(sdp
, "freeze %d error %d", n
, error
);
133 static ssize_t
withdraw_show(struct gfs2_sbd
*sdp
, char *buf
)
135 unsigned int b
= test_bit(SDF_SHUTDOWN
, &sdp
->sd_flags
);
136 return snprintf(buf
, PAGE_SIZE
, "%u\n", b
);
139 static ssize_t
withdraw_store(struct gfs2_sbd
*sdp
, const char *buf
, size_t len
)
143 if (!capable(CAP_SYS_ADMIN
))
146 error
= kstrtoint(buf
, 0, &val
);
153 gfs2_lm_withdraw(sdp
, "withdrawing from cluster at user's request\n");
158 static ssize_t
statfs_sync_store(struct gfs2_sbd
*sdp
, const char *buf
,
163 if (!capable(CAP_SYS_ADMIN
))
166 error
= kstrtoint(buf
, 0, &val
);
173 gfs2_statfs_sync(sdp
->sd_vfs
, 0);
177 static ssize_t
quota_sync_store(struct gfs2_sbd
*sdp
, const char *buf
,
182 if (!capable(CAP_SYS_ADMIN
))
185 error
= kstrtoint(buf
, 0, &val
);
192 gfs2_quota_sync(sdp
->sd_vfs
, 0);
196 static ssize_t
quota_refresh_user_store(struct gfs2_sbd
*sdp
, const char *buf
,
203 if (!capable(CAP_SYS_ADMIN
))
206 error
= kstrtou32(buf
, 0, &id
);
210 qid
= make_kqid(current_user_ns(), USRQUOTA
, id
);
214 error
= gfs2_quota_refresh(sdp
, qid
);
215 return error
? error
: len
;
218 static ssize_t
quota_refresh_group_store(struct gfs2_sbd
*sdp
, const char *buf
,
225 if (!capable(CAP_SYS_ADMIN
))
228 error
= kstrtou32(buf
, 0, &id
);
232 qid
= make_kqid(current_user_ns(), GRPQUOTA
, id
);
236 error
= gfs2_quota_refresh(sdp
, qid
);
237 return error
? error
: len
;
240 static ssize_t
demote_rq_store(struct gfs2_sbd
*sdp
, const char *buf
, size_t len
)
242 struct gfs2_glock
*gl
;
243 const struct gfs2_glock_operations
*glops
;
246 unsigned long long glnum
;
250 if (!capable(CAP_SYS_ADMIN
))
253 rv
= sscanf(buf
, "%u:%llu %15s", &gltype
, &glnum
,
258 if (strcmp(mode
, "EX") == 0)
259 glmode
= LM_ST_UNLOCKED
;
260 else if ((strcmp(mode
, "CW") == 0) || (strcmp(mode
, "DF") == 0))
261 glmode
= LM_ST_DEFERRED
;
262 else if ((strcmp(mode
, "PR") == 0) || (strcmp(mode
, "SH") == 0))
263 glmode
= LM_ST_SHARED
;
267 if (gltype
> LM_TYPE_JOURNAL
)
269 if (gltype
== LM_TYPE_NONDISK
&& glnum
== GFS2_FREEZE_LOCK
)
270 glops
= &gfs2_freeze_glops
;
272 glops
= gfs2_glops_list
[gltype
];
275 if (!test_and_set_bit(SDF_DEMOTE
, &sdp
->sd_flags
))
276 fs_info(sdp
, "demote interface used\n");
277 rv
= gfs2_glock_get(sdp
, glnum
, glops
, 0, &gl
);
280 gfs2_glock_cb(gl
, glmode
);
286 #define GFS2_ATTR(name, mode, show, store) \
287 static struct gfs2_attr gfs2_attr_##name = __ATTR(name, mode, show, store)
289 GFS2_ATTR(id
, 0444, id_show
, NULL
);
290 GFS2_ATTR(fsname
, 0444, fsname_show
, NULL
);
291 GFS2_ATTR(uuid
, 0444, uuid_show
, NULL
);
292 GFS2_ATTR(freeze
, 0644, freeze_show
, freeze_store
);
293 GFS2_ATTR(withdraw
, 0644, withdraw_show
, withdraw_store
);
294 GFS2_ATTR(statfs_sync
, 0200, NULL
, statfs_sync_store
);
295 GFS2_ATTR(quota_sync
, 0200, NULL
, quota_sync_store
);
296 GFS2_ATTR(quota_refresh_user
, 0200, NULL
, quota_refresh_user_store
);
297 GFS2_ATTR(quota_refresh_group
, 0200, NULL
, quota_refresh_group_store
);
298 GFS2_ATTR(demote_rq
, 0200, NULL
, demote_rq_store
);
300 static struct attribute
*gfs2_attrs
[] = {
302 &gfs2_attr_fsname
.attr
,
303 &gfs2_attr_uuid
.attr
,
304 &gfs2_attr_freeze
.attr
,
305 &gfs2_attr_withdraw
.attr
,
306 &gfs2_attr_statfs_sync
.attr
,
307 &gfs2_attr_quota_sync
.attr
,
308 &gfs2_attr_quota_refresh_user
.attr
,
309 &gfs2_attr_quota_refresh_group
.attr
,
310 &gfs2_attr_demote_rq
.attr
,
314 static void gfs2_sbd_release(struct kobject
*kobj
)
316 struct gfs2_sbd
*sdp
= container_of(kobj
, struct gfs2_sbd
, sd_kobj
);
321 static struct kobj_type gfs2_ktype
= {
322 .release
= gfs2_sbd_release
,
323 .default_attrs
= gfs2_attrs
,
324 .sysfs_ops
= &gfs2_attr_ops
,
329 * lock_module. Originally from lock_dlm
332 static ssize_t
proto_name_show(struct gfs2_sbd
*sdp
, char *buf
)
334 const struct lm_lockops
*ops
= sdp
->sd_lockstruct
.ls_ops
;
335 return sprintf(buf
, "%s\n", ops
->lm_proto_name
);
338 static ssize_t
block_show(struct gfs2_sbd
*sdp
, char *buf
)
340 struct lm_lockstruct
*ls
= &sdp
->sd_lockstruct
;
344 if (test_bit(DFL_BLOCK_LOCKS
, &ls
->ls_recover_flags
))
346 ret
= sprintf(buf
, "%d\n", val
);
350 static ssize_t
block_store(struct gfs2_sbd
*sdp
, const char *buf
, size_t len
)
352 struct lm_lockstruct
*ls
= &sdp
->sd_lockstruct
;
355 ret
= kstrtoint(buf
, 0, &val
);
360 set_bit(DFL_BLOCK_LOCKS
, &ls
->ls_recover_flags
);
362 clear_bit(DFL_BLOCK_LOCKS
, &ls
->ls_recover_flags
);
363 smp_mb__after_atomic();
364 gfs2_glock_thaw(sdp
);
371 static ssize_t
wdack_show(struct gfs2_sbd
*sdp
, char *buf
)
373 int val
= completion_done(&sdp
->sd_wdack
) ? 1 : 0;
375 return sprintf(buf
, "%d\n", val
);
378 static ssize_t
wdack_store(struct gfs2_sbd
*sdp
, const char *buf
, size_t len
)
382 ret
= kstrtoint(buf
, 0, &val
);
387 !strcmp(sdp
->sd_lockstruct
.ls_ops
->lm_proto_name
, "lock_dlm"))
388 complete(&sdp
->sd_wdack
);
394 static ssize_t
lkfirst_show(struct gfs2_sbd
*sdp
, char *buf
)
396 struct lm_lockstruct
*ls
= &sdp
->sd_lockstruct
;
397 return sprintf(buf
, "%d\n", ls
->ls_first
);
400 static ssize_t
lkfirst_store(struct gfs2_sbd
*sdp
, const char *buf
, size_t len
)
405 rv
= sscanf(buf
, "%u", &first
);
406 if (rv
!= 1 || first
> 1)
408 rv
= wait_for_completion_killable(&sdp
->sd_locking_init
);
411 spin_lock(&sdp
->sd_jindex_spin
);
413 if (test_bit(SDF_NOJOURNALID
, &sdp
->sd_flags
) == 0)
416 if (sdp
->sd_args
.ar_spectator
)
418 if (sdp
->sd_lockstruct
.ls_ops
->lm_mount
== NULL
)
420 sdp
->sd_lockstruct
.ls_first
= first
;
423 spin_unlock(&sdp
->sd_jindex_spin
);
424 return rv
? rv
: len
;
427 static ssize_t
first_done_show(struct gfs2_sbd
*sdp
, char *buf
)
429 struct lm_lockstruct
*ls
= &sdp
->sd_lockstruct
;
430 return sprintf(buf
, "%d\n", !!test_bit(DFL_FIRST_MOUNT_DONE
, &ls
->ls_recover_flags
));
433 int gfs2_recover_set(struct gfs2_sbd
*sdp
, unsigned jid
)
435 struct gfs2_jdesc
*jd
;
438 /* Wait for our primary journal to be initialized */
439 wait_for_completion(&sdp
->sd_journal_ready
);
441 spin_lock(&sdp
->sd_jindex_spin
);
443 if (sdp
->sd_jdesc
->jd_jid
== jid
)
446 list_for_each_entry(jd
, &sdp
->sd_jindex_list
, jd_list
) {
447 if (jd
->jd_jid
!= jid
)
449 rv
= gfs2_recover_journal(jd
, false);
453 spin_unlock(&sdp
->sd_jindex_spin
);
457 static ssize_t
recover_store(struct gfs2_sbd
*sdp
, const char *buf
, size_t len
)
462 rv
= sscanf(buf
, "%u", &jid
);
466 if (test_bit(SDF_NORECOVERY
, &sdp
->sd_flags
)) {
471 rv
= gfs2_recover_set(sdp
, jid
);
473 return rv
? rv
: len
;
476 static ssize_t
recover_done_show(struct gfs2_sbd
*sdp
, char *buf
)
478 struct lm_lockstruct
*ls
= &sdp
->sd_lockstruct
;
479 return sprintf(buf
, "%d\n", ls
->ls_recover_jid_done
);
482 static ssize_t
recover_status_show(struct gfs2_sbd
*sdp
, char *buf
)
484 struct lm_lockstruct
*ls
= &sdp
->sd_lockstruct
;
485 return sprintf(buf
, "%d\n", ls
->ls_recover_jid_status
);
488 static ssize_t
jid_show(struct gfs2_sbd
*sdp
, char *buf
)
490 return sprintf(buf
, "%d\n", sdp
->sd_lockstruct
.ls_jid
);
493 static ssize_t
jid_store(struct gfs2_sbd
*sdp
, const char *buf
, size_t len
)
498 rv
= sscanf(buf
, "%d", &jid
);
501 rv
= wait_for_completion_killable(&sdp
->sd_locking_init
);
504 spin_lock(&sdp
->sd_jindex_spin
);
506 if (sdp
->sd_lockstruct
.ls_ops
->lm_mount
== NULL
)
509 if (test_bit(SDF_NOJOURNALID
, &sdp
->sd_flags
) == 0)
512 if (sdp
->sd_args
.ar_spectator
&& jid
> 0)
514 sdp
->sd_lockstruct
.ls_jid
= jid
;
515 clear_bit(SDF_NOJOURNALID
, &sdp
->sd_flags
);
516 smp_mb__after_atomic();
517 wake_up_bit(&sdp
->sd_flags
, SDF_NOJOURNALID
);
519 spin_unlock(&sdp
->sd_jindex_spin
);
520 return rv
? rv
: len
;
523 #define GDLM_ATTR(_name,_mode,_show,_store) \
524 static struct gfs2_attr gdlm_attr_##_name = __ATTR(_name,_mode,_show,_store)
526 GDLM_ATTR(proto_name
, 0444, proto_name_show
, NULL
);
527 GDLM_ATTR(block
, 0644, block_show
, block_store
);
528 GDLM_ATTR(withdraw
, 0644, wdack_show
, wdack_store
);
529 GDLM_ATTR(jid
, 0644, jid_show
, jid_store
);
530 GDLM_ATTR(first
, 0644, lkfirst_show
, lkfirst_store
);
531 GDLM_ATTR(first_done
, 0444, first_done_show
, NULL
);
532 GDLM_ATTR(recover
, 0600, NULL
, recover_store
);
533 GDLM_ATTR(recover_done
, 0444, recover_done_show
, NULL
);
534 GDLM_ATTR(recover_status
, 0444, recover_status_show
, NULL
);
536 static struct attribute
*lock_module_attrs
[] = {
537 &gdlm_attr_proto_name
.attr
,
538 &gdlm_attr_block
.attr
,
539 &gdlm_attr_withdraw
.attr
,
541 &gdlm_attr_first
.attr
,
542 &gdlm_attr_first_done
.attr
,
543 &gdlm_attr_recover
.attr
,
544 &gdlm_attr_recover_done
.attr
,
545 &gdlm_attr_recover_status
.attr
,
550 * get and set struct gfs2_tune fields
553 static ssize_t
quota_scale_show(struct gfs2_sbd
*sdp
, char *buf
)
555 return snprintf(buf
, PAGE_SIZE
, "%u %u\n",
556 sdp
->sd_tune
.gt_quota_scale_num
,
557 sdp
->sd_tune
.gt_quota_scale_den
);
560 static ssize_t
quota_scale_store(struct gfs2_sbd
*sdp
, const char *buf
,
563 struct gfs2_tune
*gt
= &sdp
->sd_tune
;
566 if (!capable(CAP_SYS_ADMIN
))
569 if (sscanf(buf
, "%u %u", &x
, &y
) != 2 || !y
)
572 spin_lock(>
->gt_spin
);
573 gt
->gt_quota_scale_num
= x
;
574 gt
->gt_quota_scale_den
= y
;
575 spin_unlock(>
->gt_spin
);
579 static ssize_t
tune_set(struct gfs2_sbd
*sdp
, unsigned int *field
,
580 int check_zero
, const char *buf
, size_t len
)
582 struct gfs2_tune
*gt
= &sdp
->sd_tune
;
586 if (!capable(CAP_SYS_ADMIN
))
589 error
= kstrtouint(buf
, 0, &x
);
593 if (check_zero
&& !x
)
596 spin_lock(>
->gt_spin
);
598 spin_unlock(>
->gt_spin
);
602 #define TUNE_ATTR_3(name, show, store) \
603 static struct gfs2_attr tune_attr_##name = __ATTR(name, 0644, show, store)
605 #define TUNE_ATTR_2(name, store) \
606 static ssize_t name##_show(struct gfs2_sbd *sdp, char *buf) \
608 return snprintf(buf, PAGE_SIZE, "%u\n", sdp->sd_tune.gt_##name); \
610 TUNE_ATTR_3(name, name##_show, store)
612 #define TUNE_ATTR(name, check_zero) \
613 static ssize_t name##_store(struct gfs2_sbd *sdp, const char *buf, size_t len)\
615 return tune_set(sdp, &sdp->sd_tune.gt_##name, check_zero, buf, len); \
617 TUNE_ATTR_2(name, name##_store)
619 TUNE_ATTR(quota_warn_period
, 0);
620 TUNE_ATTR(quota_quantum
, 0);
621 TUNE_ATTR(max_readahead
, 0);
622 TUNE_ATTR(complain_secs
, 0);
623 TUNE_ATTR(statfs_slow
, 0);
624 TUNE_ATTR(new_files_jdata
, 0);
625 TUNE_ATTR(statfs_quantum
, 1);
626 TUNE_ATTR_3(quota_scale
, quota_scale_show
, quota_scale_store
);
628 static struct attribute
*tune_attrs
[] = {
629 &tune_attr_quota_warn_period
.attr
,
630 &tune_attr_quota_quantum
.attr
,
631 &tune_attr_max_readahead
.attr
,
632 &tune_attr_complain_secs
.attr
,
633 &tune_attr_statfs_slow
.attr
,
634 &tune_attr_statfs_quantum
.attr
,
635 &tune_attr_quota_scale
.attr
,
636 &tune_attr_new_files_jdata
.attr
,
640 static struct attribute_group tune_group
= {
645 static struct attribute_group lock_module_group
= {
646 .name
= "lock_module",
647 .attrs
= lock_module_attrs
,
650 int gfs2_sys_fs_add(struct gfs2_sbd
*sdp
)
652 struct super_block
*sb
= sdp
->sd_vfs
;
656 char *envp
[] = { ro
, spectator
, NULL
};
657 int sysfs_frees_sdp
= 0;
659 sprintf(ro
, "RDONLY=%d", (sb
->s_flags
& MS_RDONLY
) ? 1 : 0);
660 sprintf(spectator
, "SPECTATOR=%d", sdp
->sd_args
.ar_spectator
? 1 : 0);
662 sdp
->sd_kobj
.kset
= gfs2_kset
;
663 error
= kobject_init_and_add(&sdp
->sd_kobj
, &gfs2_ktype
, NULL
,
664 "%s", sdp
->sd_table_name
);
668 sysfs_frees_sdp
= 1; /* Freeing sdp is now done by sysfs calling
669 function gfs2_sbd_release. */
670 error
= sysfs_create_group(&sdp
->sd_kobj
, &tune_group
);
674 error
= sysfs_create_group(&sdp
->sd_kobj
, &lock_module_group
);
678 error
= sysfs_create_link(&sdp
->sd_kobj
,
679 &disk_to_dev(sb
->s_bdev
->bd_disk
)->kobj
,
682 goto fail_lock_module
;
684 kobject_uevent_env(&sdp
->sd_kobj
, KOBJ_ADD
, envp
);
688 sysfs_remove_group(&sdp
->sd_kobj
, &lock_module_group
);
690 sysfs_remove_group(&sdp
->sd_kobj
, &tune_group
);
692 free_percpu(sdp
->sd_lkstats
);
693 fs_err(sdp
, "error %d adding sysfs files", error
);
695 kobject_put(&sdp
->sd_kobj
);
698 sb
->s_fs_info
= NULL
;
702 void gfs2_sys_fs_del(struct gfs2_sbd
*sdp
)
704 sysfs_remove_link(&sdp
->sd_kobj
, "device");
705 sysfs_remove_group(&sdp
->sd_kobj
, &tune_group
);
706 sysfs_remove_group(&sdp
->sd_kobj
, &lock_module_group
);
707 kobject_put(&sdp
->sd_kobj
);
710 static int gfs2_uevent(struct kset
*kset
, struct kobject
*kobj
,
711 struct kobj_uevent_env
*env
)
713 struct gfs2_sbd
*sdp
= container_of(kobj
, struct gfs2_sbd
, sd_kobj
);
714 struct super_block
*s
= sdp
->sd_vfs
;
715 const u8
*uuid
= s
->s_uuid
;
717 add_uevent_var(env
, "LOCKTABLE=%s", sdp
->sd_table_name
);
718 add_uevent_var(env
, "LOCKPROTO=%s", sdp
->sd_proto_name
);
719 if (!test_bit(SDF_NOJOURNALID
, &sdp
->sd_flags
))
720 add_uevent_var(env
, "JOURNALID=%d", sdp
->sd_lockstruct
.ls_jid
);
721 if (gfs2_uuid_valid(uuid
))
722 add_uevent_var(env
, "UUID=%pUB", uuid
);
726 static const struct kset_uevent_ops gfs2_uevent_ops
= {
727 .uevent
= gfs2_uevent
,
730 int gfs2_sys_init(void)
732 gfs2_kset
= kset_create_and_add("gfs2", &gfs2_uevent_ops
, fs_kobj
);
738 void gfs2_sys_uninit(void)
740 kset_unregister(gfs2_kset
);