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 ammended 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 /* Functions in dvd.c */
83 void get_filename(DEVICE *dev, char *VolName, POOL_MEM& archive_name);
84 void update_free_space_dev(DEVICE* dev);
87 /* Forward referenced functions */
88 void set_os_device_parameters(DEVICE *dev);
89 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat);
90 static void open_tape_device(DEVICE *dev, int mode);
91 static void open_file_device(DEVICE *dev, int mode);
94 * Allocate and initialize the DEVICE structure
95 * Note, if dev is non-NULL, it is already allocated,
96 * thus we neither allocate it nor free it. This allows
97 * the caller to put the packet in shared memory.
99 * Note, for a tape, the device->device_name is the device name
100 * (e.g. /dev/nst0), and for a file, the device name
101 * is the directory in which the file will be placed.
105 init_dev(JCR *jcr, DEVRES *device)
113 /* Check that device is available */
114 if (stat(device->device_name, &statp) < 0) {
116 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
117 device->device_name, be.strerror());
124 if (S_ISDIR(statp.st_mode)) {
126 } else if (S_ISCHR(statp.st_mode)) {
128 } else if (S_ISFIFO(statp.st_mode)) {
130 } else if (!(device->cap_bits & CAP_REQMOUNT)) {
131 Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory. st_mode=%x\n"),
132 device->device_name, statp.st_mode);
136 dev = (DEVICE *)get_memory(sizeof(DEVICE));
137 memset(dev, 0, sizeof(DEVICE));
138 dev->state = ST_MALLOC;
140 /* Copy user supplied device parameters from Resource */
141 dev->dev_name = get_memory(strlen(device->device_name)+1);
142 pm_strcpy(dev->dev_name, device->device_name);
143 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
144 /* We edit "Resource-name" (physical-name) */
145 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
146 dev->capabilities = device->cap_bits;
147 dev->min_block_size = device->min_block_size;
148 dev->max_block_size = device->max_block_size;
149 dev->max_volume_size = device->max_volume_size;
150 dev->max_file_size = device->max_file_size;
151 dev->volume_capacity = device->volume_capacity;
152 dev->max_rewind_wait = device->max_rewind_wait;
153 dev->max_open_wait = device->max_open_wait;
154 dev->max_open_vols = device->max_open_vols;
155 dev->vol_poll_interval = device->vol_poll_interval;
156 dev->max_spool_size = device->max_spool_size;
157 dev->drive_index = device->drive_index;
158 dev->autoselect = device->autoselect;
159 if (tape) { /* No parts on tapes */
160 dev->max_part_size = 0;
163 dev->max_part_size = device->max_part_size;
166 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
167 dev->vol_poll_interval = 60;
169 dev->device = device;
172 dev->state |= ST_TAPE;
174 dev->state |= ST_FIFO;
175 dev->capabilities |= CAP_STREAM; /* set stream device */
177 dev->state |= ST_FILE;
180 /* If the device requires mount :
181 * - Check that the mount point is available
182 * - Check that (un)mount commands are defined
184 if (dev->is_file() && dev->requires_mount()) {
185 if (stat(device->mount_point, &statp) < 0) {
187 dev->dev_errno = errno;
188 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat mount point %s: ERR=%s\n"),
189 device->mount_point, be.strerror());
192 if (!device->mount_command || !device->unmount_command) {
193 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
195 if (!device->write_part_command) {
196 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
198 dev->state |= ST_DVD;
201 if (dev->max_block_size > 1000000) {
202 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
203 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
204 dev->max_block_size = 0;
206 if (dev->max_block_size % TAPE_BSIZE != 0) {
207 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
208 dev->max_block_size, dev->print_name());
211 dev->errmsg = get_pool_memory(PM_EMSG);
214 if ((errstat = pthread_mutex_init(&dev->mutex, NULL)) != 0) {
216 dev->dev_errno = errstat;
217 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
218 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
220 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
222 dev->dev_errno = errstat;
223 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
224 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
226 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
228 dev->dev_errno = errstat;
229 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
230 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
232 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
234 dev->dev_errno = errstat;
235 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
236 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
238 if ((errstat = rwl_init(&dev->lock)) != 0) {
240 dev->dev_errno = errstat;
241 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
242 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
246 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
247 Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
253 * Open the device with the operating system and
254 * initialize buffer pointers.
256 * Returns: -1 on error
259 * Note, for a tape, the VolName is the name we give to the
260 * volume (not really used here), but for a file, the
261 * VolName represents the name of the file to be created/opened.
262 * In the case of a file, the full name is the device name
263 * (archive_name) with the VolName concatenated.
266 DEVICE::open(char *VolName, int mode)
269 if (openmode == mode) {
272 ::close(fd); /* use system close so correct mode will be used on open */
276 bstrncpy(VolCatInfo.VolCatName, VolName, sizeof(VolCatInfo.VolCatName));
278 VolCatInfo.VolCatName[0] = 0;
281 Dmsg4(29, "open dev: tape=%d dev_name=%s vol=%s mode=%d\n", is_tape(),
282 dev_name, VolCatInfo.VolCatName, mode);
283 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
284 label_type = B_BACULA_LABEL;
285 if (is_tape() || is_fifo()) {
286 open_tape_device(this, mode);
288 Dmsg1(100, "call open_file_device mode=%d\n", mode);
289 open_file_device(this, mode);
294 static void open_tape_device(DEVICE *dev, int mode)
296 int nonblocking = 0;;
300 Dmsg0(29, "open dev: device is tape\n");
302 if (mode == OPEN_READ_WRITE) {
303 dev->mode = O_RDWR | O_BINARY;
304 } else if (mode == OPEN_READ_ONLY) {
305 dev->mode = O_RDONLY | O_BINARY;
306 } else if (mode == OPEN_WRITE_ONLY) {
307 dev->mode = O_WRONLY | O_BINARY;
309 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
311 timeout = dev->max_open_wait;
313 if (dev->open_nowait) {
314 /* Set wait counters to zero for no wait */
315 timeout = ioerrcnt = 0;
316 /* Open drive in non-block mode */
317 nonblocking = O_NONBLOCK;
319 if (dev->is_fifo() && timeout) {
321 dev->tid = start_thread_timer(pthread_self(), timeout);
323 /* If busy retry each second for max_open_wait seconds */
325 Dmsg1(500, "Try open %s\n", dev->dev_name);
326 while ((dev->fd = open(dev->dev_name, dev->mode, MODE_RW+nonblocking)) < 0) {
328 Dmsg2(500, "Open error errno=%d ERR=%s\n", errno, be.strerror());
329 if (errno == EINTR || errno == EAGAIN) {
330 Dmsg0(500, "Continue open\n");
333 /* Busy wait for specified time (default = 5 mins) */
334 if (errno == EBUSY && timeout-- > 0) {
335 Dmsg2(100, "Device %s busy. ERR=%s\n", dev->print_name(), be.strerror());
339 /* IO error (no volume) try 10 times every 6 seconds */
340 if (errno == EIO && ioerrcnt-- > 0) {
342 Dmsg0(500, "Continue open\n");
345 dev->dev_errno = errno;
346 Mmsg2(dev->errmsg, _("Unable to open device %s: ERR=%s\n"),
347 dev->print_name(), be.strerror(dev->dev_errno));
348 /* Stop any open timer we set */
350 stop_thread_timer(dev->tid);
353 Emsg0(M_FATAL, 0, dev->errmsg);
357 /* If opened in non-block mode, close it an open it normally */
363 dev->openmode = mode; /* save open mode */
365 dev->state |= ST_OPENED;
367 update_pos_dev(dev); /* update position */
368 set_os_device_parameters(dev); /* do system dependent stuff */
369 Dmsg0(500, "Open OK\n");
371 /* Stop any open() timer we started */
373 stop_thread_timer(dev->tid);
376 Dmsg1(29, "open dev: tape %d opened\n", dev->fd);
380 * Open a file or DVD device
382 static void open_file_device(DEVICE *dev, int mode)
384 POOL_MEM archive_name(PM_FNAME);
385 struct stat filestat;
388 * Handle opening of File Archive (not a tape)
390 Dmsg3(29, "Enter: open_file_dev: %s dev=%s mode=%d\n", dev->is_dvd()?"DVD":"disk",
391 archive_name.c_str(), mode);
393 if (dev->VolCatInfo.VolCatName[0] == 0) {
394 Mmsg(dev->errmsg, _("Could not open file device %s. No Volume name given.\n"),
401 if (dev->part == 0) {
406 /* if num_parts has not been set, but VolCatInfo is available, copy
407 * it from the VolCatInfo.VolCatParts */
408 if (dev->num_parts < dev->VolCatInfo.VolCatParts) {
409 dev->num_parts = dev->VolCatInfo.VolCatParts;
412 get_filename(dev, dev->VolCatInfo.VolCatName, archive_name);
414 if (mount_dev(dev, 1) < 0) {
415 Mmsg(dev->errmsg, _("Could not mount device %s.\n"),
417 Emsg0(M_FATAL, 0, dev->errmsg);
422 get_filename(dev, dev->VolCatInfo.VolCatName, archive_name);
425 Dmsg3(29, "open dev: %s dev=%s mode=%d\n", dev->is_dvd()?"DVD":"disk",
426 archive_name.c_str(), mode);
427 dev->openmode = mode;
430 * If we are not trying to access the last part, set mode to
431 * OPEN_READ_ONLY as writing would be an error.
433 if (dev->part < dev->num_parts) {
434 mode = OPEN_READ_ONLY;
437 if (mode == OPEN_READ_WRITE) {
438 dev->mode = O_CREAT | O_RDWR | O_BINARY;
439 } else if (mode == OPEN_READ_ONLY) {
440 dev->mode = O_RDONLY | O_BINARY;
441 } else if (mode == OPEN_WRITE_ONLY) {
442 dev->mode = O_WRONLY | O_BINARY;
444 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
446 /* If creating file, give 0640 permissions */
447 Dmsg2(29, "open(%s, 0x%x, 0640)\n", archive_name.c_str(), dev->mode);
448 if ((dev->fd = open(archive_name.c_str(), dev->mode, 0640)) < 0) {
450 dev->dev_errno = errno;
451 Mmsg2(dev->errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
453 Emsg0(M_FATAL, 0, dev->errmsg);
456 dev->state |= ST_OPENED;
458 update_pos_dev(dev); /* update position */
459 if (fstat(dev->fd, &filestat) < 0) {
461 dev->dev_errno = errno;
462 Mmsg2(dev->errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
464 Emsg0(M_FATAL, 0, dev->errmsg);
466 dev->part_size = filestat.st_size;
469 Dmsg5(29, "open dev: %s fd=%d opened, part=%d/%d, part_size=%u\n",
470 dev->is_dvd()?"DVD":"disk", dev->fd, dev->part, dev->num_parts,
472 if (dev->is_dvd() && (mode != OPEN_READ_ONLY) &&
473 (dev->free_space_errno == 0 || dev->num_parts == dev->part)) {
474 update_free_space_dev(dev);
480 bool _rewind_dev(char *file, int line, DEVICE *dev)
482 Dmsg2(100, "rewind_dev called from %s:%d\n", file, line);
483 return rewind_dev(dev);
489 * Returns: true on success
492 bool rewind_dev(DEVICE *dev)
497 Dmsg1(29, "rewind_dev %s\n", dev->print_name());
499 dev->dev_errno = EBADF;
500 Mmsg1(dev->errmsg, _("Bad call to rewind_dev. Device %s not open\n"),
502 Emsg0(M_ABORT, 0, dev->errmsg);
505 dev->state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
506 dev->block_num = dev->file = 0;
509 if (dev->is_tape()) {
510 mt_com.mt_op = MTREW;
512 /* If we get an I/O error on rewind, it is probably because
513 * the drive is actually busy. We loop for (about 5 minutes)
514 * retrying every 5 seconds.
516 for (i=dev->max_rewind_wait; ; i -= 5) {
517 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
519 clrerror_dev(dev, MTREW);
520 if (i == dev->max_rewind_wait) {
521 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
523 if (dev->dev_errno == EIO && i > 0) {
524 Dmsg0(200, "Sleeping 5 seconds.\n");
528 Mmsg2(dev->errmsg, _("Rewind error on %s. ERR=%s.\n"),
529 dev->print_name(), be.strerror());
534 } else if (dev->is_file()) {
535 if (lseek_dev(dev, (off_t)0, SEEK_SET) < 0) {
537 dev->dev_errno = errno;
538 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
539 dev->print_name(), be.strerror());
546 void DEVICE::block(int why)
549 block_device(this, why);
553 void DEVICE::unblock()
556 unblock_device(this);
561 * Called to indicate that we have just read an
562 * EOF from the device.
564 void DEVICE::set_ateof()
574 * Called to indicate we are now at the end of the tape, and
575 * writing is not possible.
577 void DEVICE::set_ateot()
579 /* Make tape effectively read-only */
580 state |= (ST_EOF|ST_EOT|ST_WEOT);
585 * Position device to end of medium (end of data)
586 * Returns: true on succes
593 struct mtget mt_stat;
598 dev->dev_errno = EBADF;
599 Mmsg1(dev->errmsg, _("Bad call to eod_dev. Device %s not open\n"),
604 #if defined (__digital__) && defined (__unix__)
605 return fsf_dev(dev, dev->VolCatInfo.VolCatFiles);
608 Dmsg0(29, "eod_dev\n");
612 dev->state &= ~(ST_EOF); /* remove EOF flags */
613 dev->block_num = dev->file = 0;
616 if (dev->state & (ST_FIFO | ST_PROG)) {
619 if (!dev->is_tape()) {
620 pos = lseek_dev(dev, (off_t)0, SEEK_END);
621 // Dmsg1(100, "====== Seek to %lld\n", pos);
624 dev->state |= ST_EOT;
627 dev->dev_errno = errno;
629 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
630 dev->print_name(), be.strerror());
634 if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
635 Dmsg0(100,"Using FAST FSF for EOM\n");
636 /* If unknown position, rewind */
637 if (!dev_get_os_pos(dev, &mt_stat)) {
638 if (!rewind_dev(dev)) {
642 mt_com.mt_op = MTFSF;
644 * ***FIXME*** fix code to handle case that INT16_MAX is
647 mt_com.mt_count = INT16_MAX; /* use big positive number */
648 if (mt_com.mt_count < 0) {
649 mt_com.mt_count = INT16_MAX; /* brain damaged system */
653 if (dev_cap(dev, CAP_MTIOCGET) && (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM))) {
654 if (dev_cap(dev, CAP_EOM)) {
655 Dmsg0(100,"Using EOM for EOM\n");
656 mt_com.mt_op = MTEOM;
660 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
662 clrerror_dev(dev, mt_com.mt_op);
663 Dmsg1(50, "ioctl error: %s\n", be.strerror());
665 Mmsg2(dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
666 dev->print_name(), be.strerror());
670 if (!dev_get_os_pos(dev, &mt_stat)) {
672 clrerror_dev(dev, -1);
673 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
674 dev->print_name(), be.strerror());
677 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
679 dev->file = mt_stat.mt_fileno;
685 * Rewind then use FSF until EOT reached
687 if (!rewind_dev(dev)) {
691 * Move file by file to the end of the tape
694 for (file_num=dev->file; !dev->at_eot(); file_num++) {
695 Dmsg0(200, "eod_dev: doing fsf 1\n");
696 if (!fsf_dev(dev, 1)) {
697 Dmsg0(200, "fsf_dev error.\n");
701 * Avoid infinite loop. ***FIXME*** possibly add code
702 * to set EOD or to turn off CAP_FASTFSF if on.
704 if (file_num == (int)dev->file) {
705 struct mtget mt_stat;
706 Dmsg1(100, "fsf_dev did not advance from file %d\n", file_num);
707 if (dev_get_os_pos(dev, &mt_stat)) {
708 Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
710 dev->file = mt_stat.mt_fileno;
717 * Some drivers leave us after second EOF when doing
718 * MTEOM, so we must backup so that appending overwrites
721 if (dev_cap(dev, CAP_BSFATEOM)) {
722 struct mtget mt_stat;
723 /* Backup over EOF */
724 ok = bsf_dev(dev, 1);
725 /* If BSF worked and fileno is known (not -1), set file */
726 if (dev_get_os_pos(dev, &mt_stat)) {
727 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
728 dev->file = mt_stat.mt_fileno;
730 dev->file++; /* wing it -- not correct on all OSes */
733 update_pos_dev(dev); /* update position */
735 Dmsg1(200, "EOD dev->file=%d\n", dev->file);
740 * Set the position of the device -- only for files
741 * For other devices, there is no generic way to do it.
742 * Returns: true on succes
745 bool update_pos_dev(DEVICE *dev)
751 dev->dev_errno = EBADF;
752 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
753 Emsg0(M_FATAL, 0, dev->errmsg);
757 /* Find out where we are */
758 if (dev->is_file()) {
761 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
764 dev->dev_errno = errno;
765 Pmsg1(000, "Seek error: ERR=%s\n", be.strerror());
766 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
767 dev->print_name(), be.strerror());
770 dev->file_addr = pos;
778 * Return the status of the device. This was meant
779 * to be a generic routine. Unfortunately, it doesn't
780 * seem possible (at least I do not know how to do it
781 * currently), which means that for the moment, this
782 * routine has very little value.
786 uint32_t status_dev(DEVICE *dev)
788 struct mtget mt_stat;
791 if (dev->state & (ST_EOT | ST_WEOT)) {
795 if (dev->state & ST_EOF) {
799 if (dev->is_tape()) {
801 Pmsg0(-20," Bacula status:");
802 Pmsg2(-20," file=%d block=%d\n", dev->file, dev->block_num);
803 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
805 dev->dev_errno = errno;
806 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
807 dev->print_name(), be.strerror());
810 Pmsg0(-20, " Device status:");
812 #if defined(HAVE_LINUX_OS)
813 if (GMT_EOF(mt_stat.mt_gstat)) {
817 if (GMT_BOT(mt_stat.mt_gstat)) {
821 if (GMT_EOT(mt_stat.mt_gstat)) {
825 if (GMT_SM(mt_stat.mt_gstat)) {
829 if (GMT_EOD(mt_stat.mt_gstat)) {
833 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
835 Pmsg0(-20, " WR_PROT");
837 if (GMT_ONLINE(mt_stat.mt_gstat)) {
839 Pmsg0(-20, " ONLINE");
841 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
843 Pmsg0(-20, " DR_OPEN");
845 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
846 stat |= BMT_IM_REP_EN;
847 Pmsg0(-20, " IM_REP_EN");
849 #endif /* !SunOS && !OSF */
850 if (dev_cap(dev, CAP_MTIOCGET)) {
851 Pmsg2(-20, " file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
853 Pmsg2(-20, " file=%d block=%d\n", -1, -1);
856 stat |= BMT_ONLINE | BMT_BOT;
863 * Load medium in device
864 * Returns: true on success
867 bool load_dev(DEVICE *dev)
874 dev->dev_errno = EBADF;
875 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
876 Emsg0(M_FATAL, 0, dev->errmsg);
879 if (!(dev->is_tape())) {
883 Dmsg0(200, "stored: MTLOAD command not available\n");
885 dev->dev_errno = ENOTTY; /* function not available */
886 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
887 dev->print_name(), be.strerror());
891 dev->block_num = dev->file = 0;
894 mt_com.mt_op = MTLOAD;
896 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
898 dev->dev_errno = errno;
899 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
900 dev->print_name(), be.strerror());
908 * Rewind device and put it offline
909 * Returns: true on success
912 bool offline_dev(DEVICE *dev)
917 dev->dev_errno = EBADF;
918 Mmsg0(dev->errmsg, _("Bad call to offline_dev. Device not open\n"));
919 Emsg0(M_FATAL, 0, dev->errmsg);
922 if (!(dev->is_tape())) {
926 dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
927 dev->block_num = dev->file = 0;
932 mt_com.mt_op = MTUNLOCK;
934 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
936 mt_com.mt_op = MTOFFL;
938 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
940 dev->dev_errno = errno;
941 Mmsg2(dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
942 dev->print_name(), be.strerror());
945 Dmsg1(100, "Offlined device %s\n", dev->print_name());
949 bool offline_or_rewind_dev(DEVICE *dev)
954 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
955 return offline_dev(dev);
958 * Note, this rewind probably should not be here (it wasn't
959 * in prior versions of Bacula), but on FreeBSD, this is
960 * needed in the case the tape was "frozen" due to an error
961 * such as backspacing after writing and EOF. If it is not
962 * done, all future references to the drive get and I/O error.
964 clrerror_dev(dev, MTREW);
965 return rewind_dev(dev);
970 * Foward space a file
971 * Returns: true on success
975 fsf_dev(DEVICE *dev, int num)
977 struct mtget mt_stat;
982 dev->dev_errno = EBADF;
983 Mmsg0(dev->errmsg, _("Bad call to fsf_dev. Device not open\n"));
984 Emsg0(M_FATAL, 0, dev->errmsg);
988 if (!dev->is_tape()) {
991 if (dev->state & ST_EOT) {
993 Mmsg1(dev->errmsg, _("Device %s at End of Tape.\n"), dev->print_name());
996 if (dev->state & ST_EOF) {
997 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1000 Dmsg0(100, "fsf_dev\n");
1003 * If Fast forward space file is set, then we
1004 * use MTFSF to forward space and MTIOCGET
1005 * to get the file position. We assume that
1006 * the SCSI driver will ensure that we do not
1007 * forward space past the end of the medium.
1009 if (dev_cap(dev, CAP_FSF) && dev_cap(dev, CAP_MTIOCGET) && dev_cap(dev, CAP_FASTFSF)) {
1010 mt_com.mt_op = MTFSF;
1011 mt_com.mt_count = num;
1012 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1013 if (stat < 0 || !dev_get_os_pos(dev, &mt_stat)) {
1015 dev->state |= ST_EOT;
1016 Dmsg0(200, "Set ST_EOT\n");
1017 clrerror_dev(dev, MTFSF);
1018 Mmsg2(dev->errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1019 dev->print_name(), be.strerror());
1020 Dmsg1(200, "%s", dev->errmsg);
1023 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1025 dev->file = mt_stat.mt_fileno;
1029 * Here if CAP_FSF is set, and virtually all drives
1030 * these days support it, we read a record, then forward
1031 * space one file. Using this procedure, which is slow,
1032 * is the only way we can be sure that we don't read
1033 * two consecutive EOF marks, which means End of Data.
1035 } else if (dev_cap(dev, CAP_FSF)) {
1038 Dmsg0(200, "FSF has cap_fsf\n");
1039 if (dev->max_block_size == 0) {
1040 rbuf_len = DEFAULT_BLOCK_SIZE;
1042 rbuf_len = dev->max_block_size;
1044 rbuf = get_memory(rbuf_len);
1045 mt_com.mt_op = MTFSF;
1046 mt_com.mt_count = 1;
1047 while (num-- && !(dev->state & ST_EOT)) {
1048 Dmsg0(100, "Doing read before fsf\n");
1049 if ((stat = read(dev->fd, (char *)rbuf, rbuf_len)) < 0) {
1050 if (errno == ENOMEM) { /* tape record exceeds buf len */
1051 stat = rbuf_len; /* This is OK */
1054 dev->state |= ST_EOT;
1055 clrerror_dev(dev, -1);
1056 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev->dev_errno,
1058 Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1059 dev->print_name(), be.strerror());
1060 Dmsg1(100, "%s", dev->errmsg);
1064 if (stat == 0) { /* EOF */
1065 update_pos_dev(dev);
1066 Dmsg1(100, "End of File mark from read. File=%d\n", dev->file+1);
1067 /* Two reads of zero means end of tape */
1068 if (dev->state & ST_EOF) {
1069 dev->state |= ST_EOT;
1070 Dmsg0(100, "Set ST_EOT\n");
1076 } else { /* Got data */
1077 dev->state &= ~(ST_EOF|ST_EOT);
1080 Dmsg0(100, "Doing MTFSF\n");
1081 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1082 if (stat < 0) { /* error => EOT */
1084 dev->state |= ST_EOT;
1085 Dmsg0(100, "Set ST_EOT\n");
1086 clrerror_dev(dev, MTFSF);
1087 Mmsg2(dev->errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1088 dev->print_name(), be.strerror());
1089 Dmsg0(100, "Got < 0 for MTFSF\n");
1090 Dmsg1(100, "%s", dev->errmsg);
1098 * No FSF, so use FSR to simulate it
1101 Dmsg0(200, "Doing FSR for FSF\n");
1102 while (num-- && !(dev->state & ST_EOT)) {
1103 dev->fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1105 if (dev->state & ST_EOT) {
1107 Mmsg1(dev->errmsg, _("Device %s at End of Tape.\n"), dev->print_name());
1113 update_pos_dev(dev);
1114 Dmsg1(200, "Return %d from FSF\n", stat);
1115 if (dev->state & ST_EOF)
1116 Dmsg0(200, "ST_EOF set on exit FSF\n");
1117 if (dev->state & ST_EOT)
1118 Dmsg0(200, "ST_EOT set on exit FSF\n");
1119 Dmsg1(200, "Return from FSF file=%d\n", dev->file);
1124 * Backward space a file
1125 * Returns: false on failure
1129 bsf_dev(DEVICE *dev, int num)
1135 dev->dev_errno = EBADF;
1136 Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Device not open\n"));
1137 Emsg0(M_FATAL, 0, dev->errmsg);
1141 if (!dev->is_tape()) {
1142 Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1146 Dmsg0(29, "bsf_dev\n");
1147 dev->state &= ~(ST_EOT|ST_EOF);
1151 mt_com.mt_op = MTBSF;
1152 mt_com.mt_count = num;
1153 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1156 clrerror_dev(dev, MTBSF);
1157 Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1158 dev->print_name(), be.strerror());
1160 update_pos_dev(dev);
1166 * Foward space num records
1167 * Returns: false on failure
1170 bool DEVICE::fsr(int num)
1177 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1178 Emsg0(M_FATAL, 0, errmsg);
1185 if (!dev_cap(this, CAP_FSR)) {
1186 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1190 Dmsg1(29, "fsr %d\n", num);
1191 mt_com.mt_op = MTFSR;
1192 mt_com.mt_count = num;
1193 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1199 struct mtget mt_stat;
1200 clrerror_dev(this, MTFSR);
1201 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1202 if (dev_get_os_pos(this, &mt_stat)) {
1203 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1204 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1205 file = mt_stat.mt_fileno;
1206 block_num = mt_stat.mt_blkno;
1214 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1215 num, print_name(), be.strerror());
1217 update_pos_dev(this);
1222 * Backward space a record
1223 * Returns: false on failure
1227 bsr_dev(DEVICE *dev, int num)
1233 dev->dev_errno = EBADF;
1234 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1235 Emsg0(M_FATAL, 0, dev->errmsg);
1239 if (!dev->is_tape()) {
1243 if (!dev_cap(dev, CAP_BSR)) {
1244 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1248 Dmsg0(29, "bsr_dev\n");
1249 dev->block_num -= num;
1250 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1251 mt_com.mt_op = MTBSR;
1252 mt_com.mt_count = num;
1253 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1256 clrerror_dev(dev, MTBSR);
1257 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1258 dev->print_name(), be.strerror());
1260 update_pos_dev(dev);
1265 * Reposition the device to file, block
1266 * Returns: false on failure
1270 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1273 dev->dev_errno = EBADF;
1274 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1275 Emsg0(M_FATAL, 0, dev->errmsg);
1279 if (!dev->is_tape()) {
1280 off_t pos = (((off_t)file)<<32) + block;
1281 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1282 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1284 dev->dev_errno = errno;
1285 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1286 dev->print_name(), be.strerror());
1290 dev->block_num = block;
1291 dev->file_addr = pos;
1294 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1295 dev->file, dev->block_num, file, block);
1296 if (file < dev->file) {
1297 Dmsg0(100, "Rewind_dev\n");
1298 if (!rewind_dev(dev)) {
1302 if (file > dev->file) {
1303 Dmsg1(100, "fsf %d\n", file-dev->file);
1304 if (!fsf_dev(dev, file-dev->file)) {
1305 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1308 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1310 if (block < dev->block_num) {
1311 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1312 Dmsg0(100, "bsf_dev 1\n");
1314 Dmsg0(100, "fsf_dev 1\n");
1316 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1318 if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1319 /* Ignore errors as Bacula can read to the correct block */
1320 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1321 return dev->fsr(block-dev->block_num);
1329 * Write an end of file on the device
1330 * Returns: 0 on success
1331 * non-zero on failure
1334 weof_dev(DEVICE *dev, int num)
1338 Dmsg0(29, "weof_dev\n");
1341 dev->dev_errno = EBADF;
1342 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1343 Emsg0(M_FATAL, 0, dev->errmsg);
1348 if (!dev->is_tape()) {
1351 if (!dev->can_append()) {
1352 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1353 Emsg0(M_FATAL, 0, dev->errmsg);
1357 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1358 mt_com.mt_op = MTWEOF;
1359 mt_com.mt_count = num;
1360 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1367 clrerror_dev(dev, MTWEOF);
1369 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1370 dev->print_name(), be.strerror());
1377 * Return string message with last error in English
1378 * Be careful not to call this routine from within dev.c
1379 * while editing an Mmsg() or you will end up in a recursive
1380 * loop creating a Segmentation Violation.
1383 strerror_dev(DEVICE *dev)
1390 * If implemented in system, clear the tape
1394 clrerror_dev(DEVICE *dev, int func)
1396 const char *msg = NULL;
1397 struct mtget mt_stat;
1400 dev->dev_errno = errno; /* save errno */
1402 dev->VolCatInfo.VolCatErrors++;
1405 if (!dev->is_tape()) {
1408 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1411 Emsg0(M_ABORT, 0, "Got ENOTTY on read/write!\n");
1415 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1420 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1425 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1429 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1433 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1437 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1458 bsnprintf(buf, sizeof(buf), "unknown func code %d", func);
1463 dev->dev_errno = ENOSYS;
1464 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1465 Emsg0(M_ERROR, 0, dev->errmsg);
1468 /* On some systems such as NetBSD, this clears all errors */
1469 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1471 /* Found on Linux */
1475 mt_com.mt_op = MTIOCLRERR;
1476 mt_com.mt_count = 1;
1477 /* Clear any error condition on the tape */
1478 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1479 Dmsg0(200, "Did MTIOCLRERR\n");
1483 /* Typically on FreeBSD */
1486 /* Read and clear SCSI error status */
1487 union mterrstat mt_errstat;
1488 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1489 strerror(dev->dev_errno));
1490 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1494 /* Clear Subsystem Exception OSF1 */
1498 mt_com.mt_op = MTCSE;
1499 mt_com.mt_count = 1;
1500 /* Clear any error condition on the tape */
1501 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1502 Dmsg0(200, "Did MTCSE\n");
1508 * Flush buffer contents
1511 int flush_dev(DEVICE *dev)
1516 static void do_close(DEVICE *dev)
1519 Dmsg1(29, "really close_dev %s\n", dev->print_name());
1524 if (unmount_dev(dev, 1) < 0) {
1525 Dmsg1(0, "Cannot unmount device %s.\n", dev->print_name());
1528 /* Remove the last part file if it is empty */
1529 if (dev->can_append() && (dev->num_parts > 0)) {
1531 POOL_MEM archive_name(PM_FNAME);
1532 dev->part = dev->num_parts;
1533 get_filename(dev, dev->VolCatInfo.VolCatName, archive_name);
1534 /* Check that the part file is empty */
1535 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1536 unlink(archive_name.c_str());
1540 /* Clean up device packet so it can be reused */
1542 dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1543 dev->label_type = B_BACULA_LABEL;
1544 dev->file = dev->block_num = 0;
1549 dev->part_start = 0;
1550 dev->EndFile = dev->EndBlock = 0;
1551 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1552 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1554 stop_thread_timer(dev->tid);
1564 void DEVICE::close()
1566 /*if (fd >= 0 && use_count == 1) {*/
1567 /* No need to check if fd >= 0: it is checked again
1568 * in do_close, and do_close MUST be called for volumes
1569 * splitted in parts, even if fd == -1. */
1570 if (use_count == 1) {
1572 } else if (use_count > 0) {
1577 ASSERT(use_count >= 0);
1582 bool truncate_dev(DEVICE *dev)
1584 Dmsg1(100, "truncate_dev %s\n", dev->print_name());
1585 if (dev->is_tape()) {
1586 return true; /* we don't really truncate tapes */
1587 /* maybe we should rewind and write and eof ???? */
1590 /* If there is more than one part, open the first one, and then truncate it. */
1591 if (dev->num_parts > 0) {
1593 dev->VolCatInfo.VolCatParts = 0;
1594 if (open_first_part(dev, OPEN_READ_WRITE) < 0) {
1596 Mmsg1(dev->errmsg, "Unable to truncate device, because I'm unable to open the first part. ERR=%s\n", be.strerror());
1600 if (ftruncate(dev->fd, 0) != 0) {
1602 Mmsg1(dev->errmsg, _("Unable to truncate device. ERR=%s\n"), be.strerror());
1608 /* Return the resource name for the device */
1609 const char *DEVICE::name() const
1611 return device->hdr.name;
1615 dev_vol_name(DEVICE *dev)
1617 return dev->VolCatInfo.VolCatName;
1620 uint32_t dev_block(DEVICE *dev)
1622 update_pos_dev(dev);
1623 return dev->block_num;
1626 uint32_t dev_file(DEVICE *dev)
1628 update_pos_dev(dev);
1633 * Free memory allocated for the device
1636 term_dev(DEVICE *dev)
1639 dev->dev_errno = EBADF;
1640 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1641 Emsg0(M_FATAL, 0, dev->errmsg);
1645 Dmsg0(29, "term_dev\n");
1646 if (dev->dev_name) {
1647 free_memory(dev->dev_name);
1648 dev->dev_name = NULL;
1650 if (dev->prt_name) {
1651 free_memory(dev->prt_name);
1652 dev->prt_name = NULL;
1655 free_pool_memory(dev->errmsg);
1658 pthread_mutex_destroy(&dev->mutex);
1659 pthread_cond_destroy(&dev->wait);
1660 pthread_cond_destroy(&dev->wait_next_vol);
1661 pthread_mutex_destroy(&dev->spool_mutex);
1662 rwl_destroy(&dev->lock);
1663 if (dev->attached_dcrs) {
1664 delete dev->attached_dcrs;
1665 dev->attached_dcrs = NULL;
1667 if (dev->state & ST_MALLOC) {
1668 free_pool_memory((POOLMEM *)dev);
1673 * This routine initializes the device wait timers
1675 void init_device_wait_timers(DCR *dcr)
1677 DEVICE *dev = dcr->dev;
1678 JCR *jcr = dcr->jcr;
1680 /* ******FIXME******* put these on config variables */
1681 dev->min_wait = 60 * 60;
1682 dev->max_wait = 24 * 60 * 60;
1683 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1684 dev->wait_sec = dev->min_wait;
1685 dev->rem_wait_sec = dev->wait_sec;
1688 dev->BadVolName[0] = 0;
1690 jcr->min_wait = 60 * 60;
1691 jcr->max_wait = 24 * 60 * 60;
1692 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1693 jcr->wait_sec = jcr->min_wait;
1694 jcr->rem_wait_sec = jcr->wait_sec;
1699 void init_jcr_device_wait_timers(JCR *jcr)
1701 /* ******FIXME******* put these on config variables */
1702 jcr->min_wait = 60 * 60;
1703 jcr->max_wait = 24 * 60 * 60;
1704 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1705 jcr->wait_sec = jcr->min_wait;
1706 jcr->rem_wait_sec = jcr->wait_sec;
1712 * The dev timers are used for waiting on a particular device
1714 * Returns: true if time doubled
1715 * false if max time expired
1717 bool double_dev_wait_time(DEVICE *dev)
1719 dev->wait_sec *= 2; /* double wait time */
1720 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
1721 dev->wait_sec = dev->max_wait;
1724 dev->rem_wait_sec = dev->wait_sec;
1725 if (dev->num_wait >= dev->max_num_wait) {
1732 void set_os_device_parameters(DEVICE *dev)
1734 #ifdef HAVE_LINUX_OS
1736 if (dev->min_block_size == dev->max_block_size &&
1737 dev->min_block_size == 0) { /* variable block mode */
1738 mt_com.mt_op = MTSETBLK;
1739 mt_com.mt_count = 0;
1740 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1741 clrerror_dev(dev, MTSETBLK);
1743 mt_com.mt_op = MTSETDRVBUFFER;
1744 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
1745 if (!dev_cap(dev, CAP_TWOEOF)) {
1746 mt_com.mt_count |= MT_ST_TWO_FM;
1748 if (dev_cap(dev, CAP_EOM)) {
1749 mt_com.mt_count |= MT_ST_FAST_MTEOM;
1751 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1752 clrerror_dev(dev, MTSETBLK);
1758 #ifdef HAVE_NETBSD_OS
1760 if (dev->min_block_size == dev->max_block_size &&
1761 dev->min_block_size == 0) { /* variable block mode */
1762 mt_com.mt_op = MTSETBSIZ;
1763 mt_com.mt_count = 0;
1764 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1765 clrerror_dev(dev, MTSETBSIZ);
1767 /* Get notified at logical end of tape */
1768 mt_com.mt_op = MTEWARN;
1769 mt_com.mt_count = 1;
1770 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1771 clrerror_dev(dev, MTEWARN);
1777 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
1779 if (dev->min_block_size == dev->max_block_size &&
1780 dev->min_block_size == 0) { /* variable block mode */
1781 mt_com.mt_op = MTSETBSIZ;
1782 mt_com.mt_count = 0;
1783 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1784 clrerror_dev(dev, MTSETBSIZ);
1792 if (dev->min_block_size == dev->max_block_size &&
1793 dev->min_block_size == 0) { /* variable block mode */
1794 mt_com.mt_op = MTSRSZ;
1795 mt_com.mt_count = 0;
1796 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1797 clrerror_dev(dev, MTSRSZ);
1804 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
1806 return dev_cap(dev, CAP_MTIOCGET) &&
1807 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
1808 mt_stat->mt_fileno >= 0;