dev->clear_opened();
    dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
-   Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
+   Dmsg2(100, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
    dev->initiated = true;
    
    return dev;
       bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
    }
 
-   Dmsg4(29, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
+   Dmsg4(100, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
          print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
    state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
    Slot = -1;          /* unknown slot */
 #endif
 
 
-   Dmsg0(29, "Open dev: device is tape\n");
+   Dmsg0(100, "Open dev: device is tape\n");
 
    get_autochanger_loaded_slot(dcr);
 
       if (m_fd < 0) {
          berrno be;
          dev_errno = errno;
-         Dmsg5(050, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n", 
+         Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n", 
               print_name(), omode, mode, errno, be.bstrerror());
       } else {
          /* Tape open, now rewind it */
-         Dmsg0(050, "Rewind after open\n");
+         Dmsg0(100, "Rewind after open\n");
          mt_com.mt_op = MTREW;
          mt_com.mt_count = 1;
          /* rewind only if dev is a tape */
             if (m_fd < 0) {
                berrno be;
                dev_errno = errno;
-               Dmsg5(050, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n", 
+               Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n", 
                      print_name(), omode, mode, errno, be.bstrerror());
                break;
             }
       stop_thread_timer(tid);
       tid = 0;
    }
-   Dmsg1(29, "open dev: tape %d opened\n", m_fd);
+   Dmsg1(100, "open dev: tape %d opened\n", m_fd);
 }
 
 
    openmode = omode;
    set_mode(omode);
    /* If creating file, give 0640 permissions */
-   Dmsg3(29, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode), 
+   Dmsg3(100, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode), 
          archive_name.c_str(), mode);
    /* Use system open() */
    if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
       dev_errno = errno;
       Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(), 
             be.bstrerror());
-      Dmsg1(29, "open failed: %s", errmsg);
+      Dmsg1(100, "open failed: %s", errmsg);
       Emsg0(M_FATAL, 0, errmsg);
    } else {
       dev_errno = 0;
       file = 0;
       file_addr = 0;
    }
-   Dmsg4(29, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n", 
+   Dmsg4(100, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n", 
       m_fd, part, num_dvd_parts, part_size);
 }
 
    /*
     * Handle opening of DVD Volume
     */     
-   Dmsg2(29, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n", 
+   Dmsg2(100, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n", 
          &dcr->VolCatInfo, mode_to_str(omode));
 
    /*
     * If we are not trying to access the last part, set mode to 
     *   OPEN_READ_ONLY as writing would be an error.
     */
-   Dmsg2(29, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
+   Dmsg2(100, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
    /* Now find the name of the part that we want to access */
    if (part <= num_dvd_parts) {
       omode = OPEN_READ_ONLY;
             return;
          }
          if (have_media()) {
-            Dmsg1(29, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
+            Dmsg1(100, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
          } else {
             Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
             Emsg0(M_FATAL, 0, errmsg);
       }
    }
    
-   Dmsg5(29, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n", 
+   Dmsg5(100, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n", 
       archive_name.c_str(), mode_to_str(omode),
       part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
    openmode = omode;
    
 
    /* If creating file, give 0640 permissions */
-   Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode), 
+   Dmsg3(100, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode), 
          archive_name.c_str(), mode);
    /* Use system open() */
    if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
             be.bstrerror());
       // Should this be set if we try the create/open below
       dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
-      Dmsg1(29, "open failed: %s", errmsg);
+      Dmsg1(100, "open failed: %s", errmsg);
       
       /* Previous open failed. See if we can recover */
       if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
           * level software thinks that we are extending a pre-existing
           * media. Reads for READ_ONLY will report immediately an EOF 
           * Sometimes it is better to finish with an EOF than with an error. */
-         Dmsg1(29, "Creating last part on spool: %s\n", archive_name.c_str());
+         Dmsg1(100, "Creating last part on spool: %s\n", archive_name.c_str());
          omode = CREATE_READ_WRITE;
          set_mode(CREATE_READ_WRITE);
          m_fd = ::open(archive_name.c_str(), mode, 0640);
          dev_errno = errno;
          Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(), 
                be.bstrerror());
-         Dmsg1(29, "open failed: %s", errmsg);
+         Dmsg1(100, "open failed: %s", errmsg);
          /* Use system close() */
          ::close(m_fd);
          clear_opened();
    return fsf(VolCatInfo.VolCatFiles);
 #endif
 
-   Dmsg0(29, "eod\n");
+   Dmsg0(100, "eod\n");
    if (at_eot()) {
       return true;
    }
       return false;
    }
 
-   Dmsg0(29, "bsf\n");
+   Dmsg0(100, "bsf\n");
    clear_eot();
    clear_eof();
    file -= num;
       return false;
    }
 
