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

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