2 Bacula(R) - The Network Backup Solution
4 Copyright (C) 2000-2017 Kern Sibbald
6 The original author of Bacula is Kern Sibbald, with contributions
7 from many others, a complete list can be found in the file AUTHORS.
9 You may use this file and others of this release according to the
10 license defined in the LICENSE file, which includes the Affero General
11 Public License, v3.0 ("AGPLv3") and some additional permissions and
12 terms pursuant to its AGPLv3 Section 7.
14 This notice must be preserved when any source code is
15 conveyed and/or propagated.
17 Bacula(R) is a registered trademark of Kern Sibbald.
21 * Higher Level Device routines.
22 * Knows about Bacula tape labels and such
24 * NOTE! In general, subroutines that have the word
25 * "device" in the name do locking. Subroutines
26 * that have the word "dev" in the name do not
27 * do locking. Thus if xxx_device() calls
28 * yyy_dev(), all is OK, but if xxx_device()
29 * calls yyy_device(), everything will hang.
30 * Obviously, no zzz_dev() is allowed to call
31 * a www_device() or everything falls apart.
33 * Concerning the routines dev->rLock()() and block_device()
34 * see the end of this module for details. In general,
35 * blocking a device leaves it in a state where all threads
36 * other than the current thread block when they attempt to
37 * lock the device. They remain suspended (blocked) until the device
38 * is unblocked. So, a device is blocked during an operation
39 * that takes a long time (initialization, mounting a new
40 * volume, ...) locking a device is done for an operation
41 * that takes a short time such as writing data to the
45 * Kern Sibbald, MM, MMI
49 #include "bacula.h" /* pull in global headers */
50 #include "stored.h" /* pull in Storage Deamon headers */
52 /* Forward referenced functions */
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 for the daemons.
70 * The btape utility calls it from btape.c.
72 * Returns: true on success
75 bool fixup_device_block_write_error(DCR *dcr, int retries)
77 char PrevVolName[MAX_NAME_LENGTH];
78 DEV_BLOCK *block = dcr->block;
79 DEV_BLOCK *ameta_block = dcr->ameta_block;
80 DEV_BLOCK *adata_block = dcr->adata_block;
83 char dt[MAX_TIME_LENGTH];
86 int blocked; /* save any previous blocked status */
88 bool save_adata = dcr->dev->adata;
92 dcr->set_ameta(); /* switch to working with ameta */
95 blocked = dev->blocked();
97 wait_time = time(NULL);
100 * If we are blocked at entry, unblock it, and set our own block status
102 if (blocked != BST_NOT_BLOCKED) {
105 block_device(dev, BST_DOING_ACQUIRE);
107 /* Continue unlocked, but leave BLOCKED */
110 bstrncpy(PrevVolName, dev->getVolCatName(), sizeof(PrevVolName));
111 bstrncpy(dev->VolHdr.PrevVolumeName, PrevVolName, sizeof(dev->VolHdr.PrevVolumeName));
113 /* create temporary block, that will be released at the end, current blocks
114 * have been saved in local DEV_BLOCK above and will be restored before to
117 dev->new_dcr_blocks(dcr);
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(150, "set_unload dev=%s\n", dev->print_name());
128 /* Clear DCR Start/End Block/File positions */
129 dcr->VolFirstIndex = dcr->VolLastIndex = 0;
130 dcr->StartAddr = dcr->EndAddr = 0;
132 dcr->WroteVol = false;
134 if (!dcr->mount_next_write_volume()) {
135 dev->free_dcr_blocks(dcr);
137 dcr->ameta_block = ameta_block;
138 dcr->adata_block = adata_block;
142 Dmsg2(150, "must_unload=%d dev=%s\n", dev->must_unload(), dev->print_name());
144 dev->notify_newvol_in_attached_dcrs(dcr->VolumeName);
145 dev->Lock(); /* lock again */
147 dev->VolCatInfo.VolCatJobs++; /* increment number of jobs on vol */
148 if (!dir_update_volume_info(dcr, false, false)) { /* send Volume info to Director */
152 Jmsg(jcr, M_INFO, 0, _("New volume \"%s\" mounted on device %s at %s.\n"),
153 dcr->VolumeName, dev->print_name(), bstrftime(dt, sizeof(dt), time(NULL)));
156 * If this is a new tape, the label_blk will contain the
157 * label, so write it now. If this is a previously
158 * used tape, mount_next_write_volume() will return an
159 * empty label_blk, and nothing will be written.
161 Dmsg0(190, "write label block to dev\n");
162 if (!dcr->write_block_to_dev()) {
164 Pmsg1(0, _("write_block_to_device Volume label failed. ERR=%s"),
165 be.bstrerror(dev->dev_errno));
166 dev->free_dcr_blocks(dcr);
168 dcr->ameta_block = ameta_block;
169 dcr->adata_block = adata_block;
172 dev->free_dcr_blocks(dcr);
174 dcr->ameta_block = ameta_block;
175 dcr->adata_block = adata_block;
177 /* Clear NewVol now because dir_get_volume_info() already done */
178 jcr->dcr->NewVol = false;
179 set_new_volume_parameters(dcr);
181 jcr->run_time += time(NULL) - wait_time; /* correct run time for mount wait */
183 /* Write overflow block to device */
184 Dmsg0(190, "Write overflow block to dev\n");
186 dcr->set_adata(); /* try to write block we entered with */
188 if (!dcr->write_block_to_dev()) {
190 Dmsg1(0, _("write_block_to_device overflow block failed. ERR=%s"),
191 be.bstrerror(dev->dev_errno));
192 /* Note: recursive call */
193 if (retries-- <= 0 || !fixup_device_block_write_error(dcr, retries)) {
194 Jmsg2(jcr, M_FATAL, 0,
195 _("Catastrophic error. Cannot write overflow block to device %s. ERR=%s"),
196 dev->print_name(), be.bstrerror(dev->dev_errno));
204 dcr->set_ameta(); /* Do unblock ... on ameta */
207 * At this point, the device is locked and blocked.
208 * Unblock the device, restore any entry blocked condition, then
209 * return leaving the device locked (as it was on entry).
212 if (blocked != BST_NOT_BLOCKED) {
213 block_device(dev, blocked);
216 dcr->set_adata(); /* switch back to what we entered with */
218 return ok; /* device locked */
221 void set_start_vol_position(DCR *dcr)
223 DEVICE *dev = dcr->dev;
224 /* Set new start position */
225 if (dev->is_tape()) {
226 dcr->StartAddr = dcr->EndAddr = dev->get_full_addr();
229 dev = dcr->ameta_dev;
232 * Note: we only update the DCR values for ameta blocks
233 * because all the indexing (JobMedia) is done with
234 * ameta blocks/records, which may point to adata.
236 dcr->StartAddr = dcr->EndAddr = dev->get_full_addr();
241 * We have a new Volume mounted, so reset the Volume parameters
242 * concerning this job. The global changes were made earlier
243 * in the dev structure.
245 void set_new_volume_parameters(DCR *dcr)
248 Dmsg1(40, "set_new_volume_parameters dev=%s\n", dcr->dev->print_name());
250 while (dcr->VolumeName[0] == 0) {
252 wait_for_device(dcr, retries);
254 if (dir_get_volume_info(dcr, dcr->VolumeName, GET_VOL_INFO_FOR_WRITE)) {
255 dcr->dev->clear_wait();
257 Dmsg1(40, "getvolinfo failed. No new Vol: %s", jcr->errmsg);
260 set_new_file_parameters(dcr);
261 jcr->NumWriteVolumes++;
266 * We are now in a new Volume file, so reset the Volume parameters
267 * concerning this job. The global changes were made earlier
268 * in the dev structure.
270 void set_new_file_parameters(DCR *dcr)
272 set_start_vol_position(dcr);
275 Dmsg3(1000, "Reset indices Vol=%s were: FI=%d LI=%d\n", dcr->VolumeName,
276 dcr->VolFirstIndex, dcr->VolLastIndex);
277 dcr->VolFirstIndex = 0;
278 dcr->VolLastIndex = 0;
279 dcr->NewFile = false;
280 dcr->WroteVol = false;
286 * First Open of the device. Expect dev to already be initialized.
288 * This routine is used only when the Storage daemon starts
289 * and always_open is set, and in the stand-alone utility
290 * routines such as bextract.
292 * Note, opening of a normal file is deferred to later so
293 * that we can get the filename; the device_name for
294 * a file is the directory only.
296 * Returns: false on failure
299 bool first_open_device(DCR *dcr)
301 DEVICE *dev = dcr->dev;
304 Dmsg0(120, "start open_output_device()\n");
311 /* Defer opening files */
312 if (!dev->is_tape()) {
313 Dmsg0(129, "Device is file, deferring open.\n");
317 Dmsg0(129, "Opening device.\n");
318 if (!dev->open_device(dcr, OPEN_READ_ONLY)) {
319 Jmsg1(NULL, M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
323 Dmsg1(129, "open dev %s OK\n", dev->print_name());