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 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
478 Emsg0(M_FATAL, 0, errmsg);
483 Dmsg5(29, "open dev: %s dev=%s mode=%s part=%d npart=%d\n",
484 is_dvd()?"DVD":"disk", archive_name.c_str(), mode_to_str(omode),
487 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
490 * If we are not trying to access the last part, set mode to
491 * OPEN_READ_ONLY as writing would be an error.
493 if (part < num_parts) {
494 omode = OPEN_READ_ONLY;
499 * If we are opening it read-only, it is *probably* on the
500 * DVD, so try the DVD first, otherwise look in the spool dir.
502 if (omode == OPEN_READ_ONLY) {
503 make_mounted_dvd_filename(this, archive_name);
505 make_spooled_dvd_filename(this, archive_name);
508 /* If creating file, give 0640 permissions */
509 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
510 archive_name.c_str(), mode);
511 /* Use system open() */
512 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
515 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
517 Dmsg1(29, "open failed: %s", errmsg);
518 if (omode == OPEN_READ_ONLY) {
519 make_spooled_dvd_filename(this, archive_name);
520 /* Use system open() */
521 fd = ::open(archive_name.c_str(), mode, 0640); /* try on spool */
524 Dmsg1(100, "after open fd=%d\n", fd);
526 /* Get size of file */
527 if (fstat(fd, &filestat) < 0) {
530 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
532 Dmsg1(29, "open failed: %s", errmsg);
533 /* Use system close() */
537 part_size = filestat.st_size;
541 update_pos_dev(this); /* update position */
542 /* Check if just created Volume part */
543 if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
546 VolCatInfo.VolCatParts = num_parts;
548 if (part == 0) { /* we must have opened the first part */
559 bool _rewind_dev(char *file, int line, DEVICE *dev)
561 Dmsg3(100, "rewind_dev fd=%d called from %s:%d\n", dev->fd, file, line);
562 return rewind_dev(dev);
568 * Returns: true on success
571 bool rewind_dev(DEVICE *dev)
576 Dmsg2(29, "rewind_dev fd=%d %s\n", dev->fd, dev->print_name());
578 dev->dev_errno = EBADF;
579 Mmsg1(dev->errmsg, _("Bad call to rewind_dev. Device %s not open\n"),
581 Emsg0(M_ABORT, 0, dev->errmsg);
584 dev->state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
585 dev->block_num = dev->file = 0;
588 if (dev->is_tape()) {
589 mt_com.mt_op = MTREW;
591 /* If we get an I/O error on rewind, it is probably because
592 * the drive is actually busy. We loop for (about 5 minutes)
593 * retrying every 5 seconds.
595 for (i=dev->max_rewind_wait; ; i -= 5) {
596 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
598 clrerror_dev(dev, MTREW);
599 if (i == dev->max_rewind_wait) {
600 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
602 if (dev->dev_errno == EIO && i > 0) {
603 Dmsg0(200, "Sleeping 5 seconds.\n");
607 Mmsg2(dev->errmsg, _("Rewind error on %s. ERR=%s.\n"),
608 dev->print_name(), be.strerror());
613 } else if (dev->is_file()) {
614 if (lseek_dev(dev, (off_t)0, SEEK_SET) < 0) {
616 dev->dev_errno = errno;
617 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
618 dev->print_name(), be.strerror());
625 void DEVICE::block(int why)
628 block_device(this, why);
632 void DEVICE::unblock()
635 unblock_device(this);
639 const char *DEVICE::print_blocked() const
641 switch (dev_blocked) {
642 case BST_NOT_BLOCKED:
643 return "BST_NOT_BLOCKED";
645 return "BST_UNMOUNTED";
646 case BST_WAITING_FOR_SYSOP:
647 return "BST_WAITING_FOR_SYSOP";
648 case BST_DOING_ACQUIRE:
649 return "BST_DOING_ACQUIRE";
650 case BST_WRITING_LABEL:
651 return "BST_WRITING_LABEL";
652 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
653 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
657 return "unknown blocked code";
662 * Called to indicate that we have just read an
663 * EOF from the device.
665 void DEVICE::set_ateof()
675 * Called to indicate we are now at the end of the tape, and
676 * writing is not possible.
678 void DEVICE::set_ateot()
680 /* Make tape effectively read-only */
681 state |= (ST_EOF|ST_EOT|ST_WEOT);
686 * Position device to end of medium (end of data)
687 * Returns: true on succes
694 struct mtget mt_stat;
699 dev->dev_errno = EBADF;
700 Mmsg1(dev->errmsg, _("Bad call to eod_dev. Device %s not open\n"),
705 #if defined (__digital__) && defined (__unix__)
706 return dev->fsf(dev->VolCatInfo.VolCatFiles);
709 Dmsg0(29, "eod_dev\n");
713 dev->state &= ~(ST_EOF); /* remove EOF flags */
714 dev->block_num = dev->file = 0;
717 if (dev->state & (ST_FIFO | ST_PROG)) {
720 if (!dev->is_tape()) {
721 pos = lseek_dev(dev, (off_t)0, SEEK_END);
722 // Dmsg1(100, "====== Seek to %lld\n", pos);
725 dev->state |= ST_EOT;
728 dev->dev_errno = errno;
730 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
731 dev->print_name(), be.strerror());
735 if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
736 Dmsg0(100,"Using FAST FSF for EOM\n");
737 /* If unknown position, rewind */
738 if (!dev_get_os_pos(dev, &mt_stat)) {
739 if (!rewind_dev(dev)) {
743 mt_com.mt_op = MTFSF;
745 * ***FIXME*** fix code to handle case that INT16_MAX is
748 mt_com.mt_count = INT16_MAX; /* use big positive number */
749 if (mt_com.mt_count < 0) {
750 mt_com.mt_count = INT16_MAX; /* brain damaged system */
754 if (dev_cap(dev, CAP_MTIOCGET) && (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM))) {
755 if (dev_cap(dev, CAP_EOM)) {
756 Dmsg0(100,"Using EOM for EOM\n");
757 mt_com.mt_op = MTEOM;
761 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
763 clrerror_dev(dev, mt_com.mt_op);
764 Dmsg1(50, "ioctl error: %s\n", be.strerror());
766 Mmsg2(dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
767 dev->print_name(), be.strerror());
771 if (!dev_get_os_pos(dev, &mt_stat)) {
773 clrerror_dev(dev, -1);
774 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
775 dev->print_name(), be.strerror());
778 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
780 dev->file = mt_stat.mt_fileno;
786 * Rewind then use FSF until EOT reached
788 if (!rewind_dev(dev)) {
792 * Move file by file to the end of the tape
795 for (file_num=dev->file; !dev->at_eot(); file_num++) {
796 Dmsg0(200, "eod_dev: doing fsf 1\n");
798 Dmsg0(200, "fsf error.\n");
802 * Avoid infinite loop. ***FIXME*** possibly add code
803 * to set EOD or to turn off CAP_FASTFSF if on.
805 if (file_num == (int)dev->file) {
806 struct mtget mt_stat;
807 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
808 if (dev_get_os_pos(dev, &mt_stat)) {
809 Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
811 dev->file = mt_stat.mt_fileno;
818 * Some drivers leave us after second EOF when doing
819 * MTEOM, so we must backup so that appending overwrites
822 if (dev_cap(dev, CAP_BSFATEOM)) {
823 struct mtget mt_stat;
824 /* Backup over EOF */
825 ok = bsf_dev(dev, 1);
826 /* If BSF worked and fileno is known (not -1), set file */
827 if (dev_get_os_pos(dev, &mt_stat)) {
828 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
829 dev->file = mt_stat.mt_fileno;
831 dev->file++; /* wing it -- not correct on all OSes */
834 update_pos_dev(dev); /* update position */
836 Dmsg1(200, "EOD dev->file=%d\n", dev->file);
841 * Set the position of the device -- only for files
842 * For other devices, there is no generic way to do it.
843 * Returns: true on succes
846 bool update_pos_dev(DEVICE *dev)
852 dev->dev_errno = EBADF;
853 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
854 Emsg0(M_FATAL, 0, dev->errmsg);
858 /* Find out where we are */
859 if (dev->is_file()) {
862 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
865 dev->dev_errno = errno;
866 Pmsg1(000, "Seek error: ERR=%s\n", be.strerror());
867 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
868 dev->print_name(), be.strerror());
871 dev->file_addr = pos;
879 * Return the status of the device. This was meant
880 * to be a generic routine. Unfortunately, it doesn't
881 * seem possible (at least I do not know how to do it
882 * currently), which means that for the moment, this
883 * routine has very little value.
887 uint32_t status_dev(DEVICE *dev)
889 struct mtget mt_stat;
892 if (dev->state & (ST_EOT | ST_WEOT)) {
896 if (dev->state & ST_EOF) {
900 if (dev->is_tape()) {
902 Pmsg0(-20," Bacula status:");
903 Pmsg2(-20," file=%d block=%d\n", dev->file, dev->block_num);
904 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
906 dev->dev_errno = errno;
907 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
908 dev->print_name(), be.strerror());
911 Pmsg0(-20, " Device status:");
913 #if defined(HAVE_LINUX_OS)
914 if (GMT_EOF(mt_stat.mt_gstat)) {
918 if (GMT_BOT(mt_stat.mt_gstat)) {
922 if (GMT_EOT(mt_stat.mt_gstat)) {
926 if (GMT_SM(mt_stat.mt_gstat)) {
930 if (GMT_EOD(mt_stat.mt_gstat)) {
934 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
936 Pmsg0(-20, " WR_PROT");
938 if (GMT_ONLINE(mt_stat.mt_gstat)) {
940 Pmsg0(-20, " ONLINE");
942 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
944 Pmsg0(-20, " DR_OPEN");
946 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
947 stat |= BMT_IM_REP_EN;
948 Pmsg0(-20, " IM_REP_EN");
950 #endif /* !SunOS && !OSF */
951 if (dev_cap(dev, CAP_MTIOCGET)) {
952 Pmsg2(-20, " file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
954 Pmsg2(-20, " file=%d block=%d\n", -1, -1);
957 stat |= BMT_ONLINE | BMT_BOT;
964 * Load medium in device
965 * Returns: true on success
968 bool load_dev(DEVICE *dev)
975 dev->dev_errno = EBADF;
976 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
977 Emsg0(M_FATAL, 0, dev->errmsg);
980 if (!(dev->is_tape())) {
984 Dmsg0(200, "stored: MTLOAD command not available\n");
986 dev->dev_errno = ENOTTY; /* function not available */
987 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
988 dev->print_name(), be.strerror());
992 dev->block_num = dev->file = 0;
995 mt_com.mt_op = MTLOAD;
997 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
999 dev->dev_errno = errno;
1000 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1001 dev->print_name(), be.strerror());
1009 * Rewind device and put it offline
1010 * Returns: true on success
1013 bool offline_dev(DEVICE *dev)
1018 dev->dev_errno = EBADF;
1019 Mmsg0(dev->errmsg, _("Bad call to offline_dev. Device not open\n"));
1020 Emsg0(M_FATAL, 0, dev->errmsg);
1023 if (!(dev->is_tape())) {
1027 dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1028 dev->block_num = dev->file = 0;
1033 mt_com.mt_op = MTUNLOCK;
1034 mt_com.mt_count = 1;
1035 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1037 mt_com.mt_op = MTOFFL;
1038 mt_com.mt_count = 1;
1039 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1041 dev->dev_errno = errno;
1042 Mmsg2(dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1043 dev->print_name(), be.strerror());
1046 Dmsg1(100, "Offlined device %s\n", dev->print_name());
1050 bool offline_or_rewind_dev(DEVICE *dev)
1055 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1056 return offline_dev(dev);
1059 * Note, this rewind probably should not be here (it wasn't
1060 * in prior versions of Bacula), but on FreeBSD, this is
1061 * needed in the case the tape was "frozen" due to an error
1062 * such as backspacing after writing and EOF. If it is not
1063 * done, all future references to the drive get and I/O error.
1065 clrerror_dev(dev, MTREW);
1066 return rewind_dev(dev);
1071 * Foward space a file
1072 * Returns: true on success
1075 bool DEVICE::fsf(int num)
1077 struct mtget mt_stat;
1083 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1084 Emsg0(M_FATAL, 0, errmsg);
1093 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1097 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1100 Dmsg0(100, "fsf\n");
1103 * If Fast forward space file is set, then we
1104 * use MTFSF to forward space and MTIOCGET
1105 * to get the file position. We assume that
1106 * the SCSI driver will ensure that we do not
1107 * forward space past the end of the medium.
1109 if (dev_cap(this, CAP_FSF) && dev_cap(this, CAP_MTIOCGET) && dev_cap(this, CAP_FASTFSF)) {
1110 mt_com.mt_op = MTFSF;
1111 mt_com.mt_count = num;
1112 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1113 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1116 Dmsg0(200, "Set ST_EOT\n");
1117 clrerror_dev(this, MTFSF);
1118 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1119 print_name(), be.strerror());
1120 Dmsg1(200, "%s", errmsg);
1123 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1125 file = mt_stat.mt_fileno;
1129 * Here if CAP_FSF is set, and virtually all drives
1130 * these days support it, we read a record, then forward
1131 * space one file. Using this procedure, which is slow,
1132 * is the only way we can be sure that we don't read
1133 * two consecutive EOF marks, which means End of Data.
1135 } else if (dev_cap(this, CAP_FSF)) {
1138 Dmsg0(200, "FSF has cap_fsf\n");
1139 if (max_block_size == 0) {
1140 rbuf_len = DEFAULT_BLOCK_SIZE;
1142 rbuf_len = max_block_size;
1144 rbuf = get_memory(rbuf_len);
1145 mt_com.mt_op = MTFSF;
1146 mt_com.mt_count = 1;
1147 while (num-- && !at_eot()) {
1148 Dmsg0(100, "Doing read before fsf\n");
1149 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1150 if (errno == ENOMEM) { /* tape record exceeds buf len */
1151 stat = rbuf_len; /* This is OK */
1153 * On IBM drives, they return ENOSPC at EOM
1154 * instead of EOF status
1156 } else if (at_eof() && errno == ENOSPC) {
1161 clrerror_dev(this, -1);
1162 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1164 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1165 print_name(), be.strerror());
1166 Dmsg1(100, "%s", errmsg);
1170 if (stat == 0) { /* EOF */
1171 update_pos_dev(this);
1172 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1173 /* Two reads of zero means end of tape */
1176 Dmsg0(100, "Set ST_EOT\n");
1182 } else { /* Got data */
1187 Dmsg0(100, "Doing MTFSF\n");
1188 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1189 if (stat < 0) { /* error => EOT */
1192 Dmsg0(100, "Set ST_EOT\n");
1193 clrerror_dev(this, MTFSF);
1194 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1195 print_name(), be.strerror());
1196 Dmsg0(100, "Got < 0 for MTFSF\n");
1197 Dmsg1(100, "%s", errmsg);
1205 * No FSF, so use FSR to simulate it
1208 Dmsg0(200, "Doing FSR for FSF\n");
1209 while (num-- && !at_eot()) {
1210 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1214 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1220 update_pos_dev(this);
1221 Dmsg1(200, "Return %d from FSF\n", stat);
1223 Dmsg0(200, "ST_EOF set on exit FSF\n");
1225 Dmsg0(200, "ST_EOT set on exit FSF\n");
1226 Dmsg1(200, "Return from FSF file=%d\n", file);
1231 * Backward space a file
1232 * Returns: false on failure
1236 bsf_dev(DEVICE *dev, int num)
1242 dev->dev_errno = EBADF;
1243 Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Device not open\n"));
1244 Emsg0(M_FATAL, 0, dev->errmsg);
1248 if (!dev->is_tape()) {
1249 Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1253 Dmsg0(29, "bsf_dev\n");
1254 dev->state &= ~(ST_EOT|ST_EOF);
1258 mt_com.mt_op = MTBSF;
1259 mt_com.mt_count = num;
1260 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1263 clrerror_dev(dev, MTBSF);
1264 Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1265 dev->print_name(), be.strerror());
1267 update_pos_dev(dev);
1273 * Foward space num records
1274 * Returns: false on failure
1277 bool DEVICE::fsr(int num)
1284 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1285 Emsg0(M_FATAL, 0, errmsg);
1292 if (!dev_cap(this, CAP_FSR)) {
1293 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1297 Dmsg1(29, "fsr %d\n", num);
1298 mt_com.mt_op = MTFSR;
1299 mt_com.mt_count = num;
1300 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1306 struct mtget mt_stat;
1307 clrerror_dev(this, MTFSR);
1308 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1309 if (dev_get_os_pos(this, &mt_stat)) {
1310 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1311 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1312 file = mt_stat.mt_fileno;
1313 block_num = mt_stat.mt_blkno;
1321 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1322 num, print_name(), be.strerror());
1324 update_pos_dev(this);
1329 * Backward space a record
1330 * Returns: false on failure
1334 bsr_dev(DEVICE *dev, int num)
1340 dev->dev_errno = EBADF;
1341 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1342 Emsg0(M_FATAL, 0, dev->errmsg);
1346 if (!dev->is_tape()) {
1350 if (!dev_cap(dev, CAP_BSR)) {
1351 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1355 Dmsg0(29, "bsr_dev\n");
1356 dev->block_num -= num;
1357 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1358 mt_com.mt_op = MTBSR;
1359 mt_com.mt_count = num;
1360 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1363 clrerror_dev(dev, MTBSR);
1364 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1365 dev->print_name(), be.strerror());
1367 update_pos_dev(dev);
1372 * Reposition the device to file, block
1373 * Returns: false on failure
1377 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1380 dev->dev_errno = EBADF;
1381 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1382 Emsg0(M_FATAL, 0, dev->errmsg);
1386 if (!dev->is_tape()) {
1387 off_t pos = (((off_t)file)<<32) + block;
1388 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1389 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1391 dev->dev_errno = errno;
1392 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1393 dev->print_name(), be.strerror());
1397 dev->block_num = block;
1398 dev->file_addr = pos;
1401 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1402 dev->file, dev->block_num, file, block);
1403 if (file < dev->file) {
1404 Dmsg0(100, "Rewind_dev\n");
1405 if (!rewind_dev(dev)) {
1409 if (file > dev->file) {
1410 Dmsg1(100, "fsf %d\n", file-dev->file);
1411 if (!dev->fsf(file-dev->file)) {
1412 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1415 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1417 if (block < dev->block_num) {
1418 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1419 Dmsg0(100, "bsf_dev 1\n");
1421 Dmsg0(100, "fsf_dev 1\n");
1423 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1425 if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1426 /* Ignore errors as Bacula can read to the correct block */
1427 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1428 return dev->fsr(block-dev->block_num);
1436 * Write an end of file on the device
1437 * Returns: 0 on success
1438 * non-zero on failure
1441 weof_dev(DEVICE *dev, int num)
1445 Dmsg0(29, "weof_dev\n");
1448 dev->dev_errno = EBADF;
1449 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1450 Emsg0(M_FATAL, 0, dev->errmsg);
1455 if (!dev->is_tape()) {
1458 if (!dev->can_append()) {
1459 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1460 Emsg0(M_FATAL, 0, dev->errmsg);
1464 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1465 mt_com.mt_op = MTWEOF;
1466 mt_com.mt_count = num;
1467 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1474 clrerror_dev(dev, MTWEOF);
1476 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1477 dev->print_name(), be.strerror());
1484 * Return string message with last error in English
1485 * Be careful not to call this routine from within dev.c
1486 * while editing an Mmsg() or you will end up in a recursive
1487 * loop creating a Segmentation Violation.
1490 strerror_dev(DEVICE *dev)
1497 * If implemented in system, clear the tape
1501 clrerror_dev(DEVICE *dev, int func)
1503 const char *msg = NULL;
1504 struct mtget mt_stat;
1507 dev->dev_errno = errno; /* save errno */
1509 dev->VolCatInfo.VolCatErrors++;
1512 if (!dev->is_tape()) {
1515 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1518 Emsg0(M_ABORT, 0, "Got ENOTTY on read/write!\n");
1522 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1527 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1532 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1536 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1540 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1544 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1565 bsnprintf(buf, sizeof(buf), "unknown func code %d", func);
1570 dev->dev_errno = ENOSYS;
1571 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1572 Emsg0(M_ERROR, 0, dev->errmsg);
1575 /* On some systems such as NetBSD, this clears all errors */
1576 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1578 /* Found on Linux */
1582 mt_com.mt_op = MTIOCLRERR;
1583 mt_com.mt_count = 1;
1584 /* Clear any error condition on the tape */
1585 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1586 Dmsg0(200, "Did MTIOCLRERR\n");
1590 /* Typically on FreeBSD */
1593 /* Read and clear SCSI error status */
1594 union mterrstat mt_errstat;
1595 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1596 strerror(dev->dev_errno));
1597 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1601 /* Clear Subsystem Exception OSF1 */
1605 mt_com.mt_op = MTCSE;
1606 mt_com.mt_count = 1;
1607 /* Clear any error condition on the tape */
1608 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1609 Dmsg0(200, "Did MTCSE\n");
1615 * Flush buffer contents
1618 int flush_dev(DEVICE *dev)
1623 static void do_close(DEVICE *dev)
1626 Dmsg1(29, "really close_dev %s\n", dev->print_name());
1631 if (!unmount_dev(dev, 1)) {
1632 Dmsg1(0, "Cannot unmount device %s.\n", dev->print_name());
1635 /* Remove the last part file if it is empty */
1636 if (dev->can_append() && (dev->num_parts > 0)) {
1638 POOL_MEM archive_name(PM_FNAME);
1639 dev->part = dev->num_parts;
1640 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", dev->VolCatInfo.VolCatName);
1641 make_spooled_dvd_filename(dev, archive_name);
1642 /* Check that the part file is empty */
1643 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1644 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1645 unlink(archive_name.c_str());
1649 /* Clean up device packet so it can be reused */
1651 dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1652 dev->label_type = B_BACULA_LABEL;
1653 dev->file = dev->block_num = 0;
1659 dev->part_start = 0;
1660 dev->EndFile = dev->EndBlock = 0;
1661 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1662 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1664 stop_thread_timer(dev->tid);
1674 void DEVICE::close()
1676 /*if (fd >= 0 && use_count == 1) {*/
1677 /* No need to check if fd >= 0: it is checked again
1678 * in do_close, and do_close MUST be called for volumes
1679 * splitted in parts, even if fd == -1. */
1680 if (use_count == 1) {
1682 } else if (use_count > 0) {
1687 ASSERT(use_count >= 0);
1692 bool truncate_dev(DEVICE *dev)
1694 Dmsg1(100, "truncate_dev %s\n", dev->print_name());
1695 if (dev->is_tape()) {
1696 return true; /* we don't really truncate tapes */
1697 /* maybe we should rewind and write and eof ???? */
1700 if (dev->is_dvd()) {
1701 Mmsg1(dev->errmsg, _("Truncate DVD %s not supported.\n"), dev->print_name());
1702 return false; /* we cannot truncate DVDs */
1705 if (ftruncate(dev->fd, 0) != 0) {
1707 Mmsg2(dev->errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1708 dev->print_name(), be.strerror());
1714 /* Return the resource name for the device */
1715 const char *DEVICE::name() const
1717 return device->hdr.name;
1721 dev_vol_name(DEVICE *dev)
1723 return dev->VolCatInfo.VolCatName;
1726 uint32_t dev_block(DEVICE *dev)
1728 update_pos_dev(dev);
1729 return dev->block_num;
1732 uint32_t dev_file(DEVICE *dev)
1734 update_pos_dev(dev);
1739 * Free memory allocated for the device
1742 term_dev(DEVICE *dev)
1745 dev->dev_errno = EBADF;
1746 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1747 Emsg0(M_FATAL, 0, dev->errmsg);
1750 Dmsg1(29, "term_dev: %s\n", dev->print_name());
1752 if (dev->dev_name) {
1753 free_memory(dev->dev_name);
1754 dev->dev_name = NULL;
1756 if (dev->prt_name) {
1757 free_memory(dev->prt_name);
1758 dev->prt_name = NULL;
1761 free_pool_memory(dev->errmsg);
1764 pthread_mutex_destroy(&dev->mutex);
1765 pthread_cond_destroy(&dev->wait);
1766 pthread_cond_destroy(&dev->wait_next_vol);
1767 pthread_mutex_destroy(&dev->spool_mutex);
1768 rwl_destroy(&dev->lock);
1769 if (dev->attached_dcrs) {
1770 delete dev->attached_dcrs;
1771 dev->attached_dcrs = NULL;
1773 if (dev->state & ST_MALLOC) {
1774 free_pool_memory((POOLMEM *)dev);
1779 * This routine initializes the device wait timers
1781 void init_device_wait_timers(DCR *dcr)
1783 DEVICE *dev = dcr->dev;
1784 JCR *jcr = dcr->jcr;
1786 /* ******FIXME******* put these on config variables */
1787 dev->min_wait = 60 * 60;
1788 dev->max_wait = 24 * 60 * 60;
1789 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1790 dev->wait_sec = dev->min_wait;
1791 dev->rem_wait_sec = dev->wait_sec;
1794 dev->BadVolName[0] = 0;
1796 jcr->min_wait = 60 * 60;
1797 jcr->max_wait = 24 * 60 * 60;
1798 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1799 jcr->wait_sec = jcr->min_wait;
1800 jcr->rem_wait_sec = jcr->wait_sec;
1805 void init_jcr_device_wait_timers(JCR *jcr)
1807 /* ******FIXME******* put these on config variables */
1808 jcr->min_wait = 60 * 60;
1809 jcr->max_wait = 24 * 60 * 60;
1810 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1811 jcr->wait_sec = jcr->min_wait;
1812 jcr->rem_wait_sec = jcr->wait_sec;
1818 * The dev timers are used for waiting on a particular device
1820 * Returns: true if time doubled
1821 * false if max time expired
1823 bool double_dev_wait_time(DEVICE *dev)
1825 dev->wait_sec *= 2; /* double wait time */
1826 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
1827 dev->wait_sec = dev->max_wait;
1830 dev->rem_wait_sec = dev->wait_sec;
1831 if (dev->num_wait >= dev->max_num_wait) {
1838 void set_os_device_parameters(DEVICE *dev)
1840 #ifdef HAVE_LINUX_OS
1842 if (dev->min_block_size == dev->max_block_size &&
1843 dev->min_block_size == 0) { /* variable block mode */
1844 mt_com.mt_op = MTSETBLK;
1845 mt_com.mt_count = 0;
1846 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1847 clrerror_dev(dev, MTSETBLK);
1849 mt_com.mt_op = MTSETDRVBUFFER;
1850 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
1851 if (!dev_cap(dev, CAP_TWOEOF)) {
1852 mt_com.mt_count |= MT_ST_TWO_FM;
1854 if (dev_cap(dev, CAP_EOM)) {
1855 mt_com.mt_count |= MT_ST_FAST_MTEOM;
1857 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1858 clrerror_dev(dev, MTSETBLK);
1864 #ifdef HAVE_NETBSD_OS
1866 if (dev->min_block_size == dev->max_block_size &&
1867 dev->min_block_size == 0) { /* variable block mode */
1868 mt_com.mt_op = MTSETBSIZ;
1869 mt_com.mt_count = 0;
1870 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1871 clrerror_dev(dev, MTSETBSIZ);
1873 /* Get notified at logical end of tape */
1874 mt_com.mt_op = MTEWARN;
1875 mt_com.mt_count = 1;
1876 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1877 clrerror_dev(dev, MTEWARN);
1883 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
1885 if (dev->min_block_size == dev->max_block_size &&
1886 dev->min_block_size == 0) { /* variable block mode */
1887 mt_com.mt_op = MTSETBSIZ;
1888 mt_com.mt_count = 0;
1889 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1890 clrerror_dev(dev, MTSETBSIZ);
1898 if (dev->min_block_size == dev->max_block_size &&
1899 dev->min_block_size == 0) { /* variable block mode */
1900 mt_com.mt_op = MTSRSZ;
1901 mt_com.mt_count = 0;
1902 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1903 clrerror_dev(dev, MTSRSZ);
1910 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
1912 return dev_cap(dev, CAP_MTIOCGET) &&
1913 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
1914 mt_stat->mt_fileno >= 0;
1917 static char *modes[] = {
1918 "CREATE_READ_WRITE",
1925 static char *mode_to_str(int mode)
1927 return modes[mode-1];