]> git.sur5r.net Git - bacula/bacula/blobdiff - bacula/src/stored/btape.c
Cleanup Python build so that Python is not dragged
[bacula/bacula] / bacula / src / stored / btape.c
index ff325d8cb0614aa2ab39be529412b0e634d128a3..60ea8d3c5eced9fc8f6eec66f9fe73f3fac02f59 100644 (file)
@@ -14,7 +14,7 @@
  *
  */
 /*
  *
  */
 /*
-   Copyright (C) 2000-2003 Kern Sibbald and John Walker
+   Copyright (C) 2000-2005 Kern Sibbald
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
@@ -36,6 +36,8 @@
 #include "bacula.h"
 #include "stored.h"
 
 #include "bacula.h"
 #include "stored.h"
 
+/* Dummy functions */
+int generate_daemon_event(JCR *jcr, const char *event) { return 1; }
 
 /* External subroutines */
 extern void free_config_resources();
 
 /* External subroutines */
 extern void free_config_resources();
@@ -45,11 +47,22 @@ int quit = 0;
 char buf[100000];
 int bsize = TAPE_BSIZE;
 char VolName[MAX_NAME_LENGTH];
 char buf[100000];
 int bsize = TAPE_BSIZE;
 char VolName[MAX_NAME_LENGTH];
+STORES *me = NULL;                    /* our Global resource */
+bool forge_on = false;                /* proceed inspite of I/O errors */
+pthread_mutex_t device_release_mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t wait_device_release = PTHREAD_COND_INITIALIZER;
+
+/*
+ * If you change the format of the state file,
+ *  increment this value
+ */
+static uint32_t btape_state_level = 2;
 
 DEVICE *dev = NULL;
 
 DEVICE *dev = NULL;
+DCR *dcr;
 DEVRES *device = NULL;
 
 DEVRES *device = NULL;
 
-           
+
 /* Forward referenced subroutines */
 static void do_tape_cmds();
 static void helpcmd();
 /* Forward referenced subroutines */
 static void do_tape_cmds();
 static void helpcmd();
@@ -64,117 +77,163 @@ static void qfillcmd();
 static void statcmd();
 static void unfillcmd();
 static int flush_block(DEV_BLOCK *block, int dump);
 static void statcmd();
 static void unfillcmd();
 static int flush_block(DEV_BLOCK *block, int dump);
-static void record_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec);
-static int my_mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block);
+static bool quickie_cb(DCR *dcr, DEV_RECORD *rec);
+static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block);
+static bool my_mount_next_read_volume(DCR *dcr);
 static void scan_blocks();
 static void scan_blocks();
-static void set_volume_name(char *VolName, int volnum);
+static void set_volume_name(const char *VolName, int volnum);
 static void rawfill_cmd();
 static void rawfill_cmd();
+static void bfill_cmd();
+static bool open_the_device();
+static void autochangercmd();
+static void do_unfill();
 
 
 /* Static variables */
 #define CONFIG_FILE "bacula-sd.conf"
 char *configfile;
 
 
 
 /* Static variables */
 #define CONFIG_FILE "bacula-sd.conf"
 char *configfile;
 
+#define MAX_CMD_ARGS 30
+static POOLMEM *cmd;
+static POOLMEM *args;
+static char *argk[MAX_CMD_ARGS];
+static char *argv[MAX_CMD_ARGS];
+static int argc;
+
+static int quickie_count = 0;
 static BSR *bsr = NULL;
 static BSR *bsr = NULL;
-static char cmd[1000];
 static int signals = TRUE;
 static int signals = TRUE;
-static int ok;
-static int stop;
+static bool ok;
+static int stop = 0;
 static uint64_t vol_size;
 static uint64_t VolBytes;
 static time_t now;
 static double kbs;
 static uint64_t vol_size;
 static uint64_t VolBytes;
 static time_t now;
 static double kbs;
-static long file_index;
+static int32_t file_index;
 static int end_of_tape = 0;
 static uint32_t LastBlock = 0;
 static uint32_t eot_block;
 static uint32_t eot_block_len;
 static uint32_t eot_FileIndex;
 static int dumped = 0;
 static int end_of_tape = 0;
 static uint32_t LastBlock = 0;
 static uint32_t eot_block;
 static uint32_t eot_block_len;
 static uint32_t eot_FileIndex;
 static int dumped = 0;
+static DEV_BLOCK *last_block1 = NULL;
+static DEV_BLOCK *last_block2 = NULL;
 static DEV_BLOCK *last_block = NULL;
 static DEV_BLOCK *this_block = NULL;
 static DEV_BLOCK *last_block = NULL;
 static DEV_BLOCK *this_block = NULL;
+static DEV_BLOCK *first_block = NULL;
+static uint32_t last_file1 = 0;
+static uint32_t last_file2 = 0;
 static uint32_t last_file = 0;
 static uint32_t last_file = 0;
+static uint32_t last_block_num1 = 0;
+static uint32_t last_block_num2 = 0;
 static uint32_t last_block_num = 0;
 static uint32_t BlockNumber = 0;
 static uint32_t last_block_num = 0;
 static uint32_t BlockNumber = 0;
-static int simple = FALSE;
+static bool simple = true;
 
 
-static char *VolumeName = NULL;
-static int vol_num;
+static const char *VolumeName = NULL;
+static int vol_num = 0;
 
 static JCR *jcr = NULL;
 
 
 static void usage();
 static void terminate_btape(int sig);
 
 static JCR *jcr = NULL;
 
 
 static void usage();
 static void terminate_btape(int sig);
-int get_cmd(char *prompt);
+int get_cmd(const char *prompt);
 
 
 /*********************************************************************
  *
 
 
 /*********************************************************************
  *
- *        Main Bacula Pool Creation Program
+ *         Main Bacula Pool Creation Program
  *
  */
  *
  */
-int main(int argc, char *argv[])
+int main(int margc, char *margv[])
 {
 {
-   int ch;
-   DEV_BLOCK *block;
+   int ch, i;
+   uint32_t x32, y32;
+   uint64_t x64, y64;
+   char buf[1000];
 
    /* Sanity checks */
 
    /* Sanity checks */
-   if (TAPE_BSIZE % DEV_BSIZE != 0 || TAPE_BSIZE / DEV_BSIZE == 0) {
+   if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
       Emsg2(M_ABORT, 0, "Tape block size (%d) not multiple of system size (%d)\n",
       Emsg2(M_ABORT, 0, "Tape block size (%d) not multiple of system size (%d)\n",
-        TAPE_BSIZE, DEV_BSIZE);
+         TAPE_BSIZE, B_DEV_BSIZE);
    }
    if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
       Emsg1(M_ABORT, 0, "Tape block size (%d) is not a power of 2\n", TAPE_BSIZE);
    }
    }
    if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
       Emsg1(M_ABORT, 0, "Tape block size (%d) is not a power of 2\n", TAPE_BSIZE);
    }
+   if (sizeof(off_t) < 8) {
+      Pmsg1(-1, "\n\n!!!! Warning large disk addressing disabled. off_t=%d should be 8 or more !!!!!\n\n\n",
+         sizeof(off_t));
+   }
+   x32 = 123456789;
+   bsnprintf(buf, sizeof(buf), "%u", x32);
+   i = bsscanf(buf, "%u", &y32);
+   if (i != 1 || x32 != y32) {
+      Pmsg3(-1, "32 bit printf/scanf problem. i=%d x32=%u y32=%u\n", i, x32, y32);
+      exit(1);
+   }
+   x64 = 123456789;
+   x64 = x64 << 32;
+   x64 += 123456789;
+   bsnprintf(buf, sizeof(buf), "%" llu, x64);
+   i = bsscanf(buf, "%llu", &y64);
+   if (i != 1 || x64 != y64) {
+      Pmsg3(-1, "64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n", i, x64, y64);
+      exit(1);
+   }
 
    printf("Tape block granularity is %d bytes.\n", TAPE_BSIZE);
 
    working_directory = "/tmp";
 
    printf("Tape block granularity is %d bytes.\n", TAPE_BSIZE);
 
    working_directory = "/tmp";
-   my_name_is(argc, argv, "btape");
+   my_name_is(margc, margv, "btape");
    init_msg(NULL, NULL);
 
    init_msg(NULL, NULL);
 
-   while ((ch = getopt(argc, argv, "b:c:d:sv?")) != -1) {
+   while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
       switch (ch) {
       switch (ch) {
-         case 'b':                    /* bootstrap file */
-           bsr = parse_bsr(NULL, optarg);
-//         dump_bsr(bsr);
-           break;
-
-         case 'c':                    /* specify config file */
-           if (configfile != NULL) {
-              free(configfile);
-           }
-           configfile = bstrdup(optarg);
-           break;
-
-         case 'd':                    /* set debug level */
-           debug_level = atoi(optarg);
-           if (debug_level <= 0) {
-              debug_level = 1; 
-           }
-           break;
-
-         case 's':
-           signals = FALSE;
-           break;
-
-         case 'v':
-           verbose++;
-           break;
-
-         case '?':
-        default:
-           helpcmd();
-           exit(0);
+      case 'b':                    /* bootstrap file */
+         bsr = parse_bsr(NULL, optarg);
+//       dump_bsr(bsr, true);
+         break;
+
+      case 'c':                    /* specify config file */
+         if (configfile != NULL) {
+            free(configfile);
+         }
+         configfile = bstrdup(optarg);
+         break;
+
+      case 'd':                    /* set debug level */
+         debug_level = atoi(optarg);
+         if (debug_level <= 0) {
+            debug_level = 1;
+         }
+         break;
+
+      case 'p':
+         forge_on = true;
+         break;
+
+      case 's':
+         signals = false;
+         break;
+
+      case 'v':
+         verbose++;
+         break;
+
+      case '?':
+      default:
+         helpcmd();
+         exit(0);
 
 
-      }  
+      }
    }
    }
-   argc -= optind;
-   argv += optind;
+   margc -= optind;
+   margv += optind;
 
 
+   cmd = get_pool_memory(PM_FNAME);
+   args = get_pool_memory(PM_FNAME);
 
 
-   
    if (signals) {
       init_signals(terminate_btape);
    }
    if (signals) {
       init_signals(terminate_btape);
    }
@@ -189,39 +248,32 @@ int main(int argc, char *argv[])
 
 
    /* See if we can open a device */
 
 
    /* See if we can open a device */
-   if (argc == 0) {
+   if (margc == 0) {
       Pmsg0(000, "No archive name specified.\n");
       usage();
       exit(1);
       Pmsg0(000, "No archive name specified.\n");
       usage();
       exit(1);
-   } else if (argc != 1) {
+   } else if (margc != 1) {
       Pmsg0(000, "Improper number of arguments specified.\n");
       usage();
       exit(1);
    }
 
       Pmsg0(000, "Improper number of arguments specified.\n");
       usage();
       exit(1);
    }
 
-   jcr = setup_jcr("btape", argv[0], bsr, NULL);
-   dev = setup_to_access_device(jcr, 0);     /* acquire for write */
+   jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
+   if (!jcr) {
+      exit(1);
+   }
+   dev = jcr->dcr->dev;
    if (!dev) {
       exit(1);
    }
    if (!dev) {
       exit(1);
    }
-   block = new_block(dev);
-   lock_device(dev);
-   if (!(dev->state & ST_OPENED)) {
-      Dmsg0(129, "Opening device.\n");
-      if (open_dev(dev, jcr->VolumeName, READ_WRITE) < 0) {
-         Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
-        unlock_device(dev);
-        free_block(block);
-        goto terminate;
-      }
+   dcr = jcr->dcr;
+   if (!open_the_device()) {
+      goto terminate;
    }
    }
-   Dmsg1(129, "open_dev %s OK\n", dev_name(dev));
-   unlock_device(dev);
-   free_block(block);
 
    Dmsg0(200, "Do tape commands\n");
    do_tape_cmds();
 
    Dmsg0(200, "Do tape commands\n");
    do_tape_cmds();
-  
+
 terminate:
    terminate_btape(0);
    return 0;
 terminate:
    terminate_btape(0);
    return 0;
@@ -230,127 +282,136 @@ terminate:
 static void terminate_btape(int stat)
 {
 
 static void terminate_btape(int stat)
 {
 
-   sm_check(__FILE__, __LINE__, False);
+   sm_check(__FILE__, __LINE__, false);
    if (configfile) {
       free(configfile);
    }
    free_config_resources();
    if (configfile) {
       free(configfile);
    }
    free_config_resources();
-
-   if (dev) {
-      term_dev(dev);
+   if (args) {
+      free_pool_memory(args);
+      args = NULL;
+   }
+   if (cmd) {
+      free_pool_memory(cmd);
+      cmd = NULL;
    }
 
    }
 
-   if (debug_level > 10)
-      print_memory_pool_stats(); 
+   if (bsr) {
+      free_bsr(bsr);
+   }
 
    free_jcr(jcr);
    jcr = NULL;
 
 
    free_jcr(jcr);
    jcr = NULL;
 
-   if (bsr) {
-      free_bsr(bsr);
+   if (dev) {
+      term_dev(dev);
    }
 
    }
 
-   if (last_block) {
-      free_block(last_block);
-   }
+   if (debug_level > 10)
+      print_memory_pool_stats();
+
    if (this_block) {
       free_block(this_block);
    }
 
    if (this_block) {
       free_block(this_block);
    }
 
+   stop_watchdog();
    term_msg();
    term_msg();
-   close_memory_pool();              /* free memory in pool */
+   close_memory_pool();               /* free memory in pool */
 
 
-   sm_dump(False);
+   sm_dump(false);
    exit(stat);
 }
 
    exit(stat);
 }
 