-   Dmsg1(29, "fsr %d\n", num);
+   Dmsg1(100, "fsr %d\n", num);
    mt_com.mt_op = MTFSR;
    mt_com.mt_count = num;
    stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
       return false;
    }
 
-   Dmsg0(29, "bsr_dev\n");
+   Dmsg0(100, "bsr_dev\n");
    block_num -= num;
    clear_eof();
    clear_eot();
  */
 bool DEVICE::unmount(int timeout) 
 {
-   Dmsg0(90, "Enter unmount\n");
+   Dmsg0(100, "Enter unmount\n");
    if (is_mounted()) {
       return do_mount(0, timeout);
    }
    results[0] = 0;
 
    /* If busy retry each second */
-   Dmsg1(20, "do_mount run_prog=%s\n", ocmd.c_str());
+   Dmsg1(100, "do_mount run_prog=%s\n", ocmd.c_str());
    while ((status = run_program_full_output(ocmd.c_str(), 
                        max_open_wait/2, results)) != 0) {
       /* Doesn't work with internationalization (This is not a problem) */
       }
       if (status != 0) {
          berrno be;
-         Dmsg5(40, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
+         Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
               (mount ? "" : "un"), status, results, be.bstrerror(status));
          Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"), 
               print_name(), (mount ? "" : "un"), be.bstrerror(status));
       } else {
-         Dmsg4(40, "Device %s cannot be %smounted. stat=%d ERR=%s\n", print_name(),
+         Dmsg4(100, "Device %s cannot be %smounted. stat=%d ERR=%s\n", print_name(),
               (mount ? "" : "un"), status, results);
          Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"), 
               print_name(), (mount ? "" : "un"), results);
       if (!(dp = opendir(device->mount_point))) {
          berrno be;
          dev_errno = errno;
-         Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n", 
+         Dmsg3(100, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n", 
                device->mount_point, print_name(), be.bstrerror());
          goto get_out;
       }
       free(entry);
       closedir(dp);
       
-      Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
+      Dmsg1(100, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
       
       if (count > 0) {
          /* If we got more than ., .. and .keep */
 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
    struct mtop mt_com;
 
-   Dmsg0(050, "In set_os_device_parameters\n");
+   Dmsg0(100, "In set_os_device_parameters\n");
 #if defined(MTSETBLK) 
    if (dev->min_block_size == dev->max_block_size &&
        dev->min_block_size == 0) {    /* variable block mode */
       mt_com.mt_op = MTSETBLK;
       mt_com.mt_count = 0;
-      Dmsg0(050, "Set block size to zero\n");
+      Dmsg0(100, "Set block size to zero\n");
       if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
          dev->clrerror(MTSETBLK);
       }
       if (dev->has_cap(CAP_EOM)) {
          mt_com.mt_count |= MT_ST_FAST_MTEOM;
       }
-      Dmsg0(050, "MTSETDRVBUFFER\n");
+      Dmsg0(100, "MTSETDRVBUFFER\n");
       if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
          dev->clrerror(MTSETDRVBUFFER);
       }
 
 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
 {
-   Dmsg0(050, "dev_get_os_pos\n");
+   Dmsg0(100, "dev_get_os_pos\n");
    return dev->has_cap(CAP_MTIOCGET) && 
           tape_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
           mt_stat->mt_fileno >= 0;
 
          stat = VOL_NAME_ERROR;
          goto bail_out;
       }
-      Dmsg0(30, "Leave read_volume_label() VOL_OK\n");
+      Dmsg0(130, "Leave read_volume_label() VOL_OK\n");
       return VOL_OK;       /* label already read */
    }
 
    if (!dev->rewind(dcr)) {
       Mmsg(jcr->errmsg, _("Couldn't rewind device %s: ERR=%s\n"), 
          dev->print_name(), dev->print_errmsg());
-      Dmsg1(30, "return VOL_NO_MEDIA: %s", jcr->errmsg);
+      Dmsg1(130, "return VOL_NO_MEDIA: %s", jcr->errmsg);
       return VOL_NO_MEDIA;
    }
    bstrncpy(dev->VolHdr.Id, "**error**", sizeof(dev->VolHdr.Id));
    record = new_record();
    empty_block(block);
 
-   Dmsg0(90, "Big if statement in read_volume_label\n");
+   Dmsg0(130, "Big if statement in read_volume_label\n");
    if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
       Mmsg(jcr->errmsg, _("Requested Volume \"%s\" on %s is not a Bacula "
            "labeled Volume, because: ERR=%s"), NPRT(VolName), 
            dev->print_name(), dev->print_errmsg());
-      Dmsg1(30, "%s", jcr->errmsg);
+      Dmsg1(130, "%s", jcr->errmsg);
    } else if (!read_record_from_block(dcr, block, record)) {
       Mmsg(jcr->errmsg, _("Could not read Volume label from block.\n"));
-      Dmsg1(30, "%s", jcr->errmsg);
+      Dmsg1(130, "%s", jcr->errmsg);
    } else if (!unser_volume_label(dev, record)) {
       Mmsg(jcr->errmsg, _("Could not unserialize Volume label: ERR=%s\n"),
          dev->print_errmsg());
-      Dmsg1(30, "%s", jcr->errmsg);
+      Dmsg1(130, "%s", jcr->errmsg);
    } else if (strcmp(dev->VolHdr.Id, BaculaId) != 0 &&
               strcmp(dev->VolHdr.Id, OldBaculaId) != 0) {
       Mmsg(jcr->errmsg, _("Volume Header Id bad: %s\n"), dev->VolHdr.Id);
-      Dmsg1(30, "%s", jcr->errmsg);
+      Dmsg1(130, "%s", jcr->errmsg);
    } else {
       ok = true;
    }
        dev->VolHdr.VerNum != OldCompatibleBaculaTapeVersion2) {
       Mmsg(jcr->errmsg, _("Volume on %s has wrong Bacula version. Wanted %d got %d\n"),
          dev->print_name(), BaculaTapeVersion, dev->VolHdr.VerNum);
-      Dmsg1(30, "VOL_VERSION_ERROR: %s", jcr->errmsg);
+      Dmsg1(130, "VOL_VERSION_ERROR: %s", jcr->errmsg);
       stat = VOL_VERSION_ERROR;
       goto bail_out;
    }
    if (dev->VolHdr.LabelType != PRE_LABEL && dev->VolHdr.LabelType != VOL_LABEL) {
       Mmsg(jcr->errmsg, _("Volume on %s has bad Bacula label type: %x\n"),
           dev->print_name(), dev->VolHdr.LabelType);
-      Dmsg1(30, "%s", jcr->errmsg);
+      Dmsg1(130, "%s", jcr->errmsg);
       if (!dev->poll && jcr->label_errors++ > 100) {
          Jmsg(jcr, M_FATAL, 0, _("Too many tries: %s"), jcr->errmsg);
       }
    }
 
    /* Compare Volume Names */
