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