1 /* 2 * Copyright (c) 2003,2004 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Matthew Dillon <dillon@backplane.com> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * 3. Neither the name of The DragonFly Project nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific, prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * $DragonFly: src/sbin/mountctl/mountctl.c,v 1.10 2008/02/05 20:49:50 dillon Exp $ 35 */ 36 /* 37 * This utility implements the userland mountctl command which is used to 38 * manage high level journaling on mount points. 39 */ 40 41 #include <sys/types.h> 42 #include <sys/param.h> 43 #include <sys/ucred.h> 44 #include <sys/mount.h> 45 #include <sys/time.h> 46 #include <sys/mountctl.h> 47 #include <stdio.h> 48 #include <stdlib.h> 49 #include <fcntl.h> 50 #include <string.h> 51 #include <unistd.h> 52 #include <errno.h> 53 54 static void usage(void); 55 static void parse_option_keyword(const char *opt, 56 const char **wopt, const char **xopt); 57 static int64_t getsize(const char *str); 58 static const char *numtostr(int64_t num); 59 60 static int mountctl_scan(void (*func)(const char *, const char *, int, void *), 61 const char *keyword, const char *mountpt, int fd); 62 static void mountctl_list(const char *keyword, const char *mountpt, 63 int __unused fd, void *info); 64 static void mountctl_add(const char *keyword, const char *mountpt, int fd); 65 static void mountctl_restart(const char *keyword, const char *mountpt, 66 int fd, void __unused *); 67 static void mountctl_delete(const char *keyword, const char *mountpt, 68 int __unused fd, void __unused *); 69 static void mountctl_modify(const char *keyword, const char *mountpt, int fd, void __unused *); 70 71 /* 72 * For all options 0 means unspecified, -1 means noOPT or nonOPT, and a 73 * positive number indicates enabling or execution of the option. 74 */ 75 static int exitCode; 76 static int freeze_opt; 77 static int start_opt; 78 static int close_opt; 79 static int abort_opt; 80 static int flush_opt; 81 static int reversable_opt; 82 static int twoway_opt; 83 static int output_safety_override_opt; 84 static int64_t memfifo_opt; 85 static int64_t swapfifo_opt; 86 87 int 88 main(int ac, char **av) 89 { 90 int fd; 91 int ch; 92 int aopt = 0; 93 int dopt = 0; 94 int fopt = 0; 95 int lopt = 0; 96 int mopt = 0; 97 int ropt = 0; 98 int mimplied = 0; 99 const char *wopt = NULL; 100 const char *xopt = NULL; 101 const char *keyword = NULL; 102 const char *mountpt = NULL; 103 char *tmp; 104 105 while ((ch = getopt(ac, av, "2adflmo:rw:x:ACFSW:X:Z")) != -1) { 106 switch(ch) { 107 case '2': 108 twoway_opt = 1; 109 break; 110 case 'r': 111 ropt = 1; 112 if (aopt + dopt + lopt + mopt + ropt != 1) { 113 fprintf(stderr, "too many action options specified\n"); 114 usage(); 115 } 116 break; 117 case 'a': 118 aopt = 1; 119 if (aopt + dopt + lopt + mopt + ropt != 1) { 120 fprintf(stderr, "too many action options specified\n"); 121 usage(); 122 } 123 break; 124 case 'd': 125 dopt = 1; 126 if (aopt + dopt + lopt + mopt + ropt != 1) { 127 fprintf(stderr, "too many action options specified\n"); 128 usage(); 129 } 130 break; 131 case 'f': 132 fopt = 1; 133 break; 134 case 'l': 135 lopt = 1; 136 if (aopt + dopt + lopt + mopt + ropt != 1) { 137 fprintf(stderr, "too many action options specified\n"); 138 usage(); 139 } 140 break; 141 case 'o': 142 parse_option_keyword(optarg, &wopt, &xopt); 143 break; 144 case 'm': 145 mopt = 1; 146 if (aopt + dopt + lopt + mopt + ropt != 1) { 147 fprintf(stderr, "too many action options specified\n"); 148 usage(); 149 } 150 break; 151 case 'W': 152 output_safety_override_opt = 1; 153 /* fall through */ 154 case 'w': 155 wopt = optarg; 156 mimplied = 1; 157 break; 158 case 'X': 159 output_safety_override_opt = 1; 160 /* fall through */ 161 case 'x': 162 xopt = optarg; 163 mimplied = 1; 164 break; 165 case 'A': 166 mimplied = 1; 167 abort_opt = 1; 168 break; 169 case 'C': 170 mimplied = 1; 171 close_opt = 1; 172 break; 173 case 'F': 174 mimplied = 1; 175 flush_opt = 1; 176 break; 177 case 'S': 178 mimplied = 1; 179 start_opt = 1; 180 break; 181 case 'Z': 182 mimplied = 1; 183 freeze_opt = 1; 184 break; 185 default: 186 fprintf(stderr, "unknown option: -%c\n", optopt); 187 usage(); 188 } 189 } 190 ac -= optind; 191 av += optind; 192 193 /* 194 * Parse the keyword and/or mount point. 195 */ 196 switch(ac) { 197 case 0: 198 if (aopt || ropt) { 199 fprintf(stderr, "action requires a tag and/or mount " 200 "point to be specified\n"); 201 usage(); 202 } 203 break; 204 case 1: 205 if (av[0][0] == '/') { 206 mountpt = av[0]; 207 if ((keyword = strchr(mountpt, ':')) != NULL) { 208 ++keyword; 209 tmp = strdup(mountpt); 210 *strchr(tmp, ':') = 0; 211 mountpt = tmp; 212 } 213 } else { 214 keyword = av[0]; 215 } 216 break; 217 default: 218 fprintf(stderr, "unexpected extra arguments to command\n"); 219 usage(); 220 } 221 222 /* 223 * Additional sanity checks 224 */ 225 if (aopt + dopt + lopt + mopt + ropt + mimplied == 0) { 226 fprintf(stderr, "no action or implied action options were specified\n"); 227 usage(); 228 } 229 if (mimplied && aopt + dopt + lopt + ropt == 0) 230 mopt = 1; 231 if ((wopt || xopt) && !(aopt || ropt || mopt)) { 232 fprintf(stderr, "-w/-x/path/fd options may only be used with -m/-a/-r\n"); 233 usage(); 234 } 235 if (aopt && (keyword == NULL || mountpt == NULL)) { 236 fprintf(stderr, "a keyword AND a mountpt must be specified " 237 "when adding a journal\n"); 238 usage(); 239 } 240 if (fopt == 0 && mopt + dopt && keyword == NULL && mountpt == NULL) { 241 fprintf(stderr, "a keyword, a mountpt, or both must be specified " 242 "when modifying or deleting a journal, unless " 243 "-f is also specified for safety\n"); 244 usage(); 245 } 246 247 /* 248 * Open the journaling file descriptor if required. 249 */ 250 if (wopt && xopt) { 251 fprintf(stderr, "you must specify only one of -w/-x/path/fd\n"); 252 exit(1); 253 } else if (wopt) { 254 if ((fd = open(wopt, O_RDWR|O_CREAT|O_APPEND, 0666)) < 0) { 255 fprintf(stderr, "unable to create %s: %s\n", wopt, strerror(errno)); 256 exit(1); 257 } 258 } else if (xopt) { 259 fd = strtol(xopt, NULL, 0); 260 } else if (aopt || ropt) { 261 fd = 1; /* stdout default for -a */ 262 } else { 263 fd = -1; 264 } 265 266 /* 267 * And finally execute the core command. 268 */ 269 if (lopt) 270 mountctl_scan(mountctl_list, keyword, mountpt, fd); 271 if (aopt) 272 mountctl_add(keyword, mountpt, fd); 273 if (ropt) { 274 ch = mountctl_scan(mountctl_restart, keyword, mountpt, fd); 275 if (ch) 276 fprintf(stderr, "%d journals restarted\n", ch); 277 else 278 fprintf(stderr, "Unable to locate any matching journals\n"); 279 } 280 if (dopt) { 281 ch = mountctl_scan(mountctl_delete, keyword, mountpt, -1); 282 if (ch) 283 fprintf(stderr, "%d journals deleted\n", ch); 284 else 285 fprintf(stderr, "Unable to locate any matching journals\n"); 286 } 287 if (mopt) { 288 ch = mountctl_scan(mountctl_modify, keyword, mountpt, fd); 289 if (ch) 290 fprintf(stderr, "%d journals modified\n", ch); 291 else 292 fprintf(stderr, "Unable to locate any matching journals\n"); 293 } 294 295 return(exitCode); 296 } 297 298 static void 299 parse_option_keyword(const char *opt, const char **wopt, const char **xopt) 300 { 301 char *str = strdup(opt); 302 char *name; 303 char *val; 304 int negate; 305 int hasval; 306 int cannotnegate; 307 308 /* 309 * multiple comma delimited options may be specified. 310 */ 311 while ((name = strsep(&str, ",")) != NULL) { 312 /* 313 * some options have associated data. 314 */ 315 if ((val = strchr(name, '=')) != NULL) 316 *val++ = 0; 317 318 /* 319 * options beginning with 'no' or 'non' are negated. A positive 320 * number means not negated, a negative number means negated. 321 */ 322 negate = 1; 323 cannotnegate = 0; 324 hasval = 0; 325 if (strncmp(name, "non", 3) == 0) { 326 name += 3; 327 negate = -1; 328 } else if (strncmp(name, "no", 2) == 0) { 329 name += 2; 330 negate = -1; 331 } 332 333 /* 334 * Parse supported options 335 */ 336 if (strcmp(name, "undo") == 0) { 337 reversable_opt = negate; 338 } else if (strcmp(name, "reversable") == 0) { 339 reversable_opt = negate; 340 } else if (strcmp(name, "twoway") == 0) { 341 twoway_opt = negate; 342 } else if (strcmp(name, "memfifo") == 0) { 343 cannotnegate = 1; 344 hasval = 1; 345 if (val) { 346 if ((memfifo_opt = getsize(val)) == 0) 347 memfifo_opt = -1; 348 } 349 } else if (strcmp(name, "swapfifo") == 0) { 350 if (val) { 351 hasval = 1; 352 if ((swapfifo_opt = getsize(val)) == 0) 353 swapfifo_opt = -1; 354 } else if (negate < 0) { 355 swapfifo_opt = -1; 356 } else { 357 hasval = 1; /* force error */ 358 } 359 } else if (strcmp(name, "fd") == 0) { 360 cannotnegate = 1; 361 hasval = 1; 362 if (val) 363 *xopt = val; 364 } else if (strcmp(name, "path") == 0) { 365 cannotnegate = 1; 366 hasval = 1; 367 if (val) 368 *wopt = val; 369 } else if (strcmp(name, "freeze") == 0 || strcmp(name, "stop") == 0) { 370 if (negate < 0) 371 start_opt = -negate; 372 else 373 freeze_opt = negate; 374 } else if (strcmp(name, "start") == 0) { 375 if (negate < 0) 376 freeze_opt = -negate; 377 else 378 start_opt = negate; 379 } else if (strcmp(name, "close") == 0) { 380 close_opt = negate; 381 } else if (strcmp(name, "abort") == 0) { 382 abort_opt = negate; 383 } else if (strcmp(name, "flush") == 0) { 384 flush_opt = negate; 385 } else { 386 fprintf(stderr, "unknown option keyword: %s\n", name); 387 exit(1); 388 } 389 390 /* 391 * Sanity checks 392 */ 393 if (cannotnegate && negate < 0) { 394 fprintf(stderr, "option %s may not be negated\n", name); 395 exit(1); 396 } 397 if (hasval && val == NULL) { 398 fprintf(stderr, "option %s requires assigned data\n", name); 399 exit(1); 400 } 401 if (hasval == 0 && val) { 402 fprintf(stderr, "option %s does not take an assignment\n", name); 403 exit(1); 404 } 405 406 } 407 } 408 409 static int 410 mountctl_scan(void (*func)(const char *, const char *, int, void *), 411 const char *keyword, const char *mountpt, int fd) 412 { 413 struct statfs *sfs; 414 int count; 415 int calls; 416 int i; 417 struct mountctl_status_journal statreq; 418 struct mountctl_journal_ret_status rstat[4]; /* BIG */ 419 420 calls = 0; 421 if (mountpt) { 422 bzero(&statreq, sizeof(statreq)); 423 if (keyword) { 424 statreq.index = MC_JOURNAL_INDEX_ID; 425 count = strlen(keyword); 426 if (count > JIDMAX) 427 count = JIDMAX; 428 bcopy(keyword, statreq.id, count); 429 } else { 430 statreq.index = MC_JOURNAL_INDEX_ALL; 431 } 432 count = mountctl(mountpt, MOUNTCTL_STATUS_VFS_JOURNAL, -1, 433 &statreq, sizeof(statreq), &rstat, sizeof(rstat)); 434 if (count > 0 && rstat[0].recsize != sizeof(rstat[0])) { 435 fprintf(stderr, "Unable to access status, " 436 "structure size mismatch\n"); 437 exit(1); 438 } 439 if (count > 0) { 440 count /= sizeof(rstat[0]); 441 for (i = 0; i < count; ++i) { 442 func(rstat[i].id, mountpt, fd, &rstat[i]); 443 ++calls; 444 } 445 } 446 } else { 447 if ((count = getmntinfo(&sfs, MNT_WAIT)) > 0) { 448 for (i = 0; i < count; ++i) { 449 calls += mountctl_scan(func, keyword, sfs[i].f_mntonname, fd); 450 } 451 } else if (count < 0) { 452 /* XXX */ 453 } 454 } 455 return(calls); 456 } 457 458 static void 459 mountctl_list(const char *keyword __unused, const char *mountpt, 460 int fd __unused, void *info) 461 { 462 struct mountctl_journal_ret_status *rstat = info; 463 464 printf("%s:%s\n", mountpt, rstat->id[0] ? rstat->id : "<NOID>"); 465 printf(" membufsize=%s\n", numtostr(rstat->membufsize)); 466 printf(" membufused=%s\n", numtostr(rstat->membufused)); 467 printf(" membufunacked=%s\n", numtostr(rstat->membufunacked)); 468 printf(" total_bytes=%s\n", numtostr(rstat->bytessent)); 469 printf(" fifo_stalls=%jd\n", (intmax_t)rstat->fifostalls); 470 } 471 472 static void 473 mountctl_add(const char *keyword, const char *mountpt, int fd) 474 { 475 struct mountctl_install_journal joinfo; 476 struct stat st1; 477 struct stat st2; 478 int error; 479 480 /* 481 * Make sure the file descriptor is not on the same filesystem as the 482 * mount point. This isn't a perfect test, but it should catch most 483 * foot shooting. 484 */ 485 if (output_safety_override_opt == 0 && 486 fstat(fd, &st1) == 0 && S_ISREG(st1.st_mode) && 487 stat(mountpt, &st2) == 0 && st1.st_dev == st2.st_dev 488 ) { 489 fprintf(stderr, "%s:%s failed to add, the journal cannot be on the " 490 "same filesystem being journaled!\n", 491 mountpt, keyword); 492 exitCode = 1; 493 return; 494 } 495 496 /* 497 * Setup joinfo and issue the add 498 */ 499 bzero(&joinfo, sizeof(joinfo)); 500 snprintf(joinfo.id, sizeof(joinfo.id), "%s", keyword); 501 if (memfifo_opt > 0) 502 joinfo.membufsize = memfifo_opt; 503 if (twoway_opt > 0) 504 joinfo.flags |= MC_JOURNAL_WANT_FULLDUPLEX; 505 if (reversable_opt > 0) 506 joinfo.flags |= MC_JOURNAL_WANT_REVERSABLE; 507 508 error = mountctl(mountpt, MOUNTCTL_INSTALL_VFS_JOURNAL, fd, 509 &joinfo, sizeof(joinfo), NULL, 0); 510 if (error == 0) { 511 fprintf(stderr, "%s:%s added\n", mountpt, joinfo.id); 512 } else { 513 fprintf(stderr, "%s:%s failed to add, error %s\n", mountpt, joinfo.id, strerror(errno)); 514 exitCode = 1; 515 } 516 } 517 518 static void 519 mountctl_restart(const char *keyword, const char *mountpt, 520 int fd, void __unused *info) 521 { 522 struct mountctl_restart_journal joinfo; 523 int error; 524 525 /* XXX make sure descriptor is not on same filesystem as journal */ 526 527 bzero(&joinfo, sizeof(joinfo)); 528 529 snprintf(joinfo.id, sizeof(joinfo.id), "%s", keyword); 530 if (twoway_opt > 0) 531 joinfo.flags |= MC_JOURNAL_WANT_FULLDUPLEX; 532 if (reversable_opt > 0) 533 joinfo.flags |= MC_JOURNAL_WANT_REVERSABLE; 534 535 error = mountctl(mountpt, MOUNTCTL_RESTART_VFS_JOURNAL, fd, 536 &joinfo, sizeof(joinfo), NULL, 0); 537 if (error == 0) { 538 fprintf(stderr, "%s:%s restarted\n", mountpt, joinfo.id); 539 } else { 540 fprintf(stderr, "%s:%s restart failed, error %s\n", mountpt, joinfo.id, strerror(errno)); 541 } 542 } 543 544 static void 545 mountctl_delete(const char *keyword, const char *mountpt, 546 int __unused fd, void __unused *info) 547 { 548 struct mountctl_remove_journal joinfo; 549 int error; 550 551 bzero(&joinfo, sizeof(joinfo)); 552 snprintf(joinfo.id, sizeof(joinfo.id), "%s", keyword); 553 error = mountctl(mountpt, MOUNTCTL_REMOVE_VFS_JOURNAL, -1, 554 &joinfo, sizeof(joinfo), NULL, 0); 555 if (error == 0) { 556 fprintf(stderr, "%s:%s deleted\n", mountpt, joinfo.id); 557 } else { 558 fprintf(stderr, "%s:%s deletion failed, error %s\n", mountpt, joinfo.id, strerror(errno)); 559 } 560 } 561 562 static void 563 mountctl_modify(const char *keyword __unused, const char *mountpt __unused, 564 int fd __unused, void *info __unused) 565 { 566 fprintf(stderr, "modify not yet implemented\n"); 567 } 568 569 570 static void 571 usage(void) 572 { 573 printf( 574 "usage: mountctl -l {mountpt | tag | mountpt:tag}\n" 575 " mountctl -a [-2] [-w/W output_path] [-x/X filedesc]\n" 576 " [-o options] mountpt:tag\n" 577 " mountctl -r [-2] [-w/W output_path] [-x/X filedesc] mountpt:tag\n" 578 " mountctl -d {mountpt | tag | mountpt:tag}\n" 579 " mountctl -m [-o options] {mountpt | tag | mountpt:tag}\n" 580 " mountctl -FZSCA {mountpt | tag | mountpt:tag}\n" 581 ); 582 exit(1); 583 } 584 585 static int64_t 586 getsize(const char *str) 587 { 588 char *suffix; 589 int64_t val; 590 591 val = strtoll(str, &suffix, 0); 592 if (suffix) { 593 switch(*suffix) { 594 case 'b': 595 break; 596 case 't': 597 val *= 1024; 598 /* fall through */ 599 case 'g': 600 val *= 1024; 601 /* fall through */ 602 case 'm': 603 val *= 1024; 604 /* fall through */ 605 case 'k': 606 val *= 1024; 607 /* fall through */ 608 break; 609 default: 610 fprintf(stderr, "data value '%s' has unknown suffix\n", str); 611 exit(1); 612 } 613 } 614 return(val); 615 } 616 617 static const char * 618 numtostr(int64_t num) 619 { 620 static char buf[64]; 621 622 if (num < 1024) 623 snprintf(buf, sizeof(buf), "%jd", (intmax_t)num); 624 else if (num < 10 * 1024) 625 snprintf(buf, sizeof(buf), "%3.2fK", num / 1024.0); 626 else if (num < 1024 * 1024) 627 snprintf(buf, sizeof(buf), "%3.0fK", num / 1024.0); 628 else if (num < 10 * 1024 * 1024) 629 snprintf(buf, sizeof(buf), "%3.2fM", num / (1024.0 * 1024.0)); 630 else if (num < 1024 * 1024 * 1024) 631 snprintf(buf, sizeof(buf), "%3.0fM", num / (1024.0 * 1024.0)); 632 else if (num < 10LL * 1024 * 1024 * 1024) 633 snprintf(buf, sizeof(buf), "%3.2fG", num / (1024.0 * 1024.0 * 1024.0)); 634 else 635 snprintf(buf, sizeof(buf), "%3.0fG", num / (1024.0 * 1024.0 * 1024.0)); 636 return(buf); 637 } 638 639