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

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