sbin/vinum/list.c

   1 /*      list.c: vinum interface program, list routines
   2  */
   3 /*-
   4  * Copyright (c) 1997, 1998
   5  *      Nan Yang Computer Services Limited.  All rights reserved.
   6  *
   7  *  Parts copyright (c) 1997, 1998 Cybernet Corporation, NetMAX project.
   8  *
   9  *  Written by Greg Lehey
  10  *
  11  *  This software is distributed under the so-called ``Berkeley
  12  *  License'':
  13  *
  14  * Redistribution and use in source and binary forms, with or without
  15  * modification, are permitted provided that the following conditions
  16  * are met:
  17  * 1. Redistributions of source code must retain the above copyright
  18  *    notice, this list of conditions and the following disclaimer.
  19  * 2. Redistributions in binary form must reproduce the above copyright
  20  *    notice, this list of conditions and the following disclaimer in the
  21  *    documentation and/or other materials provided with the distribution.
  22  * 3. Neither the name of the Company nor the names of its contributors
  23  *    may be used to endorse or promote products derived from this software
  24  *    without specific prior written permission.
  25  *
  26  * This software is provided ``as is'', and any express or implied
  27  * warranties, including, but not limited to, the implied warranties of
  28  * merchantability and fitness for a particular purpose are disclaimed.
  29  * In no event shall the company or contributors be liable for any
  30  * direct, indirect, incidental, special, exemplary, or consequential
  31  * damages (including, but not limited to, procurement of substitute
  32  * goods or services; loss of use, data, or profits; or business
  33  * interruption) however caused and on any theory of liability, whether
  34  * in contract, strict liability, or tort (including negligence or
  35  * otherwise) arising in any way out of the use of this software, even if
  36  * advised of the possibility of such damage.
  37  *
  38  * $Id: list.c,v 1.25 2000/12/20 03:38:43 grog Exp grog $
  39  * $FreeBSD: src/sbin/vinum/list.c,v 1.25.2.4 2001/05/28 05:58:04 grog Exp $
  40  * $DragonFly: src/sbin/vinum/list.c,v 1.7 2007/01/20 20:20:39 dillon Exp $
  41  */
  42
  43 #define _KERNEL_STRUCTURES
  44
  45 #include <ctype.h>
  46 #include <errno.h>
  47 #include <fcntl.h>
  48 #include <sys/mman.h>
  49 #include <netdb.h>
  50 #include <setjmp.h>
  51 #include <signal.h>
  52 #include <stdio.h>
  53 #include <stdlib.h>
  54 #include <string.h>
  55 #include <unistd.h>
  56 #include <sys/ioctl.h>
  57 #include <sys/utsname.h>
  58 #include <dev/raid/vinum/vinumhdr.h>
  59 #include "vext.h"
  60 #include <dev/raid/vinum/request.h>
  61 #include <devstat.h>
  62
  63 /*
  64  * When a subdisk is reviving or initializing, we
  65  * check to see whether it is still progressing
  66  * and print a warning if not.  We check every 50
  67  * ms, up to a maximum of 5 seconds.  This is the
  68  * counter value.
  69  */
  70 #define STALLCOUNT      100
  71
  72 /*
  73  * Take a size in sectors and return a pointer to
  74  * a string which represents the size best.  If lj
  75  * is != 0, return left justified, otherwise in a
  76  * fixed 10 character field suitable for columnar
  77  * printing.
  78  *
  79  * Note this uses a static string: it's only
  80  * intended to be used immediately for printing.
  81  */
  82 char *
  83 roughlength(int64_t bytes, int lj)
  84 {
  85     static char description[16];
  86
  87     if (bytes > (int64_t) MEGABYTE * 10000)                 /* gigabytes */
  88         sprintf(description, lj ? "%lld GB" : "%10lld GB", bytes / GIGABYTE);
  89     else if (bytes > KILOBYTE * 10000)                      /* megabytes */
  90         sprintf(description, lj ? "%lld MB" : "%10lld MB", bytes / MEGABYTE);
  91     else if (bytes > 10000)                                 /* kilobytes */
  92         sprintf(description, lj ? "%lld kB" : "%10lld kB", bytes / KILOBYTE);
  93     else                                                    /* bytes */
  94         sprintf(description, lj ? "%lld  B" : "%10lld  B", bytes);
  95     return description;
  96 }
  97
  98 void
  99 vinum_list(int argc, char *argv[], char *argv0[])
 100 {
 101     int object;
 102     int i;
 103     enum objecttype type;
 104
 105     if (sflag & (!vflag))                                   /* just summary stats, */
 106         printf("Object\t\t  Reads\t\tBytes\tAverage\tRecover\t Writes"
 107             "\t\tBytes\tAverage\t  Mblock  Mstripe\n\n");
 108     if (argc == 0)
 109         listconfig();                                       /* list everything */
 110     else {
 111         for (i = 0; i < argc; i++) {
 112             object = find_object(argv[i], &type);           /* look for it */
 113             if (vinum_li(object, type))
 114                 fprintf(stderr, "Can't find object: %s\n", argv[i]);
 115         }
 116     }
 117 }
 118
 119 /* List an object */
 120 int
 121 vinum_li(int object, enum objecttype type)
 122 {
 123     switch (type) {
 124     case drive_object:
 125         vinum_ldi(object, recurse);
 126         break;
 127
 128     case sd_object:
 129         vinum_lsi(object, recurse);
 130         break;
 131
 132     case plex_object:
 133         vinum_lpi(object, recurse);
 134         break;
 135
 136     case volume_object:
 137         vinum_lvi(object, recurse);
 138         break;
 139
 140     default:
 141         return -1;
 142     }
 143     return 0;
 144 }
 145
 146 void
 147 vinum_ldi(int driveno, int recurse)
 148 {
 149     time_t t;                                               /* because Bruce says so */
 150     int sdno;                                               /* for recursion */
 151
 152     get_drive_info(&drive, driveno);
 153     if (drive.state != drive_unallocated) {
 154         if (vflag) {
 155             printf("Drive %s:\tDevice %s\n",
 156                 drive.label.name,
 157                 drive.devicename);
 158             t = drive.label.date_of_birth.tv_sec;
 159             printf("\t\tCreated on %s at %s",
 160                 drive.label.sysname,
 161                 ctime(&t));
 162             t = drive.label.last_update.tv_sec;
 163             printf("\t\tConfig last updated %s",            /* care: \n at end */
 164                 ctime(&t));
 165             printf("\t\tSize: %16lld bytes (%lld MB)\n\t\tUsed: %16lld bytes (%lld MB)\n"
 166                 "\t\tAvailable: %11qd bytes (%d MB)\n",
 167                 (long long) drive.label.drive_size,         /* bytes used */
 168                 (long long) (drive.label.drive_size / MEGABYTE),
 169                 (long long) (drive.label.drive_size - drive.sectors_available
 170                     * DEV_BSIZE),
 171                 (long long) (drive.label.drive_size - drive.sectors_available
 172                     * DEV_BSIZE) / MEGABYTE,
 173                 (long long) drive.sectors_available * DEV_BSIZE,
 174                 (int) (drive.sectors_available * DEV_BSIZE / MEGABYTE));
 175             printf("\t\tState: %s\n", drive_state(drive.state));
 176             if (drive.lasterror != 0)
 177                 printf("\t\tLast error: %s\n", strerror(drive.lasterror));
 178             else
 179                 printf("\t\tLast error: none\n");
 180             printf("\t\tActive requests:\t%d\n\t\tMaximum active:\t\t%d\n",
 181                 drive.active,
 182                 drive.maxactive);
 183             if (Verbose) {                                  /* print the free list */
 184                 int fe;                                     /* freelist entry */
 185                 union freeunion {
 186                     struct drive_freelist freelist;
 187                     struct ferq {                                   /* request to pass to ioctl */
 188                         int driveno;
 189                         int fe;
 190                     } ferq;
 191                 } freeunion;
 192
 193                 printf("\t\tFree list contains %d entries:\n\t\t   Offset\t     Size\n",
 194                     drive.freelist_entries);
 195                 for (fe = 0; fe < drive.freelist_entries; fe++) {
 196                     freeunion.ferq.driveno = drive.driveno;
 197                     freeunion.ferq.fe = fe;
 198                     if (ioctl(superdev, VINUM_GETFREELIST, &freeunion.freelist) < 0) {
 199                         fprintf(stderr,
 200                             "Can't get free list element %d: %s\n",
 201                             fe,
 202                             strerror(errno));
 203                         longjmp(command_fail, -1);
 204                     }
 205                     printf("\t\t%9lld\t%9lld\n",
 206                         (long long) freeunion.freelist.offset,
 207                         (long long) freeunion.freelist.sectors);
 208                 }
 209             }
 210         } else if (!sflag) {
 211             printf("D %-21s State: %s\tDevice %s\tAvail: %lld/%lld MB",
 212                 drive.label.name,
 213                 drive_state(drive.state),
 214                 drive.devicename,
 215                 (long long) drive.sectors_available * DEV_BSIZE / MEGABYTE,
 216                 (long long) (drive.label.drive_size / MEGABYTE));
 217             if (drive.label.drive_size != 0)
 218                 printf(" (%d%%)",
 219                     (int) ((drive.sectors_available * 100 * DEV_BSIZE)
 220                         / (drive.label.drive_size - (DATASTART * DEV_BSIZE))));
 221         }
 222         if (sflag) {
 223             if (vflag || Verbose) {
 224                 printf("\t\tReads:  \t%16lld\n\t\tBytes read:\t%16lld (%s)\n",
 225                     (long long) drive.reads,
 226                     (long long) drive.bytes_read,
 227                     roughlength(drive.bytes_read, 1));
 228                 if (drive.reads != 0)
 229                     printf("\t\tAverage read:\t%16lld bytes\n",
 230                         (long long) drive.bytes_read / drive.reads);
 231                 printf("\t\tWrites: \t%16lld\n\t\tBytes written:\t%16lld (%s)\n",
 232                     (long long) drive.writes,
 233                     (long long) drive.bytes_written,
 234                     roughlength(drive.bytes_written, 1));
 235                 if (drive.writes != 0)
 236                     printf("\t\tAverage write:\t%16lld bytes\n",
 237                         (long long) (drive.bytes_written / drive.writes));
 238             } else {                                        /* non-verbose stats */
 239                 printf("%-15s\t%7lld\t%15lld\t",
 240                     drive.label.name,
 241                     (long long) drive.reads,
 242                     (long long) drive.bytes_read);
 243                 if (drive.reads != 0)
 244                     printf("%7lld\t\t",
 245                         (long long) (drive.bytes_read / drive.reads));
 246                 else
 247                     printf("\t\t");
 248                 printf("%7lld\t%15lld\t",
 249                     (long long) drive.writes,
 250                     (long long) drive.bytes_written);
 251                 if (drive.writes != 0)
 252                     printf("%7lld",
 253                         (long long) (drive.bytes_written / drive.writes));
 254             }
 255         }
 256         if (recurse) {
 257             printf("\n");
 258             for (sdno = 0; sdno < vinum_conf.subdisks_allocated; sdno++) {
 259                 get_sd_info(&sd, sdno);
 260                 if ((sd.state != sd_unallocated)
 261                     && (sd.driveno == drive.driveno))
 262                     vinum_lsi(sd.sdno, 0);
 263             }
 264         }
 265         printf("\n");
 266     }
 267 }
 268
 269 void
 270 vinum_ld(int argc, char *argv[], char *argv0[])
 271 {
 272     int i;
 273     int driveno;
 274     enum objecttype type;
 275
 276     if (ioctl(superdev, VINUM_GETCONFIG, &vinum_conf) < 0) {
 277         perror("Can't get vinum config");
 278         return;
 279     }
 280     if (argc == 0) {
 281         for (driveno = 0; driveno < vinum_conf.drives_allocated; driveno++)
 282             vinum_ldi(driveno, recurse);
 283     } else {
 284         for (i = 0; i < argc; i++) {
 285             driveno = find_object(argv[i], &type);
 286             if (type == drive_object)
 287                 vinum_ldi(driveno, recurse);
 288             else
 289                 fprintf(stderr, "%s is not a drive\n", argv[i]);
 290         }
 291     }
 292 }
 293
 294 void
 295 vinum_lvi(int volno, int recurse)
 296 {
 297     get_volume_info(&vol, volno);
 298     if (vol.state != volume_unallocated) {
 299         if (vflag) {
 300             printf("Volume %s:\tSize: %lld bytes (%lld MB)\n"
 301                 "\t\tState: %s\n\t\tFlags: %s%s%s\n",
 302                 vol.name,
 303                 ((long long) vol.size) * DEV_BSIZE,
 304                 ((long long) vol.size) * DEV_BSIZE / MEGABYTE,
 305                 volume_state(vol.state),
 306                 vol.flags & VF_OPEN ? "open " : "",
 307                 (vol.flags & VF_WRITETHROUGH ? "writethrough " : ""),
 308                 (vol.flags & VF_RAW ? "raw" : ""));
 309             printf("\t\t%d plexes\n\t\tRead policy: ", vol.plexes);
 310             if (vol.preferred_plex < 0)                     /* round robin */
 311                 printf("round robin\n");
 312             else {
 313                 get_plex_info(&plex, vol.plex[vol.preferred_plex]);
 314                 printf("plex %d (%s)\n", vol.preferred_plex, plex.name);
 315             }
 316         } else if (!sflag)                                  /* brief */
 317             printf("V %-21s State: %s\tPlexes: %7d\tSize: %s\n",
 318                 vol.name,
 319                 volume_state(vol.state),
 320                 vol.plexes,
 321                 roughlength(vol.size << DEV_BSHIFT, 0));
 322         if (sflag) {
 323             if (vflag || Verbose) {
 324                 printf("\t\tReads:  \t%16lld\n\t\tRecovered:\t%16lld\n\t\tBytes read:\t%16lld (%s)\n",
 325                     (long long) vol.reads,
 326                     (long long) vol.recovered_reads,
 327                     (long long) vol.bytes_read,
 328                     roughlength(vol.bytes_read, 1));
 329                 if (vol.reads != 0)
 330                     printf("\t\tAverage read:\t%16lld bytes\n",
 331                         (long long) (vol.bytes_read / vol.reads));
 332                 printf("\t\tWrites: \t%16lld\n\t\tBytes written:\t%16lld (%s)\n",
 333                     (long long) vol.writes,
 334                     (long long) vol.bytes_written,
 335                     roughlength(vol.bytes_written, 1));
 336                 if (vol.writes != 0)
 337                     printf("\t\tAverage write:\t%16lld bytes\n",
 338                         (long long) (vol.bytes_written / vol.writes));
 339                 printf("\t\tActive requests:\t%8d\n", vol.active);
 340             } else {                                        /* brief stats listing */
 341                 printf("%-15s\t%7lld\t%15lld\t",
 342                     vol.name,
 343                     (long long) vol.reads,
 344                     (long long) vol.bytes_read);
 345                 if (vol.reads != 0)
 346                     printf("%7lld\t",
 347                         (long long) (vol.bytes_read / vol.reads));
 348                 else
 349                     printf("\t");
 350                 printf("%7lld\t", (long long) vol.recovered_reads);
 351                 printf("%7lld\t%15lld\t",
 352                     (long long) vol.writes,
 353                     vol.bytes_written);
 354                 if (vol.writes != 0)
 355                     printf("%7lld\n",
 356                         (long long) (vol.bytes_written / vol.writes));
 357                 else
 358                     printf("\n");
 359             }
 360         }
 361         if (vol.plexes > 0) {
 362             int plexno;
 363             if (Verbose) {                                  /* brief list */
 364                 for (plexno = 0; plexno < vol.plexes; plexno++) {
 365                     get_plex_info(&plex, vol.plex[plexno]);
 366                                                             /* Just a brief summary here */
 367                     printf("\t\tPlex %2d:\t%s\t(%s), %s\n",
 368                         plexno,
 369                         plex.name,
 370                         plex_org(plex.organization),
 371                         roughlength(plex.length << DEV_BSHIFT, 0));
 372                 }
 373             }
 374             if (recurse) {
 375                 for (plexno = 0; plexno < vol.plexes; plexno++)
 376                     vinum_lpi(vol.plex[plexno], 0);         /* first show the plexes */
 377                 for (plexno = 0; plexno < vol.plexes; plexno++) { /* then the subdisks */
 378                     get_plex_info(&plex, vol.plex[plexno]);
 379                     if (plex.subdisks > 0) {
 380                         int sdno;
 381
 382                         for (sdno = 0; sdno < plex.subdisks; sdno++) {
 383                             get_plex_sd_info(&sd, vol.plex[plexno], sdno);
 384                             vinum_lsi(sd.sdno, 0);
 385                         }
 386                     }
 387                 }
 388                 printf("\n");
 389             }
 390         }
 391     }
 392 }
 393
 394 void
 395 vinum_lv(int argc, char *argv[], char *argv0[])
 396 {
 397     int i;
 398     int volno;
 399     enum objecttype type;
 400
 401     if (ioctl(superdev, VINUM_GETCONFIG, &vinum_conf) < 0) {
 402         perror("Can't get vinum config");
 403         return;
 404     }
 405     if (argc == 0)
 406         for (volno = 0; volno < vinum_conf.volumes_allocated; volno++)
 407             vinum_lvi(volno, recurse);
 408     else {
 409         for (i = 0; i < argc; i++) {
 410             volno = find_object(argv[i], &type);
 411             if (type == volume_object)
 412                 vinum_lvi(volno, recurse);
 413             else
 414                 fprintf(stderr, "%s is not a volume\n", argv[i]);
 415         }
 416     }
 417 }
 418
 419 void
 420 vinum_lpi(int plexno, int recurse)
 421 {
 422     get_plex_info(&plex, plexno);
 423     if (plex.state != plex_unallocated) {
 424         if (vflag) {
 425             printf("Plex %s:\tSize:\t%9lld bytes (%lld MB)\n\t\tSubdisks: %8d\n",
 426                 plex.name,
 427                 (long long) plex.length * DEV_BSIZE,
 428                 (long long) plex.length * DEV_BSIZE / MEGABYTE,
 429                 plex.subdisks);
 430             printf("\t\tState: %s\n\t\tOrganization: %s",
 431                 plex_state(plex.state),
 432                 plex_org(plex.organization));
 433             if (isstriped((&plex)))
 434                 printf("\tStripe size: %s\n", roughlength(plex.stripesize * DEV_BSIZE, 1));
 435             else
 436                 printf("\n");
 437             if ((isparity((&plex)))
 438                 && (plex.checkblock != 0))
 439                 printf("\t\tCheck block pointer:\t\t%s (%d%%)\n",
 440                     roughlength((plex.checkblock << DEV_BSHIFT) * (plex.subdisks - 1), 0),
 441                     (int) (((u_int64_t) (plex.checkblock * 100)) * (plex.subdisks - 1) / plex.length));
 442             if (plex.volno >= 0) {
 443                 get_volume_info(&vol, plex.volno);
 444                 printf("\t\tPart of volume %s\n", vol.name);
 445             }
 446         } else if (!sflag) {                                /* non-verbose list */
 447             char *org = "";                                 /* organization */
 448
 449             switch (plex.organization) {
 450             case plex_disorg:                               /* disorganized */
 451                 org = "??";
 452                 break;
 453             case plex_concat:                               /* concatenated plex */
 454                 org = "C";
 455                 break;
 456             case plex_striped:                              /* striped plex */
 457                 org = "S";
 458                 break;
 459             case plex_raid4:                                /* RAID4 plex */
 460                 org = "R4";
 461                 break;
 462             case plex_raid5:                                /* RAID5 plex */
 463                 org = "R5";
 464                 break;
 465             }
 466             printf("P %-18s %2s State: %s\tSubdisks: %5d\tSize: %s",
 467                 plex.name,
 468                 org,
 469                 plex_state(plex.state),
 470                 plex.subdisks,
 471                 roughlength(plex.length << DEV_BSHIFT, 0));
 472         }
 473         if (sflag) {
 474             if (vflag || Verbose) {
 475                 printf("\t\tReads:  \t%16lld\n\t\tBytes read:\t%16lld (%s)\n",
 476                     (long long) plex.reads,
 477                     (long long) plex.bytes_read,
 478                     roughlength(plex.bytes_read, 1));
 479                 if (plex.reads != 0)
 480                     printf("\t\tAverage read:\t%16lld bytes\n",
 481                         (long long) (plex.bytes_read / plex.reads));
 482                 printf("\t\tWrites: \t%16lld\n\t\tBytes written:\t%16lld (%s)\n",
 483                     (long long) plex.writes,
 484                     (long long) plex.bytes_written,
 485                     roughlength(plex.bytes_written, 1));
 486                 if (plex.writes != 0)
 487                     printf("\t\tAverage write:\t%16lld bytes\n",
 488                         (long long) (plex.bytes_written / plex.writes));
 489                 if (((plex.reads + plex.writes) > 0)
 490                     && isstriped((&plex)))
 491                     printf("\t\tMultiblock:\t%16lld (%d%%)\n"
 492                         "\t\tMultistripe:\t%16lld (%d%%)\n",
 493                         (long long) plex.multiblock,
 494                         (int) (plex.multiblock * 100 / (plex.reads + plex.writes)),
 495                         (long long) plex.multistripe,
 496                         (int) (plex.multistripe * 100 / (plex.reads + plex.writes)));
 497                 if (plex.recovered_reads)
 498                     printf("\t\tRecovered reads:%16lld\n",
 499                         (long long) plex.recovered_reads);
 500                 if (plex.degraded_writes)
 501                     printf("\t\tDegraded writes:%16lld\n",
 502                         (long long) plex.degraded_writes);
 503                 if (plex.parityless_writes)
 504                     printf("\t\tParityless writes:%14lld\n",
 505                         (long long) plex.parityless_writes);
 506             } else {
 507                 printf("%-15s\t%7lld\t%15lld\t",
 508                     plex.name,
 509                     (long long) plex.reads,
 510                     (long long) plex.bytes_read);
 511                 if (plex.reads != 0)
 512                     printf("%7lld\t",
 513                         (long long) (plex.bytes_read / plex.reads));
 514                 else
 515                     printf("\t");
 516                 printf("%7lld\t", (long long) plex.recovered_reads);
 517                 printf("%7lld\t%15lld\t",
 518                     (long long) plex.writes,
 519                     (long long) plex.bytes_written);
 520                 if (plex.writes != 0)
 521                     printf("%7lld\t",
 522                         (long long) (plex.bytes_written / plex.writes));
 523                 else
 524                     printf("\t");
 525                 printf("%7lld\t%7lld\n",
 526                     (long long) plex.multiblock,
 527                     (long long) plex.multistripe);
 528             }
 529         }
 530         if (plex.subdisks > 0) {
 531             int sdno;
 532
 533             if (Verbose) {
 534                 printf("\n");
 535                 for (sdno = 0; sdno < plex.subdisks; sdno++) {
 536                     get_plex_sd_info(&sd, plexno, sdno);
 537                     printf("\t\tSubdisk %d:\t%s\n\t\t  state: %s\tsize %11lld (%lld MB)\n",
 538                         sdno,
 539                         sd.name,
 540                         sd_state(sd.state),
 541                         (long long) sd.sectors * DEV_BSIZE,
 542                         (long long) sd.sectors * DEV_BSIZE / MEGABYTE);
 543                     if (plex.organization == plex_concat)
 544                         printf("\t\t\toffset %9ld (0x%lx)\n",
 545                             (long) sd.plexoffset,
 546                             (long) sd.plexoffset);
 547                 }
 548             }
 549             if (recurse) {
 550                 printf("\n");
 551                 for (sdno = 0; sdno < plex.subdisks; sdno++) {
 552                     get_plex_sd_info(&sd, plexno, sdno);
 553                     vinum_lsi(sd.sdno, 0);
 554                 }
 555             }
 556         }
 557         printf("\n");
 558     }
 559 }
 560
 561 void
 562 vinum_lp(int argc, char *argv[], char *argv0[])
 563 {
 564     int i;
 565     int plexno;
 566     enum objecttype type;
 567
 568     if (ioctl(superdev, VINUM_GETCONFIG, &vinum_conf) < 0) {
 569         perror("Can't get vinum config");
 570         return;
 571     }
 572     if (argc == 0) {
 573         for (plexno = 0; plexno < vinum_conf.plexes_allocated; plexno++)
 574             vinum_lpi(plexno, recurse);
 575     } else {
 576         for (i = 0; i < argc; i++) {
 577             plexno = find_object(argv[i], &type);
 578             if (type == plex_object)
 579                 vinum_lpi(plexno, recurse);
 580             else
 581                 fprintf(stderr, "%s is not a plex\n", argv[i]);
 582         }
 583     }
 584 }
 585
 586 void
 587 vinum_lsi(int sdno, int recurse)
 588 {
 589     long long revived;                                      /* keep an eye on revive progress */
 590     int times;
 591
 592     get_sd_info(&sd, sdno);
 593     if (sd.state != sd_unallocated) {
 594         if (vflag) {
 595             printf("Subdisk %s:\n\t\tSize: %16lld bytes (%lld MB)\n\t\tState: %s\n",
 596                 sd.name,
 597                 (long long) sd.sectors * DEV_BSIZE,
 598                 (long long) sd.sectors / (MEGABYTE / DEV_BSIZE),
 599                 sd_state(sd.state));
 600             if (sd.flags & VF_RETRYERRORS)
 601                 printf("\t\tretryerrors\n");
 602             if (sd.plexno >= 0) {
 603                 get_plex_info(&plex, sd.plexno);
 604                 printf("\t\tPlex %s", plex.name);
 605                 printf(" at offset %lld (%s)\n",
 606                     (long long) sd.plexoffset * DEV_BSIZE,
 607                     roughlength((long long) sd.plexoffset * DEV_BSIZE, 1));
 608             }
 609             if (sd.state == sd_reviving) {
 610                 if (sd.reviver == 0)
 611                     printf("\t\t*** Start subdisk with 'start' command ***\n");
 612                 else {
 613                     printf("\t\tReviver PID:\t%d\n", sd.reviver);
 614                     if (kill(sd.reviver, 0) == -1) {
 615                         if (errno == ESRCH)                 /* no process */
 616                             printf("\t\t*** Revive process has died ***\n");
 617                                                             /* Don't report a problem that "can't happen" */
 618                     } else {
 619                         revived = sd.revived;               /* note how far we were */
 620
 621                         /*
 622                          * Wait for up to a second until we
 623                          * see some progress with the revive.
 624                          * Do it like this so we don't have
 625                          * annoying delays in the listing.
 626                          */
 627                         for (times = 0; times < STALLCOUNT; times++) {
 628                             get_sd_info(&sd, sdno);
 629                             if (sd.revived != revived)      /* progress? */
 630                                 break;
 631                             usleep(50000);
 632                         }
 633                         if (times == STALLCOUNT)
 634                             printf("\t\t*** Revive has stalled ***\n");
 635                     }
 636                 }
 637                 printf("\t\tRevive pointer:\t\t%s (%d%%)\n",
 638                     roughlength(sd.revived << DEV_BSHIFT, 0),
 639                     (int) (((u_int64_t) (sd.revived * 100)) / sd.sectors));
 640                 printf("\t\tRevive blocksize:\t%s\n"
 641                     "\t\tRevive interval:\t%10d seconds\n",
 642                     roughlength(sd.revive_blocksize, 0),
 643                     sd.revive_interval);
 644             }
 645             if (sd.state == sd_initializing) {
 646                 printf("\t\tInitialize pointer:\t%s (%d%%)\n",
 647                     roughlength(sd.initialized << DEV_BSHIFT, 0),
 648                     (int) (((u_int64_t) (sd.initialized * 100)) / sd.sectors));
 649                 printf("\t\tInitialize blocksize:\t%s\n"
 650                     "\t\tInitialize interval:\t%10d seconds\n",
 651                     roughlength(sd.init_blocksize, 0),
 652                     sd.init_interval);
 653             }
 654             get_drive_info(&drive, sd.driveno);
 655             if (sd.driveoffset < 0)
 656                 printf("\t\tDrive %s (%s), no offset\n",
 657                     drive.label.name,
 658                     drive.devicename);
 659             else if (drive.devicename[0] != '\0')           /* has a name */
 660                 printf("\t\tDrive %s (%s) at offset %lld (%s)\n",
 661                     drive.label.name,
 662                     drive.devicename,
 663                     (long long) (sd.driveoffset * DEV_BSIZE),
 664                     roughlength(sd.driveoffset * DEV_BSIZE, 1));
 665             else
 666                 printf("\t\tDrive %s (*missing*) at offset %lld (%s)\n",
 667                     drive.label.name,
 668                     (long long) (sd.driveoffset * DEV_BSIZE),
 669                     roughlength(sd.driveoffset * DEV_BSIZE, 1));
 670         } else if (!sflag) {                                /* brief listing, no stats */
 671             if (sd.state == sd_reviving)
 672                 printf("S %-21s State: R %d%%\t",
 673                     sd.name,
 674                     (int) (((u_int64_t) (sd.revived * 100)) / sd.sectors));
 675             else if (sd.state == sd_initializing)
 676                 printf("S %-21s State: I %d%%\t",
 677                     sd.name,
 678                     (int) (((u_int64_t) (sd.initialized * 100)) / sd.sectors));
 679             else
 680                 printf("S %-21s State: %s\t",
 681                     sd.name,
 682                     sd_state(sd.state));
 683             if (sd.plexno == -1)
 684                 printf("(detached)\t");
 685             else
 686                 printf("PO: %s ",
 687                     &(roughlength(sd.plexoffset << DEV_BSHIFT, 0))[2]); /* what a kludge! */
 688             printf("Size: %s\n",
 689                 roughlength(sd.sectors << DEV_BSHIFT, 0));
 690             if (sd.state == sd_reviving) {
 691                 if (sd.reviver == 0)
 692                     printf("\t\t\t*** Start %s with 'start' command ***\n",
 693                         sd.name);
 694                 else if (kill(sd.reviver, 0) == -1) {
 695                     if (errno == ESRCH)                     /* no process */
 696                         printf("\t\t\t*** Revive process for %s has died ***\n",
 697                             sd.name);
 698                                                             /* Don't report a problem that "can't happen" */
 699                 } else {
 700                     revived = sd.revived;                   /* note how far we were */
 701
 702                     /*
 703                      * Wait for up to a second until we
 704                      * see some progress with the revive.
 705                      * Do it like this so we don't have
 706                      * annoying delays in the listing.
 707                      */
 708                     for (times = 0; times < STALLCOUNT; times++) {
 709                         get_sd_info(&sd, sdno);
 710                         if (sd.revived != revived)          /* progress? */
 711                             break;
 712                         usleep(50000);
 713                     }
 714                     if (times == STALLCOUNT)
 715                         printf("\t\t\t*** Revive of %s has stalled ***\n",
 716                             sd.name);
 717                 }
 718             }
 719         }
 720         if (sflag) {
 721             if (vflag || Verbose) {
 722                 printf("\t\tReads:  \t%16lld\n\t\tBytes read:\t%16lld (%s)\n",
 723                     (long long) sd.reads,
 724                     (long long) sd.bytes_read,
 725                     roughlength(sd.bytes_read, 1));
 726                 if (sd.reads != 0)
 727                     printf("\t\tAverage read:\t%16lld bytes\n",
 728                         (long long) (sd.bytes_read / sd.reads));
 729                 printf("\t\tWrites: \t%16lld\n\t\tBytes written:\t%16lld (%s)\n",
 730                     (long long) sd.writes,
 731                     (long long) sd.bytes_written,
 732                     roughlength(sd.bytes_written, 1));
 733                 if (sd.writes != 0)
 734                     printf("\t\tAverage write:\t%16lld bytes\n",
 735                         (long long) (sd.bytes_written / sd.writes));
 736             } else {
 737                 printf("%-15s\t%7lld\t%15lld\t",
 738                     sd.name,
 739                     (long long) sd.reads,
 740                     (long long) sd.bytes_read);
 741                 if (sd.reads != 0)
 742                     printf("%7lld\t\t",
 743                         (long long) (sd.bytes_read / sd.reads));
 744                 else
 745                     printf("\t\t");
 746                 printf("%7lld\t%15lld\t",
 747                     (long long) sd.writes,
 748                     (long long) sd.bytes_written);
 749                 if (sd.writes != 0)
 750                     printf("%7lld\n",
 751                         (long long) (sd.bytes_written / sd.writes));
 752                 else
 753                     printf("\n");
 754             }
 755         }
 756         if (recurse)
 757             vinum_ldi(sd.driveno, 0);
 758         if (vflag)
 759             printf("\n");                                   /* make it more readable */
 760     }
 761 }
 762
 763 void
 764 vinum_ls(int argc, char *argv[], char *argv0[])
 765 {
 766     int i;
 767     int sdno;
 768
 769     /* Structures to read kernel data into */
 770     struct _vinum_conf vinum_conf;
 771     enum objecttype type;
 772
 773     if (ioctl(superdev, VINUM_GETCONFIG, &vinum_conf) < 0) {
 774         perror("Can't get vinum config");
 775         return;
 776     }
 777     if (argc == 0) {
 778         for (sdno = 0; sdno < vinum_conf.subdisks_allocated; sdno++)
 779             vinum_lsi(sdno, recurse);
 780     } else {                                                /* specific subdisks */
 781         for (i = 0; i < argc; i++) {
 782             sdno = find_object(argv[i], &type);
 783             if (type == sd_object)
 784                 vinum_lsi(sdno, recurse);
 785             else
 786                 fprintf(stderr, "%s is not a subdisk\n", argv[i]);
 787         }
 788     }
 789 }
 790
 791
 792 /* List the complete configuration.
 793
 794  * XXX Change this to specific lists */
 795 void
 796 listconfig(void)
 797 {
 798     if (ioctl(superdev, VINUM_GETCONFIG, &vinum_conf) < 0) {
 799         perror("Can't get vinum config");
 800         return;
 801     }
 802     printf("%d drives:\n", vinum_conf.drives_used);
 803     if (vinum_conf.drives_used > 0) {
 804         vinum_ld(0, NULL, NULL);
 805         printf("\n");
 806     }
 807     printf("%d volumes:\n", vinum_conf.volumes_used);
 808     if (vinum_conf.volumes_used > 0) {
 809         vinum_lv(0, NULL, NULL);
 810         printf("\n");
 811     }
 812     printf("%d plexes:\n", vinum_conf.plexes_used);
 813     if (vinum_conf.plexes_used > 0) {
 814         vinum_lp(0, NULL, NULL);
 815         printf("\n");
 816     }
 817     printf("%d subdisks:\n", vinum_conf.subdisks_used);
 818     if (vinum_conf.subdisks_used > 0)
 819         vinum_ls(0, NULL, NULL);
 820 }
 821
 822 /* Convert a timeval to Tue Oct 13 13:54:14.0434324
 823  * Return pointer to text */
 824 char *
 825 timetext(struct timeval *time)
 826 {
 827     static char text[30];
 828     time_t t;                                               /* to keep Bruce happy */
 829
 830     t = time->tv_sec;
 831     strcpy(text, ctime(&t));                                /* to the second */
 832     sprintf(&text[19], ".%06ld", time->tv_usec);            /* and the microseconds */
 833     return &text[11];
 834 }
 835
 836 void
 837 vinum_info(int argc, char *argv[], char *argv0[])
 838 {
 839     struct meminfo meminfo;
 840     struct mc malloced;
 841     int i;
 842 #if VINUMDEBUG
 843     struct rqinfo rq;
 844 #endif
 845
 846     if (ioctl(superdev, VINUM_GETCONFIG, &vinum_conf) < 0) {
 847         perror("Can't get vinum config");
 848         return;
 849     }
 850     printf("Flags: 0x%x\n", vinum_conf.flags);
 851     if (ioctl(superdev, VINUM_MEMINFO, &meminfo) < 0) {
 852         perror("Can't get information");
 853         return;
 854     }
 855     printf("Total of %d blocks malloced, total memory: %d\nMaximum allocs: %8d, malloc table at 0x%08x\n",
 856         meminfo.mallocs,
 857         meminfo.total_malloced,
 858         meminfo.highwater,
 859         (int) meminfo.malloced);
 860
 861     printf("%d requests active, maximum %d active\n",
 862         vinum_conf.active,
 863         vinum_conf.maxactive);
 864     if (vflag && (!Verbose))
 865         for (i = 0; i < meminfo.mallocs; i++) {
 866             malloced.seq = i;
 867             if (ioctl(superdev, VINUM_MALLOCINFO, &malloced) < 0) {
 868                 perror("Can't get information");
 869                 return;
 870             }
 871             if (!(i & 63))
 872                 printf("Block\tSequence\t  size\t  address\t  line\t\tfile\n\n");
 873             printf("%6d\t%6d\t\t%6d\t0x%08x\t%6d\t\t%s\n",
 874                 i,
 875                 malloced.seq,
 876                 malloced.size,
 877                 (int) malloced.address,
 878                 malloced.line,
 879                 (char *) &malloced.file);
 880         }
 881 #if VINUMDEBUG
 882     if (Verbose) {
 883         printf("\nTime\t\t Event\t     Buf\tDev\t  Offset\tBytes\tSD\tSDoff\tDoffset\tGoffset\n\n");
 884         for (i = RQINFO_SIZE - 1; i >= 0; i--) {            /* go through the request list in order */
 885             *((int *) &rq) = i;
 886             if (ioctl(superdev, VINUM_RQINFO, &rq) < 0) {
 887                 perror("Can't get information");
 888                 return;
 889             }
 890             /* Compress devminor into something printable. */
 891             rq.devminor = (rq.devminor & 0xff)
 892                 | ((rq.devminor & 0xfff0000) >> 8);
 893             switch (rq.type) {
 894             case loginfo_unused:                            /* never been used */
 895                 break;
 896
 897             case loginfo_user_bp:                           /* this is the bp when strategy is called */
 898                 printf("%s %dVS %s %p\t%d.%-6d 0x%-9x\t%ld\n",
 899                     timetext(&rq.timestamp),
 900                     rq.type,
 901                     rq.info.b.b_flags & B_READ ? "Read " : "Write",
 902                     rq.bp,
 903                     rq.devmajor,
 904                     rq.devminor,
 905                     rq.info.b.b_blkno,
 906                     rq.info.b.b_bcount);
 907                 break;
 908
 909             case loginfo_sdiol:                             /* subdisk I/O launch */
 910             case loginfo_user_bpl:                          /* and this is the bp at launch time */
 911                 printf("%s %dLR %s %p\t%d.%-6d 0x%-9x\t%ld\n",
 912                     timetext(&rq.timestamp),
 913                     rq.type,
 914                     rq.info.b.b_flags & B_READ ? "Read " : "Write",
 915                     rq.bp,
 916                     rq.devmajor,
 917                     rq.devminor,
 918                     rq.info.b.b_blkno,
 919                     rq.info.b.b_bcount);
 920                 break;
 921
 922             case loginfo_rqe:                               /* user RQE */
 923                 printf("%s 3RQ %s %p\t%d.%-6d 0x%-9x\t%ld\t%d\t%x\t%x\t%x\n",
 924                     timetext(&rq.timestamp),
 925                     rq.info.rqe.b.b_flags & B_READ ? "Read " : "Write",
 926                     rq.bp,
 927                     rq.devmajor,
 928                     rq.devminor,
 929                     rq.info.rqe.b.b_blkno,
 930                     rq.info.rqe.b.b_bcount,
 931                     rq.info.rqe.sdno,
 932                     rq.info.rqe.sdoffset,
 933                     rq.info.rqe.dataoffset,
 934                     rq.info.rqe.groupoffset);
 935                 break;
 936
 937             case loginfo_iodone:                            /* iodone called */
 938                 printf("%s 4DN %s %p\t%d.%-6d 0x%-9x\t%ld\t%d\t%x\t%x\t%x\n",
 939                     timetext(&rq.timestamp),
 940                     rq.info.rqe.b.b_flags & B_READ ? "Read " : "Write",
 941                     rq.bp,
 942                     rq.devmajor,
 943                     rq.devminor,
 944                     rq.info.rqe.b.b_blkno,
 945                     rq.info.rqe.b.b_bcount,
 946                     rq.info.rqe.sdno,
 947                     rq.info.rqe.sdoffset,
 948                     rq.info.rqe.dataoffset,
 949                     rq.info.rqe.groupoffset);
 950                 break;
 951
 952             case loginfo_raid5_data:                        /* RAID-5 write data block */
 953                 printf("%s 5RD %s %p\t%d.%-6d 0x%-9x\t%ld\t%d\t%x\t%x\t%x\n",
 954                     timetext(&rq.timestamp),
 955                     rq.info.rqe.b.b_flags & B_READ ? "Read " : "Write",
 956                     rq.bp,
 957                     rq.devmajor,
 958                     rq.devminor,
 959                     rq.info.rqe.b.b_blkno,
 960                     rq.info.rqe.b.b_bcount,
 961                     rq.info.rqe.sdno,
 962                     rq.info.rqe.sdoffset,
 963                     rq.info.rqe.dataoffset,
 964                     rq.info.rqe.groupoffset);
 965                 break;
 966
 967             case loginfo_raid5_parity:                      /* RAID-5 write parity block */
 968                 printf("%s 6RP %s %p\t%d.%-6d 0x%-9x\t%ld\t%d\t%x\t%x\t%x\n",
 969                     timetext(&rq.timestamp),
 970                     rq.info.rqe.b.b_flags & B_READ ? "Read " : "Write",
 971                     rq.bp,
 972                     rq.devmajor,
 973                     rq.devminor,
 974                     rq.info.rqe.b.b_blkno,
 975                     rq.info.rqe.b.b_bcount,
 976                     rq.info.rqe.sdno,
 977                     rq.info.rqe.sdoffset,
 978                     rq.info.rqe.dataoffset,
 979                     rq.info.rqe.groupoffset);
 980                 break;
 981
 982             case loginfo_sdio:                              /* subdisk I/O */
 983                 printf("%s %dVS %s %p\t\t  0x%-9x\t%ld\t%d\n",
 984                     timetext(&rq.timestamp),
 985                     rq.type,
 986                     rq.info.b.b_flags & B_READ ? "Read " : "Write",
 987                     rq.bp,
 988                     rq.info.b.b_blkno,
 989                     rq.info.b.b_bcount,
 990                     rq.devminor);
 991                 break;
 992
 993             case loginfo_sdiodone:                          /* subdisk I/O done */
 994                 printf("%s %dSD %s %p\t\t  0x%-9x\t%ld\t%d\n",
 995                     timetext(&rq.timestamp),
 996                     rq.type,
 997                     rq.info.b.b_flags & B_READ ? "Read " : "Write",
 998                     rq.bp,
 999                     rq.info.b.b_blkno,
1000                     rq.info.b.b_bcount,
1001                     rq.devminor);
1002                 break;
1003
1004             case loginfo_lockwait:
1005                 printf("%s Lockwait  %p\t  0x%x\n",
1006                     timetext(&rq.timestamp),
1007                     rq.bp,
1008                     rq.info.lockinfo.stripe);
1009                 break;
1010
1011             case loginfo_lock:
1012                 printf("%s Lock      %p\t  0x%x\n",
1013                     timetext(&rq.timestamp),
1014                     rq.bp,
1015                     rq.info.lockinfo.stripe);
1016                 break;
1017
1018             case loginfo_unlock:
1019                 printf("%s Unlock\t  %p\t  0x%x\n",
1020                     timetext(&rq.timestamp),
1021                     rq.bp,
1022                     rq.info.lockinfo.stripe);
1023                 break;
1024             }
1025         }
1026     }
1027 #endif
1028 }
1029
1030 /*
1031  * Print config file to a file.  This is a userland version
1032  * of kernel format_config
1033  */
1034 void
1035 vinum_printconfig(int argc, char *argv[], char *argv0[])
1036 {
1037     FILE *of;
1038
1039     if (argc > 1) {
1040         fprintf(stderr, "Usage: \tprintconfig [<outfile>]\n");
1041         return;
1042     } else if (argc == 1)
1043         of = fopen(argv[0], "w");
1044     else
1045         of = stdout;
1046     if (of == NULL) {
1047         fprintf(stderr, "Can't open %s: %s\n", argv[0], strerror(errno));
1048         return;
1049     }
1050     printconfig(of, "");
1051     if (argc == 1)
1052         fclose(of);
1053 }
1054
1055 /*
1056  * The guts of printconfig.  This is called from
1057  * vinum_printconfig and from vinum_create when
1058  * called without an argument, in order to give
1059  * the user something to edit.
1060  */
1061 void
1062 printconfig(FILE * of, char *comment)
1063 {
1064     struct utsname uname_s;
1065     time_t now;
1066     int i;
1067     struct volume vol;
1068     struct plex plex;
1069     struct sd sd;
1070     struct drive drive;
1071
1072     if (ioctl(superdev, VINUM_GETCONFIG, &vinum_conf) < 0) {
1073         perror("Can't get vinum config");
1074         return;
1075     }
1076     uname(&uname_s);                                        /* get our system name */
1077     time(&now);                                             /* and the current time */
1078     fprintf(of,
1079         "# Vinum configuration of %s, saved at %s",
1080         uname_s.nodename,
1081         ctime(&now));                                       /* say who did it */
1082
1083     if (comment[0] != 0)                                    /* abuse this for commented version */
1084         fprintf(of, "# Current configuration:\n");
1085     for (i = 0; i < vinum_conf.drives_allocated; i++) {
1086         get_drive_info(&drive, i);
1087         if (drive.state != drive_unallocated) {
1088             fprintf(of,
1089                 "%sdrive %s device %s\n",
1090                 comment,
1091                 drive.label.name,
1092                 drive.devicename);
1093         }
1094     }
1095
1096     for (i = 0; i < vinum_conf.volumes_allocated; i++) {
1097         get_volume_info(&vol, i);
1098         if (vol.state != volume_unallocated) {
1099             if (vol.preferred_plex >= 0)                    /* preferences, */
1100                 fprintf(of,
1101                     "%svolume %s readpol prefer %s\n",
1102                     comment,
1103                     vol.name,
1104                     vinum_conf.plex[vol.preferred_plex].name);
1105             else                                            /* default round-robin */
1106                 fprintf(of, "%svolume %s\n", comment, vol.name);
1107         }
1108     }
1109
1110     /* Then the plex configuration */
1111     for (i = 0; i < vinum_conf.plexes_allocated; i++) {
1112         get_plex_info(&plex, i);
1113         if (plex.state != plex_unallocated) {
1114             fprintf(of, "%splex name %s org %s ",
1115                 comment,
1116                 plex.name,
1117                 plex_org(plex.organization));
1118             if (isstriped((&plex)))
1119                 fprintf(of, "%ds ", (int) plex.stripesize);
1120             if (plex.volno >= 0) {                          /* we have a volume */
1121                 get_volume_info(&vol, plex.volno);
1122                 fprintf(of, "vol %s ", vol.name);
1123             } else
1124                 fprintf(of, "detached ");
1125             fprintf(of, "\n");
1126         }
1127     }
1128
1129     /* And finally the subdisk configuration */
1130     for (i = 0; i < vinum_conf.subdisks_allocated; i++) {
1131         get_sd_info(&sd, i);
1132         if (sd.state != sd_unallocated) {
1133             get_drive_info(&drive, sd.driveno);
1134             if (sd.plexno >= 0) {
1135                 get_plex_info(&plex, sd.plexno);
1136                 fprintf(of,
1137                     "%ssd name %s drive %s plex %s len %llds driveoffset %llds plexoffset %llds\n",
1138                     comment,
1139                     sd.name,
1140                     drive.label.name,
1141                     plex.name,
1142                     (long long) sd.sectors,
1143                     (long long) sd.driveoffset,
1144                     (long long) sd.plexoffset);
1145             } else
1146                 fprintf(of,
1147                     "%ssd name %s drive %s detached len %llds driveoffset %llds\n",
1148                     comment,
1149                     sd.name,
1150                     drive.label.name,
1151                     (long long) sd.sectors,
1152                     (long long) sd.driveoffset);
1153         }
1154     }
1155 }
1156
1157 void
1158 list_defective_objects(void)
1159 {
1160     int o;                                                  /* object */
1161     int heading_needed = 1;
1162
1163     if (ioctl(superdev, VINUM_GETCONFIG, &vinum_conf) < 0) {
1164         perror("Can't get vinum config");
1165         return;
1166     }
1167     for (o = 0; o < vinum_conf.drives_allocated; o++) {
1168         get_drive_info(&drive, o);
1169         if ((drive.state != drive_unallocated)              /* drive exists */
1170         &&(drive.state != drive_up)) {                      /* but it's not up */
1171             if (heading_needed) {
1172                 printf("Warning: defective objects\n\n");
1173                 heading_needed = 0;
1174             }
1175             vinum_ldi(o, 0);                                /* print info */
1176         }
1177     }
1178
1179     for (o = 0; o < vinum_conf.volumes_allocated; o++) {
1180         get_volume_info(&vol, o);
1181         if ((vol.state != volume_unallocated)               /* volume exists */
1182         &&(vol.state != volume_up)) {                       /* but it's not up */
1183             if (heading_needed) {
1184                 printf("Warning: defective objects\n\n");
1185                 heading_needed = 0;
1186             }
1187             vinum_lvi(o, 0);                                /* print info */
1188         }
1189     }
1190
1191     for (o = 0; o < vinum_conf.plexes_allocated; o++) {
1192         get_plex_info(&plex, o);
1193         if ((plex.state != plex_unallocated)                /* plex exists */
1194         &&(plex.state != plex_up)) {                        /* but it's not up */
1195             if (heading_needed) {
1196                 printf("Warning: defective objects\n\n");
1197                 heading_needed = 0;
1198             }
1199             vinum_lpi(o, 0);                                /* print info */
1200         }
1201     }
1202
1203     for (o = 0; o < vinum_conf.subdisks_allocated; o++) {
1204         get_sd_info(&sd, o);
1205         if ((sd.state != sd_unallocated)                    /* sd exists */
1206         &&(sd.state != sd_up)) {                            /* but it's not up */
1207             if (heading_needed) {
1208                 printf("Warning: defective objects\n\n");
1209                 heading_needed = 0;
1210             }
1211             vinum_lsi(o, 0);                                /* print info */
1212         }
1213     }
1214 }
1215
1216 /* Dump config from specified disk drives */
1217 void
1218 vinum_dumpconfig(int argc, char *argv[], char *argv0[])
1219 {
1220     int i;
1221
1222     if (argc == 0) {                                        /* start everything */
1223         int devs = getnumdevs();
1224         struct statinfo statinfo;
1225         char *namelist;
1226         char *enamelist;                                    /* end of name list */
1227         int i;
1228         char **token;                                       /* list of tokens */
1229         int tokens;                                         /* and their number */
1230
1231         bzero(&statinfo, sizeof(struct statinfo));
1232         statinfo.dinfo = malloc(devs * sizeof(struct statinfo));
1233         namelist = malloc(devs * (DEVSTAT_NAME_LEN + 8));
1234         token = malloc((devs + 1) * sizeof(char *));
1235         if ((statinfo.dinfo == NULL) || (namelist == NULL) || (token == NULL)) {
1236             fprintf(stderr, "Can't allocate memory for drive list\n");
1237             return;
1238         }
1239         bzero(statinfo.dinfo, sizeof(struct devinfo));
1240
1241         tokens = 0;                                         /* no tokens yet */
1242         if (getdevs(&statinfo) < 0) {                       /* find out what devices we have */
1243             perror("Can't get device list");
1244             return;
1245         }
1246         namelist[0] = '\0';                                 /* start with empty namelist */
1247         enamelist = namelist;                               /* point to the end of the list */
1248
1249         for (i = 0; i < devs; i++) {
1250             struct devstat *stat = &statinfo.dinfo->devices[i];
1251
1252             if (((stat->device_type & DEVSTAT_TYPE_MASK) == DEVSTAT_TYPE_DIRECT) /* disk device */
1253             &&((stat->device_type & DEVSTAT_TYPE_PASS) == 0) /* and not passthrough */
1254             &&((stat->device_name[0] != '\0'))) {           /* and it has a name */
1255                 sprintf(enamelist, "/dev/%s%d", stat->device_name, stat->unit_number);
1256                 token[tokens] = enamelist;                  /* point to it */
1257                 tokens++;                                   /* one more token */
1258                 enamelist = &enamelist[strlen(enamelist) + 1]; /* and start beyond the end */
1259             }
1260         }
1261         free(statinfo.dinfo);                               /* don't need the list any more */
1262         for (i = 0; i < tokens; i++)
1263             dumpconfig(token[i]);
1264         free(namelist);
1265         free(token);
1266     } else {                                                /* list specified drives */
1267         for (i = 0; i < argc; i++)
1268             dumpconfig(argv[i]);
1269     }
1270 }
1271
1272 #define DEVLEN 5
1273 void
1274 dumpconfig(char *part)
1275 {
1276     char partname[MAXPATHLEN];
1277     char *partid;
1278     char partition;                                         /* UNIX partition */
1279     int slice;
1280     int founddrive;                                         /* flag when we find a vinum drive */
1281     struct disklabel label;                                 /* label of this drive */
1282     int driveno;                                            /* fd of drive */
1283     int found;
1284     u_int64_t drivelength;
1285
1286     if (memcmp(part, "/dev/", DEVLEN) == 0)                 /* starts with /dev */
1287         memcpy(partname, part, MAXPATHLEN);
1288     else {                                                  /* prepend */
1289         strcpy(partname, "/dev/");
1290         strncat(&partname[DEVLEN], part, MAXPATHLEN - DEVLEN);
1291     }
1292     partid = &partname[strlen(partname)];
1293     founddrive = 0;                                         /* no vinum drive found yet on this spindle */
1294     /* first try the partition table */
1295     for (slice = 1; slice < 5; slice++) {
1296         sprintf(partid, "s%dc", slice);                     /* c partition */
1297         driveno = open(partname, O_RDONLY);
1298         if (driveno < 0) {
1299             if (errno != ENOENT)
1300                 fprintf(stderr, "Can't open %s: %s (%d)\n", partname, strerror(errno), errno);
1301             continue;
1302         }
1303         if (ioctl(driveno, DIOCGDINFO, &label) < 0) {
1304             fprintf(stderr, "Can't get label from %s: %s (%d)\n", partname, strerror(errno), errno);
1305             continue;
1306         }
1307         for (partition = 'a'; partition < 'i'; partition++) {
1308             if ((partition != 'c')                          /* it's not the c partition */
1309             &&((label.d_partitions[partition - 'a'].p_fstype == FS_VINUM) /* and it's a Vinum partition */
1310             ||Verbose)) {                                   /* or we're just plain curious */
1311                 sprintf(partid, "s%d%c", slice, partition);
1312                 found = check_drive(partname);              /* try to open it */
1313                 founddrive |= found;                        /* and note if we were successful at all */
1314                 if (label.d_partitions[partition - 'a'].p_fstype == FS_VINUM) { /* it's a Vinum partition */
1315                     drivelength = ((u_int64_t) label.d_partitions[partition - 'a'].p_size) * DEV_BSIZE;
1316                     printf("Drive %s: %s (%lld bytes)\n",
1317                         partname,
1318                         roughlength(drivelength, 1),
1319                         drivelength);
1320                     if ((!found) && vflag)                  /* we're talkative */
1321                         printf("*** no configuration found ***\n");
1322                 }
1323             }
1324         }
1325     }
1326     if (founddrive == 0) {                                  /* didn't find anything, */
1327         sprintf(partid, "c");                               /* c partition */
1328         driveno = open(partname, O_RDONLY);
1329         if (driveno < 0) {
1330             if (errno != ENOENT)
1331                 fprintf(stderr, "Can't open %s: %s (%d)\n", partname, strerror(errno), errno);
1332             return;
1333         }
1334         if (ioctl(driveno, DIOCGDINFO, &label) < 0) {
1335             fprintf(stderr, "Can't get label from %s: %s (%d)\n", partname, strerror(errno), errno);
1336             return;
1337         }
1338         for (partition = 'a'; partition < 'i'; partition++) { /* try the compatibility partition */
1339             if ((partition != 'c')                          /* it's not the c partition */
1340             &&((label.d_partitions[partition - 'a'].p_fstype == FS_VINUM) /* and it's a Vinum partition */
1341             ||Verbose)) {                                   /* or we're just plain curious */
1342                 sprintf(partid, "%c", partition);
1343                 found = check_drive(partname);              /* try to open it */
1344                 founddrive |= found;                        /* and note if we were successful at all */
1345                 if (label.d_partitions[partition - 'a'].p_fstype == FS_VINUM) { /* it's a Vinum partition */
1346                     drivelength = ((u_int64_t) label.d_partitions[partition - 'a'].p_size) * DEV_BSIZE;
1347                     printf("Drive %s: %s (%lld bytes)\n",
1348                         partname,
1349                         roughlength(drivelength, 1),
1350                         drivelength);
1351                     if ((!found) && vflag)                  /* we're talkative */
1352                         printf("*** no configuration found ***\n");
1353                 }
1354             }
1355         }
1356     }
1357 }
1358
1359 /*
1360  * Check a drive for a Vinum header.  If found,
1361  * print configuration information from the drive.
1362  *
1363  * Return 1 if Vinum config found.
1364  */
1365 int
1366 check_drive(char *devicename)
1367 {
1368     int fd;
1369     char vinumlabel[DEV_BSIZE];                             /* one sector for label */
1370     struct vinum_hdr *hdr = (struct vinum_hdr *) vinumlabel; /* with this structure */
1371     char *config_text;                                      /* read the config info from disk into here */
1372     time_t t;
1373
1374     fd = open(devicename, O_RDONLY);
1375     if (fd >= 0) {
1376         if (lseek(fd, VINUM_LABEL_OFFSET, SEEK_SET) < 0) {
1377             fprintf(stderr,
1378                 "Can't seek label for %s: %s (%d)\n",
1379                 devicename,
1380                 strerror(errno),
1381                 errno);
1382             close(fd);
1383             return 0;
1384         }
1385         if (read(fd, vinumlabel, DEV_BSIZE) != DEV_BSIZE) {
1386             if (errno != EINVAL)
1387                 fprintf(stderr,
1388                     "Can't read label from %s: %s (%d)\n",
1389                     devicename,
1390                     strerror(errno),
1391                     errno);
1392             close(fd);
1393             return 0;
1394         }
1395         if ((hdr->magic == VINUM_MAGIC)
1396             || (vflag && (hdr->magic == VINUM_NOMAGIC))) {
1397             printf("Drive %s:\tDevice %s\n",
1398                 hdr->label.name,
1399                 devicename);
1400             if (hdr->magic == VINUM_NOMAGIC)
1401                 printf("*** Drive has been obliterated ***\n");
1402             t = hdr->label.date_of_birth.tv_sec;
1403             printf("\t\tCreated on %s at %s",
1404                 hdr->label.sysname,
1405                 ctime(&t));
1406             t = hdr->label.last_update.tv_sec;
1407             printf("\t\tConfig last updated %s",            /* care: \n at end */
1408                 ctime(&t));
1409             printf("\t\tSize: %16lld bytes (%lld MB)\n",
1410                 (long long) hdr->label.drive_size,          /* bytes used */
1411                 (long long) (hdr->label.drive_size / MEGABYTE));
1412             config_text = (char *) malloc(MAXCONFIG);
1413             if (config_text == NULL)
1414                 fprintf(stderr, "Can't allocate memory\n");
1415             else {
1416                 if (read(fd, config_text, MAXCONFIG) != MAXCONFIG)
1417                     fprintf(stderr,
1418                         "Can't read config from %s: %s (%d)\n",
1419                         devicename,
1420                         strerror(errno),
1421                         errno);
1422                 else
1423                     puts(config_text);
1424                 free(config_text);
1425             }
1426         }
1427         close(fd);
1428         return 1;
1429     }
1430     return 0;
1431 }
1432
1433 /* Local Variables: */
1434 /* fill-column: 50 */
1435 /* End: */