+static bool open_the_device()
+{
+   DEV_BLOCK *block;
+
+   block = new_block(dev);
+   lock_device(dev);
+   if (!dev->is_open()) {
+      Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
+      if (open_dev(dev, dcr->VolumeName, OPEN_READ_WRITE) < 0) {
+         Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
+         unlock_device(dev);
+         free_block(block);
+         return false;
+      }
+   }
+   Pmsg1(000, "open_dev %s OK\n", dev->print_name());
+   dev->set_append();                 /* put volume in append mode */
+   unlock_device(dev);
+   free_block(block);
+   return true;
+}
+
+
 void quitcmd()
 {
    quit = 1;
 }
 
 /*
 void quitcmd()
 {
    quit = 1;
 }
 
 /*
- * Write a label to the tape   
+ * Write a label to the tape
  */
 static void labelcmd()
 {
  */
 static void labelcmd()
 {
-   DEVRES *device;
-   int found = 0;
-
-   LockRes();
-   for (device=NULL; (device=(DEVRES *)GetNextRes(R_DEVICE, (RES *)device)); ) {
-      if (strcmp(device->device_name, dev->dev_name) == 0) {
-        jcr->device = device;        /* Arggg a bit of duplication here */
-        device->dev = dev;
-        dev->device = device;
-        found = 1;
-        break;
-      }
-   } 
-   UnlockRes();
-   if (!found) {
-      Pmsg2(0, "Could not find device %s in %s\n", dev->dev_name, configfile);
-      return;
-   }
-
    if (VolumeName) {
    if (VolumeName) {
-      strcpy(cmd, VolumeName);
+      pm_strcpy(cmd, VolumeName);
    } else {
       if (!get_cmd("Enter Volume Name: ")) {
    } else {
       if (!get_cmd("Enter Volume Name: ")) {
-        return;
+         return;
       }
    }
       }
    }
-        
-   if (!(dev->state & ST_OPENED)) {
-      if (!open_device(dev)) {
+
+   if (!dev->is_open()) {
+      if (!first_open_device(dev)) {
          Pmsg1(0, "Device open failed. ERR=%s\n", strerror_dev(dev));
       }
    }
          Pmsg1(0, "Device open failed. ERR=%s\n", strerror_dev(dev));
       }
    }
-   write_volume_label_to_dev(jcr, device, cmd, "Default");
+   rewind_dev(dev);
+   write_new_volume_label_to_dev(dcr, cmd, "Default");
+   Pmsg1(-1, "Wrote Volume label for volume \"%s\".\n", cmd);
 }
 
 /*
 }
 
 /*
- * Read the tape label  
+ * Read the tape label
  */
 static void readlabelcmd()
 {
    int save_debug_level = debug_level;
    int stat;
  */
 static void readlabelcmd()
 {
    int save_debug_level = debug_level;
    int stat;
-   DEV_BLOCK *block;
 
 
-   block = new_block(dev);
-   stat = read_dev_volume_label(jcr, dev, block);
+   stat = read_dev_volume_label(dcr);
    switch (stat) {
    switch (stat) {
-      case VOL_NO_LABEL:
-         Pmsg0(0, "Volume has no label.\n");
-        break;
-      case VOL_OK:
-         Pmsg0(0, "Volume label read correctly.\n");
-        break;
-      case VOL_IO_ERROR:
-         Pmsg1(0, "I/O error on device: ERR=%s", strerror_dev(dev));
-        break;
-      case VOL_NAME_ERROR:
-         Pmsg0(0, "Volume name error\n");
-        break;
-      case VOL_CREATE_ERROR:
-         Pmsg1(0, "Error creating label. ERR=%s", strerror_dev(dev));
-        break;
-      case VOL_VERSION_ERROR:
-         Pmsg0(0, "Volume version error.\n");
-        break;
-      case VOL_LABEL_ERROR:
-         Pmsg0(0, "Bad Volume label type.\n");
-        break;
-      default:
-         Pmsg0(0, "Unknown error.\n");
-        break;
+   case VOL_NO_LABEL:
+      Pmsg0(0, "Volume has no label.\n");
+      break;
+   case VOL_OK:
+      Pmsg0(0, "Volume label read correctly.\n");
+      break;
+   case VOL_IO_ERROR:
+      Pmsg1(0, "I/O error on device: ERR=%s", strerror_dev(dev));
+      break;
+   case VOL_NAME_ERROR:
+      Pmsg0(0, "Volume name error\n");
+      break;
+   case VOL_CREATE_ERROR:
+      Pmsg1(0, "Error creating label. ERR=%s", strerror_dev(dev));
+      break;
+   case VOL_VERSION_ERROR:
+      Pmsg0(0, "Volume version error.\n");
+      break;
+   case VOL_LABEL_ERROR:
+      Pmsg0(0, "Bad Volume label type.\n");
+      break;
+   default:
+      Pmsg0(0, "Unknown error.\n");
+      break;
    }
 
    debug_level = 20;
    }
 
    debug_level = 20;
-   dump_volume_label(dev); 
+   dump_volume_label(dev);
    debug_level = save_debug_level;
    debug_level = save_debug_level;
-   free_block(block);
 }
 
 
 }
 
 
@@ -364,11 +425,11 @@ static void loadcmd()
    if (!load_dev(dev)) {
       Pmsg1(0, "Bad status from load. ERR=%s\n", strerror_dev(dev));
    } else
    if (!load_dev(dev)) {
       Pmsg1(0, "Bad status from load. ERR=%s\n", strerror_dev(dev));
    } else
-      Pmsg1(0, "Loaded %s\n", dev_name(dev));
+      Pmsg1(0, "Loaded %s\n", dev->print_name());
 }
 
 /*
 }
 
 /*
- * Rewind the tape.   
+ * Rewind the tape.
  */
 static void rewindcmd()
 {
  */
 static void rewindcmd()
 {
@@ -376,12 +437,12 @@ static void rewindcmd()
       Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
       clrerror_dev(dev, -1);
    } else {
       Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
       clrerror_dev(dev, -1);
    } else {
-      Pmsg1(0, "Rewound %s\n", dev_name(dev));
+      Pmsg1(0, "Rewound %s\n", dev->print_name());
    }
 }
 
 /*
    }
 }
 
 /*
- * Clear any tape error   
+ * Clear any tape error
  */
 static void clearcmd()
 {
  */
 static void clearcmd()
 {
@@ -389,22 +450,29 @@ static void clearcmd()
 }
 
 /*
 }
 
 /*
- * Write and end of file on the tape   
+ * Write and end of file on the tape
  */
 static void weofcmd()
 {
    int stat;
  */
 static void weofcmd()
 {
    int stat;
+   int num = 1;
+   if (argc > 1) {
+      num = atoi(argk[1]);
+   }
+   if (num <= 0) {
+      num = 1;
+   }
 
 
-   if ((stat = weof_dev(dev, 1)) < 0) {
+   if ((stat = weof_dev(dev, num)) < 0) {
       Pmsg2(0, "Bad status from weof %d. ERR=%s\n", stat, strerror_dev(dev));
       return;
    } else {
       Pmsg2(0, "Bad status from weof %d. ERR=%s\n", stat, strerror_dev(dev));
       return;
    } else {
-      Pmsg1(0, "Wrote EOF to %s\n", dev_name(dev));
+      Pmsg3(0, "Wrote %d EOF%s to %s\n", num, num==1?"":"s", dev->print_name());
    }
 }
 
 
    }
 }
 
 
-/* Go to the end of the medium -- raw command  
+/* Go to the end of the medium -- raw command
  * The idea was orginally that the end of the Bacula
  * medium would be flagged differently. This is not
  * currently the case. So, this is identical to the
  * The idea was orginally that the end of the Bacula
  * medium would be flagged differently. This is not
  * currently the case. So, this is identical to the
@@ -413,7 +481,7 @@ static void weofcmd()
 static void eomcmd()
 {
    if (!eod_dev(dev)) {
 static void eomcmd()
 {
    if (!eod_dev(dev)) {
-      Pmsg1(0, _("Bad status from MTEOD. ERR=%s\n"), strerror_dev(dev));
+      Pmsg1(0, "%s", strerror_dev(dev));
       return;
    } else {
       Pmsg0(0, _("Moved to end of medium.\n"));
       return;
    } else {
       Pmsg0(0, _("Moved to end of medium.\n"));
@@ -430,45 +498,58 @@ static void eodcmd()
 }
 
 /*
 }
 
 /*
- * Backspace file   
+ * Backspace file
  */
 static void bsfcmd()
 {
  */
 static void bsfcmd()
 {
-   int stat;
+   int num = 1;
+   if (argc > 1) {
+      num = atoi(argk[1]);
+   }
+   if (num <= 0) {
+      num = 1;
+   }
 
 
-   if ((stat=bsf_dev(dev, 1)) < 0) {
-      Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), strerror(errno));
+   if (!bsf_dev(dev, num)) {
+      Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), strerror_dev(dev));
    } else {
    } else {
-      Pmsg0(0, _("Back spaced one file.\n"));
+      Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
    }
 }
 
 /*
    }
 }
 
 /*
- * Backspace record   
+ * Backspace record
  */
 static void bsrcmd()
 {
  */
 static void bsrcmd()
 {
-   int stat;
-
-   if ((stat=bsr_dev(dev, 1)) < 0) {
-      Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), strerror(errno));
+   int num = 1;
+   if (argc > 1) {
+      num = atoi(argk[1]);
+   }
+   if (num <= 0) {
+      num = 1;
+   }
+   if (!bsr_dev(dev, num)) {
+      Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), strerror_dev(dev));
    } else {
    } else {
-      Pmsg0(0, _("Back spaced one record.\n"));
+      Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
    }
 }
 
 /*
    }
 }
 
 /*
- * List device capabilities as defined in the 
+ * List device capabilities as defined in the
  *  stored.conf file.
  */
 static void capcmd()
 {
  *  stored.conf file.
  */
 static void capcmd()
 {
-   printf(_("Device capabilities:\n"));
+   printf(_("Configured device capabilities:\n"));
    printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
    printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
    printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
    printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
    printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
    printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
    printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
    printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
    printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
    printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
+   printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
+   printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
    printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
    printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
    printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
    printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
    printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
    printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
@@ -476,18 +557,19 @@ static void capcmd()
    printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
    printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
    printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
    printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
    printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
    printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
+   printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
    printf("\n");
 
    printf(_("Device status:\n"));
    printf("\n");
 
    printf(_("Device status:\n"));
-   printf("%sOPENED ", dev->state & ST_OPENED ? "" : "!");
-   printf("%sTAPE ", dev->state & ST_TAPE ? "" : "!");
-   printf("%sLABEL ", dev->state & ST_LABEL ? "" : "!");
+   printf("%sOPENED ", dev->is_open() ? "" : "!");
+   printf("%sTAPE ", dev->is_tape() ? "" : "!");
+   printf("%sLABEL ", dev->is_labeled() ? "" : "!");
    printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
    printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
-   printf("%sAPPEND ", dev->state & ST_APPEND ? "" : "!");
-   printf("%sREAD ", dev->state & ST_READ ? "" : "!");
-   printf("%sEOT ", dev->state & ST_EOT ? "" : "!");
+   printf("%sAPPEND ", dev->can_append() ? "" : "!");
+   printf("%sREAD ", dev->can_read() ? "" : "!");
+   printf("%sEOT ", dev->at_eot() ? "" : "!");
    printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
    printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
-   printf("%sEOF ", dev->state & ST_EOF ? "" : "!");
+   printf("%sEOF ", dev->at_eof() ? "" : "!");
    printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
    printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
    printf("\n");
    printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
    printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
    printf("\n");
@@ -503,7 +585,7 @@ static void capcmd()
 }
 
 /*
 }
 
 /*
- * Test writting larger and larger records.  
+ * Test writting larger and larger records.
  * This is a torture test for records.
  */
 static void rectestcmd()
  * This is a torture test for records.
  */
 static void rectestcmd()
@@ -524,7 +606,7 @@ static void rectestcmd()
       return;
    }
 
       return;
    }
 
-   sm_check(__FILE__, __LINE__, False);
+   sm_check(__FILE__, __LINE__, false);
    block = new_block(dev);
    rec = new_record();
 
    block = new_block(dev);
    rec = new_record();
 
@@ -532,19 +614,19 @@ static void rectestcmd()
       rec->data = check_pool_memory_size(rec->data, i);
       memset(rec->data, i & 0xFF, i);
       rec->data_len = i;
       rec->data = check_pool_memory_size(rec->data, i);
       memset(rec->data, i & 0xFF, i);
       rec->data_len = i;
-      sm_check(__FILE__, __LINE__, False);
+      sm_check(__FILE__, __LINE__, false);
       if (write_record_to_block(block, rec)) {
       if (write_record_to_block(block, rec)) {
-        empty_block(block);
-        blkno++;
+         empty_block(block);
+         blkno++;
          Pmsg2(0, "Block %d i=%d\n", blkno, i);
       } else {
          Pmsg2(0, "Block %d i=%d\n", blkno, i);
       } else {
-        break;
+         break;
       }
       }
-      sm_check(__FILE__, __LINE__, False);
+      sm_check(__FILE__, __LINE__, false);
    }
    free_record(rec);
    free_block(block);
    }
    free_record(rec);
    free_block(block);
-   sm_check(__FILE__, __LINE__, False);
+   sm_check(__FILE__, __LINE__, false);
 }
 
 /*
 }
 
 /*
@@ -556,7 +638,7 @@ static void rectestcmd()
  */
 static int re_read_block_test()
 {
  */
 static int re_read_block_test()
 {
-   DEV_BLOCK *block;
+   DEV_BLOCK *block = dcr->block;
    DEV_RECORD *rec;
    int stat = 0;
    int len;
    DEV_RECORD *rec;
    int stat = 0;
    int len;
@@ -567,78 +649,84 @@ static int re_read_block_test()
    }
 
    Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
    }
 
    Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
-      "I'm going to write three records and two eof's\n"
-      "then backup over the eof's and re-read the last record.\n"     
+      "I'm going to write three records and an EOF\n"
+      "then backup over the EOF and re-read the last record.\n"
       "Bacula does this after writing the last block on the\n"
       "Bacula does this after writing the last block on the\n"
-      "tape to verify that the block was written correctly.\n"
-      "It is not an *essential* feature ...\n\n")); 
+      "tape to verify that the block was written correctly.\n\n"
+      "This is not an *essential* feature ...\n\n"));
    rewindcmd();
    rewindcmd();
-   block = new_block(dev);
+   empty_block(block);
    rec = new_record();
    rec->data = check_pool_memory_size(rec->data, block->buf_len);
    len = rec->data_len = block->buf_len-100;
    memset(rec->data, 1, rec->data_len);
    if (!write_record_to_block(block, rec)) {
    rec = new_record();
    rec->data = check_pool_memory_size(rec->data, block->buf_len);
    len = rec->data_len = block->buf_len-100;
    memset(rec->data, 1, rec->data_len);
    if (!write_record_to_block(block, rec)) {
-      Pmsg0(0, _("Error writing record to block.\n")); 
+      Pmsg0(0, _("Error writing record to block.\n"));
       goto bail_out;
    }
       goto bail_out;
    }
-   if (!write_block_to_dev(jcr, dev, block)) {
-      Pmsg0(0, _("Error writing block to device.\n")); 
+   if (!write_block_to_dev(dcr)) {
+      Pmsg0(0, _("Error writing block to device.\n"));
       goto bail_out;
    } else {
       Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
    }
    memset(rec->data, 2, rec->data_len);
    if (!write_record_to_block(block, rec)) {
       goto bail_out;
    } else {
       Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
    }
    memset(rec->data, 2, rec->data_len);
    if (!write_record_to_block(block, rec)) {
-      Pmsg0(0, _("Error writing record to block.\n")); 
+      Pmsg0(0, _("Error writing record to block.\n"));
       goto bail_out;
    }
       goto bail_out;
    }
-   if (!write_block_to_dev(jcr, dev, block)) {
-      Pmsg0(0, _("Error writing block to device.\n")); 
+   if (!write_block_to_dev(dcr)) {
+      Pmsg0(0, _("Error writing block to device.\n"));
       goto bail_out;
    } else {
       Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
    }
    memset(rec->data, 3, rec->data_len);
    if (!write_record_to_block(block, rec)) {
       goto bail_out;
    } else {
       Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
    }
    memset(rec->data, 3, rec->data_len);
    if (!write_record_to_block(block, rec)) {
-      Pmsg0(0, _("Error writing record to block.\n")); 
+      Pmsg0(0, _("Error writing record to block.\n"));
       goto bail_out;
    }
       goto bail_out;
    }
-   if (!write_block_to_dev(jcr, dev, block)) {
-      Pmsg0(0, _("Error writing block to device.\n")); 
+   if (!write_block_to_dev(dcr)) {
+      Pmsg0(0, _("Error writing block to device.\n"));
       goto bail_out;
    } else {
       Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
    }
    weofcmd();
       goto bail_out;
    } else {
       Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
    }
    weofcmd();
-   weofcmd();
-   if (bsf_dev(dev, 1) != 0) {
-      Pmsg1(0, _("Back space file failed! ERR=%s\n"), strerror(dev->dev_errno));
-      goto bail_out;
+   if (dev_cap(dev, CAP_TWOEOF)) {
+      weofcmd();
    }
    }
-   if (bsf_dev(dev, 1) != 0) {
-      Pmsg1(0, _("Back space file failed! ERR=%s\n"), strerror(dev->dev_errno));
+   if (!bsf_dev(dev, 1)) {
+      Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
       goto bail_out;
    }
       goto bail_out;
    }
-   Pmsg0(0, "Backspaced over two EOFs OK.\n");
-   if (bsr_dev(dev, 1) != 0) {
-      Pmsg1(0, _("Back space record failed! ERR=%s\n"), strerror(dev->dev_errno));
+   if (dev_cap(dev, CAP_TWOEOF)) {
+      if (!bsf_dev(dev, 1)) {
+         Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
+         goto bail_out;
+      }
+   }
+   Pmsg0(0, "Backspaced over EOF OK.\n");
+   if (!bsr_dev(dev, 1)) {
+      Pmsg1(0, _("Backspace record failed! ERR=%s\n"), strerror_dev(dev));
       goto bail_out;
    }
    Pmsg0(0, "Backspace record OK.\n");
       goto bail_out;
    }
    Pmsg0(0, "Backspace record OK.\n");
