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

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