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 */
269 Dmsg0(100, "Close fd for mode change.\n");
273 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
276 Dmsg4(29, "open dev: tape=%d dev_name=%s vol=%s mode=%s\n", is_tape(),
277 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
278 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
279 label_type = B_BACULA_LABEL;
280 if (is_tape() || is_fifo()) {
281 open_tape_device(dcr, omode);
282 } else if (is_dvd()) {
283 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
284 open_dvd_device(dcr, omode);
286 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
287 open_file_device(omode);
292 void DEVICE::set_mode(int new_mode)
295 case CREATE_READ_WRITE:
296 mode = O_CREAT | O_RDWR | O_BINARY;
298 case OPEN_READ_WRITE:
299 if (is_dvd() || is_file()) {
300 mode = O_CREAT | O_RDWR | O_BINARY;
302 mode = O_RDWR | O_BINARY;
306 mode = O_RDONLY | O_BINARY;
308 case OPEN_WRITE_ONLY:
309 mode = O_WRONLY | O_BINARY;
312 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
317 * If the flage open_nowait is set, which is the case
318 * when the daemon is initially trying to open the device,
319 * we open it with O_NONBLOCK set and O_RONLY, which will
320 * allow us to open normal Linux tape drives with no tape
321 * in the drive without blocking. We then immediately
322 * set blocking status so that if we read from the device they
323 * will be normal blocking reads.
325 * If later, we want to write on the device, it will be freed and
326 * reopened, but hopefully there will be a tape in the drive so
329 void DEVICE::open_tape_device(DCR *dcr, int omode)
335 Dmsg0(29, "open dev: device is tape\n");
337 if (is_tape() && is_autochanger()) {
338 get_autochanger_loaded_slot(dcr);
342 timeout = max_open_wait;
346 /* Set wait counters to zero for no wait */
347 timeout = ioerrcnt = 0;
348 /* Open drive in non-block mode */
349 nonblocking = O_NONBLOCK;
352 if (is_fifo() && timeout) {
354 tid = start_thread_timer(pthread_self(), timeout);
356 /* If busy retry each second for max_open_wait seconds */
357 Dmsg3(100, "Try open %s mode=%s nonblocking=%d\n", print_name(),
358 mode_to_str(omode), nonblocking);
359 /* Use system open() */
360 while ((fd = ::open(dev_name, mode+nonblocking, MODE_RW)) < 0) {
362 Dmsg2(100, "Open error errno=%d ERR=%s\n", errno, be.strerror());
363 if (errno == EINTR || errno == EAGAIN) {
364 Dmsg0(100, "Continue open\n");
367 /* Busy wait for specified time (default = 5 mins) */
368 if (errno == EBUSY && timeout-- > 0) {
369 Dmsg2(100, "Device %s busy. ERR=%s\n", print_name(), be.strerror());
373 /* IO error (no volume) try 10 times every 6 seconds */
374 if (errno == EIO && ioerrcnt-- > 0) {
376 Dmsg0(100, "Continue open\n");
380 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
381 print_name(), be.strerror(dev_errno));
382 /* Stop any open timer we set */
384 stop_thread_timer(tid);
387 Jmsg0(dcr->jcr, M_FATAL, 0, errmsg);
396 openmode = omode; /* save open mode */
397 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
401 update_pos_dev(this); /* update position */
402 set_os_device_parameters(this); /* do system dependent stuff */
405 /* Stop any open() timer we started */
407 stop_thread_timer(tid);
410 Dmsg1(29, "open dev: tape %d opened\n", fd);
413 void DEVICE::set_blocking()
416 /* Try to reset blocking */
417 if ((oflags = fcntl(fd, F_GETFL, 0)) < 0 ||
418 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK) < 0) {
420 ::close(fd); /* use system close() */
421 fd = ::open(dev_name, mode, MODE_RW);
422 Dmsg2(100, "fcntl error. ERR=%s. Close-reopen fd=%d\n", be.strerror(), fd);
429 void DEVICE::open_file_device(int omode)
431 POOL_MEM archive_name(PM_FNAME);
434 * Handle opening of File Archive (not a tape)
436 Dmsg3(29, "Enter: open_file_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
437 archive_name.c_str(), mode_to_str(omode));
439 if (VolCatInfo.VolCatName[0] == 0) {
440 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
446 pm_strcpy(archive_name, dev_name);
447 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
448 pm_strcat(archive_name, "/");
450 pm_strcat(archive_name, VolCatInfo.VolCatName);
452 Dmsg3(29, "open dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
453 archive_name.c_str(), mode_to_str(omode));
455 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
458 /* If creating file, give 0640 permissions */
459 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
460 archive_name.c_str(), mode);
461 /* Use system open() */
462 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
465 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
467 Dmsg1(29, "open failed: %s", errmsg);
468 Emsg0(M_FATAL, 0, errmsg);
473 update_pos_dev(this); /* update position */
475 Dmsg5(29, "open dev: %s fd=%d opened, part=%d/%d, part_size=%u\n",
476 is_dvd()?"DVD":"disk", fd, part, num_parts,
481 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName (NB:??? I think it's VolCatInfo.VolCatName that is right)
482 * has the desired Volume name, but there is NO assurance that
483 * any other field of VolCatInfo is correct.
485 void DEVICE::open_dvd_device(DCR *dcr, int omode)
487 POOL_MEM archive_name(PM_FNAME);
488 struct stat filestat;
491 * Handle opening of DVD Volume
493 Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
494 archive_name.c_str(), mode_to_str(omode));
496 if (VolCatInfo.VolCatName[0] == 0) {
497 Dmsg1(10, "Could not open file device %s. No Volume name given.\n",
499 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
510 Dmsg2(99, "open_dvd_device: num_parts=%d, VolCatInfo.VolCatParts=%d\n",
511 dcr->dev->num_parts, dcr->VolCatInfo.VolCatParts);
512 if (dcr->dev->num_parts < dcr->VolCatInfo.VolCatParts) {
513 Dmsg2(99, "open_dvd_device: num_parts updated to %d (was %d)\n",
514 dcr->VolCatInfo.VolCatParts, dcr->dev->num_parts);
515 dcr->dev->num_parts = dcr->VolCatInfo.VolCatParts;
518 if (mount_dev(this, 1)) {
519 if ((num_parts == 0) && (!truncating)) {
520 /* If we can mount the device, and we are not truncating the DVD, we usually want to abort. */
521 /* There is one exception, if there is only one 0-sized file on the DVD, with the right volume name,
522 * we continue (it's the method used by truncate_dvd_dev to truncate a volume). */
523 if (!check_can_write_on_non_blank_dvd(dcr)) {
524 Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
525 Emsg0(M_FATAL, 0, errmsg);
532 /* We cannot mount the device */
533 if (num_parts == 0) {
534 /* Run free space, check there is a media. */
535 update_free_space_dev(this);
537 Dmsg1(29, "Could not mount device %s, this is not a problem (num_parts == 0), and have media.\n", print_name());
540 Mmsg(errmsg, _("There is no valid media in the device %s.\n"), print_name());
541 Emsg0(M_FATAL, 0, errmsg);
547 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
548 Emsg0(M_FATAL, 0, errmsg);
554 Dmsg6(29, "open dev: %s dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
555 is_dvd()?"DVD":"disk", archive_name.c_str(), mode_to_str(omode),
556 part, num_parts, dcr->VolCatInfo.VolCatParts);
558 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
561 * If we are not trying to access the last part, set mode to
562 * OPEN_READ_ONLY as writing would be an error.
564 if (part < num_parts) {
565 omode = OPEN_READ_ONLY;
566 make_mounted_dvd_filename(this, archive_name);
569 make_spooled_dvd_filename(this, archive_name);
573 /* If creating file, give 0640 permissions */
574 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
575 archive_name.c_str(), mode);
576 /* Use system open() */
577 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
579 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
581 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
582 Dmsg1(29, "open failed: %s", errmsg);
584 if ((omode == OPEN_READ_ONLY) && (part == num_parts)) {
585 /* If the last part (on spool), doesn't exists when reading, create it and read from it
586 * (it will report immediately an EOF):
587 * Sometimes it is better to finish with an EOF than with an error. */
588 set_mode(OPEN_READ_WRITE);
589 fd = ::open(archive_name.c_str(), mode, 0640);
590 set_mode(OPEN_READ_ONLY);
593 /* We don't need it. Only the last part is on spool */
594 /*if (omode == OPEN_READ_ONLY) {
595 make_spooled_dvd_filename(this, archive_name);
596 fd = ::open(archive_name.c_str(), mode, 0640); // try on spool
599 Dmsg1(100, "after open fd=%d\n", fd);
601 /* Get size of file */
602 if (fstat(fd, &filestat) < 0) {
605 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
607 Dmsg1(29, "open failed: %s", errmsg);
608 /* Use system close() */
612 part_size = filestat.st_size;
616 update_pos_dev(this); /* update position */
618 /* NB: It seems this code is wrong... part number is incremented in open_next_part, not here */
620 /* Check if just created Volume part */
621 /* if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
624 VolCatInfo.VolCatParts = num_parts;
626 if (part == 0) { // we must have opened the first part
637 bool _rewind_dev(char *file, int line, DEVICE *dev)
639 Dmsg3(100, "rewind_dev fd=%d called from %s:%d\n", dev->fd, file, line);
640 return rewind_dev(dev);
646 * Returns: true on success
649 bool rewind_dev(DEVICE *dev)
654 Dmsg2(29, "rewind_dev fd=%d %s\n", dev->fd, dev->print_name());
656 if (!dev->is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
657 dev->dev_errno = EBADF;
658 Mmsg1(dev->errmsg, _("Bad call to rewind_dev. Device %s not open\n"),
660 Emsg0(M_ABORT, 0, dev->errmsg);
664 dev->state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
665 dev->block_num = dev->file = 0;
668 if (dev->is_tape()) {
669 mt_com.mt_op = MTREW;
671 /* If we get an I/O error on rewind, it is probably because
672 * the drive is actually busy. We loop for (about 5 minutes)
673 * retrying every 5 seconds.
675 for (i=dev->max_rewind_wait; ; i -= 5) {
676 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
678 clrerror_dev(dev, MTREW);
679 if (i == dev->max_rewind_wait) {
680 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
682 if (dev->dev_errno == EIO && i > 0) {
683 Dmsg0(200, "Sleeping 5 seconds.\n");
687 Mmsg2(dev->errmsg, _("Rewind error on %s. ERR=%s.\n"),
688 dev->print_name(), be.strerror());
693 } else if (dev->is_file()) {
694 if (lseek_dev(dev, (off_t)0, SEEK_SET) < 0) {
696 dev->dev_errno = errno;
697 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
698 dev->print_name(), be.strerror());
705 void DEVICE::block(int why)
708 block_device(this, why);
712 void DEVICE::unblock()
715 unblock_device(this);
719 const char *DEVICE::print_blocked() const
721 switch (dev_blocked) {
722 case BST_NOT_BLOCKED:
723 return "BST_NOT_BLOCKED";
725 return "BST_UNMOUNTED";
726 case BST_WAITING_FOR_SYSOP:
727 return "BST_WAITING_FOR_SYSOP";
728 case BST_DOING_ACQUIRE:
729 return "BST_DOING_ACQUIRE";
730 case BST_WRITING_LABEL:
731 return "BST_WRITING_LABEL";
732 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
733 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
737 return _("unknown blocked code");
742 * Called to indicate that we have just read an
743 * EOF from the device.
745 void DEVICE::set_ateof()
755 * Called to indicate we are now at the end of the tape, and
756 * writing is not possible.
758 void DEVICE::set_ateot()
760 /* Make tape effectively read-only */
761 state |= (ST_EOF|ST_EOT|ST_WEOT);
766 * Position device to end of medium (end of data)
767 * Returns: true on succes
774 struct mtget mt_stat;
779 dev->dev_errno = EBADF;
780 Mmsg1(dev->errmsg, _("Bad call to eod_dev. Device %s not open\n"),
785 #if defined (__digital__) && defined (__unix__)
786 return dev->fsf(dev->VolCatInfo.VolCatFiles);
789 Dmsg0(29, "eod_dev\n");
793 dev->state &= ~(ST_EOF); /* remove EOF flags */
794 dev->block_num = dev->file = 0;
797 if (dev->state & (ST_FIFO | ST_PROG)) {
800 if (!dev->is_tape()) {
801 pos = lseek_dev(dev, (off_t)0, SEEK_END);
802 // Dmsg1(100, "====== Seek to %lld\n", pos);
805 dev->state |= ST_EOT;
808 dev->dev_errno = errno;
810 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
811 dev->print_name(), be.strerror());
815 if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
816 Dmsg0(100,"Using FAST FSF for EOM\n");
817 /* If unknown position, rewind */
818 if (!dev_get_os_pos(dev, &mt_stat)) {
819 if (!rewind_dev(dev)) {
823 mt_com.mt_op = MTFSF;
825 * ***FIXME*** fix code to handle case that INT16_MAX is
828 mt_com.mt_count = INT16_MAX; /* use big positive number */
829 if (mt_com.mt_count < 0) {
830 mt_com.mt_count = INT16_MAX; /* brain damaged system */
834 if (dev_cap(dev, CAP_MTIOCGET) && (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM))) {
835 if (dev_cap(dev, CAP_EOM)) {
836 Dmsg0(100,"Using EOM for EOM\n");
837 mt_com.mt_op = MTEOM;
841 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
843 clrerror_dev(dev, mt_com.mt_op);
844 Dmsg1(50, "ioctl error: %s\n", be.strerror());
846 Mmsg2(dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
847 dev->print_name(), be.strerror());
851 if (!dev_get_os_pos(dev, &mt_stat)) {
853 clrerror_dev(dev, -1);
854 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
855 dev->print_name(), be.strerror());
858 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
860 dev->file = mt_stat.mt_fileno;
866 * Rewind then use FSF until EOT reached
868 if (!rewind_dev(dev)) {
872 * Move file by file to the end of the tape
875 for (file_num=dev->file; !dev->at_eot(); file_num++) {
876 Dmsg0(200, "eod_dev: doing fsf 1\n");
878 Dmsg0(200, "fsf error.\n");
882 * Avoid infinite loop by ensuring we advance.
884 if (file_num == (int)dev->file) {
885 struct mtget mt_stat;
886 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
888 if (dev_get_os_pos(dev, &mt_stat)) {
889 Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
890 dev->file = mt_stat.mt_fileno;
897 * Some drivers leave us after second EOF when doing
898 * MTEOM, so we must backup so that appending overwrites
901 if (dev_cap(dev, CAP_BSFATEOM)) {
902 struct mtget mt_stat;
903 /* Backup over EOF */
904 ok = bsf_dev(dev, 1);
905 /* If BSF worked and fileno is known (not -1), set file */
906 if (dev_get_os_pos(dev, &mt_stat)) {
907 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
908 dev->file = mt_stat.mt_fileno;
910 dev->file++; /* wing it -- not correct on all OSes */
913 update_pos_dev(dev); /* update position */
915 Dmsg1(200, "EOD dev->file=%d\n", dev->file);
920 * Set the position of the device -- only for files and DVD
921 * For other devices, there is no generic way to do it.
922 * Returns: true on succes
925 bool update_pos_dev(DEVICE *dev)
931 dev->dev_errno = EBADF;
932 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
933 Emsg0(M_FATAL, 0, dev->errmsg);
937 /* Find out where we are */
938 if (dev->is_file()) {
941 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
944 dev->dev_errno = errno;
945 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
946 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
947 dev->print_name(), be.strerror());
950 dev->file_addr = pos;
958 * Return the status of the device. This was meant
959 * to be a generic routine. Unfortunately, it doesn't
960 * seem possible (at least I do not know how to do it
961 * currently), which means that for the moment, this
962 * routine has very little value.
966 uint32_t status_dev(DEVICE *dev)
968 struct mtget mt_stat;
971 if (dev->state & (ST_EOT | ST_WEOT)) {
975 if (dev->state & ST_EOF) {
979 if (dev->is_tape()) {
981 Pmsg0(-20,_(" Bacula status:"));
982 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
983 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
985 dev->dev_errno = errno;
986 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
987 dev->print_name(), be.strerror());
990 Pmsg0(-20, _(" Device status:"));
992 #if defined(HAVE_LINUX_OS)
993 if (GMT_EOF(mt_stat.mt_gstat)) {
997 if (GMT_BOT(mt_stat.mt_gstat)) {
1001 if (GMT_EOT(mt_stat.mt_gstat)) {
1005 if (GMT_SM(mt_stat.mt_gstat)) {
1009 if (GMT_EOD(mt_stat.mt_gstat)) {
1013 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1014 stat |= BMT_WR_PROT;
1015 Pmsg0(-20, " WR_PROT");
1017 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1019 Pmsg0(-20, " ONLINE");
1021 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1022 stat |= BMT_DR_OPEN;
1023 Pmsg0(-20, " DR_OPEN");
1025 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1026 stat |= BMT_IM_REP_EN;
1027 Pmsg0(-20, " IM_REP_EN");
1029 #endif /* !SunOS && !OSF */
1030 if (dev_cap(dev, CAP_MTIOCGET)) {
1031 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1033 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1036 stat |= BMT_ONLINE | BMT_BOT;
1043 * Load medium in device
1044 * Returns: true on success
1047 bool load_dev(DEVICE *dev)
1054 dev->dev_errno = EBADF;
1055 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1056 Emsg0(M_FATAL, 0, dev->errmsg);
1059 if (!(dev->is_tape())) {
1063 Dmsg0(200, "stored: MTLOAD command not available\n");
1065 dev->dev_errno = ENOTTY; /* function not available */
1066 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1067 dev->print_name(), be.strerror());
1071 dev->block_num = dev->file = 0;
1074 mt_com.mt_op = MTLOAD;
1075 mt_com.mt_count = 1;
1076 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1078 dev->dev_errno = errno;
1079 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1080 dev->print_name(), be.strerror());
1088 * Rewind device and put it offline
1089 * Returns: true on success
1092 bool offline_dev(DEVICE *dev)
1096 if (!dev || dev->fd < 0 || !dev->is_tape()) {
1097 return true; /* device not open */
1100 dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1101 dev->block_num = dev->file = 0;
1106 mt_com.mt_op = MTUNLOCK;
1107 mt_com.mt_count = 1;
1108 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1110 mt_com.mt_op = MTOFFL;
1111 mt_com.mt_count = 1;
1112 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1114 dev->dev_errno = errno;
1115 Mmsg2(dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1116 dev->print_name(), be.strerror());
1119 Dmsg1(100, "Offlined device %s\n", dev->print_name());
1123 bool offline_or_rewind_dev(DEVICE *dev)
1128 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1129 return offline_dev(dev);
1132 * Note, this rewind probably should not be here (it wasn't
1133 * in prior versions of Bacula), but on FreeBSD, this is
1134 * needed in the case the tape was "frozen" due to an error
1135 * such as backspacing after writing and EOF. If it is not
1136 * done, all future references to the drive get and I/O error.
1138 clrerror_dev(dev, MTREW);
1139 return rewind_dev(dev);
1144 * Foward space a file
1145 * Returns: true on success
1148 bool DEVICE::fsf(int num)
1150 struct mtget mt_stat;
1156 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1157 Emsg0(M_FATAL, 0, errmsg);
1166 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1170 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1173 Dmsg0(100, "fsf\n");
1176 * If Fast forward space file is set, then we
1177 * use MTFSF to forward space and MTIOCGET
1178 * to get the file position. We assume that
1179 * the SCSI driver will ensure that we do not
1180 * forward space past the end of the medium.
1182 if (dev_cap(this, CAP_FSF) && dev_cap(this, CAP_MTIOCGET) && dev_cap(this, CAP_FASTFSF)) {
1183 mt_com.mt_op = MTFSF;
1184 mt_com.mt_count = num;
1185 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1186 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1189 Dmsg0(200, "Set ST_EOT\n");
1190 clrerror_dev(this, MTFSF);
1191 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1192 print_name(), be.strerror());
1193 Dmsg1(200, "%s", errmsg);
1196 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1198 file = mt_stat.mt_fileno;
1202 * Here if CAP_FSF is set, and virtually all drives
1203 * these days support it, we read a record, then forward
1204 * space one file. Using this procedure, which is slow,
1205 * is the only way we can be sure that we don't read
1206 * two consecutive EOF marks, which means End of Data.
1208 } else if (dev_cap(this, CAP_FSF)) {
1211 Dmsg0(200, "FSF has cap_fsf\n");
1212 if (max_block_size == 0) {
1213 rbuf_len = DEFAULT_BLOCK_SIZE;
1215 rbuf_len = max_block_size;
1217 rbuf = get_memory(rbuf_len);
1218 mt_com.mt_op = MTFSF;
1219 mt_com.mt_count = 1;
1220 while (num-- && !at_eot()) {
1221 Dmsg0(100, "Doing read before fsf\n");
1222 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1223 if (errno == ENOMEM) { /* tape record exceeds buf len */
1224 stat = rbuf_len; /* This is OK */
1226 * On IBM drives, they return ENOSPC at EOM
1227 * instead of EOF status
1229 } else if (at_eof() && errno == ENOSPC) {
1234 clrerror_dev(this, -1);
1235 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1237 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1238 print_name(), be.strerror());
1239 Dmsg1(100, "%s", errmsg);
1243 if (stat == 0) { /* EOF */
1244 update_pos_dev(this);
1245 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1246 /* Two reads of zero means end of tape */
1249 Dmsg0(100, "Set ST_EOT\n");
1255 } else { /* Got data */
1260 Dmsg0(100, "Doing MTFSF\n");
1261 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1262 if (stat < 0) { /* error => EOT */
1265 Dmsg0(100, "Set ST_EOT\n");
1266 clrerror_dev(this, MTFSF);
1267 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1268 print_name(), be.strerror());
1269 Dmsg0(100, "Got < 0 for MTFSF\n");
1270 Dmsg1(100, "%s", errmsg);
1278 * No FSF, so use FSR to simulate it
1281 Dmsg0(200, "Doing FSR for FSF\n");
1282 while (num-- && !at_eot()) {
1283 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1287 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1293 update_pos_dev(this);
1294 Dmsg1(200, "Return %d from FSF\n", stat);
1296 Dmsg0(200, "ST_EOF set on exit FSF\n");
1298 Dmsg0(200, "ST_EOT set on exit FSF\n");
1299 Dmsg1(200, "Return from FSF file=%d\n", file);
1304 * Backward space a file
1305 * Returns: false on failure
1309 bsf_dev(DEVICE *dev, int num)
1315 dev->dev_errno = EBADF;
1316 Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Device not open\n"));
1317 Emsg0(M_FATAL, 0, dev->errmsg);
1321 if (!dev->is_tape()) {
1322 Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1326 Dmsg0(29, "bsf_dev\n");
1327 dev->state &= ~(ST_EOT|ST_EOF);
1331 mt_com.mt_op = MTBSF;
1332 mt_com.mt_count = num;
1333 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1336 clrerror_dev(dev, MTBSF);
1337 Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1338 dev->print_name(), be.strerror());
1340 update_pos_dev(dev);
1346 * Foward space num records
1347 * Returns: false on failure
1350 bool DEVICE::fsr(int num)
1357 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1358 Emsg0(M_FATAL, 0, errmsg);
1365 if (!dev_cap(this, CAP_FSR)) {
1366 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1370 Dmsg1(29, "fsr %d\n", num);
1371 mt_com.mt_op = MTFSR;
1372 mt_com.mt_count = num;
1373 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1379 struct mtget mt_stat;
1380 clrerror_dev(this, MTFSR);
1381 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1382 if (dev_get_os_pos(this, &mt_stat)) {
1383 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1384 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1385 file = mt_stat.mt_fileno;
1386 block_num = mt_stat.mt_blkno;
1394 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1395 num, print_name(), be.strerror());
1397 update_pos_dev(this);
1402 * Backward space a record
1403 * Returns: false on failure
1407 bsr_dev(DEVICE *dev, int num)
1413 dev->dev_errno = EBADF;
1414 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1415 Emsg0(M_FATAL, 0, dev->errmsg);
1419 if (!dev->is_tape()) {
1423 if (!dev_cap(dev, CAP_BSR)) {
1424 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1428 Dmsg0(29, "bsr_dev\n");
1429 dev->block_num -= num;
1430 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1431 mt_com.mt_op = MTBSR;
1432 mt_com.mt_count = num;
1433 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1436 clrerror_dev(dev, MTBSR);
1437 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1438 dev->print_name(), be.strerror());
1440 update_pos_dev(dev);
1445 * Reposition the device to file, block
1446 * Returns: false on failure
1450 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1453 dev->dev_errno = EBADF;
1454 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1455 Emsg0(M_FATAL, 0, dev->errmsg);
1459 if (!dev->is_tape()) {
1460 off_t pos = (((off_t)file)<<32) + (off_t)block;
1461 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1462 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1464 dev->dev_errno = errno;
1465 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1466 dev->print_name(), be.strerror());
1470 dev->block_num = block;
1471 dev->file_addr = pos;
1474 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1475 dev->file, dev->block_num, file, block);
1476 if (file < dev->file) {
1477 Dmsg0(100, "Rewind_dev\n");
1478 if (!rewind_dev(dev)) {
1482 if (file > dev->file) {
1483 Dmsg1(100, "fsf %d\n", file-dev->file);
1484 if (!dev->fsf(file-dev->file)) {
1485 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1488 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1490 if (block < dev->block_num) {
1491 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1492 Dmsg0(100, "bsf_dev 1\n");
1494 Dmsg0(100, "fsf_dev 1\n");
1496 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1498 if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1499 /* Ignore errors as Bacula can read to the correct block */
1500 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1501 return dev->fsr(block-dev->block_num);
1509 * Write an end of file on the device
1510 * Returns: 0 on success
1511 * non-zero on failure
1514 weof_dev(DEVICE *dev, int num)
1518 Dmsg0(29, "weof_dev\n");
1521 dev->dev_errno = EBADF;
1522 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1523 Emsg0(M_FATAL, 0, dev->errmsg);
1528 if (!dev->is_tape()) {
1531 if (!dev->can_append()) {
1532 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1533 Emsg0(M_FATAL, 0, dev->errmsg);
1537 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1538 mt_com.mt_op = MTWEOF;
1539 mt_com.mt_count = num;
1540 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1547 clrerror_dev(dev, MTWEOF);
1549 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1550 dev->print_name(), be.strerror());
1557 * Return string message with last error in English
1558 * Be careful not to call this routine from within dev.c
1559 * while editing an Mmsg() or you will end up in a recursive
1560 * loop creating a Segmentation Violation.
1563 strerror_dev(DEVICE *dev)
1570 * If implemented in system, clear the tape
1574 clrerror_dev(DEVICE *dev, int func)
1576 const char *msg = NULL;
1577 struct mtget mt_stat;
1580 dev->dev_errno = errno; /* save errno */
1582 dev->VolCatInfo.VolCatErrors++;
1585 if (!dev->is_tape()) {
1588 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1591 Emsg0(M_ABORT, 0, _("Got ENOTTY on read/write!\n"));
1595 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1600 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1605 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1609 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1613 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1617 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1638 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1643 dev->dev_errno = ENOSYS;
1644 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1645 Emsg0(M_ERROR, 0, dev->errmsg);
1648 /* On some systems such as NetBSD, this clears all errors */
1649 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1651 /* Found on Linux */
1655 mt_com.mt_op = MTIOCLRERR;
1656 mt_com.mt_count = 1;
1657 /* Clear any error condition on the tape */
1658 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1659 Dmsg0(200, "Did MTIOCLRERR\n");
1663 /* Typically on FreeBSD */
1666 /* Read and clear SCSI error status */
1667 union mterrstat mt_errstat;
1668 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1669 strerror(dev->dev_errno));
1670 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1674 /* Clear Subsystem Exception OSF1 */
1678 mt_com.mt_op = MTCSE;
1679 mt_com.mt_count = 1;
1680 /* Clear any error condition on the tape */
1681 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1682 Dmsg0(200, "Did MTCSE\n");
1688 * Flush buffer contents
1691 int flush_dev(DEVICE *dev)
1696 static void do_close(DEVICE *dev)
1699 Dmsg1(29, "really close_dev %s\n", dev->print_name());
1704 if (!unmount_dev(dev, 1)) {
1705 Dmsg1(0, "Cannot unmount device %s.\n", dev->print_name());
1708 /* Remove the last part file if it is empty */
1709 if (dev->num_parts > 0) {
1711 POOL_MEM archive_name(PM_FNAME);
1712 dev->part = dev->num_parts;
1713 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", dev->VolCatInfo.VolCatName);
1714 make_spooled_dvd_filename(dev, archive_name);
1715 /* Check that the part file is empty */
1716 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1717 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1718 unlink(archive_name.c_str());
1722 /* Clean up device packet so it can be reused */
1724 dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1725 dev->label_type = B_BACULA_LABEL;
1726 dev->file = dev->block_num = 0;
1732 dev->part_start = 0;
1733 dev->EndFile = dev->EndBlock = 0;
1734 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1736 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1738 stop_thread_timer(dev->tid);
1748 void DEVICE::close()
1750 /*if (fd >= 0 && use_count == 1) {*/
1751 /* No need to check if fd >= 0: it is checked again
1752 * in do_close, and do_close MUST be called for volumes
1753 * splitted in parts, even if fd == -1. */
1754 if (use_count == 1) {
1756 } else if (use_count > 0) {
1761 ASSERT(use_count >= 0);
1766 bool truncate_dev(DCR *dcr) /* We need the DCR for DVD-writing */
1768 DEVICE *dev = dcr->dev;
1770 Dmsg1(100, "truncate_dev %s\n", dev->print_name());
1771 if (dev->is_tape()) {
1772 return true; /* we don't really truncate tapes */
1773 /* maybe we should rewind and write and eof ???? */
1776 if (dev->is_dvd()) {
1777 return truncate_dvd_dev(dcr);
1780 if (ftruncate(dev->fd, 0) != 0) {
1782 Mmsg2(dev->errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1783 dev->print_name(), be.strerror());
1789 /* Return the resource name for the device */
1790 const char *DEVICE::name() const
1792 return device->hdr.name;
1796 dev_vol_name(DEVICE *dev)
1798 return dev->VolCatInfo.VolCatName;
1801 uint32_t dev_block(DEVICE *dev)
1803 update_pos_dev(dev);
1804 return dev->block_num;
1807 uint32_t dev_file(DEVICE *dev)
1809 update_pos_dev(dev);
1814 * Free memory allocated for the device
1817 term_dev(DEVICE *dev)
1820 dev->dev_errno = EBADF;
1821 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1822 Emsg0(M_FATAL, 0, dev->errmsg);
1825 Dmsg1(29, "term_dev: %s\n", dev->print_name());
1827 if (dev->dev_name) {
1828 free_memory(dev->dev_name);
1829 dev->dev_name = NULL;
1831 if (dev->prt_name) {
1832 free_memory(dev->prt_name);
1833 dev->prt_name = NULL;
1836 free_pool_memory(dev->errmsg);
1839 pthread_mutex_destroy(&dev->mutex);
1840 pthread_cond_destroy(&dev->wait);
1841 pthread_cond_destroy(&dev->wait_next_vol);
1842 pthread_mutex_destroy(&dev->spool_mutex);
1843 rwl_destroy(&dev->lock);
1844 if (dev->attached_dcrs) {
1845 delete dev->attached_dcrs;
1846 dev->attached_dcrs = NULL;
1848 if (dev->state & ST_MALLOC) {
1849 free_pool_memory((POOLMEM *)dev);
1854 * This routine initializes the device wait timers
1856 void init_device_wait_timers(DCR *dcr)
1858 DEVICE *dev = dcr->dev;
1859 JCR *jcr = dcr->jcr;
1861 /* ******FIXME******* put these on config variables */
1862 dev->min_wait = 60 * 60;
1863 dev->max_wait = 24 * 60 * 60;
1864 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1865 dev->wait_sec = dev->min_wait;
1866 dev->rem_wait_sec = dev->wait_sec;
1869 dev->BadVolName[0] = 0;
1871 jcr->min_wait = 60 * 60;
1872 jcr->max_wait = 24 * 60 * 60;
1873 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1874 jcr->wait_sec = jcr->min_wait;
1875 jcr->rem_wait_sec = jcr->wait_sec;
1880 void init_jcr_device_wait_timers(JCR *jcr)
1882 /* ******FIXME******* put these on config variables */
1883 jcr->min_wait = 60 * 60;
1884 jcr->max_wait = 24 * 60 * 60;
1885 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1886 jcr->wait_sec = jcr->min_wait;
1887 jcr->rem_wait_sec = jcr->wait_sec;
1893 * The dev timers are used for waiting on a particular device
1895 * Returns: true if time doubled
1896 * false if max time expired
1898 bool double_dev_wait_time(DEVICE *dev)
1900 dev->wait_sec *= 2; /* double wait time */
1901 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
1902 dev->wait_sec = dev->max_wait;
1905 dev->rem_wait_sec = dev->wait_sec;
1906 if (dev->num_wait >= dev->max_num_wait) {
1913 void set_os_device_parameters(DEVICE *dev)
1915 #ifdef HAVE_LINUX_OS
1917 if (dev->min_block_size == dev->max_block_size &&
1918 dev->min_block_size == 0) { /* variable block mode */
1919 mt_com.mt_op = MTSETBLK;
1920 mt_com.mt_count = 0;
1921 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1922 clrerror_dev(dev, MTSETBLK);
1924 mt_com.mt_op = MTSETDRVBUFFER;
1925 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
1926 if (!dev_cap(dev, CAP_TWOEOF)) {
1927 mt_com.mt_count |= MT_ST_TWO_FM;
1929 if (dev_cap(dev, CAP_EOM)) {
1930 mt_com.mt_count |= MT_ST_FAST_MTEOM;
1932 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1933 clrerror_dev(dev, MTSETBLK);
1939 #ifdef HAVE_NETBSD_OS
1941 if (dev->min_block_size == dev->max_block_size &&
1942 dev->min_block_size == 0) { /* variable block mode */
1943 mt_com.mt_op = MTSETBSIZ;
1944 mt_com.mt_count = 0;
1945 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1946 clrerror_dev(dev, MTSETBSIZ);
1948 /* Get notified at logical end of tape */
1949 mt_com.mt_op = MTEWARN;
1950 mt_com.mt_count = 1;
1951 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1952 clrerror_dev(dev, MTEWARN);
1958 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
1960 if (dev->min_block_size == dev->max_block_size &&
1961 dev->min_block_size == 0) { /* variable block mode */
1962 mt_com.mt_op = MTSETBSIZ;
1963 mt_com.mt_count = 0;
1964 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1965 clrerror_dev(dev, MTSETBSIZ);
1973 if (dev->min_block_size == dev->max_block_size &&
1974 dev->min_block_size == 0) { /* variable block mode */
1975 mt_com.mt_op = MTSRSZ;
1976 mt_com.mt_count = 0;
1977 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1978 clrerror_dev(dev, MTSRSZ);
1985 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
1987 return dev_cap(dev, CAP_MTIOCGET) &&
1988 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
1989 mt_stat->mt_fileno >= 0;
1992 static char *modes[] = {
1993 "CREATE_READ_WRITE",
2000 static char *mode_to_str(int mode)
2002 return modes[mode-1];