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)
327 int nonblocking = O_NONBLOCK;
328 Dmsg0(29, "open dev: device is tape\n");
330 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() */
344 #if defined(HAVE_WIN32)
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);
381 if (this->is_open()) {
382 openmode = omode; /* save open mode */
384 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
386 set_os_device_parameters(this); /* do system dependent stuff */
391 /* Stop any open() timer we started */
393 stop_thread_timer(tid);
396 Dmsg1(29, "open dev: tape %d opened\n", fd);
399 void DEVICE::set_blocking()
402 /* Try to reset blocking */
404 if ((oflags = fcntl(fd, F_GETFL, 0)) < 0 ||
405 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK) < 0) {
407 ::close(fd); /* use system close() */
408 fd = ::open(dev_name, mode);
409 Dmsg2(100, "fcntl error. ERR=%s. Close-reopen fd=%d\n", be.strerror(), fd);
412 oflags = fcntl(fd, F_GETFL, 0);
413 if (oflags > 0 && (oflags & O_NONBLOCK)) {
414 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK);
421 void DEVICE::open_file_device(DCR *dcr, int omode)
423 POOL_MEM archive_name(PM_FNAME);
425 get_autochanger_loaded_slot(dcr);
428 * Handle opening of File Archive (not a tape)
431 pm_strcpy(archive_name, dev_name);
433 * If this is a virtual autochanger (i.e. changer_res != NULL)
434 * we simply use the device name, assuming it has been
435 * appropriately setup by the "autochanger".
437 if (!device->changer_res) {
438 if (VolCatInfo.VolCatName[0] == 0) {
439 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
445 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
446 pm_strcat(archive_name, "/");
448 pm_strcat(archive_name, VolCatInfo.VolCatName);
451 mount(1); /* do mount if required */
455 /* If creating file, give 0640 permissions */
456 Dmsg3(29, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
457 archive_name.c_str(), mode);
458 /* Use system open() */
459 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
462 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
464 Dmsg1(29, "open failed: %s", errmsg);
465 Emsg0(M_FATAL, 0, errmsg);
471 Dmsg4(29, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
472 fd, part, num_dvd_parts, part_size);
476 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
477 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
478 * has the desired Volume name, but there is NO assurance that
479 * any other field of VolCatInfo is correct.
481 void DEVICE::open_dvd_device(DCR *dcr, int omode)
483 POOL_MEM archive_name(PM_FNAME);
484 struct stat filestat;
487 * Handle opening of DVD Volume
489 Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
490 archive_name.c_str(), mode_to_str(omode));
493 * For a DVD we must always pull the state info from dcr->VolCatInfo
494 * This is a bit ugly, but is necessary because we need to open/close/re-open
495 * the dvd file in order to properly mount/unmount and access the
496 * DVD. So we store the state of the DVD as far as is known in the
497 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
498 * copy here, when opening.
500 memcpy(&VolCatInfo, &dcr->VolCatInfo, sizeof(VolCatInfo));
501 Dmsg1(100, "Volume=%s\n", VolCatInfo.VolCatName);
503 if (VolCatInfo.VolCatName[0] == 0) {
504 Dmsg1(10, "Could not open file device %s. No Volume name given.\n",
506 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
513 Dmsg0(100, "Set part=1\n");
514 part = 1; /* count from 1 */
518 if (num_dvd_parts != VolCatInfo.VolCatParts) {
519 num_dvd_parts = VolCatInfo.VolCatParts;
523 * If we are not trying to access the last part, set mode to
524 * OPEN_READ_ONLY as writing would be an error.
526 Dmsg2(29, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
527 if (part <= num_dvd_parts) {
528 omode = OPEN_READ_ONLY;
529 make_mounted_dvd_filename(this, archive_name);
530 set_part_spooled(false);
532 omode = OPEN_READ_WRITE;
533 make_spooled_dvd_filename(this, archive_name);
534 set_part_spooled(true);
538 // Clear any previous blank_dvd status - we will recalculate it here
541 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
542 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
544 if (mount_dvd(this, 1)) {
545 Dmsg0(99, "DVD device mounted.\n");
546 if (num_dvd_parts == 0 && !truncating) {
548 * If we can mount the device, and we are not truncating the DVD,
549 * we usually want to abort. There is one exception, if there is
550 * only one 0-sized file on the DVD, with the right volume name,
551 * we continue (it's the method used by truncate_dvd to truncate a volume).
553 if (!check_can_write_on_non_blank_dvd(dcr)) {
554 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
555 Emsg0(M_FATAL, 0, errmsg);
556 unmount_dvd(this, 1); /* Unmount the device, so the operator can change it. */
563 Dmsg0(99, "DVD device mount failed.\n");
564 /* We cannot mount the device */
565 if (num_dvd_parts == 0) {
566 /* Run free space, check there is a media. */
567 if (!update_free_space_dev(this)) {
568 Emsg0(M_FATAL, 0, errmsg);
573 Dmsg1(29, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
575 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
576 Emsg0(M_FATAL, 0, errmsg);
581 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
582 Emsg0(M_FATAL, 0, errmsg);
588 Dmsg5(29, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
589 archive_name.c_str(), mode_to_str(omode),
590 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
592 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
595 /* If creating file, give 0640 permissions */
596 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
597 archive_name.c_str(), mode);
598 /* Use system open() */
599 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
601 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
603 // Should this be set if we try the create/open below
604 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
605 Dmsg1(29, "open failed: %s", errmsg);
607 /* Previous open failed. See if we can recover */
608 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
609 (part > num_dvd_parts)) {
610 /* If the last part (on spool), doesn't exist when accessing,
611 * create it. In read/write mode a write will be allowed (higher
612 * level software thinks that we are extending a pre-existing
613 * media. Reads for READ_ONLY will report immediately an EOF
614 * Sometimes it is better to finish with an EOF than with an error. */
615 Dmsg1(29, "Creating last part on spool: %s\n", archive_name.c_str());
616 omode = CREATE_READ_WRITE;
617 set_mode(CREATE_READ_WRITE);
618 fd = ::open(archive_name.c_str(), mode, 0640);
622 Dmsg1(100, "after open fd=%d\n", fd);
624 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
627 /* Get size of file */
628 if (fstat(fd, &filestat) < 0) {
631 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
633 Dmsg1(29, "open failed: %s", errmsg);
634 /* Use system close() */
638 part_size = filestat.st_size;
640 update_pos(dcr); /* update position */
648 * Returns: true on success
651 bool DEVICE::rewind(DCR *dcr)
657 Dmsg3(400, "rewind res=%d fd=%d %s\n", reserved_device, fd, print_name());
658 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
659 block_num = file = 0;
663 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
665 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
667 Emsg0(M_ABORT, 0, errmsg);
672 mt_com.mt_op = MTREW;
674 /* If we get an I/O error on rewind, it is probably because
675 * the drive is actually busy. We loop for (about 5 minutes)
676 * retrying every 5 seconds.
678 for (i=max_rewind_wait; ; i -= 5) {
679 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
682 if (i == max_rewind_wait) {
683 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
686 * This is a gross hack, because if the user has the
687 * device mounted (i.e. open), then uses mtx to load
688 * a tape, the current open file descriptor is invalid.
689 * So, we close the drive and re-open it.
692 int open_mode = openmode;
695 open(dcr, open_mode);
703 if (dev_errno == EIO) {
704 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
708 if (dev_errno == EIO && i > 0) {
709 Dmsg0(200, "Sleeping 5 seconds.\n");
714 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
715 print_name(), be.strerror());
720 } else if (is_file() || is_dvd()) {
721 if (lseek(dcr, (off_t)0, SEEK_SET) < 0) {
724 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
725 print_name(), be.strerror());
732 void DEVICE::block(int why)
735 block_device(this, why);
739 void DEVICE::unblock()
742 unblock_device(this);
746 const char *DEVICE::print_blocked() const
748 switch (dev_blocked) {
749 case BST_NOT_BLOCKED:
750 return "BST_NOT_BLOCKED";
752 return "BST_UNMOUNTED";
753 case BST_WAITING_FOR_SYSOP:
754 return "BST_WAITING_FOR_SYSOP";
755 case BST_DOING_ACQUIRE:
756 return "BST_DOING_ACQUIRE";
757 case BST_WRITING_LABEL:
758 return "BST_WRITING_LABEL";
759 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
760 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
764 return _("unknown blocked code");
769 * Called to indicate that we have just read an
770 * EOF from the device.
772 void DEVICE::set_ateof()
784 * Called to indicate we are now at the end of the tape, and
785 * writing is not possible.
787 void DEVICE::set_ateot()
789 /* Make tape effectively read-only */
790 state |= (ST_EOF|ST_EOT|ST_WEOT);
795 * Position device to end of medium (end of data)
796 * Returns: true on succes
799 bool DEVICE::eod(DCR *dcr)
802 struct mtget mt_stat;
808 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
812 #if defined (__digital__) && defined (__unix__)
813 return fsf(VolCatInfo.VolCatFiles);
820 clear_eof(); /* remove EOF flag */
821 block_num = file = 0;
824 if (is_fifo() || is_prog()) {
828 pos = lseek(dcr, (off_t)0, SEEK_END);
829 // Dmsg1(100, "====== Seek to %lld\n", pos);
837 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
838 print_name(), be.strerror());
842 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
843 Dmsg0(100,"Using FAST FSF for EOM\n");
844 /* If unknown position, rewind */
845 if (!dev_get_os_pos(this, &mt_stat)) {
850 mt_com.mt_op = MTFSF;
852 * ***FIXME*** fix code to handle case that INT16_MAX is
855 mt_com.mt_count = INT16_MAX; /* use big positive number */
856 if (mt_com.mt_count < 0) {
857 mt_com.mt_count = INT16_MAX; /* brain damaged system */
861 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
862 if (has_cap(CAP_EOM)) {
863 Dmsg0(100,"Using EOM for EOM\n");
864 mt_com.mt_op = MTEOM;
868 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
870 clrerror(mt_com.mt_op);
871 Dmsg1(50, "ioctl error: %s\n", be.strerror());
873 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
874 print_name(), be.strerror());
878 if (!dev_get_os_pos(this, &mt_stat)) {
881 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
882 print_name(), be.strerror());
885 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
887 file = mt_stat.mt_fileno;
893 * Rewind then use FSF until EOT reached
899 * Move file by file to the end of the tape
902 for (file_num=file; !at_eot(); file_num++) {
903 Dmsg0(200, "eod: doing fsf 1\n");
905 Dmsg0(200, "fsf error.\n");
909 * Avoid infinite loop by ensuring we advance.
911 if (file_num == (int)file) {
912 struct mtget mt_stat;
913 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
915 if (dev_get_os_pos(this, &mt_stat)) {
916 Dmsg2(100, "Adjust file from %d to %d\n", file , mt_stat.mt_fileno);
917 file = mt_stat.mt_fileno;
924 * Some drivers leave us after second EOF when doing
925 * MTEOM, so we must backup so that appending overwrites
928 if (has_cap(CAP_BSFATEOM)) {
929 struct mtget mt_stat;
930 /* Backup over EOF */
932 /* If BSF worked and fileno is known (not -1), set file */
933 if (dev_get_os_pos(this, &mt_stat)) {
934 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , mt_stat.mt_fileno);
935 file = mt_stat.mt_fileno;
937 file++; /* wing it -- not correct on all OSes */
940 update_pos(dcr); /* update position */
942 Dmsg1(200, "EOD dev->file=%d\n", file);
947 * Set the position of the device -- only for files and DVD
948 * For other devices, there is no generic way to do it.
949 * Returns: true on succes
952 bool DEVICE::update_pos(DCR *dcr)
959 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
960 Emsg1(M_FATAL, 0, "%s", errmsg);
964 /* Find out where we are */
965 if (is_file() || is_dvd()) {
968 pos = lseek(dcr, (off_t)0, SEEK_CUR);
972 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
973 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
974 print_name(), be.strerror());
978 block_num = (uint32_t)pos;
979 file = (uint32_t)(pos >> 32);
986 * Return the status of the device. This was meant
987 * to be a generic routine. Unfortunately, it doesn't
988 * seem possible (at least I do not know how to do it
989 * currently), which means that for the moment, this
990 * routine has very little value.
994 uint32_t status_dev(DEVICE *dev)
996 struct mtget mt_stat;
999 if (dev->state & (ST_EOT | ST_WEOT)) {
1003 if (dev->state & ST_EOF) {
1007 if (dev->is_tape()) {
1009 Pmsg0(-20,_(" Bacula status:"));
1010 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1011 if (tape_ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
1013 dev->dev_errno = errno;
1014 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1015 dev->print_name(), be.strerror());
1018 Pmsg0(-20, _(" Device status:"));
1020 #if defined(HAVE_LINUX_OS)
1021 if (GMT_EOF(mt_stat.mt_gstat)) {
1025 if (GMT_BOT(mt_stat.mt_gstat)) {
1029 if (GMT_EOT(mt_stat.mt_gstat)) {
1033 if (GMT_SM(mt_stat.mt_gstat)) {
1037 if (GMT_EOD(mt_stat.mt_gstat)) {
1041 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1042 stat |= BMT_WR_PROT;
1043 Pmsg0(-20, " WR_PROT");
1045 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1047 Pmsg0(-20, " ONLINE");
1049 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1050 stat |= BMT_DR_OPEN;
1051 Pmsg0(-20, " DR_OPEN");
1053 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1054 stat |= BMT_IM_REP_EN;
1055 Pmsg0(-20, " IM_REP_EN");
1057 #elif defined(HAVE_WIN32)
1058 if (GMT_EOF(mt_stat.mt_gstat)) {
1062 if (GMT_BOT(mt_stat.mt_gstat)) {
1066 if (GMT_EOT(mt_stat.mt_gstat)) {
1070 if (GMT_EOD(mt_stat.mt_gstat)) {
1074 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1075 stat |= BMT_WR_PROT;
1076 Pmsg0(-20, " WR_PROT");
1078 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1080 Pmsg0(-20, " ONLINE");
1082 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1083 stat |= BMT_DR_OPEN;
1084 Pmsg0(-20, " DR_OPEN");
1086 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1087 stat |= BMT_IM_REP_EN;
1088 Pmsg0(-20, " IM_REP_EN");
1091 #endif /* !SunOS && !OSF */
1092 if (dev->has_cap(CAP_MTIOCGET)) {
1093 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1095 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1098 stat |= BMT_ONLINE | BMT_BOT;
1105 * Load medium in device
1106 * Returns: true on success
1109 bool load_dev(DEVICE *dev)
1116 dev->dev_errno = EBADF;
1117 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1118 Emsg0(M_FATAL, 0, dev->errmsg);
1121 if (!(dev->is_tape())) {
1125 Dmsg0(200, "stored: MTLOAD command not available\n");
1127 dev->dev_errno = ENOTTY; /* function not available */
1128 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1129 dev->print_name(), be.strerror());
1133 dev->block_num = dev->file = 0;
1136 mt_com.mt_op = MTLOAD;
1137 mt_com.mt_count = 1;
1138 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1140 dev->dev_errno = errno;
1141 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1142 dev->print_name(), be.strerror());
1150 * Rewind device and put it offline
1151 * Returns: true on success
1154 bool DEVICE::offline()
1159 return true; /* device not open */
1162 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1163 block_num = file = 0;
1167 mt_com.mt_op = MTUNLOCK;
1168 mt_com.mt_count = 1;
1169 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1171 mt_com.mt_op = MTOFFL;
1172 mt_com.mt_count = 1;
1173 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
1176 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1177 print_name(), be.strerror());
1180 Dmsg1(100, "Offlined device %s\n", print_name());
1184 bool DEVICE::offline_or_rewind()
1189 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1193 * Note, this rewind probably should not be here (it wasn't
1194 * in prior versions of Bacula), but on FreeBSD, this is
1195 * needed in the case the tape was "frozen" due to an error
1196 * such as backspacing after writing and EOF. If it is not
1197 * done, all future references to the drive get and I/O error.
1200 return rewind(NULL);
1205 * Foward space a file
1206 * Returns: true on success
1209 bool DEVICE::fsf(int num)
1211 struct mtget mt_stat;
1217 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1218 Emsg0(M_FATAL, 0, errmsg);
1228 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1232 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1235 Dmsg0(100, "fsf\n");
1238 * If Fast forward space file is set, then we
1239 * use MTFSF to forward space and MTIOCGET
1240 * to get the file position. We assume that
1241 * the SCSI driver will ensure that we do not
1242 * forward space past the end of the medium.
1244 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1245 mt_com.mt_op = MTFSF;
1246 mt_com.mt_count = num;
1247 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1248 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1251 Dmsg0(200, "Set ST_EOT\n");
1253 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1254 print_name(), be.strerror());
1255 Dmsg1(200, "%s", errmsg);
1258 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1260 file = mt_stat.mt_fileno;
1264 * Here if CAP_FSF is set, and virtually all drives
1265 * these days support it, we read a record, then forward
1266 * space one file. Using this procedure, which is slow,
1267 * is the only way we can be sure that we don't read
1268 * two consecutive EOF marks, which means End of Data.
1270 } else if (has_cap(CAP_FSF)) {
1273 Dmsg0(200, "FSF has cap_fsf\n");
1274 if (max_block_size == 0) {
1275 rbuf_len = DEFAULT_BLOCK_SIZE;
1277 rbuf_len = max_block_size;
1279 rbuf = get_memory(rbuf_len);
1280 mt_com.mt_op = MTFSF;
1281 mt_com.mt_count = 1;
1282 while (num-- && !at_eot()) {
1283 Dmsg0(100, "Doing read before fsf\n");
1284 if ((stat = tape_read(fd, (char *)rbuf, rbuf_len)) < 0) {
1285 if (errno == ENOMEM) { /* tape record exceeds buf len */
1286 stat = rbuf_len; /* This is OK */
1288 * On IBM drives, they return ENOSPC at EOM
1289 * instead of EOF status
1291 } else if (at_eof() && errno == ENOSPC) {
1297 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1299 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1300 print_name(), be.strerror());
1301 Dmsg1(100, "%s", errmsg);
1305 if (stat == 0) { /* EOF */
1306 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1307 /* Two reads of zero means end of tape */
1310 Dmsg0(100, "Set ST_EOT\n");
1316 } else { /* Got data */
1321 Dmsg0(100, "Doing MTFSF\n");
1322 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1323 if (stat < 0) { /* error => EOT */
1326 Dmsg0(100, "Set ST_EOT\n");
1328 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1329 print_name(), be.strerror());
1330 Dmsg0(100, "Got < 0 for MTFSF\n");
1331 Dmsg1(100, "%s", errmsg);
1339 * No FSF, so use FSR to simulate it
1342 Dmsg0(200, "Doing FSR for FSF\n");
1343 while (num-- && !at_eot()) {
1344 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1348 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1354 Dmsg1(200, "Return %d from FSF\n", stat);
1356 Dmsg0(200, "ST_EOF set on exit FSF\n");
1359 Dmsg0(200, "ST_EOT set on exit FSF\n");
1361 Dmsg1(200, "Return from FSF file=%d\n", file);
1366 * Backward space a file
1367 * Returns: false on failure
1370 bool DEVICE::bsf(int num)
1377 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1378 Emsg0(M_FATAL, 0, errmsg);
1383 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1394 mt_com.mt_op = MTBSF;
1395 mt_com.mt_count = num;
1396 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1400 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1401 print_name(), be.strerror());
1408 * Foward space num records
1409 * Returns: false on failure
1412 bool DEVICE::fsr(int num)
1419 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1420 Emsg0(M_FATAL, 0, errmsg);
1428 if (!has_cap(CAP_FSR)) {
1429 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1433 Dmsg1(29, "fsr %d\n", num);
1434 mt_com.mt_op = MTFSR;
1435 mt_com.mt_count = num;
1436 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1442 struct mtget mt_stat;
1444 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1445 if (dev_get_os_pos(this, &mt_stat)) {
1446 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1447 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1448 file = mt_stat.mt_fileno;
1449 block_num = mt_stat.mt_blkno;
1457 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1458 num, print_name(), be.strerror());
1464 * Backward space a record
1465 * Returns: false on failure
1468 bool DEVICE::bsr(int num)
1475 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1476 Emsg0(M_FATAL, 0, errmsg);
1484 if (!has_cap(CAP_BSR)) {
1485 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1489 Dmsg0(29, "bsr_dev\n");
1493 mt_com.mt_op = MTBSR;
1494 mt_com.mt_count = num;
1495 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1499 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1500 print_name(), be.strerror());
1506 * Reposition the device to file, block
1507 * Returns: false on failure
1510 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1514 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1515 Emsg0(M_FATAL, 0, errmsg);
1520 off_t pos = (((off_t)rfile)<<32) + (off_t)rblock;
1521 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1522 if (lseek(dcr, pos, SEEK_SET) == (off_t)-1) {
1525 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1526 print_name(), be.strerror());
1535 /* After this point, we are tape only */
1536 Dmsg4(100, "reposition from %u:%u to %u:%u\n",
1537 file, block_num, rfile, rblock);
1539 Dmsg0(100, "Rewind\n");
1540 if (!rewind(NULL)) {
1545 Dmsg1(100, "fsf %d\n", rfile-file);
1546 if (!fsf(rfile-file)) {
1547 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1550 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1552 if (rblock < block_num) {
1553 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1554 Dmsg0(100, "bsf 1\n");
1556 Dmsg0(100, "fsf 1\n");
1558 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1560 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1561 /* Ignore errors as Bacula can read to the correct block */
1562 Dmsg1(100, "fsr %d\n", rblock-block_num);
1563 return fsr(rblock-block_num);
1571 * Write an end of file on the device
1572 * Returns: true on success
1575 bool DEVICE::weof(int num)
1579 Dmsg0(129, "weof_dev\n");
1583 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1584 Emsg0(M_FATAL, 0, errmsg);
1592 if (!can_append()) {
1593 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1594 Emsg0(M_FATAL, 0, errmsg);
1600 mt_com.mt_op = MTWEOF;
1601 mt_com.mt_count = num;
1602 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1611 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1612 print_name(), be.strerror());
1620 * If implemented in system, clear the tape
1623 void DEVICE::clrerror(int func)
1625 const char *msg = NULL;
1626 struct mtget mt_stat;
1629 dev_errno = errno; /* save errno */
1631 VolCatInfo.VolCatErrors++;
1638 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1641 break; /* ignore message printed later */
1644 capabilities &= ~CAP_EOF; /* turn off feature */
1649 capabilities &= ~CAP_EOM; /* turn off feature */
1654 capabilities &= ~CAP_FSF; /* turn off feature */
1658 capabilities &= ~CAP_BSF; /* turn off feature */
1662 capabilities &= ~CAP_FSR; /* turn off feature */
1666 capabilities &= ~CAP_BSR; /* turn off feature */
1700 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1706 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1707 Emsg0(M_ERROR, 0, errmsg);
1712 * Now we try different methods of clearing the error
1713 * status on the drive so that it is not locked for
1714 * further operations.
1717 /* On some systems such as NetBSD, this clears all errors */
1718 tape_ioctl(fd, MTIOCGET, (char *)&mt_stat);
1720 /* Found on Linux */
1724 mt_com.mt_op = MTIOCLRERR;
1725 mt_com.mt_count = 1;
1726 /* Clear any error condition on the tape */
1727 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1728 Dmsg0(200, "Did MTIOCLRERR\n");
1732 /* Typically on FreeBSD */
1736 /* Read and clear SCSI error status */
1737 union mterrstat mt_errstat;
1738 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1739 be.strerror(dev_errno));
1740 tape_ioctl(fd, MTIOCERRSTAT, (char *)&mt_errstat);
1744 /* Clear Subsystem Exception OSF1 */
1748 mt_com.mt_op = MTCSE;
1749 mt_com.mt_count = 1;
1750 /* Clear any error condition on the tape */
1751 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1752 Dmsg0(200, "Did MTCSE\n");
1760 void DEVICE::close()
1762 Dmsg1(100, "close_dev %s\n", print_name());
1763 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1774 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1776 return; /* already closed */
1779 /* Clean up device packet so it can be reused */
1781 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1782 label_type = B_BACULA_LABEL;
1783 file = block_num = 0;
1786 EndFile = EndBlock = 0;
1787 Slot = -1; /* unknown slot */
1789 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1790 memset(&VolHdr, 0, sizeof(VolHdr));
1792 stop_thread_timer(tid);
1799 * This call closes the device, but it is used in DVD handling
1800 * where we close one part and then open the next part. The
1801 * difference between close_part() and close() is that close_part()
1802 * saves the state information of the device (e.g. the Volume lable,
1803 * the Volume Catalog record, ... This permits opening and closing
1804 * the Volume parts multiple times without losing track of what the
1805 * main Volume parameters are.
1807 void DEVICE::close_part(DCR *dcr)
1809 VOLUME_LABEL saveVolHdr;
1810 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1813 memcpy(&saveVolHdr, &VolHdr, sizeof(saveVolHdr));
1814 memcpy(&saveVolCatInfo, &VolCatInfo, sizeof(saveVolCatInfo));
1815 close(); /* close current part */
1816 memcpy(&VolHdr, &saveVolHdr, sizeof(VolHdr));
1817 memcpy(&VolCatInfo, &saveVolCatInfo, sizeof(VolCatInfo));
1818 memcpy(&dcr->VolCatInfo, &saveVolCatInfo, sizeof(dcr->VolCatInfo));
1821 off_t DEVICE::lseek(DCR *dcr, off_t offset, int whence)
1824 return lseek_dvd(dcr, offset, whence);
1827 return ::lseek(fd, offset, whence);
1833 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1835 Dmsg1(100, "truncate %s\n", print_name());
1837 return true; /* we don't really truncate tapes */
1838 /* maybe we should rewind and write and eof ???? */
1842 return truncate_dvd(dcr);
1845 /* ***FIXME*** we really need to unlink() the file so that
1846 * its name can be changed for a relabel.
1848 if (ftruncate(fd, 0) != 0) {
1850 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1851 print_name(), be.strerror());
1857 /* Mount the device.
1858 * If timeout, wait until the mount command returns 0.
1859 * If !timeout, try to mount the device only once.
1861 bool DEVICE::mount(int timeout)
1863 Dmsg0(190, "Enter mount\n");
1866 } else if (requires_mount()) {
1867 return do_mount(1, timeout);
1872 /* Unmount the device
1873 * If timeout, wait until the unmount command returns 0.
1874 * If !timeout, try to unmount the device only once.
1876 bool DEVICE::unmount(int timeout)
1878 Dmsg0(90, "Enter unmount_dvd\n");
1880 return do_mount(0, timeout);
1885 /* (Un)mount the device */
1886 bool DEVICE::do_mount(int mount, int dotimeout)
1888 POOL_MEM ocmd(PM_FNAME);
1891 int status, timeout;
1893 sm_check(__FILE__, __LINE__, false);
1896 Dmsg0(200, "======= mount=1\n");
1899 icmd = device->mount_command;
1901 if (!is_mounted()) {
1902 Dmsg0(200, "======= mount=0\n");
1905 icmd = device->unmount_command;
1908 edit_mount_codes(ocmd, icmd);
1910 Dmsg2(000, "do_mount_dvd: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1913 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1918 results = get_memory(2000);
1921 /* If busy retry each second */
1922 Dmsg1(20, "do_mount run_prog=%s\n", ocmd.c_str());
1923 while ((status = run_program_full_output(ocmd.c_str(),
1924 max_open_wait/2, results)) != 0) {
1925 /* Doesn't work with internationalization (This is not a problem) */
1926 if (fnmatch("*is already mounted on", results, 0) == 0) {
1929 if (timeout-- > 0) {
1930 /* Sometimes the device cannot be mounted because it is already mounted.
1931 * Try to unmount it, then remount it */
1933 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
1939 Dmsg2(40, "Device %s cannot be mounted. ERR=%s\n", print_name(), results);
1940 Mmsg(errmsg, _("Device %s cannot be mounted. ERR=%s\n"),
1941 print_name(), results);
1943 * Now, just to be sure it is not mounted, try to read the
1947 struct dirent *entry, *result;
1951 name_max = pathconf(".", _PC_NAME_MAX);
1952 if (name_max < 1024) {
1956 if (!(dp = opendir(device->mount_point))) {
1959 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
1960 device->mount_point, print_name(), be.strerror());
1964 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
1967 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
1969 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
1970 device->mount_point, print_name());
1973 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
1974 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
1977 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
1983 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
1986 mount = 1; /* If we got more than ., .. and .keep */
1987 break; /* there must be something mounted */
1991 sm_check(__FILE__, __LINE__, false);
1992 free_pool_memory(results);
1993 Dmsg0(200, "============ mount=0\n");
1997 set_mounted(mount); /* set/clear mounted flag */
1998 free_pool_memory(results);
1999 Dmsg1(200, "============ mount=%d\n", mount);
2004 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2006 * %a = archive device name
2007 * %e = erase (set if cannot mount and first part)
2010 * %v = last part name
2012 * omsg = edited output message
2013 * imsg = input string containing edit codes (%x)
2016 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2022 POOL_MEM archive_name(PM_FNAME);
2024 omsg.c_str()[0] = 0;
2025 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2026 for (p=imsg; *p; p++) {
2036 if (num_dvd_parts == 0) {
2037 if (truncating || blank_dvd) {
2047 bsnprintf(add, sizeof(add), "%d", part);
2051 str = device->mount_point;
2054 make_spooled_dvd_filename(this, archive_name);
2055 str = archive_name.c_str();
2069 Dmsg1(1900, "add_str %s\n", str);
2070 pm_strcat(omsg, (char *)str);
2071 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2076 /* Return the resource name for the device */
2077 const char *DEVICE::name() const
2079 return device->hdr.name;
2083 dev_vol_name(DEVICE *dev)
2085 return dev->VolCatInfo.VolCatName;
2090 * Free memory allocated for the device
2092 void DEVICE::term(void)
2094 Dmsg1(900, "term dev: %s\n", print_name());
2097 free_memory(dev_name);
2101 free_memory(prt_name);
2105 free_pool_memory(errmsg);
2108 pthread_mutex_destroy(&mutex);
2109 pthread_cond_destroy(&wait);
2110 pthread_cond_destroy(&wait_next_vol);
2111 pthread_mutex_destroy(&spool_mutex);
2113 if (attached_dcrs) {
2114 delete attached_dcrs;
2115 attached_dcrs = NULL;
2124 * This routine initializes the device wait timers
2126 void init_device_wait_timers(DCR *dcr)
2128 DEVICE *dev = dcr->dev;
2129 JCR *jcr = dcr->jcr;
2131 /* ******FIXME******* put these on config variables */
2132 dev->min_wait = 60 * 60;
2133 dev->max_wait = 24 * 60 * 60;
2134 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2135 dev->wait_sec = dev->min_wait;
2136 dev->rem_wait_sec = dev->wait_sec;
2139 dev->BadVolName[0] = 0;
2141 jcr->min_wait = 60 * 60;
2142 jcr->max_wait = 24 * 60 * 60;
2143 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2144 jcr->wait_sec = jcr->min_wait;
2145 jcr->rem_wait_sec = jcr->wait_sec;
2150 void init_jcr_device_wait_timers(JCR *jcr)
2152 /* ******FIXME******* put these on config variables */
2153 jcr->min_wait = 60 * 60;
2154 jcr->max_wait = 24 * 60 * 60;
2155 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2156 jcr->wait_sec = jcr->min_wait;
2157 jcr->rem_wait_sec = jcr->wait_sec;
2163 * The dev timers are used for waiting on a particular device
2165 * Returns: true if time doubled
2166 * false if max time expired
2168 bool double_dev_wait_time(DEVICE *dev)
2170 dev->wait_sec *= 2; /* double wait time */
2171 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2172 dev->wait_sec = dev->max_wait;
2175 dev->rem_wait_sec = dev->wait_sec;
2176 if (dev->num_wait >= dev->max_num_wait) {
2183 void set_os_device_parameters(DEVICE *dev)
2185 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
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 mt_com.mt_op = MTSETDRVBUFFER;
2195 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2196 if (!dev->has_cap(CAP_TWOEOF)) {
2197 mt_com.mt_count |= MT_ST_TWO_FM;
2199 if (dev->has_cap(CAP_EOM)) {
2200 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2202 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2203 dev->clrerror(MTSETBLK);
2209 #ifdef HAVE_NETBSD_OS
2211 if (dev->min_block_size == dev->max_block_size &&
2212 dev->min_block_size == 0) { /* variable block mode */
2213 mt_com.mt_op = MTSETBSIZ;
2214 mt_com.mt_count = 0;
2215 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2216 dev->clrerror(MTSETBSIZ);
2218 /* Get notified at logical end of tape */
2219 mt_com.mt_op = MTEWARN;
2220 mt_com.mt_count = 1;
2221 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2222 dev->clrerror(MTEWARN);
2228 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2230 if (dev->min_block_size == dev->max_block_size &&
2231 dev->min_block_size == 0) { /* variable block mode */
2232 mt_com.mt_op = MTSETBSIZ;
2233 mt_com.mt_count = 0;
2234 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2235 dev->clrerror(MTSETBSIZ);
2243 if (dev->min_block_size == dev->max_block_size &&
2244 dev->min_block_size == 0) { /* variable block mode */
2245 mt_com.mt_op = MTSRSZ;
2246 mt_com.mt_count = 0;
2247 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2248 dev->clrerror(MTSRSZ);
2255 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2257 return dev->has_cap(CAP_MTIOCGET) &&
2258 tape_ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2259 mt_stat->mt_fileno >= 0;
2262 static char *modes[] = {
2263 "CREATE_READ_WRITE",
2270 static char *mode_to_str(int mode)
2272 static char buf[100];
2273 if (mode < 1 || mode > 4) {
2274 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2277 return modes[mode-1];