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);
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 get_autochanger_loaded_slot(dcr);
429 * Handle opening of File Archive (not a tape)
432 pm_strcpy(archive_name, dev_name);
434 * If this is a virtual autochanger (i.e. changer_res != NULL)
435 * we simply use the deviced name, assuming it has been
436 * appropriately setup by the "autochanger".
438 if (!device->changer_res) {
439 if (VolCatInfo.VolCatName[0] == 0) {
440 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
446 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
447 pm_strcat(archive_name, "/");
449 pm_strcat(archive_name, VolCatInfo.VolCatName);
452 mount(1); /* do mount if required */
456 /* If creating file, give 0640 permissions */
457 Dmsg3(29, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
458 archive_name.c_str(), mode);
459 /* Use system open() */
460 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
463 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
465 Dmsg1(29, "open failed: %s", errmsg);
466 Emsg0(M_FATAL, 0, errmsg);
469 update_pos_dev(this); /* update position */
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 alway 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;
521 // Clear any previous truncated_dvd status - we will recalculate it here
522 truncated_dvd = false;
524 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
525 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
527 if (mount_dvd(this, 1)) {
528 Dmsg0(99, "DVD device mounted.\n");
529 if ((num_dvd_parts == 0) && (!truncating)) {
532 * If we can mount the device, and we are not truncating the DVD,
533 * we usually want to abort. There is one exception, if there is
534 * only one 0-sized file on the DVD, with the right volume name,
535 * we continue (it's the method used by truncate_dvd to truncate a volume).
537 if (!check_can_write_on_non_blank_dvd(dcr)) {
538 Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
539 Emsg0(M_FATAL, 0, errmsg);
540 unmount_dvd(this, 1); /* Unmount the device, so the operator can change it. */
545 truncated_dvd = true;
548 Dmsg0(99, "DVD device mount failed.\n");
549 /* We cannot mount the device */
550 if (num_dvd_parts == 0) {
551 /* Run free space, check there is a media. */
552 if (!update_free_space_dev(this)) {
553 Emsg0(M_FATAL, 0, errmsg);
558 Dmsg1(29, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
560 Mmsg(errmsg, _("There is no valid media in the device %s.\n"), print_name());
561 Emsg0(M_FATAL, 0, errmsg);
566 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
567 Emsg0(M_FATAL, 0, errmsg);
573 Dmsg5(29, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
574 archive_name.c_str(), mode_to_str(omode),
575 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
577 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
580 * If we are not trying to access the last part, set mode to
581 * OPEN_READ_ONLY as writing would be an error.
583 Dmsg2(29, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
584 if (part <= num_dvd_parts) {
585 omode = OPEN_READ_ONLY;
586 make_mounted_dvd_filename(this, archive_name);
588 omode = OPEN_READ_WRITE;
589 make_spooled_dvd_filename(this, archive_name);
593 /* If creating file, give 0640 permissions */
594 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
595 archive_name.c_str(), mode);
596 /* Use system open() */
597 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
599 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
601 // Should this be set if we try the create/open below
602 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
603 Dmsg1(29, "open failed: %s", errmsg);
605 /* Previous open failed. See if we can recover */
606 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
607 (part > num_dvd_parts)) {
608 /* If the last part (on spool), doesn't exist when accessing,
609 * create it. In read/write mode a write will be allowed (higher
610 * level software thinks that we are extending a pre-existing
611 * media. Reads for READ_ONLY will report immediately an EOF
612 * Sometimes it is better to finish with an EOF than with an error. */
613 Dmsg1(29, "Creating last part on spool: %s\n", archive_name.c_str());
614 omode = CREATE_READ_WRITE;
615 set_mode(CREATE_READ_WRITE);
616 fd = ::open(archive_name.c_str(), mode, 0640);
620 Dmsg1(100, "after open fd=%d\n", fd);
622 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
625 /* Get size of file */
626 if (fstat(fd, &filestat) < 0) {
629 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
631 Dmsg1(29, "open failed: %s", errmsg);
632 /* Use system close() */
636 part_size = filestat.st_size;
638 update_pos_dev(this); /* update position */
646 * Returns: true on success
649 bool DEVICE::rewind(DCR *dcr)
655 Dmsg3(400, "rewind res=%d fd=%d %s\n", reserved_device, fd, print_name());
656 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
657 block_num = file = 0;
661 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
663 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
665 Emsg0(M_ABORT, 0, errmsg);
670 mt_com.mt_op = MTREW;
672 /* If we get an I/O error on rewind, it is probably because
673 * the drive is actually busy. We loop for (about 5 minutes)
674 * retrying every 5 seconds.
676 for (i=max_rewind_wait; ; i -= 5) {
677 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
680 if (i == max_rewind_wait) {
681 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
684 * This is a gross hack, because if the user has the
685 * device mounted (i.e. open), then uses mtx to load
686 * a tape, the current open file descriptor is invalid.
687 * So, we close the drive and re-open it.
690 int open_mode = openmode;
693 open(dcr, open_mode);
701 if (dev_errno == EIO) {
702 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
706 if (dev_errno == EIO && i > 0) {
707 Dmsg0(200, "Sleeping 5 seconds.\n");
712 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
713 print_name(), be.strerror());
718 } else if (is_file() || is_dvd()) {
719 if (lseek_dev(this, (off_t)0, SEEK_SET) < 0) {
722 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
723 print_name(), be.strerror());
730 void DEVICE::block(int why)
733 block_device(this, why);
737 void DEVICE::unblock()
740 unblock_device(this);
744 const char *DEVICE::print_blocked() const
746 switch (dev_blocked) {
747 case BST_NOT_BLOCKED:
748 return "BST_NOT_BLOCKED";
750 return "BST_UNMOUNTED";
751 case BST_WAITING_FOR_SYSOP:
752 return "BST_WAITING_FOR_SYSOP";
753 case BST_DOING_ACQUIRE:
754 return "BST_DOING_ACQUIRE";
755 case BST_WRITING_LABEL:
756 return "BST_WRITING_LABEL";
757 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
758 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
762 return _("unknown blocked code");
767 * Called to indicate that we have just read an
768 * EOF from the device.
770 void DEVICE::set_ateof()
782 * Called to indicate we are now at the end of the tape, and
783 * writing is not possible.
785 void DEVICE::set_ateot()
787 /* Make tape effectively read-only */
788 state |= (ST_EOF|ST_EOT|ST_WEOT);
793 * Position device to end of medium (end of data)
794 * Returns: true on succes
800 struct mtget mt_stat;
806 Mmsg1(errmsg, _("Bad call to eod_dev. Device %s not open\n"), print_name());
810 #if defined (__digital__) && defined (__unix__)
811 return fsf(VolCatInfo.VolCatFiles);
814 Dmsg0(29, "eod_dev\n");
818 clear_eof(); /* remove EOF flag */
819 block_num = file = 0;
822 if (is_fifo() || is_prog()) {
826 pos = lseek_dev(this, (off_t)0, SEEK_END);
827 // Dmsg1(100, "====== Seek to %lld\n", pos);
829 update_pos_dev(this);
835 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
836 print_name(), be.strerror());
840 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
841 Dmsg0(100,"Using FAST FSF for EOM\n");
842 /* If unknown position, rewind */
843 if (!dev_get_os_pos(this, &mt_stat)) {
848 mt_com.mt_op = MTFSF;
850 * ***FIXME*** fix code to handle case that INT16_MAX is
853 mt_com.mt_count = INT16_MAX; /* use big positive number */
854 if (mt_com.mt_count < 0) {
855 mt_com.mt_count = INT16_MAX; /* brain damaged system */
859 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
860 if (has_cap(CAP_EOM)) {
861 Dmsg0(100,"Using EOM for EOM\n");
862 mt_com.mt_op = MTEOM;
866 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
868 clrerror(mt_com.mt_op);
869 Dmsg1(50, "ioctl error: %s\n", be.strerror());
870 update_pos_dev(this);
871 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
872 print_name(), be.strerror());
876 if (!dev_get_os_pos(this, &mt_stat)) {
879 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
880 print_name(), be.strerror());
883 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
885 file = mt_stat.mt_fileno;
891 * Rewind then use FSF until EOT reached
897 * Move file by file to the end of the tape
900 for (file_num=file; !at_eot(); file_num++) {
901 Dmsg0(200, "eod_dev: doing fsf 1\n");
903 Dmsg0(200, "fsf error.\n");
907 * Avoid infinite loop by ensuring we advance.
909 if (file_num == (int)file) {
910 struct mtget mt_stat;
911 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
913 if (dev_get_os_pos(this, &mt_stat)) {
914 Dmsg2(100, "Adjust file from %d to %d\n", file , mt_stat.mt_fileno);
915 file = mt_stat.mt_fileno;
922 * Some drivers leave us after second EOF when doing
923 * MTEOM, so we must backup so that appending overwrites
926 if (has_cap(CAP_BSFATEOM)) {
927 struct mtget mt_stat;
928 /* Backup over EOF */
930 /* If BSF worked and fileno is known (not -1), set file */
931 if (dev_get_os_pos(this, &mt_stat)) {
932 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , mt_stat.mt_fileno);
933 file = mt_stat.mt_fileno;
935 file++; /* wing it -- not correct on all OSes */
938 update_pos_dev(this); /* update position */
940 Dmsg1(200, "EOD dev->file=%d\n", file);
945 * Set the position of the device -- only for files and DVD
946 * For other devices, there is no generic way to do it.
947 * Returns: true on succes
950 bool update_pos_dev(DEVICE *dev)
956 dev->dev_errno = EBADF;
957 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
958 Emsg0(M_FATAL, 0, dev->errmsg);
962 /* Find out where we are */
963 if (dev->is_file()) {
966 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
969 dev->dev_errno = errno;
970 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
971 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
972 dev->print_name(), be.strerror());
975 dev->file_addr = pos;
976 dev->block_num = (uint32_t)pos;
977 dev->file = (uint32_t)(pos >> 32);
985 * Return the status of the device. This was meant
986 * to be a generic routine. Unfortunately, it doesn't
987 * seem possible (at least I do not know how to do it
988 * currently), which means that for the moment, this
989 * routine has very little value.
993 uint32_t status_dev(DEVICE *dev)
995 struct mtget mt_stat;
998 if (dev->state & (ST_EOT | ST_WEOT)) {
1002 if (dev->state & ST_EOF) {
1006 if (dev->is_tape()) {
1008 Pmsg0(-20,_(" Bacula status:"));
1009 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1010 if (tape_ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
1012 dev->dev_errno = errno;
1013 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1014 dev->print_name(), be.strerror());
1017 Pmsg0(-20, _(" Device status:"));
1019 #if defined(HAVE_LINUX_OS)
1020 if (GMT_EOF(mt_stat.mt_gstat)) {
1024 if (GMT_BOT(mt_stat.mt_gstat)) {
1028 if (GMT_EOT(mt_stat.mt_gstat)) {
1032 if (GMT_SM(mt_stat.mt_gstat)) {
1036 if (GMT_EOD(mt_stat.mt_gstat)) {
1040 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1041 stat |= BMT_WR_PROT;
1042 Pmsg0(-20, " WR_PROT");
1044 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1046 Pmsg0(-20, " ONLINE");
1048 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1049 stat |= BMT_DR_OPEN;
1050 Pmsg0(-20, " DR_OPEN");
1052 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1053 stat |= BMT_IM_REP_EN;
1054 Pmsg0(-20, " IM_REP_EN");
1056 #elif defined(HAVE_WIN32)
1057 if (GMT_EOF(mt_stat.mt_gstat)) {
1061 if (GMT_BOT(mt_stat.mt_gstat)) {
1065 if (GMT_EOT(mt_stat.mt_gstat)) {
1069 if (GMT_EOD(mt_stat.mt_gstat)) {
1073 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1074 stat |= BMT_WR_PROT;
1075 Pmsg0(-20, " WR_PROT");
1077 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1079 Pmsg0(-20, " ONLINE");
1081 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1082 stat |= BMT_DR_OPEN;
1083 Pmsg0(-20, " DR_OPEN");
1085 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1086 stat |= BMT_IM_REP_EN;
1087 Pmsg0(-20, " IM_REP_EN");
1090 #endif /* !SunOS && !OSF */
1091 if (dev->has_cap(CAP_MTIOCGET)) {
1092 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1094 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1097 stat |= BMT_ONLINE | BMT_BOT;
1104 * Load medium in device
1105 * Returns: true on success
1108 bool load_dev(DEVICE *dev)
1115 dev->dev_errno = EBADF;
1116 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1117 Emsg0(M_FATAL, 0, dev->errmsg);
1120 if (!(dev->is_tape())) {
1124 Dmsg0(200, "stored: MTLOAD command not available\n");
1126 dev->dev_errno = ENOTTY; /* function not available */
1127 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1128 dev->print_name(), be.strerror());
1132 dev->block_num = dev->file = 0;
1135 mt_com.mt_op = MTLOAD;
1136 mt_com.mt_count = 1;
1137 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1139 dev->dev_errno = errno;
1140 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1141 dev->print_name(), be.strerror());
1149 * Rewind device and put it offline
1150 * Returns: true on success
1153 bool DEVICE::offline()
1158 return true; /* device not open */
1161 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1162 block_num = file = 0;
1166 mt_com.mt_op = MTUNLOCK;
1167 mt_com.mt_count = 1;
1168 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1170 mt_com.mt_op = MTOFFL;
1171 mt_com.mt_count = 1;
1172 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
1175 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1176 print_name(), be.strerror());
1179 Dmsg1(100, "Offlined device %s\n", print_name());
1183 bool DEVICE::offline_or_rewind()
1188 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1192 * Note, this rewind probably should not be here (it wasn't
1193 * in prior versions of Bacula), but on FreeBSD, this is
1194 * needed in the case the tape was "frozen" due to an error
1195 * such as backspacing after writing and EOF. If it is not
1196 * done, all future references to the drive get and I/O error.
1199 return rewind(NULL);
1204 * Foward space a file
1205 * Returns: true on success
1208 bool DEVICE::fsf(int num)
1210 struct mtget mt_stat;
1216 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1217 Emsg0(M_FATAL, 0, errmsg);
1226 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1230 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1233 Dmsg0(100, "fsf\n");
1236 * If Fast forward space file is set, then we
1237 * use MTFSF to forward space and MTIOCGET
1238 * to get the file position. We assume that
1239 * the SCSI driver will ensure that we do not
1240 * forward space past the end of the medium.
1242 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1243 mt_com.mt_op = MTFSF;
1244 mt_com.mt_count = num;
1245 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1246 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1249 Dmsg0(200, "Set ST_EOT\n");
1251 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1252 print_name(), be.strerror());
1253 Dmsg1(200, "%s", errmsg);
1256 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1258 file = mt_stat.mt_fileno;
1262 * Here if CAP_FSF is set, and virtually all drives
1263 * these days support it, we read a record, then forward
1264 * space one file. Using this procedure, which is slow,
1265 * is the only way we can be sure that we don't read
1266 * two consecutive EOF marks, which means End of Data.
1268 } else if (has_cap(CAP_FSF)) {
1271 Dmsg0(200, "FSF has cap_fsf\n");
1272 if (max_block_size == 0) {
1273 rbuf_len = DEFAULT_BLOCK_SIZE;
1275 rbuf_len = max_block_size;
1277 rbuf = get_memory(rbuf_len);
1278 mt_com.mt_op = MTFSF;
1279 mt_com.mt_count = 1;
1280 while (num-- && !at_eot()) {
1281 Dmsg0(100, "Doing read before fsf\n");
1282 if ((stat = tape_read(fd, (char *)rbuf, rbuf_len)) < 0) {
1283 if (errno == ENOMEM) { /* tape record exceeds buf len */
1284 stat = rbuf_len; /* This is OK */
1286 * On IBM drives, they return ENOSPC at EOM
1287 * instead of EOF status
1289 } else if (at_eof() && errno == ENOSPC) {
1295 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1297 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1298 print_name(), be.strerror());
1299 Dmsg1(100, "%s", errmsg);
1303 if (stat == 0) { /* EOF */
1304 update_pos_dev(this);
1305 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1306 /* Two reads of zero means end of tape */
1309 Dmsg0(100, "Set ST_EOT\n");
1315 } else { /* Got data */
1320 Dmsg0(100, "Doing MTFSF\n");
1321 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1322 if (stat < 0) { /* error => EOT */
1325 Dmsg0(100, "Set ST_EOT\n");
1327 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1328 print_name(), be.strerror());
1329 Dmsg0(100, "Got < 0 for MTFSF\n");
1330 Dmsg1(100, "%s", errmsg);
1338 * No FSF, so use FSR to simulate it
1341 Dmsg0(200, "Doing FSR for FSF\n");
1342 while (num-- && !at_eot()) {
1343 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1347 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1353 update_pos_dev(this);
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"),
1393 mt_com.mt_op = MTBSF;
1394 mt_com.mt_count = num;
1395 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1399 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1400 print_name(), be.strerror());
1402 update_pos_dev(this);
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);
1427 if (!has_cap(CAP_FSR)) {
1428 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1432 Dmsg1(29, "fsr %d\n", num);
1433 mt_com.mt_op = MTFSR;
1434 mt_com.mt_count = num;
1435 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1441 struct mtget mt_stat;
1443 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1444 if (dev_get_os_pos(this, &mt_stat)) {
1445 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1446 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1447 file = mt_stat.mt_fileno;
1448 block_num = mt_stat.mt_blkno;
1456 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1457 num, print_name(), be.strerror());
1459 update_pos_dev(this);
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());
1502 update_pos_dev(this);
1507 * Reposition the device to file, block
1508 * Returns: false on failure
1511 bool DEVICE::reposition(uint32_t rfile, uint32_t rblock)
1515 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1516 Emsg0(M_FATAL, 0, errmsg);
1521 off_t pos = (((off_t)rfile)<<32) + (off_t)rblock;
1522 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1523 if (lseek_dev(this, pos, SEEK_SET) == (off_t)-1) {
1526 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1527 print_name(), be.strerror());
1535 Dmsg4(100, "reposition from %u:%u to %u:%u\n",
1536 file, block_num, rfile, rblock);
1538 Dmsg0(100, "Rewind\n");
1539 if (!rewind(NULL)) {
1544 Dmsg1(100, "fsf %d\n", rfile-file);
1545 if (!fsf(rfile-file)) {
1546 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1549 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1551 if (rblock < block_num) {
1552 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1553 Dmsg0(100, "bsf 1\n");
1555 Dmsg0(100, "fsf_dev 1\n");
1557 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1559 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1560 /* Ignore errors as Bacula can read to the correct block */
1561 Dmsg1(100, "fsr %d\n", rblock-block_num);
1562 return fsr(rblock-block_num);
1570 * Write an end of file on the device
1571 * Returns: true on success
1574 bool DEVICE::weof(int num)
1578 Dmsg0(129, "weof_dev\n");
1582 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1583 Emsg0(M_FATAL, 0, errmsg);
1591 if (!can_append()) {
1592 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1593 Emsg0(M_FATAL, 0, errmsg);
1599 mt_com.mt_op = MTWEOF;
1600 mt_com.mt_count = num;
1601 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1610 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1611 print_name(), be.strerror());
1619 * If implemented in system, clear the tape
1622 void DEVICE::clrerror(int func)
1624 const char *msg = NULL;
1625 struct mtget mt_stat;
1628 dev_errno = errno; /* save errno */
1630 VolCatInfo.VolCatErrors++;
1636 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1639 break; /* ignore message printed later */
1642 capabilities &= ~CAP_EOF; /* turn off feature */
1647 capabilities &= ~CAP_EOM; /* turn off feature */
1652 capabilities &= ~CAP_FSF; /* turn off feature */
1656 capabilities &= ~CAP_BSF; /* turn off feature */
1660 capabilities &= ~CAP_FSR; /* turn off feature */
1664 capabilities &= ~CAP_BSR; /* turn off feature */
1698 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1704 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1705 Emsg0(M_ERROR, 0, errmsg);
1710 * Now we try different methods of clearing the error
1711 * status on the drive so that it is not locked for
1712 * further operations.
1715 /* On some systems such as NetBSD, this clears all errors */
1716 tape_ioctl(fd, MTIOCGET, (char *)&mt_stat);
1718 /* Found on Linux */
1722 mt_com.mt_op = MTIOCLRERR;
1723 mt_com.mt_count = 1;
1724 /* Clear any error condition on the tape */
1725 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1726 Dmsg0(200, "Did MTIOCLRERR\n");
1730 /* Typically on FreeBSD */
1734 /* Read and clear SCSI error status */
1735 union mterrstat mt_errstat;
1736 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1737 be.strerror(dev_errno));
1738 tape_ioctl(fd, MTIOCERRSTAT, (char *)&mt_errstat);
1742 /* Clear Subsystem Exception OSF1 */
1746 mt_com.mt_op = MTCSE;
1747 mt_com.mt_count = 1;
1748 /* Clear any error condition on the tape */
1749 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1750 Dmsg0(200, "Did MTCSE\n");
1758 void DEVICE::close()
1760 Dmsg1(100, "close_dev %s\n", print_name());
1761 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1771 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1773 return; /* already closed */
1776 if (is_dvd() && !unmount_dvd(this, 1)) {
1777 Dmsg1(0, "Cannot unmount device %s.\n", print_name());
1780 /* Remove the last part file if it is empty */
1781 if (num_dvd_parts > 0) {
1783 int part_save = part;
1784 POOL_MEM archive_name(PM_FNAME);
1786 part = num_dvd_parts;
1787 Dmsg3(100, "Remove empty part in close call make_dvd_filename. part=%d num=%d vol=%s\n",
1788 part, num_dvd_parts, VolCatInfo.VolCatName);
1789 make_spooled_dvd_filename(this, archive_name);
1790 /* Check that the part file is empty */
1791 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1792 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1793 unlink(archive_name.c_str());
1795 part = part_save; /* restore part number */
1798 /* Clean up device packet so it can be reused */
1800 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1801 label_type = B_BACULA_LABEL;
1802 file = block_num = 0;
1805 EndFile = EndBlock = 0;
1806 Slot = -1; /* unknown slot */
1808 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1809 memset(&VolHdr, 0, sizeof(VolHdr));
1811 stop_thread_timer(tid);
1819 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1821 Dmsg1(100, "truncate_dev %s\n", print_name());
1823 return true; /* we don't really truncate tapes */
1824 /* maybe we should rewind and write and eof ???? */
1828 return truncate_dvd(dcr);
1831 if (ftruncate(fd, 0) != 0) {
1833 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1834 print_name(), be.strerror());
1840 /* Mount the device.
1841 * If timeout, wait until the mount command returns 0.
1842 * If !timeout, try to mount the device only once.
1844 bool DEVICE::mount(int timeout)
1846 Dmsg0(190, "Enter mount\n");
1849 } else if (requires_mount()) {
1850 return do_mount(1, timeout);
1855 /* Unmount the device
1856 * If timeout, wait until the unmount command returns 0.
1857 * If !timeout, try to unmount the device only once.
1859 bool DEVICE::unmount(int timeout)
1861 Dmsg0(90, "Enter unmount_dvd\n");
1863 return do_mount(0, timeout);
1868 /* (Un)mount the device */
1869 bool DEVICE::do_mount(int mount, int dotimeout)
1871 POOL_MEM ocmd(PM_FNAME);
1874 int status, timeout;
1876 sm_check(__FILE__, __LINE__, false);
1879 Dmsg0(200, "======= mount=1\n");
1882 icmd = device->mount_command;
1884 if (!is_mounted()) {
1885 Dmsg0(200, "======= mount=0\n");
1888 icmd = device->unmount_command;
1891 edit_mount_codes(ocmd, icmd);
1893 Dmsg2(000, "do_mount_dvd: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1896 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1901 results = get_memory(2000);
1903 /* If busy retry each second */
1904 while ((status = run_program_full_output(ocmd.c_str(),
1905 max_open_wait/2, results)) != 0) {
1906 /* Doesn't work with internationalisation (This is not a problem) */
1907 if (fnmatch("*is already mounted on", results, 0) == 0) {
1910 if (timeout-- > 0) {
1911 /* Sometimes the device cannot be mounted because it is already mounted.
1912 * Try to unmount it, then remount it */
1914 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
1920 Dmsg2(40, "Device %s cannot be mounted. ERR=%s\n", print_name(), results);
1921 Mmsg(errmsg, _("Device %s cannot be mounted. ERR=%s\n"),
1922 print_name(), results);
1924 * Now, just to be sure it is not mounted, try to read the
1928 struct dirent *entry, *result;
1932 name_max = pathconf(".", _PC_NAME_MAX);
1933 if (name_max < 1024) {
1937 if (!(dp = opendir(device->mount_point))) {
1940 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
1941 device->mount_point, print_name(), be.strerror());
1945 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
1948 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
1950 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
1951 device->mount_point, print_name());
1954 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
1955 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
1958 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
1964 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
1967 mount = 1; /* If we got more than ., .. and .keep */
1968 break; /* there must be something mounted */
1972 sm_check(__FILE__, __LINE__, false);
1973 free_pool_memory(results);
1974 Dmsg0(200, "============ mount=0\n");
1978 set_mounted(mount); /* set/clear mounted flag */
1979 free_pool_memory(results);
1980 Dmsg1(200, "============ mount=%d\n", mount);
1985 * Edit codes into (Un)MountCommand, Write(First)PartCommand
1987 * %a = archive device name
1988 * %e = erase (set if cannot mount and first part)
1991 * %v = last part name
1993 * omsg = edited output message
1994 * imsg = input string containing edit codes (%x)
1997 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2003 POOL_MEM archive_name(PM_FNAME);
2005 omsg.c_str()[0] = 0;
2006 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2007 for (p=imsg; *p; p++) {
2017 if (num_dvd_parts == 0) {
2018 if (truncating || truncated_dvd) {
2028 bsnprintf(add, sizeof(add), "%d", part);
2032 str = device->mount_point;
2035 make_spooled_dvd_filename(this, archive_name);
2036 str = archive_name.c_str();
2050 Dmsg1(1900, "add_str %s\n", str);
2051 pm_strcat(omsg, (char *)str);
2052 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2057 /* Return the resource name for the device */
2058 const char *DEVICE::name() const
2060 return device->hdr.name;
2064 dev_vol_name(DEVICE *dev)
2066 return dev->VolCatInfo.VolCatName;
2069 uint32_t dev_block(DEVICE *dev)
2071 update_pos_dev(dev);
2072 return dev->block_num;
2075 uint32_t dev_file(DEVICE *dev)
2077 update_pos_dev(dev);
2082 * Free memory allocated for the device
2084 void DEVICE::term(void)
2086 Dmsg1(900, "term dev: %s\n", print_name());
2089 free_memory(dev_name);
2093 free_memory(prt_name);
2097 free_pool_memory(errmsg);
2100 pthread_mutex_destroy(&mutex);
2101 pthread_cond_destroy(&wait);
2102 pthread_cond_destroy(&wait_next_vol);
2103 pthread_mutex_destroy(&spool_mutex);
2105 if (attached_dcrs) {
2106 delete attached_dcrs;
2107 attached_dcrs = NULL;
2116 * This routine initializes the device wait timers
2118 void init_device_wait_timers(DCR *dcr)
2120 DEVICE *dev = dcr->dev;
2121 JCR *jcr = dcr->jcr;
2123 /* ******FIXME******* put these on config variables */
2124 dev->min_wait = 60 * 60;
2125 dev->max_wait = 24 * 60 * 60;
2126 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2127 dev->wait_sec = dev->min_wait;
2128 dev->rem_wait_sec = dev->wait_sec;
2131 dev->BadVolName[0] = 0;
2133 jcr->min_wait = 60 * 60;
2134 jcr->max_wait = 24 * 60 * 60;
2135 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2136 jcr->wait_sec = jcr->min_wait;
2137 jcr->rem_wait_sec = jcr->wait_sec;
2142 void init_jcr_device_wait_timers(JCR *jcr)
2144 /* ******FIXME******* put these on config variables */
2145 jcr->min_wait = 60 * 60;
2146 jcr->max_wait = 24 * 60 * 60;
2147 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2148 jcr->wait_sec = jcr->min_wait;
2149 jcr->rem_wait_sec = jcr->wait_sec;
2155 * The dev timers are used for waiting on a particular device
2157 * Returns: true if time doubled
2158 * false if max time expired
2160 bool double_dev_wait_time(DEVICE *dev)
2162 dev->wait_sec *= 2; /* double wait time */
2163 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2164 dev->wait_sec = dev->max_wait;
2167 dev->rem_wait_sec = dev->wait_sec;
2168 if (dev->num_wait >= dev->max_num_wait) {
2175 void set_os_device_parameters(DEVICE *dev)
2177 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2179 if (dev->min_block_size == dev->max_block_size &&
2180 dev->min_block_size == 0) { /* variable block mode */
2181 mt_com.mt_op = MTSETBLK;
2182 mt_com.mt_count = 0;
2183 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2184 dev->clrerror(MTSETBLK);
2186 mt_com.mt_op = MTSETDRVBUFFER;
2187 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2188 if (!dev->has_cap(CAP_TWOEOF)) {
2189 mt_com.mt_count |= MT_ST_TWO_FM;
2191 if (dev->has_cap(CAP_EOM)) {
2192 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2194 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2195 dev->clrerror(MTSETBLK);
2201 #ifdef HAVE_NETBSD_OS
2203 if (dev->min_block_size == dev->max_block_size &&
2204 dev->min_block_size == 0) { /* variable block mode */
2205 mt_com.mt_op = MTSETBSIZ;
2206 mt_com.mt_count = 0;
2207 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2208 dev->clrerror(MTSETBSIZ);
2210 /* Get notified at logical end of tape */
2211 mt_com.mt_op = MTEWARN;
2212 mt_com.mt_count = 1;
2213 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2214 dev->clrerror(MTEWARN);
2220 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2222 if (dev->min_block_size == dev->max_block_size &&
2223 dev->min_block_size == 0) { /* variable block mode */
2224 mt_com.mt_op = MTSETBSIZ;
2225 mt_com.mt_count = 0;
2226 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2227 dev->clrerror(MTSETBSIZ);
2235 if (dev->min_block_size == dev->max_block_size &&
2236 dev->min_block_size == 0) { /* variable block mode */
2237 mt_com.mt_op = MTSRSZ;
2238 mt_com.mt_count = 0;
2239 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2240 dev->clrerror(MTSRSZ);
2247 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2249 return dev->has_cap(CAP_MTIOCGET) &&
2250 tape_ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2251 mt_stat->mt_fileno >= 0;
2254 static char *modes[] = {
2255 "CREATE_READ_WRITE",
2262 static char *mode_to_str(int mode)
2264 static char buf[100];
2265 if (mode < 1 || mode > 4) {
2266 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2269 return modes[mode-1];