-   if (!read_block_from_dev(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
-      Pmsg1(0, _("Read block failed! ERR=%s\n"), strerror(dev->dev_errno));
+   if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
+      berrno be;
+      Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
       goto bail_out;
    }
    memset(rec->data, 0, rec->data_len);
    if (!read_record_from_block(block, rec)) {
       goto bail_out;
    }
    memset(rec->data, 0, rec->data_len);
    if (!read_record_from_block(block, rec)) {
-      Pmsg1(0, _("Read block failed! ERR=%s\n"), strerror(dev->dev_errno));
+      berrno be;
+      Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
       goto bail_out;
    }
    for (int i=0; i<len; i++) {
       if (rec->data[i] != 3) {
          Pmsg0(0, _("Bad data in record. Test failed!\n"));
       goto bail_out;
    }
    for (int i=0; i<len; i++) {
       if (rec->data[i] != 3) {
          Pmsg0(0, _("Bad data in record. Test failed!\n"));
-        goto bail_out;
+         goto bail_out;
       }
    }
    Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
       }
    }
    Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
@@ -647,7 +735,6 @@ static int re_read_block_test()
    stat = 1;
 
 bail_out:
    stat = 1;
 
 bail_out:
-   free_block(block);
    free_record(rec);
    if (stat == 0) {
       Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
    free_record(rec);
    if (stat == 0) {
       Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
@@ -656,10 +743,286 @@ bail_out:
                  "if you add:\n\n"
                   "Backward Space Record = No\n\n"
                   "to your Storage daemon's Device resource definition.\n"));
                  "if you add:\n\n"
                   "Backward Space Record = No\n\n"
                   "to your Storage daemon's Device resource definition.\n"));
-   }   
+   }
+   return stat;
+}
+
+
+/*
+ * This test writes Bacula blocks to the tape in
+ *   several files. It then rewinds the tape and attepts
+ *   to read these blocks back checking the data.
+ */
+static int write_read_test()
+{
+   DEV_BLOCK *block;
+   DEV_RECORD *rec;
+   int stat = 0;
+   int len, i, j;
+   int *p;
+
+   Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
+      "I'm going to write 1000 records and an EOF\n"
+      "then write 1000 records and an EOF, then rewind,\n"
+      "and re-read the data to verify that it is correct.\n\n"
+      "This is an *essential* feature ...\n\n"));
+   block = dcr->block;
+   rec = new_record();
+   if (!rewind_dev(dev)) {
+      Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
+      goto bail_out;
+   }
+   rec->data = check_pool_memory_size(rec->data, block->buf_len);
+   rec->data_len = block->buf_len-100;
+   len = rec->data_len/sizeof(i);
+   for (i=1; i<=1000; i++) {
+      p = (int *)rec->data;
+      for (j=0; j<len; j++) {
+         *p++ = i;
+      }
+      if (!write_record_to_block(block, rec)) {
+         Pmsg0(0, _("Error writing record to block.\n"));
+         goto bail_out;
+      }
+      if (!write_block_to_dev(dcr)) {
+         Pmsg0(0, _("Error writing block to device.\n"));
+         goto bail_out;
+      }
+   }
+   Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
+   weofcmd();
+   for (i=1001; i<=2000; i++) {
+      p = (int *)rec->data;
+      for (j=0; j<len; j++) {
+         *p++ = i;
+      }
+      if (!write_record_to_block(block, rec)) {
+         Pmsg0(0, _("Error writing record to block.\n"));
+         goto bail_out;
+      }
+      if (!write_block_to_dev(dcr)) {
+         Pmsg0(0, _("Error writing block to device.\n"));
+         goto bail_out;
+      }
+   }
+   Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
+   weofcmd();
+   if (dev_cap(dev, CAP_TWOEOF)) {
+      weofcmd();
+   }
+   if (!rewind_dev(dev)) {
+      Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
+      goto bail_out;
+   } else {
+      Pmsg0(0, "Rewind OK.\n");
+   }
+   for (i=1; i<=2000; i++) {
+read_again:
+      if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
+         berrno be;
+         if (dev_state(dev, ST_EOF)) {
+            Pmsg0(-1, _("Got EOF on tape.\n"));
+            if (i == 1001) {
+               goto read_again;
+            }
+         }
+         Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.strerror(dev->dev_errno));
+         goto bail_out;
+      }
+      memset(rec->data, 0, rec->data_len);
+      if (!read_record_from_block(block, rec)) {
+         berrno be;
+         Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.strerror(dev->dev_errno));
+         goto bail_out;
+      }
+      p = (int *)rec->data;
+      for (j=0; j<len; j++) {
+         if (*p != i) {
+            Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
+               i, *p, j);
+            goto bail_out;
+         }
+         p++;
+      }
+      if (i == 1000 || i == 2000) {
+         Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
+      }
+   }
+   Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
+   stat = 1;
+
+bail_out:
+   free_record(rec);
+   return stat;
+}
+
+/*
+ * This test writes Bacula blocks to the tape in
+ *   several files. It then rewinds the tape and attepts
+ *   to read these blocks back checking the data.
+ */
+static int position_test()
+{
+   DEV_BLOCK *block = dcr->block;
+   DEV_RECORD *rec;
+   int stat = 0;
+   int len, i, j;
+   bool ok = true;
+   int recno = 0;
+   int file = 0, blk = 0;
+   int *p;
+   bool got_eof = false;
+
+   Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
+      "I'm going to write 1000 records and an EOF\n"
+      "then write 1000 records and an EOF, then rewind,\n"
+      "and position to a few blocks and verify that it is correct.\n\n"
+      "This is an *essential* feature ...\n\n"));
+   empty_block(block);
+   rec = new_record();
+   if (!rewind_dev(dev)) {
+      Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
+      goto bail_out;
+   }
+   rec->data = check_pool_memory_size(rec->data, block->buf_len);
+   rec->data_len = block->buf_len-100;
+   len = rec->data_len/sizeof(i);
+   for (i=1; i<=1000; i++) {
+      p = (int *)rec->data;
+      for (j=0; j<len; j++) {
+         *p++ = i;
+      }
+      if (!write_record_to_block(block, rec)) {
+         Pmsg0(0, _("Error writing record to block.\n"));
+         goto bail_out;
+      }
+      if (!write_block_to_dev(dcr)) {
+         Pmsg0(0, _("Error writing block to device.\n"));
+         goto bail_out;
+      }
+   }
+   Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
+   weofcmd();
+   for (i=1001; i<=2000; i++) {
+      p = (int *)rec->data;
+      for (j=0; j<len; j++) {
+         *p++ = i;
+      }
+      if (!write_record_to_block(block, rec)) {
+         Pmsg0(0, _("Error writing record to block.\n"));
+         goto bail_out;
+      }
+      if (!write_block_to_dev(dcr)) {
+         Pmsg0(0, _("Error writing block to device.\n"));
+         goto bail_out;
+      }
+   }
+   Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
+   weofcmd();
+   if (dev_cap(dev, CAP_TWOEOF)) {
+      weofcmd();
+   }
+   if (!rewind_dev(dev)) {
+      Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
+      goto bail_out;
+   } else {
+      Pmsg0(0, "Rewind OK.\n");
+   }
+
+   while(ok) {
+      /* Set up next item to read based on where we are */
+      switch (recno) {
+      case 0:
+         recno = 5;
+         file = 0;
+         blk = 4;
+         break;
+      case 5:
+         recno = 201;
+         file = 0;
+         blk = 200;
+         break;
+      case 201:
+         recno = 1000;
+         file = 0;
+         blk = 999;
+         break;
+      case 1000:
+         recno = 1001;
+         file = 1;
+         blk = 0;
+         break;
+      case 1001:
+         recno = 1601;
+         file = 1;
+         blk = 600;
+         break;
+      case 1601:
+         recno = 2000;
+         file = 1;
+         blk = 999;
+         break;
+      case 2000:
+         ok = false;
+         continue;
+      }
+      Pmsg2(-1, "Reposition to file:block %d:%d\n", file, blk);
+      if (!reposition_dev(dev, file, blk)) {
+         Pmsg0(0, "Reposition error.\n");
+         goto bail_out;
+      }
+read_again:
+      if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
+         berrno be;
+         if (dev_state(dev, ST_EOF)) {
+            Pmsg0(-1, _("Got EOF on tape.\n"));
+            if (!got_eof) {
+               got_eof = true;
+               goto read_again;
+            }
+         }
+         Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
+            recno, file, blk, be.strerror(dev->dev_errno));
+         Pmsg0(0, _("This may be because the tape drive block size is not\n"
+                    " set to variable blocking as normally used by Bacula.\n"
+                    " Please see the Tape Testing chapter in the manual and \n"
+                    " look for using mt with defblksize and setoptions\n"
+                    "If your tape drive block size is correct, then perhaps\n"
+                    " your SCSI driver is *really* stupid and does not\n"
+                    " correctly report the file:block after a FSF. In this\n"
+                    " case try setting:\n"
+                    "    Fast Forward Space File = no\n"
+                    " in your Device resource.\n"));
+
+         goto bail_out;
+      }
+      memset(rec->data, 0, rec->data_len);
+      if (!read_record_from_block(block, rec)) {
+         berrno be;
+         Pmsg1(0, _("Read record failed! ERR=%s\n"), be.strerror(dev->dev_errno));
+         goto bail_out;
+      }
+      p = (int *)rec->data;
+      for (j=0; j<len; j++) {
+         if (p[j] != recno) {
+            Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
+               recno, p[j], j);
+            goto bail_out;
+         }
+      }
+      Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
+   }
+   Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
+   stat = 1;
+
+bail_out:
+   free_record(rec);
    return stat;
 }
 
    return stat;
 }
 
+
+
+
 /*
  * This test writes some records, then writes an end of file,
  *   rewinds the tape, moves to the end of the data and attepts
 /*
  * This test writes some records, then writes an end of file,
  *   rewinds the tape, moves to the end of the data and attepts
@@ -673,45 +1036,313 @@ static int append_test()
 "I'm going to write one record  in file 0,\n"
 "                   two records in file 1,\n"
 "             and three records in file 2\n\n"));
 "I'm going to write one record  in file 0,\n"
 "                   two records in file 1,\n"
 "             and three records in file 2\n\n"));
+   argc = 1;
    rewindcmd();
    wrcmd();
    rewindcmd();
    wrcmd();
-   weofcmd();     /* end file 0 */
+   weofcmd();      /* end file 0 */
    wrcmd();
    wrcmd();
    wrcmd();
    wrcmd();
-   weofcmd();     /* end file 1 */
+   weofcmd();      /* end file 1 */
    wrcmd();
    wrcmd();
    wrcmd();
    wrcmd();
    wrcmd();
    wrcmd();
-   weofcmd();    /* end file 2 */
+   weofcmd();     /* end file 2 */
+   if (dev_cap(dev, CAP_TWOEOF)) {
+      weofcmd();
+   }
+   force_close_dev(dev);              /* release device */
+   if (!open_the_device()) {
+      return -1;
+   }
    rewindcmd();
    Pmsg0(0, _("Now moving to end of medium.\n"));
    eodcmd();
    rewindcmd();
    Pmsg0(0, _("Now moving to end of medium.\n"));
    eodcmd();
-   Pmsg2(-1, _("We should be in file 3. I am at file %d. This is %s\n"), 
+   Pmsg2(-1, _("We should be in file 3. I am at file %d. This is %s\n"),
+      dev->file, dev->file == 3 ? "correct!" : "NOT correct!!!!");
+
+   if (dev->file != 3) {
+      return -1;
+   }
+
+   Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
+   wrcmd();
+   weofcmd();
+   if (dev_cap(dev, CAP_TWOEOF)) {
+      weofcmd();
+   }
+   rewindcmd();
+   Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
+   Pmsg0(-1, "Doing Bacula scan of blocks:\n");
+   scan_blocks();
+   Pmsg0(-1, _("End scanning the tape.\n"));
+   Pmsg2(-1, _("We should be in file 4. I am at file %d. This is %s\n"),
+      dev->file, dev->file == 4 ? "correct!" : "NOT correct!!!!");
+
+   if (dev->file != 4) {
+      return -2;
+   }
+   return 1;
+}
+
+
+/*
+ * This test exercises the autochanger
+ */
+static int autochanger_test()
+{
+   POOLMEM *results, *changer;
+   int slot, status, loaded;
+   int timeout = dcr->device->max_changer_wait;
+   int sleep_time = 0;
+
+   Dmsg1(100, "Max changer wait = %d sec\n", timeout);
+   if (!dev_cap(dev, CAP_AUTOCHANGER)) {
+      return 1;
+   }
+   if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
+      Pmsg0(-1, "\nAutochanger enabled, but no name or no command device specified.\n");
+      return 1;
+   }
+
+   Pmsg0(-1, "\nAh, I see you have an autochanger configured.\n"
+             "To test the autochanger you must have a blank tape\n"
+             " that I can write on in Slot 1.\n");
+   if (!get_cmd("\nDo you wish to continue with the Autochanger test? (y/n): ")) {
+      return 0;
+   }
+   if (cmd[0] != 'y' && cmd[0] != 'Y') {
+      return 0;
+   }
+
+   Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
+
+   results = get_pool_memory(PM_MESSAGE);
+   changer = get_pool_memory(PM_FNAME);
+
+try_again:
+   slot = 1;
+   dcr->VolCatInfo.Slot = slot;
+   /* Find out what is loaded, zero means device is unloaded */
+   Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
+   changer = edit_device_codes(dcr, changer, "loaded");
+   status = run_program(changer, timeout, results);
+   Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
+   if (status == 0) {
+      loaded = atoi(results);
+   } else {
+      berrno be;
+      Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
+      Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
+      goto bail_out;
+   }
+   if (loaded) {
+      Pmsg1(-1, "Slot %d loaded. I am going to unload it.\n", loaded);
+   } else {
+      Pmsg0(-1, "Nothing loaded in the drive. OK.\n");
+   }
+   Dmsg1(100, "Results from loaded query=%s\n", results);
+   if (loaded) {
+      dcr->VolCatInfo.Slot = loaded;
+      offline_or_rewind_dev(dev);
+      /* We are going to load a new tape, so close the device */
+      force_close_dev(dev);
+      Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
+         loaded, dev->drive_index);
+      changer = edit_device_codes(dcr, changer, "unload");
+      status = run_program(changer, timeout, results);
+      Pmsg2(-1, "unload status=%s %d\n", status==0?"OK":"Bad", status);
+      if (status != 0) {
+         berrno be;
+         Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
+         Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
+      }
+   }
+
+   /*
+    * Load the Slot 1
+    */
+
+   slot = 1;
+   dcr->VolCatInfo.Slot = slot;
+   Pmsg2(-1, _("3303 Issuing autochanger \"load slot %d %d\" command.\n"),
+      slot, dev->drive_index);
+   changer = edit_device_codes(dcr, changer, "load");
+   Dmsg1(100, "Changer=%s\n", changer);
+   force_close_dev(dev);
+   status = run_program(changer, timeout, results);
+   if (status == 0) {
+      Pmsg2(-1,  _("3303 Autochanger \"load slot %d %d\" status is OK.\n"),
+         slot, dev->drive_index);
+   } else {
+      berrno be;
+      Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
+      Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
+      goto bail_out;
+   }
+
+   if (!open_the_device()) {
+      goto bail_out;
+   }
+   /*
+    * Start with sleep_time 0 then increment by 30 seconds if we get
+    * a failure.
+    */
+   bmicrosleep(sleep_time, 0);
+   if (!rewind_dev(dev) || weof_dev(dev,1) < 0) {
+      Pmsg1(0, "Bad status from rewind. ERR=%s\n", strerror_dev(dev));
+      clrerror_dev(dev, -1);
+      Pmsg0(-1, "\nThe test failed, probably because you need to put\n"
+                "a longer sleep time in the mtx-script in the load) case.\n"
+                "Adding a 30 second sleep and trying again ...\n");
+      sleep_time += 30;
+      goto try_again;
+   } else {
+      Pmsg1(0, "Rewound %s\n", dev->print_name());
+   }
+
+   if ((status = weof_dev(dev, 1)) < 0) {
+      Pmsg2(0, "Bad status from weof %d. ERR=%s\n", status, strerror_dev(dev));
+      goto bail_out;
+   } else {
+      Pmsg1(0, "Wrote EOF to %s\n", dev->print_name());
+   }
+
+   if (sleep_time) {
+      Pmsg1(-1, "\nThe test worked this time. Please add:\n\n"
+                "   sleep %d\n\n"
+                "to your mtx-changer script in the load) case.\n\n",
+                sleep_time);
+   } else {
+      Pmsg0(-1, "\nThe test autochanger worked!!\n\n");
+   }
+
+   free_pool_memory(changer);
+   free_pool_memory(results);
+   return 1;
+
+
+bail_out:
+   free_pool_memory(changer);
+   free_pool_memory(results);
+   Pmsg0(-1, "You must correct this error or the Autochanger will not work.\n");
+   return -2;
+}
+
+static void autochangercmd()
+{
+   autochanger_test();
+}
+
+
+/*
+ * This test assumes that the append test has been done,
+ *   then it tests the fsf function.
+ */
+static int fsf_test()
+{
+   bool set_off = false;
+
+   Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
+               "This test is essential to Bacula.\n\n"
+               "I'm going to write five files then test forward spacing\n\n"));
+   argc = 1;
+   rewindcmd();
+   wrcmd();
+   weofcmd();      /* end file 0 */
+   wrcmd();
+   wrcmd();
+   weofcmd();      /* end file 1 */
+   wrcmd();
+   wrcmd();
+   wrcmd();
+   weofcmd();     /* end file 2 */
+   wrcmd();
+   wrcmd();
+   weofcmd();     /* end file 3 */
+   wrcmd();
+   weofcmd();     /* end file 4 */
+   if (dev_cap(dev, CAP_TWOEOF)) {
+      weofcmd();
+   }
+
+test_again:
+   rewindcmd();
+   Pmsg0(0, _("Now forward spacing 1 file.\n"));
+   if (!fsf_dev(dev, 1)) {
+      Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
+      goto bail_out;
+   }
+   Pmsg2(-1, _("We should be in file 1. I am at file %d. This is %s\n"),
+      dev->file, dev->file == 1 ? "correct!" : "NOT correct!!!!");
+
+   if (dev->file != 1) {
+      goto bail_out;
+   }
+
+   Pmsg0(0, _("Now forward spacing 2 files.\n"));
+   if (!fsf_dev(dev, 2)) {
+      Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
+      goto bail_out;
+   }
+   Pmsg2(-1, _("We should be in file 3. I am at file %d. This is %s\n"),
       dev->file, dev->file == 3 ? "correct!" : "NOT correct!!!!");
 
    if (dev->file != 3) {
       dev->file, dev->file == 3 ? "correct!" : "NOT correct!!!!");
 
    if (dev->file != 3) {
-      return -1;
+      goto bail_out;
    }
 
    }
 
