src/volser/vos.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <afsconfig.h>
  11 #include <afs/param.h>
  12
  13 RCSID
  14     ("$Header$");
  15
  16 #include <sys/types.h>
  17 #include <string.h>
  18 #ifdef AFS_NT40_ENV
  19 #include <fcntl.h>
  20 #include <io.h>
  21 #include <winsock2.h>
  22 #else
  23 #include <sys/time.h>
  24 #include <sys/file.h>
  25 #include <netdb.h>
  26 #include <netinet/in.h>
  27 #include <arpa/inet.h>
  28 #endif
  29 #include <sys/stat.h>
  30 #ifdef AFS_AIX_ENV
  31 #include <sys/statfs.h>
  32 #endif
  33 #include <errno.h>
  34
  35 #include <lock.h>
  36 #include <afs/stds.h>
  37 #include <rx/xdr.h>
  38 #include <rx/rx.h>
  39 #include <rx/rx_globals.h>
  40 #include <afs/nfs.h>
  41 #include <afs/vlserver.h>
  42 #include <afs/cellconfig.h>
  43 #include <afs/keys.h>
  44 #include <afs/afsutil.h>
  45 #include <ubik.h>
  46 #include <afs/afsint.h>
  47 #include <afs/cmd.h>
  48 #include <afs/usd.h>
  49 #include "volser.h"
  50 #include "volint.h"
  51 #include <afs/ihandle.h>
  52 #include <afs/vnode.h>
  53 #include <afs/volume.h>
  54 #include "dump.h"
  55 #include "lockdata.h"
  56
  57 #ifdef  AFS_AIX32_ENV
  58 #include <signal.h>
  59 #endif
  60 #include "volser_prototypes.h"
  61 #include "vsutils_prototypes.h"
  62 #include "lockprocs_prototypes.h"
  63
  64 #ifdef HAVE_POSIX_REGEX
  65 #include <regex.h>
  66 #endif
  67
  68 /* Local Prototypes */
  69 int PrintDiagnostics(char *astring, afs_int32 acode);
  70 int GetVolumeInfo(afs_uint32 volid, afs_int32 *server, afs_int32 *part,
  71                   afs_int32 *voltype, struct nvldbentry *rentry);
  72
  73 struct tqElem {
  74     afs_uint32 volid;
  75     struct tqElem *next;
  76 };
  77
  78 struct tqHead {
  79     afs_int32 count;
  80     struct tqElem *next;
  81 };
  82
  83 #define COMMONPARMS     cmd_Seek(ts, 12);\
  84 cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell name");\
  85 cmd_AddParm(ts, "-noauth", CMD_FLAG, CMD_OPTIONAL, "don't authenticate");\
  86 cmd_AddParm(ts, "-localauth",CMD_FLAG,CMD_OPTIONAL,"use server tickets");\
  87 cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, "verbose");\
  88 cmd_AddParm(ts, "-encrypt", CMD_FLAG, CMD_OPTIONAL, "encrypt commands");\
  89 cmd_AddParm(ts, "-noresolve", CMD_FLAG, CMD_OPTIONAL, "don't resolve addresses"); \
  90
  91 #define ERROR_EXIT(code) {error=(code); goto error_exit;}
  92
  93 int rxInitDone = 0;
  94 struct rx_connection *tconn;
  95 afs_int32 tserver;
  96 extern struct ubik_client *cstruct;
  97 const char *confdir;
  98
  99 static struct tqHead busyHead, notokHead;
 100
 101 static void
 102 qInit(struct tqHead *ahead)
 103 {
 104     memset((char *)ahead, 0, sizeof(struct tqHead));
 105     return;
 106 }
 107
 108
 109 static void
 110 qPut(struct tqHead *ahead, afs_uint32 volid)
 111 {
 112     struct tqElem *elem;
 113
 114     elem = (struct tqElem *)malloc(sizeof(struct tqElem));
 115     elem->next = ahead->next;
 116     elem->volid = volid;
 117     ahead->next = elem;
 118     ahead->count++;
 119     return;
 120 }
 121
 122 static void
 123 qGet(struct tqHead *ahead, afs_int32 *volid)
 124 {
 125     struct tqElem *tmp;
 126
 127     if (ahead->count <= 0)
 128         return;
 129     *volid = ahead->next->volid;
 130     tmp = ahead->next;
 131     ahead->next = tmp->next;
 132     ahead->count--;
 133     free(tmp);
 134     return;
 135 }
 136
 137 /* returns 1 if <filename> exists else 0 */
 138 static int
 139 FileExists(char *filename)
 140 {
 141     usd_handle_t ufd;
 142     int code;
 143     afs_hyper_t size;
 144
 145     code = usd_Open(filename, USD_OPEN_RDONLY, 0, &ufd);
 146     if (code) {
 147         return 0;
 148     }
 149     code = USD_IOCTL(ufd, USD_IOCTL_GETSIZE, &size);
 150     USD_CLOSE(ufd);
 151     if (code) {
 152         return 0;
 153     }
 154     return 1;
 155 }
 156
 157 /* returns 1 if <name> doesnot end in .readonly or .backup, else 0 */
 158 static int
 159 VolNameOK(char *name)
 160 {
 161     int total;
 162
 163
 164     total = strlen(name);
 165     if (!strcmp(&name[total - 9], ".readonly")) {
 166         return 0;
 167     } else if (!strcmp(&name[total - 7], ".backup")) {
 168         return 0;
 169     } else {
 170         return 1;
 171     }
 172 }
 173
 174 /* return 1 if name is a number else 0 */
 175 static int
 176 IsNumeric(char *name)
 177 {
 178     int result, len, i;
 179     char *ptr;
 180
 181     result = 1;
 182     ptr = name;
 183     len = strlen(name);
 184     for (i = 0; i < len; i++) {
 185         if (*ptr < '0' || *ptr > '9') {
 186             result = 0;
 187             break;
 188         }
 189         ptr++;
 190
 191     }
 192     return result;
 193 }
 194
 195
 196 /*
 197  * Parse a server name/address and return the address in HOST BYTE order
 198  */
 199 afs_int32
 200 GetServer(char *aname)
 201 {
 202     register struct hostent *th;
 203     afs_int32 addr;
 204     int b1, b2, b3, b4;
 205     register afs_int32 code;
 206     char hostname[MAXHOSTCHARS];
 207
 208     code = sscanf(aname, "%d.%d.%d.%d", &b1, &b2, &b3, &b4);
 209     if (code == 4) {
 210         addr = (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
 211         addr = ntohl(addr);     /* convert to host order */
 212     } else {
 213         th = gethostbyname(aname);
 214         if (!th)
 215             return 0;
 216         memcpy(&addr, th->h_addr, sizeof(addr));
 217     }
 218
 219     if (addr == htonl(0x7f000001)) {    /* local host */
 220         code = gethostname(hostname, MAXHOSTCHARS);
 221         if (code)
 222             return 0;
 223         th = gethostbyname(hostname);   /* returns host byte order */
 224         if (!th)
 225             return 0;
 226         memcpy(&addr, th->h_addr, sizeof(addr));
 227     }
 228
 229     return (addr);
 230 }
 231
 232 afs_int32
 233 GetVolumeType(char *aname)
 234 {
 235
 236     if (!strcmp(aname, "ro"))
 237         return (ROVOL);
 238     else if (!strcmp(aname, "rw"))
 239         return (RWVOL);
 240     else if (!strcmp(aname, "bk"))
 241         return (BACKVOL);
 242     else
 243         return (-1);
 244 }
 245
 246 int
 247 IsPartValid(afs_int32 partId, afs_int32 server, afs_int32 *code)
 248 {
 249     struct partList dummyPartList;
 250     int i, success, cnt;
 251
 252     success = 0;
 253     *code = 0;
 254
 255     *code = UV_ListPartitions(server, &dummyPartList, &cnt);
 256     if (*code)
 257         return success;
 258     for (i = 0; i < cnt; i++) {
 259         if (dummyPartList.partFlags[i] & PARTVALID)
 260             if (dummyPartList.partId[i] == partId)
 261                 success = 1;
 262     }
 263     return success;
 264 }
 265
 266
 267
 268  /*sends the contents of file associated with <fd> and <blksize>  to Rx Stream
 269   * associated  with <call> */
 270 int
 271 SendFile(usd_handle_t ufd, register struct rx_call *call, long blksize)
 272 {
 273     char *buffer = (char *)0;
 274     afs_int32 error = 0;
 275     int done = 0;
 276     afs_uint32 nbytes;
 277
 278     buffer = (char *)malloc(blksize);
 279     if (!buffer) {
 280         fprintf(STDERR, "malloc failed\n");
 281         return -1;
 282     }
 283
 284     while (!error && !done) {
 285 #ifndef AFS_NT40_ENV            /* NT csn't select on non-socket fd's */
 286         fd_set in;
 287         FD_ZERO(&in);
 288         FD_SET((int)(ufd->handle), &in);
 289         /* don't timeout if read blocks */
 290 #if defined(AFS_PTHREAD_ENV)
 291         select(((int)(ufd->handle)) + 1, &in, 0, 0, 0);
 292 #else
 293         IOMGR_Select(((int)(ufd->handle)) + 1, &in, 0, 0, 0);
 294 #endif
 295 #endif
 296         error = USD_READ(ufd, buffer, blksize, &nbytes);
 297         if (error) {
 298             fprintf(STDERR, "File system read failed\n");
 299             break;
 300         }
 301         if (nbytes == 0) {
 302             done = 1;
 303             break;
 304         }
 305         if (rx_Write(call, buffer, nbytes) != nbytes) {
 306             error = -1;
 307             break;
 308         }
 309     }
 310     if (buffer)
 311         free(buffer);
 312     return error;
 313 }
 314
 315 /* function invoked by UV_RestoreVolume, reads the data from rx_trx_stream and
 316  * writes it out to the volume. */
 317 afs_int32
 318 WriteData(struct rx_call *call, char *rock)
 319 {
 320     char *filename;
 321     usd_handle_t ufd;
 322     long blksize;
 323     afs_int32 error, code;
 324     int ufdIsOpen = 0;
 325     afs_hyper_t filesize, currOffset;
 326     afs_uint32 buffer;
 327     afs_uint32 got;
 328
 329     error = 0;
 330
 331     filename = rock;
 332     if (!filename || !*filename) {
 333         usd_StandardInput(&ufd);
 334         blksize = 4096;
 335         ufdIsOpen = 1;
 336     } else {
 337         code = usd_Open(filename, USD_OPEN_RDONLY, 0, &ufd);
 338         if (code == 0) {
 339             ufdIsOpen = 1;
 340             code = USD_IOCTL(ufd, USD_IOCTL_GETBLKSIZE, &blksize);
 341         }
 342         if (code) {
 343             fprintf(STDERR, "Could not access file '%s'\n", filename);
 344             error = VOLSERBADOP;
 345             goto wfail;
 346         }
 347         /* test if we have a valid dump */
 348         hset64(filesize, 0, 0);
 349         USD_SEEK(ufd, filesize, SEEK_END, &currOffset);
 350         hset64(filesize, hgethi(currOffset), hgetlo(currOffset)-sizeof(afs_uint32));
 351         USD_SEEK(ufd, filesize, SEEK_SET, &currOffset);
 352         USD_READ(ufd, (char *)&buffer, sizeof(afs_uint32), &got);
 353         if ((got != sizeof(afs_uint32)) || (ntohl(buffer) != DUMPENDMAGIC)) {
 354             fprintf(STDERR, "Signature missing from end of file '%s'\n", filename);
 355             error = VOLSERBADOP;
 356             goto wfail;
 357         }
 358         /* rewind, we are done */
 359         hset64(filesize, 0, 0);
 360         USD_SEEK(ufd, filesize, SEEK_SET, &currOffset);
 361     }
 362     code = SendFile(ufd, call, blksize);
 363     if (code) {
 364         error = code;
 365         goto wfail;
 366     }
 367   wfail:
 368     if (ufdIsOpen) {
 369         code = USD_CLOSE(ufd);
 370         if (code) {
 371             fprintf(STDERR, "Could not close dump file %s\n",
 372                     (filename && *filename) ? filename : "STDOUT");
 373             if (!error)
 374                 error = code;
 375         }
 376     }
 377     return error;
 378 }
 379
 380 /* Receive data from <call> stream into file associated
 381  * with <fd> <blksize>
 382  */
 383 int
 384 ReceiveFile(usd_handle_t ufd, struct rx_call *call, long blksize)
 385 {
 386     char *buffer = NULL;
 387     afs_int32 bytesread;
 388     afs_uint32 bytesleft, w;
 389     afs_int32 error = 0;
 390
 391     buffer = (char *)malloc(blksize);
 392     if (!buffer) {
 393         fprintf(STDERR, "memory allocation failed\n");
 394         ERROR_EXIT(-1);
 395     }
 396
 397     while ((bytesread = rx_Read(call, buffer, blksize)) > 0) {
 398         for (bytesleft = bytesread; bytesleft; bytesleft -= w) {
 399 #ifndef AFS_NT40_ENV            /* NT csn't select on non-socket fd's */
 400             fd_set out;
 401             FD_ZERO(&out);
 402             FD_SET((int)(ufd->handle), &out);
 403             /* don't timeout if write blocks */
 404 #if defined(AFS_PTHREAD_ENV)
 405             select(((int)(ufd->handle)) + 1, &out, 0, 0, 0);
 406 #else
 407             IOMGR_Select(((int)(ufd->handle)) + 1, 0, &out, 0, 0);
 408 #endif
 409 #endif
 410             error =
 411                 USD_WRITE(ufd, &buffer[bytesread - bytesleft], bytesleft, &w);
 412             if (error) {
 413                 fprintf(STDERR, "File system write failed\n");
 414                 ERROR_EXIT(-1);
 415             }
 416         }
 417     }
 418
 419   error_exit:
 420     if (buffer)
 421         free(buffer);
 422     return (error);
 423 }
 424
 425 afs_int32
 426 DumpFunction(struct rx_call *call, char *filename)
 427 {
 428     usd_handle_t ufd;           /* default is to stdout */
 429     afs_int32 error = 0, code;
 430     afs_hyper_t size;
 431     long blksize;
 432     int ufdIsOpen = 0;
 433
 434     /* Open the output file */
 435     if (!filename || !*filename) {
 436         usd_StandardOutput(&ufd);
 437         blksize = 4096;
 438         ufdIsOpen = 1;
 439     } else {
 440         code =
 441             usd_Open(filename, USD_OPEN_CREATE | USD_OPEN_RDWR, 0666, &ufd);
 442         if (code == 0) {
 443             ufdIsOpen = 1;
 444             hzero(size);
 445             code = USD_IOCTL(ufd, USD_IOCTL_SETSIZE, &size);
 446         }
 447         if (code == 0) {
 448             code = USD_IOCTL(ufd, USD_IOCTL_GETBLKSIZE, &blksize);
 449         }
 450         if (code) {
 451             fprintf(STDERR, "Could not create file '%s'\n", filename);
 452             ERROR_EXIT(VOLSERBADOP);
 453         }
 454     }
 455
 456     code = ReceiveFile(ufd, call, blksize);
 457     if (code)
 458         ERROR_EXIT(code);
 459
 460   error_exit:
 461     /* Close the output file */
 462     if (ufdIsOpen) {
 463         code = USD_CLOSE(ufd);
 464         if (code) {
 465             fprintf(STDERR, "Could not close dump file %s\n",
 466                     (filename && *filename) ? filename : "STDIN");
 467             if (!error)
 468                 error = code;
 469         }
 470     }
 471
 472     return (error);
 473 }
 474
 475 static char *
 476 vos_ctime(afs_int32 *timep)
 477 {
 478     time_t foo = *timep;
 479     return ctime(&foo);
 480 }
 481
 482 static void
 483 DisplayFormat(pntr, server, part, totalOK, totalNotOK, totalBusy, fast,
 484               longlist, disp)
 485      volintInfo *pntr;
 486      afs_int32 server, part;
 487      int *totalOK, *totalNotOK, *totalBusy;
 488      int fast, longlist, disp;
 489 {
 490     char pname[10];
 491
 492     if (fast) {
 493         fprintf(STDOUT, "%-10lu\n", (unsigned long)pntr->volid);
 494     } else if (longlist) {
 495         if (pntr->status == VOK) {
 496             fprintf(STDOUT, "%-32s ", pntr->name);
 497             fprintf(STDOUT, "%10lu ", (unsigned long)pntr->volid);
 498             if (pntr->type == 0)
 499                 fprintf(STDOUT, "RW ");
 500             if (pntr->type == 1)
 501                 fprintf(STDOUT, "RO ");
 502             if (pntr->type == 2)
 503                 fprintf(STDOUT, "BK ");
 504             fprintf(STDOUT, "%10d K  ", pntr->size);
 505             if (pntr->inUse == 1) {
 506                 fprintf(STDOUT, "On-line");
 507                 *totalOK += 1;
 508             } else {
 509                 fprintf(STDOUT, "Off-line");
 510                 *totalNotOK += 1;
 511             }
 512             if (pntr->needsSalvaged == 1)
 513                 fprintf(STDOUT, "**needs salvage**");
 514             fprintf(STDOUT, "\n");
 515             MapPartIdIntoName(part, pname);
 516             fprintf(STDOUT, "    %s %s \n", hostutil_GetNameByINet(server),
 517                     pname);
 518             fprintf(STDOUT, "    RWrite %10lu ROnly %10lu Backup %10lu \n",
 519                     (unsigned long)pntr->parentID,
 520                     (unsigned long)pntr->cloneID,
 521                     (unsigned long)pntr->backupID);
 522             fprintf(STDOUT, "    MaxQuota %10d K \n", pntr->maxquota);
 523             fprintf(STDOUT, "    Creation    %s",
 524                     vos_ctime(& pntr->creationDate));
 525 #ifdef FULL_LISTVOL_SWITCH
 526             fprintf(STDOUT, "    Copy        %s",
 527                     vos_ctime( & pntr->copyDate));
 528             if (!pntr->backupDate)
 529                 fprintf(STDOUT, "    Backup      Never\n");
 530             else
 531                 fprintf(STDOUT, "    Backup      %s",
 532                         vos_ctime( & pntr->backupDate));
 533             if (pntr->accessDate)
 534                 fprintf(STDOUT, "    Last Access %s",
 535                         vos_ctime( & pntr->accessDate));
 536 #endif
 537             if (!pntr->updateDate)
 538                 fprintf(STDOUT, "    Last Update Never\n");
 539             else {
 540                 fprintf(STDOUT, "    Last Update %s",
 541                         vos_ctime( & pntr->updateDate));
 542                 fprintf(STDOUT,
 543                         "    %d accesses in the past day (i.e., vnode references)\n",
 544                         pntr->dayUse);
 545             }
 546         } else if (pntr->status == VBUSY) {
 547             *totalBusy += 1;
 548             qPut(&busyHead, pntr->volid);
 549             if (disp)
 550                 fprintf(STDOUT, "**** Volume %lu is busy ****\n",
 551                         (unsigned long)pntr->volid);
 552         } else {
 553             *totalNotOK += 1;
 554             qPut(&notokHead, pntr->volid);
 555             if (disp)
 556                 fprintf(STDOUT, "**** Could not attach volume %lu ****\n",
 557                         (unsigned long)pntr->volid);
 558         }
 559         fprintf(STDOUT, "\n");
 560     } else {                    /* default listing */
 561         if (pntr->status == VOK) {
 562             fprintf(STDOUT, "%-32s ", pntr->name);
 563             fprintf(STDOUT, "%10lu ", (unsigned long)pntr->volid);
 564             if (pntr->type == 0)
 565                 fprintf(STDOUT, "RW ");
 566             if (pntr->type == 1)
 567                 fprintf(STDOUT, "RO ");
 568             if (pntr->type == 2)
 569                 fprintf(STDOUT, "BK ");
 570             fprintf(STDOUT, "%10d K ", pntr->size);
 571             if (pntr->inUse == 1) {
 572                 fprintf(STDOUT, "On-line");
 573                 *totalOK += 1;
 574             } else {
 575                 fprintf(STDOUT, "Off-line");
 576                 *totalNotOK += 1;
 577             }
 578             if (pntr->needsSalvaged == 1)
 579                 fprintf(STDOUT, "**needs salvage**");
 580             fprintf(STDOUT, "\n");
 581         } else if (pntr->status == VBUSY) {
 582             *totalBusy += 1;
 583             qPut(&busyHead, pntr->volid);
 584             if (disp)
 585                 fprintf(STDOUT, "**** Volume %lu is busy ****\n",
 586                         (unsigned long)pntr->volid);
 587         } else {
 588             *totalNotOK += 1;
 589             qPut(&notokHead, pntr->volid);
 590             if (disp)
 591                 fprintf(STDOUT, "**** Could not attach volume %lu ****\n",
 592                         (unsigned long)pntr->volid);
 593         }
 594     }
 595 }
 596
 597 /*------------------------------------------------------------------------
 598  * PRIVATE XDisplayFormat
 599  *
 600  * Description:
 601  *      Display the contents of one extended volume info structure.
 602  *
 603  * Arguments:
 604  *      a_xInfoP        : Ptr to extended volume info struct to print.
 605  *      a_servID        : Server ID to print.
 606  *      a_partID        : Partition ID to print.
 607  *      a_totalOKP      : Ptr to total-OK counter.
 608  *      a_totalNotOKP   : Ptr to total-screwed counter.
 609  *      a_totalBusyP    : Ptr to total-busy counter.
 610  *      a_fast          : Fast listing?
 611  *      a_int32         : Int32 listing?
 612  *      a_showProblems  : Show volume problems?
 613  *
 614  * Returns:
 615  *      Nothing.
 616  *
 617  * Environment:
 618  *      Nothing interesting.
 619  *
 620  * Side Effects:
 621  *      As advertised.
 622  *------------------------------------------------------------------------*/
 623
 624 static void
 625 XDisplayFormat(a_xInfoP, a_servID, a_partID, a_totalOKP, a_totalNotOKP,
 626                a_totalBusyP, a_fast, a_int32, a_showProblems)
 627      volintXInfo *a_xInfoP;
 628      afs_int32 a_servID;
 629      afs_int32 a_partID;
 630      int *a_totalOKP;
 631      int *a_totalNotOKP;
 632      int *a_totalBusyP;
 633      int a_fast;
 634      int a_int32;
 635      int a_showProblems;
 636
 637 {                               /*XDisplayFormat */
 638
 639     char pname[10];
 640
 641     if (a_fast) {
 642         /*
 643          * Short & sweet.
 644          */
 645         fprintf(STDOUT, "%-10lu\n", (unsigned long)a_xInfoP->volid);
 646     } else if (a_int32) {
 647         /*
 648          * Fully-detailed listing.
 649          */
 650         if (a_xInfoP->status == VOK) {
 651             /*
 652              * Volume's status is OK - all the fields are valid.
 653              */
 654             fprintf(STDOUT, "%-32s ", a_xInfoP->name);
 655             fprintf(STDOUT, "%10lu ", (unsigned long)a_xInfoP->volid);
 656             if (a_xInfoP->type == 0)
 657                 fprintf(STDOUT, "RW ");
 658             if (a_xInfoP->type == 1)
 659                 fprintf(STDOUT, "RO ");
 660             if (a_xInfoP->type == 2)
 661                 fprintf(STDOUT, "BK ");
 662             fprintf(STDOUT, "%10d K used ", a_xInfoP->size);
 663             fprintf(STDOUT, "%d files ", a_xInfoP->filecount);
 664             if (a_xInfoP->inUse == 1) {
 665                 fprintf(STDOUT, "On-line");
 666                 (*a_totalOKP)++;
 667             } else {
 668                 fprintf(STDOUT, "Off-line");
 669                 (*a_totalNotOKP)++;
 670             }
 671             fprintf(STDOUT, "\n");
 672             MapPartIdIntoName(a_partID, pname);
 673             fprintf(STDOUT, "    %s %s \n", hostutil_GetNameByINet(a_servID),
 674                     pname);
 675             fprintf(STDOUT, "    RWrite %10lu ROnly %10lu Backup %10lu \n",
 676                     (unsigned long)a_xInfoP->parentID,
 677                     (unsigned long)a_xInfoP->cloneID,
 678                     (unsigned long)a_xInfoP->backupID);
 679             fprintf(STDOUT, "    MaxQuota %10d K \n", a_xInfoP->maxquota);
 680             fprintf(STDOUT, "    Creation    %s",
 681                     vos_ctime( & a_xInfoP->creationDate));
 682 #ifdef FULL_LISTVOL_SWITCH
 683             fprintf(STDOUT, "    Copy        %s",
 684                     vos_ctime( & a_xInfoP->copyDate));
 685             if (!a_xInfoP->backupDate)
 686                 fprintf(STDOUT, "    Backup      Never\n");
 687             else
 688                 fprintf(STDOUT, "    Backup      %s",
 689                         vos_ctime( & a_xInfoP->backupDate));
 690             if (a_xInfoP->accessDate)
 691                 fprintf(STDOUT, "    Last Access %s",
 692                         vos_ctime( & a_xInfoP->accessDate));
 693 #endif
 694             if (!a_xInfoP->updateDate)
 695                 fprintf(STDOUT, "    Last Update Never\n");
 696             else {
 697                 fprintf(STDOUT, "    Last Update %s",
 698                         vos_ctime( & a_xInfoP->updateDate));
 699                 fprintf(STDOUT,
 700                         "    %d accesses in the past day (i.e., vnode references)\n",
 701                         a_xInfoP->dayUse);
 702             }
 703
 704             /*
 705              * Print all the read/write and authorship stats.
 706              */
 707             fprintf(STDOUT, "\n                      Raw Read/Write Stats\n");
 708             fprintf(STDOUT,
 709                     "          |-------------------------------------------|\n");
 710             fprintf(STDOUT,
 711                     "          |    Same Network     |    Diff Network     |\n");
 712             fprintf(STDOUT,
 713                     "          |----------|----------|----------|----------|\n");
 714             fprintf(STDOUT,
 715                     "          |  Total   |   Auth   |   Total  |   Auth   |\n");
 716             fprintf(STDOUT,
 717                     "          |----------|----------|----------|----------|\n");
 718             fprintf(STDOUT, "Reads     | %8d | %8d | %8d | %8d |\n",
 719                     a_xInfoP->stat_reads[VOLINT_STATS_SAME_NET],
 720                     a_xInfoP->stat_reads[VOLINT_STATS_SAME_NET_AUTH],
 721                     a_xInfoP->stat_reads[VOLINT_STATS_DIFF_NET],
 722                     a_xInfoP->stat_reads[VOLINT_STATS_DIFF_NET_AUTH]);
 723             fprintf(STDOUT, "Writes    | %8d | %8d | %8d | %8d |\n",
 724                     a_xInfoP->stat_writes[VOLINT_STATS_SAME_NET],
 725                     a_xInfoP->stat_writes[VOLINT_STATS_SAME_NET_AUTH],
 726                     a_xInfoP->stat_writes[VOLINT_STATS_DIFF_NET],
 727                     a_xInfoP->stat_writes[VOLINT_STATS_DIFF_NET_AUTH]);
 728             fprintf(STDOUT,
 729                     "          |-------------------------------------------|\n\n");
 730
 731             fprintf(STDOUT,
 732                     "                   Writes Affecting Authorship\n");
 733             fprintf(STDOUT,
 734                     "          |-------------------------------------------|\n");
 735             fprintf(STDOUT,
 736                     "          |   File Authorship   | Directory Authorship|\n");
 737             fprintf(STDOUT,
 738                     "          |----------|----------|----------|----------|\n");
 739             fprintf(STDOUT,
 740                     "          |   Same   |   Diff   |    Same  |   Diff   |\n");
 741             fprintf(STDOUT,
 742                     "          |----------|----------|----------|----------|\n");
 743             fprintf(STDOUT, "0-60 sec  | %8d | %8d | %8d | %8d |\n",
 744                     a_xInfoP->stat_fileSameAuthor[VOLINT_STATS_TIME_IDX_0],
 745                     a_xInfoP->stat_fileDiffAuthor[VOLINT_STATS_TIME_IDX_0],
 746                     a_xInfoP->stat_dirSameAuthor[VOLINT_STATS_TIME_IDX_0],
 747                     a_xInfoP->stat_dirDiffAuthor[VOLINT_STATS_TIME_IDX_0]);
 748             fprintf(STDOUT, "1-10 min  | %8d | %8d | %8d | %8d |\n",
 749                     a_xInfoP->stat_fileSameAuthor[VOLINT_STATS_TIME_IDX_1],
 750                     a_xInfoP->stat_fileDiffAuthor[VOLINT_STATS_TIME_IDX_1],
 751                     a_xInfoP->stat_dirSameAuthor[VOLINT_STATS_TIME_IDX_1],
 752                     a_xInfoP->stat_dirDiffAuthor[VOLINT_STATS_TIME_IDX_1]);
 753             fprintf(STDOUT, "10min-1hr | %8d | %8d | %8d | %8d |\n",
 754                     a_xInfoP->stat_fileSameAuthor[VOLINT_STATS_TIME_IDX_2],
 755                     a_xInfoP->stat_fileDiffAuthor[VOLINT_STATS_TIME_IDX_2],
 756                     a_xInfoP->stat_dirSameAuthor[VOLINT_STATS_TIME_IDX_2],
 757                     a_xInfoP->stat_dirDiffAuthor[VOLINT_STATS_TIME_IDX_2]);
 758             fprintf(STDOUT, "1hr-1day  | %8d | %8d | %8d | %8d |\n",
 759                     a_xInfoP->stat_fileSameAuthor[VOLINT_STATS_TIME_IDX_3],
 760                     a_xInfoP->stat_fileDiffAuthor[VOLINT_STATS_TIME_IDX_3],
 761                     a_xInfoP->stat_dirSameAuthor[VOLINT_STATS_TIME_IDX_3],
 762                     a_xInfoP->stat_dirDiffAuthor[VOLINT_STATS_TIME_IDX_3]);
 763             fprintf(STDOUT, "1day-1wk  | %8d | %8d | %8d | %8d |\n",
 764                     a_xInfoP->stat_fileSameAuthor[VOLINT_STATS_TIME_IDX_4],
 765                     a_xInfoP->stat_fileDiffAuthor[VOLINT_STATS_TIME_IDX_4],
 766                     a_xInfoP->stat_dirSameAuthor[VOLINT_STATS_TIME_IDX_4],
 767                     a_xInfoP->stat_dirDiffAuthor[VOLINT_STATS_TIME_IDX_4]);
 768             fprintf(STDOUT, "> 1wk     | %8d | %8d | %8d | %8d |\n",
 769                     a_xInfoP->stat_fileSameAuthor[VOLINT_STATS_TIME_IDX_5],
 770                     a_xInfoP->stat_fileDiffAuthor[VOLINT_STATS_TIME_IDX_5],
 771                     a_xInfoP->stat_dirSameAuthor[VOLINT_STATS_TIME_IDX_5],
 772                     a_xInfoP->stat_dirDiffAuthor[VOLINT_STATS_TIME_IDX_5]);
 773             fprintf(STDOUT,
 774                     "          |-------------------------------------------|\n");
 775         } /*Volume status OK */
 776         else if (a_xInfoP->status == VBUSY) {
 777             (*a_totalBusyP)++;
 778             qPut(&busyHead, a_xInfoP->volid);
 779             if (a_showProblems)
 780                 fprintf(STDOUT, "**** Volume %lu is busy ****\n",
 781                         (unsigned long)a_xInfoP->volid);
 782         } /*Busy volume */
 783         else {
 784             (*a_totalNotOKP)++;
 785             qPut(&notokHead, a_xInfoP->volid);
 786             if (a_showProblems)
 787                 fprintf(STDOUT, "**** Could not attach volume %lu ****\n",
 788                         (unsigned long)a_xInfoP->volid);
 789         }                       /*Screwed volume */
 790         fprintf(STDOUT, "\n");
 791     } /*Long listing */
 792     else {
 793         /*
 794          * Default listing.
 795          */
 796         if (a_xInfoP->status == VOK) {
 797             fprintf(STDOUT, "%-32s ", a_xInfoP->name);
 798             fprintf(STDOUT, "%10lu ", (unsigned long)a_xInfoP->volid);
 799             if (a_xInfoP->type == 0)
 800                 fprintf(STDOUT, "RW ");
 801             if (a_xInfoP->type == 1)
 802                 fprintf(STDOUT, "RO ");
 803             if (a_xInfoP->type == 2)
 804                 fprintf(STDOUT, "BK ");
 805             fprintf(STDOUT, "%10d K ", a_xInfoP->size);
 806             if (a_xInfoP->inUse == 1) {
 807                 fprintf(STDOUT, "On-line");
 808                 (*a_totalOKP)++;
 809             } else {
 810                 fprintf(STDOUT, "Off-line");
 811                 (*a_totalNotOKP)++;
 812             }
 813             fprintf(STDOUT, "\n");
 814         } /*Volume OK */
 815         else if (a_xInfoP->status == VBUSY) {
 816             (*a_totalBusyP)++;
 817             qPut(&busyHead, a_xInfoP->volid);
 818             if (a_showProblems)
 819                 fprintf(STDOUT, "**** Volume %lu is busy ****\n",
 820                         (unsigned long)a_xInfoP->volid);
 821         } /*Busy volume */
 822         else {
 823             (*a_totalNotOKP)++;
 824             qPut(&notokHead, a_xInfoP->volid);
 825             if (a_showProblems)
 826                 fprintf(STDOUT, "**** Could not attach volume %lu ****\n",
 827                         (unsigned long)a_xInfoP->volid);
 828         }                       /*Screwed volume */
 829     }                           /*Default listing */
 830 }                               /*XDisplayFormat */
 831
 832 #ifdef FULL_LISTVOL_SWITCH
 833 /*------------------------------------------------------------------------
 834  * PRIVATE XDisplayFormat2
 835  *
 836  * Description:
 837  *      Display the formated contents of one extended volume info structure.
 838  *
 839  * Arguments:
 840  *      a_xInfoP        : Ptr to extended volume info struct to print.
 841  *      a_servID        : Server ID to print.
 842  *      a_partID        : Partition ID to print.
 843  *      a_totalOKP      : Ptr to total-OK counter.
 844  *      a_totalNotOKP   : Ptr to total-screwed counter.
 845  *      a_totalBusyP    : Ptr to total-busy counter.
 846  *      a_fast          : Fast listing?
 847  *      a_int32         : Int32 listing?
 848  *      a_showProblems  : Show volume problems?
 849  *
 850  * Returns:
 851  *      Nothing.
 852  *
 853  * Environment:
 854  *      Nothing interesting.
 855  *
 856  * Side Effects:
 857  *      As advertised.
 858  *------------------------------------------------------------------------*/
 859
 860 static void
 861 XDisplayFormat2(a_xInfoP, a_servID, a_partID, a_totalOKP, a_totalNotOKP,
 862                a_totalBusyP, a_fast, a_int32, a_showProblems)
 863      volintXInfo *a_xInfoP;
 864      afs_int32 a_servID;
 865      afs_int32 a_partID;
 866      int *a_totalOKP;
 867      int *a_totalNotOKP;
 868      int *a_totalBusyP;
 869      int a_fast;
 870      int a_int32;
 871      int a_showProblems;
 872
 873 {                               /*XDisplayFormat */
 874     if (a_fast) {
 875         /*
 876          * Short & sweet.
 877          */
 878         fprintf(STDOUT, "vold_id\t%-10lu\n", (unsigned long)a_xInfoP->volid);
 879     } else if (a_int32) {
 880         /*
 881          * Fully-detailed listing.
 882          */
 883         if (a_xInfoP->status == VOK) {
 884             /*
 885              * Volume's status is OK - all the fields are valid.
 886              */
 887
 888                 static long server_cache = -1, partition_cache = -1;
 889                 static char hostname[256], address[32], pname[16];
 890                 int i,ai[] = {VOLINT_STATS_TIME_IDX_0,VOLINT_STATS_TIME_IDX_1,VOLINT_STATS_TIME_IDX_2,
 891                               VOLINT_STATS_TIME_IDX_3,VOLINT_STATS_TIME_IDX_4,VOLINT_STATS_TIME_IDX_5};
 892
 893                 if (a_servID != server_cache) {
 894                         struct in_addr s;
 895
 896                         s.s_addr = a_servID;
 897                         strcpy(hostname, hostutil_GetNameByINet(a_servID));
 898                         strcpy(address, inet_ntoa(s));
 899                         server_cache = a_servID;
 900                 }
 901                 if (a_partID != partition_cache) {
 902                         MapPartIdIntoName(a_partID, pname);
 903                         partition_cache = a_partID;
 904                 }
 905
 906                 fprintf(STDOUT, "name\t\t%s\n", a_xInfoP->name);
 907                 fprintf(STDOUT, "id\t\t%lu\n", afs_cast_uint32(a_xInfoP->volid));
 908                 fprintf(STDOUT, "serv\t\t%s\t%s\n", address, hostname);
 909                 fprintf(STDOUT, "part\t\t%s\n", pname);
 910                 switch (a_xInfoP->status) {
 911                 case VOK:
 912                         fprintf(STDOUT, "status\t\tOK\n");
 913                         break;
 914                 case VBUSY:
 915                         fprintf(STDOUT, "status\t\tBUSY\n");
 916                         return;
 917                 default:
 918                         fprintf(STDOUT, "status\t\tUNATTACHABLE\n");
 919                         return;
 920                 }
 921                 fprintf(STDOUT, "backupID\t%lu\n",
 922                         afs_cast_uint32(a_xInfoP->backupID));
 923                 fprintf(STDOUT, "parentID\t%lu\n",
 924                         afs_cast_uint32(a_xInfoP->parentID));
 925                 fprintf(STDOUT, "cloneID\t\t%lu\n",
 926                         afs_cast_uint32(a_xInfoP->cloneID));
 927                 fprintf(STDOUT, "inUse\t\t%s\n", a_xInfoP->inUse ? "Y" : "N");
 928                 switch (a_xInfoP->type) {
 929                 case 0:
 930                         fprintf(STDOUT, "type\t\tRW\n");
 931                         break;
 932                 case 1:
 933                         fprintf(STDOUT, "type\t\tRO\n");
 934                         break;
 935                 case 2:
 936                         fprintf(STDOUT, "type\t\tBK\n");
 937                         break;
 938                 default:
 939                         fprintf(STDOUT, "type\t\t?\n");
 940                         break;
 941                 }
 942                 fprintf(STDOUT, "creationDate\t%-9lu\t%s",
 943                         afs_cast_uint32(a_xInfoP->creationDate),
 944                         vos_ctime(&a_xInfoP->creationDate));
 945                 fprintf(STDOUT, "accessDate\t%-9lu\t%s",
 946                         afs_cast_uint32(a_xInfoP->accessDate),
 947                         vos_ctime(&a_xInfoP->accessDate));
 948                 fprintf(STDOUT, "updateDate\t%-9lu\t%s",
 949                         afs_cast_uint32(a_xInfoP->updateDate),
 950                         vos_ctime(&a_xInfoP->updateDate));
 951                 fprintf(STDOUT, "backupDate\t%-9lu\t%s",
 952                         afs_cast_uint32(a_xInfoP->backupDate),
 953                         vos_ctime(&a_xInfoP->backupDate));
 954                 fprintf(STDOUT, "copyDate\t%-9lu\t%s",
 955                         afs_cast_uint32(a_xInfoP->copyDate),
 956                         vos_ctime(&a_xInfoP->copyDate));
 957
 958                 fprintf(STDOUT, "diskused\t%u\n", a_xInfoP->size);
 959                 fprintf(STDOUT, "maxquota\t%u\n", a_xInfoP->maxquota);
 960
 961                 fprintf(STDOUT, "filecount\t%u\n", a_xInfoP->filecount);
 962                 fprintf(STDOUT, "dayUse\t\t%u\n", a_xInfoP->dayUse);
 963
 964
 965
 966                 fprintf(STDOUT,"reads_same_net\t%8d\n",a_xInfoP->stat_reads[VOLINT_STATS_SAME_NET]);
 967                 fprintf(STDOUT,"reads_same_net_auth\t%8d\n",a_xInfoP->stat_reads[VOLINT_STATS_SAME_NET_AUTH]);
 968                 fprintf(STDOUT,"reads_diff_net\t%8d\n",a_xInfoP->stat_reads[VOLINT_STATS_DIFF_NET]);
 969                 fprintf(STDOUT,"reads_diff_net_auth\t%8d\n",a_xInfoP->stat_reads[VOLINT_STATS_DIFF_NET_AUTH]);
 970
 971                 fprintf(STDOUT,"writes_same_net\t%8d\n",a_xInfoP->stat_writes[VOLINT_STATS_SAME_NET]);
 972                 fprintf(STDOUT,"writes_same_net_auth\t%8d\n",a_xInfoP->stat_writes[VOLINT_STATS_SAME_NET_AUTH]);
 973                 fprintf(STDOUT,"writes_diff_net\t%8d\n",a_xInfoP->stat_writes[VOLINT_STATS_DIFF_NET]);
 974                 fprintf(STDOUT,"writes_diff_net_auth\t%8d\n",a_xInfoP->stat_writes[VOLINT_STATS_DIFF_NET_AUTH]);
 975
 976                 for(i=0;i<5;i++)
 977                 {
 978                         fprintf(STDOUT,"file_same_author_idx_%d\t%8d\n",i+1,a_xInfoP->stat_fileSameAuthor[ai[i]]);
 979                         fprintf(STDOUT,"file_diff_author_idx_%d\t%8d\n",i+1,a_xInfoP->stat_fileDiffAuthor[ai[i]]);
 980                         fprintf(STDOUT,"dir_same_author_idx_%d\t%8d\n",i+1,a_xInfoP->stat_dirSameAuthor[ai[i]]);
 981                         fprintf(STDOUT,"dir_dif_author_idx_%d\t%8d\n",i+1,a_xInfoP->stat_dirDiffAuthor[ai[i]]);
 982                 }
 983
 984         } /*Volume status OK */
 985         else if (a_xInfoP->status == VBUSY) {
 986             (*a_totalBusyP)++;
 987             qPut(&busyHead, a_xInfoP->volid);
 988             if (a_showProblems)
 989                 fprintf(STDOUT, "BUSY_VOL\t%lu\n",
 990                         (unsigned long)a_xInfoP->volid);
 991         } /*Busy volume */
 992         else {
 993             (*a_totalNotOKP)++;
 994             qPut(&notokHead, a_xInfoP->volid);
 995             if (a_showProblems)
 996                 fprintf(STDOUT, "COULD_NOT_ATTACH\t%lu\n",
 997                         (unsigned long)a_xInfoP->volid);
 998         }                       /*Screwed volume */
 999     } /*Long listing */
1000     else {
1001         /*
1002          * Default listing.
1003          */
1004         if (a_xInfoP->status == VOK) {
1005             fprintf(STDOUT, "name\t%-32s\n", a_xInfoP->name);
1006             fprintf(STDOUT, "volID\t%10lu\n", (unsigned long)a_xInfoP->volid);
1007             if (a_xInfoP->type == 0)
1008                 fprintf(STDOUT, "type\tRW\n");
1009             if (a_xInfoP->type == 1)
1010                 fprintf(STDOUT, "type\tRO\n");
1011             if (a_xInfoP->type == 2)
1012                 fprintf(STDOUT, "type\tBK\n");
1013             fprintf(STDOUT, "size\t%10dK\n", a_xInfoP->size);
1014
1015             fprintf(STDOUT, "inUse\t%d\n",a_xInfoP->inUse);
1016             if (a_xInfoP->inUse == 1)
1017                 (*a_totalOKP)++;
1018             else
1019                 (*a_totalNotOKP)++;
1020
1021         } /*Volume OK */
1022         else if (a_xInfoP->status == VBUSY) {
1023             (*a_totalBusyP)++;
1024             qPut(&busyHead, a_xInfoP->volid);
1025             if (a_showProblems)
1026                 fprintf(STDOUT, "VOLUME_BUSY\t%lu\n",
1027                         (unsigned long)a_xInfoP->volid);
1028         } /*Busy volume */
1029         else {
1030             (*a_totalNotOKP)++;
1031             qPut(&notokHead, a_xInfoP->volid);
1032             if (a_showProblems)
1033                 fprintf(STDOUT, "COULD_NOT_ATTACH_VOLUME\t%lu\n",
1034                         (unsigned long)a_xInfoP->volid);
1035         }                       /*Screwed volume */
1036     }                           /*Default listing */
1037 }                               /*XDisplayFormat */
1038 #endif /*FULL_LISTVOL_SWITCH*/
1039
1040 #ifdef FULL_LISTVOL_SWITCH
1041 static void
1042 DisplayFormat2(server, partition, pntr)
1043      long server, partition;
1044      volintInfo *pntr;
1045 {
1046     static long server_cache = -1, partition_cache = -1;
1047     static char hostname[256], address[32], pname[16];
1048
1049     if (server != server_cache) {
1050         struct in_addr s;
1051
1052         s.s_addr = server;
1053         strcpy(hostname, hostutil_GetNameByINet(server));
1054         strcpy(address, inet_ntoa(s));
1055         server_cache = server;
1056     }
1057     if (partition != partition_cache) {
1058         MapPartIdIntoName(partition, pname);
1059         partition_cache = partition;
1060     }
1061     fprintf(STDOUT, "name\t\t%s\n", pntr->name);
1062     fprintf(STDOUT, "id\t\t%lu\n",
1063             afs_cast_uint32(pntr->volid));
1064     fprintf(STDOUT, "serv\t\t%s\t%s\n", address, hostname);
1065     fprintf(STDOUT, "part\t\t%s\n", pname);
1066     switch (pntr->status) {
1067     case VOK:
1068         fprintf(STDOUT, "status\t\tOK\n");
1069         break;
1070     case VBUSY:
1071         fprintf(STDOUT, "status\t\tBUSY\n");
1072         return;
1073     default:
1074         fprintf(STDOUT, "status\t\tUNATTACHABLE\n");
1075         return;
1076     }
1077     fprintf(STDOUT, "backupID\t%lu\n",
1078             afs_cast_uint32(pntr->backupID));
1079     fprintf(STDOUT, "parentID\t%lu\n",
1080             afs_cast_uint32(pntr->parentID));
1081     fprintf(STDOUT, "cloneID\t\t%lu\n",
1082             afs_cast_uint32(pntr->cloneID));
1083     fprintf(STDOUT, "inUse\t\t%s\n", pntr->inUse ? "Y" : "N");
1084     fprintf(STDOUT, "needsSalvaged\t%s\n", pntr->needsSalvaged ? "Y" : "N");
1085     /* 0xD3 is from afs/volume.h since I had trouble including the file */
1086     fprintf(STDOUT, "destroyMe\t%s\n", pntr->destroyMe == 0xD3 ? "Y" : "N");
1087     switch (pntr->type) {
1088     case 0:
1089         fprintf(STDOUT, "type\t\tRW\n");
1090         break;
1091     case 1:
1092         fprintf(STDOUT, "type\t\tRO\n");
1093         break;
1094     case 2:
1095         fprintf(STDOUT, "type\t\tBK\n");
1096         break;
1097     default:
1098         fprintf(STDOUT, "type\t\t?\n");
1099         break;
1100     }
1101     fprintf(STDOUT, "creationDate\t%-9lu\t%s",
1102             afs_cast_uint32(pntr->creationDate),
1103             vos_ctime(&pntr->creationDate));
1104     fprintf(STDOUT, "accessDate\t%-9lu\t%s",
1105             afs_cast_uint32(pntr->accessDate),
1106             vos_ctime(&pntr->accessDate));
1107     fprintf(STDOUT, "updateDate\t%-9lu\t%s",
1108             afs_cast_uint32(pntr->updateDate),
1109             vos_ctime(&pntr->updateDate));
1110     fprintf(STDOUT, "backupDate\t%-9lu\t%s",
1111             afs_cast_uint32(pntr->backupDate),
1112             vos_ctime(&pntr->backupDate));
1113     fprintf(STDOUT, "copyDate\t%-9lu\t%s",
1114             afs_cast_uint32(pntr->copyDate),
1115             vos_ctime(&pntr->copyDate));
1116     fprintf(STDOUT, "flags\t\t%#lx\t(Optional)\n",
1117             afs_cast_uint32(pntr->flags));
1118     fprintf(STDOUT, "diskused\t%u\n", pntr->size);
1119     fprintf(STDOUT, "maxquota\t%u\n", pntr->maxquota);
1120     fprintf(STDOUT, "minquota\t%lu\t(Optional)\n",
1121             afs_cast_uint32(pntr->spare0));
1122     fprintf(STDOUT, "filecount\t%u\n", pntr->filecount);
1123     fprintf(STDOUT, "dayUse\t\t%u\n", pntr->dayUse);
1124     fprintf(STDOUT, "weekUse\t\t%lu\t(Optional)\n",
1125             afs_cast_uint32(pntr->spare1));
1126     fprintf(STDOUT, "spare2\t\t%lu\t(Optional)\n",
1127             afs_cast_uint32(pntr->spare2));
1128     fprintf(STDOUT, "spare3\t\t%lu\t(Optional)\n",
1129             afs_cast_uint32(pntr->spare3));
1130     return;
1131 }
1132
1133 static void
1134 DisplayVolumes2(server, partition, pntr, count)
1135      volintInfo *pntr;
1136      long server, partition, count;
1137 {
1138     long i;
1139
1140     for (i = 0; i < count; i++) {
1141         fprintf(STDOUT, "BEGIN_OF_ENTRY\n");
1142         DisplayFormat2(server, partition, pntr);
1143         fprintf(STDOUT, "END_OF_ENTRY\n\n");
1144         pntr++;
1145     }
1146     return;
1147 }
1148 #endif /* FULL_LISTVOL_SWITCH */
1149
1150 static void
1151 DisplayVolumes(server, part, pntr, count, longlist, fast, quiet)
1152      afs_int32 server, part;
1153      volintInfo *pntr;
1154      afs_int32 count, longlist, fast;
1155      int quiet;
1156 {
1157     int totalOK, totalNotOK, totalBusy, i;
1158     afs_uint32 volid = 0;
1159
1160     totalOK = 0;
1161     totalNotOK = 0;
1162     totalBusy = 0;
1163     qInit(&busyHead);
1164     qInit(&notokHead);
1165     for (i = 0; i < count; i++) {
1166         DisplayFormat(pntr, server, part, &totalOK, &totalNotOK, &totalBusy,
1167                       fast, longlist, 0);
1168         pntr++;
1169     }
1170     if (totalBusy) {
1171         while (busyHead.count) {
1172             qGet(&busyHead, &volid);
1173             fprintf(STDOUT, "**** Volume %lu is busy ****\n",
1174                     (unsigned long)volid);
1175         }
1176     }
1177     if (totalNotOK) {
1178         while (notokHead.count) {
1179             qGet(&notokHead, &volid);
1180             fprintf(STDOUT, "**** Could not attach volume %lu ****\n",
1181                     (unsigned long)volid);
1182         }
1183     }
1184     if (!quiet) {
1185         fprintf(STDOUT, "\n");
1186         if (!fast) {
1187             fprintf(STDOUT,
1188                     "Total volumes onLine %d ; Total volumes offLine %d ; Total busy %d\n\n",
1189                     totalOK, totalNotOK, totalBusy);
1190         }
1191     }
1192 }
1193 /*------------------------------------------------------------------------
1194  * PRIVATE XDisplayVolumes
1195  *
1196  * Description:
1197  *      Display extended volume information.
1198  *
1199  * Arguments:
1200  *      a_servID : Pointer to the Rx call we're performing.
1201  *      a_partID : Partition for which we want the extended list.
1202  *      a_xInfoP : Ptr to extended volume info.
1203  *      a_count  : Number of volume records contained above.
1204  *      a_int32   : Int32 listing generated?
1205  *      a_fast   : Fast listing generated?
1206  *      a_quiet  : Quiet listing generated?
1207  *
1208  * Returns:
1209  *      Nothing.
1210  *
1211  * Environment:
1212  *      Nothing interesting.
1213  *
1214  * Side Effects:
1215  *      As advertised.
1216  *------------------------------------------------------------------------*/
1217
1218 static void
1219 XDisplayVolumes(a_servID, a_partID, a_xInfoP, a_count, a_int32, a_fast,
1220                 a_quiet)
1221      afs_int32 a_servID;
1222      afs_int32 a_partID;
1223      volintXInfo *a_xInfoP;
1224      afs_int32 a_count;
1225      afs_int32 a_int32;
1226      afs_int32 a_fast;
1227      int a_quiet;
1228
1229 {                               /*XDisplayVolumes */
1230
1231     int totalOK;                /*Total OK volumes */
1232     int totalNotOK;             /*Total screwed volumes */
1233     int totalBusy;              /*Total busy volumes */
1234     int i;                      /*Loop variable */
1235     afs_uint32 volid = 0;       /*Current volume ID */
1236
1237     /*
1238      * Initialize counters and (global!!) queues.
1239      */
1240     totalOK = 0;
1241     totalNotOK = 0;
1242     totalBusy = 0;
1243     qInit(&busyHead);
1244     qInit(&notokHead);
1245
1246     /*
1247      * Display each volume in the list.
1248      */
1249     for (i = 0; i < a_count; i++) {
1250         XDisplayFormat(a_xInfoP, a_servID, a_partID, &totalOK, &totalNotOK,
1251                        &totalBusy, a_fast, a_int32, 0);
1252         a_xInfoP++;
1253     }
1254
1255     /*
1256      * If any volumes were found to be busy or screwed, display them.
1257      */
1258     if (totalBusy) {
1259         while (busyHead.count) {
1260             qGet(&busyHead, &volid);
1261             fprintf(STDOUT, "**** Volume %lu is busy ****\n",
1262                     (unsigned long)volid);
1263         }
1264     }
1265     if (totalNotOK) {
1266         while (notokHead.count) {
1267             qGet(&notokHead, &volid);
1268             fprintf(STDOUT, "**** Could not attach volume %lu ****\n",
1269                     (unsigned long)volid);
1270         }
1271     }
1272
1273     if (!a_quiet) {
1274         fprintf(STDOUT, "\n");
1275         if (!a_fast) {
1276             fprintf(STDOUT,
1277                     "Total volumes: %d on-line, %d off-line, %d  busyd\n\n",
1278                     totalOK, totalNotOK, totalBusy);
1279         }
1280     }
1281
1282 }                               /*XDisplayVolumes */
1283 #ifdef FULL_LISTVOL_SWITCH
1284 /*------------------------------------------------------------------------
1285  * PRIVATE XDisplayVolumes2
1286  *
1287  * Description:
1288  *      Display extended formated volume information.
1289  *
1290  * Arguments:
1291  *      a_servID : Pointer to the Rx call we're performing.
1292  *      a_partID : Partition for which we want the extended list.
1293  *      a_xInfoP : Ptr to extended volume info.
1294  *      a_count  : Number of volume records contained above.
1295  *      a_int32   : Int32 listing generated?
1296  *      a_fast   : Fast listing generated?
1297  *      a_quiet  : Quiet listing generated?
1298  *
1299  * Returns:
1300  *      Nothing.
1301  *
1302  * Environment:
1303  *      Nothing interesting.
1304  *
1305  * Side Effects:
1306  *      As advertised.
1307  *------------------------------------------------------------------------*/
1308
1309 static void
1310 XDisplayVolumes2(a_servID, a_partID, a_xInfoP, a_count, a_int32, a_fast,
1311                 a_quiet)
1312      afs_int32 a_servID;
1313      afs_int32 a_partID;
1314      volintXInfo *a_xInfoP;
1315      afs_int32 a_count;
1316      afs_int32 a_int32;
1317      afs_int32 a_fast;
1318      int a_quiet;
1319
1320 {                               /*XDisplayVolumes */
1321
1322     int totalOK;                /*Total OK volumes */
1323     int totalNotOK;             /*Total screwed volumes */
1324     int totalBusy;              /*Total busy volumes */
1325     int i;                      /*Loop variable */
1326     afs_uint32 volid = 0;       /*Current volume ID */
1327
1328     /*
1329      * Initialize counters and (global!!) queues.
1330      */
1331     totalOK = 0;
1332     totalNotOK = 0;
1333     totalBusy = 0;
1334     qInit(&busyHead);
1335     qInit(&notokHead);
1336
1337     /*
1338      * Display each volume in the list.
1339      */
1340     for (i = 0; i < a_count; i++) {
1341         fprintf(STDOUT, "BEGIN_OF_ENTRY\n");
1342         XDisplayFormat2(a_xInfoP, a_servID, a_partID, &totalOK, &totalNotOK,
1343                        &totalBusy, a_fast, a_int32, 0);
1344         fprintf(STDOUT, "END_OF_ENTRY\n");
1345         a_xInfoP++;
1346     }
1347
1348     /*
1349      * If any volumes were found to be busy or screwed, display them.
1350      */
1351     if (totalBusy) {
1352         while (busyHead.count) {
1353             qGet(&busyHead, &volid);
1354             fprintf(STDOUT, "BUSY_VOL\t%lu\n",
1355                     (unsigned long)volid);
1356         }
1357     }
1358     if (totalNotOK) {
1359         while (notokHead.count) {
1360             qGet(&notokHead, &volid);
1361             fprintf(STDOUT, "COULD_NOT_ATTACH\t%lu\n",
1362                     (unsigned long)volid);
1363         }
1364     }
1365
1366     if (!a_quiet) {
1367         fprintf(STDOUT, "\n");
1368         if (!a_fast) {
1369             fprintf(STDOUT,
1370                     "VOLUMES_ONLINE\t%d\nVOLUMES_OFFLINE\t%d\nVOLUMES_BUSY\t%d\n",
1371                     totalOK, totalNotOK, totalBusy);
1372         }
1373     }
1374
1375 }                               /*XDisplayVolumes2 */
1376 #endif /* FULL_LISTVOL_SWITCH */
1377
1378
1379 /* set <server> and <part> to the correct values depending on
1380  * <voltype> and <entry> */
1381 static void
1382 GetServerAndPart(entry, voltype, server, part, previdx)
1383      struct nvldbentry *entry;
1384      afs_int32 *server, *part;
1385      int voltype;
1386      int *previdx;
1387 {
1388     int i, istart, vtype;
1389
1390     *server = -1;
1391     *part = -1;
1392
1393     /* Doesn't check for non-existance of backup volume */
1394     if ((voltype == RWVOL) || (voltype == BACKVOL)) {
1395         vtype = ITSRWVOL;
1396         istart = 0;             /* seach the entire entry */
1397     } else {
1398         vtype = ITSROVOL;
1399         /* Seach from beginning of entry or pick up where we left off */
1400         istart = ((*previdx < 0) ? 0 : *previdx + 1);
1401     }
1402
1403     for (i = istart; i < entry->nServers; i++) {
1404         if (entry->serverFlags[i] & vtype) {
1405             *server = entry->serverNumber[i];
1406             *part = entry->serverPartition[i];
1407             *previdx = i;
1408             return;
1409         }
1410     }
1411
1412     /* Didn't find any, return -1 */
1413     *previdx = -1;
1414     return;
1415 }
1416
1417 static void
1418 PostVolumeStats(struct nvldbentry *entry)
1419 {
1420     SubEnumerateEntry(entry);
1421     /* Check for VLOP_ALLOPERS */
1422     if (entry->flags & VLOP_ALLOPERS)
1423         fprintf(STDOUT, "    Volume is currently LOCKED  \n");
1424     return;
1425 }
1426
1427 /*------------------------------------------------------------------------
1428  * PRIVATE XVolumeStats
1429  *
1430  * Description:
1431  *      Display extended volume information.
1432  *
1433  * Arguments:
1434  *      a_xInfoP  : Ptr to extended volume info.
1435  *      a_entryP  : Ptr to the volume's VLDB entry.
1436  *      a_srvID   : Server ID.
1437  *      a_partID  : Partition ID.
1438  *      a_volType : Type of volume to print.
1439  *
1440  * Returns:
1441  *      Nothing.
1442  *
1443  * Environment:
1444  *      Nothing interesting.
1445  *
1446  * Side Effects:
1447  *      As advertised.
1448  *------------------------------------------------------------------------*/
1449
1450 static void
1451 XVolumeStats(a_xInfoP, a_entryP, a_srvID, a_partID, a_volType)
1452      volintXInfo *a_xInfoP;
1453      struct nvldbentry *a_entryP;
1454      afs_int32 a_srvID;
1455      afs_int32 a_partID;
1456      int a_volType;
1457
1458 {                               /*XVolumeStats */
1459
1460     int totalOK, totalNotOK, totalBusy; /*Dummies - we don't really count here */
1461
1462     XDisplayFormat(a_xInfoP,    /*Ptr to extended volume info */
1463                    a_srvID,     /*Server ID to print */
1464                    a_partID,    /*Partition ID to print */
1465                    &totalOK,    /*Ptr to total-OK counter */
1466                    &totalNotOK, /*Ptr to total-screwed counter */
1467                    &totalBusy,  /*Ptr to total-busy counter */
1468                    0,           /*Don't do a fast listing */
1469                    1,           /*Do a long listing */
1470                    1);          /*Show volume problems */
1471     return;
1472
1473 }                               /*XVolumeStats */
1474
1475 static void
1476 VolumeStats_int(volintInfo *pntr, struct nvldbentry *entry, afs_int32 server,
1477              afs_int32 part, int voltype)
1478 {
1479     int totalOK, totalNotOK, totalBusy;
1480
1481     DisplayFormat(pntr, server, part, &totalOK, &totalNotOK, &totalBusy, 0, 1,
1482                   1);
1483     return;
1484 }
1485
1486 /* command to forcibly remove a volume */
1487 static int
1488 NukeVolume(register struct cmd_syndesc *as)
1489 {
1490     register afs_int32 code;
1491     afs_uint32 volID;
1492     afs_int32  err;
1493     afs_int32 partID;
1494     afs_int32 server;
1495     register char *tp;
1496
1497     server = GetServer(tp = as->parms[0].items->data);
1498     if (!server) {
1499         fprintf(STDERR, "vos: server '%s' not found in host table\n", tp);
1500         return 1;
1501     }
1502
1503     partID = volutil_GetPartitionID(tp = as->parms[1].items->data);
1504     if (partID == -1) {
1505         fprintf(STDERR, "vos: could not parse '%s' as a partition name", tp);
1506         return 1;
1507     }
1508
1509     volID = vsu_GetVolumeID(tp = as->parms[2].items->data, cstruct, &err);
1510     if (volID == 0) {
1511         if (err)
1512             PrintError("", err);
1513         else
1514             fprintf(STDERR,
1515                     "vos: could not parse '%s' as a numeric volume ID", tp);
1516         return 1;
1517     }
1518
1519     fprintf(STDOUT,
1520             "vos: forcibly removing all traces of volume %d, please wait...",
1521             volID);
1522     fflush(STDOUT);
1523     code = UV_NukeVolume(server, partID, volID);
1524     if (code == 0)
1525         fprintf(STDOUT, "done.\n");
1526     else
1527         fprintf(STDOUT, "failed with code %d.\n", code);
1528     return code;
1529 }
1530
1531
1532 /*------------------------------------------------------------------------
1533  * PRIVATE ExamineVolume
1534  *
1535  * Description:
1536  *      Routine used to examine a single volume, contacting the VLDB as
1537  *      well as the Volume Server.
1538  *
1539  * Arguments:
1540  *      as : Ptr to parsed command line arguments.
1541  *
1542  * Returns:
1543  *      0 for a successful operation,
1544  *      Otherwise, one of the ubik or VolServer error values.
1545  *
1546  * Environment:
1547  *      Nothing interesting.
1548  *
1549  * Side Effects:
1550  *      As advertised.
1551  *------------------------------------------------------------------------
1552  */
1553 static int
1554 ExamineVolume(register struct cmd_syndesc *as, void *arock)
1555 {
1556     struct nvldbentry entry;
1557     afs_int32 vcode = 0;
1558     volintInfo *pntr = (volintInfo *) 0;
1559     volintXInfo *xInfoP = (volintXInfo *) 0;
1560     afs_uint32 volid;
1561     afs_int32 code, err, error = 0;
1562     int voltype, foundserv = 0, foundentry = 0;
1563     afs_int32 aserver, apart;
1564     int previdx = -1;
1565     int wantExtendedInfo;       /*Do we want extended vol info? */
1566
1567     wantExtendedInfo = (as->parms[1].items ? 1 : 0);    /* -extended */
1568
1569     volid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);   /* -id */
1570     if (volid == 0) {
1571         if (err)
1572             PrintError("", err);
1573         else
1574             fprintf(STDERR, "Unknown volume ID or name '%s'\n",
1575                     as->parms[0].items->data);
1576         return -1;
1577     }
1578
1579     if (verbose) {
1580         fprintf(STDOUT, "Fetching VLDB entry for %lu .. ",
1581                 (unsigned long)volid);
1582         fflush(STDOUT);
1583     }
1584     vcode = VLDB_GetEntryByID(volid, -1, &entry);
1585     if (vcode) {
1586         fprintf(STDERR,
1587                 "Could not fetch the entry for volume number %lu from VLDB \n",
1588                 (unsigned long)volid);
1589         return (vcode);
1590     }
1591     if (verbose)
1592         fprintf(STDOUT, "done\n");
1593     MapHostToNetwork(&entry);
1594
1595     if (entry.volumeId[RWVOL] == volid)
1596         voltype = RWVOL;
1597     else if (entry.volumeId[BACKVOL] == volid)
1598         voltype = BACKVOL;
1599     else                        /* (entry.volumeId[ROVOL] == volid) */
1600         voltype = ROVOL;
1601
1602     do {                        /* do {...} while (voltype == ROVOL) */
1603         /* Get the entry for the volume. If its a RW vol, get the RW entry.
1604          * It its a BK vol, get the RW entry (even if VLDB may say the BK doen't exist).
1605          * If its a RO vol, get the next RO entry.
1606          */
1607         GetServerAndPart(&entry, ((voltype == ROVOL) ? ROVOL : RWVOL),
1608                          &aserver, &apart, &previdx);
1609         if (previdx == -1) {    /* searched all entries */
1610             if (!foundentry) {
1611                 fprintf(STDERR, "Volume %s does not exist in VLDB\n\n",
1612                         as->parms[0].items->data);
1613                 error = ENOENT;
1614             }
1615             break;
1616         }
1617         foundentry = 1;
1618
1619         /* Get information about the volume from the server */
1620         if (verbose) {
1621             fprintf(STDOUT, "Getting volume listing from the server %s .. ",
1622                     hostutil_GetNameByINet(aserver));
1623             fflush(STDOUT);
1624         }
1625         if (wantExtendedInfo)
1626             code = UV_XListOneVolume(aserver, apart, volid, &xInfoP);
1627         else
1628             code = UV_ListOneVolume(aserver, apart, volid, &pntr);
1629         if (verbose)
1630             fprintf(STDOUT, "done\n");
1631
1632         if (code) {
1633             error = code;
1634             if (code == ENODEV) {
1635                 if ((voltype == BACKVOL) && !(entry.flags & BACK_EXISTS)) {
1636                     /* The VLDB says there is no backup volume and its not on disk */
1637                     fprintf(STDERR, "Volume %s does not exist\n",
1638                             as->parms[0].items->data);
1639                     error = ENOENT;
1640                 } else {
1641                     fprintf(STDERR,
1642                             "Volume does not exist on server %s as indicated by the VLDB\n",
1643                             hostutil_GetNameByINet(aserver));
1644                 }
1645             } else {
1646                 PrintDiagnostics("examine", code);
1647             }
1648             fprintf(STDOUT, "\n");
1649         } else {
1650             foundserv = 1;
1651             if (wantExtendedInfo)
1652                 XVolumeStats(xInfoP, &entry, aserver, apart, voltype);
1653             else
1654 #ifdef FULL_LISTVOL_SWITCH
1655             if (as->parms[2].items) {
1656                 DisplayFormat2(aserver, apart, pntr);
1657                 EnumerateEntry(&entry);
1658             } else
1659 #endif /* FULL_LISTVOL_SWITCH */
1660                 VolumeStats_int(pntr, &entry, aserver, apart, voltype);
1661
1662             if ((voltype == BACKVOL) && !(entry.flags & BACK_EXISTS)) {
1663                 /* The VLDB says there is no backup volume yet we found one on disk */
1664                 fprintf(STDERR, "Volume %s does not exist in VLDB\n",
1665                         as->parms[0].items->data);
1666                 error = ENOENT;
1667             }
1668         }
1669
1670         if (pntr)
1671             free(pntr);
1672         if (xInfoP)
1673             free(xInfoP);
1674     } while (voltype == ROVOL);
1675
1676     if (!foundserv) {
1677         fprintf(STDERR, "Dump only information from VLDB\n\n");
1678         fprintf(STDOUT, "%s \n", entry.name);   /* PostVolumeStats doesn't print name */
1679     }
1680     PostVolumeStats(&entry);
1681
1682     return (error);
1683 }
1684
1685 /*------------------------------------------------------------------------
1686  * PRIVATE SetFields
1687  *
1688  * Description:
1689  *      Routine used to change the status of a single volume.
1690  *
1691  * Arguments:
1692  *      as : Ptr to parsed command line arguments.
1693  *
1694  * Returns:
1695  *      0 for a successful operation,
1696  *      Otherwise, one of the ubik or VolServer error values.
1697  *
1698  * Environment:
1699  *      Nothing interesting.
1700  *
1701  * Side Effects:
1702  *      As advertised.
1703  *------------------------------------------------------------------------
1704  */
1705 static int
1706 SetFields(register struct cmd_syndesc *as, void *arock)
1707 {
1708     struct nvldbentry entry;
1709     afs_int32 vcode = 0;
1710     volintInfo info;
1711     afs_uint32 volid;
1712     afs_int32 code, err;
1713     afs_int32 aserver, apart;
1714     int previdx = -1;
1715
1716     volid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);   /* -id */
1717     if (volid == 0) {
1718         if (err)
1719             PrintError("", err);
1720         else
1721             fprintf(STDERR, "Unknown volume ID or name '%s'\n",
1722                     as->parms[0].items->data);
1723         return -1;
1724     }
1725
1726     code = VLDB_GetEntryByID(volid, RWVOL, &entry);
1727     if (code) {
1728         fprintf(STDERR,
1729                 "Could not fetch the entry for volume number %lu from VLDB \n",
1730                 (unsigned long)volid);
1731         return (code);
1732     }
1733     MapHostToNetwork(&entry);
1734
1735     GetServerAndPart(&entry, RWVOL, &aserver, &apart, &previdx);
1736     if (previdx == -1) {
1737         fprintf(STDERR, "Volume %s does not exist in VLDB\n\n",
1738                 as->parms[0].items->data);
1739         return (ENOENT);
1740     }
1741
1742     init_volintInfo(&info);
1743     info.volid = volid;
1744     info.type = RWVOL;
1745
1746     if (as->parms[1].items) {
1747         /* -max <quota> */
1748         code = util_GetInt32(as->parms[1].items->data, &info.maxquota);
1749         if (code) {
1750             fprintf(STDERR, "invalid quota value\n");
1751             return code;
1752         }
1753     }
1754     if (as->parms[2].items) {
1755         /* -clearuse */
1756         info.dayUse = 0;
1757     }
1758     if (as->parms[3].items) {
1759         /* -clearVolUpCounter */
1760         info.spare2 = 0;
1761     }
1762     code = UV_SetVolumeInfo(aserver, apart, volid, &info);
1763     if (code)
1764         fprintf(STDERR,
1765                 "Could not update volume info fields for volume number %lu\n",
1766                 (unsigned long)volid);
1767     return (code);
1768 }
1769
1770 /*------------------------------------------------------------------------
1771  * PRIVATE volOnline
1772  *
1773  * Description:
1774  *      Brings a volume online.
1775  *
1776  * Arguments:
1777  *      as : Ptr to parsed command line arguments.
1778  *
1779  * Returns:
1780  *      0 for a successful operation,
1781  *
1782  * Environment:
1783  *      Nothing interesting.
1784  *
1785  * Side Effects:
1786  *      As advertised.
1787  *------------------------------------------------------------------------
1788  */
1789 static int
1790 volOnline(register struct cmd_syndesc *as, void *arock)
1791 {
1792     afs_int32 server, partition;
1793     afs_uint32 volid;
1794     afs_int32 code, err = 0;
1795
1796     server = GetServer(as->parms[0].items->data);
1797     if (server == 0) {
1798         fprintf(STDERR, "vos: server '%s' not found in host table\n",
1799                 as->parms[0].items->data);
1800         return -1;
1801     }
1802
1803     partition = volutil_GetPartitionID(as->parms[1].items->data);
1804     if (partition < 0) {
1805         fprintf(STDERR, "vos: could not interpret partition name '%s'\n",
1806                 as->parms[1].items->data);
1807         return ENOENT;
1808     }
1809
1810     volid = vsu_GetVolumeID(as->parms[2].items->data, cstruct, &err);   /* -id */
1811     if (!volid) {
1812         if (err)
1813             PrintError("", err);
1814         else
1815             fprintf(STDERR, "Unknown volume ID or name '%s'\n",
1816                     as->parms[0].items->data);
1817         return -1;
1818     }
1819
1820     code = UV_SetVolume(server, partition, volid, ITOffline, 0 /*online */ ,
1821                         0 /*sleep */ );
1822     if (code) {
1823         fprintf(STDERR, "Failed to set volume. Code = %d\n", code);
1824         return -1;
1825     }
1826
1827     return 0;
1828 }
1829
1830 /*------------------------------------------------------------------------
1831  * PRIVATE volOffline
1832  *
1833  * Description:
1834  *      Brings a volume offline.
1835  *
1836  * Arguments:
1837  *      as : Ptr to parsed command line arguments.
1838  *
1839  * Returns:
1840  *      0 for a successful operation,
1841  *
1842  * Environment:
1843  *      Nothing interesting.
1844  *
1845  * Side Effects:
1846  *      As advertised.
1847  *------------------------------------------------------------------------
1848  */
1849 static int
1850 volOffline(register struct cmd_syndesc *as, void *arock)
1851 {
1852     afs_int32 server, partition;
1853     afs_uint32 volid;
1854     afs_int32 code, err = 0;
1855     afs_int32 transflag, sleeptime, transdone;
1856
1857     server = GetServer(as->parms[0].items->data);
1858     if (server == 0) {
1859         fprintf(STDERR, "vos: server '%s' not found in host table\n",
1860                 as->parms[0].items->data);
1861         return -1;
1862     }
1863
1864     partition = volutil_GetPartitionID(as->parms[1].items->data);
1865     if (partition < 0) {
1866         fprintf(STDERR, "vos: could not interpret partition name '%s'\n",
1867                 as->parms[1].items->data);
1868         return ENOENT;
1869     }
1870
1871     volid = vsu_GetVolumeID(as->parms[2].items->data, cstruct, &err);   /* -id */
1872     if (!volid) {
1873         if (err)
1874             PrintError("", err);
1875         else
1876             fprintf(STDERR, "Unknown volume ID or name '%s'\n",
1877                     as->parms[0].items->data);
1878         return -1;
1879     }
1880
1881     transflag = (as->parms[4].items ? ITBusy : ITOffline);
1882     sleeptime = (as->parms[3].items ? atol(as->parms[3].items->data) : 0);
1883     transdone = (sleeptime ? 0 /*online */ : VTOutOfService);
1884     if (as->parms[4].items && !as->parms[3].items) {
1885         fprintf(STDERR, "-sleep option must be used with -busy flag\n");
1886         return -1;
1887     }
1888
1889     code =
1890         UV_SetVolume(server, partition, volid, transflag, transdone,
1891                      sleeptime);
1892     if (code) {
1893         fprintf(STDERR, "Failed to set volume. Code = %d\n", code);
1894         return -1;
1895     }
1896
1897     return 0;
1898 }
1899
1900 static int
1901 CreateVolume(register struct cmd_syndesc *as, void *arock)
1902 {
1903     afs_int32 pnum;
1904     char part[10];
1905     afs_uint32 volid;
1906     afs_int32 code;
1907     struct nvldbentry entry;
1908     afs_int32 vcode;
1909     afs_int32 quota;
1910
1911     quota = 5000;
1912     tserver = GetServer(as->parms[0].items->data);
1913     if (!tserver) {
1914         fprintf(STDERR, "vos: host '%s' not found in host table\n",
1915                 as->parms[0].items->data);
1916         return ENOENT;
1917     }
1918     pnum = volutil_GetPartitionID(as->parms[1].items->data);
1919     if (pnum < 0) {
1920         fprintf(STDERR, "vos: could not interpret partition name '%s'\n",
1921                 as->parms[1].items->data);
1922         return ENOENT;
1923     }
1924     if (!IsPartValid(pnum, tserver, &code)) {   /*check for validity of the partition */
1925         if (code)
1926             PrintError("", code);
1927         else
1928             fprintf(STDERR,
1929                     "vos : partition %s does not exist on the server\n",
1930                     as->parms[1].items->data);
1931         return ENOENT;
1932     }
1933     if (!ISNAMEVALID(as->parms[2].items->data)) {
1934         fprintf(STDERR,
1935                 "vos: the name of the root volume %s exceeds the size limit of %d\n",
1936                 as->parms[2].items->data, VOLSER_OLDMAXVOLNAME - 10);
1937         return E2BIG;
1938     }
1939     if (!VolNameOK(as->parms[2].items->data)) {
1940         fprintf(STDERR,
1941                 "Illegal volume name %s, should not end in .readonly or .backup\n",
1942                 as->parms[2].items->data);
1943         return EINVAL;
1944     }
1945     if (IsNumeric(as->parms[2].items->data)) {
1946         fprintf(STDERR, "Illegal volume name %s, should not be a number\n",
1947                 as->parms[2].items->data);
1948         return EINVAL;
1949     }
1950     vcode = VLDB_GetEntryByName(as->parms[2].items->data, &entry);
1951     if (!vcode) {
1952         fprintf(STDERR, "Volume %s already exists\n",
1953                 as->parms[2].items->data);
1954         PrintDiagnostics("create", code);
1955         return EEXIST;
1956     }
1957
1958     if (as->parms[3].items) {
1959         if (!IsNumeric(as->parms[3].items->data)) {
1960             fprintf(STDERR, "Initial quota %s should be numeric.\n",
1961                     as->parms[3].items->data);
1962             return EINVAL;
1963         }
1964
1965         code = util_GetInt32(as->parms[3].items->data, &quota);
1966         if (code) {
1967             fprintf(STDERR, "vos: bad integer specified for quota.\n");
1968             return code;
1969         }
1970     }
1971
1972     code =
1973         UV_CreateVolume2(tserver, pnum, as->parms[2].items->data, quota, 0,
1974                          0, 0, 0, &volid);
1975     if (code) {
1976         PrintDiagnostics("create", code);
1977         return code;
1978     }
1979     MapPartIdIntoName(pnum, part);
1980     fprintf(STDOUT, "Volume %lu created on partition %s of %s\n",
1981             (unsigned long)volid, part, as->parms[0].items->data);
1982
1983     return 0;
1984 }
1985
1986 static afs_int32
1987 DeleteAll(entry)
1988      struct nvldbentry *entry;
1989 {
1990     int i;
1991     afs_int32 error, code, curserver, curpart;
1992     afs_uint32 volid;
1993
1994     MapHostToNetwork(entry);
1995     error = 0;
1996     for (i = 0; i < entry->nServers; i++) {
1997         curserver = entry->serverNumber[i];
1998         curpart = entry->serverPartition[i];
1999         if (entry->serverFlags[i] & ITSROVOL) {
2000             volid = entry->volumeId[ROVOL];
2001         } else {
2002             volid = entry->volumeId[RWVOL];
2003         }
2004         code = UV_DeleteVolume(curserver, curpart, volid);
2005         if (code && !error)
2006             error = code;
2007     }
2008     return error;
2009 }
2010
2011 static int
2012 DeleteVolume(struct cmd_syndesc *as, void *arock)
2013 {
2014     afs_int32 err, code = 0;
2015     afs_int32 server = 0, partition = -1;
2016     afs_uint32 volid;
2017     char pname[10];
2018     afs_int32 idx, j;
2019
2020     if (as->parms[0].items) {
2021         server = GetServer(as->parms[0].items->data);
2022         if (!server) {
2023             fprintf(STDERR, "vos: server '%s' not found in host table\n",
2024                     as->parms[0].items->data);
2025             return ENOENT;
2026         }
2027     }
2028
2029     if (as->parms[1].items) {
2030         partition = volutil_GetPartitionID(as->parms[1].items->data);
2031         if (partition < 0) {
2032             fprintf(STDERR, "vos: could not interpret partition name '%s'\n",
2033                     as->parms[1].items->data);
2034             return EINVAL;
2035         }
2036
2037         /* Check for validity of the partition */
2038         if (!IsPartValid(partition, server, &code)) {
2039             if (code) {
2040                 PrintError("", code);
2041             } else {
2042                 fprintf(STDERR,
2043                         "vos : partition %s does not exist on the server\n",
2044                         as->parms[1].items->data);
2045             }
2046             return ENOENT;
2047         }
2048     }
2049
2050     volid = vsu_GetVolumeID(as->parms[2].items->data, cstruct, &err);
2051     if (volid == 0) {
2052         fprintf(STDERR, "Can't find volume name '%s' in VLDB\n",
2053                 as->parms[2].items->data);
2054         if (err)
2055             PrintError("", err);
2056         return ENOENT;
2057     }
2058
2059     /* If the server or partition option are not complete, try to fill
2060      * them in from the VLDB entry.
2061      */
2062     if ((partition == -1) || !server) {
2063         struct nvldbentry entry;
2064
2065         code = VLDB_GetEntryByID(volid, -1, &entry);
2066         if (code) {
2067             fprintf(STDERR,
2068                     "Could not fetch the entry for volume %lu from VLDB\n",
2069                     (unsigned long)volid);
2070             PrintError("", code);
2071             return (code);
2072         }
2073
2074         if (((volid == entry.volumeId[RWVOL]) && (entry.flags & RW_EXISTS))
2075             || ((volid == entry.volumeId[BACKVOL])
2076                 && (entry.flags & BACK_EXISTS))) {
2077             idx = Lp_GetRwIndex(&entry);
2078             if ((idx == -1) || (server && (server != entry.serverNumber[idx]))
2079                 || ((partition != -1)
2080                     && (partition != entry.serverPartition[idx]))) {
2081                 fprintf(STDERR, "VLDB: Volume '%s' no match\n",
2082                         as->parms[2].items->data);
2083                 return ENOENT;
2084             }
2085         } else if ((volid == entry.volumeId[ROVOL])
2086                    && (entry.flags & RO_EXISTS)) {
2087             for (idx = -1, j = 0; j < entry.nServers; j++) {
2088                 if (entry.serverFlags[j] != ITSROVOL)
2089                     continue;
2090
2091                 if (((server == 0) || (server == entry.serverNumber[j]))
2092                     && ((partition == -1)
2093                         || (partition == entry.serverPartition[j]))) {
2094                     if (idx != -1) {
2095                         fprintf(STDERR,
2096                                 "VLDB: Volume '%s' matches more than one RO\n",
2097                                 as->parms[2].items->data);
2098                         return ENOENT;
2099                     }
2100                     idx = j;
2101                 }
2102             }
2103             if (idx == -1) {
2104                 fprintf(STDERR, "VLDB: Volume '%s' no match\n",
2105                         as->parms[2].items->data);
2106                 return ENOENT;
2107             }
2108         } else {
2109             fprintf(STDERR, "VLDB: Volume '%s' no match\n",
2110                     as->parms[2].items->data);
2111             return ENOENT;
2112         }
2113
2114         server = htonl(entry.serverNumber[idx]);
2115         partition = entry.serverPartition[idx];
2116     }
2117
2118
2119     code = UV_DeleteVolume(server, partition, volid);
2120     if (code) {
2121         PrintDiagnostics("remove", code);
2122         return code;
2123     }
2124
2125     MapPartIdIntoName(partition, pname);
2126     fprintf(STDOUT, "Volume %lu on partition %s server %s deleted\n",
2127             (unsigned long)volid, pname, hostutil_GetNameByINet(server));
2128     return 0;
2129 }
2130
2131 #define TESTM   0               /* set for move space tests, clear for production */
2132 static
2133 MoveVolume(register struct cmd_syndesc *as, void *arock)
2134 {
2135
2136     afs_uint32 volid;
2137     afs_int32 fromserver, toserver, frompart, topart;
2138     afs_int32 flags, code, err;
2139     char fromPartName[10], toPartName[10];
2140
2141     struct diskPartition64 partition;   /* for space check */
2142     volintInfo *p;
2143
2144     volid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);
2145     if (volid == 0) {
2146         if (err)
2147             PrintError("", err);
2148         else
2149             fprintf(STDERR, "vos: can't find volume ID or name '%s'\n",
2150                     as->parms[0].items->data);
2151         return ENOENT;
2152     }
2153     fromserver = GetServer(as->parms[1].items->data);
2154     if (fromserver == 0) {
2155         fprintf(STDERR, "vos: server '%s' not found in host table\n",
2156                 as->parms[1].items->data);
2157         return ENOENT;
2158     }
2159     toserver = GetServer(as->parms[3].items->data);
2160     if (toserver == 0) {
2161         fprintf(STDERR, "vos: server '%s' not found in host table\n",
2162                 as->parms[3].items->data);
2163         return ENOENT;
2164     }
2165     frompart = volutil_GetPartitionID(as->parms[2].items->data);
2166     if (frompart < 0) {
2167         fprintf(STDERR, "vos: could not interpret partition name '%s'\n",
2168                 as->parms[2].items->data);
2169         return EINVAL;
2170     }
2171     if (!IsPartValid(frompart, fromserver, &code)) {    /*check for validity of the partition */
2172         if (code)
2173             PrintError("", code);
2174         else
2175             fprintf(STDERR,
2176                     "vos : partition %s does not exist on the server\n",
2177                     as->parms[2].items->data);
2178         return ENOENT;
2179     }
2180     topart = volutil_GetPartitionID(as->parms[4].items->data);
2181     if (topart < 0) {
2182         fprintf(STDERR, "vos: could not interpret partition name '%s'\n",
2183                 as->parms[4].items->data);
2184         return EINVAL;
2185     }
2186     if (!IsPartValid(topart, toserver, &code)) {        /*check for validity of the partition */
2187         if (code)
2188             PrintError("", code);
2189         else
2190             fprintf(STDERR,
2191                     "vos : partition %s does not exist on the server\n",
2192                     as->parms[4].items->data);
2193         return ENOENT;
2194     }
2195
2196     flags = 0;
2197     if (as->parms[5].items) flags |= RV_NOCLONE;
2198
2199     /*
2200      * check source partition for space to clone volume
2201      */
2202
2203     MapPartIdIntoName(topart, toPartName);
2204     MapPartIdIntoName(frompart, fromPartName);
2205
2206     /*
2207      * check target partition for space to move volume
2208      */
2209
2210     code = UV_PartitionInfo64(toserver, toPartName, &partition);
2211     if (code) {
2212         fprintf(STDERR, "vos: cannot access partition %s\n", toPartName);
2213         exit(1);
2214     }
2215     if (TESTM)
2216         fprintf(STDOUT, "target partition %s free space %" AFS_INT64_FMT "\n", toPartName,
2217                 partition.free);
2218
2219     p = (volintInfo *) 0;
2220     code = UV_ListOneVolume(fromserver, frompart, volid, &p);
2221     if (code) {
2222         fprintf(STDERR, "vos:cannot access volume %lu\n",
2223                 (unsigned long)volid);
2224         exit(1);
2225     }
2226     if (TESTM)
2227         fprintf(STDOUT, "volume %lu size %d\n", (unsigned long)volid,
2228                 p->size);
2229     if (partition.free <= p->size) {
2230         fprintf(STDERR,
2231                 "vos: no space on target partition %s to move volume %lu\n",
2232                 toPartName, (unsigned long)volid);
2233         free(p);
2234         exit(1);
2235     }
2236     free(p);
2237
2238     if (TESTM) {
2239         fprintf(STDOUT, "size test - don't do move\n");
2240         exit(0);
2241     }
2242
2243     /* successful move still not guaranteed but shoot for it */
2244
2245     code =
2246         UV_MoveVolume2(volid, fromserver, frompart, toserver, topart, flags);
2247     if (code) {
2248         PrintDiagnostics("move", code);
2249         return code;
2250     }
2251     MapPartIdIntoName(topart, toPartName);
2252     MapPartIdIntoName(frompart, fromPartName);
2253     fprintf(STDOUT, "Volume %lu moved from %s %s to %s %s \n",
2254             (unsigned long)volid, as->parms[1].items->data, fromPartName,
2255             as->parms[3].items->data, toPartName);
2256
2257     return 0;
2258 }
2259
2260 static int
2261 CopyVolume(register struct cmd_syndesc *as, void *arock)
2262 {
2263     afs_uint32 volid;
2264     afs_int32 fromserver, toserver, frompart, topart, code, err, flags;
2265     char fromPartName[10], toPartName[10], *tovolume;
2266     struct nvldbentry entry;
2267     struct diskPartition64 partition;   /* for space check */
2268     volintInfo *p;
2269
2270     volid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);
2271     if (volid == 0) {
2272         if (err)
2273             PrintError("", err);
2274         else
2275             fprintf(STDERR, "vos: can't find volume ID or name '%s'\n",
2276                     as->parms[0].items->data);
2277         return ENOENT;
2278     }
2279     fromserver = GetServer(as->parms[1].items->data);
2280     if (fromserver == 0) {
2281         fprintf(STDERR, "vos: server '%s' not found in host table\n",
2282                 as->parms[1].items->data);
2283         return ENOENT;
2284     }
2285
2286     toserver = GetServer(as->parms[4].items->data);
2287     if (toserver == 0) {
2288         fprintf(STDERR, "vos: server '%s' not found in host table\n",
2289                 as->parms[4].items->data);
2290         return ENOENT;
2291     }
2292
2293     tovolume = as->parms[3].items->data;
2294     if (!ISNAMEVALID(tovolume)) {
2295         fprintf(STDERR,
2296                 "vos: the name of the root volume %s exceeds the size limit of %d\n",
2297                 tovolume, VOLSER_OLDMAXVOLNAME - 10);
2298         return E2BIG;
2299     }
2300     if (!VolNameOK(tovolume)) {
2301         fprintf(STDERR,
2302                 "Illegal volume name %s, should not end in .readonly or .backup\n",
2303                 tovolume);
2304         return EINVAL;
2305     }
2306     if (IsNumeric(tovolume)) {
2307         fprintf(STDERR, "Illegal volume name %s, should not be a number\n",
2308                 tovolume);
2309         return EINVAL;
2310     }
2311     code = VLDB_GetEntryByName(tovolume, &entry);
2312     if (!code) {
2313         fprintf(STDERR, "Volume %s already exists\n", tovolume);
2314         PrintDiagnostics("copy", code);
2315         return EEXIST;
2316     }
2317
2318     frompart = volutil_GetPartitionID(as->parms[2].items->data);
2319     if (frompart < 0) {
2320         fprintf(STDERR, "vos: could not interpret partition name '%s'\n",
2321                 as->parms[2].items->data);
2322         return EINVAL;
2323     }
2324     if (!IsPartValid(frompart, fromserver, &code)) {    /*check for validity of the partition */
2325         if (code)
2326             PrintError("", code);
2327         else
2328             fprintf(STDERR,
2329                     "vos : partition %s does not exist on the server\n",
2330                     as->parms[2].items->data);
2331         return ENOENT;
2332     }
2333
2334     topart = volutil_GetPartitionID(as->parms[5].items->data);
2335     if (topart < 0) {
2336         fprintf(STDERR, "vos: could not interpret partition name '%s'\n",
2337                 as->parms[5].items->data);
2338         return EINVAL;
2339     }
2340     if (!IsPartValid(topart, toserver, &code)) {        /*check for validity of the partition */
2341         if (code)
2342             PrintError("", code);
2343         else
2344             fprintf(STDERR,
2345                     "vos : partition %s does not exist on the server\n",
2346                     as->parms[5].items->data);
2347         return ENOENT;
2348     }
2349
2350     flags = 0;
2351     if (as->parms[6].items) flags |= RV_OFFLINE;
2352     if (as->parms[7].items) flags |= RV_RDONLY;
2353     if (as->parms[8].items) flags |= RV_NOCLONE;
2354
2355     MapPartIdIntoName(topart, toPartName);
2356     MapPartIdIntoName(frompart, fromPartName);
2357
2358     /*
2359      * check target partition for space to move volume
2360      */
2361
2362     code = UV_PartitionInfo64(toserver, toPartName, &partition);
2363     if (code) {
2364         fprintf(STDERR, "vos: cannot access partition %s\n", toPartName);
2365         exit(1);
2366     }
2367     if (TESTM)
2368         fprintf(STDOUT, "target partition %s free space %" AFS_INT64_FMT "\n", toPartName,
2369                 partition.free);
2370
2371     p = (volintInfo *) 0;
2372     code = UV_ListOneVolume(fromserver, frompart, volid, &p);
2373     if (code) {
2374         fprintf(STDERR, "vos:cannot access volume %lu\n",
2375                 (unsigned long)volid);
2376         exit(1);
2377     }
2378
2379     if (partition.free <= p->size) {
2380         fprintf(STDERR,
2381                 "vos: no space on target partition %s to copy volume %lu\n",
2382                 toPartName, (unsigned long)volid);
2383         free(p);
2384         exit(1);
2385     }
2386     free(p);
2387
2388     /* successful copy still not guaranteed but shoot for it */
2389
2390     code =
2391         UV_CopyVolume2(volid, fromserver, frompart, tovolume, toserver,
2392                        topart, 0, flags);
2393     if (code) {
2394         PrintDiagnostics("copy", code);
2395         return code;
2396     }
2397     MapPartIdIntoName(topart, toPartName);
2398     MapPartIdIntoName(frompart, fromPartName);
2399     fprintf(STDOUT, "Volume %lu copied from %s %s to %s on %s %s \n",
2400             (unsigned long)volid, as->parms[1].items->data, fromPartName,
2401             tovolume, as->parms[4].items->data, toPartName);
2402
2403     return 0;
2404 }
2405
2406
2407 static int
2408 ShadowVolume(register struct cmd_syndesc *as, void *arock)
2409 {
2410     afs_uint32 volid, tovolid;
2411     afs_int32 fromserver, toserver, frompart, topart;
2412     afs_int32 code, err, flags;
2413     char fromPartName[10], toPartName[10], toVolName[32], *tovolume;
2414     struct diskPartition64 partition;   /* for space check */
2415     volintInfo *p, *q;
2416
2417     p = (volintInfo *) 0;
2418     q = (volintInfo *) 0;
2419
2420     volid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);
2421     if (volid == 0) {
2422         if (err)
2423             PrintError("", err);
2424         else
2425             fprintf(STDERR, "vos: can't find volume ID or name '%s'\n",
2426                     as->parms[0].items->data);
2427         return ENOENT;
2428     }
2429     fromserver = GetServer(as->parms[1].items->data);
2430     if (fromserver == 0) {
2431         fprintf(STDERR, "vos: server '%s' not found in host table\n",
2432                 as->parms[1].items->data);
2433         return ENOENT;
2434     }
2435
2436     toserver = GetServer(as->parms[3].items->data);
2437     if (toserver == 0) {
2438         fprintf(STDERR, "vos: server '%s' not found in host table\n",
2439                 as->parms[3].items->data);
2440         return ENOENT;
2441     }
2442
2443     frompart = volutil_GetPartitionID(as->parms[2].items->data);
2444     if (frompart < 0) {
2445         fprintf(STDERR, "vos: could not interpret partition name '%s'\n",
2446                 as->parms[2].items->data);
2447         return EINVAL;
2448     }
2449     if (!IsPartValid(frompart, fromserver, &code)) {    /*check for validity of the partition */
2450         if (code)
2451             PrintError("", code);
2452         else
2453             fprintf(STDERR,
2454                     "vos : partition %s does not exist on the server\n",
2455                     as->parms[2].items->data);
2456         return ENOENT;
2457     }
2458
2459     topart = volutil_GetPartitionID(as->parms[4].items->data);
2460     if (topart < 0) {
2461         fprintf(STDERR, "vos: could not interpret partition name '%s'\n",
2462                 as->parms[4].items->data);
2463         return EINVAL;
2464     }
2465     if (!IsPartValid(topart, toserver, &code)) {        /*check for validity of the partition */
2466         if (code)
2467             PrintError("", code);
2468         else
2469             fprintf(STDERR,
2470                     "vos : partition %s does not exist on the server\n",
2471                     as->parms[4].items->data);
2472         return ENOENT;
2473     }
2474
2475     if (as->parms[5].items) {
2476         tovolume = as->parms[5].items->data;
2477         if (!ISNAMEVALID(tovolume)) {
2478             fprintf(STDERR,
2479                 "vos: the name of the root volume %s exceeds the size limit of %d\n",
2480                 tovolume, VOLSER_OLDMAXVOLNAME - 10);
2481             return E2BIG;
2482         }
2483         if (!VolNameOK(tovolume)) {
2484             fprintf(STDERR,
2485                 "Illegal volume name %s, should not end in .readonly or .backup\n",
2486                 tovolume);
2487             return EINVAL;
2488         }
2489         if (IsNumeric(tovolume)) {
2490             fprintf(STDERR,
2491                 "Illegal volume name %s, should not be a number\n",
2492                 tovolume);
2493             return EINVAL;
2494         }
2495     } else {
2496         /* use actual name of source volume */
2497         code = UV_ListOneVolume(fromserver, frompart, volid, &p);
2498         if (code) {
2499             fprintf(STDERR, "vos:cannot access volume %lu\n",
2500                 (unsigned long)volid);
2501             exit(1);
2502         }
2503         strcpy(toVolName, p->name);
2504         tovolume = toVolName;
2505         /* save p for size checks later */
2506     }
2507
2508     if (as->parms[6].items) {
2509         tovolid = vsu_GetVolumeID(as->parms[6].items->data, cstruct, &err);
2510         if (tovolid == 0) {
2511             if (err)
2512                 PrintError("", err);
2513             else
2514                 fprintf(STDERR, "vos: can't find volume ID or name '%s'\n",
2515                         as->parms[6].items->data);
2516             if (p)
2517                 free(p);
2518             return ENOENT;
2519         }
2520     } else {
2521         tovolid = vsu_GetVolumeID(tovolume, cstruct, &err);
2522         if (tovolid == 0) {
2523             if (err)
2524                 PrintError("", err);
2525             else
2526                 fprintf(STDERR, "vos: can't find volume ID or name '%s'\n",
2527                         tovolume);
2528             if (p)
2529                 free(p);
2530             return ENOENT;
2531         }
2532     }
2533
2534     flags = RV_NOVLDB;
2535     if (as->parms[7].items) flags |= RV_OFFLINE;
2536     if (as->parms[8].items) flags |= RV_RDONLY;
2537     if (as->parms[9].items) flags |= RV_NOCLONE;
2538     if (as->parms[10].items) flags |= RV_CPINCR;
2539
2540     MapPartIdIntoName(topart, toPartName);
2541     MapPartIdIntoName(frompart, fromPartName);
2542
2543     /*
2544      * check target partition for space to move volume
2545      */
2546
2547     code = UV_PartitionInfo64(toserver, toPartName, &partition);
2548     if (code) {
2549         fprintf(STDERR, "vos: cannot access partition %s\n", toPartName);
2550         exit(1);
2551     }
2552     if (TESTM)
2553         fprintf(STDOUT, "target partition %s free space %" AFS_INT64_FMT "\n", toPartName,
2554                 partition.free);
2555
2556     /* Don't do this again if we did it above */
2557     if (!p) {
2558         code = UV_ListOneVolume(fromserver, frompart, volid, &p);
2559         if (code) {
2560             fprintf(STDERR, "vos:cannot access volume %lu\n",
2561                 (unsigned long)volid);
2562             exit(1);
2563         }
2564     }
2565
2566     /* OK if this fails */
2567     code = UV_ListOneVolume(toserver, topart, tovolid, &q);
2568
2569     /* Treat existing volume size as "free" */
2570     if (q)
2571         p->size = (q->size < p->size) ? p->size - q->size : 0;
2572
2573     if (partition.free <= p->size) {
2574         fprintf(STDERR,
2575                 "vos: no space on target partition %s to copy volume %lu\n",
2576                 toPartName, (unsigned long)volid);
2577         free(p);
2578         if (q) free(q);
2579         exit(1);
2580     }
2581     free(p);
2582     if (q) free(q);
2583
2584     /* successful copy still not guaranteed but shoot for it */
2585
2586     code =
2587         UV_CopyVolume2(volid, fromserver, frompart, tovolume, toserver,
2588                        topart, tovolid, flags);
2589     if (code) {
2590         PrintDiagnostics("shadow", code);
2591         return code;
2592     }
2593     MapPartIdIntoName(topart, toPartName);
2594     MapPartIdIntoName(frompart, fromPartName);
2595     fprintf(STDOUT, "Volume %lu shadowed from %s %s to %s %s \n",
2596             (unsigned long)volid, as->parms[1].items->data, fromPartName,
2597             as->parms[3].items->data, toPartName);
2598
2599     return 0;
2600 }
2601
2602
2603 static int
2604 CloneVolume(register struct cmd_syndesc *as, void *arock)
2605 {
2606     afs_uint32 volid, cloneid;
2607     afs_int32 server, part, voltype;
2608     char partName[10], *volname;
2609     afs_int32 code, err, flags;
2610     struct nvldbentry entry;
2611
2612     volid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);
2613     if (volid == 0) {
2614         if (err)
2615             PrintError("", err);
2616         else
2617             fprintf(STDERR, "vos: can't find volume ID or name '%s'\n",
2618                     as->parms[0].items->data);
2619         return ENOENT;
2620     }
2621
2622     if (as->parms[1].items || as->parms[2].items) {
2623         if (!as->parms[1].items || !as->parms[2].items) {
2624             fprintf(STDERR,
2625                     "Must specify both -server and -partition options\n");
2626             return -1;
2627         }
2628         server = GetServer(as->parms[1].items->data);
2629         if (server == 0) {
2630             fprintf(STDERR, "vos: server '%s' not found in host table\n",
2631                     as->parms[1].items->data);
2632             return ENOENT;
2633         }
2634         part = volutil_GetPartitionID(as->parms[2].items->data);
2635         if (part < 0) {
2636             fprintf(STDERR, "vos: could not interpret partition name '%s'\n",
2637                     as->parms[2].items->data);
2638             return EINVAL;
2639         }
2640         if (!IsPartValid(part, server, &code)) {        /*check for validity of the partition */
2641             if (code)
2642                 PrintError("", code);
2643             else
2644                 fprintf(STDERR,
2645                     "vos : partition %s does not exist on the server\n",
2646                     as->parms[2].items->data);
2647             return ENOENT;
2648         }
2649     } else {
2650         code = GetVolumeInfo(volid, &server, &part, &voltype, &entry);
2651         if (code)
2652             return code;
2653     }
2654
2655     volname = 0;
2656     if (as->parms[3].items) {
2657         volname = as->parms[3].items->data;
2658         if (strlen(volname) > VOLSER_OLDMAXVOLNAME - 1) {
2659             fprintf(STDERR,
2660                 "vos: the name of the root volume %s exceeds the size limit of %d\n",
2661                 volname, VOLSER_OLDMAXVOLNAME - 1);
2662             return E2BIG;
2663         }
2664 #if 0
2665         /*
2666          * In order that you be able to make clones of RO or BK, this
2667          * check must be omitted.
2668          */
2669         if (!VolNameOK(volname)) {
2670             fprintf(STDERR,
2671                 "Illegal volume name %s, should not end in .readonly or .backup\n",
2672                 volname);
2673             return EINVAL;
2674         }
2675 #endif
2676         if (IsNumeric(volname)) {
2677             fprintf(STDERR,
2678                 "Illegal volume name %s, should not be a number\n",
2679                 volname);
2680             return EINVAL;
2681         }
2682     }
2683
2684     cloneid = 0;
2685     if (as->parms[4].items) {
2686         cloneid = vsu_GetVolumeID(as->parms[4].items->data, cstruct, &err);
2687         if (cloneid == 0) {
2688             if (err)
2689                 PrintError("", err);
2690             else
2691                 fprintf(STDERR, "vos: can't find volume ID or name '%s'\n",
2692                         as->parms[4].items->data);
2693             return ENOENT;
2694         }
2695     }
2696
2697     flags = 0;
2698     if (as->parms[5].items) flags |= RV_OFFLINE;
2699     if (as->parms[6].items) flags |= RV_RDONLY;
2700
2701
2702     code =
2703         UV_CloneVolume(server, part, volid, cloneid, volname, flags);
2704
2705     if (code) {
2706         PrintDiagnostics("clone", code);
2707         return code;
2708     }
2709     MapPartIdIntoName(part, partName);
2710     fprintf(STDOUT, "Created clone for volume %s\n",
2711             as->parms[0].items->data);
2712
2713     return 0;
2714 }
2715
2716
2717 static int
2718 BackupVolume(register struct cmd_syndesc *as, void *arock)
2719 {
2720     afs_uint32 avolid;
2721     afs_int32 aserver, apart, vtype, code, err;
2722     struct nvldbentry entry;
2723
2724     afs_uint32 buvolid;
2725     afs_int32 buserver, bupart, butype;
2726     struct nvldbentry buentry;
2727
2728     avolid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);
2729     if (avolid == 0) {
2730         if (err)
2731             PrintError("", err);
2732         else
2733             fprintf(STDERR, "vos: can't find volume ID or name '%s'\n",
2734                     as->parms[0].items->data);
2735         return ENOENT;
2736     }
2737     code = GetVolumeInfo(avolid, &aserver, &apart, &vtype, &entry);
2738     if (code)
2739         exit(1);
2740
2741     /* verify this is a readwrite volume */
2742
2743     if (vtype != RWVOL) {
2744         fprintf(STDERR, "%s not RW volume\n", as->parms[0].items->data);
2745         exit(1);
2746     }
2747
2748     /* is there a backup volume already? */
2749
2750     if (entry.flags & BACK_EXISTS) {
2751         /* yep, where is it? */
2752
2753         buvolid = entry.volumeId[BACKVOL];
2754         code = GetVolumeInfo(buvolid, &buserver, &bupart, &butype, &buentry);
2755         if (code)
2756             exit(1);
2757
2758         /* is it local? */
2759         code = VLDB_IsSameAddrs(buserver, aserver, &err);
2760         if (err) {
2761             fprintf(STDERR,
2762                     "Failed to get info about server's %d address(es) from vlserver; aborting call!\n",
2763                     buserver);
2764             exit(1);
2765         }
2766         if (!code) {
2767             fprintf(STDERR,
2768                     "FATAL ERROR: backup volume %lu exists on server %lu\n",
2769                     (unsigned long)buvolid, (unsigned long)buserver);
2770             exit(1);
2771         }
2772     }
2773
2774     /* nope, carry on */
2775
2776     code = UV_BackupVolume(aserver, apart, avolid);
2777
2778     if (code) {
2779         PrintDiagnostics("backup", code);
2780         return code;
2781     }
2782     fprintf(STDOUT, "Created backup volume for %s \n",
2783             as->parms[0].items->data);
2784     return 0;
2785 }
2786
2787 static int
2788 ReleaseVolume(register struct cmd_syndesc *as, void *arock)
2789 {
2790
2791     struct nvldbentry entry;
2792     afs_uint32 avolid;
2793     afs_int32 aserver, apart, vtype, code, err;
2794     int force = 0;
2795
2796     if (as->parms[1].items)
2797         force = 1;
2798     avolid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);
2799     if (avolid == 0) {
2800         if (err)
2801             PrintError("", err);
2802         else
2803             fprintf(STDERR, "vos: can't find volume '%s'\n",
2804                     as->parms[0].items->data);
2805         return ENOENT;
2806     }
2807     code = GetVolumeInfo(avolid, &aserver, &apart, &vtype, &entry);
2808     if (code)
2809         return code;
2810
2811     if (vtype != RWVOL) {
2812         fprintf(STDERR, "%s not a RW volume\n", as->parms[0].items->data);
2813         return (ENOENT);
2814     }
2815
2816     if (!ISNAMEVALID(entry.name)) {
2817         fprintf(STDERR,
2818                 "Volume name %s is too long, rename before releasing\n",
2819                 entry.name);
2820         return E2BIG;
2821     }
2822
2823     code = UV_ReleaseVolume(avolid, aserver, apart, force);
2824     if (code) {
2825         PrintDiagnostics("release", code);
2826         return code;
2827     }
2828     fprintf(STDOUT, "Released volume %s successfully\n",
2829             as->parms[0].items->data);
2830     return 0;
2831 }
2832
2833 static
2834 DumpVolume(register struct cmd_syndesc *as, void *arock)
2835 {
2836     afs_uint32 avolid;
2837     afs_int32 aserver, apart, voltype, fromdate = 0, code, err, i, flags;
2838     char filename[MAXPATHLEN];
2839     struct nvldbentry entry;
2840
2841     rx_SetRxDeadTime(60 * 10);
2842     for (i = 0; i < MAXSERVERS; i++) {
2843         struct rx_connection *rxConn = ubik_GetRPCConn(cstruct, i);
2844         if (rxConn == 0)
2845             break;
2846         rx_SetConnDeadTime(rxConn, rx_connDeadTime);
2847         if (rxConn->service)
2848             rxConn->service->connDeadTime = rx_connDeadTime;
2849     }
2850
2851     avolid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);
2852     if (avolid == 0) {
2853         if (err)
2854             PrintError("", err);
2855         else
2856             fprintf(STDERR, "vos: can't find volume '%s'\n",
2857                     as->parms[0].items->data);
2858         return ENOENT;
2859     }
2860
2861     if (as->parms[3].items || as->parms[4].items) {
2862         if (!as->parms[3].items || !as->parms[4].items) {
2863             fprintf(STDERR,
2864                     "Must specify both -server and -partition options\n");
2865             return -1;
2866         }
2867         aserver = GetServer(as->parms[3].items->data);
2868         if (aserver == 0) {
2869             fprintf(STDERR, "Invalid server name\n");
2870             return -1;
2871         }
2872         apart = volutil_GetPartitionID(as->parms[4].items->data);
2873         if (apart < 0) {
2874             fprintf(STDERR, "Invalid partition name\n");
2875             return -1;
2876         }
2877     } else {
2878         code = GetVolumeInfo(avolid, &aserver, &apart, &voltype, &entry);
2879         if (code)
2880             return code;
2881     }
2882
2883     if (as->parms[1].items && strcmp(as->parms[1].items->data, "0")) {
2884         code = ktime_DateToInt32(as->parms[1].items->data, &fromdate);
2885         if (code) {
2886             fprintf(STDERR, "vos: failed to parse date '%s' (error=%d))\n",
2887                     as->parms[1].items->data, code);
2888             return code;
2889         }
2890     }
2891     if (as->parms[2].items) {
2892         strcpy(filename, as->parms[2].items->data);
2893     } else {
2894         strcpy(filename, "");
2895     }
2896
2897     flags = as->parms[6].items ? VOLDUMPV2_OMITDIRS : 0;
2898 retry_dump:
2899     if (as->parms[5].items) {
2900         code =
2901             UV_DumpClonedVolume(avolid, aserver, apart, fromdate,
2902                                 DumpFunction, filename, flags);
2903     } else {
2904         code =
2905             UV_DumpVolume(avolid, aserver, apart, fromdate, DumpFunction,
2906                           filename, flags);
2907     }
2908     if ((code == RXGEN_OPCODE) && (as->parms[6].items)) {
2909         flags &= ~VOLDUMPV2_OMITDIRS;
2910         goto retry_dump;
2911     }
2912     if (code) {
2913         PrintDiagnostics("dump", code);
2914         return code;
2915     }
2916     if (strcmp(filename, ""))
2917         fprintf(STDERR, "Dumped volume %s in file %s\n",
2918                 as->parms[0].items->data, filename);
2919     else
2920         fprintf(STDERR, "Dumped volume %s in stdout \n",
2921                 as->parms[0].items->data);
2922     return 0;
2923 }
2924
2925 #define ASK   0
2926 #define ABORT 1
2927 #define FULL  2
2928 #define INC   3
2929
2930 #define TS_DUMP 1
2931 #define TS_KEEP 2
2932 #define TS_NEW  3
2933
2934 static int
2935 RestoreVolume(register struct cmd_syndesc *as, void *arock)
2936 {
2937     afs_uint32 avolid, aparentid;
2938     afs_int32 aserver, apart, code, vcode, err;
2939     afs_int32 aoverwrite = ASK;
2940     afs_int32 acreation = 0, alastupdate = 0;
2941     int restoreflags = 0;
2942     int readonly = 0, offline = 0, voltype = RWVOL;
2943     char prompt;
2944     char afilename[MAXPATHLEN], avolname[VOLSER_MAXVOLNAME + 1], apartName[10];
2945     char volname[VOLSER_MAXVOLNAME + 1];
2946     struct nvldbentry entry;
2947
2948     prompt = 'n';
2949
2950     aparentid = 0;
2951     if (as->parms[4].items) {
2952         avolid = vsu_GetVolumeID(as->parms[4].items->data, cstruct, &err);
2953         if (avolid == 0) {
2954             if (err)
2955                 PrintError("", err);
2956             else
2957                 fprintf(STDERR, "vos: can't find volume '%s'\n",
2958                         as->parms[4].items->data);
2959             exit(1);
2960         }
2961     } else
2962         avolid = 0;
2963
2964     if (as->parms[5].items) {
2965         if ((strcmp(as->parms[5].items->data, "a") == 0)
2966             || (strcmp(as->parms[5].items->data, "abort") == 0)) {
2967             aoverwrite = ABORT;
2968         } else if ((strcmp(as->parms[5].items->data, "f") == 0)
2969                    || (strcmp(as->parms[5].items->data, "full") == 0)) {
2970             aoverwrite = FULL;
2971         } else if ((strcmp(as->parms[5].items->data, "i") == 0)
2972                    || (strcmp(as->parms[5].items->data, "inc") == 0)
2973                    || (strcmp(as->parms[5].items->data, "increment") == 0)
2974                    || (strcmp(as->parms[5].items->data, "incremental") == 0)) {
2975             aoverwrite = INC;
2976         } else {
2977             fprintf(STDERR, "vos: %s is not a valid argument to -overwrite\n",
2978                     as->parms[5].items->data);
2979             exit(1);
2980         }
2981     }
2982     if (as->parms[6].items)
2983         offline = 1;
2984     if (as->parms[7].items) {
2985         readonly = 1;
2986         voltype = ROVOL;
2987     }
2988
2989     if (as->parms[8].items) {
2990         if ((strcmp(as->parms[8].items->data, "d") == 0)
2991             || (strcmp(as->parms[8].items->data, "dump") == 0)) {
2992             acreation = TS_DUMP;
2993         } else if ((strcmp(as->parms[8].items->data, "k") == 0)
2994             || (strcmp(as->parms[8].items->data, "keep") == 0)) {
2995             acreation = TS_KEEP;
2996         } else if ((strcmp(as->parms[8].items->data, "n") == 0)
2997             || (strcmp(as->parms[8].items->data, "new") == 0)) {
2998             acreation = TS_NEW;
2999         } else {
3000             fprintf(STDERR, "vos: %s is not a valid argument to -creation\n",
3001                     as->parms[8].items->data);
3002             exit(1);
3003         }
3004     }
3005
3006     if (as->parms[9].items) {
3007         if ((strcmp(as->parms[9].items->data, "d") == 0)
3008             || (strcmp(as->parms[9].items->data, "dump") == 0)) {
3009             alastupdate = TS_DUMP;
3010         } else if ((strcmp(as->parms[9].items->data, "k") == 0)
3011             || (strcmp(as->parms[9].items->data, "keep") == 0)) {
3012             alastupdate = TS_KEEP;
3013         } else if ((strcmp(as->parms[9].items->data, "n") == 0)
3014             || (strcmp(as->parms[9].items->data, "new") == 0)) {
3015             alastupdate = TS_NEW;
3016         } else {
3017             fprintf(STDERR, "vos: %s is not a valid argument to -lastupdate\n",
3018                     as->parms[9].items->data);
3019             exit(1);
3020         }
3021     }
3022
3023     aserver = GetServer(as->parms[0].items->data);
3024     if (aserver == 0) {
3025         fprintf(STDERR, "vos: server '%s' not found in host table\n",
3026                 as->parms[0].items->data);
3027         exit(1);
3028     }
3029     apart = volutil_GetPartitionID(as->parms[1].items->data);
3030     if (apart < 0) {
3031         fprintf(STDERR, "vos: could not interpret partition name '%s'\n",
3032                 as->parms[1].items->data);
3033         exit(1);
3034     }
3035     if (!IsPartValid(apart, aserver, &code)) {  /*check for validity of the partition */
3036         if (code)
3037             PrintError("", code);
3038         else
3039             fprintf(STDERR,
3040                     "vos : partition %s does not exist on the server\n",
3041                     as->parms[1].items->data);
3042         exit(1);
3043     }
3044     strcpy(avolname, as->parms[2].items->data);
3045     if (!ISNAMEVALID(avolname)) {
3046         fprintf(STDERR,
3047                 "vos: the name of the volume %s exceeds the size limit\n",
3048                 avolname);
3049         exit(1);
3050     }
3051     if (!VolNameOK(avolname)) {
3052         fprintf(STDERR,
3053                 "Illegal volume name %s, should not end in .readonly or .backup\n",
3054                 avolname);
3055         exit(1);
3056     }
3057     if (as->parms[3].items) {
3058         strcpy(afilename, as->parms[3].items->data);
3059         if (!FileExists(afilename)) {
3060             fprintf(STDERR, "Can't access file %s\n", afilename);
3061             exit(1);
3062         }
3063     } else {
3064         strcpy(afilename, "");
3065     }
3066
3067     /* Check if volume exists or not */
3068
3069     vsu_ExtractName(volname, avolname);
3070     vcode = VLDB_GetEntryByName(volname, &entry);
3071     if (vcode) {                /* no volume - do a full restore */
3072         restoreflags = RV_FULLRST;
3073         if ((aoverwrite == INC) || (aoverwrite == ABORT))
3074             fprintf(STDERR,
3075                     "Volume does not exist; Will perform a full restore\n");
3076     }
3077
3078     else if ((!readonly && Lp_GetRwIndex(&entry) == -1) /* RW volume does not exist - do a full */
3079              ||(readonly && !Lp_ROMatch(0, 0, &entry))) {       /* RO volume does not exist - do a full */
3080         restoreflags = RV_FULLRST;
3081         if ((aoverwrite == INC) || (aoverwrite == ABORT))
3082             fprintf(STDERR,
3083                     "%s Volume does not exist; Will perform a full restore\n",
3084                     readonly ? "RO" : "RW");
3085
3086         if (avolid == 0) {
3087             avolid = entry.volumeId[voltype];
3088         } else if (entry.volumeId[voltype] != 0
3089                    && entry.volumeId[voltype] != avolid) {
3090             avolid = entry.volumeId[voltype];
3091         }
3092         aparentid = entry.volumeId[RWVOL];
3093     }
3094
3095     else {                      /* volume exists - do we do a full incremental or abort */
3096         int Oserver, Opart, Otype, vol_elsewhere = 0;
3097         struct nvldbentry Oentry;
3098         int c, dc;
3099
3100         if (avolid == 0) {
3101             avolid = entry.volumeId[voltype];
3102         } else if (entry.volumeId[voltype] != 0
3103                    && entry.volumeId[voltype] != avolid) {
3104             avolid = entry.volumeId[voltype];
3105         }
3106         aparentid = entry.volumeId[RWVOL];
3107
3108         /* A file name was specified  - check if volume is on another partition */
3109         vcode = GetVolumeInfo(avolid, &Oserver, &Opart, &Otype, &Oentry);
3110         if (vcode)
3111             exit(1);
3112
3113         vcode = VLDB_IsSameAddrs(Oserver, aserver, &err);
3114         if (err) {
3115             fprintf(STDERR,
3116                     "Failed to get info about server's %d address(es) from vlserver (err=%d); aborting call!\n",
3117                     Oserver, err);
3118             exit(1);
3119         }
3120         if (!vcode || (Opart != apart))
3121             vol_elsewhere = 1;
3122
3123         if (aoverwrite == ASK) {
3124             if (strcmp(afilename, "") == 0) {   /* The file is from standard in */
3125                 fprintf(STDERR,
3126                         "Volume exists and no -overwrite option specified; Aborting restore command\n");
3127                 exit(1);
3128             }
3129
3130             /* Ask what to do */
3131             if (vol_elsewhere) {
3132                 fprintf(STDERR,
3133                         "The volume %s %u already exists on a different server/part\n",
3134                         volname, entry.volumeId[voltype]);
3135                 fprintf(STDERR,
3136                         "Do you want to do a full restore or abort? [fa](a): ");
3137             } else {
3138                 fprintf(STDERR,
3139                         "The volume %s %u already exists in the VLDB\n",
3140                         volname, entry.volumeId[voltype]);
3141                 fprintf(STDERR,
3142                         "Do you want to do a full/incremental restore or abort? [fia](a): ");
3143             }
3144             dc = c = getchar();
3145             while (!(dc == EOF || dc == '\n'))
3146                 dc = getchar(); /* goto end of line */
3147             if ((c == 'f') || (c == 'F'))
3148                 aoverwrite = FULL;
3149             else if ((c == 'i') || (c == 'I'))
3150                 aoverwrite = INC;
3151             else
3152                 aoverwrite = ABORT;
3153         }
3154
3155         if (aoverwrite == ABORT) {
3156             fprintf(STDERR, "Volume exists; Aborting restore command\n");
3157             exit(1);
3158         } else if (aoverwrite == FULL) {
3159             restoreflags = RV_FULLRST;
3160             fprintf(STDERR,
3161                     "Volume exists; Will delete and perform full restore\n");
3162         } else if (aoverwrite == INC) {
3163             restoreflags = 0;
3164             if (vol_elsewhere) {
3165                 fprintf(STDERR,
3166                         "%s volume %lu already exists on a different server/part; not allowed\n",
3167                         readonly ? "RO" : "RW", (unsigned long)avolid);
3168                 exit(1);
3169             }
3170         }
3171     }
3172     if (offline)
3173         restoreflags |= RV_OFFLINE;
3174     if (readonly)
3175         restoreflags |= RV_RDONLY;
3176
3177     switch (acreation) {
3178         case TS_DUMP:
3179             restoreflags |= RV_CRDUMP;
3180             break;
3181         case TS_KEEP:
3182             restoreflags |= RV_CRKEEP;
3183             break;
3184         case TS_NEW:
3185             restoreflags |= RV_CRNEW;
3186             break;
3187         default:
3188             if (aoverwrite == FULL)
3189                 restoreflags |= RV_CRNEW;
3190             else
3191                 restoreflags |= RV_CRKEEP;
3192     }
3193
3194     switch (alastupdate) {
3195         case TS_DUMP:
3196             restoreflags |= RV_LUDUMP;
3197             break;
3198         case TS_KEEP:
3199             restoreflags |= RV_LUKEEP;
3200             break;
3201         case TS_NEW:
3202             restoreflags |= RV_LUNEW;
3203             break;
3204         default:
3205             restoreflags |= RV_LUDUMP;
3206     }
3207     if (as->parms[10].items) {
3208         restoreflags |= RV_NODEL;
3209     }
3210
3211
3212     code =
3213         UV_RestoreVolume2(aserver, apart, avolid, aparentid,
3214                           avolname, restoreflags, WriteData, afilename);
3215     if (code) {
3216         PrintDiagnostics("restore", code);
3217         exit(1);
3218     }
3219     MapPartIdIntoName(apart, apartName);
3220
3221     /*
3222      * patch typo here - originally "parms[1]", should be "parms[0]"
3223      */
3224
3225     fprintf(STDOUT, "Restored volume %s on %s %s\n", avolname,
3226             as->parms[0].items->data, apartName);
3227     return 0;
3228 }
3229
3230 static int
3231 LockReleaseCmd(register struct cmd_syndesc *as, void *arock)
3232 {
3233     afs_uint32 avolid;
3234     afs_int32 code, err;
3235
3236     avolid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);
3237     if (avolid == 0) {
3238         if (err)
3239             PrintError("", err);
3240         else
3241             fprintf(STDERR, "vos: can't find volume '%s'\n",
3242                     as->parms[0].items->data);
3243         exit(1);
3244     }
3245
3246     code = UV_LockRelease(avolid);
3247     if (code) {
3248         PrintDiagnostics("unlock", code);
3249         exit(1);
3250     }
3251     fprintf(STDOUT, "Released lock on vldb entry for volume %s\n",
3252             as->parms[0].items->data);
3253     return 0;
3254 }
3255
3256 static int
3257 AddSite(register struct cmd_syndesc *as, void *arock)
3258 {
3259     afs_uint32 avolid;
3260     afs_int32 aserver, apart, code, err, valid = 0;
3261     char apartName[10], avolname[VOLSER_MAXVOLNAME + 1];
3262
3263     vsu_ExtractName(avolname, as->parms[2].items->data);;
3264     avolid = vsu_GetVolumeID(avolname, cstruct, &err);
3265     if (avolid == 0) {
3266         if (err)
3267             PrintError("", err);
3268         else
3269             fprintf(STDERR, "vos: can't find volume '%s'\n",
3270                     as->parms[2].items->data);
3271         exit(1);
3272     }
3273     aserver = GetServer(as->parms[0].items->data);
3274     if (aserver == 0) {
3275         fprintf(STDERR, "vos: server '%s' not found in host table\n",
3276                 as->parms[0].items->data);
3277         exit(1);
3278     }
3279     apart = volutil_GetPartitionID(as->parms[1].items->data);
3280     if (apart < 0) {
3281         fprintf(STDERR, "vos: could not interpret partition name '%s'\n",
3282                 as->parms[1].items->data);
3283         exit(1);
3284     }
3285     if (!IsPartValid(apart, aserver, &code)) {  /*check for validity of the partition */
3286         if (code)
3287             PrintError("", code);
3288         else
3289             fprintf(STDERR,
3290                     "vos : partition %s does not exist on the server\n",
3291                     as->parms[1].items->data);
3292         exit(1);
3293     }
3294     if (as->parms[3].items) {
3295         valid = 1;
3296     }
3297     code = UV_AddSite(aserver, apart, avolid, valid);
3298     if (code) {
3299         PrintDiagnostics("addsite", code);
3300         exit(1);
3301     }
3302     MapPartIdIntoName(apart, apartName);
3303     fprintf(STDOUT, "Added replication site %s %s for volume %s\n",
3304             as->parms[0].items->data, apartName, as->parms[2].items->data);
3305     return 0;
3306 }
3307
3308 static int
3309 RemoveSite(register struct cmd_syndesc *as, void *arock)
3310 {
3311
3312     afs_uint32 avolid;
3313     afs_int32 aserver, apart, code, err;
3314     char apartName[10], avolname[VOLSER_MAXVOLNAME + 1];
3315
3316     vsu_ExtractName(avolname, as->parms[2].items->data);
3317     avolid = vsu_GetVolumeID(avolname, cstruct, &err);
3318     if (avolid == 0) {
3319         if (err)
3320             PrintError("", err);
3321         else
3322             fprintf(STDERR, "vos: can't find volume '%s'\n",
3323                     as->parms[2].items->data);
3324         exit(1);
3325     }
3326     aserver = GetServer(as->parms[0].items->data);
3327     if (aserver == 0) {
3328         fprintf(STDERR, "vos: server '%s' not found in host table\n",
3329                 as->parms[0].items->data);
3330         exit(1);
3331     }
3332     apart = volutil_GetPartitionID(as->parms[1].items->data);
3333     if (apart < 0) {
3334         fprintf(STDERR, "vos: could not interpret partition name '%s'\n",
3335                 as->parms[1].items->data);
3336         exit(1);
3337     }
3338 /*
3339  *skip the partition validity check, since it is possible that the partition
3340  *has since been decomissioned.
3341  */
3342 /*
3343         if (!IsPartValid(apart,aserver,&code)){
3344             if(code) PrintError("",code);
3345             else fprintf(STDERR,"vos : partition %s does not exist on the server\n",as->parms[1].items->data);
3346             exit(1);
3347         }
3348 */
3349     code = UV_RemoveSite(aserver, apart, avolid);
3350     if (code) {
3351         PrintDiagnostics("remsite", code);
3352         exit(1);
3353     }
3354     MapPartIdIntoName(apart, apartName);
3355     fprintf(STDOUT, "Removed replication site %s %s for volume %s\n",
3356             as->parms[0].items->data, apartName, as->parms[2].items->data);
3357     return 0;
3358 }
3359
3360 static int
3361 ChangeLocation(register struct cmd_syndesc *as, void *arock)
3362 {
3363     afs_uint32 avolid;
3364     afs_int32 aserver, apart, code, err;
3365     char apartName[10];
3366
3367     avolid = vsu_GetVolumeID(as->parms[2].items->data, cstruct, &err);
3368     if (avolid == 0) {
3369         if (err)
3370             PrintError("", err);
3371         else
3372             fprintf(STDERR, "vos: can't find volume '%s'\n",
3373                     as->parms[2].items->data);
3374         exit(1);
3375     }
3376     aserver = GetServer(as->parms[0].items->data);
3377     if (aserver == 0) {
3378         fprintf(STDERR, "vos: server '%s' not found in host table\n",
3379                 as->parms[0].items->data);
3380         exit(1);
3381     }
3382     apart = volutil_GetPartitionID(as->parms[1].items->data);
3383     if (apart < 0) {
3384         fprintf(STDERR, "vos: could not interpret partition name '%s'\n",
3385                 as->parms[1].items->data);
3386         exit(1);
3387     }
3388     if (!IsPartValid(apart, aserver, &code)) {  /*check for validity of the partition */
3389         if (code)
3390             PrintError("", code);
3391         else
3392             fprintf(STDERR,
3393                     "vos : partition %s does not exist on the server\n",
3394                     as->parms[1].items->data);
3395         exit(1);
3396     }
3397     code = UV_ChangeLocation(aserver, apart, avolid);
3398     if (code) {
3399         PrintDiagnostics("addsite", code);
3400         exit(1);
3401     }
3402     MapPartIdIntoName(apart, apartName);
3403     fprintf(STDOUT, "Changed location to %s %s for volume %s\n",
3404             as->parms[0].items->data, apartName, as->parms[2].items->data);
3405     return 0;
3406 }
3407
3408 static int
3409 ListPartitions(register struct cmd_syndesc *as, void *arock)
3410 {
3411     afs_int32 aserver, code;
3412     struct partList dummyPartList;
3413     int i;
3414     char pname[10];
3415     int total, cnt;
3416
3417     aserver = GetServer(as->parms[0].items->data);
3418     if (aserver == 0) {
3419         fprintf(STDERR, "vos: server '%s' not found in host table\n",
3420                 as->parms[0].items->data);
3421         exit(1);
3422     }
3423
3424
3425     code = UV_ListPartitions(aserver, &dummyPartList, &cnt);
3426     if (code) {
3427         PrintDiagnostics("listpart", code);
3428         exit(1);
3429     }
3430     total = 0;
3431     fprintf(STDOUT, "The partitions on the server are:\n");
3432     for (i = 0; i < cnt; i++) {
3433         if (dummyPartList.partFlags[i] & PARTVALID) {
3434             memset(pname, 0, sizeof(pname));
3435             MapPartIdIntoName(dummyPartList.partId[i], pname);
3436             fprintf(STDOUT, " %10s ", pname);
3437             total++;
3438             if ((i % 5) == 0 && (i != 0))
3439                 fprintf(STDOUT, "\n");
3440         }
3441     }
3442     fprintf(STDOUT, "\n");
3443     fprintf(STDOUT, "Total: %d\n", total);
3444     return 0;
3445
3446 }
3447
3448 static int
3449 CompareVolName(p1, p2)
3450      char *p1, *p2;
3451 {
3452     volintInfo *arg1, *arg2;
3453
3454     arg1 = (volintInfo *) p1;
3455     arg2 = (volintInfo *) p2;
3456     return (strcmp(arg1->name, arg2->name));
3457
3458 }
3459
3460 /*------------------------------------------------------------------------
3461  * PRIVATE XCompareVolName
3462  *
3463  * Description:
3464  *      Comparison routine for volume names coming from an extended
3465  *      volume listing.
3466  *
3467  * Arguments:
3468  *      a_obj1P : Char ptr to first extended vol info object
3469  *      a_obj1P : Char ptr to second extended vol info object
3470  *
3471  * Returns:
3472  *      The value of strcmp() on the volume names within the passed
3473  *      objects (i,e., -1, 0, or 1).
3474  *
3475  * Environment:
3476  *      Passed to qsort() as the designated comparison routine.
3477  *
3478  * Side Effects:
3479  *      As advertised.
3480  *------------------------------------------------------------------------*/
3481
3482 static int
3483 XCompareVolName(a_obj1P, a_obj2P)
3484      char *a_obj1P, *a_obj2P;
3485
3486 {                               /*XCompareVolName */
3487
3488     return (strcmp
3489             (((struct volintXInfo *)(a_obj1P))->name,
3490              ((struct volintXInfo *)(a_obj2P))->name));
3491
3492 }                               /*XCompareVolName */
3493
3494 static int
3495 CompareVolID(p1, p2)
3496      char *p1, *p2;
3497 {
3498     volintInfo *arg1, *arg2;
3499
3500     arg1 = (volintInfo *) p1;
3501     arg2 = (volintInfo *) p2;
3502     if (arg1->volid == arg2->volid)
3503         return 0;
3504     if (arg1->volid > arg2->volid)
3505         return 1;
3506     else
3507         return -1;
3508
3509 }
3510
3511 /*------------------------------------------------------------------------
3512  * PRIVATE XCompareVolID
3513  *
3514  * Description:
3515  *      Comparison routine for volume IDs coming from an extended
3516  *      volume listing.
3517  *
3518  * Arguments:
3519  *      a_obj1P : Char ptr to first extended vol info object
3520  *      a_obj1P : Char ptr to second extended vol info object
3521  *
3522  * Returns:
3523  *      The value of strcmp() on the volume names within the passed
3524  *      objects (i,e., -1, 0, or 1).
3525  *
3526  * Environment:
3527  *      Passed to qsort() as the designated comparison routine.
3528  *
3529  * Side Effects:
3530  *      As advertised.
3531  *------------------------------------------------------------------------*/
3532
3533 static int
3534 XCompareVolID(a_obj1P, a_obj2P)
3535      char *a_obj1P, *a_obj2P;
3536
3537 {                               /*XCompareVolID */
3538
3539     afs_int32 id1, id2;         /*Volume IDs we're comparing */
3540
3541     id1 = ((struct volintXInfo *)(a_obj1P))->volid;
3542     id2 = ((struct volintXInfo *)(a_obj2P))->volid;
3543     if (id1 == id2)
3544         return (0);
3545     else if (id1 > id2)
3546         return (1);
3547     else
3548         return (-1);
3549
3550 }                               /*XCompareVolID */
3551
3552 /*------------------------------------------------------------------------
3553  * PRIVATE ListVolumes
3554  *
3555  * Description:
3556  *      Routine used to list volumes, contacting the Volume Server
3557  *      directly, bypassing the VLDB.
3558  *
3559  * Arguments:
3560  *      as : Ptr to parsed command line arguments.
3561  *
3562  * Returns:
3563  *      0                       Successful operation
3564  *
3565  * Environment:
3566  *      Nothing interesting.
3567  *
3568  * Side Effects:
3569  *      As advertised.
3570  *------------------------------------------------------------------------*/
3571
3572 static
3573 ListVolumes(register struct cmd_syndesc *as, void *arock)
3574 {
3575     afs_int32 apart, int32list, fast;
3576     afs_int32 aserver, code;
3577     volintInfo *pntr;
3578     volintInfo *oldpntr = NULL;
3579     afs_int32 count;
3580     int i;
3581     char *base;
3582     volintXInfo *xInfoP;
3583     volintXInfo *origxInfoP = NULL; /*Ptr to current/orig extended vol info */
3584     int wantExtendedInfo;       /*Do we want extended vol info? */
3585
3586     char pname[10];
3587     struct partList dummyPartList;
3588     int all;
3589     int quiet, cnt;
3590
3591     apart = -1;
3592     fast = 0;
3593     int32list = 0;
3594
3595     if (as->parms[3].items)
3596         int32list = 1;
3597     if (as->parms[4].items)
3598         quiet = 1;
3599     else
3600         quiet = 0;
3601     if (as->parms[2].items)
3602         fast = 1;
3603     if (fast)
3604         all = 0;
3605     else
3606         all = 1;
3607     if (as->parms[5].items) {
3608         /*
3609          * We can't coexist with the fast flag.
3610          */
3611         if (fast) {
3612             fprintf(STDERR,
3613                     "vos: Can't use the -fast and -extended flags together\n");
3614             exit(1);
3615         }
3616
3617         /*
3618          * We need to turn on ``long'' listings to get the full effect.
3619          */
3620         wantExtendedInfo = 1;
3621         int32list = 1;
3622     } else
3623         wantExtendedInfo = 0;
3624     if (as->parms[1].items) {
3625         apart = volutil_GetPartitionID(as->parms[1].items->data);
3626         if (apart < 0) {
3627             fprintf(STDERR, "vos: could not interpret partition name '%s'\n",
3628                     as->parms[1].items->data);
3629             exit(1);
3630         }
3631         dummyPartList.partId[0] = apart;
3632         dummyPartList.partFlags[0] = PARTVALID;
3633         cnt = 1;
3634     }
3635     aserver = GetServer(as->parms[0].items->data);
3636     if (aserver == 0) {
3637         fprintf(STDERR, "vos: server '%s' not found in host table\n",
3638                 as->parms[0].items->data);
3639         exit(1);
3640     }
3641
3642     if (apart != -1) {
3643         if (!IsPartValid(apart, aserver, &code)) {      /*check for validity of the partition */
3644             if (code)
3645                 PrintError("", code);
3646             else
3647                 fprintf(STDERR,
3648                         "vos : partition %s does not exist on the server\n",
3649                         as->parms[1].items->data);
3650             exit(1);
3651         }
3652     } else {
3653         code = UV_ListPartitions(aserver, &dummyPartList, &cnt);
3654         if (code) {
3655             PrintDiagnostics("listvol", code);
3656             exit(1);
3657         }
3658     }
3659     for (i = 0; i < cnt; i++) {
3660         if (dummyPartList.partFlags[i] & PARTVALID) {
3661             if (wantExtendedInfo)
3662                 code =
3663                     UV_XListVolumes(aserver, dummyPartList.partId[i], all,
3664                                     &xInfoP, &count);
3665             else
3666                 code =
3667     &n