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