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(dcr, 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"));
315 * If the flage open_nowait is set, which is the case
316 * when the daemon is initially trying to open the device,
317 * we open it with O_NONBLOCK set and O_RONLY, which will
318 * allow us to open normal Linux tape drives with no tape
319 * in the drive without blocking. We then immediately
320 * set blocking status so that if we read from the device they
321 * will be normal blocking reads.
323 * If later, we want to write on the device, it will be freed and
324 * reopened, but hopefully there will be a tape in the drive so
327 void DEVICE::open_tape_device(DCR *dcr, int omode)
329 int nonblocking = 0;;
333 Dmsg0(29, "open dev: device is tape\n");
335 if (is_tape() && is_autochanger()) {
336 get_autochanger_loaded_slot(dcr);
340 timeout = max_open_wait;
343 /* Set wait counters to zero for no wait */
344 timeout = ioerrcnt = 0;
345 /* Open drive in non-block mode */
346 nonblocking = O_NONBLOCK;
348 if (is_fifo() && timeout) {
350 tid = start_thread_timer(pthread_self(), timeout);
352 /* If busy retry each second for max_open_wait seconds */
353 Dmsg3(100, "Try open %s mode=%s nonblocking=%d\n", print_name(),
354 mode_to_str(omode), nonblocking);
355 /* Use system open() */
356 while ((fd = ::open(dev_name, mode+nonblocking, MODE_RW)) < 0) {
358 Dmsg2(100, "Open error errno=%d ERR=%s\n", errno, be.strerror());
359 if (errno == EINTR || errno == EAGAIN) {
360 Dmsg0(100, "Continue open\n");
363 /* Busy wait for specified time (default = 5 mins) */
364 if (errno == EBUSY && timeout-- > 0) {
365 Dmsg2(100, "Device %s busy. ERR=%s\n", print_name(), be.strerror());
369 /* IO error (no volume) try 10 times every 6 seconds */
370 if (errno == EIO && ioerrcnt-- > 0) {
372 Dmsg0(100, "Continue open\n");
376 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
377 print_name(), be.strerror(dev_errno));
378 /* Stop any open timer we set */
380 stop_thread_timer(tid);
383 Emsg0(M_FATAL, 0, errmsg);
386 /* Really an if, but we use a break for an error exit */
388 /* If opened in non-block mode, make it block now */
392 /* Try to reset blocking */
393 if ((oflags = fcntl(fd, F_GETFL, 0)) < 0 ||
394 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK) < 0) {
396 Jmsg1(dcr->jcr, M_ERROR, 0, _("fcntl error. ERR=%s\n"), be.strerror());
397 ::close(fd); /* use system close() */
402 openmode = omode; /* save open mode */
403 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
407 update_pos_dev(this); /* update position */
408 set_os_device_parameters(this); /* do system dependent stuff */
409 Dmsg0(500, "Open OK\n");
412 /* Stop any open() timer we started */
414 stop_thread_timer(tid);
417 Dmsg1(29, "open dev: tape %d opened\n", fd);
423 void DEVICE::open_file_device(int omode)
425 POOL_MEM archive_name(PM_FNAME);
428 * Handle opening of File Archive (not a tape)
430 Dmsg3(29, "Enter: open_file_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
431 archive_name.c_str(), mode_to_str(omode));
433 if (VolCatInfo.VolCatName[0] == 0) {
434 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
440 pm_strcpy(archive_name, dev_name);
441 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
442 pm_strcat(archive_name, "/");
444 pm_strcat(archive_name, VolCatInfo.VolCatName);
446 Dmsg3(29, "open dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
447 archive_name.c_str(), mode_to_str(omode));
449 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
452 /* If creating file, give 0640 permissions */
453 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
454 archive_name.c_str(), mode);
455 /* Use system open() */
456 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
459 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
461 Dmsg1(29, "open failed: %s", errmsg);
462 Emsg0(M_FATAL, 0, errmsg);
467 update_pos_dev(this); /* update position */
469 Dmsg5(29, "open dev: %s fd=%d opened, part=%d/%d, part_size=%u\n",
470 is_dvd()?"DVD":"disk", fd, part, num_parts,
475 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName (NB:??? I think it's VolCatInfo.VolCatName that is right)
476 * has the desired Volume name, but there is NO assurance that
477 * any other field of VolCatInfo is correct.
479 void DEVICE::open_dvd_device(DCR *dcr, int omode)
481 POOL_MEM archive_name(PM_FNAME);
482 struct stat filestat;
485 * Handle opening of DVD Volume
487 Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
488 archive_name.c_str(), mode_to_str(omode));
490 if (VolCatInfo.VolCatName[0] == 0) {
491 Dmsg1(10, "Could not open file device %s. No Volume name given.\n",
493 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
504 Dmsg2(99, "open_dvd_device: num_parts=%d, VolCatInfo.VolCatParts=%d\n",
505 dcr->dev->num_parts, dcr->VolCatInfo.VolCatParts);
506 if (dcr->dev->num_parts < dcr->VolCatInfo.VolCatParts) {
507 Dmsg2(99, "open_dvd_device: num_parts updated to %d (was %d)\n",
508 dcr->VolCatInfo.VolCatParts, dcr->dev->num_parts);
509 dcr->dev->num_parts = dcr->VolCatInfo.VolCatParts;
512 if (mount_dev(this, 1)) {
513 if ((num_parts == 0) && (!truncating)) {
514 /* If we can mount the device, and we are not truncating the DVD, we usually want to abort. */
515 /* There is one exception, if there is only one 0-sized file on the DVD, with the right volume name,
516 * we continue (it's the method used by truncate_dvd_dev to truncate a volume). */
517 if (!check_can_write_on_non_blank_dvd(dcr)) {
518 Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
519 Emsg0(M_FATAL, 0, errmsg);
526 /* We cannot mount the device */
527 if (num_parts == 0) {
528 /* Run free space, check there is a media. */
529 update_free_space_dev(this);
531 Dmsg1(29, "Could not mount device %s, this is not a problem (num_parts == 0), and have media.\n", print_name());
534 Mmsg(errmsg, _("There is no valid media in the device %s.\n"), print_name());
535 Emsg0(M_FATAL, 0, errmsg);
541 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
542 Emsg0(M_FATAL, 0, errmsg);
548 Dmsg6(29, "open dev: %s dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
549 is_dvd()?"DVD":"disk", archive_name.c_str(), mode_to_str(omode),
550 part, num_parts, dcr->VolCatInfo.VolCatParts);
552 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
555 * If we are not trying to access the last part, set mode to
556 * OPEN_READ_ONLY as writing would be an error.
558 if (part < num_parts) {
559 omode = OPEN_READ_ONLY;
560 make_mounted_dvd_filename(this, archive_name);
563 make_spooled_dvd_filename(this, archive_name);
567 /* If creating file, give 0640 permissions */
568 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
569 archive_name.c_str(), mode);
570 /* Use system open() */
571 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
573 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
575 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
576 Dmsg1(29, "open failed: %s", errmsg);
578 if ((omode == OPEN_READ_ONLY) && (part == num_parts)) {
579 /* If the last part (on spool), doesn't exists when reading, create it and read from it
580 * (it will report immediately an EOF):
581 * Sometimes it is better to finish with an EOF than with an error. */
582 set_mode(OPEN_READ_WRITE);
583 fd = ::open(archive_name.c_str(), mode, 0640);
584 set_mode(OPEN_READ_ONLY);
587 /* We don't need it. Only the last part is on spool */
588 /*if (omode == OPEN_READ_ONLY) {
589 make_spooled_dvd_filename(this, archive_name);
590 fd = ::open(archive_name.c_str(), mode, 0640); // try on spool
593 Dmsg1(100, "after open fd=%d\n", fd);
595 /* Get size of file */
596 if (fstat(fd, &filestat) < 0) {
599 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
601 Dmsg1(29, "open failed: %s", errmsg);
602 /* Use system close() */
606 part_size = filestat.st_size;
610 update_pos_dev(this); /* update position */
612 /* NB: It seems this code is wrong... part number is incremented in open_next_part, not here */
614 /* Check if just created Volume part */
615 /* if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
618 VolCatInfo.VolCatParts = num_parts;
620 if (part == 0) { // we must have opened the first part
631 bool _rewind_dev(char *file, int line, DEVICE *dev)
633 Dmsg3(100, "rewind_dev fd=%d called from %s:%d\n", dev->fd, file, line);
634 return rewind_dev(dev);
640 * Returns: true on success
643 bool rewind_dev(DEVICE *dev)
648 Dmsg2(29, "rewind_dev fd=%d %s\n", dev->fd, dev->print_name());
650 if (!dev->is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
651 dev->dev_errno = EBADF;
652 Mmsg1(dev->errmsg, _("Bad call to rewind_dev. Device %s not open\n"),
654 Emsg0(M_ABORT, 0, dev->errmsg);
658 dev->state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
659 dev->block_num = dev->file = 0;
662 if (dev->is_tape()) {
663 mt_com.mt_op = MTREW;
665 /* If we get an I/O error on rewind, it is probably because
666 * the drive is actually busy. We loop for (about 5 minutes)
667 * retrying every 5 seconds.
669 for (i=dev->max_rewind_wait; ; i -= 5) {
670 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
672 clrerror_dev(dev, MTREW);
673 if (i == dev->max_rewind_wait) {
674 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
676 if (dev->dev_errno == EIO && i > 0) {
677 Dmsg0(200, "Sleeping 5 seconds.\n");
681 Mmsg2(dev->errmsg, _("Rewind error on %s. ERR=%s.\n"),
682 dev->print_name(), be.strerror());
687 } else if (dev->is_file()) {
688 if (lseek_dev(dev, (off_t)0, SEEK_SET) < 0) {
690 dev->dev_errno = errno;
691 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
692 dev->print_name(), be.strerror());
699 void DEVICE::block(int why)
702 block_device(this, why);
706 void DEVICE::unblock()
709 unblock_device(this);
713 const char *DEVICE::print_blocked() const
715 switch (dev_blocked) {
716 case BST_NOT_BLOCKED:
717 return "BST_NOT_BLOCKED";
719 return "BST_UNMOUNTED";
720 case BST_WAITING_FOR_SYSOP:
721 return "BST_WAITING_FOR_SYSOP";
722 case BST_DOING_ACQUIRE:
723 return "BST_DOING_ACQUIRE";
724 case BST_WRITING_LABEL:
725 return "BST_WRITING_LABEL";
726 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
727 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
731 return _("unknown blocked code");
736 * Called to indicate that we have just read an
737 * EOF from the device.
739 void DEVICE::set_ateof()
749 * Called to indicate we are now at the end of the tape, and
750 * writing is not possible.
752 void DEVICE::set_ateot()
754 /* Make tape effectively read-only */
755 state |= (ST_EOF|ST_EOT|ST_WEOT);
760 * Position device to end of medium (end of data)
761 * Returns: true on succes
768 struct mtget mt_stat;
773 dev->dev_errno = EBADF;
774 Mmsg1(dev->errmsg, _("Bad call to eod_dev. Device %s not open\n"),
779 #if defined (__digital__) && defined (__unix__)
780 return dev->fsf(dev->VolCatInfo.VolCatFiles);
783 Dmsg0(29, "eod_dev\n");
787 dev->state &= ~(ST_EOF); /* remove EOF flags */
788 dev->block_num = dev->file = 0;
791 if (dev->state & (ST_FIFO | ST_PROG)) {
794 if (!dev->is_tape()) {
795 pos = lseek_dev(dev, (off_t)0, SEEK_END);
796 // Dmsg1(100, "====== Seek to %lld\n", pos);
799 dev->state |= ST_EOT;
802 dev->dev_errno = errno;
804 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
805 dev->print_name(), be.strerror());
809 if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
810 Dmsg0(100,"Using FAST FSF for EOM\n");
811 /* If unknown position, rewind */
812 if (!dev_get_os_pos(dev, &mt_stat)) {
813 if (!rewind_dev(dev)) {
817 mt_com.mt_op = MTFSF;
819 * ***FIXME*** fix code to handle case that INT16_MAX is
822 mt_com.mt_count = INT16_MAX; /* use big positive number */
823 if (mt_com.mt_count < 0) {
824 mt_com.mt_count = INT16_MAX; /* brain damaged system */
828 if (dev_cap(dev, CAP_MTIOCGET) && (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM))) {
829 if (dev_cap(dev, CAP_EOM)) {
830 Dmsg0(100,"Using EOM for EOM\n");
831 mt_com.mt_op = MTEOM;
835 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
837 clrerror_dev(dev, mt_com.mt_op);
838 Dmsg1(50, "ioctl error: %s\n", be.strerror());
840 Mmsg2(dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
841 dev->print_name(), be.strerror());
845 if (!dev_get_os_pos(dev, &mt_stat)) {
847 clrerror_dev(dev, -1);
848 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
849 dev->print_name(), be.strerror());
852 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
854 dev->file = mt_stat.mt_fileno;
860 * Rewind then use FSF until EOT reached
862 if (!rewind_dev(dev)) {
866 * Move file by file to the end of the tape
869 for (file_num=dev->file; !dev->at_eot(); file_num++) {
870 Dmsg0(200, "eod_dev: doing fsf 1\n");
872 Dmsg0(200, "fsf error.\n");
876 * Avoid infinite loop. ***FIXME*** possibly add code
877 * to set EOD or to turn off CAP_FASTFSF if on.
879 if (file_num == (int)dev->file) {
880 struct mtget mt_stat;
881 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
882 if (dev_get_os_pos(dev, &mt_stat)) {
883 Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
885 dev->file = mt_stat.mt_fileno;
892 * Some drivers leave us after second EOF when doing
893 * MTEOM, so we must backup so that appending overwrites
896 if (dev_cap(dev, CAP_BSFATEOM)) {
897 struct mtget mt_stat;
898 /* Backup over EOF */
899 ok = bsf_dev(dev, 1);
900 /* If BSF worked and fileno is known (not -1), set file */
901 if (dev_get_os_pos(dev, &mt_stat)) {
902 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
903 dev->file = mt_stat.mt_fileno;
905 dev->file++; /* wing it -- not correct on all OSes */
908 update_pos_dev(dev); /* update position */
910 Dmsg1(200, "EOD dev->file=%d\n", dev->file);
915 * Set the position of the device -- only for files and DVD
916 * For other devices, there is no generic way to do it.
917 * Returns: true on succes
920 bool update_pos_dev(DEVICE *dev)
926 dev->dev_errno = EBADF;
927 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
928 Emsg0(M_FATAL, 0, dev->errmsg);
932 /* Find out where we are */
933 if (dev->is_file()) {
936 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
939 dev->dev_errno = errno;
940 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
941 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
942 dev->print_name(), be.strerror());
945 dev->file_addr = pos;
953 * Return the status of the device. This was meant
954 * to be a generic routine. Unfortunately, it doesn't
955 * seem possible (at least I do not know how to do it
956 * currently), which means that for the moment, this
957 * routine has very little value.
961 uint32_t status_dev(DEVICE *dev)
963 struct mtget mt_stat;
966 if (dev->state & (ST_EOT | ST_WEOT)) {
970 if (dev->state & ST_EOF) {
974 if (dev->is_tape()) {
976 Pmsg0(-20,_(" Bacula status:"));
977 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
978 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
980 dev->dev_errno = errno;
981 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
982 dev->print_name(), be.strerror());
985 Pmsg0(-20, _(" Device status:"));
987 #if defined(HAVE_LINUX_OS)
988 if (GMT_EOF(mt_stat.mt_gstat)) {
992 if (GMT_BOT(mt_stat.mt_gstat)) {
996 if (GMT_EOT(mt_stat.mt_gstat)) {
1000 if (GMT_SM(mt_stat.mt_gstat)) {
1004 if (GMT_EOD(mt_stat.mt_gstat)) {
1008 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1009 stat |= BMT_WR_PROT;
1010 Pmsg0(-20, " WR_PROT");
1012 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1014 Pmsg0(-20, " ONLINE");
1016 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1017 stat |= BMT_DR_OPEN;
1018 Pmsg0(-20, " DR_OPEN");
1020 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1021 stat |= BMT_IM_REP_EN;
1022 Pmsg0(-20, " IM_REP_EN");
1024 #endif /* !SunOS && !OSF */
1025 if (dev_cap(dev, CAP_MTIOCGET)) {
1026 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1028 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1031 stat |= BMT_ONLINE | BMT_BOT;
1038 * Load medium in device
1039 * Returns: true on success
1042 bool load_dev(DEVICE *dev)
1049 dev->dev_errno = EBADF;
1050 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1051 Emsg0(M_FATAL, 0, dev->errmsg);
1054 if (!(dev->is_tape())) {
1058 Dmsg0(200, "stored: MTLOAD command not available\n");
1060 dev->dev_errno = ENOTTY; /* function not available */
1061 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1062 dev->print_name(), be.strerror());
1066 dev->block_num = dev->file = 0;
1069 mt_com.mt_op = MTLOAD;
1070 mt_com.mt_count = 1;
1071 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1073 dev->dev_errno = errno;
1074 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1075 dev->print_name(), be.strerror());
1083 * Rewind device and put it offline
1084 * Returns: true on success
1087 bool offline_dev(DEVICE *dev)
1091 if (!dev || dev->fd < 0 || !dev->is_tape()) {
1092 return true; /* device not open */
1095 dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1096 dev->block_num = dev->file = 0;
1101 mt_com.mt_op = MTUNLOCK;
1102 mt_com.mt_count = 1;
1103 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1105 mt_com.mt_op = MTOFFL;
1106 mt_com.mt_count = 1;
1107 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1109 dev->dev_errno = errno;
1110 Mmsg2(dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1111 dev->print_name(), be.strerror());
1114 Dmsg1(100, "Offlined device %s\n", dev->print_name());
1118 bool offline_or_rewind_dev(DEVICE *dev)
1123 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1124 return offline_dev(dev);
1127 * Note, this rewind probably should not be here (it wasn't
1128 * in prior versions of Bacula), but on FreeBSD, this is
1129 * needed in the case the tape was "frozen" due to an error
1130 * such as backspacing after writing and EOF. If it is not
1131 * done, all future references to the drive get and I/O error.
1133 clrerror_dev(dev, MTREW);
1134 return rewind_dev(dev);
1139 * Foward space a file
1140 * Returns: true on success
1143 bool DEVICE::fsf(int num)
1145 struct mtget mt_stat;
1151 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1152 Emsg0(M_FATAL, 0, errmsg);
1161 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1165 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1168 Dmsg0(100, "fsf\n");
1171 * If Fast forward space file is set, then we
1172 * use MTFSF to forward space and MTIOCGET
1173 * to get the file position. We assume that
1174 * the SCSI driver will ensure that we do not
1175 * forward space past the end of the medium.
1177 if (dev_cap(this, CAP_FSF) && dev_cap(this, CAP_MTIOCGET) && dev_cap(this, CAP_FASTFSF)) {
1178 mt_com.mt_op = MTFSF;
1179 mt_com.mt_count = num;
1180 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1181 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1184 Dmsg0(200, "Set ST_EOT\n");
1185 clrerror_dev(this, MTFSF);
1186 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1187 print_name(), be.strerror());
1188 Dmsg1(200, "%s", errmsg);
1191 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1193 file = mt_stat.mt_fileno;
1197 * Here if CAP_FSF is set, and virtually all drives
1198 * these days support it, we read a record, then forward
1199 * space one file. Using this procedure, which is slow,
1200 * is the only way we can be sure that we don't read
1201 * two consecutive EOF marks, which means End of Data.
1203 } else if (dev_cap(this, CAP_FSF)) {
1206 Dmsg0(200, "FSF has cap_fsf\n");
1207 if (max_block_size == 0) {
1208 rbuf_len = DEFAULT_BLOCK_SIZE;
1210 rbuf_len = max_block_size;
1212 rbuf = get_memory(rbuf_len);
1213 mt_com.mt_op = MTFSF;
1214 mt_com.mt_count = 1;
1215 while (num-- && !at_eot()) {
1216 Dmsg0(100, "Doing read before fsf\n");
1217 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1218 if (errno == ENOMEM) { /* tape record exceeds buf len */
1219 stat = rbuf_len; /* This is OK */
1221 * On IBM drives, they return ENOSPC at EOM
1222 * instead of EOF status
1224 } else if (at_eof() && errno == ENOSPC) {
1229 clrerror_dev(this, -1);
1230 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1232 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1233 print_name(), be.strerror());
1234 Dmsg1(100, "%s", errmsg);
1238 if (stat == 0) { /* EOF */
1239 update_pos_dev(this);
1240 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1241 /* Two reads of zero means end of tape */
1244 Dmsg0(100, "Set ST_EOT\n");
1250 } else { /* Got data */
1255 Dmsg0(100, "Doing MTFSF\n");
1256 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1257 if (stat < 0) { /* error => EOT */
1260 Dmsg0(100, "Set ST_EOT\n");
1261 clrerror_dev(this, MTFSF);
1262 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1263 print_name(), be.strerror());
1264 Dmsg0(100, "Got < 0 for MTFSF\n");
1265 Dmsg1(100, "%s", errmsg);
1273 * No FSF, so use FSR to simulate it
1276 Dmsg0(200, "Doing FSR for FSF\n");
1277 while (num-- && !at_eot()) {
1278 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1282 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1288 update_pos_dev(this);
1289 Dmsg1(200, "Return %d from FSF\n", stat);
1291 Dmsg0(200, "ST_EOF set on exit FSF\n");
1293 Dmsg0(200, "ST_EOT set on exit FSF\n");
1294 Dmsg1(200, "Return from FSF file=%d\n", file);
1299 * Backward space a file
1300 * Returns: false on failure
1304 bsf_dev(DEVICE *dev, int num)
1310 dev->dev_errno = EBADF;
1311 Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Device not open\n"));
1312 Emsg0(M_FATAL, 0, dev->errmsg);
1316 if (!dev->is_tape()) {
1317 Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1321 Dmsg0(29, "bsf_dev\n");
1322 dev->state &= ~(ST_EOT|ST_EOF);
1326 mt_com.mt_op = MTBSF;
1327 mt_com.mt_count = num;
1328 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1331 clrerror_dev(dev, MTBSF);
1332 Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1333 dev->print_name(), be.strerror());
1335 update_pos_dev(dev);
1341 * Foward space num records
1342 * Returns: false on failure
1345 bool DEVICE::fsr(int num)
1352 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1353 Emsg0(M_FATAL, 0, errmsg);
1360 if (!dev_cap(this, CAP_FSR)) {
1361 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1365 Dmsg1(29, "fsr %d\n", num);
1366 mt_com.mt_op = MTFSR;
1367 mt_com.mt_count = num;
1368 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1374 struct mtget mt_stat;
1375 clrerror_dev(this, MTFSR);
1376 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1377 if (dev_get_os_pos(this, &mt_stat)) {
1378 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1379 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1380 file = mt_stat.mt_fileno;
1381 block_num = mt_stat.mt_blkno;
1389 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1390 num, print_name(), be.strerror());
1392 update_pos_dev(this);
1397 * Backward space a record
1398 * Returns: false on failure
1402 bsr_dev(DEVICE *dev, int num)
1408 dev->dev_errno = EBADF;
1409 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1410 Emsg0(M_FATAL, 0, dev->errmsg);
1414 if (!dev->is_tape()) {
1418 if (!dev_cap(dev, CAP_BSR)) {
1419 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1423 Dmsg0(29, "bsr_dev\n");
1424 dev->block_num -= num;
1425 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1426 mt_com.mt_op = MTBSR;
1427 mt_com.mt_count = num;
1428 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1431 clrerror_dev(dev, MTBSR);
1432 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1433 dev->print_name(), be.strerror());
1435 update_pos_dev(dev);
1440 * Reposition the device to file, block
1441 * Returns: false on failure
1445 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1448 dev->dev_errno = EBADF;
1449 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1450 Emsg0(M_FATAL, 0, dev->errmsg);
1454 if (!dev->is_tape()) {
1455 off_t pos = (((off_t)file)<<32) + (off_t)block;
1456 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1457 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1459 dev->dev_errno = errno;
1460 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1461 dev->print_name(), be.strerror());
1465 dev->block_num = block;
1466 dev->file_addr = pos;
1469 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1470 dev->file, dev->block_num, file, block);
1471 if (file < dev->file) {
1472 Dmsg0(100, "Rewind_dev\n");
1473 if (!rewind_dev(dev)) {
1477 if (file > dev->file) {
1478 Dmsg1(100, "fsf %d\n", file-dev->file);
1479 if (!dev->fsf(file-dev->file)) {
1480 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1483 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1485 if (block < dev->block_num) {
1486 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1487 Dmsg0(100, "bsf_dev 1\n");
1489 Dmsg0(100, "fsf_dev 1\n");
1491 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1493 if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1494 /* Ignore errors as Bacula can read to the correct block */
1495 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1496 return dev->fsr(block-dev->block_num);
1504 * Write an end of file on the device
1505 * Returns: 0 on success
1506 * non-zero on failure
1509 weof_dev(DEVICE *dev, int num)
1513 Dmsg0(29, "weof_dev\n");
1516 dev->dev_errno = EBADF;
1517 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1518 Emsg0(M_FATAL, 0, dev->errmsg);
1523 if (!dev->is_tape()) {
1526 if (!dev->can_append()) {
1527 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1528 Emsg0(M_FATAL, 0, dev->errmsg);
1532 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1533 mt_com.mt_op = MTWEOF;
1534 mt_com.mt_count = num;
1535 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1542 clrerror_dev(dev, MTWEOF);
1544 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1545 dev->print_name(), be.strerror());
1552 * Return string message with last error in English
1553 * Be careful not to call this routine from within dev.c
1554 * while editing an Mmsg() or you will end up in a recursive
1555 * loop creating a Segmentation Violation.
1558 strerror_dev(DEVICE *dev)
1565 * If implemented in system, clear the tape
1569 clrerror_dev(DEVICE *dev, int func)
1571 const char *msg = NULL;
1572 struct mtget mt_stat;
1575 dev->dev_errno = errno; /* save errno */
1577 dev->VolCatInfo.VolCatErrors++;
1580 if (!dev->is_tape()) {
1583 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1586 Emsg0(M_ABORT, 0, _("Got ENOTTY on read/write!\n"));
1590 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1595 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1600 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1604 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1608 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1612 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1633 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1638 dev->dev_errno = ENOSYS;
1639 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1640 Emsg0(M_ERROR, 0, dev->errmsg);
1643 /* On some systems such as NetBSD, this clears all errors */
1644 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1646 /* Found on Linux */
1650 mt_com.mt_op = MTIOCLRERR;
1651 mt_com.mt_count = 1;
1652 /* Clear any error condition on the tape */
1653 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1654 Dmsg0(200, "Did MTIOCLRERR\n");
1658 /* Typically on FreeBSD */
1661 /* Read and clear SCSI error status */
1662 union mterrstat mt_errstat;
1663 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1664 strerror(dev->dev_errno));
1665 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1669 /* Clear Subsystem Exception OSF1 */
1673 mt_com.mt_op = MTCSE;
1674 mt_com.mt_count = 1;
1675 /* Clear any error condition on the tape */
1676 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1677 Dmsg0(200, "Did MTCSE\n");
1683 * Flush buffer contents
1686 int flush_dev(DEVICE *dev)
1691 static void do_close(DEVICE *dev)
1694 Dmsg1(29, "really close_dev %s\n", dev->print_name());
1699 if (!unmount_dev(dev, 1)) {
1700 Dmsg1(0, "Cannot unmount device %s.\n", dev->print_name());
1703 /* Remove the last part file if it is empty */
1704 if (dev->num_parts > 0) {
1706 POOL_MEM archive_name(PM_FNAME);
1707 dev->part = dev->num_parts;
1708 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", dev->VolCatInfo.VolCatName);
1709 make_spooled_dvd_filename(dev, archive_name);
1710 /* Check that the part file is empty */
1711 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1712 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1713 unlink(archive_name.c_str());
1717 /* Clean up device packet so it can be reused */
1719 dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1720 dev->label_type = B_BACULA_LABEL;
1721 dev->file = dev->block_num = 0;
1727 dev->part_start = 0;
1728 dev->EndFile = dev->EndBlock = 0;
1729 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1731 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1733 stop_thread_timer(dev->tid);
1743 void DEVICE::close()
1745 /*if (fd >= 0 && use_count == 1) {*/
1746 /* No need to check if fd >= 0: it is checked again
1747 * in do_close, and do_close MUST be called for volumes
1748 * splitted in parts, even if fd == -1. */
1749 if (use_count == 1) {
1751 } else if (use_count > 0) {
1756 ASSERT(use_count >= 0);
1761 bool truncate_dev(DCR *dcr) /* We need the DCR for DVD-writing */
1763 DEVICE *dev = dcr->dev;
1765 Dmsg1(100, "truncate_dev %s\n", dev->print_name());
1766 if (dev->is_tape()) {
1767 return true; /* we don't really truncate tapes */
1768 /* maybe we should rewind and write and eof ???? */
1771 if (dev->is_dvd()) {
1772 return truncate_dvd_dev(dcr);
1775 if (ftruncate(dev->fd, 0) != 0) {
1777 Mmsg2(dev->errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1778 dev->print_name(), be.strerror());
1784 /* Return the resource name for the device */
1785 const char *DEVICE::name() const
1787 return device->hdr.name;
1791 dev_vol_name(DEVICE *dev)
1793 return dev->VolCatInfo.VolCatName;
1796 uint32_t dev_block(DEVICE *dev)
1798 update_pos_dev(dev);
1799 return dev->block_num;
1802 uint32_t dev_file(DEVICE *dev)
1804 update_pos_dev(dev);
1809 * Free memory allocated for the device
1812 term_dev(DEVICE *dev)
1815 dev->dev_errno = EBADF;
1816 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1817 Emsg0(M_FATAL, 0, dev->errmsg);
1820 Dmsg1(29, "term_dev: %s\n", dev->print_name());
1822 if (dev->dev_name) {
1823 free_memory(dev->dev_name);
1824 dev->dev_name = NULL;
1826 if (dev->prt_name) {
1827 free_memory(dev->prt_name);
1828 dev->prt_name = NULL;
1831 free_pool_memory(dev->errmsg);
1834 pthread_mutex_destroy(&dev->mutex);
1835 pthread_cond_destroy(&dev->wait);
1836 pthread_cond_destroy(&dev->wait_next_vol);
1837 pthread_mutex_destroy(&dev->spool_mutex);
1838 rwl_destroy(&dev->lock);
1839 if (dev->attached_dcrs) {
1840 delete dev->attached_dcrs;
1841 dev->attached_dcrs = NULL;
1843 if (dev->state & ST_MALLOC) {
1844 free_pool_memory((POOLMEM *)dev);
1849 * This routine initializes the device wait timers
1851 void init_device_wait_timers(DCR *dcr)
1853 DEVICE *dev = dcr->dev;
1854 JCR *jcr = dcr->jcr;
1856 /* ******FIXME******* put these on config variables */
1857 dev->min_wait = 60 * 60;
1858 dev->max_wait = 24 * 60 * 60;
1859 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1860 dev->wait_sec = dev->min_wait;
1861 dev->rem_wait_sec = dev->wait_sec;
1864 dev->BadVolName[0] = 0;
1866 jcr->min_wait = 60 * 60;
1867 jcr->max_wait = 24 * 60 * 60;
1868 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1869 jcr->wait_sec = jcr->min_wait;
1870 jcr->rem_wait_sec = jcr->wait_sec;
1875 void init_jcr_device_wait_timers(JCR *jcr)
1877 /* ******FIXME******* put these on config variables */
1878 jcr->min_wait = 60 * 60;
1879 jcr->max_wait = 24 * 60 * 60;
1880 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1881 jcr->wait_sec = jcr->min_wait;
1882 jcr->rem_wait_sec = jcr->wait_sec;
1888 * The dev timers are used for waiting on a particular device
1890 * Returns: true if time doubled
1891 * false if max time expired
1893 bool double_dev_wait_time(DEVICE *dev)
1895 dev->wait_sec *= 2; /* double wait time */
1896 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
1897 dev->wait_sec = dev->max_wait;
1900 dev->rem_wait_sec = dev->wait_sec;
1901 if (dev->num_wait >= dev->max_num_wait) {
1908 void set_os_device_parameters(DEVICE *dev)
1910 #ifdef HAVE_LINUX_OS
1912 if (dev->min_block_size == dev->max_block_size &&
1913 dev->min_block_size == 0) { /* variable block mode */
1914 mt_com.mt_op = MTSETBLK;
1915 mt_com.mt_count = 0;
1916 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1917 clrerror_dev(dev, MTSETBLK);
1919 mt_com.mt_op = MTSETDRVBUFFER;
1920 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
1921 if (!dev_cap(dev, CAP_TWOEOF)) {
1922 mt_com.mt_count |= MT_ST_TWO_FM;
1924 if (dev_cap(dev, CAP_EOM)) {
1925 mt_com.mt_count |= MT_ST_FAST_MTEOM;
1927 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1928 clrerror_dev(dev, MTSETBLK);
1934 #ifdef HAVE_NETBSD_OS
1936 if (dev->min_block_size == dev->max_block_size &&
1937 dev->min_block_size == 0) { /* variable block mode */
1938 mt_com.mt_op = MTSETBSIZ;
1939 mt_com.mt_count = 0;
1940 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1941 clrerror_dev(dev, MTSETBSIZ);
1943 /* Get notified at logical end of tape */
1944 mt_com.mt_op = MTEWARN;
1945 mt_com.mt_count = 1;
1946 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1947 clrerror_dev(dev, MTEWARN);
1953 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
1955 if (dev->min_block_size == dev->max_block_size &&
1956 dev->min_block_size == 0) { /* variable block mode */
1957 mt_com.mt_op = MTSETBSIZ;
1958 mt_com.mt_count = 0;
1959 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1960 clrerror_dev(dev, MTSETBSIZ);
1968 if (dev->min_block_size == dev->max_block_size &&
1969 dev->min_block_size == 0) { /* variable block mode */
1970 mt_com.mt_op = MTSRSZ;
1971 mt_com.mt_count = 0;
1972 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1973 clrerror_dev(dev, MTSRSZ);
1980 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
1982 return dev_cap(dev, CAP_MTIOCGET) &&
1983 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
1984 mt_stat->mt_fileno >= 0;
1987 static char *modes[] = {
1988 "CREATE_READ_WRITE",
1995 static char *mode_to_str(int mode)
1997 return modes[mode-1];