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);
518 if ((omode == OPEN_READ_ONLY) && (part == num_parts)) {
519 /* If the last part (on spool), doesn't exists when reading, create it and read from it
520 * (it will report immediately an EOF):
521 * Sometimes it is better to finish with an EOF than with an error. */
522 set_mode(OPEN_READ_WRITE);
523 fd = ::open(archive_name.c_str(), mode, 0640);
524 set_mode(OPEN_READ_ONLY);
527 /* We don't need it. Only the last part is on spool */
528 /*if (omode == OPEN_READ_ONLY) {
529 make_spooled_dvd_filename(this, archive_name);
530 fd = ::open(archive_name.c_str(), mode, 0640); // try on spool
533 Dmsg1(100, "after open fd=%d\n", fd);
535 /* Get size of file */
536 if (fstat(fd, &filestat) < 0) {
539 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
541 Dmsg1(29, "open failed: %s", errmsg);
542 /* Use system close() */
546 part_size = filestat.st_size;
550 update_pos_dev(this); /* update position */
552 /* NB: It seems this code is wrong... part number is incremented in open_next_part, not here */
554 /* Check if just created Volume part */
555 /* if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
558 VolCatInfo.VolCatParts = num_parts;
560 if (part == 0) { // we must have opened the first part
571 bool _rewind_dev(char *file, int line, DEVICE *dev)
573 Dmsg3(100, "rewind_dev fd=%d called from %s:%d\n", dev->fd, file, line);
574 return rewind_dev(dev);
580 * Returns: true on success
583 bool rewind_dev(DEVICE *dev)
588 Dmsg2(29, "rewind_dev fd=%d %s\n", dev->fd, dev->print_name());
590 dev->dev_errno = EBADF;
591 Mmsg1(dev->errmsg, _("Bad call to rewind_dev. Device %s not open\n"),
593 Emsg0(M_ABORT, 0, dev->errmsg);
596 dev->state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
597 dev->block_num = dev->file = 0;
600 if (dev->is_tape()) {
601 mt_com.mt_op = MTREW;
603 /* If we get an I/O error on rewind, it is probably because
604 * the drive is actually busy. We loop for (about 5 minutes)
605 * retrying every 5 seconds.
607 for (i=dev->max_rewind_wait; ; i -= 5) {
608 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
610 clrerror_dev(dev, MTREW);
611 if (i == dev->max_rewind_wait) {
612 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
614 if (dev->dev_errno == EIO && i > 0) {
615 Dmsg0(200, "Sleeping 5 seconds.\n");
619 Mmsg2(dev->errmsg, _("Rewind error on %s. ERR=%s.\n"),
620 dev->print_name(), be.strerror());
625 } else if (dev->is_file()) {
626 if (lseek_dev(dev, (off_t)0, SEEK_SET) < 0) {
628 dev->dev_errno = errno;
629 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
630 dev->print_name(), be.strerror());
637 void DEVICE::block(int why)
640 block_device(this, why);
644 void DEVICE::unblock()
647 unblock_device(this);
651 const char *DEVICE::print_blocked() const
653 switch (dev_blocked) {
654 case BST_NOT_BLOCKED:
655 return "BST_NOT_BLOCKED";
657 return "BST_UNMOUNTED";
658 case BST_WAITING_FOR_SYSOP:
659 return "BST_WAITING_FOR_SYSOP";
660 case BST_DOING_ACQUIRE:
661 return "BST_DOING_ACQUIRE";
662 case BST_WRITING_LABEL:
663 return "BST_WRITING_LABEL";
664 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
665 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
669 return "unknown blocked code";
674 * Called to indicate that we have just read an
675 * EOF from the device.
677 void DEVICE::set_ateof()
687 * Called to indicate we are now at the end of the tape, and
688 * writing is not possible.
690 void DEVICE::set_ateot()
692 /* Make tape effectively read-only */
693 state |= (ST_EOF|ST_EOT|ST_WEOT);
698 * Position device to end of medium (end of data)
699 * Returns: true on succes
706 struct mtget mt_stat;
711 dev->dev_errno = EBADF;
712 Mmsg1(dev->errmsg, _("Bad call to eod_dev. Device %s not open\n"),
717 #if defined (__digital__) && defined (__unix__)
718 return dev->fsf(dev->VolCatInfo.VolCatFiles);
721 Dmsg0(29, "eod_dev\n");
725 dev->state &= ~(ST_EOF); /* remove EOF flags */
726 dev->block_num = dev->file = 0;
729 if (dev->state & (ST_FIFO | ST_PROG)) {
732 if (!dev->is_tape()) {
733 pos = lseek_dev(dev, (off_t)0, SEEK_END);
734 // Dmsg1(100, "====== Seek to %lld\n", pos);
737 dev->state |= ST_EOT;
740 dev->dev_errno = errno;
742 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
743 dev->print_name(), be.strerror());
747 if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
748 Dmsg0(100,"Using FAST FSF for EOM\n");
749 /* If unknown position, rewind */
750 if (!dev_get_os_pos(dev, &mt_stat)) {
751 if (!rewind_dev(dev)) {
755 mt_com.mt_op = MTFSF;
757 * ***FIXME*** fix code to handle case that INT16_MAX is
760 mt_com.mt_count = INT16_MAX; /* use big positive number */
761 if (mt_com.mt_count < 0) {
762 mt_com.mt_count = INT16_MAX; /* brain damaged system */
766 if (dev_cap(dev, CAP_MTIOCGET) && (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM))) {
767 if (dev_cap(dev, CAP_EOM)) {
768 Dmsg0(100,"Using EOM for EOM\n");
769 mt_com.mt_op = MTEOM;
773 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
775 clrerror_dev(dev, mt_com.mt_op);
776 Dmsg1(50, "ioctl error: %s\n", be.strerror());
778 Mmsg2(dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
779 dev->print_name(), be.strerror());
783 if (!dev_get_os_pos(dev, &mt_stat)) {
785 clrerror_dev(dev, -1);
786 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
787 dev->print_name(), be.strerror());
790 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
792 dev->file = mt_stat.mt_fileno;
798 * Rewind then use FSF until EOT reached
800 if (!rewind_dev(dev)) {
804 * Move file by file to the end of the tape
807 for (file_num=dev->file; !dev->at_eot(); file_num++) {
808 Dmsg0(200, "eod_dev: doing fsf 1\n");
810 Dmsg0(200, "fsf error.\n");
814 * Avoid infinite loop. ***FIXME*** possibly add code
815 * to set EOD or to turn off CAP_FASTFSF if on.
817 if (file_num == (int)dev->file) {
818 struct mtget mt_stat;
819 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
820 if (dev_get_os_pos(dev, &mt_stat)) {
821 Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
823 dev->file = mt_stat.mt_fileno;
830 * Some drivers leave us after second EOF when doing
831 * MTEOM, so we must backup so that appending overwrites
834 if (dev_cap(dev, CAP_BSFATEOM)) {
835 struct mtget mt_stat;
836 /* Backup over EOF */
837 ok = bsf_dev(dev, 1);
838 /* If BSF worked and fileno is known (not -1), set file */
839 if (dev_get_os_pos(dev, &mt_stat)) {
840 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
841 dev->file = mt_stat.mt_fileno;
843 dev->file++; /* wing it -- not correct on all OSes */
846 update_pos_dev(dev); /* update position */
848 Dmsg1(200, "EOD dev->file=%d\n", dev->file);
853 * Set the position of the device -- only for files
854 * For other devices, there is no generic way to do it.
855 * Returns: true on succes
858 bool update_pos_dev(DEVICE *dev)
864 dev->dev_errno = EBADF;
865 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
866 Emsg0(M_FATAL, 0, dev->errmsg);
870 /* Find out where we are */
871 if (dev->is_file()) {
874 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
877 dev->dev_errno = errno;
878 Pmsg1(000, "Seek error: ERR=%s\n", be.strerror());
879 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
880 dev->print_name(), be.strerror());
883 dev->file_addr = pos;
891 * Return the status of the device. This was meant
892 * to be a generic routine. Unfortunately, it doesn't
893 * seem possible (at least I do not know how to do it
894 * currently), which means that for the moment, this
895 * routine has very little value.
899 uint32_t status_dev(DEVICE *dev)
901 struct mtget mt_stat;
904 if (dev->state & (ST_EOT | ST_WEOT)) {
908 if (dev->state & ST_EOF) {
912 if (dev->is_tape()) {
914 Pmsg0(-20," Bacula status:");
915 Pmsg2(-20," file=%d block=%d\n", dev->file, dev->block_num);
916 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
918 dev->dev_errno = errno;
919 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
920 dev->print_name(), be.strerror());
923 Pmsg0(-20, " Device status:");
925 #if defined(HAVE_LINUX_OS)
926 if (GMT_EOF(mt_stat.mt_gstat)) {
930 if (GMT_BOT(mt_stat.mt_gstat)) {
934 if (GMT_EOT(mt_stat.mt_gstat)) {
938 if (GMT_SM(mt_stat.mt_gstat)) {
942 if (GMT_EOD(mt_stat.mt_gstat)) {
946 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
948 Pmsg0(-20, " WR_PROT");
950 if (GMT_ONLINE(mt_stat.mt_gstat)) {
952 Pmsg0(-20, " ONLINE");
954 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
956 Pmsg0(-20, " DR_OPEN");
958 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
959 stat |= BMT_IM_REP_EN;
960 Pmsg0(-20, " IM_REP_EN");
962 #endif /* !SunOS && !OSF */
963 if (dev_cap(dev, CAP_MTIOCGET)) {
964 Pmsg2(-20, " file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
966 Pmsg2(-20, " file=%d block=%d\n", -1, -1);
969 stat |= BMT_ONLINE | BMT_BOT;
976 * Load medium in device
977 * Returns: true on success
980 bool load_dev(DEVICE *dev)
987 dev->dev_errno = EBADF;
988 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
989 Emsg0(M_FATAL, 0, dev->errmsg);
992 if (!(dev->is_tape())) {
996 Dmsg0(200, "stored: MTLOAD command not available\n");
998 dev->dev_errno = ENOTTY; /* function not available */
999 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1000 dev->print_name(), be.strerror());
1004 dev->block_num = dev->file = 0;
1007 mt_com.mt_op = MTLOAD;
1008 mt_com.mt_count = 1;
1009 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1011 dev->dev_errno = errno;
1012 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1013 dev->print_name(), be.strerror());
1021 * Rewind device and put it offline
1022 * Returns: true on success
1025 bool offline_dev(DEVICE *dev)
1030 dev->dev_errno = EBADF;
1031 Mmsg0(dev->errmsg, _("Bad call to offline_dev. Device not open\n"));
1032 Emsg0(M_FATAL, 0, dev->errmsg);
1035 if (!(dev->is_tape())) {
1039 dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1040 dev->block_num = dev->file = 0;
1045 mt_com.mt_op = MTUNLOCK;
1046 mt_com.mt_count = 1;
1047 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1049 mt_com.mt_op = MTOFFL;
1050 mt_com.mt_count = 1;
1051 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1053 dev->dev_errno = errno;
1054 Mmsg2(dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1055 dev->print_name(), be.strerror());
1058 Dmsg1(100, "Offlined device %s\n", dev->print_name());
1062 bool offline_or_rewind_dev(DEVICE *dev)
1067 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1068 return offline_dev(dev);
1071 * Note, this rewind probably should not be here (it wasn't
1072 * in prior versions of Bacula), but on FreeBSD, this is
1073 * needed in the case the tape was "frozen" due to an error
1074 * such as backspacing after writing and EOF. If it is not
1075 * done, all future references to the drive get and I/O error.
1077 clrerror_dev(dev, MTREW);
1078 return rewind_dev(dev);
1083 * Foward space a file
1084 * Returns: true on success
1087 bool DEVICE::fsf(int num)
1089 struct mtget mt_stat;
1095 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1096 Emsg0(M_FATAL, 0, errmsg);
1105 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1109 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1112 Dmsg0(100, "fsf\n");
1115 * If Fast forward space file is set, then we
1116 * use MTFSF to forward space and MTIOCGET
1117 * to get the file position. We assume that
1118 * the SCSI driver will ensure that we do not
1119 * forward space past the end of the medium.
1121 if (dev_cap(this, CAP_FSF) && dev_cap(this, CAP_MTIOCGET) && dev_cap(this, CAP_FASTFSF)) {
1122 mt_com.mt_op = MTFSF;
1123 mt_com.mt_count = num;
1124 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1125 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1128 Dmsg0(200, "Set ST_EOT\n");
1129 clrerror_dev(this, MTFSF);
1130 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1131 print_name(), be.strerror());
1132 Dmsg1(200, "%s", errmsg);
1135 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1137 file = mt_stat.mt_fileno;
1141 * Here if CAP_FSF is set, and virtually all drives
1142 * these days support it, we read a record, then forward
1143 * space one file. Using this procedure, which is slow,
1144 * is the only way we can be sure that we don't read
1145 * two consecutive EOF marks, which means End of Data.
1147 } else if (dev_cap(this, CAP_FSF)) {
1150 Dmsg0(200, "FSF has cap_fsf\n");
1151 if (max_block_size == 0) {
1152 rbuf_len = DEFAULT_BLOCK_SIZE;
1154 rbuf_len = max_block_size;
1156 rbuf = get_memory(rbuf_len);
1157 mt_com.mt_op = MTFSF;
1158 mt_com.mt_count = 1;
1159 while (num-- && !at_eot()) {
1160 Dmsg0(100, "Doing read before fsf\n");
1161 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1162 if (errno == ENOMEM) { /* tape record exceeds buf len */
1163 stat = rbuf_len; /* This is OK */
1165 * On IBM drives, they return ENOSPC at EOM
1166 * instead of EOF status
1168 } else if (at_eof() && errno == ENOSPC) {
1173 clrerror_dev(this, -1);
1174 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1176 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1177 print_name(), be.strerror());
1178 Dmsg1(100, "%s", errmsg);
1182 if (stat == 0) { /* EOF */
1183 update_pos_dev(this);
1184 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1185 /* Two reads of zero means end of tape */
1188 Dmsg0(100, "Set ST_EOT\n");
1194 } else { /* Got data */
1199 Dmsg0(100, "Doing MTFSF\n");
1200 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1201 if (stat < 0) { /* error => EOT */
1204 Dmsg0(100, "Set ST_EOT\n");
1205 clrerror_dev(this, MTFSF);
1206 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1207 print_name(), be.strerror());
1208 Dmsg0(100, "Got < 0 for MTFSF\n");
1209 Dmsg1(100, "%s", errmsg);
1217 * No FSF, so use FSR to simulate it
1220 Dmsg0(200, "Doing FSR for FSF\n");
1221 while (num-- && !at_eot()) {
1222 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1226 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1232 update_pos_dev(this);
1233 Dmsg1(200, "Return %d from FSF\n", stat);
1235 Dmsg0(200, "ST_EOF set on exit FSF\n");
1237 Dmsg0(200, "ST_EOT set on exit FSF\n");
1238 Dmsg1(200, "Return from FSF file=%d\n", file);
1243 * Backward space a file
1244 * Returns: false on failure
1248 bsf_dev(DEVICE *dev, int num)
1254 dev->dev_errno = EBADF;
1255 Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Device not open\n"));
1256 Emsg0(M_FATAL, 0, dev->errmsg);
1260 if (!dev->is_tape()) {
1261 Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1265 Dmsg0(29, "bsf_dev\n");
1266 dev->state &= ~(ST_EOT|ST_EOF);
1270 mt_com.mt_op = MTBSF;
1271 mt_com.mt_count = num;
1272 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1275 clrerror_dev(dev, MTBSF);
1276 Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1277 dev->print_name(), be.strerror());
1279 update_pos_dev(dev);
1285 * Foward space num records
1286 * Returns: false on failure
1289 bool DEVICE::fsr(int num)
1296 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1297 Emsg0(M_FATAL, 0, errmsg);
1304 if (!dev_cap(this, CAP_FSR)) {
1305 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1309 Dmsg1(29, "fsr %d\n", num);
1310 mt_com.mt_op = MTFSR;
1311 mt_com.mt_count = num;
1312 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1318 struct mtget mt_stat;
1319 clrerror_dev(this, MTFSR);
1320 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1321 if (dev_get_os_pos(this, &mt_stat)) {
1322 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1323 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1324 file = mt_stat.mt_fileno;
1325 block_num = mt_stat.mt_blkno;
1333 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1334 num, print_name(), be.strerror());
1336 update_pos_dev(this);
1341 * Backward space a record
1342 * Returns: false on failure
1346 bsr_dev(DEVICE *dev, int num)
1352 dev->dev_errno = EBADF;
1353 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1354 Emsg0(M_FATAL, 0, dev->errmsg);
1358 if (!dev->is_tape()) {
1362 if (!dev_cap(dev, CAP_BSR)) {
1363 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1367 Dmsg0(29, "bsr_dev\n");
1368 dev->block_num -= num;
1369 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1370 mt_com.mt_op = MTBSR;
1371 mt_com.mt_count = num;
1372 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1375 clrerror_dev(dev, MTBSR);
1376 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1377 dev->print_name(), be.strerror());
1379 update_pos_dev(dev);
1384 * Reposition the device to file, block
1385 * Returns: false on failure
1389 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1392 dev->dev_errno = EBADF;
1393 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1394 Emsg0(M_FATAL, 0, dev->errmsg);
1398 if (!dev->is_tape()) {
1399 off_t pos = (((off_t)file)<<32) + block;
1400 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1401 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1403 dev->dev_errno = errno;
1404 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1405 dev->print_name(), be.strerror());
1409 dev->block_num = block;
1410 dev->file_addr = pos;
1413 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1414 dev->file, dev->block_num, file, block);
1415 if (file < dev->file) {
1416 Dmsg0(100, "Rewind_dev\n");
1417 if (!rewind_dev(dev)) {
1421 if (file > dev->file) {
1422 Dmsg1(100, "fsf %d\n", file-dev->file);
1423 if (!dev->fsf(file-dev->file)) {
1424 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1427 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1429 if (block < dev->block_num) {
1430 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1431 Dmsg0(100, "bsf_dev 1\n");
1433 Dmsg0(100, "fsf_dev 1\n");
1435 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1437 if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1438 /* Ignore errors as Bacula can read to the correct block */
1439 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1440 return dev->fsr(block-dev->block_num);
1448 * Write an end of file on the device
1449 * Returns: 0 on success
1450 * non-zero on failure
1453 weof_dev(DEVICE *dev, int num)
1457 Dmsg0(29, "weof_dev\n");
1460 dev->dev_errno = EBADF;
1461 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1462 Emsg0(M_FATAL, 0, dev->errmsg);
1467 if (!dev->is_tape()) {
1470 if (!dev->can_append()) {
1471 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1472 Emsg0(M_FATAL, 0, dev->errmsg);
1476 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1477 mt_com.mt_op = MTWEOF;
1478 mt_com.mt_count = num;
1479 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1486 clrerror_dev(dev, MTWEOF);
1488 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1489 dev->print_name(), be.strerror());
1496 * Return string message with last error in English
1497 * Be careful not to call this routine from within dev.c
1498 * while editing an Mmsg() or you will end up in a recursive
1499 * loop creating a Segmentation Violation.
1502 strerror_dev(DEVICE *dev)
1509 * If implemented in system, clear the tape
1513 clrerror_dev(DEVICE *dev, int func)
1515 const char *msg = NULL;
1516 struct mtget mt_stat;
1519 dev->dev_errno = errno; /* save errno */
1521 dev->VolCatInfo.VolCatErrors++;
1524 if (!dev->is_tape()) {
1527 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1530 Emsg0(M_ABORT, 0, "Got ENOTTY on read/write!\n");
1534 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1539 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1544 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1548 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1552 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1556 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1577 bsnprintf(buf, sizeof(buf), "unknown func code %d", func);
1582 dev->dev_errno = ENOSYS;
1583 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1584 Emsg0(M_ERROR, 0, dev->errmsg);
1587 /* On some systems such as NetBSD, this clears all errors */
1588 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1590 /* Found on Linux */
1594 mt_com.mt_op = MTIOCLRERR;
1595 mt_com.mt_count = 1;
1596 /* Clear any error condition on the tape */
1597 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1598 Dmsg0(200, "Did MTIOCLRERR\n");
1602 /* Typically on FreeBSD */
1605 /* Read and clear SCSI error status */
1606 union mterrstat mt_errstat;
1607 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1608 strerror(dev->dev_errno));
1609 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1613 /* Clear Subsystem Exception OSF1 */
1617 mt_com.mt_op = MTCSE;
1618 mt_com.mt_count = 1;
1619 /* Clear any error condition on the tape */
1620 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1621 Dmsg0(200, "Did MTCSE\n");
1627 * Flush buffer contents
1630 int flush_dev(DEVICE *dev)
1635 static void do_close(DEVICE *dev)
1638 Dmsg1(29, "really close_dev %s\n", dev->print_name());
1643 if (!unmount_dev(dev, 1)) {
1644 Dmsg1(0, "Cannot unmount device %s.\n", dev->print_name());
1647 /* Remove the last part file if it is empty */
1648 if (dev->can_append() && (dev->num_parts > 0)) {
1650 POOL_MEM archive_name(PM_FNAME);
1651 dev->part = dev->num_parts;
1652 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", dev->VolCatInfo.VolCatName);
1653 make_spooled_dvd_filename(dev, archive_name);
1654 /* Check that the part file is empty */
1655 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1656 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1657 unlink(archive_name.c_str());
1661 /* Clean up device packet so it can be reused */
1663 dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1664 dev->label_type = B_BACULA_LABEL;
1665 dev->file = dev->block_num = 0;
1671 dev->part_start = 0;
1672 dev->EndFile = dev->EndBlock = 0;
1673 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1674 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1676 stop_thread_timer(dev->tid);
1686 void DEVICE::close()
1688 /*if (fd >= 0 && use_count == 1) {*/
1689 /* No need to check if fd >= 0: it is checked again
1690 * in do_close, and do_close MUST be called for volumes
1691 * splitted in parts, even if fd == -1. */
1692 if (use_count == 1) {
1694 } else if (use_count > 0) {
1699 ASSERT(use_count >= 0);
1704 bool truncate_dev(DEVICE *dev)
1706 Dmsg1(100, "truncate_dev %s\n", dev->print_name());
1707 if (dev->is_tape()) {
1708 return true; /* we don't really truncate tapes */
1709 /* maybe we should rewind and write and eof ???? */
1712 if (dev->is_dvd()) {
1713 Mmsg1(dev->errmsg, _("Truncate DVD %s not supported.\n"), dev->print_name());
1714 return false; /* we cannot truncate DVDs */
1717 if (ftruncate(dev->fd, 0) != 0) {
1719 Mmsg2(dev->errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1720 dev->print_name(), be.strerror());
1726 /* Return the resource name for the device */
1727 const char *DEVICE::name() const
1729 return device->hdr.name;
1733 dev_vol_name(DEVICE *dev)
1735 return dev->VolCatInfo.VolCatName;
1738 uint32_t dev_block(DEVICE *dev)
1740 update_pos_dev(dev);
1741 return dev->block_num;
1744 uint32_t dev_file(DEVICE *dev)
1746 update_pos_dev(dev);
1751 * Free memory allocated for the device
1754 term_dev(DEVICE *dev)
1757 dev->dev_errno = EBADF;
1758 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1759 Emsg0(M_FATAL, 0, dev->errmsg);
1762 Dmsg1(29, "term_dev: %s\n", dev->print_name());
1764 if (dev->dev_name) {
1765 free_memory(dev->dev_name);
1766 dev->dev_name = NULL;
1768 if (dev->prt_name) {
1769 free_memory(dev->prt_name);
1770 dev->prt_name = NULL;
1773 free_pool_memory(dev->errmsg);
1776 pthread_mutex_destroy(&dev->mutex);
1777 pthread_cond_destroy(&dev->wait);
1778 pthread_cond_destroy(&dev->wait_next_vol);
1779 pthread_mutex_destroy(&dev->spool_mutex);
1780 rwl_destroy(&dev->lock);
1781 if (dev->attached_dcrs) {
1782 delete dev->attached_dcrs;
1783 dev->attached_dcrs = NULL;
1785 if (dev->state & ST_MALLOC) {
1786 free_pool_memory((POOLMEM *)dev);
1791 * This routine initializes the device wait timers
1793 void init_device_wait_timers(DCR *dcr)
1795 DEVICE *dev = dcr->dev;
1796 JCR *jcr = dcr->jcr;
1798 /* ******FIXME******* put these on config variables */
1799 dev->min_wait = 60 * 60;
1800 dev->max_wait = 24 * 60 * 60;
1801 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1802 dev->wait_sec = dev->min_wait;
1803 dev->rem_wait_sec = dev->wait_sec;
1806 dev->BadVolName[0] = 0;
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;
1817 void init_jcr_device_wait_timers(JCR *jcr)
1819 /* ******FIXME******* put these on config variables */
1820 jcr->min_wait = 60 * 60;
1821 jcr->max_wait = 24 * 60 * 60;
1822 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1823 jcr->wait_sec = jcr->min_wait;
1824 jcr->rem_wait_sec = jcr->wait_sec;
1830 * The dev timers are used for waiting on a particular device
1832 * Returns: true if time doubled
1833 * false if max time expired
1835 bool double_dev_wait_time(DEVICE *dev)
1837 dev->wait_sec *= 2; /* double wait time */
1838 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
1839 dev->wait_sec = dev->max_wait;
1842 dev->rem_wait_sec = dev->wait_sec;
1843 if (dev->num_wait >= dev->max_num_wait) {
1850 void set_os_device_parameters(DEVICE *dev)
1852 #ifdef HAVE_LINUX_OS
1854 if (dev->min_block_size == dev->max_block_size &&
1855 dev->min_block_size == 0) { /* variable block mode */
1856 mt_com.mt_op = MTSETBLK;
1857 mt_com.mt_count = 0;
1858 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1859 clrerror_dev(dev, MTSETBLK);
1861 mt_com.mt_op = MTSETDRVBUFFER;
1862 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
1863 if (!dev_cap(dev, CAP_TWOEOF)) {
1864 mt_com.mt_count |= MT_ST_TWO_FM;
1866 if (dev_cap(dev, CAP_EOM)) {
1867 mt_com.mt_count |= MT_ST_FAST_MTEOM;
1869 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1870 clrerror_dev(dev, MTSETBLK);
1876 #ifdef HAVE_NETBSD_OS
1878 if (dev->min_block_size == dev->max_block_size &&
1879 dev->min_block_size == 0) { /* variable block mode */
1880 mt_com.mt_op = MTSETBSIZ;
1881 mt_com.mt_count = 0;
1882 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1883 clrerror_dev(dev, MTSETBSIZ);
1885 /* Get notified at logical end of tape */
1886 mt_com.mt_op = MTEWARN;
1887 mt_com.mt_count = 1;
1888 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1889 clrerror_dev(dev, MTEWARN);
1895 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
1897 if (dev->min_block_size == dev->max_block_size &&
1898 dev->min_block_size == 0) { /* variable block mode */
1899 mt_com.mt_op = MTSETBSIZ;
1900 mt_com.mt_count = 0;
1901 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1902 clrerror_dev(dev, MTSETBSIZ);
1910 if (dev->min_block_size == dev->max_block_size &&
1911 dev->min_block_size == 0) { /* variable block mode */
1912 mt_com.mt_op = MTSRSZ;
1913 mt_com.mt_count = 0;
1914 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1915 clrerror_dev(dev, MTSRSZ);
1922 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
1924 return dev_cap(dev, CAP_MTIOCGET) &&
1925 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
1926 mt_stat->mt_fileno >= 0;
1929 static char *modes[] = {
1930 "CREATE_READ_WRITE",
1937 static char *mode_to_str(int mode)
1939 return modes[mode-1];