X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Fdevice.c;h=7d5a9af81bf2e4ebace9dd2583ec056ebd96a9dd;hb=dc43fa5c6823b93c4206888e3bf639982af4563b;hp=66894d0596630708777b800b24e194f5bd080e97;hpb=5b4e4c084dfebb100fc278a396cfceb90edd2446;p=bacula%2Fbacula diff --git a/bacula/src/stored/device.c b/bacula/src/stored/device.c index 66894d0596..7d5a9af81b 100644 --- a/bacula/src/stored/device.c +++ b/bacula/src/stored/device.c @@ -29,7 +29,7 @@ * Version $Id$ */ /* - Copyright (C) 2000, 2001, 2002 Kern Sibbald and John Walker + Copyright (C) 2000-2004 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 @@ -61,138 +61,200 @@ extern int debug_level; * medium condition or worse, and error condition. * Attempt to "recover" by obtaining a new Volume. * + * 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 * - * 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; + uint32_t stat; 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; wait_time = time(NULL); - status_dev(dev, &stat); - if (stat & MT_EOD) { - Dmsg0(100, "======= Got EOD ========\n"); + stat = status_dev(dev); + if (!(stat & BMT_EOD)) { + return false; /* this really shouldn't happen */ + } - block_device(dev, BST_DOING_ACQUIRE); - /* Unlock, but leave BLOCKED */ - unlock_device(dev); + Dmsg0(100, "======= Got EOD ========\n"); - /* - * 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; - } - } + block_device(dev, BST_DOING_ACQUIRE); + /* Unlock, but leave BLOCKED */ + unlock_device(dev); - strcpy(dev->VolCatInfo.VolCatStatus, "Full"); - Dmsg2(100, "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 */ - Jmsg(jcr, M_ERROR, 0, _("Could not update Volume info Volume=%s Job=%s\n"), - dev->VolCatInfo.VolCatName, jcr->Job); - P(dev->mutex); - unblock_device(dev); - return 0; /* device locked */ - } - Dmsg0(100, "Back from update_vol_info\n"); + /* Create a jobmedia record for this job */ + if (!dir_create_jobmedia_record(dcr)) { + Jmsg(jcr, M_ERROR, 0, _("Could not create JobMedia record for Volume=\"%s\" Job=%s\n"), + dcr->VolCatInfo.VolCatName, jcr->Job); + P(dev->mutex); + unblock_device(dev); + return false; + } + + bstrncpy(dev->VolCatInfo.VolCatStatus, "Full", sizeof(dev->VolCatInfo.VolCatStatus)); + Dmsg2(100, "Call update_vol_info Stat=%s Vol=%s\n", + dev->VolCatInfo.VolCatStatus, dev->VolCatInfo.VolCatName); + dev->VolCatInfo.VolCatFiles = dev->file; /* set number of files */ + dev->VolCatInfo.VolCatJobs++; /* increment number of jobs */ + if (!dir_update_volume_info(dcr, false)) { /* send Volume info to Director */ + P(dev->mutex); + unblock_device(dev); + return false; /* device locked */ + } + Dmsg0(100, "Back from update_vol_info\n"); - strcpy(PrevVolName, dev->VolCatInfo.VolCatName); - strcpy(dev->VolHdr.PrevVolName, PrevVolName); + bstrncpy(PrevVolName, dev->VolCatInfo.VolCatName, sizeof(PrevVolName)); + bstrncpy(dev->VolHdr.PrevVolName, PrevVolName, sizeof(dev->VolHdr.PrevVolName)); - label_blk = new_block(dev); + label_blk = new_block(dev); + dcr->block = label_blk; - /* 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)); + /* 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))); - if (!mount_next_write_volume(jcr, dev, label_blk, 1)) { - P(dev->mutex); - unblock_device(dev); - return 0; /* device locked */ + if (!mount_next_write_volume(dcr, 1)) { + free_block(label_blk); + dcr->block = block; + P(dev->mutex); + unblock_device(dev); + return false; /* device locked */ + } + P(dev->mutex); /* lock again */ + + Jmsg(jcr, M_INFO, 0, _("New volume \"%s\" mounted on device %s at %s.\n"), + dcr->VolumeName, dev_name(dev), 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)) { + Pmsg1(0, "write_block_to_device Volume label failed. ERR=%s", + strerror_dev(dev)); + free_block(label_blk); + dcr->block = block; + unblock_device(dev); + return false; /* device locked */ + } + free_block(label_blk); + dcr->block = block; + + /* + * Walk through all attached jcrs indicating the volume has changed + */ + Dmsg1(100, "Walk attached jcrs. Volume=%s\n", dev->VolCatInfo.VolCatName); +// for (JCR *mjcr=NULL; (mjcr=next_attached_jcr(dev, mjcr)); ) { + DCR *mdcr; + foreach_dlist(mdcr, dev->attached_dcrs) { + JCR *mjcr = mdcr->jcr; + if (mjcr->JobId == 0) { + continue; /* ignore console */ } - 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 */ + mdcr->NewVol = true; + if (jcr != mjcr) { + bstrncpy(mdcr->VolumeName, dcr->VolumeName, sizeof(mdcr->VolumeName)); } + } - /* 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 */ - } + /* Clear NewVol now because dir_get_volume_info() already done */ + jcr->dcr->NewVol = false; + set_new_volume_parameters(dcr); - jcr->NumVolumes++; - Dmsg0(190, "Wake up any waiting threads.\n"); - 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); - } - mjcr->VolFirstFile = mjcr->JobFiles; - mjcr->run_time += time(NULL) - wait_time; /* correct run time */ - } + jcr->run_time += time(NULL) - wait_time; /* correct run time for mount wait */ + + /* Write overflow block to device */ + Dmsg0(190, "Write overflow block to dev\n"); + if (!write_block_to_dev(dcr)) { + Pmsg1(0, "write_block_to_device overflow block failed. ERR=%s", + strerror_dev(dev)); unblock_device(dev); - return 1; /* device locked */ + return false; /* device locked */ } - if (label_blk) { - free_block(label_blk); + + unblock_device(dev); + return true; /* device locked */ +} + +/* + * 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 set_new_volume_parameters(DCR *dcr) +{ + JCR *jcr = dcr->jcr; + DEVICE *dev = dcr->dev; + if (dcr->NewVol && !dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) { + Jmsg1(jcr, M_ERROR, 0, "%s", jcr->errmsg); + } + /* Set new start/end positions */ + if (dev_state(dev, ST_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); + } + /* Reset indicies */ + dcr->VolFirstIndex = 0; + dcr->VolLastIndex = 0; + jcr->NumVolumes++; + dcr->NewVol = false; + dcr->WroteVol = false; +} + +/* + * 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) +{ + DEVICE *dev = dcr->dev; + + /* Set new start/end positions */ + if (dev_state(dev, ST_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); } - return 0; /* device locked */ + /* Reset indicies */ + dcr->VolFirstIndex = 0; + dcr->VolLastIndex = 0; + dcr->NewFile = false; + dcr->WroteVol = false; } + /* - * Open the device. Expect dev to already be initialized. + * 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 @@ -202,14 +264,14 @@ int fixup_device_block_write_error(JCR *jcr, DEVICE *dev, DEV_BLOCK *block) * that we can get the filename; the device_name for * a file is the directory only. * - * Retuns: 0 on failure - * 1 on success + * Returns: false on failure + * true on success */ -int open_device(DEVICE *dev) +bool first_open_device(DEVICE *dev) { Dmsg0(120, "start open_output_device()\n"); if (!dev) { - return 0; + return false; } lock_device(dev); @@ -218,21 +280,69 @@ int open_device(DEVICE *dev) if (!dev_is_tape(dev)) { Dmsg0(129, "Device is file, deferring open.\n"); unlock_device(dev); - return 1; + return true; } if (!(dev->state & ST_OPENED)) { + int mode; + if (dev_cap(dev, CAP_STREAM)) { + mode = OPEN_WRITE_ONLY; + } else { + mode = OPEN_READ_WRITE; + } Dmsg0(129, "Opening device.\n"); - if (open_dev(dev, NULL, READ_WRITE) < 0) { + if (open_dev(dev, NULL, mode) < 0) { Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg); unlock_device(dev); - return 0; + return false; } } Dmsg1(129, "open_dev %s OK\n", dev_name(dev)); unlock_device(dev); - return 1; + return true; +} + +/* + * Make sure device is open, if not do so + */ +bool open_device(DCR *dcr) +{ + DEVICE *dev = dcr->dev; + /* Open device */ + if (!(dev_state(dev, ST_OPENED))) { + int mode; + if (dev_cap(dev, CAP_STREAM)) { + mode = OPEN_WRITE_ONLY; + } else { + mode = OPEN_READ_WRITE; + } + if (open_dev(dev, dcr->VolCatInfo.VolCatName, mode) < 0) { + /* If polling, ignore the error */ + if (!dev->poll) { + Jmsg2(dcr->jcr, M_FATAL, 0, _("Unable to open device %s. ERR=%s\n"), + dev_name(dev), strerror_dev(dev)); + } + return false; + } + } + return true; +} + +void dev_lock(DEVICE *dev) +{ + int errstat; + if ((errstat=rwl_writelock(&dev->lock))) { + Emsg1(M_ABORT, 0, "Device write lock failure. ERR=%s\n", strerror(errstat)); + } +} + +void dev_unlock(DEVICE *dev) +{ + int errstat; + if ((errstat=rwl_writeunlock(&dev->lock))) { + Emsg1(M_ABORT, 0, "Device write unlock failure. ERR=%s\n", strerror(errstat)); + } } /* @@ -240,10 +350,10 @@ int open_device(DEVICE *dev) * 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) +void _lock_device(const char *file, int line, DEVICE *dev) { int stat; - Dmsg3(100, "lock %d from %s:%d\n", dev->dev_blocked, file, line); + Dmsg3(500, "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 */ @@ -258,9 +368,43 @@ void _lock_device(char *file, int line, DEVICE *dev) } } -void _unlock_device(char *file, int line, DEVICE *dev) +/* + * Check if the device is blocked or not + */ +bool device_is_unmounted(DEVICE *dev) +{ + bool stat; + int blocked = dev->dev_blocked; + stat = (blocked == BST_UNMOUNTED) || + (blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP); + return stat; +} + +const char *edit_blocked_reason(DEVICE *dev) +{ + switch (dev->dev_blocked) { + case BST_NOT_BLOCKED: + return "not blocked"; + case BST_UNMOUNTED: + return "user unmounted device"; + case BST_WAITING_FOR_SYSOP: + return "waiting for operator action"; + case BST_DOING_ACQUIRE: + return "opening, validating, or positioning tape"; + case BST_WRITING_LABEL: + return "labeling tape"; + case BST_UNMOUNTED_WAITING_FOR_SYSOP: + return "closed by user during mount request"; + case BST_MOUNT: + return "mount request"; + default: + return "unknown blocked code"; + } +} + +void _unlock_device(const char *file, int line, DEVICE *dev) { - Dmsg2(100, "unlock from %s:%d\n", file, line); + Dmsg2(500, "unlock from %s:%d\n", file, line); V(dev->mutex); } @@ -272,9 +416,9 @@ void _unlock_device(char *file, int line, DEVICE *dev) * the current thread can do slip through the lock_device() * calls without blocking. */ -void _block_device(char *file, int line, DEVICE *dev, int state) +void _block_device(const char *file, int line, DEVICE *dev, int state) { - Dmsg3(100, "block set %d from %s:%d\n", state, file, line); + Dmsg3(500, "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 */ @@ -285,99 +429,46 @@ void _block_device(char *file, int line, DEVICE *dev, int state) /* * Unblock the device, and wake up anyone who went to sleep. */ -void _unblock_device(char *file, int line, DEVICE *dev) +void _unblock_device(const char *file, int line, DEVICE *dev) { - Dmsg3(100, "unblock %d from %s:%d\n", dev->dev_blocked, file, line); + Dmsg3(500, "unblock %d from %s:%d\n", dev->dev_blocked, file, line); ASSERT(dev->dev_blocked); dev->dev_blocked = BST_NOT_BLOCKED; + dev->no_wait_id = 0; if (dev->num_waiting > 0) { pthread_cond_broadcast(&dev->wait); /* wake them up */ } } -void _steal_device_lock(char *file, int line, DEVICE *dev, bsteal_lock_t *hold, int state) +/* + * Enter with device locked and blocked + * Exit with device unlocked and blocked by us. + */ +void _steal_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold, int state) { - Dmsg4(100, "steal lock. old=%d new=%d from %s:%d\n", dev->dev_blocked, state, + Dmsg4(500, "steal lock. old=%d new=%d from %s:%d\n", dev->dev_blocked, state, file, line); hold->dev_blocked = dev->dev_blocked; + hold->dev_prev_blocked = dev->dev_prev_blocked; hold->no_wait_id = dev->no_wait_id; dev->dev_blocked = state; dev->no_wait_id = pthread_self(); V(dev->mutex); } -void _return_device_lock(char *file, int line, DEVICE *dev, bsteal_lock_t *hold) +/* + * Enter with device blocked by us but not locked + * Exit with device locked, and blocked by previous owner + */ +void _give_back_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold) { - Dmsg4(100, "return lock. old=%d new=%d from %s:%d\n", + Dmsg4(500, "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->dev_prev_blocked = hold->dev_prev_blocked; dev->no_wait_id = hold->no_wait_id; -} - - - -/* ================================================================== - * New device locking code. It is not currently used. - * ================================================================== - */ - -/* - * New device locking scheme - */ -void _new_lock_device(char *file, int line, DEVICE *dev) -{ -#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 -} - -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)); - } - 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; - } - if ((errstat=rwl_writeunlock(&dev->lock)) != 0) { - e_msg(file, line, M_ABORT, 0, "rwl_writeunlock failure. ERR=%s\n", - strerror(errstat)); + if (dev->dev_blocked == BST_NOT_BLOCKED && dev->num_waiting > 0) { + pthread_cond_broadcast(&dev->wait); /* wake them up */ } -#endif -} - -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 -} - -void new_return_device_lock(DEVICE *dev, brwsteal_t *hold) -{ -#ifdef NEW_LOCK - P(dev->lock.mutex); - dev->dev_blocked = hold->state; - dev->lock.writer_id = hold->writer_id; -#endif }