-   Dmsg2(30, "Compare Vol names: VolName=%s hdr=%s\n", VolName?VolName:"*", dev->VolHdr.VolumeName);
+   Dmsg2(130, "Compare Vol names: VolName=%s hdr=%s\n", VolName?VolName:"*", dev->VolHdr.VolumeName);
    if (VolName && *VolName && *VolName != '*' && strcmp(dev->VolHdr.VolumeName, VolName) != 0) {
       Mmsg(jcr->errmsg, _("Wrong Volume mounted on device %s: Wanted %s have %s\n"),
            dev->print_name(), VolName, dev->VolHdr.VolumeName);
-      Dmsg1(30, "%s", jcr->errmsg);
+      Dmsg1(130, "%s", jcr->errmsg);
       /*
        * Cancel Job if too many label errors
        *  => we are in a loop
       stat = VOL_NAME_ERROR;
       goto bail_out;
    }
-   Dmsg1(30, "Copy vol_name=%s\n", dev->VolHdr.VolumeName);
+   Dmsg1(130, "Copy vol_name=%s\n", dev->VolHdr.VolumeName);
 
    if (debug_level >= 10) {
       dump_volume_label(dev);
    }
-   Dmsg0(30, "Leave read_volume_label() VOL_OK\n");
+   Dmsg0(130, "Leave read_volume_label() VOL_OK\n");
    /* If we are a streaming device, we only get one chance to read */
    if (!dev->has_cap(CAP_STREAM)) {
       dev->rewind(dcr);
    JCR *jcr = dcr->jcr;
    DEV_BLOCK *block = dcr->block;
 
-   Dmsg0(20, "write Label in write_volume_label_to_block()\n");
+   Dmsg0(130, "write Label in write_volume_label_to_block()\n");
    memset(&rec, 0, sizeof(rec));
    rec.data = get_memory(SER_LENGTH_Volume_Label);
    empty_block(block);                /* Volume label always at beginning */
          dev->print_name());
       return false;
    } else {
-      Dmsg1(90, "Wrote label of %d bytes to block\n", rec.data_len);
+      Dmsg1(130, "Wrote label of %d bytes to block\n", rec.data_len);
    }
    free_pool_memory(rec.data);
    return true;
    DEVICE *dev = dcr->dev;
 
 