-   Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
-   wrcmd(); 
-   weofcmd();
    rewindcmd();
    rewindcmd();
-   Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
-   Pmsg0(-1, "Doing Bacula scan of blocks:\n");
-   scan_blocks();
-   Pmsg0(-1, _("End scanning the tape.\n"));
-   Pmsg2(-1, _("We should be in file 4. I am at file %d. This is %s\n"), 
+   Pmsg0(0, _("Now forward spacing 4 files.\n"));
+   if (!fsf_dev(dev, 4)) {
+      Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
+      goto bail_out;
+   }
+   Pmsg2(-1, _("We should be in file 4. I am at file %d. This is %s\n"),
       dev->file, dev->file == 4 ? "correct!" : "NOT correct!!!!");
 
    if (dev->file != 4) {
       dev->file, dev->file == 4 ? "correct!" : "NOT correct!!!!");
 
    if (dev->file != 4) {
-      return -2;
+      goto bail_out;
+   }
+   if (set_off) {
+      Pmsg0(-1, "The test worked this time. Please add:\n\n"
+                "   Fast Forward Space File = no\n\n"
+                "to your Device resource for this drive.\n");
    }
 
    }
 
+   Pmsg0(-1, "\n");
+   Pmsg0(0, _("Now forward spacing 1 more file.\n"));
+   if (!fsf_dev(dev, 1)) {
+      Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
+   }
+   Pmsg2(-1, _("We should be in file 5. I am at file %d. This is %s\n"),
+      dev->file, dev->file == 5 ? "correct!" : "NOT correct!!!!");
+   if (dev->file != 5) {
+      goto bail_out;
+   }
+   Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
    return 1;
    return 1;
+
+bail_out:
+   Pmsg0(-1, _("\nThe forward space file test failed.\n"));
+   if (dev_cap(dev, CAP_FASTFSF)) {
+      Pmsg0(-1, "You have Fast Forward Space File enabled.\n"
+              "I am turning it off then retrying the test.\n");
+      dev->capabilities &= ~CAP_FASTFSF;
+      set_off = true;
+      goto test_again;
+   }
+   Pmsg0(-1, "You must correct this error or Bacula will not work.\n"
+            "Some systems, e.g. OpenBSD, require you to set\n"
+            "   Use MTIOCGET= no\n"
+            "in your device resource. Use with caution.\n");
+   return -2;
 }
 
 }
 
-/* 
+
+
+
+
+/*
  * This is a general test of Bacula's functions
  *   needed to read and write the tape.
  */
  * This is a general test of Bacula's functions
  *   needed to read and write the tape.
  */
@@ -719,52 +1350,73 @@ static void testcmd()
 {
    int stat;
 
 {
    int stat;
 
+   if (!write_read_test()) {
+      return;
+   }
+   if (!position_test()) {
+      return;
+   }
+
    stat = append_test();
    stat = append_test();
-   if (stat == 1) {                  /* OK get out */
+   if (stat == 1) {                   /* OK get out */
       goto all_done;
    }
       goto all_done;
    }
-   if (stat == -1) {                 /* first test failed */
-      if (dev_cap(dev, CAP_EOM)) {
+   if (stat == -1) {                  /* first test failed */
+      if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
          Pmsg0(-1, "\nAppend test failed. Attempting again.\n"
          Pmsg0(-1, "\nAppend test failed. Attempting again.\n"
-                   "Setting \"Hardware End of Medium = no\" and retrying append test.\n\n");
-        dev->capabilities &= ~CAP_EOM; /* turn off eom */
-        stat = append_test();
-        if (stat == 1) {
+                   "Setting \"Hardware End of Medium = no\n"
+                   "    and \"Fast Forward Space File = no\n"
+                   "and retrying append test.\n\n");
+         dev->capabilities &= ~CAP_EOM; /* turn off eom */
+         dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
+         stat = append_test();
+         if (stat == 1) {
             Pmsg0(-1, "\n\nIt looks like the test worked this time, please add:\n\n"
                      "    Hardware End of Medium = No\n\n"
             Pmsg0(-1, "\n\nIt looks like the test worked this time, please add:\n\n"
                      "    Hardware End of Medium = No\n\n"
+                     "    Fast Forward Space File = No\n"
                      "to your Device resource in the Storage conf file.\n");
                      "to your Device resource in the Storage conf file.\n");
-           goto all_done;
-        }
-        if (stat == -1) {
-            Pmsg0(-1, "\n\nThat appears not to have corrected the problem.\n");
-           goto all_done;
-        }
-        /* Wrong count after append */
-        if (stat == -2) {
+            goto all_done;
+         }
+         if (stat == -1) {
+            Pmsg0(-1, "\n\nThat appears *NOT* to have corrected the problem.\n");
+            goto failed;
+         }
+         /* Wrong count after append */
+         if (stat == -2) {
             Pmsg0(-1, "\n\nIt looks like the append failed. Attempting again.\n"
                      "Setting \"BSF at EOM = yes\" and retrying append test.\n");
             Pmsg0(-1, "\n\nIt looks like the append failed. Attempting again.\n"
                      "Setting \"BSF at EOM = yes\" and retrying append test.\n");
-           dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
-           stat = append_test();
-           if (stat == 1) {
+            dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
+            stat = append_test();
+            if (stat == 1) {
                Pmsg0(-1, "\n\nIt looks like the test worked this time, please add:\n\n"
                      "    Hardware End of Medium = No\n"
                Pmsg0(-1, "\n\nIt looks like the test worked this time, please add:\n\n"
                      "    Hardware End of Medium = No\n"
-                     "    BSR at EOM = yes\n\n"
+                     "    Fast Forward Space File = No\n"
+                     "    BSF at EOM = yes\n\n"
                      "to your Device resource in the Storage conf file.\n");
                      "to your Device resource in the Storage conf file.\n");
-              goto all_done;
-           }
-        }
+               goto all_done;
+            }
+         }
 
 
-         Pmsg0(-1, "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
-               "Unable to correct the problem. You MUST fix this\n"
-                "problem before Bacula can use your tape drive correctly\n");
-         Pmsg0(-1, "\nPerhaps running Bacula in fixed block mode will work.\n"
-               "Do so by setting:\n\n"
-               "Minimum Block Size = nnn\n"
-               "Maximum Block Size = nnn\n\n"
-               "in your Storage daemon's Device definition.\n"
-               "nnn must match your tape driver's block size.\n"
-               "This, however, is not really an ideal solution.\n");
       }
       }
+failed:
+      Pmsg0(-1, "\nAppend test failed.\n\n");
+      Pmsg0(-1, "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
+            "Unable to correct the problem. You MUST fix this\n"
+             "problem before Bacula can use your tape drive correctly\n");
+      Pmsg0(-1, "\nPerhaps running Bacula in fixed block mode will work.\n"
+            "Do so by setting:\n\n"
+            "Minimum Block Size = nnn\n"
+            "Maximum Block Size = nnn\n\n"
+            "in your Storage daemon's Device definition.\n"
+            "nnn must match your tape driver's block size, which\n"
+            "can be determined by reading your tape manufacturers\n"
+            "information, and the information on your kernel dirver.\n"
+            "Fixed block sizes, however, are not normally an ideal solution.\n"
+            "\n"
+            "Some systems, e.g. OpenBSD, require you to set\n"
+            "   Use MTIOCGET= no\n"
+            "in your device resource. Use with caution.\n");
+       return;
    }
 
 all_done:
    }
 
 all_done:
@@ -777,9 +1429,9 @@ all_done:
         "End of File mark.\n"
         "3 blocks of 64448 bytes in file 3\n"
         "End of File mark.\n"
         "End of File mark.\n"
         "3 blocks of 64448 bytes in file 3\n"
         "End of File mark.\n"
-        "1 block of 64448 bytes in file 4\n" 
+        "1 block of 64448 bytes in file 4\n"
         "End of File mark.\n"
         "End of File mark.\n"
-        "Total files=4, blocks=7, bytes = 451136\n"
+        "Total files=4, blocks=7, bytes = 451,136\n"
         "=== End sample correct output ===\n\n"));
 
    Pmsg0(-1, _("If the above scan output is not identical to the\n"
         "=== End sample correct output ===\n\n"));
 
    Pmsg0(-1, _("If the above scan output is not identical to the\n"
@@ -791,30 +1443,44 @@ all_done:
       re_read_block_test();
    }
 
       re_read_block_test();
    }
 
-   Pmsg0(-1, _("\n=== End Append files test ===\n"));
-   
+   fsf_test();                        /* do fast forward space file test */
+
+   autochanger_test();                /* do autochanger test */
+
 }
 
 /* Forward space a file */
 static void fsfcmd()
 {
 }
 
 /* Forward space a file */
 static void fsfcmd()
 {
-   if (!fsf_dev(dev, 1)) {
+   int num = 1;
+   if (argc > 1) {
+      num = atoi(argk[1]);
+   }
+   if (num <= 0) {
+      num = 1;
+   }
+   if (!fsf_dev(dev, num)) {
       Pmsg1(0, "Bad status from fsf. ERR=%s\n", strerror_dev(dev));
       return;
    }
       Pmsg1(0, "Bad status from fsf. ERR=%s\n", strerror_dev(dev));
       return;
    }
-   Pmsg0(0, "Forward spaced one file.\n");
+   Pmsg2(0, "Forward spaced %d file%s.\n", num, num==1?"":"s");
 }
 
 /* Forward space a record */
 static void fsrcmd()
 {
 }
 
 /* Forward space a record */
 static void fsrcmd()
 {
-   int stat;
-
-   if ((stat=fsr_dev(dev, 1)) < 0) {
-      Pmsg2(0, "Bad status from fsr %d. ERR=%s\n", stat, strerror_dev(dev));
+   int num = 1;
+   if (argc > 1) {
+      num = atoi(argk[1]);
+   }
+   if (num <= 0) {
+      num = 1;
+   }
+   if (!dev->fsr(num)) {
+      Pmsg1(0, "Bad status from fsr. ERR=%s\n", strerror_dev(dev));
       return;
    }
       return;
    }
-   Pmsg0(0, "Forward spaced one record.\n");
+   Pmsg2(0, "Forward spaced %d record%s.\n", num, num==1?"":"s");
 }
 
 
 }
 
 
@@ -823,27 +1489,28 @@ static void fsrcmd()
  */
 static void wrcmd()
 {
  */
 static void wrcmd()
 {
-   DEV_BLOCK *block;
-   DEV_RECORD *rec;
+   DEV_BLOCK *block = dcr->block;
+   DEV_RECORD *rec = dcr->rec;
    int i;
 
    int i;
 
-   sm_check(__FILE__, __LINE__, False);
-   block = new_block(dev);
-   rec = new_record();
-   dump_block(block, "test");
+   sm_check(__FILE__, __LINE__, false);
+   empty_block(block);
+   if (verbose > 1) {
+      dump_block(block, "test");
+   }
 
    i = block->buf_len - 100;
    ASSERT (i > 0);
    rec->data = check_pool_memory_size(rec->data, i);
    memset(rec->data, i & 0xFF, i);
    rec->data_len = i;
 
    i = block->buf_len - 100;
    ASSERT (i > 0);
    rec->data = check_pool_memory_size(rec->data, i);
    memset(rec->data, i & 0xFF, i);
    rec->data_len = i;
-   sm_check(__FILE__, __LINE__, False);
+   sm_check(__FILE__, __LINE__, false);
    if (!write_record_to_block(block, rec)) {
    if (!write_record_to_block(block, rec)) {
-      Pmsg0(0, _("Error writing record to block.\n")); 
+      Pmsg0(0, _("Error writing record to block.\n"));
       goto bail_out;
    }
       goto bail_out;
    }
-   if (!write_block_to_dev(jcr, dev, block)) {
-      Pmsg0(0, _("Error writing block to device.\n")); 
+   if (!write_block_to_dev(dcr)) {
+      Pmsg0(0, _("Error writing block to device.\n"));
       goto bail_out;
    } else {
       Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
       goto bail_out;
    } else {
       Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
@@ -851,13 +1518,11 @@ static void wrcmd()
    Pmsg0(0, _("Wrote block to device.\n"));
 
 bail_out:
    Pmsg0(0, _("Wrote block to device.\n"));
 
 bail_out:
-   sm_check(__FILE__, __LINE__, False);
-   free_record(rec);
-   free_block(block);
-   sm_check(__FILE__, __LINE__, False);
+   sm_check(__FILE__, __LINE__, false);
+   sm_check(__FILE__, __LINE__, false);
 }
 
 }
 
-/* 
+/*
  * Read a record from the tape
  */
 static void rrcmd()
  * Read a record from the tape
  */
 static void rrcmd()
@@ -878,8 +1543,9 @@ static void rrcmd()
    if (stat > 0 && stat <= len) {
       errno = 0;
    }
    if (stat > 0 && stat <= len) {
       errno = 0;
    }
+   berrno be;
    Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
    Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
-      len, stat, strerror(errno));
+      len, stat, be.strerror());
    free(buf);
 }
 
    free(buf);
 }
 
