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