3 * dev.c -- low level operations on device (storage device)
7 * NOTE!!!! None of these routines are reentrant. You must
8 * use lock_device() and unlock_device() at a higher level,
9 * or use the xxx_device() equivalents. By moving the
10 * thread synchronization to a higher level, we permit
11 * the higher level routines to "seize" the device and
12 * to carry out operations without worrying about who
13 * set what lock (i.e. race conditions).
15 * Note, this is the device dependent code, and my have
16 * to be modified for each system, but is meant to
17 * be as "generic" as possible.
19 * The purpose of this code is to develop a SIMPLE Storage
20 * daemon. More complicated coding (double buffering, writer
21 * thread, ...) is left for a later version.
23 * Unfortunately, I have had to add more and more complication
24 * to this code. This was not foreseen as noted above, and as
25 * a consequence has lead to something more contorted than is
26 * really necessary -- KES. Note, this contortion has been
27 * corrected to a large extent by a rewrite (Apr MMI).
32 Copyright (C) 2000-2005 Kern Sibbald
34 This program is free software; you can redistribute it and/or
35 modify it under the terms of the GNU General Public License
36 version 2 as amended with additional clauses defined in the
37 file LICENSE in the main source directory.
39 This program is distributed in the hope that it will be useful,
40 but WITHOUT ANY WARRANTY; without even the implied warranty of
41 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
42 the file LICENSE for additional details.
47 * Handling I/O errors and end of tape conditions are a bit tricky.
48 * This is how it is currently done when writting.
49 * On either an I/O error or end of tape,
50 * we will stop writing on the physical device (no I/O recovery is
51 * attempted at least in this daemon). The state flag will be sent
52 * to include ST_EOT, which is ephimeral, and ST_WEOT, which is
53 * persistent. Lots of routines clear ST_EOT, but ST_WEOT is
54 * cleared only when the problem goes away. Now when ST_WEOT
55 * is set all calls to write_block_to_device() call the fix_up
56 * routine. In addition, all threads are blocked
57 * from writing on the tape by calling lock_dev(), and thread other
58 * than the first thread to hit the EOT will block on a condition
59 * variable. The first thread to hit the EOT will continue to
60 * be able to read and write the tape (he sort of tunnels through
61 * the locking mechanism -- see lock_dev() for details).
63 * Now presumably somewhere higher in the chain of command
64 * (device.c), someone will notice the EOT condition and
65 * get a new tape up, get the tape label read, and mark
66 * the label for rewriting. Then this higher level routine
67 * will write the unwritten buffer to the new volume.
68 * Finally, he will release
69 * any blocked threads by doing a broadcast on the condition
70 * variable. At that point, we should be totally back in
71 * business with no lost data.
82 /* Forward referenced functions */
83 void set_os_device_parameters(DEVICE *dev);
84 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat);
85 static char *mode_to_str(int mode);
88 * Allocate and initialize the DEVICE structure
89 * Note, if dev is non-NULL, it is already allocated,
90 * thus we neither allocate it nor free it. This allows
91 * the caller to put the packet in shared memory.
93 * Note, for a tape, the device->device_name is the device name
94 * (e.g. /dev/nst0), and for a file, the device name
95 * is the directory in which the file will be placed.
99 init_dev(JCR *jcr, DEVRES *device)
107 /* Check that device is available */
108 if (stat(device->device_name, &statp) < 0) {
110 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
111 device->device_name, be.strerror());
118 if (S_ISDIR(statp.st_mode)) {
120 } else if (S_ISCHR(statp.st_mode)) {
122 } else if (S_ISFIFO(statp.st_mode)) {
124 } else if (!(device->cap_bits & CAP_REQMOUNT)) {
125 Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
126 " or have RequiresMount=yes for DVD. st_mode=%x\n"),
127 device->device_name, statp.st_mode);
131 dev = (DEVICE *)get_memory(sizeof(DEVICE));
132 memset(dev, 0, sizeof(DEVICE));
133 dev->state = ST_MALLOC;
135 /* Copy user supplied device parameters from Resource */
136 dev->dev_name = get_memory(strlen(device->device_name)+1);
137 pm_strcpy(dev->dev_name, device->device_name);
138 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
139 /* We edit "Resource-name" (physical-name) */
140 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
141 dev->capabilities = device->cap_bits;
142 dev->min_block_size = device->min_block_size;
143 dev->max_block_size = device->max_block_size;
144 dev->max_volume_size = device->max_volume_size;
145 dev->max_file_size = device->max_file_size;
146 dev->volume_capacity = device->volume_capacity;
147 dev->max_rewind_wait = device->max_rewind_wait;
148 dev->max_open_wait = device->max_open_wait;
149 dev->max_open_vols = device->max_open_vols;
150 dev->vol_poll_interval = device->vol_poll_interval;
151 dev->max_spool_size = device->max_spool_size;
152 dev->drive_index = device->drive_index;
153 dev->autoselect = device->autoselect;
154 if (tape) { /* No parts on tapes */
155 dev->max_part_size = 0;
158 dev->max_part_size = device->max_part_size;
161 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
162 dev->vol_poll_interval = 60;
164 dev->device = device;
167 dev->state |= ST_TAPE;
169 dev->state |= ST_FIFO;
170 dev->capabilities |= CAP_STREAM; /* set stream device */
172 dev->state |= ST_FILE;
175 /* If the device requires mount :
176 * - Check that the mount point is available
177 * - Check that (un)mount commands are defined
179 if (dev->is_file() && dev->requires_mount()) {
180 if (stat(device->mount_point, &statp) < 0) {
182 dev->dev_errno = errno;
183 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat mount point %s: ERR=%s\n"),
184 device->mount_point, be.strerror());
187 if (!device->mount_command || !device->unmount_command) {
188 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
190 if (!device->write_part_command) {
191 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
193 dev->state |= ST_DVD;
196 if (dev->max_block_size > 1000000) {
197 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
198 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
199 dev->max_block_size = 0;
201 if (dev->max_block_size % TAPE_BSIZE != 0) {
202 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
203 dev->max_block_size, dev->print_name());
206 dev->errmsg = get_pool_memory(PM_EMSG);
209 if ((errstat = pthread_mutex_init(&dev->mutex, NULL)) != 0) {
211 dev->dev_errno = errstat;
212 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
213 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
215 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
217 dev->dev_errno = errstat;
218 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
219 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
221 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
223 dev->dev_errno = errstat;
224 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
225 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
227 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
229 dev->dev_errno = errstat;
230 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
231 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
233 if ((errstat = rwl_init(&dev->lock)) != 0) {
235 dev->dev_errno = errstat;
236 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
237 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
241 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
242 Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
248 * Open the device with the operating system and
249 * initialize buffer pointers.
251 * Returns: -1 on error
254 * Note, for a tape, the VolName is the name we give to the
255 * volume (not really used here), but for a file, the
256 * VolName represents the name of the file to be created/opened.
257 * In the case of a file, the full name is the device name
258 * (archive_name) with the VolName concatenated.
261 DEVICE::open(DCR *dcr, int omode)
264 if (openmode == omode) {
267 ::close(fd); /* use system close so correct mode will be used on open */
271 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
274 Dmsg4(29, "open dev: tape=%d dev_name=%s vol=%s mode=%s\n", is_tape(),
275 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
276 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
277 label_type = B_BACULA_LABEL;
278 if (is_tape() || is_fifo()) {
279 open_tape_device(omode);
280 } else if (is_dvd()) {
281 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
282 open_dvd_device(dcr, omode);
284 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
285 open_file_device(omode);
290 void DEVICE::set_mode(int new_mode)
293 case CREATE_READ_WRITE:
294 mode = O_CREAT | O_RDWR | O_BINARY;
296 case OPEN_READ_WRITE:
297 if (is_dvd() || is_file()) {
298 mode = O_CREAT | O_RDWR | O_BINARY;
300 mode = O_RDWR | O_BINARY;
304 mode = O_RDONLY | O_BINARY;
306 case OPEN_WRITE_ONLY:
307 mode = O_WRONLY | O_BINARY;
310 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
314 void DEVICE::open_tape_device(int omode)
316 int nonblocking = 0;;
320 Dmsg0(29, "open dev: device is tape\n");
323 timeout = max_open_wait;
326 /* Set wait counters to zero for no wait */
327 timeout = ioerrcnt = 0;
328 /* Open drive in non-block mode */
329 nonblocking = O_NONBLOCK;
331 if (is_fifo() && timeout) {
333 tid = start_thread_timer(pthread_self(), timeout);
335 /* If busy retry each second for max_open_wait seconds */
337 Dmsg1(500, "Try open %s\n", print_name());
338 /* Use system open() */
339 while ((fd = ::open(dev_name, mode, MODE_RW+nonblocking)) < 0) {
341 Dmsg2(500, "Open error errno=%d ERR=%s\n", errno, be.strerror());
342 if (errno == EINTR || errno == EAGAIN) {
343 Dmsg0(500, "Continue open\n");
346 /* Busy wait for specified time (default = 5 mins) */
347 if (errno == EBUSY && timeout-- > 0) {
348 Dmsg2(100, "Device %s busy. ERR=%s\n", print_name(), be.strerror());
352 /* IO error (no volume) try 10 times every 6 seconds */
353 if (errno == EIO && ioerrcnt-- > 0) {
355 Dmsg0(500, "Continue open\n");
359 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
360 print_name(), be.strerror(dev_errno));
361 /* Stop any open timer we set */
363 stop_thread_timer(tid);
366 Emsg0(M_FATAL, 0, errmsg);
370 /* If opened in non-block mode, close it an open it normally */
373 ::close(fd); /* use system close() */
376 openmode = omode; /* save open mode */
377 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
381 update_pos_dev(this); /* update position */
382 set_os_device_parameters(this); /* do system dependent stuff */
383 Dmsg0(500, "Open OK\n");
385 /* Stop any open() timer we started */
387 stop_thread_timer(tid);
390 Dmsg1(29, "open dev: tape %d opened\n", fd);
396 void DEVICE::open_file_device(int omode)
398 POOL_MEM archive_name(PM_FNAME);
401 * Handle opening of File Archive (not a tape)
403 Dmsg3(29, "Enter: open_file_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
404 archive_name.c_str(), mode_to_str(omode));
406 if (VolCatInfo.VolCatName[0] == 0) {
407 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
413 pm_strcpy(archive_name, dev_name);
414 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
415 pm_strcat(archive_name, "/");
417 pm_strcat(archive_name, VolCatInfo.VolCatName);
419 Dmsg3(29, "open dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
420 archive_name.c_str(), mode_to_str(omode));
422 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
425 /* If creating file, give 0640 permissions */
426 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
427 archive_name.c_str(), mode);
428 /* Use system open() */
429 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
432 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
434 Dmsg1(29, "open failed: %s", errmsg);
435 Emsg0(M_FATAL, 0, errmsg);
440 update_pos_dev(this); /* update position */
442 Dmsg5(29, "open dev: %s fd=%d opened, part=%d/%d, part_size=%u\n",
443 is_dvd()?"DVD":"disk", fd, part, num_parts,
448 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
449 * has the desired Volume name, but there is NO assurance that
450 * any other field of VolCatInfo is correct.
452 void DEVICE::open_dvd_device(DCR *dcr, int omode)
454 POOL_MEM archive_name(PM_FNAME);
455 struct stat filestat;
458 * Handle opening of DVD Volume
460 Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
461 archive_name.c_str(), mode_to_str(omode));
463 if (VolCatInfo.VolCatName[0] == 0) {
464 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
476 if (!mount_dev(this, 1)) {
477 if (num_parts == 0) {
478 Dmsg1(29, "Could not mount device %s, this is not a problem (num_parts == 0).\n", print_name());
481 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
482 Emsg0(M_FATAL, 0, errmsg);
488 Dmsg5(29, "open dev: %s dev=%s mode=%s part=%d npart=%d\n",
489 is_dvd()?"DVD":"disk", archive_name.c_str(), mode_to_str(omode),
492 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
495 * If we are not trying to access the last part, set mode to
496 * OPEN_READ_ONLY as writing would be an error.
498 if (part < num_parts) {
499 omode = OPEN_READ_ONLY;
500 make_mounted_dvd_filename(this, archive_name);
503 make_spooled_dvd_filename(this, archive_name);
507 /* If creating file, give 0640 permissions */
508 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
509 archive_name.c_str(), mode);
510 /* Use system open() */
511 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
514 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
516 Dmsg1(29, "open failed: %s", errmsg);
517 if (omode == OPEN_READ_ONLY) {
518 make_spooled_dvd_filename(this, archive_name);
519 /* Use system open() */
520 fd = ::open(archive_name.c_str(), mode, 0640); /* try on spool */
523 Dmsg1(100, "after open fd=%d\n", fd);
525 /* Get size of file */
526 if (fstat(fd, &filestat) < 0) {
529 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
531 Dmsg1(29, "open failed: %s", errmsg);
532 /* Use system close() */
536 part_size = filestat.st_size;
540 Dmsg2(100, "after open(2a) part=%d part_size=%d\n", part, part_size);
541 update_pos_dev(this); /* update position */
543 /* NB: It seems this code is wrong... part number is incremented in open_next_part, not here */
545 /* Check if just created Volume part */
546 /* if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
549 VolCatInfo.VolCatParts = num_parts;
551 if (part == 0) { // we must have opened the first part
562 bool _rewind_dev(char *file, int line, DEVICE *dev)
564 Dmsg3(100, "rewind_dev fd=%d called from %s:%d\n", dev->fd, file, line);
565 return rewind_dev(dev);
571 * Returns: true on success
574 bool rewind_dev(DEVICE *dev)
579 Dmsg2(29, "rewind_dev fd=%d %s\n", dev->fd, dev->print_name());
581 dev->dev_errno = EBADF;
582 Mmsg1(dev->errmsg, _("Bad call to rewind_dev. Device %s not open\n"),
584 Emsg0(M_ABORT, 0, dev->errmsg);
587 dev->state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
588 dev->block_num = dev->file = 0;
591 if (dev->is_tape()) {
592 mt_com.mt_op = MTREW;
594 /* If we get an I/O error on rewind, it is probably because
595 * the drive is actually busy. We loop for (about 5 minutes)
596 * retrying every 5 seconds.
598 for (i=dev->max_rewind_wait; ; i -= 5) {
599 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
601 clrerror_dev(dev, MTREW);
602 if (i == dev->max_rewind_wait) {
603 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
605 if (dev->dev_errno == EIO && i > 0) {
606 Dmsg0(200, "Sleeping 5 seconds.\n");
610 Mmsg2(dev->errmsg, _("Rewind error on %s. ERR=%s.\n"),
611 dev->print_name(), be.strerror());
616 } else if (dev->is_file()) {
617 if (lseek_dev(dev, (off_t)0, SEEK_SET) < 0) {
619 dev->dev_errno = errno;
620 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
621 dev->print_name(), be.strerror());
628 void DEVICE::block(int why)
631 block_device(this, why);
635 void DEVICE::unblock()
638 unblock_device(this);
642 const char *DEVICE::print_blocked() const
644 switch (dev_blocked) {
645 case BST_NOT_BLOCKED:
646 return "BST_NOT_BLOCKED";
648 return "BST_UNMOUNTED";
649 case BST_WAITING_FOR_SYSOP:
650 return "BST_WAITING_FOR_SYSOP";
651 case BST_DOING_ACQUIRE:
652 return "BST_DOING_ACQUIRE";
653 case BST_WRITING_LABEL:
654 return "BST_WRITING_LABEL";
655 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
656 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
660 return "unknown blocked code";
665 * Called to indicate that we have just read an
666 * EOF from the device.
668 void DEVICE::set_ateof()
678 * Called to indicate we are now at the end of the tape, and
679 * writing is not possible.
681 void DEVICE::set_ateot()
683 /* Make tape effectively read-only */
684 state |= (ST_EOF|ST_EOT|ST_WEOT);
689 * Position device to end of medium (end of data)
690 * Returns: true on succes
697 struct mtget mt_stat;
702 dev->dev_errno = EBADF;
703 Mmsg1(dev->errmsg, _("Bad call to eod_dev. Device %s not open\n"),
708 #if defined (__digital__) && defined (__unix__)
709 return dev->fsf(dev->VolCatInfo.VolCatFiles);
712 Dmsg0(29, "eod_dev\n");
716 dev->state &= ~(ST_EOF); /* remove EOF flags */
717 dev->block_num = dev->file = 0;
720 if (dev->state & (ST_FIFO | ST_PROG)) {
723 if (!dev->is_tape()) {
724 pos = lseek_dev(dev, (off_t)0, SEEK_END);
725 // Dmsg1(100, "====== Seek to %lld\n", pos);
728 dev->state |= ST_EOT;
731 dev->dev_errno = errno;
733 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
734 dev->print_name(), be.strerror());
738 if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
739 Dmsg0(100,"Using FAST FSF for EOM\n");
740 /* If unknown position, rewind */
741 if (!dev_get_os_pos(dev, &mt_stat)) {
742 if (!rewind_dev(dev)) {
746 mt_com.mt_op = MTFSF;
748 * ***FIXME*** fix code to handle case that INT16_MAX is
751 mt_com.mt_count = INT16_MAX; /* use big positive number */
752 if (mt_com.mt_count < 0) {
753 mt_com.mt_count = INT16_MAX; /* brain damaged system */
757 if (dev_cap(dev, CAP_MTIOCGET) && (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM))) {
758 if (dev_cap(dev, CAP_EOM)) {
759 Dmsg0(100,"Using EOM for EOM\n");
760 mt_com.mt_op = MTEOM;
764 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
766 clrerror_dev(dev, mt_com.mt_op);
767 Dmsg1(50, "ioctl error: %s\n", be.strerror());
769 Mmsg2(dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
770 dev->print_name(), be.strerror());
774 if (!dev_get_os_pos(dev, &mt_stat)) {
776 clrerror_dev(dev, -1);
777 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
778 dev->print_name(), be.strerror());
781 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
783 dev->file = mt_stat.mt_fileno;
789 * Rewind then use FSF until EOT reached
791 if (!rewind_dev(dev)) {
795 * Move file by file to the end of the tape
798 for (file_num=dev->file; !dev->at_eot(); file_num++) {
799 Dmsg0(200, "eod_dev: doing fsf 1\n");
801 Dmsg0(200, "fsf error.\n");
805 * Avoid infinite loop. ***FIXME*** possibly add code
806 * to set EOD or to turn off CAP_FASTFSF if on.
808 if (file_num == (int)dev->file) {
809 struct mtget mt_stat;
810 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
811 if (dev_get_os_pos(dev, &mt_stat)) {
812 Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
814 dev->file = mt_stat.mt_fileno;
821 * Some drivers leave us after second EOF when doing
822 * MTEOM, so we must backup so that appending overwrites
825 if (dev_cap(dev, CAP_BSFATEOM)) {
826 struct mtget mt_stat;
827 /* Backup over EOF */
828 ok = bsf_dev(dev, 1);
829 /* If BSF worked and fileno is known (not -1), set file */
830 if (dev_get_os_pos(dev, &mt_stat)) {
831 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
832 dev->file = mt_stat.mt_fileno;
834 dev->file++; /* wing it -- not correct on all OSes */
837 update_pos_dev(dev); /* update position */
839 Dmsg1(200, "EOD dev->file=%d\n", dev->file);
844 * Set the position of the device -- only for files
845 * For other devices, there is no generic way to do it.
846 * Returns: true on succes
849 bool update_pos_dev(DEVICE *dev)
855 dev->dev_errno = EBADF;
856 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
857 Emsg0(M_FATAL, 0, dev->errmsg);
861 /* Find out where we are */
862 if (dev->is_file()) {
865 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
868 dev->dev_errno = errno;
869 Pmsg1(000, "Seek error: ERR=%s\n", be.strerror());
870 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
871 dev->print_name(), be.strerror());
874 dev->file_addr = pos;
882 * Return the status of the device. This was meant
883 * to be a generic routine. Unfortunately, it doesn't
884 * seem possible (at least I do not know how to do it
885 * currently), which means that for the moment, this
886 * routine has very little value.
890 uint32_t status_dev(DEVICE *dev)
892 struct mtget mt_stat;
895 if (dev->state & (ST_EOT | ST_WEOT)) {
899 if (dev->state & ST_EOF) {
903 if (dev->is_tape()) {
905 Pmsg0(-20," Bacula status:");
906 Pmsg2(-20," file=%d block=%d\n", dev->file, dev->block_num);
907 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
909 dev->dev_errno = errno;
910 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
911 dev->print_name(), be.strerror());
914 Pmsg0(-20, " Device status:");
916 #if defined(HAVE_LINUX_OS)
917 if (GMT_EOF(mt_stat.mt_gstat)) {
921 if (GMT_BOT(mt_stat.mt_gstat)) {
925 if (GMT_EOT(mt_stat.mt_gstat)) {
929 if (GMT_SM(mt_stat.mt_gstat)) {
933 if (GMT_EOD(mt_stat.mt_gstat)) {
937 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
939 Pmsg0(-20, " WR_PROT");
941 if (GMT_ONLINE(mt_stat.mt_gstat)) {
943 Pmsg0(-20, " ONLINE");
945 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
947 Pmsg0(-20, " DR_OPEN");
949 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
950 stat |= BMT_IM_REP_EN;
951 Pmsg0(-20, " IM_REP_EN");
953 #endif /* !SunOS && !OSF */
954 if (dev_cap(dev, CAP_MTIOCGET)) {
955 Pmsg2(-20, " file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
957 Pmsg2(-20, " file=%d block=%d\n", -1, -1);
960 stat |= BMT_ONLINE | BMT_BOT;
967 * Load medium in device
968 * Returns: true on success
971 bool load_dev(DEVICE *dev)
978 dev->dev_errno = EBADF;
979 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
980 Emsg0(M_FATAL, 0, dev->errmsg);
983 if (!(dev->is_tape())) {
987 Dmsg0(200, "stored: MTLOAD command not available\n");
989 dev->dev_errno = ENOTTY; /* function not available */
990 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
991 dev->print_name(), be.strerror());
995 dev->block_num = dev->file = 0;
998 mt_com.mt_op = MTLOAD;
1000 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1002 dev->dev_errno = errno;
1003 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1004 dev->print_name(), be.strerror());
1012 * Rewind device and put it offline
1013 * Returns: true on success
1016 bool offline_dev(DEVICE *dev)
1021 dev->dev_errno = EBADF;
1022 Mmsg0(dev->errmsg, _("Bad call to offline_dev. Device not open\n"));
1023 Emsg0(M_FATAL, 0, dev->errmsg);
1026 if (!(dev->is_tape())) {
1030 dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1031 dev->block_num = dev->file = 0;
1036 mt_com.mt_op = MTUNLOCK;
1037 mt_com.mt_count = 1;
1038 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1040 mt_com.mt_op = MTOFFL;
1041 mt_com.mt_count = 1;
1042 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1044 dev->dev_errno = errno;
1045 Mmsg2(dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1046 dev->print_name(), be.strerror());
1049 Dmsg1(100, "Offlined device %s\n", dev->print_name());
1053 bool offline_or_rewind_dev(DEVICE *dev)
1058 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1059 return offline_dev(dev);
1062 * Note, this rewind probably should not be here (it wasn't
1063 * in prior versions of Bacula), but on FreeBSD, this is
1064 * needed in the case the tape was "frozen" due to an error
1065 * such as backspacing after writing and EOF. If it is not
1066 * done, all future references to the drive get and I/O error.
1068 clrerror_dev(dev, MTREW);
1069 return rewind_dev(dev);
1074 * Foward space a file
1075 * Returns: true on success
1078 bool DEVICE::fsf(int num)
1080 struct mtget mt_stat;
1086 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1087 Emsg0(M_FATAL, 0, errmsg);
1096 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1100 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1103 Dmsg0(100, "fsf\n");
1106 * If Fast forward space file is set, then we
1107 * use MTFSF to forward space and MTIOCGET
1108 * to get the file position. We assume that
1109 * the SCSI driver will ensure that we do not
1110 * forward space past the end of the medium.
1112 if (dev_cap(this, CAP_FSF) && dev_cap(this, CAP_MTIOCGET) && dev_cap(this, CAP_FASTFSF)) {
1113 mt_com.mt_op = MTFSF;
1114 mt_com.mt_count = num;
1115 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1116 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1119 Dmsg0(200, "Set ST_EOT\n");
1120 clrerror_dev(this, MTFSF);
1121 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1122 print_name(), be.strerror());
1123 Dmsg1(200, "%s", errmsg);
1126 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1128 file = mt_stat.mt_fileno;
1132 * Here if CAP_FSF is set, and virtually all drives
1133 * these days support it, we read a record, then forward
1134 * space one file. Using this procedure, which is slow,
1135 * is the only way we can be sure that we don't read
1136 * two consecutive EOF marks, which means End of Data.
1138 } else if (dev_cap(this, CAP_FSF)) {
1141 Dmsg0(200, "FSF has cap_fsf\n");
1142 if (max_block_size == 0) {
1143 rbuf_len = DEFAULT_BLOCK_SIZE;
1145 rbuf_len = max_block_size;
1147 rbuf = get_memory(rbuf_len);
1148 mt_com.mt_op = MTFSF;
1149 mt_com.mt_count = 1;
1150 while (num-- && !at_eot()) {
1151 Dmsg0(100, "Doing read before fsf\n");
1152 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1153 if (errno == ENOMEM) { /* tape record exceeds buf len */
1154 stat = rbuf_len; /* This is OK */
1156 * On IBM drives, they return ENOSPC at EOM
1157 * instead of EOF status
1159 } else if (at_eof() && errno == ENOSPC) {
1164 clrerror_dev(this, -1);
1165 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1167 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1168 print_name(), be.strerror());
1169 Dmsg1(100, "%s", errmsg);
1173 if (stat == 0) { /* EOF */
1174 update_pos_dev(this);
1175 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1176 /* Two reads of zero means end of tape */
1179 Dmsg0(100, "Set ST_EOT\n");
1185 } else { /* Got data */
1190 Dmsg0(100, "Doing MTFSF\n");
1191 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1192 if (stat < 0) { /* error => EOT */
1195 Dmsg0(100, "Set ST_EOT\n");
1196 clrerror_dev(this, MTFSF);
1197 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1198 print_name(), be.strerror());
1199 Dmsg0(100, "Got < 0 for MTFSF\n");
1200 Dmsg1(100, "%s", errmsg);
1208 * No FSF, so use FSR to simulate it
1211 Dmsg0(200, "Doing FSR for FSF\n");
1212 while (num-- && !at_eot()) {
1213 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1217 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1223 update_pos_dev(this);
1224 Dmsg1(200, "Return %d from FSF\n", stat);
1226 Dmsg0(200, "ST_EOF set on exit FSF\n");
1228 Dmsg0(200, "ST_EOT set on exit FSF\n");
1229 Dmsg1(200, "Return from FSF file=%d\n", file);
1234 * Backward space a file
1235 * Returns: false on failure
1239 bsf_dev(DEVICE *dev, int num)
1245 dev->dev_errno = EBADF;
1246 Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Device not open\n"));
1247 Emsg0(M_FATAL, 0, dev->errmsg);
1251 if (!dev->is_tape()) {
1252 Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1256 Dmsg0(29, "bsf_dev\n");
1257 dev->state &= ~(ST_EOT|ST_EOF);
1261 mt_com.mt_op = MTBSF;
1262 mt_com.mt_count = num;
1263 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1266 clrerror_dev(dev, MTBSF);
1267 Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1268 dev->print_name(), be.strerror());
1270 update_pos_dev(dev);
1276 * Foward space num records
1277 * Returns: false on failure
1280 bool DEVICE::fsr(int num)
1287 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1288 Emsg0(M_FATAL, 0, errmsg);
1295 if (!dev_cap(this, CAP_FSR)) {
1296 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1300 Dmsg1(29, "fsr %d\n", num);
1301 mt_com.mt_op = MTFSR;
1302 mt_com.mt_count = num;
1303 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1309 struct mtget mt_stat;
1310 clrerror_dev(this, MTFSR);
1311 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1312 if (dev_get_os_pos(this, &mt_stat)) {
1313 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1314 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1315 file = mt_stat.mt_fileno;
1316 block_num = mt_stat.mt_blkno;
1324 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1325 num, print_name(), be.strerror());
1327 update_pos_dev(this);
1332 * Backward space a record
1333 * Returns: false on failure
1337 bsr_dev(DEVICE *dev, int num)
1343 dev->dev_errno = EBADF;
1344 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1345 Emsg0(M_FATAL, 0, dev->errmsg);
1349 if (!dev->is_tape()) {
1353 if (!dev_cap(dev, CAP_BSR)) {
1354 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1358 Dmsg0(29, "bsr_dev\n");
1359 dev->block_num -= num;
1360 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1361 mt_com.mt_op = MTBSR;
1362 mt_com.mt_count = num;
1363 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1366 clrerror_dev(dev, MTBSR);
1367 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1368 dev->print_name(), be.strerror());
1370 update_pos_dev(dev);
1375 * Reposition the device to file, block
1376 * Returns: false on failure
1380 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1383 dev->dev_errno = EBADF;
1384 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1385 Emsg0(M_FATAL, 0, dev->errmsg);
1389 if (!dev->is_tape()) {
1390 off_t pos = (((off_t)file)<<32) + block;
1391 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1392 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1394 dev->dev_errno = errno;
1395 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1396 dev->print_name(), be.strerror());
1400 dev->block_num = block;
1401 dev->file_addr = pos;
1404 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1405 dev->file, dev->block_num, file, block);
1406 if (file < dev->file) {
1407 Dmsg0(100, "Rewind_dev\n");
1408 if (!rewind_dev(dev)) {
1412 if (file > dev->file) {
1413 Dmsg1(100, "fsf %d\n", file-dev->file);
1414 if (!dev->fsf(file-dev->file)) {
1415 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1418 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1420 if (block < dev->block_num) {
1421 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1422 Dmsg0(100, "bsf_dev 1\n");
1424 Dmsg0(100, "fsf_dev 1\n");
1426 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1428 if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1429 /* Ignore errors as Bacula can read to the correct block */
1430 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1431 return dev->fsr(block-dev->block_num);
1439 * Write an end of file on the device
1440 * Returns: 0 on success
1441 * non-zero on failure
1444 weof_dev(DEVICE *dev, int num)
1448 Dmsg0(29, "weof_dev\n");
1451 dev->dev_errno = EBADF;
1452 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1453 Emsg0(M_FATAL, 0, dev->errmsg);
1458 if (!dev->is_tape()) {
1461 if (!dev->can_append()) {
1462 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1463 Emsg0(M_FATAL, 0, dev->errmsg);
1467 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1468 mt_com.mt_op = MTWEOF;
1469 mt_com.mt_count = num;
1470 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1477 clrerror_dev(dev, MTWEOF);
1479 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1480 dev->print_name(), be.strerror());
1487 * Return string message with last error in English
1488 * Be careful not to call this routine from within dev.c
1489 * while editing an Mmsg() or you will end up in a recursive
1490 * loop creating a Segmentation Violation.
1493 strerror_dev(DEVICE *dev)
1500 * If implemented in system, clear the tape
1504 clrerror_dev(DEVICE *dev, int func)
1506 const char *msg = NULL;
1507 struct mtget mt_stat;
1510 dev->dev_errno = errno; /* save errno */
1512 dev->VolCatInfo.VolCatErrors++;
1515 if (!dev->is_tape()) {
1518 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1521 Emsg0(M_ABORT, 0, "Got ENOTTY on read/write!\n");
1525 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1530 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1535 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1539 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1543 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1547 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1568 bsnprintf(buf, sizeof(buf), "unknown func code %d", func);
1573 dev->dev_errno = ENOSYS;
1574 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1575 Emsg0(M_ERROR, 0, dev->errmsg);
1578 /* On some systems such as NetBSD, this clears all errors */
1579 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1581 /* Found on Linux */
1585 mt_com.mt_op = MTIOCLRERR;
1586 mt_com.mt_count = 1;
1587 /* Clear any error condition on the tape */
1588 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1589 Dmsg0(200, "Did MTIOCLRERR\n");
1593 /* Typically on FreeBSD */
1596 /* Read and clear SCSI error status */
1597 union mterrstat mt_errstat;
1598 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1599 strerror(dev->dev_errno));
1600 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1604 /* Clear Subsystem Exception OSF1 */
1608 mt_com.mt_op = MTCSE;
1609 mt_com.mt_count = 1;
1610 /* Clear any error condition on the tape */
1611 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1612 Dmsg0(200, "Did MTCSE\n");
1618 * Flush buffer contents
1621 int flush_dev(DEVICE *dev)
1626 static void do_close(DEVICE *dev)
1629 Dmsg1(29, "really close_dev %s\n", dev->print_name());
1634 if (!unmount_dev(dev, 1)) {
1635 Dmsg1(0, "Cannot unmount device %s.\n", dev->print_name());
1638 /* Remove the last part file if it is empty */
1639 if (dev->can_append() && (dev->num_parts > 0)) {
1641 POOL_MEM archive_name(PM_FNAME);
1642 dev->part = dev->num_parts;
1643 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", dev->VolCatInfo.VolCatName);
1644 make_spooled_dvd_filename(dev, archive_name);
1645 /* Check that the part file is empty */
1646 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1647 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1648 unlink(archive_name.c_str());
1652 /* Clean up device packet so it can be reused */
1654 dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1655 dev->label_type = B_BACULA_LABEL;
1656 dev->file = dev->block_num = 0;
1662 dev->part_start = 0;
1663 dev->EndFile = dev->EndBlock = 0;
1664 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1665 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1667 stop_thread_timer(dev->tid);
1677 void DEVICE::close()
1679 /*if (fd >= 0 && use_count == 1) {*/
1680 /* No need to check if fd >= 0: it is checked again
1681 * in do_close, and do_close MUST be called for volumes
1682 * splitted in parts, even if fd == -1. */
1683 if (use_count == 1) {
1685 } else if (use_count > 0) {
1690 ASSERT(use_count >= 0);
1695 bool truncate_dev(DEVICE *dev)
1697 Dmsg1(100, "truncate_dev %s\n", dev->print_name());
1698 if (dev->is_tape()) {
1699 return true; /* we don't really truncate tapes */
1700 /* maybe we should rewind and write and eof ???? */
1703 if (dev->is_dvd()) {
1704 Mmsg1(dev->errmsg, _("Truncate DVD %s not supported.\n"), dev->print_name());
1705 return false; /* we cannot truncate DVDs */
1708 if (ftruncate(dev->fd, 0) != 0) {
1710 Mmsg2(dev->errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1711 dev->print_name(), be.strerror());
1717 /* Return the resource name for the device */
1718 const char *DEVICE::name() const
1720 return device->hdr.name;
1724 dev_vol_name(DEVICE *dev)
1726 return dev->VolCatInfo.VolCatName;
1729 uint32_t dev_block(DEVICE *dev)
1731 update_pos_dev(dev);
1732 return dev->block_num;
1735 uint32_t dev_file(DEVICE *dev)
1737 update_pos_dev(dev);
1742 * Free memory allocated for the device
1745 term_dev(DEVICE *dev)
1748 dev->dev_errno = EBADF;
1749 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1750 Emsg0(M_FATAL, 0, dev->errmsg);
1753 Dmsg1(29, "term_dev: %s\n", dev->print_name());
1755 if (dev->dev_name) {
1756 free_memory(dev->dev_name);
1757 dev->dev_name = NULL;
1759 if (dev->prt_name) {
1760 free_memory(dev->prt_name);
1761 dev->prt_name = NULL;
1764 free_pool_memory(dev->errmsg);
1767 pthread_mutex_destroy(&dev->mutex);
1768 pthread_cond_destroy(&dev->wait);
1769 pthread_cond_destroy(&dev->wait_next_vol);
1770 pthread_mutex_destroy(&dev->spool_mutex);
1771 rwl_destroy(&dev->lock);
1772 if (dev->attached_dcrs) {
1773 delete dev->attached_dcrs;
1774 dev->attached_dcrs = NULL;
1776 if (dev->state & ST_MALLOC) {
1777 free_pool_memory((POOLMEM *)dev);
1782 * This routine initializes the device wait timers
1784 void init_device_wait_timers(DCR *dcr)
1786 DEVICE *dev = dcr->dev;
1787 JCR *jcr = dcr->jcr;
1789 /* ******FIXME******* put these on config variables */
1790 dev->min_wait = 60 * 60;
1791 dev->max_wait = 24 * 60 * 60;
1792 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1793 dev->wait_sec = dev->min_wait;
1794 dev->rem_wait_sec = dev->wait_sec;
1797 dev->BadVolName[0] = 0;
1799 jcr->min_wait = 60 * 60;
1800 jcr->max_wait = 24 * 60 * 60;
1801 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1802 jcr->wait_sec = jcr->min_wait;
1803 jcr->rem_wait_sec = jcr->wait_sec;
1808 void init_jcr_device_wait_timers(JCR *jcr)
1810 /* ******FIXME******* put these on config variables */
1811 jcr->min_wait = 60 * 60;
1812 jcr->max_wait = 24 * 60 * 60;
1813 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1814 jcr->wait_sec = jcr->min_wait;
1815 jcr->rem_wait_sec = jcr->wait_sec;
1821 * The dev timers are used for waiting on a particular device
1823 * Returns: true if time doubled
1824 * false if max time expired
1826 bool double_dev_wait_time(DEVICE *dev)
1828 dev->wait_sec *= 2; /* double wait time */
1829 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
1830 dev->wait_sec = dev->max_wait;
1833 dev->rem_wait_sec = dev->wait_sec;
1834 if (dev->num_wait >= dev->max_num_wait) {
1841 void set_os_device_parameters(DEVICE *dev)
1843 #ifdef HAVE_LINUX_OS
1845 if (dev->min_block_size == dev->max_block_size &&
1846 dev->min_block_size == 0) { /* variable block mode */
1847 mt_com.mt_op = MTSETBLK;
1848 mt_com.mt_count = 0;
1849 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1850 clrerror_dev(dev, MTSETBLK);
1852 mt_com.mt_op = MTSETDRVBUFFER;
1853 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
1854 if (!dev_cap(dev, CAP_TWOEOF)) {
1855 mt_com.mt_count |= MT_ST_TWO_FM;
1857 if (dev_cap(dev, CAP_EOM)) {
1858 mt_com.mt_count |= MT_ST_FAST_MTEOM;
1860 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1861 clrerror_dev(dev, MTSETBLK);
1867 #ifdef HAVE_NETBSD_OS
1869 if (dev->min_block_size == dev->max_block_size &&
1870 dev->min_block_size == 0) { /* variable block mode */
1871 mt_com.mt_op = MTSETBSIZ;
1872 mt_com.mt_count = 0;
1873 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1874 clrerror_dev(dev, MTSETBSIZ);
1876 /* Get notified at logical end of tape */
1877 mt_com.mt_op = MTEWARN;
1878 mt_com.mt_count = 1;
1879 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1880 clrerror_dev(dev, MTEWARN);
1886 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
1888 if (dev->min_block_size == dev->max_block_size &&
1889 dev->min_block_size == 0) { /* variable block mode */
1890 mt_com.mt_op = MTSETBSIZ;
1891 mt_com.mt_count = 0;
1892 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1893 clrerror_dev(dev, MTSETBSIZ);
1901 if (dev->min_block_size == dev->max_block_size &&
1902 dev->min_block_size == 0) { /* variable block mode */
1903 mt_com.mt_op = MTSRSZ;
1904 mt_com.mt_count = 0;
1905 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1906 clrerror_dev(dev, MTSRSZ);
1913 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
1915 return dev_cap(dev, CAP_MTIOCGET) &&
1916 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
1917 mt_stat->mt_fileno >= 0;
1920 static char *modes[] = {
1921 "CREATE_READ_WRITE",
1928 static char *mode_to_str(int mode)
1930 return modes[mode-1];