]> git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/device.c
29Jun07
[bacula/bacula] / bacula / src / stored / device.c
1 /*
2    Bacula® - The Network Backup Solution
3
4    Copyright (C) 2000-2007 Free Software Foundation Europe e.V.
5
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 and included
11    in the file LICENSE.
12
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.
17
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
21    02110-1301, USA.
22
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.
27 */
28 /*
29  *
30  *  Higher Level Device routines.
31  *  Knows about Bacula tape labels and such
32  *
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.
41  *
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
51  *  device.
52  *
53  *
54  *   Kern Sibbald, MM, MMI
55  *
56  *   Version $Id$
57  */
58
59 #include "bacula.h"                   /* pull in global headers */
60 #include "stored.h"                   /* pull in Storage Deamon headers */
61
62 /* Forward referenced functions */
63
64 /*
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.
68  *
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.
75  *
76  * We enter with device locked, and
77  *     exit with device locked.
78  *
79  * Note, we are called only from one place in block.c for the daemons.  
80  *     The btape utility calls it from btape.c.
81  *
82  *  Returns: true  on success
83  *           false on failure
84  */
85 bool fixup_device_block_write_error(DCR *dcr)
86 {
87    char PrevVolName[MAX_NAME_LENGTH];
88    DEV_BLOCK *label_blk;
89    DEV_BLOCK *block = dcr->block;
90    char b1[30], b2[30];
91    time_t wait_time;
92    char dt[MAX_TIME_LENGTH];
93    JCR *jcr = dcr->jcr;
94    DEVICE *dev = dcr->dev;
95    int blocked = dev->blocked();         /* save any previous blocked status */
96    bool ok = false;
97
98    wait_time = time(NULL);
99
100    Dmsg0(100, "Enter fixup_device_block_write_error\n");
101
102    /*
103     * If we are blocked at entry, unblock it, and set our own block status
104     */
105    if (blocked != BST_NOT_BLOCKED) {
106       unblock_device(dev);
107    }
108    block_device(dev, BST_DOING_ACQUIRE);
109
110    /* Continue unlocked, but leave BLOCKED */
111    dev->dunlock();
112
113    bstrncpy(PrevVolName, dev->VolCatInfo.VolCatName, sizeof(PrevVolName));
114    bstrncpy(dev->VolHdr.PrevVolumeName, PrevVolName, sizeof(dev->VolHdr.PrevVolumeName));
115
116    label_blk = new_block(dev);
117    dcr->block = label_blk;
118
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)));
124
125    if (!mount_next_write_volume(dcr, 1)) {
126       free_block(label_blk);
127       dcr->block = block;
128       dev->dlock();  
129       goto bail_out;
130    }
131    dev->dlock();                    /* lock again */
132
133    dev->VolCatInfo.VolCatJobs++;              /* increment number of jobs on vol */
134    dir_update_volume_info(dcr, false);        /* send Volume info to Director */
135
136    Jmsg(jcr, M_INFO, 0, _("New volume \"%s\" mounted on device %s at %s.\n"),
137       dcr->VolumeName, dev->print_name(), bstrftime(dt, sizeof(dt), time(NULL)));
138
139    /*
140     * If this is a new tape, the label_blk will contain the
141     *  label, so write it now. If this is a previously
142     *  used tape, mount_next_write_volume() will return an
143     *  empty label_blk, and nothing will be written.
144     */
145    Dmsg0(190, "write label block to dev\n");
146    if (!write_block_to_dev(dcr)) {
147       berrno be;
148       Pmsg1(0, _("write_block_to_device Volume label failed. ERR=%s"),
149         be.bstrerror(dev->dev_errno));
150       free_block(label_blk);
151       dcr->block = block;
152       goto bail_out;
153    }
154    free_block(label_blk);
155    dcr->block = block;
156
157    /*
158     * Walk through all attached jcrs indicating the volume has changed
159     */
160    Dmsg1(100, "Walk attached dcrs. Volume=%s\n", dev->VolCatInfo.VolCatName);
161    DCR *mdcr;
162    foreach_dlist(mdcr, dev->attached_dcrs) {
163       JCR *mjcr = mdcr->jcr;
164       if (mjcr->JobId == 0) {
165          continue;                 /* ignore console */
166       }
167       mdcr->NewVol = true;
168       if (jcr != mjcr) {
169          bstrncpy(mdcr->VolumeName, dcr->VolumeName, sizeof(mdcr->VolumeName));
170       }
171    }
172
173    /* Clear NewVol now because dir_get_volume_info() already done */
174    jcr->dcr->NewVol = false;
175    set_new_volume_parameters(dcr);
176
177    jcr->run_time += time(NULL) - wait_time; /* correct run time for mount wait */
178
179    /* Write overflow block to device */
180    Dmsg0(190, "Write overflow block to dev\n");
181    if (!write_block_to_dev(dcr)) {
182       berrno be;
183       Pmsg1(0, _("write_block_to_device overflow block failed. ERR=%s"),
184         be.bstrerror(dev->dev_errno));
185       goto bail_out;
186    }
187    ok = true;
188
189 bail_out:
190    /*
191     * At this point, the device is locked and blocked.
192     * Unblock the device, restore any entry blocked condition, then
193     *   return leaving the device locked (as it was on entry).
194     */
195    unblock_device(dev);
196    if (blocked != BST_NOT_BLOCKED) {
197       block_device(dev, blocked);
198    }
199    return ok;                               /* device locked */
200 }
201
202 /*
203  * We have a new Volume mounted, so reset the Volume parameters
204  *  concerning this job.  The global changes were made earlier
205  *  in the dev structure.
206  */
207 void set_new_volume_parameters(DCR *dcr)
208 {
209    JCR *jcr = dcr->jcr;
210    DEVICE *dev = dcr->dev;
211    if (dcr->NewVol && !dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
212       Jmsg1(jcr, M_ERROR, 0, "%s", jcr->errmsg);
213    }
214    /* Set new start/end positions */
215    if (dev->is_tape()) {
216       dcr->StartBlock = dev->block_num;
217       dcr->StartFile = dev->file;
218    } else {
219       dcr->StartBlock = (uint32_t)dev->file_addr;
220       dcr->StartFile  = (uint32_t)(dev->file_addr >> 32);
221    }
222    /* Reset indicies */
223    dcr->VolFirstIndex = 0;
224    dcr->VolLastIndex = 0;
225    jcr->NumWriteVolumes++;
226    dcr->NewVol = false;
227    dcr->WroteVol = false;
228 }
229
230 /*
231  * We are now in a new Volume file, so reset the Volume parameters
232  *  concerning this job.  The global changes were made earlier
233  *  in the dev structure.
234  */
235 void set_new_file_parameters(DCR *dcr)
236 {
237    DEVICE *dev = dcr->dev;
238
239    /* Set new start/end positions */
240    if (dev->is_tape()) {
241       dcr->StartBlock = dev->block_num;
242       dcr->StartFile = dev->file;
243    } else {
244       dcr->StartBlock = (uint32_t)dev->file_addr;
245       dcr->StartFile  = (uint32_t)(dev->file_addr >> 32);
246    }
247    /* Reset indicies */
248    dcr->VolFirstIndex = 0;
249    dcr->VolLastIndex = 0;
250    dcr->NewFile = false;
251    dcr->WroteVol = false;
252 }
253
254
255
256 /*
257  *   First Open of the device. Expect dev to already be initialized.
258  *
259  *   This routine is used only when the Storage daemon starts
260  *   and always_open is set, and in the stand-alone utility
261  *   routines such as bextract.
262  *
263  *   Note, opening of a normal file is deferred to later so
264  *    that we can get the filename; the device_name for
265  *    a file is the directory only.
266  *
267  *   Returns: false on failure
268  *            true  on success
269  */
270 bool first_open_device(DCR *dcr)
271 {
272    DEVICE *dev = dcr->dev;
273    bool ok = true;
274
275    Dmsg0(120, "start open_output_device()\n");
276    if (!dev) {
277       return false;
278    }
279
280    dev->r_dlock();
281
282    /* Defer opening files */
283    if (!dev->is_tape()) {
284       Dmsg0(129, "Device is file, deferring open.\n");
285       goto bail_out;
286    }
287
288     int mode;
289     if (dev->has_cap(CAP_STREAM)) {
290        mode = OPEN_WRITE_ONLY;
291     } else {
292        mode = OPEN_READ_ONLY;
293     }
294    Dmsg0(129, "Opening device.\n");
295    if (dev->open(dcr, mode) < 0) {
296       Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
297       ok = false;
298       goto bail_out;
299    }
300    Dmsg1(129, "open dev %s OK\n", dev->print_name());
301
302 bail_out:
303    dev->dunlock();
304    return ok;
305 }
306
307 /*
308  * Make sure device is open, if not do so
309  */
310 bool open_device(DCR *dcr)
311 {
312    DEVICE *dev = dcr->dev;
313    /* Open device */
314    int mode;
315    if (dev->has_cap(CAP_STREAM)) {
316       mode = OPEN_WRITE_ONLY;
317    } else {
318       mode = OPEN_READ_WRITE;
319    }
320    if (dev->open(dcr, mode) < 0) {
321       /* If polling, ignore the error */
322       /* If DVD, also ignore the error, very often you cannot open the device
323        * (when there is no DVD, or when the one inserted is a wrong one) */
324       if (!dev->poll && !dev->is_dvd() && !dev->is_removable()) {
325          Jmsg2(dcr->jcr, M_FATAL, 0, _("Unable to open device %s: ERR=%s\n"),
326             dev->print_name(), dev->bstrerror());
327          Pmsg2(000, _("Unable to open archive %s: ERR=%s\n"), 
328             dev->print_name(), dev->bstrerror());
329       }
330       return false;
331    }
332    return true;
333 }