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

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