1 /* vinum.c: vinum interface program */ 2 /*- 3 * Copyright (c) 1997, 1998 4 * Nan Yang Computer Services Limited. All rights reserved. 5 * 6 * Written by Greg Lehey 7 * 8 * This software is distributed under the so-called ``Berkeley 9 * License'': 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. Neither the name of the Company nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * This software is provided ``as is'', and any express or implied 24 * warranties, including, but not limited to, the implied warranties of 25 * merchantability and fitness for a particular purpose are disclaimed. 26 * In no event shall the company or contributors be liable for any 27 * direct, indirect, incidental, special, exemplary, or consequential 28 * damages (including, but not limited to, procurement of substitute 29 * goods or services; loss of use, data, or profits; or business 30 * interruption) however caused and on any theory of liability, whether 31 * in contract, strict liability, or tort (including negligence or 32 * otherwise) arising in any way out of the use of this software, even if 33 * advised of the possibility of such damage. 34 * 35 * $Id: v.c,v 1.31 2000/09/03 01:29:26 grog Exp grog $ 36 * $FreeBSD: src/sbin/vinum/v.c,v 1.26.2.3 2001/03/13 03:04:06 grog Exp $ 37 * $DragonFly: src/sbin/vinum/v.c,v 1.5 2007/01/20 19:20:39 dillon Exp $ 38 */ 39 40 #include <ctype.h> 41 #include <errno.h> 42 #include <fcntl.h> 43 #include <sys/mman.h> 44 #include <netdb.h> 45 #include <setjmp.h> 46 #include <signal.h> 47 #include <stdio.h> 48 #include <stdlib.h> 49 #include <string.h> 50 #include <syslog.h> 51 #include <unistd.h> 52 #include <sys/ioctl.h> 53 #include <dev/raid/vinum/vinumhdr.h> 54 #include "vext.h" 55 #include <sys/types.h> 56 #include <sys/wait.h> 57 #include <readline/history.h> 58 #include <readline/readline.h> 59 #include <sys/linker.h> 60 #include <sys/module.h> 61 #include <sys/resource.h> 62 63 FILE *cf; /* config file handle */ 64 FILE *history; /* history file */ 65 char *historyfile; /* and its name */ 66 67 char *dateformat; /* format in which to store date */ 68 69 char buffer[BUFSIZE]; /* buffer to read in to */ 70 71 int line = 0; /* stdin line number for error messages */ 72 int file_line = 0; /* and line in input file (yes, this is tacky) */ 73 int inerror; /* set to 1 to exit after end of config file */ 74 75 /* flags */ 76 77 #if VINUMDEBUG 78 int debug = 0; /* debug flag, usage varies */ 79 #endif 80 int force = 0; /* set to 1 to force some dangerous ops */ 81 int interval = 0; /* interval in ms between init/revive */ 82 int vflag = 0; /* set verbose operation or verify */ 83 int Verbose = 0; /* set very verbose operation */ 84 int recurse = 0; /* set recursion */ 85 int sflag = 0; /* show statistics */ 86 int SSize = 0; /* sector size for revive */ 87 int dowait = 0; /* wait for completion */ 88 char *objectname; /* name to be passed for -n flag */ 89 90 /* Structures to read kernel data into */ 91 struct _vinum_conf vinum_conf; /* configuration information */ 92 93 struct volume vol; 94 struct plex plex; 95 struct sd sd; 96 struct drive drive; 97 98 jmp_buf command_fail; /* return on a failed command */ 99 int superdev; /* vinum super device */ 100 101 void start_daemon(void); 102 103 #define ofs(x) ((void *) (& ((struct confdata *) 0)->x)) /* offset of x in struct confdata */ 104 105 char *token[MAXARGS]; /* pointers to individual tokens */ 106 int tokens; /* number of tokens */ 107 108 int 109 main(int argc, char *argv[], char *envp[]) 110 { 111 struct stat histstat; 112 113 if (modfind(VINUMMOD) < 0) { 114 /* need to load the vinum module */ 115 if (kldload(VINUMMOD) < 0 || modfind(VINUMMOD) < 0) { 116 perror(VINUMMOD ": Kernel module not available"); 117 return 1; 118 } 119 } 120 dateformat = getenv("VINUM_DATEFORMAT"); 121 if (dateformat == NULL) 122 dateformat = "%e %b %Y %H:%M:%S"; 123 historyfile = getenv("VINUM_HISTORY"); 124 if (historyfile == NULL) 125 historyfile = DEFAULT_HISTORYFILE; 126 if (stat(historyfile, &histstat) == 0) { /* history file exists */ 127 if ((histstat.st_mode & S_IFMT) != S_IFREG) { 128 fprintf(stderr, 129 "Vinum history file %s must be a regular file\n", 130 historyfile); 131 exit(1); 132 } 133 } else if ((errno != ENOENT) /* not "not there", */ 134 &&(errno != EROFS)) { /* and not read-only file system */ 135 fprintf(stderr, 136 "Can't open %s: %s (%d)\n", 137 historyfile, 138 strerror(errno), 139 errno); 140 exit(1); 141 } 142 history = fopen(historyfile, "a+"); 143 if (history != NULL) { 144 timestamp(); 145 fprintf(history, "*** " VINUMMOD " started ***\n"); 146 fflush(history); /* before we start the daemon */ 147 } 148 superdev = open(VINUM_SUPERDEV_NAME, O_RDWR); /* open vinum superdevice */ 149 if (superdev < 0) { /* no go */ 150 if (errno == ENODEV) { /* not configured, */ 151 superdev = open(VINUM_WRONGSUPERDEV_NAME, O_RDWR); /* do we have a debug mismatch? */ 152 if (superdev >= 0) { /* yup! */ 153 #if VINUMDEBUG 154 fprintf(stderr, 155 "This program is compiled with debug support, but the kernel module does\n" 156 "not have debug support. This program must be matched with the kernel\n" 157 "module. Please alter /usr/src/sbin/" VINUMMOD "/Makefile and remove\n" 158 "the option -DVINUMDEBUG from the CFLAGS definition, or alternatively\n" 159 "edit /usr/src/sys/modules/" VINUMMOD "/Makefile and add the option\n" 160 "-DVINUMDEBUG to the CFLAGS definition. Then rebuild the component\n" 161 "of your choice with 'make clean all install'. If you rebuild the kernel\n" 162 "module, you must stop " VINUMMOD " and restart it\n"); 163 #else 164 fprintf(stderr, 165 "This program is compiled without debug support, but the kernel module\n" 166 "includes debug support. This program must be matched with the kernel\n" 167 "module. Please alter /usr/src/sbin/" VINUMMOD "/Makefile and add\n" 168 "the option -DVINUMDEBUG to the CFLAGS definition, or alternatively\n" 169 "edit /usr/src/sys/modules/" VINUMMOD "/Makefile and remove the option\n" 170 "-DVINUMDEBUG from the CFLAGS definition. Then rebuild the component\n" 171 "of your choice with 'make clean all install'. If you rebuild the kernel\n" 172 "module, you must stop " VINUMMOD " and restart it\n"); 173 #endif 174 return 1; 175 } 176 } else if (errno == ENOENT) /* we don't have our node, */ 177 make_devices(); /* create them first */ 178 if (superdev < 0) { 179 perror("Can't open " VINUM_SUPERDEV_NAME); 180 return 1; 181 } 182 } 183 /* Check if the d�mon is running. If not, start it in the 184 * background */ 185 start_daemon(); 186 187 if (argc > 1) { /* we have a command on the line */ 188 if (setjmp(command_fail) != 0) /* long jumped out */ 189 return -1; 190 parseline(argc - 1, &argv[1]); /* do it */ 191 } else { 192 /* 193 * Catch a possible race condition which could cause us to 194 * longjmp() into nowhere if we receive a SIGINT in the next few 195 * lines. 196 */ 197 if (setjmp(command_fail)) /* come back here on catastrophic failure */ 198 return 1; 199 setsigs(); /* set signal handler */ 200 for (;;) { /* ugh */ 201 char *c; 202 int childstatus; /* from wait4 */ 203 204 if (setjmp(command_fail) == 2) /* come back here on catastrophic failure */ 205 fprintf(stderr, "*** interrupted ***\n"); /* interrupted */ 206 207 while (wait4(-1, &childstatus, WNOHANG, NULL) > 0); /* wait for all dead children */ 208 c = readline(VINUMMOD " -> "); /* get an input */ 209 if (c == NULL) { /* EOF or error */ 210 if (ferror(stdin)) { 211 fprintf(stderr, "Can't read input: %s (%d)\n", strerror(errno), errno); 212 return 1; 213 } else { /* EOF */ 214 printf("\n"); 215 return 0; 216 } 217 } else if (*c) { /* got something there */ 218 add_history(c); /* save it in the history */ 219 strcpy(buffer, c); /* put it where we can munge it */ 220 free(c); 221 line++; /* count the lines */ 222 tokens = tokenize(buffer, token); 223 /* got something potentially worth parsing */ 224 if (tokens) 225 parseline(tokens, token); /* and do what he says */ 226 } 227 if (history) 228 fflush(history); 229 } 230 } 231 return 0; /* normal completion */ 232 } 233 234 /* stop the hard way */ 235 void 236 vinum_quit(int argc, char *argv[], char *argv0[]) 237 { 238 exit(0); 239 } 240 241 /* Set action on receiving a SIGINT */ 242 void 243 setsigs(void) 244 { 245 struct sigaction act; 246 247 act.sa_handler = catchsig; 248 act.sa_flags = 0; 249 sigemptyset(&act.sa_mask); 250 sigaction(SIGINT, &act, NULL); 251 } 252 253 void 254 catchsig(int ignore) 255 { 256 longjmp(command_fail, 2); 257 } 258 259 #define FUNKEY(x) { kw_##x, &vinum_##x } /* create pair "kw_foo", vinum_foo */ 260 #define vinum_move vinum_mv /* synonym for 'mv' */ 261 262 struct funkey { 263 enum keyword kw; 264 void (*fun) (int argc, char *argv[], char *arg0[]); 265 } funkeys[] = { 266 267 FUNKEY(create), 268 FUNKEY(read), 269 #ifdef VINUMDEBUG 270 FUNKEY(debug), 271 #endif 272 FUNKEY(modify), 273 FUNKEY(list), 274 FUNKEY(ld), 275 FUNKEY(ls), 276 FUNKEY(lp), 277 FUNKEY(lv), 278 FUNKEY(info), 279 FUNKEY(set), 280 FUNKEY(init), 281 FUNKEY(label), 282 FUNKEY(resetconfig), 283 FUNKEY(rm), 284 FUNKEY(mv), 285 FUNKEY(move), 286 FUNKEY(attach), 287 FUNKEY(detach), 288 FUNKEY(rename), 289 FUNKEY(replace), 290 FUNKEY(printconfig), 291 FUNKEY(saveconfig), 292 FUNKEY(start), 293 FUNKEY(stop), 294 FUNKEY(makedev), 295 FUNKEY(help), 296 FUNKEY(quit), 297 FUNKEY(concat), 298 FUNKEY(stripe), 299 FUNKEY(raid4), 300 FUNKEY(raid5), 301 FUNKEY(mirror), 302 FUNKEY(setdaemon), 303 FUNKEY(readpol), 304 FUNKEY(resetstats), 305 FUNKEY(setstate), 306 FUNKEY(checkparity), 307 FUNKEY(rebuildparity), 308 FUNKEY(dumpconfig) 309 }; 310 311 /* Take args arguments at argv and attempt to perform the operation specified */ 312 void 313 parseline(int args, char *argv[]) 314 { 315 int i; 316 int j; 317 enum keyword command; /* command to execute */ 318 319 if (history != NULL) { /* save the command to history file */ 320 timestamp(); 321 for (i = 0; i < args; i++) /* all args */ 322 fprintf(history, "%s ", argv[i]); 323 fputs("\n", history); 324 } 325 if ((args == 0) /* empty line */ 326 ||(*argv[0] == '#')) /* or a comment, */ 327 return; 328 if (args == MAXARGS) { /* too many arguments, */ 329 fprintf(stderr, "Too many arguments to %s, this can't be right\n", argv[0]); 330 return; 331 } 332 command = get_keyword(argv[0], &keyword_set); 333 dowait = 0; /* initialize flags */ 334 force = 0; /* initialize flags */ 335 vflag = 0; /* initialize flags */ 336 Verbose = 0; /* initialize flags */ 337 recurse = 0; /* initialize flags */ 338 sflag = 0; /* initialize flags */ 339 objectname = NULL; /* no name yet */ 340 341 /* 342 * first handle generic options 343 * We don't use getopt(3) because 344 * getopt doesn't allow merging flags 345 * (for example, -fr). 346 */ 347 for (i = 1; (i < args) && (argv[i][0] == '-'); i++) { /* while we have flags */ 348 for (j = 1; j < strlen(argv[i]); j++) 349 switch (argv[i][j]) { 350 #if VINUMDEBUG 351 case 'd': /* -d: debug */ 352 debug = 1; 353 break; 354 #endif 355 356 case 'f': /* -f: force */ 357 force = 1; 358 break; 359 360 case 'i': /* interval */ 361 interval = 0; 362 if (argv[i][j + 1] != '\0') /* operand follows, */ 363 interval = atoi(&argv[i][j + 1]); /* use it */ 364 else if (args > (i + 1)) /* another following, */ 365 interval = atoi(argv[++i]); /* use it */ 366 if (interval == 0) /* nothing valid, */ 367 fprintf(stderr, "-i: no interval specified\n"); 368 break; 369 370 case 'n': /* -n: get name */ 371 if (i == args - 1) { /* last arg */ 372 fprintf(stderr, "-n requires a name parameter\n"); 373 return; 374 } 375 objectname = argv[++i]; /* pick it up */ 376 j = strlen(argv[i]); /* skip the next parm */ 377 break; 378 379 case 'r': /* -r: recurse */ 380 recurse = 1; 381 break; 382 383 case 's': /* -s: show statistics */ 384 sflag = 1; 385 break; 386 387 case 'S': 388 SSize = 0; 389 if (argv[i][j + 1] != '\0') /* operand follows, */ 390 SSize = atoi(&argv[i][j + 1]); /* use it */ 391 else if (args > (i + 1)) /* another following, */ 392 SSize = atoi(argv[++i]); /* use it */ 393 if (SSize == 0) /* nothing valid, */ 394 fprintf(stderr, "-S: no size specified\n"); 395 break; 396 397 case 'v': /* -v: verbose */ 398 vflag++; 399 break; 400 401 case 'V': /* -V: Very verbose */ 402 vflag++; 403 Verbose++; 404 break; 405 406 case 'w': /* -w: wait for completion */ 407 dowait = 1; 408 break; 409 410 default: 411 fprintf(stderr, "Invalid flag: %s\n", argv[i]); 412 } 413 } 414 415 /* Pass what we have left to the command to handle it */ 416 for (j = 0; j < (sizeof(funkeys) / sizeof(struct funkey)); j++) { 417 if (funkeys[j].kw == command) { /* found the command */ 418 funkeys[j].fun(args - i, &argv[i], &argv[0]); 419 return; 420 } 421 } 422 fprintf(stderr, "Unknown command: %s\n", argv[0]); 423 } 424 425 void 426 get_drive_info(struct drive *drive, int index) 427 { 428 *(int *) drive = index; /* put in drive to hand to driver */ 429 if (ioctl(superdev, VINUM_DRIVECONFIG, drive) < 0) { 430 fprintf(stderr, 431 "Can't get config for drive %d: %s\n", 432 index, 433 strerror(errno)); 434 longjmp(command_fail, -1); 435 } 436 } 437 438 void 439 get_sd_info(struct sd *sd, int index) 440 { 441 *(int *) sd = index; /* put in sd to hand to driver */ 442 if (ioctl(superdev, VINUM_SDCONFIG, sd) < 0) { 443 fprintf(stderr, 444 "Can't get config for subdisk %d: %s\n", 445 index, 446 strerror(errno)); 447 longjmp(command_fail, -1); 448 } 449 } 450 451 /* Get the contents of the sd entry for subdisk <sdno> 452 * of the specified plex. */ 453 void 454 get_plex_sd_info(struct sd *sd, int plexno, int sdno) 455 { 456 ((int *) sd)[0] = plexno; 457 ((int *) sd)[1] = sdno; /* pass parameters */ 458 if (ioctl(superdev, VINUM_PLEXSDCONFIG, sd) < 0) { 459 fprintf(stderr, 460 "Can't get config for subdisk %d (part of plex %d): %s\n", 461 sdno, 462 plexno, 463 strerror(errno)); 464 longjmp(command_fail, -1); 465 } 466 } 467 468 void 469 get_plex_info(struct plex *plex, int index) 470 { 471 *(int *) plex = index; /* put in plex to hand to driver */ 472 if (ioctl(superdev, VINUM_PLEXCONFIG, plex) < 0) { 473 fprintf(stderr, 474 "Can't get config for plex %d: %s\n", 475 index, 476 strerror(errno)); 477 longjmp(command_fail, -1); 478 } 479 } 480 481 void 482 get_volume_info(struct volume *volume, int index) 483 { 484 *(int *) volume = index; /* put in volume to hand to driver */ 485 if (ioctl(superdev, VINUM_VOLCONFIG, volume) < 0) { 486 fprintf(stderr, 487 "Can't get config for volume %d: %s\n", 488 index, 489 strerror(errno)); 490 longjmp(command_fail, -1); 491 } 492 } 493 494 struct drive * 495 find_drive_by_devname(char *name) 496 { 497 int driveno; 498 499 if (ioctl(superdev, VINUM_GETCONFIG, &vinum_conf) < 0) { 500 perror("Can't get vinum config"); 501 return NULL; 502 } 503 for (driveno = 0; driveno < vinum_conf.drives_allocated; driveno++) { 504 get_drive_info(&drive, driveno); 505 if ((drive.state != drive_unallocated) /* real drive */ 506 &&(!strcmp(drive.devicename, name))) /* and the name's right, */ 507 return &drive; /* found it */ 508 } 509 return NULL; /* no drive of that name */ 510 } 511 512 /* Create the device nodes for vinum objects */ 513 void 514 make_devices(void) 515 { 516 int volno; 517 int plexno; 518 int sdno; 519 int driveno; 520 521 if (access("/dev", W_OK) < 0) { /* can't access /dev to write? */ 522 if (errno == EROFS) /* because it's read-only, */ 523 fprintf(stderr, VINUMMOD ": /dev is mounted read-only, not rebuilding " VINUM_DIR "\n"); 524 else 525 perror(VINUMMOD ": Can't write to /dev"); 526 return; 527 } 528 if (history) { 529 timestamp(); 530 fprintf(history, "*** Created devices ***\n"); 531 } 532 if (superdev >= 0) /* super device open */ 533 close(superdev); 534 535 system("rm -rf " VINUM_DIR); /* remove the old directories */ 536 system("mkdir -p " VINUM_DIR "/drive " /* and make them again */ 537 VINUM_DIR "/plex " 538 VINUM_DIR "/sd " 539 VINUM_DIR "/vol"); 540 541 if (mknod(VINUM_SUPERDEV_NAME, 542 S_IRUSR | S_IWUSR | S_IFCHR, /* user only */ 543 makedev(VINUM_CDEV_MAJOR, VINUM_SUPERDEV)) < 0) 544 fprintf(stderr, "Can't create %s: %s\n", VINUM_SUPERDEV_NAME, strerror(errno)); 545 546 if (mknod(VINUM_WRONGSUPERDEV_NAME, 547 S_IRUSR | S_IWUSR | S_IFCHR, /* user only */ 548 makedev(VINUM_CDEV_MAJOR, VINUM_WRONGSUPERDEV)) < 0) 549 fprintf(stderr, "Can't create %s: %s\n", VINUM_WRONGSUPERDEV_NAME, strerror(errno)); 550 551 superdev = open(VINUM_SUPERDEV_NAME, O_RDWR); /* open the super device */ 552 553 if (mknod(VINUM_DAEMON_DEV_NAME, /* daemon super device */ 554 S_IRUSR | S_IWUSR | S_IFCHR, /* user only */ 555 makedev(VINUM_CDEV_MAJOR, VINUM_DAEMON_DEV)) < 0) 556 fprintf(stderr, "Can't create %s: %s\n", VINUM_DAEMON_DEV_NAME, strerror(errno)); 557 558 if (ioctl(superdev, VINUM_GETCONFIG, &vinum_conf) < 0) { 559 perror("Can't get vinum config"); 560 return; 561 } 562 for (volno = 0; volno < vinum_conf.volumes_allocated; volno++) 563 make_vol_dev(volno, 0); 564 565 for (plexno = 0; plexno < vinum_conf.plexes_allocated; plexno++) 566 make_plex_dev(plexno, 0); 567 568 for (sdno = 0; sdno < vinum_conf.subdisks_allocated; sdno++) 569 make_sd_dev(sdno); 570 571 /* Drives. Do this later (both logical and physical names) XXX */ 572 for (driveno = 0; driveno < vinum_conf.drives_allocated; driveno++) { 573 char filename[PATH_MAX]; /* for forming file names */ 574 575 get_drive_info(&drive, driveno); 576 if (drive.state > drive_referenced) { 577 sprintf(filename, "ln -s %s " VINUM_DIR "/drive/%s", drive.devicename, drive.label.name); 578 system(filename); 579 } 580 } 581 } 582 583 /* make the devices for a volume */ 584 void 585 make_vol_dev(int volno, int recurse) 586 { 587 dev_t voldev; 588 char filename[PATH_MAX]; /* for forming file names */ 589 int plexno; 590 591 get_volume_info(&vol, volno); 592 if (vol.state != volume_unallocated) { /* we could have holes in our lists */ 593 voldev = VINUMDEV(volno, 0, 0, VINUM_VOLUME_TYPE); /* create a device number */ 594 595 /* Create /dev/vinum/<myvol> */ 596 sprintf(filename, VINUM_DIR "/%s", vol.name); 597 if (mknod(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IFCHR, voldev) < 0) 598 fprintf(stderr, "Can't create %s: %s\n", filename, strerror(errno)); 599 600 /* Create /dev/vinum/vol/<myvol> */ 601 sprintf(filename, VINUM_DIR "/vol/%s", vol.name); 602 if (mknod(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IFCHR, voldev) < 0) 603 fprintf(stderr, "Can't create %s: %s\n", filename, strerror(errno)); 604 605 if (vol.plexes > 0) { 606 /* Create /dev/vinum/vol/<myvol>.plex/ */ 607 sprintf(filename, VINUM_DIR "/vol/%s.plex", vol.name); 608 if (mkdir(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IXOTH) < 0) 609 fprintf(stderr, "Can't create %s: %s\n", filename, strerror(errno)); 610 } 611 if (recurse) 612 for (plexno = 0; plexno < vol.plexes; plexno++) 613 make_plex_dev(plex.plexno, recurse); 614 } 615 } 616 617 /* 618 * Create device entries for the plexes in 619 * /dev/vinum/<vol>.plex/ and /dev/vinum/plex. 620 */ 621 void 622 make_plex_dev(int plexno, int recurse) 623 { 624 dev_t plexdev; /* device */ 625 char filename[PATH_MAX]; /* for forming file names */ 626 int sdno; 627 628 get_plex_info(&plex, plexno); 629 if (plex.state != plex_unallocated) { 630 plexdev = VINUM_PLEX(plexno); 631 632 /* /dev/vinum/plex/<plex> */ 633 sprintf(filename, VINUM_DIR "/plex/%s", plex.name); 634 if (mknod(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IFCHR, plexdev) < 0) 635 fprintf(stderr, "Can't create %s: %s\n", filename, strerror(errno)); 636 637 if (plex.volno >= 0) { 638 get_volume_info(&vol, plex.volno); 639 plexdev = VINUMDEV(plex.volno, plexno, 0, VINUM_PLEX_TYPE); 640 641 /* Create device /dev/vinum/vol/<vol>.plex/<plex> */ 642 sprintf(filename, VINUM_DIR "/vol/%s.plex/%s", vol.name, plex.name); 643 if (mknod(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IFCHR, plexdev) < 0) 644 fprintf(stderr, "Can't create %s: %s\n", filename, strerror(errno)); 645 646 /* Create directory /dev/vinum/vol/<vol>.plex/<plex>.sd */ 647 sprintf(filename, VINUM_DIR "/vol/%s.plex/%s.sd", vol.name, plex.name); 648 if (mkdir(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IXOTH) < 0) 649 fprintf(stderr, "Can't create %s: %s\n", filename, strerror(errno)); 650 } 651 if (recurse) { 652 for (sdno = 0; sdno < plex.subdisks; sdno++) { 653 get_plex_sd_info(&sd, plex.plexno, sdno); 654 make_sd_dev(sd.sdno); 655 } 656 } 657 } 658 } 659 660 /* Create the contents of /dev/vinum/sd and /dev/vinum/rsd */ 661 void 662 make_sd_dev(int sdno) 663 { 664 dev_t sddev; /* device */ 665 char filename[PATH_MAX]; /* for forming file names */ 666 667 get_sd_info(&sd, sdno); 668 if (sd.state != sd_unallocated) { 669 sddev = VINUM_SD(sdno); 670 671 /* /dev/vinum/sd/<sd> */ 672 sprintf(filename, VINUM_DIR "/sd/%s", sd.name); 673 if (mknod(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IFCHR, sddev) < 0) 674 fprintf(stderr, "Can't create %s: %s\n", filename, strerror(errno)); 675 } 676 } 677 678 679 /* command line interface for the 'makedev' command */ 680 void 681 vinum_makedev(int argc, char *argv[], char *arg0[]) 682 { 683 make_devices(); 684 } 685 686 /* 687 * Find the object "name". Return object type at type, 688 * and the index as the return value. 689 * If not found, return -1 and invalid_object. 690 */ 691 int 692 find_object(const char *name, enum objecttype *type) 693 { 694 int object; 695 696 if (ioctl(superdev, VINUM_GETCONFIG, &vinum_conf) < 0) { 697 perror("Can't get vinum config"); 698 *type = invalid_object; 699 return -1; 700 } 701 /* Search the drive table */ 702 for (object = 0; object < vinum_conf.drives_allocated; object++) { 703 get_drive_info(&drive, object); 704 if (strcmp(name, drive.label.name) == 0) { 705 *type = drive_object; 706 return object; 707 } 708 } 709 710 /* Search the subdisk table */ 711 for (object = 0; object < vinum_conf.subdisks_allocated; object++) { 712 get_sd_info(&sd, object); 713 if (strcmp(name, sd.name) == 0) { 714 *type = sd_object; 715 return object; 716 } 717 } 718 719 /* Search the plex table */ 720 for (object = 0; object < vinum_conf.plexes_allocated; object++) { 721 get_plex_info(&plex, object); 722 if (strcmp(name, plex.name) == 0) { 723 *type = plex_object; 724 return object; 725 } 726 } 727 728 /* Search the volume table */ 729 for (object = 0; object < vinum_conf.volumes_allocated; object++) { 730 get_volume_info(&vol, object); 731 if (strcmp(name, vol.name) == 0) { 732 *type = volume_object; 733 return object; 734 } 735 } 736 737 /* Didn't find the name: invalid */ 738 *type = invalid_object; 739 return -1; 740 } 741 742 /* Continue reviving a subdisk in the background */ 743 void 744 continue_revive(int sdno) 745 { 746 struct sd sd; 747 pid_t pid; 748 get_sd_info(&sd, sdno); 749 750 if (dowait == 0) 751 pid = fork(); /* do this in the background */ 752 else 753 pid = 0; 754 if (pid == 0) { /* we're the child */ 755 struct _ioctl_reply reply; 756 struct vinum_ioctl_msg *message = (struct vinum_ioctl_msg *) &reply; 757 758 openlog(VINUMMOD, LOG_CONS | LOG_PERROR | LOG_PID, LOG_KERN); 759 syslog(LOG_INFO | LOG_KERN, "reviving %s", sd.name); 760 setproctitle("reviving %s", sd.name); 761 762 for (reply.error = EAGAIN; reply.error == EAGAIN;) { /* revive the subdisk */ 763 if (interval) 764 usleep(interval * 1000); /* pause between each copy */ 765 message->index = sdno; /* pass sd number */ 766 message->type = sd_object; /* and type of object */ 767 message->state = object_up; 768 if (SSize != 0) { /* specified a size for init */ 769 if (SSize < 512) 770 SSize <<= DEV_BSHIFT; 771 message->blocksize = SSize; 772 } else 773 message->blocksize = DEFAULT_REVIVE_BLOCKSIZE; 774 ioctl(superdev, VINUM_SETSTATE, message); 775 } 776 if (reply.error) { 777 syslog(LOG_ERR | LOG_KERN, 778 "can't revive %s: %s", 779 sd.name, 780 reply.msg[0] ? reply.msg : strerror(reply.error)); 781 if (dowait == 0) 782 exit(1); 783 } else { 784 get_sd_info(&sd, sdno); /* update the info */ 785 syslog(LOG_INFO | LOG_KERN, "%s is %s", sd.name, sd_state(sd.state)); 786 if (dowait == 0) 787 exit(0); 788 } 789 } else if (pid < 0) /* couldn't fork? */ 790 fprintf(stderr, "Can't continue reviving %s: %s\n", sd.name, strerror(errno)); 791 else /* parent */ 792 printf("Reviving %s in the background\n", sd.name); 793 } 794 795 /* 796 * Check if the daemon is running, 797 * start it if it isn't. The check itself 798 * could take a while, so we do it as a separate 799 * process, which will become the daemon if one isn't 800 * running already 801 */ 802 void 803 start_daemon(void) 804 { 805 int pid; 806 int status; 807 int error; 808 809 pid = (int) fork(); 810 811 if (pid == 0) { /* We're the child, do the work */ 812 /* 813 * We have a problem when stopping the subsystem: 814 * The only way to know that we're idle is when 815 * all open superdevs close. But we want the 816 * daemon to clean up for us, and since we can't 817 * count the opens, we need to have the main device 818 * closed when we stop. We solve this conundrum 819 * by getting the daemon to open a separate device. 820 */ 821 close(superdev); /* this is the wrong device */ 822 superdev = open(VINUM_DAEMON_DEV_NAME, O_RDWR); /* open deamon superdevice */ 823 if (superdev < 0) { 824 perror("Can't open " VINUM_DAEMON_DEV_NAME); 825 exit(1); 826 } 827 error = daemon(0, 0); /* this will fork again, but who's counting? */ 828 if (error != 0) { 829 fprintf(stderr, "Can't start daemon: %s (%d)\n", strerror(errno), errno); 830 exit(1); 831 } 832 setproctitle(VINUMMOD " daemon"); /* show what we're doing */ 833 status = ioctl(superdev, VINUM_FINDDAEMON, NULL); 834 if (status != 0) { /* no daemon, */ 835 ioctl(superdev, VINUM_DAEMON, &vflag); /* we should hang here */ 836 syslog(LOG_ERR | LOG_KERN, "%s", strerror(errno)); 837 exit(1); 838 } 839 exit(0); /* when told to die */ 840 } else if (pid < 0) /* couldn't fork */ 841 printf("Can't fork to check daemon\n"); 842 } 843 844 void 845 timestamp(void) 846 { 847 struct timeval now; 848 struct tm *date; 849 char datetext[MAXDATETEXT]; 850 time_t sec; 851 852 if (history != NULL) { 853 if (gettimeofday(&now, NULL) != 0) { 854 fprintf(stderr, "Can't get time: %s\n", strerror(errno)); 855 return; 856 } 857 sec = now.tv_sec; 858 date = localtime(&sec); 859 strftime(datetext, MAXDATETEXT, dateformat, date), 860 fprintf(history, 861 "%s.%06ld ", 862 datetext, 863 now.tv_usec); 864 } 865 } 866