2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2007 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 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)
114 /* If no device type specified, try to guess */
115 if (!device->dev_type) {
116 /* Check that device is available */
117 if (stat(device->device_name, &statp) < 0) {
119 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
120 device->device_name, be.bstrerror());
123 if (S_ISDIR(statp.st_mode)) {
124 device->dev_type = B_FILE_DEV;
125 } else if (S_ISCHR(statp.st_mode)) {
126 device->dev_type = B_TAPE_DEV;
127 } else if (S_ISFIFO(statp.st_mode)) {
128 device->dev_type = B_FIFO_DEV;
129 } else if (!(device->cap_bits & CAP_REQMOUNT)) {
130 Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
131 " or have RequiresMount=yes for DVD. st_mode=%x\n"),
132 device->device_name, statp.st_mode);
135 device->dev_type = B_DVD_DEV;
139 dev = (DEVICE *)malloc(sizeof(DEVICE));
140 memset(dev, 0, sizeof(DEVICE));
141 dev->Slot = -1; /* unknown */
143 /* Copy user supplied device parameters from Resource */
144 dev->dev_name = get_memory(strlen(device->device_name)+1);
145 pm_strcpy(dev->dev_name, device->device_name);
146 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
147 /* We edit "Resource-name" (physical-name) */
148 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
149 Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
150 dev->capabilities = device->cap_bits;
151 dev->min_block_size = device->min_block_size;
152 dev->max_block_size = device->max_block_size;
153 dev->max_volume_size = device->max_volume_size;
154 dev->max_file_size = device->max_file_size;
155 dev->volume_capacity = device->volume_capacity;
156 dev->max_rewind_wait = device->max_rewind_wait;
157 dev->max_open_wait = device->max_open_wait;
158 dev->max_open_vols = device->max_open_vols;
159 dev->vol_poll_interval = device->vol_poll_interval;
160 dev->max_spool_size = device->max_spool_size;
161 dev->drive_index = device->drive_index;
162 dev->autoselect = device->autoselect;
163 dev->dev_type = device->dev_type;
164 if (dev->is_tape()) { /* No parts on tapes */
165 dev->max_part_size = 0;
167 dev->max_part_size = device->max_part_size;
170 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
171 dev->vol_poll_interval = 60;
173 /* Link the dev and device structures together */
174 dev->device = device;
177 if (dev->is_fifo()) {
178 dev->capabilities |= CAP_STREAM; /* set stream device */
181 /* If the device requires mount :
182 * - Check that the mount point is available
183 * - Check that (un)mount commands are defined
185 if ((dev->is_file() || dev->is_dvd()) && dev->requires_mount()) {
186 if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
188 dev->dev_errno = errno;
189 Jmsg2(jcr, M_ERROR_TERM, 0, _("Unable to stat mount point %s: ERR=%s\n"),
190 device->mount_point, be.bstrerror());
194 if (!device->mount_command || !device->unmount_command) {
195 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
197 if (!device->write_part_command) {
198 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
202 if (dev->max_block_size > 1000000) {
203 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
204 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
205 dev->max_block_size = 0;
207 if (dev->max_block_size % TAPE_BSIZE != 0) {
208 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
209 dev->max_block_size, dev->print_name());
212 dev->errmsg = get_pool_memory(PM_EMSG);
215 if ((errstat = pthread_mutex_init(&dev->m_mutex, NULL)) != 0) {
217 dev->dev_errno = errstat;
218 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
219 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
221 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
223 dev->dev_errno = errstat;
224 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
225 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
227 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
229 dev->dev_errno = errstat;
230 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
231 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
233 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
235 dev->dev_errno = errstat;
236 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
237 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
240 if ((errstat = rwl_init(&dev->lock)) != 0) {
242 dev->dev_errno = errstat;
243 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
244 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
249 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
250 Dmsg2(100, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
251 dev->initiated = true;
257 * Open the device with the operating system and
258 * initialize buffer pointers.
260 * Returns: -1 on error
263 * Note, for a tape, the VolName is the name we give to the
264 * volume (not really used here), but for a file, the
265 * VolName represents the name of the file to be created/opened.
266 * In the case of a file, the full name is the device name
267 * (archive_name) with the VolName concatenated.
270 DEVICE::open(DCR *dcr, int omode)
274 if (openmode == omode) {
283 Dmsg0(100, "Close fd for mode change.\n");
284 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
288 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
291 Dmsg4(100, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
292 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
293 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
294 Slot = -1; /* unknown slot */
295 label_type = B_BACULA_LABEL;
296 if (is_tape() || is_fifo()) {
297 open_tape_device(dcr, omode);
298 } else if (is_dvd()) {
299 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
300 open_dvd_device(dcr, omode);
302 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
303 open_file_device(dcr, omode);
305 state |= preserve; /* reset any important state info */
306 Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, m_fd);
310 void DEVICE::set_mode(int new_mode)
313 case CREATE_READ_WRITE:
314 mode = O_CREAT | O_RDWR | O_BINARY;
316 case OPEN_READ_WRITE:
317 mode = O_RDWR | O_BINARY;
320 mode = O_RDONLY | O_BINARY;
322 case OPEN_WRITE_ONLY:
323 mode = O_WRONLY | O_BINARY;
326 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
332 void DEVICE::open_tape_device(DCR *dcr, int omode)
335 int timeout = max_open_wait;
336 #if !defined(HAVE_WIN32)
338 utime_t start_time = time(NULL);
342 Dmsg0(100, "Open dev: device is tape\n");
344 get_autochanger_loaded_slot(dcr);
353 if (is_fifo() && timeout) {
355 tid = start_thread_timer(pthread_self(), timeout);
357 Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
358 #if defined(HAVE_WIN32)
361 if ((m_fd = tape_open(dev_name, mode)) < 0) {
368 /* If busy retry each second for max_open_wait seconds */
370 /* Try non-blocking open */
371 m_fd = ::open(dev_name, mode+O_NONBLOCK);
375 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
376 print_name(), omode, mode, errno, be.bstrerror());
378 /* Tape open, now rewind it */
379 Dmsg0(100, "Rewind after open\n");
380 mt_com.mt_op = MTREW;
382 /* rewind only if dev is a tape */
383 if (is_tape() && (ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0)) {
385 dev_errno = errno; /* set error status from rewind */
388 Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
389 be.bstrerror(dev_errno));
390 /* If we get busy, device is probably rewinding, try again */
391 if (dev_errno != EBUSY) {
392 break; /* error -- no medium */
395 /* Got fd and rewind worked, so we must have medium in drive */
397 m_fd = ::open(dev_name, mode); /* open normally */
401 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
402 print_name(), omode, mode, errno, be.bstrerror());
407 set_os_device_parameters(dcr); /* do system dependent stuff */
408 break; /* Successfully opened and rewound */
412 /* Exceed wait time ? */
413 if (time(NULL) - start_time >= max_open_wait) {
414 break; /* yes, get out */
421 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
422 print_name(), be.bstrerror(dev_errno));
423 Dmsg1(100, "%s", errmsg);
426 /* Stop any open() timer we started */
428 stop_thread_timer(tid);
431 Dmsg1(100, "open dev: tape %d opened\n", m_fd);
438 void DEVICE::open_file_device(DCR *dcr, int omode)
440 POOL_MEM archive_name(PM_FNAME);
442 get_autochanger_loaded_slot(dcr);
445 * Handle opening of File Archive (not a tape)
448 pm_strcpy(archive_name, dev_name);
450 * If this is a virtual autochanger (i.e. changer_res != NULL)
451 * we simply use the device name, assuming it has been
452 * appropriately setup by the "autochanger".
454 if (!device->changer_res || device->changer_command[0] == 0) {
455 if (VolCatInfo.VolCatName[0] == 0) {
456 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
462 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
463 pm_strcat(archive_name, "/");
465 pm_strcat(archive_name, VolCatInfo.VolCatName);
468 mount(1); /* do mount if required */
472 /* If creating file, give 0640 permissions */
473 Dmsg3(100, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
474 archive_name.c_str(), mode);
475 /* Use system open() */
476 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
479 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
481 Dmsg1(100, "open failed: %s", errmsg);
482 Emsg0(M_FATAL, 0, errmsg);
488 Dmsg4(100, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
489 m_fd, part, num_dvd_parts, part_size);
493 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
494 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
495 * has the desired Volume name, but there is NO assurance that
496 * any other field of VolCatInfo is correct.
498 void DEVICE::open_dvd_device(DCR *dcr, int omode)
500 POOL_MEM archive_name(PM_FNAME);
501 struct stat filestat;
504 * Handle opening of DVD Volume
506 Dmsg2(100, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n",
507 &dcr->VolCatInfo, mode_to_str(omode));
510 * For a DVD we must always pull the state info from dcr->VolCatInfo
511 * This is a bit ugly, but is necessary because we need to open/close/re-open
512 * the dvd file in order to properly mount/unmount and access the
513 * DVD. So we store the state of the DVD as far as is known in the
514 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
515 * copy here, when opening.
517 VolCatInfo = dcr->VolCatInfo; /* structure assignment */
518 Dmsg1(100, "Volume=%s\n", VolCatInfo.VolCatName);
520 if (VolCatInfo.VolCatName[0] == 0) {
521 Dmsg1(10, "Could not open DVD device %s. No Volume name given.\n",
523 Mmsg(errmsg, _("Could not open DVD device %s. No Volume name given.\n"),
530 Dmsg0(100, "Set part=1\n");
531 part = 1; /* count from 1 */
535 if (num_dvd_parts != VolCatInfo.VolCatParts) {
536 num_dvd_parts = VolCatInfo.VolCatParts;
540 * If we are not trying to access the last part, set mode to
541 * OPEN_READ_ONLY as writing would be an error.
543 Dmsg2(100, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
544 /* Now find the name of the part that we want to access */
545 if (part <= num_dvd_parts) {
546 omode = OPEN_READ_ONLY;
547 make_mounted_dvd_filename(this, archive_name);
548 set_part_spooled(false);
550 omode = OPEN_READ_WRITE;
551 make_spooled_dvd_filename(this, archive_name);
552 set_part_spooled(true);
556 // Clear any previous blank_dvd status - we will recalculate it here
559 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
560 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
563 Dmsg0(99, "DVD device mounted.\n");
564 if (num_dvd_parts == 0 && !truncating) {
566 * If we can mount the device, and we are not truncating the DVD,
567 * we usually want to abort. There is one exception, if there is
568 * only one 0-sized file on the DVD, with the right volume name,
569 * we continue (it's the method used by truncate_dvd to truncate a volume).
571 if (!check_can_write_on_non_blank_dvd(dcr)) {
572 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
573 Emsg0(M_FATAL, 0, errmsg);
574 unmount(1); /* Unmount the device, so the operator can change it. */
581 * Ensure that we have the correct DVD loaded by looking for part1.
582 * We only succeed the open if it exists. Failure to do this could
583 * leave us trying to add a part to a different DVD!
585 uint32_t oldpart = part;
587 POOL_MEM part1_name(PM_FNAME);
589 make_mounted_dvd_filename(this, part1_name);
591 if (stat(part1_name.c_str(), &statp) < 0) {
593 Mmsg(errmsg, _("Unable to stat DVD part 1 file %s: ERR=%s\n"),
594 part1_name.c_str(), be.bstrerror());
595 Emsg0(M_FATAL, 0, errmsg);
599 if (!S_ISREG(statp.st_mode)) {
600 /* It is not a regular file */
601 Mmsg(errmsg, _("DVD part 1 is not a regular file %s.\n"),
603 Emsg0(M_FATAL, 0, errmsg);
609 Dmsg0(99, "DVD device mount failed.\n");
610 /* We cannot mount the device */
611 if (num_dvd_parts == 0) {
612 /* Run free space, check there is a media. */
613 if (!update_freespace()) {
614 Emsg0(M_FATAL, 0, errmsg);
619 Dmsg1(100, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
621 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
622 Emsg0(M_FATAL, 0, errmsg);
627 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
628 Emsg0(M_FATAL, 0, errmsg);
634 Dmsg5(100, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
635 archive_name.c_str(), mode_to_str(omode),
636 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
638 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
641 /* If creating file, give 0640 permissions */
642 Dmsg3(100, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
643 archive_name.c_str(), mode);
644 /* Use system open() */
645 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
647 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
649 // Should this be set if we try the create/open below
650 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
651 Dmsg1(100, "open failed: %s", errmsg);
653 /* Previous open failed. See if we can recover */
654 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
655 (part > num_dvd_parts)) {
656 /* If the last part (on spool), doesn't exist when accessing,
657 * create it. In read/write mode a write will be allowed (higher
658 * level software thinks that we are extending a pre-existing
659 * media. Reads for READ_ONLY will report immediately an EOF
660 * Sometimes it is better to finish with an EOF than with an error. */
661 Dmsg1(100, "Creating last part on spool: %s\n", archive_name.c_str());
662 omode = CREATE_READ_WRITE;
663 set_mode(CREATE_READ_WRITE);
664 m_fd = ::open(archive_name.c_str(), mode, 0640);
668 Dmsg1(100, "after open fd=%d\n", m_fd);
670 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
673 /* Get size of file */
674 if (fstat(m_fd, &filestat) < 0) {
677 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
679 Dmsg1(100, "open failed: %s", errmsg);
680 /* Use system close() */
684 part_size = filestat.st_size;
686 update_pos(dcr); /* update position */
694 * Returns: true on success
697 bool DEVICE::rewind(DCR *dcr)
703 Dmsg3(400, "rewind res=%d fd=%d %s\n", reserved_device, m_fd, print_name());
704 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
705 block_num = file = 0;
709 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
711 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
713 Emsg0(M_ABORT, 0, errmsg);
718 mt_com.mt_op = MTREW;
720 /* If we get an I/O error on rewind, it is probably because
721 * the drive is actually busy. We loop for (about 5 minutes)
722 * retrying every 5 seconds.
724 for (i=max_rewind_wait; ; i -= 5) {
725 if (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
728 if (i == max_rewind_wait) {
729 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.bstrerror());
732 * This is a gross hack, because if the user has the
733 * device mounted (i.e. open), then uses mtx to load
734 * a tape, the current open file descriptor is invalid.
735 * So, we close the drive and re-open it.
738 int open_mode = openmode;
741 open(dcr, open_mode);
749 if (dev_errno == EIO) {
750 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
754 if (dev_errno == EIO && i > 0) {
755 Dmsg0(200, "Sleeping 5 seconds.\n");
760 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
761 print_name(), be.bstrerror());
766 } else if (is_file() || is_dvd()) {
767 if (lseek(dcr, (boffset_t)0, SEEK_SET) < 0) {
770 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
771 print_name(), be.bstrerror());
780 * Called to indicate that we have just read an
781 * EOF from the device.
783 void DEVICE::set_ateof()
795 * Called to indicate we are now at the end of the tape, and
796 * writing is not possible.
798 void DEVICE::set_ateot()
800 /* Make tape effectively read-only */
801 state |= (ST_EOF|ST_EOT|ST_WEOT);
806 * Position device to end of medium (end of data)
807 * Returns: true on succes
810 bool DEVICE::eod(DCR *dcr)
819 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
823 #if defined (__digital__) && defined (__unix__)
824 return fsf(VolCatInfo.VolCatFiles);
831 clear_eof(); /* remove EOF flag */
832 block_num = file = 0;
835 if (is_fifo() || is_prog()) {
839 pos = lseek(dcr, (boffset_t)0, SEEK_END);
840 // Dmsg1(100, "====== Seek to %lld\n", pos);
848 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
849 print_name(), be.bstrerror());
853 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
854 Dmsg0(100,"Using FAST FSF for EOM\n");
855 /* If unknown position, rewind */
856 if (get_os_tape_file() < 0) {
861 mt_com.mt_op = MTFSF;
863 * ***FIXME*** fix code to handle case that INT16_MAX is
866 mt_com.mt_count = INT16_MAX; /* use big positive number */
867 if (mt_com.mt_count < 0) {
868 mt_com.mt_count = INT16_MAX; /* brain damaged system */
872 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
873 if (has_cap(CAP_EOM)) {
874 Dmsg0(100,"Using EOM for EOM\n");
875 mt_com.mt_op = MTEOM;
879 if (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
881 clrerror(mt_com.mt_op);
882 Dmsg1(50, "ioctl error: %s\n", be.bstrerror());
884 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
885 print_name(), be.bstrerror());
889 os_file = get_os_tape_file();
893 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
894 print_name(), be.bstrerror());
897 Dmsg1(100, "EOD file=%d\n", os_file);
905 * Rewind then use FSF until EOT reached
911 * Move file by file to the end of the tape
914 for (file_num=file; !at_eot(); file_num++) {
915 Dmsg0(200, "eod: doing fsf 1\n");
917 Dmsg0(200, "fsf error.\n");
921 * Avoid infinite loop by ensuring we advance.
923 if (!at_eot() && file_num == (int)file) {
924 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
926 os_file = get_os_tape_file();
928 Dmsg2(100, "Adjust file from %d to %d\n", file_num, os_file);
936 * Some drivers leave us after second EOF when doing
937 * MTEOM, so we must backup so that appending overwrites
940 if (has_cap(CAP_BSFATEOM)) {
941 /* Backup over EOF */
943 /* If BSF worked and fileno is known (not -1), set file */
944 os_file = get_os_tape_file();
946 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , os_file);
949 file++; /* wing it -- not correct on all OSes */
952 update_pos(dcr); /* update position */
954 Dmsg1(200, "EOD dev->file=%d\n", file);
959 * Set the position of the device -- only for files and DVD
960 * For other devices, there is no generic way to do it.
961 * Returns: true on succes
964 bool DEVICE::update_pos(DCR *dcr)
971 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
972 Emsg1(M_FATAL, 0, "%s", errmsg);
976 /* Find out where we are */
977 if (is_file() || is_dvd()) {
980 pos = lseek(dcr, (boffset_t)0, SEEK_CUR);
984 Pmsg1(000, _("Seek error: ERR=%s\n"), be.bstrerror());
985 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
986 print_name(), be.bstrerror());
990 block_num = (uint32_t)pos;
991 file = (uint32_t)(pos >> 32);
998 * Return the status of the device. This was meant
999 * to be a generic routine. Unfortunately, it doesn't
1000 * seem possible (at least I do not know how to do it
1001 * currently), which means that for the moment, this
1002 * routine has very little value.
1006 uint32_t status_dev(DEVICE *dev)
1008 struct mtget mt_stat;
1011 if (dev->state & (ST_EOT | ST_WEOT)) {
1015 if (dev->state & ST_EOF) {
1019 if (dev->is_tape()) {
1021 Pmsg0(-20,_(" Bacula status:"));
1022 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1023 if (tape_ioctl(dev->fd(), MTIOCGET, (char *)&mt_stat) < 0) {
1025 dev->dev_errno = errno;
1026 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1027 dev->print_name(), be.bstrerror());
1030 Pmsg0(-20, _(" Device status:"));
1032 #if defined(HAVE_LINUX_OS)
1033 if (GMT_EOF(mt_stat.mt_gstat)) {
1037 if (GMT_BOT(mt_stat.mt_gstat)) {
1041 if (GMT_EOT(mt_stat.mt_gstat)) {
1045 if (GMT_SM(mt_stat.mt_gstat)) {
1049 if (GMT_EOD(mt_stat.mt_gstat)) {
1053 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1054 stat |= BMT_WR_PROT;
1055 Pmsg0(-20, " WR_PROT");
1057 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1059 Pmsg0(-20, " ONLINE");
1061 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1062 stat |= BMT_DR_OPEN;
1063 Pmsg0(-20, " DR_OPEN");
1065 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1066 stat |= BMT_IM_REP_EN;
1067 Pmsg0(-20, " IM_REP_EN");
1069 #elif defined(HAVE_WIN32)
1070 if (GMT_EOF(mt_stat.mt_gstat)) {
1074 if (GMT_BOT(mt_stat.mt_gstat)) {
1078 if (GMT_EOT(mt_stat.mt_gstat)) {
1082 if (GMT_EOD(mt_stat.mt_gstat)) {
1086 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1087 stat |= BMT_WR_PROT;
1088 Pmsg0(-20, " WR_PROT");
1090 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1092 Pmsg0(-20, " ONLINE");
1094 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1095 stat |= BMT_DR_OPEN;
1096 Pmsg0(-20, " DR_OPEN");
1098 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1099 stat |= BMT_IM_REP_EN;
1100 Pmsg0(-20, " IM_REP_EN");
1103 #endif /* !SunOS && !OSF */
1104 if (dev->has_cap(CAP_MTIOCGET)) {
1105 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1107 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1110 stat |= BMT_ONLINE | BMT_BOT;
1117 * Load medium in device
1118 * Returns: true on success
1121 bool load_dev(DEVICE *dev)
1127 if (dev->fd() < 0) {
1128 dev->dev_errno = EBADF;
1129 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1130 Emsg0(M_FATAL, 0, dev->errmsg);
1133 if (!(dev->is_tape())) {
1137 Dmsg0(200, "stored: MTLOAD command not available\n");
1139 dev->dev_errno = ENOTTY; /* function not available */
1140 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1141 dev->print_name(), be.bstrerror());
1145 dev->block_num = dev->file = 0;
1148 mt_com.mt_op = MTLOAD;
1149 mt_com.mt_count = 1;
1150 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
1152 dev->dev_errno = errno;
1153 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1154 dev->print_name(), be.bstrerror());
1162 * Rewind device and put it offline
1163 * Returns: true on success
1166 bool DEVICE::offline()
1171 return true; /* device not open */
1174 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1175 block_num = file = 0;
1179 mt_com.mt_op = MTOFFL;
1180 mt_com.mt_count = 1;
1181 if (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
1184 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1185 print_name(), be.bstrerror());
1188 Dmsg1(100, "Offlined device %s\n", print_name());
1192 bool DEVICE::offline_or_rewind()
1197 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1201 * Note, this rewind probably should not be here (it wasn't
1202 * in prior versions of Bacula), but on FreeBSD, this is
1203 * needed in the case the tape was "frozen" due to an error
1204 * such as backspacing after writing and EOF. If it is not
1205 * done, all future references to the drive get and I/O error.
1208 return rewind(NULL);
1213 * Foward space a file
1214 * Returns: true on success
1217 bool DEVICE::fsf(int num)
1219 int32_t os_file = 0;
1225 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1226 Emsg0(M_FATAL, 0, errmsg);
1236 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1240 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1243 Dmsg0(100, "fsf\n");
1246 * If Fast forward space file is set, then we
1247 * use MTFSF to forward space and MTIOCGET
1248 * to get the file position. We assume that
1249 * the SCSI driver will ensure that we do not
1250 * forward space past the end of the medium.
1252 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1254 mt_com.mt_op = MTFSF;
1255 mt_com.mt_count = num;
1256 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1258 my_errno = errno; /* save errno */
1259 } else if ((os_file=get_os_tape_file()) < 0) {
1260 my_errno = errno; /* save errno */
1262 if (my_errno != 0) {
1265 Dmsg0(200, "Set ST_EOT\n");
1267 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1268 print_name(), be.bstrerror(my_errno));
1269 Dmsg1(200, "%s", errmsg);
1273 Dmsg1(200, "fsf file=%d\n", os_file);
1279 * Here if CAP_FSF is set, and virtually all drives
1280 * these days support it, we read a record, then forward
1281 * space one file. Using this procedure, which is slow,
1282 * is the only way we can be sure that we don't read
1283 * two consecutive EOF marks, which means End of Data.
1285 } else if (has_cap(CAP_FSF)) {
1288 Dmsg0(200, "FSF has cap_fsf\n");
1289 if (max_block_size == 0) {
1290 rbuf_len = DEFAULT_BLOCK_SIZE;
1292 rbuf_len = max_block_size;
1294 rbuf = get_memory(rbuf_len);
1295 mt_com.mt_op = MTFSF;
1296 mt_com.mt_count = 1;
1297 while (num-- && !at_eot()) {
1298 Dmsg0(100, "Doing read before fsf\n");
1299 if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1300 if (errno == ENOMEM) { /* tape record exceeds buf len */
1301 stat = rbuf_len; /* This is OK */
1303 * On IBM drives, they return ENOSPC at EOM
1304 * instead of EOF status
1306 } else if (at_eof() && errno == ENOSPC) {
1312 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1314 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1315 print_name(), be.bstrerror());
1316 Dmsg1(100, "%s", errmsg);
1320 if (stat == 0) { /* EOF */
1321 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1322 /* Two reads of zero means end of tape */
1325 Dmsg0(100, "Set ST_EOT\n");
1331 } else { /* Got data */
1336 Dmsg0(100, "Doing MTFSF\n");
1337 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1338 if (stat < 0) { /* error => EOT */
1341 Dmsg0(100, "Set ST_EOT\n");
1343 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1344 print_name(), be.bstrerror());
1345 Dmsg0(100, "Got < 0 for MTFSF\n");
1346 Dmsg1(100, "%s", errmsg);
1354 * No FSF, so use FSR to simulate it
1357 Dmsg0(200, "Doing FSR for FSF\n");
1358 while (num-- && !at_eot()) {
1359 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1363 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1369 Dmsg1(200, "Return %d from FSF\n", stat);
1371 Dmsg0(200, "ST_EOF set on exit FSF\n");
1374 Dmsg0(200, "ST_EOT set on exit FSF\n");
1376 Dmsg1(200, "Return from FSF file=%d\n", file);
1381 * Backward space a file
1382 * Returns: false on failure
1385 bool DEVICE::bsf(int num)
1392 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1393 Emsg0(M_FATAL, 0, errmsg);
1398 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1403 Dmsg0(100, "bsf\n");
1409 mt_com.mt_op = MTBSF;
1410 mt_com.mt_count = num;
1411 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1415 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1416 print_name(), be.bstrerror());
1423 * Foward space num records
1424 * Returns: false on failure
1427 bool DEVICE::fsr(int num)
1434 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1435 Emsg0(M_FATAL, 0, errmsg);
1443 if (!has_cap(CAP_FSR)) {
1444 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1448 Dmsg1(100, "fsr %d\n", num);
1449 mt_com.mt_op = MTFSR;
1450 mt_com.mt_count = num;
1451 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1457 struct mtget mt_stat;
1459 Dmsg1(100, "FSF fail: ERR=%s\n", be.bstrerror());
1460 if (dev_get_os_pos(this, &mt_stat)) {
1461 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1462 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1463 file = mt_stat.mt_fileno;
1464 block_num = mt_stat.mt_blkno;
1472 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1473 num, print_name(), be.bstrerror());
1479 * Backward space a record
1480 * Returns: false on failure
1483 bool DEVICE::bsr(int num)
1490 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1491 Emsg0(M_FATAL, 0, errmsg);
1499 if (!has_cap(CAP_BSR)) {
1500 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1504 Dmsg0(100, "bsr_dev\n");
1508 mt_com.mt_op = MTBSR;
1509 mt_com.mt_count = num;
1510 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1514 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1515 print_name(), be.bstrerror());
1520 void DEVICE::lock_door()
1524 mt_com.mt_op = MTLOCK;
1525 mt_com.mt_count = 1;
1526 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1530 void DEVICE::unlock_door()
1534 mt_com.mt_op = MTUNLOCK;
1535 mt_com.mt_count = 1;
1536 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1542 * Reposition the device to file, block
1543 * Returns: false on failure
1546 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1550 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1551 Emsg0(M_FATAL, 0, errmsg);
1556 boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1557 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1558 if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1561 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1562 print_name(), be.bstrerror());
1571 /* After this point, we are tape only */
1572 Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1574 Dmsg0(100, "Rewind\n");
1575 if (!rewind(NULL)) {
1580 Dmsg1(100, "fsf %d\n", rfile-file);
1581 if (!fsf(rfile-file)) {
1582 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1585 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1587 if (rblock < block_num) {
1588 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1589 Dmsg0(100, "bsf 1\n");
1591 Dmsg0(100, "fsf 1\n");
1593 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1595 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1596 /* Ignore errors as Bacula can read to the correct block */
1597 Dmsg1(100, "fsr %d\n", rblock-block_num);
1598 return fsr(rblock-block_num);
1600 while (rblock > block_num) {
1601 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1604 Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1605 print_name(), be.bstrerror());
1608 Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1617 * Write an end of file on the device
1618 * Returns: true on success
1621 bool DEVICE::weof(int num)
1625 Dmsg0(129, "weof_dev\n");
1629 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1630 Emsg0(M_FATAL, 0, errmsg);
1638 if (!can_append()) {
1639 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1640 Emsg0(M_FATAL, 0, errmsg);
1646 mt_com.mt_op = MTWEOF;
1647 mt_com.mt_count = num;
1648 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1657 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1658 print_name(), be.bstrerror());
1666 * If implemented in system, clear the tape
1669 void DEVICE::clrerror(int func)
1671 const char *msg = NULL;
1674 dev_errno = errno; /* save errno */
1676 VolCatInfo.VolCatErrors++;
1683 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1686 break; /* ignore message printed later */
1689 clear_cap(CAP_EOF); /* turn off feature */
1694 clear_cap(CAP_EOM); /* turn off feature */
1699 clear_cap(CAP_FSF); /* turn off feature */
1703 clear_cap(CAP_BSF); /* turn off feature */
1707 clear_cap(CAP_FSR); /* turn off feature */
1711 clear_cap(CAP_BSR); /* turn off feature */
1721 #ifdef MTSETDRVBUFFER
1722 case MTSETDRVBUFFER:
1723 msg = "MTSETDRVBUFFER";
1756 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1762 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1763 Emsg0(M_ERROR, 0, errmsg);
1768 * Now we try different methods of clearing the error
1769 * status on the drive so that it is not locked for
1770 * further operations.
1773 /* On some systems such as NetBSD, this clears all errors */
1776 /* Found on Solaris */
1779 tape_ioctl(m_fd, MTIOCLRERR);
1780 Dmsg0(200, "Did MTIOCLRERR\n");
1784 /* Typically on FreeBSD */
1788 /* Read and clear SCSI error status */
1789 union mterrstat mt_errstat;
1790 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1791 be.bstrerror(dev_errno));
1792 tape_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1796 /* Clear Subsystem Exception OSF1 */
1800 mt_com.mt_op = MTCSE;
1801 mt_com.mt_count = 1;
1802 /* Clear any error condition on the tape */
1803 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1804 Dmsg0(200, "Did MTCSE\n");
1811 * Clear volume header
1813 void DEVICE::clear_volhdr()
1815 Dmsg1(100, "Clear volhdr vol=%s\n", VolHdr.VolumeName);
1816 memset(&VolHdr, 0, sizeof(VolHdr));
1823 void DEVICE::close()
1825 Dmsg1(100, "close_dev %s\n", print_name());
1826 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1831 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1833 return; /* already closed */
1845 /* Clean up device packet so it can be reused */
1847 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1848 label_type = B_BACULA_LABEL;
1849 file = block_num = 0;
1852 EndFile = EndBlock = 0;
1854 Slot = -1; /* unknown slot */
1856 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1858 stop_thread_timer(tid);
1864 * This call closes the device, but it is used in DVD handling
1865 * where we close one part and then open the next part. The
1866 * difference between close_part() and close() is that close_part()
1867 * saves the state information of the device (e.g. the Volume lable,
1868 * the Volume Catalog record, ... This permits opening and closing
1869 * the Volume parts multiple times without losing track of what the
1870 * main Volume parameters are.
1872 void DEVICE::close_part(DCR *dcr)
1874 VOLUME_LABEL saveVolHdr;
1875 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1878 saveVolHdr = VolHdr; /* structure assignment */
1879 saveVolCatInfo = VolCatInfo; /* structure assignment */
1880 close(); /* close current part */
1881 VolHdr = saveVolHdr; /* structure assignment */
1882 VolCatInfo = saveVolCatInfo; /* structure assignment */
1883 dcr->VolCatInfo = saveVolCatInfo; /* structure assignment */
1886 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1890 return lseek_dvd(dcr, offset, whence);
1892 #if defined(HAVE_WIN32)
1893 return ::_lseeki64(m_fd, (__int64)offset, whence);
1895 return ::lseek(m_fd, (off_t)offset, whence);
1902 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1904 Dmsg1(100, "truncate %s\n", print_name());
1907 /* maybe we should rewind and write and eof ???? */
1908 return true; /* we don't really truncate tapes */
1910 return truncate_dvd(dcr);
1912 /* ***FIXME*** we really need to unlink() the file so that
1913 * its name can be changed for a relabel.
1915 if (ftruncate(m_fd, 0) != 0) {
1917 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1918 print_name(), be.bstrerror());
1926 /* Mount the device.
1927 * If timeout, wait until the mount command returns 0.
1928 * If !timeout, try to mount the device only once.
1930 bool DEVICE::mount(int timeout)
1932 Dmsg0(190, "Enter mount\n");
1935 } else if (requires_mount()) {
1936 return do_mount(1, timeout);
1941 /* Unmount the device
1942 * If timeout, wait until the unmount command returns 0.
1943 * If !timeout, try to unmount the device only once.
1945 bool DEVICE::unmount(int timeout)
1947 Dmsg0(100, "Enter unmount\n");
1949 return do_mount(0, timeout);
1954 /* (Un)mount the device */
1955 bool DEVICE::do_mount(int mount, int dotimeout)
1957 POOL_MEM ocmd(PM_FNAME);
1960 int status, timeout;
1965 Dmsg0(200, "======= mount=1\n");
1968 icmd = device->mount_command;
1970 if (!is_mounted()) {
1971 Dmsg0(200, "======= mount=0\n");
1974 icmd = device->unmount_command;
1977 clear_freespace_ok();
1978 edit_mount_codes(ocmd, icmd);
1980 Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1983 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1988 results = get_memory(4000);
1991 /* If busy retry each second */
1992 Dmsg1(100, "do_mount run_prog=%s\n", ocmd.c_str());
1993 while ((status = run_program_full_output(ocmd.c_str(),
1994 max_open_wait/2, results)) != 0) {
1995 /* Doesn't work with internationalization (This is not a problem) */
1996 if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
1999 if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2002 if (timeout-- > 0) {
2003 /* Sometimes the device cannot be mounted because it is already mounted.
2004 * Try to unmount it, then remount it */
2006 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2014 Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2015 (mount ? "" : "un"), status, results, be.bstrerror(status));
2016 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2017 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2019 Dmsg4(100, "Device %s cannot be %smounted. stat=%d ERR=%s\n", print_name(),
2020 (mount ? "" : "un"), status, results);
2021 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2022 print_name(), (mount ? "" : "un"), results);
2025 * Now, just to be sure it is not mounted, try to read the
2029 struct dirent *entry, *result;
2033 name_max = pathconf(".", _PC_NAME_MAX);
2034 if (name_max < 1024) {
2038 if (!(dp = opendir(device->mount_point))) {
2041 Dmsg3(100, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2042 device->mount_point, print_name(), be.bstrerror());
2046 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2049 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2051 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
2052 device->mount_point, print_name());
2055 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2056 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2059 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2065 Dmsg1(100, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2068 /* If we got more than ., .. and .keep */
2069 /* there must be something mounted */
2071 Dmsg1(100, "Did Mount by count=%d\n", count);
2074 /* An unmount request. We failed to unmount - report an error */
2076 free_pool_memory(results);
2077 Dmsg0(200, "== error mount=1 wanted unmount\n");
2083 free_pool_memory(results);
2084 Dmsg0(200, "============ mount=0\n");
2089 set_mounted(mount); /* set/clear mounted flag */
2090 free_pool_memory(results);
2091 /* Do not check free space when unmounting */
2092 if (mount && !update_freespace()) {
2095 Dmsg1(200, "============ mount=%d\n", mount);
2100 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2102 * %a = archive device name
2103 * %e = erase (set if cannot mount and first part)
2106 * %v = last part name
2108 * omsg = edited output message
2109 * imsg = input string containing edit codes (%x)
2112 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2118 POOL_MEM archive_name(PM_FNAME);
2120 omsg.c_str()[0] = 0;
2121 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2122 for (p=imsg; *p; p++) {
2132 if (num_dvd_parts == 0) {
2133 if (truncating || blank_dvd) {
2143 bsnprintf(add, sizeof(add), "%d", part);
2147 str = device->mount_point;
2150 make_spooled_dvd_filename(this, archive_name);
2151 str = archive_name.c_str();
2165 Dmsg1(1900, "add_str %s\n", str);
2166 pm_strcat(omsg, (char *)str);
2167 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2171 /* return the last timer interval (ms) */
2172 btime_t DEVICE::get_timer_count()
2174 btime_t old = last_timer;
2175 last_timer = get_current_btime();
2176 return last_timer - old;
2180 ssize_t DEVICE::read(void *buf, size_t len)
2186 if (this->is_tape()) {
2187 read_len = tape_read(m_fd, buf, len);
2189 read_len = ::read(m_fd, buf, len);
2192 last_tick = get_timer_count();
2194 DevReadTime += last_tick;
2195 VolCatInfo.VolReadTime += last_tick;
2197 if (read_len > 0) { /* skip error */
2198 DevReadBytes += read_len;
2205 ssize_t DEVICE::write(const void *buf, size_t len)
2211 if (this->is_tape()) {
2212 write_len = tape_write(m_fd, buf, len);
2214 write_len = ::write(m_fd, buf, len);
2217 last_tick = get_timer_count();
2219 DevWriteTime += last_tick;
2220 VolCatInfo.VolWriteTime += last_tick;
2222 if (write_len > 0) { /* skip error */
2223 DevWriteBytes += write_len;
2229 /* Return the resource name for the device */
2230 const char *DEVICE::name() const
2232 return device->hdr.name;
2235 /* Returns file position on tape or -1 */
2236 int32_t DEVICE::get_os_tape_file()
2238 struct mtget mt_stat;
2240 if (has_cap(CAP_MTIOCGET) &&
2241 tape_ioctl(m_fd, MTIOCGET, (char *)&mt_stat) == 0) {
2242 return mt_stat.mt_fileno;
2248 dev_vol_name(DEVICE *dev)
2250 return dev->VolCatInfo.VolCatName;
2255 * Free memory allocated for the device
2257 void DEVICE::term(void)
2259 Dmsg1(900, "term dev: %s\n", print_name());
2262 free_memory(dev_name);
2266 free_memory(prt_name);
2270 free_pool_memory(errmsg);
2273 pthread_mutex_destroy(&m_mutex);
2274 pthread_cond_destroy(&wait);
2275 pthread_cond_destroy(&wait_next_vol);
2276 pthread_mutex_destroy(&spool_mutex);
2277 // rwl_destroy(&lock);
2278 if (attached_dcrs) {
2279 delete attached_dcrs;
2280 attached_dcrs = NULL;
2289 * This routine initializes the device wait timers
2291 void init_device_wait_timers(DCR *dcr)
2293 DEVICE *dev = dcr->dev;
2294 JCR *jcr = dcr->jcr;
2296 /* ******FIXME******* put these on config variables */
2297 dev->min_wait = 60 * 60;
2298 dev->max_wait = 24 * 60 * 60;
2299 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2300 dev->wait_sec = dev->min_wait;
2301 dev->rem_wait_sec = dev->wait_sec;
2304 dev->BadVolName[0] = 0;
2306 jcr->min_wait = 60 * 60;
2307 jcr->max_wait = 24 * 60 * 60;
2308 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2309 jcr->wait_sec = jcr->min_wait;
2310 jcr->rem_wait_sec = jcr->wait_sec;
2315 void init_jcr_device_wait_timers(JCR *jcr)
2317 /* ******FIXME******* put these on config variables */
2318 jcr->min_wait = 60 * 60;
2319 jcr->max_wait = 24 * 60 * 60;
2320 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2321 jcr->wait_sec = jcr->min_wait;
2322 jcr->rem_wait_sec = jcr->wait_sec;
2328 * The dev timers are used for waiting on a particular device
2330 * Returns: true if time doubled
2331 * false if max time expired
2333 bool double_dev_wait_time(DEVICE *dev)
2335 dev->wait_sec *= 2; /* double wait time */
2336 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2337 dev->wait_sec = dev->max_wait;
2340 dev->rem_wait_sec = dev->wait_sec;
2341 if (dev->num_wait >= dev->max_num_wait) {
2348 void set_os_device_parameters(DCR *dcr)
2350 DEVICE *dev = dcr->dev;
2352 if (strcmp(dev->dev_name, "/dev/null") == 0) {
2353 return; /* no use trying to set /dev/null */
2356 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2359 Dmsg0(100, "In set_os_device_parameters\n");
2360 #if defined(MTSETBLK)
2361 if (dev->min_block_size == dev->max_block_size &&
2362 dev->min_block_size == 0) { /* variable block mode */
2363 mt_com.mt_op = MTSETBLK;
2364 mt_com.mt_count = 0;
2365 Dmsg0(100, "Set block size to zero\n");
2366 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2367 dev->clrerror(MTSETBLK);
2371 #if defined(MTSETDRVBUFFER)
2372 if (getpid() == 0) { /* Only root can do this */
2373 mt_com.mt_op = MTSETDRVBUFFER;
2374 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2375 if (!dev->has_cap(CAP_TWOEOF)) {
2376 mt_com.mt_count |= MT_ST_TWO_FM;
2378 if (dev->has_cap(CAP_EOM)) {
2379 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2381 Dmsg0(100, "MTSETDRVBUFFER\n");
2382 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2383 dev->clrerror(MTSETDRVBUFFER);
2390 #ifdef HAVE_NETBSD_OS
2392 if (dev->min_block_size == dev->max_block_size &&
2393 dev->min_block_size == 0) { /* variable block mode */
2394 mt_com.mt_op = MTSETBSIZ;
2395 mt_com.mt_count = 0;
2396 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2397 dev->clrerror(MTSETBSIZ);
2399 /* Get notified at logical end of tape */
2400 mt_com.mt_op = MTEWARN;
2401 mt_com.mt_count = 1;
2402 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2403 dev->clrerror(MTEWARN);
2409 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2411 if (dev->min_block_size == dev->max_block_size &&
2412 dev->min_block_size == 0) { /* variable block mode */
2413 mt_com.mt_op = MTSETBSIZ;
2414 mt_com.mt_count = 0;
2415 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2416 dev->clrerror(MTSETBSIZ);
2419 #if defined(MTIOCSETEOTMODEL)
2421 if (dev->has_cap(CAP_TWOEOF)) {
2426 if (ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2428 dev->dev_errno = errno; /* save errno */
2429 Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2430 dev->print_name(), be.bstrerror(dev->dev_errno));
2431 Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2439 if (dev->min_block_size == dev->max_block_size &&
2440 dev->min_block_size == 0) { /* variable block mode */
2441 mt_com.mt_op = MTSRSZ;
2442 mt_com.mt_count = 0;
2443 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2444 dev->clrerror(MTSRSZ);
2451 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2453 Dmsg0(100, "dev_get_os_pos\n");
2454 return dev->has_cap(CAP_MTIOCGET) &&
2455 tape_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2456 mt_stat->mt_fileno >= 0;
2459 static char *modes[] = {
2460 "CREATE_READ_WRITE",
2467 static char *mode_to_str(int mode)
2469 static char buf[100];
2470 if (mode < 1 || mode > 4) {
2471 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2474 return modes[mode-1];