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