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 */
270 Dmsg0(100, "Close fd for mode change.\n");
274 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
277 Dmsg4(29, "open dev: tape=%d dev_name=%s vol=%s mode=%s\n", is_tape(),
278 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
279 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
280 label_type = B_BACULA_LABEL;
281 if (is_tape() || is_fifo()) {
282 open_tape_device(dcr, omode);
283 } else if (is_dvd()) {
284 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
285 open_dvd_device(dcr, omode);
287 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
288 open_file_device(omode);
293 void DEVICE::set_mode(int new_mode)
296 case CREATE_READ_WRITE:
297 mode = O_CREAT | O_RDWR | O_BINARY;
299 case OPEN_READ_WRITE:
300 if (is_dvd() || is_file()) {
301 mode = O_CREAT | O_RDWR | O_BINARY;
303 mode = O_RDWR | O_BINARY;
307 mode = O_RDONLY | O_BINARY;
309 case OPEN_WRITE_ONLY:
310 mode = O_WRONLY | O_BINARY;
313 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
318 * If the flage open_nowait is set, which is the case
319 * when the daemon is initially trying to open the device,
320 * we open it with O_NONBLOCK set and O_RONLY, which will
321 * allow us to open normal Linux tape drives with no tape
322 * in the drive without blocking. We then immediately
323 * set blocking status so that if we read from the device they
324 * will be normal blocking reads.
326 * If later, we want to write on the device, it will be freed and
327 * reopened, but hopefully there will be a tape in the drive so
330 void DEVICE::open_tape_device(DCR *dcr, int omode)
334 int nonblocking = O_NONBLOCK;
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;
344 if (is_fifo() && timeout) {
346 tid = start_thread_timer(pthread_self(), timeout);
348 /* If busy retry each second for max_open_wait seconds */
349 Dmsg3(100, "Try open %s mode=%s nonblocking=%d\n", print_name(),
350 mode_to_str(omode), nonblocking);
351 /* Use system open() */
352 while ((fd = ::open(dev_name, mode+nonblocking)) < 0) {
355 Dmsg5(050, "Open omode=%d mode=%x nonblock=%d error errno=%d ERR=%s\n",
356 omode, mode, nonblocking, errno, be.strerror());
357 if (dev_errno == EINTR || dev_errno == EAGAIN) {
358 Dmsg0(100, "Continue open\n");
361 /* Busy wait for specified time (default = 5 mins) */
362 if (dev_errno == EBUSY && timeout-- > 0) {
363 Dmsg2(100, "Device %s busy. ERR=%s\n", print_name(), be.strerror());
367 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
368 print_name(), be.strerror(dev_errno));
369 /* Stop any open timer we set */
371 stop_thread_timer(tid);
374 Jmsg0(dcr->jcr, M_FATAL, 0, errmsg);
379 openmode = omode; /* save open mode */
381 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
385 update_pos_dev(this); /* update position */
386 set_os_device_parameters(this); /* do system dependent stuff */
391 /* Stop any open() timer we started */
393 stop_thread_timer(tid);
396 Dmsg1(29, "open dev: tape %d opened\n", fd);
399 void DEVICE::set_blocking()
402 /* Try to reset blocking */
404 if ((oflags = fcntl(fd, F_GETFL, 0)) < 0 ||
405 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK) < 0) {
407 ::close(fd); /* use system close() */
408 fd = ::open(dev_name, mode);
409 Dmsg2(100, "fcntl error. ERR=%s. Close-reopen fd=%d\n", be.strerror(), fd);
412 oflags = fcntl(fd, F_GETFL, 0);
413 if (oflags > 0 && (oflags & O_NONBLOCK)) {
414 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK);
421 void DEVICE::open_file_device(int omode)
423 POOL_MEM archive_name(PM_FNAME);
426 * Handle opening of File Archive (not a tape)
428 Dmsg3(29, "Enter: open_file_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
429 archive_name.c_str(), mode_to_str(omode));
431 if (VolCatInfo.VolCatName[0] == 0) {
432 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
439 pm_strcpy(archive_name, dev_name);
440 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
441 pm_strcat(archive_name, "/");
443 pm_strcat(archive_name, VolCatInfo.VolCatName);
445 Dmsg3(29, "open dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
446 archive_name.c_str(), mode_to_str(omode));
448 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
451 /* If creating file, give 0640 permissions */
452 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
453 archive_name.c_str(), mode);
454 /* Use system open() */
455 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
458 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"),
505 Dmsg2(99, "open_dvd_device: num_parts=%d, VolCatInfo.VolCatParts=%d\n",
506 dcr->dev->num_parts, dcr->VolCatInfo.VolCatParts);
507 if (dcr->dev->num_parts < dcr->VolCatInfo.VolCatParts) {
508 Dmsg2(99, "open_dvd_device: num_parts updated to %d (was %d)\n",
509 dcr->VolCatInfo.VolCatParts, dcr->dev->num_parts);
510 dcr->dev->num_parts = dcr->VolCatInfo.VolCatParts;
513 if (mount_dev(this, 1)) {
514 if ((num_parts == 0) && (!truncating)) {
515 /* If we can mount the device, and we are not truncating the DVD, we usually want to abort. */
516 /* There is one exception, if there is only one 0-sized file on the DVD, with the right volume name,
517 * we continue (it's the method used by truncate_dvd_dev to truncate a volume). */
518 if (!check_can_write_on_non_blank_dvd(dcr)) {
519 Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
520 Emsg0(M_FATAL, 0, errmsg);
521 unmount_dev(this, 1); /* Unmount the device, so the operator can change it. */
528 /* We cannot mount the device */
529 if (num_parts == 0) {
530 /* Run free space, check there is a media. */
531 update_free_space_dev(this);
533 Dmsg1(29, "Could not mount device %s, this is not a problem (num_parts == 0), and have media.\n", print_name());
536 Mmsg(errmsg, _("There is no valid media in the device %s.\n"), print_name());
537 Emsg0(M_FATAL, 0, errmsg);
543 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
544 Emsg0(M_FATAL, 0, errmsg);
550 Dmsg6(29, "open dev: %s dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
551 is_dvd()?"DVD":"disk", archive_name.c_str(), mode_to_str(omode),
552 part, num_parts, dcr->VolCatInfo.VolCatParts);
554 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
557 * If we are not trying to access the last part, set mode to
558 * OPEN_READ_ONLY as writing would be an error.
560 if (part < num_parts) {
561 omode = OPEN_READ_ONLY;
562 make_mounted_dvd_filename(this, archive_name);
565 make_spooled_dvd_filename(this, archive_name);
569 /* If creating file, give 0640 permissions */
570 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
571 archive_name.c_str(), mode);
572 /* Use system open() */
573 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
575 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
577 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
578 Dmsg1(29, "open failed: %s", errmsg);
580 if ((omode == OPEN_READ_ONLY) && (part == num_parts)) {
581 /* If the last part (on spool), doesn't exists when reading, create it and read from it
582 * (it will report immediately an EOF):
583 * Sometimes it is better to finish with an EOF than with an error. */
584 set_mode(OPEN_READ_WRITE);
585 fd = ::open(archive_name.c_str(), mode, 0640);
586 set_mode(OPEN_READ_ONLY);
589 /* We don't need it. Only the last part is on spool */
590 /*if (omode == OPEN_READ_ONLY) {
591 make_spooled_dvd_filename(this, archive_name);
592 fd = ::open(archive_name.c_str(), mode, 0640); // try on spool
595 Dmsg1(100, "after open fd=%d\n", fd);
597 /* Get size of file */
598 if (fstat(fd, &filestat) < 0) {
601 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
603 Dmsg1(29, "open failed: %s", errmsg);
604 /* Use system close() */
609 part_size = filestat.st_size;
613 update_pos_dev(this); /* update position */
615 /* NB: It seems this code is wrong... part number is incremented in open_next_part, not here */
617 /* Check if just created Volume part */
618 /* if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
621 VolCatInfo.VolCatParts = num_parts;
623 if (part == 0) { // we must have opened the first part
636 bool _rewind_dev(char *file, int line, DEVICE *dev)
638 Dmsg3(100, "rewind_dev fd=%d called from %s:%d\n", dev->fd, file, line);
639 return rewind_dev(dev);
645 * Returns: true on success
648 bool rewind_dev(DEVICE *dev)
653 Dmsg3(29, "rewind_dev res=%d fd=%d %s\n", dev->reserved_device,
654 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()
757 * Called to indicate we are now at the end of the tape, and
758 * writing is not possible.
760 void DEVICE::set_ateot()
762 /* Make tape effectively read-only */
763 state |= (ST_EOF|ST_EOT|ST_WEOT);
768 * Position device to end of medium (end of data)
769 * Returns: true on succes
776 struct mtget mt_stat;
781 dev->dev_errno = EBADF;
782 Mmsg1(dev->errmsg, _("Bad call to eod_dev. Device %s not open\n"),
787 #if defined (__digital__) && defined (__unix__)
788 return dev->fsf(dev->VolCatInfo.VolCatFiles);
791 Dmsg0(29, "eod_dev\n");
795 dev->state &= ~(ST_EOF); /* remove EOF flags */
796 dev->block_num = dev->file = 0;
799 if (dev->state & (ST_FIFO | ST_PROG)) {
802 if (!dev->is_tape()) {
803 pos = lseek_dev(dev, (off_t)0, SEEK_END);
804 // Dmsg1(100, "====== Seek to %lld\n", pos);
807 dev->state |= ST_EOT;
810 dev->dev_errno = errno;
812 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
813 dev->print_name(), be.strerror());
817 if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
818 Dmsg0(100,"Using FAST FSF for EOM\n");
819 /* If unknown position, rewind */
820 if (!dev_get_os_pos(dev, &mt_stat)) {
821 if (!rewind_dev(dev)) {
825 mt_com.mt_op = MTFSF;
827 * ***FIXME*** fix code to handle case that INT16_MAX is
830 mt_com.mt_count = INT16_MAX; /* use big positive number */
831 if (mt_com.mt_count < 0) {
832 mt_com.mt_count = INT16_MAX; /* brain damaged system */
836 if (dev_cap(dev, CAP_MTIOCGET) && (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM))) {
837 if (dev_cap(dev, CAP_EOM)) {
838 Dmsg0(100,"Using EOM for EOM\n");
839 mt_com.mt_op = MTEOM;
843 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
845 clrerror_dev(dev, mt_com.mt_op);
846 Dmsg1(50, "ioctl error: %s\n", be.strerror());
848 Mmsg2(dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
849 dev->print_name(), be.strerror());
853 if (!dev_get_os_pos(dev, &mt_stat)) {
855 clrerror_dev(dev, -1);
856 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
857 dev->print_name(), be.strerror());
860 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
862 dev->file = mt_stat.mt_fileno;
868 * Rewind then use FSF until EOT reached
870 if (!rewind_dev(dev)) {
874 * Move file by file to the end of the tape
877 for (file_num=dev->file; !dev->at_eot(); file_num++) {
878 Dmsg0(200, "eod_dev: doing fsf 1\n");
880 Dmsg0(200, "fsf error.\n");
884 * Avoid infinite loop by ensuring we advance.
886 if (file_num == (int)dev->file) {
887 struct mtget mt_stat;
888 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
890 if (dev_get_os_pos(dev, &mt_stat)) {
891 Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
892 dev->file = mt_stat.mt_fileno;
899 * Some drivers leave us after second EOF when doing
900 * MTEOM, so we must backup so that appending overwrites
903 if (dev_cap(dev, CAP_BSFATEOM)) {
904 struct mtget mt_stat;
905 /* Backup over EOF */
906 ok = bsf_dev(dev, 1);
907 /* If BSF worked and fileno is known (not -1), set file */
908 if (dev_get_os_pos(dev, &mt_stat)) {
909 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
910 dev->file = mt_stat.mt_fileno;
912 dev->file++; /* wing it -- not correct on all OSes */
915 update_pos_dev(dev); /* update position */
917 Dmsg1(200, "EOD dev->file=%d\n", dev->file);
922 * Set the position of the device -- only for files and DVD
923 * For other devices, there is no generic way to do it.
924 * Returns: true on succes
927 bool update_pos_dev(DEVICE *dev)
933 dev->dev_errno = EBADF;
934 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
935 Emsg0(M_FATAL, 0, dev->errmsg);
939 /* Find out where we are */
940 if (dev->is_file()) {
943 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
946 dev->dev_errno = errno;
947 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
948 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
949 dev->print_name(), be.strerror());
952 dev->file_addr = pos;
960 * Return the status of the device. This was meant
961 * to be a generic routine. Unfortunately, it doesn't
962 * seem possible (at least I do not know how to do it
963 * currently), which means that for the moment, this
964 * routine has very little value.
968 uint32_t status_dev(DEVICE *dev)
970 struct mtget mt_stat;
973 if (dev->state & (ST_EOT | ST_WEOT)) {
977 if (dev->state & ST_EOF) {
981 if (dev->is_tape()) {
983 Pmsg0(-20,_(" Bacula status:"));
984 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
985 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
987 dev->dev_errno = errno;
988 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
989 dev->print_name(), be.strerror());
992 Pmsg0(-20, _(" Device status:"));
994 #if defined(HAVE_LINUX_OS)
995 if (GMT_EOF(mt_stat.mt_gstat)) {
999 if (GMT_BOT(mt_stat.mt_gstat)) {
1003 if (GMT_EOT(mt_stat.mt_gstat)) {
1007 if (GMT_SM(mt_stat.mt_gstat)) {
1011 if (GMT_EOD(mt_stat.mt_gstat)) {
1015 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1016 stat |= BMT_WR_PROT;
1017 Pmsg0(-20, " WR_PROT");
1019 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1021 Pmsg0(-20, " ONLINE");
1023 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1024 stat |= BMT_DR_OPEN;
1025 Pmsg0(-20, " DR_OPEN");
1027 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1028 stat |= BMT_IM_REP_EN;
1029 Pmsg0(-20, " IM_REP_EN");
1031 #endif /* !SunOS && !OSF */
1032 if (dev_cap(dev, CAP_MTIOCGET)) {
1033 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1035 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1038 stat |= BMT_ONLINE | BMT_BOT;
1045 * Load medium in device
1046 * Returns: true on success
1049 bool load_dev(DEVICE *dev)
1056 dev->dev_errno = EBADF;
1057 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1058 Emsg0(M_FATAL, 0, dev->errmsg);
1061 if (!(dev->is_tape())) {
1065 Dmsg0(200, "stored: MTLOAD command not available\n");
1067 dev->dev_errno = ENOTTY; /* function not available */
1068 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1069 dev->print_name(), be.strerror());
1073 dev->block_num = dev->file = 0;
1076 mt_com.mt_op = MTLOAD;
1077 mt_com.mt_count = 1;
1078 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1080 dev->dev_errno = errno;
1081 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1082 dev->print_name(), be.strerror());
1090 * Rewind device and put it offline
1091 * Returns: true on success
1094 bool offline_dev(DEVICE *dev)
1098 if (!dev || dev->fd < 0 || !dev->is_tape()) {
1099 return true; /* device not open */
1102 dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1103 dev->block_num = dev->file = 0;
1108 mt_com.mt_op = MTUNLOCK;
1109 mt_com.mt_count = 1;
1110 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1112 mt_com.mt_op = MTOFFL;
1113 mt_com.mt_count = 1;
1114 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1116 dev->dev_errno = errno;
1117 Mmsg2(dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1118 dev->print_name(), be.strerror());
1121 Dmsg1(100, "Offlined device %s\n", dev->print_name());
1125 bool offline_or_rewind_dev(DEVICE *dev)
1130 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1131 return offline_dev(dev);
1134 * Note, this rewind probably should not be here (it wasn't
1135 * in prior versions of Bacula), but on FreeBSD, this is
1136 * needed in the case the tape was "frozen" due to an error
1137 * such as backspacing after writing and EOF. If it is not
1138 * done, all future references to the drive get and I/O error.
1140 clrerror_dev(dev, MTREW);
1141 return rewind_dev(dev);
1146 * Foward space a file
1147 * Returns: true on success
1150 bool DEVICE::fsf(int num)
1152 struct mtget mt_stat;
1158 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1159 Emsg0(M_FATAL, 0, errmsg);
1168 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1172 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1175 Dmsg0(100, "fsf\n");
1178 * If Fast forward space file is set, then we
1179 * use MTFSF to forward space and MTIOCGET
1180 * to get the file position. We assume that
1181 * the SCSI driver will ensure that we do not
1182 * forward space past the end of the medium.
1184 if (dev_cap(this, CAP_FSF) && dev_cap(this, CAP_MTIOCGET) && dev_cap(this, CAP_FASTFSF)) {
1185 mt_com.mt_op = MTFSF;
1186 mt_com.mt_count = num;
1187 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1188 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1191 Dmsg0(200, "Set ST_EOT\n");
1192 clrerror_dev(this, MTFSF);
1193 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1194 print_name(), be.strerror());
1195 Dmsg1(200, "%s", errmsg);
1198 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1200 file = mt_stat.mt_fileno;
1204 * Here if CAP_FSF is set, and virtually all drives
1205 * these days support it, we read a record, then forward
1206 * space one file. Using this procedure, which is slow,
1207 * is the only way we can be sure that we don't read
1208 * two consecutive EOF marks, which means End of Data.
1210 } else if (dev_cap(this, CAP_FSF)) {
1213 Dmsg0(200, "FSF has cap_fsf\n");
1214 if (max_block_size == 0) {
1215 rbuf_len = DEFAULT_BLOCK_SIZE;
1217 rbuf_len = max_block_size;
1219 rbuf = get_memory(rbuf_len);
1220 mt_com.mt_op = MTFSF;
1221 mt_com.mt_count = 1;
1222 while (num-- && !at_eot()) {
1223 Dmsg0(100, "Doing read before fsf\n");
1224 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1225 if (errno == ENOMEM) { /* tape record exceeds buf len */
1226 stat = rbuf_len; /* This is OK */
1228 * On IBM drives, they return ENOSPC at EOM
1229 * instead of EOF status
1231 } else if (at_eof() && errno == ENOSPC) {
1236 clrerror_dev(this, -1);
1237 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1239 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1240 print_name(), be.strerror());
1241 Dmsg1(100, "%s", errmsg);
1245 if (stat == 0) { /* EOF */
1246 update_pos_dev(this);
1247 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1248 /* Two reads of zero means end of tape */
1251 Dmsg0(100, "Set ST_EOT\n");
1257 } else { /* Got data */
1262 Dmsg0(100, "Doing MTFSF\n");
1263 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1264 if (stat < 0) { /* error => EOT */
1267 Dmsg0(100, "Set ST_EOT\n");
1268 clrerror_dev(this, MTFSF);
1269 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1270 print_name(), be.strerror());
1271 Dmsg0(100, "Got < 0 for MTFSF\n");
1272 Dmsg1(100, "%s", errmsg);
1280 * No FSF, so use FSR to simulate it
1283 Dmsg0(200, "Doing FSR for FSF\n");
1284 while (num-- && !at_eot()) {
1285 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1289 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1295 update_pos_dev(this);
1296 Dmsg1(200, "Return %d from FSF\n", stat);
1298 Dmsg0(200, "ST_EOF set on exit FSF\n");
1300 Dmsg0(200, "ST_EOT set on exit FSF\n");
1301 Dmsg1(200, "Return from FSF file=%d\n", file);
1306 * Backward space a file
1307 * Returns: false on failure
1311 bsf_dev(DEVICE *dev, int num)
1317 dev->dev_errno = EBADF;
1318 Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Device not open\n"));
1319 Emsg0(M_FATAL, 0, dev->errmsg);
1323 if (!dev->is_tape()) {
1324 Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1328 Dmsg0(29, "bsf_dev\n");
1329 dev->state &= ~(ST_EOT|ST_EOF);
1333 mt_com.mt_op = MTBSF;
1334 mt_com.mt_count = num;
1335 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1338 clrerror_dev(dev, MTBSF);
1339 Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1340 dev->print_name(), be.strerror());
1342 update_pos_dev(dev);
1348 * Foward space num records
1349 * Returns: false on failure
1352 bool DEVICE::fsr(int num)
1359 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1360 Emsg0(M_FATAL, 0, errmsg);
1367 if (!dev_cap(this, CAP_FSR)) {
1368 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1372 Dmsg1(29, "fsr %d\n", num);
1373 mt_com.mt_op = MTFSR;
1374 mt_com.mt_count = num;
1375 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1381 struct mtget mt_stat;
1382 clrerror_dev(this, MTFSR);
1383 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1384 if (dev_get_os_pos(this, &mt_stat)) {
1385 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1386 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1387 file = mt_stat.mt_fileno;
1388 block_num = mt_stat.mt_blkno;
1396 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1397 num, print_name(), be.strerror());
1399 update_pos_dev(this);
1404 * Backward space a record
1405 * Returns: false on failure
1409 bsr_dev(DEVICE *dev, int num)
1415 dev->dev_errno = EBADF;
1416 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1417 Emsg0(M_FATAL, 0, dev->errmsg);
1421 if (!dev->is_tape()) {
1425 if (!dev_cap(dev, CAP_BSR)) {
1426 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1430 Dmsg0(29, "bsr_dev\n");
1431 dev->block_num -= num;
1432 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1433 mt_com.mt_op = MTBSR;
1434 mt_com.mt_count = num;
1435 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1438 clrerror_dev(dev, MTBSR);
1439 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1440 dev->print_name(), be.strerror());
1442 update_pos_dev(dev);
1447 * Reposition the device to file, block
1448 * Returns: false on failure
1452 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1455 dev->dev_errno = EBADF;
1456 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1457 Emsg0(M_FATAL, 0, dev->errmsg);
1461 if (!dev->is_tape()) {
1462 off_t pos = (((off_t)file)<<32) + (off_t)block;
1463 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1464 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1466 dev->dev_errno = errno;
1467 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1468 dev->print_name(), be.strerror());
1472 dev->block_num = block;
1473 dev->file_addr = pos;
1476 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1477 dev->file, dev->block_num, file, block);
1478 if (file < dev->file) {
1479 Dmsg0(100, "Rewind_dev\n");
1480 if (!rewind_dev(dev)) {
1484 if (file > dev->file) {
1485 Dmsg1(100, "fsf %d\n", file-dev->file);
1486 if (!dev->fsf(file-dev->file)) {
1487 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1490 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1492 if (block < dev->block_num) {
1493 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1494 Dmsg0(100, "bsf_dev 1\n");
1496 Dmsg0(100, "fsf_dev 1\n");
1498 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1500 if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1501 /* Ignore errors as Bacula can read to the correct block */
1502 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1503 return dev->fsr(block-dev->block_num);
1511 * Write an end of file on the device
1512 * Returns: 0 on success
1513 * non-zero on failure
1516 weof_dev(DEVICE *dev, int num)
1520 Dmsg0(29, "weof_dev\n");
1523 dev->dev_errno = EBADF;
1524 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1525 Emsg0(M_FATAL, 0, dev->errmsg);
1530 if (!dev->is_tape()) {
1533 if (!dev->can_append()) {
1534 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1535 Emsg0(M_FATAL, 0, dev->errmsg);
1539 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1540 mt_com.mt_op = MTWEOF;
1541 mt_com.mt_count = num;
1542 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1549 clrerror_dev(dev, MTWEOF);
1551 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1552 dev->print_name(), be.strerror());
1559 * Return string message with last error in English
1560 * Be careful not to call this routine from within dev.c
1561 * while editing an Mmsg() or you will end up in a recursive
1562 * loop creating a Segmentation Violation.
1565 strerror_dev(DEVICE *dev)
1572 * If implemented in system, clear the tape
1576 clrerror_dev(DEVICE *dev, int func)
1578 const char *msg = NULL;
1579 struct mtget mt_stat;
1582 dev->dev_errno = errno; /* save errno */
1584 dev->VolCatInfo.VolCatErrors++;
1587 if (!dev->is_tape()) {
1590 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1593 Emsg0(M_ABORT, 0, _("Got ENOTTY on read/write!\n"));
1597 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1602 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1607 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1611 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1615 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1619 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1640 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1645 dev->dev_errno = ENOSYS;
1646 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1647 Emsg0(M_ERROR, 0, dev->errmsg);
1650 /* On some systems such as NetBSD, this clears all errors */
1651 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1653 /* Found on Linux */
1657 mt_com.mt_op = MTIOCLRERR;
1658 mt_com.mt_count = 1;
1659 /* Clear any error condition on the tape */
1660 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1661 Dmsg0(200, "Did MTIOCLRERR\n");
1665 /* Typically on FreeBSD */
1668 /* Read and clear SCSI error status */
1669 union mterrstat mt_errstat;
1670 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1671 strerror(dev->dev_errno));
1672 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1676 /* Clear Subsystem Exception OSF1 */
1680 mt_com.mt_op = MTCSE;
1681 mt_com.mt_count = 1;
1682 /* Clear any error condition on the tape */
1683 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1684 Dmsg0(200, "Did MTCSE\n");
1690 * Flush buffer contents
1693 int flush_dev(DEVICE *dev)
1698 static void do_close(DEVICE *dev)
1701 Dmsg1(100, "really close_dev %s\n", dev->print_name());
1706 if (!unmount_dev(dev, 1)) {
1707 Dmsg1(0, "Cannot unmount device %s.\n", dev->print_name());
1710 /* Remove the last part file if it is empty */
1711 if (dev->num_parts > 0) {
1713 POOL_MEM archive_name(PM_FNAME);
1714 dev->part = dev->num_parts;
1715 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", dev->VolCatInfo.VolCatName);
1716 make_spooled_dvd_filename(dev, archive_name);
1717 /* Check that the part file is empty */
1718 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1719 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1720 unlink(archive_name.c_str());
1724 /* Clean up device packet so it can be reused */
1726 dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1727 dev->label_type = B_BACULA_LABEL;
1728 dev->file = dev->block_num = 0;
1734 dev->part_start = 0;
1735 dev->EndFile = dev->EndBlock = 0;
1736 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1738 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1740 stop_thread_timer(dev->tid);
1750 void DEVICE::close()
1752 /*if (fd >= 0 && use_count == 1) {*/
1753 /* No need to check if fd >= 0: it is checked again
1754 * in do_close, and do_close MUST be called for volumes
1755 * split in parts, even if fd == -1.
1757 if (use_count == 1) {
1759 } else if (use_count > 0) {
1764 ASSERT(use_count >= 0);
1769 bool truncate_dev(DCR *dcr) /* We need the DCR for DVD-writing */
1771 DEVICE *dev = dcr->dev;
1773 Dmsg1(100, "truncate_dev %s\n", dev->print_name());
1774 if (dev->is_tape()) {
1775 return true; /* we don't really truncate tapes */
1776 /* maybe we should rewind and write and eof ???? */
1779 if (dev->is_dvd()) {
1780 return truncate_dvd_dev(dcr);
1783 if (ftruncate(dev->fd, 0) != 0) {
1785 Mmsg2(dev->errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1786 dev->print_name(), be.strerror());
1792 /* Return the resource name for the device */
1793 const char *DEVICE::name() const
1795 return device->hdr.name;
1799 dev_vol_name(DEVICE *dev)
1801 return dev->VolCatInfo.VolCatName;
1804 uint32_t dev_block(DEVICE *dev)
1806 update_pos_dev(dev);
1807 return dev->block_num;
1810 uint32_t dev_file(DEVICE *dev)
1812 update_pos_dev(dev);
1817 * Free memory allocated for the device
1820 term_dev(DEVICE *dev)
1823 dev->dev_errno = EBADF;
1824 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1825 Emsg0(M_FATAL, 0, dev->errmsg);
1828 Dmsg1(29, "term_dev: %s\n", dev->print_name());
1830 if (dev->dev_name) {
1831 free_memory(dev->dev_name);
1832 dev->dev_name = NULL;
1834 if (dev->prt_name) {
1835 free_memory(dev->prt_name);
1836 dev->prt_name = NULL;
1839 free_pool_memory(dev->errmsg);
1842 pthread_mutex_destroy(&dev->mutex);
1843 pthread_cond_destroy(&dev->wait);
1844 pthread_cond_destroy(&dev->wait_next_vol);
1845 pthread_mutex_destroy(&dev->spool_mutex);
1846 rwl_destroy(&dev->lock);
1847 if (dev->attached_dcrs) {
1848 delete dev->attached_dcrs;
1849 dev->attached_dcrs = NULL;
1851 if (dev->state & ST_MALLOC) {
1852 free_pool_memory((POOLMEM *)dev);
1857 * This routine initializes the device wait timers
1859 void init_device_wait_timers(DCR *dcr)
1861 DEVICE *dev = dcr->dev;
1862 JCR *jcr = dcr->jcr;
1864 /* ******FIXME******* put these on config variables */
1865 dev->min_wait = 60 * 60;
1866 dev->max_wait = 24 * 60 * 60;
1867 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1868 dev->wait_sec = dev->min_wait;
1869 dev->rem_wait_sec = dev->wait_sec;
1872 dev->BadVolName[0] = 0;
1874 jcr->min_wait = 60 * 60;
1875 jcr->max_wait = 24 * 60 * 60;
1876 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1877 jcr->wait_sec = jcr->min_wait;
1878 jcr->rem_wait_sec = jcr->wait_sec;
1883 void init_jcr_device_wait_timers(JCR *jcr)
1885 /* ******FIXME******* put these on config variables */
1886 jcr->min_wait = 60 * 60;
1887 jcr->max_wait = 24 * 60 * 60;
1888 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1889 jcr->wait_sec = jcr->min_wait;
1890 jcr->rem_wait_sec = jcr->wait_sec;
1896 * The dev timers are used for waiting on a particular device
1898 * Returns: true if time doubled
1899 * false if max time expired
1901 bool double_dev_wait_time(DEVICE *dev)
1903 dev->wait_sec *= 2; /* double wait time */
1904 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
1905 dev->wait_sec = dev->max_wait;
1908 dev->rem_wait_sec = dev->wait_sec;
1909 if (dev->num_wait >= dev->max_num_wait) {
1916 void set_os_device_parameters(DEVICE *dev)
1918 #ifdef HAVE_LINUX_OS
1920 if (dev->min_block_size == dev->max_block_size &&
1921 dev->min_block_size == 0) { /* variable block mode */
1922 mt_com.mt_op = MTSETBLK;
1923 mt_com.mt_count = 0;
1924 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1925 clrerror_dev(dev, MTSETBLK);
1927 mt_com.mt_op = MTSETDRVBUFFER;
1928 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
1929 if (!dev_cap(dev, CAP_TWOEOF)) {
1930 mt_com.mt_count |= MT_ST_TWO_FM;
1932 if (dev_cap(dev, CAP_EOM)) {
1933 mt_com.mt_count |= MT_ST_FAST_MTEOM;
1935 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1936 clrerror_dev(dev, MTSETBLK);
1942 #ifdef HAVE_NETBSD_OS
1944 if (dev->min_block_size == dev->max_block_size &&
1945 dev->min_block_size == 0) { /* variable block mode */
1946 mt_com.mt_op = MTSETBSIZ;
1947 mt_com.mt_count = 0;
1948 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1949 clrerror_dev(dev, MTSETBSIZ);
1951 /* Get notified at logical end of tape */
1952 mt_com.mt_op = MTEWARN;
1953 mt_com.mt_count = 1;
1954 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1955 clrerror_dev(dev, MTEWARN);
1961 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
1963 if (dev->min_block_size == dev->max_block_size &&
1964 dev->min_block_size == 0) { /* variable block mode */
1965 mt_com.mt_op = MTSETBSIZ;
1966 mt_com.mt_count = 0;
1967 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1968 clrerror_dev(dev, MTSETBSIZ);
1976 if (dev->min_block_size == dev->max_block_size &&
1977 dev->min_block_size == 0) { /* variable block mode */
1978 mt_com.mt_op = MTSRSZ;
1979 mt_com.mt_count = 0;
1980 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1981 clrerror_dev(dev, MTSRSZ);
1988 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
1990 return dev_cap(dev, CAP_MTIOCGET) &&
1991 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
1992 mt_stat->mt_fileno >= 0;
1995 static char *modes[] = {
1996 "CREATE_READ_WRITE",
2003 static char *mode_to_str(int mode)
2005 return modes[mode-1];