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

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