2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2012 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 three of the GNU Affero General Public
10 License as published by the Free Software Foundation and included
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 Affero 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 Kern Sibbald.
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 dev->r_lock()() 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, int retries)
87 char PrevVolName[MAX_NAME_LENGTH];
89 DEV_BLOCK *block = dcr->block;
92 char dt[MAX_TIME_LENGTH];
94 DEVICE *dev = dcr->dev;
95 int blocked = dev->blocked(); /* save any previous blocked status */
98 wait_time = time(NULL);
100 Dmsg0(100, "=== Enter fixup_device_block_write_error\n");
103 * If we are blocked at entry, unblock it, and set our own block status
105 if (blocked != BST_NOT_BLOCKED) {
108 block_device(dev, BST_DOING_ACQUIRE);
110 /* Continue unlocked, but leave BLOCKED */
113 bstrncpy(PrevVolName, dev->getVolCatName(), sizeof(PrevVolName));
114 bstrncpy(dev->VolHdr.PrevVolumeName, PrevVolName, sizeof(dev->VolHdr.PrevVolumeName));
116 label_blk = new_block(dev);
117 dcr->block = label_blk;
119 /* Inform User about end of medium */
120 Jmsg(jcr, M_INFO, 0, _("End of medium on Volume \"%s\" Bytes=%s Blocks=%s at %s.\n"),
121 PrevVolName, edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, b1),
122 edit_uint64_with_commas(dev->VolCatInfo.VolCatBlocks, b2),
123 bstrftime(dt, sizeof(dt), time(NULL)));
125 Dmsg1(050, "set_unload dev=%s\n", dev->print_name());
127 if (!dcr->mount_next_write_volume()) {
128 free_block(label_blk);
133 Dmsg2(050, "must_unload=%d dev=%s\n", dev->must_unload(), dev->print_name());
134 dev->Lock(); /* lock again */
136 dev->VolCatInfo.VolCatJobs++; /* increment number of jobs on vol */
137 dir_update_volume_info(dcr, false, false); /* send Volume info to Director */
139 Jmsg(jcr, M_INFO, 0, _("New volume \"%s\" mounted on device %s at %s.\n"),
140 dcr->VolumeName, dev->print_name(), bstrftime(dt, sizeof(dt), time(NULL)));
143 * If this is a new tape, the label_blk will contain the
144 * label, so write it now. If this is a previously
145 * used tape, mount_next_write_volume() will return an
146 * empty label_blk, and nothing will be written.
148 Dmsg0(190, "write label block to dev\n");
149 if (!dcr->write_block_to_dev()) {
151 Pmsg1(0, _("write_block_to_device Volume label failed. ERR=%s"),
152 be.bstrerror(dev->dev_errno));
153 free_block(label_blk);
157 free_block(label_blk);
161 * Walk through all attached jcrs indicating the volume has changed
163 Dmsg1(100, "Notify vol change. Volume=%s\n", dev->getVolCatName());
165 foreach_dlist(mdcr, dev->attached_dcrs) {
166 JCR *mjcr = mdcr->jcr;
167 if (mjcr->JobId == 0) {
168 continue; /* ignore console */
172 bstrncpy(mdcr->VolumeName, dcr->VolumeName, sizeof(mdcr->VolumeName));
176 /* Clear NewVol now because dir_get_volume_info() already done */
177 jcr->dcr->NewVol = false;
178 set_new_volume_parameters(dcr);
180 jcr->run_time += time(NULL) - wait_time; /* correct run time for mount wait */
182 /* Write overflow block to device */
183 Dmsg0(190, "Write overflow block to dev\n");
184 if (!dcr->write_block_to_dev()) {
186 Dmsg1(0, _("write_block_to_device overflow block failed. ERR=%s"),
187 be.bstrerror(dev->dev_errno));
188 /* Note: recursive call */
189 if (retries-- <= 0 || !fixup_device_block_write_error(dcr, retries)) {
190 Jmsg2(jcr, M_FATAL, 0,
191 _("Catastrophic error. Cannot write overflow block to device %s. ERR=%s"),
192 dev->print_name(), be.bstrerror(dev->dev_errno));
200 * At this point, the device is locked and blocked.
201 * Unblock the device, restore any entry blocked condition, then
202 * return leaving the device locked (as it was on entry).
205 if (blocked != BST_NOT_BLOCKED) {
206 block_device(dev, blocked);
208 return ok; /* device locked */
211 void set_start_vol_position(DCR *dcr)
213 DEVICE *dev = dcr->dev;
214 /* Set new start position */
215 if (dev->is_tape()) {
216 dcr->StartBlock = dev->block_num;
217 dcr->StartFile = dev->file;
219 dcr->StartBlock = (uint32_t)dev->file_addr;
220 dcr->StartFile = (uint32_t)(dev->file_addr >> 32);
225 * We have a new Volume mounted, so reset the Volume parameters
226 * concerning this job. The global changes were made earlier
227 * in the dev structure.
229 void set_new_volume_parameters(DCR *dcr)
232 if (dcr->NewVol && !dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
233 Jmsg1(jcr, M_ERROR, 0, "%s", jcr->errmsg);
235 set_new_file_parameters(dcr);
236 jcr->NumWriteVolumes++;
241 * We are now in a new Volume file, so reset the Volume parameters
242 * concerning this job. The global changes were made earlier
243 * in the dev structure.
245 void set_new_file_parameters(DCR *dcr)
247 set_start_vol_position(dcr);
250 dcr->VolFirstIndex = 0;
251 dcr->VolLastIndex = 0;
252 dcr->NewFile = false;
253 dcr->WroteVol = false;
259 * First Open of the device. Expect dev to already be initialized.
261 * This routine is used only when the Storage daemon starts
262 * and always_open is set, and in the stand-alone utility
263 * routines such as bextract.
265 * Note, opening of a normal file is deferred to later so
266 * that we can get the filename; the device_name for
267 * a file is the directory only.
269 * Returns: false on failure
272 bool first_open_device(DCR *dcr)
274 DEVICE *dev = dcr->dev;
277 Dmsg0(120, "start open_output_device()\n");
284 /* Defer opening files */
285 if (!dev->is_tape()) {
286 Dmsg0(129, "Device is file, deferring open.\n");
291 if (dev->has_cap(CAP_STREAM)) {
292 mode = OPEN_WRITE_ONLY;
294 mode = OPEN_READ_ONLY;
296 Dmsg0(129, "Opening device.\n");
297 if (!dev->open(dcr, mode)) {
298 Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
302 Dmsg1(129, "open dev %s OK\n", dev->print_name());
310 * Make sure device is open, if not do so
312 bool open_device(DCR *dcr)
314 DEVICE *dev = dcr->dev;
317 if (dev->has_cap(CAP_STREAM)) {
318 mode = OPEN_WRITE_ONLY;
320 mode = OPEN_READ_WRITE;
322 if (!dev->open(dcr, mode)) {
323 /* If polling, ignore the error */
324 /* If DVD, also ignore the error, very often you cannot open the device
325 * (when there is no DVD, or when the one inserted is a wrong one) */
326 if (!dev->poll && !dev->is_dvd() && !dev->is_removable()) {
327 Jmsg2(dcr->jcr, M_FATAL, 0, _("Unable to open device %s: ERR=%s\n"),
328 dev->print_name(), dev->bstrerror());
329 Pmsg2(000, _("Unable to open archive %s: ERR=%s\n"),
330 dev->print_name(), dev->bstrerror());