]> git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/device.c
kes Update copyright date in program files, and for the most part
[bacula/bacula] / bacula / src / stored / device.c
1 /*
2  *
3  *  Higher Level Device routines.
4  *  Knows about Bacula tape labels and such
5  *
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.
14  *
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
24  *  device.
25  *
26  *
27  *   Kern Sibbald, MM, MMI
28  *
29  *   Version $Id$
30  */
31 /*
32    Copyright (C) 2000-2006 Kern Sibbald
33
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 amended with additional clauses defined in the
37    file LICENSE in the main source directory.
38
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.
43
44  */
45
46 #include "bacula.h"                   /* pull in global headers */
47 #include "stored.h"                   /* pull in Storage Deamon headers */
48
49 /* Forward referenced functions */
50
51 /*
52  * This is the dreaded moment. We either have an end of
53  * medium condition or worse, and error condition.
54  * Attempt to "recover" by obtaining a new Volume.
55  *
56  * Here are a few things to know:
57  *  dcr->VolCatInfo contains the info on the "current" tape for this job.
58  *  dev->VolCatInfo contains the info on the tape in the drive.
59  *    The tape in the drive could have changed several times since
60  *    the last time the job used it (jcr->VolCatInfo).
61  *  dcr->VolumeName is the name of the current/desired tape in the drive.
62  *
63  * We enter with device locked, and
64  *     exit with device locked.
65  *
66  * Note, we are called only from one place in block.c
67  *
68  *  Returns: true  on success
69  *           false on failure
70  */
71 bool fixup_device_block_write_error(DCR *dcr)
72 {
73    char PrevVolName[MAX_NAME_LENGTH];
74    DEV_BLOCK *label_blk;
75    DEV_BLOCK *block = dcr->block;
76    char b1[30], b2[30];
77    time_t wait_time;
78    char dt[MAX_TIME_LENGTH];
79    JCR *jcr = dcr->jcr;
80    DEVICE *dev = dcr->dev;
81
82    wait_time = time(NULL);
83
84    Dmsg0(100, "Enter fixup_device_block_write_error\n");
85
86    block_device(dev, BST_DOING_ACQUIRE);
87    /* Unlock, but leave BLOCKED */
88    unlock_device(dev);
89
90    bstrncpy(PrevVolName, dev->VolCatInfo.VolCatName, sizeof(PrevVolName));
91    bstrncpy(dev->VolHdr.PrevVolumeName, PrevVolName, sizeof(dev->VolHdr.PrevVolumeName));
92
93    label_blk = new_block(dev);
94    dcr->block = label_blk;
95
96    /* Inform User about end of medium */
97    Jmsg(jcr, M_INFO, 0, _("End of medium on Volume \"%s\" Bytes=%s Blocks=%s at %s.\n"),
98         PrevVolName, edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, b1),
99         edit_uint64_with_commas(dev->VolCatInfo.VolCatBlocks, b2),
100         bstrftime(dt, sizeof(dt), time(NULL)));
101
102    if (!mount_next_write_volume(dcr, 1)) {
103       free_block(label_blk);
104       dcr->block = block;
105       P(dev->mutex);
106       unblock_device(dev);
107       return false;                /* device locked */
108    }
109    P(dev->mutex);                  /* lock again */
110
111    Jmsg(jcr, M_INFO, 0, _("New volume \"%s\" mounted on device %s at %s.\n"),
112       dcr->VolumeName, dev->print_name(), bstrftime(dt, sizeof(dt), time(NULL)));
113
114    /*
115     * If this is a new tape, the label_blk will contain the
116     *  label, so write it now. If this is a previously
117     *  used tape, mount_next_write_volume() will return an
118     *  empty label_blk, and nothing will be written.
119     */
120    Dmsg0(190, "write label block to dev\n");
121    if (!write_block_to_dev(dcr)) {
122       berrno be;
123       Pmsg1(0, _("write_block_to_device Volume label failed. ERR=%s"),
124         be.strerror(dev->dev_errno));
125       free_block(label_blk);
126       dcr->block = block;
127       unblock_device(dev);
128       return false;                /* device locked */
129    }
130    free_block(label_blk);
131    dcr->block = block;
132
133    /*
134     * Walk through all attached jcrs indicating the volume has changed
135     */
136    Dmsg1(100, "Walk attached dcrs. Volume=%s\n", dev->VolCatInfo.VolCatName);
137    DCR *mdcr;
138    foreach_dlist(mdcr, dev->attached_dcrs) {
139       JCR *mjcr = mdcr->jcr;
140       if (mjcr->JobId == 0) {
141          continue;                 /* ignore console */
142       }
143       mdcr->NewVol = true;
144       if (jcr != mjcr) {
145          bstrncpy(mdcr->VolumeName, dcr->VolumeName, sizeof(mdcr->VolumeName));
146       }
147    }
148
149    /* Clear NewVol now because dir_get_volume_info() already done */
150    jcr->dcr->NewVol = false;
151    set_new_volume_parameters(dcr);
152
153    jcr->run_time += time(NULL) - wait_time; /* correct run time for mount wait */
154
155    /* Write overflow block to device */
156    Dmsg0(190, "Write overflow block to dev\n");
157    if (!write_block_to_dev(dcr)) {
158       berrno be;
159       Pmsg1(0, _("write_block_to_device overflow block failed. ERR=%s"),
160         be.strerror(dev->dev_errno));
161       unblock_device(dev);
162       return false;                /* device locked */
163    }
164
165    unblock_device(dev);
166    return true;                             /* device locked */
167 }
168
169 /*
170  * We have a new Volume mounted, so reset the Volume parameters
171  *  concerning this job.  The global changes were made earlier
172  *  in the dev structure.
173  */
174 void set_new_volume_parameters(DCR *dcr)
175 {
176    JCR *jcr = dcr->jcr;
177    DEVICE *dev = dcr->dev;
178    if (dcr->NewVol && !dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
179       Jmsg1(jcr, M_ERROR, 0, "%s", jcr->errmsg);
180    }
181    /* Set new start/end positions */
182    if (dev->is_tape()) {
183       dcr->StartBlock = dev->block_num;
184       dcr->StartFile = dev->file;
185    } else {
186       dcr->StartBlock = (uint32_t)dev->file_addr;
187       dcr->StartFile  = (uint32_t)(dev->file_addr >> 32);
188    }
189    /* Reset indicies */
190    dcr->VolFirstIndex = 0;
191    dcr->VolLastIndex = 0;
192    jcr->NumVolumes++;
193    dcr->NewVol = false;
194    dcr->WroteVol = false;
195 }
196
197 /*
198  * We are now in a new Volume file, so reset the Volume parameters
199  *  concerning this job.  The global changes were made earlier
200  *  in the dev structure.
201  */
202 void set_new_file_parameters(DCR *dcr)
203 {
204    DEVICE *dev = dcr->dev;
205
206    /* Set new start/end positions */
207    if (dev->is_tape()) {
208       dcr->StartBlock = dev->block_num;
209       dcr->StartFile = dev->file;
210    } else {
211       dcr->StartBlock = (uint32_t)dev->file_addr;
212       dcr->StartFile  = (uint32_t)(dev->file_addr >> 32);
213    }
214    /* Reset indicies */
215    dcr->VolFirstIndex = 0;
216    dcr->VolLastIndex = 0;
217    dcr->NewFile = false;
218    dcr->WroteVol = false;
219 }
220
221
222
223 /*
224  *   First Open of the device. Expect dev to already be initialized.
225  *
226  *   This routine is used only when the Storage daemon starts
227  *   and always_open is set, and in the stand-alone utility
228  *   routines such as bextract.
229  *
230  *   Note, opening of a normal file is deferred to later so
231  *    that we can get the filename; the device_name for
232  *    a file is the directory only.
233  *
234  *   Returns: false on failure
235  *            true  on success
236  */
237 bool first_open_device(DCR *dcr)
238 {
239    DEVICE *dev = dcr->dev;
240    bool ok = true;
241
242    Dmsg0(120, "start open_output_device()\n");
243    if (!dev) {
244       return false;
245    }
246
247    lock_device(dev);
248
249    /* Defer opening files */
250    if (!dev->is_tape()) {
251       Dmsg0(129, "Device is file, deferring open.\n");
252       goto bail_out;
253    }
254
255     int mode;
256     if (dev_cap(dev, CAP_STREAM)) {
257        mode = OPEN_WRITE_ONLY;
258     } else {
259        mode = OPEN_READ_ONLY;
260     }
261    Dmsg0(129, "Opening device.\n");
262    if (dev->open(dcr, mode) < 0) {
263       Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
264       ok = false;
265       goto bail_out;
266    }
267    Dmsg1(129, "open dev %s OK\n", dev->print_name());
268
269 bail_out:
270    unlock_device(dev);
271    return ok;
272 }
273
274 /*
275  * Make sure device is open, if not do so
276  */
277 bool open_device(DCR *dcr)
278 {
279    DEVICE *dev = dcr->dev;
280    /* Open device */
281    int mode;
282    if (dev_cap(dev, CAP_STREAM)) {
283       mode = OPEN_WRITE_ONLY;
284    } else {
285       mode = OPEN_READ_WRITE;
286    }
287    if (dev->open(dcr, mode) < 0) {
288       /* If polling, ignore the error */
289       /* If DVD, also ignore the error, very often you cannot open the device
290        * (when there is no DVD, or when the one inserted is a wrong one) */
291       if (!dev->poll && !dev->is_dvd() && !dev->is_removable()) {
292          Jmsg2(dcr->jcr, M_FATAL, 0, _("Unable to open device %s: ERR=%s\n"),
293             dev->print_name(), dev->bstrerror());
294          Pmsg2(000, _("Unable to open archive %s: ERR=%s\n"), 
295             dev->print_name(), dev->bstrerror());
296       }
297       return false;
298    }
299    return true;
300 }
301
302
303
304 void dev_lock(DEVICE *dev)
305 {
306    int errstat;
307    if ((errstat=rwl_writelock(&dev->lock))) {
308       Emsg1(M_ABORT, 0, _("Device write lock failure. ERR=%s\n"), strerror(errstat));
309    }
310 }
311
312 void dev_unlock(DEVICE *dev)
313 {
314    int errstat;
315    if ((errstat=rwl_writeunlock(&dev->lock))) {
316       Emsg1(M_ABORT, 0, _("Device write unlock failure. ERR=%s\n"), strerror(errstat));
317    }
318 }
319
320 /*
321  * When dev_blocked is set, all threads EXCEPT thread with id no_wait_id
322  * must wait. The no_wait_id thread is out obtaining a new volume
323  * and preparing the label.
324  */
325 void _lock_device(const char *file, int line, DEVICE *dev)
326 {
327    int stat;
328    Dmsg3(500, "lock %d from %s:%d\n", dev->dev_blocked, file, line);
329    P(dev->mutex);
330    if (dev->dev_blocked && !pthread_equal(dev->no_wait_id, pthread_self())) {
331       dev->num_waiting++;             /* indicate that I am waiting */
332       while (dev->dev_blocked) {
333          if ((stat = pthread_cond_wait(&dev->wait, &dev->mutex)) != 0) {
334             V(dev->mutex);
335             Emsg1(M_ABORT, 0, _("pthread_cond_wait failure. ERR=%s\n"),
336                strerror(stat));
337          }
338       }
339       dev->num_waiting--;             /* no longer waiting */
340    }
341 }
342
343 /*
344  * Check if the device is blocked or not
345  */
346 bool is_device_unmounted(DEVICE *dev)
347 {
348    bool stat;
349    int blocked = dev->dev_blocked;
350    stat = (blocked == BST_UNMOUNTED) ||
351           (blocked == BST_UNMOUNTED_WAITING_FOR_SYSOP);
352    return stat;
353 }
354
355 void _unlock_device(const char *file, int line, DEVICE *dev)
356 {
357    Dmsg2(500, "unlock from %s:%d\n", file, line);
358    V(dev->mutex);
359 }
360
361 /*
362  * Block all other threads from using the device
363  *  Device must already be locked.  After this call,
364  *  the device is blocked to any thread calling lock_device(),
365  *  but the device is not locked (i.e. no P on device).  Also,
366  *  the current thread can do slip through the lock_device()
367  *  calls without blocking.
368  */
369 void _block_device(const char *file, int line, DEVICE *dev, int state)
370 {
371    Dmsg3(500, "block set %d from %s:%d\n", state, file, line);
372    ASSERT(dev->get_blocked() == BST_NOT_BLOCKED);
373    dev->set_blocked(state);           /* make other threads wait */
374    dev->no_wait_id = pthread_self();  /* allow us to continue */
375 }
376
377
378
379 /*
380  * Unblock the device, and wake up anyone who went to sleep.
381  */
382 void _unblock_device(const char *file, int line, DEVICE *dev)
383 {
384    Dmsg3(500, "unblock %s from %s:%d\n", dev->print_blocked(), file, line);
385    ASSERT(dev->dev_blocked);
386    dev->set_blocked(BST_NOT_BLOCKED);
387    dev->no_wait_id = 0;
388    if (dev->num_waiting > 0) {
389       pthread_cond_broadcast(&dev->wait); /* wake them up */
390    }
391 }
392
393 /*
394  * Enter with device locked and blocked
395  * Exit with device unlocked and blocked by us.
396  */
397 void _steal_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold, int state)
398 {
399
400    Dmsg3(400, "steal lock. old=%s from %s:%d\n", dev->print_blocked(),
401       file, line);
402    hold->dev_blocked = dev->get_blocked();
403    hold->dev_prev_blocked = dev->dev_prev_blocked;
404    hold->no_wait_id = dev->no_wait_id;
405    dev->set_blocked(state);
406    Dmsg1(400, "steal lock. new=%s\n", dev->print_blocked());
407    dev->no_wait_id = pthread_self();
408    V(dev->mutex);
409 }
410
411 /*
412  * Enter with device blocked by us but not locked
413  * Exit with device locked, and blocked by previous owner
414  */
415 void _give_back_device_lock(const char *file, int line, DEVICE *dev, bsteal_lock_t *hold)
416 {
417    Dmsg3(400, "return lock. old=%s from %s:%d\n",
418       dev->print_blocked(), file, line);
419    P(dev->mutex);
420    dev->dev_blocked = hold->dev_blocked;
421    dev->dev_prev_blocked = hold->dev_prev_blocked;
422    dev->no_wait_id = hold->no_wait_id;
423    Dmsg1(400, "return lock. new=%s\n", dev->print_blocked());
424    if (dev->num_waiting > 0) {
425       pthread_cond_broadcast(&dev->wait); /* wake them up */
426    }
427 }