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

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