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 update_free_space_dev(DEVICE* dev);
86 /* Forward referenced functions */
87 void set_os_device_parameters(DEVICE *dev);
88 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat);
89 static void open_tape_device(DCR *dcr, int mode);
90 static void open_file_device(DCR *dcr, int mode);
91 static void open_dvd_device(DCR *dcr, 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\n"
132 " or have RequiresMount=yes for DVD. st_mode=%x\n"),
133 device->device_name, statp.st_mode);
137 dev = (DEVICE *)get_memory(sizeof(DEVICE));
138 memset(dev, 0, sizeof(DEVICE));
139 dev->state = ST_MALLOC;
141 /* Copy user supplied device parameters from Resource */
142 dev->dev_name = get_memory(strlen(device->device_name)+1);
143 pm_strcpy(dev->dev_name, device->device_name);
144 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
145 /* We edit "Resource-name" (physical-name) */
146 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
147 dev->capabilities = device->cap_bits;
148 dev->min_block_size = device->min_block_size;
149 dev->max_block_size = device->max_block_size;
150 dev->max_volume_size = device->max_volume_size;
151 dev->max_file_size = device->max_file_size;
152 dev->volume_capacity = device->volume_capacity;
153 dev->max_rewind_wait = device->max_rewind_wait;
154 dev->max_open_wait = device->max_open_wait;
155 dev->max_open_vols = device->max_open_vols;
156 dev->vol_poll_interval = device->vol_poll_interval;
157 dev->max_spool_size = device->max_spool_size;
158 dev->drive_index = device->drive_index;
159 dev->autoselect = device->autoselect;
160 if (tape) { /* No parts on tapes */
161 dev->max_part_size = 0;
164 dev->max_part_size = device->max_part_size;
167 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
168 dev->vol_poll_interval = 60;
170 dev->device = device;
173 dev->state |= ST_TAPE;
175 dev->state |= ST_FIFO;
176 dev->capabilities |= CAP_STREAM; /* set stream device */
178 dev->state |= ST_FILE;
181 /* If the device requires mount :
182 * - Check that the mount point is available
183 * - Check that (un)mount commands are defined
185 if (dev->is_file() && dev->requires_mount()) {
186 if (stat(device->mount_point, &statp) < 0) {
188 dev->dev_errno = errno;
189 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat mount point %s: ERR=%s\n"),
190 device->mount_point, be.strerror());
193 if (!device->mount_command || !device->unmount_command) {
194 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
196 if (!device->write_part_command) {
197 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
199 dev->state |= ST_DVD;
202 if (dev->max_block_size > 1000000) {
203 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
204 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
205 dev->max_block_size = 0;
207 if (dev->max_block_size % TAPE_BSIZE != 0) {
208 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
209 dev->max_block_size, dev->print_name());
212 dev->errmsg = get_pool_memory(PM_EMSG);
215 if ((errstat = pthread_mutex_init(&dev->mutex, NULL)) != 0) {
217 dev->dev_errno = errstat;
218 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
219 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
221 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
223 dev->dev_errno = errstat;
224 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
225 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
227 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
229 dev->dev_errno = errstat;
230 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
231 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
233 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
235 dev->dev_errno = errstat;
236 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
237 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
239 if ((errstat = rwl_init(&dev->lock)) != 0) {
241 dev->dev_errno = errstat;
242 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
243 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
247 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
248 Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
254 * Open the device with the operating system and
255 * initialize buffer pointers.
257 * Returns: -1 on error
260 * Note, for a tape, the VolName is the name we give to the
261 * volume (not really used here), but for a file, the
262 * VolName represents the name of the file to be created/opened.
263 * In the case of a file, the full name is the device name
264 * (archive_name) with the VolName concatenated.
267 DEVICE::open(DCR *dcr, int mode)
270 if (openmode == mode) {
273 ::close(fd); /* use system close so correct mode will be used on open */
276 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
278 Dmsg4(29, "open dev: tape=%d dev_name=%s vol=%s mode=%d\n", is_tape(),
279 dev_name, VolCatInfo.VolCatName, mode);
280 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
281 label_type = B_BACULA_LABEL;
282 if (is_tape() || is_fifo()) {
283 open_tape_device(dcr, mode);
284 } else if (is_dvd()) {
285 Dmsg1(100, "call open_dvd_device mode=%d\n", mode);
286 open_dvd_device(dcr, mode);
288 Dmsg1(100, "call open_file_device mode=%d\n", mode);
289 open_file_device(dcr, mode);
294 void DEVICE::set_mode(int new_mode)
297 case CREATE_READ_WRITE:
298 mode = O_CREAT | O_RDWR | O_BINARY;
300 case OPEN_READ_WRITE:
301 if (is_dvd() || is_file()) {
302 mode = O_CREAT | O_RDWR | O_BINARY;
304 mode = O_RDWR | O_BINARY;
308 mode = O_RDONLY | O_BINARY;
310 case OPEN_WRITE_ONLY:
311 mode = O_WRONLY | O_BINARY;
314 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
318 static void open_tape_device(DCR *dcr, int mode)
320 DEVICE *dev = dcr->dev;
321 int nonblocking = 0;;
325 Dmsg0(29, "open dev: device is tape\n");
328 timeout = dev->max_open_wait;
330 if (dev->open_nowait) {
331 /* Set wait counters to zero for no wait */
332 timeout = ioerrcnt = 0;
333 /* Open drive in non-block mode */
334 nonblocking = O_NONBLOCK;
336 if (dev->is_fifo() && timeout) {
338 dev->tid = start_thread_timer(pthread_self(), timeout);
340 /* If busy retry each second for max_open_wait seconds */
342 Dmsg1(500, "Try open %s\n", dev->dev_name);
343 while ((dev->fd = open(dev->dev_name, dev->mode, MODE_RW+nonblocking)) < 0) {
345 Dmsg2(500, "Open error errno=%d ERR=%s\n", errno, be.strerror());
346 if (errno == EINTR || errno == EAGAIN) {
347 Dmsg0(500, "Continue open\n");
350 /* Busy wait for specified time (default = 5 mins) */
351 if (errno == EBUSY && timeout-- > 0) {
352 Dmsg2(100, "Device %s busy. ERR=%s\n", dev->print_name(), be.strerror());
356 /* IO error (no volume) try 10 times every 6 seconds */
357 if (errno == EIO && ioerrcnt-- > 0) {
359 Dmsg0(500, "Continue open\n");
362 dev->dev_errno = errno;
363 Mmsg2(dev->errmsg, _("Unable to open device %s: ERR=%s\n"),
364 dev->print_name(), be.strerror(dev->dev_errno));
365 /* Stop any open timer we set */
367 stop_thread_timer(dev->tid);
370 Emsg0(M_FATAL, 0, dev->errmsg);
374 /* If opened in non-block mode, close it an open it normally */
380 dev->openmode = mode; /* save open mode */
382 dev->state |= ST_OPENED;
384 update_pos_dev(dev); /* update position */
385 set_os_device_parameters(dev); /* do system dependent stuff */
386 Dmsg0(500, "Open OK\n");
388 /* Stop any open() timer we started */
390 stop_thread_timer(dev->tid);
393 Dmsg1(29, "open dev: tape %d opened\n", dev->fd);
399 static void open_file_device(DCR *dcr, int mode)
401 DEVICE *dev = dcr->dev;
402 POOL_MEM archive_name(PM_FNAME);
405 * Handle opening of File Archive (not a tape)
407 Dmsg3(29, "Enter: open_file_dev: %s dev=%s mode=%d\n", dev->is_dvd()?"DVD":"disk",
408 archive_name.c_str(), mode);
410 if (dev->VolCatInfo.VolCatName[0] == 0) {
411 Mmsg(dev->errmsg, _("Could not open file device %s. No Volume name given.\n"),
417 pm_strcpy(archive_name, dev->dev_name);
418 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
419 pm_strcat(archive_name, "/");
421 pm_strcat(archive_name, dev->VolCatInfo.VolCatName);
423 Dmsg3(29, "open dev: %s dev=%s mode=%d\n", dev->is_dvd()?"DVD":"disk",
424 archive_name.c_str(), mode);
425 dev->openmode = mode;
428 /* If creating file, give 0640 permissions */
429 Dmsg3(29, "mode=%d open(%s, 0x%x, 0640)\n", mode, archive_name.c_str(), dev->mode);
430 if ((dev->fd = open(archive_name.c_str(), dev->mode, 0640)) < 0) {
432 dev->dev_errno = errno;
433 Mmsg2(dev->errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
435 Dmsg1(29, "open failed: %s", dev->errmsg);
436 Emsg0(M_FATAL, 0, dev->errmsg);
439 dev->state |= ST_OPENED;
441 update_pos_dev(dev); /* update position */
443 Dmsg5(29, "open dev: %s fd=%d opened, part=%d/%d, part_size=%u\n",
444 dev->is_dvd()?"DVD":"disk", dev->fd, dev->part, dev->num_parts,
449 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
450 * has the desired Volume name, but there is NO assurance that
451 * any other field of VolCatInfo is correct.
453 static void open_dvd_device(DCR *dcr, int mode)
455 DEVICE *dev = dcr->dev;
456 POOL_MEM archive_name(PM_FNAME);
457 struct stat filestat;
460 * Handle opening of DVD Volume
462 Dmsg3(29, "Enter: open_file_dev: %s dev=%s mode=%d\n", dev->is_dvd()?"DVD":"disk",
463 archive_name.c_str(), mode);
465 if (dev->VolCatInfo.VolCatName[0] == 0) {
466 Mmsg(dev->errmsg, _("Could not open file device %s. No Volume name given.\n"),
472 if (dev->part == 0) {
478 if (mount_dev(dev, 1) < 0) {
479 Mmsg(dev->errmsg, _("Could not mount device %s.\n"),
481 Emsg0(M_FATAL, 0, dev->errmsg);
486 Dmsg3(29, "open dev: %s dev=%s mode=%d\n", dev->is_dvd()?"DVD":"disk",
487 archive_name.c_str(), mode);
488 dev->openmode = mode;
491 * If we are not trying to access the last part, set mode to
492 * OPEN_READ_ONLY as writing would be an error.
494 if (dev->part < dev->num_parts) {
495 mode = OPEN_READ_ONLY;
499 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", dev->VolCatInfo.VolCatName);
501 * If we are opening it read-only, it is *probably* on the
502 * DVD, so try the DVD first, otherwise look in the spool dir.
504 if (mode == OPEN_READ_ONLY) {
505 make_mounted_dvd_filename(dev, archive_name);
507 make_spooled_dvd_filename(dev, archive_name);
510 /* If creating file, give 0640 permissions */
511 Dmsg3(29, "mode=%d open(%s, 0x%x, 0640)\n", mode, archive_name.c_str(), dev->mode);
512 if ((dev->fd = open(archive_name.c_str(), dev->mode, 0640)) < 0) {
514 dev->dev_errno = errno;
515 Mmsg2(dev->errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
517 Dmsg1(29, "open failed: %s", dev->errmsg);
518 if (mode == OPEN_READ_ONLY) {
519 make_spooled_dvd_filename(dev, archive_name);
520 dev->fd = open(archive_name.c_str(), dev->mode, 0640); /* try on spool */
524 /* Get size of file */
525 if (fstat(dev->fd, &filestat) < 0) {
527 dev->dev_errno = errno;
528 Mmsg2(dev->errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
530 Dmsg1(29, "open failed: %s", dev->errmsg);
534 dev->part_size = filestat.st_size;
536 dev->state |= ST_OPENED;
538 update_pos_dev(dev); /* update position */
541 Dmsg4(29, "open dev: DVD fd=%d opened, part=%d/%d, part_size=%u\n",
542 dev->fd, dev->part, dev->num_parts, dev->part_size);
543 if (dev->is_open() && dev->is_dvd() && (mode != OPEN_READ_ONLY) &&
544 (dev->free_space_errno == 0 || dev->num_parts == dev->part)) {
545 update_free_space_dev(dev);
552 bool _rewind_dev(char *file, int line, DEVICE *dev)
554 Dmsg2(100, "rewind_dev called from %s:%d\n", file, line);
555 return rewind_dev(dev);
561 * Returns: true on success
564 bool rewind_dev(DEVICE *dev)
569 Dmsg1(29, "rewind_dev %s\n", dev->print_name());
571 dev->dev_errno = EBADF;
572 Mmsg1(dev->errmsg, _("Bad call to rewind_dev. Device %s not open\n"),
574 Emsg0(M_ABORT, 0, dev->errmsg);
577 dev->state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
578 dev->block_num = dev->file = 0;
581 if (dev->is_tape()) {
582 mt_com.mt_op = MTREW;
584 /* If we get an I/O error on rewind, it is probably because
585 * the drive is actually busy. We loop for (about 5 minutes)
586 * retrying every 5 seconds.
588 for (i=dev->max_rewind_wait; ; i -= 5) {
589 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
591 clrerror_dev(dev, MTREW);
592 if (i == dev->max_rewind_wait) {
593 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
595 if (dev->dev_errno == EIO && i > 0) {
596 Dmsg0(200, "Sleeping 5 seconds.\n");
600 Mmsg2(dev->errmsg, _("Rewind error on %s. ERR=%s.\n"),
601 dev->print_name(), be.strerror());
606 } else if (dev->is_file()) {
607 if (lseek_dev(dev, (off_t)0, SEEK_SET) < 0) {
609 dev->dev_errno = errno;
610 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
611 dev->print_name(), be.strerror());
618 void DEVICE::block(int why)
621 block_device(this, why);
625 void DEVICE::unblock()
628 unblock_device(this);
633 * Called to indicate that we have just read an
634 * EOF from the device.
636 void DEVICE::set_ateof()
646 * Called to indicate we are now at the end of the tape, and
647 * writing is not possible.
649 void DEVICE::set_ateot()
651 /* Make tape effectively read-only */
652 state |= (ST_EOF|ST_EOT|ST_WEOT);
657 * Position device to end of medium (end of data)
658 * Returns: true on succes
665 struct mtget mt_stat;
670 dev->dev_errno = EBADF;
671 Mmsg1(dev->errmsg, _("Bad call to eod_dev. Device %s not open\n"),
676 #if defined (__digital__) && defined (__unix__)
677 return fsf_dev(dev, dev->VolCatInfo.VolCatFiles);
680 Dmsg0(29, "eod_dev\n");
684 dev->state &= ~(ST_EOF); /* remove EOF flags */
685 dev->block_num = dev->file = 0;
688 if (dev->state & (ST_FIFO | ST_PROG)) {
691 if (!dev->is_tape()) {
692 pos = lseek_dev(dev, (off_t)0, SEEK_END);
693 // Dmsg1(100, "====== Seek to %lld\n", pos);
696 dev->state |= ST_EOT;
699 dev->dev_errno = errno;
701 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
702 dev->print_name(), be.strerror());
706 if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
707 Dmsg0(100,"Using FAST FSF for EOM\n");
708 /* If unknown position, rewind */
709 if (!dev_get_os_pos(dev, &mt_stat)) {
710 if (!rewind_dev(dev)) {
714 mt_com.mt_op = MTFSF;
716 * ***FIXME*** fix code to handle case that INT16_MAX is
719 mt_com.mt_count = INT16_MAX; /* use big positive number */
720 if (mt_com.mt_count < 0) {
721 mt_com.mt_count = INT16_MAX; /* brain damaged system */
725 if (dev_cap(dev, CAP_MTIOCGET) && (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM))) {
726 if (dev_cap(dev, CAP_EOM)) {
727 Dmsg0(100,"Using EOM for EOM\n");
728 mt_com.mt_op = MTEOM;
732 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
734 clrerror_dev(dev, mt_com.mt_op);
735 Dmsg1(50, "ioctl error: %s\n", be.strerror());
737 Mmsg2(dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
738 dev->print_name(), be.strerror());
742 if (!dev_get_os_pos(dev, &mt_stat)) {
744 clrerror_dev(dev, -1);
745 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
746 dev->print_name(), be.strerror());
749 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
751 dev->file = mt_stat.mt_fileno;
757 * Rewind then use FSF until EOT reached
759 if (!rewind_dev(dev)) {
763 * Move file by file to the end of the tape
766 for (file_num=dev->file; !dev->at_eot(); file_num++) {
767 Dmsg0(200, "eod_dev: doing fsf 1\n");
768 if (!fsf_dev(dev, 1)) {
769 Dmsg0(200, "fsf_dev error.\n");
773 * Avoid infinite loop. ***FIXME*** possibly add code
774 * to set EOD or to turn off CAP_FASTFSF if on.
776 if (file_num == (int)dev->file) {
777 struct mtget mt_stat;
778 Dmsg1(100, "fsf_dev did not advance from file %d\n", file_num);
779 if (dev_get_os_pos(dev, &mt_stat)) {
780 Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
782 dev->file = mt_stat.mt_fileno;
789 * Some drivers leave us after second EOF when doing
790 * MTEOM, so we must backup so that appending overwrites
793 if (dev_cap(dev, CAP_BSFATEOM)) {
794 struct mtget mt_stat;
795 /* Backup over EOF */
796 ok = bsf_dev(dev, 1);
797 /* If BSF worked and fileno is known (not -1), set file */
798 if (dev_get_os_pos(dev, &mt_stat)) {
799 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
800 dev->file = mt_stat.mt_fileno;
802 dev->file++; /* wing it -- not correct on all OSes */
805 update_pos_dev(dev); /* update position */
807 Dmsg1(200, "EOD dev->file=%d\n", dev->file);
812 * Set the position of the device -- only for files
813 * For other devices, there is no generic way to do it.
814 * Returns: true on succes
817 bool update_pos_dev(DEVICE *dev)
823 dev->dev_errno = EBADF;
824 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
825 Emsg0(M_FATAL, 0, dev->errmsg);
829 /* Find out where we are */
830 if (dev->is_file()) {
833 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
836 dev->dev_errno = errno;
837 Pmsg1(000, "Seek error: ERR=%s\n", be.strerror());
838 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
839 dev->print_name(), be.strerror());
842 dev->file_addr = pos;
850 * Return the status of the device. This was meant
851 * to be a generic routine. Unfortunately, it doesn't
852 * seem possible (at least I do not know how to do it
853 * currently), which means that for the moment, this
854 * routine has very little value.
858 uint32_t status_dev(DEVICE *dev)
860 struct mtget mt_stat;
863 if (dev->state & (ST_EOT | ST_WEOT)) {
867 if (dev->state & ST_EOF) {
871 if (dev->is_tape()) {
873 Pmsg0(-20," Bacula status:");
874 Pmsg2(-20," file=%d block=%d\n", dev->file, dev->block_num);
875 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
877 dev->dev_errno = errno;
878 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
879 dev->print_name(), be.strerror());
882 Pmsg0(-20, " Device status:");
884 #if defined(HAVE_LINUX_OS)
885 if (GMT_EOF(mt_stat.mt_gstat)) {
889 if (GMT_BOT(mt_stat.mt_gstat)) {
893 if (GMT_EOT(mt_stat.mt_gstat)) {
897 if (GMT_SM(mt_stat.mt_gstat)) {
901 if (GMT_EOD(mt_stat.mt_gstat)) {
905 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
907 Pmsg0(-20, " WR_PROT");
909 if (GMT_ONLINE(mt_stat.mt_gstat)) {
911 Pmsg0(-20, " ONLINE");
913 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
915 Pmsg0(-20, " DR_OPEN");
917 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
918 stat |= BMT_IM_REP_EN;
919 Pmsg0(-20, " IM_REP_EN");
921 #endif /* !SunOS && !OSF */
922 if (dev_cap(dev, CAP_MTIOCGET)) {
923 Pmsg2(-20, " file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
925 Pmsg2(-20, " file=%d block=%d\n", -1, -1);
928 stat |= BMT_ONLINE | BMT_BOT;
935 * Load medium in device
936 * Returns: true on success
939 bool load_dev(DEVICE *dev)
946 dev->dev_errno = EBADF;
947 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
948 Emsg0(M_FATAL, 0, dev->errmsg);
951 if (!(dev->is_tape())) {
955 Dmsg0(200, "stored: MTLOAD command not available\n");
957 dev->dev_errno = ENOTTY; /* function not available */
958 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
959 dev->print_name(), be.strerror());
963 dev->block_num = dev->file = 0;
966 mt_com.mt_op = MTLOAD;
968 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
970 dev->dev_errno = errno;
971 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
972 dev->print_name(), be.strerror());
980 * Rewind device and put it offline
981 * Returns: true on success
984 bool offline_dev(DEVICE *dev)
989 dev->dev_errno = EBADF;
990 Mmsg0(dev->errmsg, _("Bad call to offline_dev. Device not open\n"));
991 Emsg0(M_FATAL, 0, dev->errmsg);
994 if (!(dev->is_tape())) {
998 dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
999 dev->block_num = dev->file = 0;
1004 mt_com.mt_op = MTUNLOCK;
1005 mt_com.mt_count = 1;
1006 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1008 mt_com.mt_op = MTOFFL;
1009 mt_com.mt_count = 1;
1010 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1012 dev->dev_errno = errno;
1013 Mmsg2(dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1014 dev->print_name(), be.strerror());
1017 Dmsg1(100, "Offlined device %s\n", dev->print_name());
1021 bool offline_or_rewind_dev(DEVICE *dev)
1026 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1027 return offline_dev(dev);
1030 * Note, this rewind probably should not be here (it wasn't
1031 * in prior versions of Bacula), but on FreeBSD, this is
1032 * needed in the case the tape was "frozen" due to an error
1033 * such as backspacing after writing and EOF. If it is not
1034 * done, all future references to the drive get and I/O error.
1036 clrerror_dev(dev, MTREW);
1037 return rewind_dev(dev);
1042 * Foward space a file
1043 * Returns: true on success
1047 fsf_dev(DEVICE *dev, int num)
1049 struct mtget mt_stat;
1054 dev->dev_errno = EBADF;
1055 Mmsg0(dev->errmsg, _("Bad call to fsf_dev. Device not open\n"));
1056 Emsg0(M_FATAL, 0, dev->errmsg);
1060 if (!dev->is_tape()) {
1063 if (dev->state & ST_EOT) {
1065 Mmsg1(dev->errmsg, _("Device %s at End of Tape.\n"), dev->print_name());
1068 if (dev->state & ST_EOF) {
1069 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1072 Dmsg0(100, "fsf_dev\n");
1075 * If Fast forward space file is set, then we
1076 * use MTFSF to forward space and MTIOCGET
1077 * to get the file position. We assume that
1078 * the SCSI driver will ensure that we do not
1079 * forward space past the end of the medium.
1081 if (dev_cap(dev, CAP_FSF) && dev_cap(dev, CAP_MTIOCGET) && dev_cap(dev, CAP_FASTFSF)) {
1082 mt_com.mt_op = MTFSF;
1083 mt_com.mt_count = num;
1084 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1085 if (stat < 0 || !dev_get_os_pos(dev, &mt_stat)) {
1087 dev->state |= ST_EOT;
1088 Dmsg0(200, "Set ST_EOT\n");
1089 clrerror_dev(dev, MTFSF);
1090 Mmsg2(dev->errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1091 dev->print_name(), be.strerror());
1092 Dmsg1(200, "%s", dev->errmsg);
1095 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1097 dev->file = mt_stat.mt_fileno;
1101 * Here if CAP_FSF is set, and virtually all drives
1102 * these days support it, we read a record, then forward
1103 * space one file. Using this procedure, which is slow,
1104 * is the only way we can be sure that we don't read
1105 * two consecutive EOF marks, which means End of Data.
1107 } else if (dev_cap(dev, CAP_FSF)) {
1110 Dmsg0(200, "FSF has cap_fsf\n");
1111 if (dev->max_block_size == 0) {
1112 rbuf_len = DEFAULT_BLOCK_SIZE;
1114 rbuf_len = dev->max_block_size;
1116 rbuf = get_memory(rbuf_len);
1117 mt_com.mt_op = MTFSF;
1118 mt_com.mt_count = 1;
1119 while (num-- && !(dev->state & ST_EOT)) {
1120 Dmsg0(100, "Doing read before fsf\n");
1121 if ((stat = read(dev->fd, (char *)rbuf, rbuf_len)) < 0) {
1122 if (errno == ENOMEM) { /* tape record exceeds buf len */
1123 stat = rbuf_len; /* This is OK */
1126 dev->state |= ST_EOT;
1127 clrerror_dev(dev, -1);
1128 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev->dev_errno,
1130 Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1131 dev->print_name(), be.strerror());
1132 Dmsg1(100, "%s", dev->errmsg);
1136 if (stat == 0) { /* EOF */
1137 update_pos_dev(dev);
1138 Dmsg1(100, "End of File mark from read. File=%d\n", dev->file+1);
1139 /* Two reads of zero means end of tape */
1140 if (dev->state & ST_EOF) {
1141 dev->state |= ST_EOT;
1142 Dmsg0(100, "Set ST_EOT\n");
1148 } else { /* Got data */
1149 dev->state &= ~(ST_EOF|ST_EOT);
1152 Dmsg0(100, "Doing MTFSF\n");
1153 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1154 if (stat < 0) { /* error => EOT */
1156 dev->state |= ST_EOT;
1157 Dmsg0(100, "Set ST_EOT\n");
1158 clrerror_dev(dev, MTFSF);
1159 Mmsg2(dev->errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1160 dev->print_name(), be.strerror());
1161 Dmsg0(100, "Got < 0 for MTFSF\n");
1162 Dmsg1(100, "%s", dev->errmsg);
1170 * No FSF, so use FSR to simulate it
1173 Dmsg0(200, "Doing FSR for FSF\n");
1174 while (num-- && !(dev->state & ST_EOT)) {
1175 dev->fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1177 if (dev->state & ST_EOT) {
1179 Mmsg1(dev->errmsg, _("Device %s at End of Tape.\n"), dev->print_name());
1185 update_pos_dev(dev);
1186 Dmsg1(200, "Return %d from FSF\n", stat);
1187 if (dev->state & ST_EOF)
1188 Dmsg0(200, "ST_EOF set on exit FSF\n");
1189 if (dev->state & ST_EOT)
1190 Dmsg0(200, "ST_EOT set on exit FSF\n");
1191 Dmsg1(200, "Return from FSF file=%d\n", dev->file);
1196 * Backward space a file
1197 * Returns: false on failure
1201 bsf_dev(DEVICE *dev, int num)
1207 dev->dev_errno = EBADF;
1208 Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Device not open\n"));
1209 Emsg0(M_FATAL, 0, dev->errmsg);
1213 if (!dev->is_tape()) {
1214 Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1218 Dmsg0(29, "bsf_dev\n");
1219 dev->state &= ~(ST_EOT|ST_EOF);
1223 mt_com.mt_op = MTBSF;
1224 mt_com.mt_count = num;
1225 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1228 clrerror_dev(dev, MTBSF);
1229 Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1230 dev->print_name(), be.strerror());
1232 update_pos_dev(dev);
1238 * Foward space num records
1239 * Returns: false on failure
1242 bool DEVICE::fsr(int num)
1249 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1250 Emsg0(M_FATAL, 0, errmsg);
1257 if (!dev_cap(this, CAP_FSR)) {
1258 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1262 Dmsg1(29, "fsr %d\n", num);
1263 mt_com.mt_op = MTFSR;
1264 mt_com.mt_count = num;
1265 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1271 struct mtget mt_stat;
1272 clrerror_dev(this, MTFSR);
1273 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1274 if (dev_get_os_pos(this, &mt_stat)) {
1275 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1276 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1277 file = mt_stat.mt_fileno;
1278 block_num = mt_stat.mt_blkno;
1286 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1287 num, print_name(), be.strerror());
1289 update_pos_dev(this);
1294 * Backward space a record
1295 * Returns: false on failure
1299 bsr_dev(DEVICE *dev, int num)
1305 dev->dev_errno = EBADF;
1306 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1307 Emsg0(M_FATAL, 0, dev->errmsg);
1311 if (!dev->is_tape()) {
1315 if (!dev_cap(dev, CAP_BSR)) {
1316 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1320 Dmsg0(29, "bsr_dev\n");
1321 dev->block_num -= num;
1322 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1323 mt_com.mt_op = MTBSR;
1324 mt_com.mt_count = num;
1325 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1328 clrerror_dev(dev, MTBSR);
1329 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1330 dev->print_name(), be.strerror());
1332 update_pos_dev(dev);
1337 * Reposition the device to file, block
1338 * Returns: false on failure
1342 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1345 dev->dev_errno = EBADF;
1346 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1347 Emsg0(M_FATAL, 0, dev->errmsg);
1351 if (!dev->is_tape()) {
1352 off_t pos = (((off_t)file)<<32) + block;
1353 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1354 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1356 dev->dev_errno = errno;
1357 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1358 dev->print_name(), be.strerror());
1362 dev->block_num = block;
1363 dev->file_addr = pos;
1366 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1367 dev->file, dev->block_num, file, block);
1368 if (file < dev->file) {
1369 Dmsg0(100, "Rewind_dev\n");
1370 if (!rewind_dev(dev)) {
1374 if (file > dev->file) {
1375 Dmsg1(100, "fsf %d\n", file-dev->file);
1376 if (!fsf_dev(dev, file-dev->file)) {
1377 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1380 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1382 if (block < dev->block_num) {
1383 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1384 Dmsg0(100, "bsf_dev 1\n");
1386 Dmsg0(100, "fsf_dev 1\n");
1388 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1390 if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1391 /* Ignore errors as Bacula can read to the correct block */
1392 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1393 return dev->fsr(block-dev->block_num);
1401 * Write an end of file on the device
1402 * Returns: 0 on success
1403 * non-zero on failure
1406 weof_dev(DEVICE *dev, int num)
1410 Dmsg0(29, "weof_dev\n");
1413 dev->dev_errno = EBADF;
1414 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1415 Emsg0(M_FATAL, 0, dev->errmsg);
1420 if (!dev->is_tape()) {
1423 if (!dev->can_append()) {
1424 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1425 Emsg0(M_FATAL, 0, dev->errmsg);
1429 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1430 mt_com.mt_op = MTWEOF;
1431 mt_com.mt_count = num;
1432 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1439 clrerror_dev(dev, MTWEOF);
1441 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1442 dev->print_name(), be.strerror());
1449 * Return string message with last error in English
1450 * Be careful not to call this routine from within dev.c
1451 * while editing an Mmsg() or you will end up in a recursive
1452 * loop creating a Segmentation Violation.
1455 strerror_dev(DEVICE *dev)
1462 * If implemented in system, clear the tape
1466 clrerror_dev(DEVICE *dev, int func)
1468 const char *msg = NULL;
1469 struct mtget mt_stat;
1472 dev->dev_errno = errno; /* save errno */
1474 dev->VolCatInfo.VolCatErrors++;
1477 if (!dev->is_tape()) {
1480 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1483 Emsg0(M_ABORT, 0, "Got ENOTTY on read/write!\n");
1487 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1492 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1497 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1501 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1505 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1509 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1530 bsnprintf(buf, sizeof(buf), "unknown func code %d", func);
1535 dev->dev_errno = ENOSYS;
1536 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1537 Emsg0(M_ERROR, 0, dev->errmsg);
1540 /* On some systems such as NetBSD, this clears all errors */
1541 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1543 /* Found on Linux */
1547 mt_com.mt_op = MTIOCLRERR;
1548 mt_com.mt_count = 1;
1549 /* Clear any error condition on the tape */
1550 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1551 Dmsg0(200, "Did MTIOCLRERR\n");
1555 /* Typically on FreeBSD */
1558 /* Read and clear SCSI error status */
1559 union mterrstat mt_errstat;
1560 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1561 strerror(dev->dev_errno));
1562 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1566 /* Clear Subsystem Exception OSF1 */
1570 mt_com.mt_op = MTCSE;
1571 mt_com.mt_count = 1;
1572 /* Clear any error condition on the tape */
1573 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1574 Dmsg0(200, "Did MTCSE\n");
1580 * Flush buffer contents
1583 int flush_dev(DEVICE *dev)
1588 static void do_close(DEVICE *dev)
1591 Dmsg1(29, "really close_dev %s\n", dev->print_name());
1596 if (unmount_dev(dev, 1) < 0) {
1597 Dmsg1(0, "Cannot unmount device %s.\n", dev->print_name());
1600 /* Remove the last part file if it is empty */
1601 if (dev->can_append() && (dev->num_parts > 0)) {
1603 POOL_MEM archive_name(PM_FNAME);
1604 dev->part = dev->num_parts;
1605 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", dev->VolCatInfo.VolCatName);
1606 make_spooled_dvd_filename(dev, archive_name);
1607 /* Check that the part file is empty */
1608 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1609 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1610 unlink(archive_name.c_str());
1614 /* Clean up device packet so it can be reused */
1616 dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1617 dev->label_type = B_BACULA_LABEL;
1618 dev->file = dev->block_num = 0;
1623 dev->part_start = 0;
1624 dev->EndFile = dev->EndBlock = 0;
1625 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1626 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1628 stop_thread_timer(dev->tid);
1638 void DEVICE::close()
1640 /*if (fd >= 0 && use_count == 1) {*/
1641 /* No need to check if fd >= 0: it is checked again
1642 * in do_close, and do_close MUST be called for volumes
1643 * splitted in parts, even if fd == -1. */
1644 if (use_count == 1) {
1646 } else if (use_count > 0) {
1651 ASSERT(use_count >= 0);
1656 bool truncate_dev(DEVICE *dev)
1658 Dmsg1(100, "truncate_dev %s\n", dev->print_name());
1659 if (dev->is_tape()) {
1660 return true; /* we don't really truncate tapes */
1661 /* maybe we should rewind and write and eof ???? */
1664 if (dev->is_dvd()) {
1665 Mmsg1(dev->errmsg, _("Truncate DVD %s not supported.\n"), dev->print_name());
1666 return false; /* we cannot truncate DVDs */
1669 if (ftruncate(dev->fd, 0) != 0) {
1671 Mmsg2(dev->errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1672 dev->print_name(), be.strerror());
1678 /* Return the resource name for the device */
1679 const char *DEVICE::name() const
1681 return device->hdr.name;
1685 dev_vol_name(DEVICE *dev)
1687 return dev->VolCatInfo.VolCatName;
1690 uint32_t dev_block(DEVICE *dev)
1692 update_pos_dev(dev);
1693 return dev->block_num;
1696 uint32_t dev_file(DEVICE *dev)
1698 update_pos_dev(dev);
1703 * Free memory allocated for the device
1706 term_dev(DEVICE *dev)
1709 dev->dev_errno = EBADF;
1710 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1711 Emsg0(M_FATAL, 0, dev->errmsg);
1714 Dmsg1(29, "term_dev: %s\n", dev->print_name());
1716 if (dev->dev_name) {
1717 free_memory(dev->dev_name);
1718 dev->dev_name = NULL;
1720 if (dev->prt_name) {
1721 free_memory(dev->prt_name);
1722 dev->prt_name = NULL;
1725 free_pool_memory(dev->errmsg);
1728 pthread_mutex_destroy(&dev->mutex);
1729 pthread_cond_destroy(&dev->wait);
1730 pthread_cond_destroy(&dev->wait_next_vol);
1731 pthread_mutex_destroy(&dev->spool_mutex);
1732 rwl_destroy(&dev->lock);
1733 if (dev->attached_dcrs) {
1734 delete dev->attached_dcrs;
1735 dev->attached_dcrs = NULL;
1737 if (dev->state & ST_MALLOC) {
1738 free_pool_memory((POOLMEM *)dev);
1743 * This routine initializes the device wait timers
1745 void init_device_wait_timers(DCR *dcr)
1747 DEVICE *dev = dcr->dev;
1748 JCR *jcr = dcr->jcr;
1750 /* ******FIXME******* put these on config variables */
1751 dev->min_wait = 60 * 60;
1752 dev->max_wait = 24 * 60 * 60;
1753 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1754 dev->wait_sec = dev->min_wait;
1755 dev->rem_wait_sec = dev->wait_sec;
1758 dev->BadVolName[0] = 0;
1760 jcr->min_wait = 60 * 60;
1761 jcr->max_wait = 24 * 60 * 60;
1762 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1763 jcr->wait_sec = jcr->min_wait;
1764 jcr->rem_wait_sec = jcr->wait_sec;
1769 void init_jcr_device_wait_timers(JCR *jcr)
1771 /* ******FIXME******* put these on config variables */
1772 jcr->min_wait = 60 * 60;
1773 jcr->max_wait = 24 * 60 * 60;
1774 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1775 jcr->wait_sec = jcr->min_wait;
1776 jcr->rem_wait_sec = jcr->wait_sec;
1782 * The dev timers are used for waiting on a particular device
1784 * Returns: true if time doubled
1785 * false if max time expired
1787 bool double_dev_wait_time(DEVICE *dev)
1789 dev->wait_sec *= 2; /* double wait time */
1790 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
1791 dev->wait_sec = dev->max_wait;
1794 dev->rem_wait_sec = dev->wait_sec;
1795 if (dev->num_wait >= dev->max_num_wait) {
1802 void set_os_device_parameters(DEVICE *dev)
1804 #ifdef HAVE_LINUX_OS
1806 if (dev->min_block_size == dev->max_block_size &&
1807 dev->min_block_size == 0) { /* variable block mode */
1808 mt_com.mt_op = MTSETBLK;
1809 mt_com.mt_count = 0;
1810 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1811 clrerror_dev(dev, MTSETBLK);
1813 mt_com.mt_op = MTSETDRVBUFFER;
1814 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
1815 if (!dev_cap(dev, CAP_TWOEOF)) {
1816 mt_com.mt_count |= MT_ST_TWO_FM;
1818 if (dev_cap(dev, CAP_EOM)) {
1819 mt_com.mt_count |= MT_ST_FAST_MTEOM;
1821 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1822 clrerror_dev(dev, MTSETBLK);
1828 #ifdef HAVE_NETBSD_OS
1830 if (dev->min_block_size == dev->max_block_size &&
1831 dev->min_block_size == 0) { /* variable block mode */
1832 mt_com.mt_op = MTSETBSIZ;
1833 mt_com.mt_count = 0;
1834 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1835 clrerror_dev(dev, MTSETBSIZ);
1837 /* Get notified at logical end of tape */
1838 mt_com.mt_op = MTEWARN;
1839 mt_com.mt_count = 1;
1840 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1841 clrerror_dev(dev, MTEWARN);
1847 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
1849 if (dev->min_block_size == dev->max_block_size &&
1850 dev->min_block_size == 0) { /* variable block mode */
1851 mt_com.mt_op = MTSETBSIZ;
1852 mt_com.mt_count = 0;
1853 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1854 clrerror_dev(dev, MTSETBSIZ);
1862 if (dev->min_block_size == dev->max_block_size &&
1863 dev->min_block_size == 0) { /* variable block mode */
1864 mt_com.mt_op = MTSRSZ;
1865 mt_com.mt_count = 0;
1866 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1867 clrerror_dev(dev, MTSRSZ);
1874 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
1876 return dev_cap(dev, CAP_MTIOCGET) &&
1877 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
1878 mt_stat->mt_fileno >= 0;