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 device 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) {
531 * If we can mount the device, and we are not truncating the DVD,
532 * we usually want to abort. There is one exception, if there is
533 * only one 0-sized file on the DVD, with the right volume name,
534 * we continue (it's the method used by truncate_dvd to truncate a volume).
536 if (!check_can_write_on_non_blank_dvd(dcr)) {
537 Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
538 Emsg0(M_FATAL, 0, errmsg);
539 unmount_dvd(this, 1); /* Unmount the device, so the operator can change it. */
543 truncated_dvd = true;
546 Dmsg0(99, "DVD device mount failed.\n");
547 /* We cannot mount the device */
548 if (num_dvd_parts == 0) {
549 /* Run free space, check there is a media. */
550 if (!update_free_space_dev(this)) {
551 Emsg0(M_FATAL, 0, errmsg);
556 Dmsg1(29, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
558 Mmsg(errmsg, _("There is no valid media in the device %s.\n"), print_name());
559 Emsg0(M_FATAL, 0, errmsg);
564 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
565 Emsg0(M_FATAL, 0, errmsg);
571 Dmsg5(29, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
572 archive_name.c_str(), mode_to_str(omode),
573 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
575 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
578 * If we are not trying to access the last part, set mode to
579 * OPEN_READ_ONLY as writing would be an error.
581 Dmsg2(29, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
582 if (part <= num_dvd_parts) {
583 omode = OPEN_READ_ONLY;
584 make_mounted_dvd_filename(this, archive_name);
586 omode = OPEN_READ_WRITE;
587 make_spooled_dvd_filename(this, archive_name);
591 /* If creating file, give 0640 permissions */
592 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
593 archive_name.c_str(), mode);
594 /* Use system open() */
595 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
597 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
599 // Should this be set if we try the create/open below
600 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
601 Dmsg1(29, "open failed: %s", errmsg);
603 /* Previous open failed. See if we can recover */
604 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
605 (part > num_dvd_parts)) {
606 /* If the last part (on spool), doesn't exist when accessing,
607 * create it. In read/write mode a write will be allowed (higher
608 * level software thinks that we are extending a pre-existing
609 * media. Reads for READ_ONLY will report immediately an EOF
610 * Sometimes it is better to finish with an EOF than with an error. */
611 Dmsg1(29, "Creating last part on spool: %s\n", archive_name.c_str());
612 omode = CREATE_READ_WRITE;
613 set_mode(CREATE_READ_WRITE);
614 fd = ::open(archive_name.c_str(), mode, 0640);
618 Dmsg1(100, "after open fd=%d\n", fd);
620 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
623 /* Get size of file */
624 if (fstat(fd, &filestat) < 0) {
627 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
629 Dmsg1(29, "open failed: %s", errmsg);
630 /* Use system close() */
634 part_size = filestat.st_size;
636 update_pos_dev(this); /* update position */
644 * Returns: true on success
647 bool DEVICE::rewind(DCR *dcr)
653 Dmsg3(400, "rewind res=%d fd=%d %s\n", reserved_device, fd, print_name());
654 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
655 block_num = file = 0;
659 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
661 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
663 Emsg0(M_ABORT, 0, errmsg);
668 mt_com.mt_op = MTREW;
670 /* If we get an I/O error on rewind, it is probably because
671 * the drive is actually busy. We loop for (about 5 minutes)
672 * retrying every 5 seconds.
674 for (i=max_rewind_wait; ; i -= 5) {
675 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
678 if (i == max_rewind_wait) {
679 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
682 * This is a gross hack, because if the user has the
683 * device mounted (i.e. open), then uses mtx to load
684 * a tape, the current open file descriptor is invalid.
685 * So, we close the drive and re-open it.
688 int open_mode = openmode;
691 open(dcr, open_mode);
699 if (dev_errno == EIO) {
700 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
704 if (dev_errno == EIO && i > 0) {
705 Dmsg0(200, "Sleeping 5 seconds.\n");
710 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
711 print_name(), be.strerror());
716 } else if (is_file() || is_dvd()) {
717 if (lseek_dev(this, (off_t)0, SEEK_SET) < 0) {
720 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
721 print_name(), be.strerror());
728 void DEVICE::block(int why)
731 block_device(this, why);
735 void DEVICE::unblock()
738 unblock_device(this);
742 const char *DEVICE::print_blocked() const
744 switch (dev_blocked) {
745 case BST_NOT_BLOCKED:
746 return "BST_NOT_BLOCKED";
748 return "BST_UNMOUNTED";
749 case BST_WAITING_FOR_SYSOP:
750 return "BST_WAITING_FOR_SYSOP";
751 case BST_DOING_ACQUIRE:
752 return "BST_DOING_ACQUIRE";
753 case BST_WRITING_LABEL:
754 return "BST_WRITING_LABEL";
755 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
756 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
760 return _("unknown blocked code");
765 * Called to indicate that we have just read an
766 * EOF from the device.
768 void DEVICE::set_ateof()
780 * Called to indicate we are now at the end of the tape, and
781 * writing is not possible.
783 void DEVICE::set_ateot()
785 /* Make tape effectively read-only */
786 state |= (ST_EOF|ST_EOT|ST_WEOT);
791 * Position device to end of medium (end of data)
792 * Returns: true on succes
798 struct mtget mt_stat;
804 Mmsg1(errmsg, _("Bad call to eod_dev. Device %s not open\n"), print_name());
808 #if defined (__digital__) && defined (__unix__)
809 return fsf(VolCatInfo.VolCatFiles);
812 Dmsg0(29, "eod_dev\n");
816 clear_eof(); /* remove EOF flag */
817 block_num = file = 0;
820 if (is_fifo() || is_prog()) {
824 pos = lseek_dev(this, (off_t)0, SEEK_END);
825 // Dmsg1(100, "====== Seek to %lld\n", pos);
827 update_pos_dev(this);
833 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
834 print_name(), be.strerror());
838 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
839 Dmsg0(100,"Using FAST FSF for EOM\n");
840 /* If unknown position, rewind */
841 if (!dev_get_os_pos(this, &mt_stat)) {
846 mt_com.mt_op = MTFSF;
848 * ***FIXME*** fix code to handle case that INT16_MAX is
851 mt_com.mt_count = INT16_MAX; /* use big positive number */
852 if (mt_com.mt_count < 0) {
853 mt_com.mt_count = INT16_MAX; /* brain damaged system */
857 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
858 if (has_cap(CAP_EOM)) {
859 Dmsg0(100,"Using EOM for EOM\n");
860 mt_com.mt_op = MTEOM;
864 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
866 clrerror(mt_com.mt_op);
867 Dmsg1(50, "ioctl error: %s\n", be.strerror());
868 update_pos_dev(this);
869 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
870 print_name(), be.strerror());
874 if (!dev_get_os_pos(this, &mt_stat)) {
877 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
878 print_name(), be.strerror());
881 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
883 file = mt_stat.mt_fileno;
889 * Rewind then use FSF until EOT reached
895 * Move file by file to the end of the tape
898 for (file_num=file; !at_eot(); file_num++) {
899 Dmsg0(200, "eod_dev: doing fsf 1\n");
901 Dmsg0(200, "fsf error.\n");
905 * Avoid infinite loop by ensuring we advance.
907 if (file_num == (int)file) {
908 struct mtget mt_stat;
909 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
911 if (dev_get_os_pos(this, &mt_stat)) {
912 Dmsg2(100, "Adjust file from %d to %d\n", file , mt_stat.mt_fileno);
913 file = mt_stat.mt_fileno;
920 * Some drivers leave us after second EOF when doing
921 * MTEOM, so we must backup so that appending overwrites
924 if (has_cap(CAP_BSFATEOM)) {
925 struct mtget mt_stat;
926 /* Backup over EOF */
928 /* If BSF worked and fileno is known (not -1), set file */
929 if (dev_get_os_pos(this, &mt_stat)) {
930 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , mt_stat.mt_fileno);
931 file = mt_stat.mt_fileno;
933 file++; /* wing it -- not correct on all OSes */
936 update_pos_dev(this); /* update position */
938 Dmsg1(200, "EOD dev->file=%d\n", file);
943 * Set the position of the device -- only for files and DVD
944 * For other devices, there is no generic way to do it.
945 * Returns: true on succes
948 bool update_pos_dev(DEVICE *dev)
954 dev->dev_errno = EBADF;
955 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
956 Emsg0(M_FATAL, 0, dev->errmsg);
960 /* Find out where we are */
961 if (dev->is_file()) {
964 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
967 dev->dev_errno = errno;
968 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
969 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
970 dev->print_name(), be.strerror());
973 dev->file_addr = pos;
974 dev->block_num = (uint32_t)pos;
975 dev->file = (uint32_t)(pos >> 32);
983 * Return the status of the device. This was meant
984 * to be a generic routine. Unfortunately, it doesn't
985 * seem possible (at least I do not know how to do it
986 * currently), which means that for the moment, this
987 * routine has very little value.
991 uint32_t status_dev(DEVICE *dev)
993 struct mtget mt_stat;
996 if (dev->state & (ST_EOT | ST_WEOT)) {
1000 if (dev->state & ST_EOF) {
1004 if (dev->is_tape()) {
1006 Pmsg0(-20,_(" Bacula status:"));
1007 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1008 if (tape_ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
1010 dev->dev_errno = errno;
1011 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1012 dev->print_name(), be.strerror());
1015 Pmsg0(-20, _(" Device status:"));
1017 #if defined(HAVE_LINUX_OS)
1018 if (GMT_EOF(mt_stat.mt_gstat)) {
1022 if (GMT_BOT(mt_stat.mt_gstat)) {
1026 if (GMT_EOT(mt_stat.mt_gstat)) {
1030 if (GMT_SM(mt_stat.mt_gstat)) {
1034 if (GMT_EOD(mt_stat.mt_gstat)) {
1038 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1039 stat |= BMT_WR_PROT;
1040 Pmsg0(-20, " WR_PROT");
1042 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1044 Pmsg0(-20, " ONLINE");
1046 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1047 stat |= BMT_DR_OPEN;
1048 Pmsg0(-20, " DR_OPEN");
1050 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1051 stat |= BMT_IM_REP_EN;
1052 Pmsg0(-20, " IM_REP_EN");
1054 #elif defined(HAVE_WIN32)
1055 if (GMT_EOF(mt_stat.mt_gstat)) {
1059 if (GMT_BOT(mt_stat.mt_gstat)) {
1063 if (GMT_EOT(mt_stat.mt_gstat)) {
1067 if (GMT_EOD(mt_stat.mt_gstat)) {
1071 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1072 stat |= BMT_WR_PROT;
1073 Pmsg0(-20, " WR_PROT");
1075 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1077 Pmsg0(-20, " ONLINE");
1079 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1080 stat |= BMT_DR_OPEN;
1081 Pmsg0(-20, " DR_OPEN");
1083 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1084 stat |= BMT_IM_REP_EN;
1085 Pmsg0(-20, " IM_REP_EN");
1088 #endif /* !SunOS && !OSF */
1089 if (dev->has_cap(CAP_MTIOCGET)) {
1090 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1092 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1095 stat |= BMT_ONLINE | BMT_BOT;
1102 * Load medium in device
1103 * Returns: true on success
1106 bool load_dev(DEVICE *dev)
1113 dev->dev_errno = EBADF;
1114 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1115 Emsg0(M_FATAL, 0, dev->errmsg);
1118 if (!(dev->is_tape())) {
1122 Dmsg0(200, "stored: MTLOAD command not available\n");
1124 dev->dev_errno = ENOTTY; /* function not available */
1125 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1126 dev->print_name(), be.strerror());
1130 dev->block_num = dev->file = 0;
1133 mt_com.mt_op = MTLOAD;
1134 mt_com.mt_count = 1;
1135 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1137 dev->dev_errno = errno;
1138 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1139 dev->print_name(), be.strerror());
1147 * Rewind device and put it offline
1148 * Returns: true on success
1151 bool DEVICE::offline()
1156 return true; /* device not open */
1159 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1160 block_num = file = 0;
1164 mt_com.mt_op = MTUNLOCK;
1165 mt_com.mt_count = 1;
1166 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1168 mt_com.mt_op = MTOFFL;
1169 mt_com.mt_count = 1;
1170 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
1173 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1174 print_name(), be.strerror());
1177 Dmsg1(100, "Offlined device %s\n", print_name());
1181 bool DEVICE::offline_or_rewind()
1186 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1190 * Note, this rewind probably should not be here (it wasn't
1191 * in prior versions of Bacula), but on FreeBSD, this is
1192 * needed in the case the tape was "frozen" due to an error
1193 * such as backspacing after writing and EOF. If it is not
1194 * done, all future references to the drive get and I/O error.
1197 return rewind(NULL);
1202 * Foward space a file
1203 * Returns: true on success
1206 bool DEVICE::fsf(int num)
1208 struct mtget mt_stat;
1214 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1215 Emsg0(M_FATAL, 0, errmsg);
1224 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1228 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1231 Dmsg0(100, "fsf\n");
1234 * If Fast forward space file is set, then we
1235 * use MTFSF to forward space and MTIOCGET
1236 * to get the file position. We assume that
1237 * the SCSI driver will ensure that we do not
1238 * forward space past the end of the medium.
1240 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1241 mt_com.mt_op = MTFSF;
1242 mt_com.mt_count = num;
1243 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1244 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1247 Dmsg0(200, "Set ST_EOT\n");
1249 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1250 print_name(), be.strerror());
1251 Dmsg1(200, "%s", errmsg);
1254 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1256 file = mt_stat.mt_fileno;
1260 * Here if CAP_FSF is set, and virtually all drives
1261 * these days support it, we read a record, then forward
1262 * space one file. Using this procedure, which is slow,
1263 * is the only way we can be sure that we don't read
1264 * two consecutive EOF marks, which means End of Data.
1266 } else if (has_cap(CAP_FSF)) {
1269 Dmsg0(200, "FSF has cap_fsf\n");
1270 if (max_block_size == 0) {
1271 rbuf_len = DEFAULT_BLOCK_SIZE;
1273 rbuf_len = max_block_size;
1275 rbuf = get_memory(rbuf_len);
1276 mt_com.mt_op = MTFSF;
1277 mt_com.mt_count = 1;
1278 while (num-- && !at_eot()) {
1279 Dmsg0(100, "Doing read before fsf\n");
1280 if ((stat = tape_read(fd, (char *)rbuf, rbuf_len)) < 0) {
1281 if (errno == ENOMEM) { /* tape record exceeds buf len */
1282 stat = rbuf_len; /* This is OK */
1284 * On IBM drives, they return ENOSPC at EOM
1285 * instead of EOF status
1287 } else if (at_eof() && errno == ENOSPC) {
1293 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1295 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1296 print_name(), be.strerror());
1297 Dmsg1(100, "%s", errmsg);
1301 if (stat == 0) { /* EOF */
1302 update_pos_dev(this);
1303 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1304 /* Two reads of zero means end of tape */
1307 Dmsg0(100, "Set ST_EOT\n");
1313 } else { /* Got data */
1318 Dmsg0(100, "Doing MTFSF\n");
1319 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1320 if (stat < 0) { /* error => EOT */
1323 Dmsg0(100, "Set ST_EOT\n");
1325 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1326 print_name(), be.strerror());
1327 Dmsg0(100, "Got < 0 for MTFSF\n");
1328 Dmsg1(100, "%s", errmsg);
1336 * No FSF, so use FSR to simulate it
1339 Dmsg0(200, "Doing FSR for FSF\n");
1340 while (num-- && !at_eot()) {
1341 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1345 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1351 update_pos_dev(this);
1352 Dmsg1(200, "Return %d from FSF\n", stat);
1354 Dmsg0(200, "ST_EOF set on exit FSF\n");
1357 Dmsg0(200, "ST_EOT set on exit FSF\n");
1359 Dmsg1(200, "Return from FSF file=%d\n", file);
1364 * Backward space a file
1365 * Returns: false on failure
1368 bool DEVICE::bsf(int num)
1375 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1376 Emsg0(M_FATAL, 0, errmsg);
1381 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1391 mt_com.mt_op = MTBSF;
1392 mt_com.mt_count = num;
1393 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1397 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1398 print_name(), be.strerror());
1400 update_pos_dev(this);
1406 * Foward space num records
1407 * Returns: false on failure
1410 bool DEVICE::fsr(int num)
1417 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1418 Emsg0(M_FATAL, 0, errmsg);
1425 if (!has_cap(CAP_FSR)) {
1426 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1430 Dmsg1(29, "fsr %d\n", num);
1431 mt_com.mt_op = MTFSR;
1432 mt_com.mt_count = num;
1433 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1439 struct mtget mt_stat;
1441 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1442 if (dev_get_os_pos(this, &mt_stat)) {
1443 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1444 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1445 file = mt_stat.mt_fileno;
1446 block_num = mt_stat.mt_blkno;
1454 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1455 num, print_name(), be.strerror());
1457 update_pos_dev(this);
1462 * Backward space a record
1463 * Returns: false on failure
1466 bool DEVICE::bsr(int num)
1473 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1474 Emsg0(M_FATAL, 0, errmsg);
1482 if (!has_cap(CAP_BSR)) {
1483 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1487 Dmsg0(29, "bsr_dev\n");
1491 mt_com.mt_op = MTBSR;
1492 mt_com.mt_count = num;
1493 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1497 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1498 print_name(), be.strerror());
1500 update_pos_dev(this);
1505 * Reposition the device to file, block
1506 * Returns: false on failure
1509 bool DEVICE::reposition(uint32_t rfile, uint32_t rblock)
1513 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1514 Emsg0(M_FATAL, 0, errmsg);
1519 off_t pos = (((off_t)rfile)<<32) + (off_t)rblock;
1520 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1521 if (lseek_dev(this, pos, SEEK_SET) == (off_t)-1) {
1524 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1525 print_name(), be.strerror());
1533 Dmsg4(100, "reposition from %u:%u to %u:%u\n",
1534 file, block_num, rfile, rblock);
1536 Dmsg0(100, "Rewind\n");
1537 if (!rewind(NULL)) {
1542 Dmsg1(100, "fsf %d\n", rfile-file);
1543 if (!fsf(rfile-file)) {
1544 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1547 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1549 if (rblock < block_num) {
1550 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1551 Dmsg0(100, "bsf 1\n");
1553 Dmsg0(100, "fsf_dev 1\n");
1555 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1557 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1558 /* Ignore errors as Bacula can read to the correct block */
1559 Dmsg1(100, "fsr %d\n", rblock-block_num);
1560 return fsr(rblock-block_num);
1568 * Write an end of file on the device
1569 * Returns: true on success
1572 bool DEVICE::weof(int num)
1576 Dmsg0(129, "weof_dev\n");
1580 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1581 Emsg0(M_FATAL, 0, errmsg);
1589 if (!can_append()) {
1590 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1591 Emsg0(M_FATAL, 0, errmsg);
1597 mt_com.mt_op = MTWEOF;
1598 mt_com.mt_count = num;
1599 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1608 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1609 print_name(), be.strerror());
1617 * If implemented in system, clear the tape
1620 void DEVICE::clrerror(int func)
1622 const char *msg = NULL;
1623 struct mtget mt_stat;
1626 dev_errno = errno; /* save errno */
1628 VolCatInfo.VolCatErrors++;
1634 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1637 break; /* ignore message printed later */
1640 capabilities &= ~CAP_EOF; /* turn off feature */
1645 capabilities &= ~CAP_EOM; /* turn off feature */
1650 capabilities &= ~CAP_FSF; /* turn off feature */
1654 capabilities &= ~CAP_BSF; /* turn off feature */
1658 capabilities &= ~CAP_FSR; /* turn off feature */
1662 capabilities &= ~CAP_BSR; /* turn off feature */
1696 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1702 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1703 Emsg0(M_ERROR, 0, errmsg);
1708 * Now we try different methods of clearing the error
1709 * status on the drive so that it is not locked for
1710 * further operations.
1713 /* On some systems such as NetBSD, this clears all errors */
1714 tape_ioctl(fd, MTIOCGET, (char *)&mt_stat);
1716 /* Found on Linux */
1720 mt_com.mt_op = MTIOCLRERR;
1721 mt_com.mt_count = 1;
1722 /* Clear any error condition on the tape */
1723 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1724 Dmsg0(200, "Did MTIOCLRERR\n");
1728 /* Typically on FreeBSD */
1732 /* Read and clear SCSI error status */
1733 union mterrstat mt_errstat;
1734 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1735 be.strerror(dev_errno));
1736 tape_ioctl(fd, MTIOCERRSTAT, (char *)&mt_errstat);
1740 /* Clear Subsystem Exception OSF1 */
1744 mt_com.mt_op = MTCSE;
1745 mt_com.mt_count = 1;
1746 /* Clear any error condition on the tape */
1747 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1748 Dmsg0(200, "Did MTCSE\n");
1756 void DEVICE::close()
1758 Dmsg1(100, "close_dev %s\n", print_name());
1759 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1769 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1771 return; /* already closed */
1774 if (is_dvd() && !unmount_dvd(this, 1)) {
1775 Dmsg1(0, "Cannot unmount device %s.\n", print_name());
1778 /* Remove the last part file if it is empty */
1779 if (num_dvd_parts > 0) {
1781 int part_save = part;
1782 POOL_MEM archive_name(PM_FNAME);
1785 part = num_dvd_parts;
1786 make_spooled_dvd_filename(this, archive_name);
1787 /* Check that the part file is empty */
1788 status = stat(archive_name.c_str(), &statp);
1789 if (status == 0 && statp.st_size == 0) {
1790 Dmsg3(100, "Unlink empty part in close call make_dvd_filename. part=%d num=%d vol=%s\n",
1791 part, num_dvd_parts, VolCatInfo.VolCatName);
1792 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1793 unlink(archive_name.c_str());
1794 set_part_spooled(false); /* no spooled part left */
1795 } else if (status < 0) {
1796 set_part_spooled(false); /* spool doesn't exit */
1798 part = part_save; /* restore part number */
1801 /* Clean up device packet so it can be reused */
1803 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1804 label_type = B_BACULA_LABEL;
1805 file = block_num = 0;
1808 EndFile = EndBlock = 0;
1809 Slot = -1; /* unknown slot */
1811 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1812 memset(&VolHdr, 0, sizeof(VolHdr));
1814 stop_thread_timer(tid);
1821 * This call closes the device, but it is used in DVD handling
1822 * where we close one part and then open the next part. The
1823 * difference between close_part() and close() is that close_part()
1824 * saves the state information of the device (e.g. the Volume lable,
1825 * the Volume Catalog record, ... This permits opening and closing
1826 * the Volume parts multiple times without losing track of what the
1827 * main Volume parameters are.
1829 void DEVICE::close_part(DCR *dcr)
1831 VOLUME_LABEL saveVolHdr;
1832 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1835 memcpy(&saveVolHdr, &VolHdr, sizeof(saveVolHdr));
1836 memcpy(&saveVolCatInfo, &VolCatInfo, sizeof(saveVolCatInfo));
1837 close(); /* close current part */
1838 memcpy(&VolHdr, &saveVolHdr, sizeof(VolHdr));
1839 memcpy(&VolCatInfo, &saveVolCatInfo, sizeof(VolCatInfo));
1840 memcpy(&dcr->VolCatInfo, &saveVolCatInfo, sizeof(dcr->VolCatInfo));
1846 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1848 Dmsg1(100, "truncate_dev %s\n", print_name());
1850 return true; /* we don't really truncate tapes */
1851 /* maybe we should rewind and write and eof ???? */
1855 return truncate_dvd(dcr);
1858 if (ftruncate(fd, 0) != 0) {
1860 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1861 print_name(), be.strerror());
1867 /* Mount the device.
1868 * If timeout, wait until the mount command returns 0.
1869 * If !timeout, try to mount the device only once.
1871 bool DEVICE::mount(int timeout)
1873 Dmsg0(190, "Enter mount\n");
1876 } else if (requires_mount()) {
1877 return do_mount(1, timeout);
1882 /* Unmount the device
1883 * If timeout, wait until the unmount command returns 0.
1884 * If !timeout, try to unmount the device only once.
1886 bool DEVICE::unmount(int timeout)
1888 Dmsg0(90, "Enter unmount_dvd\n");
1890 return do_mount(0, timeout);
1895 /* (Un)mount the device */
1896 bool DEVICE::do_mount(int mount, int dotimeout)
1898 POOL_MEM ocmd(PM_FNAME);
1901 int status, timeout;
1903 sm_check(__FILE__, __LINE__, false);
1906 Dmsg0(200, "======= mount=1\n");
1909 icmd = device->mount_command;
1911 if (!is_mounted()) {
1912 Dmsg0(200, "======= mount=0\n");
1915 icmd = device->unmount_command;
1918 edit_mount_codes(ocmd, icmd);
1920 Dmsg2(000, "do_mount_dvd: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1923 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1928 results = get_memory(2000);
1931 /* If busy retry each second */
1932 Dmsg1(20, "do_mount run_prog=%s\n", ocmd.c_str());
1933 while ((status = run_program_full_output(ocmd.c_str(),
1934 max_open_wait/2, results)) != 0) {
1935 /* Doesn't work with internationalization (This is not a problem) */
1936 if (fnmatch("*is already mounted on", results, 0) == 0) {
1939 if (timeout-- > 0) {
1940 /* Sometimes the device cannot be mounted because it is already mounted.
1941 * Try to unmount it, then remount it */
1943 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
1949 Dmsg2(40, "Device %s cannot be mounted. ERR=%s\n", print_name(), results);
1950 Mmsg(errmsg, _("Device %s cannot be mounted. ERR=%s\n"),
1951 print_name(), results);
1953 * Now, just to be sure it is not mounted, try to read the
1957 struct dirent *entry, *result;
1961 name_max = pathconf(".", _PC_NAME_MAX);
1962 if (name_max < 1024) {
1966 if (!(dp = opendir(device->mount_point))) {
1969 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
1970 device->mount_point, print_name(), be.strerror());
1974 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
1977 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
1979 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
1980 device->mount_point, print_name());
1983 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
1984 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
1987 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
1993 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
1996 mount = 1; /* If we got more than ., .. and .keep */
1997 break; /* there must be something mounted */
2001 sm_check(__FILE__, __LINE__, false);
2002 free_pool_memory(results);
2003 Dmsg0(200, "============ mount=0\n");
2007 set_mounted(mount); /* set/clear mounted flag */
2008 free_pool_memory(results);
2009 Dmsg1(200, "============ mount=%d\n", mount);
2014 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2016 * %a = archive device name
2017 * %e = erase (set if cannot mount and first part)
2020 * %v = last part name
2022 * omsg = edited output message
2023 * imsg = input string containing edit codes (%x)
2026 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2032 POOL_MEM archive_name(PM_FNAME);
2034 omsg.c_str()[0] = 0;
2035 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2036 for (p=imsg; *p; p++) {
2046 if (num_dvd_parts == 0) {
2047 if (truncating || truncated_dvd) {
2057 bsnprintf(add, sizeof(add), "%d", part);
2061 str = device->mount_point;
2064 make_spooled_dvd_filename(this, archive_name);
2065 str = archive_name.c_str();
2079 Dmsg1(1900, "add_str %s\n", str);
2080 pm_strcat(omsg, (char *)str);
2081 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2086 /* Return the resource name for the device */
2087 const char *DEVICE::name() const
2089 return device->hdr.name;
2093 dev_vol_name(DEVICE *dev)
2095 return dev->VolCatInfo.VolCatName;
2098 uint32_t dev_block(DEVICE *dev)
2100 update_pos_dev(dev);
2101 return dev->block_num;
2104 uint32_t dev_file(DEVICE *dev)
2106 update_pos_dev(dev);
2111 * Free memory allocated for the device
2113 void DEVICE::term(void)
2115 Dmsg1(900, "term dev: %s\n", print_name());
2118 free_memory(dev_name);
2122 free_memory(prt_name);
2126 free_pool_memory(errmsg);
2129 pthread_mutex_destroy(&mutex);
2130 pthread_cond_destroy(&wait);
2131 pthread_cond_destroy(&wait_next_vol);
2132 pthread_mutex_destroy(&spool_mutex);
2134 if (attached_dcrs) {
2135 delete attached_dcrs;
2136 attached_dcrs = NULL;
2145 * This routine initializes the device wait timers
2147 void init_device_wait_timers(DCR *dcr)
2149 DEVICE *dev = dcr->dev;
2150 JCR *jcr = dcr->jcr;
2152 /* ******FIXME******* put these on config variables */
2153 dev->min_wait = 60 * 60;
2154 dev->max_wait = 24 * 60 * 60;
2155 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2156 dev->wait_sec = dev->min_wait;
2157 dev->rem_wait_sec = dev->wait_sec;
2160 dev->BadVolName[0] = 0;
2162 jcr->min_wait = 60 * 60;
2163 jcr->max_wait = 24 * 60 * 60;
2164 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2165 jcr->wait_sec = jcr->min_wait;
2166 jcr->rem_wait_sec = jcr->wait_sec;
2171 void init_jcr_device_wait_timers(JCR *jcr)
2173 /* ******FIXME******* put these on config variables */
2174 jcr->min_wait = 60 * 60;
2175 jcr->max_wait = 24 * 60 * 60;
2176 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2177 jcr->wait_sec = jcr->min_wait;
2178 jcr->rem_wait_sec = jcr->wait_sec;
2184 * The dev timers are used for waiting on a particular device
2186 * Returns: true if time doubled
2187 * false if max time expired
2189 bool double_dev_wait_time(DEVICE *dev)
2191 dev->wait_sec *= 2; /* double wait time */
2192 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2193 dev->wait_sec = dev->max_wait;
2196 dev->rem_wait_sec = dev->wait_sec;
2197 if (dev->num_wait >= dev->max_num_wait) {
2204 void set_os_device_parameters(DEVICE *dev)
2206 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2208 if (dev->min_block_size == dev->max_block_size &&
2209 dev->min_block_size == 0) { /* variable block mode */
2210 mt_com.mt_op = MTSETBLK;
2211 mt_com.mt_count = 0;
2212 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2213 dev->clrerror(MTSETBLK);
2215 mt_com.mt_op = MTSETDRVBUFFER;
2216 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2217 if (!dev->has_cap(CAP_TWOEOF)) {
2218 mt_com.mt_count |= MT_ST_TWO_FM;
2220 if (dev->has_cap(CAP_EOM)) {
2221 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2223 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2224 dev->clrerror(MTSETBLK);
2230 #ifdef HAVE_NETBSD_OS
2232 if (dev->min_block_size == dev->max_block_size &&
2233 dev->min_block_size == 0) { /* variable block mode */
2234 mt_com.mt_op = MTSETBSIZ;
2235 mt_com.mt_count = 0;
2236 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2237 dev->clrerror(MTSETBSIZ);
2239 /* Get notified at logical end of tape */
2240 mt_com.mt_op = MTEWARN;
2241 mt_com.mt_count = 1;
2242 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2243 dev->clrerror(MTEWARN);
2249 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2251 if (dev->min_block_size == dev->max_block_size &&
2252 dev->min_block_size == 0) { /* variable block mode */
2253 mt_com.mt_op = MTSETBSIZ;
2254 mt_com.mt_count = 0;
2255 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2256 dev->clrerror(MTSETBSIZ);
2264 if (dev->min_block_size == dev->max_block_size &&
2265 dev->min_block_size == 0) { /* variable block mode */
2266 mt_com.mt_op = MTSRSZ;
2267 mt_com.mt_count = 0;
2268 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2269 dev->clrerror(MTSRSZ);
2276 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2278 return dev->has_cap(CAP_MTIOCGET) &&
2279 tape_ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2280 mt_stat->mt_fileno >= 0;
2283 static char *modes[] = {
2284 "CREATE_READ_WRITE",
2291 static char *mode_to_str(int mode)
2293 static char buf[100];
2294 if (mode < 1 || mode > 4) {
2295 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2298 return modes[mode-1];