3 * Higher Level Device routines.
4 * Knows about Bacula tape labels and such
6 * NOTE! In general, subroutines that have the word
7 * "device" in the name do locking. Subroutines
8 * that have the word "dev" in the name do not
9 * do locking. Thus if xxx_device() calls
10 * yyy_dev(), all is OK, but if xxx_device()
11 * calls yyy_device(), everything will hang.
12 * Obviously, no zzz_dev() is allowed to call
13 * a www_device() or everything falls apart.
15 * Concerning the routines lock_device() and block_device()
16 * see the end of this module for details. In general,
17 * blocking a device leaves it in a state where all threads
18 * other than the current thread block when they attempt to
19 * lock the device. They remain suspended (blocked) until the device
20 * is unblocked. So, a device is blocked during an operation
21 * that takes a long time (initialization, mounting a new
22 * volume, ...) locking a device is done for an operation
23 * that takes a short time such as writing data to the
27 * Kern Sibbald, MM, MMI
32 Copyright (C) 2000-2005 Kern Sibbald
34 This program is free software; you can redistribute it and/or
35 modify it under the terms of the GNU General Public License
36 version 2 as ammended with additional clauses defined in the
37 file LICENSE in the main source directory.
39 This program is distributed in the hope that it will be useful,
40 but WITHOUT ANY WARRANTY; without even the implied warranty of
41 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
42 the file LICENSE for additional details.
46 #include "bacula.h" /* pull in global headers */
47 #include "stored.h" /* pull in Storage Deamon headers */
49 /* Forward referenced functions */
51 extern char my_name[];
52 extern int debug_level;
55 * This is the dreaded moment. We either have an end of
56 * medium condition or worse, and error condition.
57 * Attempt to "recover" by obtaining a new Volume.
59 * Here are a few things to know:
60 * dcr->VolCatInfo contains the info on the "current" tape for this job.
61 * dev->VolCatInfo contains the info on the tape in the drive.
62 * The tape in the drive could have changed several times since
63 * the last time the job used it (jcr->VolCatInfo).
64 * dcr->VolumeName is the name of the current/desired tape in the drive.
66 * We enter with device locked, and
67 * exit with device locked.
69 * Note, we are called only from one place in block.c
71 * Returns: true on success
74 bool fixup_device_block_write_error(DCR *dcr)
77 char PrevVolName[MAX_NAME_LENGTH];
79 DEV_BLOCK *block = dcr->block;
82 char dt[MAX_TIME_LENGTH];
84 DEVICE *dev = dcr->dev;
86 wait_time = time(NULL);
87 stat = status_dev(dev);
88 if (!(stat & BMT_EOD)) {
89 return false; /* this really shouldn't happen */
92 Dmsg0(100, "======= Got EOD ========\n");
94 block_device(dev, BST_DOING_ACQUIRE);
95 /* Unlock, but leave BLOCKED */
98 bstrncpy(PrevVolName, dev->VolCatInfo.VolCatName, sizeof(PrevVolName));
99 bstrncpy(dev->VolHdr.PrevVolName, PrevVolName, sizeof(dev->VolHdr.PrevVolName));
101 label_blk = new_block(dev);
102 dcr->block = label_blk;
104 /* Inform User about end of medium */
105 Jmsg(jcr, M_INFO, 0, _("End of medium on Volume \"%s\" Bytes=%s Blocks=%s at %s.\n"),
106 PrevVolName, edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, b1),
107 edit_uint64_with_commas(dev->VolCatInfo.VolCatBlocks, b2),
108 bstrftime(dt, sizeof(dt), time(NULL)));
110 if (!mount_next_write_volume(dcr, 1)) {
111 free_block(label_blk);
115 return false; /* device locked */
117 P(dev->mutex); /* lock again */
119 Jmsg(jcr, M_INFO, 0, _("New volume \"%s\" mounted on device %s at %s.\n"),
120 dcr->VolumeName, dev->print_name(), bstrftime(dt, sizeof(dt), time(NULL)));
123 * If this is a new tape, the label_blk will contain the
124 * label, so write it now. If this is a previously
125 * used tape, mount_next_write_volume() will return an
126 * empty label_blk, and nothing will be written.
128 Dmsg0(190, "write label block to dev\n");
129 if (!write_block_to_dev(dcr)) {
131 Pmsg1(0, "write_block_to_device Volume label failed. ERR=%s",
132 be.strerror(dev->dev_errno));
133 free_block(label_blk);
136 return false; /* device locked */
138 free_block(label_blk);
142 * Walk through all attached jcrs indicating the volume has changed
144 Dmsg1(100, "Walk attached jcrs. Volume=%s\n", dev->VolCatInfo.VolCatName);
145 // for (JCR *mjcr=NULL; (mjcr=next_attached_jcr(dev, mjcr)); ) {
147 foreach_dlist(mdcr, dev->attached_dcrs) {
148 JCR *mjcr = mdcr->jcr;
149 if (mjcr->JobId == 0) {
150 continue; /* ignore console */
154 bstrncpy(mdcr->VolumeName, dcr->VolumeName, sizeof(mdcr->VolumeName));
158 /* Clear NewVol now because dir_get_volume_info() already done */
159 jcr->dcr->NewVol = false;
160 set_new_volume_parameters(dcr);
162 jcr->run_time += time(NULL) - wait_time; /* correct run time for mount wait */
164 /* Write overflow block to device */
165 Dmsg0(190, "Write overflow block to dev\n");
166 if (!write_block_to_dev(dcr)) {
168 Pmsg1(0, "write_block_to_device overflow block failed. ERR=%s",
169 be.strerror(dev->dev_errno));
171 return false; /* device locked */
175 return true; /* device locked */
179 * We have a new Volume mounted, so reset the Volume parameters
180 * concerning this job. The global changes were made earlier
181 * in the dev structure.
183 void set_new_volume_parameters(DCR *dcr)
186 DEVICE *dev = dcr->dev;
187 if (dcr->NewVol && !dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
188 Jmsg1(jcr, M_ERROR, 0, "%s", jcr->errmsg);
190 /* Set new start/end positions */
191 if (dev_state(dev, ST_TAPE)) {
192 dcr->StartBlock = dev->block_num;
193 dcr->StartFile = dev->file;
195 dcr->StartBlock = (uint32_t)dev->file_addr;
196 dcr->StartFile = (uint32_t)(dev->file_addr >> 32);
199 dcr->VolFirstIndex = 0;
200 dcr->VolLastIndex = 0;
203 dcr->WroteVol = false;
207 * We are now in a new Volume file, so reset the Volume parameters
208 * concerning this job. The global changes were made earlier
209 * in the dev structure.
211 void set_new_file_parameters(DCR *dcr)
213 DEVICE *dev = dcr->dev;
215 /* Set new start/end positions */
216 if (dev_state(dev, ST_TAPE)) {
217 dcr->StartBlock = dev->block_num;
218 dcr->StartFile = dev->file;
220 dcr->StartBlock = (uint32_t)dev->file_addr;
221 dcr->StartFile = (uint32_t)(dev->file_addr >> 32);
224 dcr->VolFirstIndex = 0;
225 dcr->VolLastIndex = 0;
226 dcr->NewFile = false;
227 dcr->WroteVol = false;
233 * First Open of the device. Expect dev to already be initialized.
235 * This routine is used only when the Storage daemon starts
236 * and always_open is set, and in the stand-alone utility
237 * routines such as bextract.
239 * Note, opening of a normal file is deferred to later so
240 * that we can get the filename; the device_name for
241 * a file is the directory only.
243 * Returns: false on failure
246 bool first_open_device(DEVICE *dev)
248 Dmsg0(120, "start open_output_device()\n");
255 /* Defer opening files */
256 if (!dev->is_tape()) {
257 Dmsg0(129, "Device is file, deferring open.\n");
263 if (dev_cap(dev, CAP_STREAM)) {
264 mode = OPEN_WRITE_ONLY;
266 mode = OPEN_READ_WRITE;
268 Dmsg0(129, "Opening device.\n");
269 dev->open_nowait = true;
270 if (open_dev(dev, NULL, mode) < 0) {
271 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
272 dev->open_nowait = false;
276 Dmsg1(129, "open_dev %s OK\n", dev->print_name());
277 dev->open_nowait = false;
283 * Make sure device is open, if not do so
285 bool open_device(DCR *dcr)
287 DEVICE *dev = dcr->dev;
290 if (dev_cap(dev, CAP_STREAM)) {
291 mode = OPEN_WRITE_ONLY;
293 mode = OPEN_READ_WRITE;
295 if (open_dev(dev, dcr->VolCatInfo.VolCatName, mode) < 0) {
296 /* If polling, ignore the error */
298 Jmsg2(dcr->jcr, M_FATAL, 0, _("Unable to open device %s: ERR=%s\n"),
299 dev->print_name(), strerror_dev(dev));
300 Pmsg2(000, "Unable to open archive %s: ERR=%s\n",
301 dev->print_name(), strerror_dev(dev));
309 * Release any Volume attached to this device
310 * then close the device.
312 void close_device(DEVICE *dev)
319 * Used when unmounting the device, ignore use_count
321 void force_close_device(DEVICE *dev)
324 Mmsg0(dev->errmsg, _("Bad call to force_close_dev. Device not open\n"));
325 Emsg0(M_FATAL, 0, dev->errmsg);
328 Dmsg1(29, "Force close_dev %s\n", dev->print_name());
333 ASSERT(dev->use_count >= 0);
338 void dev_lock(DEVICE *dev)
341 if ((errstat=rwl_writelock(&dev->lock))) {
342 Emsg1(M_ABORT, 0, "Device write lock failure. ERR=%s\n", strerror(errstat));
346 void dev_unlock(DEVICE *dev)
349 if ((errstat=rwl_writeunlock(&dev->lock))) {
350 Emsg1(M_ABORT, 0, "Device write unlock failure. ERR=%s\n", strerror(errstat));
355 * When dev_blocked is set, all threads EXCEPT thread with id no_wait_id
356 * must wait. The no_wait_id thread is out obtaining a new volume
357 * and preparing the label.
359 void _lock_device(const char *file, int line, DEVICE *dev)
362 Dmsg3(500, "lock %d from %s:%d\n", dev->dev_blocked, file, line);
364 if (dev->dev_blocked && !pthread_equal(dev->no_wait_id, pthread_self())) {
365 dev->num_waiting++; /* indicate that I am waiting */
366 while (dev->dev_blocked) {
367 if ((stat = pthread_cond_wait(&dev->wait, &dev->mutex)) != 0) {
369 Emsg1(M_ABORT, 0, _("pthread_cond_wait failure. ERR=%s\n"),
373 dev->num_waiting--; /* no longer waiting */
378 * Check if the device is blocked or not
380 bool device_is_unmounted(DEVICE *dev)
383 int blocked = dev->dev_blocked;
384 stat = (blocked == BST_UNMOUNTED) ||
385 (blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP);
389 const char *edit_blocked_reason(DEVICE *dev)
391 switch (dev->dev_blocked) {
392 case BST_NOT_BLOCKED:
393 return "not blocked";
395 return "user unmounted device";
396 case BST_WAITING_FOR_SYSOP:
397 return "waiting for operator action";
398 case BST_DOING_ACQUIRE:
399 return "opening, validating, or positioning tape";
400 case BST_WRITING_LABEL:
401 return "labeling tape";
402 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
403 return "closed by user during mount request";
405 return "mount request";
407 return "unknown blocked code";
411 void _unlock_device(const char *file, int line, DEVICE *dev)
413 Dmsg2(500, "unlock from %s:%d\n", file, line);
418 * Block all other threads from using the device
419 * Device must already be locked. After this call,
420 * the device is blocked to any thread calling lock_device(),
421 * but the device is not locked (i.e. no P on device). Also,
422 * the current thread can do slip through the lock_device()
423 * calls without blocking.
425 void _block_device(const char *file, int line, DEVICE *dev, int state)
427 Dmsg3(500, "block set %d from %s:%d\n", state, file, line);
428 ASSERT(dev->dev_blocked == BST_NOT_BLOCKED);
429 dev->dev_blocked = state; /* make other threads wait */
430 dev->no_wait_id = pthread_self(); /* allow us to continue */
436 * Unblock the device, and wake up anyone who went to sleep.
438 void _unblock_device(const char *file, int line, DEVICE *dev)
440 Dmsg3(500, "unblock %d from %s:%d\n", dev->dev_blocked, file, line);
441 ASSERT(dev->dev_blocked);
442 dev->dev_blocked = BST_NOT_BLOCKED;
444 if (dev->num_waiting > 0) {
445 pthread_cond_broadcast(&dev->wait); /* wake them up */
450 * Enter with device locked and blocked
451 * Exit with device unlocked and blocked by us.
453 void _steal_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold, int state)
455 Dmsg4(500, "steal lock. old=%d new=%d from %s:%d\n", dev->dev_blocked, state,
457 hold->dev_blocked = dev->dev_blocked;
458 hold->dev_prev_blocked = dev->dev_prev_blocked;
459 hold->no_wait_id = dev->no_wait_id;
460 dev->dev_blocked = state;
461 dev->no_wait_id = pthread_self();
466 * Enter with device blocked by us but not locked
467 * Exit with device locked, and blocked by previous owner
469 void _give_back_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold)
471 Dmsg4(500, "return lock. old=%d new=%d from %s:%d\n",
472 dev->dev_blocked, hold->dev_blocked, file, line);
474 dev->dev_blocked = hold->dev_blocked;
475 dev->dev_prev_blocked = hold->dev_prev_blocked;
476 dev->no_wait_id = hold->no_wait_id;
477 if (dev->dev_blocked == BST_NOT_BLOCKED && dev->num_waiting > 0) {
478 pthread_cond_broadcast(&dev->wait); /* wake them up */