@@ -902,57 +1568,58 @@ static void scancmd()
    bytes = 0;
    if (dev->state & ST_EOT) {
       Pmsg0(0, "End of tape\n");
    bytes = 0;
    if (dev->state & ST_EOT) {
       Pmsg0(0, "End of tape\n");
-      return; 
+      return;
    }
    update_pos_dev(dev);
    tot_files = dev->file;
    Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
    for (;;) {
       if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
    }
    update_pos_dev(dev);
    tot_files = dev->file;
    Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
    for (;;) {
       if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
-        clrerror_dev(dev, -1);
-         Mmsg2(&dev->errmsg, "read error on %s. ERR=%s.\n",
-           dev->dev_name, strerror(dev->dev_errno));
+         berrno be;
+         clrerror_dev(dev, -1);
+         Mmsg2(dev->errmsg, "read error on %s. ERR=%s.\n",
+            dev->dev_name, be.strerror());
          Pmsg2(0, "Bad status from read %d. ERR=%s\n", stat, strerror_dev(dev));
          Pmsg2(0, "Bad status from read %d. ERR=%s\n", stat, strerror_dev(dev));
-        if (blocks > 0)
-            printf("%d block%s of %d bytes in file %d\n",        
+         if (blocks > 0)
+            printf("%d block%s of %d bytes in file %d\n",
                     blocks, blocks>1?"s":"", block_size, dev->file);
                     blocks, blocks>1?"s":"", block_size, dev->file);
-        return;
+         return;
       }
       Dmsg1(200, "read status = %d\n", stat);
 /*    sleep(1); */
       if (stat != block_size) {
       }
       Dmsg1(200, "read status = %d\n", stat);
 /*    sleep(1); */
       if (stat != block_size) {
-        update_pos_dev(dev);
-        if (blocks > 0) {
-            printf("%d block%s of %d bytes in file %d\n", 
+         update_pos_dev(dev);
+         if (blocks > 0) {
+            printf("%d block%s of %d bytes in file %d\n",
                  blocks, blocks>1?"s":"", block_size, dev->file);
                  blocks, blocks>1?"s":"", block_size, dev->file);
-           blocks = 0;
-        }
-        block_size = stat;
+            blocks = 0;
+         }
+         block_size = stat;
       }
       }
-      if (stat == 0) {               /* EOF */
-        update_pos_dev(dev);
+      if (stat == 0) {                /* EOF */
+         update_pos_dev(dev);
          printf("End of File mark.\n");
          printf("End of File mark.\n");
-        /* Two reads of zero means end of tape */
-        if (dev->state & ST_EOF)
-           dev->state |= ST_EOT;
-        else {
-           dev->state |= ST_EOF;
-           dev->file++;
-        }
-        if (dev->state & ST_EOT) {
+         /* Two reads of zero means end of tape */
+         if (dev->state & ST_EOF)
+            dev->state |= ST_EOT;
+         else {
+            dev->state |= ST_EOF;
+            dev->file++;
+         }
+         if (dev->state & ST_EOT) {
             printf("End of tape\n");
             printf("End of tape\n");
-           break;
-        }
-      } else {                       /* Got data */
-        dev->state &= ~ST_EOF;
-        blocks++;
-        tot_blocks++;
-        bytes += stat;
+            break;
+         }
+      } else {                        /* Got data */
+         dev->state &= ~ST_EOF;
+         blocks++;
+         tot_blocks++;
+         bytes += stat;
       }
    }
    update_pos_dev(dev);
    tot_files = dev->file - tot_files;
       }
    }
    update_pos_dev(dev);
    tot_files = dev->file - tot_files;
-   printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks, 
+   printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks,
       edit_uint64_with_commas(bytes, ec1));
 }
 
       edit_uint64_with_commas(bytes, ec1));
 }
 
@@ -968,94 +1635,87 @@ static void scan_blocks()
    int blocks, tot_blocks, tot_files;
    uint32_t block_size;
    uint64_t bytes;
    int blocks, tot_blocks, tot_files;
    uint32_t block_size;
    uint64_t bytes;
-   DEV_BLOCK *block;
+   DEV_BLOCK *block = dcr->block;
    char ec1[50];
 
    char ec1[50];
 
-   block = new_block(dev);
    blocks = block_size = tot_blocks = 0;
    bytes = 0;
 
    blocks = block_size = tot_blocks = 0;
    bytes = 0;
 
+   empty_block(block);
    update_pos_dev(dev);
    tot_files = dev->file;
    for (;;) {
    update_pos_dev(dev);
    tot_files = dev->file;
    for (;;) {
-      if (!read_block_from_device(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
+      if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
          Dmsg1(100, "!read_block(): ERR=%s\n", strerror_dev(dev));
          Dmsg1(100, "!read_block(): ERR=%s\n", strerror_dev(dev));
-        if (dev->state & ST_EOT) {
-           if (blocks > 0) {
-               printf("%d block%s of %d bytes in file %d\n", 
+         if (dev->state & ST_EOT) {
+            if (blocks > 0) {
+               printf("%d block%s of %d bytes in file %d\n",
                     blocks, blocks>1?"s":"", block_size, dev->file);
                     blocks, blocks>1?"s":"", block_size, dev->file);
-              blocks = 0;
-           }
-           goto bail_out;
-        }
-        if (dev->state & ST_EOF) {
-           if (blocks > 0) {
-               printf("%d block%s of %d bytes in file %d\n",        
+               blocks = 0;
+            }
+            goto bail_out;
+         }
+         if (dev->state & ST_EOF) {
+            if (blocks > 0) {
+               printf("%d block%s of %d bytes in file %d\n",
                        blocks, blocks>1?"s":"", block_size, dev->file);
                        blocks, blocks>1?"s":"", block_size, dev->file);
-              blocks = 0;
-           }
+               blocks = 0;
+            }
             printf(_("End of File mark.\n"));
             printf(_("End of File mark.\n"));
-           continue;
-        }
-        if (dev->state & ST_SHORT) {
-           if (blocks > 0) {
-               printf("%d block%s of %d bytes in file %d\n",        
+            continue;
+         }
+         if (dev->state & ST_SHORT) {
+            if (blocks > 0) {
+               printf("%d block%s of %d bytes in file %d\n",
                        blocks, blocks>1?"s":"", block_size, dev->file);
                        blocks, blocks>1?"s":"", block_size, dev->file);
-              blocks = 0;
-           }
+               blocks = 0;
+            }
             printf(_("Short block read.\n"));
             printf(_("Short block read.\n"));
-           continue;
-        }
+            continue;
+         }
          printf(_("Error reading block. ERR=%s\n"), strerror_dev(dev));
          printf(_("Error reading block. ERR=%s\n"), strerror_dev(dev));
-        goto bail_out;
+         goto bail_out;
       }
       if (block->block_len != block_size) {
       }
       if (block->block_len != block_size) {
-        if (blocks > 0) {
-            printf("%d block%s of %d bytes in file %d\n",        
+         if (blocks > 0) {
+            printf("%d block%s of %d bytes in file %d\n",
                     blocks, blocks>1?"s":"", block_size, dev->file);
                     blocks, blocks>1?"s":"", block_size, dev->file);
-           blocks = 0;
-        }
-        block_size = block->block_len;
+            blocks = 0;
+         }
+         block_size = block->block_len;
       }
       blocks++;
       tot_blocks++;
       bytes += block->block_len;
       }
       blocks++;
       tot_blocks++;
       bytes += block->block_len;
-      Dmsg5(100, "Blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
-        block->BlockNumber, block->block_len, block->BlockVer,
-        block->VolSessionId, block->VolSessionTime);
+      Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
+         block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
+         block->VolSessionId, block->VolSessionTime);
       if (verbose == 1) {
       if (verbose == 1) {
-        DEV_RECORD *rec = new_record();
-        read_record_from_block(block, rec);
-         Pmsg7(-1, "Block: %u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n",
-             block->BlockNumber, block->block_len,
-             FI_to_ascii(rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
-             stream_to_ascii(rec->Stream, rec->FileIndex), rec->data_len);
-        rec->remainder = 0;
-        free_record(rec);
+         DEV_RECORD *rec = new_record();
+         read_record_from_block(block, rec);
+         Pmsg8(-1, "Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n",
+              block->BlockNumber, dev->block_num, block->block_len,
+              FI_to_ascii(rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
+              stream_to_ascii(rec->Stream, rec->FileIndex), rec->data_len);
+         rec->remainder = 0;
+         free_record(rec);
       } else if (verbose > 1) {
          dump_block(block, "");
       }
 
    }
 bail_out:
       } else if (verbose > 1) {
          dump_block(block, "");
       }
 
    }
 bail_out:
-   free_block(block);
    tot_files = dev->file - tot_files;
    tot_files = dev->file - tot_files;
-   printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks, 
+   printf("Total files=%d, blocks=%d, bytes = %s\n", tot_files, tot_blocks,
       edit_uint64_with_commas(bytes, ec1));
 }
 
 
 static void statcmd()
 {
       edit_uint64_with_commas(bytes, ec1));
 }
 
 
 static void statcmd()
 {
-   int stat = 0;
-   int debug;
-   uint32_t status;
-
-   debug = debug_level;
+   int debug = debug_level;
    debug_level = 30;
    debug_level = 30;
-   if (!status_dev(dev, &status)) {
-      Pmsg2(0, "Bad status from status %d. ERR=%s\n", stat, strerror_dev(dev));
-   }
+   Pmsg2(0, "Device status: %u. ERR=%s\n", status_dev(dev), strerror_dev(dev));
 #ifdef xxxx
    dump_volume_label(dev);
 #endif
 #ifdef xxxx
    dump_volume_label(dev);
 #endif
@@ -1063,79 +1723,96 @@ static void statcmd()
 }
 
 
 }
 
 
-/* 
+/*
  * First we label the tape, then we fill
  *  it with data get a new tape and write a few blocks.
  * First we label the tape, then we fill
  *  it with data get a new tape and write a few blocks.
- */                           
+ */
 static void fillcmd()
 {
    DEV_RECORD rec;
 static void fillcmd()
 {
    DEV_RECORD rec;
-   DEV_BLOCK  *block;
+   DEV_BLOCK  *block = dcr->block;
    char ec1[50];
    char ec1[50];
+   int fd;
+   uint32_t i;
+   uint32_t min_block_size;
 
 
-   ok = TRUE;
+   ok = true;
    stop = 0;
    vol_num = 0;
    stop = 0;
    vol_num = 0;
+   last_file = 0;
+   last_block_num = 0;
+   BlockNumber = 0;
 
 
-   Pmsg0(-1, "\n\
-This command simulates Bacula writing to a tape.\n\
-It requires either one or two blank tapes, which it\n\
-will label and write. It will print a status approximately\n\
-every 322 MB, and write an EOF every 3.2 GB.  If you have\n\
-selected the simple test option, after writing the first tape\n\
-it will rewind it and re-read the last block written.\n\
-If you have selected the multiple tape test, when the first tape\n\
-fills, it will ask for a second, and after writing a few more \n\
-blocks, it will stop.  Then it will begin re-reading the\n\
-two tapes.\n\n\
-This may take a long time -- hours! ...\n\n");
-
-   get_cmd("Insert a blank tape then indicate if you want\n"
-           "to run the simplified test (s) with one tape or\n"
-           "the complete multiple tape (m) test: (s/m) ");
+   Pmsg0(-1, "\n"
+"This command simulates Bacula writing to a tape.\n"
+"It requires either one or two blank tapes, which it\n"
+"will label and write.\n\n"
+"If you have an autochanger configured, it will use\n"
+"the tapes that are in slots 1 and 2, otherwise, you will\n"
+"be prompted to insert the tapes when necessary.\n\n"
+"It will print a status approximately\n"
+"every 322 MB, and write an EOF every 3.2 GB.  If you have\n"
+"selected the simple test option, after writing the first tape\n"
+"it will rewind it and re-read the last block written.\n\n"
+"If you have selected the multiple tape test, when the first tape\n"
+"fills, it will ask for a second, and after writing a few more \n"
+"blocks, it will stop.  Then it will begin re-reading the\n"
+"two tapes.\n\n"
+"This may take a long time -- hours! ...\n\n");
+
+   get_cmd("Do you want to run the simplified test (s) with one tape\n"
+           "or the complete multiple tape (m) test: (s/m) ");
    if (cmd[0] == 's') {
       Pmsg0(-1, "Simple test (single tape) selected.\n");
    if (cmd[0] == 's') {
       Pmsg0(-1, "Simple test (single tape) selected.\n");
-      simple = TRUE;
+      simple = true;
    } else if (cmd[0] == 'm') {
    } else if (cmd[0] == 'm') {
-      Pmsg0(-1, "Complete multiple tape test selected.\n"); 
-      simple = FALSE;
+      Pmsg0(-1, "Multiple tape test selected.\n");
+      simple = false;
    } else {
       Pmsg0(000, "Command aborted.\n");
       return;
    }
 
    } else {
       Pmsg0(000, "Command aborted.\n");
       return;
    }
 
-   set_volume_name("TestVolume1", 1);
-   labelcmd();
-   VolumeName = NULL;
+   Dmsg1(20, "Begin append device=%s\n", dev->print_name());
+   Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
 
 
-   
-   Dmsg1(20, "Begin append device=%s\n", dev_name(dev));
+   /* Use fixed block size to simplify read back */
+   min_block_size = dev->min_block_size;
+   dev->min_block_size = dev->max_block_size;
+   set_volume_name("TestVolume1", 1);
 
 
-   block = new_block(dev);
+   if (!dev->rewind()) {
+      Pmsg0(000, "Rewind failed.\n");
+   }
+   if (!dev->weof()) {
+      Pmsg0(000, "Write EOF failed.\n");
+   }
+   labelcmd();
+   dev->set_append();                 /* force volume to be relabeled */
 
 
-   /* 
+   /*
     * Acquire output device for writing.  Note, after acquiring a
     * Acquire output device for writing.  Note, after acquiring a
-    *  device, we MUST release it, which is done at the end of this
-    *  subroutine.
+    *   device, we MUST release it, which is done at the end of this
+    *   subroutine.
     */
    Dmsg0(100, "just before acquire_device\n");
     */
    Dmsg0(100, "just before acquire_device\n");
-   if (!(dev=acquire_device_for_append(jcr, dev, block))) {
+   if (!acquire_device_for_append(dcr)) {
       set_jcr_job_status(jcr, JS_ErrorTerminated);
       set_jcr_job_status(jcr, JS_ErrorTerminated);
-      free_block(block);
       return;
    }
       return;
    }
+   block = jcr->dcr->block;
 
    Dmsg0(100, "Just after acquire_device_for_append\n");
    /*
     * Write Begin Session Record
     */
 
    Dmsg0(100, "Just after acquire_device_for_append\n");
    /*
     * Write Begin Session Record
     */
-   if (!write_session_label(jcr, block, SOS_LABEL)) {
+   if (!write_session_label(dcr, SOS_LABEL)) {
       set_jcr_job_status(jcr, JS_ErrorTerminated);
       Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
       set_jcr_job_status(jcr, JS_ErrorTerminated);
       Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
-        strerror_dev(dev));
-      ok = FALSE;
+         strerror_dev(dev));
+      ok = false;
    }
    }
-   Pmsg0(-1, "Wrote Start Of Session label.\n");
+   Pmsg0(-1, "Wrote Start of Session label.\n");
 
    memset(&rec, 0, sizeof(rec));
    rec.data = get_memory(100000);     /* max record size */
 
    memset(&rec, 0, sizeof(rec));
    rec.data = get_memory(100000);     /* max record size */
@@ -1143,116 +1820,158 @@ This may take a long time -- hours! ...\n\n");
 #define REC_SIZE 32768
    rec.data_len = REC_SIZE;
 
 #define REC_SIZE 32768
    rec.data_len = REC_SIZE;
 
-   /* 
-    * Generate data as if from File daemon, write to device   
+   /*
+    * Put some random data in the record
+    */
+   fd = open("/dev/urandom", O_RDONLY);
+   if (fd) {
+      read(fd, rec.data, rec.data_len);
+      close(fd);
+   } else {
+      uint32_t *p = (uint32_t *)rec.data;
+      srandom(time(NULL));
+      for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
+         p[i] = random();
+      }
+   }
+
+   /*
+    * Generate data as if from File daemon, write to device
     */
     */
