X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Fdevice.c;h=7d5a9af81bf2e4ebace9dd2583ec056ebd96a9dd;hb=dc43fa5c6823b93c4206888e3bf639982af4563b;hp=1bee572b4c93039b7e80a858a5f7ebee94c6d60c;hpb=ba0ddc011c5e8d5488ef79cdcef2643927fc5539;p=bacula%2Fbacula diff --git a/bacula/src/stored/device.c b/bacula/src/stored/device.c index 1bee572b4c..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 @@ -52,659 +52,209 @@ #include "stored.h" /* pull in Storage Deamon headers */ /* Forward referenced functions */ -static int mount_next_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *label_blk, int release); -static char *edit_device_codes(JCR *jcr, char *omsg, char *imsg, char *cmd); extern char my_name[]; extern int debug_level; - -/********************************************************************* - * Acquire device for reading. We permit (for the moment) - * only one reader. We read the Volume label from the block and - * leave the block pointers just after the label. +/* + * 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. + * + * 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. * - * Returns: 0 if failed for any reason - * 1 if successful + * We enter with device locked, and + * exit with device locked. + * + * Note, we are called only from one place in block.c + * + * Returns: true on success + * false on failure */ -int acquire_device_for_read(JCR *jcr, DEVICE *dev, DEV_BLOCK *block) +bool fixup_device_block_write_error(DCR *dcr) { - int stat; + uint32_t stat; + char PrevVolName[MAX_NAME_LENGTH]; + 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; - lock_device(dev); - if (dev->state & ST_READ || dev->num_writers > 0) { - Jmsg(jcr, M_FATAL, 0, _("Device %s is busy.\n"), dev_name(dev)); - unlock_device(dev); - return 0; + wait_time = time(NULL); + stat = status_dev(dev); + if (!(stat & BMT_EOD)) { + return false; /* this really shouldn't happen */ } - dev->state &= ~ST_LABEL; /* force reread of label */ + + Dmsg0(100, "======= Got EOD ========\n"); + block_device(dev, BST_DOING_ACQUIRE); + /* Unlock, but leave BLOCKED */ unlock_device(dev); - stat = ready_dev_for_read(jcr, dev, block); - P(dev->mutex); - unblock_device(dev); - V(dev->mutex); - return stat; -} - -/* - * Acquire device for writing. We permit multiple writers. - * If this is the first one, we read the label. - * - * Returns: 0 if failed for any reason - * 1 if successful - */ -int acquire_device_for_append(JCR *jcr, DEVICE *dev, DEV_BLOCK *block) -{ - int release = 0; - int do_mount = 0; - lock_device(dev); - Dmsg1(90, "acquire_append device is %s\n", dev_is_tape(dev)?"tape":"disk"); - - - if (dev->state & ST_APPEND) { - /* - * Device already in append mode - * - * Check if we have the right Volume mounted - * OK if AnonVols and volume info OK - * OK if next volume matches current volume - * otherwise mount desired volume obtained from - * dir_find_next_appendable_volume - */ - strcpy(jcr->VolumeName, dev->VolHdr.VolName); - if (((dev->capabilities & CAP_ANONVOLS) && - !dir_get_volume_info(jcr)) || - (!dir_find_next_appendable_volume(jcr) || - strcmp(dev->VolHdr.VolName, jcr->VolumeName) != 0)) { /* wrong tape mounted */ - if (dev->num_writers != 0) { - Jmsg(jcr, M_FATAL, 0, _("Device %s is busy writing with another Volume.\n"), dev_name(dev)); - unlock_device(dev); - return 0; - } - /* Wrong tape mounted, release it, then fall through to get correct one */ - release = 1; - do_mount = 1; - } - } else { - /* Not already in append mode, so mount the device */ - if (dev->state & ST_READ) { - Jmsg(jcr, M_FATAL, 0, _("Device %s is busy reading.\n"), dev_name(dev)); - unlock_device(dev); - return 0; - } - ASSERT(dev->num_writers == 0); - do_mount = 1; + /* 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; } - if (do_mount) { - block_device(dev, BST_DOING_ACQUIRE); - unlock_device(dev); - if (!mount_next_volume(jcr, dev, block, release)) { - Jmsg(jcr, M_FATAL, 0, _("Could not ready device %s for append.\n"), - dev_name(dev)); - P(dev->mutex); - unblock_device(dev); - unlock_device(dev); - return 0; - } + 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"); - dev->num_writers++; - if (dev->num_writers > 1) { - Dmsg2(0, "Hey!!!! There are %d writers on device %s\n", dev->num_writers, - dev_name(dev)); - } - if (jcr->NumVolumes == 0) { - jcr->NumVolumes = 1; - } - unlock_device(dev); - return 1; /* got it */ -} - -/* - * This job is done, so release the device. From a Unix standpoint, - * the device remains open. - * - */ -int release_device(JCR *jcr, DEVICE *dev, DEV_BLOCK *block) -{ - P(dev->mutex); - Dmsg1(90, "release_device device is %s\n", dev_is_tape(dev)?"tape":"disk"); - if (dev->state & ST_READ) { - dev->state &= ~ST_READ; /* clear read bit */ - if (!dev_is_tape(dev) || !(dev->capabilities & CAP_ALWAYSOPEN)) { - if (dev->capabilities & CAP_OFFLINEUNMOUNT) { - offline_dev(dev); - } - close_dev(dev); - } - /******FIXME**** send read volume usage statistics to director */ - - } else if (dev->num_writers > 0) { - dev->num_writers--; - Dmsg1(90, "There are %d writers in release_device\n", dev->num_writers); - if (dev->num_writers == 0) { - weof_dev(dev, 1); - dir_create_job_media_record(jcr); - dev->VolCatInfo.VolCatFiles++; /* increment number of files */ - /* Note! do volume update before close, which zaps VolCatInfo */ - dir_update_volume_info(jcr, &dev->VolCatInfo, 0); /* send Volume info to Director */ - - if (!dev_is_tape(dev) || !(dev->capabilities & CAP_ALWAYSOPEN)) { - if (dev->capabilities & CAP_OFFLINEUNMOUNT) { - offline_dev(dev); - } - close_dev(dev); - } - } else { - dir_create_job_media_record(jcr); - dir_update_volume_info(jcr, &dev->VolCatInfo, 0); /* send Volume info to Director */ - } - } else { - Jmsg1(jcr, M_ERROR, 0, _("BAD ERROR: release_device %s not in use.\n"), dev_name(dev)); - } - V(dev->mutex); - return 1; -} - - + bstrncpy(PrevVolName, dev->VolCatInfo.VolCatName, sizeof(PrevVolName)); + bstrncpy(dev->VolHdr.PrevVolName, PrevVolName, sizeof(dev->VolHdr.PrevVolName)); -/* - * If release is set, we rewind the current volume, - * which we no longer want, and ask the user (console) - * to mount the next volume. - * - * Continue trying until we get it, and then ensure - * that we can write on it. - * - * This routine returns a 0 only if it is REALLY - * impossible to get the requested Volume. - */ -static int mount_next_volume(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, int release) -{ - int recycle, ask, retry = 0, autochanger; + label_blk = new_block(dev); + dcr->block = label_blk; - Dmsg0(90, "Enter mount_next_volume()\n"); + /* 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))); -mount_next_vol: - if (retry++ > 5) { - Jmsg(jcr, M_FATAL, 0, _("Too many errors on device %s.\n"), dev_name(dev)); - return 0; - } - if (job_cancelled(jcr)) { - Jmsg(jcr, M_FATAL, 0, _("Job cancelled.\n")); - return 0; + if (!mount_next_write_volume(dcr, 1)) { + free_block(label_blk); + dcr->block = block; + P(dev->mutex); + unblock_device(dev); + return false; /* device locked */ } - recycle = ask = autochanger = 0; - if (release) { - Dmsg0(500, "mount_next_volume release=1\n"); - /* - * First erase all memory of the current volume - */ - dev->block_num = 0; - dev->file = 0; - dev->LastBlockNumWritten = 0; - memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo)); - memset(&dev->VolHdr, 0, sizeof(dev->VolHdr)); - dev->state &= ~ST_LABEL; /* label not yet read */ - - if (!dev_is_tape(dev) || !(dev->capabilities & CAP_ALWAYSOPEN)) { - if (dev->capabilities & CAP_OFFLINEUNMOUNT) { - offline_dev(dev); - } - close_dev(dev); - } + P(dev->mutex); /* lock again */ - /* If we have not closed the device, then at least rewind the tape */ - if (dev->state & ST_OPENED) { - if (dev->capabilities & CAP_OFFLINEUNMOUNT) { - offline_dev(dev); - } - if (!rewind_dev(dev)) { - Jmsg2(jcr, M_WARNING, 0, _("Rewind error on device %s. ERR=%s\n"), - dev_name(dev), strerror_dev(dev)); - } - } - ask = 1; /* ask operator to mount tape */ - } else { - /* - * Get Director's idea of what tape we should have mounted. - */ - if (!dir_find_next_appendable_volume(jcr)) { - ask = 1; /* we must ask */ - } - } - release = 1; /* release if we "recurse" */ + 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))); /* - * Get next volume and ready it for append - * This code ensures that the device is ready for - * writing. We start from the assumption that there - * may not be a tape mounted. - * - * If the device is a file, we create the output - * file. If it is a tape, we check the volume name - * and move the tape to the end of data. - * - * It assumes that the device is not already in use! - * + * 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(100, "Enter ready_dev_for_append\n"); - - dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF); - - jcr->VolFirstFile = 0; /* first update of Vol FileIndex */ - for ( ;; ) { - int slot = jcr->VolCatInfo.Slot; - - /* - * Handle autoloaders here. If we cannot autoload it, we - * will fall through to ask the sysop. - */ - if (dev->capabilities && CAP_AUTOCHANGER && slot <= 0) { - if (dir_find_next_appendable_volume(jcr)) { - slot = jcr->VolCatInfo.Slot; - } - } - Dmsg1(100, "Want changer slot=%d\n", slot); - - if (slot > 0 && jcr->device->changer_name && jcr->device->changer_command) { - uint32_t timeout = jcr->device->max_changer_wait; - POOLMEM *changer, *results; - int status, loaded; - - results = get_pool_memory(PM_MESSAGE); - changer = get_pool_memory(PM_FNAME); - /* Find out what is loaded */ - changer = edit_device_codes(jcr, changer, jcr->device->changer_command, - "loaded"); - status = run_program(changer, timeout, results); - if (status == 0) { - loaded = atoi(results); - } else { - loaded = -1; /* force unload */ - } - Dmsg1(100, "loaded=%s\n", results); - - /* If bad status or tape we want is not loaded, load it. */ - if (status != 0 || loaded != slot) { - if (dev->capabilities & CAP_OFFLINEUNMOUNT) { - offline_dev(dev); - } - /* We are going to load a new tape, so close the device */ - force_close_dev(dev); - if (loaded != 0) { /* must unload drive */ - Dmsg0(100, "Doing changer unload.\n"); - changer = edit_device_codes(jcr, changer, - jcr->device->changer_command, "unload"); - status = run_program(changer, timeout, NULL); - Dmsg1(100, "unload status=%d\n", status); - } - /* - * Load the desired cassette - */ - Dmsg1(100, "Doing changer load slot %d\n", slot); - changer = edit_device_codes(jcr, changer, - jcr->device->changer_command, "load"); - status = run_program(changer, timeout, NULL); - Dmsg2(100, "load slot %d status=%d\n", slot, status); - } - free_pool_memory(changer); - free_pool_memory(results); - Dmsg1(100, "After changer, status=%d\n", status); - if (status == 0) { /* did we succeed? */ - ask = 0; /* yes, got vol, no need to ask sysop */ - autochanger = 1; /* tape loaded by changer */ - } - } - - - if (ask && !dir_ask_sysop_to_mount_next_volume(jcr, dev)) { - return 0; /* error return */ - } - Dmsg1(200, "want vol=%s\n", jcr->VolumeName); - - /* Open device */ - for ( ; !(dev->state & ST_OPENED); ) { - if (open_dev(dev, jcr->VolCatInfo.VolCatName, READ_WRITE) < 0) { - if (dev->dev_errno == EAGAIN || dev->dev_errno == EBUSY) { - sleep(30); - } - Jmsg2(jcr, M_FATAL, 0, _("Unable to open device %s. ERR=%s\n"), - dev_name(dev), strerror_dev(dev)); - return 0; - } - } - - /* - * Now make sure we have the right tape mounted - */ -read_volume: - switch (read_dev_volume_label(jcr, dev, block)) { - case VOL_OK: - Dmsg1(500, "Vol OK name=%s\n", jcr->VolumeName); - memcpy(&dev->VolCatInfo, &jcr->VolCatInfo, sizeof(jcr->VolCatInfo)); - if (strcmp(dev->VolCatInfo.VolCatStatus, "Recycle") == 0) { - recycle = 1; - } - break; /* got it */ - case VOL_NAME_ERROR: - Dmsg1(500, "Vol NAME Error Name=%s\n", jcr->VolumeName); - /* Check if we can accept this as an anonymous volume */ - strcpy(jcr->VolumeName, dev->VolHdr.VolName); - if (!dev->capabilities & CAP_ANONVOLS || !dir_get_volume_info(jcr)) { - goto mount_next_vol; - } - Dmsg1(200, "want new name=%s\n", jcr->VolumeName); - memcpy(&dev->VolCatInfo, &jcr->VolCatInfo, sizeof(jcr->VolCatInfo)); - break; - - case VOL_NO_LABEL: - case VOL_IO_ERROR: - Dmsg1(500, "Vol NO_LABEL or IO_ERROR name=%s\n", jcr->VolumeName); - /* If permitted, create a label */ - if (dev->capabilities & CAP_LABEL) { - Dmsg0(90, "Create volume label\n"); - if (!write_volume_label_to_dev(jcr, (DEVRES *)dev->device, jcr->VolumeName, - jcr->pool_name)) { - goto mount_next_vol; - } - Jmsg(jcr, M_INFO, 0, _("Created Volume label %s on device %s.\n"), - jcr->VolumeName, dev_name(dev)); - goto read_volume; /* read label we just wrote */ - } - /* NOTE! Fall-through wanted. */ - default: - /* Send error message */ - Jmsg(jcr, M_WARNING, 0, "%s", jcr->errmsg); - if (autochanger) { - Jmsg(jcr, M_ERROR, 0, _("Autochanger Volume %s not found in slot %d.\n\ - Setting slot to zero in catalog.\n"), - jcr->VolumeName, jcr->VolCatInfo.Slot); - jcr->VolCatInfo.Slot = 0; /* invalidate slot */ - dir_update_volume_info(jcr, &jcr->VolCatInfo, 1); /* set slot */ - } - goto mount_next_vol; - } - break; + 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; /* - * See if we have a fresh tape or tape with data. - * - * Note, if the LabelType is PRE_LABEL, it was labeled - * but never written. If so, rewrite the label but set as - * VOL_LABEL. We rewind and return the label (reconstructed) - * in the block so that in the case of a new tape, data can - * be appended just after the block label. If we are writing - * an second volume, the calling routine will write the label - * before writing the overflow block. - * - * If the tape is marked as Recycle, we rewrite the label. + * Walk through all attached jcrs indicating the volume has changed */ - if (dev->VolHdr.LabelType == PRE_LABEL || recycle) { - Dmsg1(90, "ready_for_append found freshly labeled volume. dev=%x\n", dev); - dev->VolHdr.LabelType = VOL_LABEL; /* set Volume label */ - write_volume_label_to_block(jcr, dev, block); - /* - * Write the block now to ensure we have write permission. - * It is better to find out now rather than later. - */ - dev->VolCatInfo.VolCatBytes = 0; - if (!rewind_dev(dev)) { - Jmsg2(jcr, M_WARNING, 0, _("Rewind error on device %s. ERR=%s\n"), - dev_name(dev), strerror_dev(dev)); - } - if (recycle) { - if (!truncate_dev(dev)) { - Jmsg2(jcr, M_WARNING, 0, _("Truncate error on device %s. ERR=%s\n"), - dev_name(dev), strerror_dev(dev)); - } - } - if (!write_block_to_dev(dev, block)) { - Jmsg2(jcr, M_ERROR, 0, _("Unable to write device %s. ERR=%s\n"), - dev_name(dev), strerror_dev(dev)); - goto mount_next_vol; - } - if (!rewind_dev(dev)) { - Jmsg2(jcr, M_ERROR, 0, _("Unable to rewind device %s. ERR=%s\n"), - dev_name(dev), strerror_dev(dev)); - goto mount_next_vol; + 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 */ } - /* Recreate a correct volume label and return it in the block */ - write_volume_label_to_block(jcr, dev, block); - dev->VolCatInfo.VolCatJobs = 1; - dev->VolCatInfo.VolCatFiles = 1; - dev->VolCatInfo.VolCatErrors = 0; - dev->VolCatInfo.VolCatBlocks = 1; - if (recycle) { - dev->VolCatInfo.VolCatMounts++; - dev->VolCatInfo.VolCatRecycles++; - } else { - dev->VolCatInfo.VolCatMounts = 1; - dev->VolCatInfo.VolCatRecycles = 0; - dev->VolCatInfo.VolCatWrites = 1; - dev->VolCatInfo.VolCatReads = 1; - } - strcpy(dev->VolCatInfo.VolCatStatus, "Append"); - dir_update_volume_info(jcr, &dev->VolCatInfo, 1); /* indicate doing relabel */ - if (recycle) { - Jmsg(jcr, M_INFO, 0, _("Recycled volume %s on device %s, all previous data lost.\n"), - jcr->VolumeName, dev_name(dev)); - } else { - Jmsg(jcr, M_INFO, 0, _("Wrote label to prelabeled Volume %s on device %s\n"), - jcr->VolumeName, dev_name(dev)); + mdcr->NewVol = true; + if (jcr != mjcr) { + bstrncpy(mdcr->VolumeName, dcr->VolumeName, sizeof(mdcr->VolumeName)); } + } - } else { - /* - * OK, at this point, we have a valid Bacula label, but - * we need to position to the end of the volume, since we are - * just now putting it into append mode. - */ - Dmsg0(20, "Device previously written, moving to end of data\n"); - Jmsg(jcr, M_INFO, 0, _("Volume %s previously written, moving to end of data.\n"), - jcr->VolumeName); - if (!eod_dev(dev)) { - Jmsg(jcr, M_ERROR, 0, _("Unable to position to end of data %s. ERR=%s\n"), - dev_name(dev), strerror_dev(dev)); - Jmsg(jcr, M_INFO, 0, _("Marking Volume %s in Error in Catalog.\n"), - jcr->VolumeName); - strcpy(dev->VolCatInfo.VolCatStatus, "Error"); - dir_update_volume_info(jcr, &dev->VolCatInfo, 0); - goto mount_next_vol; - } - /* *****FIXME**** we should do some checking for files too */ - if (dev_is_tape(dev)) { - Jmsg(jcr, M_INFO, 0, _("Ready to append to end of Volume at file=%d.\n"), dev_file(dev)); - /* - * Check if we are positioned on the tape at the same place - * that the database says we should be. - */ - if (dev->VolCatInfo.VolCatFiles != dev_file(dev) + 1) { - /* ****FIXME**** this should refuse to write on tape */ - Jmsg(jcr, M_ERROR, 0, _("Hey! Num files mismatch! Volume=%d Catalog=%d\n"), - dev_file(dev)+1, dev->VolCatInfo.VolCatFiles); - } - } - /* Update Volume Info -- will be written at end of Job */ - dev->VolCatInfo.VolCatMounts++; /* Update mounts */ - dev->VolCatInfo.VolCatJobs++; - /* Return an empty block */ - empty_block(block); /* we used it for reading so set for write */ + /* Clear NewVol now because dir_get_volume_info() already done */ + jcr->dcr->NewVol = false; + set_new_volume_parameters(dcr); + + 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 false; /* device locked */ } - dev->state |= ST_APPEND; - Dmsg0(100, "Normal return from read_dev_for_append\n"); - return 1; + + unblock_device(dev); + return true; /* device locked */ } /* - * This routine 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 - * - * Returns 0 on failure - * Returns 1 on success + * We have a new Volume mounted, so reset the Volume parameters + * concerning this job. The global changes were made earlier + * in the dev structure. */ -int ready_dev_for_read(JCR *jcr, DEVICE *dev, DEV_BLOCK *block) +void set_new_volume_parameters(DCR *dcr) { - if (!(dev->state & ST_OPENED)) { - Dmsg1(20, "bstored: open vol=%s\n", jcr->VolumeName); - if (open_dev(dev, jcr->VolumeName, READ_ONLY) < 0) { - Jmsg(jcr, M_FATAL, 0, _("Open device %s volume %s failed, ERR=%s\n"), - dev_name(dev), jcr->VolumeName, strerror_dev(dev)); - return 0; - } - Dmsg1(29, "open_dev %s OK\n", dev_name(dev)); + 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); } - - for (;;) { - if (job_cancelled(jcr)) { - Mmsg0(&dev->errmsg, _("Job cancelled.\n")); - return 0; - } - if (!rewind_dev(dev)) { - Jmsg2(jcr, M_WARNING, 0, _("Rewind error on device %s. ERR=%s\n"), - dev_name(dev), strerror_dev(dev)); - } - switch (read_dev_volume_label(jcr, dev, block)) { - case VOL_OK: - break; /* got it */ - default: - /* Send error message generated by read_dev_volume_label() */ - Jmsg(jcr, M_WARNING, 0, "%s", jcr->errmsg); - if (!rewind_dev(dev)) { - Jmsg2(jcr, M_WARNING, 0, _("Rewind error on device %s. ERR=%s\n"), - dev_name(dev), strerror_dev(dev)); - } - /* Mount a specific volume and no other */ - if (!dir_ask_sysop_to_mount_volume(jcr, dev)) { - return 0; /* error return */ - } - continue; /* try reading again */ - } - break; + /* 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); } - - dev->state |= ST_READ; - return 1; + /* Reset indicies */ + dcr->VolFirstIndex = 0; + dcr->VolLastIndex = 0; + jcr->NumVolumes++; + dcr->NewVol = false; + dcr->WroteVol = false; } /* - * 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 - * exit with device locked. - * - * Note, we are called only from one place in block.c - * - * Returns: 1 on success - * 0 on failure + * 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. */ -int fixup_device_block_write_error(JCR *jcr, DEVICE *dev, DEV_BLOCK *block) +void set_new_file_parameters(DCR *dcr) { - uint32_t stat = 0; - char PrevVolName[MAX_NAME_LENGTH]; - DEV_BLOCK *label_blk; - char b1[30], b2[30]; - time_t wait_time; - - wait_time = time(NULL); - status_dev(dev, &stat); - if (stat & MT_EOD) { - Dmsg0(90, "======= Got EOD ========\n"); - - block_device(dev, BST_DOING_ACQUIRE); - - strcpy(dev->VolCatInfo.VolCatStatus, "Full"); - Dmsg0(90, "Call update_vol_info\n"); - /* Update position counters */ - jcr->end_block = dev->block_num; - jcr->end_file = dev->file; - /* - * ****FIXME**** update JobMedia record of every job using - * this device - */ - if (!dir_create_job_media_record(jcr) || - !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); - return 0; /* device locked */ - } - Dmsg0(90, "Back from update_vol_info\n"); - - strcpy(PrevVolName, dev->VolCatInfo.VolCatName); - strcpy(dev->VolHdr.PrevVolName, PrevVolName); - - label_blk = new_block(dev); - - /* 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)); - - /* Unlock, but leave BLOCKED */ - unlock_device(dev); - if (!mount_next_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_volume() will return an - * empty label_blk, and nothing will be written. - */ - Dmsg0(90, "write label block to dev\n"); - if (!write_block_to_dev(dev, label_blk)) { - Dmsg1(0, "write_block_to_device Volume label failed. ERR=%s", - strerror_dev(dev)); - free_block(label_blk); - unblock_device(dev); - return 0; /* device locked */ - } - - /* Write overflow block to tape */ - Dmsg0(90, "Write overflow block to dev\n"); - if (!write_block_to_dev(dev, block)) { - Dmsg1(0, "write_block_to_device overflow block failed. ERR=%s", - strerror_dev(dev)); - free_block(label_blk); - unblock_device(dev); - return 0; /* device locked */ - } - - jcr->NumVolumes++; - Dmsg0(90, "Wake up any waiting threads.\n"); - free_block(label_blk); - /* Set new start/end positions */ - jcr->start_block = dev->block_num; - jcr->start_file = dev->file; - unblock_device(dev); - jcr->run_time += time(NULL) - wait_time; /* correct run time */ - return 1; /* device locked */ + 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); } - free_block(label_blk); - 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 @@ -714,50 +264,96 @@ 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(20, "start open_output_device()\n"); + Dmsg0(120, "start open_output_device()\n"); if (!dev) { - return 0; + return false; } lock_device(dev); /* Defer opening files */ if (!dev_is_tape(dev)) { - Dmsg0(29, "Device is file, deferring open.\n"); + Dmsg0(129, "Device is file, deferring open.\n"); unlock_device(dev); - return 1; + return true; } if (!(dev->state & ST_OPENED)) { - Dmsg0(29, "Opening device.\n"); - if (open_dev(dev, NULL, READ_WRITE) < 0) { + 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, mode) < 0) { Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg); unlock_device(dev); - return 0; + return false; } } - Dmsg1(29, "open_dev %s OK\n", dev_name(dev)); + 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)); + } +} /* * 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(DEVICE *dev) +void _lock_device(const char *file, int line, DEVICE *dev) { int stat; - - Dmsg1(90, "lock %d\n", dev->dev_blocked); + 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 */ @@ -772,9 +368,43 @@ void lock_device(DEVICE *dev) } } -void unlock_device(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) { - Dmsg0(90, "unlock\n"); + Dmsg2(500, "unlock from %s:%d\n", file, line); V(dev->mutex); } @@ -786,103 +416,59 @@ void unlock_device(DEVICE *dev) * the current thread can do slip through the lock_device() * calls without blocking. */ -void block_device(DEVICE *dev, int state) +void _block_device(const char *file, int line, DEVICE *dev, int state) { - Dmsg1(90, "block set %d\n", state); + 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 */ } + + /* * Unblock the device, and wake up anyone who went to sleep. */ -void unblock_device(DEVICE *dev) +void _unblock_device(const char *file, int line, DEVICE *dev) { - Dmsg1(90, "unblock %d\n", dev->dev_blocked); + 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 */ } } - +/* + * 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(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); +} /* - * Edit codes into ChangerCommand - * %% = % - * %a = archive device name - * %c = changer device name - * %f = Client's name - * %j = Job name - * %o = command - * %s = Slot base 0 - * %S = Slot base 1 - * %v = Volume name - * - * - * omsg = edited output message - * imsg = input string containing edit codes (%x) - * cmd = command string (load, unload, ...) - * + * Enter with device blocked by us but not locked + * Exit with device locked, and blocked by previous owner */ -static char *edit_device_codes(JCR *jcr, char *omsg, char *imsg, char *cmd) +void _give_back_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold) { - char *p; - const char *str; - char add[20]; - - *omsg = 0; - Dmsg1(200, "edit_device_codes: %s\n", imsg); - for (p=imsg; *p; p++) { - if (*p == '%') { - switch (*++p) { - case '%': - str = "%"; - break; - case 'a': - str = jcr->device->dev->dev_name; - break; - case 'c': - str = NPRT(jcr->device->changer_name); - break; - case 'o': - str = NPRT(cmd); - break; - case 's': - sprintf(add, "%d", jcr->VolCatInfo.Slot - 1); - str = add; - break; - case 'S': - sprintf(add, "%d", jcr->VolCatInfo.Slot); - str = add; - break; - case 'j': /* Job name */ - str = jcr->Job; - break; - case 'v': - str = NPRT(jcr->VolumeName); - break; - case 'f': - str = NPRT(jcr->client_name); - break; - - default: - add[0] = '%'; - add[1] = *p; - add[2] = 0; - str = add; - break; - } - } else { - add[0] = *p; - add[1] = 0; - str = add; - } - Dmsg1(200, "add_str %s\n", str); - pm_strcat(&omsg, (char *)str); - Dmsg1(200, "omsg=%s\n", omsg); + 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; + if (dev->dev_blocked == BST_NOT_BLOCKED && dev->num_waiting > 0) { + pthread_cond_broadcast(&dev->wait); /* wake them up */ } - return omsg; }