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 may 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-2006 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 /* If no device type specified, try to guess */
108 if (!device->dev_type) {
109 /* Check that device is available */
110 if (stat(device->device_name, &statp) < 0) {
112 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
113 device->device_name, be.strerror());
116 if (S_ISDIR(statp.st_mode)) {
117 device->dev_type = B_FILE_DEV;
118 } else if (S_ISCHR(statp.st_mode)) {
119 device->dev_type = B_TAPE_DEV;
120 } else if (S_ISFIFO(statp.st_mode)) {
121 device->dev_type = B_FILE_DEV;
122 } else if (!(device->cap_bits & CAP_REQMOUNT)) {
123 Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
124 " or have RequiresMount=yes for DVD. st_mode=%x\n"),
125 device->device_name, statp.st_mode);
128 device->dev_type = B_DVD_DEV;
132 dev = (DEVICE *)malloc(sizeof(DEVICE));
133 memset(dev, 0, sizeof(DEVICE));
134 dev->Slot = -1; /* unknown */
136 /* Copy user supplied device parameters from Resource */
137 dev->dev_name = get_memory(strlen(device->device_name)+1);
138 pm_strcpy(dev->dev_name, device->device_name);
139 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
140 /* We edit "Resource-name" (physical-name) */
141 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
142 Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
143 dev->capabilities = device->cap_bits;
144 dev->min_block_size = device->min_block_size;
145 dev->max_block_size = device->max_block_size;
146 dev->max_volume_size = device->max_volume_size;
147 dev->max_file_size = device->max_file_size;
148 dev->volume_capacity = device->volume_capacity;
149 dev->max_rewind_wait = device->max_rewind_wait;
150 dev->max_open_wait = device->max_open_wait;
151 dev->max_open_vols = device->max_open_vols;
152 dev->vol_poll_interval = device->vol_poll_interval;
153 dev->max_spool_size = device->max_spool_size;
154 dev->drive_index = device->drive_index;
155 dev->autoselect = device->autoselect;
156 dev->dev_type = device->dev_type;
157 if (dev->is_tape()) { /* No parts on tapes */
158 dev->max_part_size = 0;
160 dev->max_part_size = device->max_part_size;
163 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
164 dev->vol_poll_interval = 60;
166 /* Link the dev and device structures together */
167 dev->device = device;
170 if (dev->is_fifo()) {
171 dev->capabilities |= CAP_STREAM; /* set stream device */
174 /* If the device requires mount :
175 * - Check that the mount point is available
176 * - Check that (un)mount commands are defined
178 if ((dev->is_file() || dev->is_dvd()) && dev->requires_mount()) {
179 if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
181 dev->dev_errno = errno;
182 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat mount point %s: ERR=%s\n"),
183 device->mount_point, be.strerror());
188 if (!device->mount_command || !device->unmount_command) {
189 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
191 if (!device->write_part_command) {
192 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
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)
265 if (openmode == omode) {
274 Dmsg0(100, "Close fd for mode change.\n");
275 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
279 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
282 Dmsg4(29, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
283 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
284 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
285 Slot = -1; /* unknown slot */
286 label_type = B_BACULA_LABEL;
287 if (is_tape() || is_fifo()) {
288 open_tape_device(dcr, omode);
289 } else if (is_dvd()) {
290 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
291 open_dvd_device(dcr, omode);
293 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
294 open_file_device(dcr, omode);
296 state |= preserve; /* reset any important state info */
297 Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, fd);
301 void DEVICE::set_mode(int new_mode)
304 case CREATE_READ_WRITE:
305 mode = O_CREAT | O_RDWR | O_BINARY;
307 case OPEN_READ_WRITE:
308 mode = O_RDWR | O_BINARY;
311 mode = O_RDONLY | O_BINARY;
313 case OPEN_WRITE_ONLY:
314 mode = O_WRONLY | O_BINARY;
317 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
323 void DEVICE::open_tape_device(DCR *dcr, int omode)
326 int timeout = max_open_wait;
328 utime_t start_time = time(NULL);
329 Dmsg0(29, "Open dev: device is tape\n");
331 get_autochanger_loaded_slot(dcr);
338 if (is_fifo() && timeout) {
340 tid = start_thread_timer(pthread_self(), timeout);
342 /* If busy retry each second for max_open_wait seconds */
343 Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
344 /* Use system open() */
345 #if defined(HAVE_WIN32)
346 if ((fd = tape_open(dev_name, mode)) < 0) {
351 fd = ::open(dev_name, mode);
355 Dmsg5(050, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
356 print_name(), omode, mode, errno, be.strerror());
358 /* Tape open, now rewind it */
359 mt_com.mt_op = MTREW;
361 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
363 dev_errno = errno; /* set error status from rewind */
366 Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
367 be.strerror(dev_errno));
370 set_os_device_parameters(this); /* do system dependent stuff */
371 break; /* Successfully opened and rewound */
375 /* Exceed wait time ? */
376 if (time(NULL) - start_time >= max_open_wait) {
377 break; /* yes, get out */
384 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
385 print_name(), be.strerror(dev_errno));
386 Dmsg1(100, "%s", errmsg);
389 /* Stop any open() timer we started */
391 stop_thread_timer(tid);
394 Dmsg1(29, "open dev: tape %d opened\n", fd);
401 void DEVICE::open_file_device(DCR *dcr, int omode)
403 POOL_MEM archive_name(PM_FNAME);
405 get_autochanger_loaded_slot(dcr);
408 * Handle opening of File Archive (not a tape)
411 pm_strcpy(archive_name, dev_name);
413 * If this is a virtual autochanger (i.e. changer_res != NULL)
414 * we simply use the device name, assuming it has been
415 * appropriately setup by the "autochanger".
417 if (!device->changer_res) {
418 if (VolCatInfo.VolCatName[0] == 0) {
419 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
425 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
426 pm_strcat(archive_name, "/");
428 pm_strcat(archive_name, VolCatInfo.VolCatName);
431 mount(1); /* do mount if required */
435 /* If creating file, give 0640 permissions */
436 Dmsg3(29, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
437 archive_name.c_str(), mode);
438 /* Use system open() */
439 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
442 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
444 Dmsg1(29, "open failed: %s", errmsg);
445 Emsg0(M_FATAL, 0, errmsg);
451 Dmsg4(29, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
452 fd, part, num_dvd_parts, part_size);
456 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
457 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
458 * has the desired Volume name, but there is NO assurance that
459 * any other field of VolCatInfo is correct.
461 void DEVICE::open_dvd_device(DCR *dcr, int omode)
463 POOL_MEM archive_name(PM_FNAME);
464 struct stat filestat;
467 * Handle opening of DVD Volume
469 Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
470 archive_name.c_str(), mode_to_str(omode));
473 * For a DVD we must always pull the state info from dcr->VolCatInfo
474 * This is a bit ugly, but is necessary because we need to open/close/re-open
475 * the dvd file in order to properly mount/unmount and access the
476 * DVD. So we store the state of the DVD as far as is known in the
477 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
478 * copy here, when opening.
480 memcpy(&VolCatInfo, &dcr->VolCatInfo, sizeof(VolCatInfo));
481 Dmsg1(100, "Volume=%s\n", VolCatInfo.VolCatName);
483 if (VolCatInfo.VolCatName[0] == 0) {
484 Dmsg1(10, "Could not open file device %s. No Volume name given.\n",
486 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
493 Dmsg0(100, "Set part=1\n");
494 part = 1; /* count from 1 */
498 if (num_dvd_parts != VolCatInfo.VolCatParts) {
499 num_dvd_parts = VolCatInfo.VolCatParts;
503 * If we are not trying to access the last part, set mode to
504 * OPEN_READ_ONLY as writing would be an error.
506 Dmsg2(29, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
507 if (part <= num_dvd_parts) {
508 omode = OPEN_READ_ONLY;
509 make_mounted_dvd_filename(this, archive_name);
510 set_part_spooled(false);
512 omode = OPEN_READ_WRITE;
513 make_spooled_dvd_filename(this, archive_name);
514 set_part_spooled(true);
518 // Clear any previous blank_dvd status - we will recalculate it here
521 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
522 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
524 if (mount_dvd(this, 1)) {
525 Dmsg0(99, "DVD device mounted.\n");
526 if (num_dvd_parts == 0 && !truncating) {
528 * If we can mount the device, and we are not truncating the DVD,
529 * we usually want to abort. There is one exception, if there is
530 * only one 0-sized file on the DVD, with the right volume name,
531 * we continue (it's the method used by truncate_dvd to truncate a volume).
533 if (!check_can_write_on_non_blank_dvd(dcr)) {
534 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
535 Emsg0(M_FATAL, 0, errmsg);
536 unmount_dvd(this, 1); /* Unmount the device, so the operator can change it. */
543 Dmsg0(99, "DVD device mount failed.\n");
544 /* We cannot mount the device */
545 if (num_dvd_parts == 0) {
546 /* Run free space, check there is a media. */
547 if (!update_free_space_dev(this)) {
548 Emsg0(M_FATAL, 0, errmsg);
553 Dmsg1(29, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
555 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
556 Emsg0(M_FATAL, 0, errmsg);
561 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
562 Emsg0(M_FATAL, 0, errmsg);
568 Dmsg5(29, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
569 archive_name.c_str(), mode_to_str(omode),
570 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
572 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
575 /* If creating file, give 0640 permissions */
576 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
577 archive_name.c_str(), mode);
578 /* Use system open() */
579 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
581 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
583 // Should this be set if we try the create/open below
584 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
585 Dmsg1(29, "open failed: %s", errmsg);
587 /* Previous open failed. See if we can recover */
588 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
589 (part > num_dvd_parts)) {
590 /* If the last part (on spool), doesn't exist when accessing,
591 * create it. In read/write mode a write will be allowed (higher
592 * level software thinks that we are extending a pre-existing
593 * media. Reads for READ_ONLY will report immediately an EOF
594 * Sometimes it is better to finish with an EOF than with an error. */
595 Dmsg1(29, "Creating last part on spool: %s\n", archive_name.c_str());
596 omode = CREATE_READ_WRITE;
597 set_mode(CREATE_READ_WRITE);
598 fd = ::open(archive_name.c_str(), mode, 0640);
602 Dmsg1(100, "after open fd=%d\n", fd);
604 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
607 /* Get size of file */
608 if (fstat(fd, &filestat) < 0) {
611 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
613 Dmsg1(29, "open failed: %s", errmsg);
614 /* Use system close() */
618 part_size = filestat.st_size;
620 update_pos(dcr); /* update position */
628 * Returns: true on success
631 bool DEVICE::rewind(DCR *dcr)
637 Dmsg3(400, "rewind res=%d fd=%d %s\n", reserved_device, fd, print_name());
638 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
639 block_num = file = 0;
643 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
645 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
647 Emsg0(M_ABORT, 0, errmsg);
652 mt_com.mt_op = MTREW;
654 /* If we get an I/O error on rewind, it is probably because
655 * the drive is actually busy. We loop for (about 5 minutes)
656 * retrying every 5 seconds.
658 for (i=max_rewind_wait; ; i -= 5) {
659 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
662 if (i == max_rewind_wait) {
663 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
666 * This is a gross hack, because if the user has the
667 * device mounted (i.e. open), then uses mtx to load
668 * a tape, the current open file descriptor is invalid.
669 * So, we close the drive and re-open it.
672 int open_mode = openmode;
675 open(dcr, open_mode);
683 if (dev_errno == EIO) {
684 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
688 if (dev_errno == EIO && i > 0) {
689 Dmsg0(200, "Sleeping 5 seconds.\n");
694 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
695 print_name(), be.strerror());
700 } else if (is_file() || is_dvd()) {
701 if (lseek(dcr, (off_t)0, SEEK_SET) < 0) {
704 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
705 print_name(), be.strerror());
712 void DEVICE::block(int why)
715 block_device(this, why);
719 void DEVICE::unblock()
722 unblock_device(this);
726 const char *DEVICE::print_blocked() const
728 switch (dev_blocked) {
729 case BST_NOT_BLOCKED:
730 return "BST_NOT_BLOCKED";
732 return "BST_UNMOUNTED";
733 case BST_WAITING_FOR_SYSOP:
734 return "BST_WAITING_FOR_SYSOP";
735 case BST_DOING_ACQUIRE:
736 return "BST_DOING_ACQUIRE";
737 case BST_WRITING_LABEL:
738 return "BST_WRITING_LABEL";
739 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
740 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
744 return _("unknown blocked code");
749 * Called to indicate that we have just read an
750 * EOF from the device.
752 void DEVICE::set_ateof()
764 * Called to indicate we are now at the end of the tape, and
765 * writing is not possible.
767 void DEVICE::set_ateot()
769 /* Make tape effectively read-only */
770 state |= (ST_EOF|ST_EOT|ST_WEOT);
775 * Position device to end of medium (end of data)
776 * Returns: true on succes
779 bool DEVICE::eod(DCR *dcr)
782 struct mtget mt_stat;
788 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
792 #if defined (__digital__) && defined (__unix__)
793 return fsf(VolCatInfo.VolCatFiles);
800 clear_eof(); /* remove EOF flag */
801 block_num = file = 0;
804 if (is_fifo() || is_prog()) {
808 pos = lseek(dcr, (off_t)0, SEEK_END);
809 // Dmsg1(100, "====== Seek to %lld\n", pos);
817 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
818 print_name(), be.strerror());
822 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
823 Dmsg0(100,"Using FAST FSF for EOM\n");
824 /* If unknown position, rewind */
825 if (!dev_get_os_pos(this, &mt_stat)) {
830 mt_com.mt_op = MTFSF;
832 * ***FIXME*** fix code to handle case that INT16_MAX is
835 mt_com.mt_count = INT16_MAX; /* use big positive number */
836 if (mt_com.mt_count < 0) {
837 mt_com.mt_count = INT16_MAX; /* brain damaged system */
841 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
842 if (has_cap(CAP_EOM)) {
843 Dmsg0(100,"Using EOM for EOM\n");
844 mt_com.mt_op = MTEOM;
848 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
850 clrerror(mt_com.mt_op);
851 Dmsg1(50, "ioctl error: %s\n", be.strerror());
853 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
854 print_name(), be.strerror());
858 if (!dev_get_os_pos(this, &mt_stat)) {
861 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
862 print_name(), be.strerror());
865 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
867 file = mt_stat.mt_fileno;
873 * Rewind then use FSF until EOT reached
879 * Move file by file to the end of the tape
882 for (file_num=file; !at_eot(); file_num++) {
883 Dmsg0(200, "eod: doing fsf 1\n");
885 Dmsg0(200, "fsf error.\n");
889 * Avoid infinite loop by ensuring we advance.
891 if (file_num == (int)file) {
892 struct mtget mt_stat;
893 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
895 if (dev_get_os_pos(this, &mt_stat)) {
896 Dmsg2(100, "Adjust file from %d to %d\n", file , mt_stat.mt_fileno);
897 file = mt_stat.mt_fileno;
904 * Some drivers leave us after second EOF when doing
905 * MTEOM, so we must backup so that appending overwrites
908 if (has_cap(CAP_BSFATEOM)) {
909 struct mtget mt_stat;
910 /* Backup over EOF */
912 /* If BSF worked and fileno is known (not -1), set file */
913 if (dev_get_os_pos(this, &mt_stat)) {
914 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , mt_stat.mt_fileno);
915 file = mt_stat.mt_fileno;
917 file++; /* wing it -- not correct on all OSes */
920 update_pos(dcr); /* update position */
922 Dmsg1(200, "EOD dev->file=%d\n", file);
927 * Set the position of the device -- only for files and DVD
928 * For other devices, there is no generic way to do it.
929 * Returns: true on succes
932 bool DEVICE::update_pos(DCR *dcr)
939 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
940 Emsg1(M_FATAL, 0, "%s", errmsg);
944 /* Find out where we are */
945 if (is_file() || is_dvd()) {
948 pos = lseek(dcr, (off_t)0, SEEK_CUR);
952 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
953 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
954 print_name(), be.strerror());
958 block_num = (uint32_t)pos;
959 file = (uint32_t)(pos >> 32);
966 * Return the status of the device. This was meant
967 * to be a generic routine. Unfortunately, it doesn't
968 * seem possible (at least I do not know how to do it
969 * currently), which means that for the moment, this
970 * routine has very little value.
974 uint32_t status_dev(DEVICE *dev)
976 struct mtget mt_stat;
979 if (dev->state & (ST_EOT | ST_WEOT)) {
983 if (dev->state & ST_EOF) {
987 if (dev->is_tape()) {
989 Pmsg0(-20,_(" Bacula status:"));
990 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
991 if (tape_ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
993 dev->dev_errno = errno;
994 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
995 dev->print_name(), be.strerror());
998 Pmsg0(-20, _(" Device status:"));
1000 #if defined(HAVE_LINUX_OS)
1001 if (GMT_EOF(mt_stat.mt_gstat)) {
1005 if (GMT_BOT(mt_stat.mt_gstat)) {
1009 if (GMT_EOT(mt_stat.mt_gstat)) {
1013 if (GMT_SM(mt_stat.mt_gstat)) {
1017 if (GMT_EOD(mt_stat.mt_gstat)) {
1021 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1022 stat |= BMT_WR_PROT;
1023 Pmsg0(-20, " WR_PROT");
1025 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1027 Pmsg0(-20, " ONLINE");
1029 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1030 stat |= BMT_DR_OPEN;
1031 Pmsg0(-20, " DR_OPEN");
1033 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1034 stat |= BMT_IM_REP_EN;
1035 Pmsg0(-20, " IM_REP_EN");
1037 #elif defined(HAVE_WIN32)
1038 if (GMT_EOF(mt_stat.mt_gstat)) {
1042 if (GMT_BOT(mt_stat.mt_gstat)) {
1046 if (GMT_EOT(mt_stat.mt_gstat)) {
1050 if (GMT_EOD(mt_stat.mt_gstat)) {
1054 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1055 stat |= BMT_WR_PROT;
1056 Pmsg0(-20, " WR_PROT");
1058 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1060 Pmsg0(-20, " ONLINE");
1062 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1063 stat |= BMT_DR_OPEN;
1064 Pmsg0(-20, " DR_OPEN");
1066 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1067 stat |= BMT_IM_REP_EN;
1068 Pmsg0(-20, " IM_REP_EN");
1071 #endif /* !SunOS && !OSF */
1072 if (dev->has_cap(CAP_MTIOCGET)) {
1073 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1075 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1078 stat |= BMT_ONLINE | BMT_BOT;
1085 * Load medium in device
1086 * Returns: true on success
1089 bool load_dev(DEVICE *dev)
1096 dev->dev_errno = EBADF;
1097 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1098 Emsg0(M_FATAL, 0, dev->errmsg);
1101 if (!(dev->is_tape())) {
1105 Dmsg0(200, "stored: MTLOAD command not available\n");
1107 dev->dev_errno = ENOTTY; /* function not available */
1108 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1109 dev->print_name(), be.strerror());
1113 dev->block_num = dev->file = 0;
1116 mt_com.mt_op = MTLOAD;
1117 mt_com.mt_count = 1;
1118 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1120 dev->dev_errno = errno;
1121 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1122 dev->print_name(), be.strerror());
1130 * Rewind device and put it offline
1131 * Returns: true on success
1134 bool DEVICE::offline()
1139 return true; /* device not open */
1142 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1143 block_num = file = 0;
1147 mt_com.mt_op = MTUNLOCK;
1148 mt_com.mt_count = 1;
1149 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1151 mt_com.mt_op = MTOFFL;
1152 mt_com.mt_count = 1;
1153 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
1156 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1157 print_name(), be.strerror());
1160 Dmsg1(100, "Offlined device %s\n", print_name());
1164 bool DEVICE::offline_or_rewind()
1169 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1173 * Note, this rewind probably should not be here (it wasn't
1174 * in prior versions of Bacula), but on FreeBSD, this is
1175 * needed in the case the tape was "frozen" due to an error
1176 * such as backspacing after writing and EOF. If it is not
1177 * done, all future references to the drive get and I/O error.
1180 return rewind(NULL);
1185 * Foward space a file
1186 * Returns: true on success
1189 bool DEVICE::fsf(int num)
1191 struct mtget mt_stat;
1197 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1198 Emsg0(M_FATAL, 0, errmsg);
1208 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1212 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1215 Dmsg0(100, "fsf\n");
1218 * If Fast forward space file is set, then we
1219 * use MTFSF to forward space and MTIOCGET
1220 * to get the file position. We assume that
1221 * the SCSI driver will ensure that we do not
1222 * forward space past the end of the medium.
1224 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1225 mt_com.mt_op = MTFSF;
1226 mt_com.mt_count = num;
1227 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1228 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1231 Dmsg0(200, "Set ST_EOT\n");
1233 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1234 print_name(), be.strerror());
1235 Dmsg1(200, "%s", errmsg);
1238 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1240 file = mt_stat.mt_fileno;
1244 * Here if CAP_FSF is set, and virtually all drives
1245 * these days support it, we read a record, then forward
1246 * space one file. Using this procedure, which is slow,
1247 * is the only way we can be sure that we don't read
1248 * two consecutive EOF marks, which means End of Data.
1250 } else if (has_cap(CAP_FSF)) {
1253 Dmsg0(200, "FSF has cap_fsf\n");
1254 if (max_block_size == 0) {
1255 rbuf_len = DEFAULT_BLOCK_SIZE;
1257 rbuf_len = max_block_size;
1259 rbuf = get_memory(rbuf_len);
1260 mt_com.mt_op = MTFSF;
1261 mt_com.mt_count = 1;
1262 while (num-- && !at_eot()) {
1263 Dmsg0(100, "Doing read before fsf\n");
1264 if ((stat = tape_read(fd, (char *)rbuf, rbuf_len)) < 0) {
1265 if (errno == ENOMEM) { /* tape record exceeds buf len */
1266 stat = rbuf_len; /* This is OK */
1268 * On IBM drives, they return ENOSPC at EOM
1269 * instead of EOF status
1271 } else if (at_eof() && errno == ENOSPC) {
1277 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1279 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1280 print_name(), be.strerror());
1281 Dmsg1(100, "%s", errmsg);
1285 if (stat == 0) { /* EOF */
1286 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1287 /* Two reads of zero means end of tape */
1290 Dmsg0(100, "Set ST_EOT\n");
1296 } else { /* Got data */
1301 Dmsg0(100, "Doing MTFSF\n");
1302 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1303 if (stat < 0) { /* error => EOT */
1306 Dmsg0(100, "Set ST_EOT\n");
1308 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1309 print_name(), be.strerror());
1310 Dmsg0(100, "Got < 0 for MTFSF\n");
1311 Dmsg1(100, "%s", errmsg);
1319 * No FSF, so use FSR to simulate it
1322 Dmsg0(200, "Doing FSR for FSF\n");
1323 while (num-- && !at_eot()) {
1324 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1328 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1334 Dmsg1(200, "Return %d from FSF\n", stat);
1336 Dmsg0(200, "ST_EOF set on exit FSF\n");
1339 Dmsg0(200, "ST_EOT set on exit FSF\n");
1341 Dmsg1(200, "Return from FSF file=%d\n", file);
1346 * Backward space a file
1347 * Returns: false on failure
1350 bool DEVICE::bsf(int num)
1357 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1358 Emsg0(M_FATAL, 0, errmsg);
1363 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1374 mt_com.mt_op = MTBSF;
1375 mt_com.mt_count = num;
1376 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1380 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1381 print_name(), be.strerror());
1388 * Foward space num records
1389 * Returns: false on failure
1392 bool DEVICE::fsr(int num)
1399 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1400 Emsg0(M_FATAL, 0, errmsg);
1408 if (!has_cap(CAP_FSR)) {
1409 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1413 Dmsg1(29, "fsr %d\n", num);
1414 mt_com.mt_op = MTFSR;
1415 mt_com.mt_count = num;
1416 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1422 struct mtget mt_stat;
1424 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1425 if (dev_get_os_pos(this, &mt_stat)) {
1426 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1427 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1428 file = mt_stat.mt_fileno;
1429 block_num = mt_stat.mt_blkno;
1437 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1438 num, print_name(), be.strerror());
1444 * Backward space a record
1445 * Returns: false on failure
1448 bool DEVICE::bsr(int num)
1455 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1456 Emsg0(M_FATAL, 0, errmsg);
1464 if (!has_cap(CAP_BSR)) {
1465 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1469 Dmsg0(29, "bsr_dev\n");
1473 mt_com.mt_op = MTBSR;
1474 mt_com.mt_count = num;
1475 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1479 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1480 print_name(), be.strerror());
1486 * Reposition the device to file, block
1487 * Returns: false on failure
1490 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1494 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1495 Emsg0(M_FATAL, 0, errmsg);
1500 off_t pos = (((off_t)rfile)<<32) + (off_t)rblock;
1501 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1502 if (lseek(dcr, pos, SEEK_SET) == (off_t)-1) {
1505 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1506 print_name(), be.strerror());
1515 /* After this point, we are tape only */
1516 Dmsg4(100, "reposition from %u:%u to %u:%u\n",
1517 file, block_num, rfile, rblock);
1519 Dmsg0(100, "Rewind\n");
1520 if (!rewind(NULL)) {
1525 Dmsg1(100, "fsf %d\n", rfile-file);
1526 if (!fsf(rfile-file)) {
1527 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1530 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1532 if (rblock < block_num) {
1533 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1534 Dmsg0(100, "bsf 1\n");
1536 Dmsg0(100, "fsf 1\n");
1538 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1540 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1541 /* Ignore errors as Bacula can read to the correct block */
1542 Dmsg1(100, "fsr %d\n", rblock-block_num);
1543 return fsr(rblock-block_num);
1551 * Write an end of file on the device
1552 * Returns: true on success
1555 bool DEVICE::weof(int num)
1559 Dmsg0(129, "weof_dev\n");
1563 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1564 Emsg0(M_FATAL, 0, errmsg);
1572 if (!can_append()) {
1573 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1574 Emsg0(M_FATAL, 0, errmsg);
1580 mt_com.mt_op = MTWEOF;
1581 mt_com.mt_count = num;
1582 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1591 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1592 print_name(), be.strerror());
1600 * If implemented in system, clear the tape
1603 void DEVICE::clrerror(int func)
1605 const char *msg = NULL;
1606 struct mtget mt_stat;
1609 dev_errno = errno; /* save errno */
1611 VolCatInfo.VolCatErrors++;
1618 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1621 break; /* ignore message printed later */
1624 capabilities &= ~CAP_EOF; /* turn off feature */
1629 capabilities &= ~CAP_EOM; /* turn off feature */
1634 capabilities &= ~CAP_FSF; /* turn off feature */
1638 capabilities &= ~CAP_BSF; /* turn off feature */
1642 capabilities &= ~CAP_FSR; /* turn off feature */
1646 capabilities &= ~CAP_BSR; /* turn off feature */
1656 #ifdef MTSETDRVBUFFER
1657 case MTSETDRVBUFFER:
1658 msg = "MTSETDRVBUFFER";
1691 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1697 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1698 Emsg0(M_ERROR, 0, errmsg);
1703 * Now we try different methods of clearing the error
1704 * status on the drive so that it is not locked for
1705 * further operations.
1708 /* On some systems such as NetBSD, this clears all errors */
1709 tape_ioctl(fd, MTIOCGET, (char *)&mt_stat);
1711 /* Found on Linux */
1715 mt_com.mt_op = MTIOCLRERR;
1716 mt_com.mt_count = 1;
1717 /* Clear any error condition on the tape */
1718 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1719 Dmsg0(200, "Did MTIOCLRERR\n");
1723 /* Typically on FreeBSD */
1727 /* Read and clear SCSI error status */
1728 union mterrstat mt_errstat;
1729 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1730 be.strerror(dev_errno));
1731 tape_ioctl(fd, MTIOCERRSTAT, (char *)&mt_errstat);
1735 /* Clear Subsystem Exception OSF1 */
1739 mt_com.mt_op = MTCSE;
1740 mt_com.mt_count = 1;
1741 /* Clear any error condition on the tape */
1742 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1743 Dmsg0(200, "Did MTCSE\n");
1751 void DEVICE::close()
1753 Dmsg1(100, "close_dev %s\n", print_name());
1754 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1765 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1767 return; /* already closed */
1770 /* Clean up device packet so it can be reused */
1772 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1773 label_type = B_BACULA_LABEL;
1774 file = block_num = 0;
1777 EndFile = EndBlock = 0;
1778 Slot = -1; /* unknown slot */
1780 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1781 memset(&VolHdr, 0, sizeof(VolHdr));
1783 stop_thread_timer(tid);
1790 * This call closes the device, but it is used in DVD handling
1791 * where we close one part and then open the next part. The
1792 * difference between close_part() and close() is that close_part()
1793 * saves the state information of the device (e.g. the Volume lable,
1794 * the Volume Catalog record, ... This permits opening and closing
1795 * the Volume parts multiple times without losing track of what the
1796 * main Volume parameters are.
1798 void DEVICE::close_part(DCR *dcr)
1800 VOLUME_LABEL saveVolHdr;
1801 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1804 memcpy(&saveVolHdr, &VolHdr, sizeof(saveVolHdr));
1805 memcpy(&saveVolCatInfo, &VolCatInfo, sizeof(saveVolCatInfo));
1806 close(); /* close current part */
1807 memcpy(&VolHdr, &saveVolHdr, sizeof(VolHdr));
1808 memcpy(&VolCatInfo, &saveVolCatInfo, sizeof(VolCatInfo));
1809 memcpy(&dcr->VolCatInfo, &saveVolCatInfo, sizeof(dcr->VolCatInfo));
1812 off_t DEVICE::lseek(DCR *dcr, off_t offset, int whence)
1816 return lseek_dvd(dcr, offset, whence);
1818 return ::lseek(fd, offset, whence);
1824 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1826 Dmsg1(100, "truncate %s\n", print_name());
1829 /* maybe we should rewind and write and eof ???? */
1830 return true; /* we don't really truncate tapes */
1832 return truncate_dvd(dcr);
1834 /* ***FIXME*** we really need to unlink() the file so that
1835 * its name can be changed for a relabel.
1837 if (ftruncate(fd, 0) != 0) {
1839 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1840 print_name(), be.strerror());
1848 /* Mount the device.
1849 * If timeout, wait until the mount command returns 0.
1850 * If !timeout, try to mount the device only once.
1852 bool DEVICE::mount(int timeout)
1854 Dmsg0(190, "Enter mount\n");
1857 } else if (requires_mount()) {
1858 return do_mount(1, timeout);
1863 /* Unmount the device
1864 * If timeout, wait until the unmount command returns 0.
1865 * If !timeout, try to unmount the device only once.
1867 bool DEVICE::unmount(int timeout)
1869 Dmsg0(90, "Enter unmount_dvd\n");
1871 return do_mount(0, timeout);
1876 /* (Un)mount the device */
1877 bool DEVICE::do_mount(int mount, int dotimeout)
1879 POOL_MEM ocmd(PM_FNAME);
1882 int status, timeout;
1884 sm_check(__FILE__, __LINE__, false);
1887 Dmsg0(200, "======= mount=1\n");
1890 icmd = device->mount_command;
1892 if (!is_mounted()) {
1893 Dmsg0(200, "======= mount=0\n");
1896 icmd = device->unmount_command;
1899 edit_mount_codes(ocmd, icmd);
1901 Dmsg2(100, "do_mount_dvd: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1904 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1909 results = get_memory(2000);
1912 /* If busy retry each second */
1913 Dmsg1(20, "do_mount run_prog=%s\n", ocmd.c_str());
1914 while ((status = run_program_full_output(ocmd.c_str(),
1915 max_open_wait/2, results)) != 0) {
1916 /* Doesn't work with internationalization (This is not a problem) */
1917 if (fnmatch("*is already mounted on", results, 0) == 0) {
1920 if (timeout-- > 0) {
1921 /* Sometimes the device cannot be mounted because it is already mounted.
1922 * Try to unmount it, then remount it */
1924 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
1930 Dmsg2(40, "Device %s cannot be mounted. ERR=%s\n", print_name(), results);
1931 Mmsg(errmsg, _("Device %s cannot be mounted. ERR=%s\n"),
1932 print_name(), results);
1934 * Now, just to be sure it is not mounted, try to read the
1938 struct dirent *entry, *result;
1942 name_max = pathconf(".", _PC_NAME_MAX);
1943 if (name_max < 1024) {
1947 if (!(dp = opendir(device->mount_point))) {
1950 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
1951 device->mount_point, print_name(), be.strerror());
1955 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
1958 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
1960 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
1961 device->mount_point, print_name());
1964 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
1965 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
1968 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
1974 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
1977 mount = 1; /* If we got more than ., .. and .keep */
1978 break; /* there must be something mounted */
1982 sm_check(__FILE__, __LINE__, false);
1983 free_pool_memory(results);
1984 Dmsg0(200, "============ mount=0\n");
1988 set_mounted(mount); /* set/clear mounted flag */
1989 free_pool_memory(results);
1990 Dmsg1(200, "============ mount=%d\n", mount);
1995 * Edit codes into (Un)MountCommand, Write(First)PartCommand
1997 * %a = archive device name
1998 * %e = erase (set if cannot mount and first part)
2001 * %v = last part name
2003 * omsg = edited output message
2004 * imsg = input string containing edit codes (%x)
2007 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2013 POOL_MEM archive_name(PM_FNAME);
2015 omsg.c_str()[0] = 0;
2016 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2017 for (p=imsg; *p; p++) {
2027 if (num_dvd_parts == 0) {
2028 if (truncating || blank_dvd) {
2038 bsnprintf(add, sizeof(add), "%d", part);
2042 str = device->mount_point;
2045 make_spooled_dvd_filename(this, archive_name);
2046 str = archive_name.c_str();
2060 Dmsg1(1900, "add_str %s\n", str);
2061 pm_strcat(omsg, (char *)str);
2062 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2067 /* Return the resource name for the device */
2068 const char *DEVICE::name() const
2070 return device->hdr.name;
2074 dev_vol_name(DEVICE *dev)
2076 return dev->VolCatInfo.VolCatName;
2081 * Free memory allocated for the device
2083 void DEVICE::term(void)
2085 Dmsg1(900, "term dev: %s\n", print_name());
2088 free_memory(dev_name);
2092 free_memory(prt_name);
2096 free_pool_memory(errmsg);
2099 pthread_mutex_destroy(&mutex);
2100 pthread_cond_destroy(&wait);
2101 pthread_cond_destroy(&wait_next_vol);
2102 pthread_mutex_destroy(&spool_mutex);
2104 if (attached_dcrs) {
2105 delete attached_dcrs;
2106 attached_dcrs = NULL;
2115 * This routine initializes the device wait timers
2117 void init_device_wait_timers(DCR *dcr)
2119 DEVICE *dev = dcr->dev;
2120 JCR *jcr = dcr->jcr;
2122 /* ******FIXME******* put these on config variables */
2123 dev->min_wait = 60 * 60;
2124 dev->max_wait = 24 * 60 * 60;
2125 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2126 dev->wait_sec = dev->min_wait;
2127 dev->rem_wait_sec = dev->wait_sec;
2130 dev->BadVolName[0] = 0;
2132 jcr->min_wait = 60 * 60;
2133 jcr->max_wait = 24 * 60 * 60;
2134 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2135 jcr->wait_sec = jcr->min_wait;
2136 jcr->rem_wait_sec = jcr->wait_sec;
2141 void init_jcr_device_wait_timers(JCR *jcr)
2143 /* ******FIXME******* put these on config variables */
2144 jcr->min_wait = 60 * 60;
2145 jcr->max_wait = 24 * 60 * 60;
2146 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2147 jcr->wait_sec = jcr->min_wait;
2148 jcr->rem_wait_sec = jcr->wait_sec;
2154 * The dev timers are used for waiting on a particular device
2156 * Returns: true if time doubled
2157 * false if max time expired
2159 bool double_dev_wait_time(DEVICE *dev)
2161 dev->wait_sec *= 2; /* double wait time */
2162 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2163 dev->wait_sec = dev->max_wait;
2166 dev->rem_wait_sec = dev->wait_sec;
2167 if (dev->num_wait >= dev->max_num_wait) {
2174 void set_os_device_parameters(DEVICE *dev)
2176 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2179 #if defined(MTRESET)
2180 mt_com.mt_op = MTRESET;
2181 mt_com.mt_count = 0;
2182 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2183 dev->clrerror(MTRESET);
2186 #if defined(MTSETBLK)
2187 if (dev->min_block_size == dev->max_block_size &&
2188 dev->min_block_size == 0) { /* variable block mode */
2189 mt_com.mt_op = MTSETBLK;
2190 mt_com.mt_count = 0;
2191 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2192 dev->clrerror(MTSETBLK);
2194 Dmsg0(100, "Set block size to 0\n");
2197 #if defined(MTSETDRVBUFFER)
2198 if (getpid() == 0) { /* Only root can do this */
2199 mt_com.mt_op = MTSETDRVBUFFER;
2200 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2201 if (!dev->has_cap(CAP_TWOEOF)) {
2202 mt_com.mt_count |= MT_ST_TWO_FM;
2204 if (dev->has_cap(CAP_EOM)) {
2205 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2207 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2208 dev->clrerror(MTSETDRVBUFFER);
2215 #ifdef HAVE_NETBSD_OS
2217 if (dev->min_block_size == dev->max_block_size &&
2218 dev->min_block_size == 0) { /* variable block mode */
2219 mt_com.mt_op = MTSETBSIZ;
2220 mt_com.mt_count = 0;
2221 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2222 dev->clrerror(MTSETBSIZ);
2224 /* Get notified at logical end of tape */
2225 mt_com.mt_op = MTEWARN;
2226 mt_com.mt_count = 1;
2227 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2228 dev->clrerror(MTEWARN);
2234 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2236 if (dev->min_block_size == dev->max_block_size &&
2237 dev->min_block_size == 0) { /* variable block mode */
2238 mt_com.mt_op = MTSETBSIZ;
2239 mt_com.mt_count = 0;
2240 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2241 dev->clrerror(MTSETBSIZ);
2249 if (dev->min_block_size == dev->max_block_size &&
2250 dev->min_block_size == 0) { /* variable block mode */
2251 mt_com.mt_op = MTSRSZ;
2252 mt_com.mt_count = 0;
2253 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2254 dev->clrerror(MTSRSZ);
2261 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2263 return dev->has_cap(CAP_MTIOCGET) &&
2264 tape_ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2265 mt_stat->mt_fileno >= 0;
2268 static char *modes[] = {
2269 "CREATE_READ_WRITE",
2276 static char *mode_to_str(int mode)
2278 static char buf[100];
2279 if (mode < 1 || mode > 4) {
2280 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2283 return modes[mode-1];