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

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