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)
1092 dev->dev_errno = EBADF;
1093 Mmsg0(dev->errmsg, _("Bad call to offline_dev. Device not open\n"));
1094 Emsg0(M_FATAL, 0, dev->errmsg);
1097 if (!(dev->is_tape())) {
1101 dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1102 dev->block_num = dev->file = 0;
1107 mt_com.mt_op = MTUNLOCK;
1108 mt_com.mt_count = 1;
1109 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1111 mt_com.mt_op = MTOFFL;
1112 mt_com.mt_count = 1;
1113 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1115 dev->dev_errno = errno;
1116 Mmsg2(dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1117 dev->print_name(), be.strerror());
1120 Dmsg1(100, "Offlined device %s\n", dev->print_name());
1124 bool offline_or_rewind_dev(DEVICE *dev)
1129 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1130 return offline_dev(dev);
1133 * Note, this rewind probably should not be here (it wasn't
1134 * in prior versions of Bacula), but on FreeBSD, this is
1135 * needed in the case the tape was "frozen" due to an error
1136 * such as backspacing after writing and EOF. If it is not
1137 * done, all future references to the drive get and I/O error.
1139 clrerror_dev(dev, MTREW);
1140 return rewind_dev(dev);
1145 * Foward space a file
1146 * Returns: true on success
1149 bool DEVICE::fsf(int num)
1151 struct mtget mt_stat;
1157 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1158 Emsg0(M_FATAL, 0, errmsg);
1167 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1171 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1174 Dmsg0(100, "fsf\n");
1177 * If Fast forward space file is set, then we
1178 * use MTFSF to forward space and MTIOCGET
1179 * to get the file position. We assume that
1180 * the SCSI driver will ensure that we do not
1181 * forward space past the end of the medium.
1183 if (dev_cap(this, CAP_FSF) && dev_cap(this, CAP_MTIOCGET) && dev_cap(this, CAP_FASTFSF)) {
1184 mt_com.mt_op = MTFSF;
1185 mt_com.mt_count = num;
1186 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1187 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1190 Dmsg0(200, "Set ST_EOT\n");
1191 clrerror_dev(this, MTFSF);
1192 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1193 print_name(), be.strerror());
1194 Dmsg1(200, "%s", errmsg);
1197 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1199 file = mt_stat.mt_fileno;
1203 * Here if CAP_FSF is set, and virtually all drives
1204 * these days support it, we read a record, then forward
1205 * space one file. Using this procedure, which is slow,
1206 * is the only way we can be sure that we don't read
1207 * two consecutive EOF marks, which means End of Data.
1209 } else if (dev_cap(this, CAP_FSF)) {
1212 Dmsg0(200, "FSF has cap_fsf\n");
1213 if (max_block_size == 0) {
1214 rbuf_len = DEFAULT_BLOCK_SIZE;
1216 rbuf_len = max_block_size;
1218 rbuf = get_memory(rbuf_len);
1219 mt_com.mt_op = MTFSF;
1220 mt_com.mt_count = 1;
1221 while (num-- && !at_eot()) {
1222 Dmsg0(100, "Doing read before fsf\n");
1223 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1224 if (errno == ENOMEM) { /* tape record exceeds buf len */
1225 stat = rbuf_len; /* This is OK */
1227 * On IBM drives, they return ENOSPC at EOM
1228 * instead of EOF status
1230 } else if (at_eof() && errno == ENOSPC) {
1235 clrerror_dev(this, -1);
1236 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1238 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1239 print_name(), be.strerror());
1240 Dmsg1(100, "%s", errmsg);
1244 if (stat == 0) { /* EOF */
1245 update_pos_dev(this);
1246 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1247 /* Two reads of zero means end of tape */
1250 Dmsg0(100, "Set ST_EOT\n");
1256 } else { /* Got data */
1261 Dmsg0(100, "Doing MTFSF\n");
1262 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1263 if (stat < 0) { /* error => EOT */
1266 Dmsg0(100, "Set ST_EOT\n");
1267 clrerror_dev(this, MTFSF);
1268 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1269 print_name(), be.strerror());
1270 Dmsg0(100, "Got < 0 for MTFSF\n");
1271 Dmsg1(100, "%s", errmsg);
1279 * No FSF, so use FSR to simulate it
1282 Dmsg0(200, "Doing FSR for FSF\n");
1283 while (num-- && !at_eot()) {
1284 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1288 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1294 update_pos_dev(this);
1295 Dmsg1(200, "Return %d from FSF\n", stat);
1297 Dmsg0(200, "ST_EOF set on exit FSF\n");
1299 Dmsg0(200, "ST_EOT set on exit FSF\n");
1300 Dmsg1(200, "Return from FSF file=%d\n", file);
1305 * Backward space a file
1306 * Returns: false on failure
1310 bsf_dev(DEVICE *dev, int num)
1316 dev->dev_errno = EBADF;
1317 Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Device not open\n"));
1318 Emsg0(M_FATAL, 0, dev->errmsg);
1322 if (!dev->is_tape()) {
1323 Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1327 Dmsg0(29, "bsf_dev\n");
1328 dev->state &= ~(ST_EOT|ST_EOF);
1332 mt_com.mt_op = MTBSF;
1333 mt_com.mt_count = num;
1334 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1337 clrerror_dev(dev, MTBSF);
1338 Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1339 dev->print_name(), be.strerror());
1341 update_pos_dev(dev);
1347 * Foward space num records
1348 * Returns: false on failure
1351 bool DEVICE::fsr(int num)
1358 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1359 Emsg0(M_FATAL, 0, errmsg);
1366 if (!dev_cap(this, CAP_FSR)) {
1367 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1371 Dmsg1(29, "fsr %d\n", num);
1372 mt_com.mt_op = MTFSR;
1373 mt_com.mt_count = num;
1374 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1380 struct mtget mt_stat;
1381 clrerror_dev(this, MTFSR);
1382 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1383 if (dev_get_os_pos(this, &mt_stat)) {
1384 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1385 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1386 file = mt_stat.mt_fileno;
1387 block_num = mt_stat.mt_blkno;
1395 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1396 num, print_name(), be.strerror());
1398 update_pos_dev(this);
1403 * Backward space a record
1404 * Returns: false on failure
1408 bsr_dev(DEVICE *dev, int num)
1414 dev->dev_errno = EBADF;
1415 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1416 Emsg0(M_FATAL, 0, dev->errmsg);
1420 if (!dev->is_tape()) {
1424 if (!dev_cap(dev, CAP_BSR)) {
1425 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1429 Dmsg0(29, "bsr_dev\n");
1430 dev->block_num -= num;
1431 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1432 mt_com.mt_op = MTBSR;
1433 mt_com.mt_count = num;
1434 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1437 clrerror_dev(dev, MTBSR);
1438 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1439 dev->print_name(), be.strerror());
1441 update_pos_dev(dev);
1446 * Reposition the device to file, block
1447 * Returns: false on failure
1451 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1454 dev->dev_errno = EBADF;
1455 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1456 Emsg0(M_FATAL, 0, dev->errmsg);
1460 if (!dev->is_tape()) {
1461 off_t pos = (((off_t)file)<<32) + (off_t)block;
1462 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1463 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1465 dev->dev_errno = errno;
1466 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1467 dev->print_name(), be.strerror());
1471 dev->block_num = block;
1472 dev->file_addr = pos;
1475 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1476 dev->file, dev->block_num, file, block);
1477 if (file < dev->file) {
1478 Dmsg0(100, "Rewind_dev\n");
1479 if (!rewind_dev(dev)) {
1483 if (file > dev->file) {
1484 Dmsg1(100, "fsf %d\n", file-dev->file);
1485 if (!dev->fsf(file-dev->file)) {
1486 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1489 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1491 if (block < dev->block_num) {
1492 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1493 Dmsg0(100, "bsf_dev 1\n");
1495 Dmsg0(100, "fsf_dev 1\n");
1497 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1499 if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1500 /* Ignore errors as Bacula can read to the correct block */
1501 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1502 return dev->fsr(block-dev->block_num);
1510 * Write an end of file on the device
1511 * Returns: 0 on success
1512 * non-zero on failure
1515 weof_dev(DEVICE *dev, int num)
1519 Dmsg0(29, "weof_dev\n");
1522 dev->dev_errno = EBADF;
1523 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1524 Emsg0(M_FATAL, 0, dev->errmsg);
1529 if (!dev->is_tape()) {
1532 if (!dev->can_append()) {
1533 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1534 Emsg0(M_FATAL, 0, dev->errmsg);
1538 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1539 mt_com.mt_op = MTWEOF;
1540 mt_com.mt_count = num;
1541 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1548 clrerror_dev(dev, MTWEOF);
1550 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1551 dev->print_name(), be.strerror());
1558 * Return string message with last error in English
1559 * Be careful not to call this routine from within dev.c
1560 * while editing an Mmsg() or you will end up in a recursive
1561 * loop creating a Segmentation Violation.
1564 strerror_dev(DEVICE *dev)
1571 * If implemented in system, clear the tape
1575 clrerror_dev(DEVICE *dev, int func)
1577 const char *msg = NULL;
1578 struct mtget mt_stat;
1581 dev->dev_errno = errno; /* save errno */
1583 dev->VolCatInfo.VolCatErrors++;
1586 if (!dev->is_tape()) {
1589 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1592 Emsg0(M_ABORT, 0, _("Got ENOTTY on read/write!\n"));
1596 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1601 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1606 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1610 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1614 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1618 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1639 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1644 dev->dev_errno = ENOSYS;
1645 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1646 Emsg0(M_ERROR, 0, dev->errmsg);
1649 /* On some systems such as NetBSD, this clears all errors */
1650 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1652 /* Found on Linux */
1656 mt_com.mt_op = MTIOCLRERR;
1657 mt_com.mt_count = 1;
1658 /* Clear any error condition on the tape */
1659 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1660 Dmsg0(200, "Did MTIOCLRERR\n");
1664 /* Typically on FreeBSD */
1667 /* Read and clear SCSI error status */
1668 union mterrstat mt_errstat;
1669 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1670 strerror(dev->dev_errno));
1671 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1675 /* Clear Subsystem Exception OSF1 */
1679 mt_com.mt_op = MTCSE;
1680 mt_com.mt_count = 1;
1681 /* Clear any error condition on the tape */
1682 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1683 Dmsg0(200, "Did MTCSE\n");
1689 * Flush buffer contents
1692 int flush_dev(DEVICE *dev)
1697 static void do_close(DEVICE *dev)
1700 Dmsg1(29, "really close_dev %s\n", dev->print_name());
1705 if (!unmount_dev(dev, 1)) {
1706 Dmsg1(0, "Cannot unmount device %s.\n", dev->print_name());
1709 /* Remove the last part file if it is empty */
1710 if (dev->num_parts > 0) {
1712 POOL_MEM archive_name(PM_FNAME);
1713 dev->part = dev->num_parts;
1714 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", dev->VolCatInfo.VolCatName);
1715 make_spooled_dvd_filename(dev, archive_name);
1716 /* Check that the part file is empty */
1717 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1718 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1719 unlink(archive_name.c_str());
1723 /* Clean up device packet so it can be reused */
1725 dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1726 dev->label_type = B_BACULA_LABEL;
1727 dev->file = dev->block_num = 0;
1733 dev->part_start = 0;
1734 dev->EndFile = dev->EndBlock = 0;
1735 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1737 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1739 stop_thread_timer(dev->tid);
1749 void DEVICE::close()
1751 /*if (fd >= 0 && use_count == 1) {*/
1752 /* No need to check if fd >= 0: it is checked again
1753 * in do_close, and do_close MUST be called for volumes
1754 * splitted in parts, even if fd == -1. */
1755 if (use_count == 1) {
1757 } else if (use_count > 0) {
1762 ASSERT(use_count >= 0);
1767 bool truncate_dev(DCR *dcr) /* We need the DCR for DVD-writing */
1769 DEVICE *dev = dcr->dev;
1771 Dmsg1(100, "truncate_dev %s\n", dev->print_name());
1772 if (dev->is_tape()) {
1773 return true; /* we don't really truncate tapes */
1774 /* maybe we should rewind and write and eof ???? */
1777 if (dev->is_dvd()) {
1778 return truncate_dvd_dev(dcr);
1781 if (ftruncate(dev->fd, 0) != 0) {
1783 Mmsg2(dev->errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1784 dev->print_name(), be.strerror());
1790 /* Return the resource name for the device */
1791 const char *DEVICE::name() const
1793 return device->hdr.name;
1797 dev_vol_name(DEVICE *dev)
1799 return dev->VolCatInfo.VolCatName;
1802 uint32_t dev_block(DEVICE *dev)
1804 update_pos_dev(dev);
1805 return dev->block_num;
1808 uint32_t dev_file(DEVICE *dev)
1810 update_pos_dev(dev);
1815 * Free memory allocated for the device
1818 term_dev(DEVICE *dev)
1821 dev->dev_errno = EBADF;
1822 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1823 Emsg0(M_FATAL, 0, dev->errmsg);
1826 Dmsg1(29, "term_dev: %s\n", dev->print_name());
1828 if (dev->dev_name) {
1829 free_memory(dev->dev_name);
1830 dev->dev_name = NULL;
1832 if (dev->prt_name) {
1833 free_memory(dev->prt_name);
1834 dev->prt_name = NULL;
1837 free_pool_memory(dev->errmsg);
1840 pthread_mutex_destroy(&dev->mutex);
1841 pthread_cond_destroy(&dev->wait);
1842 pthread_cond_destroy(&dev->wait_next_vol);
1843 pthread_mutex_destroy(&dev->spool_mutex);
1844 rwl_destroy(&dev->lock);
1845 if (dev->attached_dcrs) {
1846 delete dev->attached_dcrs;
1847 dev->attached_dcrs = NULL;
1849 if (dev->state & ST_MALLOC) {
1850 free_pool_memory((POOLMEM *)dev);
1855 * This routine initializes the device wait timers
1857 void init_device_wait_timers(DCR *dcr)
1859 DEVICE *dev = dcr->dev;
1860 JCR *jcr = dcr->jcr;
1862 /* ******FIXME******* put these on config variables */
1863 dev->min_wait = 60 * 60;
1864 dev->max_wait = 24 * 60 * 60;
1865 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1866 dev->wait_sec = dev->min_wait;
1867 dev->rem_wait_sec = dev->wait_sec;
1870 dev->BadVolName[0] = 0;
1872 jcr->min_wait = 60 * 60;
1873 jcr->max_wait = 24 * 60 * 60;
1874 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1875 jcr->wait_sec = jcr->min_wait;
1876 jcr->rem_wait_sec = jcr->wait_sec;
1881 void init_jcr_device_wait_timers(JCR *jcr)
1883 /* ******FIXME******* put these on config variables */
1884 jcr->min_wait = 60 * 60;
1885 jcr->max_wait = 24 * 60 * 60;
1886 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1887 jcr->wait_sec = jcr->min_wait;
1888 jcr->rem_wait_sec = jcr->wait_sec;
1894 * The dev timers are used for waiting on a particular device
1896 * Returns: true if time doubled
1897 * false if max time expired
1899 bool double_dev_wait_time(DEVICE *dev)
1901 dev->wait_sec *= 2; /* double wait time */
1902 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
1903 dev->wait_sec = dev->max_wait;
1906 dev->rem_wait_sec = dev->wait_sec;
1907 if (dev->num_wait >= dev->max_num_wait) {
1914 void set_os_device_parameters(DEVICE *dev)
1916 #ifdef HAVE_LINUX_OS
1918 if (dev->min_block_size == dev->max_block_size &&
1919 dev->min_block_size == 0) { /* variable block mode */
1920 mt_com.mt_op = MTSETBLK;
1921 mt_com.mt_count = 0;
1922 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1923 clrerror_dev(dev, MTSETBLK);
1925 mt_com.mt_op = MTSETDRVBUFFER;
1926 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
1927 if (!dev_cap(dev, CAP_TWOEOF)) {
1928 mt_com.mt_count |= MT_ST_TWO_FM;
1930 if (dev_cap(dev, CAP_EOM)) {
1931 mt_com.mt_count |= MT_ST_FAST_MTEOM;
1933 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1934 clrerror_dev(dev, MTSETBLK);
1940 #ifdef HAVE_NETBSD_OS
1942 if (dev->min_block_size == dev->max_block_size &&
1943 dev->min_block_size == 0) { /* variable block mode */
1944 mt_com.mt_op = MTSETBSIZ;
1945 mt_com.mt_count = 0;
1946 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1947 clrerror_dev(dev, MTSETBSIZ);
1949 /* Get notified at logical end of tape */
1950 mt_com.mt_op = MTEWARN;
1951 mt_com.mt_count = 1;
1952 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1953 clrerror_dev(dev, MTEWARN);
1959 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
1961 if (dev->min_block_size == dev->max_block_size &&
1962 dev->min_block_size == 0) { /* variable block mode */
1963 mt_com.mt_op = MTSETBSIZ;
1964 mt_com.mt_count = 0;
1965 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1966 clrerror_dev(dev, MTSETBSIZ);
1974 if (dev->min_block_size == dev->max_block_size &&
1975 dev->min_block_size == 0) { /* variable block mode */
1976 mt_com.mt_op = MTSRSZ;
1977 mt_com.mt_count = 0;
1978 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1979 clrerror_dev(dev, MTSRSZ);
1986 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
1988 return dev_cap(dev, CAP_MTIOCGET) &&
1989 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
1990 mt_stat->mt_fileno >= 0;
1993 static char *modes[] = {
1994 "CREATE_READ_WRITE",
2001 static char *mode_to_str(int mode)
2003 return modes[mode-1];