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

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