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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2011 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    DEVICE *dev = dcr->dev;
1116
1117    /*
1118     * Set big max_file_size so that write_record_to_block
1119     * doesn't insert any additional EOF marks
1120     */
1121    dev->max_file_size = 2 * num_recs * dev->max_block_size;
1122    Pmsg2(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
1123       "I'm going to write %d records and an EOF\n"
1124       "then write %d records and an EOF, then rewind,\n"
1125       "and re-read the data to verify that it is correct.\n\n"
1126       "This is an *essential* feature ...\n\n"), num_recs, num_recs);
1127
1128    block = dcr->block;
1129    empty_block(block);
1130    rec = new_record();
1131    rec->data = check_pool_memory_size(rec->data, block->buf_len);
1132    rec->data_len = block->buf_len-100;
1133    len = rec->data_len/sizeof(i);
1134
1135    if (!dev->rewind(dcr)) {
1136       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1137       goto bail_out;
1138    }
1139
1140    for (i=1; i<=num_recs; i++) {
1141       p = (int *)rec->data;
1142       for (j=0; j<len; j++) {
1143          *p++ = i;
1144       }
1145       if (!write_record_to_block(block, rec)) {
1146          Pmsg0(0, _("Error writing record to block.\n"));
1147          goto bail_out;
1148       }
1149       if (!write_block_to_dev(dcr)) {
1150          Pmsg0(0, _("Error writing block to device.\n"));
1151          goto bail_out;
1152       }
1153    }
1154    Pmsg2(0, _("Wrote %d blocks of %d bytes.\n"), num_recs, rec->data_len);
1155    weofcmd();
1156    for (i=num_recs+1; i<=2*num_recs; i++) {
1157       p = (int *)rec->data;
1158       for (j=0; j<len; j++) {
1159          *p++ = i;
1160       }
1161       if (!write_record_to_block(block, rec)) {
1162          Pmsg0(0, _("Error writing record to block.\n"));
1163          goto bail_out;
1164       }
1165       if (!write_block_to_dev(dcr)) {
1166          Pmsg0(0, _("Error writing block to device.\n"));
1167          goto bail_out;
1168       }
1169    }
1170    Pmsg2(0, _("Wrote %d blocks of %d bytes.\n"), num_recs, rec->data_len);
1171    weofcmd();
1172    if (dev->has_cap(CAP_TWOEOF)) {
1173       weofcmd();
1174    }
1175    rc = true;
1176
1177 bail_out:
1178    free_record(rec);
1179    if (!rc) {
1180       exit_code = 1;
1181    }
1182    return rc;
1183
1184 }
1185
1186 /*
1187  * This test writes Bacula blocks to the tape in
1188  *   several files. It then rewinds the tape and attepts
1189  *   to read these blocks back checking the data.
1190  */
1191 static bool write_read_test()
1192 {
1193    DEV_BLOCK *block;
1194    DEV_RECORD *rec;
1195    bool rc = false;
1196    int len, i, j;
1197    int *p;
1198
1199    rec = new_record();
1200
1201    if (!write_two_files()) {
1202       goto bail_out;
1203    }
1204
1205    block = dcr->block;
1206    empty_block(block);
1207
1208    if (!dev->rewind(dcr)) {
1209       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1210       goto bail_out;
1211    } else {
1212       Pmsg0(0, _("Rewind OK.\n"));
1213    }
1214
1215    rec->data = check_pool_memory_size(rec->data, block->buf_len);
1216    rec->data_len = block->buf_len-100;
1217    len = rec->data_len/sizeof(i);
1218
1219    /* Now read it back */
1220    for (i=1; i<=2*num_recs; i++) {
1221 read_again:
1222       if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1223          berrno be;
1224          if (dev_state(dev, ST_EOF)) {
1225             Pmsg0(-1, _("Got EOF on tape.\n"));
1226             if (i == num_recs+1) {
1227                goto read_again;
1228             }
1229          }
1230          Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.bstrerror(dev->dev_errno));
1231          goto bail_out;
1232       }
1233       memset(rec->data, 0, rec->data_len);
1234       if (!read_record_from_block(dcr, block, rec)) {
1235          berrno be;
1236          Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.bstrerror(dev->dev_errno));
1237          goto bail_out;
1238       }
1239       p = (int *)rec->data;
1240       for (j=0; j<len; j++) {
1241          if (*p != i) {
1242             Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1243                i, *p, j);
1244             goto bail_out;
1245          }
1246          p++;
1247       }
1248       if (i == num_recs || i == 2*num_recs) {
1249          Pmsg1(-1, _("%d blocks re-read correctly.\n"), num_recs);
1250       }
1251    }
1252    Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1253    rc = true;
1254
1255 bail_out:
1256    free_record(rec);
1257    if (!rc) {
1258       exit_code = 1;
1259    }
1260    return rc;
1261 }
1262
1263 /*
1264  * This test writes Bacula blocks to the tape in
1265  *   several files. It then rewinds the tape and attepts
1266  *   to read these blocks back checking the data.
1267  */
1268 static bool position_test()
1269 {
1270    DEV_BLOCK *block = dcr->block;
1271    DEV_RECORD *rec;
1272    bool rc = false;
1273    int len, j;
1274    bool more = true;
1275    int recno = 0;
1276    int file = 0, blk = 0;
1277    int *p;
1278    bool got_eof = false;
1279
1280    Pmsg0(0, _("Block position test\n"));
1281    block = dcr->block;
1282    empty_block(block);
1283    rec = new_record();
1284    rec->data = check_pool_memory_size(rec->data, block->buf_len);
1285    rec->data_len = block->buf_len-100;
1286    len = rec->data_len/sizeof(j);
1287
1288    if (!dev->rewind(dcr)) {
1289       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1290       goto bail_out;
1291    } else {
1292       Pmsg0(0, _("Rewind OK.\n"));
1293    }
1294
1295    while (more) {
1296       /* Set up next item to read based on where we are */
1297       /* At each step, recno is what we print for the "block number"
1298        *  and file, blk are the real positions to go to.
1299        */
1300       switch (recno) {
1301       case 0:
1302          recno = 5;
1303          file = 0;
1304          blk = 4;
1305          break;
1306       case 5:
1307          recno = 201;
1308          file = 0;
1309          blk = 200;
1310          break;
1311       case 201:
1312          recno = num_recs;
1313          file = 0;
1314          blk = num_recs-1;
1315          break;
1316       case num_recs:
1317          recno = num_recs+1;
1318          file = 1;
1319          blk = 0;
1320          break;
1321       case num_recs+1:
1322          recno = num_recs+601;
1323          file = 1;
1324          blk = 600;
1325          break;
1326       case num_recs+601:
1327          recno = 2*num_recs;
1328          file = 1;
1329          blk = num_recs-1;
1330          break;
1331       case 2*num_recs:
1332          more = false;
1333          continue;
1334       }
1335       Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
1336       if (!dev->reposition(dcr, file, blk)) {
1337          Pmsg0(0, _("Reposition error.\n"));
1338          goto bail_out;
1339       }
1340 read_again:
1341       if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1342          berrno be;
1343          if (dev_state(dev, ST_EOF)) {
1344             Pmsg0(-1, _("Got EOF on tape.\n"));
1345             if (!got_eof) {
1346                got_eof = true;
1347                goto read_again;
1348             }
1349          }
1350          Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
1351             recno, file, blk, be.bstrerror(dev->dev_errno));
1352          Pmsg0(0, _("This may be because the tape drive block size is not\n"
1353                     " set to variable blocking as normally used by Bacula.\n"
1354                     " Please see the Tape Testing chapter in the manual and \n"
1355                     " look for using mt with defblksize and setoptions\n"
1356                     "If your tape drive block size is correct, then perhaps\n"
1357                     " your SCSI driver is *really* stupid and does not\n"
1358                     " correctly report the file:block after a FSF. In this\n"
1359                     " case try setting:\n"
1360                     "    Fast Forward Space File = no\n"
1361                     " in your Device resource.\n"));
1362
1363          goto bail_out;
1364       }
1365       memset(rec->data, 0, rec->data_len);
1366       if (!read_record_from_block(dcr, block, rec)) {
1367          berrno be;
1368          Pmsg1(0, _("Read record failed! ERR=%s\n"), be.bstrerror(dev->dev_errno));
1369          goto bail_out;
1370       }
1371       p = (int *)rec->data;
1372       for (j=0; j<len; j++) {
1373          if (p[j] != recno) {
1374             Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1375                recno, p[j], j);
1376             goto bail_out;
1377          }
1378       }
1379       Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1380    }
1381    Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1382    rc = true;
1383
1384 bail_out:
1385    free_record(rec);
1386    return rc;
1387 }
1388
1389
1390
1391
1392 /*
1393  * This test writes some records, then writes an end of file,
1394  *   rewinds the tape, moves to the end of the data and attepts
1395  *   to append to the tape.  This function is essential for
1396  *   Bacula to be able to write multiple jobs to the tape.
1397  */
1398 static int append_test()
1399 {
1400    Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1401                "This test is essential to Bacula.\n\n"
1402 "I'm going to write one record  in file 0,\n"
1403 "                   two records in file 1,\n"
1404 "             and three records in file 2\n\n"));
1405    argc = 1;
1406    rewindcmd();
1407    wrcmd();
1408    weofcmd();      /* end file 0 */
1409    wrcmd();
1410    wrcmd();
1411    weofcmd();      /* end file 1 */
1412    wrcmd();
1413    wrcmd();
1414    wrcmd();
1415    weofcmd();     /* end file 2 */
1416    if (dev->has_cap(CAP_TWOEOF)) {
1417       weofcmd();
1418    }
1419    dev->close();              /* release device */
1420    if (!open_the_device()) {
1421       return -1;
1422    }
1423    rewindcmd();
1424    Pmsg0(0, _("Now moving to end of medium.\n"));
1425    eodcmd();
1426    Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1427       dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1428
1429    if (dev->file != 3) {
1430       return -1;
1431    }
1432
1433    Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1434    wrcmd();
1435    weofcmd();
1436    if (dev->has_cap(CAP_TWOEOF)) {
1437       weofcmd();
1438    }
1439    rewindcmd();
1440    Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1441    Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1442    scan_blocks();
1443    Pmsg0(-1, _("End scanning the tape.\n"));
1444    Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1445       dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1446
1447    if (dev->file != 4) {
1448       return -2;
1449    }
1450    return 1;
1451 }
1452
1453
1454 /*
1455  * This test exercises the autochanger
1456  */
1457 static int autochanger_test()
1458 {
1459    POOLMEM *results, *changer;
1460    int slot, status, loaded;
1461    int timeout = dcr->device->max_changer_wait;
1462    int sleep_time = 0;
1463
1464    Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1465    if (!dev->has_cap(CAP_AUTOCHANGER)) {
1466       return 1;
1467    }
1468    if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1469       Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1470       return 1;
1471    }
1472
1473    Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1474              "To test the autochanger you must have a blank tape\n"
1475              " that I can write on in Slot 1.\n"));
1476    if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1477       return 0;
1478    }
1479    if (cmd[0] != 'y' && cmd[0] != 'Y') {
1480       return 0;
1481    }
1482
1483    Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1484
1485    results = get_pool_memory(PM_MESSAGE);
1486    changer = get_pool_memory(PM_FNAME);
1487
1488 try_again:
1489    slot = 1;
1490    dcr->VolCatInfo.Slot = slot;
1491    /* Find out what is loaded, zero means device is unloaded */
1492    Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1493    changer = edit_device_codes(dcr, changer,
1494                 dcr->device->changer_command, "loaded");
1495    status = run_program(changer, timeout, results);
1496    Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1497    if (status == 0) {
1498       loaded = atoi(results);
1499    } else {
1500       berrno be;
1501       Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1502       Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1503       goto bail_out;
1504    }
1505    if (loaded) {
1506       Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1507    } else {
1508       Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1509    }
1510    Dmsg1(100, "Results from loaded query=%s\n", results);
1511    if (loaded) {
1512       dcr->VolCatInfo.Slot = loaded;
1513       /* We are going to load a new tape, so close the device */
1514       dev->close();
1515       Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1516          loaded, dev->drive_index);
1517       changer = edit_device_codes(dcr, changer,
1518                    dcr->device->changer_command, "unload");
1519       status = run_program(changer, timeout, results);
1520       Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1521       if (status != 0) {
1522          berrno be;
1523          Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1524          Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1525       }
1526    }
1527
1528    /*
1529     * Load the Slot 1
1530     */
1531
1532    slot = 1;
1533    dcr->VolCatInfo.Slot = slot;
1534    Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1535       slot, dev->drive_index);
1536    changer = edit_device_codes(dcr, changer,
1537                 dcr->device->changer_command, "load");
1538    Dmsg1(100, "Changer=%s\n", changer);
1539    dev->close();
1540    status = run_program(changer, timeout, results);
1541    if (status == 0) {
1542       Pmsg2(-1,  _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1543          slot, dev->drive_index);
1544    } else {
1545       berrno be;
1546       Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1547       Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.bstrerror(status));
1548       goto bail_out;
1549    }
1550
1551    if (!open_the_device()) {
1552       goto bail_out;
1553    }
1554    /*
1555     * Start with sleep_time 0 then increment by 30 seconds if we get
1556     * a failure.
1557     */
1558    bmicrosleep(sleep_time, 0);
1559    if (!dev->rewind(dcr) || !dev->weof(1)) {
1560       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1561       dev->clrerror(-1);
1562       Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1563                 "a longer sleep time in the mtx-script in the load) case.\n"
1564                 "Adding a 30 second sleep and trying again ...\n"));
1565       sleep_time += 30;
1566       goto try_again;
1567    } else {
1568       Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1569    }
1570
1571    if (!dev->weof(1)) {
1572       Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
1573       goto bail_out;
1574    } else {
1575       Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1576    }
1577
1578    if (sleep_time) {
1579       Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1580                 "   sleep %d\n\n"
1581                 "to your mtx-changer script in the load) case.\n\n"),
1582                 sleep_time);
1583    } else {
1584       Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1585    }
1586
1587    free_pool_memory(changer);
1588    free_pool_memory(results);
1589    return 1;
1590
1591
1592 bail_out:
1593    free_pool_memory(changer);
1594    free_pool_memory(results);
1595    Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1596    return -2;
1597 }
1598
1599 static void autochangercmd()
1600 {
1601    autochanger_test();
1602 }
1603
1604
1605 /*
1606  * This test assumes that the append test has been done,
1607  *   then it tests the fsf function.
1608  */
1609 static bool fsf_test()
1610 {
1611    bool set_off = false;
1612
1613    Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1614                "This test is essential to Bacula.\n\n"
1615                "I'm going to write five files then test forward spacing\n\n"));
1616    argc = 1;
1617    rewindcmd();
1618    wrcmd();
1619    weofcmd();      /* end file 0 */
1620    wrcmd();
1621    wrcmd();
1622    weofcmd();      /* end file 1 */
1623    wrcmd();
1624    wrcmd();
1625    wrcmd();
1626    weofcmd();     /* end file 2 */
1627    wrcmd();
1628    wrcmd();
1629    weofcmd();     /* end file 3 */
1630    wrcmd();
1631    weofcmd();     /* end file 4 */
1632    if (dev->has_cap(CAP_TWOEOF)) {
1633       weofcmd();
1634    }
1635
1636 test_again:
1637    rewindcmd();
1638    Pmsg0(0, _("Now forward spacing 1 file.\n"));
1639    if (!dev->fsf(1)) {
1640       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1641       goto bail_out;
1642    }
1643    Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1644       dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1645
1646    if (dev->file != 1) {
1647       goto bail_out;
1648    }
1649
1650    Pmsg0(0, _("Now forward spacing 2 files.\n"));
1651    if (!dev->fsf(2)) {
1652       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1653       goto bail_out;
1654    }
1655    Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1656       dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1657
1658    if (dev->file != 3) {
1659       goto bail_out;
1660    }
1661
1662    rewindcmd();
1663    Pmsg0(0, _("Now forward spacing 4 files.\n"));
1664    if (!dev->fsf(4)) {
1665       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1666       goto bail_out;
1667    }
1668    Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1669       dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1670
1671    if (dev->file != 4) {
1672       goto bail_out;
1673    }
1674    if (set_off) {
1675       Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1676                 "   Fast Forward Space File = no\n\n"
1677                 "to your Device resource for this drive.\n"));
1678    }
1679
1680    Pmsg0(-1, "\n");
1681    Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1682    if (!dev->fsf(1)) {
1683       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1684    }
1685    Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1686       dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1687    if (dev->file != 5) {
1688       goto bail_out;
1689    }
1690    Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1691    return true;
1692
1693 bail_out:
1694    Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1695    if (dev->has_cap(CAP_FASTFSF)) {
1696       Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1697               "I am turning it off then retrying the test.\n"));
1698       dev->clear_cap(CAP_FASTFSF);
1699       set_off = true;
1700       goto test_again;
1701    }
1702    Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1703             "Some systems, e.g. OpenBSD, require you to set\n"
1704             "   Use MTIOCGET= no\n"
1705             "in your device resource. Use with caution.\n"));
1706    return false;
1707 }
1708
1709
1710
1711
1712
1713 /*
1714  * This is a general test of Bacula's functions
1715  *   needed to read and write the tape.
1716  */
1717 static void testcmd()
1718 {
1719    int stat;
1720
1721    if (!write_read_test()) {
1722       exit_code = 1;
1723       return;
1724    }
1725    if (!position_test()) {
1726       exit_code = 1;
1727       return;
1728    }
1729
1730    stat = append_test();
1731    if (stat == 1) {                   /* OK get out */
1732       goto all_done;
1733    }
1734    if (stat == -1) {                  /* first test failed */
1735       if (dev->has_cap(CAP_EOM) || dev->has_cap(CAP_FASTFSF)) {
1736          Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1737                    "Setting \"Hardware End of Medium = no\n"
1738                    "    and \"Fast Forward Space File = no\n"
1739                    "and retrying append test.\n\n"));
1740          dev->clear_cap(CAP_EOM);      /* turn off eom */
1741          dev->clear_cap(CAP_FASTFSF);  /* turn off fast fsf */
1742          stat = append_test();
1743          if (stat == 1) {
1744             Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1745                      "    Hardware End of Medium = No\n\n"
1746                      "    Fast Forward Space File = No\n"
1747                      "to your Device resource in the Storage conf file.\n"));
1748             goto all_done;
1749          }
1750          if (stat == -1) {
1751             Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1752             goto failed;
1753          }
1754          /* Wrong count after append */
1755          if (stat == -2) {
1756             Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1757                      "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1758             dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1759             stat = append_test();
1760             if (stat == 1) {
1761                Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1762                      "    Hardware End of Medium = No\n"
1763                      "    Fast Forward Space File = No\n"
1764                      "    BSF at EOM = yes\n\n"
1765                      "to your Device resource in the Storage conf file.\n"));
1766                goto all_done;
1767             }
1768          }
1769
1770       }
1771 failed:
1772       Pmsg0(-1, _("\nAppend test failed.\n\n"
1773             "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1774             "Unable to correct the problem. You MUST fix this\n"
1775              "problem before Bacula can use your tape drive correctly\n"
1776             "\nPerhaps running Bacula in fixed block mode will work.\n"
1777             "Do so by setting:\n\n"
1778             "Minimum Block Size = nnn\n"
1779             "Maximum Block Size = nnn\n\n"
1780             "in your Storage daemon's Device definition.\n"
1781             "nnn must match your tape driver's block size, which\n"
1782             "can be determined by reading your tape manufacturers\n"
1783             "information, and the information on your kernel dirver.\n"
1784             "Fixed block sizes, however, are not normally an ideal solution.\n"
1785             "\n"
1786             "Some systems, e.g. OpenBSD, require you to set\n"
1787             "   Use MTIOCGET= no\n"
1788             "in your device resource. Use with caution.\n"));
1789        exit_code = 1;
1790        return;
1791    }
1792
1793 all_done:
1794    Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1795         "Please double check it ...\n"
1796         "=== Sample correct output ===\n"
1797         "1 block of 64448 bytes in file 1\n"
1798         "End of File mark.\n"
1799         "2 blocks of 64448 bytes in file 2\n"
1800         "End of File mark.\n"
1801         "3 blocks of 64448 bytes in file 3\n"
1802         "End of File mark.\n"
1803         "1 block of 64448 bytes in file 4\n"
1804         "End of File mark.\n"
1805         "Total files=4, blocks=7, bytes = 451,136\n"
1806         "=== End sample correct output ===\n\n"
1807         "If the above scan output is not identical to the\n"
1808         "sample output, you MUST correct the problem\n"
1809         "or Bacula will not be able to write multiple Jobs to \n"
1810         "the tape.\n\n"));
1811
1812    if (stat == 1) {
1813       if (!re_read_block_test()) {
1814          exit_code = 1;
1815       }
1816    }
1817
1818    if (!fsf_test()) {                  /* do fast forward space file test */
1819       exit_code = 1;
1820    }
1821
1822    autochanger_test();                /* do autochanger test */
1823
1824 }
1825
1826 /* Forward space a file */
1827 static void fsfcmd()
1828 {
1829    int num = 1;
1830    if (argc > 1) {
1831       num = atoi(argk[1]);
1832    }
1833    if (num <= 0) {
1834       num = 1;
1835    }
1836    if (!dev->fsf(num)) {
1837       Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), dev->bstrerror());
1838       return;
1839    }
1840    if (num == 1) {
1841       Pmsg0(0, _("Forward spaced 1 file.\n"));
1842    }
1843    else {
1844       Pmsg1(0, _("Forward spaced %d files.\n"), num);
1845    }
1846 }
1847
1848 /* Forward space a record */
1849 static void fsrcmd()
1850 {
1851    int num = 1;
1852    if (argc > 1) {
1853       num = atoi(argk[1]);
1854    }
1855    if (num <= 0) {
1856       num = 1;
1857    }
1858    if (!dev->fsr(num)) {
1859       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1860       return;
1861    }
1862    if (num == 1) {
1863       Pmsg0(0, _("Forward spaced 1 record.\n"));
1864    }
1865    else {
1866       Pmsg1(0, _("Forward spaced %d records.\n"), num);
1867    }
1868 }
1869
1870 /*
1871  * Read a Bacula block from the tape
1872  */
1873 static void rbcmd()
1874 {
1875    dev->open(dcr, OPEN_READ_ONLY);
1876    read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK);
1877 }
1878
1879 /*
1880  * Write a Bacula block to the tape
1881  */
1882 static void wrcmd()
1883 {
1884    DEV_BLOCK *block = dcr->block;
1885    DEV_RECORD *rec = dcr->rec;
1886    int i;
1887
1888    if (!dev->is_open()) {
1889       open_the_device();
1890    }
1891    sm_check(__FILE__, __LINE__, false);
1892    empty_block(block);
1893    if (verbose > 1) {
1894       dump_block(block, "test");
1895    }
1896
1897    i = block->buf_len - 100;
1898    ASSERT (i > 0);
1899    rec->data = check_pool_memory_size(rec->data, i);
1900    memset(rec->data, i & 0xFF, i);
1901    rec->data_len = i;
1902    sm_check(__FILE__, __LINE__, false);
1903    if (!write_record_to_block(block, rec)) {
1904       Pmsg0(0, _("Error writing record to block.\n"));
1905       goto bail_out;
1906    }
1907    if (!write_block_to_dev(dcr)) {
1908       Pmsg0(0, _("Error writing block to device.\n"));
1909       goto bail_out;
1910    } else {
1911       Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1912    }
1913    Pmsg0(0, _("Wrote block to device.\n"));
1914
1915 bail_out:
1916    sm_check(__FILE__, __LINE__, false);
1917    sm_check(__FILE__, __LINE__, false);
1918 }
1919
1920 /*
1921  * Read a record from the tape
1922  */
1923 static void rrcmd()
1924 {
1925    char *buf;
1926    int stat, len;
1927
1928    if (!get_cmd(_("Enter length to read: "))) {
1929       return;
1930    }
1931    len = atoi(cmd);
1932    if (len < 0 || len > 1000000) {
1933       Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1934       len = 1024;
1935    }
1936    buf = (char *)malloc(len);
1937    stat = read(dev->fd(), buf, len);
1938    if (stat > 0 && stat <= len) {
1939       errno = 0;
1940    }
1941    berrno be;
1942    Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1943       len, stat, be.bstrerror());
1944    free(buf);
1945 }
1946
1947
1948 /*
1949  * Scan tape by reading block by block. Report what is
1950  * on the tape.  Note, this command does raw reads, and as such
1951  * will not work with fixed block size devices.
1952  */
1953 static void scancmd()
1954 {
1955    int stat;
1956    int blocks, tot_blocks, tot_files;
1957    int block_size;
1958    uint64_t bytes;
1959    char ec1[50];
1960
1961
1962    blocks = block_size = tot_blocks = 0;
1963    bytes = 0;
1964    if (dev->state & ST_EOT) {
1965       Pmsg0(0, _("End of tape\n"));
1966       return;
1967    }
1968    dev->update_pos(dcr);
1969    tot_files = dev->file;
1970    Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1971    for (;;) {
1972       if ((stat = read(dev->fd(), buf, sizeof(buf))) < 0) {
1973          berrno be;
1974          dev->clrerror(-1);
1975          Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1976             dev->dev_name, be.bstrerror());
1977          Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
1978          if (blocks > 0) {
1979             if (blocks==1) {
1980                printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1981             }
1982             else {
1983                printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1984             }
1985          }
1986          return;
1987       }
1988       Dmsg1(200, "read status = %d\n", stat);
1989 /*    sleep(1); */
1990       if (stat != block_size) {
1991          dev->update_pos(dcr);
1992          if (blocks > 0) {
1993             if (blocks==1) {
1994                printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1995             }
1996             else {
1997                printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1998             }
1999             blocks = 0;
2000          }
2001          block_size = stat;
2002       }
2003       if (stat == 0) {                /* EOF */
2004          dev->update_pos(dcr);
2005          printf(_("End of File mark.\n"));
2006          /* Two reads of zero means end of tape */
2007          if (dev->state & ST_EOF)
2008             dev->state |= ST_EOT;
2009          else {
2010             dev->state |= ST_EOF;
2011             dev->file++;
2012          }
2013          if (dev->state & ST_EOT) {
2014             printf(_("End of tape\n"));
2015             break;
2016          }
2017       } else {                        /* Got data */
2018          dev->state &= ~ST_EOF;
2019          blocks++;
2020          tot_blocks++;
2021          bytes += stat;
2022       }
2023    }
2024    dev->update_pos(dcr);
2025    tot_files = dev->file - tot_files;
2026    printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
2027       edit_uint64_with_commas(bytes, ec1));
2028 }
2029
2030
2031 /*
2032  * Scan tape by reading Bacula block by block. Report what is
2033  * on the tape.  This function reads Bacula blocks, so if your
2034  * Device resource is correctly defined, it should work with
2035  * either variable or fixed block sizes.
2036  */
2037 static void scan_blocks()
2038 {
2039    int blocks, tot_blocks, tot_files;
2040    uint32_t block_size;
2041    uint64_t bytes;
2042    DEV_BLOCK *block = dcr->block;
2043    char ec1[50];
2044    char buf1[100], buf2[100];
2045
2046    blocks = block_size = tot_blocks = 0;
2047    bytes = 0;
2048
2049    empty_block(block);
2050    dev->update_pos(dcr);
2051    tot_files = dev->file;
2052    for (;;) {
2053       if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2054          Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
2055          if (dev->state & ST_EOT) {
2056             if (blocks > 0) {
2057                if (blocks==1) {
2058                   printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
2059                }
2060                else {
2061                   printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
2062                }
2063                blocks = 0;
2064             }
2065             goto bail_out;
2066          }
2067          if (dev->state & ST_EOF) {
2068             if (blocks > 0) {
2069                if (blocks==1) {
2070                   printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
2071                }
2072                else {
2073                   printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
2074                }
2075                blocks = 0;
2076             }
2077             printf(_("End of File mark.\n"));
2078             continue;
2079          }
2080          if (dev->state & ST_SHORT) {
2081             if (blocks > 0) {
2082                if (blocks==1) {
2083                   printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
2084                }
2085                else {
2086                   printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
2087                }
2088                blocks = 0;
2089             }
2090             printf(_("Short block read.\n"));
2091             continue;
2092          }
2093          printf(_("Error reading block. ERR=%s\n"), dev->bstrerror());
2094          goto bail_out;
2095       }
2096       if (block->block_len != block_size) {
2097          if (blocks > 0) {
2098             if (blocks==1) {
2099                printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
2100             }
2101             else {
2102                printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
2103             }
2104             blocks = 0;
2105          }
2106          block_size = block->block_len;
2107       }
2108       blocks++;
2109       tot_blocks++;
2110       bytes += block->block_len;
2111       Dmsg7(100, "Blk_blk=%u file,blk=%u,%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
2112          block->BlockNumber, dev->file, dev->block_num, block->block_len, block->BlockVer,
2113          block->VolSessionId, block->VolSessionTime);
2114       if (verbose == 1) {
2115          DEV_RECORD *rec = new_record();
2116          read_record_from_block(dcr, block, rec);
2117          Pmsg9(-1, _("Block=%u file,blk=%u,%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
2118               block->BlockNumber, dev->file, dev->block_num, block->block_len,
2119               FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
2120               stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
2121          rec->remainder = 0;
2122          free_record(rec);
2123       } else if (verbose > 1) {
2124          dump_block(block, "");
2125       }
2126
2127    }
2128 bail_out:
2129    tot_files = dev->file - tot_files;
2130    printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
2131       edit_uint64_with_commas(bytes, ec1));
2132 }
2133
2134
2135 static void statcmd()
2136 {
2137    int debug = debug_level;
2138    debug_level = 30;
2139    Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), dev->bstrerror());
2140 #ifdef xxxx
2141    dump_volume_label(dev);
2142 #endif
2143    debug_level = debug;
2144 }
2145
2146
2147 /*
2148  * First we label the tape, then we fill
2149  *  it with data get a new tape and write a few blocks.
2150  */
2151 static void fillcmd()
2152 {
2153    DEV_RECORD rec;
2154    DEV_BLOCK  *block = dcr->block;
2155    char ec1[50], ec2[50];
2156    char buf1[100], buf2[100];
2157    uint64_t write_eof;
2158    uint64_t rate;
2159    uint32_t min_block_size;
2160    int fd;
2161    struct tm tm;
2162
2163    ok = true;
2164    stop = 0;
2165    vol_num = 0;
2166    last_file = 0;
2167    last_block_num = 0;
2168    BlockNumber = 0;
2169    exit_code = 0;
2170
2171    Pmsg1(-1, _("\n"
2172 "This command simulates Bacula writing to a tape.\n"
2173 "It requires either one or two blank tapes, which it\n"
2174 "will label and write.\n\n"
2175 "If you have an autochanger configured, it will use\n"
2176 "the tapes that are in slots 1 and 2, otherwise, you will\n"
2177 "be prompted to insert the tapes when necessary.\n\n"
2178 "It will print a status approximately\n"
2179 "every 322 MB, and write an EOF every %s.  If you have\n"
2180 "selected the simple test option, after writing the first tape\n"
2181 "it will rewind it and re-read the last block written.\n\n"
2182 "If you have selected the multiple tape test, when the first tape\n"
2183 "fills, it will ask for a second, and after writing a few more \n"
2184 "blocks, it will stop.  Then it will begin re-reading the\n"
2185 "two tapes.\n\n"
2186 "This may take a long time -- hours! ...\n\n"),
2187          edit_uint64_with_suffix(dev->max_file_size, buf1));
2188
2189    get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
2190            "or the complete multiple tape (m) test: (s/m) "));
2191    if (cmd[0] == 's') {
2192       Pmsg0(-1, _("Simple test (single tape) selected.\n"));
2193       simple = true;
2194    } else if (cmd[0] == 'm') {
2195       Pmsg0(-1, _("Multiple tape test selected.\n"));
2196       simple = false;
2197    } else {
2198       Pmsg0(000, _("Command aborted.\n"));
2199       exit_code = 1;
2200       return;
2201    }
2202
2203    Dmsg1(20, "Begin append device=%s\n", dev->print_name());
2204    Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
2205
2206    /* Use fixed block size to simplify read back */
2207    min_block_size = dev->min_block_size;
2208    dev->min_block_size = dev->max_block_size;
2209    write_eof = dev->max_file_size / REC_SIZE; /*compute when we add EOF*/
2210    set_volume_name("TestVolume1", 1);
2211    dir_ask_sysop_to_create_appendable_volume(dcr);
2212    dev->set_append();                 /* force volume to be relabeled */
2213
2214    /*
2215     * Acquire output device for writing.  Note, after acquiring a
2216     *   device, we MUST release it, which is done at the end of this
2217     *   subroutine.
2218     */
2219    Dmsg0(100, "just before acquire_device\n");
2220    if (!acquire_device_for_append(dcr)) {
2221       jcr->setJobStatus(JS_ErrorTerminated);
2222       exit_code = 1;
2223       return;
2224    }
2225    block = jcr->dcr->block;
2226
2227    Dmsg0(100, "Just after acquire_device_for_append\n");
2228    /*
2229     * Write Begin Session Record
2230     */
2231    if (!write_session_label(dcr, SOS_LABEL)) {
2232       jcr->setJobStatus(JS_ErrorTerminated);
2233       Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
2234          dev->bstrerror());
2235       ok = false;
2236    }
2237    Pmsg0(-1, _("Wrote Start of Session label.\n"));
2238
2239    memset(&rec, 0, sizeof(rec));
2240    rec.data = get_memory(100000);     /* max record size */
2241    rec.data_len = REC_SIZE;
2242
2243    /*
2244     * Put some random data in the record
2245     */
2246    fill_buffer(FILL_RANDOM, rec.data, rec.data_len);
2247
2248    /*
2249     * Generate data as if from File daemon, write to device
2250     */
2251    jcr->dcr->VolFirstIndex = 0;
2252    time(&jcr->run_time);              /* start counting time for rates */
2253    (void)localtime_r(&jcr->run_time, &tm);
2254    strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2255    if (simple) {
2256       Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
2257    } else {
2258       Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
2259    }
2260    for (file_index = 0; ok && !job_canceled(jcr); ) {
2261       rec.VolSessionId = jcr->VolSessionId;
2262       rec.VolSessionTime = jcr->VolSessionTime;
2263       rec.FileIndex = ++file_index;
2264       rec.Stream = STREAM_FILE_DATA;
2265       rec.maskedStream = STREAM_FILE_DATA;
2266
2267       /* Mix up the data just a bit */
2268       mix_buffer(FILL_RANDOM, rec.data, rec.data_len);
2269
2270       Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
2271          rec.FileIndex, rec.VolSessionId,
2272          stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
2273          rec.data_len);
2274
2275       while (!write_record_to_block(block, &rec)) {
2276          /*
2277           * When we get here we have just filled a block
2278           */
2279          Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
2280                     rec.remainder);
2281
2282          /* Write block to tape */
2283          if (!flush_block(block, 1)) {
2284             Pmsg0(000, _("Flush block failed.\n"));
2285             exit_code = 1;
2286             break;
2287          }
2288
2289          /* Every 5000 blocks (approx 322MB) report where we are.
2290           */
2291          if ((block->BlockNumber % 5000) == 0) {
2292             now = time(NULL);
2293             now -= jcr->run_time;
2294             if (now <= 0) {
2295                now = 1;          /* prevent divide error */
2296             }
2297             rate = dev->VolCatInfo.VolCatBytes / now;
2298             Pmsg5(-1, _("Wrote block=%u, file,blk=%u,%u VolBytes=%s rate=%sB/s\n"),
2299                block->BlockNumber, dev->file, dev->block_num,
2300                edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1),
2301                edit_uint64_with_suffix(rate, ec2));
2302          }
2303          /* Every X blocks (dev->max_file_size) write an EOF.
2304           */
2305          if ((block->BlockNumber % write_eof) == 0) {
2306             now = time(NULL);
2307             (void)localtime_r(&now, &tm);
2308             strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2309             Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
2310             flush_block(block, 0);
2311 #ifdef needed_xxx
2312             dev->weof(1);
2313 #endif
2314          }
2315
2316          /* Get out after writing 1000 blocks to the second tape */
2317          if (++BlockNumber > 1000 && stop != 0) {      /* get out */
2318             Pmsg0(000, _("Wrote 1000 blocks on second tape. Done.\n"));
2319             break;
2320          }
2321       }
2322       if (!ok) {
2323          Pmsg0(000, _("Not OK\n"));
2324          exit_code = 1;
2325          break;
2326       }
2327       jcr->JobBytes += rec.data_len;   /* increment bytes this job */
2328       Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
2329          FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
2330          stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
2331
2332       /* Get out after writing 1000 blocks to the second tape */
2333       if (BlockNumber > 1000 && stop != 0) {      /* get out */
2334          char ed1[50];
2335          Pmsg1(-1, "Done writing %s records ...\n",
2336              edit_uint64_with_commas(write_count, ed1));
2337          break;
2338       }
2339    } /* end big for loop */
2340
2341    if (vol_num > 1) {
2342       Dmsg0(100, "Write_end_session_label()\n");
2343       /* Create Job status for end of session label */
2344       if (!job_canceled(jcr) && ok) {
2345          jcr->setJobStatus(JS_Terminated);
2346       } else if (!ok) {
2347          Pmsg0(000, _("Job canceled.\n"));
2348          jcr->setJobStatus(JS_ErrorTerminated);
2349          exit_code = 1;
2350       }
2351       if (!write_session_label(dcr, EOS_LABEL)) {
2352          Pmsg1(000, _("Error writing end session label. ERR=%s\n"), dev->bstrerror());
2353          ok = false;
2354          exit_code = 1;
2355       }
2356       /* Write out final block of this session */
2357       if (!write_block_to_device(dcr)) {
2358          Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
2359          ok = false;
2360          exit_code = 1;
2361       }
2362       Pmsg0(-1, _("Wrote End of Session label.\n"));
2363
2364       /* Save last block info for second tape */
2365       last_block_num2 = last_block_num;
2366       last_file2 = last_file;
2367       if (last_block2) {
2368          free_block(last_block2);
2369       }
2370       last_block2 = dup_block(last_block);
2371    }
2372
2373    sprintf(buf, "%s/btape.state", working_directory);
2374    fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
2375    if (fd >= 0) {
2376       write(fd, &btape_state_level, sizeof(btape_state_level));
2377       write(fd, &simple, sizeof(simple));
2378       write(fd, &last_block_num1, sizeof(last_block_num1));
2379       write(fd, &last_block_num2, sizeof(last_block_num2));
2380       write(fd, &last_file1, sizeof(last_file1));
2381       write(fd, &last_file2, sizeof(last_file2));
2382       write(fd, last_block1->buf, last_block1->buf_len);
2383       write(fd, last_block2->buf, last_block2->buf_len);
2384       write(fd, first_block->buf, first_block->buf_len);
2385       close(fd);
2386       Pmsg2(0, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2387          last_block_num1, last_block_num2);
2388    } else {
2389       berrno be;
2390       Pmsg2(0, _("Could not create state file: %s ERR=%s\n"), buf,
2391                  be.bstrerror());
2392       exit_code = 1;
2393       ok = false;
2394    }
2395
2396    now = time(NULL);
2397    (void)localtime_r(&now, &tm);
2398    strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2399    if (ok) {
2400       if (simple) {
2401          Pmsg3(0, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2402                buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2403       } else {
2404          Pmsg3(0, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2405                buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2406       }
2407
2408       jcr->dcr->block = block;
2409       if (!do_unfill()) {
2410          Pmsg0(000, _("do_unfill failed.\n"));
2411          exit_code = 1;
2412          ok = false;
2413       }
2414    } else {
2415       Pmsg1(000, _("%s: Error during test.\n"), buf1);
2416    }
2417    dev->min_block_size = min_block_size;
2418    free_memory(rec.data);
2419 }
2420
2421 /*
2422  * Read two tapes written by the "fill" command and ensure
2423  *  that the data is valid.  If stop==1 we simulate full read back
2424  *  of two tapes.  If stop==-1 we simply read the last block and
2425  *  verify that it is correct.
2426  */
2427 static void unfillcmd()
2428 {
2429    int fd;
2430
2431    exit_code = 0;
2432    last_block1 = new_block(dev);
2433    last_block2 = new_block(dev);
2434    first_block = new_block(dev);
2435    sprintf(buf, "%s/btape.state", working_directory);
2436    fd = open(buf, O_RDONLY);
2437    if (fd >= 0) {
2438       uint32_t state_level;
2439       read(fd, &state_level, sizeof(btape_state_level));
2440       read(fd, &simple, sizeof(simple));
2441       read(fd, &last_block_num1, sizeof(last_block_num1));
2442       read(fd, &last_block_num2, sizeof(last_block_num2));
2443       read(fd, &last_file1, sizeof(last_file1));
2444       read(fd, &last_file2, sizeof(last_file2));
2445       read(fd, last_block1->buf, last_block1->buf_len);
2446       read(fd, last_block2->buf, last_block2->buf_len);
2447       read(fd, first_block->buf, first_block->buf_len);
2448       close(fd);
2449       if (state_level != btape_state_level) {
2450           Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2451                   "the fill command.\n"));
2452           exit_code = 1;
2453           return;
2454        }
2455    } else {
2456       berrno be;
2457       Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2458              "You must redo the fill command.\n"), buf, be.bstrerror());
2459       exit_code = 1;
2460       return;
2461    }
2462    if (!do_unfill()) {
2463       exit_code = 1;
2464    }
2465    this_block = NULL;
2466 }
2467
2468 /*
2469  * This is the second part of the fill command. After the tape or
2470  *  tapes are written, we are called here to reread parts, particularly
2471  *  the last block.
2472  */
2473 static bool do_unfill()
2474 {
2475    DEV_BLOCK *block = dcr->block;
2476    int autochanger;
2477    bool rc = false;
2478
2479    dumped = 0;
2480    VolBytes = 0;
2481    LastBlock = 0;
2482
2483    Pmsg0(000, "Enter do_unfill\n");
2484    dev->set_cap(CAP_ANONVOLS);        /* allow reading any volume */
2485    dev->clear_cap(CAP_LABEL);         /* don't label anything here */
2486
2487    end_of_tape = 0;
2488
2489    time(&jcr->run_time);              /* start counting time for rates */
2490    stop = 0;
2491    file_index = 0;
2492    if (last_block) {
2493       free_block(last_block);
2494       last_block = NULL;
2495    }
2496    last_block_num = last_block_num1;
2497    last_file = last_file1;
2498    last_block = last_block1;
2499
2500    free_restore_volume_list(jcr);
2501    jcr->bsr = NULL;
2502    bstrncpy(dcr->VolumeName, "TestVolume1|TestVolume2", sizeof(dcr->VolumeName));
2503    create_restore_volume_list(jcr);
2504    if (jcr->VolList != NULL) {
2505       jcr->VolList->Slot = 1;
2506       if (jcr->VolList->next != NULL) {
2507          jcr->VolList->next->Slot = 2;
2508       }
2509    }
2510
2511    set_volume_name("TestVolume1", 1);
2512
2513    if (!simple) {
2514       /* Multiple Volume tape */
2515       /* Close device so user can use autochanger if desired */
2516       if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2517          dev->offline();
2518       }
2519       autochanger = autoload_device(dcr, 1, NULL);
2520       if (autochanger != 1) {
2521          Pmsg1(100, "Autochanger returned: %d\n", autochanger);
2522          dev->close();
2523          get_cmd(_("Mount first tape. Press enter when ready: "));
2524          Pmsg0(000, "\n");
2525       }
2526    }
2527
2528    dev->close();
2529    dev->num_writers = 0;
2530    if (!acquire_device_for_read(dcr)) {
2531       Pmsg1(-1, "%s", dev->errmsg);
2532       goto bail_out;
2533    }
2534    /*
2535     * We now have the first tape mounted.
2536     * Note, re-reading last block may have caused us to
2537     *   loose track of where we are (block number unknown).
2538     */
2539    Pmsg0(-1, _("Rewinding.\n"));
2540    if (!dev->rewind(dcr)) {                /* get to a known place on tape */
2541       goto bail_out;
2542    }
2543    /* Read the first 10000 records */
2544    Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2545       dev->file, dev->block_num);
2546    quickie_count = 0;
2547    read_records(dcr, quickie_cb, my_mount_next_read_volume);
2548    Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2549          last_file, last_block_num);
2550    if (!dev->reposition(dcr, last_file, last_block_num)) {
2551       Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2552       goto bail_out;
2553    }
2554    Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2555    if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2556       Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2557       goto bail_out;
2558    }
2559    if (compare_blocks(last_block, block)) {
2560       if (simple) {
2561          Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2562          rc = true;
2563       } else {
2564          Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2565       }
2566    }
2567    if (simple) {
2568       goto bail_out;
2569    }
2570
2571    /* restore info for last block on second Volume */
2572    last_block_num = last_block_num2;
2573    last_file = last_file2;
2574    last_block = last_block2;
2575
2576    /* Multiple Volume tape */
2577    /* Close device so user can use autochanger if desired */
2578    if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
2579       dev->offline();
2580    }
2581
2582    set_volume_name("TestVolume2", 2);
2583
2584    autochanger = autoload_device(dcr, 1, NULL);
2585    if (autochanger != 1) {
2586       Pmsg1(100, "Autochanger returned: %d\n", autochanger);
2587       dev->close();
2588       get_cmd(_("Mount second tape. Press enter when ready: "));
2589       Pmsg0(000, "\n");
2590    }
2591
2592    dev->clear_read();
2593    if (!acquire_device_for_read(dcr)) {
2594       Pmsg1(-1, "%s", dev->errmsg);
2595       goto bail_out;
2596    }
2597
2598    /* Space to "first" block which is last block not written
2599     * on the previous tape.
2600     */
2601    Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2602    if (!dev->reposition(dcr, 0, 1)) {
2603       Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2604       goto bail_out;
2605    }
2606    Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2607    if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2608       Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2609       goto bail_out;
2610    }
2611    if (compare_blocks(first_block, block)) {
2612       Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2613    }
2614
2615    /* Now find and compare the last block */
2616    Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2617          last_file, last_block_num);
2618    if (!dev->reposition(dcr, last_file, last_block_num)) {
2619       Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2620       goto bail_out;
2621    }
2622    Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2623    if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2624       Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2625       goto bail_out;
2626    }
2627    if (compare_blocks(last_block, block)) {
2628       Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2629       rc = true;
2630    }
2631
2632 bail_out:
2633    free_block(last_block1);
2634    free_block(last_block2);
2635    free_block(first_block);
2636    return rc;
2637 }
2638
2639 /* Read 10000 records then stop */
2640 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2641 {
2642    DEVICE *dev = dcr->dev;
2643    quickie_count++;
2644    if (quickie_count == 10000) {
2645       Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2646    }
2647    return quickie_count < 10000;
2648 }
2649
2650 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2651 {
2652    char *p, *q;
2653    uint32_t CheckSum, block_len;
2654    ser_declare;
2655
2656    p = last_block->buf;
2657    q = block->buf;
2658    unser_begin(q, BLKHDR2_LENGTH);
2659    unser_uint32(CheckSum);
2660    unser_uint32(block_len);
2661    while (q < (block->buf+block_len)) {
2662       if (*p == *q) {
2663          p++;
2664          q++;
2665          continue;
2666       }
2667       Pmsg0(-1, "\n");
2668       dump_block(last_block, _("Last block written"));
2669       Pmsg0(-1, "\n");
2670       dump_block(block, _("Block read back"));
2671       Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2672       Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2673                 "that was read back differ. The test FAILED !!!!\n"
2674                 "This must be corrected before you use Bacula\n"
2675                 "to write multi-tape Volumes.!!!!\n"));
2676       return false;
2677    }
2678    if (verbose) {
2679       dump_block(last_block, _("Last block written"));
2680       dump_block(block, _("Block read back"));
2681    }
2682    return true;
2683 }
2684
2685 /*
2686  * Write current block to tape regardless of whether or
2687  *   not it is full. If the tape fills, attempt to
2688  *   acquire another tape.
2689  */
2690 static int flush_block(DEV_BLOCK *block, int dump)
2691 {
2692    char ec1[50], ec2[50];
2693    uint64_t rate;
2694    DEV_BLOCK *tblock;
2695    uint32_t this_file, this_block_num;
2696
2697    dev->r_dlock();
2698    if (!this_block) {
2699       this_block = new_block(dev);
2700    }
2701    if (!last_block) {
2702       last_block = new_block(dev);
2703    }
2704    /* Copy block */
2705    this_file = dev->file;
2706    this_block_num = dev->block_num;
2707    if (!write_block_to_dev(dcr)) {
2708       Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2709                   last_file, last_block_num, this_block_num);
2710       if (vol_num == 1) {
2711          /*
2712           * This is 1st tape, so save first tape info separate
2713           *  from second tape info
2714           */
2715          last_block_num1 = last_block_num;
2716          last_file1 = last_file;
2717          last_block1 = dup_block(last_block);
2718          last_block2 = dup_block(last_block);
2719          first_block = dup_block(block); /* first block second tape */
2720       }
2721       if (verbose) {
2722          Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2723             (unsigned)file_index, block->BlockNumber, block->block_len);
2724          dump_block(last_block, _("Last block written"));
2725          Pmsg0(-1, "\n");
2726          dump_block(block, _("Block not written"));
2727       }
2728       if (stop == 0) {
2729          eot_block = block->BlockNumber;
2730          eot_block_len = block->block_len;
2731          eot_FileIndex = file_index;
2732          stop = 1;
2733       }
2734       now = time(NULL);
2735       now -= jcr->run_time;
2736       if (now <= 0) {
2737          now = 1;                     /* don't divide by zero */
2738       }
2739       rate = dev->VolCatInfo.VolCatBytes / now;
2740       vol_size = dev->VolCatInfo.VolCatBytes;
2741       Pmsg4(000, _("End of tape %d:%d. Volume Bytes=%s. Write rate = %sB/s\n"),
2742          dev->file, dev->block_num,
2743          edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1),
2744          edit_uint64_with_suffix(rate, ec2));
2745
2746       if (simple) {
2747          stop = -1;                   /* stop, but do simplified test */
2748       } else {
2749          /* Full test in progress */
2750          if (!fixup_device_block_write_error(jcr->dcr)) {
2751             Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2752             ok = false;
2753             dev->dunlock();
2754             return 0;
2755          }
2756          BlockNumber = 0;             /* start counting for second tape */
2757       }
2758       dev->dunlock();
2759       return 1;                       /* end of tape reached */
2760    }
2761
2762    /* Save contents after write so that the header is serialized */
2763    memcpy(this_block->buf, block->buf, this_block->buf_len);
2764
2765    /*
2766     * Note, we always read/write to block, but we toggle
2767     *  copying it to one or another of two allocated blocks.
2768     * Switch blocks so that the block just successfully written is
2769     *  always in last_block.
2770     */
2771    tblock = last_block;
2772    last_block = this_block;
2773    this_block = tblock;
2774    last_file = this_file;
2775    last_block_num = this_block_num;
2776
2777    dev->dunlock();
2778    return 1;
2779 }
2780
2781
2782 /*
2783  * First we label the tape, then we fill
2784  *  it with data get a new tape and write a few blocks.
2785  */
2786 static void qfillcmd()
2787 {
2788    DEV_BLOCK *block = dcr->block;
2789    DEV_RECORD *rec = dcr->rec;
2790    int i, count;
2791
2792    Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2793
2794    get_cmd(_("How many blocks do you want to write? (1000): "));
2795
2796    count = atoi(cmd);
2797    if (count <= 0) {
2798       count = 1000;
2799    }
2800
2801    sm_check(__FILE__, __LINE__, false);
2802
2803    i = block->buf_len - 100;
2804    ASSERT (i > 0);
2805    rec->data = check_pool_memory_size(rec->data, i);
2806    memset(rec->data, i & 0xFF, i);
2807    rec->data_len = i;
2808    rewindcmd();
2809    init_speed();
2810
2811    Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2812    for (i=0; i < count; i++) {
2813       if (i % 100 == 0) {
2814          printf("+");
2815          fflush(stdout);
2816       }
2817       if (!write_record_to_block(block, rec)) {
2818          Pmsg0(0, _("Error writing record to block.\n"));
2819          goto bail_out;
2820       }
2821       if (!write_block_to_dev(dcr)) {
2822          Pmsg0(0, _("Error writing block to device.\n"));
2823          goto bail_out;
2824       }
2825    }
2826    printf("\n");
2827    print_speed(dev->VolCatInfo.VolCatBytes);
2828    weofcmd();
2829    if (dev->has_cap(CAP_TWOEOF)) {
2830       weofcmd();
2831    }
2832    rewindcmd();
2833    scan_blocks();
2834
2835 bail_out:
2836    sm_check(__FILE__, __LINE__, false);
2837 }
2838
2839 /*
2840  * Fill a tape using raw write() command
2841  */
2842 static void rawfill_cmd()
2843 {
2844    DEV_BLOCK *block = dcr->block;
2845    int stat;
2846    uint32_t block_num = 0;
2847    uint32_t *p;
2848    int my_errno;
2849
2850    fill_buffer(FILL_RANDOM, block->buf, block->buf_len);
2851    init_speed();
2852
2853    p = (uint32_t *)block->buf;
2854    Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2855    for ( ;; ) {
2856       *p = block_num;
2857       stat = dev->d_write(dev->fd(), block->buf, block->buf_len);
2858       if (stat == (int)block->buf_len) {
2859          if ((block_num++ % 100) == 0) {
2860             printf("+");
2861             fflush(stdout);
2862          }
2863
2864          mix_buffer(FILL_RANDOM, block->buf, block->buf_len);
2865
2866          jcr->JobBytes += stat;
2867          continue;
2868       }
2869       break;
2870    }
2871    my_errno = errno;
2872    printf("\n");
2873    berrno be;
2874    printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2875       be.bstrerror(my_errno));
2876
2877    print_speed(jcr->JobBytes);
2878    weofcmd();
2879 }
2880
2881
2882
2883 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2884 static struct cmdstruct commands[] = {
2885  {NT_("autochanger"),autochangercmd, _("test autochanger")},
2886  {NT_("bsf"),       bsfcmd,       _("backspace file")},
2887  {NT_("bsr"),       bsrcmd,       _("backspace record")},
2888  {NT_("cap"),       capcmd,       _("list device capabilities")},
2889  {NT_("clear"),     clearcmd,     _("clear tape errors")},
2890  {NT_("eod"),       eodcmd,       _("go to end of Bacula data for append")},
2891  {NT_("eom"),       eomcmd,       _("go to the physical end of medium")},
2892  {NT_("fill"),      fillcmd,      _("fill tape, write onto second volume")},
2893  {NT_("unfill"),    unfillcmd,    _("read filled tape")},
2894  {NT_("fsf"),       fsfcmd,       _("forward space a file")},
2895  {NT_("fsr"),       fsrcmd,       _("forward space a record")},
2896  {NT_("help"),      helpcmd,      _("print this command")},
2897  {NT_("label"),     labelcmd,     _("write a Bacula label to the tape")},
2898  {NT_("load"),      loadcmd,      _("load a tape")},
2899  {NT_("quit"),      quitcmd,      _("quit btape")},
2900  {NT_("rawfill"),   rawfill_cmd,  _("use write() to fill tape")},
2901  {NT_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2902  {NT_("rectest"),   rectestcmd,   _("test record handling functions")},
2903  {NT_("rewind"),    rewindcmd,    _("rewind the tape")},
2904  {NT_("scan"),      scancmd,      _("read() tape block by block to EOT and report")},
2905  {NT_("scanblocks"),scan_blocks,  _("Bacula read block by block to EOT and report")},
2906  {NT_("speed"),     speed_test,   _("[file_size=n(GB)|nb_file=3|skip_zero|skip_random|skip_raw|skip_block] report drive speed")},
2907  {NT_("status"),    statcmd,      _("print tape status")},
2908  {NT_("test"),      testcmd,      _("General test Bacula tape functions")},
2909  {NT_("weof"),      weofcmd,      _("write an EOF on the tape")},
2910  {NT_("wr"),        wrcmd,        _("write a single Bacula block")},
2911  {NT_("rr"),        rrcmd,        _("read a single record")},
2912  {NT_("rb"),        rbcmd,        _("read a single Bacula block")},
2913  {NT_("qfill"),     qfillcmd,     _("quick fill command")}
2914              };
2915 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2916
2917 static void
2918 do_tape_cmds()
2919 {
2920    unsigned int i;
2921    bool found;
2922
2923    while (!quit && get_cmd("*")) {
2924       sm_check(__FILE__, __LINE__, false);
2925       found = false;
2926       parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2927       for (i=0; i<comsize; i++)       /* search for command */
2928          if (argc > 0 && fstrsch(argk[0],  commands[i].key)) {
2929             (*commands[i].func)();    /* go execute command */
2930             found = true;
2931             break;
2932          }
2933       if (*cmd && !found) {
2934          Pmsg1(0, _("\"%s\" is an invalid command\n"), cmd);
2935       }
2936    }
2937 }
2938
2939 static void helpcmd()
2940 {
2941    unsigned int i;
2942    usage();
2943    printf(_("Interactive commands:\n"));
2944    printf(_("  Command    Description\n  =======    ===========\n"));
2945    for (i=0; i<comsize; i++)
2946       printf("  %-10s %s\n", commands[i].key, commands[i].help);
2947    printf("\n");
2948 }
2949
2950 static void usage()
2951 {
2952    fprintf(stderr, _(
2953 PROG_COPYRIGHT
2954 "\nVersion: %s (%s)\n\n"
2955 "Usage: btape <options> <device_name>\n"
2956 "       -b <file>   specify bootstrap file\n"
2957 "       -c <file>   set configuration file to file\n"
2958 "       -d <nn>     set debug level to <nn>\n"
2959 "       -dt         print timestamp in debug output\n"
2960 "       -p          proceed inspite of I/O errors\n"
2961 "       -s          turn off signals\n"
2962 "       -v          be verbose\n"
2963 "       -?          print this message.\n"
2964 "\n"), 2000, VERSION, BDATE);
2965
2966 }
2967
2968 /*
2969  * Get next input command from terminal.  This
2970  * routine is REALLY primitive, and should be enhanced
2971  * to have correct backspacing, etc.
2972  */
2973 int
2974 get_cmd(const char *prompt)
2975 {
2976    int i = 0;
2977    int ch;
2978
2979    fprintf(stdout, "%s", prompt);
2980
2981    /* We really should turn off echoing and pretty this
2982     * up a bit.
2983     */
2984    cmd[i] = 0;
2985    while ((ch = fgetc(stdin)) != EOF) {
2986       if (ch == '\n') {
2987          strip_trailing_junk(cmd);
2988          return 1;
2989       } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2990          if (i > 0) {
2991             cmd[--i] = 0;
2992          }
2993          continue;
2994       }
2995
2996       cmd[i++] = ch;
2997       cmd[i] = 0;
2998    }
2999    quit = 1;
3000    return 0;
3001 }
3002
3003 /* Dummies to replace askdir.c */
3004 bool    dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
3005 bool    dir_send_job_status(JCR *jcr) {return 1;}
3006
3007 bool dir_update_volume_info(DCR *dcr, bool relabel, bool update_LastWritten)
3008 {
3009    return 1;
3010 }
3011
3012
3013 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw  writing)
3014 {
3015    Dmsg0(20, "Enter dir_get_volume_info\n");
3016    dcr->setVolCatName(dcr->VolumeName);
3017    return 1;
3018 }
3019
3020 bool dir_create_jobmedia_record(DCR *dcr, bool zero)
3021 {
3022    dcr->WroteVol = false;
3023    return 1;
3024 }
3025
3026
3027 bool dir_find_next_appendable_volume(DCR *dcr)
3028 {
3029    Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
3030    return dcr->VolumeName[0] != 0;
3031 }
3032
3033 bool dir_ask_sysop_to_mount_volume(DCR *dcr, int /* mode */)
3034 {
3035    DEVICE *dev = dcr->dev;
3036    Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
3037    if (dcr->VolumeName[0] == 0) {
3038       return dir_ask_sysop_to_create_appendable_volume(dcr);
3039    }
3040    Pmsg1(-1, "%s", dev->errmsg);           /* print reason */
3041    if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
3042       fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
3043          dev->print_name());
3044    } else {
3045       fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
3046          dcr->VolumeName, dev->print_name());
3047    }
3048    dev->close();
3049    getchar();
3050    return true;
3051 }
3052
3053 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
3054 {
3055    int autochanger;
3056    DEVICE *dev = dcr->dev;
3057    Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
3058    if (stop == 0) {
3059       set_volume_name("TestVolume1", 1);
3060    } else {
3061       set_volume_name("TestVolume2", 2);
3062    }
3063    /* Close device so user can use autochanger if desired */
3064    if (dev->has_cap(CAP_OFFLINEUNMOUNT)) {
3065       dev->offline();
3066    }
3067    autochanger = autoload_device(dcr, 1, NULL);
3068    if (autochanger != 1) {
3069       Pmsg1(100, "Autochanger returned: %d\n", autochanger);
3070       fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
3071          dev->print_name());
3072       dev->close();
3073       getchar();
3074       Pmsg0(000, "\n");
3075    }
3076    labelcmd();
3077    VolumeName = NULL;
3078    BlockNumber = 0;
3079    return true;
3080 }
3081
3082 static bool my_mount_next_read_volume(DCR *dcr)
3083 {
3084    char ec1[50], ec2[50];
3085    uint64_t rate;
3086    JCR *jcr = dcr->jcr;
3087    DEV_BLOCK *block = dcr->block;
3088
3089    Dmsg0(20, "Enter my_mount_next_read_volume\n");
3090    Pmsg2(000, _("End of Volume \"%s\" %d records.\n"), dcr->VolumeName,
3091       quickie_count);
3092
3093    volume_unused(dcr);             /* release current volume */
3094    if (LastBlock != block->BlockNumber) {
3095       VolBytes += block->block_len;
3096    }
3097    LastBlock = block->BlockNumber;
3098    now = time(NULL);
3099    now -= jcr->run_time;
3100    if (now <= 0) {
3101       now = 1;
3102    }
3103    rate = VolBytes / now;
3104    Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%sB/s\n"), block->BlockNumber,
3105             edit_uint64_with_commas(VolBytes, ec1),
3106             edit_uint64_with_suffix(rate, ec2));
3107
3108    if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
3109       end_of_tape = 1;
3110       return false;
3111    }
3112
3113    set_volume_name("TestVolume2", 2);
3114
3115    dev->close();
3116    if (!acquire_device_for_read(dcr)) {
3117       Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
3118       return false;
3119    }
3120    return true;                    /* next volume mounted */
3121 }
3122
3123 static void set_volume_name(const char *VolName, int volnum)
3124 {
3125    DCR *dcr = jcr->dcr;
3126    VolumeName = VolName;
3127    vol_num = volnum;
3128    dev->setVolCatName(VolName);
3129    dcr->setVolCatName(VolName);
3130    bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
3131    dcr->VolCatInfo.Slot = volnum;
3132    dcr->VolCatInfo.InChanger = true;
3133 }