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");
336 timeout = max_open_wait;
339 /* Set wait counters to zero for no wait */
340 timeout = ioerrcnt = 0;
341 /* Open drive in non-block mode */
342 nonblocking = O_NONBLOCK;
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, MODE_RW)) < 0) {
354 Dmsg2(100, "Open error errno=%d ERR=%s\n", errno, be.strerror());
355 if (errno == EINTR || errno == EAGAIN) {
356 Dmsg0(100, "Continue open\n");
359 /* Busy wait for specified time (default = 5 mins) */
360 if (errno == EBUSY && timeout-- > 0) {
361 Dmsg2(100, "Device %s busy. ERR=%s\n", print_name(), be.strerror());
365 /* IO error (no volume) try 10 times every 6 seconds */
366 if (errno == EIO && ioerrcnt-- > 0) {
368 Dmsg0(100, "Continue open\n");
372 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
373 print_name(), be.strerror(dev_errno));
374 /* Stop any open timer we set */
376 stop_thread_timer(tid);
379 Emsg0(M_FATAL, 0, errmsg);
382 /* Really an if, but we use a break for an error exit */
384 /* If opened in non-block mode, make it block now */
388 /* Try to reset blocking */
389 if ((oflags = fcntl(fd, F_GETFL, 0)) < 0 ||
390 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK) < 0) {
392 Jmsg1(dcr->jcr, M_ERROR, 0, "fcntl error. ERR=%s\n", be.strerror());
393 ::close(fd); /* use system close() */
398 openmode = omode; /* save open mode */
399 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
403 update_pos_dev(this); /* update position */
404 set_os_device_parameters(this); /* do system dependent stuff */
405 Dmsg0(500, "Open OK\n");
408 /* Stop any open() timer we started */
410 stop_thread_timer(tid);
413 Dmsg1(29, "open dev: tape %d opened\n", fd);
419 void DEVICE::open_file_device(int omode)
421 POOL_MEM archive_name(PM_FNAME);
424 * Handle opening of File Archive (not a tape)
426 Dmsg3(29, "Enter: open_file_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
427 archive_name.c_str(), mode_to_str(omode));
429 if (VolCatInfo.VolCatName[0] == 0) {
430 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
436 pm_strcpy(archive_name, dev_name);
437 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
438 pm_strcat(archive_name, "/");
440 pm_strcat(archive_name, VolCatInfo.VolCatName);
442 Dmsg3(29, "open dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
443 archive_name.c_str(), mode_to_str(omode));
445 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
448 /* If creating file, give 0640 permissions */
449 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
450 archive_name.c_str(), mode);
451 /* Use system open() */
452 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
455 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
457 Dmsg1(29, "open failed: %s", errmsg);
458 Emsg0(M_FATAL, 0, errmsg);
463 update_pos_dev(this); /* update position */
465 Dmsg5(29, "open dev: %s fd=%d opened, part=%d/%d, part_size=%u\n",
466 is_dvd()?"DVD":"disk", fd, part, num_parts,
471 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName (NB:??? I think it's VolCatInfo.VolCatName that is right)
472 * has the desired Volume name, but there is NO assurance that
473 * any other field of VolCatInfo is correct.
475 void DEVICE::open_dvd_device(DCR *dcr, int omode)
477 POOL_MEM archive_name(PM_FNAME);
478 struct stat filestat;
481 * Handle opening of DVD Volume
483 Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
484 archive_name.c_str(), mode_to_str(omode));
486 if (VolCatInfo.VolCatName[0] == 0) {
487 Dmsg1(10, "Could not open file device %s. No Volume name given.\n",
489 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
500 Dmsg2(99, "open_dvd_device: num_parts=%d, VolCatInfo.VolCatParts=%d\n",
501 dcr->dev->num_parts, dcr->VolCatInfo.VolCatParts);
502 if (dcr->dev->num_parts < dcr->VolCatInfo.VolCatParts) {
503 Dmsg2(99, "open_dvd_device: num_parts updated to %d (was %d)\n",
504 dcr->VolCatInfo.VolCatParts, dcr->dev->num_parts);
505 dcr->dev->num_parts = dcr->VolCatInfo.VolCatParts;
508 if (mount_dev(this, 1)) {
509 if ((num_parts == 0) && (!truncating)) {
510 /* If we can mount the device, and we are not truncating the DVD, we usually want to abort. */
511 /* There is one exception, if there is only one 0-sized file on the DVD, with the right volume name,
512 * we continue (it's the method used by truncate_dvd_dev to truncate a volume). */
513 if (!check_can_write_on_non_blank_dvd(dcr)) {
514 Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
515 Emsg0(M_FATAL, 0, errmsg);
522 /* We cannot mount the device */
523 if (num_parts == 0) {
524 /* Run free space, check there is a media. */
525 update_free_space_dev(this);
527 Dmsg1(29, "Could not mount device %s, this is not a problem (num_parts == 0), and have media.\n", print_name());
530 Mmsg(errmsg, _("There is no valid media in the device %s.\n"), print_name());
531 Emsg0(M_FATAL, 0, errmsg);
537 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
538 Emsg0(M_FATAL, 0, errmsg);
544 Dmsg6(29, "open dev: %s dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
545 is_dvd()?"DVD":"disk", archive_name.c_str(), mode_to_str(omode),
546 part, num_parts, dcr->VolCatInfo.VolCatParts);
548 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
551 * If we are not trying to access the last part, set mode to
552 * OPEN_READ_ONLY as writing would be an error.
554 if (part < num_parts) {
555 omode = OPEN_READ_ONLY;
556 make_mounted_dvd_filename(this, archive_name);
559 make_spooled_dvd_filename(this, archive_name);
563 /* If creating file, give 0640 permissions */
564 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
565 archive_name.c_str(), mode);
566 /* Use system open() */
567 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
569 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
571 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
572 Dmsg1(29, "open failed: %s", errmsg);
574 if ((omode == OPEN_READ_ONLY) && (part == num_parts)) {
575 /* If the last part (on spool), doesn't exists when reading, create it and read from it
576 * (it will report immediately an EOF):
577 * Sometimes it is better to finish with an EOF than with an error. */
578 set_mode(OPEN_READ_WRITE);
579 fd = ::open(archive_name.c_str(), mode, 0640);
580 set_mode(OPEN_READ_ONLY);
583 /* We don't need it. Only the last part is on spool */
584 /*if (omode == OPEN_READ_ONLY) {
585 make_spooled_dvd_filename(this, archive_name);
586 fd = ::open(archive_name.c_str(), mode, 0640); // try on spool
589 Dmsg1(100, "after open fd=%d\n", fd);
591 /* Get size of file */
592 if (fstat(fd, &filestat) < 0) {
595 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
597 Dmsg1(29, "open failed: %s", errmsg);
598 /* Use system close() */
602 part_size = filestat.st_size;
606 update_pos_dev(this); /* update position */
608 /* NB: It seems this code is wrong... part number is incremented in open_next_part, not here */
610 /* Check if just created Volume part */
611 /* if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
614 VolCatInfo.VolCatParts = num_parts;
616 if (part == 0) { // we must have opened the first part
627 bool _rewind_dev(char *file, int line, DEVICE *dev)
629 Dmsg3(100, "rewind_dev fd=%d called from %s:%d\n", dev->fd, file, line);
630 return rewind_dev(dev);
636 * Returns: true on success
639 bool rewind_dev(DEVICE *dev)
644 Dmsg2(29, "rewind_dev fd=%d %s\n", dev->fd, dev->print_name());
646 if (!dev->is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
647 dev->dev_errno = EBADF;
648 Mmsg1(dev->errmsg, _("Bad call to rewind_dev. Device %s not open\n"),
650 Emsg0(M_ABORT, 0, dev->errmsg);
654 dev->state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
655 dev->block_num = dev->file = 0;
658 if (dev->is_tape()) {
659 mt_com.mt_op = MTREW;
661 /* If we get an I/O error on rewind, it is probably because
662 * the drive is actually busy. We loop for (about 5 minutes)
663 * retrying every 5 seconds.
665 for (i=dev->max_rewind_wait; ; i -= 5) {
666 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
668 clrerror_dev(dev, MTREW);
669 if (i == dev->max_rewind_wait) {
670 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
672 if (dev->dev_errno == EIO && i > 0) {
673 Dmsg0(200, "Sleeping 5 seconds.\n");
677 Mmsg2(dev->errmsg, _("Rewind error on %s. ERR=%s.\n"),
678 dev->print_name(), be.strerror());
683 } else if (dev->is_file()) {
684 if (lseek_dev(dev, (off_t)0, SEEK_SET) < 0) {
686 dev->dev_errno = errno;
687 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
688 dev->print_name(), be.strerror());
695 void DEVICE::block(int why)
698 block_device(this, why);
702 void DEVICE::unblock()
705 unblock_device(this);
709 const char *DEVICE::print_blocked() const
711 switch (dev_blocked) {
712 case BST_NOT_BLOCKED:
713 return "BST_NOT_BLOCKED";
715 return "BST_UNMOUNTED";
716 case BST_WAITING_FOR_SYSOP:
717 return "BST_WAITING_FOR_SYSOP";
718 case BST_DOING_ACQUIRE:
719 return "BST_DOING_ACQUIRE";
720 case BST_WRITING_LABEL:
721 return "BST_WRITING_LABEL";
722 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
723 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
727 return "unknown blocked code";
732 * Called to indicate that we have just read an
733 * EOF from the device.
735 void DEVICE::set_ateof()
745 * Called to indicate we are now at the end of the tape, and
746 * writing is not possible.
748 void DEVICE::set_ateot()
750 /* Make tape effectively read-only */
751 state |= (ST_EOF|ST_EOT|ST_WEOT);
756 * Position device to end of medium (end of data)
757 * Returns: true on succes
764 struct mtget mt_stat;
769 dev->dev_errno = EBADF;
770 Mmsg1(dev->errmsg, _("Bad call to eod_dev. Device %s not open\n"),
775 #if defined (__digital__) && defined (__unix__)
776 return dev->fsf(dev->VolCatInfo.VolCatFiles);
779 Dmsg0(29, "eod_dev\n");
783 dev->state &= ~(ST_EOF); /* remove EOF flags */
784 dev->block_num = dev->file = 0;
787 if (dev->state & (ST_FIFO | ST_PROG)) {
790 if (!dev->is_tape()) {
791 pos = lseek_dev(dev, (off_t)0, SEEK_END);
792 // Dmsg1(100, "====== Seek to %lld\n", pos);
795 dev->state |= ST_EOT;
798 dev->dev_errno = errno;
800 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
801 dev->print_name(), be.strerror());
805 if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
806 Dmsg0(100,"Using FAST FSF for EOM\n");
807 /* If unknown position, rewind */
808 if (!dev_get_os_pos(dev, &mt_stat)) {
809 if (!rewind_dev(dev)) {
813 mt_com.mt_op = MTFSF;
815 * ***FIXME*** fix code to handle case that INT16_MAX is
818 mt_com.mt_count = INT16_MAX; /* use big positive number */
819 if (mt_com.mt_count < 0) {
820 mt_com.mt_count = INT16_MAX; /* brain damaged system */
824 if (dev_cap(dev, CAP_MTIOCGET) && (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM))) {
825 if (dev_cap(dev, CAP_EOM)) {
826 Dmsg0(100,"Using EOM for EOM\n");
827 mt_com.mt_op = MTEOM;
831 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
833 clrerror_dev(dev, mt_com.mt_op);
834 Dmsg1(50, "ioctl error: %s\n", be.strerror());
836 Mmsg2(dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
837 dev->print_name(), be.strerror());
841 if (!dev_get_os_pos(dev, &mt_stat)) {
843 clrerror_dev(dev, -1);
844 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
845 dev->print_name(), be.strerror());
848 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
850 dev->file = mt_stat.mt_fileno;
856 * Rewind then use FSF until EOT reached
858 if (!rewind_dev(dev)) {
862 * Move file by file to the end of the tape
865 for (file_num=dev->file; !dev->at_eot(); file_num++) {
866 Dmsg0(200, "eod_dev: doing fsf 1\n");
868 Dmsg0(200, "fsf error.\n");
872 * Avoid infinite loop. ***FIXME*** possibly add code
873 * to set EOD or to turn off CAP_FASTFSF if on.
875 if (file_num == (int)dev->file) {
876 struct mtget mt_stat;
877 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
878 if (dev_get_os_pos(dev, &mt_stat)) {
879 Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
881 dev->file = mt_stat.mt_fileno;
888 * Some drivers leave us after second EOF when doing
889 * MTEOM, so we must backup so that appending overwrites
892 if (dev_cap(dev, CAP_BSFATEOM)) {
893 struct mtget mt_stat;
894 /* Backup over EOF */
895 ok = bsf_dev(dev, 1);
896 /* If BSF worked and fileno is known (not -1), set file */
897 if (dev_get_os_pos(dev, &mt_stat)) {
898 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
899 dev->file = mt_stat.mt_fileno;
901 dev->file++; /* wing it -- not correct on all OSes */
904 update_pos_dev(dev); /* update position */
906 Dmsg1(200, "EOD dev->file=%d\n", dev->file);
911 * Set the position of the device -- only for files and DVD
912 * For other devices, there is no generic way to do it.
913 * Returns: true on succes
916 bool update_pos_dev(DEVICE *dev)
922 dev->dev_errno = EBADF;
923 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
924 Emsg0(M_FATAL, 0, dev->errmsg);
928 /* Find out where we are */
929 if (dev->is_file()) {
932 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
935 dev->dev_errno = errno;
936 Pmsg1(000, "Seek error: ERR=%s\n", be.strerror());
937 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
938 dev->print_name(), be.strerror());
941 dev->file_addr = pos;
949 * Return the status of the device. This was meant
950 * to be a generic routine. Unfortunately, it doesn't
951 * seem possible (at least I do not know how to do it
952 * currently), which means that for the moment, this
953 * routine has very little value.
957 uint32_t status_dev(DEVICE *dev)
959 struct mtget mt_stat;
962 if (dev->state & (ST_EOT | ST_WEOT)) {
966 if (dev->state & ST_EOF) {
970 if (dev->is_tape()) {
972 Pmsg0(-20," Bacula status:");
973 Pmsg2(-20," file=%d block=%d\n", dev->file, dev->block_num);
974 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
976 dev->dev_errno = errno;
977 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
978 dev->print_name(), be.strerror());
981 Pmsg0(-20, " Device status:");
983 #if defined(HAVE_LINUX_OS)
984 if (GMT_EOF(mt_stat.mt_gstat)) {
988 if (GMT_BOT(mt_stat.mt_gstat)) {
992 if (GMT_EOT(mt_stat.mt_gstat)) {
996 if (GMT_SM(mt_stat.mt_gstat)) {
1000 if (GMT_EOD(mt_stat.mt_gstat)) {
1004 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1005 stat |= BMT_WR_PROT;
1006 Pmsg0(-20, " WR_PROT");
1008 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1010 Pmsg0(-20, " ONLINE");
1012 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1013 stat |= BMT_DR_OPEN;
1014 Pmsg0(-20, " DR_OPEN");
1016 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1017 stat |= BMT_IM_REP_EN;
1018 Pmsg0(-20, " IM_REP_EN");
1020 #endif /* !SunOS && !OSF */
1021 if (dev_cap(dev, CAP_MTIOCGET)) {
1022 Pmsg2(-20, " file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1024 Pmsg2(-20, " file=%d block=%d\n", -1, -1);
1027 stat |= BMT_ONLINE | BMT_BOT;
1034 * Load medium in device
1035 * Returns: true on success
1038 bool load_dev(DEVICE *dev)
1045 dev->dev_errno = EBADF;
1046 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1047 Emsg0(M_FATAL, 0, dev->errmsg);
1050 if (!(dev->is_tape())) {
1054 Dmsg0(200, "stored: MTLOAD command not available\n");
1056 dev->dev_errno = ENOTTY; /* function not available */
1057 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1058 dev->print_name(), be.strerror());
1062 dev->block_num = dev->file = 0;
1065 mt_com.mt_op = MTLOAD;
1066 mt_com.mt_count = 1;
1067 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1069 dev->dev_errno = errno;
1070 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1071 dev->print_name(), be.strerror());
1079 * Rewind device and put it offline
1080 * Returns: true on success
1083 bool offline_dev(DEVICE *dev)
1088 dev->dev_errno = EBADF;
1089 Mmsg0(dev->errmsg, _("Bad call to offline_dev. Device not open\n"));
1090 Emsg0(M_FATAL, 0, dev->errmsg);
1093 if (!(dev->is_tape())) {
1097 dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1098 dev->block_num = dev->file = 0;
1103 mt_com.mt_op = MTUNLOCK;
1104 mt_com.mt_count = 1;
1105 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1107 mt_com.mt_op = MTOFFL;
1108 mt_com.mt_count = 1;
1109 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1111 dev->dev_errno = errno;
1112 Mmsg2(dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1113 dev->print_name(), be.strerror());
1116 Dmsg1(100, "Offlined device %s\n", dev->print_name());
1120 bool offline_or_rewind_dev(DEVICE *dev)
1125 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1126 return offline_dev(dev);
1129 * Note, this rewind probably should not be here (it wasn't
1130 * in prior versions of Bacula), but on FreeBSD, this is
1131 * needed in the case the tape was "frozen" due to an error
1132 * such as backspacing after writing and EOF. If it is not
1133 * done, all future references to the drive get and I/O error.
1135 clrerror_dev(dev, MTREW);
1136 return rewind_dev(dev);
1141 * Foward space a file
1142 * Returns: true on success
1145 bool DEVICE::fsf(int num)
1147 struct mtget mt_stat;
1153 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1154 Emsg0(M_FATAL, 0, errmsg);
1163 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1167 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1170 Dmsg0(100, "fsf\n");
1173 * If Fast forward space file is set, then we
1174 * use MTFSF to forward space and MTIOCGET
1175 * to get the file position. We assume that
1176 * the SCSI driver will ensure that we do not
1177 * forward space past the end of the medium.
1179 if (dev_cap(this, CAP_FSF) && dev_cap(this, CAP_MTIOCGET) && dev_cap(this, CAP_FASTFSF)) {
1180 mt_com.mt_op = MTFSF;
1181 mt_com.mt_count = num;
1182 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1183 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1186 Dmsg0(200, "Set ST_EOT\n");
1187 clrerror_dev(this, MTFSF);
1188 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1189 print_name(), be.strerror());
1190 Dmsg1(200, "%s", errmsg);
1193 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1195 file = mt_stat.mt_fileno;
1199 * Here if CAP_FSF is set, and virtually all drives
1200 * these days support it, we read a record, then forward
1201 * space one file. Using this procedure, which is slow,
1202 * is the only way we can be sure that we don't read
1203 * two consecutive EOF marks, which means End of Data.
1205 } else if (dev_cap(this, CAP_FSF)) {
1208 Dmsg0(200, "FSF has cap_fsf\n");
1209 if (max_block_size == 0) {
1210 rbuf_len = DEFAULT_BLOCK_SIZE;
1212 rbuf_len = max_block_size;
1214 rbuf = get_memory(rbuf_len);
1215 mt_com.mt_op = MTFSF;
1216 mt_com.mt_count = 1;
1217 while (num-- && !at_eot()) {
1218 Dmsg0(100, "Doing read before fsf\n");
1219 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1220 if (errno == ENOMEM) { /* tape record exceeds buf len */
1221 stat = rbuf_len; /* This is OK */
1223 * On IBM drives, they return ENOSPC at EOM
1224 * instead of EOF status
1226 } else if (at_eof() && errno == ENOSPC) {
1231 clrerror_dev(this, -1);
1232 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1234 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1235 print_name(), be.strerror());
1236 Dmsg1(100, "%s", errmsg);
1240 if (stat == 0) { /* EOF */
1241 update_pos_dev(this);
1242 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1243 /* Two reads of zero means end of tape */
1246 Dmsg0(100, "Set ST_EOT\n");
1252 } else { /* Got data */
1257 Dmsg0(100, "Doing MTFSF\n");
1258 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1259 if (stat < 0) { /* error => EOT */
1262 Dmsg0(100, "Set ST_EOT\n");
1263 clrerror_dev(this, MTFSF);
1264 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1265 print_name(), be.strerror());
1266 Dmsg0(100, "Got < 0 for MTFSF\n");
1267 Dmsg1(100, "%s", errmsg);
1275 * No FSF, so use FSR to simulate it
1278 Dmsg0(200, "Doing FSR for FSF\n");
1279 while (num-- && !at_eot()) {
1280 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1284 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1290 update_pos_dev(this);
1291 Dmsg1(200, "Return %d from FSF\n", stat);
1293 Dmsg0(200, "ST_EOF set on exit FSF\n");
1295 Dmsg0(200, "ST_EOT set on exit FSF\n");
1296 Dmsg1(200, "Return from FSF file=%d\n", file);
1301 * Backward space a file
1302 * Returns: false on failure
1306 bsf_dev(DEVICE *dev, int num)
1312 dev->dev_errno = EBADF;
1313 Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Device not open\n"));
1314 Emsg0(M_FATAL, 0, dev->errmsg);
1318 if (!dev->is_tape()) {
1319 Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1323 Dmsg0(29, "bsf_dev\n");
1324 dev->state &= ~(ST_EOT|ST_EOF);
1328 mt_com.mt_op = MTBSF;
1329 mt_com.mt_count = num;
1330 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1333 clrerror_dev(dev, MTBSF);
1334 Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1335 dev->print_name(), be.strerror());
1337 update_pos_dev(dev);
1343 * Foward space num records
1344 * Returns: false on failure
1347 bool DEVICE::fsr(int num)
1354 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1355 Emsg0(M_FATAL, 0, errmsg);
1362 if (!dev_cap(this, CAP_FSR)) {
1363 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1367 Dmsg1(29, "fsr %d\n", num);
1368 mt_com.mt_op = MTFSR;
1369 mt_com.mt_count = num;
1370 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1376 struct mtget mt_stat;
1377 clrerror_dev(this, MTFSR);
1378 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1379 if (dev_get_os_pos(this, &mt_stat)) {
1380 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1381 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1382 file = mt_stat.mt_fileno;
1383 block_num = mt_stat.mt_blkno;
1391 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1392 num, print_name(), be.strerror());
1394 update_pos_dev(this);
1399 * Backward space a record
1400 * Returns: false on failure
1404 bsr_dev(DEVICE *dev, int num)
1410 dev->dev_errno = EBADF;
1411 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1412 Emsg0(M_FATAL, 0, dev->errmsg);
1416 if (!dev->is_tape()) {
1420 if (!dev_cap(dev, CAP_BSR)) {
1421 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1425 Dmsg0(29, "bsr_dev\n");
1426 dev->block_num -= num;
1427 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1428 mt_com.mt_op = MTBSR;
1429 mt_com.mt_count = num;
1430 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1433 clrerror_dev(dev, MTBSR);
1434 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1435 dev->print_name(), be.strerror());
1437 update_pos_dev(dev);
1442 * Reposition the device to file, block
1443 * Returns: false on failure
1447 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1450 dev->dev_errno = EBADF;
1451 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1452 Emsg0(M_FATAL, 0, dev->errmsg);
1456 if (!dev->is_tape()) {
1457 off_t pos = (((off_t)file)<<32) + (off_t)block;
1458 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1459 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1461 dev->dev_errno = errno;
1462 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1463 dev->print_name(), be.strerror());
1467 dev->block_num = block;
1468 dev->file_addr = pos;
1471 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1472 dev->file, dev->block_num, file, block);
1473 if (file < dev->file) {
1474 Dmsg0(100, "Rewind_dev\n");
1475 if (!rewind_dev(dev)) {
1479 if (file > dev->file) {
1480 Dmsg1(100, "fsf %d\n", file-dev->file);
1481 if (!dev->fsf(file-dev->file)) {
1482 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1485 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1487 if (block < dev->block_num) {
1488 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1489 Dmsg0(100, "bsf_dev 1\n");
1491 Dmsg0(100, "fsf_dev 1\n");
1493 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1495 if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1496 /* Ignore errors as Bacula can read to the correct block */
1497 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1498 return dev->fsr(block-dev->block_num);
1506 * Write an end of file on the device
1507 * Returns: 0 on success
1508 * non-zero on failure
1511 weof_dev(DEVICE *dev, int num)
1515 Dmsg0(29, "weof_dev\n");
1518 dev->dev_errno = EBADF;
1519 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1520 Emsg0(M_FATAL, 0, dev->errmsg);
1525 if (!dev->is_tape()) {
1528 if (!dev->can_append()) {
1529 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1530 Emsg0(M_FATAL, 0, dev->errmsg);
1534 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1535 mt_com.mt_op = MTWEOF;
1536 mt_com.mt_count = num;
1537 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1544 clrerror_dev(dev, MTWEOF);
1546 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1547 dev->print_name(), be.strerror());
1554 * Return string message with last error in English
1555 * Be careful not to call this routine from within dev.c
1556 * while editing an Mmsg() or you will end up in a recursive
1557 * loop creating a Segmentation Violation.
1560 strerror_dev(DEVICE *dev)
1567 * If implemented in system, clear the tape
1571 clrerror_dev(DEVICE *dev, int func)
1573 const char *msg = NULL;
1574 struct mtget mt_stat;
1577 dev->dev_errno = errno; /* save errno */
1579 dev->VolCatInfo.VolCatErrors++;
1582 if (!dev->is_tape()) {
1585 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1588 Emsg0(M_ABORT, 0, "Got ENOTTY on read/write!\n");
1592 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1597 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1602 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1606 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1610 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1614 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1635 bsnprintf(buf, sizeof(buf), "unknown func code %d", func);
1640 dev->dev_errno = ENOSYS;
1641 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1642 Emsg0(M_ERROR, 0, dev->errmsg);
1645 /* On some systems such as NetBSD, this clears all errors */
1646 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1648 /* Found on Linux */
1652 mt_com.mt_op = MTIOCLRERR;
1653 mt_com.mt_count = 1;
1654 /* Clear any error condition on the tape */
1655 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1656 Dmsg0(200, "Did MTIOCLRERR\n");
1660 /* Typically on FreeBSD */
1663 /* Read and clear SCSI error status */
1664 union mterrstat mt_errstat;
1665 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1666 strerror(dev->dev_errno));
1667 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1671 /* Clear Subsystem Exception OSF1 */
1675 mt_com.mt_op = MTCSE;
1676 mt_com.mt_count = 1;
1677 /* Clear any error condition on the tape */
1678 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1679 Dmsg0(200, "Did MTCSE\n");
1685 * Flush buffer contents
1688 int flush_dev(DEVICE *dev)
1693 static void do_close(DEVICE *dev)
1696 Dmsg1(29, "really close_dev %s\n", dev->print_name());
1701 if (!unmount_dev(dev, 1)) {
1702 Dmsg1(0, "Cannot unmount device %s.\n", dev->print_name());
1705 /* Remove the last part file if it is empty */
1706 if (dev->num_parts > 0) {
1708 POOL_MEM archive_name(PM_FNAME);
1709 dev->part = dev->num_parts;
1710 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", dev->VolCatInfo.VolCatName);
1711 make_spooled_dvd_filename(dev, archive_name);
1712 /* Check that the part file is empty */
1713 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1714 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1715 unlink(archive_name.c_str());
1719 /* Clean up device packet so it can be reused */
1721 dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1722 dev->label_type = B_BACULA_LABEL;
1723 dev->file = dev->block_num = 0;
1729 dev->part_start = 0;
1730 dev->EndFile = dev->EndBlock = 0;
1731 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1733 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1735 stop_thread_timer(dev->tid);
1745 void DEVICE::close()
1747 /*if (fd >= 0 && use_count == 1) {*/
1748 /* No need to check if fd >= 0: it is checked again
1749 * in do_close, and do_close MUST be called for volumes
1750 * splitted in parts, even if fd == -1. */
1751 if (use_count == 1) {
1753 } else if (use_count > 0) {
1758 ASSERT(use_count >= 0);
1763 bool truncate_dev(DCR *dcr) /* We need the DCR for DVD-writing */
1765 DEVICE *dev = dcr->dev;
1767 Dmsg1(100, "truncate_dev %s\n", dev->print_name());
1768 if (dev->is_tape()) {
1769 return true; /* we don't really truncate tapes */
1770 /* maybe we should rewind and write and eof ???? */
1773 if (dev->is_dvd()) {
1774 return truncate_dvd_dev(dcr);
1777 if (ftruncate(dev->fd, 0) != 0) {
1779 Mmsg2(dev->errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1780 dev->print_name(), be.strerror());
1786 /* Return the resource name for the device */
1787 const char *DEVICE::name() const
1789 return device->hdr.name;
1793 dev_vol_name(DEVICE *dev)
1795 return dev->VolCatInfo.VolCatName;
1798 uint32_t dev_block(DEVICE *dev)
1800 update_pos_dev(dev);
1801 return dev->block_num;
1804 uint32_t dev_file(DEVICE *dev)
1806 update_pos_dev(dev);
1811 * Free memory allocated for the device
1814 term_dev(DEVICE *dev)
1817 dev->dev_errno = EBADF;
1818 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1819 Emsg0(M_FATAL, 0, dev->errmsg);
1822 Dmsg1(29, "term_dev: %s\n", dev->print_name());
1824 if (dev->dev_name) {
1825 free_memory(dev->dev_name);
1826 dev->dev_name = NULL;
1828 if (dev->prt_name) {
1829 free_memory(dev->prt_name);
1830 dev->prt_name = NULL;
1833 free_pool_memory(dev->errmsg);
1836 pthread_mutex_destroy(&dev->mutex);
1837 pthread_cond_destroy(&dev->wait);
1838 pthread_cond_destroy(&dev->wait_next_vol);
1839 pthread_mutex_destroy(&dev->spool_mutex);
1840 rwl_destroy(&dev->lock);
1841 if (dev->attached_dcrs) {
1842 delete dev->attached_dcrs;
1843 dev->attached_dcrs = NULL;
1845 if (dev->state & ST_MALLOC) {
1846 free_pool_memory((POOLMEM *)dev);
1851 * This routine initializes the device wait timers
1853 void init_device_wait_timers(DCR *dcr)
1855 DEVICE *dev = dcr->dev;
1856 JCR *jcr = dcr->jcr;
1858 /* ******FIXME******* put these on config variables */
1859 dev->min_wait = 60 * 60;
1860 dev->max_wait = 24 * 60 * 60;
1861 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1862 dev->wait_sec = dev->min_wait;
1863 dev->rem_wait_sec = dev->wait_sec;
1866 dev->BadVolName[0] = 0;
1868 jcr->min_wait = 60 * 60;
1869 jcr->max_wait = 24 * 60 * 60;
1870 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1871 jcr->wait_sec = jcr->min_wait;
1872 jcr->rem_wait_sec = jcr->wait_sec;
1877 void init_jcr_device_wait_timers(JCR *jcr)
1879 /* ******FIXME******* put these on config variables */
1880 jcr->min_wait = 60 * 60;
1881 jcr->max_wait = 24 * 60 * 60;
1882 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1883 jcr->wait_sec = jcr->min_wait;
1884 jcr->rem_wait_sec = jcr->wait_sec;
1890 * The dev timers are used for waiting on a particular device
1892 * Returns: true if time doubled
1893 * false if max time expired
1895 bool double_dev_wait_time(DEVICE *dev)
1897 dev->wait_sec *= 2; /* double wait time */
1898 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
1899 dev->wait_sec = dev->max_wait;
1902 dev->rem_wait_sec = dev->wait_sec;
1903 if (dev->num_wait >= dev->max_num_wait) {
1910 void set_os_device_parameters(DEVICE *dev)
1912 #ifdef HAVE_LINUX_OS
1914 if (dev->min_block_size == dev->max_block_size &&
1915 dev->min_block_size == 0) { /* variable block mode */
1916 mt_com.mt_op = MTSETBLK;
1917 mt_com.mt_count = 0;
1918 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1919 clrerror_dev(dev, MTSETBLK);
1921 mt_com.mt_op = MTSETDRVBUFFER;
1922 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
1923 if (!dev_cap(dev, CAP_TWOEOF)) {
1924 mt_com.mt_count |= MT_ST_TWO_FM;
1926 if (dev_cap(dev, CAP_EOM)) {
1927 mt_com.mt_count |= MT_ST_FAST_MTEOM;
1929 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1930 clrerror_dev(dev, MTSETBLK);
1936 #ifdef HAVE_NETBSD_OS
1938 if (dev->min_block_size == dev->max_block_size &&
1939 dev->min_block_size == 0) { /* variable block mode */
1940 mt_com.mt_op = MTSETBSIZ;
1941 mt_com.mt_count = 0;
1942 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1943 clrerror_dev(dev, MTSETBSIZ);
1945 /* Get notified at logical end of tape */
1946 mt_com.mt_op = MTEWARN;
1947 mt_com.mt_count = 1;
1948 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1949 clrerror_dev(dev, MTEWARN);
1955 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
1957 if (dev->min_block_size == dev->max_block_size &&
1958 dev->min_block_size == 0) { /* variable block mode */
1959 mt_com.mt_op = MTSETBSIZ;
1960 mt_com.mt_count = 0;
1961 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1962 clrerror_dev(dev, MTSETBSIZ);
1970 if (dev->min_block_size == dev->max_block_size &&
1971 dev->min_block_size == 0) { /* variable block mode */
1972 mt_com.mt_op = MTSRSZ;
1973 mt_com.mt_count = 0;
1974 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1975 clrerror_dev(dev, MTSRSZ);
1982 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
1984 return dev_cap(dev, CAP_MTIOCGET) &&
1985 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
1986 mt_stat->mt_fileno >= 0;
1989 static char *modes[] = {
1990 "CREATE_READ_WRITE",
1997 static char *mode_to_str(int mode)
1999 return modes[mode-1];