X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Facquire.c;h=a64b14da6363c8befca61febb9e405fecbfc4bb8;hb=b6a1f7208143a51f07573fe986fcea297f90944b;hp=f1efa711888fe7af1e0c19d5e9de93daa33a0d26;hpb=8816678a26a56569ea9f21f3e30281f7ad4dcf6f;p=bacula%2Fbacula diff --git a/bacula/src/stored/acquire.c b/bacula/src/stored/acquire.c index f1efa71188..a64b14da63 100644 --- a/bacula/src/stored/acquire.c +++ b/bacula/src/stored/acquire.c @@ -1,48 +1,36 @@ /* Bacula® - The Network Backup Solution - Copyright (C) 2002-2007 Free Software Foundation Europe e.V. - - The main author of Bacula is Kern Sibbald, with contributions from - many others, a complete list can be found in the file AUTHORS. - This program is Free Software; you can redistribute it and/or - modify it under the terms of version two of the GNU General Public - License as published by the Free Software Foundation and included - in the file LICENSE. - - This program is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA - 02110-1301, USA. - - Bacula® is a registered trademark of John Walker. - The licensor of Bacula is the Free Software Foundation Europe - (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich, - Switzerland, email:ftf@fsfeurope.org. + Copyright (C) 2002-2014 Free Software Foundation Europe e.V. + + The main author of Bacula is Kern Sibbald, with contributions from many + others, a complete list can be found in the file AUTHORS. + + You may use this file and others of this release according to the + license defined in the LICENSE file, which includes the Affero General + Public License, v3.0 ("AGPLv3") and some additional permissions and + terms pursuant to its AGPLv3 Section 7. + + Bacula® is a registered trademark of Kern Sibbald. */ /* * Routines to acquire and release a device for read/write * - * Kern Sibbald, August MMII + * Written by Kern Sibbald, August MMII * - * Version $Id$ */ #include "bacula.h" /* pull in global headers */ #include "stored.h" /* pull in Storage Deamon headers */ -/* Forward referenced functions */ -static void attach_dcr_to_dev(DCR *dcr); +static int const rdbglvl = 100; +/* Forward referenced functions */ +static void set_dcr_from_vol(DCR *dcr, VOL_LIST *vol); /********************************************************************* - * Acquire device for reading. - * The drive should have previously been reserved by calling + * Acquire device for reading. + * The drive should have previously been reserved by calling * reserve_device_for_read(). We read the Volume label from the block and * leave the block pointers just after the label. * @@ -51,22 +39,25 @@ static void attach_dcr_to_dev(DCR *dcr); */ bool acquire_device_for_read(DCR *dcr) { - DEVICE *dev = dcr->dev; + DEVICE *dev; JCR *jcr = dcr->jcr; bool ok = false; bool tape_previously_mounted; - bool tape_initially_mounted; VOL_LIST *vol; bool try_autochanger = true; int i; int vol_label_status; int retry = 0; - - Dmsg1(50, "jcr->dcr=%p\n", jcr->dcr); + + Enter(rdbglvl); + dev = dcr->dev; + dev->Lock_read_acquire(); + Dmsg2(rdbglvl, "dcr=%p dev=%p\n", dcr, dcr->dev); + Dmsg2(rdbglvl, "MediaType dcr=%s dev=%s\n", dcr->media_type, dev->device->media_type); dev->dblock(BST_DOING_ACQUIRE); if (dev->num_writers > 0) { - Jmsg2(jcr, M_FATAL, 0, _("Acquire read: num_writers=%d not zero. Job %d canceled.\n"), + Jmsg2(jcr, M_FATAL, 0, _("Acquire read: num_writers=%d not zero. Job %d canceled.\n"), dev->num_writers, jcr->JobId); goto get_out; } @@ -75,7 +66,7 @@ bool acquire_device_for_read(DCR *dcr) vol = jcr->VolList; if (!vol) { char ed1[50]; - Jmsg(jcr, M_FATAL, 0, _("No volumes specified for reading. Job %s canceled.\n"), + Jmsg(jcr, M_FATAL, 0, _("No volumes specified for reading. Job %s canceled.\n"), edit_int64(jcr->JobId, ed1)); goto get_out; } @@ -86,87 +77,131 @@ bool acquire_device_for_read(DCR *dcr) if (!vol) { Jmsg(jcr, M_FATAL, 0, _("Logic error: no next volume to read. Numvol=%d Curvol=%d\n"), jcr->NumReadVolumes, jcr->CurReadVolume); - goto get_out; /* should not happen */ + goto get_out; /* should not happen */ } - bstrncpy(dcr->VolumeName, vol->VolumeName, sizeof(dcr->VolumeName)); - bstrncpy(dcr->media_type, vol->MediaType, sizeof(dcr->media_type)); - dcr->VolCatInfo.Slot = vol->Slot; - + set_dcr_from_vol(dcr, vol); + + if (generate_plugin_event(jcr, bsdEventDeviceOpen, dcr) != bRC_OK) { + Jmsg(jcr, M_FATAL, 0, _("generate_plugin_event(bsdEventDeviceOpen) Failed\n")); + goto get_out; + } + + Dmsg2(rdbglvl, "Want Vol=%s Slot=%d\n", vol->VolumeName, vol->Slot); + /* * If the MediaType requested for this volume is not the * same as the current drive, we attempt to find the same * device that was used to write the orginal volume. If * found, we switch to using that device. + * + * N.B. A lot of routines rely on the dcr pointer not changing + * read_records.c even has multiple dcrs cached, so we take care + * here to release all important parts of the dcr and re-acquire + * them such as the block pointer (size may change), but we do + * not release the dcr. */ - Dmsg2(50, "MediaType dcr=%s dev=%s\n", dcr->media_type, dev->device->media_type); + Dmsg2(rdbglvl, "MediaType dcr=%s dev=%s\n", dcr->media_type, dev->device->media_type); if (dcr->media_type[0] && strcmp(dcr->media_type, dev->device->media_type) != 0) { RCTX rctx; DIRSTORE *store; int stat; - Jmsg3(jcr, M_INFO, 0, _("Changing device. Want Media Type=\"%s\" have=\"%s\"\n" - " device=%s\n"), - dcr->media_type, dev->device->media_type, dev->print_name()); + Jmsg4(jcr, M_INFO, 0, _("Changing read device. Want Media Type=\"%s\" have=\"%s\"\n" + " %s device=%s\n"), + dcr->media_type, dev->device->media_type, dev->print_type(), + dev->print_name()); + Dmsg4(rdbglvl, "Changing read device. Want Media Type=\"%s\" have=\"%s\"\n" + " %s device=%s\n", + dcr->media_type, dev->device->media_type, + dev->print_type(), dev->print_name()); + + generate_plugin_event(jcr, bsdEventDeviceClose, dcr); dev->dunblock(DEV_UNLOCKED); - detach_dcr_from_dev(dcr); /* release old device */ lock_reservations(); memset(&rctx, 0, sizeof(RCTX)); rctx.jcr = jcr; + jcr->read_dcr = dcr; jcr->reserve_msgs = New(alist(10, not_owned_by_alist)); rctx.any_drive = true; rctx.device_name = vol->device; store = new DIRSTORE; memset(store, 0, sizeof(DIRSTORE)); - store->name[0] = 0; /* No dir name */ + store->name[0] = 0; /* No storage name */ bstrncpy(store->media_type, vol->MediaType, sizeof(store->media_type)); bstrncpy(store->pool_name, dcr->pool_name, sizeof(store->pool_name)); bstrncpy(store->pool_type, dcr->pool_type, sizeof(store->pool_type)); store->append = false; rctx.store = store; - + clean_device(dcr); /* clean up the dcr */ + /* - * Note, if search_for_device() succeeds, we get a new dcr, - * which we do not use except for the dev info. + * Search for a new device */ stat = search_res_for_device(rctx); release_reserve_messages(jcr); /* release queued messages */ unlock_reservations(); - dev->dblock(BST_DOING_ACQUIRE); - if (stat == 1) { + + if (stat == 1) { /* found new device to use */ + /* + * Switching devices, so acquire lock on new device, + * then release the old one. + */ + dcr->dev->Lock_read_acquire(); /* lock new one */ + dev->Unlock_read_acquire(); /* release old one */ + dev = dcr->dev; /* get new device pointer */ + dev->dblock(BST_DOING_ACQUIRE); + dcr->VolumeName[0] = 0; - Jmsg(jcr, M_INFO, 0, _("Media Type change. New device %s chosen.\n"), - dev->print_name()); + Jmsg(jcr, M_INFO, 0, _("Media Type change. New read %s device %s chosen.\n"), + dev->print_type(), dev->print_name()); + Dmsg2(50, "Media Type change. New read %s device %s chosen.\n", + dev->print_type(), dev->print_name()); + if (generate_plugin_event(jcr, bsdEventDeviceOpen, dcr) != bRC_OK) { + Jmsg(jcr, M_FATAL, 0, _("generate_plugin_event(bsdEventDeviceOpen) Failed\n")); + goto get_out; + } bstrncpy(dcr->VolumeName, vol->VolumeName, sizeof(dcr->VolumeName)); + dcr->setVolCatName(vol->VolumeName); bstrncpy(dcr->media_type, vol->MediaType, sizeof(dcr->media_type)); dcr->VolCatInfo.Slot = vol->Slot; + dcr->VolCatInfo.InChanger = vol->Slot > 0; bstrncpy(dcr->pool_name, store->pool_name, sizeof(dcr->pool_name)); bstrncpy(dcr->pool_type, store->pool_type, sizeof(dcr->pool_type)); - } else if (stat == 0) { /* device busy */ - Pmsg1(000, "Device %s is busy.\n", vol->device); } else { /* error */ Jmsg1(jcr, M_FATAL, 0, _("No suitable device found to read Volume \"%s\"\n"), vol->VolumeName); + Dmsg1(rdbglvl, "No suitable device found to read Volume \"%s\"\n", vol->VolumeName); goto get_out; } } + Dmsg2(rdbglvl, "MediaType dcr=%s dev=%s\n", dcr->media_type, dev->device->media_type); + dev->clear_unload(); + + if (dev->vol && dev->vol->is_swapping()) { + dev->vol->set_slot(vol->Slot); + Dmsg3(rdbglvl, "swapping: slot=%d Vol=%s dev=%s\n", dev->vol->get_slot(), + dev->vol->vol_name, dev->print_name()); + } init_device_wait_timers(dcr); tape_previously_mounted = dev->can_read() || dev->can_append() || dev->is_labeled(); - tape_initially_mounted = tape_previously_mounted; - +// tape_initially_mounted = tape_previously_mounted; /* Volume info is always needed because of VolParts */ - Dmsg0(200, "dir_get_volume_info\n"); + Dmsg1(rdbglvl, "dir_get_volume_info vol=%s\n", dcr->VolumeName); if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_READ)) { - Jmsg1(jcr, M_WARNING, 0, "%s", jcr->errmsg); + Dmsg2(rdbglvl, "dir_get_vol_info failed for vol=%s: %s\n", + dcr->VolumeName, jcr->errmsg); + Jmsg1(jcr, M_WARNING, 0, "Read acquire: %s", jcr->errmsg); } - + dev->set_load(); /* set to load volume */ + for ( ;; ) { /* If not polling limit retries */ if (!dev->poll && retry++ > 10) { @@ -180,112 +215,147 @@ bool acquire_device_for_read(DCR *dcr) goto get_out; /* error return */ } - autoload_device(dcr, 0, NULL); + dcr->do_unload(); + dcr->do_swapping(SD_READ); + dcr->do_load(SD_READ); + set_dcr_from_vol(dcr, vol); /* refresh dcr with desired volume info */ /* * This code ensures that the device is ready for * reading. If it is a file, it opens it. * If it is a tape, it checks the volume name */ - Dmsg1(100, "bstored: open vol=%s\n", dcr->VolumeName); - if (dev->open(dcr, OPEN_READ_ONLY) < 0) { - Jmsg3(jcr, M_WARNING, 0, _("Read open device %s Volume \"%s\" failed: ERR=%s\n"), - dev->print_name(), dcr->VolumeName, dev->bstrerror()); + Dmsg1(rdbglvl, "open vol=%s\n", dcr->VolumeName); + if (!dev->open(dcr, OPEN_READ_ONLY)) { + if (!dev->poll) { + Jmsg4(jcr, M_WARNING, 0, _("Read open %s device %s Volume \"%s\" failed: ERR=%s\n"), + dev->print_type(), dev->print_name(), dcr->VolumeName, dev->bstrerror()); + } goto default_path; } - Dmsg1(100, "opened dev %s OK\n", dev->print_name()); - + Dmsg1(rdbglvl, "opened dev %s OK\n", dev->print_name()); + /* Read Volume Label */ - - Dmsg0(200, "calling read-vol-label\n"); + Dmsg0(rdbglvl, "calling read-vol-label\n"); vol_label_status = read_dev_volume_label(dcr); switch (vol_label_status) { case VOL_OK: + Dmsg0(rdbglvl, "Got correct volume.\n"); ok = true; - memcpy(&dev->VolCatInfo, &dcr->VolCatInfo, sizeof(dev->VolCatInfo)); + dev->VolCatInfo = dcr->VolCatInfo; /* structure assignment */ break; /* got it */ case VOL_IO_ERROR: + Dmsg0(rdbglvl, "IO Error\n"); /* * Send error message generated by read_dev_volume_label() * only we really had a tape mounted. This supresses superfluous * error messages when nothing is mounted. */ if (tape_previously_mounted) { - Jmsg(jcr, M_WARNING, 0, "%s", jcr->errmsg); + Jmsg(jcr, M_WARNING, 0, "Read acquire: %s", jcr->errmsg); } goto default_path; + case VOL_TYPE_ERROR: + Jmsg(jcr, M_FATAL, 0, dev->errmsg); + goto get_out; case VOL_NAME_ERROR: - if (tape_initially_mounted) { - tape_initially_mounted = false; + Dmsg3(rdbglvl, "Vol name=%s want=%s drv=%s.\n", dev->VolHdr.VolumeName, + dcr->VolumeName, dev->print_name()); + if (dev->is_volume_to_unload()) { goto default_path; } - /* If polling and got a previous bad name, ignore it */ - if (dev->poll && strcmp(dev->BadVolName, dev->VolHdr.VolumeName) == 0) { - goto default_path; - } else { - bstrncpy(dev->BadVolName, dev->VolHdr.VolumeName, sizeof(dev->BadVolName)); + dev->set_unload(); /* force unload of unwanted tape */ + if (!unload_autochanger(dcr, -1)) { + /* at least free the device so we can re-open with correct volume */ + dev->close(); + free_volume(dev); } + dev->set_load(); /* Fall through */ default: - Jmsg1(jcr, M_WARNING, 0, "%s", jcr->errmsg); + Jmsg1(jcr, M_WARNING, 0, "Read acquire: %s", jcr->errmsg); default_path: + Dmsg0(rdbglvl, "default path\n"); tape_previously_mounted = true; - + /* * If the device requires mount, close it, so the device can be ejected. */ if (dev->requires_mount()) { dev->close(); + free_volume(dev); } - + /* Call autochanger only once unless ask_sysop called */ if (try_autochanger) { int stat; - Dmsg2(200, "calling autoload Vol=%s Slot=%d\n", + Dmsg2(rdbglvl, "calling autoload Vol=%s Slot=%d\n", dcr->VolumeName, dcr->VolCatInfo.Slot); - stat = autoload_device(dcr, 0, NULL); + stat = autoload_device(dcr, SD_READ, NULL); if (stat > 0) { try_autochanger = false; continue; /* try reading volume mounted */ } } - + /* Mount a specific volume and no other */ - Dmsg0(200, "calling dir_ask_sysop\n"); - if (!dir_ask_sysop_to_mount_volume(dcr)) { + Dmsg0(rdbglvl, "calling dir_ask_sysop\n"); + if (!dir_ask_sysop_to_mount_volume(dcr, SD_READ)) { goto get_out; /* error return */ } - try_autochanger = true; /* permit using autochanger again */ + + /* Volume info is always needed because of VolParts */ + Dmsg1(150, "dir_get_volume_info vol=%s\n", dcr->VolumeName); + if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_READ)) { + Dmsg2(150, "dir_get_vol_info failed for vol=%s: %s\n", + dcr->VolumeName, jcr->errmsg); + Jmsg1(jcr, M_WARNING, 0, "Read acquire: %s", jcr->errmsg); + } + dev->set_load(); /* set to load volume */ + + try_autochanger = true; /* permit trying the autochanger again */ + continue; /* try reading again */ } /* end switch */ break; } /* end for loop */ + if (!ok) { - Jmsg1(jcr, M_FATAL, 0, _("Too many errors trying to mount device %s for reading.\n"), - dev->print_name()); + Jmsg2(jcr, M_FATAL, 0, _("Too many errors trying to mount %s device %s for reading.\n"), + dev->print_type(), dev->print_name()); goto get_out; } dev->clear_append(); dev->set_read(); - set_jcr_job_status(jcr, JS_Running); - dir_send_job_status(jcr); - Jmsg(jcr, M_INFO, 0, _("Ready to read from volume \"%s\" on device %s.\n"), - dcr->VolumeName, dev->print_name()); + jcr->sendJobStatus(JS_Running); + Jmsg(jcr, M_INFO, 0, _("Ready to read from volume \"%s\" on %s device %s.\n"), + dcr->VolumeName, dev->print_type(), dev->print_name()); get_out: - dev->dlock(); - if (dcr->reserved_device) { - dev->reserved_device--; - Dmsg2(100, "Dec reserve=%d dev=%s\n", dev->reserved_device, dev->print_name()); - dcr->reserved_device = false; - } - dev->dunblock(DEV_LOCKED); - Dmsg1(50, "jcr->dcr=%p\n", jcr->dcr); + dev->Lock(); + dcr->clear_reserved(); + /* If failed and not writing plugin close device */ + if (!ok && dev->num_writers == 0 && dev->num_reserved() == 0) { + generate_plugin_event(jcr, bsdEventDeviceClose, dcr); + } + /* + * Normally we are blocked, but in at least one error case above + * we are not blocked because we unsuccessfully tried changing + * devices. + */ + if (dev->is_blocked()) { + dev->dunblock(DEV_LOCKED); + } else { + dev->Unlock(); /* dunblock() unlock the device too */ + } + Dmsg2(rdbglvl, "dcr=%p dev=%p\n", dcr, dcr->dev); + Dmsg2(rdbglvl, "MediaType dcr=%s dev=%s\n", dcr->media_type, dev->device->media_type); + dev->Unlock_read_acquire(); + Leave(rdbglvl); return ok; } - /* * Acquire device for writing. We permit multiple writers. * If this is the first one, we read the label. @@ -297,124 +367,76 @@ get_out: */ DCR *acquire_device_for_append(DCR *dcr) { - bool release = false; - bool recycle = false; - bool do_mount = false; DEVICE *dev = dcr->dev; JCR *jcr = dcr->jcr; + bool ok = false; + bool have_vol = false; + Enter(200); init_device_wait_timers(dcr); - dev->dblock(BST_DOING_ACQUIRE); - Dmsg1(190, "acquire_append device is %s\n", dev->is_tape()?"tape": + dev->Lock_acquire(); /* only one job at a time */ + dev->Lock(); + Dmsg1(100, "acquire_append device is %s\n", dev->is_tape()?"tape": (dev->is_dvd()?"DVD":"disk")); - /* * With the reservation system, this should not happen */ if (dev->can_read()) { - Jmsg1(jcr, M_FATAL, 0, _("Want to append, but device %s is busy reading.\n"), dev->print_name()); - Dmsg1(200, "Want to append but device %s is busy reading.\n", dev->print_name()); + Mmsg2(jcr->errmsg, "Want to append but %s device %s is busy reading.\n", + dev->print_type(), dev->print_name()); + Jmsg(jcr, M_FATAL, 0, jcr->errmsg); + Dmsg0(50, jcr->errmsg); goto get_out; } - if (dev->can_append()) { + dev->clear_unload(); + + /* + * have_vol defines whether or not mount_next_write_volume should + * ask the Director again about what Volume to use. + */ + if (dev->can_append() && dcr->is_suitable_volume_mounted() && + strcmp(dcr->VolCatInfo.VolCatStatus, "Recycle") != 0) { Dmsg0(190, "device already in append.\n"); /* - * Device already in append mode - * - * Check if we have the right Volume mounted - * OK if current volume info OK - * OK if next volume matches current volume - * otherwise mount desired volume obtained from - * dir_find_next_appendable_volume - * dev->VolHdr.VolumeName is what is in the drive - * dcr->VolumeName is what we pass into the routines, or - * get back from the subroutines. + * At this point, the correct tape is already mounted, so + * we do not need to do mount_next_write_volume(), unless + * we need to recycle the tape. */ - bstrncpy(dcr->VolumeName, dev->VolHdr.VolumeName, sizeof(dcr->VolumeName)); - if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE) && - !(dir_find_next_appendable_volume(dcr) && - strcmp(dev->VolHdr.VolumeName, dcr->VolumeName) == 0)) { /* wrong tape mounted */ - Dmsg2(190, "Wrong tape mounted: %s. wants:%s\n", dev->VolHdr.VolumeName, - dcr->VolumeName); - /* Release volume reserved by dir_find_next_appendable_volume() */ - if (dcr->VolumeName[0]) { - volume_unused(dcr); - } - if (dev->num_writers != 0) { - Jmsg3(jcr, M_FATAL, 0, _("Wanted to append to Volume \"%s\", but device %s is busy writing on \"%s\" .\n"), - dcr->VolumeName, dev->print_name(), dev->VolHdr.VolumeName); - Dmsg3(200, "Wanted to append to Volume \"%s\", but device %s is busy writing on \"%s\" .\n", - dcr->VolumeName, dev->print_name(), dev->VolHdr.VolumeName); - goto get_out; - } - /* Wrong tape mounted, release it, then fall through to get correct one */ - Dmsg0(190, "Wrong tape mounted, release and try mount.\n"); - release = true; - do_mount = true; - } else { - /* - * At this point, the correct tape is already mounted, so - * we do not need to do mount_next_write_volume(), unless - * we need to recycle the tape. - */ - recycle = strcmp(dcr->VolCatInfo.VolCatStatus, "Recycle") == 0; - Dmsg1(190, "Correct tape mounted. recycle=%d\n", recycle); - if (recycle && dev->num_writers != 0) { - Jmsg(jcr, M_FATAL, 0, _("Cannot recycle volume \"%s\"" - " on device %s because it is in use by another job.\n"), - dev->VolHdr.VolumeName, dev->print_name()); - goto get_out; - } - if (dev->num_writers == 0) { - memcpy(&dev->VolCatInfo, &dcr->VolCatInfo, sizeof(dev->VolCatInfo)); - } - - /* - * Insanity check - * - * Check to see if the tape position as defined by the OS is - * the same as our concept. If it is not, we bail out, because - * it means the user has probably manually rewound the tape. - * Note, we check only if num_writers == 0, but this code will - * also work fine for any number of writers. If num_writers > 0, - * we probably should cancel all jobs using this device, or - * perhaps even abort the SD, or at a minimum, mark the tape - * in error. Another strategy with num_writers == 0, would be - * to rewind the tape and do a new eod() request. - */ - if (dev->is_tape() && dev->num_writers == 0) { - int32_t file = dev->get_os_tape_file(); - if (file >= 0 && file != (int32_t)dev->get_file()) { - Jmsg(jcr, M_FATAL, 0, _("Invalid tape position on volume \"%s\"" - " on device %s. Expected %d, got %d\n"), - dev->VolHdr.VolumeName, dev->print_name(), dev->get_file(), file); - goto get_out; - } - } - } - } else { - /* Not already in append mode, so mount the device */ - Dmsg0(190, "Not in append mode, try mount.\n"); - ASSERT(dev->num_writers == 0); - do_mount = true; + if (dev->num_writers == 0) { + dev->VolCatInfo = dcr->VolCatInfo; /* structure assignment */ + } + have_vol = dcr->is_tape_position_ok(); } - if (do_mount || recycle) { - Dmsg0(190, "Do mount_next_write_vol\n"); - bool mounted = mount_next_write_volume(dcr, release); - if (!mounted) { + if (!have_vol) { + dev->rLock(true); + block_device(dev, BST_DOING_ACQUIRE); + dev->Unlock(); + Dmsg1(190, "jid=%u Do mount_next_write_vol\n", (uint32_t)jcr->JobId); + if (!dcr->mount_next_write_volume()) { if (!job_canceled(jcr)) { /* Reduce "noise" -- don't print if job canceled */ - Jmsg(jcr, M_FATAL, 0, _("Could not ready device %s for append.\n"), - dev->print_name()); - Dmsg1(200, "Could not ready device %s for append.\n", - dev->print_name()); + Mmsg2(jcr->errmsg, _("Could not ready %s device %s for append.\n"), + dev->print_type(), dev->print_name()); + Jmsg(jcr, M_FATAL, 0, jcr->errmsg); + Dmsg0(50, jcr->errmsg); } + dev->Lock(); + unblock_device(dev); goto get_out; } Dmsg2(190, "Output pos=%u:%u\n", dcr->dev->file, dcr->dev->block_num); + dev->Lock(); + unblock_device(dev); + } + + if (generate_plugin_event(jcr, bsdEventDeviceOpen, dcr) != bRC_OK) { + Mmsg0(jcr->errmsg, _("generate_plugin_event(bsdEventDeviceOpen) Failed\n")); + Jmsg(jcr, M_FATAL, 0, jcr->errmsg); + Dmsg0(50, jcr->errmsg); + goto get_out; } dev->num_writers++; /* we are now a writer */ @@ -422,37 +444,28 @@ DCR *acquire_device_for_append(DCR *dcr) jcr->NumWriteVolumes = 1; } dev->VolCatInfo.VolCatJobs++; /* increment number of jobs on vol */ - dir_update_volume_info(dcr, false); /* send Volume info to Director */ - dev->dlock(); - if (dcr->reserved_device) { - dev->reserved_device--; - Dmsg2(100, "Dec reserve=%d dev=%s\n", dev->reserved_device, dev->print_name()); - dcr->reserved_device = false; - } - dev->dunblock(DEV_LOCKED); - return dcr; + Dmsg4(100, "=== nwriters=%d nres=%d vcatjob=%d dev=%s\n", + dev->num_writers, dev->num_reserved(), dev->VolCatInfo.VolCatJobs, + dev->print_name()); + dir_update_volume_info(dcr, false, false); /* send Volume info to Director */ + ok = true; -/* - * Error return - */ get_out: - dev->dlock(); - if (dcr->reserved_device) { - dev->reserved_device--; - Dmsg2(100, "Dec reserve=%d dev=%s\n", dev->reserved_device, dev->print_name()); - dcr->reserved_device = false; - } - dev->dunblock(DEV_LOCKED); - return NULL; + /* Don't plugin close here, we might have multiple writers */ + dcr->clear_reserved(); + dev->Unlock(); + dev->Unlock_acquire(); + Leave(200); + return ok ? dcr : NULL; } - /* * This job is done, so release the device. From a Unix standpoint, * the device remains open. * - * Note, if we are spooling, we may enter with the device locked. - * However, in all cases, unlock the device when leaving. + * Note, if we were spooling, we may enter with the device blocked. + * We unblock at the end, only if it was us who blocked the + * device. * */ bool release_device(DCR *dcr) @@ -460,27 +473,36 @@ bool release_device(DCR *dcr) JCR *jcr = dcr->jcr; DEVICE *dev = dcr->dev; bool ok = true; + char tbuf[100]; + int was_blocked = BST_NOT_BLOCKED; + - /* lock only if not already locked by this thread */ - if (!dcr->is_dev_locked()) { - dev->r_dlock(); + dev->Lock(); + if (!dev->is_blocked()) { + block_device(dev, BST_RELEASING); + } else { + was_blocked = dev->blocked(); + dev->set_blocked(BST_RELEASING); } + lock_volumes(); Dmsg2(100, "release_device device %s is %s\n", dev->print_name(), dev->is_tape()?"tape":"disk"); /* if device is reserved, job never started, so release the reserve here */ - if (dcr->reserved_device) { - dev->reserved_device--; - Dmsg2(100, "Dec reserve=%d dev=%s\n", dev->reserved_device, dev->print_name()); - dcr->reserved_device = false; - } + dcr->clear_reserved(); if (dev->can_read()) { + VOLUME_CAT_INFO *vol = &dev->VolCatInfo; + generate_plugin_event(jcr, bsdEventDeviceClose, dcr); dev->clear_read(); /* clear read bit */ - Dmsg0(100, "dir_update_vol_info. Release0\n"); - dir_update_volume_info(dcr, false); /* send Volume info to Director */ - + Dmsg2(150, "dir_update_vol_info. label=%d Vol=%s\n", + dev->is_labeled(), vol->VolCatName); + if (dev->is_labeled() && vol->VolCatName[0] != 0) { + dir_update_volume_info(dcr, false, false); /* send Volume info to Director */ + remove_read_volume(jcr, dcr->VolumeName); + volume_unused(dcr); + } } else if (dev->num_writers > 0) { - /* + /* * Note if WEOT is set, we are at the end of the tape * and may not be positioned correctly, so the * job_media_record and update_vol_info have already been @@ -489,37 +511,49 @@ bool release_device(DCR *dcr) dev->num_writers--; Dmsg1(100, "There are %d writers in release_device\n", dev->num_writers); if (dev->is_labeled()) { - Dmsg0(100, "dir_create_jobmedia_record. Release\n"); + Dmsg2(200, "dir_create_jobmedia. Release vol=%s dev=%s\n", + dev->getVolCatName(), dev->print_name()); if (!dev->at_weot() && !dir_create_jobmedia_record(dcr)) { - Jmsg(jcr, M_FATAL, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"), - dcr->VolCatInfo.VolCatName, jcr->Job); + Jmsg2(jcr, M_FATAL, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"), + dcr->getVolCatName(), jcr->Job); } - /* If no more writers, write an EOF */ + /* If no more writers, and no errors, and wrote something, write an EOF */ if (!dev->num_writers && dev->can_write() && dev->block_num > 0) { dev->weof(1); write_ansi_ibm_labels(dcr, ANSI_EOF_LABEL, dev->VolHdr.VolumeName); } if (!dev->at_weot()) { - dev->VolCatInfo.VolCatFiles = dev->file; /* set number of files */ + dev->VolCatInfo.VolCatFiles = dev->get_file(); /* set number of files */ /* Note! do volume update before close, which zaps VolCatInfo */ - Dmsg0(100, "dir_update_vol_info. Release0\n"); - dir_update_volume_info(dcr, false); /* send Volume info to Director */ + dir_update_volume_info(dcr, false, false); /* send Volume info to Director */ + Dmsg2(200, "dir_update_vol_info. Release vol=%s dev=%s\n", + dev->getVolCatName(), dev->print_name()); + } + if (dev->num_writers == 0) { /* if not being used */ + volume_unused(dcr); /* we obviously are not using the volume */ + generate_plugin_event(jcr, bsdEventDeviceClose, dcr); } } } else { - /* + /* * If we reach here, it is most likely because the job * has failed, since the device is not in read mode and * there are no writers. It was probably reserved. */ + volume_unused(dcr); + generate_plugin_event(jcr, bsdEventDeviceClose, dcr); } + Dmsg3(100, "%d writers, %d reserve, dev=%s\n", dev->num_writers, dev->num_reserved(), + dev->print_name()); /* If no writers, close if file or !CAP_ALWAYS_OPEN */ if (dev->num_writers == 0 && (!dev->is_tape() || !dev->has_cap(CAP_ALWAYSOPEN))) { - dvd_remove_empty_part(dcr); /* get rid of any empty spool part */ + generate_plugin_event(jcr, bsdEventDeviceClose, dcr); dev->close(); + free_volume(dev); } + unlock_volumes(); /* Fire off Alert command and include any output */ if (!job_canceled(jcr) && dcr->device->alert_command) { @@ -529,7 +563,8 @@ bool release_device(DCR *dcr) char line[MAXSTRING]; alert = get_pool_memory(PM_FNAME); alert = edit_device_codes(dcr, alert, dcr->device->alert_command, ""); - bpipe = open_bpipe(alert, 0, "r"); + /* Wait maximum 5 minutes */ + bpipe = open_bpipe(alert, 60 * 5, "r"); if (bpipe) { while (fgets(line, sizeof(line), bpipe->rfd)) { Jmsg(jcr, M_ALERT, 0, _("Alert: %s"), line); @@ -548,25 +583,47 @@ bool release_device(DCR *dcr) free_pool_memory(alert); } pthread_cond_broadcast(&dev->wait_next_vol); - Dmsg1(100, "JobId=%u broadcast wait_device_release\n", (uint32_t)jcr->JobId); + Dmsg2(100, "JobId=%u broadcast wait_device_release at %s\n", + (uint32_t)jcr->JobId, bstrftimes(tbuf, sizeof(tbuf), (utime_t)time(NULL))); pthread_cond_broadcast(&wait_device_release); - dev->dunlock(); - if (jcr->read_dcr == dcr) { - jcr->read_dcr = NULL; + + /* + * If we are the thread that blocked the device, then unblock it + */ + if (pthread_equal(dev->no_wait_id, pthread_self())) { + dev->dunblock(true); + } else { + /* Otherwise, reset the prior block status and unlock */ + dev->set_blocked(was_blocked); + dev->Unlock(); } - if (jcr->dcr == dcr) { - jcr->dcr = NULL; + + if (dcr->keep_dcr) { + dev->detach_dcr_from_dev(dcr); + } else { + free_dcr(dcr); } - free_dcr(dcr); - Dmsg2(100, "===== Device %s released by JobId=%u\n", dev->print_name(), + Dmsg2(100, "Device %s released by JobId=%u\n", dev->print_name(), (uint32_t)jcr->JobId); return ok; } +/* + * Clean up the device for reuse without freeing the memory + */ +bool clean_device(DCR *dcr) +{ + bool ok; + dcr->keep_dcr = true; /* do not free the dcr */ + ok = release_device(dcr); + dcr->keep_dcr = false; + return ok; +} + /* * Create a new Device Control Record and attach * it to the device (if this is a real job). - * Note, this has been updated so that it can be called first + * Note, this has been updated so that it can be called first * without a DEVICE, then a second or third time with a DEVICE, * and each time, it should cleanup and point to the new device. * This should facilitate switching devices. @@ -576,8 +633,9 @@ bool release_device(DCR *dcr) * this dcr in the right place * */ -DCR *new_dcr(JCR *jcr, DCR *dcr, DEVICE *dev) +DCR *new_dcr(JCR *jcr, DCR *dcr, DEVICE *dev, bool writing) { + DEVICE *odev; if (!dcr) { dcr = (DCR *)malloc(sizeof(DCR)); memset(dcr, 0, sizeof(DCR)); @@ -585,23 +643,35 @@ DCR *new_dcr(JCR *jcr, DCR *dcr, DEVICE *dev) dcr->spool_fd = -1; } dcr->jcr = jcr; /* point back to jcr */ + odev = dcr->dev; + if (dcr->attached_to_dev && odev) { + Dmsg2(100, "Detach 0x%x from olddev %s\n", dcr, odev->print_name()); + odev->detach_dcr_from_dev(dcr); + } + ASSERT2(!dcr->attached_to_dev, "DCR is attached. Wrong!"); /* Set device information, possibly change device */ if (dev) { - if (dcr->block) { - free_block(dcr->block); - } + dcr->free_blocks(); dcr->block = new_block(dev); if (dcr->rec) { free_record(dcr->rec); } dcr->rec = new_record(); - if (dcr->attached_to_dev) { - detach_dcr_from_dev(dcr); + /* Use job spoolsize prior to device spoolsize */ + if (jcr && jcr->spool_size) { + dcr->max_job_spool_size = jcr->spool_size; + } else { + dcr->max_job_spool_size = dev->device->max_job_spool_size; } - dcr->max_job_spool_size = dev->device->max_job_spool_size; dcr->device = dev->device; - dcr->dev = dev; - attach_dcr_to_dev(dcr); + dcr->set_dev(dev); + Dmsg2(100, "Attach 0x%x to dev %s\n", dcr, dev->print_name()); + dev->attach_dcr_to_dev(dcr); + } + if (writing) { + dcr->set_writing(); + } else { + dcr->clear_writing(); } return dcr; } @@ -635,33 +705,46 @@ static void remove_dcr_from_dcrs(DCR *dcr) } #endif -static void attach_dcr_to_dev(DCR *dcr) +void DEVICE::attach_dcr_to_dev(DCR *dcr) { - DEVICE *dev = dcr->dev; JCR *jcr = dcr->jcr; + Lock_dcrs(); + jcr = dcr->jcr; if (jcr) Dmsg1(500, "JobId=%u enter attach_dcr_to_dev\n", (uint32_t)jcr->JobId); - if (!dcr->attached_to_dev && dev->initiated && jcr && jcr->JobType != JT_SYSTEM) { - dev->attached_dcrs->append(dcr); /* attach dcr to device */ + /* ***FIXME*** return error if dev not initiated */ + if (!dcr->attached_to_dev && initiated && jcr && jcr->getJobType() != JT_SYSTEM) { + Dmsg4(200, "Attach Jid=%d dcr=%p size=%d dev=%s\n", (uint32_t)jcr->JobId, + dcr, attached_dcrs->size(), print_name()); + attached_dcrs->append(dcr); /* attach dcr to device */ dcr->attached_to_dev = true; - Dmsg1(500, "JobId=%u attach_dcr_to_dev\n", (uint32_t)jcr->JobId); } + Unlock_dcrs(); } -void detach_dcr_from_dev(DCR *dcr) +/* + * Note!! Do not enter with dev->Lock() since unreserve_device() + * is going to lock it too. + */ +void DEVICE::detach_dcr_from_dev(DCR *dcr) { - DEVICE *dev = dcr->dev; - Dmsg1(500, "JobId=%u enter detach_dcr_from_dev\n", (uint32_t)dcr->jcr->JobId); + Dmsg0(500, "Enter detach_dcr_from_dev\n"); /* jcr is NULL in some cases */ + Lock(); + Lock_dcrs(); /* Detach this dcr only if attached */ - if (dcr->attached_to_dev && dev) { - dev->dlock(); - unreserve_device(dcr); - dcr->dev->attached_dcrs->remove(dcr); /* detach dcr from device */ + if (dcr->attached_to_dev) { + dcr->unreserve_device(true); + Dmsg4(200, "Detach Jid=%d dcr=%p size=%d to dev=%s\n", (uint32_t)dcr->jcr->JobId, + dcr, attached_dcrs->size(), print_name()); dcr->attached_to_dev = false; -// remove_dcr_from_dcrs(dcr); /* remove dcr from jcr list */ - dev->dunlock(); + if (attached_dcrs->size()) { + attached_dcrs->remove(dcr); /* detach dcr from device */ + } } + dcr->attached_to_dev = false; + Unlock_dcrs(); + Unlock(); } /* @@ -670,18 +753,36 @@ void detach_dcr_from_dev(DCR *dcr) */ void free_dcr(DCR *dcr) { - JCR *jcr = dcr->jcr; + JCR *jcr; - detach_dcr_from_dev(dcr); + jcr = dcr->jcr; - if (dcr->block) { - free_block(dcr->block); + if (dcr->dev) { + dcr->dev->detach_dcr_from_dev(dcr); } + + dcr->free_blocks(); if (dcr->rec) { free_record(dcr->rec); } if (jcr && jcr->dcr == dcr) { jcr->dcr = NULL; } + if (jcr && jcr->read_dcr == dcr) { + jcr->read_dcr = NULL; + } free(dcr); } + +static void set_dcr_from_vol(DCR *dcr, VOL_LIST *vol) +{ + /* + * Note, if we want to be able to work from a .bsr file only + * for disaster recovery, we must "simulate" reading the catalog + */ + bstrncpy(dcr->VolumeName, vol->VolumeName, sizeof(dcr->VolumeName)); + dcr->setVolCatName(vol->VolumeName); + bstrncpy(dcr->media_type, vol->MediaType, sizeof(dcr->media_type)); + dcr->VolCatInfo.Slot = vol->Slot; + dcr->VolCatInfo.InChanger = vol->Slot > 0; +}