2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2008 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 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 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 * dev.c -- low level operations on device (storage device)
34 * NOTE!!!! None of these routines are reentrant. You must
35 * use dev->r_dlock() and dev->unlock() at a higher level,
36 * or use the xxx_device() equivalents. By moving the
37 * thread synchronization to a higher level, we permit
38 * the higher level routines to "seize" the device and
39 * to carry out operations without worrying about who
40 * set what lock (i.e. race conditions).
42 * Note, this is the device dependent code, and may have
43 * to be modified for each system, but is meant to
44 * be as "generic" as possible.
46 * The purpose of this code is to develop a SIMPLE Storage
47 * daemon. More complicated coding (double buffering, writer
48 * thread, ...) is left for a later version.
54 * Handling I/O errors and end of tape conditions are a bit tricky.
55 * This is how it is currently done when writting.
56 * On either an I/O error or end of tape,
57 * we will stop writing on the physical device (no I/O recovery is
58 * attempted at least in this daemon). The state flag will be sent
59 * to include ST_EOT, which is ephemeral, and ST_WEOT, which is
60 * persistent. Lots of routines clear ST_EOT, but ST_WEOT is
61 * cleared only when the problem goes away. Now when ST_WEOT
62 * is set all calls to write_block_to_device() call the fix_up
63 * routine. In addition, all threads are blocked
64 * from writing on the tape by calling lock_dev(), and thread other
65 * than the first thread to hit the EOT will block on a condition
66 * variable. The first thread to hit the EOT will continue to
67 * be able to read and write the tape (he sort of tunnels through
68 * the locking mechanism -- see lock_dev() for details).
70 * Now presumably somewhere higher in the chain of command
71 * (device.c), someone will notice the EOT condition and
72 * get a new tape up, get the tape label read, and mark
73 * the label for rewriting. Then this higher level routine
74 * will write the unwritten buffer to the new volume.
75 * Finally, he will release
76 * any blocked threads by doing a broadcast on the condition
77 * variable. At that point, we should be totally back in
78 * business with no lost data.
89 /* Forward referenced functions */
90 void set_os_device_parameters(DCR *dcr);
91 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat);
92 static const char *mode_to_str(int mode);
95 * Allocate and initialize the DEVICE structure
96 * Note, if dev is non-NULL, it is already allocated,
97 * thus we neither allocate it nor free it. This allows
98 * the caller to put the packet in shared memory.
100 * Note, for a tape, the device->device_name is the device name
101 * (e.g. /dev/nst0), and for a file, the device name
102 * is the directory in which the file will be placed.
106 init_dev(JCR *jcr, DEVRES *device)
115 /* If no device type specified, try to guess */
116 if (!device->dev_type) {
117 /* Check that device is available */
118 if (stat(device->device_name, &statp) < 0) {
120 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
121 device->device_name, be.bstrerror());
124 if (S_ISDIR(statp.st_mode)) {
125 device->dev_type = B_FILE_DEV;
126 } else if (IS_TAPE(statp.st_mode)) { /* char device or fake tape */
127 device->dev_type = B_TAPE_DEV;
128 } else if (S_ISFIFO(statp.st_mode)) {
129 device->dev_type = B_FIFO_DEV;
130 } else if (!(device->cap_bits & CAP_REQMOUNT)) {
131 Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
132 " or have RequiresMount=yes for DVD. st_mode=%x\n"),
133 device->device_name, statp.st_mode);
136 device->dev_type = B_DVD_DEV;
140 dev = (DEVICE *)malloc(sizeof(DEVICE));
141 memset(dev, 0, sizeof(DEVICE));
142 dev->clear_slot(); /* unknown */
144 /* Copy user supplied device parameters from Resource */
145 dev->dev_name = get_memory(strlen(device->device_name)+1);
146 pm_strcpy(dev->dev_name, device->device_name);
147 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
148 /* We edit "Resource-name" (physical-name) */
149 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
150 Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
151 dev->capabilities = device->cap_bits;
152 dev->min_block_size = device->min_block_size;
153 dev->max_block_size = device->max_block_size;
154 dev->max_volume_size = device->max_volume_size;
155 dev->max_file_size = device->max_file_size;
156 dev->volume_capacity = device->volume_capacity;
157 dev->max_rewind_wait = device->max_rewind_wait;
158 dev->max_open_wait = device->max_open_wait;
159 dev->max_open_vols = device->max_open_vols;
160 dev->vol_poll_interval = device->vol_poll_interval;
161 dev->max_spool_size = device->max_spool_size;
162 dev->drive_index = device->drive_index;
163 dev->autoselect = device->autoselect;
164 dev->dev_type = device->dev_type;
165 if (dev->is_tape()) { /* No parts on tapes */
166 dev->max_part_size = 0;
168 dev->max_part_size = device->max_part_size;
171 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
172 dev->vol_poll_interval = 60;
174 /* Link the dev and device structures together */
175 dev->device = device;
178 if (dev->is_fifo()) {
179 dev->capabilities |= CAP_STREAM; /* set stream device */
182 /* If the device requires mount :
183 * - Check that the mount point is available
184 * - Check that (un)mount commands are defined
186 if ((dev->is_file() || dev->is_dvd()) && dev->requires_mount()) {
187 if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
189 dev->dev_errno = errno;
190 Jmsg2(jcr, M_ERROR_TERM, 0, _("Unable to stat mount point %s: ERR=%s\n"),
191 device->mount_point, be.bstrerror());
195 if (!device->mount_command || !device->unmount_command) {
196 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
198 if (!device->write_part_command) {
199 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
204 if (dev->max_block_size == 0) {
205 max_bs = DEFAULT_BLOCK_SIZE;
207 max_bs = dev->max_block_size;
209 if (dev->min_block_size > max_bs) {
210 Jmsg(jcr, M_ERROR_TERM, 0, _("Min block size > max on device %s\n"),
213 if (dev->max_block_size > 4096000) {
214 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
215 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
216 dev->max_block_size = 0;
218 if (dev->max_block_size % TAPE_BSIZE != 0) {
219 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
220 dev->max_block_size, dev->print_name());
223 dev->errmsg = get_pool_memory(PM_EMSG);
226 if ((errstat = pthread_mutex_init(&dev->m_mutex, NULL)) != 0) {
228 dev->dev_errno = errstat;
229 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
230 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
232 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
234 dev->dev_errno = errstat;
235 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
236 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
238 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
240 dev->dev_errno = errstat;
241 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
242 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
244 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
246 dev->dev_errno = errstat;
247 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
248 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
251 if ((errstat = rwl_init(&dev->lock)) != 0) {
253 dev->dev_errno = errstat;
254 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
255 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
260 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
261 Dmsg2(100, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
262 dev->initiated = true;
268 * Open the device with the operating system and
269 * initialize buffer pointers.
271 * Returns: -1 on error
274 * Note, for a tape, the VolName is the name we give to the
275 * volume (not really used here), but for a file, the
276 * VolName represents the name of the file to be created/opened.
277 * In the case of a file, the full name is the device name
278 * (archive_name) with the VolName concatenated.
281 DEVICE::open(DCR *dcr, int omode)
285 if (openmode == omode) {
294 Dmsg0(100, "Close fd for mode change.\n");
295 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
299 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
302 Dmsg4(100, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
303 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
304 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
305 label_type = B_BACULA_LABEL;
306 if (is_tape() || is_fifo()) {
307 open_tape_device(dcr, omode);
308 } else if (is_dvd()) {
309 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
310 open_dvd_device(dcr, omode);
312 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
313 open_file_device(dcr, omode);
315 state |= preserve; /* reset any important state info */
316 Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, m_fd);
320 void DEVICE::set_mode(int new_mode)
323 case CREATE_READ_WRITE:
324 mode = O_CREAT | O_RDWR | O_BINARY;
326 case OPEN_READ_WRITE:
327 mode = O_RDWR | O_BINARY;
330 mode = O_RDONLY | O_BINARY;
332 case OPEN_WRITE_ONLY:
333 mode = O_WRONLY | O_BINARY;
336 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
342 void DEVICE::open_tape_device(DCR *dcr, int omode)
345 int timeout = max_open_wait;
346 #if !defined(HAVE_WIN32)
348 utime_t start_time = time(NULL);
352 Dmsg0(100, "Open dev: device is tape\n");
354 get_autochanger_loaded_slot(dcr);
363 if (is_fifo() && timeout) {
365 tid = start_thread_timer(dcr->jcr, pthread_self(), timeout);
367 Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
368 #if defined(HAVE_WIN32)
371 if ((m_fd = tape_open(dev_name, mode)) < 0) {
378 /* If busy retry each second for max_open_wait seconds */
380 /* Try non-blocking open */
381 m_fd = tape_open(dev_name, mode+O_NONBLOCK);
385 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
386 print_name(), omode, mode, errno, be.bstrerror());
388 /* Tape open, now rewind it */
389 Dmsg0(100, "Rewind after open\n");
390 mt_com.mt_op = MTREW;
392 /* rewind only if dev is a tape */
393 if (is_tape() && (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0)) {
395 dev_errno = errno; /* set error status from rewind */
398 Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
399 be.bstrerror(dev_errno));
400 /* If we get busy, device is probably rewinding, try again */
401 if (dev_errno != EBUSY) {
402 break; /* error -- no medium */
405 /* Got fd and rewind worked, so we must have medium in drive */
407 m_fd = tape_open(dev_name, mode); /* open normally */
411 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
412 print_name(), omode, mode, errno, be.bstrerror());
417 set_os_device_parameters(dcr); /* do system dependent stuff */
418 break; /* Successfully opened and rewound */
422 /* Exceed wait time ? */
423 if (time(NULL) - start_time >= max_open_wait) {
424 break; /* yes, get out */
431 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
432 print_name(), be.bstrerror(dev_errno));
433 Dmsg1(100, "%s", errmsg);
436 /* Stop any open() timer we started */
438 stop_thread_timer(tid);
441 Dmsg1(100, "open dev: tape %d opened\n", m_fd);
448 void DEVICE::open_file_device(DCR *dcr, int omode)
450 POOL_MEM archive_name(PM_FNAME);
452 get_autochanger_loaded_slot(dcr);
455 * Handle opening of File Archive (not a tape)
458 pm_strcpy(archive_name, dev_name);
460 * If this is a virtual autochanger (i.e. changer_res != NULL)
461 * we simply use the device name, assuming it has been
462 * appropriately setup by the "autochanger".
464 if (!device->changer_res || device->changer_command[0] == 0) {
465 if (VolCatInfo.VolCatName[0] == 0) {
466 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
472 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
473 pm_strcat(archive_name, "/");
475 pm_strcat(archive_name, VolCatInfo.VolCatName);
478 mount(1); /* do mount if required */
482 /* If creating file, give 0640 permissions */
483 Dmsg3(100, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
484 archive_name.c_str(), mode);
485 /* Use system open() */
486 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
489 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
491 Dmsg1(100, "open failed: %s", errmsg);
492 Jmsg1(NULL, M_WARNING, 0, "%s", errmsg);
498 Dmsg4(100, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
499 m_fd, part, num_dvd_parts, part_size);
503 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
504 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
505 * has the desired Volume name, but there is NO assurance that
506 * any other field of VolCatInfo is correct.
508 void DEVICE::open_dvd_device(DCR *dcr, int omode)
510 POOL_MEM archive_name(PM_FNAME);
511 struct stat filestat;
514 * Handle opening of DVD Volume
516 Dmsg2(100, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n",
517 &dcr->VolCatInfo, mode_to_str(omode));
520 * For a DVD we must always pull the state info from dcr->VolCatInfo
521 * This is a bit ugly, but is necessary because we need to open/close/re-open
522 * the dvd file in order to properly mount/unmount and access the
523 * DVD. So we store the state of the DVD as far as is known in the
524 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
525 * copy here, when opening.
527 VolCatInfo = dcr->VolCatInfo; /* structure assignment */
528 Dmsg1(100, "Volume=%s\n", VolCatInfo.VolCatName);
530 if (VolCatInfo.VolCatName[0] == 0) {
531 Dmsg1(10, "Could not open DVD device %s. No Volume name given.\n",
533 Mmsg(errmsg, _("Could not open DVD device %s. No Volume name given.\n"),
540 Dmsg0(100, "Set part=1\n");
541 part = 1; /* count from 1 */
545 if (num_dvd_parts != VolCatInfo.VolCatParts) {
546 num_dvd_parts = VolCatInfo.VolCatParts;
550 * If we are not trying to access the last part, set mode to
551 * OPEN_READ_ONLY as writing would be an error.
553 Dmsg2(100, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
554 /* Now find the name of the part that we want to access */
555 if (part <= num_dvd_parts) {
556 omode = OPEN_READ_ONLY;
557 make_mounted_dvd_filename(this, archive_name);
558 set_part_spooled(false);
560 omode = OPEN_READ_WRITE;
561 make_spooled_dvd_filename(this, archive_name);
562 set_part_spooled(true);
566 // Clear any previous blank_dvd status - we will recalculate it here
569 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
570 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
573 Dmsg0(99, "DVD device mounted.\n");
574 if (num_dvd_parts == 0 && !truncating) {
576 * If we can mount the device, and we are not truncating the DVD,
577 * we usually want to abort. There is one exception, if there is
578 * only one 0-sized file on the DVD, with the right volume name,
579 * we continue (it's the method used by truncate_dvd to truncate a volume).
581 if (!check_can_write_on_non_blank_dvd(dcr)) {
582 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
583 Emsg0(M_FATAL, 0, errmsg);
584 unmount(1); /* Unmount the device, so the operator can change it. */
591 * Ensure that we have the correct DVD loaded by looking for part1.
592 * We only succeed the open if it exists. Failure to do this could
593 * leave us trying to add a part to a different DVD!
595 uint32_t oldpart = part;
597 POOL_MEM part1_name(PM_FNAME);
599 make_mounted_dvd_filename(this, part1_name);
601 if (stat(part1_name.c_str(), &statp) < 0) {
603 Mmsg(errmsg, _("Unable to stat DVD part 1 file %s: ERR=%s\n"),
604 part1_name.c_str(), be.bstrerror());
605 Emsg0(M_FATAL, 0, errmsg);
609 if (!S_ISREG(statp.st_mode)) {
610 /* It is not a regular file */
611 Mmsg(errmsg, _("DVD part 1 is not a regular file %s.\n"),
613 Emsg0(M_FATAL, 0, errmsg);
619 Dmsg0(99, "DVD device mount failed.\n");
620 /* We cannot mount the device */
621 if (num_dvd_parts == 0) {
622 /* Run free space, check there is a media. */
623 if (!update_freespace()) {
624 Emsg0(M_FATAL, 0, errmsg);
629 Dmsg1(100, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
631 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
632 Emsg0(M_FATAL, 0, errmsg);
637 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
638 Emsg0(M_FATAL, 0, errmsg);
644 Dmsg5(100, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
645 archive_name.c_str(), mode_to_str(omode),
646 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
648 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
651 /* If creating file, give 0640 permissions */
652 Dmsg3(100, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
653 archive_name.c_str(), mode);
654 /* Use system open() */
655 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
657 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
659 // Should this be set if we try the create/open below
660 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
661 Dmsg1(100, "open failed: %s", errmsg);
663 /* Previous open failed. See if we can recover */
664 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
665 (part > num_dvd_parts)) {
666 /* If the last part (on spool), doesn't exist when accessing,
667 * create it. In read/write mode a write will be allowed (higher
668 * level software thinks that we are extending a pre-existing
669 * media. Reads for READ_ONLY will report immediately an EOF
670 * Sometimes it is better to finish with an EOF than with an error. */
671 Dmsg1(100, "Creating last part on spool: %s\n", archive_name.c_str());
672 omode = CREATE_READ_WRITE;
673 set_mode(CREATE_READ_WRITE);
674 m_fd = ::open(archive_name.c_str(), mode, 0640);
678 Dmsg1(100, "after open fd=%d\n", m_fd);
680 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
683 /* Get size of file */
684 if (fstat(m_fd, &filestat) < 0) {
687 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
689 Dmsg1(100, "open failed: %s", errmsg);
690 /* Use system close() */
694 part_size = filestat.st_size;
696 update_pos(dcr); /* update position */
704 * Returns: true on success
707 bool DEVICE::rewind(DCR *dcr)
713 Dmsg3(400, "rewind res=%d fd=%d %s\n", num_reserved(), m_fd, print_name());
714 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
715 block_num = file = 0;
719 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
721 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
723 Emsg0(M_ABORT, 0, errmsg);
728 mt_com.mt_op = MTREW;
730 /* If we get an I/O error on rewind, it is probably because
731 * the drive is actually busy. We loop for (about 5 minutes)
732 * retrying every 5 seconds.
734 for (i=max_rewind_wait; ; i -= 5) {
735 if (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
738 if (i == max_rewind_wait) {
739 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.bstrerror());
742 * This is a gross hack, because if the user has the
743 * device mounted (i.e. open), then uses mtx to load
744 * a tape, the current open file descriptor is invalid.
745 * So, we close the drive and re-open it.
748 int open_mode = openmode;
751 open(dcr, open_mode);
759 if (dev_errno == EIO) {
760 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
764 if (dev_errno == EIO && i > 0) {
765 Dmsg0(200, "Sleeping 5 seconds.\n");
770 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
771 print_name(), be.bstrerror());
776 } else if (is_file() || is_dvd()) {
777 if (lseek(dcr, (boffset_t)0, SEEK_SET) < 0) {
780 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
781 print_name(), be.bstrerror());
790 * Called to indicate that we have just read an
791 * EOF from the device.
793 void DEVICE::set_ateof()
805 * Called to indicate we are now at the end of the tape, and
806 * writing is not possible.
808 void DEVICE::set_ateot()
810 /* Make tape effectively read-only */
811 state |= (ST_EOF|ST_EOT|ST_WEOT);
816 * Position device to end of medium (end of data)
817 * Returns: true on succes
820 bool DEVICE::eod(DCR *dcr)
829 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
833 #if defined (__digital__) && defined (__unix__)
834 return fsf(VolCatInfo.VolCatFiles);
841 clear_eof(); /* remove EOF flag */
842 block_num = file = 0;
849 pos = lseek(dcr, (boffset_t)0, SEEK_END);
850 // Dmsg1(100, "====== Seek to %lld\n", pos);
858 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
859 print_name(), be.bstrerror());
863 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
864 Dmsg0(100,"Using FAST FSF for EOM\n");
865 /* If unknown position, rewind */
866 if (get_os_tape_file() < 0) {
871 mt_com.mt_op = MTFSF;
873 * ***FIXME*** fix code to handle case that INT16_MAX is
876 mt_com.mt_count = INT16_MAX; /* use big positive number */
877 if (mt_com.mt_count < 0) {
878 mt_com.mt_count = INT16_MAX; /* brain damaged system */
882 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
883 if (has_cap(CAP_EOM)) {
884 Dmsg0(100,"Using EOM for EOM\n");
885 mt_com.mt_op = MTEOM;
889 if (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
891 clrerror(mt_com.mt_op);
892 Dmsg1(50, "ioctl error: %s\n", be.bstrerror());
894 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
895 print_name(), be.bstrerror());
899 os_file = get_os_tape_file();
903 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
904 print_name(), be.bstrerror());
907 Dmsg1(100, "EOD file=%d\n", os_file);
915 * Rewind then use FSF until EOT reached
921 * Move file by file to the end of the tape
924 for (file_num=file; !at_eot(); file_num++) {
925 Dmsg0(200, "eod: doing fsf 1\n");
927 Dmsg0(200, "fsf error.\n");
931 * Avoid infinite loop by ensuring we advance.
933 if (!at_eot() && file_num == (int)file) {
934 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
936 os_file = get_os_tape_file();
938 Dmsg2(100, "Adjust file from %d to %d\n", file_num, os_file);
946 * Some drivers leave us after second EOF when doing
947 * MTEOM, so we must backup so that appending overwrites
950 if (has_cap(CAP_BSFATEOM)) {
951 /* Backup over EOF */
953 /* If BSF worked and fileno is known (not -1), set file */
954 os_file = get_os_tape_file();
956 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , os_file);
959 file++; /* wing it -- not correct on all OSes */
962 update_pos(dcr); /* update position */
964 Dmsg1(200, "EOD dev->file=%d\n", file);
969 * Set the position of the device -- only for files and DVD
970 * For other devices, there is no generic way to do it.
971 * Returns: true on succes
974 bool DEVICE::update_pos(DCR *dcr)
981 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
982 Emsg1(M_FATAL, 0, "%s", errmsg);
986 /* Find out where we are */
987 if (is_file() || is_dvd()) {
990 pos = lseek(dcr, (boffset_t)0, SEEK_CUR);
994 Pmsg1(000, _("Seek error: ERR=%s\n"), be.bstrerror());
995 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
996 print_name(), be.bstrerror());
1000 block_num = (uint32_t)pos;
1001 file = (uint32_t)(pos >> 32);
1008 * Return the status of the device. This was meant
1009 * to be a generic routine. Unfortunately, it doesn't
1010 * seem possible (at least I do not know how to do it
1011 * currently), which means that for the moment, this
1012 * routine has very little value.
1016 uint32_t status_dev(DEVICE *dev)
1018 struct mtget mt_stat;
1021 if (dev->state & (ST_EOT | ST_WEOT)) {
1025 if (dev->state & ST_EOF) {
1029 if (dev->is_tape()) {
1031 Pmsg0(-20,_(" Bacula status:"));
1032 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1033 if (tape_ioctl(dev->fd(), MTIOCGET, (char *)&mt_stat) < 0) {
1035 dev->dev_errno = errno;
1036 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1037 dev->print_name(), be.bstrerror());
1040 Pmsg0(-20, _(" Device status:"));
1042 #if defined(HAVE_LINUX_OS)
1043 if (GMT_EOF(mt_stat.mt_gstat)) {
1047 if (GMT_BOT(mt_stat.mt_gstat)) {
1051 if (GMT_EOT(mt_stat.mt_gstat)) {
1055 if (GMT_SM(mt_stat.mt_gstat)) {
1059 if (GMT_EOD(mt_stat.mt_gstat)) {
1063 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1064 stat |= BMT_WR_PROT;
1065 Pmsg0(-20, " WR_PROT");
1067 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1069 Pmsg0(-20, " ONLINE");
1071 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1072 stat |= BMT_DR_OPEN;
1073 Pmsg0(-20, " DR_OPEN");
1075 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1076 stat |= BMT_IM_REP_EN;
1077 Pmsg0(-20, " IM_REP_EN");
1079 #elif defined(HAVE_WIN32)
1080 if (GMT_EOF(mt_stat.mt_gstat)) {
1084 if (GMT_BOT(mt_stat.mt_gstat)) {
1088 if (GMT_EOT(mt_stat.mt_gstat)) {
1092 if (GMT_EOD(mt_stat.mt_gstat)) {
1096 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1097 stat |= BMT_WR_PROT;
1098 Pmsg0(-20, " WR_PROT");
1100 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1102 Pmsg0(-20, " ONLINE");
1104 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1105 stat |= BMT_DR_OPEN;
1106 Pmsg0(-20, " DR_OPEN");
1108 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1109 stat |= BMT_IM_REP_EN;
1110 Pmsg0(-20, " IM_REP_EN");
1113 #endif /* !SunOS && !OSF */
1114 if (dev->has_cap(CAP_MTIOCGET)) {
1115 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1117 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1120 stat |= BMT_ONLINE | BMT_BOT;
1127 * Load medium in device
1128 * Returns: true on success
1131 bool load_dev(DEVICE *dev)
1137 if (dev->fd() < 0) {
1138 dev->dev_errno = EBADF;
1139 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1140 Emsg0(M_FATAL, 0, dev->errmsg);
1143 if (!(dev->is_tape())) {
1147 Dmsg0(200, "stored: MTLOAD command not available\n");
1149 dev->dev_errno = ENOTTY; /* function not available */
1150 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1151 dev->print_name(), be.bstrerror());
1155 dev->block_num = dev->file = 0;
1158 mt_com.mt_op = MTLOAD;
1159 mt_com.mt_count = 1;
1160 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
1162 dev->dev_errno = errno;
1163 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1164 dev->print_name(), be.bstrerror());
1172 * Rewind device and put it offline
1173 * Returns: true on success
1176 bool DEVICE::offline()
1181 return true; /* device not open */
1184 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1185 block_num = file = 0;
1189 mt_com.mt_op = MTOFFL;
1190 mt_com.mt_count = 1;
1191 if (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
1194 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1195 print_name(), be.bstrerror());
1198 Dmsg1(100, "Offlined device %s\n", print_name());
1202 bool DEVICE::offline_or_rewind()
1207 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1211 * Note, this rewind probably should not be here (it wasn't
1212 * in prior versions of Bacula), but on FreeBSD, this is
1213 * needed in the case the tape was "frozen" due to an error
1214 * such as backspacing after writing and EOF. If it is not
1215 * done, all future references to the drive get and I/O error.
1218 return rewind(NULL);
1223 * Foward space a file
1224 * Returns: true on success
1227 bool DEVICE::fsf(int num)
1229 int32_t os_file = 0;
1235 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1236 Emsg0(M_FATAL, 0, errmsg);
1246 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1250 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1253 Dmsg0(100, "fsf\n");
1256 * If Fast forward space file is set, then we
1257 * use MTFSF to forward space and MTIOCGET
1258 * to get the file position. We assume that
1259 * the SCSI driver will ensure that we do not
1260 * forward space past the end of the medium.
1262 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1264 mt_com.mt_op = MTFSF;
1265 mt_com.mt_count = num;
1266 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1268 my_errno = errno; /* save errno */
1269 } else if ((os_file=get_os_tape_file()) < 0) {
1270 my_errno = errno; /* save errno */
1272 if (my_errno != 0) {
1275 Dmsg0(200, "Set ST_EOT\n");
1277 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1278 print_name(), be.bstrerror(my_errno));
1279 Dmsg1(200, "%s", errmsg);
1283 Dmsg1(200, "fsf file=%d\n", os_file);
1289 * Here if CAP_FSF is set, and virtually all drives
1290 * these days support it, we read a record, then forward
1291 * space one file. Using this procedure, which is slow,
1292 * is the only way we can be sure that we don't read
1293 * two consecutive EOF marks, which means End of Data.
1295 } else if (has_cap(CAP_FSF)) {
1298 Dmsg0(200, "FSF has cap_fsf\n");
1299 if (max_block_size == 0) {
1300 rbuf_len = DEFAULT_BLOCK_SIZE;
1302 rbuf_len = max_block_size;
1304 rbuf = get_memory(rbuf_len);
1305 mt_com.mt_op = MTFSF;
1306 mt_com.mt_count = 1;
1307 while (num-- && !at_eot()) {
1308 Dmsg0(100, "Doing read before fsf\n");
1309 if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1310 if (errno == ENOMEM) { /* tape record exceeds buf len */
1311 stat = rbuf_len; /* This is OK */
1313 * On IBM drives, they return ENOSPC at EOM
1314 * instead of EOF status
1316 } else if (at_eof() && errno == ENOSPC) {
1322 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1324 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1325 print_name(), be.bstrerror());
1326 Dmsg1(100, "%s", errmsg);
1330 if (stat == 0) { /* EOF */
1331 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1332 /* Two reads of zero means end of tape */
1335 Dmsg0(100, "Set ST_EOT\n");
1341 } else { /* Got data */
1346 Dmsg0(100, "Doing MTFSF\n");
1347 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1348 if (stat < 0) { /* error => EOT */
1351 Dmsg0(100, "Set ST_EOT\n");
1353 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1354 print_name(), be.bstrerror());
1355 Dmsg0(100, "Got < 0 for MTFSF\n");
1356 Dmsg1(100, "%s", errmsg);
1364 * No FSF, so use FSR to simulate it
1367 Dmsg0(200, "Doing FSR for FSF\n");
1368 while (num-- && !at_eot()) {
1369 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1373 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1379 Dmsg1(200, "Return %d from FSF\n", stat);
1381 Dmsg0(200, "ST_EOF set on exit FSF\n");
1384 Dmsg0(200, "ST_EOT set on exit FSF\n");
1386 Dmsg1(200, "Return from FSF file=%d\n", file);
1391 * Backward space a file
1392 * Returns: false on failure
1395 bool DEVICE::bsf(int num)
1402 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1403 Emsg0(M_FATAL, 0, errmsg);
1408 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1413 Dmsg0(100, "bsf\n");
1419 mt_com.mt_op = MTBSF;
1420 mt_com.mt_count = num;
1421 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1425 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1426 print_name(), be.bstrerror());
1433 * Foward space num records
1434 * Returns: false on failure
1437 bool DEVICE::fsr(int num)
1444 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1445 Emsg0(M_FATAL, 0, errmsg);
1453 if (!has_cap(CAP_FSR)) {
1454 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1458 Dmsg1(100, "fsr %d\n", num);
1459 mt_com.mt_op = MTFSR;
1460 mt_com.mt_count = num;
1461 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1467 struct mtget mt_stat;
1469 Dmsg1(100, "FSF fail: ERR=%s\n", be.bstrerror());
1470 if (dev_get_os_pos(this, &mt_stat)) {
1471 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1472 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1473 file = mt_stat.mt_fileno;
1474 block_num = mt_stat.mt_blkno;
1482 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1483 num, print_name(), be.bstrerror());
1489 * Backward space a record
1490 * Returns: false on failure
1493 bool DEVICE::bsr(int num)
1500 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1501 Emsg0(M_FATAL, 0, errmsg);
1509 if (!has_cap(CAP_BSR)) {
1510 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1514 Dmsg0(100, "bsr_dev\n");
1518 mt_com.mt_op = MTBSR;
1519 mt_com.mt_count = num;
1520 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1524 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1525 print_name(), be.bstrerror());
1530 void DEVICE::lock_door()
1534 mt_com.mt_op = MTLOCK;
1535 mt_com.mt_count = 1;
1536 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1540 void DEVICE::unlock_door()
1544 mt_com.mt_op = MTUNLOCK;
1545 mt_com.mt_count = 1;
1546 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1550 void DEVICE::set_slot(int32_t slot)
1553 if (vol) vol->clear_slot();
1556 void DEVICE::clear_slot()
1559 if (vol) vol->set_slot(-1);
1565 * Reposition the device to file, block
1566 * Returns: false on failure
1569 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1573 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1574 Emsg0(M_FATAL, 0, errmsg);
1579 boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1580 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1581 if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1584 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1585 print_name(), be.bstrerror());
1594 /* After this point, we are tape only */
1595 Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1597 Dmsg0(100, "Rewind\n");
1598 if (!rewind(NULL)) {
1603 Dmsg1(100, "fsf %d\n", rfile-file);
1604 if (!fsf(rfile-file)) {
1605 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1608 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1610 if (rblock < block_num) {
1611 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1612 Dmsg0(100, "bsf 1\n");
1614 Dmsg0(100, "fsf 1\n");
1616 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1618 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1619 /* Ignore errors as Bacula can read to the correct block */
1620 Dmsg1(100, "fsr %d\n", rblock-block_num);
1621 return fsr(rblock-block_num);
1623 while (rblock > block_num) {
1624 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1627 Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1628 print_name(), be.bstrerror());
1631 Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1640 * Write an end of file on the device
1641 * Returns: true on success
1644 bool DEVICE::weof(int num)
1648 Dmsg0(129, "weof_dev\n");
1652 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1653 Emsg0(M_FATAL, 0, errmsg);
1661 if (!can_append()) {
1662 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1663 Emsg0(M_FATAL, 0, errmsg);
1669 mt_com.mt_op = MTWEOF;
1670 mt_com.mt_count = num;
1671 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1680 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1681 print_name(), be.bstrerror());
1689 * If implemented in system, clear the tape
1692 void DEVICE::clrerror(int func)
1694 const char *msg = NULL;
1697 dev_errno = errno; /* save errno */
1699 VolCatInfo.VolCatErrors++;
1706 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1709 break; /* ignore message printed later */
1712 clear_cap(CAP_EOF); /* turn off feature */
1717 clear_cap(CAP_EOM); /* turn off feature */
1722 clear_cap(CAP_FSF); /* turn off feature */
1726 clear_cap(CAP_BSF); /* turn off feature */
1730 clear_cap(CAP_FSR); /* turn off feature */
1734 clear_cap(CAP_BSR); /* turn off feature */
1744 #ifdef MTSETDRVBUFFER
1745 case MTSETDRVBUFFER:
1746 msg = "MTSETDRVBUFFER";
1779 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1785 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1786 Emsg0(M_ERROR, 0, errmsg);
1791 * Now we try different methods of clearing the error
1792 * status on the drive so that it is not locked for
1793 * further operations.
1796 /* On some systems such as NetBSD, this clears all errors */
1799 /* Found on Solaris */
1802 tape_ioctl(m_fd, MTIOCLRERR);
1803 Dmsg0(200, "Did MTIOCLRERR\n");
1807 /* Typically on FreeBSD */
1811 /* Read and clear SCSI error status */
1812 union mterrstat mt_errstat;
1813 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1814 be.bstrerror(dev_errno));
1815 tape_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1819 /* Clear Subsystem Exception OSF1 */
1823 mt_com.mt_op = MTCSE;
1824 mt_com.mt_count = 1;
1825 /* Clear any error condition on the tape */
1826 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1827 Dmsg0(200, "Did MTCSE\n");
1834 * Clear volume header
1836 void DEVICE::clear_volhdr()
1838 Dmsg1(100, "Clear volhdr vol=%s\n", VolHdr.VolumeName);
1839 memset(&VolHdr, 0, sizeof(VolHdr));
1846 void DEVICE::close()
1848 Dmsg1(100, "close_dev %s\n", print_name());
1849 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1854 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1856 return; /* already closed */
1869 /* Clean up device packet so it can be reused */
1872 * Be careful not to clear items needed by the DVD driver
1873 * when it is closing a single part.
1875 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF|
1876 ST_MOUNTED|ST_MEDIA|ST_SHORT);
1877 label_type = B_BACULA_LABEL;
1878 file = block_num = 0;
1881 EndFile = EndBlock = 0;
1884 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1886 stop_thread_timer(tid);
1892 * This call closes the device, but it is used in DVD handling
1893 * where we close one part and then open the next part. The
1894 * difference between close_part() and close() is that close_part()
1895 * saves the state information of the device (e.g. the Volume lable,
1896 * the Volume Catalog record, ... This permits opening and closing
1897 * the Volume parts multiple times without losing track of what the
1898 * main Volume parameters are.
1900 void DEVICE::close_part(DCR * /*dcr*/)
1902 VOLUME_LABEL saveVolHdr;
1903 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1906 saveVolHdr = VolHdr; /* structure assignment */
1907 saveVolCatInfo = VolCatInfo; /* structure assignment */
1908 close(); /* close current part */
1909 VolHdr = saveVolHdr; /* structure assignment */
1910 VolCatInfo = saveVolCatInfo; /* structure assignment */
1913 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1917 return lseek_dvd(dcr, offset, whence);
1919 #if defined(HAVE_WIN32)
1920 return ::_lseeki64(m_fd, (__int64)offset, whence);
1922 return ::lseek(m_fd, (off_t)offset, whence);
1929 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1933 Dmsg1(100, "truncate %s\n", print_name());
1937 /* maybe we should rewind and write and eof ???? */
1938 return true; /* we don't really truncate tapes */
1940 return truncate_dvd(dcr);
1942 if (ftruncate(m_fd, 0) != 0) {
1944 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1945 print_name(), be.bstrerror());
1950 * Check for a successful ftruncate() and issue a work-around for devices
1951 * (mostly cheap NAS) that don't support truncation.
1952 * Workaround supplied by Martin Schmid as a solution to bug #1011.
1955 * 3. open new file with same mode
1956 * 4. change ownership to original
1959 if (fstat(m_fd, &st) != 0) {
1961 Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"),
1962 print_name(), be.bstrerror());
1966 if (st.st_size != 0) { /* ftruncate() didn't work */
1967 POOL_MEM archive_name(PM_FNAME);
1969 pm_strcpy(archive_name, dev_name);
1970 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
1971 pm_strcat(archive_name, "/");
1973 pm_strcat(archive_name, dcr->VolumeName);
1975 Mmsg2(errmsg, _("Device %s doesn't support ftruncate(). Recreating file %s.\n"),
1976 print_name(), archive_name.c_str());
1978 /* Close file and blow it away */
1980 ::unlink(archive_name.c_str());
1982 /* Recreate the file -- of course, empty */
1983 set_mode(CREATE_READ_WRITE);
1984 if ((m_fd = ::open(archive_name.c_str(), mode, st.st_mode)) < 0) {
1987 Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), archive_name.c_str(),
1989 Dmsg1(100, "reopen failed: %s", errmsg);
1990 Emsg0(M_FATAL, 0, errmsg);
1994 /* Reset proper owner */
1995 chown(archive_name.c_str(), st.st_uid, st.st_gid);
2003 /* Mount the device.
2004 * If timeout, wait until the mount command returns 0.
2005 * If !timeout, try to mount the device only once.
2007 bool DEVICE::mount(int timeout)
2009 Dmsg0(190, "Enter mount\n");
2012 } else if (requires_mount()) {
2013 return do_mount(1, timeout);
2018 /* Unmount the device
2019 * If timeout, wait until the unmount command returns 0.
2020 * If !timeout, try to unmount the device only once.
2022 bool DEVICE::unmount(int timeout)
2024 Dmsg0(100, "Enter unmount\n");
2026 return do_mount(0, timeout);
2031 /* (Un)mount the device */
2032 bool DEVICE::do_mount(int mount, int dotimeout)
2034 POOL_MEM ocmd(PM_FNAME);
2037 int status, timeout;
2042 Dmsg0(200, "======= mount=1\n");
2045 icmd = device->mount_command;
2047 if (!is_mounted()) {
2048 Dmsg0(200, "======= mount=0\n");
2051 icmd = device->unmount_command;
2054 clear_freespace_ok();
2055 edit_mount_codes(ocmd, icmd);
2057 Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2060 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
2065 results = get_memory(4000);
2067 /* If busy retry each second */
2068 Dmsg1(100, "do_mount run_prog=%s\n", ocmd.c_str());
2069 while ((status = run_program_full_output(ocmd.c_str(),
2070 max_open_wait/2, results)) != 0) {
2071 /* Doesn't work with internationalization (This is not a problem) */
2072 if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2075 if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2078 if (timeout-- > 0) {
2079 /* Sometimes the device cannot be mounted because it is already mounted.
2080 * Try to unmount it, then remount it */
2082 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2090 Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2091 (mount ? "" : "un"), status, results, be.bstrerror(status));
2092 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2093 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2095 Dmsg4(100, "Device %s cannot be %smounted. stat=%d ERR=%s\n", print_name(),
2096 (mount ? "" : "un"), status, results);
2097 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2098 print_name(), (mount ? "" : "un"), results);
2101 * Now, just to be sure it is not mounted, try to read the
2105 struct dirent *entry, *result;
2109 name_max = pathconf(".", _PC_NAME_MAX);
2110 if (name_max < 1024) {
2114 if (!(dp = opendir(device->mount_point))) {
2117 Dmsg3(100, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2118 device->mount_point, print_name(), be.bstrerror());
2122 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2125 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2127 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
2128 device->mount_point, print_name());
2131 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2132 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2135 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2141 Dmsg1(100, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2144 /* If we got more than ., .. and .keep */
2145 /* there must be something mounted */
2147 Dmsg1(100, "Did Mount by count=%d\n", count);
2150 /* An unmount request. We failed to unmount - report an error */
2152 free_pool_memory(results);
2153 Dmsg0(200, "== error mount=1 wanted unmount\n");
2159 free_pool_memory(results);
2160 Dmsg0(200, "============ mount=0\n");
2165 set_mounted(mount); /* set/clear mounted flag */
2166 free_pool_memory(results);
2167 /* Do not check free space when unmounting */
2168 if (mount && !update_freespace()) {
2171 Dmsg1(200, "============ mount=%d\n", mount);
2176 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2178 * %a = archive device name
2179 * %e = erase (set if cannot mount and first part)
2182 * %v = last part name
2184 * omsg = edited output message
2185 * imsg = input string containing edit codes (%x)
2188 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2194 POOL_MEM archive_name(PM_FNAME);
2196 omsg.c_str()[0] = 0;
2197 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2198 for (p=imsg; *p; p++) {
2208 if (num_dvd_parts == 0) {
2209 if (truncating || blank_dvd) {
2219 bsnprintf(add, sizeof(add), "%d", part);
2223 str = device->mount_point;
2226 make_spooled_dvd_filename(this, archive_name);
2227 str = archive_name.c_str();
2241 Dmsg1(1900, "add_str %s\n", str);
2242 pm_strcat(omsg, (char *)str);
2243 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2247 /* return the last timer interval (ms)
2248 * or 0 if something goes wrong
2250 btime_t DEVICE::get_timer_count()
2252 btime_t temp = last_timer;
2253 last_timer = get_current_btime();
2254 temp = last_timer - temp; /* get elapsed time */
2255 return (temp>0)?temp:0; /* take care of skewed clock */
2259 ssize_t DEVICE::read(void *buf, size_t len)
2265 if (this->is_tape()) {
2266 read_len = tape_read(m_fd, buf, len);
2268 read_len = ::read(m_fd, buf, len);
2271 last_tick = get_timer_count();
2273 DevReadTime += last_tick;
2274 VolCatInfo.VolReadTime += last_tick;
2276 if (read_len > 0) { /* skip error */
2277 DevReadBytes += read_len;
2284 ssize_t DEVICE::write(const void *buf, size_t len)
2290 if (this->is_tape()) {
2291 write_len = tape_write(m_fd, buf, len);
2293 write_len = ::write(m_fd, buf, len);
2296 last_tick = get_timer_count();
2298 DevWriteTime += last_tick;
2299 VolCatInfo.VolWriteTime += last_tick;
2301 if (write_len > 0) { /* skip error */
2302 DevWriteBytes += write_len;
2308 /* Return the resource name for the device */
2309 const char *DEVICE::name() const
2311 return device->hdr.name;
2314 /* Returns file position on tape or -1 */
2315 int32_t DEVICE::get_os_tape_file()
2317 struct mtget mt_stat;
2319 if (has_cap(CAP_MTIOCGET) &&
2320 tape_ioctl(m_fd, MTIOCGET, (char *)&mt_stat) == 0) {
2321 return mt_stat.mt_fileno;
2327 dev_vol_name(DEVICE *dev)
2329 return dev->VolCatInfo.VolCatName;
2334 * Free memory allocated for the device
2336 void DEVICE::term(void)
2338 Dmsg1(900, "term dev: %s\n", print_name());
2341 free_memory(dev_name);
2345 free_memory(prt_name);
2349 free_pool_memory(errmsg);
2352 pthread_mutex_destroy(&m_mutex);
2353 pthread_cond_destroy(&wait);
2354 pthread_cond_destroy(&wait_next_vol);
2355 pthread_mutex_destroy(&spool_mutex);
2356 // rwl_destroy(&lock);
2357 if (attached_dcrs) {
2358 delete attached_dcrs;
2359 attached_dcrs = NULL;
2368 * This routine initializes the device wait timers
2370 void init_device_wait_timers(DCR *dcr)
2372 DEVICE *dev = dcr->dev;
2373 JCR *jcr = dcr->jcr;
2375 /* ******FIXME******* put these on config variables */
2376 dev->min_wait = 60 * 60;
2377 dev->max_wait = 24 * 60 * 60;
2378 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2379 dev->wait_sec = dev->min_wait;
2380 dev->rem_wait_sec = dev->wait_sec;
2383 dev->BadVolName[0] = 0;
2385 jcr->min_wait = 60 * 60;
2386 jcr->max_wait = 24 * 60 * 60;
2387 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2388 jcr->wait_sec = jcr->min_wait;
2389 jcr->rem_wait_sec = jcr->wait_sec;
2394 void init_jcr_device_wait_timers(JCR *jcr)
2396 /* ******FIXME******* put these on config variables */
2397 jcr->min_wait = 60 * 60;
2398 jcr->max_wait = 24 * 60 * 60;
2399 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2400 jcr->wait_sec = jcr->min_wait;
2401 jcr->rem_wait_sec = jcr->wait_sec;
2407 * The dev timers are used for waiting on a particular device
2409 * Returns: true if time doubled
2410 * false if max time expired
2412 bool double_dev_wait_time(DEVICE *dev)
2414 dev->wait_sec *= 2; /* double wait time */
2415 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2416 dev->wait_sec = dev->max_wait;
2419 dev->rem_wait_sec = dev->wait_sec;
2420 if (dev->num_wait >= dev->max_num_wait) {
2427 void set_os_device_parameters(DCR *dcr)
2429 DEVICE *dev = dcr->dev;
2431 if (strcmp(dev->dev_name, "/dev/null") == 0) {
2432 return; /* no use trying to set /dev/null */
2435 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2438 Dmsg0(100, "In set_os_device_parameters\n");
2439 #if defined(MTSETBLK)
2440 if (dev->min_block_size == dev->max_block_size &&
2441 dev->min_block_size == 0) { /* variable block mode */
2442 mt_com.mt_op = MTSETBLK;
2443 mt_com.mt_count = 0;
2444 Dmsg0(100, "Set block size to zero\n");
2445 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2446 dev->clrerror(MTSETBLK);
2450 #if defined(MTSETDRVBUFFER)
2451 if (getuid() == 0) { /* Only root can do this */
2452 mt_com.mt_op = MTSETDRVBUFFER;
2453 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2454 if (!dev->has_cap(CAP_TWOEOF)) {
2455 mt_com.mt_count |= MT_ST_TWO_FM;
2457 if (dev->has_cap(CAP_EOM)) {
2458 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2460 Dmsg0(100, "MTSETDRVBUFFER\n");
2461 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2462 dev->clrerror(MTSETDRVBUFFER);
2469 #ifdef HAVE_NETBSD_OS
2471 if (dev->min_block_size == dev->max_block_size &&
2472 dev->min_block_size == 0) { /* variable block mode */
2473 mt_com.mt_op = MTSETBSIZ;
2474 mt_com.mt_count = 0;
2475 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2476 dev->clrerror(MTSETBSIZ);
2478 /* Get notified at logical end of tape */
2479 mt_com.mt_op = MTEWARN;
2480 mt_com.mt_count = 1;
2481 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2482 dev->clrerror(MTEWARN);
2488 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2490 if (dev->min_block_size == dev->max_block_size &&
2491 dev->min_block_size == 0) { /* variable block mode */
2492 mt_com.mt_op = MTSETBSIZ;
2493 mt_com.mt_count = 0;
2494 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2495 dev->clrerror(MTSETBSIZ);
2498 #if defined(MTIOCSETEOTMODEL)
2500 if (dev->has_cap(CAP_TWOEOF)) {
2505 if (tape_ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2507 dev->dev_errno = errno; /* save errno */
2508 Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2509 dev->print_name(), be.bstrerror(dev->dev_errno));
2510 Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2518 if (dev->min_block_size == dev->max_block_size &&
2519 dev->min_block_size == 0) { /* variable block mode */
2520 mt_com.mt_op = MTSRSZ;
2521 mt_com.mt_count = 0;
2522 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2523 dev->clrerror(MTSRSZ);
2530 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2532 Dmsg0(100, "dev_get_os_pos\n");
2533 return dev->has_cap(CAP_MTIOCGET) &&
2534 tape_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2535 mt_stat->mt_fileno >= 0;
2538 static const char *modes[] = {
2539 "CREATE_READ_WRITE",
2546 static const char *mode_to_str(int mode)
2548 static char buf[100];
2549 if (mode < 1 || mode > 4) {
2550 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2553 return modes[mode-1];