X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Fdevice.c;h=b38b512d0bba87783189ab5d40f589c78febd802;hb=bc9b9b481e86991abd879d30aa03b64b4c68d578;hp=f1d066c3a73b1ddd14a36d79c4502dcfbdd0e5fb;hpb=1fd377cf78296a3d93ef1bb953f54a99707f655a;p=bacula%2Fbacula diff --git a/bacula/src/stored/device.c b/bacula/src/stored/device.c index f1d066c3a7..b38b512d0b 100644 --- a/bacula/src/stored/device.c +++ b/bacula/src/stored/device.c @@ -1,383 +1,326 @@ +/* + Bacula® - The Network Backup Solution + + Copyright (C) 2000-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. +*/ /* * - * Higher Level Device routines. - * Knows about Bacula tape labels and such + * Higher Level Device routines. + * Knows about Bacula tape labels and such * * NOTE! In general, subroutines that have the word * "device" in the name do locking. Subroutines * that have the word "dev" in the name do not - * do locking. Thus if xxx_device() calls - * yyy_dev(), all is OK, but if xxx_device() - * calls yyy_device(), everything will hang. - * Obviously, no zzz_dev() is allowed to call - * a www_device() or everything falls apart. + * do locking. Thus if xxx_device() calls + * yyy_dev(), all is OK, but if xxx_device() + * calls yyy_device(), everything will hang. + * Obviously, no zzz_dev() is allowed to call + * a www_device() or everything falls apart. * - * Concerning the routines lock_device() and block_device() + * Concerning the routines dev->r_lock()() and block_device() * see the end of this module for details. In general, * blocking a device leaves it in a state where all threads - * other than the current thread block when they attempt to + * other than the current thread block when they attempt to * lock the device. They remain suspended (blocked) until the device * is unblocked. So, a device is blocked during an operation * that takes a long time (initialization, mounting a new * volume, ...) locking a device is done for an operation - * that takes a short time such as writing data to the + * that takes a short time such as writing data to the * device. * * * Kern Sibbald, MM, MMI - * + * * Version $Id$ */ -/* - Copyright (C) 2000-2003 Kern Sibbald and John Walker - - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License as - published by the Free Software Foundation; either version 2 of - the License, or (at your option) any later version. - - 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., 59 Temple Place - Suite 330, Boston, - MA 02111-1307, USA. - - */ #include "bacula.h" /* pull in global headers */ #include "stored.h" /* pull in Storage Deamon headers */ /* Forward referenced functions */ -extern char my_name[]; -extern int debug_level; - /* * This is the dreaded moment. We either have an end of * medium condition or worse, and error condition. * Attempt to "recover" by obtaining a new Volume. * - * We enter with device locked, and + * Here are a few things to know: + * dcr->VolCatInfo contains the info on the "current" tape for this job. + * dev->VolCatInfo contains the info on the tape in the drive. + * The tape in the drive could have changed several times since + * the last time the job used it (jcr->VolCatInfo). + * dcr->VolumeName is the name of the current/desired tape in the drive. + * + * We enter with device locked, and * exit with device locked. * - * Note, we are called only from one place in block.c + * Note, we are called only from one place in block.c for the daemons. + * The btape utility calls it from btape.c. * - * Returns: 1 on success - * 0 on failure + * Returns: true on success + * false on failure */ -int fixup_device_block_write_error(JCR *jcr, DEVICE *dev, DEV_BLOCK *block) +bool fixup_device_block_write_error(DCR *dcr) { - uint32_t stat = 0; char PrevVolName[MAX_NAME_LENGTH]; - DEV_BLOCK *label_blk = NULL; + DEV_BLOCK *label_blk; + DEV_BLOCK *block = dcr->block; char b1[30], b2[30]; time_t wait_time; + char dt[MAX_TIME_LENGTH]; + JCR *jcr = dcr->jcr; + DEVICE *dev = dcr->dev; + int blocked = dev->blocked(); /* save any previous blocked status */ + bool ok = false; wait_time = time(NULL); - status_dev(dev, &stat); - if (stat & BMT_EOD) { - Dmsg0(100, "======= Got EOD ========\n"); - - block_device(dev, BST_DOING_ACQUIRE); - /* Unlock, but leave BLOCKED */ - unlock_device(dev); - - /* - * Walk through all attached jcrs creating a jobmedia_record() - */ - Dmsg1(100, "Walk attached jcrs. Volume=%s\n", dev->VolCatInfo.VolCatName); - for (JCR *mjcr=NULL; (mjcr=next_attached_jcr(dev, mjcr)); ) { - Dmsg1(100, "create JobMedia for Job %s\n", mjcr->Job); - if (dev->state & ST_TAPE) { - mjcr->EndBlock = dev->EndBlock; - mjcr->EndFile = dev->EndFile; - Dmsg2(200, "Fixup EndFile=%u EndBlock=%u\n", mjcr->EndFile, mjcr->EndBlock); - } else { - mjcr->EndBlock = (uint32_t)dev->file_addr; - mjcr->EndFile = (uint32_t)(dev->file_addr >> 32); - } - if (!dir_create_jobmedia_record(mjcr)) { - Jmsg(mjcr, M_ERROR, 0, _("Could not create JobMedia record for Volume=%s Job=%s\n"), - dev->VolCatInfo.VolCatName, mjcr->Job); - P(dev->mutex); - unblock_device(dev); - return 0; - } - mjcr->VolFirstIndex = 0; /* prevent writing jobmedia second time */ - } - strcpy(dev->VolCatInfo.VolCatStatus, "Full"); - Dmsg2(200, "Call update_vol_info Stat=%s Vol=%s\n", - dev->VolCatInfo.VolCatStatus, dev->VolCatInfo.VolCatName); - if (!dir_update_volume_info(jcr, &dev->VolCatInfo, 0)) { /* send Volume info to Director */ - P(dev->mutex); - unblock_device(dev); - return 0; /* device locked */ - } - Dmsg0(100, "Back from update_vol_info\n"); + Dmsg0(100, "Enter fixup_device_block_write_error\n"); - strcpy(PrevVolName, dev->VolCatInfo.VolCatName); - strcpy(dev->VolHdr.PrevVolName, PrevVolName); + /* + * If we are blocked at entry, unblock it, and set our own block status + */ + if (blocked != BST_NOT_BLOCKED) { + unblock_device(dev); + } + block_device(dev, BST_DOING_ACQUIRE); - label_blk = new_block(dev); + /* Continue unlocked, but leave BLOCKED */ + dev->dunlock(); - /* Inform User about end of media */ - Jmsg(jcr, M_INFO, 0, _("End of media on Volume %s Bytes=%s Blocks=%s.\n"), - PrevVolName, edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, b1), - edit_uint64_with_commas(dev->VolCatInfo.VolCatBlocks, b2)); + bstrncpy(PrevVolName, dev->VolCatInfo.VolCatName, sizeof(PrevVolName)); + bstrncpy(dev->VolHdr.PrevVolumeName, PrevVolName, sizeof(dev->VolHdr.PrevVolumeName)); - if (!mount_next_write_volume(jcr, dev, label_blk, 1)) { - P(dev->mutex); - unblock_device(dev); - return 0; /* device locked */ - } - P(dev->mutex); /* lock again */ - - Jmsg(jcr, M_INFO, 0, _("New volume %s mounted on device %s\n"), - jcr->VolumeName, dev_name(dev)); - - /* - * If this is a new tape, the label_blk will contain the - * label, so write it now. If this is a previously - * used tape, mount_next_write_volume() will return an - * empty label_blk, and nothing will be written. - */ - Dmsg0(190, "write label block to dev\n"); - if (!write_block_to_dev(jcr, dev, label_blk)) { - Pmsg1(0, "write_block_to_device Volume label failed. ERR=%s", - strerror_dev(dev)); - free_block(label_blk); - unblock_device(dev); - return 0; /* device locked */ - } + label_blk = new_block(dev); + dcr->block = label_blk; - /* Write overflow block to tape */ - Dmsg0(190, "Write overflow block to dev\n"); - if (!write_block_to_dev(jcr, dev, block)) { - Pmsg1(0, "write_block_to_device overflow block failed. ERR=%s", - strerror_dev(dev)); - free_block(label_blk); - unblock_device(dev); - return 0; /* device locked */ - } + /* Inform User about end of medium */ + Jmsg(jcr, M_INFO, 0, _("End of medium on Volume \"%s\" Bytes=%s Blocks=%s at %s.\n"), + PrevVolName, edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, b1), + edit_uint64_with_commas(dev->VolCatInfo.VolCatBlocks, b2), + bstrftime(dt, sizeof(dt), time(NULL))); - jcr->NumVolumes++; - Dmsg0(190, "Wake up any waiting threads.\n"); + /* Called with have_vol=false, release=true */ + if (!mount_next_write_volume(dcr, false, true)) { free_block(label_blk); - for (JCR *mjcr=NULL; (mjcr=next_attached_jcr(dev, mjcr)); ) { - /* Set new start/end positions */ - if (dev->state & ST_TAPE) { - mjcr->StartBlock = dev->block_num; - mjcr->StartFile = dev->file; - } else { - mjcr->StartBlock = (uint32_t)dev->file_addr; - mjcr->StartFile = (uint32_t)(dev->file_addr >> 32); - } - /* Set first FirstIndex for new Volume */ - mjcr->VolFirstIndex = mjcr->JobFiles; - mjcr->run_time += time(NULL) - wait_time; /* correct run time */ - } - unblock_device(dev); - return 1; /* device locked */ + dcr->block = block; + dev->dlock(); + goto bail_out; } - if (label_blk) { + dev->dlock(); /* lock again */ + + dev->VolCatInfo.VolCatJobs++; /* increment number of jobs on vol */ + dir_update_volume_info(dcr, false, false); /* send Volume info to Director */ + + Jmsg(jcr, M_INFO, 0, _("New volume \"%s\" mounted on device %s at %s.\n"), + dcr->VolumeName, dev->print_name(), bstrftime(dt, sizeof(dt), time(NULL))); + + /* + * If this is a new tape, the label_blk will contain the + * label, so write it now. If this is a previously + * used tape, mount_next_write_volume() will return an + * empty label_blk, and nothing will be written. + */ + Dmsg0(190, "write label block to dev\n"); + if (!write_block_to_dev(dcr)) { + berrno be; + Pmsg1(0, _("write_block_to_device Volume label failed. ERR=%s"), + be.bstrerror(dev->dev_errno)); free_block(label_blk); + dcr->block = block; + goto bail_out; } - return 0; /* device locked */ -} - - -/* - * Open the device. Expect dev to already be initialized. - * - * This routine is used only when the Storage daemon starts - * and always_open is set, and in the stand-alone utility - * routines such as bextract. - * - * Note, opening of a normal file is deferred to later so - * that we can get the filename; the device_name for - * a file is the directory only. - * - * Retuns: 0 on failure - * 1 on success - */ -int open_device(DEVICE *dev) -{ - Dmsg0(120, "start open_output_device()\n"); - if (!dev) { - return 0; + free_block(label_blk); + dcr->block = block; + + /* + * Walk through all attached jcrs indicating the volume has changed + */ + Dmsg1(100, "Walk attached dcrs. Volume=%s\n", dev->VolCatInfo.VolCatName); + DCR *mdcr; + foreach_dlist(mdcr, dev->attached_dcrs) { + JCR *mjcr = mdcr->jcr; + if (mjcr->JobId == 0) { + continue; /* ignore console */ + } + mdcr->NewVol = true; + if (jcr != mjcr) { + bstrncpy(mdcr->VolumeName, dcr->VolumeName, sizeof(mdcr->VolumeName)); + } } - lock_device(dev); + /* Clear NewVol now because dir_get_volume_info() already done */ + jcr->dcr->NewVol = false; + set_new_volume_parameters(dcr); - /* Defer opening files */ - if (!dev_is_tape(dev)) { - Dmsg0(129, "Device is file, deferring open.\n"); - unlock_device(dev); - return 1; - } + jcr->run_time += time(NULL) - wait_time; /* correct run time for mount wait */ - if (!(dev->state & ST_OPENED)) { - Dmsg0(129, "Opening device.\n"); - if (open_dev(dev, NULL, READ_WRITE) < 0) { - Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg); - unlock_device(dev); - return 0; - } + /* Write overflow block to device */ + Dmsg0(190, "Write overflow block to dev\n"); + if (!write_block_to_dev(dcr)) { + berrno be; + Pmsg1(0, _("write_block_to_device overflow block failed. ERR=%s"), + be.bstrerror(dev->dev_errno)); + goto bail_out; } - Dmsg1(129, "open_dev %s OK\n", dev_name(dev)); - - unlock_device(dev); - return 1; -} - -/* - * When dev_blocked is set, all threads EXCEPT thread with id no_wait_id - * must wait. The no_wait_id thread is out obtaining a new volume - * and preparing the label. - */ -void _lock_device(char *file, int line, DEVICE *dev) -{ - int stat; - Dmsg3(100, "lock %d from %s:%d\n", dev->dev_blocked, file, line); - P(dev->mutex); - if (dev->dev_blocked && !pthread_equal(dev->no_wait_id, pthread_self())) { - dev->num_waiting++; /* indicate that I am waiting */ - while (dev->dev_blocked) { - if ((stat = pthread_cond_wait(&dev->wait, &dev->mutex)) != 0) { - V(dev->mutex); - Emsg1(M_ABORT, 0, _("pthread_cond_wait failure. ERR=%s\n"), - strerror(stat)); - } - } - dev->num_waiting--; /* no longer waiting */ + ok = true; + +bail_out: + /* + * At this point, the device is locked and blocked. + * Unblock the device, restore any entry blocked condition, then + * return leaving the device locked (as it was on entry). + */ + unblock_device(dev); + if (blocked != BST_NOT_BLOCKED) { + block_device(dev, blocked); } + return ok; /* device locked */ } -void _unlock_device(char *file, int line, DEVICE *dev) +void set_start_vol_position(DCR *dcr) { - Dmsg2(100, "unlock from %s:%d\n", file, line); - V(dev->mutex); -} - -/* - * Block all other threads from using the device - * Device must already be locked. After this call, - * the device is blocked to any thread calling lock_device(), - * but the device is not locked (i.e. no P on device). Also, - * the current thread can do slip through the lock_device() - * calls without blocking. - */ -void _block_device(char *file, int line, DEVICE *dev, int state) -{ - Dmsg3(100, "block set %d from %s:%d\n", state, file, line); - ASSERT(dev->dev_blocked == BST_NOT_BLOCKED); - dev->dev_blocked = state; /* make other threads wait */ - dev->no_wait_id = pthread_self(); /* allow us to continue */ + DEVICE *dev = dcr->dev; + /* Set new start position */ + if (dev->is_tape()) { + dcr->StartBlock = dev->block_num; + dcr->StartFile = dev->file; + } else { + dcr->StartBlock = (uint32_t)dev->file_addr; + dcr->StartFile = (uint32_t)(dev->file_addr >> 32); + } } - - /* - * Unblock the device, and wake up anyone who went to sleep. + * We have a new Volume mounted, so reset the Volume parameters + * concerning this job. The global changes were made earlier + * in the dev structure. */ -void _unblock_device(char *file, int line, DEVICE *dev) +void set_new_volume_parameters(DCR *dcr) { - Dmsg3(100, "unblock %d from %s:%d\n", dev->dev_blocked, file, line); - ASSERT(dev->dev_blocked); - dev->dev_blocked = BST_NOT_BLOCKED; - if (dev->num_waiting > 0) { - pthread_cond_broadcast(&dev->wait); /* wake them up */ + JCR *jcr = dcr->jcr; + if (dcr->NewVol && !dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) { + Jmsg1(jcr, M_ERROR, 0, "%s", jcr->errmsg); } + set_new_file_parameters(dcr); + jcr->NumWriteVolumes++; } -void _steal_device_lock(char *file, int line, DEVICE *dev, bsteal_lock_t *hold, int state) +/* + * We are now in a new Volume file, so reset the Volume parameters + * concerning this job. The global changes were made earlier + * in the dev structure. + */ +void set_new_file_parameters(DCR *dcr) { - Dmsg4(100, "steal lock. old=%d new=%d from %s:%d\n", dev->dev_blocked, state, - file, line); - hold->dev_blocked = dev->dev_blocked; - hold->no_wait_id = dev->no_wait_id; - dev->dev_blocked = state; - dev->no_wait_id = pthread_self(); - V(dev->mutex); -} + set_start_vol_position(dcr); -void _return_device_lock(char *file, int line, DEVICE *dev, bsteal_lock_t *hold) -{ - Dmsg4(100, "return lock. old=%d new=%d from %s:%d\n", - dev->dev_blocked, hold->dev_blocked, file, line); - P(dev->mutex); - dev->dev_blocked = hold->dev_blocked; - dev->no_wait_id = hold->no_wait_id; + /* Reset indicies */ + dcr->VolFirstIndex = 0; + dcr->VolLastIndex = 0; + dcr->NewFile = false; + dcr->WroteVol = false; } -/* ================================================================== - * New device locking code. It is not currently used. - * ================================================================== - */ - /* - * New device locking scheme + * First Open of the device. Expect dev to already be initialized. + * + * This routine is used only when the Storage daemon starts + * and always_open is set, and in the stand-alone utility + * routines such as bextract. + * + * Note, opening of a normal file is deferred to later so + * that we can get the filename; the device_name for + * a file is the directory only. + * + * Returns: false on failure + * true on success */ -void _new_lock_device(char *file, int line, DEVICE *dev) +bool first_open_device(DCR *dcr) { -#ifdef NEW_LOCK - int errstat; - if ((errstat=rwl_writelock(&dev->lock)) != 0) { - e_msg(file, line, M_ABORT, 0, "rwl_writelock failure. ERR=%s\n", - strerror(errstat)); - } -#endif -} + DEVICE *dev = dcr->dev; + bool ok = true; -void _new_lock_device(char *file, int line, DEVICE *dev, int state) -{ -#ifdef NEW_LOCK - int errstat; - if ((errstat=rwl_writelock(&dev->lock)) != 0) { - e_msg(file, line, M_ABORT, 0, "rwl_writelock failure. ERR=%s\n", - strerror(errstat)); + Dmsg0(120, "start open_output_device()\n"); + if (!dev) { + return false; } - dev->dev_blocked = state; -#endif -} -void _new_unlock_device(char *file, int line, DEVICE *dev) -{ -#ifdef NEW_LOCK - int errstat; - if (dev->lock.w_active == 1) { - dev->dev_blocked = BST_NOT_BLOCKED; + dev->r_dlock(); + + /* Defer opening files */ + if (!dev->is_tape()) { + Dmsg0(129, "Device is file, deferring open.\n"); + goto bail_out; } - if ((errstat=rwl_writeunlock(&dev->lock)) != 0) { - e_msg(file, line, M_ABORT, 0, "rwl_writeunlock failure. ERR=%s\n", - strerror(errstat)); + + int mode; + if (dev->has_cap(CAP_STREAM)) { + mode = OPEN_WRITE_ONLY; + } else { + mode = OPEN_READ_ONLY; + } + Dmsg0(129, "Opening device.\n"); + if (dev->open(dcr, mode) < 0) { + Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg); + ok = false; + goto bail_out; } -#endif -} + Dmsg1(129, "open dev %s OK\n", dev->print_name()); -void new_steal_device_lock(DEVICE *dev, brwsteal_t *hold, int state) -{ -#ifdef NEW_LOCK - hold->state = dev->dev_blocked; - hold->writer_id = dev->lock.writer_id; - dev->dev_blocked = state; - dev->lock.writer_id = pthread_self(); - V(dev->lock.mutex); -#endif +bail_out: + dev->dunlock(); + return ok; } -void new_return_device_lock(DEVICE *dev, brwsteal_t *hold) +/* + * Make sure device is open, if not do so + */ +bool open_device(DCR *dcr) { -#ifdef NEW_LOCK - P(dev->lock.mutex); - dev->dev_blocked = hold->state; - dev->lock.writer_id = hold->writer_id; -#endif + DEVICE *dev = dcr->dev; + /* Open device */ + int mode; + if (dev->has_cap(CAP_STREAM)) { + mode = OPEN_WRITE_ONLY; + } else { + mode = OPEN_READ_WRITE; + } + if (dev->open(dcr, mode) < 0) { + /* If polling, ignore the error */ + /* If DVD, also ignore the error, very often you cannot open the device + * (when there is no DVD, or when the one inserted is a wrong one) */ + if (!dev->poll && !dev->is_dvd() && !dev->is_removable()) { + Jmsg2(dcr->jcr, M_FATAL, 0, _("Unable to open device %s: ERR=%s\n"), + dev->print_name(), dev->bstrerror()); + Pmsg2(000, _("Unable to open archive %s: ERR=%s\n"), + dev->print_name(), dev->bstrerror()); + } + return false; + } + return true; }