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