This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
- version 2 as ammended with additional clauses defined in the
+ version 2 as amended with additional clauses defined in the
file LICENSE in the main source directory.
This program is distributed in the hope that it will be useful,
*/
bool fixup_device_block_write_error(DCR *dcr)
{
- uint32_t stat;
char PrevVolName[MAX_NAME_LENGTH];
DEV_BLOCK *label_blk;
DEV_BLOCK *block = dcr->block;
DEVICE *dev = dcr->dev;
wait_time = time(NULL);
- stat = status_dev(dev);
- if (!(stat & BMT_EOD)) {
- return false; /* this really shouldn't happen */
- }
- Dmsg0(100, "======= Got EOD ========\n");
+ Dmsg0(100, "Enter fixup_device_block_write_error\n");
block_device(dev, BST_DOING_ACQUIRE);
/* Unlock, but leave BLOCKED */
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",
+ Pmsg1(0, _("write_block_to_device Volume label failed. ERR=%s"),
be.strerror(dev->dev_errno));
free_block(label_blk);
dcr->block = block;
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",
+ Pmsg1(0, _("write_block_to_device overflow block failed. ERR=%s"),
be.strerror(dev->dev_errno));
unblock_device(dev);
return false; /* device locked */
* Returns: false on failure
* true on success
*/
-bool first_open_device(DEVICE *dev)
+bool first_open_device(DCR *dcr)
{
+ DEVICE *dev = dcr->dev;
+ bool ok = true;
+
Dmsg0(120, "start open_output_device()\n");
if (!dev) {
return false;
/* Defer opening files */
if (!dev->is_tape()) {
Dmsg0(129, "Device is file, deferring open.\n");
- unlock_device(dev);
- return true;
+ goto bail_out;
}
int mode;
if (dev_cap(dev, CAP_STREAM)) {
mode = OPEN_WRITE_ONLY;
} else {
- mode = OPEN_READ_WRITE;
+ mode = OPEN_READ_ONLY;
}
Dmsg0(129, "Opening device.\n");
dev->open_nowait = true;
- if (dev->open(NULL, mode) < 0) {
+ if (dev->open(dcr, mode) < 0) {
Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
- dev->open_nowait = false;
- unlock_device(dev);
- return false;
+ ok = false;
+ goto bail_out;
}
Dmsg1(129, "open dev %s OK\n", dev->print_name());
+
+bail_out:
dev->open_nowait = false;
unlock_device(dev);
- return true;
+ return ok;
}
/*
} else {
mode = OPEN_READ_WRITE;
}
- if (dev->open(dcr->VolCatInfo.VolCatName, mode) < 0) {
+ if (dev->open(dcr, mode) < 0) {
/* If polling, ignore the error */
- if (!dev->poll) {
+ /* 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())) {
Jmsg2(dcr->jcr, M_FATAL, 0, _("Unable to open device %s: ERR=%s\n"),
dev->print_name(), strerror_dev(dev));
- Pmsg2(000, "Unable to open archive %s: ERR=%s\n",
+ Pmsg2(000, _("Unable to open archive %s: ERR=%s\n"),
dev->print_name(), strerror_dev(dev));
}
return false;
*/
void force_close_device(DEVICE *dev)
{
- if (!dev) {
- Mmsg0(dev->errmsg, _("Bad call to force_close_dev. Device not open\n"));
- Emsg0(M_FATAL, 0, dev->errmsg);
+ if (!dev || dev->fd < 0) {
return;
}
Dmsg1(29, "Force close_dev %s\n", dev->print_name());
{
int errstat;
if ((errstat=rwl_writelock(&dev->lock))) {
- Emsg1(M_ABORT, 0, "Device write lock failure. ERR=%s\n", strerror(errstat));
+ Emsg1(M_ABORT, 0, _("Device write lock failure. ERR=%s\n"), strerror(errstat));
}
}
{
int errstat;
if ((errstat=rwl_writeunlock(&dev->lock))) {
- Emsg1(M_ABORT, 0, "Device write unlock failure. ERR=%s\n", strerror(errstat));
+ Emsg1(M_ABORT, 0, _("Device write unlock failure. ERR=%s\n"), strerror(errstat));
}
}
/*
* Check if the device is blocked or not
*/
-bool device_is_unmounted(DEVICE *dev)
+bool is_device_unmounted(DEVICE *dev)
{
bool stat;
int blocked = dev->dev_blocked;
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(500, "unlock from %s:%d\n", file, line);
*/
void _unblock_device(const char *file, int line, DEVICE *dev)
{
- Dmsg3(500, "unblock %d from %s:%d\n", dev->dev_blocked, file, line);
+ Dmsg3(500, "unblock %s from %s:%d\n", dev->print_blocked(), file, line);
ASSERT(dev->dev_blocked);
dev->set_blocked(BST_NOT_BLOCKED);
dev->no_wait_id = 0;
*/
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,
+
+ Dmsg3(400, "steal lock. old=%s from %s:%d\n", dev->print_blocked(),
file, line);
hold->dev_blocked = dev->get_blocked();
hold->dev_prev_blocked = dev->dev_prev_blocked;
hold->no_wait_id = dev->no_wait_id;
dev->set_blocked(state);
+ Dmsg1(400, "steal lock. new=%s\n", dev->print_blocked());
dev->no_wait_id = pthread_self();
V(dev->mutex);
}
*/
void _give_back_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold)
{
- Dmsg4(500, "return lock. old=%d new=%d from %s:%d\n",
- dev->dev_blocked, hold->dev_blocked, file, line);
+ Dmsg3(400, "return lock. old=%s from %s:%d\n",
+ dev->print_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) {
+ Dmsg1(400, "return lock. new=%s\n", dev->print_blocked());
+ if (dev->num_waiting > 0) {
+ Dmsg0(400, "Broadcast\n");
pthread_cond_broadcast(&dev->wait); /* wake them up */
}
}
projects / bacula / bacula / blobdiff