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_spin); 573 gt->gt_quota_scale_num = x; 574 gt->gt_quota_scale_den = y; 575 spin_unlock(>->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_spin); 597 *field = x; 598 spin_unlock(>->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 743