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

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