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, 2001, 2002 Kern Sibbald and John Walker
34 This program is free software; you can redistribute it and/or
35 modify it under the terms of the GNU General Public License as
36 published by the Free Software Foundation; either version 2 of
37 the License, or (at your option) any later version.
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 GNU
42 General Public License for more details.
44 You should have received a copy of the GNU General Public
45 License along with this program; if not, write to the Free
46 Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
52 * Handling I/O errors and end of tape conditions are a bit tricky.
53 * This is how it is currently done when writting.
54 * On either an I/O error or end of tape,
55 * we will stop writing on the physical device (no I/O recovery is
56 * attempted at least in this daemon). The state flag will be sent
57 * to include ST_EOT, which is ephimeral, and ST_WEOT, which is
58 * persistent. Lots of routines clear ST_EOT, but ST_WEOT is
59 * cleared only when the problem goes away. Now when ST_WEOT
60 * is set all calls to write_dev() are handled as usual. However,
61 * in write_block() instead of attempting to write the block to
62 * the physical device, it is chained into a list of blocks written
63 * after the EOT condition. In addition, all threads are blocked
64 * from writing on the tape by calling lock(), and thread other
65 * than the first thread to hit the EOT will block on a condition
66 * variable. The first thread to hit the EOT will continue to
67 * be able to read and write the tape (he sort of tunnels through
68 * the locking mechanism -- see lock() for details).
70 * Now presumably somewhere higher in the chain of command
71 * (device.c), someone will notice the EOT condition and
72 * get a new tape up, get the tape label read, and mark
73 * the label for rewriting. Then this higher level routine
74 * will write the unwritten buffer to the new volume.
75 * Finally, he will release
76 * any blocked threads by doing a broadcast on the condition
77 * variable. At that point, we should be totally back in
78 * business with no lost data.
85 /* Forward referenced functions */
86 int dev_is_tape(DEVICE *dev);
87 void clrerror_dev(DEVICE *dev, int func);
88 int fsr_dev(DEVICE *dev, int num);
90 extern int debug_level;
93 * Allocate and initialize the DEVICE structure
94 * Note, if dev is non-NULL, it is already allocated,
95 * thus we neither allocate it nor free it. This allows
96 * the caller to put the packet in shared memory.
98 * Note, for a tape, the dev_name is the device name
99 * (e.g. /dev/nst0), and for a file, the device name
100 * is the directory in which the file will be placed.
104 init_dev(DEVICE *dev, char *dev_name)
110 /* Check that device is available */
111 if (stat(dev_name, &statp) < 0) {
113 dev->dev_errno = errno;
115 Emsg2(M_FATAL, 0, "Unable to stat device %s : %s\n", dev_name, strerror(errno));
119 if (S_ISDIR(statp.st_mode)) {
121 } else if (S_ISCHR(statp.st_mode)) {
125 dev->dev_errno = ENODEV;
127 Emsg2(M_FATAL, 0, "%s is an unknown device type. Must be tape or directory. st_mode=%x\n",
128 dev_name, statp.st_mode);
132 dev = (DEVICE *)get_memory(sizeof(DEVICE));
133 memset(dev, 0, sizeof(DEVICE));
134 dev->state = ST_MALLOC;
136 memset(dev, 0, sizeof(DEVICE));
139 dev->state |= ST_TAPE;
141 dev->dev_name = (char *) get_memory(strlen(dev_name)+1);
142 strcpy(dev->dev_name, dev_name);
144 dev->errmsg = (char *) get_pool_memory(PM_EMSG);
147 if ((errstat = pthread_mutex_init(&dev->mutex, NULL)) != 0) {
148 dev->dev_errno = errstat;
149 Mmsg1(&dev->errmsg, _("Unable to init mutex: ERR=%s\n"), strerror(errstat));
150 Emsg0(M_FATAL, 0, dev->errmsg);
152 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
153 dev->dev_errno = errstat;
154 Mmsg1(&dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), strerror(errstat));
155 Emsg0(M_FATAL, 0, dev->errmsg);
157 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
158 dev->dev_errno = errstat;
159 Mmsg1(&dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), strerror(errstat));
160 Emsg0(M_FATAL, 0, dev->errmsg);
163 Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev_is_tape(dev), dev->dev_name);
167 /* Open the device with the operating system and
168 * initialize buffer pointers.
170 * Note, for a tape, the VolName is the name we give to the
171 * volume (not really used here), but for a file, the
172 * VolName represents the name of the file to be created/opened.
173 * In the case of a file, the full name is the device name
174 * (archive_name) with the VolName concatenated.
177 open_dev(DEVICE *dev, char *VolName, int mode)
179 POOLMEM *archive_name;
181 if (dev->state & ST_OPENED) {
183 * *****FIXME***** how to handle two threads wanting
184 * different volumes mounted???? E.g. one is waiting
185 * for the next volume to be mounted, and a new job
186 * starts and snatches up the device.
188 if (VolName && strcmp(dev->VolCatInfo.VolCatName, VolName) != 0) {
192 Mmsg2(&dev->errmsg, _("WARNING!!!! device %s opened %d times!!!\n"),
193 dev->dev_name, dev->use_count);
194 Emsg0(M_WARNING, 0, dev->errmsg);
198 strcpy(dev->VolCatInfo.VolCatName, VolName);
201 Dmsg3(29, "open_dev: tape=%d dev_name=%s vol=%s\n", dev_is_tape(dev),
202 dev->dev_name, dev->VolCatInfo.VolCatName);
203 dev->state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
204 if (dev->state & ST_TAPE) {
206 Dmsg0(29, "open_dev: device is tape\n");
207 if (mode == READ_WRITE) {
208 dev->mode = O_RDWR | O_BINARY;
210 dev->mode = O_RDONLY | O_BINARY;
212 timeout = dev->max_open_wait;
213 while ((dev->fd = open(dev->dev_name, dev->mode, MODE_RW)) < 0) {
214 if (errno == EBUSY && timeout-- > 0) {
218 dev->dev_errno = errno;
219 Mmsg2(&dev->errmsg, _("stored: unable to open device %s: ERR=%s\n"),
220 dev->dev_name, strerror(dev->dev_errno));
221 Emsg0(M_FATAL, 0, dev->errmsg);
225 dev->state |= ST_OPENED;
227 update_pos_dev(dev); /* update position */
229 Dmsg1(29, "open_dev: tape %d opened\n", dev->fd);
232 * Handle opening of file
234 archive_name = get_pool_memory(PM_FNAME);
235 strcpy(archive_name, dev->dev_name);
236 if (archive_name[strlen(archive_name)] != '/') {
237 strcat(archive_name, "/");
239 strcat(archive_name, VolName);
240 Dmsg1(29, "open_dev: device is disk %s\n", archive_name);
241 if (mode == READ_WRITE) {
242 dev->mode = O_CREAT | O_RDWR | O_BINARY;
244 dev->mode = O_RDONLY | O_BINARY;
246 if ((dev->fd = open(archive_name, dev->mode, MODE_RW)) < 0) {
247 dev->dev_errno = errno;
248 Mmsg2(&dev->errmsg, _("Could not open: %s, ERR=%s\n"), archive_name, strerror(dev->dev_errno));
249 Emsg0(M_FATAL, 0, dev->errmsg);
252 dev->state |= ST_OPENED;
254 update_pos_dev(dev); /* update position */
256 Dmsg1(29, "open_dev: disk fd=%d opened\n", dev->fd);
257 free_pool_memory(archive_name);
264 * Returns: 1 on success
267 int rewind_dev(DEVICE *dev)
272 Dmsg0(29, "rewind_dev\n");
274 dev->dev_errno = EBADF;
275 Mmsg1(&dev->errmsg, _("Bad call to rewind_dev. Device %s not open\n"),
277 Emsg0(M_FATAL, 0, dev->errmsg);
280 dev->state &= ~(ST_APPEND|ST_READ|ST_EOT | ST_EOF | ST_WEOT); /* remove EOF/EOT flags */
281 dev->block_num = dev->file = 0;
283 if (dev->state & ST_TAPE) {
284 mt_com.mt_op = MTREW;
286 /* If we get an I/O error on rewind, it is probably because
287 * the drive is actually busy. We loop for (about 5 minutes)
288 * retrying every 5 seconds.
290 for (i=dev->max_rewind_wait; ; i -= 5) {
291 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
292 if (i == dev->max_rewind_wait) {
293 Dmsg1(200, "Rewind error, %s. retrying ...\n", strerror(errno));
295 clrerror_dev(dev, MTREW);
296 if (dev->dev_errno == EIO && i > 0) {
297 Dmsg0(200, "Sleeping 5 seconds.\n");
301 Mmsg2(&dev->errmsg, _("Rewind error on %s. ERR=%s.\n"),
302 dev->dev_name, strerror(dev->dev_errno));
308 if (lseek(dev->fd, 0, SEEK_SET) < 0) {
309 dev->dev_errno = errno;
310 Mmsg2(&dev->errmsg, _("lseek error on %s. ERR=%s.\n"),
311 dev->dev_name, strerror(dev->dev_errno));
319 * Position device to end of medium (end of data)
320 * Returns: 1 on succes
327 struct mtget mt_stat;
331 Dmsg0(29, "eod_dev\n");
332 if (dev->state & ST_EOT) {
335 dev->state &= ~(ST_EOF); /* remove EOF flags */
336 dev->block_num = dev->file = 0;
338 if (!(dev->state & ST_TAPE)) {
339 pos = lseek(dev->fd, 0, SEEK_END);
342 dev->state |= ST_EOT;
347 if (dev->capabilities & CAP_EOM) {
348 mt_com.mt_op = MTEOM;
350 if ((stat=ioctl(dev->fd, MTIOCTOP, (char *)&mt_com)) < 0) {
351 Dmsg1(50, "ioctl error: %s\n", strerror(dev->dev_errno));
352 clrerror_dev(dev, mt_com.mt_op);
354 Mmsg2(&dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
355 dev->dev_name, strerror(dev->dev_errno));
358 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
359 dev->dev_errno = errno;
360 Mmsg2(&dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
361 dev->dev_name, strerror(dev->dev_errno));
364 Dmsg2(200, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
365 dev->file = mt_stat.mt_fileno;
368 * Rewind then use FSF until EOT reached
371 if (!rewind_dev(dev)) {
374 while (!(dev->state & ST_EOT)) {
375 Dmsg0(200, "Do fsf 1\n");
376 if (fsf_dev(dev, 1) < 0) {
377 Dmsg0(200, "fsf_dev return < 0\n");
382 update_pos_dev(dev); /* update position */
383 Dmsg1(200, "EOD dev->file=%d\n", dev->file);
388 * Set the position of the device.
389 * Returns: 1 on succes
392 int update_pos_dev(DEVICE *dev)
395 struct mtget mt_stat;
401 dev->dev_errno = EBADF;
402 Mmsg0(&dev->errmsg, _("Bad device call. Archive not open\n"));
403 Emsg0(M_FATAL, 0, dev->errmsg);
407 /* Find out where we are */
408 if (!(dev->state & ST_TAPE)) {
411 pos = lseek(dev->fd, 0, SEEK_CUR);
413 Dmsg1(200, "Seek error: ERR=%s\n", strerror(dev->dev_errno));
415 dev->dev_errno = errno;
416 Mmsg2(&dev->errmsg, _("lseek error on %s. ERR=%s.\n"),
417 dev->dev_name, strerror(dev->dev_errno));
424 #ifdef REALLY_IMPLEMENTED
425 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
426 Dmsg1(50, "MTIOCGET error: %s\n", strerror(dev->dev_errno));
427 dev->dev_errno = errno;
428 Mmsg2(&dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
429 dev->dev_name, strerror(dev->dev_errno));
440 * Return the status of the device. This was meant
441 * to be a generic routine. Unfortunately, it doesn't
442 * seem possible (at least I do not know how to do it
443 * currently), which means that for the moment, this
444 * routine has very little value.
446 * Returns: 1 on success
450 status_dev(DEVICE *dev, uint32_t *status)
452 struct mtget mt_stat;
455 if (dev->state & (ST_EOT | ST_WEOT)) {
459 if (dev->state & ST_EOF) {
463 if (dev->state & ST_TAPE) {
465 Dmsg0(-20," Driver status:");
466 Dmsg2(-20," file=%d block=%d\n", dev->file, dev->block_num);
467 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
468 dev->dev_errno = errno;
469 Mmsg2(&dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
470 dev->dev_name, strerror(dev->dev_errno));
473 Dmsg0(-20, " Device status:");
475 #if defined(HAVE_LINUX_OS)
476 if (GMT_EOF(mt_stat.mt_gstat)) {
480 if (GMT_BOT(mt_stat.mt_gstat)) {
484 if (GMT_EOT(mt_stat.mt_gstat)) {
488 if (GMT_SM(mt_stat.mt_gstat)) {
492 if (GMT_EOD(mt_stat.mt_gstat)) {
496 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
498 Dmsg0(-20, " WR_PROT");
500 if (GMT_ONLINE(mt_stat.mt_gstat)) {
502 Dmsg0(-20, " ONLINE");
504 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
506 Dmsg0(-20, " DR_OPEN");
508 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
509 stat |= MT_IM_REP_EN;
510 Dmsg0(-20, " IM_REP_EN");
512 #endif /* !SunOS && !OSF */
513 Dmsg2(-20, " file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
515 stat |= MT_ONLINE | MT_BOT;
523 * Load medium in device
524 * Returns: 1 on success
527 int load_dev(DEVICE *dev)
534 dev->dev_errno = EBADF;
535 Mmsg0(&dev->errmsg, _("Bad call to load_dev. Archive not open\n"));
536 Emsg0(M_FATAL, 0, dev->errmsg);
539 if (!(dev->state & ST_TAPE)) {
543 Dmsg0(200, "stored: MTLOAD command not available\n");
544 dev->dev_errno = ENOTTY; /* function not available */
545 Mmsg2(&dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
546 dev->dev_name, strerror(dev->dev_errno)); return 0;
550 dev->block_num = dev->file = 0;
552 mt_com.mt_op = MTLOAD;
554 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
555 dev->dev_errno = errno;
556 Mmsg2(&dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
557 dev->dev_name, strerror(dev->dev_errno)); return 0;
564 * Rewind device and put it offline
565 * Returns: 1 on success
568 int offline_dev(DEVICE *dev)
573 dev->dev_errno = EBADF;
574 Mmsg0(&dev->errmsg, _("Bad call to load_dev. Archive not open\n"));
575 Emsg0(M_FATAL, 0, dev->errmsg);
578 if (!(dev->state & ST_TAPE)) {
582 dev->block_num = dev->file = 0;
584 mt_com.mt_op = MTOFFL;
586 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
587 dev->dev_errno = errno;
588 Mmsg2(&dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
589 dev->dev_name, strerror(dev->dev_errno));
592 Dmsg1(100, "Offlined device %s\n", dev->dev_name);
598 * Foward space a file
601 fsf_dev(DEVICE *dev, int num)
608 dev->dev_errno = EBADF;
609 Mmsg0(&dev->errmsg, _("Bad call to fsf_dev. Archive not open\n"));
610 Emsg0(M_FATAL, 0, dev->errmsg);
614 if (!(dev->state & ST_TAPE)) {
617 if (dev->state & ST_EOT) {
619 Mmsg1(&dev->errmsg, _("Device %s at End of Tape.\n"), dev->dev_name);
622 if (dev->state & ST_EOF)
623 Dmsg0(200, "ST_EOF set on entry to FSF\n");
624 if (dev->state & ST_EOT)
625 Dmsg0(200, "ST_EOT set on entry to FSF\n");
627 Dmsg0(29, "fsf_dev\n");
629 if (dev->capabilities & CAP_FSF) {
630 Dmsg0(200, "FSF has cap_fsf\n");
631 mt_com.mt_op = MTFSF;
633 while (num-- && !(dev->state & ST_EOT)) {
634 Dmsg0(200, "Doing read for fsf\n");
635 if ((stat = read(dev->fd, rbuf, sizeof(rbuf))) < 0) {
636 if (errno == ENOMEM) { /* tape record exceeds buf len */
637 stat = sizeof(rbuf); /* This is OK */
639 dev->state |= ST_EOT;
640 clrerror_dev(dev, -1);
641 Dmsg1(200, "Set ST_EOT read error %d\n", dev->dev_errno);
642 Mmsg2(&dev->errmsg, _("read error on %s. ERR=%s.\n"),
643 dev->dev_name, strerror(dev->dev_errno));
644 Dmsg1(200, "%s", dev->errmsg);
648 if (stat == 0) { /* EOF */
650 Dmsg1(200, "End of File mark from read. File=%d\n", dev->file+1);
651 /* Two reads of zero means end of tape */
652 if (dev->state & ST_EOF) {
653 dev->state |= ST_EOT;
654 Dmsg0(200, "Set ST_EOT\n");
657 dev->state |= ST_EOF;
662 } else { /* Got data */
663 dev->state &= ~(ST_EOF|ST_EOT);
666 Dmsg0(200, "Doing MT_FSF\n");
667 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
668 if (stat < 0) { /* error => EOT */
669 dev->state |= ST_EOT;
670 Dmsg0(200, "Set ST_EOT\n");
671 clrerror_dev(dev, MTFSF);
672 Mmsg2(&dev->errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
673 dev->dev_name, strerror(dev->dev_errno));
674 Dmsg0(200, "Got < 0 for MT_FSF\n");
675 Dmsg1(200, "%s", dev->errmsg);
677 dev->state |= ST_EOF; /* just read EOF */
684 * No FSF, so use FSR to simulate it
687 Dmsg0(200, "Doing FSR for FSF\n");
688 while (num-- && !(dev->state & ST_EOT)) {
689 fsr_dev(dev, INT32_MAX); /* returns -1 on EOF or EOT */
691 if (dev->state & ST_EOT) {
693 Mmsg1(&dev->errmsg, _("Device %s at End of Tape.\n"), dev->dev_name);
700 Dmsg1(200, "Return %d from FSF\n", stat);
701 if (dev->state & ST_EOF)
702 Dmsg0(200, "ST_EOF set on exit FSF\n");
703 if (dev->state & ST_EOT)
704 Dmsg0(200, "ST_EOT set on exit FSF\n");
705 Dmsg1(200, "Return from FSF file=%d\n", dev->file);
710 * Backward space a file
713 bsf_dev(DEVICE *dev, int num)
719 dev->dev_errno = EBADF;
720 Mmsg0(&dev->errmsg, _("Bad call to fsf_dev. Archive not open\n"));
721 Emsg0(M_FATAL, 0, dev->errmsg);
725 if (!(dev->state & ST_TAPE)) {
728 Dmsg0(29, "bsf_dev\n");
729 dev->state &= ~(ST_EOT|ST_EOF);
732 mt_com.mt_op = MTBSF;
733 mt_com.mt_count = num;
734 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
736 clrerror_dev(dev, MTBSF);
737 Mmsg2(&dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
738 dev->dev_name, strerror(dev->dev_errno));
746 * Foward space a record
749 fsr_dev(DEVICE *dev, int num)
755 dev->dev_errno = EBADF;
756 Mmsg0(&dev->errmsg, _("Bad call to fsf_dev. Archive not open\n"));
757 Emsg0(M_FATAL, 0, dev->errmsg);
761 if (!(dev->state & ST_TAPE)) {
764 Dmsg0(29, "fsr_dev\n");
765 dev->block_num += num;
766 mt_com.mt_op = MTFSR;
767 mt_com.mt_count = num;
768 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
770 dev->state &= ~ST_EOF;
772 if (dev->state & ST_EOF) {
773 dev->state |= ST_EOT;
775 dev->state |= ST_EOF; /* assume EOF */
779 clrerror_dev(dev, MTFSR);
780 Mmsg2(&dev->errmsg, _("ioctl MTFSR error on %s. ERR=%s.\n"),
781 dev->dev_name, strerror(dev->dev_errno));
788 * Backward space a record
791 bsr_dev(DEVICE *dev, int num)
797 dev->dev_errno = EBADF;
798 Mmsg0(&dev->errmsg, _("Bad call to fsf_dev. Archive not open\n"));
799 Emsg0(M_FATAL, 0, dev->errmsg);
803 if (!(dev->state & ST_TAPE)) {
806 Dmsg0(29, "bsr_dev\n");
807 dev->block_num -= num;
808 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
809 mt_com.mt_op = MTBSR;
810 mt_com.mt_count = num;
811 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
813 clrerror_dev(dev, MTBSR);
814 Mmsg2(&dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
815 dev->dev_name, strerror(dev->dev_errno));
824 * Write an end of file on the device
827 weof_dev(DEVICE *dev, int num)
833 dev->dev_errno = EBADF;
834 Mmsg0(&dev->errmsg, _("Bad call to fsf_dev. Archive not open\n"));
835 Emsg0(M_FATAL, 0, dev->errmsg);
839 if (!(dev->state & ST_TAPE)) {
842 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
844 Dmsg0(29, "weof_dev\n");
845 mt_com.mt_op = MTWEOF;
846 mt_com.mt_count = num;
847 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
852 clrerror_dev(dev, MTWEOF);
853 Mmsg2(&dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
854 dev->dev_name, strerror(dev->dev_errno));
860 * Return string message with last error in English
861 * Be careful not to call this routine from within dev.c
862 * while editing an Mmsg(&) or you will end up in a recursive
863 * loop creating a Segmentation Violation.
866 strerror_dev(DEVICE *dev)
873 * If implemented in system, clear the tape
877 clrerror_dev(DEVICE *dev, int func)
881 dev->dev_errno = errno; /* save errno */
883 dev->VolCatInfo.VolCatErrors++;
886 if (!(dev->state & ST_TAPE)) {
889 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
892 Emsg0(M_ABORT, 0, "Got ENOTTY on read/write!\n");
896 dev->capabilities &= ~CAP_EOF; /* turn off feature */
900 dev->capabilities &= ~CAP_EOM; /* turn off feature */
904 dev->capabilities &= ~CAP_FSF; /* turn off feature */
908 dev->capabilities &= ~CAP_BSF; /* turn off feature */
912 dev->capabilities &= ~CAP_FSR; /* turn off feature */
916 dev->capabilities &= ~CAP_BSR; /* turn off feature */
923 dev->dev_errno = ENOSYS;
924 Mmsg1(&dev->errmsg, _("This device does not support %s.\n"), msg);
925 Emsg0(M_ERROR, 0, dev->errmsg);
932 mt_com.mt_op = MTIOCLRERR;
934 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
935 Dmsg0(200, "Did MTIOCLRERR\n");
941 * Flush buffer contents
944 int flush_dev(DEVICE *dev)
949 static void do_close(DEVICE *dev)
951 Dmsg0(29, "really close_dev\n");
953 /* Clean up device packet so it can be reused */
955 dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
959 dev->LastBlockNumWritten = 0;
960 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
961 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
968 close_dev(DEVICE *dev)
971 Mmsg0(&dev->errmsg, _("Bad call to fsf_dev. Archive not open\n"));
972 Emsg0(M_FATAL, 0, dev->errmsg);
975 if (dev->fd >= 0 && dev->use_count == 1) {
978 Dmsg0(29, "close_dev but in use so leave open.\n");
984 * Used when unmounting the device
986 void force_close_dev(DEVICE *dev)
989 Mmsg0(&dev->errmsg, _("Bad call to fsf_dev. Archive not open\n"));
990 Emsg0(M_FATAL, 0, dev->errmsg);
993 Dmsg0(29, "really close_dev\n");
998 int truncate_dev(DEVICE *dev)
1000 if (dev->state & ST_TAPE) {
1003 if (ftruncate(dev->fd, 0) != 0) {
1004 Mmsg1(&dev->errmsg, _("Unable to truncate device. ERR=%s\n"), strerror(errno));
1011 dev_is_tape(DEVICE *dev)
1013 return (dev->state & ST_TAPE) ? 1 : 0;
1017 dev_name(DEVICE *dev)
1019 return dev->dev_name;
1023 dev_vol_name(DEVICE *dev)
1025 return dev->VolCatInfo.VolCatName;
1028 uint32_t dev_block(DEVICE *dev)
1030 update_pos_dev(dev);
1031 return dev->block_num;
1034 uint32_t dev_file(DEVICE *dev)
1036 update_pos_dev(dev);
1041 * Free memory allocated for the device
1044 term_dev(DEVICE *dev)
1047 dev->dev_errno = EBADF;
1048 Mmsg0(&dev->errmsg, _("Bad call to fsf_dev. Archive not open\n"));
1049 Emsg0(M_FATAL, 0, dev->errmsg);
1053 Dmsg0(29, "term_dev\n");
1054 if (dev->dev_name) {
1055 free_memory(dev->dev_name);
1056 dev->dev_name = NULL;
1059 free_pool_memory(dev->errmsg);
1062 pthread_mutex_destroy(&dev->mutex);
1063 pthread_cond_destroy(&dev->wait);
1064 pthread_cond_destroy(&dev->wait_next_vol);
1065 if (dev->state & ST_MALLOC) {
1066 free_pool_memory((POOLMEM *)dev);