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-2003 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
  43 /* Exported variables */
  44 int quit = 0;
  45 char buf[100000];
  46 int bsize = TAPE_BSIZE;
  47 char VolName[MAX_NAME_LENGTH];
  48
  49 DEVICE *dev = NULL;
  50 DEVRES *device = NULL;
  51
  52
  53 /* Forward referenced subroutines */
  54 static void do_tape_cmds();
  55 static void helpcmd();
  56 static void scancmd();
  57 static void rewindcmd();
  58 static void clearcmd();
  59 static void wrcmd();
  60 static void rrcmd();
  61 static void eodcmd();
  62 static void fillcmd();
  63 static void qfillcmd();
  64 static void statcmd();
  65 static void unfillcmd();
  66 static int flush_block(DEV_BLOCK *block, int dump);
  67 static int record_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec);
  68 static int my_mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
  69 static void scan_blocks();
  70 static void set_volume_name(char *VolName, int volnum);
  71 static void rawfill_cmd();
  72
  73
  74 /* Static variables */
  75 #define CONFIG_FILE "bacula-sd.conf"
  76 char *configfile;
  77
  78 static BSR *bsr = NULL;
  79 static char cmd[1000];
  80 static int signals = TRUE;
  81 static int ok;
  82 static int stop;
  83 static uint64_t vol_size;
  84 static uint64_t VolBytes;
  85 static time_t now;
  86 static double kbs;
  87 static int32_t file_index;
  88 static int end_of_tape = 0;
  89 static uint32_t LastBlock = 0;
  90 static uint32_t eot_block;
  91 static uint32_t eot_block_len;
  92 static uint32_t eot_FileIndex;
  93 static int dumped = 0;
  94 static DEV_BLOCK *last_block = NULL;
  95 static DEV_BLOCK *this_block = NULL;
  96 static uint32_t last_file = 0;
  97 static uint32_t last_block_num = 0;
  98 static uint32_t BlockNumber = 0;
  99 static int simple = FALSE;
 100
 101 static char *VolumeName = NULL;
 102 static int vol_num;
 103
 104 static JCR *jcr = NULL;
 105
 106
 107 static void usage();
 108 static void terminate_btape(int sig);
 109 int get_cmd(char *prompt);
 110
 111
 112 /*********************************************************************
 113  *
 114  *         Main Bacula Pool Creation Program
 115  *
 116  */
 117 int main(int argc, char *argv[])
 118 {
 119    int ch;
 120    DEV_BLOCK *block;
 121
 122    /* Sanity checks */
 123    if (TAPE_BSIZE % DEV_BSIZE != 0 || TAPE_BSIZE / DEV_BSIZE == 0) {
 124       Emsg2(M_ABORT, 0, "Tape block size (%d) not multiple of system size (%d)\n",
 125          TAPE_BSIZE, DEV_BSIZE);
 126    }
 127    if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
 128       Emsg1(M_ABORT, 0, "Tape block size (%d) is not a power of 2\n", TAPE_BSIZE);
 129    }
 130
 131    printf("Tape block granularity is %d bytes.\n", TAPE_BSIZE);
 132
 133    working_directory = "/tmp";
 134    my_name_is(argc, argv, "btape");
 135    init_msg(NULL, NULL);
 136
 137    while ((ch = getopt(argc, argv, "b:c:d:sv?")) != -1) {
 138       switch (ch) {
 139          case 'b':                    /* bootstrap file */
 140             bsr = parse_bsr(NULL, optarg);
 141 //          dump_bsr(bsr);
 142             break;
 143
 144          case 'c':                    /* specify config file */
 145             if (configfile != NULL) {
 146                free(configfile);
 147             }
 148             configfile = bstrdup(optarg);
 149             break;
 150
 151          case 'd':                    /* set debug level */
 152             debug_level = atoi(optarg);
 153             if (debug_level <= 0) {
 154                debug_level = 1;
 155             }
 156             break;
 157
 158          case 's':
 159             signals = FALSE;
 160             break;
 161
 162          case 'v':
 163             verbose++;
 164             break;
 165
 166          case '?':
 167          default:
 168             helpcmd();
 169             exit(0);
 170
 171       }
 172    }
 173    argc -= optind;
 174    argv += optind;
 175
 176
 177
 178    if (signals) {
 179       init_signals(terminate_btape);
 180    }
 181
 182    if (configfile == NULL) {
 183       configfile = bstrdup(CONFIG_FILE);
 184    }
 185
 186    daemon_start_time = time(NULL);
 187
 188    parse_config(configfile);
 189
 190
 191    /* See if we can open a device */
 192    if (argc == 0) {
 193       Pmsg0(000, "No archive name specified.\n");
 194       usage();
 195       exit(1);
 196    } else if (argc != 1) {
 197       Pmsg0(000, "Improper number of arguments specified.\n");
 198       usage();
 199       exit(1);
 200    }
 201
 202    jcr = setup_jcr("btape", argv[0], bsr, NULL);
 203    dev = setup_to_access_device(jcr, 0);     /* acquire for write */
 204    if (!dev) {
 205       exit(1);
 206    }
 207    block = new_block(dev);
 208    lock_device(dev);
 209    if (!(dev->state & ST_OPENED)) {
 210       Dmsg0(129, "Opening device.\n");
 211       if (open_dev(dev, jcr->VolumeName, READ_WRITE) < 0) {
 212          Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
 213          unlock_device(dev);
 214          free_block(block);
 215          goto terminate;
 216       }
 217    }
 218    Dmsg1(129, "open_dev %s OK\n", dev_name(dev));
 219    unlock_device(dev);
 220    free_block(block);
 221
 222    Dmsg0(200, "Do tape commands\n");
 223    do_tape_cmds();
 224
 225 terminate:
 226    terminate_btape(0);
 227    return 0;
 228 }
 229
 230 static void terminate_btape(int stat)
 231 {
 232
 233    sm_check(__FILE__, __LINE__, False);
 234    if (configfile) {
 235       free(configfile);
 236    }
 237    free_config_resources();
 238
 239    if (dev) {
 240       term_dev(dev);
 241    }
 242
 243    if (debug_level > 10)
 244       print_memory_pool_stats();
 245
 246    free_jcr(jcr);
 247    jcr = NULL;
 248
 249    if (bsr) {
 250       free_bsr(bsr);
 251    }
 252
 253    if (last_block) {
 254       free_block(last_block);
 255    }
 256    if (this_block) {
 257       free_block(this_block);
 258    }
 259
 260    term_msg();
 261    close_memory_pool();               /* free memory in pool */
 262
 263    sm_dump(False);
 264    exit(stat);
 265 }
 266
 267 void quitcmd()
 268 {
 269    quit = 1;
 270 }
 271
 272 /*
 273  * Write a label to the tape
 274  */
 275 static void labelcmd()
 276 {
 277    DEVRES *device;
 278    int found = 0;
 279
 280    LockRes();
 281    for (device=NULL; (device=(DEVRES *)GetNextRes(R_DEVICE, (RES *)device)); ) {
 282       if (strcmp(device->device_name, dev->dev_name) == 0) {
 283          jcr->device = device;        /* Arggg a bit of duplication here */
 284          device->dev = dev;
 285          dev->device = device;
 286          found = 1;
 287          break;
 288       }
 289    }
 290    UnlockRes();
 291    if (!found) {
 292       Pmsg2(0, "Could not find device %s in %s\n", dev->dev_name, configfile);
 293       return;
 294    }
 295
 296    if (VolumeName) {
 297       strcpy(cmd, VolumeName);
 298    } else {
 299       if (!get_cmd("Enter Volume Name: ")) {
 300          return;
 301       }
 302    }
 303
 304    if (!(dev->state & ST_OPENED)) {
 305       if (!open_device(dev)) {
 306          Pmsg1(0, "Device open failed. ERR=%s\n", strerror_dev(dev));
 307       }
 308    }
 309    write_volume_label_to_dev(jcr, device, cmd, "Default");
 310 }
 311
 312 /*
 313  * Read the tape label
 314  */
 315 static void readlabelcmd()
 316 {
 317    int save_debug_level = debug_level;
 318    int stat;
 319    DEV_BLOCK *block;
 320
 321    block = new_block(dev);
 322    stat = read_dev_volume_label(jcr, dev, block);
 323    switch (stat) {
 324       case VOL_NO_LABEL:
 325          Pmsg0(0, "Volume has no label.\n");
 326          break;
 327       case VOL_OK:
 328          Pmsg0(0, "Volume label read correctly.\n");
 329          break;
 330       case VOL_IO_ERROR:
 331          Pmsg1(0, "I/O error on device: ERR=%s", strerror_dev(dev));
 332          break;
 333       case VOL_NAME_ERROR:
 334          Pmsg0(0, "Volume name error\n");
 335          break;
 336       case VOL_CREATE_ERROR:
 337          Pmsg1(0, "Error creating label. ERR=%s", strerror_dev(dev));
 338          break;
 339       case VOL_VERSION_ERROR:
 340          Pmsg0(0, "Volume version error.\n");
 341          break;
 342       case VOL_LABEL_ERROR:
 343          Pmsg0(0, "Bad Volume label type.\n");
 344          break;
 345       default:
 346          Pmsg0(0, "Unknown error.\n");
 347          break;
 348    }
 349
 350    debug_level = 20;
 351    dump_volume_label(dev);
 352    debug_level = save_debug_level;
 353    free_block(block);
 354 }
 355
 356
 357 /*
 358  * Load the tape should have prevously been taken
 359  * off line, otherwise this command is not necessary.
 360  */
 361 static void loadcmd()
 362 {
 363
 364    if (!load_dev(dev)) {
 365       Pmsg1(0, "Bad status from load. ERR=%s\n", strerror_dev(dev));
 366    } else
 367       Pmsg1(0, "Loaded %s\n", dev_name(dev));
 368 }
 369
 370 /*
 371  * Rewind the tape.
 372  */
 373 static void rewindcmd()
 374 {
 375    if (!rewind_dev(dev)) {
 376       Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
 377       clrerror_dev(dev, -1);
 378    } else {
 379       Pmsg1(0, "Rewound %s\n", dev_name(dev));
 380    }
 381 }
 382
 383 /*
 384  * Clear any tape error
 385  */
 386 static void clearcmd()
 387 {
 388    clrerror_dev(dev, -1);
 389 }
 390
 391 /*
 392  * Write and end of file on the tape
 393  */
 394 static void weofcmd()
 395 {
 396    int stat;
 397
 398    if ((stat = weof_dev(dev, 1)) < 0) {
 399       Pmsg2(0, "Bad status from weof %d. ERR=%s\n", stat, strerror_dev(dev));
 400       return;
 401    } else {
 402       Pmsg1(0, "Wrote EOF to %s\n", dev_name(dev));
 403    }
 404 }
 405
 406
 407 /* Go to the end of the medium -- raw command
 408  * The idea was orginally that the end of the Bacula
 409  * medium would be flagged differently. This is not
 410  * currently the case. So, this is identical to the
 411  * eodcmd().
 412  */
 413 static void eomcmd()
 414 {
 415    if (!eod_dev(dev)) {
 416       Pmsg1(0, _("Bad status from MTEOD. ERR=%s\n"), strerror_dev(dev));
 417       return;
 418    } else {
 419       Pmsg0(0, _("Moved to end of medium.\n"));
 420    }
 421 }
 422
 423 /*
 424  * Go to the end of the medium (either hardware determined
 425  *  or defined by two eofs.
 426  */
 427 static void eodcmd()
 428 {
 429    eomcmd();
 430 }
 431
 432 /*
 433  * Backspace file
 434  */
 435 static void bsfcmd()
 436 {
 437    int stat;
 438
 439    if ((stat=bsf_dev(dev, 1)) < 0) {
 440       Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), strerror(errno));
 441    } else {
 442       Pmsg0(0, _("Backspaced one file.\n"));
 443    }
 444 }
 445
 446 /*
 447  * Backspace record
 448  */
 449 static void bsrcmd()
 450 {
 451    int stat;
 452
 453    if ((stat=bsr_dev(dev, 1)) < 0) {
 454       Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), strerror(errno));
 455    } else {
 456       Pmsg0(0, _("Backspaced one record.\n"));
 457    }
 458 }
 459
 460 /*
 461  * List device capabilities as defined in the
 462  *  stored.conf file.
 463  */
 464 static void capcmd()
 465 {
 466    printf(_("Device capabilities:\n"));
 467    printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
 468    printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
 469    printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
 470    printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
 471    printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
 472    printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
 473    printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
 474    printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
 475    printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
 476    printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
 477    printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
 478    printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
 479    printf("\n");
 480
 481    printf(_("Device status:\n"));
 482    printf("%sOPENED ", dev->state & ST_OPENED ? "" : "!");
 483    printf("%sTAPE ", dev->state & ST_TAPE ? "" : "!");
 484    printf("%sLABEL ", dev->state & ST_LABEL ? "" : "!");
 485    printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
 486    printf("%sAPPEND ", dev->state & ST_APPEND ? "" : "!");
 487    printf("%sREAD ", dev->state & ST_READ ? "" : "!");
 488    printf("%sEOT ", dev->state & ST_EOT ? "" : "!");
 489    printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
 490    printf("%sEOF ", dev->state & ST_EOF ? "" : "!");
 491    printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
 492    printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
 493    printf("\n");
 494
 495    printf(_("Device parameters:\n"));
 496    printf("Device name: %s\n", dev->dev_name);
 497    printf("File=%u block=%u\n", dev->file, dev->block_num);
 498    printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
 499
 500    printf("Status:\n");
 501    statcmd();
 502
 503 }
 504
 505 /*
 506  * Test writting larger and larger records.
 507  * This is a torture test for records.
 508  */
 509 static void rectestcmd()
 510 {
 511    DEV_BLOCK *block;
 512    DEV_RECORD *rec;
 513    int i, blkno = 0;
 514
 515    Pmsg0(0, "Test writting larger and larger records.\n"
 516 "This is a torture test for records.\nI am going to write\n"
 517 "larger and larger records. It will stop when the record size\n"
 518 "plus the header exceeds the block size (by default about 64K)\n");
 519
 520
 521    get_cmd("Do you want to continue? (y/n): ");
 522    if (cmd[0] != 'y') {
 523       Pmsg0(000, "Command aborted.\n");
 524       return;
 525    }
 526
 527    sm_check(__FILE__, __LINE__, False);
 528    block = new_block(dev);
 529    rec = new_record();
 530
 531    for (i=1; i<500000; i++) {
 532       rec->data = check_pool_memory_size(rec->data, i);
 533       memset(rec->data, i & 0xFF, i);
 534       rec->data_len = i;
 535       sm_check(__FILE__, __LINE__, False);
 536       if (write_record_to_block(block, rec)) {
 537          empty_block(block);
 538          blkno++;
 539          Pmsg2(0, "Block %d i=%d\n", blkno, i);
 540       } else {
 541          break;
 542       }
 543       sm_check(__FILE__, __LINE__, False);
 544    }
 545    free_record(rec);
 546    free_block(block);
 547    sm_check(__FILE__, __LINE__, False);
 548 }
 549
 550 /*
 551  * This test attempts to re-read a block written by Bacula
 552  *   normally at the end of the tape. Bacula will then back up
 553  *   over the two eof marks, backup over the record and reread
 554  *   it to make sure it is valid.  Bacula can skip this validation
 555  *   if you set "Backward space record = no"
 556  */
 557 static int re_read_block_test()
 558 {
 559    DEV_BLOCK *block;
 560    DEV_RECORD *rec;
 561    int stat = 0;
 562    int len;
 563
 564    if (!(dev->capabilities & CAP_BSR)) {
 565       Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
 566       return 0;
 567    }
 568
 569    Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
 570       "I'm going to write three records and two eof's\n"
 571       "then backup over the eof's and re-read the last record.\n"
 572       "Bacula does this after writing the last block on the\n"
 573       "tape to verify that the block was written correctly.\n"
 574       "It is not an *essential* feature ...\n\n"));
 575    rewindcmd();
 576    block = new_block(dev);
 577    rec = new_record();
 578    rec->data = check_pool_memory_size(rec->data, block->buf_len);
 579    len = rec->data_len = block->buf_len-100;
 580    memset(rec->data, 1, rec->data_len);
 581    if (!write_record_to_block(block, rec)) {
 582       Pmsg0(0, _("Error writing record to block.\n"));
 583       goto bail_out;
 584    }
 585    if (!write_block_to_dev(jcr, dev, block)) {
 586       Pmsg0(0, _("Error writing block to device.\n"));
 587       goto bail_out;
 588    } else {
 589       Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
 590    }
 591    memset(rec->data, 2, rec->data_len);
 592    if (!write_record_to_block(block, rec)) {
 593       Pmsg0(0, _("Error writing record to block.\n"));
 594       goto bail_out;
 595    }
 596    if (!write_block_to_dev(jcr, dev, block)) {
 597       Pmsg0(0, _("Error writing block to device.\n"));
 598       goto bail_out;
 599    } else {
 600       Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
 601    }
 602    memset(rec->data, 3, rec->data_len);
 603    if (!write_record_to_block(block, rec)) {
 604       Pmsg0(0, _("Error writing record to block.\n"));
 605       goto bail_out;
 606    }
 607    if (!write_block_to_dev(jcr, dev, block)) {
 608       Pmsg0(0, _("Error writing block to device.\n"));
 609       goto bail_out;
 610    } else {
 611       Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
 612    }
 613    weofcmd();
 614    weofcmd();
 615    if (bsf_dev(dev, 1) != 0) {
 616       Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror(dev->dev_errno));
 617       goto bail_out;
 618    }
 619    if (bsf_dev(dev, 1) != 0) {
 620       Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror(dev->dev_errno));
 621       goto bail_out;
 622    }
 623    Pmsg0(0, "Backspaced over two EOFs OK.\n");
 624    if (bsr_dev(dev, 1) != 0) {
 625       Pmsg1(0, _("Backspace record failed! ERR=%s\n"), strerror(dev->dev_errno));
 626       goto bail_out;
 627    }
 628    Pmsg0(0, "Backspace record OK.\n");
 629    if (!read_block_from_dev(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
 630       Pmsg1(0, _("Read block failed! ERR=%s\n"), strerror(dev->dev_errno));
 631       goto bail_out;
 632    }
 633    memset(rec->data, 0, rec->data_len);
 634    if (!read_record_from_block(block, rec)) {
 635       Pmsg1(0, _("Read block failed! ERR=%s\n"), strerror(dev->dev_errno));
 636       goto bail_out;
 637    }
 638    for (int i=0; i<len; i++) {
 639       if (rec->data[i] != 3) {
 640          Pmsg0(0, _("Bad data in record. Test failed!\n"));
 641          goto bail_out;
 642       }
 643    }
 644    Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
 645    Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
 646
 647    stat = 1;
 648
 649 bail_out:
 650    free_block(block);
 651    free_record(rec);
 652    if (stat == 0) {
 653       Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
 654                  "this function to verify the last block written to the\n"
 655                  "tape. Bacula will skip the last block verification\n"
 656                  "if you add:\n\n"
 657                   "Backward Space Record = No\n\n"
 658                   "to your Storage daemon's Device resource definition.\n"));
 659    }
 660    return stat;
 661 }
 662
 663 /*
 664  * This test writes some records, then writes an end of file,
 665  *   rewinds the tape, moves to the end of the data and attepts
 666  *   to append to the tape.  This function is essential for
 667  *   Bacula to be able to write multiple jobs to the tape.
 668  */
 669 static int append_test()
 670 {
 671    Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
 672                "This test is essential to Bacula.\n\n"
 673 "I'm going to write one record  in file 0,\n"
 674 "                   two records in file 1,\n"
 675 "             and three records in file 2\n\n"));
 676    rewindcmd();
 677    wrcmd();
 678    weofcmd();      /* end file 0 */
 679    wrcmd();
 680    wrcmd();
 681    weofcmd();      /* end file 1 */
 682    wrcmd();
 683    wrcmd();
 684    wrcmd();
 685    weofcmd();     /* end file 2 */
 686    rewindcmd();
 687    Pmsg0(0, _("Now moving to end of medium.\n"));
 688    eodcmd();
 689    Pmsg2(-1, _("We should be in file 3. I am at file %d. This is %s\n"),
 690       dev->file, dev->file == 3 ? "correct!" : "NOT correct!!!!");
 691
 692    if (dev->file != 3) {
 693       return -1;
 694    }
 695
 696    Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
 697    wrcmd();
 698    weofcmd();
 699    rewindcmd();
 700    Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
 701    Pmsg0(-1, "Doing Bacula scan of blocks:\n");
 702    scan_blocks();
 703    Pmsg0(-1, _("End scanning the tape.\n"));
 704    Pmsg2(-1, _("We should be in file 4. I am at file %d. This is %s\n"),
 705       dev->file, dev->file == 4 ? "correct!" : "NOT correct!!!!");
 706
 707    if (dev->file != 4) {
 708       return -2;
 709    }
 710
 711    return 1;
 712 }
 713
 714 /*
 715  * This is a general test of Bacula's functions
 716  *   needed to read and write the tape.
 717  */
 718 static void testcmd()
 719 {
 720    int stat;
 721
 722    stat = append_test();
 723    if (stat == 1) {                   /* OK get out */
 724       goto all_done;
 725    }
 726    if (stat == -1) {                  /* first test failed */
 727       if (dev_cap(dev, CAP_EOM)) {
 728          Pmsg0(-1, "\nAppend test failed. Attempting again.\n"
 729                    "Setting \"Hardware End of Medium = no\" and retrying append test.\n\n");
 730          dev->capabilities &= ~CAP_EOM; /* turn off eom */
 731          stat = append_test();
 732          if (stat == 1) {
 733             Pmsg0(-1, "\n\nIt looks like the test worked this time, please add:\n\n"
 734                      "    Hardware End of Medium = No\n\n"
 735                      "to your Device resource in the Storage conf file.\n");
 736             goto all_done;
 737          }
 738          if (stat == -1) {
 739             Pmsg0(-1, "\n\nThat appears not to have corrected the problem.\n");
 740             goto all_done;
 741          }
 742          /* Wrong count after append */
 743          if (stat == -2) {
 744             Pmsg0(-1, "\n\nIt looks like the append failed. Attempting again.\n"
 745                      "Setting \"BSF at EOM = yes\" and retrying append test.\n");
 746             dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
 747             stat = append_test();
 748             if (stat == 1) {
 749                Pmsg0(-1, "\n\nIt looks like the test worked this time, please add:\n\n"
 750                      "    Hardware End of Medium = No\n"
 751                      "    BSR at EOM = yes\n\n"
 752                      "to your Device resource in the Storage conf file.\n");
 753                goto all_done;
 754             }
 755          }
 756
 757          Pmsg0(-1, "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
 758                "Unable to correct the problem. You MUST fix this\n"
 759                 "problem before Bacula can use your tape drive correctly\n");
 760          Pmsg0(-1, "\nPerhaps running Bacula in fixed block mode will work.\n"
 761                "Do so by setting:\n\n"
 762                "Minimum Block Size = nnn\n"
 763                "Maximum Block Size = nnn\n\n"
 764                "in your Storage daemon's Device definition.\n"
 765                "nnn must match your tape driver's block size.\n"
 766                "This, however, is not really an ideal solution.\n");
 767       }
 768    }
 769
 770 all_done:
 771    Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
 772         "Please double check it ...\n"
 773         "=== Sample correct output ===\n"
 774         "1 block of 64448 bytes in file 1\n"
 775         "End of File mark.\n"
 776         "2 blocks of 64448 bytes in file 2\n"
 777         "End of File mark.\n"
 778         "3 blocks of 64448 bytes in file 3\n"
 779         "End of File mark.\n"
 780         "1 block of 64448 bytes in file 4\n"
 781         "End of File mark.\n"
 782         "Total files=4, blocks=7, bytes = 451136\n"
 783         "=== End sample correct output ===\n\n"));
 784
 785    Pmsg0(-1, _("If the above scan output is not identical to the\n"
 786                "sample output, you MUST correct the problem\n"
 787                "or Bacula will not be able to write multiple Jobs to \n"
 788                "the tape.\n\n"));
 789
 790    if (stat == 1) {
 791       re_read_block_test();
 792    }
 793
 794    Pmsg0(-1, _("\n=== End Append files test ===\n"));
 795
 796 }
 797
 798 /* Forward space a file */
 799 static void fsfcmd()
 800 {
 801    if (!fsf_dev(dev, 1)) {
 802       Pmsg1(0, "Bad status from fsf. ERR=%s\n", strerror_dev(dev));
 803       return;
 804    }
 805    Pmsg0(0, "Forward spaced one file.\n");
 806 }
 807
 808 /* Forward space a record */
 809 static void fsrcmd()
 810 {
 811    int stat;
 812
 813    if ((stat=fsr_dev(dev, 1)) < 0) {
 814       Pmsg2(0, "Bad status from fsr %d. ERR=%s\n", stat, strerror_dev(dev));
 815       return;
 816    }
 817    Pmsg0(0, "Forward spaced one record.\n");
 818 }
 819
 820
 821 /*
 822  * Write a Bacula block to the tape
 823  */
 824 static void wrcmd()
 825 {
 826    DEV_BLOCK *block;
 827    DEV_RECORD *rec;
 828    int i;
 829
 830    sm_check(__FILE__, __LINE__, False);
 831    block = new_block(dev);
 832    rec = new_record();
 833    dump_block(block, "test");
 834
 835    i = block->buf_len - 100;
 836    ASSERT (i > 0);
 837    rec->data = check_pool_memory_size(rec->data, i);
 838    memset(rec->data, i & 0xFF, i);
 839    rec->data_len = i;
 840    sm_check(__FILE__, __LINE__, False);
 841    if (!write_record_to_block(block, rec)) {
 842       Pmsg0(0, _("Error writing record to block.\n"));
 843       goto bail_out;
 844    }
 845    if (!write_block_to_dev(jcr, dev, block)) {
 846       Pmsg0(0, _("Error writing block to device.\n"));
 847       goto bail_out;
 848    } else {
 849       Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
 850    }
 851    Pmsg0(0, _("Wrote block to device.\n"));
 852
 853 bail_out:
 854    sm_check(__FILE__, __LINE__, False);
 855    free_record(rec);
 856    free_block(block);
 857    sm_check(__FILE__, __LINE__, False);
 858 }
 859
 860 /*
 861  * Read a record from the tape
 862  */
 863 static void rrcmd()
 864 {
 865    char *buf;
 866    int stat, len;
 867
 868    if (!get_cmd("Enter length to read: ")) {
 869       return;
 870    }
 871    len = atoi(cmd);
 872    if (len < 0 || len > 1000000) {
 873       Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
 874       len = 1024;
 875    }
 876    buf = (char *)malloc(len);
 877    stat = read(dev->fd, buf, len);
 878    if (stat > 0 && stat <= len) {
 879       errno = 0;
 880    }
 881    Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
 882       len, stat, strerror(errno));
 883    free(buf);
 884 }
 885
 886
 887 /*
 888  * Scan tape by reading block by block. Report what is
 889  * on the tape.  Note, this command does raw reads, and as such
 890  * will not work with fixed block size devices.
 891  */
 892 static void scancmd()
 893 {
 894    int stat;
 895    int blocks, tot_blocks, tot_files;
 896    int block_size;
 897    uint64_t bytes;
 898    char ec1[50];
 899
 900
 901    blocks = block_size = tot_blocks = 0;
 902    bytes = 0;
 903    if (dev->state & ST_EOT) {
 904       Pmsg0(0, "End of tape\n");
 905       return;
 906    }
 907    update_pos_dev(dev);
 908    tot_files = dev->file;
 909    Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
 910    for (;;) {
 911       if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
 912          clrerror_dev(dev, -1);
 913          Mmsg2(&dev->errmsg, "read error on %s. ERR=%s.\n",
 914             dev->dev_name, strerror(dev->dev_errno));
 915          Pmsg2(0, "Bad status from read %d. ERR=%s\n", stat, strerror_dev(dev));
 916          if (blocks > 0)
 917             printf("%d block%s of %d bytes in file %d\n",
 918                     blocks, blocks>1?"s":"", block_size, dev->file);
 919          return;
 920       }
 921       Dmsg1(200, "read status = %d\n", stat);
 922 /*    sleep(1); */
 923       if (stat != block_size) {
 924          update_pos_dev(dev);
 925          if (blocks > 0) {
 926             printf("%d block%s of %d bytes in file %d\n",
 927                  blocks, blocks>1?"s":"", block_size, dev->file);
 928             blocks = 0;
 929          }
 930          block_size = stat;
 931       }
 932       if (stat == 0) {                /* EOF */
 933          update_pos_dev(dev);
 934          printf("End of File mark.\n");
 935          /* Two reads of zero means end of tape */
 936          if (dev->state & ST_EOF)
 937             dev->state |= ST_EOT;
 938          else {
 939             dev->state |= ST_EOF;
 940             dev->file++;
 941          }
 942          if (dev->state & ST_EOT) {
 943             printf("End of tape\n");
 944             break;
 945          }
 946       } else {                        /* Got data */
 947          dev->state &= ~ST_EOF;
 948          blocks++;
 949          tot_blocks++;
 950          bytes += stat;
 951       }
 952    }
 953    update_pos_dev(dev);
 954    tot_files = dev->file - tot_files;
 955    printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks,
 956       edit_uint64_with_commas(bytes, ec1));
 957 }
 958
 959
 960 /*
 961  * Scan tape by reading Bacula block by block. Report what is
 962  * on the tape.  This function reads Bacula blocks, so if your
 963  * Device resource is correctly defined, it should work with
 964  * either variable or fixed block sizes.
 965  */
 966 static void scan_blocks()
 967 {
 968    int blocks, tot_blocks, tot_files;
 969    uint32_t block_size;
 970    uint64_t bytes;
 971    DEV_BLOCK *block;
 972    char ec1[50];
 973
 974    block = new_block(dev);
 975    blocks = block_size = tot_blocks = 0;
 976    bytes = 0;
 977
 978    update_pos_dev(dev);
 979    tot_files = dev->file;
 980    for (;;) {
 981       if (!read_block_from_device(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
 982          Dmsg1(100, "!read_block(): ERR=%s\n", strerror_dev(dev));
 983          if (dev->state & ST_EOT) {
 984             if (blocks > 0) {
 985                printf("%d block%s of %d bytes in file %d\n",
 986                     blocks, blocks>1?"s":"", block_size, dev->file);
 987                blocks = 0;
 988             }
 989             goto bail_out;
 990          }
 991          if (dev->state & ST_EOF) {
 992             if (blocks > 0) {
 993                printf("%d block%s of %d bytes in file %d\n",
 994                        blocks, blocks>1?"s":"", block_size, dev->file);
 995                blocks = 0;
 996             }
 997             printf(_("End of File mark.\n"));
 998             continue;
 999          }
1000          if (dev->state & ST_SHORT) {
1001             if (blocks > 0) {
1002                printf("%d block%s of %d bytes in file %d\n",
1003                        blocks, blocks>1?"s":"", block_size, dev->file);
1004                blocks = 0;
1005             }
1006             printf(_("Short block read.\n"));
1007             continue;
1008          }
1009          printf(_("Error reading block. ERR=%s\n"), strerror_dev(dev));
1010          goto bail_out;
1011       }
1012       if (block->block_len != block_size) {
1013          if (blocks > 0) {
1014             printf("%d block%s of %d bytes in file %d\n",
1015                     blocks, blocks>1?"s":"", block_size, dev->file);
1016             blocks = 0;
1017          }
1018          block_size = block->block_len;
1019       }
1020       blocks++;
1021       tot_blocks++;
1022       bytes += block->block_len;
1023       Dmsg5(100, "Blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1024          block->BlockNumber, block->block_len, block->BlockVer,
1025          block->VolSessionId, block->VolSessionTime);
1026       if (verbose == 1) {
1027          DEV_RECORD *rec = new_record();
1028          read_record_from_block(block, rec);
1029          Pmsg7(-1, "Block: %u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n",
1030               block->BlockNumber, block->block_len,
1031               FI_to_ascii(rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1032               stream_to_ascii(rec->Stream, rec->FileIndex), rec->data_len);
1033          rec->remainder = 0;
1034          free_record(rec);
1035       } else if (verbose > 1) {
1036          dump_block(block, "");
1037       }
1038
1039    }
1040 bail_out:
1041    free_block(block);
1042    tot_files = dev->file - tot_files;
1043    printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks,
1044       edit_uint64_with_commas(bytes, ec1));
1045 }
1046
1047
1048 static void statcmd()
1049 {
1050    int stat = 0;
1051    int debug;
1052    uint32_t status;
1053
1054    debug = debug_level;
1055    debug_level = 30;
1056    if (!status_dev(dev, &status)) {
1057       Pmsg2(0, "Bad status from status %d. ERR=%s\n", stat, strerror_dev(dev));
1058    }
1059 #ifdef xxxx
1060    dump_volume_label(dev);
1061 #endif
1062    debug_level = debug;
1063 }
1064
1065
1066 /*
1067  * First we label the tape, then we fill
1068  *  it with data get a new tape and write a few blocks.
1069  */
1070 static void fillcmd()
1071 {
1072    DEV_RECORD rec;
1073    DEV_BLOCK  *block;
1074    char ec1[50];
1075
1076    ok = TRUE;
1077    stop = 0;
1078    vol_num = 0;
1079
1080    Pmsg0(-1, "\n\
1081 This command simulates Bacula writing to a tape.\n\
1082 It requires either one or two blank tapes, which it\n\
1083 will label and write. It will print a status approximately\n\
1084 every 322 MB, and write an EOF every 3.2 GB.  If you have\n\
1085 selected the simple test option, after writing the first tape\n\
1086 it will rewind it and re-read the last block written.\n\
1087 If you have selected the multiple tape test, when the first tape\n\
1088 fills, it will ask for a second, and after writing a few more \n\
1089 blocks, it will stop.  Then it will begin re-reading the\n\
1090 two tapes.\n\n\
1091 This may take a long time -- hours! ...\n\n");
1092
1093    get_cmd("Insert a blank tape then indicate if you want\n"
1094            "to run the simplified test (s) with one tape or\n"
1095            "the complete multiple tape (m) test: (s/m) ");
1096    if (cmd[0] == 's') {
1097       Pmsg0(-1, "Simple test (single tape) selected.\n");
1098       simple = TRUE;
1099    } else if (cmd[0] == 'm') {
1100       Pmsg0(-1, "Complete multiple tape test selected.\n");
1101       simple = FALSE;
1102    } else {
1103       Pmsg0(000, "Command aborted.\n");
1104       return;
1105    }
1106
1107    set_volume_name("TestVolume1", 1);
1108    labelcmd();
1109    VolumeName = NULL;
1110
1111
1112    Dmsg1(20, "Begin append device=%s\n", dev_name(dev));
1113
1114    block = new_block(dev);
1115
1116    /*
1117     * Acquire output device for writing.  Note, after acquiring a
1118     *   device, we MUST release it, which is done at the end of this
1119     *   subroutine.
1120     */
1121    Dmsg0(100, "just before acquire_device\n");
1122    if (!(dev=acquire_device_for_append(jcr, dev, block))) {
1123       set_jcr_job_status(jcr, JS_ErrorTerminated);
1124       free_block(block);
1125       return;
1126    }
1127
1128    Dmsg0(100, "Just after acquire_device_for_append\n");
1129    /*
1130     * Write Begin Session Record
1131     */
1132    if (!write_session_label(jcr, block, SOS_LABEL)) {
1133       set_jcr_job_status(jcr, JS_ErrorTerminated);
1134       Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1135          strerror_dev(dev));
1136       ok = FALSE;
1137    }
1138    Pmsg0(-1, "Wrote Start Of Session label.\n");
1139
1140    memset(&rec, 0, sizeof(rec));
1141    rec.data = get_memory(100000);     /* max record size */
1142
1143 #define REC_SIZE 32768
1144    rec.data_len = REC_SIZE;
1145
1146    /*
1147     * Generate data as if from File daemon, write to device
1148     */
1149    jcr->VolFirstIndex = 0;
1150    time(&jcr->run_time);              /* start counting time for rates */
1151    Pmsg0(-1, "Begin writing records to first tape ...\n");
1152    for (file_index = 0; ok && !job_canceled(jcr); ) {
1153       rec.VolSessionId = jcr->VolSessionId;
1154       rec.VolSessionTime = jcr->VolSessionTime;
1155       rec.FileIndex = ++file_index;
1156       rec.Stream = STREAM_FILE_DATA;
1157
1158       /*
1159        * Fill the buffer with the file_index negated. Negation ensures that
1160        *   more bits are turned on.
1161        */
1162       uint64_t *lp = (uint64_t *)rec.data;
1163       for (uint32_t i=0; i < (rec.data_len-sizeof(uint64_t))/sizeof(uint64_t); i++) {
1164          *lp++ = ~file_index;
1165       }
1166
1167       Dmsg4(250, "before writ_rec FI=%d SessId=%d Strm=%s len=%d\n",
1168          rec.FileIndex, rec.VolSessionId, stream_to_ascii(rec.Stream, rec.FileIndex),
1169          rec.data_len);
1170
1171       while (!write_record_to_block(block, &rec)) {
1172          /*
1173           * When we get here we have just filled a block
1174           */
1175          Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1176                     rec.remainder);
1177
1178          /* Write block to tape */
1179          if (!flush_block(block, 1)) {
1180             return;
1181          }
1182
1183          /* Every 5000 blocks (approx 322MB) report where we are.
1184           */
1185          if ((block->BlockNumber % 5000) == 0) {
1186             now = time(NULL);
1187             now -= jcr->run_time;
1188             if (now <= 0) {
1189                now = 1;
1190             }
1191             kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1192             Pmsg3(-1, "Wrote block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
1193                edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1194          }
1195          /* Every 15000 blocks (approx 1GB) write an EOF.
1196           */
1197          if ((block->BlockNumber % 15000) == 0) {
1198             Pmsg0(-1, "Flush block, write EOF\n");
1199             flush_block(block, 0);
1200             weof_dev(dev, 1);
1201          }
1202
1203          /* Get out after writing 10 blocks to the second tape */
1204          if (++BlockNumber > 10 && stop != 0) {      /* get out */
1205             break;
1206          }
1207       }
1208       if (!ok) {
1209          Pmsg0(000, _("Not OK\n"));
1210          break;
1211       }
1212       jcr->JobBytes += rec.data_len;   /* increment bytes this job */
1213       Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1214          FI_to_ascii(rec.FileIndex), rec.VolSessionId,
1215          stream_to_ascii(rec.Stream, rec.FileIndex), rec.data_len);
1216
1217       /* Get out after writing 10 blocks to the second tape */
1218       if (BlockNumber > 10 && stop != 0) {      /* get out */
1219          Pmsg0(-1, "Done writing ...\n");
1220          break;
1221       }
1222    }
1223    if (stop > 0) {
1224       Dmsg0(100, "Write_end_session_label()\n");
1225       /* Create Job status for end of session label */
1226       if (!job_canceled(jcr) && ok) {
1227          set_jcr_job_status(jcr, JS_Terminated);
1228       } else if (!ok) {
1229          set_jcr_job_status(jcr, JS_ErrorTerminated);
1230       }
1231       if (!write_session_label(jcr, block, EOS_LABEL)) {
1232          Pmsg1(000, _("Error writting end session label. ERR=%s\n"), strerror_dev(dev));
1233          ok = FALSE;
1234       }
1235       /* Write out final block of this session */
1236       if (!write_block_to_device(jcr, dev, block)) {
1237          Pmsg0(-1, _("Set ok=FALSE after write_block_to_device.\n"));
1238          ok = FALSE;
1239       }
1240       Pmsg0(-1, "Wrote End Of Session label.\n");
1241    }
1242
1243    /* Release the device */
1244    if (!release_device(jcr, dev)) {
1245       Pmsg0(-1, _("Error in release_device\n"));
1246       ok = FALSE;
1247    }
1248
1249    free_block(block);
1250    free_memory(rec.data);
1251    Pmsg0(-1, _("\n\nDone filling tape. Now beginning re-read of tape ...\n"));
1252
1253    dump_block(last_block, _("Last block written to tape.\n"));
1254
1255    unfillcmd();
1256 }
1257
1258 /*
1259  * Read two tapes written by the "fill" command and ensure
1260  *  that the data is valid.  If stop==1 we simulate full read back
1261  *  of two tapes.  If stop==-1 we simply read the last block and
1262  *  verify that it is correct.
1263  */
1264 static void unfillcmd()
1265 {
1266    DEV_BLOCK *block;
1267
1268    dumped = 0;
1269    VolBytes = 0;
1270    LastBlock = 0;
1271    block = new_block(dev);
1272
1273    dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
1274    dev->capabilities &= ~CAP_LABEL;   /* don't label anything here */
1275
1276    end_of_tape = 0;
1277
1278    if (!simple) {
1279       /* Close device so user can use autochanger if desired */
1280       if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1281          offline_dev(dev);
1282       }
1283       force_close_dev(dev);
1284       get_cmd(_("Mount first tape. Press enter when ready: "));
1285
1286       free_vol_list(jcr);
1287       set_volume_name("TestVolume1", 1);
1288       jcr->bsr = NULL;
1289       create_vol_list(jcr);
1290       close_dev(dev);
1291       dev->state &= ~ST_READ;
1292       if (!acquire_device_for_read(jcr, dev, block)) {
1293          Pmsg1(-1, "%s", dev->errmsg);
1294          return;
1295       }
1296    }
1297
1298    time(&jcr->run_time);              /* start counting time for rates */
1299    stop = 0;
1300    file_index = 0;
1301    if (!simple) {
1302       /* Read all records and then second tape */
1303       read_records(jcr, dev, record_cb, my_mount_next_read_volume);
1304    } else {
1305       /*
1306        * Simplified test, we simply fsf to file, then read the
1307        * last block and make sure it is the same as the saved block.
1308        */
1309       Pmsg0(000, "Rewinding tape ...\n");
1310       if (!rewind_dev(dev)) {
1311          Pmsg1(-1, _("Error rewinding: ERR=%s\n"), strerror_dev(dev));
1312          goto bail_out;
1313       }
1314       if (last_file > 0) {
1315          Pmsg1(000, "Forward spacing to last file=%u\n", last_file);
1316          if (!fsf_dev(dev, last_file)) {
1317             Pmsg1(-1, _("Error in FSF: ERR=%s\n"), strerror_dev(dev));
1318             goto bail_out;
1319          }
1320       }
1321       Pmsg1(-1, _("Forward space to file %u complete. Reading blocks ...\n"),
1322             last_file);
1323       Pmsg1(-1, _("Now reading to block %u.\n"), last_block_num);
1324       for (uint32_t i=0; i <= last_block_num; i++) {
1325          if (!read_block_from_device(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
1326             Pmsg1(-1, _("Error reading blocks: ERR=%s\n"), strerror_dev(dev));
1327             Pmsg2(-1, _("Wanted block %u error at block %u\n"), last_block_num, i);
1328             goto bail_out;
1329          }
1330          if (i > 0 && i % 1000 == 0) {
1331             Pmsg1(-1, _("At block %u\n"), i);
1332          }
1333       }
1334       if (last_block) {
1335          dump_block(last_block, _("Last block written"));
1336          dump_block(block, _("Block read back"));
1337          Pmsg0(-1, _("Except for the buffer address, the contents of\n"
1338                      "the above two block dumps should be the same.\n"
1339                      "If not you have a problem ...\n"));
1340       }
1341    }
1342
1343 bail_out:
1344    free_block(block);
1345
1346    Pmsg0(000, _("Done with reread of fill data.\n"));
1347 }
1348
1349 /*
1350  * We are called here from "unfill" for each record on the tape.
1351  */
1352 static int record_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec)
1353 {
1354    SESSION_LABEL label;
1355
1356    if (stop > 1 && !dumped) {         /* on second tape */
1357       dumped = 1;
1358       dump_block(block, "First block on second tape");
1359       Pmsg4(-1, "Blk: FileIndex=%d: block=%u size=%d vol=%s\n",
1360            rec->FileIndex, block->BlockNumber, block->block_len, dev->VolHdr.VolName);
1361       Pmsg6(-1, "   Rec: VId=%d VT=%d FI=%s Strm=%s len=%d state=%x\n",
1362            rec->VolSessionId, rec->VolSessionTime,
1363            FI_to_ascii(rec->FileIndex), stream_to_ascii(rec->Stream, rec->FileIndex),
1364            rec->data_len, rec->state);
1365    }
1366    if (rec->FileIndex < 0) {
1367       if (verbose > 1) {
1368          dump_label_record(dev, rec, 1);
1369       }
1370       switch (rec->FileIndex) {
1371       case PRE_LABEL:
1372          Pmsg0(-1, "Volume is prelabeled. This tape cannot be scanned.\n");
1373          return 1;;
1374       case VOL_LABEL:
1375          unser_volume_label(dev, rec);
1376          Pmsg3(-1, "VOL_LABEL: block=%u size=%d vol=%s\n", block->BlockNumber,
1377             block->block_len, dev->VolHdr.VolName);
1378          stop++;
1379          break;
1380       case SOS_LABEL:
1381          unser_session_label(&label, rec);
1382          Pmsg1(-1, "SOS_LABEL: JobId=%u\n", label.JobId);
1383          break;
1384       case EOS_LABEL:
1385          unser_session_label(&label, rec);
1386          Pmsg2(-1, "EOS_LABEL: block=%u JobId=%u\n", block->BlockNumber,
1387             label.JobId);
1388          break;
1389       case EOM_LABEL:
1390          Pmsg0(-1, "EOM_LABEL:\n");
1391          break;
1392       case EOT_LABEL:              /* end of all tapes */
1393          char ec1[50];
1394
1395          if (LastBlock != block->BlockNumber) {
1396             VolBytes += block->block_len;
1397          }
1398          LastBlock = block->BlockNumber;
1399          now = time(NULL);
1400          now -= jcr->run_time;
1401          if (now <= 0) {
1402             now = 1;
1403          }
1404          kbs = (double)VolBytes / (1000 * now);
1405          Pmsg3(000, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
1406                   edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
1407
1408          Pmsg0(000, "End of all tapes.\n");
1409
1410          break;
1411       default:
1412          break;
1413       }
1414       return 1;
1415    }
1416    if (++file_index != rec->FileIndex) {
1417       Pmsg3(000, "Incorrect FileIndex in Block %u. Got %d, expected %d.\n",
1418          block->BlockNumber, rec->FileIndex, file_index);
1419    }
1420    /*
1421     * Now check that the right data is in the record.
1422     */
1423    uint64_t *lp = (uint64_t *)rec->data;
1424    uint64_t val = ~file_index;
1425    for (uint32_t i=0; i < (REC_SIZE-sizeof(uint64_t))/sizeof(uint64_t); i++) {
1426       if (*lp++ != val) {
1427          Pmsg2(000, "Record %d contains bad data in Block %u.\n",
1428             file_index, block->BlockNumber);
1429          break;
1430       }
1431    }
1432
1433    if (LastBlock != block->BlockNumber) {
1434       VolBytes += block->block_len;
1435    }
1436    if ((block->BlockNumber != LastBlock) && (block->BlockNumber % 50000) == 0) {
1437       char ec1[50];
1438       now = time(NULL);
1439       now -= jcr->run_time;
1440       if (now <= 0) {
1441          now = 1;
1442       }
1443       kbs = (double)VolBytes / (1000 * now);
1444       Pmsg3(000, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
1445                edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
1446    }
1447    LastBlock = block->BlockNumber;
1448    if (end_of_tape) {
1449       Pmsg1(000, "End of all blocks. Block=%u\n", block->BlockNumber);
1450    }
1451    return 1;
1452 }
1453
1454
1455
1456 /*
1457  * Write current block to tape regardless of whether or
1458  *   not it is full. If the tape fills, attempt to
1459  *   acquire another tape.
1460  */
1461 static int flush_block(DEV_BLOCK *block, int dump)
1462 {
1463    char ec1[50];
1464    lock_device(dev);
1465    DEV_BLOCK *tblock;
1466    uint32_t this_file, this_block_num;
1467
1468    if (!this_block) {
1469       this_block = new_block(dev);
1470    }
1471    /* Copy block */
1472    free_memory(this_block->buf);
1473    memcpy(this_block, block, sizeof(DEV_BLOCK));
1474    this_block->buf = get_memory(block->buf_len);
1475    memcpy(this_block->buf, block->buf, this_block->buf_len);
1476    this_file = dev->file;
1477    this_block_num = dev->block_num;
1478    if (!write_block_to_dev(jcr, dev, block)) {
1479       Pmsg0(000, strerror_dev(dev));
1480       Pmsg3(000, "Block not written: FileIndex=%u Block=%u Size=%u\n",
1481          (unsigned)file_index, block->BlockNumber, block->block_len);
1482       Pmsg2(000, "last_block_num=%u this_block_num=%d\n", last_block_num,
1483          this_block_num);
1484       if (dump) {
1485          dump_block(block, "Block not written");
1486       }
1487       if (stop == 0) {
1488          eot_block = block->BlockNumber;
1489          eot_block_len = block->block_len;
1490          eot_FileIndex = file_index;
1491       }
1492       now = time(NULL);
1493       now -= jcr->run_time;
1494       if (now <= 0) {
1495          now = 1;
1496       }
1497       kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
1498       vol_size = dev->VolCatInfo.VolCatBytes;
1499       Pmsg2(000, "End of tape. VolumeCapacity=%s. Write rate = %.1f KB/s\n",
1500          edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
1501
1502       if (simple) {
1503          stop = -1;                   /* stop, but do simplified test */
1504       } else {
1505          /* Full test in progress */
1506          if (!fixup_device_block_write_error(jcr, dev, block)) {
1507             Pmsg1(000, _("Cannot fixup device error. %s\n"), strerror_dev(dev));
1508             ok = FALSE;
1509             unlock_device(dev);
1510             return 0;
1511          }
1512          stop = 1;
1513          BlockNumber = 0;             /* start counting for second tape */
1514       }
1515       unlock_device(dev);
1516       return 1;                       /* end of tape reached */
1517    }
1518
1519    /*
1520     * Toggle between two allocated blocks for efficiency.
1521     * Switch blocks so that the block just successfully written is
1522     *  always in last_block.
1523     */
1524    tblock = last_block;
1525    last_block = this_block;
1526    this_block = tblock;
1527    last_file = this_file;
1528    last_block_num = this_block_num;
1529
1530    unlock_device(dev);
1531    return 1;
1532 }
1533
1534
1535 /*
1536  * First we label the tape, then we fill
1537  *  it with data get a new tape and write a few blocks.
1538  */
1539 static void qfillcmd()
1540 {
1541    DEV_BLOCK *block;
1542    DEV_RECORD *rec;
1543    int i, count;
1544
1545    Pmsg0(0, "Test writing blocks of 64512 bytes to tape.\n");
1546
1547    get_cmd("How many blocks do you want to write? (1000): ");
1548
1549    count = atoi(cmd);
1550    if (count <= 0) {
1551       count = 1000;
1552    }
1553
1554    sm_check(__FILE__, __LINE__, False);
1555    block = new_block(dev);
1556    rec = new_record();
1557
1558    i = block->buf_len - 100;
1559    ASSERT (i > 0);
1560    rec->data = check_pool_memory_size(rec->data, i);
1561    memset(rec->data, i & 0xFF, i);
1562    rec->data_len = i;
1563    rewindcmd();
1564    Pmsg1(0, "Begin writing %d blocks to tape ...\n", count);
1565    for (i=0; i < count; i++) {
1566       if (i % 100 == 0) {
1567          printf("+");
1568       }
1569       if (!write_record_to_block(block, rec)) {
1570          Pmsg0(0, _("Error writing record to block.\n"));
1571          goto bail_out;
1572       }
1573       if (!write_block_to_dev(jcr, dev, block)) {
1574          Pmsg0(0, _("Error writing block to device.\n"));
1575          goto bail_out;
1576       }
1577    }
1578    printf("\n");
1579    weofcmd();
1580    weofcmd();
1581    rewindcmd();
1582    scan_blocks();
1583
1584 bail_out:
1585    sm_check(__FILE__, __LINE__, False);
1586    free_record(rec);
1587    free_block(block);
1588    sm_check(__FILE__, __LINE__, False);
1589
1590 }
1591
1592 static void rawfill_cmd()
1593 {
1594    DEV_BLOCK *block;
1595    int stat;
1596    int fd;
1597    uint32_t block_num = 0;
1598    uint32_t *p;
1599    int my_errno;
1600
1601    block = new_block(dev);
1602    fd = open("/dev/urandom", O_RDONLY);
1603    if (fd) {
1604       read(fd, block->buf, block->buf_len);
1605    } else {
1606       Pmsg0(0, "Cannot open /dev/urandom.\n");
1607       free_block(block);
1608       return;
1609    }
1610    p = (uint32_t *)block->buf;
1611    Pmsg1(0, "Begin writing blocks of %u bytes.\n", block->buf_len);
1612    for ( ;; ) {
1613       *p = block_num;
1614       stat = write(dev->fd, block->buf, block->buf_len);
1615       if (stat == (int)block->buf_len) {
1616          if ((block_num++ % 100) == 0) {
1617             printf("+");
1618          }
1619          continue;
1620       }
1621       break;
1622    }
1623    my_errno = errno;
1624    printf("\n");
1625    weofcmd();
1626    printf("Write failed at block %u. stat=%d ERR=%s\n", block_num, stat,
1627       strerror(my_errno));
1628    free_block(block);
1629
1630 }
1631
1632 struct cmdstruct { char *key; void (*func)(); char *help; };
1633 static struct cmdstruct commands[] = {
1634  {"bsf",        bsfcmd,       "backspace file"},
1635  {"bsr",        bsrcmd,       "backspace record"},
1636  {"cap",        capcmd,       "list device capabilities"},
1637  {"clear",      clearcmd,     "clear tape errors"},
1638  {"eod",        eodcmd,       "go to end of Bacula data for append"},
1639  {"eom",        eomcmd,       "go to the physical end of medium"},
1640  {"fill",       fillcmd,      "fill tape, write onto second volume"},
1641  {"unfill",     unfillcmd,    "read filled tape"},
1642  {"fsf",        fsfcmd,       "forward space a file"},
1643  {"fsr",        fsrcmd,       "forward space a record"},
1644  {"help",       helpcmd,      "print this command"},
1645  {"label",      labelcmd,     "write a Bacula label to the tape"},
1646  {"load",       loadcmd,      "load a tape"},
1647  {"quit",       quitcmd,      "quit btape"},
1648  {"rawfill",    rawfill_cmd,  "use write() to fill tape"},
1649  {"readlabel",  readlabelcmd, "read and print the Bacula tape label"},
1650  {"rectest",    rectestcmd,   "test record handling functions"},
1651  {"rewind",     rewindcmd,    "rewind the tape"},
1652  {"scan",       scancmd,      "read() tape block by block to EOT and report"},
1653  {"scanblocks", scan_blocks,  "Bacula read block by block to EOT and report"},
1654  {"status",     statcmd,      "print tape status"},
1655  {"test",       testcmd,      "General test Bacula tape functions"},
1656  {"weof",       weofcmd,      "write an EOF on the tape"},
1657  {"wr",         wrcmd,        "write a single Bacula block"},
1658  {"rr",         rrcmd,        "read a single record"},
1659  {"qfill",      qfillcmd,     "quick fill command"},
1660              };
1661 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
1662
1663 static void
1664 do_tape_cmds()
1665 {
1666    unsigned int i;
1667    int found;
1668
1669    while (get_cmd("*")) {
1670       sm_check(__FILE__, __LINE__, False);
1671       found = 0;
1672       for (i=0; i<comsize; i++)       /* search for command */
1673          if (fstrsch(cmd,  commands[i].key)) {
1674             (*commands[i].func)();    /* go execute command */
1675             found = 1;
1676             break;
1677          }
1678       if (!found)
1679          Pmsg1(0, _("%s is an illegal command\n"), cmd);
1680       if (quit)
1681          break;
1682    }
1683 }
1684
1685 static void helpcmd()
1686 {
1687    unsigned int i;
1688    usage();
1689    printf(_("  Command    Description\n  =======    ===========\n"));
1690    for (i=0; i<comsize; i++)
1691       printf("  %-10s %s\n", commands[i].key, commands[i].help);
1692    printf("\n");
1693 }
1694
1695 static void usage()
1696 {
1697    fprintf(stderr, _(
1698 "\nVersion: " VERSION " (" BDATE ")\n\n"
1699 "Usage: btape [-c config_file] [-d debug_level] [device_name]\n"
1700 "       -c <file>   set configuration file to file\n"
1701 "       -dnn        set debug level to nn\n"
1702 "       -s          turn off signals\n"
1703 "       -t          open the default tape device\n"
1704 "       -?          print this message.\n"
1705 "\n"));
1706
1707 }
1708
1709 /*
1710  * Get next input command from terminal.  This
1711  * routine is REALLY primitive, and should be enhanced
1712  * to have correct backspacing, etc.
1713  */
1714 int
1715 get_cmd(char *prompt)
1716 {
1717    int i = 0;
1718    int ch;
1719    fprintf(stdout, prompt);
1720
1721    /* We really should turn off echoing and pretty this
1722     * up a bit.
1723     */
1724    cmd[i] = 0;
1725    while ((ch = fgetc(stdin)) != EOF) {
1726       if (ch == '\n') {
1727          strip_trailing_junk(cmd);
1728          return 1;
1729       } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
1730          if (i > 0)
1731             cmd[--i] = 0;
1732          continue;
1733       }
1734
1735       cmd[i++] = ch;
1736       cmd[i] = 0;
1737    }
1738    quit = 1;
1739    return 0;
1740 }
1741
1742 /* Dummies to replace askdir.c */
1743 int     dir_get_volume_info(JCR *jcr, enum get_vol_info_rw  writing) { return 1;}
1744 int     dir_update_volume_info(JCR *jcr, VOLUME_CAT_INFO *vol, int relabel) { return 1; }
1745 int     dir_create_jobmedia_record(JCR *jcr) { return 1; }
1746 int     dir_update_file_attributes(JCR *jcr, DEV_RECORD *rec) { return 1;}
1747 int     dir_send_job_status(JCR *jcr) {return 1;}
1748
1749
1750
1751 int     dir_find_next_appendable_volume(JCR *jcr)
1752 {
1753    return 1;
1754 }
1755
1756 int dir_ask_sysop_to_mount_volume(JCR *jcr, DEVICE *dev)
1757 {
1758    /* Close device so user can use autochanger if desired */
1759    if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1760       offline_dev(dev);
1761    }
1762    force_close_dev(dev);
1763    Pmsg1(-1, "%s", dev->errmsg);           /* print reason */
1764    fprintf(stderr, "Mount Volume \"%s\" on device %s and press return when ready: ",
1765       jcr->VolumeName, dev_name(dev));
1766    getchar();
1767    return 1;
1768 }
1769
1770 int dir_ask_sysop_to_mount_next_volume(JCR *jcr, DEVICE *dev)
1771 {
1772    /* Close device so user can use autochanger if desired */
1773    if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1774       offline_dev(dev);
1775    }
1776    force_close_dev(dev);
1777    fprintf(stderr, "Mount next Volume on device %s and press return when ready: ",
1778       dev_name(dev));
1779    getchar();
1780    set_volume_name("TestVolume2", 2);
1781    labelcmd();
1782    VolumeName = NULL;
1783    BlockNumber = 0;
1784    stop = 1;
1785    return 1;
1786 }
1787
1788 static int my_mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block)
1789 {
1790    char ec1[50];
1791
1792    Pmsg1(000, "End of Volume \"%s\"\n", jcr->VolumeName);
1793
1794    if (LastBlock != block->BlockNumber) {
1795       VolBytes += block->block_len;
1796    }
1797    LastBlock = block->BlockNumber;
1798    now = time(NULL);
1799    now -= jcr->run_time;
1800    if (now <= 0) {
1801       now = 1;
1802    }
1803    kbs = (double)VolBytes / (1000.0 * (double)now);
1804    Pmsg3(-1, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
1805             edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
1806
1807    if (strcmp(jcr->VolumeName, "TestVolume2") == 0) {
1808       end_of_tape = 1;
1809       return 0;
1810    }
1811
1812    free_vol_list(jcr);
1813    set_volume_name("TestVolume2", 2);
1814    jcr->bsr = NULL;
1815    create_vol_list(jcr);
1816    close_dev(dev);
1817    dev->state &= ~ST_READ;
1818    if (!acquire_device_for_read(jcr, dev, block)) {
1819       Pmsg2(0, "Cannot open Dev=%s, Vol=%s\n", dev_name(dev), jcr->VolumeName);
1820       return 0;
1821    }
1822    return 1;                       /* next volume mounted */
1823 }
1824
1825 static void set_volume_name(char *VolName, int volnum)
1826 {
1827    VolumeName = VolName;
1828    vol_num = volnum;
1829    pm_strcpy(&jcr->VolumeName, VolName);
1830    bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
1831 }