-   Dmsg0(99, "write_volume_label()\n");
+   Dmsg0(150, "write_volume_label()\n");
    empty_block(dcr->block);
 
    /* If relabeling, truncate the device */
    Dmsg1(150, "Label type=%d\n", dev->label_type);
    if (!dev->rewind(dcr)) {
       dev->clear_volhdr();
-      Dmsg2(30, "Bad status on %s from rewind: ERR=%s\n", dev->print_name(), dev->print_errmsg());
+      Dmsg2(130, "Bad status on %s from rewind: ERR=%s\n", dev->print_name(), dev->print_errmsg());
       if (!forge_on) {
          goto bail_out;
       }
    /* Temporarily mark in append state to enable writing */
    dev->set_append();
    if (!write_record_to_block(dcr->block, dcr->rec)) {
-      Dmsg2(30, "Bad Label write on %s: ERR=%s\n", dev->print_name(), dev->print_errmsg());
+      Dmsg2(130, "Bad Label write on %s: ERR=%s\n", dev->print_name(), dev->print_errmsg());
       goto bail_out;
    } else {
-      Dmsg2(30, "Wrote label of %d bytes to %s\n", dcr->rec->data_len, dev->print_name());
+      Dmsg2(130, "Wrote label of %d bytes to %s\n", dcr->rec->data_len, dev->print_name());
    }
 
-   Dmsg0(99, "Call write_block_to_dev()\n");
+   Dmsg0(130, "Call write_block_to_dev()\n");
    if (!write_block_to_dev(dcr)) {
-      Dmsg2(30, "Bad Label write on %s: ERR=%s\n", dev->print_name(), dev->print_errmsg());
+      Dmsg2(130, "Bad Label write on %s: ERR=%s\n", dev->print_name(), dev->print_errmsg());
       goto bail_out;
    }
 
    if (dev->is_dvd() && dvdnow) {
       Dmsg1(150, "New VolName=%s\n", dev->VolCatInfo.VolCatName);
       if (!dvd_write_part(dcr)) {
-         Dmsg2(30, "Bad DVD write on %s: ERR=%s\n", dev->print_name(), dev->print_errmsg());
+         Dmsg2(130, "Bad DVD write on %s: ERR=%s\n", dev->print_name(), dev->print_errmsg());
          goto bail_out;
       }
    }
 
-   Dmsg0(99, " Wrote block to device\n");
+   Dmsg0(130, " Wrote block to device\n");
 
    if (dev->weof(1)) {
       dev->set_labeled();
 {
    DEVRES *device = (DEVRES *)dev->device;
 
-   Dmsg0(90, "Start create_volume_label()\n");
+   Dmsg0(130, "Start create_volume_label()\n");
 
    ASSERT(dev != NULL);
 
    char buf1[100], buf2[100];
 
    rec = new_record();
-   Dmsg1(90, "session_label record=%x\n", rec);
+   Dmsg1(130, "session_label record=%x\n", rec);
    switch (label) {
    case SOS_LABEL:
       if (dev->is_tape()) {
    if (!can_write_record_to_block(block, rec)) {
       Dmsg0(150, "Cannot write session label to block.\n");
       if (!write_block_to_device(dcr)) {
-         Dmsg0(90, "Got session label write_block_to_dev error.\n");
+         Dmsg0(130, "Got session label write_block_to_dev error.\n");
          /* ****FIXME***** errno is not set here */
          Jmsg(jcr, M_FATAL, 0, _("Error writing Session label to %s: %s\n"),
                            dev_vol_name(dev), strerror(errno));
       return false;
    }
 
-   Dmsg6(50, "Write sesson_label record JobId=%d FI=%s SessId=%d Strm=%s len=%d "
+   Dmsg6(150, "Write sesson_label record JobId=%d FI=%s SessId=%d Strm=%s len=%d "
              "remainder=%d\n", jcr->JobId,
       FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId,
       stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len,
       rec->remainder);
 
    free_record(rec);
-   Dmsg2(50, "Leave write_session_label Block=%ud File=%ud\n",
+   Dmsg2(150, "Leave write_session_label Block=%ud File=%ud\n",
       dev->get_block(), dev->get_file());
    return true;
 }