-   jcr->VolFirstIndex = 0;
-   time(&jcr->run_time);             /* start counting time for rates */
-   Pmsg0(-1, "Begin writing records to first tape ...\n");
+   jcr->dcr->VolFirstIndex = 0;
+   time(&jcr->run_time);              /* start counting time for rates */
+   if (simple) {
+      Pmsg0(-1, "Begin writing Bacula records to tape ...\n");
+   } else {
+      Pmsg0(-1, "Begin writing Bacula records to first tape ...\n");
+   }
    for (file_index = 0; ok && !job_canceled(jcr); ) {
       rec.VolSessionId = jcr->VolSessionId;
       rec.VolSessionTime = jcr->VolSessionTime;
       rec.FileIndex = ++file_index;
       rec.Stream = STREAM_FILE_DATA;
 
    for (file_index = 0; ok && !job_canceled(jcr); ) {
       rec.VolSessionId = jcr->VolSessionId;
       rec.VolSessionTime = jcr->VolSessionTime;
       rec.FileIndex = ++file_index;
       rec.Stream = STREAM_FILE_DATA;
 
-      /* 
-       * Fill the buffer with the file_index negated. Negation ensures that
-       *   more bits are turned on.
-       */
-      uint64_t *lp = (uint64_t *)rec.data;
-      for (uint32_t i=0; i < (rec.data_len-sizeof(uint64_t))/sizeof(uint64_t); i++) {
-        *lp++ = ~file_index;
+      /* Mix up the data just a bit */
+      uint32_t *lp = (uint32_t *)rec.data;
+      lp[0] += lp[13];
+      for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
+         lp[i] += lp[i-1];
       }
 
       }
 
-      Dmsg4(250, "before writ_rec FI=%d SessId=%d Strm=%s len=%d\n",
-        rec.FileIndex, rec.VolSessionId, stream_to_ascii(rec.Stream, rec.FileIndex), 
-        rec.data_len);
-       
+      Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
+         rec.FileIndex, rec.VolSessionId, stream_to_ascii(rec.Stream, rec.FileIndex),
+         rec.data_len);
+
       while (!write_record_to_block(block, &rec)) {
       while (!write_record_to_block(block, &rec)) {
-        /*
-         * When we get here we have just filled a block
-         */
+         /*
+          * When we get here we have just filled a block
+          */
          Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
          Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
-                   rec.remainder);
-
-        /* Write block to tape */
-        if (!flush_block(block, 1)) {
-           return;
-        }
-
-        /* Every 5000 blocks (approx 322MB) report where we are.
-         */
-        if ((block->BlockNumber % 5000) == 0) {
-           now = time(NULL);
-           now -= jcr->run_time;
-           if (now <= 0) {
-              now = 1;
-           }
-           kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
-            Pmsg3(-1, "Wrote block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
-              edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
-        }
-        /* Every 15000 blocks (approx 1GB) write an EOF.
-         */
-        if ((block->BlockNumber % 15000) == 0) {
+                    rec.remainder);
+
+         /* Write block to tape */
+         if (!flush_block(block, 1)) {
+            break;
+         }
+
+         /* Every 5000 blocks (approx 322MB) report where we are.
+          */
+         if ((block->BlockNumber % 5000) == 0) {
+            now = time(NULL);
+            now -= jcr->run_time;
+            if (now <= 0) {
+               now = 1;          /* prevent divide error */
+            }
+            kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
+            Pmsg4(-1, "Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n",
+               block->BlockNumber, dev->block_num,
+               edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
+         }
+         /* Every 15000 blocks (approx 1GB) write an EOF.
+          */
+         if ((block->BlockNumber % 15000) == 0) {
             Pmsg0(-1, "Flush block, write EOF\n");
             Pmsg0(-1, "Flush block, write EOF\n");
-           flush_block(block, 0);
-           weof_dev(dev, 1);
-        }
-
-        /* Get out after writing 10 blocks to the second tape */
-        if (++BlockNumber > 10 && stop != 0) {      /* get out */
-           break;    
-        }
+            flush_block(block, 0);
+            weof_dev(dev, 1);
+         }
+
+         /* Get out after writing 10 blocks to the second tape */
+         if (++BlockNumber > 10 && stop != 0) {      /* get out */
+            break;
+         }
       }
       if (!ok) {
          Pmsg0(000, _("Not OK\n"));
       }
       if (!ok) {
          Pmsg0(000, _("Not OK\n"));
-        break;
+         break;
       }
       jcr->JobBytes += rec.data_len;   /* increment bytes this job */
       Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
       }
       jcr->JobBytes += rec.data_len;   /* increment bytes this job */
       Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
-        FI_to_ascii(rec.FileIndex), rec.VolSessionId, 
-        stream_to_ascii(rec.Stream, rec.FileIndex), rec.data_len);
+         FI_to_ascii(rec.FileIndex), rec.VolSessionId,
+         stream_to_ascii(rec.Stream, rec.FileIndex), rec.data_len);
 
       /* Get out after writing 10 blocks to the second tape */
 
       /* Get out after writing 10 blocks to the second tape */
-      if (BlockNumber > 10 && stop != 0) {     /* get out */
+      if (BlockNumber > 10 && stop != 0) {      /* get out */
          Pmsg0(-1, "Done writing ...\n");
          Pmsg0(-1, "Done writing ...\n");
-        break;    
+         break;
       }
    }
       }
    }
-   if (stop > 0) {
+   if (vol_num > 1) {
       Dmsg0(100, "Write_end_session_label()\n");
       /* Create Job status for end of session label */
       if (!job_canceled(jcr) && ok) {
       Dmsg0(100, "Write_end_session_label()\n");
       /* Create Job status for end of session label */
       if (!job_canceled(jcr) && ok) {
-        set_jcr_job_status(jcr, JS_Terminated);
+         set_jcr_job_status(jcr, JS_Terminated);
       } else if (!ok) {
       } else if (!ok) {
-        set_jcr_job_status(jcr, JS_ErrorTerminated);
+         set_jcr_job_status(jcr, JS_ErrorTerminated);
       }
       }
-      if (!write_session_label(jcr, block, EOS_LABEL)) {
+      if (!write_session_label(dcr, EOS_LABEL)) {
          Pmsg1(000, _("Error writting end session label. ERR=%s\n"), strerror_dev(dev));
          Pmsg1(000, _("Error writting end session label. ERR=%s\n"), strerror_dev(dev));
-        ok = FALSE;
+         ok = false;
       }
       /* Write out final block of this session */
       }
       /* Write out final block of this session */
-      if (!write_block_to_device(jcr, dev, block)) {
-         Pmsg0(-1, _("Set ok=FALSE after write_block_to_device.\n"));
-        ok = FALSE;
+      if (!write_block_to_device(dcr)) {
+         Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
+         ok = false;
       }
       }
-      Pmsg0(-1, "Wrote End Of Session label.\n");
-   }
+      Pmsg0(-1, _("Wrote End of Session label.\n"));
 
 
-   /* Release the device */
-   if (!release_device(jcr, dev)) {
-      Pmsg0(-1, _("Error in release_device\n"));
-      ok = FALSE;
+      /* Save last block info for second tape */
+      last_block_num2 = last_block_num;
+      last_file2 = last_file;
+      if (last_block2) {
+         free_block(last_block2);
+      }
+      last_block2 = dup_block(last_block);
+   }
+
+   sprintf(buf, "%s/btape.state", working_directory);
+   fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
+   if (fd >= 0) {
+      write(fd, &btape_state_level, sizeof(btape_state_level));
+      write(fd, &simple, sizeof(simple));
+      write(fd, &last_block_num1, sizeof(last_block_num1));
+      write(fd, &last_block_num2, sizeof(last_block_num2));
+      write(fd, &last_file1, sizeof(last_file1));
+      write(fd, &last_file2, sizeof(last_file2));
+      write(fd, last_block1->buf, last_block1->buf_len);
+      write(fd, last_block2->buf, last_block2->buf_len);
+      write(fd, first_block->buf, first_block->buf_len);
+      close(fd);
+      Pmsg2(-1, "Wrote state file last_block_num1=%d last_block_num2=%d\n",
+         last_block_num1, last_block_num2);
+   } else {
+      berrno be;
+      Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
+                 be.strerror());
    }
 
    }
 
-   free_block(block);
-   free_memory(rec.data);
-   Pmsg0(-1, _("\n\nDone filling tape. Now beginning re-read of tape ...\n"));
+   Pmsg4(-1, _("\n\nDone filling tape%s at %d:%d. Now beginning re-read of %stape ...\n"),
+      simple?"":"s", jcr->dcr->dev->file, jcr->dcr->dev->block_num, simple?"":"first ");
 
 
-   dump_block(last_block, _("Last block written to tape.\n"));
+   jcr->dcr->block = block;
+   do_unfill();
 
 
-   unfillcmd();
+   dev->min_block_size = min_block_size;
+   free_memory(rec.data);
 }
 
 /*
 }
 
 /*
@@ -1263,195 +1982,244 @@ This may take a long time -- hours! ...\n\n");
  */
 static void unfillcmd()
 {
  */
 static void unfillcmd()
 {
-   DEV_BLOCK *block;
+   int fd;
+
+   last_block1 = new_block(dev);
+   last_block2 = new_block(dev);
+   first_block = new_block(dev);
+   sprintf(buf, "%s/btape.state", working_directory);
+   fd = open(buf, O_RDONLY);
+   if (fd >= 0) {
+      uint32_t state_level;
+      read(fd, &state_level, sizeof(btape_state_level));
+      read(fd, &simple, sizeof(simple));
+      read(fd, &last_block_num1, sizeof(last_block_num1));
+      read(fd, &last_block_num2, sizeof(last_block_num2));
+      read(fd, &last_file1, sizeof(last_file1));
+      read(fd, &last_file2, sizeof(last_file2));
+      read(fd, last_block1->buf, last_block1->buf_len);
+      read(fd, last_block2->buf, last_block2->buf_len);
+      read(fd, first_block->buf, first_block->buf_len);
+      close(fd);
+      if (state_level != btape_state_level) {
+          Pmsg0(-1, "\nThe state file level has changed. You must redo\n"
+                  "the fill command.\n");
+          return;
+       }
+   } else {
+      berrno be;
+      Pmsg2(-1, "\nCould not find the state file: %s ERR=%s\n"
+             "You must redo the fill command.\n", buf, be.strerror());
+      return;
+   }
+   do_unfill();
+   this_block = NULL;
+}
+
+static void do_unfill()
+{
+   DEV_BLOCK *block = dcr->block;
+   bool autochanger;
 
    dumped = 0;
    VolBytes = 0;
    LastBlock = 0;
 
    dumped = 0;
    VolBytes = 0;
    LastBlock = 0;
-   block = new_block(dev);
 
 
+   Dmsg0(20, "Enter do_unfill\n");
    dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
    dev->capabilities &= ~CAP_LABEL;   /* don't label anything here */
 
    end_of_tape = 0;
 
    dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
    dev->capabilities &= ~CAP_LABEL;   /* don't label anything here */
 
    end_of_tape = 0;
 
+   time(&jcr->run_time);              /* start counting time for rates */
+   stop = 0;
+   file_index = 0;
+   if (last_block) {
+      free_block(last_block);
+   }
+   last_block_num = last_block_num1;
+   last_file = last_file1;
+   last_block = last_block1;
+
    if (!simple) {
    if (!simple) {
+      /* Multiple Volume tape */
       /* Close device so user can use autochanger if desired */
       if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
       /* Close device so user can use autochanger if desired */
       if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
-        offline_dev(dev);
+         offline_dev(dev);
+      }
+      autochanger = autoload_device(dcr, 1, NULL);
+      if (!autochanger) {
+         force_close_dev(dev);
+         get_cmd(_("Mount first tape. Press enter when ready: "));
       }
       }
-      force_close_dev(dev);
-      get_cmd(_("Mount first tape. Press enter when ready: ")); 
-   
       free_vol_list(jcr);
       free_vol_list(jcr);
+      jcr->dcr = new_dcr(jcr, dev);
       set_volume_name("TestVolume1", 1);
       jcr->bsr = NULL;
       create_vol_list(jcr);
       close_dev(dev);
       set_volume_name("TestVolume1", 1);
       jcr->bsr = NULL;
       create_vol_list(jcr);
       close_dev(dev);
-      dev->state &= ~ST_READ;
-      if (!acquire_device_for_read(jcr, dev, block)) {
+      dev->state &= ~(ST_READ|ST_APPEND);
+      dev->num_writers = 0;
+      if (!acquire_device_for_read(dcr)) {
          Pmsg1(-1, "%s", dev->errmsg);
          Pmsg1(-1, "%s", dev->errmsg);
-        return;
+         goto bail_out;
       }
    }
       }
    }
-
-   time(&jcr->run_time);             /* start counting time for rates */
-   stop = 0;
-   file_index = 0;
-   if (!simple) {
-      /* Read all records and then second tape */
-      read_records(jcr, dev, record_cb, my_mount_next_read_volume);
-   } else {
-      /*
-       * Simplified test, we simply fsf to file, then read the
-       * last block and make sure it is the same as the saved block.
-       */
-      Pmsg0(000, "Rewinding tape ...\n");
-      if (!rewind_dev(dev)) {
-         Pmsg1(-1, _("Error rewinding: ERR=%s\n"), strerror_dev(dev));
-        goto bail_out;
-      }
-      if (last_file > 0) {
-         Pmsg1(000, "Forward spacing to last file=%u\n", last_file);
-        if (!fsf_dev(dev, last_file)) {
-            Pmsg1(-1, _("Error in FSF: ERR=%s\n"), strerror_dev(dev));
-           goto bail_out;
-        }
-      }
-      Pmsg1(-1, _("Forward space to file %u complete. Reading blocks ...\n"), 
-           last_file);
-      Pmsg1(-1, _("Now reading to block %u.\n"), last_block_num);
-      for (uint32_t i=0; i <= last_block_num; i++) {
-        if (!read_block_from_device(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
-            Pmsg1(-1, _("Error reading blocks: ERR=%s\n"), strerror_dev(dev));
-            Pmsg2(-1, _("Wanted block %u error at block %u\n"), last_block_num, i);
-           goto bail_out;
-        }
-        if (i > 0 && i % 1000 == 0) {
-            Pmsg1(-1, _("At block %u\n"), i);
-        }
-      }
-      if (last_block) {
-         dump_block(last_block, _("Last block written"));
-         dump_block(block, _("Block read back"));
-         Pmsg0(-1, _("Except for the buffer address, the contents of\n"
-                     "the above two block dumps should be the same.\n"
-                     "If not you have a problem ...\n"));
+   /*
+    * We now have the first tape mounted.
+    * Note, re-reading last block may have caused us to
+    *   loose track of where we are (block number unknown).
+    */
+   if (!rewind_dev(dev)) {                /* get to a known place on tape */
+      goto bail_out;
+   }
+   /* Read the first 10000 records */
+   Pmsg0(-1, _("Reading the first 10000 records.\n"));
+   quickie_count = 0;
+   read_records(dcr, quickie_cb, my_mount_next_read_volume);
+   Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
+         last_file, last_block_num);
+   if (!reposition_dev(dev, last_file, last_block_num)) {
+      Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
+      goto bail_out;
+   }
+   Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
+   if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
+      Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
+      goto bail_out;
+   }
+   if (compare_blocks(last_block, block)) {
+      if (simple) {
+         Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
+      } else {
+         Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
       }
    }
       }
    }
