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

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