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

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