+   if (simple) {
+      goto bail_out;
+   }
 
 
-bail_out:
-   free_block(block);
+   /* restore info for last block on second Volume */
+   last_block_num = last_block_num2;
+   last_file = last_file2;
+   last_block = last_block2;
 
 
-   Pmsg0(000, _("Done with reread of fill data.\n"));
-}
+   /* Multiple Volume tape */
+   /* Close device so user can use autochanger if desired */
+   if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
+      offline_dev(dev);
+   }
 
 
-/* 
- * We are called here from "unfill" for each record on the tape.
- */
-static void record_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec)
-{
-   SESSION_LABEL label;
-
-   if (stop > 1 && !dumped) {        /* on second tape */
-      dumped = 1;
-      dump_block(block, "First block on second tape");
-      Pmsg4(-1, "Blk: FileIndex=%d: block=%u size=%d vol=%s\n", 
-          rec->FileIndex, block->BlockNumber, block->block_len, dev->VolHdr.VolName);
-      Pmsg6(-1, "   Rec: VId=%d VT=%d FI=%s Strm=%s len=%d state=%x\n",
-          rec->VolSessionId, rec->VolSessionTime, 
-          FI_to_ascii(rec->FileIndex), stream_to_ascii(rec->Stream, rec->FileIndex),
-          rec->data_len, rec->state);
-   }
-   if (rec->FileIndex < 0) {
-      if (verbose > 1) {
-        dump_label_record(dev, rec, 1);
-      }
-      switch (rec->FileIndex) {
-      case PRE_LABEL:
-         Pmsg0(-1, "Volume is prelabeled. This tape cannot be scanned.\n");
-        return;
-      case VOL_LABEL:
-        unser_volume_label(dev, rec);
-         Pmsg3(-1, "VOL_LABEL: block=%u size=%d vol=%s\n", block->BlockNumber, 
-           block->block_len, dev->VolHdr.VolName);
-        stop++;
-        break;
-      case SOS_LABEL:
-        unser_session_label(&label, rec);
-         Pmsg1(-1, "SOS_LABEL: JobId=%u\n", label.JobId);
-        break;
-      case EOS_LABEL:
-        unser_session_label(&label, rec);
-         Pmsg2(-1, "EOS_LABEL: block=%u JobId=%u\n", block->BlockNumber, 
-           label.JobId);
-        break;
-      case EOM_LABEL:
-         Pmsg0(-1, "EOM_LABEL:\n");
-        break;
-      case EOT_LABEL:             /* end of all tapes */
-        char ec1[50];
-
-        if (LastBlock != block->BlockNumber) {
-           VolBytes += block->block_len;
-        }
-        LastBlock = block->BlockNumber;
-        now = time(NULL);
-        now -= jcr->run_time;
-        if (now <= 0) {
-           now = 1;
-        }
-        kbs = (double)VolBytes / (1000 * now);
-         Pmsg3(000, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
-                 edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
-
-         Pmsg0(000, "End of all tapes.\n");
-
-        break;
-      default:
-        break;
-      }
-      return;
+   free_vol_list(jcr);
+   set_volume_name("TestVolume2", 2);
+   jcr->bsr = NULL;
+   create_vol_list(jcr);
+   autochanger = autoload_device(dcr, 1, NULL);
+   if (!autochanger) {
+      force_close_dev(dev);
+      get_cmd(_("Mount second tape. Press enter when ready: "));
    }
    }
-   if (++file_index != rec->FileIndex) {
-      Pmsg3(000, "Incorrect FileIndex in Block %u. Got %d, expected %d.\n", 
-        block->BlockNumber, rec->FileIndex, file_index);
+
+   dev->clear_read();
+   if (!acquire_device_for_read(dcr)) {
+      Pmsg1(-1, "%s", dev->errmsg);
+      goto bail_out;
    }
    }
-   /*
-    * Now check that the right data is in the record.
+
+   /* Space to "first" block which is last block not written
+    * on the previous tape.
     */
     */
-   uint64_t *lp = (uint64_t *)rec->data;
-   uint64_t val = ~file_index;
-   for (uint32_t i=0; i < (REC_SIZE-sizeof(uint64_t))/sizeof(uint64_t); i++) {
-      if (*lp++ != val) {
-         Pmsg2(000, "Record %d contains bad data in Block %u.\n",
-           file_index, block->BlockNumber);
-        break;
-      }
+   Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
+   if (!reposition_dev(dev, 0, 1)) {
+      Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
+      goto bail_out;
+   }
+   Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
+   if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
+      Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
+      goto bail_out;
+   }
+   if (compare_blocks(first_block, block)) {
+      Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
    }
 
    }
 
-   if (LastBlock != block->BlockNumber) {
-      VolBytes += block->block_len;
+   /* Now find and compare the last block */
+   Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
+         last_file, last_block_num);
+   if (!reposition_dev(dev, last_file, last_block_num)) {
+      Pmsg1(-1, "Reposition error. ERR=%s\n", strerror_dev(dev));
+      goto bail_out;
    }
    }
-   if ((block->BlockNumber != LastBlock) && (block->BlockNumber % 50000) == 0) {
-      char ec1[50];
-      now = time(NULL);
-      now -= jcr->run_time;
-      if (now <= 0) {
-        now = 1;
-      }
-      kbs = (double)VolBytes / (1000 * now);
-      Pmsg3(000, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
-              edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
+   Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
+   if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
+      Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
+      goto bail_out;
    }
    }
-   LastBlock = block->BlockNumber;
-   if (end_of_tape) {
-      Pmsg1(000, "End of all blocks. Block=%u\n", block->BlockNumber);
+   if (compare_blocks(last_block, block)) {
+      Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
+   }
+
+bail_out:
+   free_block(last_block1);
+   free_block(last_block2);
+   free_block(first_block);
+}
+
+/* Read 10000 records then stop */
+static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
+{
+   DEVICE *dev = dcr->dev;
+   if (dev->file != 0) {
+      Pmsg3(-1, "ERROR! device at %d:%d count=%d\n", dev->file, dev->block_num,
+         quickie_count);
+      return false;
    }
    }
+   quickie_count++;
+   if (quickie_count == 10000) {
+      Pmsg2(-1, "1000 records read now at %d:%d\n", dev->file, dev->block_num);
+   }
+   return quickie_count < 10000;
+}
+
+static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
+{
+   char *p, *q;
+   uint32_t CheckSum, block_len;
+   ser_declare;
+
+   p = last_block->buf;
+   q = block->buf;
+   unser_begin(q, BLKHDR2_LENGTH);
+   unser_uint32(CheckSum);
+   unser_uint32(block_len);
+   while (q < (block->buf+block_len)) {
+      if (*p == *q) {
+         p++;
+         q++;
+         continue;
+      }
+      Pmsg0(-1, "\n");
+      dump_block(last_block, _("Last block written"));
+      Pmsg0(-1, "\n");
+      dump_block(block, _("Block read back"));
+      Pmsg1(-1, "\n\nThe blocks differ at byte %u\n", p - last_block->buf);
+      Pmsg0(-1, "\n\n!!!! The last block written and the block\n"
+                "that was read back differ. The test FAILED !!!!\n"
+                "This must be corrected before you use Bacula\n"
+                "to write multi-tape Volumes.!!!!\n");
+      return false;
+   }
+   if (verbose) {
+      dump_block(last_block, _("Last block written"));
+      dump_block(block, _("Block read back"));
+   }
+   return true;
 }
 
 
 
 }
 
 
 
+
+
 /*
  * Write current block to tape regardless of whether or
  *   not it is full. If the tape fills, attempt to
 /*
  * Write current block to tape regardless of whether or
  *   not it is full. If the tape fills, attempt to
@@ -1460,68 +2228,84 @@ static void record_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec)
 static int flush_block(DEV_BLOCK *block, int dump)
 {
    char ec1[50];
 static int flush_block(DEV_BLOCK *block, int dump)
 {
    char ec1[50];
-   lock_device(dev);
    DEV_BLOCK *tblock;
    uint32_t this_file, this_block_num;
 
    DEV_BLOCK *tblock;
    uint32_t this_file, this_block_num;
 
+   lock_device(dev);
    if (!this_block) {
       this_block = new_block(dev);
    }
    if (!this_block) {
       this_block = new_block(dev);
    }
+   if (!last_block) {
+      last_block = new_block(dev);
+   }
    /* Copy block */
    /* Copy block */
-   free_memory(this_block->buf);    
-   memcpy(this_block, block, sizeof(DEV_BLOCK));
-   this_block->buf = get_memory(block->buf_len);
-   memcpy(this_block->buf, block->buf, this_block->buf_len);
    this_file = dev->file;
    this_block_num = dev->block_num;
    this_file = dev->file;
    this_block_num = dev->block_num;
-   if (!write_block_to_dev(jcr, dev, block)) {
-      Pmsg0(000, strerror_dev(dev));           
-      Pmsg3(000, "Block not written: FileIndex=%u Block=%u Size=%u\n", 
-        (unsigned)file_index, block->BlockNumber, block->block_len);
-      Pmsg2(000, "last_block_num=%u this_block_num=%d\n", last_block_num,
-        this_block_num);
-      if (dump) {
+   if (!write_block_to_dev(dcr)) {
+      Pmsg3(000, "Last block at: %u:%u this_dev_block_num=%d\n",
+                  last_file, last_block_num, this_block_num);
+      if (vol_num == 1) {
+         /*
+          * This is 1st tape, so save first tape info separate
+          *  from second tape info
+          */
+         last_block_num1 = last_block_num;
+         last_file1 = last_file;
+         last_block1 = dup_block(last_block);
+         last_block2 = dup_block(last_block);
+         first_block = dup_block(block); /* first block second tape */
+      }
+      if (verbose) {
+         Pmsg3(000, "Block not written: FileIndex=%u blk_block=%u Size=%u\n",
+            (unsigned)file_index, block->BlockNumber, block->block_len);
+         dump_block(last_block, "Last block written");
+         Pmsg0(-1, "\n");
          dump_block(block, "Block not written");
       }
       if (stop == 0) {
          dump_block(block, "Block not written");
       }
       if (stop == 0) {
-        eot_block = block->BlockNumber;
-        eot_block_len = block->block_len;
-        eot_FileIndex = file_index;
+         eot_block = block->BlockNumber;
+         eot_block_len = block->block_len;
+         eot_FileIndex = file_index;
+         stop = 1;
       }
       now = time(NULL);
       now -= jcr->run_time;
       if (now <= 0) {
       }
       now = time(NULL);
       now -= jcr->run_time;
       if (now <= 0) {
-        now = 1;
+         now = 1;                     /* don't divide by zero */
       }
       kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
       vol_size = dev->VolCatInfo.VolCatBytes;
       }
       kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
       vol_size = dev->VolCatInfo.VolCatBytes;
-      Pmsg2(000, "End of tape. VolumeCapacity=%s. Write rate = %.1f KB/s\n", 
-        edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
+      Pmsg4(000, "End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n",
+         dev->file, dev->block_num,
+         edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
 
       if (simple) {
 
       if (simple) {
-        stop = -1;                   /* stop, but do simplified test */
+         stop = -1;                   /* stop, but do simplified test */
       } else {
       } else {
-        /* Full test in progress */
-        if (!fixup_device_block_write_error(jcr, dev, block)) {
+         /* Full test in progress */
+         if (!fixup_device_block_write_error(jcr->dcr)) {
             Pmsg1(000, _("Cannot fixup device error. %s\n"), strerror_dev(dev));
             Pmsg1(000, _("Cannot fixup device error. %s\n"), strerror_dev(dev));
-           ok = FALSE;
-           unlock_device(dev);
-           return 0;
-        }
-        stop = 1;                                                     
-        BlockNumber = 0;             /* start counting for second tape */
+            ok = false;
+            unlock_device(dev);
+            return 0;
+         }
+         BlockNumber = 0;             /* start counting for second tape */
       }
       unlock_device(dev);
       }
       unlock_device(dev);
-      return 1;                      /* end of tape reached */
+      return 1;                       /* end of tape reached */
    }
 
    }
 
+   /* Save contents after write so that the header is serialized */
+   memcpy(this_block->buf, block->buf, this_block->buf_len);
+
    /*
    /*
-    * Toggle between two allocated blocks for efficiency.
+    * Note, we always read/write to block, but we toggle
+    *  copying it to one or another of two allocated blocks.
     * Switch blocks so that the block just successfully written is
     * Switch blocks so that the block just successfully written is
-    *  always in last_block. 
+    *  always in last_block.
     */
    tblock = last_block;
     */
    tblock = last_block;
-   last_block = this_block; 
+   last_block = this_block;
    this_block = tblock;
    last_file = this_file;
    last_block_num = this_block_num;
    this_block = tblock;
    last_file = this_file;
    last_block_num = this_block_num;
@@ -1531,14 +2315,14 @@ static int flush_block(DEV_BLOCK *block, int dump)
 }
 
 
 }
 
 
-/* 
+/*
  * First we label the tape, then we fill
  *  it with data get a new tape and write a few blocks.
  * First we label the tape, then we fill
  *  it with data get a new tape and write a few blocks.
- */                           
+ */
 static void qfillcmd()
 {
 static void qfillcmd()
 {
-   DEV_BLOCK *block;
-   DEV_RECORD *rec;
+   DEV_BLOCK *block = dcr->block;
+   DEV_RECORD *rec = dcr->rec;
    int i, count;
 
    Pmsg0(0, "Test writing blocks of 64512 bytes to tape.\n");
    int i, count;
 
    Pmsg0(0, "Test writing blocks of 64512 bytes to tape.\n");
@@ -1550,9 +2334,7 @@ static void qfillcmd()
       count = 1000;
    }
 
       count = 1000;
    }
 
-   sm_check(__FILE__, __LINE__, False);
-   block = new_block(dev);
-   rec = new_record();
+   sm_check(__FILE__, __LINE__, false);
 
    i = block->buf_len - 100;
    ASSERT (i > 0);
 
    i = block->buf_len - 100;
    ASSERT (i > 0);
@@ -1560,78 +2342,138 @@ static void qfillcmd()
    memset(rec->data, i & 0xFF, i);
    rec->data_len = i;
    rewindcmd();
    memset(rec->data, i & 0xFF, i);
    rec->data_len = i;
    rewindcmd();
-   Pmsg1(0, "Begin writing %d blocks to tape ...\n", count);
+   Pmsg1(0, "Begin writing %d Bacula blocks to tape ...\n", count);
    for (i=0; i < count; i++) {
       if (i % 100 == 0) {
          printf("+");
    for (i=0; i < count; i++) {
       if (i % 100 == 0) {
          printf("+");
+         fflush(stdout);
       }
       if (!write_record_to_block(block, rec)) {
       }
       if (!write_record_to_block(block, rec)) {
-         Pmsg0(0, _("Error writing record to block.\n")); 
-        goto bail_out;
+         Pmsg0(0, _("Error writing record to block.\n"));
+         goto bail_out;
       }
       }
-      if (!write_block_to_dev(jcr, dev, block)) {
-         Pmsg0(0, _("Error writing block to device.\n")); 
-        goto bail_out;
+      if (!write_block_to_dev(dcr)) {
+         Pmsg0(0, _("Error writing block to device.\n"));
+         goto bail_out;
       }
    }
    printf("\n");
    weofcmd();
       }
    }
    printf("\n");
    weofcmd();
-   weofcmd();
+   if (dev_cap(dev, CAP_TWOEOF)) {
+      weofcmd();
+   }
    rewindcmd();
    scan_blocks();
 
 bail_out:
    rewindcmd();
    scan_blocks();
 
 bail_out:
-   sm_check(__FILE__, __LINE__, False);
-   free_record(rec);
-   free_block(block);
-   sm_check(__FILE__, __LINE__, False);
-
+   sm_check(__FILE__, __LINE__, false);
 }
 
 }
 
+/*
+ * Fill a tape using raw write() command
+ */
 static void rawfill_cmd()
 {
 static void rawfill_cmd()
 {
-   DEV_BLOCK *block;
+   DEV_BLOCK *block = dcr->block;
    int stat;
    int fd;
    uint32_t block_num = 0;
    uint32_t *p;
    int my_errno;
    int stat;
    int fd;
    uint32_t block_num = 0;
    uint32_t *p;
    int my_errno;
+   uint32_t i;
 
 
-   block = new_block(dev);
    fd = open("/dev/urandom", O_RDONLY);
    if (fd) {
       read(fd, block->buf, block->buf_len);
    fd = open("/dev/urandom", O_RDONLY);
    if (fd) {
       read(fd, block->buf, block->buf_len);
+      close(fd);
    } else {
    } else {
-      Pmsg0(0, "Cannot open /dev/urandom.\n");
-      free_block(block);
-      return;
+      uint32_t *p = (uint32_t *)block->buf;
+      srandom(time(NULL));
+      for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
+         p[i] = random();
+      }
    }
    p = (uint32_t *)block->buf;
    }
    p = (uint32_t *)block->buf;
-   Pmsg1(0, "Begin writing blocks of %u bytes.\n", block->buf_len);
+   Pmsg1(0, "Begin writing raw blocks of %u bytes.\n", block->buf_len);
    for ( ;; ) {
       *p = block_num;
       stat = write(dev->fd, block->buf, block->buf_len);
       if (stat == (int)block->buf_len) {
    for ( ;; ) {
       *p = block_num;
       stat = write(dev->fd, block->buf, block->buf_len);
       if (stat == (int)block->buf_len) {
-        if ((block_num++ % 100) == 0) {
+         if ((block_num++ % 100) == 0) {
             printf("+");
             printf("+");
-        }
-        continue;
+            fflush(stdout);
+         }
+         p[0] += p[13];
+         for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
+            p[i] += p[i-1];
+         }
+         continue;
       }
       break;
    }
    my_errno = errno;
    printf("\n");
       }
       break;
    }
    my_errno = errno;
    printf("\n");
