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 update_free_space_dev(this);
502 Dmsg1(29, "Could not mount device %s, this is not a problem (num_parts == 0), and have media.\n", print_name());
505 Mmsg(errmsg, _("There is no valid media in the device %s.\n"), print_name());
506 Emsg0(M_FATAL, 0, errmsg);
512 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
513 Emsg0(M_FATAL, 0, errmsg);
519 Dmsg6(29, "open dev: %s dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
520 is_dvd()?"DVD":"disk", archive_name.c_str(), mode_to_str(omode),
521 part, num_parts, dcr->VolCatInfo.VolCatParts);
523 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
526 * If we are not trying to access the last part, set mode to
527 * OPEN_READ_ONLY as writing would be an error.
529 if (part < num_parts) {
530 omode = OPEN_READ_ONLY;
531 make_mounted_dvd_filename(this, archive_name);
534 make_spooled_dvd_filename(this, archive_name);
538 /* If creating file, give 0640 permissions */
539 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
540 archive_name.c_str(), mode);
541 /* Use system open() */
542 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
544 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
546 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
547 Dmsg1(29, "open failed: %s", errmsg);
549 if ((omode == OPEN_READ_ONLY) && (part == num_parts)) {
550 /* If the last part (on spool), doesn't exists when reading, create it and read from it
551 * (it will report immediately an EOF):
552 * Sometimes it is better to finish with an EOF than with an error. */
553 set_mode(OPEN_READ_WRITE);
554 fd = ::open(archive_name.c_str(), mode, 0640);
555 set_mode(OPEN_READ_ONLY);
558 /* We don't need it. Only the last part is on spool */
559 /*if (omode == OPEN_READ_ONLY) {
560 make_spooled_dvd_filename(this, archive_name);
561 fd = ::open(archive_name.c_str(), mode, 0640); // try on spool
564 Dmsg1(100, "after open fd=%d\n", fd);
566 /* Get size of file */
567 if (fstat(fd, &filestat) < 0) {
570 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
572 Dmsg1(29, "open failed: %s", errmsg);
573 /* Use system close() */
577 part_size = filestat.st_size;
581 update_pos_dev(this); /* update position */
583 /* NB: It seems this code is wrong... part number is incremented in open_next_part, not here */
585 /* Check if just created Volume part */
586 /* if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
589 VolCatInfo.VolCatParts = num_parts;
591 if (part == 0) { // we must have opened the first part
602 bool _rewind_dev(char *file, int line, DEVICE *dev)
604 Dmsg3(100, "rewind_dev fd=%d called from %s:%d\n", dev->fd, file, line);
605 return rewind_dev(dev);
611 * Returns: true on success
614 bool rewind_dev(DEVICE *dev)
619 Dmsg2(29, "rewind_dev fd=%d %s\n", dev->fd, dev->print_name());
621 if (!dev->is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
622 dev->dev_errno = EBADF;
623 Mmsg1(dev->errmsg, _("Bad call to rewind_dev. Device %s not open\n"),
625 Emsg0(M_ABORT, 0, dev->errmsg);
629 dev->state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
630 dev->block_num = dev->file = 0;
633 if (dev->is_tape()) {
634 mt_com.mt_op = MTREW;
636 /* If we get an I/O error on rewind, it is probably because
637 * the drive is actually busy. We loop for (about 5 minutes)
638 * retrying every 5 seconds.
640 for (i=dev->max_rewind_wait; ; i -= 5) {
641 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
643 clrerror_dev(dev, MTREW);
644 if (i == dev->max_rewind_wait) {
645 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
647 if (dev->dev_errno == EIO && i > 0) {
648 Dmsg0(200, "Sleeping 5 seconds.\n");
652 Mmsg2(dev->errmsg, _("Rewind error on %s. ERR=%s.\n"),
653 dev->print_name(), be.strerror());
658 } else if (dev->is_file()) {
659 if (lseek_dev(dev, (off_t)0, SEEK_SET) < 0) {
661 dev->dev_errno = errno;
662 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
663 dev->print_name(), be.strerror());
670 void DEVICE::block(int why)
673 block_device(this, why);
677 void DEVICE::unblock()
680 unblock_device(this);
684 const char *DEVICE::print_blocked() const
686 switch (dev_blocked) {
687 case BST_NOT_BLOCKED:
688 return "BST_NOT_BLOCKED";
690 return "BST_UNMOUNTED";
691 case BST_WAITING_FOR_SYSOP:
692 return "BST_WAITING_FOR_SYSOP";
693 case BST_DOING_ACQUIRE:
694 return "BST_DOING_ACQUIRE";
695 case BST_WRITING_LABEL:
696 return "BST_WRITING_LABEL";
697 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
698 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
702 return "unknown blocked code";
707 * Called to indicate that we have just read an
708 * EOF from the device.
710 void DEVICE::set_ateof()
720 * Called to indicate we are now at the end of the tape, and
721 * writing is not possible.
723 void DEVICE::set_ateot()
725 /* Make tape effectively read-only */
726 state |= (ST_EOF|ST_EOT|ST_WEOT);
731 * Position device to end of medium (end of data)
732 * Returns: true on succes
739 struct mtget mt_stat;
744 dev->dev_errno = EBADF;
745 Mmsg1(dev->errmsg, _("Bad call to eod_dev. Device %s not open\n"),
750 #if defined (__digital__) && defined (__unix__)
751 return dev->fsf(dev->VolCatInfo.VolCatFiles);
754 Dmsg0(29, "eod_dev\n");
758 dev->state &= ~(ST_EOF); /* remove EOF flags */
759 dev->block_num = dev->file = 0;
762 if (dev->state & (ST_FIFO | ST_PROG)) {
765 if (!dev->is_tape()) {
766 pos = lseek_dev(dev, (off_t)0, SEEK_END);
767 // Dmsg1(100, "====== Seek to %lld\n", pos);
770 dev->state |= ST_EOT;
773 dev->dev_errno = errno;
775 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
776 dev->print_name(), be.strerror());
780 if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
781 Dmsg0(100,"Using FAST FSF for EOM\n");
782 /* If unknown position, rewind */
783 if (!dev_get_os_pos(dev, &mt_stat)) {
784 if (!rewind_dev(dev)) {
788 mt_com.mt_op = MTFSF;
790 * ***FIXME*** fix code to handle case that INT16_MAX is
793 mt_com.mt_count = INT16_MAX; /* use big positive number */
794 if (mt_com.mt_count < 0) {
795 mt_com.mt_count = INT16_MAX; /* brain damaged system */
799 if (dev_cap(dev, CAP_MTIOCGET) && (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM))) {
800 if (dev_cap(dev, CAP_EOM)) {
801 Dmsg0(100,"Using EOM for EOM\n");
802 mt_com.mt_op = MTEOM;
806 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
808 clrerror_dev(dev, mt_com.mt_op);
809 Dmsg1(50, "ioctl error: %s\n", be.strerror());
811 Mmsg2(dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
812 dev->print_name(), be.strerror());
816 if (!dev_get_os_pos(dev, &mt_stat)) {
818 clrerror_dev(dev, -1);
819 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
820 dev->print_name(), be.strerror());
823 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
825 dev->file = mt_stat.mt_fileno;
831 * Rewind then use FSF until EOT reached
833 if (!rewind_dev(dev)) {
837 * Move file by file to the end of the tape
840 for (file_num=dev->file; !dev->at_eot(); file_num++) {
841 Dmsg0(200, "eod_dev: doing fsf 1\n");
843 Dmsg0(200, "fsf error.\n");
847 * Avoid infinite loop. ***FIXME*** possibly add code
848 * to set EOD or to turn off CAP_FASTFSF if on.
850 if (file_num == (int)dev->file) {
851 struct mtget mt_stat;
852 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
853 if (dev_get_os_pos(dev, &mt_stat)) {
854 Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
856 dev->file = mt_stat.mt_fileno;
863 * Some drivers leave us after second EOF when doing
864 * MTEOM, so we must backup so that appending overwrites
867 if (dev_cap(dev, CAP_BSFATEOM)) {
868 struct mtget mt_stat;
869 /* Backup over EOF */
870 ok = bsf_dev(dev, 1);
871 /* If BSF worked and fileno is known (not -1), set file */
872 if (dev_get_os_pos(dev, &mt_stat)) {
873 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
874 dev->file = mt_stat.mt_fileno;
876 dev->file++; /* wing it -- not correct on all OSes */
879 update_pos_dev(dev); /* update position */
881 Dmsg1(200, "EOD dev->file=%d\n", dev->file);
886 * Set the position of the device -- only for files
887 * For other devices, there is no generic way to do it.
888 * Returns: true on succes
891 bool update_pos_dev(DEVICE *dev)
897 dev->dev_errno = EBADF;
898 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
899 Emsg0(M_FATAL, 0, dev->errmsg);
903 /* Find out where we are */
904 if (dev->is_file()) {
907 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
910 dev->dev_errno = errno;
911 Pmsg1(000, "Seek error: ERR=%s\n", be.strerror());
912 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
913 dev->print_name(), be.strerror());
916 dev->file_addr = pos;
924 * Return the status of the device. This was meant
925 * to be a generic routine. Unfortunately, it doesn't
926 * seem possible (at least I do not know how to do it
927 * currently), which means that for the moment, this
928 * routine has very little value.
932 uint32_t status_dev(DEVICE *dev)
934 struct mtget mt_stat;
937 if (dev->state & (ST_EOT | ST_WEOT)) {
941 if (dev->state & ST_EOF) {
945 if (dev->is_tape()) {
947 Pmsg0(-20," Bacula status:");
948 Pmsg2(-20," file=%d block=%d\n", dev->file, dev->block_num);
949 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
951 dev->dev_errno = errno;
952 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
953 dev->print_name(), be.strerror());
956 Pmsg0(-20, " Device status:");
958 #if defined(HAVE_LINUX_OS)
959 if (GMT_EOF(mt_stat.mt_gstat)) {
963 if (GMT_BOT(mt_stat.mt_gstat)) {
967 if (GMT_EOT(mt_stat.mt_gstat)) {
971 if (GMT_SM(mt_stat.mt_gstat)) {
975 if (GMT_EOD(mt_stat.mt_gstat)) {
979 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
981 Pmsg0(-20, " WR_PROT");
983 if (GMT_ONLINE(mt_stat.mt_gstat)) {
985 Pmsg0(-20, " ONLINE");
987 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
989 Pmsg0(-20, " DR_OPEN");
991 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
992 stat |= BMT_IM_REP_EN;
993 Pmsg0(-20, " IM_REP_EN");
995 #endif /* !SunOS && !OSF */
996 if (dev_cap(dev, CAP_MTIOCGET)) {
997 Pmsg2(-20, " file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
999 Pmsg2(-20, " file=%d block=%d\n", -1, -1);
1002 stat |= BMT_ONLINE | BMT_BOT;
1009 * Load medium in device
1010 * Returns: true on success
1013 bool load_dev(DEVICE *dev)
1020 dev->dev_errno = EBADF;
1021 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1022 Emsg0(M_FATAL, 0, dev->errmsg);
1025 if (!(dev->is_tape())) {
1029 Dmsg0(200, "stored: MTLOAD command not available\n");
1031 dev->dev_errno = ENOTTY; /* function not available */
1032 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1033 dev->print_name(), be.strerror());
1037 dev->block_num = dev->file = 0;
1040 mt_com.mt_op = MTLOAD;
1041 mt_com.mt_count = 1;
1042 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1044 dev->dev_errno = errno;
1045 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1046 dev->print_name(), be.strerror());
1054 * Rewind device and put it offline
1055 * Returns: true on success
1058 bool offline_dev(DEVICE *dev)
1063 dev->dev_errno = EBADF;
1064 Mmsg0(dev->errmsg, _("Bad call to offline_dev. Device not open\n"));
1065 Emsg0(M_FATAL, 0, dev->errmsg);
1068 if (!(dev->is_tape())) {
1072 dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1073 dev->block_num = dev->file = 0;
1078 mt_com.mt_op = MTUNLOCK;
1079 mt_com.mt_count = 1;
1080 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1082 mt_com.mt_op = MTOFFL;
1083 mt_com.mt_count = 1;
1084 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1086 dev->dev_errno = errno;
1087 Mmsg2(dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1088 dev->print_name(), be.strerror());
1091 Dmsg1(100, "Offlined device %s\n", dev->print_name());
1095 bool offline_or_rewind_dev(DEVICE *dev)
1100 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1101 return offline_dev(dev);
1104 * Note, this rewind probably should not be here (it wasn't
1105 * in prior versions of Bacula), but on FreeBSD, this is
1106 * needed in the case the tape was "frozen" due to an error
1107 * such as backspacing after writing and EOF. If it is not
1108 * done, all future references to the drive get and I/O error.
1110 clrerror_dev(dev, MTREW);
1111 return rewind_dev(dev);
1116 * Foward space a file
1117 * Returns: true on success
1120 bool DEVICE::fsf(int num)
1122 struct mtget mt_stat;
1128 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1129 Emsg0(M_FATAL, 0, errmsg);
1138 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1142 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1145 Dmsg0(100, "fsf\n");
1148 * If Fast forward space file is set, then we
1149 * use MTFSF to forward space and MTIOCGET
1150 * to get the file position. We assume that
1151 * the SCSI driver will ensure that we do not
1152 * forward space past the end of the medium.
1154 if (dev_cap(this, CAP_FSF) && dev_cap(this, CAP_MTIOCGET) && dev_cap(this, CAP_FASTFSF)) {
1155 mt_com.mt_op = MTFSF;
1156 mt_com.mt_count = num;
1157 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1158 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1161 Dmsg0(200, "Set ST_EOT\n");
1162 clrerror_dev(this, MTFSF);
1163 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1164 print_name(), be.strerror());
1165 Dmsg1(200, "%s", errmsg);
1168 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1170 file = mt_stat.mt_fileno;
1174 * Here if CAP_FSF is set, and virtually all drives
1175 * these days support it, we read a record, then forward
1176 * space one file. Using this procedure, which is slow,
1177 * is the only way we can be sure that we don't read
1178 * two consecutive EOF marks, which means End of Data.
1180 } else if (dev_cap(this, CAP_FSF)) {
1183 Dmsg0(200, "FSF has cap_fsf\n");
1184 if (max_block_size == 0) {
1185 rbuf_len = DEFAULT_BLOCK_SIZE;
1187 rbuf_len = max_block_size;
1189 rbuf = get_memory(rbuf_len);
1190 mt_com.mt_op = MTFSF;
1191 mt_com.mt_count = 1;
1192 while (num-- && !at_eot()) {
1193 Dmsg0(100, "Doing read before fsf\n");
1194 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1195 if (errno == ENOMEM) { /* tape record exceeds buf len */
1196 stat = rbuf_len; /* This is OK */
1198 * On IBM drives, they return ENOSPC at EOM
1199 * instead of EOF status
1201 } else if (at_eof() && errno == ENOSPC) {
1206 clrerror_dev(this, -1);
1207 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1209 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1210 print_name(), be.strerror());
1211 Dmsg1(100, "%s", errmsg);
1215 if (stat == 0) { /* EOF */
1216 update_pos_dev(this);
1217 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1218 /* Two reads of zero means end of tape */
1221 Dmsg0(100, "Set ST_EOT\n");
1227 } else { /* Got data */
1232 Dmsg0(100, "Doing MTFSF\n");
1233 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1234 if (stat < 0) { /* error => EOT */
1237 Dmsg0(100, "Set ST_EOT\n");
1238 clrerror_dev(this, MTFSF);
1239 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1240 print_name(), be.strerror());
1241 Dmsg0(100, "Got < 0 for MTFSF\n");
1242 Dmsg1(100, "%s", errmsg);
1250 * No FSF, so use FSR to simulate it
1253 Dmsg0(200, "Doing FSR for FSF\n");
1254 while (num-- && !at_eot()) {
1255 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1259 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1265 update_pos_dev(this);
1266 Dmsg1(200, "Return %d from FSF\n", stat);
1268 Dmsg0(200, "ST_EOF set on exit FSF\n");
1270 Dmsg0(200, "ST_EOT set on exit FSF\n");
1271 Dmsg1(200, "Return from FSF file=%d\n", file);
1276 * Backward space a file
1277 * Returns: false on failure
1281 bsf_dev(DEVICE *dev, int num)
1287 dev->dev_errno = EBADF;
1288 Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Device not open\n"));
1289 Emsg0(M_FATAL, 0, dev->errmsg);
1293 if (!dev->is_tape()) {
1294 Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1298 Dmsg0(29, "bsf_dev\n");
1299 dev->state &= ~(ST_EOT|ST_EOF);
1303 mt_com.mt_op = MTBSF;
1304 mt_com.mt_count = num;
1305 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1308 clrerror_dev(dev, MTBSF);
1309 Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1310 dev->print_name(), be.strerror());
1312 update_pos_dev(dev);
1318 * Foward space num records
1319 * Returns: false on failure
1322 bool DEVICE::fsr(int num)
1329 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1330 Emsg0(M_FATAL, 0, errmsg);
1337 if (!dev_cap(this, CAP_FSR)) {
1338 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1342 Dmsg1(29, "fsr %d\n", num);
1343 mt_com.mt_op = MTFSR;
1344 mt_com.mt_count = num;
1345 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1351 struct mtget mt_stat;
1352 clrerror_dev(this, MTFSR);
1353 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1354 if (dev_get_os_pos(this, &mt_stat)) {
1355 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1356 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1357 file = mt_stat.mt_fileno;
1358 block_num = mt_stat.mt_blkno;
1366 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1367 num, print_name(), be.strerror());
1369 update_pos_dev(this);
1374 * Backward space a record
1375 * Returns: false on failure
1379 bsr_dev(DEVICE *dev, int num)
1385 dev->dev_errno = EBADF;
1386 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1387 Emsg0(M_FATAL, 0, dev->errmsg);
1391 if (!dev->is_tape()) {
1395 if (!dev_cap(dev, CAP_BSR)) {
1396 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1400 Dmsg0(29, "bsr_dev\n");
1401 dev->block_num -= num;
1402 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1403 mt_com.mt_op = MTBSR;
1404 mt_com.mt_count = num;
1405 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1408 clrerror_dev(dev, MTBSR);
1409 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1410 dev->print_name(), be.strerror());
1412 update_pos_dev(dev);
1417 * Reposition the device to file, block
1418 * Returns: false on failure
1422 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1425 dev->dev_errno = EBADF;
1426 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1427 Emsg0(M_FATAL, 0, dev->errmsg);
1431 if (!dev->is_tape()) {
1432 off_t pos = (((off_t)file)<<32) + (off_t)block;
1433 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1434 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1436 dev->dev_errno = errno;
1437 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1438 dev->print_name(), be.strerror());
1442 dev->block_num = block;
1443 dev->file_addr = pos;
1446 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1447 dev->file, dev->block_num, file, block);
1448 if (file < dev->file) {
1449 Dmsg0(100, "Rewind_dev\n");
1450 if (!rewind_dev(dev)) {
1454 if (file > dev->file) {
1455 Dmsg1(100, "fsf %d\n", file-dev->file);
1456 if (!dev->fsf(file-dev->file)) {
1457 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1460 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1462 if (block < dev->block_num) {
1463 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1464 Dmsg0(100, "bsf_dev 1\n");
1466 Dmsg0(100, "fsf_dev 1\n");
1468 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1470 if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1471 /* Ignore errors as Bacula can read to the correct block */
1472 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1473 return dev->fsr(block-dev->block_num);
1481 * Write an end of file on the device
1482 * Returns: 0 on success
1483 * non-zero on failure
1486 weof_dev(DEVICE *dev, int num)
1490 Dmsg0(29, "weof_dev\n");
1493 dev->dev_errno = EBADF;
1494 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1495 Emsg0(M_FATAL, 0, dev->errmsg);
1500 if (!dev->is_tape()) {
1503 if (!dev->can_append()) {
1504 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1505 Emsg0(M_FATAL, 0, dev->errmsg);
1509 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1510 mt_com.mt_op = MTWEOF;
1511 mt_com.mt_count = num;
1512 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1519 clrerror_dev(dev, MTWEOF);
1521 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1522 dev->print_name(), be.strerror());
1529 * Return string message with last error in English
1530 * Be careful not to call this routine from within dev.c
1531 * while editing an Mmsg() or you will end up in a recursive
1532 * loop creating a Segmentation Violation.
1535 strerror_dev(DEVICE *dev)
1542 * If implemented in system, clear the tape
1546 clrerror_dev(DEVICE *dev, int func)
1548 const char *msg = NULL;
1549 struct mtget mt_stat;
1552 dev->dev_errno = errno; /* save errno */
1554 dev->VolCatInfo.VolCatErrors++;
1557 if (!dev->is_tape()) {
1560 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1563 Emsg0(M_ABORT, 0, "Got ENOTTY on read/write!\n");
1567 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1572 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1577 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1581 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1585 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1589 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1610 bsnprintf(buf, sizeof(buf), "unknown func code %d", func);
1615 dev->dev_errno = ENOSYS;
1616 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1617 Emsg0(M_ERROR, 0, dev->errmsg);
1620 /* On some systems such as NetBSD, this clears all errors */
1621 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1623 /* Found on Linux */
1627 mt_com.mt_op = MTIOCLRERR;
1628 mt_com.mt_count = 1;
1629 /* Clear any error condition on the tape */
1630 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1631 Dmsg0(200, "Did MTIOCLRERR\n");
1635 /* Typically on FreeBSD */
1638 /* Read and clear SCSI error status */
1639 union mterrstat mt_errstat;
1640 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1641 strerror(dev->dev_errno));
1642 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1646 /* Clear Subsystem Exception OSF1 */
1650 mt_com.mt_op = MTCSE;
1651 mt_com.mt_count = 1;
1652 /* Clear any error condition on the tape */
1653 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1654 Dmsg0(200, "Did MTCSE\n");
1660 * Flush buffer contents
1663 int flush_dev(DEVICE *dev)
1668 static void do_close(DEVICE *dev)
1671 Dmsg1(29, "really close_dev %s\n", dev->print_name());
1676 if (!unmount_dev(dev, 1)) {
1677 Dmsg1(0, "Cannot unmount device %s.\n", dev->print_name());
1680 /* Remove the last part file if it is empty */
1681 if (dev->can_append() && (dev->num_parts > 0)) {
1683 POOL_MEM archive_name(PM_FNAME);
1684 dev->part = dev->num_parts;
1685 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", dev->VolCatInfo.VolCatName);
1686 make_spooled_dvd_filename(dev, archive_name);
1687 /* Check that the part file is empty */
1688 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1689 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1690 unlink(archive_name.c_str());
1694 /* Clean up device packet so it can be reused */
1696 dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1697 dev->label_type = B_BACULA_LABEL;
1698 dev->file = dev->block_num = 0;
1704 dev->part_start = 0;
1705 dev->EndFile = dev->EndBlock = 0;
1706 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1707 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1709 stop_thread_timer(dev->tid);
1719 void DEVICE::close()
1721 /*if (fd >= 0 && use_count == 1) {*/
1722 /* No need to check if fd >= 0: it is checked again
1723 * in do_close, and do_close MUST be called for volumes
1724 * splitted in parts, even if fd == -1. */
1725 if (use_count == 1) {
1727 } else if (use_count > 0) {
1732 ASSERT(use_count >= 0);
1737 bool truncate_dev(DCR *dcr) /* We need the DCR for DVD-writing */
1739 DEVICE *dev = dcr->dev;
1741 Dmsg1(100, "truncate_dev %s\n", dev->print_name());
1742 if (dev->is_tape()) {
1743 return true; /* we don't really truncate tapes */
1744 /* maybe we should rewind and write and eof ???? */
1747 if (dev->is_dvd()) {
1748 return truncate_dvd_dev(dcr);
1751 if (ftruncate(dev->fd, 0) != 0) {
1753 Mmsg2(dev->errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1754 dev->print_name(), be.strerror());
1760 /* Return the resource name for the device */
1761 const char *DEVICE::name() const
1763 return device->hdr.name;
1767 dev_vol_name(DEVICE *dev)
1769 return dev->VolCatInfo.VolCatName;
1772 uint32_t dev_block(DEVICE *dev)
1774 update_pos_dev(dev);
1775 return dev->block_num;
1778 uint32_t dev_file(DEVICE *dev)
1780 update_pos_dev(dev);
1785 * Free memory allocated for the device
1788 term_dev(DEVICE *dev)
1791 dev->dev_errno = EBADF;
1792 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1793 Emsg0(M_FATAL, 0, dev->errmsg);
1796 Dmsg1(29, "term_dev: %s\n", dev->print_name());
1798 if (dev->dev_name) {
1799 free_memory(dev->dev_name);
1800 dev->dev_name = NULL;
1802 if (dev->prt_name) {
1803 free_memory(dev->prt_name);
1804 dev->prt_name = NULL;
1807 free_pool_memory(dev->errmsg);
1810 pthread_mutex_destroy(&dev->mutex);
1811 pthread_cond_destroy(&dev->wait);
1812 pthread_cond_destroy(&dev->wait_next_vol);
1813 pthread_mutex_destroy(&dev->spool_mutex);
1814 rwl_destroy(&dev->lock);
1815 if (dev->attached_dcrs) {
1816 delete dev->attached_dcrs;
1817 dev->attached_dcrs = NULL;
1819 if (dev->state & ST_MALLOC) {
1820 free_pool_memory((POOLMEM *)dev);
1825 * This routine initializes the device wait timers
1827 void init_device_wait_timers(DCR *dcr)
1829 DEVICE *dev = dcr->dev;
1830 JCR *jcr = dcr->jcr;
1832 /* ******FIXME******* put these on config variables */
1833 dev->min_wait = 60 * 60;
1834 dev->max_wait = 24 * 60 * 60;
1835 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1836 dev->wait_sec = dev->min_wait;
1837 dev->rem_wait_sec = dev->wait_sec;
1840 dev->BadVolName[0] = 0;
1842 jcr->min_wait = 60 * 60;
1843 jcr->max_wait = 24 * 60 * 60;
1844 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1845 jcr->wait_sec = jcr->min_wait;
1846 jcr->rem_wait_sec = jcr->wait_sec;
1851 void init_jcr_device_wait_timers(JCR *jcr)
1853 /* ******FIXME******* put these on config variables */
1854 jcr->min_wait = 60 * 60;
1855 jcr->max_wait = 24 * 60 * 60;
1856 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1857 jcr->wait_sec = jcr->min_wait;
1858 jcr->rem_wait_sec = jcr->wait_sec;
1864 * The dev timers are used for waiting on a particular device
1866 * Returns: true if time doubled
1867 * false if max time expired
1869 bool double_dev_wait_time(DEVICE *dev)
1871 dev->wait_sec *= 2; /* double wait time */
1872 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
1873 dev->wait_sec = dev->max_wait;
1876 dev->rem_wait_sec = dev->wait_sec;
1877 if (dev->num_wait >= dev->max_num_wait) {
1884 void set_os_device_parameters(DEVICE *dev)
1886 #ifdef HAVE_LINUX_OS
1888 if (dev->min_block_size == dev->max_block_size &&
1889 dev->min_block_size == 0) { /* variable block mode */
1890 mt_com.mt_op = MTSETBLK;
1891 mt_com.mt_count = 0;
1892 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1893 clrerror_dev(dev, MTSETBLK);
1895 mt_com.mt_op = MTSETDRVBUFFER;
1896 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
1897 if (!dev_cap(dev, CAP_TWOEOF)) {
1898 mt_com.mt_count |= MT_ST_TWO_FM;
1900 if (dev_cap(dev, CAP_EOM)) {
1901 mt_com.mt_count |= MT_ST_FAST_MTEOM;
1903 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1904 clrerror_dev(dev, MTSETBLK);
1910 #ifdef HAVE_NETBSD_OS
1912 if (dev->min_block_size == dev->max_block_size &&
1913 dev->min_block_size == 0) { /* variable block mode */
1914 mt_com.mt_op = MTSETBSIZ;
1915 mt_com.mt_count = 0;
1916 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1917 clrerror_dev(dev, MTSETBSIZ);
1919 /* Get notified at logical end of tape */
1920 mt_com.mt_op = MTEWARN;
1921 mt_com.mt_count = 1;
1922 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1923 clrerror_dev(dev, MTEWARN);
1929 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
1931 if (dev->min_block_size == dev->max_block_size &&
1932 dev->min_block_size == 0) { /* variable block mode */
1933 mt_com.mt_op = MTSETBSIZ;
1934 mt_com.mt_count = 0;
1935 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1936 clrerror_dev(dev, MTSETBSIZ);
1944 if (dev->min_block_size == dev->max_block_size &&
1945 dev->min_block_size == 0) { /* variable block mode */
1946 mt_com.mt_op = MTSRSZ;
1947 mt_com.mt_count = 0;
1948 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1949 clrerror_dev(dev, MTSRSZ);
1956 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
1958 return dev_cap(dev, CAP_MTIOCGET) &&
1959 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
1960 mt_stat->mt_fileno >= 0;
1963 static char *modes[] = {
1964 "CREATE_READ_WRITE",
1971 static char *mode_to_str(int mode)
1973 return modes[mode-1];