blob: d09f6edda0ff8d55f31ef04dba7f4720852f7a8d [file] [log] [blame]
David Teiglandb3b94fa2006-01-16 16:50:04 +00001/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
Steven Whitehouse3a8a9a12006-05-18 15:09:15 -04003 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
David Teiglandb3b94fa2006-01-16 16:50:04 +00004 *
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04007 * of the GNU General Public License version 2.
David Teiglandb3b94fa2006-01-16 16:50:04 +00008 */
9
10#include <linux/sched.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000011#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>
David Teiglandb3b94fa2006-01-16 16:50:04 +000016#include <asm/uaccess.h>
Steven Whitehousef057f6c2009-01-12 10:43:39 +000017#include <linux/gfs2_ondisk.h>
Steven Whitehouse31e54b02009-08-13 12:18:08 +010018#include <linux/genhd.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000019
20#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050021#include "incore.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000022#include "sys.h"
23#include "super.h"
24#include "glock.h"
25#include "quota.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050026#include "util.h"
Steven Whitehouse64d576b2009-02-12 13:31:58 +000027#include "glops.h"
Tejun Heo6ecd7c22010-07-20 22:09:02 +020028#include "recovery.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000029
Steven Whitehouse48c2b612009-05-13 14:49:48 +010030struct 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
Emese Revfy52cf25d2010-01-19 02:58:23 +010052static const struct sysfs_ops gfs2_attr_ops = {
Steven Whitehouse48c2b612009-05-13 14:49:48 +010053 .show = gfs2_attr_show,
54 .store = gfs2_attr_store,
55};
56
57
58static struct kset *gfs2_kset;
59
David Teiglandb3b94fa2006-01-16 16:50:04 +000060static ssize_t id_show(struct gfs2_sbd *sdp, char *buf)
61{
Bob Petersonc7227e462007-11-02 09:37:15 -050062 return snprintf(buf, PAGE_SIZE, "%u:%u\n",
63 MAJOR(sdp->sd_vfs->s_dev), MINOR(sdp->sd_vfs->s_dev));
David Teiglandb3b94fa2006-01-16 16:50:04 +000064}
65
66static ssize_t fsname_show(struct gfs2_sbd *sdp, char *buf)
67{
David Teigland3204a6c2006-09-06 16:57:06 -050068 return snprintf(buf, PAGE_SIZE, "%s\n", sdp->sd_fsname);
David Teiglandb3b94fa2006-01-16 16:50:04 +000069}
70
Steven Whitehouse02e3cc72009-02-10 13:48:30 +000071static int gfs2_uuid_valid(const u8 *uuid)
72{
73 int i;
74
75 for (i = 0; i < 16; i++) {
76 if (uuid[i])
77 return 1;
78 }
79 return 0;
80}
81
82static ssize_t uuid_show(struct gfs2_sbd *sdp, char *buf)
83{
Steven Whitehouse32e471e2011-05-10 15:01:59 +010084 struct super_block *s = sdp->sd_vfs;
85 const u8 *uuid = s->s_uuid;
Steven Whitehouse02e3cc72009-02-10 13:48:30 +000086 buf[0] = '\0';
87 if (!gfs2_uuid_valid(uuid))
88 return 0;
Joe Perchesf0b34ae2009-12-14 18:01:13 -080089 return snprintf(buf, PAGE_SIZE, "%pUB\n", uuid);
Steven Whitehouse02e3cc72009-02-10 13:48:30 +000090}
91
David Teiglandb3b94fa2006-01-16 16:50:04 +000092static ssize_t freeze_show(struct gfs2_sbd *sdp, char *buf)
93{
Steven Whitehoused564053f2013-01-11 10:49:34 +000094 struct super_block *sb = sdp->sd_vfs;
95 int frozen = (sb->s_writers.frozen == SB_UNFROZEN) ? 0 : 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +000096
Steven Whitehoused564053f2013-01-11 10:49:34 +000097 return snprintf(buf, PAGE_SIZE, "%u\n", frozen);
David Teiglandb3b94fa2006-01-16 16:50:04 +000098}
99
100static ssize_t freeze_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
101{
Steven Whitehoused564053f2013-01-11 10:49:34 +0000102 int error;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000103 int n = simple_strtol(buf, NULL, 0);
104
105 if (!capable(CAP_SYS_ADMIN))
Zhao Hongjiang41735812013-02-20 13:13:55 +1100106 return -EPERM;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000107
108 switch (n) {
109 case 0:
Steven Whitehoused564053f2013-01-11 10:49:34 +0000110 error = thaw_super(sdp->sd_vfs);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000111 break;
112 case 1:
Steven Whitehoused564053f2013-01-11 10:49:34 +0000113 error = freeze_super(sdp->sd_vfs);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000114 break;
115 default:
Steven Whitehoused564053f2013-01-11 10:49:34 +0000116 return -EINVAL;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000117 }
118
Steven Whitehoused564053f2013-01-11 10:49:34 +0000119 if (error) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000120 fs_warn(sdp, "freeze %d error %d", n, error);
Steven Whitehoused564053f2013-01-11 10:49:34 +0000121 return error;
122 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000123
Steven Whitehoused564053f2013-01-11 10:49:34 +0000124 return len;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000125}
126
127static ssize_t withdraw_show(struct gfs2_sbd *sdp, char *buf)
128{
129 unsigned int b = test_bit(SDF_SHUTDOWN, &sdp->sd_flags);
David Teigland3204a6c2006-09-06 16:57:06 -0500130 return snprintf(buf, PAGE_SIZE, "%u\n", b);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000131}
132
133static ssize_t withdraw_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
134{
135 if (!capable(CAP_SYS_ADMIN))
Zhao Hongjiang41735812013-02-20 13:13:55 +1100136 return -EPERM;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000137
138 if (simple_strtol(buf, NULL, 0) != 1)
139 return -EINVAL;
140
141 gfs2_lm_withdraw(sdp,
142 "GFS2: fsid=%s: withdrawing from cluster at user's request\n",
143 sdp->sd_fsname);
144 return len;
145}
146
147static ssize_t statfs_sync_store(struct gfs2_sbd *sdp, const char *buf,
148 size_t len)
149{
150 if (!capable(CAP_SYS_ADMIN))
Zhao Hongjiang41735812013-02-20 13:13:55 +1100151 return -EPERM;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000152
153 if (simple_strtol(buf, NULL, 0) != 1)
154 return -EINVAL;
155
Steven Whitehouse8c42d632009-09-11 14:36:44 +0100156 gfs2_statfs_sync(sdp->sd_vfs, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000157 return len;
158}
159
David Teiglandb3b94fa2006-01-16 16:50:04 +0000160static ssize_t quota_sync_store(struct gfs2_sbd *sdp, const char *buf,
161 size_t len)
162{
163 if (!capable(CAP_SYS_ADMIN))
Zhao Hongjiang41735812013-02-20 13:13:55 +1100164 return -EPERM;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000165
166 if (simple_strtol(buf, NULL, 0) != 1)
167 return -EINVAL;
168
Jan Karaceed1722012-07-03 16:45:28 +0200169 gfs2_quota_sync(sdp->sd_vfs, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000170 return len;
171}
172
173static ssize_t quota_refresh_user_store(struct gfs2_sbd *sdp, const char *buf,
174 size_t len)
175{
Eric W. Biedermaned87dab2013-01-31 19:42:40 -0800176 struct kqid qid;
Steven Whitehouseea762332009-09-15 16:20:30 +0100177 int error;
Steven Whitehousecd915492006-09-04 12:49:07 -0400178 u32 id;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000179
180 if (!capable(CAP_SYS_ADMIN))
Zhao Hongjiang41735812013-02-20 13:13:55 +1100181 return -EPERM;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000182
183 id = simple_strtoul(buf, NULL, 0);
184
Eric W. Biedermaned87dab2013-01-31 19:42:40 -0800185 qid = make_kqid(current_user_ns(), USRQUOTA, id);
186 if (!qid_valid(qid))
187 return -EINVAL;
188
189 error = gfs2_quota_refresh(sdp, qid);
Steven Whitehouseea762332009-09-15 16:20:30 +0100190 return error ? error : len;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000191}
192
193static ssize_t quota_refresh_group_store(struct gfs2_sbd *sdp, const char *buf,
194 size_t len)
195{
Eric W. Biedermaned87dab2013-01-31 19:42:40 -0800196 struct kqid qid;
Steven Whitehouseea762332009-09-15 16:20:30 +0100197 int error;
Steven Whitehousecd915492006-09-04 12:49:07 -0400198 u32 id;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000199
200 if (!capable(CAP_SYS_ADMIN))
Zhao Hongjiang41735812013-02-20 13:13:55 +1100201 return -EPERM;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000202
203 id = simple_strtoul(buf, NULL, 0);
204
Eric W. Biedermaned87dab2013-01-31 19:42:40 -0800205 qid = make_kqid(current_user_ns(), GRPQUOTA, id);
206 if (!qid_valid(qid))
207 return -EINVAL;
208
209 error = gfs2_quota_refresh(sdp, qid);
Steven Whitehouseea762332009-09-15 16:20:30 +0100210 return error ? error : len;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000211}
212
Steven Whitehouse64d576b2009-02-12 13:31:58 +0000213static ssize_t demote_rq_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
214{
215 struct gfs2_glock *gl;
216 const struct gfs2_glock_operations *glops;
217 unsigned int glmode;
218 unsigned int gltype;
219 unsigned long long glnum;
220 char mode[16];
221 int rv;
222
223 if (!capable(CAP_SYS_ADMIN))
Zhao Hongjiang41735812013-02-20 13:13:55 +1100224 return -EPERM;
Steven Whitehouse64d576b2009-02-12 13:31:58 +0000225
226 rv = sscanf(buf, "%u:%llu %15s", &gltype, &glnum,
227 mode);
228 if (rv != 3)
229 return -EINVAL;
230
231 if (strcmp(mode, "EX") == 0)
232 glmode = LM_ST_UNLOCKED;
233 else if ((strcmp(mode, "CW") == 0) || (strcmp(mode, "DF") == 0))
234 glmode = LM_ST_DEFERRED;
235 else if ((strcmp(mode, "PR") == 0) || (strcmp(mode, "SH") == 0))
236 glmode = LM_ST_SHARED;
237 else
238 return -EINVAL;
239
240 if (gltype > LM_TYPE_JOURNAL)
241 return -EINVAL;
Steven Whitehouse13466982010-10-06 09:58:44 +0100242 if (gltype == LM_TYPE_NONDISK && glnum == GFS2_TRANS_LOCK)
243 glops = &gfs2_trans_glops;
244 else
245 glops = gfs2_glops_list[gltype];
Steven Whitehouse64d576b2009-02-12 13:31:58 +0000246 if (glops == NULL)
247 return -EINVAL;
Steven Whitehouse6a99be52010-05-14 14:05:51 +0100248 if (!test_and_set_bit(SDF_DEMOTE, &sdp->sd_flags))
Steven Whitehouse913a71d2010-05-06 11:03:29 +0100249 fs_info(sdp, "demote interface used\n");
Steven Whitehouse64d576b2009-02-12 13:31:58 +0000250 rv = gfs2_glock_get(sdp, glnum, glops, 0, &gl);
251 if (rv)
252 return rv;
253 gfs2_glock_cb(gl, glmode);
254 gfs2_glock_put(gl);
255 return len;
256}
257
David Teiglandb3b94fa2006-01-16 16:50:04 +0000258
259#define GFS2_ATTR(name, mode, show, store) \
260static struct gfs2_attr gfs2_attr_##name = __ATTR(name, mode, show, store)
261
262GFS2_ATTR(id, 0444, id_show, NULL);
263GFS2_ATTR(fsname, 0444, fsname_show, NULL);
Steven Whitehouse02e3cc72009-02-10 13:48:30 +0000264GFS2_ATTR(uuid, 0444, uuid_show, NULL);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000265GFS2_ATTR(freeze, 0644, freeze_show, freeze_store);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000266GFS2_ATTR(withdraw, 0644, withdraw_show, withdraw_store);
267GFS2_ATTR(statfs_sync, 0200, NULL, statfs_sync_store);
268GFS2_ATTR(quota_sync, 0200, NULL, quota_sync_store);
269GFS2_ATTR(quota_refresh_user, 0200, NULL, quota_refresh_user_store);
270GFS2_ATTR(quota_refresh_group, 0200, NULL, quota_refresh_group_store);
Steven Whitehouse64d576b2009-02-12 13:31:58 +0000271GFS2_ATTR(demote_rq, 0200, NULL, demote_rq_store);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000272
273static struct attribute *gfs2_attrs[] = {
274 &gfs2_attr_id.attr,
275 &gfs2_attr_fsname.attr,
Steven Whitehouse02e3cc72009-02-10 13:48:30 +0000276 &gfs2_attr_uuid.attr,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000277 &gfs2_attr_freeze.attr,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000278 &gfs2_attr_withdraw.attr,
279 &gfs2_attr_statfs_sync.attr,
280 &gfs2_attr_quota_sync.attr,
281 &gfs2_attr_quota_refresh_user.attr,
282 &gfs2_attr_quota_refresh_group.attr,
Steven Whitehouse64d576b2009-02-12 13:31:58 +0000283 &gfs2_attr_demote_rq.attr,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000284 NULL,
285};
286
Bob Peterson0d515212012-06-13 10:27:41 -0400287static void gfs2_sbd_release(struct kobject *kobj)
288{
289 struct gfs2_sbd *sdp = container_of(kobj, struct gfs2_sbd, sd_kobj);
290
291 kfree(sdp);
292}
293
David Teiglandb3b94fa2006-01-16 16:50:04 +0000294static struct kobj_type gfs2_ktype = {
Bob Peterson0d515212012-06-13 10:27:41 -0400295 .release = gfs2_sbd_release,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000296 .default_attrs = gfs2_attrs,
297 .sysfs_ops = &gfs2_attr_ops,
298};
299
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000300
301/*
302 * lock_module. Originally from lock_dlm
303 */
304
305static ssize_t proto_name_show(struct gfs2_sbd *sdp, char *buf)
306{
307 const struct lm_lockops *ops = sdp->sd_lockstruct.ls_ops;
308 return sprintf(buf, "%s\n", ops->lm_proto_name);
309}
310
311static ssize_t block_show(struct gfs2_sbd *sdp, char *buf)
312{
313 struct lm_lockstruct *ls = &sdp->sd_lockstruct;
314 ssize_t ret;
315 int val = 0;
316
David Teiglande0c2a9a2012-01-09 17:18:05 -0500317 if (test_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags))
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000318 val = 1;
319 ret = sprintf(buf, "%d\n", val);
320 return ret;
321}
322
323static ssize_t block_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
324{
325 struct lm_lockstruct *ls = &sdp->sd_lockstruct;
326 ssize_t ret = len;
327 int val;
328
329 val = simple_strtol(buf, NULL, 0);
330
331 if (val == 1)
David Teiglande0c2a9a2012-01-09 17:18:05 -0500332 set_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags);
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000333 else if (val == 0) {
David Teiglande0c2a9a2012-01-09 17:18:05 -0500334 clear_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags);
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000335 smp_mb__after_clear_bit();
336 gfs2_glock_thaw(sdp);
337 } else {
338 ret = -EINVAL;
339 }
340 return ret;
341}
342
Steven Whitehousefd95e812013-02-13 12:21:40 +0000343static ssize_t wdack_show(struct gfs2_sbd *sdp, char *buf)
344{
345 int val = completion_done(&sdp->sd_wdack) ? 1 : 0;
346
347 return sprintf(buf, "%d\n", val);
348}
349
350static ssize_t wdack_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
351{
352 ssize_t ret = len;
353 int val;
354
355 val = simple_strtol(buf, NULL, 0);
356
357 if ((val == 1) &&
358 !strcmp(sdp->sd_lockstruct.ls_ops->lm_proto_name, "lock_dlm"))
359 complete(&sdp->sd_wdack);
360 else
361 ret = -EINVAL;
362 return ret;
363}
364
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000365static ssize_t lkfirst_show(struct gfs2_sbd *sdp, char *buf)
366{
367 struct lm_lockstruct *ls = &sdp->sd_lockstruct;
368 return sprintf(buf, "%d\n", ls->ls_first);
369}
370
Steven Whitehouseba6e9362010-06-14 10:01:30 +0100371static ssize_t lkfirst_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
372{
373 unsigned first;
374 int rv;
375
376 rv = sscanf(buf, "%u", &first);
377 if (rv != 1 || first > 1)
378 return -EINVAL;
Steven Whitehouse3942ae52011-07-11 08:53:30 +0100379 rv = wait_for_completion_killable(&sdp->sd_locking_init);
380 if (rv)
381 return rv;
Steven Whitehouseba6e9362010-06-14 10:01:30 +0100382 spin_lock(&sdp->sd_jindex_spin);
383 rv = -EBUSY;
384 if (test_bit(SDF_NOJOURNALID, &sdp->sd_flags) == 0)
385 goto out;
386 rv = -EINVAL;
387 if (sdp->sd_args.ar_spectator)
388 goto out;
389 if (sdp->sd_lockstruct.ls_ops->lm_mount == NULL)
390 goto out;
David Teiglande0c2a9a2012-01-09 17:18:05 -0500391 sdp->sd_lockstruct.ls_first = first;
392 rv = 0;
Steven Whitehouseba6e9362010-06-14 10:01:30 +0100393out:
394 spin_unlock(&sdp->sd_jindex_spin);
395 return rv ? rv : len;
396}
397
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000398static ssize_t first_done_show(struct gfs2_sbd *sdp, char *buf)
399{
400 struct lm_lockstruct *ls = &sdp->sd_lockstruct;
David Teiglande0c2a9a2012-01-09 17:18:05 -0500401 return sprintf(buf, "%d\n", !!test_bit(DFL_FIRST_MOUNT_DONE, &ls->ls_recover_flags));
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000402}
403
David Teiglande0c2a9a2012-01-09 17:18:05 -0500404int gfs2_recover_set(struct gfs2_sbd *sdp, unsigned jid)
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000405{
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000406 struct gfs2_jdesc *jd;
Steven Whitehousefe64d512009-05-19 10:01:18 +0100407 int rv;
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000408
409 spin_lock(&sdp->sd_jindex_spin);
Steven Whitehousefe64d512009-05-19 10:01:18 +0100410 rv = -EBUSY;
411 if (sdp->sd_jdesc->jd_jid == jid)
412 goto out;
413 rv = -ENOENT;
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000414 list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
415 if (jd->jd_jid != jid)
416 continue;
Tejun Heo6ecd7c22010-07-20 22:09:02 +0200417 rv = gfs2_recover_journal(jd, false);
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000418 break;
419 }
Steven Whitehousefe64d512009-05-19 10:01:18 +0100420out:
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000421 spin_unlock(&sdp->sd_jindex_spin);
David Teiglande0c2a9a2012-01-09 17:18:05 -0500422 return rv;
423}
424
425static ssize_t recover_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
426{
427 unsigned jid;
428 int rv;
429
430 rv = sscanf(buf, "%u", &jid);
431 if (rv != 1)
432 return -EINVAL;
433
David Teigland1a058f52012-05-01 15:50:48 -0500434 if (test_bit(SDF_NORECOVERY, &sdp->sd_flags)) {
435 rv = -ESHUTDOWN;
436 goto out;
437 }
David Teiglande0c2a9a2012-01-09 17:18:05 -0500438
David Teigland1a058f52012-05-01 15:50:48 -0500439 rv = gfs2_recover_set(sdp, jid);
440out:
Steven Whitehousefe64d512009-05-19 10:01:18 +0100441 return rv ? rv : len;
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000442}
443
444static ssize_t recover_done_show(struct gfs2_sbd *sdp, char *buf)
445{
446 struct lm_lockstruct *ls = &sdp->sd_lockstruct;
447 return sprintf(buf, "%d\n", ls->ls_recover_jid_done);
448}
449
450static ssize_t recover_status_show(struct gfs2_sbd *sdp, char *buf)
451{
452 struct lm_lockstruct *ls = &sdp->sd_lockstruct;
453 return sprintf(buf, "%d\n", ls->ls_recover_jid_status);
454}
455
Steven Whitehousee1b28aa2009-05-26 15:41:27 +0100456static ssize_t jid_show(struct gfs2_sbd *sdp, char *buf)
457{
Steven Whitehousefeb47ca92010-09-29 15:04:18 +0100458 return sprintf(buf, "%d\n", sdp->sd_lockstruct.ls_jid);
Steven Whitehousee1b28aa2009-05-26 15:41:27 +0100459}
460
Steven Whitehouseba6e9362010-06-14 10:01:30 +0100461static ssize_t jid_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
462{
Steven Whitehousefeb47ca92010-09-29 15:04:18 +0100463 int jid;
Steven Whitehouseba6e9362010-06-14 10:01:30 +0100464 int rv;
465
Steven Whitehousefeb47ca92010-09-29 15:04:18 +0100466 rv = sscanf(buf, "%d", &jid);
Steven Whitehouseba6e9362010-06-14 10:01:30 +0100467 if (rv != 1)
468 return -EINVAL;
Steven Whitehouse3942ae52011-07-11 08:53:30 +0100469 rv = wait_for_completion_killable(&sdp->sd_locking_init);
470 if (rv)
471 return rv;
Steven Whitehouseba6e9362010-06-14 10:01:30 +0100472 spin_lock(&sdp->sd_jindex_spin);
473 rv = -EINVAL;
Steven Whitehouseba6e9362010-06-14 10:01:30 +0100474 if (sdp->sd_lockstruct.ls_ops->lm_mount == NULL)
475 goto out;
476 rv = -EBUSY;
Steven Whitehousefeb47ca92010-09-29 15:04:18 +0100477 if (test_bit(SDF_NOJOURNALID, &sdp->sd_flags) == 0)
Steven Whitehouseba6e9362010-06-14 10:01:30 +0100478 goto out;
Steven Whitehousefeb47ca92010-09-29 15:04:18 +0100479 rv = 0;
480 if (sdp->sd_args.ar_spectator && jid > 0)
481 rv = jid = -EINVAL;
Steven Whitehouseba6e9362010-06-14 10:01:30 +0100482 sdp->sd_lockstruct.ls_jid = jid;
Steven Whitehousefeb47ca92010-09-29 15:04:18 +0100483 clear_bit(SDF_NOJOURNALID, &sdp->sd_flags);
Steven Whitehouseba6e9362010-06-14 10:01:30 +0100484 smp_mb__after_clear_bit();
485 wake_up_bit(&sdp->sd_flags, SDF_NOJOURNALID);
Steven Whitehouseba6e9362010-06-14 10:01:30 +0100486out:
487 spin_unlock(&sdp->sd_jindex_spin);
488 return rv ? rv : len;
489}
490
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000491#define GDLM_ATTR(_name,_mode,_show,_store) \
Steven Whitehouse48c2b612009-05-13 14:49:48 +0100492static struct gfs2_attr gdlm_attr_##_name = __ATTR(_name,_mode,_show,_store)
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000493
Steven Whitehoused7e623d2009-08-11 11:20:11 +0100494GDLM_ATTR(proto_name, 0444, proto_name_show, NULL);
495GDLM_ATTR(block, 0644, block_show, block_store);
Steven Whitehousefd95e812013-02-13 12:21:40 +0000496GDLM_ATTR(withdraw, 0644, wdack_show, wdack_store);
Steven Whitehouseba6e9362010-06-14 10:01:30 +0100497GDLM_ATTR(jid, 0644, jid_show, jid_store);
498GDLM_ATTR(first, 0644, lkfirst_show, lkfirst_store);
Steven Whitehoused7e623d2009-08-11 11:20:11 +0100499GDLM_ATTR(first_done, 0444, first_done_show, NULL);
500GDLM_ATTR(recover, 0600, NULL, recover_store);
501GDLM_ATTR(recover_done, 0444, recover_done_show, NULL);
502GDLM_ATTR(recover_status, 0444, recover_status_show, NULL);
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000503
504static struct attribute *lock_module_attrs[] = {
505 &gdlm_attr_proto_name.attr,
506 &gdlm_attr_block.attr,
507 &gdlm_attr_withdraw.attr,
Steven Whitehousee1b28aa2009-05-26 15:41:27 +0100508 &gdlm_attr_jid.attr,
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000509 &gdlm_attr_first.attr,
510 &gdlm_attr_first_done.attr,
511 &gdlm_attr_recover.attr,
512 &gdlm_attr_recover_done.attr,
513 &gdlm_attr_recover_status.attr,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400514 NULL,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000515};
516
David Teiglandb3b94fa2006-01-16 16:50:04 +0000517/*
David Teiglandb3b94fa2006-01-16 16:50:04 +0000518 * get and set struct gfs2_tune fields
519 */
520
521static ssize_t quota_scale_show(struct gfs2_sbd *sdp, char *buf)
522{
David Teigland3204a6c2006-09-06 16:57:06 -0500523 return snprintf(buf, PAGE_SIZE, "%u %u\n",
524 sdp->sd_tune.gt_quota_scale_num,
525 sdp->sd_tune.gt_quota_scale_den);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000526}
527
528static ssize_t quota_scale_store(struct gfs2_sbd *sdp, const char *buf,
529 size_t len)
530{
531 struct gfs2_tune *gt = &sdp->sd_tune;
532 unsigned int x, y;
533
534 if (!capable(CAP_SYS_ADMIN))
Zhao Hongjiang41735812013-02-20 13:13:55 +1100535 return -EPERM;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000536
537 if (sscanf(buf, "%u %u", &x, &y) != 2 || !y)
538 return -EINVAL;
539
540 spin_lock(&gt->gt_spin);
541 gt->gt_quota_scale_num = x;
542 gt->gt_quota_scale_den = y;
543 spin_unlock(&gt->gt_spin);
544 return len;
545}
546
547static ssize_t tune_set(struct gfs2_sbd *sdp, unsigned int *field,
548 int check_zero, const char *buf, size_t len)
549{
550 struct gfs2_tune *gt = &sdp->sd_tune;
551 unsigned int x;
552
553 if (!capable(CAP_SYS_ADMIN))
Zhao Hongjiang41735812013-02-20 13:13:55 +1100554 return -EPERM;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000555
556 x = simple_strtoul(buf, NULL, 0);
557
558 if (check_zero && !x)
559 return -EINVAL;
560
561 spin_lock(&gt->gt_spin);
562 *field = x;
563 spin_unlock(&gt->gt_spin);
564 return len;
565}
566
David Teiglandb3b94fa2006-01-16 16:50:04 +0000567#define TUNE_ATTR_3(name, show, store) \
Steven Whitehouse48c2b612009-05-13 14:49:48 +0100568static struct gfs2_attr tune_attr_##name = __ATTR(name, 0644, show, store)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000569
570#define TUNE_ATTR_2(name, store) \
571static ssize_t name##_show(struct gfs2_sbd *sdp, char *buf) \
572{ \
David Teigland3204a6c2006-09-06 16:57:06 -0500573 return snprintf(buf, PAGE_SIZE, "%u\n", sdp->sd_tune.gt_##name); \
David Teiglandb3b94fa2006-01-16 16:50:04 +0000574} \
575TUNE_ATTR_3(name, name##_show, store)
576
577#define TUNE_ATTR(name, check_zero) \
578static ssize_t name##_store(struct gfs2_sbd *sdp, const char *buf, size_t len)\
579{ \
580 return tune_set(sdp, &sdp->sd_tune.gt_##name, check_zero, buf, len); \
581} \
582TUNE_ATTR_2(name, name##_store)
583
David Teiglandb3b94fa2006-01-16 16:50:04 +0000584TUNE_ATTR(quota_warn_period, 0);
585TUNE_ATTR(quota_quantum, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000586TUNE_ATTR(max_readahead, 0);
587TUNE_ATTR(complain_secs, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000588TUNE_ATTR(statfs_slow, 0);
589TUNE_ATTR(new_files_jdata, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000590TUNE_ATTR(statfs_quantum, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000591TUNE_ATTR_3(quota_scale, quota_scale_show, quota_scale_store);
592
593static struct attribute *tune_attrs[] = {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000594 &tune_attr_quota_warn_period.attr,
595 &tune_attr_quota_quantum.attr,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000596 &tune_attr_max_readahead.attr,
597 &tune_attr_complain_secs.attr,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000598 &tune_attr_statfs_slow.attr,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000599 &tune_attr_statfs_quantum.attr,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000600 &tune_attr_quota_scale.attr,
601 &tune_attr_new_files_jdata.attr,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400602 NULL,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000603};
604
David Teiglandb3b94fa2006-01-16 16:50:04 +0000605static struct attribute_group tune_group = {
606 .name = "tune",
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400607 .attrs = tune_attrs,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000608};
609
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000610static struct attribute_group lock_module_group = {
611 .name = "lock_module",
612 .attrs = lock_module_attrs,
613};
614
David Teiglandb3b94fa2006-01-16 16:50:04 +0000615int gfs2_sys_fs_add(struct gfs2_sbd *sdp)
616{
Steven Whitehouse440d6da2009-07-31 12:16:25 +0100617 struct super_block *sb = sdp->sd_vfs;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000618 int error;
Steven Whitehouse440d6da2009-07-31 12:16:25 +0100619 char ro[20];
620 char spectator[20];
621 char *envp[] = { ro, spectator, NULL };
Bob Peterson0d515212012-06-13 10:27:41 -0400622 int sysfs_frees_sdp = 0;
Steven Whitehouse440d6da2009-07-31 12:16:25 +0100623
624 sprintf(ro, "RDONLY=%d", (sb->s_flags & MS_RDONLY) ? 1 : 0);
625 sprintf(spectator, "SPECTATOR=%d", sdp->sd_args.ar_spectator ? 1 : 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000626
Greg Kroah-Hartman9bec1012007-10-29 20:13:17 +0100627 sdp->sd_kobj.kset = gfs2_kset;
Greg Kroah-Hartman901195e2007-12-17 15:54:39 -0400628 error = kobject_init_and_add(&sdp->sd_kobj, &gfs2_ktype, NULL,
629 "%s", sdp->sd_table_name);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000630 if (error)
Bob Peterson0d515212012-06-13 10:27:41 -0400631 goto fail_reg;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000632
Bob Peterson0d515212012-06-13 10:27:41 -0400633 sysfs_frees_sdp = 1; /* Freeing sdp is now done by sysfs calling
634 function gfs2_sbd_release. */
David Teiglandb3b94fa2006-01-16 16:50:04 +0000635 error = sysfs_create_group(&sdp->sd_kobj, &tune_group);
636 if (error)
Steven Whitehousef6eb5342009-05-26 15:50:25 +0100637 goto fail_reg;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000638
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000639 error = sysfs_create_group(&sdp->sd_kobj, &lock_module_group);
640 if (error)
641 goto fail_tune;
642
Steven Whitehouse31e54b02009-08-13 12:18:08 +0100643 error = sysfs_create_link(&sdp->sd_kobj,
644 &disk_to_dev(sb->s_bdev->bd_disk)->kobj,
645 "device");
646 if (error)
647 goto fail_lock_module;
648
Steven Whitehouse440d6da2009-07-31 12:16:25 +0100649 kobject_uevent_env(&sdp->sd_kobj, KOBJ_ADD, envp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000650 return 0;
651
Steven Whitehouse31e54b02009-08-13 12:18:08 +0100652fail_lock_module:
653 sysfs_remove_group(&sdp->sd_kobj, &lock_module_group);
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000654fail_tune:
655 sysfs_remove_group(&sdp->sd_kobj, &tune_group);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400656fail_reg:
Bob Peterson0d515212012-06-13 10:27:41 -0400657 free_percpu(sdp->sd_lkstats);
David Teigland65952fb2006-09-15 13:09:11 -0500658 fs_err(sdp, "error %d adding sysfs files", error);
Bob Peterson0d515212012-06-13 10:27:41 -0400659 if (sysfs_frees_sdp)
660 kobject_put(&sdp->sd_kobj);
661 else
662 kfree(sdp);
663 sb->s_fs_info = NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000664 return error;
665}
666
667void gfs2_sys_fs_del(struct gfs2_sbd *sdp)
668{
Steven Whitehouse31e54b02009-08-13 12:18:08 +0100669 sysfs_remove_link(&sdp->sd_kobj, "device");
David Teiglandb3b94fa2006-01-16 16:50:04 +0000670 sysfs_remove_group(&sdp->sd_kobj, &tune_group);
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000671 sysfs_remove_group(&sdp->sd_kobj, &lock_module_group);
Greg Kroah-Hartman197b12d2007-12-20 08:13:05 -0800672 kobject_put(&sdp->sd_kobj);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000673}
674
Steven Whitehousefdd10622008-11-26 10:26:38 +0000675static int gfs2_uevent(struct kset *kset, struct kobject *kobj,
676 struct kobj_uevent_env *env)
677{
678 struct gfs2_sbd *sdp = container_of(kobj, struct gfs2_sbd, sd_kobj);
Steven Whitehouse32e471e2011-05-10 15:01:59 +0100679 struct super_block *s = sdp->sd_vfs;
680 const u8 *uuid = s->s_uuid;
Steven Whitehouse02e3cc72009-02-10 13:48:30 +0000681
Steven Whitehousefdd10622008-11-26 10:26:38 +0000682 add_uevent_var(env, "LOCKTABLE=%s", sdp->sd_table_name);
683 add_uevent_var(env, "LOCKPROTO=%s", sdp->sd_proto_name);
Steven Whitehouseba6e9362010-06-14 10:01:30 +0100684 if (!test_bit(SDF_NOJOURNALID, &sdp->sd_flags))
Steven Whitehousefeb47ca92010-09-29 15:04:18 +0100685 add_uevent_var(env, "JOURNALID=%d", sdp->sd_lockstruct.ls_jid);
Joe Perchesf0b34ae2009-12-14 18:01:13 -0800686 if (gfs2_uuid_valid(uuid))
687 add_uevent_var(env, "UUID=%pUB", uuid);
Steven Whitehousefdd10622008-11-26 10:26:38 +0000688 return 0;
689}
690
Emese Revfy9cd43612009-12-31 14:52:51 +0100691static const struct kset_uevent_ops gfs2_uevent_ops = {
Steven Whitehousefdd10622008-11-26 10:26:38 +0000692 .uevent = gfs2_uevent,
693};
694
David Teiglandb3b94fa2006-01-16 16:50:04 +0000695int gfs2_sys_init(void)
696{
Steven Whitehousefdd10622008-11-26 10:26:38 +0000697 gfs2_kset = kset_create_and_add("gfs2", &gfs2_uevent_ops, fs_kobj);
Greg Kroah-Hartman9bec1012007-10-29 20:13:17 +0100698 if (!gfs2_kset)
699 return -ENOMEM;
700 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000701}
702
703void gfs2_sys_uninit(void)
704{
Greg Kroah-Hartman9bec1012007-10-29 20:13:17 +0100705 kset_unregister(gfs2_kset);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000706}
707