git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/btape.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of Kern Sibbald.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  *
  30  *   Bacula Tape manipulation program
  31  *
  32  *    Has various tape manipulation commands -- mostly for
  33  *    use in determining how tapes really work.
  34  *
  35  *     Kern Sibbald, April MM
  36  *
  37  *   Note, this program reads stored.conf, and will only
  38  *     talk to devices that are configured.
  39  *
  40  *   Version $Id$
  41  *
  42  */
  43
  44 #include "bacula.h"
  45 #include "stored.h"
  46
  47 #ifdef USE_VTAPE
  48 #include "vtape.h"
  49 #endif
  50
  51 /* Dummy functions */
  52 int generate_daemon_event(JCR *jcr, const char *event) { return 1; }
  53 extern bool parse_sd_config(CONFIG *config, const char *configfile, int exit_code);
  54
  55 /* External subroutines */
  56 extern void free_config_resources();
  57
  58 /* Exported variables */
  59 int quit = 0;
  60 char buf[100000];
  61 int bsize = TAPE_BSIZE;
  62 char VolName[MAX_NAME_LENGTH];
  63 STORES *me = NULL;                    /* our Global resource */
  64 bool forge_on = false;                /* proceed inspite of I/O errors */
  65 pthread_mutex_t device_release_mutex = PTHREAD_MUTEX_INITIALIZER;
  66 pthread_cond_t wait_device_release = PTHREAD_COND_INITIALIZER;
  67
  68 /*
  69  * If you change the format of the state file,
  70  *  increment this value
  71  */
  72 static uint32_t btape_state_level = 2;
  73
  74 DEVICE *dev = NULL;
  75 DCR *dcr;
  76 DEVRES *device = NULL;
  77
  78
  79 /* Forward referenced subroutines */
  80 static void do_tape_cmds();
  81 static void helpcmd();
  82 static void scancmd();
  83 static void rewindcmd();
  84 static void clearcmd();
  85 static void wrcmd();
  86 static void rrcmd();
  87 static void rbcmd();
  88 static void eodcmd();
  89 static void fillcmd();
  90 static void qfillcmd();
  91 static void statcmd();
  92 static void unfillcmd();
  93 static int flush_block(DEV_BLOCK *block, int dump);
  94 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec);
  95 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block);
  96 static bool my_mount_next_read_volume(DCR *dcr);
  97 static void scan_blocks();
  98 static void set_volume_name(const char *VolName, int volnum);
  99 static void rawfill_cmd();
 100 static bool open_the_device();
 101 static void autochangercmd();
 102 static void do_unfill();
 103
 104
 105 /* Static variables */
 106 static CONFIG *config;
 107 #define CONFIG_FILE "bacula-sd.conf"
 108 char *configfile = NULL;
 109
 110 #define MAX_CMD_ARGS 30
 111 static POOLMEM *cmd;
 112 static POOLMEM *args;
 113 static char *argk[MAX_CMD_ARGS];
 114 static char *argv[MAX_CMD_ARGS];
 115 static int argc;
 116
 117 static int quickie_count = 0;
 118 static uint64_t write_count = 0;
 119 static BSR *bsr = NULL;
 120 static int signals = TRUE;
 121 static bool ok;
 122 static int stop = 0;
 123 static uint64_t vol_size;
 124 static uint64_t VolBytes;
 125 static time_t now;
 126 static double kbs;
 127 static int32_t file_index;
 128 static int end_of_tape = 0;
 129 static uint32_t LastBlock = 0;
 130 static uint32_t eot_block;
 131 static uint32_t eot_block_len;
 132 static uint32_t eot_FileIndex;
 133 static int dumped = 0;
 134 static DEV_BLOCK *last_block1 = NULL;
 135 static DEV_BLOCK *last_block2 = NULL;
 136 static DEV_BLOCK *last_block = NULL;
 137 static DEV_BLOCK *this_block = NULL;
 138 static DEV_BLOCK *first_block = NULL;
 139 static uint32_t last_file1 = 0;
 140 static uint32_t last_file2 = 0;
 141 static uint32_t last_file = 0;
 142 static uint32_t last_block_num1 = 0;
 143 static uint32_t last_block_num2 = 0;
 144 static uint32_t last_block_num = 0;
 145 static uint32_t BlockNumber = 0;
 146 static bool simple = true;
 147
 148 static const char *VolumeName = NULL;
 149 static int vol_num = 0;
 150
 151 static JCR *jcr = NULL;
 152
 153
 154 static void usage();
 155 static void terminate_btape(int sig);
 156 int get_cmd(const char *prompt);
 157
 158
 159 /*********************************************************************
 160  *
 161  *     Bacula tape testing program
 162  *
 163  */
 164 int main(int margc, char *margv[])
 165 {
 166    int ch, i;
 167    uint32_t x32, y32;
 168    uint64_t x64, y64;
 169    char buf[1000];
 170
 171    setlocale(LC_ALL, "");
 172    bindtextdomain("bacula", LOCALEDIR);
 173    textdomain("bacula");
 174    init_stack_dump();
 175
 176    /* Sanity checks */
 177    if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
 178       Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"),
 179          TAPE_BSIZE, B_DEV_BSIZE);
 180    }
 181    if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
 182       Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE);
 183    }
 184    if (sizeof(boffset_t) < 8) {
 185       Pmsg1(-1, _("\n\n!!!! Warning large disk addressing disabled. boffset_t=%d should be 8 or more !!!!!\n\n\n"),
 186          sizeof(boffset_t));
 187    }
 188    x32 = 123456789;
 189    bsnprintf(buf, sizeof(buf), "%u", x32);
 190    i = bsscanf(buf, "%lu", &y32);
 191    if (i != 1 || x32 != y32) {
 192       Pmsg3(-1, _("32 bit printf/scanf problem. i=%d x32=%u y32=%u\n"), i, x32, y32);
 193       exit(1);
 194    }
 195    x64 = 123456789;
 196    x64 = x64 << 32;
 197    x64 += 123456789;
 198    bsnprintf(buf, sizeof(buf), "%" llu, x64);
 199    i = bsscanf(buf, "%llu", &y64);
 200    if (i != 1 || x64 != y64) {
 201       Pmsg3(-1, _("64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n"),
 202             i, x64, y64);
 203       exit(1);
 204    }
 205
 206    printf(_("Tape block granularity is %d bytes.\n"), TAPE_BSIZE);
 207
 208    working_directory = "/tmp";
 209    my_name_is(margc, margv, "btape");
 210    init_msg(NULL, NULL);
 211
 212    OSDependentInit();
 213
 214    while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
 215       switch (ch) {
 216       case 'b':                    /* bootstrap file */
 217          bsr = parse_bsr(NULL, optarg);
 218 //       dump_bsr(bsr, true);
 219          break;
 220
 221       case 'c':                    /* specify config file */
 222          if (configfile != NULL) {
 223             free(configfile);
 224          }
 225          configfile = bstrdup(optarg);
 226          break;
 227
 228       case 'd':                    /* set debug level */
 229          if (*optarg == 't') {
 230             dbg_timestamp = true;
 231          } else {
 232             debug_level = atoi(optarg);
 233             if (debug_level <= 0) {
 234                debug_level = 1;
 235             }
 236          }
 237          break;
 238
 239       case 'p':
 240          forge_on = true;
 241          break;
 242
 243       case 's':
 244          signals = false;
 245          break;
 246
 247       case 'v':
 248          verbose++;
 249          break;
 250
 251       case '?':
 252       default:
 253          helpcmd();
 254          exit(0);
 255
 256       }
 257    }
 258    margc -= optind;
 259    margv += optind;
 260
 261    cmd = get_pool_memory(PM_FNAME);
 262    args = get_pool_memory(PM_FNAME);
 263
 264    if (signals) {
 265       init_signals(terminate_btape);
 266    }
 267
 268    if (configfile == NULL) {
 269       configfile = bstrdup(CONFIG_FILE);
 270    }
 271
 272    daemon_start_time = time(NULL);
 273
 274    config = new_config_parser();
 275    parse_sd_config(config, configfile, M_ERROR_TERM);
 276
 277    /* See if we can open a device */
 278    if (margc == 0) {
 279       Pmsg0(000, _("No archive name specified.\n"));
 280       usage();
 281       exit(1);
 282    } else if (margc != 1) {
 283       Pmsg0(000, _("Improper number of arguments specified.\n"));
 284       usage();
 285       exit(1);
 286    }
 287
 288    jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
 289    if (!jcr) {
 290       exit(1);
 291    }
 292    dev = jcr->dcr->dev;
 293    if (!dev) {
 294       exit(1);
 295    }
 296    if (dev->is_dvd()) {
 297       Pmsg0(000, _("btape does not work with DVD storage.\n"));
 298       usage();
 299       exit(1);
 300    }
 301    if (!dev->is_tape()) {
 302       Pmsg0(000, _("btape only works with tape storage.\n"));
 303       usage();
 304       exit(1);
 305    }
 306    dcr = jcr->dcr;
 307    if (!open_the_device()) {
 308       goto terminate;
 309    }
 310
 311    Dmsg0(200, "Do tape commands\n");
 312    do_tape_cmds();
 313
 314 terminate:
 315    terminate_btape(0);
 316    return 0;
 317 }
 318
 319 static void terminate_btape(int stat)
 320 {
 321
 322    sm_check(__FILE__, __LINE__, false);
 323    if (configfile) {
 324       free(configfile);
 325    }
 326    if (config) {
 327       config->free_resources();
 328       free(config);
 329       config = NULL;
 330    }
 331    if (args) {
 332       free_pool_memory(args);
 333       args = NULL;
 334    }
 335    if (cmd) {
 336       free_pool_memory(cmd);
 337       cmd = NULL;
 338    }
 339
 340    if (bsr) {
 341       free_bsr(bsr);
 342    }
 343
 344    free_jcr(jcr);
 345    jcr = NULL;
 346
 347    free_volume_list();
 348
 349    if (dev) {
 350       dev->term();
 351    }
 352
 353    if (debug_level > 10)
 354       print_memory_pool_stats();
 355
 356    if (this_block) {
 357       free_block(this_block);
 358    }
 359
 360    stop_watchdog();
 361    term_msg();
 362    close_memory_pool();               /* free memory in pool */
 363    term_last_jobs_list();
 364
 365    sm_dump(false);
 366    exit(stat);
 367 }
 368
 369 static bool open_the_device()
 370 {
 371    DEV_BLOCK *block;
 372    bool ok = true;
 373
 374    block = new_block(dev);
 375    dev->r_dlock();
 376    Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
 377    if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
 378       Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
 379       ok = false;
 380       goto bail_out;
 381    }
 382    Pmsg1(000, _("open device %s: OK\n"), dev->print_name());
 383    dev->set_append();                 /* put volume in append mode */
 384
 385 bail_out:
 386    dev->dunlock();
 387    free_block(block);
 388    return ok;
 389 }
 390
 391
 392 void quitcmd()
 393 {
 394    quit = 1;
 395 }
 396
 397 /*
 398  * Write a label to the tape
 399  */
 400 static void labelcmd()
 401 {
 402    if (VolumeName) {
 403       pm_strcpy(cmd, VolumeName);
 404    } else {
 405       if (!get_cmd(_("Enter Volume Name: "))) {
 406          return;
 407       }
 408    }
 409
 410    if (!dev->is_open()) {
 411       if (!first_open_device(dcr)) {
 412          Pmsg1(0, _("Device open failed. ERR=%s\n"), dev->bstrerror());
 413       }
 414    }
 415    dev->rewind(dcr);
 416    dev->weof(1);
 417    write_new_volume_label_to_dev(dcr, cmd, "Default", false,/*no relabel*/ true /* label dvd now */);
 418    Pmsg1(-1, _("Wrote Volume label for volume \"%s\".\n"), cmd);
 419 }
 420
 421 /*
 422  * Read the tape label
 423  */
 424 static void readlabelcmd()
 425 {
 426    int save_debug_level = debug_level;
 427    int stat;
 428
 429    stat = read_dev_volume_label(dcr);
 430    switch (stat) {
 431    case VOL_NO_LABEL:
 432       Pmsg0(0, _("Volume has no label.\n"));
 433       break;
 434    case VOL_OK:
 435       Pmsg0(0, _("Volume label read correctly.\n"));
 436       break;
 437    case VOL_IO_ERROR:
 438       Pmsg1(0, _("I/O error on device: ERR=%s"), dev->bstrerror());
 439       break;
 440    case VOL_NAME_ERROR:
 441       Pmsg0(0, _("Volume name error\n"));
 442       break;
 443    case VOL_CREATE_ERROR:
 444       Pmsg1(0, _("Error creating label. ERR=%s"), dev->bstrerror());
 445       break;
 446    case VOL_VERSION_ERROR:
 447       Pmsg0(0, _("Volume version error.\n"));
 448       break;
 449    case VOL_LABEL_ERROR:
 450       Pmsg0(0, _("Bad Volume label type.\n"));
 451       break;
 452    default:
 453       Pmsg0(0, _("Unknown error.\n"));
 454       break;
 455    }
 456
 457    debug_level = 20;
 458    dump_volume_label(dev);
 459    debug_level = save_debug_level;
 460 }
 461
 462
 463 /*
 464  * Load the tape should have prevously been taken
 465  * off line, otherwise this command is not necessary.
 466  */
 467 static void loadcmd()
 468 {
 469
 470    if (!load_dev(dev)) {
 471       Pmsg1(0, _("Bad status from load. ERR=%s\n"), dev->bstrerror());
 472    } else
 473       Pmsg1(0, _("Loaded %s\n"), dev->print_name());
 474 }
 475
 476 /*
 477  * Rewind the tape.
 478  */
 479 static void rewindcmd()
 480 {
 481    if (!dev->rewind(dcr)) {
 482       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
 483       dev->clrerror(-1);
 484    } else {
 485       Pmsg1(0, _("Rewound %s\n"), dev->print_name());
 486    }
 487 }
 488
 489 /*
 490  * Clear any tape error
 491  */
 492 static void clearcmd()
 493 {
 494    dev->clrerror(-1);
 495 }
 496
 497 /*
 498  * Write and end of file on the tape
 499  */
 500 static void weofcmd()
 501 {
 502    int num = 1;
 503    if (argc > 1) {
 504       num = atoi(argk[1]);
 505    }
 506    if (num <= 0) {
 507       num = 1;
 508    }
 509
 510    if (!dev->weof(num)) {
 511       Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
 512       return;
 513    } else {
 514       if (num==1) {
 515          Pmsg1(0, _("Wrote 1 EOF to %s\n"), dev->print_name());
 516       }
 517       else {
 518          Pmsg2(0, _("Wrote %d EOFs to %s\n"), num, dev->print_name());
 519       }
 520    }
 521 }
 522
 523
 524 /* Go to the end of the medium -- raw command
 525  * The idea was orginally that the end of the Bacula
 526  * medium would be flagged differently. This is not
 527  * currently the case. So, this is identical to the
 528  * eodcmd().
 529  */
 530 static void eomcmd()
 531 {
 532    if (!dev->eod(dcr)) {
 533       Pmsg1(0, "%s", dev->bstrerror());
 534       return;
 535    } else {
 536       Pmsg0(0, _("Moved to end of medium.\n"));
 537    }
 538 }
 539
 540 /*
 541  * Go to the end of the medium (either hardware determined
 542  *  or defined by two eofs.
 543  */
 544 static void eodcmd()
 545 {
 546    eomcmd();
 547 }
 548
 549 /*
 550  * Backspace file
 551  */
 552 static void bsfcmd()
 553 {
 554    int num = 1;
 555    if (argc > 1) {
 556       num = atoi(argk[1]);
 557    }
 558    if (num <= 0) {
 559       num = 1;
 560    }
 561
 562    if (!dev->bsf(num)) {
 563       Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), dev->bstrerror());
 564    } else {
 565       Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
 566    }
 567 }
 568
 569 /*
 570  * Backspace record
 571  */
 572 static void bsrcmd()
 573 {
 574    int num = 1;
 575    if (argc > 1) {
 576       num = atoi(argk[1]);
 577    }
 578    if (num <= 0) {
 579       num = 1;
 580    }
 581    if (!dev->bsr(num)) {
 582       Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), dev->bstrerror());
 583    } else {
 584       Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
 585    }
 586 }
 587
 588 /*
 589  * List device capabilities as defined in the
 590  *  stored.conf file.
 591  */
 592 static void capcmd()
 593 {
 594    printf(_("Configured device capabilities:\n"));
 595    printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
 596    printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
 597    printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
 598    printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
 599    printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
 600    printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
 601    printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
 602    printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
 603    printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
 604    printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
 605    printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
 606    printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
 607    printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
 608    printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
 609    printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
 610    printf("\n");
 611
 612    printf(_("Device status:\n"));
 613    printf("%sOPENED ", dev->is_open() ? "" : "!");
 614    printf("%sTAPE ", dev->is_tape() ? "" : "!");
 615    printf("%sLABEL ", dev->is_labeled() ? "" : "!");
 616    printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
 617    printf("%sAPPEND ", dev->can_append() ? "" : "!");
 618    printf("%sREAD ", dev->can_read() ? "" : "!");
 619    printf("%sEOT ", dev->at_eot() ? "" : "!");
 620    printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
 621    printf("%sEOF ", dev->at_eof() ? "" : "!");
 622    printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
 623    printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
 624    printf("\n");
 625
 626    printf(_("Device parameters:\n"));
 627    printf("Device name: %s\n", dev->dev_name);
 628    printf("File=%u block=%u\n", dev->file, dev->block_num);
 629    printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
 630
 631    printf(_("Status:\n"));
 632    statcmd();
 633
 634 }
 635
 636 /*
 637  * Test writting larger and larger records.
 638  * This is a torture test for records.
 639  */
 640 static void rectestcmd()
 641 {
 642    DEV_BLOCK *block;
 643    DEV_RECORD *rec;
 644    int i, blkno = 0;
 645
 646    Pmsg0(0, _("Test writting larger and larger records.\n"
 647 "This is a torture test for records.\nI am going to write\n"
 648 "larger and larger records. It will stop when the record size\n"
 649 "plus the header exceeds the block size (by default about 64K)\n"));
 650
 651
 652    get_cmd(_("Do you want to continue? (y/n): "));
 653    if (cmd[0] != 'y') {
 654       Pmsg0(000, _("Command aborted.\n"));
 655       return;
 656    }
 657
 658    sm_check(__FILE__, __LINE__, false);
 659    block = new_block(dev);
 660    rec = new_record();
 661
 662    for (i=1; i<500000; i++) {
 663       rec->data = check_pool_memory_size(rec->data, i);
 664       memset(rec->data, i & 0xFF, i);
 665       rec->data_len = i;
 666       sm_check(__FILE__, __LINE__, false);
 667       if (write_record_to_block(block, rec)) {
 668          empty_block(block);
 669          blkno++;
 670          Pmsg2(0, _("Block %d i=%d\n"), blkno, i);
 671       } else {
 672          break;
 673       }
 674       sm_check(__FILE__, __LINE__, false);
 675    }
 676    free_record(rec);
 677    free_block(block);
 678    sm_check(__FILE__, __LINE__, false);
 679 }
 680
 681 /*
 682  * This test attempts to re-read a block written by Bacula
 683  *   normally at the end of the tape. Bacula will then back up
 684  *   over the two eof marks, backup over the record and reread
 685  *   it to make sure it is valid.  Bacula can skip this validation
 686  *   if you set "Backward space record = no"
 687  */
 688 static int re_read_block_test()
 689 {
 690    DEV_BLOCK *block = dcr->block;
 691    DEV_RECORD *rec;
 692    int stat = 0;
 693    int len;
 694
 695    if (!(dev->capabilities & CAP_BSR)) {
 696       Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
 697       return 0;
 698    }
 699
 700    Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
 701       "I'm going to write three records and an EOF\n"
 702       "then backup over the EOF and re-read the last record.\n"
 703       "Bacula does this after writing the last block on the\n"
 704       "tape to verify that the block was written correctly.\n\n"
 705       "This is not an *essential* feature ...\n\n"));
 706    rewindcmd();
 707    empty_block(block);
 708    rec = new_record();
 709    rec->data = check_pool_memory_size(rec->data, block->buf_len);
 710    len = rec->data_len = block->buf_len-100;
 711    memset(rec->data, 1, rec->data_len);
 712    if (!write_record_to_block(block, rec)) {
 713       Pmsg0(0, _("Error writing record to block.\n"));
 714       goto bail_out;
 715    }
 716    if (!write_block_to_dev(dcr)) {
 717       Pmsg0(0, _("Error writing block to device.\n"));
 718       goto bail_out;
 719    } else {
 720       Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
 721    }
 722    memset(rec->data, 2, rec->data_len);
 723    if (!write_record_to_block(block, rec)) {
 724       Pmsg0(0, _("Error writing record to block.\n"));
 725       goto bail_out;
 726    }
 727    if (!write_block_to_dev(dcr)) {
 728       Pmsg0(0, _("Error writing block to device.\n"));
 729       goto bail_out;
 730    } else {
 731       Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
 732    }
 733    memset(rec->data, 3, rec->data_len);
 734    if (!write_record_to_block(block, rec)) {
 735       Pmsg0(0, _("Error writing record to block.\n"));
 736       goto bail_out;
 737    }
 738    if (!write_block_to_dev(dcr)) {
 739       Pmsg0(0, _("Error writing block to device.\n"));
 740       goto bail_out;
 741    } else {
 742       Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
 743    }
 744    weofcmd();
 745    if (dev->has_cap(CAP_TWOEOF)) {
 746       weofcmd();
 747    }
 748    if (!dev->bsf(1)) {
 749       Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
 750       goto bail_out;
 751    }
 752    if (dev->has_cap(CAP_TWOEOF)) {
 753       if (!dev->bsf(1)) {
 754          Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
 755          goto bail_out;
 756       }
 757    }
 758    Pmsg0(0, _("Backspaced over EOF OK.\n"));
 759    if (!dev->bsr(1)) {
 760       Pmsg1(0, _("Backspace record failed! ERR=%s\n"), dev->bstrerror());
 761       goto bail_out;
 762    }
 763    Pmsg0(0, _("Backspace record OK.\n"));
 764    if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
 765       berrno be;
 766       Pmsg1(0, _("Read block failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
 767       goto bail_out;
 768    }
 769    memset(rec->data, 0, rec->data_len);
 770    if (!read_record_from_block(dcr, block, rec)) {
 771       berrno be;
 772       Pmsg1(0, _("Read block failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
 773       goto bail_out;
 774    }
 775    for (int i=0; i<len; i++) {
 776       if (rec->data[i] != 3) {
 777          Pmsg0(0, _("Bad data in record. Test failed!\n"));
 778          goto bail_out;
 779       }
 780    }
 781    Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
 782    Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
 783
 784    stat = 1;
 785
 786 bail_out:
 787    free_record(rec);
 788    if (stat == 0) {
 789       Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
 790                  "this function to verify the last block written to the\n"
 791                  "tape. Bacula will skip the last block verification\n"
 792                  "if you add:\n\n"
 793                   "Backward Space Record = No\n\n"
 794                   "to your Storage daemon's Device resource definition.\n"));
 795    }
 796    return stat;
 797 }
 798
 799
 800 /*
 801  * This test writes Bacula blocks to the tape in
 802  *   several files. It then rewinds the tape and attepts
 803  *   to read these blocks back checking the data.
 804  */
 805 static int write_read_test()
 806 {
 807    DEV_BLOCK *block;
 808    DEV_RECORD *rec;
 809    int stat = 0;
 810    int len, i, j;
 811    int *p;
 812
 813    Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
 814       "I'm going to write 1000 records and an EOF\n"
 815       "then write 1000 records and an EOF, then rewind,\n"
 816       "and re-read the data to verify that it is correct.\n\n"
 817       "This is an *essential* feature ...\n\n"));
 818    block = dcr->block;
 819    rec = new_record();
 820    if (!dev->rewind(dcr)) {
 821       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
 822       goto bail_out;
 823    }
 824    rec->data = check_pool_memory_size(rec->data, block->buf_len);
 825    rec->data_len = block->buf_len-100;
 826    len = rec->data_len/sizeof(i);
 827    for (i=1; i<=1000; i++) {
 828       p = (int *)rec->data;
 829       for (j=0; j<len; j++) {
 830          *p++ = i;
 831       }
 832       if (!write_record_to_block(block, rec)) {
 833          Pmsg0(0, _("Error writing record to block.\n"));
 834          goto bail_out;
 835       }
 836       if (!write_block_to_dev(dcr)) {
 837          Pmsg0(0, _("Error writing block to device.\n"));
 838          goto bail_out;
 839       }
 840    }
 841    Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
 842    weofcmd();
 843    for (i=1001; i<=2000; i++) {
 844       p = (int *)rec->data;
 845       for (j=0; j<len; j++) {
 846          *p++ = i;
 847       }
 848       if (!write_record_to_block(block, rec)) {
 849          Pmsg0(0, _("Error writing record to block.\n"));
 850          goto bail_out;
 851       }
 852       if (!write_block_to_dev(dcr)) {
 853          Pmsg0(0, _("Error writing block to device.\n"));
 854          goto bail_out;
 855       }
 856    }
 857    Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
 858    weofcmd();
 859    if (dev->has_cap(CAP_TWOEOF)) {
 860       weofcmd();
 861    }
 862    if (!dev->rewind(dcr)) {
 863       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
 864       goto bail_out;
 865    } else {
 866       Pmsg0(0, _("Rewind OK.\n"));
 867    }
 868    for (i=1; i<=2000; i++) {
 869 read_again:
 870       if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
 871          berrno be;
 872          if (dev_state(dev, ST_EOF)) {
 873             Pmsg0(-1, _("Got EOF on tape.\n"));
 874             if (i == 1001) {
 875                goto read_again;
 876             }
 877          }
 878          Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.bstrerror(dev->dev_errno));
 879          goto bail_out;
 880       }
 881       memset(rec->data, 0, rec->data_len);
 882       if (!read_record_from_block(dcr, block, rec)) {
 883          berrno be;
 884          Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.bstrerror(dev->dev_errno));
 885          goto bail_out;
 886       }
 887       p = (int *)rec->data;
 888       for (j=0; j<len; j++) {
 889          if (*p != i) {
 890             Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
 891                i, *p, j);
 892             goto bail_out;
 893          }
 894          p++;
 895       }
 896       if (i == 1000 || i == 2000) {
 897          Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
 898       }
 899    }
 900    Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
 901    stat = 1;
 902
 903 bail_out:
 904    free_record(rec);
 905    return stat;
 906 }
 907
 908 /*
 909  * This test writes Bacula blocks to the tape in
 910  *   several files. It then rewinds the tape and attepts
 911  *   to read these blocks back checking the data.
 912  */
 913 static int position_test()
 914 {
 915    DEV_BLOCK *block = dcr->block;
 916    DEV_RECORD *rec;
 917    int stat = 0;
 918    int len, i, j;
 919    bool ok = true;
 920    int recno = 0;
 921    int file = 0, blk = 0;
 922    int *p;
 923    bool got_eof = false;
 924
 925    Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
 926       "I'm going to write 1000 records and an EOF\n"
 927       "then write 1000 records and an EOF, then rewind,\n"
 928       "and position to a few blocks and verify that it is correct.\n\n"
 929       "This is an *essential* feature ...\n\n"));
 930    empty_block(block);
 931    rec = new_record();
 932    if (!dev->rewind(dcr)) {
 933       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
 934       goto bail_out;
 935    }
 936    rec->data = check_pool_memory_size(rec->data, block->buf_len);
 937    rec->data_len = block->buf_len-100;
 938    len = rec->data_len/sizeof(i);
 939    for (i=1; i<=1000; i++) {
 940       p = (int *)rec->data;
 941       for (j=0; j<len; j++) {
 942          *p++ = i;
 943       }
 944       if (!write_record_to_block(block, rec)) {
 945          Pmsg0(0, _("Error writing record to block.\n"));
 946          goto bail_out;
 947       }
 948       if (!write_block_to_dev(dcr)) {
 949          Pmsg0(0, _("Error writing block to device.\n"));
 950          goto bail_out;
 951       }
 952    }
 953    Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
 954    weofcmd();
 955    for (i=1001; i<=2000; i++) {
 956       p = (int *)rec->data;
 957       for (j=0; j<len; j++) {
 958          *p++ = i;
 959       }
 960       if (!write_record_to_block(block, rec)) {
 961          Pmsg0(0, _("Error writing record to block.\n"));
 962          goto bail_out;
 963       }
 964       if (!write_block_to_dev(dcr)) {
 965          Pmsg0(0, _("Error writing block to device.\n"));
 966          goto bail_out;
 967       }
 968    }
 969    Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
 970    weofcmd();
 971    if (dev->has_cap(CAP_TWOEOF)) {
 972       weofcmd();
 973    }
 974    if (!dev->rewind(dcr)) {
 975       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
 976       goto bail_out;
 977    } else {
 978       Pmsg0(0, _("Rewind OK.\n"));
 979    }
 980
 981    while(ok) {
 982       /* Set up next item to read based on where we are */
 983       switch (recno) {
 984       case 0:
 985          recno = 5;
 986          file = 0;
 987          blk = 4;
 988          break;
 989       case 5:
 990          recno = 201;
 991          file = 0;
 992          blk = 200;
 993          break;
 994       case 201:
 995          recno = 1000;
 996          file = 0;
 997          blk = 999;
 998          break;
 999       case 1000:
1000          recno = 1001;
1001          file = 1;
1002          blk = 0;
1003          break;
1004       case 1001:
1005          recno = 1601;
1006          file = 1;
1007          blk = 600;
1008          break;
1009       case 1601:
1010          recno = 2000;
1011          file = 1;
1012          blk = 999;
1013          break;
1014       case 2000:
1015          ok = false;
1016          continue;
1017       }
1018       Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
1019       if (!dev->reposition(dcr, file, blk)) {
1020          Pmsg0(0, _("Reposition error.\n"));
1021          goto bail_out;
1022       }
1023 read_again:
1024       if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1025          berrno be;
1026          if (dev_state(dev, ST_EOF)) {
1027             Pmsg0(-1, _("Got EOF on tape.\n"));
1028             if (!got_eof) {
1029                got_eof = true;
1030                goto read_again;
1031             }
1032          }
1033          Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
1034             recno, file, blk, be.bstrerror(dev->dev_errno));
1035          Pmsg0(0, _("This may be because the tape drive block size is not\n"
1036                     " set to variable blocking as normally used by Bacula.\n"
1037                     " Please see the Tape Testing chapter in the manual and \n"
1038                     " look for using mt with defblksize and setoptions\n"
1039                     "If your tape drive block size is correct, then perhaps\n"
1040                     " your SCSI driver is *really* stupid and does not\n"
1041                     " correctly report the file:block after a FSF. In this\n"
1042                     " case try setting:\n"
1043                     "    Fast Forward Space File = no\n"
1044                     " in your Device resource.\n"));
1045
1046          goto bail_out;
1047       }
1048       memset(rec->data, 0, rec->data_len);
1049       if (!read_record_from_block(dcr, block, rec)) {
1050          berrno be;
1051          Pmsg1(0, _("Read record failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
1052          goto bail_out;
1053       }
1054       p = (int *)rec->data;
1055       for (j=0; j<len; j++) {
1056          if (p[j] != recno) {
1057             Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1058                recno, p[j], j);
1059             goto bail_out;
1060          }
1061       }
1062       Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1063    }
1064    Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1065    stat = 1;
1066
1067 bail_out:
1068    free_record(rec);
1069    return stat;
1070 }
1071
1072
1073
1074
1075 /*
1076  * This test writes some records, then writes an end of file,
1077  *   rewinds the tape, moves to the end of the data and attepts
1078  *   to append to the tape.  This function is essential for
1079  *   Bacula to be able to write multiple jobs to the tape.
1080  */
1081 static int append_test()
1082 {
1083    Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1084                "This test is essential to Bacula.\n\n"
1085 "I'm going to write one record  in file 0,\n"
1086 "                   two records in file 1,\n"
1087 "             and three records in file 2\n\n"));
1088    argc = 1;
1089    rewindcmd();
1090    wrcmd();
1091    weofcmd();      /* end file 0 */
1092    wrcmd();
1093    wrcmd();
1094    weofcmd();      /* end file 1 */
1095    wrcmd();
1096    wrcmd();
1097    wrcmd();
1098    weofcmd();     /* end file 2 */
1099    if (dev->has_cap(CAP_TWOEOF)) {
1100       weofcmd();
1101    }
1102    dev->close();              /* release device */
1103    if (!open_the_device()) {
1104       return -1;
1105    }
1106    rewindcmd();
1107    Pmsg0(0, _("Now moving to end of medium.\n"));
1108    eodcmd();
1109    Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1110       dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1111
1112    if (dev->file != 3) {
1113       return -1;
1114    }
1115
1116    Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1117    wrcmd();
1118    weofcmd();
1119    if (dev->has_cap(CAP_TWOEOF)) {
1120       weofcmd();
1121    }
1122    rewindcmd();
1123    Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1124    Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1125    scan_blocks();
1126    Pmsg0(-1, _("End scanning the tape.\n"));
1127    Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1128       dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1129
1130    if (dev->file != 4) {
1131       return -2;
1132    }
1133    return 1;
1134 }
1135
1136
1137 /*
1138  * This test exercises the autochanger
1139  */
1140 static int autochanger_test()
1141 {
1142    POOLMEM *results, *changer;
1143    int slot, status, loaded;
1144    int timeout = dcr->device->max_changer_wait;
1145    int sleep_time = 0;
1146
1147    Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1148    if (!dev->has_cap(CAP_AUTOCHANGER)) {
1149       return 1;
1150    }
1151    if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1152       Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1153       return 1;
1154    }
1155
1156    Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1157              "To test the autochanger you must have a blank tape\n"
1158              " that I can write on in Slot 1.\n"));
1159    if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1160       return 0;
1161    }
1162    if (cmd[0] != 'y' && cmd[0] != 'Y') {
1163       return 0;
1164    }
1165
1166    Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1167
1168    results = get_pool_memory(PM_MESSAGE);
1169    changer = get_pool_memory(PM_FNAME);
1170
1171 try_again:
1172    slot = 1;
1173    dcr->VolCatInfo.Slot = slot;
1174    /* Find out what is loaded, zero means device is unloaded */
1175    Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1176    changer = edit_device_codes(dcr, changer,
1177                 dcr->device->changer_command, "loaded");
1178    status = run_program(changer, timeout, results);
1179    Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1180    if (status == 0) {
1181       loaded = atoi(results);
1182    } else {
1183       berrno be;
1184       Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1185       Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1186       goto bail_out;
1187    }
1188    if (loaded) {
1189       Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1190    } else {
1191       Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1192    }
1193    Dmsg1(100, "Results from loaded query=%s\n", results);
1194    if (loaded) {
1195       dcr->VolCatInfo.Slot = loaded;
1196       /* We are going to load a new tape, so close the device */
1197       dev->close();
1198       Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1199          loaded, dev->drive_index);
1200       changer = edit_device_codes(dcr, changer,
1201                    dcr->device->changer_command, "unload");
1202       status = run_program(changer, timeout, results);
1203       Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1204       if (status != 0) {
1205          berrno be;
1206          Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1207          Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1208       }
1209    }
1210
1211    /*
1212     * Load the Slot 1
1213     */
1214
1215    slot = 1;
1216    dcr->VolCatInfo.Slot = slot;
1217    Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1218       slot, dev->drive_index);
1219    changer = edit_device_codes(dcr, changer,
1220                 dcr->device->changer_command, "load");
1221    Dmsg1(100, "Changer=%s\n", changer);
1222    dev->close();
1223    status = run_program(changer, timeout, results);
1224    if (status == 0) {
1225       Pmsg2(-1,  _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1226          slot, dev->drive_index);
1227    } else {
1228       berrno be;
1229       Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1230       Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1231       goto bail_out;
1232    }
1233
1234    if (!open_the_device()) {
1235       goto bail_out;
1236    }
1237    /*
1238     * Start with sleep_time 0 then increment by 30 seconds if we get
1239     * a failure.
1240     */
1241    bmicrosleep(sleep_time, 0);
1242    if (!dev->rewind(dcr) || !dev->weof(1)) {
1243       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1244       dev->clrerror(-1);
1245       Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1246                 "a longer sleep time in the mtx-script in the load) case.\n"
1247                 "Adding a 30 second sleep and trying again ...\n"));
1248       sleep_time += 30;
1249       goto try_again;
1250    } else {
1251       Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1252    }
1253
1254    if (!dev->weof(1)) {
1255       Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
1256       goto bail_out;
1257    } else {
1258       Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1259    }
1260
1261    if (sleep_time) {
1262       Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1263                 "   sleep %d\n\n"
1264                 "to your mtx-changer script in the load) case.\n\n"),
1265                 sleep_time);
1266    } else {
1267       Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1268    }
1269
1270    free_pool_memory(changer);
1271    free_pool_memory(results);
1272    return 1;
1273
1274
1275 bail_out:
1276    free_pool_memory(changer);
1277    free_pool_memory(results);
1278    Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1279    return -2;
1280 }
1281
1282 static void autochangercmd()
1283 {
1284    autochanger_test();
1285 }
1286
1287
1288 /*
1289  * This test assumes that the append test has been done,
1290  *   then it tests the fsf function.
1291  */
1292 static int fsf_test()
1293 {
1294    bool set_off = false;
1295
1296    Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1297                "This test is essential to Bacula.\n\n"
1298                "I'm going to write five files then test forward spacing\n\n"));
1299    argc = 1;
1300    rewindcmd();
1301    wrcmd();
1302    weofcmd();      /* end file 0 */
1303    wrcmd();
1304    wrcmd();
1305    weofcmd();      /* end file 1 */
1306    wrcmd();
1307    wrcmd();
1308    wrcmd();
1309    weofcmd();     /* end file 2 */
1310    wrcmd();
1311    wrcmd();
1312    weofcmd();     /* end file 3 */
1313    wrcmd();
1314    weofcmd();     /* end file 4 */
1315    if (dev->has_cap(CAP_TWOEOF)) {
1316       weofcmd();
1317    }
1318
1319 test_again:
1320    rewindcmd();
1321    Pmsg0(0, _("Now forward spacing 1 file.\n"));
1322    if (!dev->fsf(1)) {
1323       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1324       goto bail_out;
1325    }
1326    Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1327       dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1328
1329    if (dev->file != 1) {
1330       goto bail_out;
1331    }
1332
1333    Pmsg0(0, _("Now forward spacing 2 files.\n"));
1334    if (!dev->fsf(2)) {
1335       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1336       goto bail_out;
1337    }
1338    Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1339       dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1340
1341    if (dev->file != 3) {
1342       goto bail_out;
1343    }
1344
1345    rewindcmd();
1346    Pmsg0(0, _("Now forward spacing 4 files.\n"));
1347    if (!dev->fsf(4)) {
1348       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1349       goto bail_out;
1350    }
1351    Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1352       dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1353
1354    if (dev->file != 4) {
1355       goto bail_out;
1356    }
1357    if (set_off) {
1358       Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1359                 "   Fast Forward Space File = no\n\n"
1360                 "to your Device resource for this drive.\n"));
1361    }
1362
1363    Pmsg0(-1, "\n");
1364    Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1365    if (!dev->fsf(1)) {
1366       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1367    }
1368    Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1369       dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1370    if (dev->file != 5) {
1371       goto bail_out;
1372    }
1373    Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1374    return 1;
1375
1376 bail_out:
1377    Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1378    if (dev->has_cap(CAP_FASTFSF)) {
1379       Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1380               "I am turning it off then retrying the test.\n"));
1381       dev->clear_cap(CAP_FASTFSF);
1382       set_off = true;
1383       goto test_again;
1384    }
1385    Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1386             "Some systems, e.g. OpenBSD, require you to set\n"
1387             "   Use MTIOCGET= no\n"
1388             "in your device resource. Use with caution.\n"));
1389    return -2;
1390 }
1391
1392
1393
1394
1395
1396 /*
1397  * This is a general test of Bacula's functions
1398  *   needed to read and write the tape.
1399  */
1400 static void testcmd()
1401 {
1402    int stat;
1403
1404    if (!write_read_test()) {
1405       return;
1406    }
1407    if (!position_test()) {
1408       return;
1409    }
1410
1411    stat = append_test();
1412    if (stat == 1) {                   /* OK get out */
1413       goto all_done;
1414    }
1415    if (stat == -1) {                  /* first test failed */
1416       if (dev->has_cap(CAP_EOM) || dev->has_cap(CAP_FASTFSF)) {
1417          Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1418                    "Setting \"Hardware End of Medium = no\n"
1419                    "    and \"Fast Forward Space File = no\n"
1420                    "and retrying append test.\n\n"));
1421          dev->clear_cap(CAP_EOM);      /* turn off eom */
1422          dev->clear_cap(CAP_FASTFSF);  /* turn off fast fsf */
1423          stat = append_test();
1424          if (stat == 1) {
1425             Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1426                      "    Hardware End of Medium = No\n\n"
1427                      "    Fast Forward Space File = No\n"
1428                      "to your Device resource in the Storage conf file.\n"));
1429             goto all_done;
1430          }
1431          if (stat == -1) {
1432             Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1433             goto failed;
1434          }
1435          /* Wrong count after append */
1436          if (stat == -2) {
1437             Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1438                      "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1439             dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1440             stat = append_test();
1441             if (stat == 1) {
1442                Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1443                      "    Hardware End of Medium = No\n"
1444                      "    Fast Forward Space File = No\n"
1445                      "    BSF at EOM = yes\n\n"
1446                      "to your Device resource in the Storage conf file.\n"));
1447                goto all_done;
1448             }
1449          }
1450
1451       }
1452 failed:
1453       Pmsg0(-1, _("\nAppend test failed.\n\n"
1454             "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1455             "Unable to correct the problem. You MUST fix this\n"
1456              "problem before Bacula can use your tape drive correctly\n"
1457             "\nPerhaps running Bacula in fixed block mode will work.\n"
1458             "Do so by setting:\n\n"
1459             "Minimum Block Size = nnn\n"
1460             "Maximum Block Size = nnn\n\n"
1461             "in your Storage daemon's Device definition.\n"
1462             "nnn must match your tape driver's block size, which\n"
1463             "can be determined by reading your tape manufacturers\n"
1464             "information, and the information on your kernel dirver.\n"
1465             "Fixed block sizes, however, are not normally an ideal solution.\n"
1466             "\n"
1467             "Some systems, e.g. OpenBSD, require you to set\n"
1468             "   Use MTIOCGET= no\n"
1469             "in your device resource. Use with caution.\n"));
1470        return;
1471    }
1472
1473 all_done:
1474    Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1475         "Please double check it ...\n"
1476         "=== Sample correct output ===\n"
1477         "1 block of 64448 bytes in file 1\n"
1478         "End of File mark.\n"
1479         "2 blocks of 64448 bytes in file 2\n"
1480         "End of File mark.\n"
1481         "3 blocks of 64448 bytes in file 3\n"
1482         "End of File mark.\n"
1483         "1 block of 64448 bytes in file 4\n"
1484         "End of File mark.\n"
1485         "Total files=4, blocks=7, bytes = 451,136\n"
1486         "=== End sample correct output ===\n\n"
1487         "If the above scan output is not identical to the\n"
1488         "sample output, you MUST correct the problem\n"
1489         "or Bacula will not be able to write multiple Jobs to \n"
1490         "the tape.\n\n"));
1491
1492    if (stat == 1) {
1493       re_read_block_test();
1494    }
1495
1496    fsf_test();                        /* do fast forward space file test */
1497
1498    autochanger_test();                /* do autochanger test */
1499
1500 }
1501
1502 /* Forward space a file */
1503 static void fsfcmd()
1504 {
1505    int num = 1;
1506    if (argc > 1) {
1507       num = atoi(argk[1]);
1508    }
1509    if (num <= 0) {
1510       num = 1;
1511    }
1512    if (!dev->fsf(num)) {
1513       Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), dev->bstrerror());
1514       return;
1515    }
1516    if (num == 1) {
1517       Pmsg0(0, _("Forward spaced 1 file.\n"));
1518    }
1519    else {
1520       Pmsg1(0, _("Forward spaced %d files.\n"), num);
1521    }
1522 }
1523
1524 /* Forward space a record */
1525 static void fsrcmd()
1526 {
1527    int num = 1;
1528    if (argc > 1) {
1529       num = atoi(argk[1]);
1530    }
1531    if (num <= 0) {
1532       num = 1;
1533    }
1534    if (!dev->fsr(num)) {
1535       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1536       return;
1537    }
1538    if (num == 1) {
1539       Pmsg0(0, _("Forward spaced 1 record.\n"));
1540    }
1541    else {
1542       Pmsg1(0, _("Forward spaced %d records.\n"), num);
1543    }
1544 }
1545
1546 /*
1547  * Read a Bacula block from the tape
1548  */
1549 static void rbcmd()
1550 {
1551    dev->open(dcr, OPEN_READ_ONLY);
1552    read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK);
1553 }
1554
1555 /*
1556  * Write a Bacula block to the tape
1557  */
1558 static void wrcmd()
1559 {
1560    DEV_BLOCK *block = dcr->block;
1561    DEV_RECORD *rec = dcr->rec;
1562    int i;
1563
1564    if (!dev->is_open()) {
1565       open_the_device();
1566    }
1567    sm_check(__FILE__, __LINE__, false);
1568    empty_block(block);
1569    if (verbose > 1) {
1570       dump_block(block, "test");
1571    }
1572
1573    i = block->buf_len - 100;
1574    ASSERT (i > 0);
1575    rec->data = check_pool_memory_size(rec->data, i);
1576    memset(rec->data, i & 0xFF, i);
1577    rec->data_len = i;
1578    sm_check(__FILE__, __LINE__, false);
1579    if (!write_record_to_block(block, rec)) {
1580       Pmsg0(0, _("Error writing record to block.\n"));
1581       goto bail_out;
1582    }
1583    if (!write_block_to_dev(dcr)) {
1584       Pmsg0(0, _("Error writing block to device.\n"));
1585       goto bail_out;
1586    } else {
1587       Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1588    }
1589    Pmsg0(0, _("Wrote block to device.\n"));
1590
1591 bail_out:
1592    sm_check(__FILE__, __LINE__, false);
1593    sm_check(__FILE__, __LINE__, false);
1594 }
1595
1596 /*
1597  * Read a record from the tape
1598  */
1599 static void rrcmd()
1600 {
1601    char *buf;
1602    int stat, len;
1603
1604    if (!get_cmd(_("Enter length to read: "))) {
1605       return;
1606    }
1607    len = atoi(cmd);
1608    if (len < 0 || len > 1000000) {
1609       Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1610       len = 1024;
1611    }
1612    buf = (char *)malloc(len);
1613    stat = read(dev->fd(), buf, len);
1614    if (stat > 0 && stat <= len) {
1615       errno = 0;
1616    }
1617    berrno be;
1618    Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1619       len, stat, be.bstrerror());
1620    free(buf);
1621 }
1622
1623
1624 /*
1625  * Scan tape by reading block by block. Report what is
1626  * on the tape.  Note, this command does raw reads, and as such
1627  * will not work with fixed block size devices.
1628  */
1629 static void scancmd()
1630 {
1631    int stat;
1632    int blocks, tot_blocks, tot_files;
1633    int block_size;
1634    uint64_t bytes;
1635    char ec1[50];
1636
1637
1638    blocks = block_size = tot_blocks = 0;
1639    bytes = 0;
1640    if (dev->state & ST_EOT) {
1641       Pmsg0(0, _("End of tape\n"));
1642       return;
1643    }
1644    dev->update_pos(dcr);
1645    tot_files = dev->file;
1646    Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1647    for (;;) {
1648       if ((stat = read(dev->fd(), buf, sizeof(buf))) < 0) {
1649          berrno be;
1650          dev->clrerror(-1);
1651          Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1652             dev->dev_name, be.bstrerror());
1653          Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
1654          if (blocks > 0) {
1655             if (blocks==1) {
1656                printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1657             }
1658             else {
1659                printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1660             }
1661          }
1662          return;
1663       }
1664       Dmsg1(200, "read status = %d\n", stat);
1665 /*    sleep(1); */
1666       if (stat != block_size) {
1667          dev->update_pos(dcr);
1668          if (blocks > 0) {
1669             if (blocks==1) {
1670                printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1671             }
1672             else {
1673                printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1674             }
1675             blocks = 0;
1676          }
1677          block_size = stat;
1678       }
1679       if (stat == 0) {                /* EOF */
1680          dev->update_pos(dcr);
1681          printf(_("End of File mark.\n"));
1682          /* Two reads of zero means end of tape */
1683          if (dev->state & ST_EOF)
1684             dev->state |= ST_EOT;
1685          else {
1686             dev->state |= ST_EOF;
1687             dev->file++;
1688          }
1689          if (dev->state & ST_EOT) {
1690             printf(_("End of tape\n"));
1691             break;
1692          }
1693       } else {                        /* Got data */
1694          dev->state &= ~ST_EOF;
1695          blocks++;
1696          tot_blocks++;
1697          bytes += stat;
1698       }
1699    }
1700    dev->update_pos(dcr);
1701    tot_files = dev->file - tot_files;
1702    printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1703       edit_uint64_with_commas(bytes, ec1));
1704 }
1705
1706
1707 /*
1708  * Scan tape by reading Bacula block by block. Report what is
1709  * on the tape.  This function reads Bacula blocks, so if your
1710  * Device resource is correctly defined, it should work with
1711  * either variable or fixed block sizes.
1712  */
1713 static void scan_blocks()
1714 {
1715    int blocks, tot_blocks, tot_files;
1716    uint32_t block_size;
1717    uint64_t bytes;
1718    DEV_BLOCK *block = dcr->block;
1719    char ec1[50];
1720    char buf1[100], buf2[100];
1721
1722    blocks = block_size = tot_blocks = 0;
1723    bytes = 0;
1724
1725    empty_block(block);
1726    dev->update_pos(dcr);
1727    tot_files = dev->file;
1728    for (;;) {
1729       if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1730          Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
1731          if (dev->state & ST_EOT) {
1732             if (blocks > 0) {
1733                if (blocks==1) {
1734                   printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1735                }
1736                else {
1737                   printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1738                }
1739                blocks = 0;
1740             }
1741             goto bail_out;
1742          }
1743          if (dev->state & ST_EOF) {
1744             if (blocks > 0) {
1745                if (blocks==1) {
1746                   printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1747                }
1748                else {
1749                   printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1750                }
1751                blocks = 0;
1752             }
1753             printf(_("End of File mark.\n"));
1754             continue;
1755          }
1756          if (dev->state & ST_SHORT) {
1757             if (blocks > 0) {
1758                if (blocks==1) {
1759                   printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1760                }
1761                else {
1762                   printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1763                }
1764                blocks = 0;
1765             }
1766             printf(_("Short block read.\n"));
1767             continue;
1768          }
1769          printf(_("Error reading block. ERR=%s\n"), dev->bstrerror());
1770          goto bail_out;
1771       }
1772       if (block->block_len != block_size) {
1773          if (blocks > 0) {
1774             if (blocks==1) {
1775                printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1776             }
1777             else {
1778                printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1779             }
1780             blocks = 0;
1781          }
1782          block_size = block->block_len;
1783       }
1784       blocks++;
1785       tot_blocks++;
1786       bytes += block->block_len;
1787       Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1788          block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1789          block->VolSessionId, block->VolSessionTime);
1790       if (verbose == 1) {
1791          DEV_RECORD *rec = new_record();
1792          read_record_from_block(dcr, block, rec);
1793          Pmsg8(-1, _("Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1794               block->BlockNumber, dev->block_num, block->block_len,
1795               FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1796               stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
1797          rec->remainder = 0;
1798          free_record(rec);
1799       } else if (verbose > 1) {
1800          dump_block(block, "");
1801       }
1802
1803    }
1804 bail_out:
1805    tot_files = dev->file - tot_files;
1806    printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1807       edit_uint64_with_commas(bytes, ec1));
1808 }
1809
1810
1811 static void statcmd()
1812 {
1813    int debug = debug_level;
1814    debug_level = 30;
1815    Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), dev->bstrerror());
1816 #ifdef xxxx
1817    dump_volume_label(dev);
1818 #endif
1819    debug_level = debug;
1820 }
1821
1822
1823 /*
1824  * First we label the tape, then we fill
1825  *  it with data get a new tape and write a few blocks.
1826  */
1827 static void fillcmd()
1828 {
1829    DEV_RECORD rec;
1830    DEV_BLOCK  *block = dcr->block;
1831    char ec1[50];
1832    char buf1[100], buf2[100];
1833    int fd;
1834    uint32_t i;
1835    uint32_t min_block_size;
1836    struct tm tm;
1837
1838    ok = true;
1839    stop = 0;
1840    vol_num = 0;
1841    last_file = 0;
1842    last_block_num = 0;
1843    BlockNumber = 0;
1844
1845    Pmsg0(-1, _("\n"
1846 "This command simulates Bacula writing to a tape.\n"
1847 "It requires either one or two blank tapes, which it\n"
1848 "will label and write.\n\n"
1849 "If you have an autochanger configured, it will use\n"
1850 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1851 "be prompted to insert the tapes when necessary.\n\n"
1852 "It will print a status approximately\n"
1853 "every 322 MB, and write an EOF every 3.2 GB.  If you have\n"
1854 "selected the simple test option, after writing the first tape\n"
1855 "it will rewind it and re-read the last block written.\n\n"
1856 "If you have selected the multiple tape test, when the first tape\n"
1857 "fills, it will ask for a second, and after writing a few more \n"
1858 "blocks, it will stop.  Then it will begin re-reading the\n"
1859 "two tapes.\n\n"
1860 "This may take a long time -- hours! ...\n\n"));
1861
1862    get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1863            "or the complete multiple tape (m) test: (s/m) "));
1864    if (cmd[0] == 's') {
1865       Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1866       simple = true;
1867    } else if (cmd[0] == 'm') {
1868       Pmsg0(-1, _("Multiple tape test selected.\n"));
1869       simple = false;
1870    } else {
1871       Pmsg0(000, _("Command aborted.\n"));
1872       return;
1873    }
1874
1875    Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1876    Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1877
1878    /* Use fixed block size to simplify read back */
1879    min_block_size = dev->min_block_size;
1880    dev->min_block_size = dev->max_block_size;
1881    set_volume_name("TestVolume1", 1);
1882    dir_ask_sysop_to_create_appendable_volume(dcr);
1883    dev->set_append();                 /* force volume to be relabeled */
1884
1885    /*
1886     * Acquire output device for writing.  Note, after acquiring a
1887     *   device, we MUST release it, which is done at the end of this
1888     *   subroutine.
1889     */
1890    Dmsg0(100, "just before acquire_device\n");
1891    if (!acquire_device_for_append(dcr)) {
1892       set_jcr_job_status(jcr, JS_ErrorTerminated);
1893       return;
1894    }
1895    block = jcr->dcr->block;
1896
1897    Dmsg0(100, "Just after acquire_device_for_append\n");
1898    /*
1899     * Write Begin Session Record
1900     */
1901    if (!write_session_label(dcr, SOS_LABEL)) {
1902       set_jcr_job_status(jcr, JS_ErrorTerminated);
1903       Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1904          dev->bstrerror());
1905       ok = false;
1906    }
1907    Pmsg0(-1, _("Wrote Start of Session label.\n"));
1908
1909    memset(&rec, 0, sizeof(rec));
1910    rec.data = get_memory(100000);     /* max record size */
1911
1912 #define REC_SIZE 32768
1913    rec.data_len = REC_SIZE;
1914
1915    /*
1916     * Put some random data in the record
1917     */
1918    fd = open("/dev/urandom", O_RDONLY);
1919    if (fd != -1) {
1920       read(fd, rec.data, rec.data_len);
1921       close(fd);
1922    } else {
1923       uint32_t *p = (uint32_t *)rec.data;
1924       srandom(time(NULL));
1925       for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1926          p[i] = random();
1927       }
1928    }
1929
1930    /*
1931     * Generate data as if from File daemon, write to device
1932     */
1933    jcr->dcr->VolFirstIndex = 0;
1934    time(&jcr->run_time);              /* start counting time for rates */
1935    (void)localtime_r(&jcr->run_time, &tm);
1936    strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1937    if (simple) {
1938       Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1939    } else {
1940       Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1941    }
1942    for (file_index = 0; ok && !job_canceled(jcr); ) {
1943       rec.VolSessionId = jcr->VolSessionId;
1944       rec.VolSessionTime = jcr->VolSessionTime;
1945       rec.FileIndex = ++file_index;
1946       rec.Stream = STREAM_FILE_DATA;
1947
1948       /* Mix up the data just a bit */
1949       uint32_t *lp = (uint32_t *)rec.data;
1950       lp[0] += lp[13];
1951       for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1952          lp[i] += lp[i-1];
1953       }
1954
1955       Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1956          rec.FileIndex, rec.VolSessionId,
1957          stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1958          rec.data_len);
1959
1960       while (!write_record_to_block(block, &rec)) {
1961          /*
1962           * When we get here we have just filled a block
1963           */
1964          Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1965                     rec.remainder);
1966
1967          /* Write block to tape */
1968          if (!flush_block(block, 1)) {
1969             break;
1970          }
1971
1972          /* Every 5000 blocks (approx 322MB) report where we are.
1973           */
1974          if ((block->BlockNumber % 5000) == 0) {
1975             now = time(NULL);
1976             now -= jcr->run_time;
1977             if (now <= 0) {
1978                now = 1;          /* prevent divide error */
1979             }
1980             kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1981             Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1982                block->BlockNumber, dev->block_num,
1983                edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1984          }
1985          /* Every 32000 blocks (approx 2GB) write an EOF.
1986           */
1987          if ((block->BlockNumber % 32000) == 0) {
1988             now = time(NULL);
1989             (void)localtime_r(&now, &tm);
1990             strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1991             Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
1992             flush_block(block, 0);
1993             dev->weof(1);
1994          }
1995
1996          /* Get out after writing 10 blocks to the second tape */
1997          if (++BlockNumber > 10 && stop != 0) {      /* get out */
1998             break;
1999          }
2000       }
2001       if (!ok) {
2002          Pmsg0(000, _("Not OK\n"));
2003          break;
2004       }
2005       jcr->JobBytes += rec.data_len;   /* increment bytes this job */
2006       Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
2007          FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
2008          stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
2009
2010       /* Get out after writing 10 blocks to the second tape */
2011       if (BlockNumber > 10 && stop != 0) {      /* get out */
2012          char ed1[50];
2013          Pmsg1(-1, "Done writing %s records ...\n",
2014              edit_uint64_with_commas(write_count, ed1));
2015          break;
2016       }
2017    }
2018    if (vol_num > 1) {
2019       Dmsg0(100, "Write_end_session_label()\n");
2020       /* Create Job status for end of session label */
2021       if (!job_canceled(jcr) && ok) {
2022          set_jcr_job_status(jcr, JS_Terminated);
2023       } else if (!ok) {
2024          set_jcr_job_status(jcr, JS_ErrorTerminated);
2025       }
2026       if (!write_session_label(dcr, EOS_LABEL)) {
2027          Pmsg1(000, _("Error writting end session label. ERR=%s\n"), dev->bstrerror());
2028          ok = false;
2029       }
2030       /* Write out final block of this session */
2031       if (!write_block_to_device(dcr)) {
2032          Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
2033          ok = false;
2034       }
2035       Pmsg0(-1, _("Wrote End of Session label.\n"));
2036
2037       /* Save last block info for second tape */
2038       last_block_num2 = last_block_num;
2039       last_file2 = last_file;
2040       if (last_block2) {
2041          free_block(last_block2);
2042       }
2043       last_block2 = dup_block(last_block);
2044    }
2045
2046    sprintf(buf, "%s/btape.state", working_directory);
2047    fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
2048    if (fd >= 0) {
2049       write(fd, &btape_state_level, sizeof(btape_state_level));
2050       write(fd, &simple, sizeof(simple));
2051       write(fd, &last_block_num1, sizeof(last_block_num1));
2052       write(fd, &last_block_num2, sizeof(last_block_num2));
2053       write(fd, &last_file1, sizeof(last_file1));
2054       write(fd, &last_file2, sizeof(last_file2));
2055       write(fd, last_block1->buf, last_block1->buf_len);
2056       write(fd, last_block2->buf, last_block2->buf_len);
2057       write(fd, first_block->buf, first_block->buf_len);
2058       close(fd);
2059       Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2060          last_block_num1, last_block_num2);
2061    } else {
2062       berrno be;
2063       Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2064                  be.bstrerror());
2065    }
2066
2067    now = time(NULL);
2068    (void)localtime_r(&now, &tm);
2069    strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2070    if (simple) {
2071       Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2072          buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2073    }
2074    else {
2075       Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2076          buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2077    }
2078
2079    jcr->dcr->block = block;
2080    do_unfill();
2081
2082    dev->min_block_size = min_block_size;
2083    free_memory(rec.data);
2084 }
2085
2086 /*
2087  * Read two tapes written by the "fill" command and ensure
2088  *  that the data is valid.  If stop==1 we simulate full read back
2089  *  of two tapes.  If stop==-1 we simply read the last block and
2090  *  verify that it is correct.
2091  */
2092 static void unfillcmd()
2093 {
2094    int fd;
2095
2096    last_block1 = new_block(dev);
2097    last_block2 = new_block(dev);
2098    first_block = new_block(dev);
2099    sprintf(buf, "%s/btape.state", working_directory);
2100    fd = open(buf, O_RDONLY);
2101    if (fd >= 0) {
2102       uint32_t state_level;
2103       read(fd, &state_level, sizeof(btape_state_level));
2104       read(fd, &simple, sizeof(simple));
2105       read(fd, &last_block_num1, sizeof(last_block_num1));
2106       read(fd, &last_block_num2, sizeof(last_block_num2));
2107       read(fd, &last_file1, sizeof(last_file1));
2108       read(fd, &last_file2, sizeof(last_file2));
2109       read(fd, last_block1->buf, last_block1->buf_len);
2110       read(fd, last_block2->buf, last_block2->buf_len);
2111       read(fd, first_block->buf, first_block->buf_len);
2112       close(fd);
2113       if (state_level != btape_state_level) {
2114           Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2115                   "the fill command.\n"));
2116           return;
2117        }
2118    } else {
2119       berrno be;
2120       Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2121              "You must redo the fill command.\n"), buf, be.bstrerror());
2122       return;
2123    }
2124    do_unfill();
2125    this_block = NULL;
2126 }
2127
2128 static void do_unfill()
2129 {
2130    DEV_BLOCK *block = dcr->block;
2131    int autochanger;
2132
2133    dumped = 0;
2134    VolBytes = 0;
2135    LastBlock = 0;
2136
2137    Dmsg0(20, "Enter do_unfill\n");
2138    dev->set_cap(CAP_ANONVOLS);        /* allow reading any volume */
2139    dev->clear_cap(CAP_LABEL);         /* don't label anything here */
2140
2141    end_of_tape = 0;
2142
2143    time(&jcr->run_time);              /* start counting time for rates */
2144    stop = 0;
2145    file_index = 0;
2146    if (last_block) {
2147       free_block(last_block);
2148       last_block = NULL;
2149    }
2150    last_block_num = last_block_num1;
2151    last_file = last_file1;
2152    last_block = last_block1;
2153
2154    free_restore_volume_list(jcr);
2155    jcr->bsr = NULL;
2156    bstrncpy(dcr->VolumeName, "TestVolume1|TestVolume2", sizeof(dcr->VolumeName));
2157    create_restore_volume_list(jcr);
2158    if (jcr->VolList != NULL) {
2159       jcr->VolList->Slot = 1;
2160       if (jcr->VolList->next != NULL) {
2161          jcr->VolList->next->Slot = 2;
2162       }
2163    }
2164
2165    set_volume_name("TestVolume1", 1);
2166
2167    if (!simple) {
2168       /* Multiple Volume tape */
2169       /* Close device so user can use autochanger if desired */
2170       if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2171          dev->offline();
2172       }
2173       autochanger = autoload_device(dcr, 1, NULL);
2174       if (autochanger != 1) {
2175          dev->close();
2176          get_cmd(_("Mount first tape. Press enter when ready: "));
2177       }
2178    }
2179
2180    dev->close();
2181    dev->num_writers = 0;
2182    if (!acquire_device_for_read(dcr)) {
2183       Pmsg1(-1, "%s", dev->errmsg);
2184       goto bail_out;
2185    }
2186    /*
2187     * We now have the first tape mounted.
2188     * Note, re-reading last block may have caused us to
2189     *   loose track of where we are (block number unknown).
2190     */
2191    Pmsg0(-1, _("Rewinding.\n"));
2192    if (!dev->rewind(dcr)) {                /* get to a known place on tape */
2193       goto bail_out;
2194    }
2195    /* Read the first 10000 records */
2196    Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2197       dev->file, dev->block_num);
2198    quickie_count = 0;
2199    read_records(dcr, quickie_cb, my_mount_next_read_volume);
2200    Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2201          last_file, last_block_num);
2202    if (!dev->reposition(dcr, last_file, last_block_num)) {
2203       Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2204       goto bail_out;
2205    }
2206    Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2207    if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2208       Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2209       goto bail_out;
2210    }
2211    if (compare_blocks(last_block, block)) {
2212       if (simple) {
2213          Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2214       } else {
2215          Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2216       }
2217    }
2218    if (simple) {
2219       goto bail_out;
2220    }
2221
2222    /* restore info for last block on second Volume */
2223    last_block_num = last_block_num2;
2224    last_file = last_file2;
2225    last_block = last_block2;
2226
2227    /* Multiple Volume tape */
2228    /* Close device so user can use autochanger if desired */
2229    if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2230       dev->offline();
2231    }
2232
2233    set_volume_name("TestVolume2", 2);
2234
2235    autochanger = autoload_device(dcr, 1, NULL);
2236    if (autochanger != 1) {
2237       dev->close();
2238       get_cmd(_("Mount second tape. Press enter when ready: "));
2239    }
2240
2241    dev->clear_read();
2242    if (!acquire_device_for_read(dcr)) {
2243       Pmsg1(-1, "%s", dev->errmsg);
2244       goto bail_out;
2245    }
2246
2247    /* Space to "first" block which is last block not written
2248     * on the previous tape.
2249     */
2250    Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2251    if (!dev->reposition(dcr, 0, 1)) {
2252       Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2253       goto bail_out;
2254    }
2255    Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2256    if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2257       Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2258       goto bail_out;
2259    }
2260    if (compare_blocks(first_block, block)) {
2261       Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2262    }
2263
2264    /* Now find and compare the last block */
2265    Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2266          last_file, last_block_num);
2267    if (!dev->reposition(dcr, last_file, last_block_num)) {
2268       Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2269       goto bail_out;
2270    }
2271    Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2272    if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2273       Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2274       goto bail_out;
2275    }
2276    if (compare_blocks(last_block, block)) {
2277       Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2278    }
2279
2280 bail_out:
2281    free_block(last_block1);
2282    free_block(last_block2);
2283    free_block(first_block);
2284 }
2285
2286 /* Read 10000 records then stop */
2287 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2288 {
2289    DEVICE *dev = dcr->dev;
2290    quickie_count++;
2291    if (quickie_count == 10000) {
2292       Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2293    }
2294    return quickie_count < 10000;
2295 }
2296
2297 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2298 {
2299    char *p, *q;
2300    uint32_t CheckSum, block_len;
2301    ser_declare;
2302
2303    p = last_block->buf;
2304    q = block->buf;
2305    unser_begin(q, BLKHDR2_LENGTH);
2306    unser_uint32(CheckSum);
2307    unser_uint32(block_len);
2308    while (q < (block->buf+block_len)) {
2309       if (*p == *q) {
2310          p++;
2311          q++;
2312          continue;
2313       }
2314       Pmsg0(-1, "\n");
2315       dump_block(last_block, _("Last block written"));
2316       Pmsg0(-1, "\n");
2317       dump_block(block, _("Block read back"));
2318       Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2319       Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2320                 "that was read back differ. The test FAILED !!!!\n"
2321                 "This must be corrected before you use Bacula\n"
2322                 "to write multi-tape Volumes.!!!!\n"));
2323       return false;
2324    }
2325    if (verbose) {
2326       dump_block(last_block, _("Last block written"));
2327       dump_block(block, _("Block read back"));
2328    }
2329    return true;
2330 }
2331
2332
2333
2334
2335
2336 /*
2337  * Write current block to tape regardless of whether or
2338  *   not it is full. If the tape fills, attempt to
2339  *   acquire another tape.
2340  */
2341 static int flush_block(DEV_BLOCK *block, int dump)
2342 {
2343    char ec1[50];
2344    DEV_BLOCK *tblock;
2345    uint32_t this_file, this_block_num;
2346
2347    dev->r_dlock();
2348    if (!this_block) {
2349       this_block = new_block(dev);
2350    }
2351    if (!last_block) {
2352       last_block = new_block(dev);
2353    }
2354    /* Copy block */
2355    this_file = dev->file;
2356    this_block_num = dev->block_num;
2357    if (!write_block_to_dev(dcr)) {
2358       Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2359                   last_file, last_block_num, this_block_num);
2360       if (vol_num == 1) {
2361          /*
2362           * This is 1st tape, so save first tape info separate
2363           *  from second tape info
2364           */
2365          last_block_num1 = last_block_num;
2366          last_file1 = last_file;
2367          last_block1 = dup_block(last_block);
2368          last_block2 = dup_block(last_block);
2369          first_block = dup_block(block); /* first block second tape */
2370       }
2371       if (verbose) {
2372          Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2373             (unsigned)file_index, block->BlockNumber, block->block_len);
2374          dump_block(last_block, _("Last block written"));
2375          Pmsg0(-1, "\n");
2376          dump_block(block, _("Block not written"));
2377       }
2378       if (stop == 0) {
2379          eot_block = block->BlockNumber;
2380          eot_block_len = block->block_len;
2381          eot_FileIndex = file_index;
2382          stop = 1;
2383       }
2384       now = time(NULL);
2385       now -= jcr->run_time;
2386       if (now <= 0) {
2387          now = 1;                     /* don't divide by zero */
2388       }
2389       kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2390       vol_size = dev->VolCatInfo.VolCatBytes;
2391       Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2392          dev->file, dev->block_num,
2393          edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2394
2395       if (simple) {
2396          stop = -1;                   /* stop, but do simplified test */
2397       } else {
2398          /* Full test in progress */
2399          if (!fixup_device_block_write_error(jcr->dcr)) {
2400             Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2401             ok = false;
2402             dev->dunlock();
2403             return 0;
2404          }
2405          BlockNumber = 0;             /* start counting for second tape */
2406       }
2407       dev->dunlock();
2408       return 1;                       /* end of tape reached */
2409    }
2410
2411    /* Save contents after write so that the header is serialized */
2412    memcpy(this_block->buf, block->buf, this_block->buf_len);
2413
2414    /*
2415     * Note, we always read/write to block, but we toggle
2416     *  copying it to one or another of two allocated blocks.
2417     * Switch blocks so that the block just successfully written is
2418     *  always in last_block.
2419     */
2420    tblock = last_block;
2421    last_block = this_block;
2422    this_block = tblock;
2423    last_file = this_file;
2424    last_block_num = this_block_num;
2425
2426    dev->dunlock();
2427    return 1;
2428 }
2429
2430
2431 /*
2432  * First we label the tape, then we fill
2433  *  it with data get a new tape and write a few blocks.
2434  */
2435 static void qfillcmd()
2436 {
2437    DEV_BLOCK *block = dcr->block;
2438    DEV_RECORD *rec = dcr->rec;
2439    int i, count;
2440
2441    Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2442
2443    get_cmd(_("How many blocks do you want to write? (1000): "));
2444
2445    count = atoi(cmd);
2446    if (count <= 0) {
2447       count = 1000;
2448    }
2449
2450    sm_check(__FILE__, __LINE__, false);
2451
2452    i = block->buf_len - 100;
2453    ASSERT (i > 0);
2454    rec->data = check_pool_memory_size(rec->data, i);
2455    memset(rec->data, i & 0xFF, i);
2456    rec->data_len = i;
2457    rewindcmd();
2458    Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2459    for (i=0; i < count; i++) {
2460       if (i % 100 == 0) {
2461          printf("+");
2462          fflush(stdout);
2463       }
2464       if (!write_record_to_block(block, rec)) {
2465          Pmsg0(0, _("Error writing record to block.\n"));
2466          goto bail_out;
2467       }
2468       if (!write_block_to_dev(dcr)) {
2469          Pmsg0(0, _("Error writing block to device.\n"));
2470          goto bail_out;
2471       }
2472    }
2473    printf("\n");
2474    weofcmd();
2475    if (dev->has_cap(CAP_TWOEOF)) {
2476       weofcmd();
2477    }
2478    rewindcmd();
2479    scan_blocks();
2480
2481 bail_out:
2482    sm_check(__FILE__, __LINE__, false);
2483 }
2484
2485 /*
2486  * Fill a tape using raw write() command
2487  */
2488 static void rawfill_cmd()
2489 {
2490    DEV_BLOCK *block = dcr->block;
2491    int stat;
2492    int fd;
2493    uint32_t block_num = 0;
2494    uint32_t *p;
2495    int my_errno;
2496    uint32_t i;
2497
2498    fd = open("/dev/urandom", O_RDONLY);
2499    if (fd) {
2500       read(fd, block->buf, block->buf_len);
2501       close(fd);
2502    } else {
2503       uint32_t *p = (uint32_t *)block->buf;
2504       srandom(time(NULL));
2505       for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2506          p[i] = random();
2507       }
2508    }
2509    p = (uint32_t *)block->buf;
2510    Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2511    for ( ;; ) {
2512       *p = block_num;
2513       stat = dev->d_write(dev->fd(), block->buf, block->buf_len);
2514       if (stat == (int)block->buf_len) {
2515          if ((block_num++ % 100) == 0) {
2516             printf("+");
2517             fflush(stdout);
2518          }
2519          p[0] += p[13];
2520          for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2521             p[i] += p[i-1];
2522          }
2523          continue;
2524       }
2525       break;
2526    }
2527    my_errno = errno;
2528    printf("\n");
2529    berrno be;
2530    printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2531       be.bstrerror(my_errno));
2532    weofcmd();
2533 }
2534
2535
2536
2537 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2538 static struct cmdstruct commands[] = {
2539  {NT_("autochanger"),autochangercmd, _("test autochanger")},
2540  {NT_("bsf"),       bsfcmd,       _("backspace file")},
2541  {NT_("bsr"),       bsrcmd,       _("backspace record")},
2542  {NT_("cap"),       capcmd,       _("list device capabilities")},
2543  {NT_("clear"),     clearcmd,     _("clear tape errors")},
2544  {NT_("eod"),       eodcmd,       _("go to end of Bacula data for append")},
2545  {NT_("eom"),       eomcmd,       _("go to the physical end of medium")},
2546  {NT_("fill"),      fillcmd,      _("fill tape, write onto second volume")},
2547  {NT_("unfill"),    unfillcmd,    _("read filled tape")},
2548  {NT_("fsf"),       fsfcmd,       _("forward space a file")},
2549  {NT_("fsr"),       fsrcmd,       _("forward space a record")},
2550  {NT_("help"),      helpcmd,      _("print this command")},
2551  {NT_("label"),     labelcmd,     _("write a Bacula label to the tape")},
2552  {NT_("load"),      loadcmd,      _("load a tape")},
2553  {NT_("quit"),      quitcmd,      _("quit btape")},
2554  {NT_("rawfill"),   rawfill_cmd,  _("use write() to fill tape")},
2555  {NT_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2556  {NT_("rectest"),   rectestcmd,   _("test record handling functions")},
2557  {NT_("rewind"),    rewindcmd,    _("rewind the tape")},
2558  {NT_("scan"),      scancmd,      _("read() tape block by block to EOT and report")},
2559  {NT_("scanblocks"),scan_blocks,  _("Bacula read block by block to EOT and report")},
2560  {NT_("status"),    statcmd,      _("print tape status")},
2561  {NT_("test"),      testcmd,      _("General test Bacula tape functions")},
2562  {NT_("weof"),      weofcmd,      _("write an EOF on the tape")},
2563  {NT_("wr"),        wrcmd,        _("write a single Bacula block")},
2564  {NT_("rr"),        rrcmd,        _("read a single record")},
2565  {NT_("rb"),        rbcmd,        _("read a single Bacula block")},
2566  {NT_("qfill"),     qfillcmd,     _("quick fill command")}
2567              };
2568 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2569
2570 static void
2571 do_tape_cmds()
2572 {
2573    unsigned int i;
2574    bool found;
2575
2576    while (!quit && get_cmd("*")) {
2577       sm_check(__FILE__, __LINE__, false);
2578       found = false;
2579       parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2580       for (i=0; i<comsize; i++)       /* search for command */
2581          if (argc > 0 && fstrsch(argk[0],  commands[i].key)) {
2582             (*commands[i].func)();    /* go execute command */
2583             found = true;
2584             break;
2585          }
2586       if (*cmd && !found) {
2587          Pmsg1(0, _("\"%s\" is an invalid command\n"), cmd);
2588       }
2589    }
2590 }
2591
2592 static void helpcmd()
2593 {
2594    unsigned int i;
2595    usage();
2596    printf(_("Interactive commands:\n"));
2597    printf(_("  Command    Description\n  =======    ===========\n"));
2598    for (i=0; i<comsize; i++)
2599       printf("  %-10s %s\n", commands[i].key, commands[i].help);
2600    printf("\n");
2601 }
2602
2603 static void usage()
2604 {
2605    fprintf(stderr, _(
2606 PROG_COPYRIGHT
2607 "\nVersion: %s (%s)\n\n"
2608 "Usage: btape <options> <device_name>\n"
2609 "       -b <file>   specify bootstrap file\n"
2610 "       -c <file>   set configuration file to file\n"
2611 "       -d <nn>     set debug level to <nn>\n"
2612 "       -dt         print timestamp in debug output\n"
2613 "       -p          proceed inspite of I/O errors\n"
2614 "       -s          turn off signals\n"
2615 "       -v          be verbose\n"
2616 "       -?          print this message.\n"
2617 "\n"), 2000, VERSION, BDATE);
2618
2619 }
2620
2621 /*
2622  * Get next input command from terminal.  This
2623  * routine is REALLY primitive, and should be enhanced
2624  * to have correct backspacing, etc.
2625  */
2626 int
2627 get_cmd(const char *prompt)
2628 {
2629    int i = 0;
2630    int ch;
2631    fprintf(stdout, prompt);
2632
2633    /* We really should turn off echoing and pretty this
2634     * up a bit.
2635     */
2636    cmd[i] = 0;
2637    while ((ch = fgetc(stdin)) != EOF) {
2638       if (ch == '\n') {
2639          strip_trailing_junk(cmd);
2640          return 1;
2641       } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2642          if (i > 0)
2643             cmd[--i] = 0;
2644          continue;
2645       }
2646
2647       cmd[i++] = ch;
2648       cmd[i] = 0;
2649    }
2650    quit = 1;
2651    return 0;
2652 }
2653
2654 /* Dummies to replace askdir.c */
2655 bool    dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2656 bool    dir_send_job_status(JCR *jcr) {return 1;}
2657
2658 bool dir_update_volume_info(DCR *dcr, bool relabel, bool update_LastWritten)
2659 {
2660    return 1;
2661 }
2662
2663
2664 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw  writing)
2665 {
2666    Dmsg0(20, "Enter dir_get_volume_info\n");
2667    bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2668    return 1;
2669 }
2670
2671 bool dir_create_jobmedia_record(DCR *dcr)
2672 {
2673    dcr->WroteVol = false;
2674    return 1;
2675 }
2676
2677
2678 bool dir_find_next_appendable_volume(DCR *dcr)
2679 {
2680    Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2681    return dcr->VolumeName[0] != 0;
2682 }
2683
2684 bool dir_ask_sysop_to_mount_volume(DCR *dcr, int /* mode */)
2685 {
2686    DEVICE *dev = dcr->dev;
2687    Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2688    if (dcr->VolumeName[0] == 0) {
2689       return dir_ask_sysop_to_create_appendable_volume(dcr);
2690    }
2691    Pmsg1(-1, "%s", dev->errmsg);           /* print reason */
2692    if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2693       fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2694          dev->print_name());
2695    } else {
2696       fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2697          dcr->VolumeName, dev->print_name());
2698    }
2699    dev->close();
2700    getchar();
2701    return true;
2702 }
2703
2704 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2705 {
2706    int autochanger;
2707    DEVICE *dev = dcr->dev;
2708    Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2709    if (stop == 0) {
2710       set_volume_name("TestVolume1", 1);
2711    } else {
2712       set_volume_name("TestVolume2", 2);
2713    }
2714    /* Close device so user can use autochanger if desired */
2715    if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2716       dev->offline();
2717    }
2718    autochanger = autoload_device(dcr, 1, NULL);
2719    if (autochanger != 1) {
2720       fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2721          dev->print_name());
2722       dev->close();
2723       getchar();
2724    }
2725    labelcmd();
2726    VolumeName = NULL;
2727    BlockNumber = 0;
2728    return true;
2729 }
2730
2731 static bool my_mount_next_read_volume(DCR *dcr)
2732 {
2733    char ec1[50];
2734    JCR *jcr = dcr->jcr;
2735    DEV_BLOCK *block = dcr->block;
2736
2737    Dmsg0(20, "Enter my_mount_next_read_volume\n");
2738    Pmsg2(000, _("End of Volume \"%s\" %d records.\n"), dcr->VolumeName,
2739       quickie_count);
2740
2741    volume_unused(dcr);             /* release current volume */
2742    if (LastBlock != block->BlockNumber) {
2743       VolBytes += block->block_len;
2744    }
2745    LastBlock = block->BlockNumber;
2746    now = time(NULL);
2747    now -= jcr->run_time;
2748    if (now <= 0) {
2749       now = 1;
2750    }
2751    kbs = (double)VolBytes / (1000.0 * (double)now);
2752    Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2753             edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2754
2755    if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2756       end_of_tape = 1;
2757       return false;
2758    }
2759
2760    set_volume_name("TestVolume2", 2);
2761
2762    dev->close();
2763    if (!acquire_device_for_read(dcr)) {
2764       Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2765       return false;
2766    }
2767    return true;                    /* next volume mounted */
2768 }
2769
2770 static void set_volume_name(const char *VolName, int volnum)
2771 {
2772    DCR *dcr = jcr->dcr;
2773    VolumeName = VolName;
2774    vol_num = volnum;
2775    bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2776    bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2777    bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2778    dcr->VolCatInfo.Slot = volnum;
2779    dcr->VolCatInfo.InChanger = true;
2780 }