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 (NB:??? I think it's VolCatInfo.VolCatName that is right)
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 Dmsg1(10, "Could not open file device %s. No Volume name given.\n",
466 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
477 if (dcr->dev->num_parts < dcr->VolCatInfo.VolCatParts) {
478 Dmsg2(99, "open_dvd_device: num_parts updated to %d (was %d)\n",
479 dcr->VolCatInfo.VolCatParts, dcr->dev->num_parts);
480 dcr->dev->num_parts = dcr->VolCatInfo.VolCatParts;
483 if (mount_dev(this, 1)) {
484 if ((num_parts == 0) && (!truncating)) {
485 /* If we can mount the device, and we are not truncating the DVD, we usually want to abort. */
486 /* There is one exception, if there is only one 0-sized file on the DVD, with the right volume name,
487 * we continue (it's the method used by truncate_dvd_dev to truncate a volume). */
488 if (!check_can_write_on_non_blank_dvd(dcr)) {
489 Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
490 Emsg0(M_FATAL, 0, errmsg);
497 /* We cannot mount the device */
498 if (num_parts == 0) {
499 /* Run free space, check there is a media. */
500 Dmsg1(29, "Could not mount device %s, this is not a problem (num_parts == 0).\n", print_name());
503 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
504 Emsg0(M_FATAL, 0, errmsg);
510 Dmsg6(29, "open dev: %s dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
511 is_dvd()?"DVD":"disk", archive_name.c_str(), mode_to_str(omode),
512 part, num_parts, dcr->VolCatInfo.VolCatParts);
514 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
517 * If we are not trying to access the last part, set mode to
518 * OPEN_READ_ONLY as writing would be an error.
520 if (part < num_parts) {
521 omode = OPEN_READ_ONLY;
522 make_mounted_dvd_filename(this, archive_name);
525 make_spooled_dvd_filename(this, archive_name);
529 /* If creating file, give 0640 permissions */
530 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
531 archive_name.c_str(), mode);
532 /* Use system open() */
533 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
535 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
537 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
538 Dmsg1(29, "open failed: %s", errmsg);
540 if ((omode == OPEN_READ_ONLY) && (part == num_parts)) {
541 /* If the last part (on spool), doesn't exists when reading, create it and read from it
542 * (it will report immediately an EOF):
543 * Sometimes it is better to finish with an EOF than with an error. */
544 set_mode(OPEN_READ_WRITE);
545 fd = ::open(archive_name.c_str(), mode, 0640);
546 set_mode(OPEN_READ_ONLY);
549 /* We don't need it. Only the last part is on spool */
550 /*if (omode == OPEN_READ_ONLY) {
551 make_spooled_dvd_filename(this, archive_name);
552 fd = ::open(archive_name.c_str(), mode, 0640); // try on spool
555 Dmsg1(100, "after open fd=%d\n", fd);
557 /* Get size of file */
558 if (fstat(fd, &filestat) < 0) {
561 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
563 Dmsg1(29, "open failed: %s", errmsg);
564 /* Use system close() */
568 part_size = filestat.st_size;
572 update_pos_dev(this); /* update position */
574 /* NB: It seems this code is wrong... part number is incremented in open_next_part, not here */
576 /* Check if just created Volume part */
577 /* if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
580 VolCatInfo.VolCatParts = num_parts;
582 if (part == 0) { // we must have opened the first part
593 bool _rewind_dev(char *file, int line, DEVICE *dev)
595 Dmsg3(100, "rewind_dev fd=%d called from %s:%d\n", dev->fd, file, line);
596 return rewind_dev(dev);
602 * Returns: true on success
605 bool rewind_dev(DEVICE *dev)
610 Dmsg2(29, "rewind_dev fd=%d %s\n", dev->fd, dev->print_name());
612 if (!dev->is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
613 dev->dev_errno = EBADF;
614 Mmsg1(dev->errmsg, _("Bad call to rewind_dev. Device %s not open\n"),
616 Emsg0(M_ABORT, 0, dev->errmsg);
620 dev->state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
621 dev->block_num = dev->file = 0;
624 if (dev->is_tape()) {
625 mt_com.mt_op = MTREW;
627 /* If we get an I/O error on rewind, it is probably because
628 * the drive is actually busy. We loop for (about 5 minutes)
629 * retrying every 5 seconds.
631 for (i=dev->max_rewind_wait; ; i -= 5) {
632 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
634 clrerror_dev(dev, MTREW);
635 if (i == dev->max_rewind_wait) {
636 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
638 if (dev->dev_errno == EIO && i > 0) {
639 Dmsg0(200, "Sleeping 5 seconds.\n");
643 Mmsg2(dev->errmsg, _("Rewind error on %s. ERR=%s.\n"),
644 dev->print_name(), be.strerror());
649 } else if (dev->is_file()) {
650 if (lseek_dev(dev, (off_t)0, SEEK_SET) < 0) {
652 dev->dev_errno = errno;
653 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
654 dev->print_name(), be.strerror());
661 void DEVICE::block(int why)
664 block_device(this, why);
668 void DEVICE::unblock()
671 unblock_device(this);
675 const char *DEVICE::print_blocked() const
677 switch (dev_blocked) {
678 case BST_NOT_BLOCKED:
679 return "BST_NOT_BLOCKED";
681 return "BST_UNMOUNTED";
682 case BST_WAITING_FOR_SYSOP:
683 return "BST_WAITING_FOR_SYSOP";
684 case BST_DOING_ACQUIRE:
685 return "BST_DOING_ACQUIRE";
686 case BST_WRITING_LABEL:
687 return "BST_WRITING_LABEL";
688 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
689 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
693 return "unknown blocked code";
698 * Called to indicate that we have just read an
699 * EOF from the device.
701 void DEVICE::set_ateof()
711 * Called to indicate we are now at the end of the tape, and
712 * writing is not possible.
714 void DEVICE::set_ateot()
716 /* Make tape effectively read-only */
717 state |= (ST_EOF|ST_EOT|ST_WEOT);
722 * Position device to end of medium (end of data)
723 * Returns: true on succes
730 struct mtget mt_stat;
735 dev->dev_errno = EBADF;
736 Mmsg1(dev->errmsg, _("Bad call to eod_dev. Device %s not open\n"),
741 #if defined (__digital__) && defined (__unix__)
742 return dev->fsf(dev->VolCatInfo.VolCatFiles);
745 Dmsg0(29, "eod_dev\n");
749 dev->state &= ~(ST_EOF); /* remove EOF flags */
750 dev->block_num = dev->file = 0;
753 if (dev->state & (ST_FIFO | ST_PROG)) {
756 if (!dev->is_tape()) {
757 pos = lseek_dev(dev, (off_t)0, SEEK_END);
758 // Dmsg1(100, "====== Seek to %lld\n", pos);
761 dev->state |= ST_EOT;
764 dev->dev_errno = errno;
766 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
767 dev->print_name(), be.strerror());
771 if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
772 Dmsg0(100,"Using FAST FSF for EOM\n");
773 /* If unknown position, rewind */
774 if (!dev_get_os_pos(dev, &mt_stat)) {
775 if (!rewind_dev(dev)) {
779 mt_com.mt_op = MTFSF;
781 * ***FIXME*** fix code to handle case that INT16_MAX is
784 mt_com.mt_count = INT16_MAX; /* use big positive number */
785 if (mt_com.mt_count < 0) {
786 mt_com.mt_count = INT16_MAX; /* brain damaged system */
790 if (dev_cap(dev, CAP_MTIOCGET) && (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM))) {
791 if (dev_cap(dev, CAP_EOM)) {
792 Dmsg0(100,"Using EOM for EOM\n");
793 mt_com.mt_op = MTEOM;
797 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
799 clrerror_dev(dev, mt_com.mt_op);
800 Dmsg1(50, "ioctl error: %s\n", be.strerror());
802 Mmsg2(dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
803 dev->print_name(), be.strerror());
807 if (!dev_get_os_pos(dev, &mt_stat)) {
809 clrerror_dev(dev, -1);
810 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
811 dev->print_name(), be.strerror());
814 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
816 dev->file = mt_stat.mt_fileno;
822 * Rewind then use FSF until EOT reached
824 if (!rewind_dev(dev)) {
828 * Move file by file to the end of the tape
831 for (file_num=dev->file; !dev->at_eot(); file_num++) {
832 Dmsg0(200, "eod_dev: doing fsf 1\n");
834 Dmsg0(200, "fsf error.\n");
838 * Avoid infinite loop. ***FIXME*** possibly add code
839 * to set EOD or to turn off CAP_FASTFSF if on.
841 if (file_num == (int)dev->file) {
842 struct mtget mt_stat;
843 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
844 if (dev_get_os_pos(dev, &mt_stat)) {
845 Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
847 dev->file = mt_stat.mt_fileno;
854 * Some drivers leave us after second EOF when doing
855 * MTEOM, so we must backup so that appending overwrites
858 if (dev_cap(dev, CAP_BSFATEOM)) {
859 struct mtget mt_stat;
860 /* Backup over EOF */
861 ok = bsf_dev(dev, 1);
862 /* If BSF worked and fileno is known (not -1), set file */
863 if (dev_get_os_pos(dev, &mt_stat)) {
864 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
865 dev->file = mt_stat.mt_fileno;
867 dev->file++; /* wing it -- not correct on all OSes */
870 update_pos_dev(dev); /* update position */
872 Dmsg1(200, "EOD dev->file=%d\n", dev->file);
877 * Set the position of the device -- only for files
878 * For other devices, there is no generic way to do it.
879 * Returns: true on succes
882 bool update_pos_dev(DEVICE *dev)
888 dev->dev_errno = EBADF;
889 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
890 Emsg0(M_FATAL, 0, dev->errmsg);
894 /* Find out where we are */
895 if (dev->is_file()) {
898 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
901 dev->dev_errno = errno;
902 Pmsg1(000, "Seek error: ERR=%s\n", be.strerror());
903 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
904 dev->print_name(), be.strerror());
907 dev->file_addr = pos;
915 * Return the status of the device. This was meant
916 * to be a generic routine. Unfortunately, it doesn't
917 * seem possible (at least I do not know how to do it
918 * currently), which means that for the moment, this
919 * routine has very little value.
923 uint32_t status_dev(DEVICE *dev)
925 struct mtget mt_stat;
928 if (dev->state & (ST_EOT | ST_WEOT)) {
932 if (dev->state & ST_EOF) {
936 if (dev->is_tape()) {
938 Pmsg0(-20," Bacula status:");
939 Pmsg2(-20," file=%d block=%d\n", dev->file, dev->block_num);
940 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
942 dev->dev_errno = errno;
943 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
944 dev->print_name(), be.strerror());
947 Pmsg0(-20, " Device status:");
949 #if defined(HAVE_LINUX_OS)
950 if (GMT_EOF(mt_stat.mt_gstat)) {
954 if (GMT_BOT(mt_stat.mt_gstat)) {
958 if (GMT_EOT(mt_stat.mt_gstat)) {
962 if (GMT_SM(mt_stat.mt_gstat)) {
966 if (GMT_EOD(mt_stat.mt_gstat)) {
970 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
972 Pmsg0(-20, " WR_PROT");
974 if (GMT_ONLINE(mt_stat.mt_gstat)) {
976 Pmsg0(-20, " ONLINE");
978 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
980 Pmsg0(-20, " DR_OPEN");
982 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
983 stat |= BMT_IM_REP_EN;
984 Pmsg0(-20, " IM_REP_EN");
986 #endif /* !SunOS && !OSF */
987 if (dev_cap(dev, CAP_MTIOCGET)) {
988 Pmsg2(-20, " file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
990 Pmsg2(-20, " file=%d block=%d\n", -1, -1);
993 stat |= BMT_ONLINE | BMT_BOT;
1000 * Load medium in device
1001 * Returns: true on success
1004 bool load_dev(DEVICE *dev)
1011 dev->dev_errno = EBADF;
1012 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1013 Emsg0(M_FATAL, 0, dev->errmsg);
1016 if (!(dev->is_tape())) {
1020 Dmsg0(200, "stored: MTLOAD command not available\n");
1022 dev->dev_errno = ENOTTY; /* function not available */
1023 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1024 dev->print_name(), be.strerror());
1028 dev->block_num = dev->file = 0;
1031 mt_com.mt_op = MTLOAD;
1032 mt_com.mt_count = 1;
1033 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1035 dev->dev_errno = errno;
1036 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1037 dev->print_name(), be.strerror());
1045 * Rewind device and put it offline
1046 * Returns: true on success
1049 bool offline_dev(DEVICE *dev)
1054 dev->dev_errno = EBADF;
1055 Mmsg0(dev->errmsg, _("Bad call to offline_dev. Device not open\n"));
1056 Emsg0(M_FATAL, 0, dev->errmsg);
1059 if (!(dev->is_tape())) {
1063 dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1064 dev->block_num = dev->file = 0;
1069 mt_com.mt_op = MTUNLOCK;
1070 mt_com.mt_count = 1;
1071 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1073 mt_com.mt_op = MTOFFL;
1074 mt_com.mt_count = 1;
1075 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1077 dev->dev_errno = errno;
1078 Mmsg2(dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1079 dev->print_name(), be.strerror());
1082 Dmsg1(100, "Offlined device %s\n", dev->print_name());
1086 bool offline_or_rewind_dev(DEVICE *dev)
1091 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1092 return offline_dev(dev);
1095 * Note, this rewind probably should not be here (it wasn't
1096 * in prior versions of Bacula), but on FreeBSD, this is
1097 * needed in the case the tape was "frozen" due to an error
1098 * such as backspacing after writing and EOF. If it is not
1099 * done, all future references to the drive get and I/O error.
1101 clrerror_dev(dev, MTREW);
1102 return rewind_dev(dev);
1107 * Foward space a file
1108 * Returns: true on success
1111 bool DEVICE::fsf(int num)
1113 struct mtget mt_stat;
1119 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1120 Emsg0(M_FATAL, 0, errmsg);
1129 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1133 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1136 Dmsg0(100, "fsf\n");
1139 * If Fast forward space file is set, then we
1140 * use MTFSF to forward space and MTIOCGET
1141 * to get the file position. We assume that
1142 * the SCSI driver will ensure that we do not
1143 * forward space past the end of the medium.
1145 if (dev_cap(this, CAP_FSF) && dev_cap(this, CAP_MTIOCGET) && dev_cap(this, CAP_FASTFSF)) {
1146 mt_com.mt_op = MTFSF;
1147 mt_com.mt_count = num;
1148 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1149 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1152 Dmsg0(200, "Set ST_EOT\n");
1153 clrerror_dev(this, MTFSF);
1154 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1155 print_name(), be.strerror());
1156 Dmsg1(200, "%s", errmsg);
1159 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1161 file = mt_stat.mt_fileno;
1165 * Here if CAP_FSF is set, and virtually all drives
1166 * these days support it, we read a record, then forward
1167 * space one file. Using this procedure, which is slow,
1168 * is the only way we can be sure that we don't read
1169 * two consecutive EOF marks, which means End of Data.
1171 } else if (dev_cap(this, CAP_FSF)) {
1174 Dmsg0(200, "FSF has cap_fsf\n");
1175 if (max_block_size == 0) {
1176 rbuf_len = DEFAULT_BLOCK_SIZE;
1178 rbuf_len = max_block_size;
1180 rbuf = get_memory(rbuf_len);
1181 mt_com.mt_op = MTFSF;
1182 mt_com.mt_count = 1;
1183 while (num-- && !at_eot()) {
1184 Dmsg0(100, "Doing read before fsf\n");
1185 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1186 if (errno == ENOMEM) { /* tape record exceeds buf len */
1187 stat = rbuf_len; /* This is OK */
1189 * On IBM drives, they return ENOSPC at EOM
1190 * instead of EOF status
1192 } else if (at_eof() && errno == ENOSPC) {
1197 clrerror_dev(this, -1);
1198 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1200 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1201 print_name(), be.strerror());
1202 Dmsg1(100, "%s", errmsg);
1206 if (stat == 0) { /* EOF */
1207 update_pos_dev(this);
1208 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1209 /* Two reads of zero means end of tape */
1212 Dmsg0(100, "Set ST_EOT\n");
1218 } else { /* Got data */
1223 Dmsg0(100, "Doing MTFSF\n");
1224 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1225 if (stat < 0) { /* error => EOT */
1228 Dmsg0(100, "Set ST_EOT\n");
1229 clrerror_dev(this, MTFSF);
1230 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1231 print_name(), be.strerror());
1232 Dmsg0(100, "Got < 0 for MTFSF\n");
1233 Dmsg1(100, "%s", errmsg);
1241 * No FSF, so use FSR to simulate it
1244 Dmsg0(200, "Doing FSR for FSF\n");
1245 while (num-- && !at_eot()) {
1246 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1250 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1256 update_pos_dev(this);
1257 Dmsg1(200, "Return %d from FSF\n", stat);
1259 Dmsg0(200, "ST_EOF set on exit FSF\n");
1261 Dmsg0(200, "ST_EOT set on exit FSF\n");
1262 Dmsg1(200, "Return from FSF file=%d\n", file);
1267 * Backward space a file
1268 * Returns: false on failure
1272 bsf_dev(DEVICE *dev, int num)
1278 dev->dev_errno = EBADF;
1279 Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Device not open\n"));
1280 Emsg0(M_FATAL, 0, dev->errmsg);
1284 if (!dev->is_tape()) {
1285 Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1289 Dmsg0(29, "bsf_dev\n");
1290 dev->state &= ~(ST_EOT|ST_EOF);
1294 mt_com.mt_op = MTBSF;
1295 mt_com.mt_count = num;
1296 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1299 clrerror_dev(dev, MTBSF);
1300 Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1301 dev->print_name(), be.strerror());
1303 update_pos_dev(dev);
1309 * Foward space num records
1310 * Returns: false on failure
1313 bool DEVICE::fsr(int num)
1320 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1321 Emsg0(M_FATAL, 0, errmsg);
1328 if (!dev_cap(this, CAP_FSR)) {
1329 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1333 Dmsg1(29, "fsr %d\n", num);
1334 mt_com.mt_op = MTFSR;
1335 mt_com.mt_count = num;
1336 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1342 struct mtget mt_stat;
1343 clrerror_dev(this, MTFSR);
1344 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1345 if (dev_get_os_pos(this, &mt_stat)) {
1346 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1347 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1348 file = mt_stat.mt_fileno;
1349 block_num = mt_stat.mt_blkno;
1357 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1358 num, print_name(), be.strerror());
1360 update_pos_dev(this);
1365 * Backward space a record
1366 * Returns: false on failure
1370 bsr_dev(DEVICE *dev, int num)
1376 dev->dev_errno = EBADF;
1377 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1378 Emsg0(M_FATAL, 0, dev->errmsg);
1382 if (!dev->is_tape()) {
1386 if (!dev_cap(dev, CAP_BSR)) {
1387 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1391 Dmsg0(29, "bsr_dev\n");
1392 dev->block_num -= num;
1393 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1394 mt_com.mt_op = MTBSR;
1395 mt_com.mt_count = num;
1396 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1399 clrerror_dev(dev, MTBSR);
1400 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1401 dev->print_name(), be.strerror());
1403 update_pos_dev(dev);
1408 * Reposition the device to file, block
1409 * Returns: false on failure
1413 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1416 dev->dev_errno = EBADF;
1417 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1418 Emsg0(M_FATAL, 0, dev->errmsg);
1422 if (!dev->is_tape()) {
1423 off_t pos = (((off_t)file)<<32) + block;
1424 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1425 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1427 dev->dev_errno = errno;
1428 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1429 dev->print_name(), be.strerror());
1433 dev->block_num = block;
1434 dev->file_addr = pos;
1437 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1438 dev->file, dev->block_num, file, block);
1439 if (file < dev->file) {
1440 Dmsg0(100, "Rewind_dev\n");
1441 if (!rewind_dev(dev)) {
1445 if (file > dev->file) {
1446 Dmsg1(100, "fsf %d\n", file-dev->file);
1447 if (!dev->fsf(file-dev->file)) {
1448 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1451 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1453 if (block < dev->block_num) {
1454 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1455 Dmsg0(100, "bsf_dev 1\n");
1457 Dmsg0(100, "fsf_dev 1\n");
1459 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1461 if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1462 /* Ignore errors as Bacula can read to the correct block */
1463 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1464 return dev->fsr(block-dev->block_num);
1472 * Write an end of file on the device
1473 * Returns: 0 on success
1474 * non-zero on failure
1477 weof_dev(DEVICE *dev, int num)
1481 Dmsg0(29, "weof_dev\n");
1484 dev->dev_errno = EBADF;
1485 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1486 Emsg0(M_FATAL, 0, dev->errmsg);
1491 if (!dev->is_tape()) {
1494 if (!dev->can_append()) {
1495 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1496 Emsg0(M_FATAL, 0, dev->errmsg);
1500 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1501 mt_com.mt_op = MTWEOF;
1502 mt_com.mt_count = num;
1503 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1510 clrerror_dev(dev, MTWEOF);
1512 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1513 dev->print_name(), be.strerror());
1520 * Return string message with last error in English
1521 * Be careful not to call this routine from within dev.c
1522 * while editing an Mmsg() or you will end up in a recursive
1523 * loop creating a Segmentation Violation.
1526 strerror_dev(DEVICE *dev)
1533 * If implemented in system, clear the tape
1537 clrerror_dev(DEVICE *dev, int func)
1539 const char *msg = NULL;
1540 struct mtget mt_stat;
1543 dev->dev_errno = errno; /* save errno */
1545 dev->VolCatInfo.VolCatErrors++;
1548 if (!dev->is_tape()) {
1551 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1554 Emsg0(M_ABORT, 0, "Got ENOTTY on read/write!\n");
1558 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1563 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1568 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1572 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1576 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1580 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1601 bsnprintf(buf, sizeof(buf), "unknown func code %d", func);
1606 dev->dev_errno = ENOSYS;
1607 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1608 Emsg0(M_ERROR, 0, dev->errmsg);
1611 /* On some systems such as NetBSD, this clears all errors */
1612 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1614 /* Found on Linux */
1618 mt_com.mt_op = MTIOCLRERR;
1619 mt_com.mt_count = 1;
1620 /* Clear any error condition on the tape */
1621 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1622 Dmsg0(200, "Did MTIOCLRERR\n");
1626 /* Typically on FreeBSD */
1629 /* Read and clear SCSI error status */
1630 union mterrstat mt_errstat;
1631 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1632 strerror(dev->dev_errno));
1633 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1637 /* Clear Subsystem Exception OSF1 */
1641 mt_com.mt_op = MTCSE;
1642 mt_com.mt_count = 1;
1643 /* Clear any error condition on the tape */
1644 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1645 Dmsg0(200, "Did MTCSE\n");
1651 * Flush buffer contents
1654 int flush_dev(DEVICE *dev)
1659 static void do_close(DEVICE *dev)
1662 Dmsg1(29, "really close_dev %s\n", dev->print_name());
1667 if (!unmount_dev(dev, 1)) {
1668 Dmsg1(0, "Cannot unmount device %s.\n", dev->print_name());
1671 /* Remove the last part file if it is empty */
1672 if (dev->can_append() && (dev->num_parts > 0)) {
1674 POOL_MEM archive_name(PM_FNAME);
1675 dev->part = dev->num_parts;
1676 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", dev->VolCatInfo.VolCatName);
1677 make_spooled_dvd_filename(dev, archive_name);
1678 /* Check that the part file is empty */
1679 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1680 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1681 unlink(archive_name.c_str());
1685 /* Clean up device packet so it can be reused */
1687 dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1688 dev->label_type = B_BACULA_LABEL;
1689 dev->file = dev->block_num = 0;
1695 dev->part_start = 0;
1696 dev->EndFile = dev->EndBlock = 0;
1697 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1698 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1700 stop_thread_timer(dev->tid);
1710 void DEVICE::close()
1712 /*if (fd >= 0 && use_count == 1) {*/
1713 /* No need to check if fd >= 0: it is checked again
1714 * in do_close, and do_close MUST be called for volumes
1715 * splitted in parts, even if fd == -1. */
1716 if (use_count == 1) {
1718 } else if (use_count > 0) {
1723 ASSERT(use_count >= 0);
1728 bool truncate_dev(DCR *dcr) /* We need the DCR for DVD-writing */
1730 DEVICE *dev = dcr->dev;
1732 Dmsg1(100, "truncate_dev %s\n", dev->print_name());
1733 if (dev->is_tape()) {
1734 return true; /* we don't really truncate tapes */
1735 /* maybe we should rewind and write and eof ???? */
1738 if (dev->is_dvd()) {
1739 return truncate_dvd_dev(dcr);
1742 if (ftruncate(dev->fd, 0) != 0) {
1744 Mmsg2(dev->errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1745 dev->print_name(), be.strerror());
1751 /* Return the resource name for the device */
1752 const char *DEVICE::name() const
1754 return device->hdr.name;
1758 dev_vol_name(DEVICE *dev)
1760 return dev->VolCatInfo.VolCatName;
1763 uint32_t dev_block(DEVICE *dev)
1765 update_pos_dev(dev);
1766 return dev->block_num;
1769 uint32_t dev_file(DEVICE *dev)
1771 update_pos_dev(dev);
1776 * Free memory allocated for the device
1779 term_dev(DEVICE *dev)
1782 dev->dev_errno = EBADF;
1783 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1784 Emsg0(M_FATAL, 0, dev->errmsg);
1787 Dmsg1(29, "term_dev: %s\n", dev->print_name());
1789 if (dev->dev_name) {
1790 free_memory(dev->dev_name);
1791 dev->dev_name = NULL;
1793 if (dev->prt_name) {
1794 free_memory(dev->prt_name);
1795 dev->prt_name = NULL;
1798 free_pool_memory(dev->errmsg);
1801 pthread_mutex_destroy(&dev->mutex);
1802 pthread_cond_destroy(&dev->wait);
1803 pthread_cond_destroy(&dev->wait_next_vol);
1804 pthread_mutex_destroy(&dev->spool_mutex);
1805 rwl_destroy(&dev->lock);
1806 if (dev->attached_dcrs) {
1807 delete dev->attached_dcrs;
1808 dev->attached_dcrs = NULL;
1810 if (dev->state & ST_MALLOC) {
1811 free_pool_memory((POOLMEM *)dev);
1816 * This routine initializes the device wait timers
1818 void init_device_wait_timers(DCR *dcr)
1820 DEVICE *dev = dcr->dev;
1821 JCR *jcr = dcr->jcr;
1823 /* ******FIXME******* put these on config variables */
1824 dev->min_wait = 60 * 60;
1825 dev->max_wait = 24 * 60 * 60;
1826 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1827 dev->wait_sec = dev->min_wait;
1828 dev->rem_wait_sec = dev->wait_sec;
1831 dev->BadVolName[0] = 0;
1833 jcr->min_wait = 60 * 60;
1834 jcr->max_wait = 24 * 60 * 60;
1835 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1836 jcr->wait_sec = jcr->min_wait;
1837 jcr->rem_wait_sec = jcr->wait_sec;
1842 void init_jcr_device_wait_timers(JCR *jcr)
1844 /* ******FIXME******* put these on config variables */
1845 jcr->min_wait = 60 * 60;
1846 jcr->max_wait = 24 * 60 * 60;
1847 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1848 jcr->wait_sec = jcr->min_wait;
1849 jcr->rem_wait_sec = jcr->wait_sec;
1855 * The dev timers are used for waiting on a particular device
1857 * Returns: true if time doubled
1858 * false if max time expired
1860 bool double_dev_wait_time(DEVICE *dev)
1862 dev->wait_sec *= 2; /* double wait time */
1863 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
1864 dev->wait_sec = dev->max_wait;
1867 dev->rem_wait_sec = dev->wait_sec;
1868 if (dev->num_wait >= dev->max_num_wait) {
1875 void set_os_device_parameters(DEVICE *dev)
1877 #ifdef HAVE_LINUX_OS
1879 if (dev->min_block_size == dev->max_block_size &&
1880 dev->min_block_size == 0) { /* variable block mode */
1881 mt_com.mt_op = MTSETBLK;
1882 mt_com.mt_count = 0;
1883 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1884 clrerror_dev(dev, MTSETBLK);
1886 mt_com.mt_op = MTSETDRVBUFFER;
1887 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
1888 if (!dev_cap(dev, CAP_TWOEOF)) {
1889 mt_com.mt_count |= MT_ST_TWO_FM;
1891 if (dev_cap(dev, CAP_EOM)) {
1892 mt_com.mt_count |= MT_ST_FAST_MTEOM;
1894 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1895 clrerror_dev(dev, MTSETBLK);
1901 #ifdef HAVE_NETBSD_OS
1903 if (dev->min_block_size == dev->max_block_size &&
1904 dev->min_block_size == 0) { /* variable block mode */
1905 mt_com.mt_op = MTSETBSIZ;
1906 mt_com.mt_count = 0;
1907 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1908 clrerror_dev(dev, MTSETBSIZ);
1910 /* Get notified at logical end of tape */
1911 mt_com.mt_op = MTEWARN;
1912 mt_com.mt_count = 1;
1913 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1914 clrerror_dev(dev, MTEWARN);
1920 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
1922 if (dev->min_block_size == dev->max_block_size &&
1923 dev->min_block_size == 0) { /* variable block mode */
1924 mt_com.mt_op = MTSETBSIZ;
1925 mt_com.mt_count = 0;
1926 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1927 clrerror_dev(dev, MTSETBSIZ);
1935 if (dev->min_block_size == dev->max_block_size &&
1936 dev->min_block_size == 0) { /* variable block mode */
1937 mt_com.mt_op = MTSRSZ;
1938 mt_com.mt_count = 0;
1939 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1940 clrerror_dev(dev, MTSRSZ);
1947 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
1949 return dev_cap(dev, CAP_MTIOCGET) &&
1950 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
1951 mt_stat->mt_fileno >= 0;
1954 static char *modes[] = {
1955 "CREATE_READ_WRITE",
1962 static char *mode_to_str(int mode)
1964 return modes[mode-1];