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