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

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