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 Dmsg2(99, "open_dvd_device: num_parts=%d, VolCatInfo.VolCatParts=%d\n",
478 dcr->dev->num_parts, dcr->VolCatInfo.VolCatParts);
479 if (dcr->dev->num_parts < dcr->VolCatInfo.VolCatParts) {
480 Dmsg2(99, "open_dvd_device: num_parts updated to %d (was %d)\n",
481 dcr->VolCatInfo.VolCatParts, dcr->dev->num_parts);
482 dcr->dev->num_parts = dcr->VolCatInfo.VolCatParts;
485 if (mount_dev(this, 1)) {
486 if ((num_parts == 0) && (!truncating)) {
487 /* If we can mount the device, and we are not truncating the DVD, we usually want to abort. */
488 /* There is one exception, if there is only one 0-sized file on the DVD, with the right volume name,
489 * we continue (it's the method used by truncate_dvd_dev to truncate a volume). */
490 if (!check_can_write_on_non_blank_dvd(dcr)) {
491 Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
492 Emsg0(M_FATAL, 0, errmsg);
499 /* We cannot mount the device */
500 if (num_parts == 0) {
501 /* Run free space, check there is a media. */
502 update_free_space_dev(this);
504 Dmsg1(29, "Could not mount device %s, this is not a problem (num_parts == 0), and have media.\n", print_name());
507 Mmsg(errmsg, _("There is no valid media in the device %s.\n"), print_name());
508 Emsg0(M_FATAL, 0, errmsg);
514 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
515 Emsg0(M_FATAL, 0, errmsg);
521 Dmsg6(29, "open dev: %s dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
522 is_dvd()?"DVD":"disk", archive_name.c_str(), mode_to_str(omode),
523 part, num_parts, dcr->VolCatInfo.VolCatParts);
525 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
528 * If we are not trying to access the last part, set mode to
529 * OPEN_READ_ONLY as writing would be an error.
531 if (part < num_parts) {
532 omode = OPEN_READ_ONLY;
533 make_mounted_dvd_filename(this, archive_name);
536 make_spooled_dvd_filename(this, archive_name);
540 /* If creating file, give 0640 permissions */
541 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
542 archive_name.c_str(), mode);
543 /* Use system open() */
544 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
546 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
548 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
549 Dmsg1(29, "open failed: %s", errmsg);
551 if ((omode == OPEN_READ_ONLY) && (part == num_parts)) {
552 /* If the last part (on spool), doesn't exists when reading, create it and read from it
553 * (it will report immediately an EOF):
554 * Sometimes it is better to finish with an EOF than with an error. */
555 set_mode(OPEN_READ_WRITE);
556 fd = ::open(archive_name.c_str(), mode, 0640);
557 set_mode(OPEN_READ_ONLY);
560 /* We don't need it. Only the last part is on spool */
561 /*if (omode == OPEN_READ_ONLY) {
562 make_spooled_dvd_filename(this, archive_name);
563 fd = ::open(archive_name.c_str(), mode, 0640); // try on spool
566 Dmsg1(100, "after open fd=%d\n", fd);
568 /* Get size of file */
569 if (fstat(fd, &filestat) < 0) {
572 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
574 Dmsg1(29, "open failed: %s", errmsg);
575 /* Use system close() */
579 part_size = filestat.st_size;
583 update_pos_dev(this); /* update position */
585 /* NB: It seems this code is wrong... part number is incremented in open_next_part, not here */
587 /* Check if just created Volume part */
588 /* if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
591 VolCatInfo.VolCatParts = num_parts;
593 if (part == 0) { // we must have opened the first part
604 bool _rewind_dev(char *file, int line, DEVICE *dev)
606 Dmsg3(100, "rewind_dev fd=%d called from %s:%d\n", dev->fd, file, line);
607 return rewind_dev(dev);
613 * Returns: true on success
616 bool rewind_dev(DEVICE *dev)
621 Dmsg2(29, "rewind_dev fd=%d %s\n", dev->fd, dev->print_name());
623 if (!dev->is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
624 dev->dev_errno = EBADF;
625 Mmsg1(dev->errmsg, _("Bad call to rewind_dev. Device %s not open\n"),
627 Emsg0(M_ABORT, 0, dev->errmsg);
631 dev->state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
632 dev->block_num = dev->file = 0;
635 if (dev->is_tape()) {
636 mt_com.mt_op = MTREW;
638 /* If we get an I/O error on rewind, it is probably because
639 * the drive is actually busy. We loop for (about 5 minutes)
640 * retrying every 5 seconds.
642 for (i=dev->max_rewind_wait; ; i -= 5) {
643 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
645 clrerror_dev(dev, MTREW);
646 if (i == dev->max_rewind_wait) {
647 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
649 if (dev->dev_errno == EIO && i > 0) {
650 Dmsg0(200, "Sleeping 5 seconds.\n");
654 Mmsg2(dev->errmsg, _("Rewind error on %s. ERR=%s.\n"),
655 dev->print_name(), be.strerror());
660 } else if (dev->is_file()) {
661 if (lseek_dev(dev, (off_t)0, SEEK_SET) < 0) {
663 dev->dev_errno = errno;
664 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
665 dev->print_name(), be.strerror());
672 void DEVICE::block(int why)
675 block_device(this, why);
679 void DEVICE::unblock()
682 unblock_device(this);
686 const char *DEVICE::print_blocked() const
688 switch (dev_blocked) {
689 case BST_NOT_BLOCKED:
690 return "BST_NOT_BLOCKED";
692 return "BST_UNMOUNTED";
693 case BST_WAITING_FOR_SYSOP:
694 return "BST_WAITING_FOR_SYSOP";
695 case BST_DOING_ACQUIRE:
696 return "BST_DOING_ACQUIRE";
697 case BST_WRITING_LABEL:
698 return "BST_WRITING_LABEL";
699 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
700 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
704 return "unknown blocked code";
709 * Called to indicate that we have just read an
710 * EOF from the device.
712 void DEVICE::set_ateof()
722 * Called to indicate we are now at the end of the tape, and
723 * writing is not possible.
725 void DEVICE::set_ateot()
727 /* Make tape effectively read-only */
728 state |= (ST_EOF|ST_EOT|ST_WEOT);
733 * Position device to end of medium (end of data)
734 * Returns: true on succes
741 struct mtget mt_stat;
746 dev->dev_errno = EBADF;
747 Mmsg1(dev->errmsg, _("Bad call to eod_dev. Device %s not open\n"),
752 #if defined (__digital__) && defined (__unix__)
753 return dev->fsf(dev->VolCatInfo.VolCatFiles);
756 Dmsg0(29, "eod_dev\n");
760 dev->state &= ~(ST_EOF); /* remove EOF flags */
761 dev->block_num = dev->file = 0;
764 if (dev->state & (ST_FIFO | ST_PROG)) {
767 if (!dev->is_tape()) {
768 pos = lseek_dev(dev, (off_t)0, SEEK_END);
769 // Dmsg1(100, "====== Seek to %lld\n", pos);
772 dev->state |= ST_EOT;
775 dev->dev_errno = errno;
777 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
778 dev->print_name(), be.strerror());
782 if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
783 Dmsg0(100,"Using FAST FSF for EOM\n");
784 /* If unknown position, rewind */
785 if (!dev_get_os_pos(dev, &mt_stat)) {
786 if (!rewind_dev(dev)) {
790 mt_com.mt_op = MTFSF;
792 * ***FIXME*** fix code to handle case that INT16_MAX is
795 mt_com.mt_count = INT16_MAX; /* use big positive number */
796 if (mt_com.mt_count < 0) {
797 mt_com.mt_count = INT16_MAX; /* brain damaged system */
801 if (dev_cap(dev, CAP_MTIOCGET) && (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM))) {
802 if (dev_cap(dev, CAP_EOM)) {
803 Dmsg0(100,"Using EOM for EOM\n");
804 mt_com.mt_op = MTEOM;
808 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
810 clrerror_dev(dev, mt_com.mt_op);
811 Dmsg1(50, "ioctl error: %s\n", be.strerror());
813 Mmsg2(dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
814 dev->print_name(), be.strerror());
818 if (!dev_get_os_pos(dev, &mt_stat)) {
820 clrerror_dev(dev, -1);
821 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
822 dev->print_name(), be.strerror());
825 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
827 dev->file = mt_stat.mt_fileno;
833 * Rewind then use FSF until EOT reached
835 if (!rewind_dev(dev)) {
839 * Move file by file to the end of the tape
842 for (file_num=dev->file; !dev->at_eot(); file_num++) {
843 Dmsg0(200, "eod_dev: doing fsf 1\n");
845 Dmsg0(200, "fsf error.\n");
849 * Avoid infinite loop. ***FIXME*** possibly add code
850 * to set EOD or to turn off CAP_FASTFSF if on.
852 if (file_num == (int)dev->file) {
853 struct mtget mt_stat;
854 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
855 if (dev_get_os_pos(dev, &mt_stat)) {
856 Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
858 dev->file = mt_stat.mt_fileno;
865 * Some drivers leave us after second EOF when doing
866 * MTEOM, so we must backup so that appending overwrites
869 if (dev_cap(dev, CAP_BSFATEOM)) {
870 struct mtget mt_stat;
871 /* Backup over EOF */
872 ok = bsf_dev(dev, 1);
873 /* If BSF worked and fileno is known (not -1), set file */
874 if (dev_get_os_pos(dev, &mt_stat)) {
875 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
876 dev->file = mt_stat.mt_fileno;
878 dev->file++; /* wing it -- not correct on all OSes */
881 update_pos_dev(dev); /* update position */
883 Dmsg1(200, "EOD dev->file=%d\n", dev->file);
888 * Set the position of the device -- only for files and DVD
889 * For other devices, there is no generic way to do it.
890 * Returns: true on succes
893 bool update_pos_dev(DEVICE *dev)
899 dev->dev_errno = EBADF;
900 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
901 Emsg0(M_FATAL, 0, dev->errmsg);
905 /* Find out where we are */
906 if (dev->is_file()) {
909 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
912 dev->dev_errno = errno;
913 Pmsg1(000, "Seek error: ERR=%s\n", be.strerror());
914 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
915 dev->print_name(), be.strerror());
918 dev->file_addr = pos;
926 * Return the status of the device. This was meant
927 * to be a generic routine. Unfortunately, it doesn't
928 * seem possible (at least I do not know how to do it
929 * currently), which means that for the moment, this
930 * routine has very little value.
934 uint32_t status_dev(DEVICE *dev)
936 struct mtget mt_stat;
939 if (dev->state & (ST_EOT | ST_WEOT)) {
943 if (dev->state & ST_EOF) {
947 if (dev->is_tape()) {
949 Pmsg0(-20," Bacula status:");
950 Pmsg2(-20," file=%d block=%d\n", dev->file, dev->block_num);
951 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
953 dev->dev_errno = errno;
954 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
955 dev->print_name(), be.strerror());
958 Pmsg0(-20, " Device status:");
960 #if defined(HAVE_LINUX_OS)
961 if (GMT_EOF(mt_stat.mt_gstat)) {
965 if (GMT_BOT(mt_stat.mt_gstat)) {
969 if (GMT_EOT(mt_stat.mt_gstat)) {
973 if (GMT_SM(mt_stat.mt_gstat)) {
977 if (GMT_EOD(mt_stat.mt_gstat)) {
981 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
983 Pmsg0(-20, " WR_PROT");
985 if (GMT_ONLINE(mt_stat.mt_gstat)) {
987 Pmsg0(-20, " ONLINE");
989 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
991 Pmsg0(-20, " DR_OPEN");
993 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
994 stat |= BMT_IM_REP_EN;
995 Pmsg0(-20, " IM_REP_EN");
997 #endif /* !SunOS && !OSF */
998 if (dev_cap(dev, CAP_MTIOCGET)) {
999 Pmsg2(-20, " file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1001 Pmsg2(-20, " file=%d block=%d\n", -1, -1);
1004 stat |= BMT_ONLINE | BMT_BOT;
1011 * Load medium in device
1012 * Returns: true on success
1015 bool load_dev(DEVICE *dev)
1022 dev->dev_errno = EBADF;
1023 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1024 Emsg0(M_FATAL, 0, dev->errmsg);
1027 if (!(dev->is_tape())) {
1031 Dmsg0(200, "stored: MTLOAD command not available\n");
1033 dev->dev_errno = ENOTTY; /* function not available */
1034 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1035 dev->print_name(), be.strerror());
1039 dev->block_num = dev->file = 0;
1042 mt_com.mt_op = MTLOAD;
1043 mt_com.mt_count = 1;
1044 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1046 dev->dev_errno = errno;
1047 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1048 dev->print_name(), be.strerror());
1056 * Rewind device and put it offline
1057 * Returns: true on success
1060 bool offline_dev(DEVICE *dev)
1065 dev->dev_errno = EBADF;
1066 Mmsg0(dev->errmsg, _("Bad call to offline_dev. Device not open\n"));
1067 Emsg0(M_FATAL, 0, dev->errmsg);
1070 if (!(dev->is_tape())) {
1074 dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1075 dev->block_num = dev->file = 0;
1080 mt_com.mt_op = MTUNLOCK;
1081 mt_com.mt_count = 1;
1082 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1084 mt_com.mt_op = MTOFFL;
1085 mt_com.mt_count = 1;
1086 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1088 dev->dev_errno = errno;
1089 Mmsg2(dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1090 dev->print_name(), be.strerror());
1093 Dmsg1(100, "Offlined device %s\n", dev->print_name());
1097 bool offline_or_rewind_dev(DEVICE *dev)
1102 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1103 return offline_dev(dev);
1106 * Note, this rewind probably should not be here (it wasn't
1107 * in prior versions of Bacula), but on FreeBSD, this is
1108 * needed in the case the tape was "frozen" due to an error
1109 * such as backspacing after writing and EOF. If it is not
1110 * done, all future references to the drive get and I/O error.
1112 clrerror_dev(dev, MTREW);
1113 return rewind_dev(dev);
1118 * Foward space a file
1119 * Returns: true on success
1122 bool DEVICE::fsf(int num)
1124 struct mtget mt_stat;
1130 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1131 Emsg0(M_FATAL, 0, errmsg);
1140 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1144 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1147 Dmsg0(100, "fsf\n");
1150 * If Fast forward space file is set, then we
1151 * use MTFSF to forward space and MTIOCGET
1152 * to get the file position. We assume that
1153 * the SCSI driver will ensure that we do not
1154 * forward space past the end of the medium.
1156 if (dev_cap(this, CAP_FSF) && dev_cap(this, CAP_MTIOCGET) && dev_cap(this, CAP_FASTFSF)) {
1157 mt_com.mt_op = MTFSF;
1158 mt_com.mt_count = num;
1159 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1160 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1163 Dmsg0(200, "Set ST_EOT\n");
1164 clrerror_dev(this, MTFSF);
1165 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1166 print_name(), be.strerror());
1167 Dmsg1(200, "%s", errmsg);
1170 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1172 file = mt_stat.mt_fileno;
1176 * Here if CAP_FSF is set, and virtually all drives
1177 * these days support it, we read a record, then forward
1178 * space one file. Using this procedure, which is slow,
1179 * is the only way we can be sure that we don't read
1180 * two consecutive EOF marks, which means End of Data.
1182 } else if (dev_cap(this, CAP_FSF)) {
1185 Dmsg0(200, "FSF has cap_fsf\n");
1186 if (max_block_size == 0) {
1187 rbuf_len = DEFAULT_BLOCK_SIZE;
1189 rbuf_len = max_block_size;
1191 rbuf = get_memory(rbuf_len);
1192 mt_com.mt_op = MTFSF;
1193 mt_com.mt_count = 1;
1194 while (num-- && !at_eot()) {
1195 Dmsg0(100, "Doing read before fsf\n");
1196 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1197 if (errno == ENOMEM) { /* tape record exceeds buf len */
1198 stat = rbuf_len; /* This is OK */
1200 * On IBM drives, they return ENOSPC at EOM
1201 * instead of EOF status
1203 } else if (at_eof() && errno == ENOSPC) {
1208 clrerror_dev(this, -1);
1209 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1211 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1212 print_name(), be.strerror());
1213 Dmsg1(100, "%s", errmsg);
1217 if (stat == 0) { /* EOF */
1218 update_pos_dev(this);
1219 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1220 /* Two reads of zero means end of tape */
1223 Dmsg0(100, "Set ST_EOT\n");
1229 } else { /* Got data */
1234 Dmsg0(100, "Doing MTFSF\n");
1235 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1236 if (stat < 0) { /* error => EOT */
1239 Dmsg0(100, "Set ST_EOT\n");
1240 clrerror_dev(this, MTFSF);
1241 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1242 print_name(), be.strerror());
1243 Dmsg0(100, "Got < 0 for MTFSF\n");
1244 Dmsg1(100, "%s", errmsg);
1252 * No FSF, so use FSR to simulate it
1255 Dmsg0(200, "Doing FSR for FSF\n");
1256 while (num-- && !at_eot()) {
1257 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1261 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1267 update_pos_dev(this);
1268 Dmsg1(200, "Return %d from FSF\n", stat);
1270 Dmsg0(200, "ST_EOF set on exit FSF\n");
1272 Dmsg0(200, "ST_EOT set on exit FSF\n");
1273 Dmsg1(200, "Return from FSF file=%d\n", file);
1278 * Backward space a file
1279 * Returns: false on failure
1283 bsf_dev(DEVICE *dev, int num)
1289 dev->dev_errno = EBADF;
1290 Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Device not open\n"));
1291 Emsg0(M_FATAL, 0, dev->errmsg);
1295 if (!dev->is_tape()) {
1296 Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1300 Dmsg0(29, "bsf_dev\n");
1301 dev->state &= ~(ST_EOT|ST_EOF);
1305 mt_com.mt_op = MTBSF;
1306 mt_com.mt_count = num;
1307 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1310 clrerror_dev(dev, MTBSF);
1311 Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1312 dev->print_name(), be.strerror());
1314 update_pos_dev(dev);
1320 * Foward space num records
1321 * Returns: false on failure
1324 bool DEVICE::fsr(int num)
1331 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1332 Emsg0(M_FATAL, 0, errmsg);
1339 if (!dev_cap(this, CAP_FSR)) {
1340 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1344 Dmsg1(29, "fsr %d\n", num);
1345 mt_com.mt_op = MTFSR;
1346 mt_com.mt_count = num;
1347 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1353 struct mtget mt_stat;
1354 clrerror_dev(this, MTFSR);
1355 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1356 if (dev_get_os_pos(this, &mt_stat)) {
1357 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1358 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1359 file = mt_stat.mt_fileno;
1360 block_num = mt_stat.mt_blkno;
1368 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1369 num, print_name(), be.strerror());
1371 update_pos_dev(this);
1376 * Backward space a record
1377 * Returns: false on failure
1381 bsr_dev(DEVICE *dev, int num)
1387 dev->dev_errno = EBADF;
1388 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1389 Emsg0(M_FATAL, 0, dev->errmsg);
1393 if (!dev->is_tape()) {
1397 if (!dev_cap(dev, CAP_BSR)) {
1398 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1402 Dmsg0(29, "bsr_dev\n");
1403 dev->block_num -= num;
1404 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1405 mt_com.mt_op = MTBSR;
1406 mt_com.mt_count = num;
1407 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1410 clrerror_dev(dev, MTBSR);
1411 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1412 dev->print_name(), be.strerror());
1414 update_pos_dev(dev);
1419 * Reposition the device to file, block
1420 * Returns: false on failure
1424 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1427 dev->dev_errno = EBADF;
1428 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1429 Emsg0(M_FATAL, 0, dev->errmsg);
1433 if (!dev->is_tape()) {
1434 off_t pos = (((off_t)file)<<32) + (off_t)block;
1435 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1436 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1438 dev->dev_errno = errno;
1439 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1440 dev->print_name(), be.strerror());
1444 dev->block_num = block;
1445 dev->file_addr = pos;
1448 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1449 dev->file, dev->block_num, file, block);
1450 if (file < dev->file) {
1451 Dmsg0(100, "Rewind_dev\n");
1452 if (!rewind_dev(dev)) {
1456 if (file > dev->file) {
1457 Dmsg1(100, "fsf %d\n", file-dev->file);
1458 if (!dev->fsf(file-dev->file)) {
1459 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1462 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1464 if (block < dev->block_num) {
1465 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1466 Dmsg0(100, "bsf_dev 1\n");
1468 Dmsg0(100, "fsf_dev 1\n");
1470 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1472 if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1473 /* Ignore errors as Bacula can read to the correct block */
1474 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1475 return dev->fsr(block-dev->block_num);
1483 * Write an end of file on the device
1484 * Returns: 0 on success
1485 * non-zero on failure
1488 weof_dev(DEVICE *dev, int num)
1492 Dmsg0(29, "weof_dev\n");
1495 dev->dev_errno = EBADF;
1496 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1497 Emsg0(M_FATAL, 0, dev->errmsg);
1502 if (!dev->is_tape()) {
1505 if (!dev->can_append()) {
1506 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1507 Emsg0(M_FATAL, 0, dev->errmsg);
1511 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1512 mt_com.mt_op = MTWEOF;
1513 mt_com.mt_count = num;
1514 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1521 clrerror_dev(dev, MTWEOF);
1523 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1524 dev->print_name(), be.strerror());
1531 * Return string message with last error in English
1532 * Be careful not to call this routine from within dev.c
1533 * while editing an Mmsg() or you will end up in a recursive
1534 * loop creating a Segmentation Violation.
1537 strerror_dev(DEVICE *dev)
1544 * If implemented in system, clear the tape
1548 clrerror_dev(DEVICE *dev, int func)
1550 const char *msg = NULL;
1551 struct mtget mt_stat;
1554 dev->dev_errno = errno; /* save errno */
1556 dev->VolCatInfo.VolCatErrors++;
1559 if (!dev->is_tape()) {
1562 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1565 Emsg0(M_ABORT, 0, "Got ENOTTY on read/write!\n");
1569 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1574 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1579 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1583 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1587 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1591 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1612 bsnprintf(buf, sizeof(buf), "unknown func code %d", func);
1617 dev->dev_errno = ENOSYS;
1618 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1619 Emsg0(M_ERROR, 0, dev->errmsg);
1622 /* On some systems such as NetBSD, this clears all errors */
1623 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1625 /* Found on Linux */
1629 mt_com.mt_op = MTIOCLRERR;
1630 mt_com.mt_count = 1;
1631 /* Clear any error condition on the tape */
1632 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1633 Dmsg0(200, "Did MTIOCLRERR\n");
1637 /* Typically on FreeBSD */
1640 /* Read and clear SCSI error status */
1641 union mterrstat mt_errstat;
1642 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1643 strerror(dev->dev_errno));
1644 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1648 /* Clear Subsystem Exception OSF1 */
1652 mt_com.mt_op = MTCSE;
1653 mt_com.mt_count = 1;
1654 /* Clear any error condition on the tape */
1655 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1656 Dmsg0(200, "Did MTCSE\n");
1662 * Flush buffer contents
1665 int flush_dev(DEVICE *dev)
1670 static void do_close(DEVICE *dev)
1673 Dmsg1(29, "really close_dev %s\n", dev->print_name());
1678 if (!unmount_dev(dev, 1)) {
1679 Dmsg1(0, "Cannot unmount device %s.\n", dev->print_name());
1682 /* Remove the last part file if it is empty */
1683 if (dev->num_parts > 0) {
1685 POOL_MEM archive_name(PM_FNAME);
1686 dev->part = dev->num_parts;
1687 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", dev->VolCatInfo.VolCatName);
1688 make_spooled_dvd_filename(dev, archive_name);
1689 /* Check that the part file is empty */
1690 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1691 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1692 unlink(archive_name.c_str());
1696 /* Clean up device packet so it can be reused */
1698 dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1699 dev->label_type = B_BACULA_LABEL;
1700 dev->file = dev->block_num = 0;
1706 dev->part_start = 0;
1707 dev->EndFile = dev->EndBlock = 0;
1708 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1709 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1711 stop_thread_timer(dev->tid);
1721 void DEVICE::close()
1723 /*if (fd >= 0 && use_count == 1) {*/
1724 /* No need to check if fd >= 0: it is checked again
1725 * in do_close, and do_close MUST be called for volumes
1726 * splitted in parts, even if fd == -1. */
1727 if (use_count == 1) {
1729 } else if (use_count > 0) {
1734 ASSERT(use_count >= 0);
1739 bool truncate_dev(DCR *dcr) /* We need the DCR for DVD-writing */
1741 DEVICE *dev = dcr->dev;
1743 Dmsg1(100, "truncate_dev %s\n", dev->print_name());
1744 if (dev->is_tape()) {
1745 return true; /* we don't really truncate tapes */
1746 /* maybe we should rewind and write and eof ???? */
1749 if (dev->is_dvd()) {
1750 return truncate_dvd_dev(dcr);
1753 if (ftruncate(dev->fd, 0) != 0) {
1755 Mmsg2(dev->errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1756 dev->print_name(), be.strerror());
1762 /* Return the resource name for the device */
1763 const char *DEVICE::name() const
1765 return device->hdr.name;
1769 dev_vol_name(DEVICE *dev)
1771 return dev->VolCatInfo.VolCatName;
1774 uint32_t dev_block(DEVICE *dev)
1776 update_pos_dev(dev);
1777 return dev->block_num;
1780 uint32_t dev_file(DEVICE *dev)
1782 update_pos_dev(dev);
1787 * Free memory allocated for the device
1790 term_dev(DEVICE *dev)
1793 dev->dev_errno = EBADF;
1794 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1795 Emsg0(M_FATAL, 0, dev->errmsg);
1798 Dmsg1(29, "term_dev: %s\n", dev->print_name());
1800 if (dev->dev_name) {
1801 free_memory(dev->dev_name);
1802 dev->dev_name = NULL;
1804 if (dev->prt_name) {
1805 free_memory(dev->prt_name);
1806 dev->prt_name = NULL;
1809 free_pool_memory(dev->errmsg);
1812 pthread_mutex_destroy(&dev->mutex);
1813 pthread_cond_destroy(&dev->wait);
1814 pthread_cond_destroy(&dev->wait_next_vol);
1815 pthread_mutex_destroy(&dev->spool_mutex);
1816 rwl_destroy(&dev->lock);
1817 if (dev->attached_dcrs) {
1818 delete dev->attached_dcrs;
1819 dev->attached_dcrs = NULL;
1821 if (dev->state & ST_MALLOC) {
1822 free_pool_memory((POOLMEM *)dev);
1827 * This routine initializes the device wait timers
1829 void init_device_wait_timers(DCR *dcr)
1831 DEVICE *dev = dcr->dev;
1832 JCR *jcr = dcr->jcr;
1834 /* ******FIXME******* put these on config variables */
1835 dev->min_wait = 60 * 60;
1836 dev->max_wait = 24 * 60 * 60;
1837 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1838 dev->wait_sec = dev->min_wait;
1839 dev->rem_wait_sec = dev->wait_sec;
1842 dev->BadVolName[0] = 0;
1844 jcr->min_wait = 60 * 60;
1845 jcr->max_wait = 24 * 60 * 60;
1846 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1847 jcr->wait_sec = jcr->min_wait;
1848 jcr->rem_wait_sec = jcr->wait_sec;
1853 void init_jcr_device_wait_timers(JCR *jcr)
1855 /* ******FIXME******* put these on config variables */
1856 jcr->min_wait = 60 * 60;
1857 jcr->max_wait = 24 * 60 * 60;
1858 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1859 jcr->wait_sec = jcr->min_wait;
1860 jcr->rem_wait_sec = jcr->wait_sec;
1866 * The dev timers are used for waiting on a particular device
1868 * Returns: true if time doubled
1869 * false if max time expired
1871 bool double_dev_wait_time(DEVICE *dev)
1873 dev->wait_sec *= 2; /* double wait time */
1874 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
1875 dev->wait_sec = dev->max_wait;
1878 dev->rem_wait_sec = dev->wait_sec;
1879 if (dev->num_wait >= dev->max_num_wait) {
1886 void set_os_device_parameters(DEVICE *dev)
1888 #ifdef HAVE_LINUX_OS
1890 if (dev->min_block_size == dev->max_block_size &&
1891 dev->min_block_size == 0) { /* variable block mode */
1892 mt_com.mt_op = MTSETBLK;
1893 mt_com.mt_count = 0;
1894 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1895 clrerror_dev(dev, MTSETBLK);
1897 mt_com.mt_op = MTSETDRVBUFFER;
1898 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
1899 if (!dev_cap(dev, CAP_TWOEOF)) {
1900 mt_com.mt_count |= MT_ST_TWO_FM;
1902 if (dev_cap(dev, CAP_EOM)) {
1903 mt_com.mt_count |= MT_ST_FAST_MTEOM;
1905 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1906 clrerror_dev(dev, MTSETBLK);
1912 #ifdef HAVE_NETBSD_OS
1914 if (dev->min_block_size == dev->max_block_size &&
1915 dev->min_block_size == 0) { /* variable block mode */
1916 mt_com.mt_op = MTSETBSIZ;
1917 mt_com.mt_count = 0;
1918 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1919 clrerror_dev(dev, MTSETBSIZ);
1921 /* Get notified at logical end of tape */
1922 mt_com.mt_op = MTEWARN;
1923 mt_com.mt_count = 1;
1924 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1925 clrerror_dev(dev, MTEWARN);
1931 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
1933 if (dev->min_block_size == dev->max_block_size &&
1934 dev->min_block_size == 0) { /* variable block mode */
1935 mt_com.mt_op = MTSETBSIZ;
1936 mt_com.mt_count = 0;
1937 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1938 clrerror_dev(dev, MTSETBSIZ);
1946 if (dev->min_block_size == dev->max_block_size &&
1947 dev->min_block_size == 0) { /* variable block mode */
1948 mt_com.mt_op = MTSRSZ;
1949 mt_com.mt_count = 0;
1950 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1951 clrerror_dev(dev, MTSRSZ);
1958 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
1960 return dev_cap(dev, CAP_MTIOCGET) &&
1961 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
1962 mt_stat->mt_fileno >= 0;
1965 static char *modes[] = {
1966 "CREATE_READ_WRITE",
1973 static char *mode_to_str(int mode)
1975 return modes[mode-1];