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));
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 Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
142 dev->capabilities = device->cap_bits;
143 dev->min_block_size = device->min_block_size;
144 dev->max_block_size = device->max_block_size;
145 dev->max_volume_size = device->max_volume_size;
146 dev->max_file_size = device->max_file_size;
147 dev->volume_capacity = device->volume_capacity;
148 dev->max_rewind_wait = device->max_rewind_wait;
149 dev->max_open_wait = device->max_open_wait;
150 dev->max_open_vols = device->max_open_vols;
151 dev->vol_poll_interval = device->vol_poll_interval;
152 dev->max_spool_size = device->max_spool_size;
153 dev->drive_index = device->drive_index;
154 dev->autoselect = device->autoselect;
155 dev->dev_type = device->dev_type;
156 if (dev->is_tape()) { /* No parts on tapes */
157 dev->max_part_size = 0;
159 dev->max_part_size = device->max_part_size;
162 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
163 dev->vol_poll_interval = 60;
165 /* Link the dev and device structures together */
166 dev->device = device;
169 if (dev->is_fifo()) {
170 dev->capabilities |= CAP_STREAM; /* set stream device */
173 /* If the device requires mount :
174 * - Check that the mount point is available
175 * - Check that (un)mount commands are defined
177 if ((dev->is_file() || dev->is_dvd()) && dev->requires_mount()) {
178 if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
180 dev->dev_errno = errno;
181 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat mount point %s: ERR=%s\n"),
182 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"));
195 if (dev->max_block_size > 1000000) {
196 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
197 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
198 dev->max_block_size = 0;
200 if (dev->max_block_size % TAPE_BSIZE != 0) {
201 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
202 dev->max_block_size, dev->print_name());
205 dev->errmsg = get_pool_memory(PM_EMSG);
208 if ((errstat = pthread_mutex_init(&dev->mutex, NULL)) != 0) {
210 dev->dev_errno = errstat;
211 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
212 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
214 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
216 dev->dev_errno = errstat;
217 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
218 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
220 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
222 dev->dev_errno = errstat;
223 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
224 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
226 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
228 dev->dev_errno = errstat;
229 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
230 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
232 if ((errstat = rwl_init(&dev->lock)) != 0) {
234 dev->dev_errno = errstat;
235 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
236 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
240 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
241 Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
247 * Open the device with the operating system and
248 * initialize buffer pointers.
250 * Returns: -1 on error
253 * Note, for a tape, the VolName is the name we give to the
254 * volume (not really used here), but for a file, the
255 * VolName represents the name of the file to be created/opened.
256 * In the case of a file, the full name is the device name
257 * (archive_name) with the VolName concatenated.
260 DEVICE::open(DCR *dcr, int omode)
264 if (openmode == omode) {
273 Dmsg0(100, "Close fd for mode change.\n");
274 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
278 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
281 Dmsg4(29, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
282 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
283 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
284 label_type = B_BACULA_LABEL;
285 if (is_tape() || is_fifo()) {
286 open_tape_device(dcr, omode);
287 } else if (is_dvd()) {
288 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
289 open_dvd_device(dcr, omode);
291 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
292 open_file_device(dcr, omode);
294 state |= preserve; /* reset any important state info */
295 Dmsg1(100, "preserve=0x%x\n", preserve);
299 void DEVICE::set_mode(int new_mode)
302 case CREATE_READ_WRITE:
303 mode = O_CREAT | O_RDWR | O_BINARY;
305 case OPEN_READ_WRITE:
306 mode = O_RDWR | O_BINARY;
309 mode = O_RDONLY | O_BINARY;
311 case OPEN_WRITE_ONLY:
312 mode = O_WRONLY | O_BINARY;
315 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
321 void DEVICE::open_tape_device(DCR *dcr, int omode)
325 int nonblocking = O_NONBLOCK;
326 Dmsg0(29, "open dev: device is tape\n");
328 if (is_autochanger()) {
329 get_autochanger_loaded_slot(dcr);
333 timeout = max_open_wait;
335 if (is_fifo() && timeout) {
337 tid = start_thread_timer(pthread_self(), timeout);
339 /* If busy retry each second for max_open_wait seconds */
340 Dmsg3(100, "Try open %s mode=%s nonblocking=%d\n", print_name(),
341 mode_to_str(omode), nonblocking);
342 /* Use system open() */
345 if ((fd = tape_open(dev_name, mode)) < 0) {
349 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
350 print_name(), be.strerror(dev_errno));
351 Jmsg0(dcr->jcr, M_FATAL, 0, errmsg);
354 while ((fd = ::open(dev_name, mode+nonblocking)) < 0) {
357 Dmsg5(050, "Open omode=%d mode=%x nonblock=%d error errno=%d ERR=%s\n",
358 omode, mode, nonblocking, errno, be.strerror());
359 if (dev_errno == EINTR || dev_errno == EAGAIN) {
360 Dmsg0(100, "Continue open\n");
363 /* Busy wait for specified time (default = 5 mins) */
364 if (dev_errno == EBUSY && timeout-- > 0) {
365 Dmsg2(100, "Device %s busy. ERR=%s\n", print_name(), be.strerror());
369 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
370 print_name(), be.strerror(dev_errno));
371 /* Stop any open timer we set */
373 stop_thread_timer(tid);
376 Jmsg0(dcr->jcr, M_FATAL, 0, errmsg);
382 openmode = omode; /* save open mode */
384 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
386 update_pos_dev(this); /* update position */
387 set_os_device_parameters(this); /* do system dependent stuff */
392 /* Stop any open() timer we started */
394 stop_thread_timer(tid);
397 Dmsg1(29, "open dev: tape %d opened\n", fd);
400 void DEVICE::set_blocking()
403 /* Try to reset blocking */
405 if ((oflags = fcntl(fd, F_GETFL, 0)) < 0 ||
406 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK) < 0) {
408 ::close(fd); /* use system close() */
409 fd = ::open(dev_name, mode);
410 Dmsg2(100, "fcntl error. ERR=%s. Close-reopen fd=%d\n", be.strerror(), fd);
413 oflags = fcntl(fd, F_GETFL, 0);
414 if (oflags > 0 && (oflags & O_NONBLOCK)) {
415 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK);
422 void DEVICE::open_file_device(DCR *dcr, int omode)
424 POOL_MEM archive_name(PM_FNAME);
426 if (is_autochanger()) {
427 get_autochanger_loaded_slot(dcr);
431 * Handle opening of File Archive (not a tape)
434 pm_strcpy(archive_name, dev_name);
436 * If this is a virtual autochanger (i.e. changer_res != NULL)
437 * we simply use the deviced name, assuming it has been
438 * appropriately setup by the "autochanger".
440 if (!device->changer_res) {
441 if (VolCatInfo.VolCatName[0] == 0) {
442 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
448 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
449 pm_strcat(archive_name, "/");
451 pm_strcat(archive_name, VolCatInfo.VolCatName);
454 mount(1); /* do mount if required */
458 /* If creating file, give 0640 permissions */
459 Dmsg3(29, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
460 archive_name.c_str(), mode);
461 /* Use system open() */
462 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
465 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
467 Dmsg1(29, "open failed: %s", errmsg);
468 Emsg0(M_FATAL, 0, errmsg);
471 update_pos_dev(this); /* update position */
473 Dmsg4(29, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
474 fd, part, num_parts, part_size);
478 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
479 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
480 * has the desired Volume name, but there is NO assurance that
481 * any other field of VolCatInfo is correct.
483 void DEVICE::open_dvd_device(DCR *dcr, int omode)
485 POOL_MEM archive_name(PM_FNAME);
486 struct stat filestat;
489 * Handle opening of DVD Volume
491 Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
492 archive_name.c_str(), mode_to_str(omode));
494 if (VolCatInfo.VolCatName[0] == 0) {
495 Dmsg1(10, "Could not open file device %s. No Volume name given.\n",
497 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
507 // Clear any previous truncated_dvd status - we will recalculate it here
508 truncated_dvd = false;
510 Dmsg2(99, "open_dvd_device: num_parts=%d, VolCatInfo.VolCatParts=%d\n",
511 dcr->dev->num_parts, dcr->VolCatInfo.VolCatParts);
512 if (dcr->dev->num_parts < dcr->VolCatInfo.VolCatParts) {
513 Dmsg2(99, "open_dvd_device: num_parts updated to %d (was %d)\n",
514 dcr->VolCatInfo.VolCatParts, dcr->dev->num_parts);
515 dcr->dev->num_parts = dcr->VolCatInfo.VolCatParts;
518 if (mount_dvd(this, 1)) {
519 if ((num_parts == 0) && (!truncating)) {
520 /* If we can mount the device, and we are not truncating the DVD, we usually want to abort. */
521 /* There is one exception, if there is only one 0-sized file on the DVD, with the right volume name,
522 * we continue (it's the method used by truncate_dvd to truncate a volume). */
523 if (!check_can_write_on_non_blank_dvd(dcr)) {
524 Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
525 Emsg0(M_FATAL, 0, errmsg);
526 unmount_dvd(this, 1); /* Unmount the device, so the operator can change it. */
530 truncated_dvd = true;
533 /* We cannot mount the device */
534 if (num_parts == 0) {
535 /* Run free space, check there is a media. */
536 update_free_space_dev(this);
538 Dmsg1(29, "Could not mount device %s, this is not a problem (num_parts == 0), and have media.\n", print_name());
541 Mmsg(errmsg, _("There is no valid media in the device %s.\n"), print_name());
542 Emsg0(M_FATAL, 0, errmsg);
548 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
549 Emsg0(M_FATAL, 0, errmsg);
555 Dmsg6(29, "open dev: %s dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
556 is_dvd()?"DVD":"disk", archive_name.c_str(), mode_to_str(omode),
557 part, num_parts, dcr->VolCatInfo.VolCatParts);
559 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
562 * If we are not trying to access the last part, set mode to
563 * OPEN_READ_ONLY as writing would be an error.
565 if (part < num_parts) {
566 omode = OPEN_READ_ONLY;
567 make_mounted_dvd_filename(this, archive_name);
570 make_spooled_dvd_filename(this, archive_name);
574 /* If creating file, give 0640 permissions */
575 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
576 archive_name.c_str(), mode);
577 /* Use system open() */
578 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
580 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
582 // Should this be set if we try the create/open below
583 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
584 Dmsg1(29, "open failed: %s", errmsg);
586 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
587 (part == num_parts)) {
588 /* If the last part (on spool), doesn't exists when accessing,
589 * create it. In read/write mode a write will be allowed (higher
590 * level software thinks that we are extending a pre-existing
591 * media. Reads for READ_ONLY will report immediately an EOF
592 * Sometimes it is better to finish with an EOF than with an error. */
593 Dmsg0(29, "Creating last part on spool to make our caller happy\n");
594 set_mode(CREATE_READ_WRITE);
595 fd = ::open(archive_name.c_str(), mode, 0640);
599 /* We don't need it. Only the last part is on spool */
600 /*if (omode == OPEN_READ_ONLY) {
601 make_spooled_dvd_filename(this, archive_name);
602 fd = ::open(archive_name.c_str(), mode, 0640); // try on spool
605 Dmsg1(100, "after open fd=%d\n", fd);
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_dev(this); /* update position */
622 /* NB: It seems this code is wrong... part number is incremented in open_next_part, not here */
624 /* Check if just created Volume part */
625 /* if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
628 VolCatInfo.VolCatParts = num_parts;
630 if (part == 0) { // we must have opened the first part
641 * Returns: true on success
644 bool DEVICE::rewind(DCR *dcr)
650 Dmsg3(400, "rewind res=%d fd=%d %s\n", reserved_device, fd, print_name());
652 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
654 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
656 Emsg0(M_ABORT, 0, errmsg);
660 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
661 block_num = file = 0;
665 mt_com.mt_op = MTREW;
667 /* If we get an I/O error on rewind, it is probably because
668 * the drive is actually busy. We loop for (about 5 minutes)
669 * retrying every 5 seconds.
671 for (i=max_rewind_wait; ; i -= 5) {
672 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
675 if (i == max_rewind_wait) {
676 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
679 * This is a gross hack, because if the user has the
680 * device mounted (i.e. open), then uses mtx to load
681 * a tape, the current open file descriptor is invalid.
682 * So, we close the drive and re-open it.
685 int open_mode = openmode;
688 open(dcr, open_mode);
696 if (dev_errno == EIO) {
697 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
701 if (dev_errno == EIO && i > 0) {
702 Dmsg0(200, "Sleeping 5 seconds.\n");
707 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
708 print_name(), be.strerror());
713 } else if (is_file() || is_dvd()) {
714 if (lseek_dev(this, (off_t)0, SEEK_SET) < 0) {
717 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
718 print_name(), be.strerror());
725 void DEVICE::block(int why)
728 block_device(this, why);
732 void DEVICE::unblock()
735 unblock_device(this);
739 const char *DEVICE::print_blocked() const
741 switch (dev_blocked) {
742 case BST_NOT_BLOCKED:
743 return "BST_NOT_BLOCKED";
745 return "BST_UNMOUNTED";
746 case BST_WAITING_FOR_SYSOP:
747 return "BST_WAITING_FOR_SYSOP";
748 case BST_DOING_ACQUIRE:
749 return "BST_DOING_ACQUIRE";
750 case BST_WRITING_LABEL:
751 return "BST_WRITING_LABEL";
752 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
753 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
757 return _("unknown blocked code");
762 * Called to indicate that we have just read an
763 * EOF from the device.
765 void DEVICE::set_ateof()
777 * Called to indicate we are now at the end of the tape, and
778 * writing is not possible.
780 void DEVICE::set_ateot()
782 /* Make tape effectively read-only */
783 state |= (ST_EOF|ST_EOT|ST_WEOT);
788 * Position device to end of medium (end of data)
789 * Returns: true on succes
795 struct mtget mt_stat;
801 Mmsg1(errmsg, _("Bad call to eod_dev. Device %s not open\n"), print_name());
805 #if defined (__digital__) && defined (__unix__)
806 return fsf(VolCatInfo.VolCatFiles);
809 Dmsg0(29, "eod_dev\n");
813 clear_eof(); /* remove EOF flag */
814 block_num = file = 0;
817 if (is_fifo() || is_prog()) {
821 pos = lseek_dev(this, (off_t)0, SEEK_END);
822 // Dmsg1(100, "====== Seek to %lld\n", pos);
824 update_pos_dev(this);
830 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
831 print_name(), be.strerror());
835 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
836 Dmsg0(100,"Using FAST FSF for EOM\n");
837 /* If unknown position, rewind */
838 if (!dev_get_os_pos(this, &mt_stat)) {
843 mt_com.mt_op = MTFSF;
845 * ***FIXME*** fix code to handle case that INT16_MAX is
848 mt_com.mt_count = INT16_MAX; /* use big positive number */
849 if (mt_com.mt_count < 0) {
850 mt_com.mt_count = INT16_MAX; /* brain damaged system */
854 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
855 if (has_cap(CAP_EOM)) {
856 Dmsg0(100,"Using EOM for EOM\n");
857 mt_com.mt_op = MTEOM;
861 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
863 clrerror(mt_com.mt_op);
864 Dmsg1(50, "ioctl error: %s\n", be.strerror());
865 update_pos_dev(this);
866 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
867 print_name(), be.strerror());
871 if (!dev_get_os_pos(this, &mt_stat)) {
874 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
875 print_name(), be.strerror());
878 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
880 file = mt_stat.mt_fileno;
886 * Rewind then use FSF until EOT reached
892 * Move file by file to the end of the tape
895 for (file_num=file; !at_eot(); file_num++) {
896 Dmsg0(200, "eod_dev: doing fsf 1\n");
898 Dmsg0(200, "fsf error.\n");
902 * Avoid infinite loop by ensuring we advance.
904 if (file_num == (int)file) {
905 struct mtget mt_stat;
906 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
908 if (dev_get_os_pos(this, &mt_stat)) {
909 Dmsg2(100, "Adjust file from %d to %d\n", file , mt_stat.mt_fileno);
910 file = mt_stat.mt_fileno;
917 * Some drivers leave us after second EOF when doing
918 * MTEOM, so we must backup so that appending overwrites
921 if (has_cap(CAP_BSFATEOM)) {
922 struct mtget mt_stat;
923 /* Backup over EOF */
925 /* If BSF worked and fileno is known (not -1), set file */
926 if (dev_get_os_pos(this, &mt_stat)) {
927 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , mt_stat.mt_fileno);
928 file = mt_stat.mt_fileno;
930 file++; /* wing it -- not correct on all OSes */
933 update_pos_dev(this); /* update position */
935 Dmsg1(200, "EOD dev->file=%d\n", file);
940 * Set the position of the device -- only for files and DVD
941 * For other devices, there is no generic way to do it.
942 * Returns: true on succes
945 bool update_pos_dev(DEVICE *dev)
951 dev->dev_errno = EBADF;
952 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
953 Emsg0(M_FATAL, 0, dev->errmsg);
957 /* Find out where we are */
958 if (dev->is_file()) {
961 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
964 dev->dev_errno = errno;
965 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
966 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
967 dev->print_name(), be.strerror());
970 dev->file_addr = pos;
971 dev->block_num = (uint32_t)pos;
972 dev->file = (uint32_t)(pos >> 32);
980 * Return the status of the device. This was meant
981 * to be a generic routine. Unfortunately, it doesn't
982 * seem possible (at least I do not know how to do it
983 * currently), which means that for the moment, this
984 * routine has very little value.
988 uint32_t status_dev(DEVICE *dev)
990 struct mtget mt_stat;
993 if (dev->state & (ST_EOT | ST_WEOT)) {
997 if (dev->state & ST_EOF) {
1001 if (dev->is_tape()) {
1003 Pmsg0(-20,_(" Bacula status:"));
1004 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1005 if (tape_ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
1007 dev->dev_errno = errno;
1008 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1009 dev->print_name(), be.strerror());
1012 Pmsg0(-20, _(" Device status:"));
1014 #if defined(HAVE_LINUX_OS)
1015 if (GMT_EOF(mt_stat.mt_gstat)) {
1019 if (GMT_BOT(mt_stat.mt_gstat)) {
1023 if (GMT_EOT(mt_stat.mt_gstat)) {
1027 if (GMT_SM(mt_stat.mt_gstat)) {
1031 if (GMT_EOD(mt_stat.mt_gstat)) {
1035 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1036 stat |= BMT_WR_PROT;
1037 Pmsg0(-20, " WR_PROT");
1039 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1041 Pmsg0(-20, " ONLINE");
1043 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1044 stat |= BMT_DR_OPEN;
1045 Pmsg0(-20, " DR_OPEN");
1047 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1048 stat |= BMT_IM_REP_EN;
1049 Pmsg0(-20, " IM_REP_EN");
1051 #elif defined(HAVE_WIN32)
1052 if (GMT_EOF(mt_stat.mt_gstat)) {
1056 if (GMT_BOT(mt_stat.mt_gstat)) {
1060 if (GMT_EOT(mt_stat.mt_gstat)) {
1064 if (GMT_EOD(mt_stat.mt_gstat)) {
1068 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1069 stat |= BMT_WR_PROT;
1070 Pmsg0(-20, " WR_PROT");
1072 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1074 Pmsg0(-20, " ONLINE");
1076 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1077 stat |= BMT_DR_OPEN;
1078 Pmsg0(-20, " DR_OPEN");
1080 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1081 stat |= BMT_IM_REP_EN;
1082 Pmsg0(-20, " IM_REP_EN");
1085 #endif /* !SunOS && !OSF */
1086 if (dev->has_cap(CAP_MTIOCGET)) {
1087 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1089 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1092 stat |= BMT_ONLINE | BMT_BOT;
1099 * Load medium in device
1100 * Returns: true on success
1103 bool load_dev(DEVICE *dev)
1110 dev->dev_errno = EBADF;
1111 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1112 Emsg0(M_FATAL, 0, dev->errmsg);
1115 if (!(dev->is_tape())) {
1119 Dmsg0(200, "stored: MTLOAD command not available\n");
1121 dev->dev_errno = ENOTTY; /* function not available */
1122 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1123 dev->print_name(), be.strerror());
1127 dev->block_num = dev->file = 0;
1130 mt_com.mt_op = MTLOAD;
1131 mt_com.mt_count = 1;
1132 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1134 dev->dev_errno = errno;
1135 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1136 dev->print_name(), be.strerror());
1144 * Rewind device and put it offline
1145 * Returns: true on success
1148 bool DEVICE::offline()
1153 return true; /* device not open */
1156 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1157 block_num = file = 0;
1162 mt_com.mt_op = MTUNLOCK;
1163 mt_com.mt_count = 1;
1164 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1166 mt_com.mt_op = MTOFFL;
1167 mt_com.mt_count = 1;
1168 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
1171 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1172 print_name(), be.strerror());
1175 Dmsg1(100, "Offlined device %s\n", print_name());
1179 bool DEVICE::offline_or_rewind()
1184 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1188 * Note, this rewind probably should not be here (it wasn't
1189 * in prior versions of Bacula), but on FreeBSD, this is
1190 * needed in the case the tape was "frozen" due to an error
1191 * such as backspacing after writing and EOF. If it is not
1192 * done, all future references to the drive get and I/O error.
1195 return rewind(NULL);
1200 * Foward space a file
1201 * Returns: true on success
1204 bool DEVICE::fsf(int num)
1206 struct mtget mt_stat;
1212 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1213 Emsg0(M_FATAL, 0, errmsg);
1222 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1226 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1229 Dmsg0(100, "fsf\n");
1232 * If Fast forward space file is set, then we
1233 * use MTFSF to forward space and MTIOCGET
1234 * to get the file position. We assume that
1235 * the SCSI driver will ensure that we do not
1236 * forward space past the end of the medium.
1238 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1239 mt_com.mt_op = MTFSF;
1240 mt_com.mt_count = num;
1241 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1242 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1245 Dmsg0(200, "Set ST_EOT\n");
1247 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1248 print_name(), be.strerror());
1249 Dmsg1(200, "%s", errmsg);
1252 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1254 file = mt_stat.mt_fileno;
1258 * Here if CAP_FSF is set, and virtually all drives
1259 * these days support it, we read a record, then forward
1260 * space one file. Using this procedure, which is slow,
1261 * is the only way we can be sure that we don't read
1262 * two consecutive EOF marks, which means End of Data.
1264 } else if (has_cap(CAP_FSF)) {
1267 Dmsg0(200, "FSF has cap_fsf\n");
1268 if (max_block_size == 0) {
1269 rbuf_len = DEFAULT_BLOCK_SIZE;
1271 rbuf_len = max_block_size;
1273 rbuf = get_memory(rbuf_len);
1274 mt_com.mt_op = MTFSF;
1275 mt_com.mt_count = 1;
1276 while (num-- && !at_eot()) {
1277 Dmsg0(100, "Doing read before fsf\n");
1278 if ((stat = tape_read(fd, (char *)rbuf, rbuf_len)) < 0) {
1279 if (errno == ENOMEM) { /* tape record exceeds buf len */
1280 stat = rbuf_len; /* This is OK */
1282 * On IBM drives, they return ENOSPC at EOM
1283 * instead of EOF status
1285 } else if (at_eof() && errno == ENOSPC) {
1291 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1293 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1294 print_name(), be.strerror());
1295 Dmsg1(100, "%s", errmsg);
1299 if (stat == 0) { /* EOF */
1300 update_pos_dev(this);
1301 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1302 /* Two reads of zero means end of tape */
1305 Dmsg0(100, "Set ST_EOT\n");
1311 } else { /* Got data */
1316 Dmsg0(100, "Doing MTFSF\n");
1317 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1318 if (stat < 0) { /* error => EOT */
1321 Dmsg0(100, "Set ST_EOT\n");
1323 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1324 print_name(), be.strerror());
1325 Dmsg0(100, "Got < 0 for MTFSF\n");
1326 Dmsg1(100, "%s", errmsg);
1334 * No FSF, so use FSR to simulate it
1337 Dmsg0(200, "Doing FSR for FSF\n");
1338 while (num-- && !at_eot()) {
1339 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1343 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1349 update_pos_dev(this);
1350 Dmsg1(200, "Return %d from FSF\n", stat);
1352 Dmsg0(200, "ST_EOF set on exit FSF\n");
1355 Dmsg0(200, "ST_EOT set on exit FSF\n");
1357 Dmsg1(200, "Return from FSF file=%d\n", file);
1362 * Backward space a file
1363 * Returns: false on failure
1366 bool DEVICE::bsf(int num)
1373 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1374 Emsg0(M_FATAL, 0, errmsg);
1379 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1389 mt_com.mt_op = MTBSF;
1390 mt_com.mt_count = num;
1391 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1395 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1396 print_name(), be.strerror());
1398 update_pos_dev(this);
1404 * Foward space num records
1405 * Returns: false on failure
1408 bool DEVICE::fsr(int num)
1415 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1416 Emsg0(M_FATAL, 0, errmsg);
1423 if (!has_cap(CAP_FSR)) {
1424 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1428 Dmsg1(29, "fsr %d\n", num);
1429 mt_com.mt_op = MTFSR;
1430 mt_com.mt_count = num;
1431 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1437 struct mtget mt_stat;
1439 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1440 if (dev_get_os_pos(this, &mt_stat)) {
1441 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1442 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1443 file = mt_stat.mt_fileno;
1444 block_num = mt_stat.mt_blkno;
1452 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1453 num, print_name(), be.strerror());
1455 update_pos_dev(this);
1460 * Backward space a record
1461 * Returns: false on failure
1464 bool DEVICE::bsr(int num)
1471 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1472 Emsg0(M_FATAL, 0, errmsg);
1480 if (!has_cap(CAP_BSR)) {
1481 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1485 Dmsg0(29, "bsr_dev\n");
1489 mt_com.mt_op = MTBSR;
1490 mt_com.mt_count = num;
1491 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1495 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1496 print_name(), be.strerror());
1498 update_pos_dev(this);
1503 * Reposition the device to file, block
1504 * Returns: false on failure
1507 bool DEVICE::reposition(uint32_t rfile, uint32_t rblock)
1511 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1512 Emsg0(M_FATAL, 0, errmsg);
1517 off_t pos = (((off_t)rfile)<<32) + (off_t)rblock;
1518 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1519 if (lseek_dev(this, pos, SEEK_SET) == (off_t)-1) {
1522 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1523 print_name(), be.strerror());
1531 Dmsg4(100, "reposition from %u:%u to %u:%u\n",
1532 file, block_num, rfile, rblock);
1534 Dmsg0(100, "Rewind\n");
1535 if (!rewind(NULL)) {
1540 Dmsg1(100, "fsf %d\n", rfile-file);
1541 if (!fsf(rfile-file)) {
1542 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1545 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1547 if (rblock < block_num) {
1548 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1549 Dmsg0(100, "bsf 1\n");
1551 Dmsg0(100, "fsf_dev 1\n");
1553 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1555 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1556 /* Ignore errors as Bacula can read to the correct block */
1557 Dmsg1(100, "fsr %d\n", rblock-block_num);
1558 return fsr(rblock-block_num);
1566 * Write an end of file on the device
1567 * Returns: true on success
1570 bool DEVICE::weof(int num)
1574 Dmsg0(129, "weof_dev\n");
1578 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1579 Emsg0(M_FATAL, 0, errmsg);
1587 if (!can_append()) {
1588 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1589 Emsg0(M_FATAL, 0, errmsg);
1595 mt_com.mt_op = MTWEOF;
1596 mt_com.mt_count = num;
1597 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1606 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1607 print_name(), be.strerror());
1615 * If implemented in system, clear the tape
1618 void DEVICE::clrerror(int func)
1620 const char *msg = NULL;
1621 struct mtget mt_stat;
1624 dev_errno = errno; /* save errno */
1626 VolCatInfo.VolCatErrors++;
1632 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1635 break; /* ignore message printed later */
1638 capabilities &= ~CAP_EOF; /* turn off feature */
1643 capabilities &= ~CAP_EOM; /* turn off feature */
1648 capabilities &= ~CAP_FSF; /* turn off feature */
1652 capabilities &= ~CAP_BSF; /* turn off feature */
1656 capabilities &= ~CAP_FSR; /* turn off feature */
1660 capabilities &= ~CAP_BSR; /* turn off feature */
1694 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1700 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1701 Emsg0(M_ERROR, 0, errmsg);
1706 * Now we try different methods of clearing the error
1707 * status on the drive so that it is not locked for
1708 * further operations.
1711 /* On some systems such as NetBSD, this clears all errors */
1712 tape_ioctl(fd, MTIOCGET, (char *)&mt_stat);
1714 /* Found on Linux */
1718 mt_com.mt_op = MTIOCLRERR;
1719 mt_com.mt_count = 1;
1720 /* Clear any error condition on the tape */
1721 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1722 Dmsg0(200, "Did MTIOCLRERR\n");
1726 /* Typically on FreeBSD */
1730 /* Read and clear SCSI error status */
1731 union mterrstat mt_errstat;
1732 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1733 be.strerror(dev_errno));
1734 tape_ioctl(fd, MTIOCERRSTAT, (char *)&mt_errstat);
1738 /* Clear Subsystem Exception OSF1 */
1742 mt_com.mt_op = MTCSE;
1743 mt_com.mt_count = 1;
1744 /* Clear any error condition on the tape */
1745 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1746 Dmsg0(200, "Did MTCSE\n");
1754 void DEVICE::close()
1756 Dmsg1(100, "close_dev %s\n", print_name());
1757 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1767 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1769 return; /* already closed */
1772 if (is_dvd() && !unmount_dvd(this, 1)) {
1773 Dmsg1(0, "Cannot unmount device %s.\n", print_name());
1776 /* Remove the last part file if it is empty */
1777 if (num_parts > 0) {
1779 POOL_MEM archive_name(PM_FNAME);
1781 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", VolCatInfo.VolCatName);
1782 make_spooled_dvd_filename(this, archive_name);
1783 /* Check that the part file is empty */
1784 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1785 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1786 unlink(archive_name.c_str());
1790 /* Clean up device packet so it can be reused */
1792 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1793 label_type = B_BACULA_LABEL;
1794 file = block_num = 0;
1801 EndFile = EndBlock = 0;
1803 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1804 memset(&VolHdr, 0, sizeof(VolHdr));
1806 stop_thread_timer(tid);
1814 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1816 Dmsg1(100, "truncate_dev %s\n", print_name());
1818 return true; /* we don't really truncate tapes */
1819 /* maybe we should rewind and write and eof ???? */
1823 return truncate_dvd(dcr);
1826 if (ftruncate(fd, 0) != 0) {
1828 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1829 print_name(), be.strerror());
1835 /* Mount the device.
1836 * If timeout, wait until the mount command returns 0.
1837 * If !timeout, try to mount the device only once.
1839 bool DEVICE::mount(int timeout)
1841 Dmsg0(190, "Enter mount\n");
1844 } else if (requires_mount()) {
1845 return do_mount(1, timeout);
1850 /* Unmount the device
1851 * If timeout, wait until the unmount command returns 0.
1852 * If !timeout, try to unmount the device only once.
1854 bool DEVICE::unmount(int timeout)
1856 Dmsg0(90, "Enter unmount_dvd\n");
1858 return do_mount(0, timeout);
1863 /* (Un)mount the device */
1864 bool DEVICE::do_mount(int mount, int dotimeout)
1866 POOL_MEM ocmd(PM_FNAME);
1869 int status, timeout;
1871 sm_check(__FILE__, __LINE__, false);
1874 Dmsg0(200, "======= mount=1\n");
1877 icmd = device->mount_command;
1879 if (!is_mounted()) {
1880 Dmsg0(200, "======= mount=0\n");
1883 icmd = device->unmount_command;
1886 edit_mount_codes(ocmd, icmd);
1888 Dmsg2(000, "do_mount_dvd: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1891 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1896 results = get_memory(2000);
1898 /* If busy retry each second */
1899 while ((status = run_program_full_output(ocmd.c_str(),
1900 max_open_wait/2, results)) != 0) {
1901 /* Doesn't work with internationalisation (This is not a problem) */
1902 if (fnmatch("*is already mounted on", results, 0) == 0) {
1905 if (timeout-- > 0) {
1906 /* Sometimes the device cannot be mounted because it is already mounted.
1907 * Try to unmount it, then remount it */
1909 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
1915 Dmsg2(40, "Device %s cannot be mounted. ERR=%s\n", print_name(), results);
1916 Mmsg(errmsg, _("Device %s cannot be mounted. ERR=%s\n"),
1917 print_name(), results);
1919 * Now, just to be sure it is not mounted, try to read the
1923 struct dirent *entry, *result;
1927 name_max = pathconf(".", _PC_NAME_MAX);
1928 if (name_max < 1024) {
1932 if (!(dp = opendir(device->mount_point))) {
1935 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
1936 device->mount_point, print_name(), be.strerror());
1940 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
1943 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
1945 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
1946 device->mount_point, print_name());
1949 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
1950 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
1953 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
1959 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
1962 mount = 1; /* If we got more than ., .. and .keep */
1963 break; /* there must be something mounted */
1967 sm_check(__FILE__, __LINE__, false);
1968 free_pool_memory(results);
1969 Dmsg0(200, "============ mount=0\n");
1973 set_mounted(mount); /* set/clear mounted flag */
1974 free_pool_memory(results);
1975 Dmsg1(200, "============ mount=%d\n", mount);
1980 * Edit codes into (Un)MountCommand, Write(First)PartCommand
1982 * %a = archive device name
1983 * %e = erase (set if cannot mount and first part)
1986 * %v = last part name
1988 * omsg = edited output message
1989 * imsg = input string containing edit codes (%x)
1992 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
1998 POOL_MEM archive_name(PM_FNAME);
2000 omsg.c_str()[0] = 0;
2001 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2002 for (p=imsg; *p; p++) {
2012 if (num_parts == 0) {
2013 if (truncating || truncated_dvd) {
2023 bsnprintf(add, sizeof(add), "%d", part);
2027 str = device->mount_point;
2030 make_spooled_dvd_filename(this, archive_name);
2031 str = archive_name.c_str();
2045 Dmsg1(1900, "add_str %s\n", str);
2046 pm_strcat(omsg, (char *)str);
2047 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2052 /* Return the resource name for the device */
2053 const char *DEVICE::name() const
2055 return device->hdr.name;
2059 dev_vol_name(DEVICE *dev)
2061 return dev->VolCatInfo.VolCatName;
2064 uint32_t dev_block(DEVICE *dev)
2066 update_pos_dev(dev);
2067 return dev->block_num;
2070 uint32_t dev_file(DEVICE *dev)
2072 update_pos_dev(dev);
2077 * Free memory allocated for the device
2079 void DEVICE::term(void)
2081 Dmsg1(900, "term dev: %s\n", print_name());
2084 free_memory(dev_name);
2088 free_memory(prt_name);
2092 free_pool_memory(errmsg);
2095 pthread_mutex_destroy(&mutex);
2096 pthread_cond_destroy(&wait);
2097 pthread_cond_destroy(&wait_next_vol);
2098 pthread_mutex_destroy(&spool_mutex);
2100 if (attached_dcrs) {
2101 delete attached_dcrs;
2102 attached_dcrs = NULL;
2111 * This routine initializes the device wait timers
2113 void init_device_wait_timers(DCR *dcr)
2115 DEVICE *dev = dcr->dev;
2116 JCR *jcr = dcr->jcr;
2118 /* ******FIXME******* put these on config variables */
2119 dev->min_wait = 60 * 60;
2120 dev->max_wait = 24 * 60 * 60;
2121 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2122 dev->wait_sec = dev->min_wait;
2123 dev->rem_wait_sec = dev->wait_sec;
2126 dev->BadVolName[0] = 0;
2128 jcr->min_wait = 60 * 60;
2129 jcr->max_wait = 24 * 60 * 60;
2130 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2131 jcr->wait_sec = jcr->min_wait;
2132 jcr->rem_wait_sec = jcr->wait_sec;
2137 void init_jcr_device_wait_timers(JCR *jcr)
2139 /* ******FIXME******* put these on config variables */
2140 jcr->min_wait = 60 * 60;
2141 jcr->max_wait = 24 * 60 * 60;
2142 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2143 jcr->wait_sec = jcr->min_wait;
2144 jcr->rem_wait_sec = jcr->wait_sec;
2150 * The dev timers are used for waiting on a particular device
2152 * Returns: true if time doubled
2153 * false if max time expired
2155 bool double_dev_wait_time(DEVICE *dev)
2157 dev->wait_sec *= 2; /* double wait time */
2158 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2159 dev->wait_sec = dev->max_wait;
2162 dev->rem_wait_sec = dev->wait_sec;
2163 if (dev->num_wait >= dev->max_num_wait) {
2170 void set_os_device_parameters(DEVICE *dev)
2172 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2174 if (dev->min_block_size == dev->max_block_size &&
2175 dev->min_block_size == 0) { /* variable block mode */
2176 mt_com.mt_op = MTSETBLK;
2177 mt_com.mt_count = 0;
2178 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2179 dev->clrerror(MTSETBLK);
2181 mt_com.mt_op = MTSETDRVBUFFER;
2182 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2183 if (!dev->has_cap(CAP_TWOEOF)) {
2184 mt_com.mt_count |= MT_ST_TWO_FM;
2186 if (dev->has_cap(CAP_EOM)) {
2187 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2189 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2190 dev->clrerror(MTSETBLK);
2196 #ifdef HAVE_NETBSD_OS
2198 if (dev->min_block_size == dev->max_block_size &&
2199 dev->min_block_size == 0) { /* variable block mode */
2200 mt_com.mt_op = MTSETBSIZ;
2201 mt_com.mt_count = 0;
2202 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2203 dev->clrerror(MTSETBSIZ);
2205 /* Get notified at logical end of tape */
2206 mt_com.mt_op = MTEWARN;
2207 mt_com.mt_count = 1;
2208 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2209 dev->clrerror(MTEWARN);
2215 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_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);
2230 if (dev->min_block_size == dev->max_block_size &&
2231 dev->min_block_size == 0) { /* variable block mode */
2232 mt_com.mt_op = MTSRSZ;
2233 mt_com.mt_count = 0;
2234 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2235 dev->clrerror(MTSRSZ);
2242 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2244 return dev->has_cap(CAP_MTIOCGET) &&
2245 tape_ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2246 mt_stat->mt_fileno >= 0;
2249 static char *modes[] = {
2250 "CREATE_READ_WRITE",
2257 static char *mode_to_str(int mode)
2259 return modes[mode-1];