2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2007 Free Software Foundation Europe e.V.
6 The main author of Bacula is Kern Sibbald, with contributions from
7 many others, a complete list can be found in the file AUTHORS.
8 This program is Free Software; you can redistribute it and/or
9 modify it under the terms of version two of the GNU General Public
10 License as published by the Free Software Foundation plus additions
11 that are listed in the file LICENSE.
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 Bacula® is a registered trademark of John Walker.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
30 * Higher Level Device routines.
31 * Knows about Bacula tape labels and such
33 * NOTE! In general, subroutines that have the word
34 * "device" in the name do locking. Subroutines
35 * that have the word "dev" in the name do not
36 * do locking. Thus if xxx_device() calls
37 * yyy_dev(), all is OK, but if xxx_device()
38 * calls yyy_device(), everything will hang.
39 * Obviously, no zzz_dev() is allowed to call
40 * a www_device() or everything falls apart.
42 * Concerning the routines lock_device() and block_device()
43 * see the end of this module for details. In general,
44 * blocking a device leaves it in a state where all threads
45 * other than the current thread block when they attempt to
46 * lock the device. They remain suspended (blocked) until the device
47 * is unblocked. So, a device is blocked during an operation
48 * that takes a long time (initialization, mounting a new
49 * volume, ...) locking a device is done for an operation
50 * that takes a short time such as writing data to the
54 * Kern Sibbald, MM, MMI
59 #include "bacula.h" /* pull in global headers */
60 #include "stored.h" /* pull in Storage Deamon headers */
62 /* Forward referenced functions */
65 * This is the dreaded moment. We either have an end of
66 * medium condition or worse, and error condition.
67 * Attempt to "recover" by obtaining a new Volume.
69 * Here are a few things to know:
70 * dcr->VolCatInfo contains the info on the "current" tape for this job.
71 * dev->VolCatInfo contains the info on the tape in the drive.
72 * The tape in the drive could have changed several times since
73 * the last time the job used it (jcr->VolCatInfo).
74 * dcr->VolumeName is the name of the current/desired tape in the drive.
76 * We enter with device locked, and
77 * exit with device locked.
79 * Note, we are called only from one place in block.c for the daemons.
80 * The btape utility calls it from btape.c.
82 * Returns: true on success
85 bool fixup_device_block_write_error(DCR *dcr)
87 char PrevVolName[MAX_NAME_LENGTH];
89 DEV_BLOCK *block = dcr->block;
92 char dt[MAX_TIME_LENGTH];
94 DEVICE *dev = dcr->dev;
96 wait_time = time(NULL);
98 Dmsg0(100, "Enter fixup_device_block_write_error\n");
100 block_device(dev, BST_DOING_ACQUIRE);
101 /* Unlock, but leave BLOCKED */
104 bstrncpy(PrevVolName, dev->VolCatInfo.VolCatName, sizeof(PrevVolName));
105 bstrncpy(dev->VolHdr.PrevVolumeName, PrevVolName, sizeof(dev->VolHdr.PrevVolumeName));
107 label_blk = new_block(dev);
108 dcr->block = label_blk;
110 /* Inform User about end of medium */
111 Jmsg(jcr, M_INFO, 0, _("End of medium on Volume \"%s\" Bytes=%s Blocks=%s at %s.\n"),
112 PrevVolName, edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, b1),
113 edit_uint64_with_commas(dev->VolCatInfo.VolCatBlocks, b2),
114 bstrftime(dt, sizeof(dt), time(NULL)));
116 if (!mount_next_write_volume(dcr, 1)) {
117 free_block(label_blk);
121 return false; /* device locked */
123 dev->lock(); /* lock again */
125 dev->VolCatInfo.VolCatJobs++; /* increment number of jobs on vol */
126 dir_update_volume_info(dcr, false); /* send Volume info to Director */
128 Jmsg(jcr, M_INFO, 0, _("New volume \"%s\" mounted on device %s at %s.\n"),
129 dcr->VolumeName, dev->print_name(), bstrftime(dt, sizeof(dt), time(NULL)));
132 * If this is a new tape, the label_blk will contain the
133 * label, so write it now. If this is a previously
134 * used tape, mount_next_write_volume() will return an
135 * empty label_blk, and nothing will be written.
137 Dmsg0(190, "write label block to dev\n");
138 if (!write_block_to_dev(dcr)) {
140 Pmsg1(0, _("write_block_to_device Volume label failed. ERR=%s"),
141 be.strerror(dev->dev_errno));
142 free_block(label_blk);
145 return false; /* device locked */
147 free_block(label_blk);
151 * Walk through all attached jcrs indicating the volume has changed
153 Dmsg1(100, "Walk attached dcrs. Volume=%s\n", dev->VolCatInfo.VolCatName);
155 foreach_dlist(mdcr, dev->attached_dcrs) {
156 JCR *mjcr = mdcr->jcr;
157 if (mjcr->JobId == 0) {
158 continue; /* ignore console */
162 bstrncpy(mdcr->VolumeName, dcr->VolumeName, sizeof(mdcr->VolumeName));
166 /* Clear NewVol now because dir_get_volume_info() already done */
167 jcr->dcr->NewVol = false;
168 set_new_volume_parameters(dcr);
170 jcr->run_time += time(NULL) - wait_time; /* correct run time for mount wait */
172 /* Write overflow block to device */
173 Dmsg0(190, "Write overflow block to dev\n");
174 if (!write_block_to_dev(dcr)) {
176 Pmsg1(0, _("write_block_to_device overflow block failed. ERR=%s"),
177 be.strerror(dev->dev_errno));
179 return false; /* device locked */
183 return true; /* device locked */
187 * We have a new Volume mounted, so reset the Volume parameters
188 * concerning this job. The global changes were made earlier
189 * in the dev structure.
191 void set_new_volume_parameters(DCR *dcr)
194 DEVICE *dev = dcr->dev;
195 if (dcr->NewVol && !dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
196 Jmsg1(jcr, M_ERROR, 0, "%s", jcr->errmsg);
198 /* Set new start/end positions */
199 if (dev->is_tape()) {
200 dcr->StartBlock = dev->block_num;
201 dcr->StartFile = dev->file;
203 dcr->StartBlock = (uint32_t)dev->file_addr;
204 dcr->StartFile = (uint32_t)(dev->file_addr >> 32);
207 dcr->VolFirstIndex = 0;
208 dcr->VolLastIndex = 0;
209 jcr->NumWriteVolumes++;
211 dcr->WroteVol = false;
215 * We are now in a new Volume file, so reset the Volume parameters
216 * concerning this job. The global changes were made earlier
217 * in the dev structure.
219 void set_new_file_parameters(DCR *dcr)
221 DEVICE *dev = dcr->dev;
223 /* Set new start/end positions */
224 if (dev->is_tape()) {
225 dcr->StartBlock = dev->block_num;
226 dcr->StartFile = dev->file;
228 dcr->StartBlock = (uint32_t)dev->file_addr;
229 dcr->StartFile = (uint32_t)(dev->file_addr >> 32);
232 dcr->VolFirstIndex = 0;
233 dcr->VolLastIndex = 0;
234 dcr->NewFile = false;
235 dcr->WroteVol = false;
241 * First Open of the device. Expect dev to already be initialized.
243 * This routine is used only when the Storage daemon starts
244 * and always_open is set, and in the stand-alone utility
245 * routines such as bextract.
247 * Note, opening of a normal file is deferred to later so
248 * that we can get the filename; the device_name for
249 * a file is the directory only.
251 * Returns: false on failure
254 bool first_open_device(DCR *dcr)
256 DEVICE *dev = dcr->dev;
259 Dmsg0(120, "start open_output_device()\n");
266 /* Defer opening files */
267 if (!dev->is_tape()) {
268 Dmsg0(129, "Device is file, deferring open.\n");
273 if (dev->has_cap(CAP_STREAM)) {
274 mode = OPEN_WRITE_ONLY;
276 mode = OPEN_READ_ONLY;
278 Dmsg0(129, "Opening device.\n");
279 if (dev->open(dcr, mode) < 0) {
280 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
284 Dmsg1(129, "open dev %s OK\n", dev->print_name());
292 * Make sure device is open, if not do so
294 bool open_device(DCR *dcr)
296 DEVICE *dev = dcr->dev;
299 if (dev->has_cap(CAP_STREAM)) {
300 mode = OPEN_WRITE_ONLY;
302 mode = OPEN_READ_WRITE;
304 if (dev->open(dcr, mode) < 0) {
305 /* If polling, ignore the error */
306 /* If DVD, also ignore the error, very often you cannot open the device
307 * (when there is no DVD, or when the one inserted is a wrong one) */
308 if (!dev->poll && !dev->is_dvd() && !dev->is_removable()) {
309 Jmsg2(dcr->jcr, M_FATAL, 0, _("Unable to open device %s: ERR=%s\n"),
310 dev->print_name(), dev->bstrerror());
311 Pmsg2(000, _("Unable to open archive %s: ERR=%s\n"),
312 dev->print_name(), dev->bstrerror());
322 void dev_lock(DEVICE *dev)
325 if ((errstat=rwl_writelock(&dev->lock))) {
326 Emsg1(M_ABORT, 0, _("Device write lock failure. ERR=%s\n"), strerror(errstat));
330 void dev_unlock(DEVICE *dev)
333 if ((errstat=rwl_writeunlock(&dev->lock))) {
334 Emsg1(M_ABORT, 0, _("Device write unlock failure. ERR=%s\n"), strerror(errstat));
340 * When dev_blocked is set, all threads EXCEPT thread with id no_wait_id
341 * must wait. The no_wait_id thread is out obtaining a new volume
342 * and preparing the label.
344 void _lock_device(const char *file, int line, DEVICE *dev)
347 Dmsg3(500, "lock %d from %s:%d\n", dev->blocked(), file, line);
349 if (dev->blocked() && !pthread_equal(dev->no_wait_id, pthread_self())) {
350 dev->num_waiting++; /* indicate that I am waiting */
351 while (dev->blocked()) {
352 if ((stat = pthread_cond_wait(&dev->wait, &dev->m_mutex)) != 0) {
354 Emsg1(M_ABORT, 0, _("pthread_cond_wait failure. ERR=%s\n"),
358 dev->num_waiting--; /* no longer waiting */
363 * Check if the device is blocked or not
365 bool is_device_unmounted(DEVICE *dev)
368 int blocked = dev->blocked();
369 stat = (blocked == BST_UNMOUNTED) ||
370 (blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP);
374 void _unlock_device(const char *file, int line, DEVICE *dev)
376 Dmsg2(500, "unlock from %s:%d\n", file, line);
381 * Block all other threads from using the device
382 * Device must already be locked. After this call,
383 * the device is blocked to any thread calling lock_device(),
384 * but the device is not locked (i.e. no P on device). Also,
385 * the current thread can do slip through the lock_device()
386 * calls without blocking.
388 void _block_device(const char *file, int line, DEVICE *dev, int state)
390 Dmsg3(500, "block set %d from %s:%d\n", state, file, line);
391 ASSERT(dev->blocked() == BST_NOT_BLOCKED);
392 dev->set_blocked(state); /* make other threads wait */
393 dev->no_wait_id = pthread_self(); /* allow us to continue */
397 * Unblock the device, and wake up anyone who went to sleep.
399 void _unblock_device(const char *file, int line, DEVICE *dev)
401 Dmsg3(500, "unblock %s from %s:%d\n", dev->print_blocked(), file, line);
402 ASSERT(dev->blocked());
403 dev->set_blocked(BST_NOT_BLOCKED);
405 if (dev->num_waiting > 0) {
406 pthread_cond_broadcast(&dev->wait); /* wake them up */
411 * Enter with device locked and blocked
412 * Exit with device unlocked and blocked by us.
414 void _steal_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold, int state)
417 Dmsg3(400, "steal lock. old=%s from %s:%d\n", dev->print_blocked(),
419 hold->dev_blocked = dev->blocked();
420 hold->dev_prev_blocked = dev->dev_prev_blocked;
421 hold->no_wait_id = dev->no_wait_id;
422 dev->set_blocked(state);
423 Dmsg1(400, "steal lock. new=%s\n", dev->print_blocked());
424 dev->no_wait_id = pthread_self();
429 * Enter with device blocked by us but not locked
430 * Exit with device locked, and blocked by previous owner
432 void _give_back_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold)
434 Dmsg3(400, "return lock. old=%s from %s:%d\n",
435 dev->print_blocked(), file, line);
437 dev->set_blocked(hold->dev_blocked);
438 dev->dev_prev_blocked = hold->dev_prev_blocked;
439 dev->no_wait_id = hold->no_wait_id;
440 Dmsg1(400, "return lock. new=%s\n", dev->print_blocked());
441 if (dev->num_waiting > 0) {
442 pthread_cond_broadcast(&dev->wait); /* wake them up */