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, "%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_spin); 572 gt->gt_quota_scale_num = x; 573 gt->gt_quota_scale_den = y; 574 spin_unlock(>->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_spin); 596 *field = x; 597 spin_unlock(>->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 742