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