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