-   weofcmd();
+   berrno be;
    printf("Write failed at block %u. stat=%d ERR=%s\n", block_num, stat,
    printf("Write failed at block %u. stat=%d ERR=%s\n", block_num, stat,
-      strerror(my_errno));
-   free_block(block);
+      be.strerror(my_errno));
+   weofcmd();
+}
+
+
+/*
+ * Fill a tape using Bacula block writes
+ */
+static void bfill_cmd()
+{
+   DEV_BLOCK *block = dcr->block;
+   uint32_t block_num = 0;
+   uint32_t *p;
+   int my_errno;
+   int fd;
+   uint32_t i;
 
 
+   fd = open("/dev/urandom", O_RDONLY);
+   if (fd) {
+      read(fd, block->buf, block->buf_len);
+      close(fd);
+   } else {
+      uint32_t *p = (uint32_t *)block->buf;
+      srandom(time(NULL));
+      for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
+         p[i] = random();
+      }
+   }
+   p = (uint32_t *)block->buf;
+   Pmsg1(0, "Begin writing Bacula blocks of %u bytes.\n", block->buf_len);
+   for ( ;; ) {
+      *p = block_num;
+      block->binbuf = block->buf_len;
+      block->bufp = block->buf + block->binbuf;
+      if (!write_block_to_dev(dcr)) {
+         break;
+      }
+      if ((block_num++ % 100) == 0) {
+         printf("+");
+         fflush(stdout);
+      }
+      p[0] += p[13];
+      for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
+         p[i] += p[i-1];
+      }
+   }
+   my_errno = errno;
+   printf("\n");
+   printf("Write failed at block %u.\n", block_num);
+   weofcmd();
 }
 
 }
 
-struct cmdstruct { char *key; void (*func)(); char *help; }; 
+
+struct cmdstruct { const char *key; void (*func)(); const char *help; };
 static struct cmdstruct commands[] = {
 static struct cmdstruct commands[] = {
+ {"autochanger", autochangercmd, "test autochanger"},
  {"bsf",        bsfcmd,       "backspace file"},
  {"bsr",        bsrcmd,       "backspace record"},
  {"bsf",        bsfcmd,       "backspace file"},
  {"bsr",        bsrcmd,       "backspace record"},
+ {"bfill",      bfill_cmd,    "fill tape using Bacula writes"},
  {"cap",        capcmd,       "list device capabilities"},
  {"clear",      clearcmd,     "clear tape errors"},
  {"eod",        eodcmd,       "go to end of Bacula data for append"},
  {"cap",        capcmd,       "list device capabilities"},
  {"clear",      clearcmd,     "clear tape errors"},
  {"eod",        eodcmd,       "go to end of Bacula data for append"},
@@ -1643,41 +2485,42 @@ static struct cmdstruct commands[] = {
  {"help",       helpcmd,      "print this command"},
  {"label",      labelcmd,     "write a Bacula label to the tape"},
  {"load",       loadcmd,      "load a tape"},
  {"help",       helpcmd,      "print this command"},
  {"label",      labelcmd,     "write a Bacula label to the tape"},
  {"load",       loadcmd,      "load a tape"},
- {"quit",       quitcmd,      "quit btape"},   
+ {"quit",       quitcmd,      "quit btape"},
  {"rawfill",    rawfill_cmd,  "use write() to fill tape"},
  {"readlabel",  readlabelcmd, "read and print the Bacula tape label"},
  {"rectest",    rectestcmd,   "test record handling functions"},
  {"rewind",     rewindcmd,    "rewind the tape"},
  {"rawfill",    rawfill_cmd,  "use write() to fill tape"},
  {"readlabel",  readlabelcmd, "read and print the Bacula tape label"},
  {"rectest",    rectestcmd,   "test record handling functions"},
  {"rewind",     rewindcmd,    "rewind the tape"},
- {"scan",       scancmd,      "read() tape block by block to EOT and report"}, 
+ {"scan",       scancmd,      "read() tape block by block to EOT and report"},
  {"scanblocks", scan_blocks,  "Bacula read block by block to EOT and report"},
  {"status",     statcmd,      "print tape status"},
  {"test",       testcmd,      "General test Bacula tape functions"},
  {"weof",       weofcmd,      "write an EOF on the tape"},
  {"scanblocks", scan_blocks,  "Bacula read block by block to EOT and report"},
  {"status",     statcmd,      "print tape status"},
  {"test",       testcmd,      "General test Bacula tape functions"},
  {"weof",       weofcmd,      "write an EOF on the tape"},
- {"wr",         wrcmd,        "write a single Bacula block"}, 
+ {"wr",         wrcmd,        "write a single Bacula block"},
  {"rr",         rrcmd,        "read a single record"},
  {"qfill",      qfillcmd,     "quick fill command"},
  {"rr",         rrcmd,        "read a single record"},
  {"qfill",      qfillcmd,     "quick fill command"},
-            };
+             };
 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
 
 static void
 do_tape_cmds()
 {
    unsigned int i;
 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
 
 static void
 do_tape_cmds()
 {
    unsigned int i;
-   int found;
+   bool found;
 
    while (get_cmd("*")) {
 
    while (get_cmd("*")) {
-      sm_check(__FILE__, __LINE__, False);
-      found = 0;
+      sm_check(__FILE__, __LINE__, false);
+      found = false;
+      parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
       for (i=0; i<comsize; i++)       /* search for command */
       for (i=0; i<comsize; i++)       /* search for command */
-        if (fstrsch(cmd,  commands[i].key)) {
-           (*commands[i].func)();    /* go execute command */
-           found = 1;
-           break;
-        }
+         if (argc > 0 && fstrsch(argk[0],  commands[i].key)) {
+            (*commands[i].func)();    /* go execute command */
+            found = true;
+            break;
+         }
       if (!found)
          Pmsg1(0, _("%s is an illegal command\n"), cmd);
       if (quit)
       if (!found)
          Pmsg1(0, _("%s is an illegal command\n"), cmd);
       if (quit)
-        break;
+         break;
    }
 }
 
    }
 }
 
@@ -1685,6 +2528,7 @@ static void helpcmd()
 {
    unsigned int i;
    usage();
 {
    unsigned int i;
    usage();
+   printf(_("Interactive commands:\n"));
    printf(_("  Command    Description\n  =======    ===========\n"));
    for (i=0; i<comsize; i++)
       printf("  %-10s %s\n", commands[i].key, commands[i].help);
    printf(_("  Command    Description\n  =======    ===========\n"));
    for (i=0; i<comsize; i++)
       printf("  %-10s %s\n", commands[i].key, commands[i].help);
@@ -1694,24 +2538,27 @@ static void helpcmd()
 static void usage()
 {
    fprintf(stderr, _(
 static void usage()
 {
    fprintf(stderr, _(
+"Copyright (C) 2000-2005 Kern Sibbald.\n"
 "\nVersion: " VERSION " (" BDATE ")\n\n"
 "\nVersion: " VERSION " (" BDATE ")\n\n"
-"Usage: btape [-c config_file] [-d debug_level] [device_name]\n"
+"Usage: btape <options> <device_name>\n"
+"       -b <file>   specify bootstrap file\n"
 "       -c <file>   set configuration file to file\n"
 "       -c <file>   set configuration file to file\n"
-"       -dnn        set debug level to nn\n"
+"       -d <nn>     set debug level to nn\n"
+"       -p          proceed inspite of I/O errors\n"
 "       -s          turn off signals\n"
 "       -s          turn off signals\n"
-"       -t          open the default tape device\n"
-"       -?          print this message.\n"  
+"       -v          be verbose\n"
+"       -?          print this message.\n"
 "\n"));
 
 }
 
 "\n"));
 
 }
 
-/*     
+/*
  * Get next input command from terminal.  This
  * routine is REALLY primitive, and should be enhanced
  * to have correct backspacing, etc.
  */
  * Get next input command from terminal.  This
  * routine is REALLY primitive, and should be enhanced
  * to have correct backspacing, etc.
  */
-int 
-get_cmd(char *prompt)
+int
+get_cmd(const char *prompt)
 {
    int i = 0;
    int ch;
 {
    int i = 0;
    int ch;
@@ -1721,16 +2568,16 @@ get_cmd(char *prompt)
     * up a bit.
     */
    cmd[i] = 0;
     * up a bit.
     */
    cmd[i] = 0;
-   while ((ch = fgetc(stdin)) != EOF) { 
+   while ((ch = fgetc(stdin)) != EOF) {
       if (ch == '\n') {
       if (ch == '\n') {
-        strip_trailing_junk(cmd);
-        return 1;
+         strip_trailing_junk(cmd);
+         return 1;
       } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
       } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
-        if (i > 0)
-           cmd[--i] = 0;
-        continue;
-      } 
-        
+         if (i > 0)
+            cmd[--i] = 0;
+         continue;
+      }
+
       cmd[i++] = ch;
       cmd[i] = 0;
    }
       cmd[i++] = ch;
       cmd[i] = 0;
    }
@@ -1739,56 +2586,95 @@ get_cmd(char *prompt)
 }
 
 /* Dummies to replace askdir.c */
 }
 
 /* Dummies to replace askdir.c */
-int    dir_get_volume_info(JCR *jcr, int writing) { return 1;}
-int    dir_update_volume_info(JCR *jcr, VOLUME_CAT_INFO *vol, int relabel) { return 1; }
-int    dir_create_jobmedia_record(JCR *jcr) { return 1; }
-int    dir_update_file_attributes(JCR *jcr, DEV_RECORD *rec) { return 1;}
-int    dir_send_job_status(JCR *jcr) {return 1;}
+bool    dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
+bool    dir_send_job_status(JCR *jcr) {return 1;}
+
+bool dir_update_volume_info(DCR *dcr, bool relabel)
+{
+   return 1;
+}
+
+
+bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw  writing)
+{
+   Dmsg0(20, "Enter dir_get_volume_info\n");
+   bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
+   return 1;
+}
 
 
+bool dir_create_jobmedia_record(DCR *dcr)
+{
+   dcr->WroteVol = false;
+   return 1;
+}
 
 
 
 
-int    dir_find_next_appendable_volume(JCR *jcr) 
-{ 
-   return 1; 
+bool dir_find_next_appendable_volume(DCR *dcr)
+{
+   Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
+   return dcr->VolumeName[0] != 0;
 }
 
 }
 
-int dir_ask_sysop_to_mount_volume(JCR *jcr, DEVICE *dev)
+bool dir_ask_sysop_to_mount_volume(DCR *dcr)
 {
 {
+   DEVICE *dev = dcr->dev;
+   Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
+   if (dcr->VolumeName[0] == 0) {
+      return dir_ask_sysop_to_create_appendable_volume(dcr);
+   }
    /* Close device so user can use autochanger if desired */
    if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
       offline_dev(dev);
    }
    force_close_dev(dev);
    Pmsg1(-1, "%s", dev->errmsg);           /* print reason */
    /* Close device so user can use autochanger if desired */
    if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
       offline_dev(dev);
    }
    force_close_dev(dev);
    Pmsg1(-1, "%s", dev->errmsg);           /* print reason */
-   fprintf(stderr, "Mount Volume \"%s\" on device %s and press return when ready: ",
-      jcr->VolumeName, dev_name(dev));
-   getchar();  
-   return 1;
+   if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
+      fprintf(stderr, "Mount second Volume on device %s and press return when ready: ",
+         dev->print_name());
+   } else {
+      fprintf(stderr, "Mount Volume \"%s\" on device %s and press return when ready: ",
+         dcr->VolumeName, dev->print_name());
+   }
+   getchar();
+   return true;
 }
 
 }
 
-int dir_ask_sysop_to_mount_next_volume(JCR *jcr, DEVICE *dev)
+bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
 {
 {
+   bool autochanger;
+   DEVICE *dev = dcr->dev;
+   Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
+   if (stop == 0) {
+      set_volume_name("TestVolume1", 1);
+   } else {
+      set_volume_name("TestVolume2", 2);
+   }
    /* Close device so user can use autochanger if desired */
    if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
       offline_dev(dev);
    }
    /* Close device so user can use autochanger if desired */
    if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
       offline_dev(dev);
    }
-   force_close_dev(dev);
-   fprintf(stderr, "Mount next Volume on device %s and press return when ready: ",
-      dev_name(dev));
-   getchar();  
-   set_volume_name("TestVolume2", 2);
+   autochanger = autoload_device(dcr, 1, NULL);
+   if (!autochanger) {
+      force_close_dev(dev);
+      fprintf(stderr, "Mount blank Volume on device %s and press return when ready: ",
+         dev->print_name());
+      getchar();
+   }
+   open_device(dcr);
    labelcmd();
    VolumeName = NULL;
    BlockNumber = 0;
    labelcmd();
    VolumeName = NULL;
    BlockNumber = 0;
-   stop = 1;
-   return 1;
+   return true;
 }
 
 }
 
-static int my_mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block)
+static bool my_mount_next_read_volume(DCR *dcr)
 {
    char ec1[50];
 {
    char ec1[50];
+   JCR *jcr = dcr->jcr;
+   DEV_BLOCK *block = dcr->block;
 
 
-   Pmsg1(000, "End of Volume \"%s\"\n", jcr->VolumeName);
+   Dmsg0(20, "Enter my_mount_next_read_volume\n");
+   Pmsg1(000, "End of Volume \"%s\"\n", dcr->VolumeName);
 
    if (LastBlock != block->BlockNumber) {
       VolBytes += block->block_len;
 
    if (LastBlock != block->BlockNumber) {
       VolBytes += block->block_len;
@@ -1801,11 +2687,11 @@ static int my_mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block)
    }
    kbs = (double)VolBytes / (1000.0 * (double)now);
    Pmsg3(-1, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
    }
    kbs = (double)VolBytes / (1000.0 * (double)now);
    Pmsg3(-1, "Read block=%u, VolBytes=%s rate=%.1f KB/s\n", block->BlockNumber,
-           edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
+            edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
 
 
-   if (strcmp(jcr->VolumeName, "TestVolume2") == 0) {
+   if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
       end_of_tape = 1;
       end_of_tape = 1;
-      return 0;
+      return false;
    }
 
    free_vol_list(jcr);
    }
 
    free_vol_list(jcr);
@@ -1813,18 +2699,21 @@ static int my_mount_next_read_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block)
    jcr->bsr = NULL;
    create_vol_list(jcr);
    close_dev(dev);
    jcr->bsr = NULL;
    create_vol_list(jcr);
    close_dev(dev);
-   dev->state &= ~ST_READ; 
-   if (!acquire_device_for_read(jcr, dev, block)) {
-      Pmsg2(0, "Cannot open Dev=%s, Vol=%s\n", dev_name(dev), jcr->VolumeName);
-      return 0;
+   dev->clear_read();
+   if (!acquire_device_for_read(dcr)) {
+      Pmsg2(0, "Cannot open Dev=%s, Vol=%s\n", dev->print_name(), dcr->VolumeName);
+      return false;
    }
    }
-   return 1;                      /* next volume mounted */
+   return true;                    /* next volume mounted */
 }
 
 }
 
-static void set_volume_name(char *VolName, int volnum) 
+static void set_volume_name(const char *VolName, int volnum)
 {
 {
+   DCR *dcr = jcr->dcr;
    VolumeName = VolName;
    vol_num = volnum;
    VolumeName = VolName;
    vol_num = volnum;
-   pm_strcpy(&jcr->VolumeName, VolName);
    bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
    bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
+   bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
+   bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
+   dcr->VolCatInfo.Slot = volnum;
 }
 }