3 * dev.c -- low level operations on device (storage device)
7 * NOTE!!!! None of these routines are reentrant. You must
8 * use lock_device() and unlock_device() at a higher level,
9 * or use the xxx_device() equivalents. By moving the
10 * thread synchronization to a higher level, we permit
11 * the higher level routines to "seize" the device and
12 * to carry out operations without worrying about who
13 * set what lock (i.e. race conditions).
15 * Note, this is the device dependent code, and my have
16 * to be modified for each system, but is meant to
17 * be as "generic" as possible.
19 * The purpose of this code is to develop a SIMPLE Storage
20 * daemon. More complicated coding (double buffering, writer
21 * thread, ...) is left for a later version.
23 * Unfortunately, I have had to add more and more complication
24 * to this code. This was not foreseen as noted above, and as
25 * a consequence has lead to something more contorted than is
26 * really necessary -- KES. Note, this contortion has been
27 * corrected to a large extent by a rewrite (Apr MMI).
32 Copyright (C) 2000-2005 Kern Sibbald
34 This program is free software; you can redistribute it and/or
35 modify it under the terms of the GNU General Public License
36 version 2 as amended with additional clauses defined in the
37 file LICENSE in the main source directory.
39 This program is distributed in the hope that it will be useful,
40 but WITHOUT ANY WARRANTY; without even the implied warranty of
41 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
42 the file LICENSE for additional details.
47 * Handling I/O errors and end of tape conditions are a bit tricky.
48 * This is how it is currently done when writting.
49 * On either an I/O error or end of tape,
50 * we will stop writing on the physical device (no I/O recovery is
51 * attempted at least in this daemon). The state flag will be sent
52 * to include ST_EOT, which is ephimeral, and ST_WEOT, which is
53 * persistent. Lots of routines clear ST_EOT, but ST_WEOT is
54 * cleared only when the problem goes away. Now when ST_WEOT
55 * is set all calls to write_block_to_device() call the fix_up
56 * routine. In addition, all threads are blocked
57 * from writing on the tape by calling lock_dev(), and thread other
58 * than the first thread to hit the EOT will block on a condition
59 * variable. The first thread to hit the EOT will continue to
60 * be able to read and write the tape (he sort of tunnels through
61 * the locking mechanism -- see lock_dev() for details).
63 * Now presumably somewhere higher in the chain of command
64 * (device.c), someone will notice the EOT condition and
65 * get a new tape up, get the tape label read, and mark
66 * the label for rewriting. Then this higher level routine
67 * will write the unwritten buffer to the new volume.
68 * Finally, he will release
69 * any blocked threads by doing a broadcast on the condition
70 * variable. At that point, we should be totally back in
71 * business with no lost data.
82 /* Forward referenced functions */
83 void set_os_device_parameters(DEVICE *dev);
84 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat);
85 static char *mode_to_str(int mode);
88 * Allocate and initialize the DEVICE structure
89 * Note, if dev is non-NULL, it is already allocated,
90 * thus we neither allocate it nor free it. This allows
91 * the caller to put the packet in shared memory.
93 * Note, for a tape, the device->device_name is the device name
94 * (e.g. /dev/nst0), and for a file, the device name
95 * is the directory in which the file will be placed.
99 init_dev(JCR *jcr, DEVRES *device)
107 /* Check that device is available */
108 if (stat(device->device_name, &statp) < 0) {
110 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
111 device->device_name, be.strerror());
118 if (S_ISDIR(statp.st_mode)) {
120 } else if (S_ISCHR(statp.st_mode)) {
122 } else if (S_ISFIFO(statp.st_mode)) {
124 } else if (!(device->cap_bits & CAP_REQMOUNT)) {
125 Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
126 " or have RequiresMount=yes for DVD. st_mode=%x\n"),
127 device->device_name, statp.st_mode);
131 dev = (DEVICE *)get_memory(sizeof(DEVICE));
132 memset(dev, 0, sizeof(DEVICE));
133 dev->state = ST_MALLOC;
135 /* Copy user supplied device parameters from Resource */
136 dev->dev_name = get_memory(strlen(device->device_name)+1);
137 pm_strcpy(dev->dev_name, device->device_name);
138 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
139 /* We edit "Resource-name" (physical-name) */
140 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
141 dev->capabilities = device->cap_bits;
142 dev->min_block_size = device->min_block_size;
143 dev->max_block_size = device->max_block_size;
144 dev->max_volume_size = device->max_volume_size;
145 dev->max_file_size = device->max_file_size;
146 dev->volume_capacity = device->volume_capacity;
147 dev->max_rewind_wait = device->max_rewind_wait;
148 dev->max_open_wait = device->max_open_wait;
149 dev->max_open_vols = device->max_open_vols;
150 dev->vol_poll_interval = device->vol_poll_interval;
151 dev->max_spool_size = device->max_spool_size;
152 dev->drive_index = device->drive_index;
153 dev->autoselect = device->autoselect;
154 if (tape) { /* No parts on tapes */
155 dev->max_part_size = 0;
158 dev->max_part_size = device->max_part_size;
161 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
162 dev->vol_poll_interval = 60;
164 dev->device = device;
167 dev->state |= ST_TAPE;
169 dev->state |= ST_FIFO;
170 dev->capabilities |= CAP_STREAM; /* set stream device */
172 dev->state |= ST_FILE;
175 /* If the device requires mount :
176 * - Check that the mount point is available
177 * - Check that (un)mount commands are defined
179 if (dev->is_file() && dev->requires_mount()) {
180 if (stat(device->mount_point, &statp) < 0) {
182 dev->dev_errno = errno;
183 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat mount point %s: ERR=%s\n"),
184 device->mount_point, be.strerror());
187 if (!device->mount_command || !device->unmount_command) {
188 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
190 if (!device->write_part_command) {
191 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
193 dev->state |= ST_DVD;
196 if (dev->max_block_size > 1000000) {
197 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
198 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
199 dev->max_block_size = 0;
201 if (dev->max_block_size % TAPE_BSIZE != 0) {
202 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
203 dev->max_block_size, dev->print_name());
206 dev->errmsg = get_pool_memory(PM_EMSG);
209 if ((errstat = pthread_mutex_init(&dev->mutex, NULL)) != 0) {
211 dev->dev_errno = errstat;
212 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
213 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
215 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
217 dev->dev_errno = errstat;
218 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
219 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
221 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
223 dev->dev_errno = errstat;
224 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
225 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
227 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
229 dev->dev_errno = errstat;
230 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
231 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
233 if ((errstat = rwl_init(&dev->lock)) != 0) {
235 dev->dev_errno = errstat;
236 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
237 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
241 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
242 Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
248 * Open the device with the operating system and
249 * initialize buffer pointers.
251 * Returns: -1 on error
254 * Note, for a tape, the VolName is the name we give to the
255 * volume (not really used here), but for a file, the
256 * VolName represents the name of the file to be created/opened.
257 * In the case of a file, the full name is the device name
258 * (archive_name) with the VolName concatenated.
261 DEVICE::open(DCR *dcr, int omode)
264 if (openmode == omode) {
267 ::close(fd); /* use system close so correct mode will be used on open */
269 Dmsg0(100, "Close fd for mode change.\n");
273 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
276 Dmsg4(29, "open dev: tape=%d dev_name=%s vol=%s mode=%s\n", is_tape(),
277 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
278 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
279 label_type = B_BACULA_LABEL;
280 if (is_tape() || is_fifo()) {
281 open_tape_device(dcr, omode);
282 } else if (is_dvd()) {
283 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
284 open_dvd_device(dcr, omode);
286 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
287 open_file_device(omode);
292 void DEVICE::set_mode(int new_mode)
295 case CREATE_READ_WRITE:
296 mode = O_CREAT | O_RDWR | O_BINARY;
298 case OPEN_READ_WRITE:
299 if (is_dvd() || is_file()) {
300 mode = O_CREAT | O_RDWR | O_BINARY;
302 mode = O_RDWR | O_BINARY;
306 mode = O_RDONLY | O_BINARY;
308 case OPEN_WRITE_ONLY:
309 mode = O_WRONLY | O_BINARY;
312 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
317 * If the flage open_nowait is set, which is the case
318 * when the daemon is initially trying to open the device,
319 * we open it with O_NONBLOCK set and O_RONLY, which will
320 * allow us to open normal Linux tape drives with no tape
321 * in the drive without blocking. We then immediately
322 * set blocking status so that if we read from the device they
323 * will be normal blocking reads.
325 * If later, we want to write on the device, it will be freed and
326 * reopened, but hopefully there will be a tape in the drive so
329 void DEVICE::open_tape_device(DCR *dcr, int omode)
333 int nonblocking = O_NONBLOCK;
334 Dmsg0(29, "open dev: device is tape\n");
336 if (is_tape() && is_autochanger()) {
337 get_autochanger_loaded_slot(dcr);
341 timeout = max_open_wait;
343 if (is_fifo() && timeout) {
345 tid = start_thread_timer(pthread_self(), timeout);
347 /* If busy retry each second for max_open_wait seconds */
348 Dmsg3(100, "Try open %s mode=%s nonblocking=%d\n", print_name(),
349 mode_to_str(omode), nonblocking);
350 /* Use system open() */
351 while ((fd = ::open(dev_name, mode+nonblocking)) < 0) {
354 Dmsg5(050, "Open omode=%d mode=%x nonblock=%d error errno=%d ERR=%s\n",
355 omode, mode, nonblocking, errno, be.strerror());
356 if (dev_errno == EINTR || dev_errno == EAGAIN) {
357 Dmsg0(100, "Continue open\n");
360 /* Busy wait for specified time (default = 5 mins) */
361 if (dev_errno == EBUSY && timeout-- > 0) {
362 Dmsg2(100, "Device %s busy. ERR=%s\n", print_name(), be.strerror());
366 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
367 print_name(), be.strerror(dev_errno));
368 /* Stop any open timer we set */
370 stop_thread_timer(tid);
373 Jmsg0(dcr->jcr, M_FATAL, 0, errmsg);
378 openmode = omode; /* save open mode */
380 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
384 update_pos_dev(this); /* update position */
385 set_os_device_parameters(this); /* do system dependent stuff */
388 /* Stop any open() timer we started */
390 stop_thread_timer(tid);
393 Dmsg1(29, "open dev: tape %d opened\n", fd);
396 void DEVICE::set_blocking()
399 /* Try to reset blocking */
401 if ((oflags = fcntl(fd, F_GETFL, 0)) < 0 ||
402 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK) < 0) {
404 ::close(fd); /* use system close() */
405 fd = ::open(dev_name, mode);
406 Dmsg2(100, "fcntl error. ERR=%s. Close-reopen fd=%d\n", be.strerror(), fd);
409 oflags = fcntl(fd, F_GETFL, 0);
410 if (oflags > 0 && (oflags & O_NONBLOCK)) {
411 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK);
418 void DEVICE::open_file_device(int omode)
420 POOL_MEM archive_name(PM_FNAME);
423 * Handle opening of File Archive (not a tape)
425 Dmsg3(29, "Enter: open_file_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
426 archive_name.c_str(), mode_to_str(omode));
428 if (VolCatInfo.VolCatName[0] == 0) {
429 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
435 pm_strcpy(archive_name, dev_name);
436 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
437 pm_strcat(archive_name, "/");
439 pm_strcat(archive_name, VolCatInfo.VolCatName);
441 Dmsg3(29, "open dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
442 archive_name.c_str(), mode_to_str(omode));
444 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
447 /* If creating file, give 0640 permissions */
448 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
449 archive_name.c_str(), mode);
450 /* Use system open() */
451 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
454 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
456 Dmsg1(29, "open failed: %s", errmsg);
457 Emsg0(M_FATAL, 0, errmsg);
462 update_pos_dev(this); /* update position */
464 Dmsg5(29, "open dev: %s fd=%d opened, part=%d/%d, part_size=%u\n",
465 is_dvd()?"DVD":"disk", fd, part, num_parts,
470 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName (NB:??? I think it's VolCatInfo.VolCatName that is right)
471 * has the desired Volume name, but there is NO assurance that
472 * any other field of VolCatInfo is correct.
474 void DEVICE::open_dvd_device(DCR *dcr, int omode)
476 POOL_MEM archive_name(PM_FNAME);
477 struct stat filestat;
480 * Handle opening of DVD Volume
482 Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
483 archive_name.c_str(), mode_to_str(omode));
485 if (VolCatInfo.VolCatName[0] == 0) {
486 Dmsg1(10, "Could not open file device %s. No Volume name given.\n",
488 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
499 Dmsg2(99, "open_dvd_device: num_parts=%d, VolCatInfo.VolCatParts=%d\n",
500 dcr->dev->num_parts, dcr->VolCatInfo.VolCatParts);
501 if (dcr->dev->num_parts < dcr->VolCatInfo.VolCatParts) {
502 Dmsg2(99, "open_dvd_device: num_parts updated to %d (was %d)\n",
503 dcr->VolCatInfo.VolCatParts, dcr->dev->num_parts);
504 dcr->dev->num_parts = dcr->VolCatInfo.VolCatParts;
507 if (mount_dev(this, 1)) {
508 if ((num_parts == 0) && (!truncating)) {
509 /* If we can mount the device, and we are not truncating the DVD, we usually want to abort. */
510 /* There is one exception, if there is only one 0-sized file on the DVD, with the right volume name,
511 * we continue (it's the method used by truncate_dvd_dev to truncate a volume). */
512 if (!check_can_write_on_non_blank_dvd(dcr)) {
513 Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
514 Emsg0(M_FATAL, 0, errmsg);
515 unmount_dev(this, 1); /* Unmount the device, so the operator can change it. */
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 Dmsg3(29, "rewind_dev res=%d fd=%d %s\n", dev->reserved_device,
645 dev->fd, dev->print_name());
647 if (!dev->is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
648 dev->dev_errno = EBADF;
649 Mmsg1(dev->errmsg, _("Bad call to rewind_dev. Device %s not open\n"),
651 Emsg0(M_ABORT, 0, dev->errmsg);
655 dev->state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
656 dev->block_num = dev->file = 0;
659 if (dev->is_tape()) {
660 mt_com.mt_op = MTREW;
662 /* If we get an I/O error on rewind, it is probably because
663 * the drive is actually busy. We loop for (about 5 minutes)
664 * retrying every 5 seconds.
666 for (i=dev->max_rewind_wait; ; i -= 5) {
667 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
669 clrerror_dev(dev, MTREW);
670 if (i == dev->max_rewind_wait) {
671 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
673 if (dev->dev_errno == EIO && i > 0) {
674 Dmsg0(200, "Sleeping 5 seconds.\n");
678 Mmsg2(dev->errmsg, _("Rewind error on %s. ERR=%s.\n"),
679 dev->print_name(), be.strerror());
684 } else if (dev->is_file()) {
685 if (lseek_dev(dev, (off_t)0, SEEK_SET) < 0) {
687 dev->dev_errno = errno;
688 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
689 dev->print_name(), be.strerror());
696 void DEVICE::block(int why)
699 block_device(this, why);
703 void DEVICE::unblock()
706 unblock_device(this);
710 const char *DEVICE::print_blocked() const
712 switch (dev_blocked) {
713 case BST_NOT_BLOCKED:
714 return "BST_NOT_BLOCKED";
716 return "BST_UNMOUNTED";
717 case BST_WAITING_FOR_SYSOP:
718 return "BST_WAITING_FOR_SYSOP";
719 case BST_DOING_ACQUIRE:
720 return "BST_DOING_ACQUIRE";
721 case BST_WRITING_LABEL:
722 return "BST_WRITING_LABEL";
723 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
724 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
728 return _("unknown blocked code");
733 * Called to indicate that we have just read an
734 * EOF from the device.
736 void DEVICE::set_ateof()
748 * Called to indicate we are now at the end of the tape, and
749 * writing is not possible.
751 void DEVICE::set_ateot()
753 /* Make tape effectively read-only */
754 state |= (ST_EOF|ST_EOT|ST_WEOT);
759 * Position device to end of medium (end of data)
760 * Returns: true on succes
767 struct mtget mt_stat;
772 dev->dev_errno = EBADF;
773 Mmsg1(dev->errmsg, _("Bad call to eod_dev. Device %s not open\n"),
778 #if defined (__digital__) && defined (__unix__)
779 return dev->fsf(dev->VolCatInfo.VolCatFiles);
782 Dmsg0(29, "eod_dev\n");
786 dev->state &= ~(ST_EOF); /* remove EOF flags */
787 dev->block_num = dev->file = 0;
790 if (dev->state & (ST_FIFO | ST_PROG)) {
793 if (!dev->is_tape()) {
794 pos = lseek_dev(dev, (off_t)0, SEEK_END);
795 // Dmsg1(100, "====== Seek to %lld\n", pos);
798 dev->state |= ST_EOT;
801 dev->dev_errno = errno;
803 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
804 dev->print_name(), be.strerror());
808 if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
809 Dmsg0(100,"Using FAST FSF for EOM\n");
810 /* If unknown position, rewind */
811 if (!dev_get_os_pos(dev, &mt_stat)) {
812 if (!rewind_dev(dev)) {
816 mt_com.mt_op = MTFSF;
818 * ***FIXME*** fix code to handle case that INT16_MAX is
821 mt_com.mt_count = INT16_MAX; /* use big positive number */
822 if (mt_com.mt_count < 0) {
823 mt_com.mt_count = INT16_MAX; /* brain damaged system */
827 if (dev_cap(dev, CAP_MTIOCGET) && (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM))) {
828 if (dev_cap(dev, CAP_EOM)) {
829 Dmsg0(100,"Using EOM for EOM\n");
830 mt_com.mt_op = MTEOM;
834 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
836 clrerror_dev(dev, mt_com.mt_op);
837 Dmsg1(50, "ioctl error: %s\n", be.strerror());
839 Mmsg2(dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
840 dev->print_name(), be.strerror());
844 if (!dev_get_os_pos(dev, &mt_stat)) {
846 clrerror_dev(dev, -1);
847 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
848 dev->print_name(), be.strerror());
851 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
853 dev->file = mt_stat.mt_fileno;
859 * Rewind then use FSF until EOT reached
861 if (!rewind_dev(dev)) {
865 * Move file by file to the end of the tape
868 for (file_num=dev->file; !dev->at_eot(); file_num++) {
869 Dmsg0(200, "eod_dev: doing fsf 1\n");
871 Dmsg0(200, "fsf error.\n");
875 * Avoid infinite loop by ensuring we advance.
877 if (file_num == (int)dev->file) {
878 struct mtget mt_stat;
879 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
881 if (dev_get_os_pos(dev, &mt_stat)) {
882 Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
883 dev->file = mt_stat.mt_fileno;
890 * Some drivers leave us after second EOF when doing
891 * MTEOM, so we must backup so that appending overwrites
894 if (dev_cap(dev, CAP_BSFATEOM)) {
895 struct mtget mt_stat;
896 /* Backup over EOF */
897 ok = bsf_dev(dev, 1);
898 /* If BSF worked and fileno is known (not -1), set file */
899 if (dev_get_os_pos(dev, &mt_stat)) {
900 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
901 dev->file = mt_stat.mt_fileno;
903 dev->file++; /* wing it -- not correct on all OSes */
906 update_pos_dev(dev); /* update position */
908 Dmsg1(200, "EOD dev->file=%d\n", dev->file);
913 * Set the position of the device -- only for files and DVD
914 * For other devices, there is no generic way to do it.
915 * Returns: true on succes
918 bool update_pos_dev(DEVICE *dev)
924 dev->dev_errno = EBADF;
925 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
926 Emsg0(M_FATAL, 0, dev->errmsg);
930 /* Find out where we are */
931 if (dev->is_file()) {
934 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
937 dev->dev_errno = errno;
938 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
939 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
940 dev->print_name(), be.strerror());
943 dev->file_addr = pos;
951 * Return the status of the device. This was meant
952 * to be a generic routine. Unfortunately, it doesn't
953 * seem possible (at least I do not know how to do it
954 * currently), which means that for the moment, this
955 * routine has very little value.
959 uint32_t status_dev(DEVICE *dev)
961 struct mtget mt_stat;
964 if (dev->state & (ST_EOT | ST_WEOT)) {
968 if (dev->state & ST_EOF) {
972 if (dev->is_tape()) {
974 Pmsg0(-20,_(" Bacula status:"));
975 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
976 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
978 dev->dev_errno = errno;
979 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
980 dev->print_name(), be.strerror());
983 Pmsg0(-20, _(" Device status:"));
985 #if defined(HAVE_LINUX_OS)
986 if (GMT_EOF(mt_stat.mt_gstat)) {
990 if (GMT_BOT(mt_stat.mt_gstat)) {
994 if (GMT_EOT(mt_stat.mt_gstat)) {
998 if (GMT_SM(mt_stat.mt_gstat)) {
1002 if (GMT_EOD(mt_stat.mt_gstat)) {
1006 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1007 stat |= BMT_WR_PROT;
1008 Pmsg0(-20, " WR_PROT");
1010 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1012 Pmsg0(-20, " ONLINE");
1014 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1015 stat |= BMT_DR_OPEN;
1016 Pmsg0(-20, " DR_OPEN");
1018 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1019 stat |= BMT_IM_REP_EN;
1020 Pmsg0(-20, " IM_REP_EN");
1022 #endif /* !SunOS && !OSF */
1023 if (dev_cap(dev, CAP_MTIOCGET)) {
1024 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1026 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1029 stat |= BMT_ONLINE | BMT_BOT;
1036 * Load medium in device
1037 * Returns: true on success
1040 bool load_dev(DEVICE *dev)
1047 dev->dev_errno = EBADF;
1048 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1049 Emsg0(M_FATAL, 0, dev->errmsg);
1052 if (!(dev->is_tape())) {
1056 Dmsg0(200, "stored: MTLOAD command not available\n");
1058 dev->dev_errno = ENOTTY; /* function not available */
1059 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1060 dev->print_name(), be.strerror());
1064 dev->block_num = dev->file = 0;
1067 mt_com.mt_op = MTLOAD;
1068 mt_com.mt_count = 1;
1069 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1071 dev->dev_errno = errno;
1072 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1073 dev->print_name(), be.strerror());
1081 * Rewind device and put it offline
1082 * Returns: true on success
1085 bool offline_dev(DEVICE *dev)
1089 if (!dev || dev->fd < 0 || !dev->is_tape()) {
1090 return true; /* device not open */
1093 dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1094 dev->block_num = dev->file = 0;
1099 mt_com.mt_op = MTUNLOCK;
1100 mt_com.mt_count = 1;
1101 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1103 mt_com.mt_op = MTOFFL;
1104 mt_com.mt_count = 1;
1105 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1107 dev->dev_errno = errno;
1108 Mmsg2(dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1109 dev->print_name(), be.strerror());
1112 Dmsg1(100, "Offlined device %s\n", dev->print_name());
1116 bool offline_or_rewind_dev(DEVICE *dev)
1121 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1122 return offline_dev(dev);
1125 * Note, this rewind probably should not be here (it wasn't
1126 * in prior versions of Bacula), but on FreeBSD, this is
1127 * needed in the case the tape was "frozen" due to an error
1128 * such as backspacing after writing and EOF. If it is not
1129 * done, all future references to the drive get and I/O error.
1131 clrerror_dev(dev, MTREW);
1132 return rewind_dev(dev);
1137 * Foward space a file
1138 * Returns: true on success
1141 bool DEVICE::fsf(int num)
1143 struct mtget mt_stat;
1149 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1150 Emsg0(M_FATAL, 0, errmsg);
1159 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1163 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1166 Dmsg0(100, "fsf\n");
1169 * If Fast forward space file is set, then we
1170 * use MTFSF to forward space and MTIOCGET
1171 * to get the file position. We assume that
1172 * the SCSI driver will ensure that we do not
1173 * forward space past the end of the medium.
1175 if (dev_cap(this, CAP_FSF) && dev_cap(this, CAP_MTIOCGET) && dev_cap(this, CAP_FASTFSF)) {
1176 mt_com.mt_op = MTFSF;
1177 mt_com.mt_count = num;
1178 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1179 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1182 Dmsg0(200, "Set ST_EOT\n");
1183 clrerror_dev(this, MTFSF);
1184 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1185 print_name(), be.strerror());
1186 Dmsg1(200, "%s", errmsg);
1189 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1191 file = mt_stat.mt_fileno;
1195 * Here if CAP_FSF is set, and virtually all drives
1196 * these days support it, we read a record, then forward
1197 * space one file. Using this procedure, which is slow,
1198 * is the only way we can be sure that we don't read
1199 * two consecutive EOF marks, which means End of Data.
1201 } else if (dev_cap(this, CAP_FSF)) {
1204 Dmsg0(200, "FSF has cap_fsf\n");
1205 if (max_block_size == 0) {
1206 rbuf_len = DEFAULT_BLOCK_SIZE;
1208 rbuf_len = max_block_size;
1210 rbuf = get_memory(rbuf_len);
1211 mt_com.mt_op = MTFSF;
1212 mt_com.mt_count = 1;
1213 while (num-- && !at_eot()) {
1214 Dmsg0(100, "Doing read before fsf\n");
1215 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1216 if (errno == ENOMEM) { /* tape record exceeds buf len */
1217 stat = rbuf_len; /* This is OK */
1219 * On IBM drives, they return ENOSPC at EOM
1220 * instead of EOF status
1222 } else if (at_eof() && errno == ENOSPC) {
1227 clrerror_dev(this, -1);
1228 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1230 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1231 print_name(), be.strerror());
1232 Dmsg1(100, "%s", errmsg);
1236 if (stat == 0) { /* EOF */
1237 update_pos_dev(this);
1238 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1239 /* Two reads of zero means end of tape */
1242 Dmsg0(100, "Set ST_EOT\n");
1248 } else { /* Got data */
1253 Dmsg0(100, "Doing MTFSF\n");
1254 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1255 if (stat < 0) { /* error => EOT */
1258 Dmsg0(100, "Set ST_EOT\n");
1259 clrerror_dev(this, MTFSF);
1260 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1261 print_name(), be.strerror());
1262 Dmsg0(100, "Got < 0 for MTFSF\n");
1263 Dmsg1(100, "%s", errmsg);
1271 * No FSF, so use FSR to simulate it
1274 Dmsg0(200, "Doing FSR for FSF\n");
1275 while (num-- && !at_eot()) {
1276 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1280 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1286 update_pos_dev(this);
1287 Dmsg1(200, "Return %d from FSF\n", stat);
1289 Dmsg0(200, "ST_EOF set on exit FSF\n");
1291 Dmsg0(200, "ST_EOT set on exit FSF\n");
1292 Dmsg1(200, "Return from FSF file=%d\n", file);
1297 * Backward space a file
1298 * Returns: false on failure
1302 bsf_dev(DEVICE *dev, int num)
1308 dev->dev_errno = EBADF;
1309 Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Device not open\n"));
1310 Emsg0(M_FATAL, 0, dev->errmsg);
1314 if (!dev->is_tape()) {
1315 Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1319 Dmsg0(29, "bsf_dev\n");
1320 dev->state &= ~(ST_EOT|ST_EOF);
1324 mt_com.mt_op = MTBSF;
1325 mt_com.mt_count = num;
1326 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1329 clrerror_dev(dev, MTBSF);
1330 Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1331 dev->print_name(), be.strerror());
1333 update_pos_dev(dev);
1339 * Foward space num records
1340 * Returns: false on failure
1343 bool DEVICE::fsr(int num)
1350 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1351 Emsg0(M_FATAL, 0, errmsg);
1358 if (!dev_cap(this, CAP_FSR)) {
1359 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1363 Dmsg1(29, "fsr %d\n", num);
1364 mt_com.mt_op = MTFSR;
1365 mt_com.mt_count = num;
1366 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1372 struct mtget mt_stat;
1373 clrerror_dev(this, MTFSR);
1374 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1375 if (dev_get_os_pos(this, &mt_stat)) {
1376 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1377 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1378 file = mt_stat.mt_fileno;
1379 block_num = mt_stat.mt_blkno;
1387 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1388 num, print_name(), be.strerror());
1390 update_pos_dev(this);
1395 * Backward space a record
1396 * Returns: false on failure
1400 bsr_dev(DEVICE *dev, int num)
1406 dev->dev_errno = EBADF;
1407 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1408 Emsg0(M_FATAL, 0, dev->errmsg);
1412 if (!dev->is_tape()) {
1416 if (!dev_cap(dev, CAP_BSR)) {
1417 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1421 Dmsg0(29, "bsr_dev\n");
1422 dev->block_num -= num;
1423 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1424 mt_com.mt_op = MTBSR;
1425 mt_com.mt_count = num;
1426 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1429 clrerror_dev(dev, MTBSR);
1430 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1431 dev->print_name(), be.strerror());
1433 update_pos_dev(dev);
1438 * Reposition the device to file, block
1439 * Returns: false on failure
1443 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1446 dev->dev_errno = EBADF;
1447 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1448 Emsg0(M_FATAL, 0, dev->errmsg);
1452 if (!dev->is_tape()) {
1453 off_t pos = (((off_t)file)<<32) + (off_t)block;
1454 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1455 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1457 dev->dev_errno = errno;
1458 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1459 dev->print_name(), be.strerror());
1463 dev->block_num = block;
1464 dev->file_addr = pos;
1467 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1468 dev->file, dev->block_num, file, block);
1469 if (file < dev->file) {
1470 Dmsg0(100, "Rewind_dev\n");
1471 if (!rewind_dev(dev)) {
1475 if (file > dev->file) {
1476 Dmsg1(100, "fsf %d\n", file-dev->file);
1477 if (!dev->fsf(file-dev->file)) {
1478 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1481 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1483 if (block < dev->block_num) {
1484 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1485 Dmsg0(100, "bsf_dev 1\n");
1487 Dmsg0(100, "fsf_dev 1\n");
1489 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1491 if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1492 /* Ignore errors as Bacula can read to the correct block */
1493 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1494 return dev->fsr(block-dev->block_num);
1502 * Write an end of file on the device
1503 * Returns: 0 on success
1504 * non-zero on failure
1507 weof_dev(DEVICE *dev, int num)
1511 Dmsg0(29, "weof_dev\n");
1514 dev->dev_errno = EBADF;
1515 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1516 Emsg0(M_FATAL, 0, dev->errmsg);
1521 if (!dev->is_tape()) {
1524 if (!dev->can_append()) {
1525 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1526 Emsg0(M_FATAL, 0, dev->errmsg);
1530 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1531 mt_com.mt_op = MTWEOF;
1532 mt_com.mt_count = num;
1533 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1540 clrerror_dev(dev, MTWEOF);
1542 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1543 dev->print_name(), be.strerror());
1550 * Return string message with last error in English
1551 * Be careful not to call this routine from within dev.c
1552 * while editing an Mmsg() or you will end up in a recursive
1553 * loop creating a Segmentation Violation.
1556 strerror_dev(DEVICE *dev)
1563 * If implemented in system, clear the tape
1567 clrerror_dev(DEVICE *dev, int func)
1569 const char *msg = NULL;
1570 struct mtget mt_stat;
1573 dev->dev_errno = errno; /* save errno */
1575 dev->VolCatInfo.VolCatErrors++;
1578 if (!dev->is_tape()) {
1581 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1584 Emsg0(M_ABORT, 0, _("Got ENOTTY on read/write!\n"));
1588 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1593 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1598 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1602 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1606 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1610 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1631 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1636 dev->dev_errno = ENOSYS;
1637 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1638 Emsg0(M_ERROR, 0, dev->errmsg);
1641 /* On some systems such as NetBSD, this clears all errors */
1642 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1644 /* Found on Linux */
1648 mt_com.mt_op = MTIOCLRERR;
1649 mt_com.mt_count = 1;
1650 /* Clear any error condition on the tape */
1651 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1652 Dmsg0(200, "Did MTIOCLRERR\n");
1656 /* Typically on FreeBSD */
1659 /* Read and clear SCSI error status */
1660 union mterrstat mt_errstat;
1661 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1662 strerror(dev->dev_errno));
1663 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1667 /* Clear Subsystem Exception OSF1 */
1671 mt_com.mt_op = MTCSE;
1672 mt_com.mt_count = 1;
1673 /* Clear any error condition on the tape */
1674 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1675 Dmsg0(200, "Did MTCSE\n");
1681 * Flush buffer contents
1684 int flush_dev(DEVICE *dev)
1689 static void do_close(DEVICE *dev)
1692 Dmsg1(100, "really close_dev %s\n", dev->print_name());
1697 if (!unmount_dev(dev, 1)) {
1698 Dmsg1(0, "Cannot unmount device %s.\n", dev->print_name());
1701 /* Remove the last part file if it is empty */
1702 if (dev->num_parts > 0) {
1704 POOL_MEM archive_name(PM_FNAME);
1705 dev->part = dev->num_parts;
1706 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", dev->VolCatInfo.VolCatName);
1707 make_spooled_dvd_filename(dev, archive_name);
1708 /* Check that the part file is empty */
1709 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1710 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1711 unlink(archive_name.c_str());
1715 /* Clean up device packet so it can be reused */
1717 dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1718 dev->label_type = B_BACULA_LABEL;
1719 dev->file = dev->block_num = 0;
1725 dev->part_start = 0;
1726 dev->EndFile = dev->EndBlock = 0;
1727 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1729 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1731 stop_thread_timer(dev->tid);
1741 void DEVICE::close()
1743 /*if (fd >= 0 && use_count == 1) {*/
1744 /* No need to check if fd >= 0: it is checked again
1745 * in do_close, and do_close MUST be called for volumes
1746 * split in parts, even if fd == -1.
1748 if (use_count == 1) {
1750 } else if (use_count > 0) {
1755 ASSERT(use_count >= 0);
1760 bool truncate_dev(DCR *dcr) /* We need the DCR for DVD-writing */
1762 DEVICE *dev = dcr->dev;
1764 Dmsg1(100, "truncate_dev %s\n", dev->print_name());
1765 if (dev->is_tape()) {
1766 return true; /* we don't really truncate tapes */
1767 /* maybe we should rewind and write and eof ???? */
1770 if (dev->is_dvd()) {
1771 return truncate_dvd_dev(dcr);
1774 if (ftruncate(dev->fd, 0) != 0) {
1776 Mmsg2(dev->errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1777 dev->print_name(), be.strerror());
1783 /* Return the resource name for the device */
1784 const char *DEVICE::name() const
1786 return device->hdr.name;
1790 dev_vol_name(DEVICE *dev)
1792 return dev->VolCatInfo.VolCatName;
1795 uint32_t dev_block(DEVICE *dev)
1797 update_pos_dev(dev);
1798 return dev->block_num;
1801 uint32_t dev_file(DEVICE *dev)
1803 update_pos_dev(dev);
1808 * Free memory allocated for the device
1811 term_dev(DEVICE *dev)
1814 dev->dev_errno = EBADF;
1815 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1816 Emsg0(M_FATAL, 0, dev->errmsg);
1819 Dmsg1(29, "term_dev: %s\n", dev->print_name());
1821 if (dev->dev_name) {
1822 free_memory(dev->dev_name);
1823 dev->dev_name = NULL;
1825 if (dev->prt_name) {
1826 free_memory(dev->prt_name);
1827 dev->prt_name = NULL;
1830 free_pool_memory(dev->errmsg);
1833 pthread_mutex_destroy(&dev->mutex);
1834 pthread_cond_destroy(&dev->wait);
1835 pthread_cond_destroy(&dev->wait_next_vol);
1836 pthread_mutex_destroy(&dev->spool_mutex);
1837 rwl_destroy(&dev->lock);
1838 if (dev->attached_dcrs) {
1839 delete dev->attached_dcrs;
1840 dev->attached_dcrs = NULL;
1842 if (dev->state & ST_MALLOC) {
1843 free_pool_memory((POOLMEM *)dev);
1848 * This routine initializes the device wait timers
1850 void init_device_wait_timers(DCR *dcr)
1852 DEVICE *dev = dcr->dev;
1853 JCR *jcr = dcr->jcr;
1855 /* ******FIXME******* put these on config variables */
1856 dev->min_wait = 60 * 60;
1857 dev->max_wait = 24 * 60 * 60;
1858 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1859 dev->wait_sec = dev->min_wait;
1860 dev->rem_wait_sec = dev->wait_sec;
1863 dev->BadVolName[0] = 0;
1865 jcr->min_wait = 60 * 60;
1866 jcr->max_wait = 24 * 60 * 60;
1867 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1868 jcr->wait_sec = jcr->min_wait;
1869 jcr->rem_wait_sec = jcr->wait_sec;
1874 void init_jcr_device_wait_timers(JCR *jcr)
1876 /* ******FIXME******* put these on config variables */
1877 jcr->min_wait = 60 * 60;
1878 jcr->max_wait = 24 * 60 * 60;
1879 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1880 jcr->wait_sec = jcr->min_wait;
1881 jcr->rem_wait_sec = jcr->wait_sec;
1887 * The dev timers are used for waiting on a particular device
1889 * Returns: true if time doubled
1890 * false if max time expired
1892 bool double_dev_wait_time(DEVICE *dev)
1894 dev->wait_sec *= 2; /* double wait time */
1895 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
1896 dev->wait_sec = dev->max_wait;
1899 dev->rem_wait_sec = dev->wait_sec;
1900 if (dev->num_wait >= dev->max_num_wait) {
1907 void set_os_device_parameters(DEVICE *dev)
1909 #ifdef HAVE_LINUX_OS
1911 if (dev->min_block_size == dev->max_block_size &&
1912 dev->min_block_size == 0) { /* variable block mode */
1913 mt_com.mt_op = MTSETBLK;
1914 mt_com.mt_count = 0;
1915 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1916 clrerror_dev(dev, MTSETBLK);
1918 mt_com.mt_op = MTSETDRVBUFFER;
1919 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
1920 if (!dev_cap(dev, CAP_TWOEOF)) {
1921 mt_com.mt_count |= MT_ST_TWO_FM;
1923 if (dev_cap(dev, CAP_EOM)) {
1924 mt_com.mt_count |= MT_ST_FAST_MTEOM;
1926 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1927 clrerror_dev(dev, MTSETBLK);
1933 #ifdef HAVE_NETBSD_OS
1935 if (dev->min_block_size == dev->max_block_size &&
1936 dev->min_block_size == 0) { /* variable block mode */
1937 mt_com.mt_op = MTSETBSIZ;
1938 mt_com.mt_count = 0;
1939 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1940 clrerror_dev(dev, MTSETBSIZ);
1942 /* Get notified at logical end of tape */
1943 mt_com.mt_op = MTEWARN;
1944 mt_com.mt_count = 1;
1945 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1946 clrerror_dev(dev, MTEWARN);
1952 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
1954 if (dev->min_block_size == dev->max_block_size &&
1955 dev->min_block_size == 0) { /* variable block mode */
1956 mt_com.mt_op = MTSETBSIZ;
1957 mt_com.mt_count = 0;
1958 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1959 clrerror_dev(dev, MTSETBSIZ);
1967 if (dev->min_block_size == dev->max_block_size &&
1968 dev->min_block_size == 0) { /* variable block mode */
1969 mt_com.mt_op = MTSRSZ;
1970 mt_com.mt_count = 0;
1971 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1972 clrerror_dev(dev, MTSRSZ);
1979 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
1981 return dev_cap(dev, CAP_MTIOCGET) &&
1982 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
1983 mt_stat->mt_fileno >= 0;
1986 static char *modes[] = {
1987 "CREATE_READ_WRITE",
1994 static char *mode_to_str(int mode)
1996 return modes[mode-1];