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