fs/gfs2/sys.c

   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, "%u\n", frozen);
 100 }
 101
 102 static ssize_t freeze_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
 103 {
 104         int error;
 105         int n = simple_strtol(buf, NULL, 0);
 106
 107         if (!capable(CAP_SYS_ADMIN))
 108                 return -EPERM;
 109
 110         switch (n) {
 111         case 0:
 112                 error = thaw_super(sdp->sd_vfs);
 113                 break;
 114         case 1:
 115                 error = freeze_super(sdp->sd_vfs);
 116                 break;
 117         default:
 118                 return -EINVAL;
 119         }
 120
 121         if (error) {
 122                 fs_warn(sdp, "freeze %d error %d", n, error);
 123                 return error;
 124         }
 125
 126         return len;
 127 }
 128
 129 static ssize_t withdraw_show(struct gfs2_sbd *sdp, char *buf)
 130 {
 131         unsigned int b = test_bit(SDF_SHUTDOWN, &sdp->sd_flags);
 132         return snprintf(buf, PAGE_SIZE, "%u\n", b);
 133 }
 134
 135 static ssize_t withdraw_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
 136 {
 137         if (!capable(CAP_SYS_ADMIN))
 138                 return -EPERM;
 139
 140         if (simple_strtol(buf, NULL, 0) != 1)
 141                 return -EINVAL;
 142
 143         gfs2_lm_withdraw(sdp,
 144                 "GFS2: fsid=%s: withdrawing from cluster at user's request\n",
 145                 sdp->sd_fsname);
 146         return len;
 147 }
 148
 149 static ssize_t statfs_sync_store(struct gfs2_sbd *sdp, const char *buf,
 150                                  size_t len)
 151 {
 152         if (!capable(CAP_SYS_ADMIN))
 153                 return -EPERM;
 154
 155         if (simple_strtol(buf, NULL, 0) != 1)
 156                 return -EINVAL;
 157
 158         gfs2_statfs_sync(sdp->sd_vfs, 0);
 159         return len;
 160 }
 161
 162 static ssize_t quota_sync_store(struct gfs2_sbd *sdp, const char *buf,
 163                                 size_t len)
 164 {
 165         if (!capable(CAP_SYS_ADMIN))
 166                 return -EPERM;
 167
 168         if (simple_strtol(buf, NULL, 0) != 1)
 169                 return -EINVAL;
 170
 171         gfs2_quota_sync(sdp->sd_vfs, 0);
 172         return len;
 173 }
 174
 175 static ssize_t quota_refresh_user_store(struct gfs2_sbd *sdp, const char *buf,
 176                                         size_t len)
 177 {
 178         struct kqid qid;
 179         int error;
 180         u32 id;
 181
 182         if (!capable(CAP_SYS_ADMIN))
 183                 return -EPERM;
 184
 185         id = simple_strtoul(buf, NULL, 0);
 186
 187         qid = make_kqid(current_user_ns(), USRQUOTA, id);
 188         if (!qid_valid(qid))
 189                 return -EINVAL;
 190
 191         error = gfs2_quota_refresh(sdp, qid);
 192         return error ? error : len;
 193 }
 194
 195 static ssize_t quota_refresh_group_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         id = simple_strtoul(buf, NULL, 0);
 206
 207         qid = make_kqid(current_user_ns(), GRPQUOTA, id);
 208         if (!qid_valid(qid))
 209                 return -EINVAL;
 210
 211         error = gfs2_quota_refresh(sdp, qid);
 212         return error ? error : len;
 213 }
 214
 215 static ssize_t demote_rq_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
 216 {
 217         struct gfs2_glock *gl;
 218         const struct gfs2_glock_operations *glops;
 219         unsigned int glmode;
 220         unsigned int gltype;
 221         unsigned long long glnum;
 222         char mode[16];
 223         int rv;
 224
 225         if (!capable(CAP_SYS_ADMIN))
 226                 return -EPERM;
 227
 228         rv = sscanf(buf, "%u:%llu %15s", &gltype, &glnum,
 229                     mode);
 230         if (rv != 3)
 231                 return -EINVAL;
 232
 233         if (strcmp(mode, "EX") == 0)
 234                 glmode = LM_ST_UNLOCKED;
 235         else if ((strcmp(mode, "CW") == 0) || (strcmp(mode, "DF") == 0))
 236                 glmode = LM_ST_DEFERRED;
 237         else if ((strcmp(mode, "PR") == 0) || (strcmp(mode, "SH") == 0))
 238                 glmode = LM_ST_SHARED;
 239         else
 240                 return -EINVAL;
 241
 242         if (gltype > LM_TYPE_JOURNAL)
 243                 return -EINVAL;
 244         if (gltype == LM_TYPE_NONDISK && glnum == GFS2_TRANS_LOCK)
 245                 glops = &gfs2_trans_glops;
 246         else
 247                 glops = gfs2_glops_list[gltype];
 248         if (glops == NULL)
 249                 return -EINVAL;
 250         if (!test_and_set_bit(SDF_DEMOTE, &sdp->sd_flags))
 251                 fs_info(sdp, "demote interface used\n");
 252         rv = gfs2_glock_get(sdp, glnum, glops, 0, &gl);
 253         if (rv)
 254                 return rv;
 255         gfs2_glock_cb(gl, glmode);
 256         gfs2_glock_put(gl);
 257         return len;
 258 }
 259
 260
 261 #define GFS2_ATTR(name, mode, show, store) \
 262 static struct gfs2_attr gfs2_attr_##name = __ATTR(name, mode, show, store)
 263
 264 GFS2_ATTR(id,                  0444, id_show,       NULL);
 265 GFS2_ATTR(fsname,              0444, fsname_show,   NULL);
 266 GFS2_ATTR(uuid,                0444, uuid_show,     NULL);
 267 GFS2_ATTR(freeze,              0644, freeze_show,   freeze_store);
 268 GFS2_ATTR(withdraw,            0644, withdraw_show, withdraw_store);
 269 GFS2_ATTR(statfs_sync,         0200, NULL,          statfs_sync_store);
 270 GFS2_ATTR(quota_sync,          0200, NULL,          quota_sync_store);
 271 GFS2_ATTR(quota_refresh_user,  0200, NULL,          quota_refresh_user_store);
 272 GFS2_ATTR(quota_refresh_group, 0200, NULL,          quota_refresh_group_store);
 273 GFS2_ATTR(demote_rq,           0200, NULL,          demote_rq_store);
 274
 275 static struct attribute *gfs2_attrs[] = {
 276         &gfs2_attr_id.attr,
 277         &gfs2_attr_fsname.attr,
 278         &gfs2_attr_uuid.attr,
 279         &gfs2_attr_freeze.attr,
 280         &gfs2_attr_withdraw.attr,
 281         &gfs2_attr_statfs_sync.attr,
 282         &gfs2_attr_quota_sync.attr,
 283         &gfs2_attr_quota_refresh_user.attr,
 284         &gfs2_attr_quota_refresh_group.attr,
 285         &gfs2_attr_demote_rq.attr,
 286         NULL,
 287 };
 288
 289 static void gfs2_sbd_release(struct kobject *kobj)
 290 {
 291         struct gfs2_sbd *sdp = container_of(kobj, struct gfs2_sbd, sd_kobj);
 292
 293         kfree(sdp);
 294 }
 295
 296 static struct kobj_type gfs2_ktype = {
 297         .release = gfs2_sbd_release,
 298         .default_attrs = gfs2_attrs,
 299         .sysfs_ops     = &gfs2_attr_ops,
 300 };
 301
 302
 303 /*
 304  * lock_module. Originally from lock_dlm
 305  */
 306
 307 static ssize_t proto_name_show(struct gfs2_sbd *sdp, char *buf)
 308 {
 309         const struct lm_lockops *ops = sdp->sd_lockstruct.ls_ops;
 310         return sprintf(buf, "%s\n", ops->lm_proto_name);
 311 }
 312
 313 static ssize_t block_show(struct gfs2_sbd *sdp, char *buf)
 314 {
 315         struct lm_lockstruct *ls = &sdp->sd_lockstruct;
 316         ssize_t ret;
 317         int val = 0;
 318
 319         if (test_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags))
 320                 val = 1;
 321         ret = sprintf(buf, "%d\n", val);
 322         return ret;
 323 }
 324
 325 static ssize_t block_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
 326 {
 327         struct lm_lockstruct *ls = &sdp->sd_lockstruct;
 328         ssize_t ret = len;
 329         int val;
 330
 331         val = simple_strtol(buf, NULL, 0);
 332
 333         if (val == 1)
 334                 set_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags);
 335         else if (val == 0) {
 336                 clear_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags);
 337                 smp_mb__after_clear_bit();
 338                 gfs2_glock_thaw(sdp);
 339         } else {
 340                 ret = -EINVAL;
 341         }
 342         return ret;
 343 }
 344
 345 static ssize_t wdack_show(struct gfs2_sbd *sdp, char *buf)
 346 {
 347         int val = completion_done(&sdp->sd_wdack) ? 1 : 0;
 348
 349         return sprintf(buf, "%d\n", val);
 350 }
 351
 352 static ssize_t wdack_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
 353 {
 354         ssize_t ret = len;
 355         int val;
 356
 357         val = simple_strtol(buf, NULL, 0);
 358
 359         if ((val == 1) &&
 360             !strcmp(sdp->sd_lockstruct.ls_ops->lm_proto_name, "lock_dlm"))
 361                 complete(&sdp->sd_wdack);
 362         else
 363                 ret = -EINVAL;
 364         return ret;
 365 }
 366
 367 static ssize_t lkfirst_show(struct gfs2_sbd *sdp, char *buf)
 368 {
 369         struct lm_lockstruct *ls = &sdp->sd_lockstruct;
 370         return sprintf(buf, "%d\n", ls->ls_first);
 371 }
 372
 373 static ssize_t lkfirst_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
 374 {
 375         unsigned first;
 376         int rv;
 377
 378         rv = sscanf(buf, "%u", &first);
 379         if (rv != 1 || first > 1)
 380                 return -EINVAL;
 381         rv = wait_for_completion_killable(&sdp->sd_locking_init);
 382         if (rv)
 383                 return rv;
 384         spin_lock(&sdp->sd_jindex_spin);
 385         rv = -EBUSY;
 386         if (test_bit(SDF_NOJOURNALID, &sdp->sd_flags) == 0)
 387                 goto out;
 388         rv = -EINVAL;
 389         if (sdp->sd_args.ar_spectator)
 390                 goto out;
 391         if (sdp->sd_lockstruct.ls_ops->lm_mount == NULL)
 392                 goto out;
 393         sdp->sd_lockstruct.ls_first = first;
 394         rv = 0;
 395 out:
 396         spin_unlock(&sdp->sd_jindex_spin);
 397         return rv ? rv : len;
 398 }
 399
 400 static ssize_t first_done_show(struct gfs2_sbd *sdp, char *buf)
 401 {
 402         struct lm_lockstruct *ls = &sdp->sd_lockstruct;
 403         return sprintf(buf, "%d\n", !!test_bit(DFL_FIRST_MOUNT_DONE, &ls->ls_recover_flags));
 404 }
 405
 406 int gfs2_recover_set(struct gfs2_sbd *sdp, unsigned jid)
 407 {
 408         struct gfs2_jdesc *jd;
 409         int rv;
 410
 411         spin_lock(&sdp->sd_jindex_spin);
 412         rv = -EBUSY;
 413         if (sdp->sd_jdesc->jd_jid == jid)
 414                 goto out;
 415         rv = -ENOENT;
 416         list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
 417                 if (jd->jd_jid != jid)
 418                         continue;
 419                 rv = gfs2_recover_journal(jd, false);
 420                 break;
 421         }
 422 out:
 423         spin_unlock(&sdp->sd_jindex_spin);
 424         return rv;
 425 }
 426
 427 static ssize_t recover_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
 428 {
 429         unsigned jid;
 430         int rv;
 431
 432         rv = sscanf(buf, "%u", &jid);
 433         if (rv != 1)
 434                 return -EINVAL;
 435
 436         if (test_bit(SDF_NORECOVERY, &sdp->sd_flags)) {
 437                 rv = -ESHUTDOWN;
 438                 goto out;
 439         }
 440
 441         rv = gfs2_recover_set(sdp, jid);
 442 out:
 443         return rv ? rv : len;
 444 }
 445
 446 static ssize_t recover_done_show(struct gfs2_sbd *sdp, char *buf)
 447 {
 448         struct lm_lockstruct *ls = &sdp->sd_lockstruct;
 449         return sprintf(buf, "%d\n", ls->ls_recover_jid_done);
 450 }
 451
 452 static ssize_t recover_status_show(struct gfs2_sbd *sdp, char *buf)
 453 {
 454         struct lm_lockstruct *ls = &sdp->sd_lockstruct;
 455         return sprintf(buf, "%d\n", ls->ls_recover_jid_status);
 456 }
 457
 458 static ssize_t jid_show(struct gfs2_sbd *sdp, char *buf)
 459 {
 460         return sprintf(buf, "%d\n", sdp->sd_lockstruct.ls_jid);
 461 }
 462
 463 static ssize_t jid_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
 464 {
 465         int jid;
 466         int rv;
 467
 468         rv = sscanf(buf, "%d", &jid);
 469         if (rv != 1)
 470                 return -EINVAL;
 471         rv = wait_for_completion_killable(&sdp->sd_locking_init);
 472         if (rv)
 473                 return rv;
 474         spin_lock(&sdp->sd_jindex_spin);
 475         rv = -EINVAL;
 476         if (sdp->sd_lockstruct.ls_ops->lm_mount == NULL)
 477                 goto out;
 478         rv = -EBUSY;
 479         if (test_bit(SDF_NOJOURNALID, &sdp->sd_flags) == 0)
 480                 goto out;
 481         rv = 0;
 482         if (sdp->sd_args.ar_spectator && jid > 0)
 483                 rv = jid = -EINVAL;
 484         sdp->sd_lockstruct.ls_jid = jid;
 485         clear_bit(SDF_NOJOURNALID, &sdp->sd_flags);
 486         smp_mb__after_clear_bit();
 487         wake_up_bit(&sdp->sd_flags, SDF_NOJOURNALID);
 488 out:
 489         spin_unlock(&sdp->sd_jindex_spin);
 490         return rv ? rv : len;
 491 }
 492
 493 #define GDLM_ATTR(_name,_mode,_show,_store) \
 494 static struct gfs2_attr gdlm_attr_##_name = __ATTR(_name,_mode,_show,_store)
 495
 496 GDLM_ATTR(proto_name,           0444, proto_name_show,          NULL);
 497 GDLM_ATTR(block,                0644, block_show,               block_store);
 498 GDLM_ATTR(withdraw,             0644, wdack_show,               wdack_store);
 499 GDLM_ATTR(jid,                  0644, jid_show,                 jid_store);
 500 GDLM_ATTR(first,                0644, lkfirst_show,             lkfirst_store);
 501 GDLM_ATTR(first_done,           0444, first_done_show,          NULL);
 502 GDLM_ATTR(recover,              0600, NULL,                     recover_store);
 503 GDLM_ATTR(recover_done,         0444, recover_done_show,        NULL);
 504 GDLM_ATTR(recover_status,       0444, recover_status_show,      NULL);
 505
 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 /*
 520  * get and set struct gfs2_tune fields
 521  */
 522
 523 static ssize_t quota_scale_show(struct gfs2_sbd *sdp, char *buf)
 524 {
 525         return snprintf(buf, PAGE_SIZE, "%u %u\n",
 526                         sdp->sd_tune.gt_quota_scale_num,
 527                         sdp->sd_tune.gt_quota_scale_den);
 528 }
 529
 530 static ssize_t quota_scale_store(struct gfs2_sbd *sdp, const char *buf,
 531                                  size_t len)
 532 {
 533         struct gfs2_tune *gt = &sdp->sd_tune;
 534         unsigned int x, y;
 535
 536         if (!capable(CAP_SYS_ADMIN))
 537                 return -EPERM;
 538
 539         if (sscanf(buf, "%u %u", &x, &y) != 2 || !y)
 540                 return -EINVAL;
 541
 542         spin_lock(&gt->gt_spin);
 543         gt->gt_quota_scale_num = x;
 544         gt->gt_quota_scale_den = y;
 545         spin_unlock(&gt->gt_spin);
 546         return len;
 547 }
 548
 549 static ssize_t tune_set(struct gfs2_sbd *sdp, unsigned int *field,
 550                         int check_zero, const char *buf, size_t len)
 551 {
 552         struct gfs2_tune *gt = &sdp->sd_tune;
 553         unsigned int x;
 554
 555         if (!capable(CAP_SYS_ADMIN))
 556                 return -EPERM;
 557
 558         x = simple_strtoul(buf, NULL, 0);
 559
 560         if (check_zero && !x)
 561                 return -EINVAL;
 562
 563         spin_lock(&gt->gt_spin);
 564         *field = x;
 565         spin_unlock(&gt->gt_spin);
 566         return len;
 567 }
 568
 569 #define TUNE_ATTR_3(name, show, store)                                        \
 570 static struct gfs2_attr tune_attr_##name = __ATTR(name, 0644, show, store)
 571
 572 #define TUNE_ATTR_2(name, store)                                              \
 573 static ssize_t name##_show(struct gfs2_sbd *sdp, char *buf)                   \
 574 {                                                                             \
 575         return snprintf(buf, PAGE_SIZE, "%u\n", sdp->sd_tune.gt_##name);      \
 576 }                                                                             \
 577 TUNE_ATTR_3(name, name##_show, store)
 578
 579 #define TUNE_ATTR(name, check_zero)                                           \
 580 static ssize_t name##_store(struct gfs2_sbd *sdp, const char *buf, size_t len)\
 581 {                                                                             \
 582         return tune_set(sdp, &sdp->sd_tune.gt_##name, check_zero, buf, len);  \
 583 }                                                                             \
 584 TUNE_ATTR_2(name, name##_store)
 585
 586 TUNE_ATTR(quota_warn_period, 0);
 587 TUNE_ATTR(quota_quantum, 0);
 588 TUNE_ATTR(max_readahead, 0);
 589 TUNE_ATTR(complain_secs, 0);
 590 TUNE_ATTR(statfs_slow, 0);
 591 TUNE_ATTR(new_files_jdata, 0);
 592 TUNE_ATTR(statfs_quantum, 1);
 593 TUNE_ATTR_3(quota_scale, quota_scale_show, quota_scale_store);
 594
 595 static struct attribute *tune_attrs[] = {
 596         &tune_attr_quota_warn_period.attr,
 597         &tune_attr_quota_quantum.attr,
 598         &tune_attr_max_readahead.attr,
 599         &tune_attr_complain_secs.attr,
 600         &tune_attr_statfs_slow.attr,
 601         &tune_attr_statfs_quantum.attr,
 602         &tune_attr_quota_scale.attr,
 603         &tune_attr_new_files_jdata.attr,
 604         NULL,
 605 };
 606
 607 static struct attribute_group tune_group = {
 608         .name = "tune",
 609         .attrs = tune_attrs,
 610 };
 611
 612 static struct attribute_group lock_module_group = {
 613         .name = "lock_module",
 614         .attrs = lock_module_attrs,
 615 };
 616
 617 int gfs2_sys_fs_add(struct gfs2_sbd *sdp)
 618 {
 619         struct super_block *sb = sdp->sd_vfs;
 620         int error;
 621         char ro[20];
 622         char spectator[20];
 623         char *envp[] = { ro, spectator, NULL };
 624         int sysfs_frees_sdp = 0;
 625
 626         sprintf(ro, "RDONLY=%d", (sb->s_flags & MS_RDONLY) ? 1 : 0);
 627         sprintf(spectator, "SPECTATOR=%d", sdp->sd_args.ar_spectator ? 1 : 0);
 628
 629         sdp->sd_kobj.kset = gfs2_kset;
 630         error = kobject_init_and_add(&sdp->sd_kobj, &gfs2_ktype, NULL,
 631                                      "%s", sdp->sd_table_name);
 632         if (error)
 633                 goto fail_reg;
 634
 635         sysfs_frees_sdp = 1; /* Freeing sdp is now done by sysfs calling
 636                                 function gfs2_sbd_release. */
 637         error = sysfs_create_group(&sdp->sd_kobj, &tune_group);
 638         if (error)
 639                 goto fail_reg;
 640
 641         error = sysfs_create_group(&sdp->sd_kobj, &lock_module_group);
 642         if (error)
 643                 goto fail_tune;
 644
 645         error = sysfs_create_link(&sdp->sd_kobj,
 646                                   &disk_to_dev(sb->s_bdev->bd_disk)->kobj,
 647                                   "device");
 648         if (error)
 649                 goto fail_lock_module;
 650
 651         kobject_uevent_env(&sdp->sd_kobj, KOBJ_ADD, envp);
 652         return 0;
 653
 654 fail_lock_module:
 655         sysfs_remove_group(&sdp->sd_kobj, &lock_module_group);
 656 fail_tune:
 657         sysfs_remove_group(&sdp->sd_kobj, &tune_group);
 658 fail_reg:
 659         free_percpu(sdp->sd_lkstats);
 660         fs_err(sdp, "error %d adding sysfs files", error);
 661         if (sysfs_frees_sdp)
 662                 kobject_put(&sdp->sd_kobj);
 663         else
 664                 kfree(sdp);
 665         sb->s_fs_info = NULL;
 666         return error;
 667 }
 668
 669 void gfs2_sys_fs_del(struct gfs2_sbd *sdp)
 670 {
 671         sysfs_remove_link(&sdp->sd_kobj, "device");
 672         sysfs_remove_group(&sdp->sd_kobj, &tune_group);
 673         sysfs_remove_group(&sdp->sd_kobj, &lock_module_group);
 674         kobject_put(&sdp->sd_kobj);
 675 }
 676
 677 static int gfs2_uevent(struct kset *kset, struct kobject *kobj,
 678                        struct kobj_uevent_env *env)
 679 {
 680         struct gfs2_sbd *sdp = container_of(kobj, struct gfs2_sbd, sd_kobj);
 681         struct super_block *s = sdp->sd_vfs;
 682         const u8 *uuid = s->s_uuid;
 683
 684         add_uevent_var(env, "LOCKTABLE=%s", sdp->sd_table_name);
 685         add_uevent_var(env, "LOCKPROTO=%s", sdp->sd_proto_name);
 686         if (!test_bit(SDF_NOJOURNALID, &sdp->sd_flags))
 687                 add_uevent_var(env, "JOURNALID=%d", sdp->sd_lockstruct.ls_jid);
 688         if (gfs2_uuid_valid(uuid))
 689                 add_uevent_var(env, "UUID=%pUB", uuid);
 690         return 0;
 691 }
 692
 693 static const struct kset_uevent_ops gfs2_uevent_ops = {
 694         .uevent = gfs2_uevent,
 695 };
 696
 697 int gfs2_sys_init(void)
 698 {
 699         gfs2_kset = kset_create_and_add("gfs2", &gfs2_uevent_ops, fs_kobj);
 700         if (!gfs2_kset)
 701                 return -ENOMEM;
 702         return 0;
 703 }
 704
 705 void gfs2_sys_uninit(void)
 706 {
 707         kset_unregister(gfs2_kset);
 708 }
 709