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

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