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

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