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