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

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