3 * dev.c -- low level operations on device (storage device)
7 * NOTE!!!! None of these routines are reentrant. You must
8 * use lock_device() and unlock_device() at a higher level,
9 * or use the xxx_device() equivalents. By moving the
10 * thread synchronization to a higher level, we permit
11 * the higher level routines to "seize" the device and
12 * to carry out operations without worrying about who
13 * set what lock (i.e. race conditions).
15 * Note, this is the device dependent code, and may have
16 * to be modified for each system, but is meant to
17 * be as "generic" as possible.
19 * The purpose of this code is to develop a SIMPLE Storage
20 * daemon. More complicated coding (double buffering, writer
21 * thread, ...) is left for a later version.
23 * Unfortunately, I have had to add more and more complication
24 * to this code. This was not foreseen as noted above, and as
25 * a consequence has lead to something more contorted than is
26 * really necessary -- KES. Note, this contortion has been
27 * corrected to a large extent by a rewrite (Apr MMI).
32 Copyright (C) 2000-2006 Kern Sibbald
34 This program is free software; you can redistribute it and/or
35 modify it under the terms of the GNU General Public License
36 version 2 as amended with additional clauses defined in the
37 file LICENSE in the main source directory.
39 This program is distributed in the hope that it will be useful,
40 but WITHOUT ANY WARRANTY; without even the implied warranty of
41 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
42 the file LICENSE for additional details.
47 * Handling I/O errors and end of tape conditions are a bit tricky.
48 * This is how it is currently done when writting.
49 * On either an I/O error or end of tape,
50 * we will stop writing on the physical device (no I/O recovery is
51 * attempted at least in this daemon). The state flag will be sent
52 * to include ST_EOT, which is ephimeral, and ST_WEOT, which is
53 * persistent. Lots of routines clear ST_EOT, but ST_WEOT is
54 * cleared only when the problem goes away. Now when ST_WEOT
55 * is set all calls to write_block_to_device() call the fix_up
56 * routine. In addition, all threads are blocked
57 * from writing on the tape by calling lock_dev(), and thread other
58 * than the first thread to hit the EOT will block on a condition
59 * variable. The first thread to hit the EOT will continue to
60 * be able to read and write the tape (he sort of tunnels through
61 * the locking mechanism -- see lock_dev() for details).
63 * Now presumably somewhere higher in the chain of command
64 * (device.c), someone will notice the EOT condition and
65 * get a new tape up, get the tape label read, and mark
66 * the label for rewriting. Then this higher level routine
67 * will write the unwritten buffer to the new volume.
68 * Finally, he will release
69 * any blocked threads by doing a broadcast on the condition
70 * variable. At that point, we should be totally back in
71 * business with no lost data.
82 /* Forward referenced functions */
83 void set_os_device_parameters(DEVICE *dev);
84 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat);
85 static char *mode_to_str(int mode);
88 * Allocate and initialize the DEVICE structure
89 * Note, if dev is non-NULL, it is already allocated,
90 * thus we neither allocate it nor free it. This allows
91 * the caller to put the packet in shared memory.
93 * Note, for a tape, the device->device_name is the device name
94 * (e.g. /dev/nst0), and for a file, the device name
95 * is the directory in which the file will be placed.
99 init_dev(JCR *jcr, DEVRES *device)
107 /* If no device type specified, try to guess */
108 if (!device->dev_type) {
109 /* Check that device is available */
110 if (stat(device->device_name, &statp) < 0) {
112 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
113 device->device_name, be.strerror());
116 if (S_ISDIR(statp.st_mode)) {
117 device->dev_type = B_FILE_DEV;
118 } else if (S_ISCHR(statp.st_mode)) {
119 device->dev_type = B_TAPE_DEV;
120 } else if (S_ISFIFO(statp.st_mode)) {
121 device->dev_type = B_FILE_DEV;
122 } else if (!(device->cap_bits & CAP_REQMOUNT)) {
123 Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
124 " or have RequiresMount=yes for DVD. st_mode=%x\n"),
125 device->device_name, statp.st_mode);
128 device->dev_type = B_DVD_DEV;
132 dev = (DEVICE *)malloc(sizeof(DEVICE));
133 memset(dev, 0, sizeof(DEVICE));
135 /* Copy user supplied device parameters from Resource */
136 dev->dev_name = get_memory(strlen(device->device_name)+1);
137 pm_strcpy(dev->dev_name, device->device_name);
138 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
139 /* We edit "Resource-name" (physical-name) */
140 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
141 Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
142 dev->capabilities = device->cap_bits;
143 dev->min_block_size = device->min_block_size;
144 dev->max_block_size = device->max_block_size;
145 dev->max_volume_size = device->max_volume_size;
146 dev->max_file_size = device->max_file_size;
147 dev->volume_capacity = device->volume_capacity;
148 dev->max_rewind_wait = device->max_rewind_wait;
149 dev->max_open_wait = device->max_open_wait;
150 dev->max_open_vols = device->max_open_vols;
151 dev->vol_poll_interval = device->vol_poll_interval;
152 dev->max_spool_size = device->max_spool_size;
153 dev->drive_index = device->drive_index;
154 dev->autoselect = device->autoselect;
155 dev->dev_type = device->dev_type;
156 if (dev->is_tape()) { /* No parts on tapes */
157 dev->max_part_size = 0;
159 dev->max_part_size = device->max_part_size;
162 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
163 dev->vol_poll_interval = 60;
165 /* Link the dev and device structures together */
166 dev->device = device;
169 if (dev->is_fifo()) {
170 dev->capabilities |= CAP_STREAM; /* set stream device */
173 /* If the device requires mount :
174 * - Check that the mount point is available
175 * - Check that (un)mount commands are defined
177 if ((dev->is_file() || dev->is_dvd()) && dev->requires_mount()) {
178 if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
180 dev->dev_errno = errno;
181 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat mount point %s: ERR=%s\n"),
182 device->mount_point, be.strerror());
187 if (!device->mount_command || !device->unmount_command) {
188 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
190 if (!device->write_part_command) {
191 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
195 if (dev->max_block_size > 1000000) {
196 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
197 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
198 dev->max_block_size = 0;
200 if (dev->max_block_size % TAPE_BSIZE != 0) {
201 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
202 dev->max_block_size, dev->print_name());
205 dev->errmsg = get_pool_memory(PM_EMSG);
208 if ((errstat = pthread_mutex_init(&dev->mutex, NULL)) != 0) {
210 dev->dev_errno = errstat;
211 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
212 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
214 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
216 dev->dev_errno = errstat;
217 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
218 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
220 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
222 dev->dev_errno = errstat;
223 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
224 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
226 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
228 dev->dev_errno = errstat;
229 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
230 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
232 if ((errstat = rwl_init(&dev->lock)) != 0) {
234 dev->dev_errno = errstat;
235 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
236 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
240 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
241 Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
247 * Open the device with the operating system and
248 * initialize buffer pointers.
250 * Returns: -1 on error
253 * Note, for a tape, the VolName is the name we give to the
254 * volume (not really used here), but for a file, the
255 * VolName represents the name of the file to be created/opened.
256 * In the case of a file, the full name is the device name
257 * (archive_name) with the VolName concatenated.
260 DEVICE::open(DCR *dcr, int omode)
264 if (openmode == omode) {
273 Dmsg0(100, "Close fd for mode change.\n");
274 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
278 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
281 Dmsg4(29, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
282 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
283 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
284 label_type = B_BACULA_LABEL;
285 if (is_tape() || is_fifo()) {
286 open_tape_device(dcr, omode);
287 } else if (is_dvd()) {
288 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
289 open_dvd_device(dcr, omode);
291 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
292 open_file_device(dcr, omode);
294 state |= preserve; /* reset any important state info */
295 Dmsg1(100, "preserve=0x%x\n", preserve);
299 void DEVICE::set_mode(int new_mode)
302 case CREATE_READ_WRITE:
303 mode = O_CREAT | O_RDWR | O_BINARY;
305 case OPEN_READ_WRITE:
306 mode = O_RDWR | O_BINARY;
309 mode = O_RDONLY | O_BINARY;
311 case OPEN_WRITE_ONLY:
312 mode = O_WRONLY | O_BINARY;
315 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
321 void DEVICE::open_tape_device(DCR *dcr, int omode)
325 int nonblocking = O_NONBLOCK;
326 Dmsg0(29, "open dev: device is tape\n");
328 if (is_autochanger()) {
329 get_autochanger_loaded_slot(dcr);
333 timeout = max_open_wait;
335 if (is_fifo() && timeout) {
337 tid = start_thread_timer(pthread_self(), timeout);
339 /* If busy retry each second for max_open_wait seconds */
340 Dmsg3(100, "Try open %s mode=%s nonblocking=%d\n", print_name(),
341 mode_to_str(omode), nonblocking);
342 /* Use system open() */
345 if ((fd = tape_open(dev_name, mode)) < 0) {
349 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
350 print_name(), be.strerror(dev_errno));
351 Jmsg0(dcr->jcr, M_FATAL, 0, errmsg);
354 while ((fd = ::open(dev_name, mode+nonblocking)) < 0) {
357 Dmsg5(050, "Open omode=%d mode=%x nonblock=%d error errno=%d ERR=%s\n",
358 omode, mode, nonblocking, errno, be.strerror());
359 if (dev_errno == EINTR || dev_errno == EAGAIN) {
360 Dmsg0(100, "Continue open\n");
363 /* Busy wait for specified time (default = 5 mins) */
364 if (dev_errno == EBUSY && timeout-- > 0) {
365 Dmsg2(100, "Device %s busy. ERR=%s\n", print_name(), be.strerror());
369 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
370 print_name(), be.strerror(dev_errno));
371 /* Stop any open timer we set */
373 stop_thread_timer(tid);
376 Jmsg0(dcr->jcr, M_FATAL, 0, errmsg);
382 openmode = omode; /* save open mode */
384 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
386 update_pos_dev(this); /* update position */
387 set_os_device_parameters(this); /* do system dependent stuff */
392 /* Stop any open() timer we started */
394 stop_thread_timer(tid);
397 Dmsg1(29, "open dev: tape %d opened\n", fd);
400 void DEVICE::set_blocking()
403 /* Try to reset blocking */
405 if ((oflags = fcntl(fd, F_GETFL, 0)) < 0 ||
406 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK) < 0) {
408 ::close(fd); /* use system close() */
409 fd = ::open(dev_name, mode);
410 Dmsg2(100, "fcntl error. ERR=%s. Close-reopen fd=%d\n", be.strerror(), fd);
413 oflags = fcntl(fd, F_GETFL, 0);
414 if (oflags > 0 && (oflags & O_NONBLOCK)) {
415 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK);
422 void DEVICE::open_file_device(DCR *dcr, int omode)
424 POOL_MEM archive_name(PM_FNAME);
426 if (is_autochanger()) {
427 get_autochanger_loaded_slot(dcr);
431 * Handle opening of File Archive (not a tape)
434 pm_strcpy(archive_name, dev_name);
436 * If this is a virtual autochanger (i.e. changer_res != NULL)
437 * we simply use the deviced name, assuming it has been
438 * appropriately setup by the "autochanger".
440 if (!device->changer_res) {
441 if (VolCatInfo.VolCatName[0] == 0) {
442 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
448 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
449 pm_strcat(archive_name, "/");
451 pm_strcat(archive_name, VolCatInfo.VolCatName);
454 mount(1); /* do mount if required */
458 /* If creating file, give 0640 permissions */
459 Dmsg3(29, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
460 archive_name.c_str(), mode);
461 /* Use system open() */
462 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
465 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
467 Dmsg1(29, "open failed: %s", errmsg);
468 Emsg0(M_FATAL, 0, errmsg);
471 update_pos_dev(this); /* update position */
473 Dmsg4(29, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
474 fd, part, num_parts, part_size);
478 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
479 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
480 * has the desired Volume name, but there is NO assurance that
481 * any other field of VolCatInfo is correct.
483 void DEVICE::open_dvd_device(DCR *dcr, int omode)
485 POOL_MEM archive_name(PM_FNAME);
486 struct stat filestat;
489 * Handle opening of DVD Volume
491 Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
492 archive_name.c_str(), mode_to_str(omode));
494 if (VolCatInfo.VolCatName[0] == 0) {
495 Dmsg1(10, "Could not open file device %s. No Volume name given.\n",
497 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
508 Dmsg2(99, "open_dvd_device: num_parts=%d, VolCatInfo.VolCatParts=%d\n",
509 dcr->dev->num_parts, dcr->VolCatInfo.VolCatParts);
510 if (dcr->dev->num_parts < dcr->VolCatInfo.VolCatParts) {
511 Dmsg2(99, "open_dvd_device: num_parts updated to %d (was %d)\n",
512 dcr->VolCatInfo.VolCatParts, dcr->dev->num_parts);
513 dcr->dev->num_parts = dcr->VolCatInfo.VolCatParts;
516 if (mount_dvd(this, 1)) {
517 if ((num_parts == 0) && (!truncating)) {
518 /* If we can mount the device, and we are not truncating the DVD, we usually want to abort. */
519 /* There is one exception, if there is only one 0-sized file on the DVD, with the right volume name,
520 * we continue (it's the method used by truncate_dvd to truncate a volume). */
521 if (!check_can_write_on_non_blank_dvd(dcr)) {
522 Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
523 Emsg0(M_FATAL, 0, errmsg);
524 unmount_dvd(this, 1); /* Unmount the device, so the operator can change it. */
530 /* We cannot mount the device */
531 if (num_parts == 0) {
532 /* Run free space, check there is a media. */
533 update_free_space_dev(this);
535 Dmsg1(29, "Could not mount device %s, this is not a problem (num_parts == 0), and have media.\n", print_name());
538 Mmsg(errmsg, _("There is no valid media in the device %s.\n"), print_name());
539 Emsg0(M_FATAL, 0, errmsg);
545 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
546 Emsg0(M_FATAL, 0, errmsg);
552 Dmsg6(29, "open dev: %s dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
553 is_dvd()?"DVD":"disk", archive_name.c_str(), mode_to_str(omode),
554 part, num_parts, dcr->VolCatInfo.VolCatParts);
556 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
559 * If we are not trying to access the last part, set mode to
560 * OPEN_READ_ONLY as writing would be an error.
562 if (part < num_parts) {
563 omode = OPEN_READ_ONLY;
564 make_mounted_dvd_filename(this, archive_name);
567 make_spooled_dvd_filename(this, archive_name);
571 /* If creating file, give 0640 permissions */
572 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
573 archive_name.c_str(), mode);
574 /* Use system open() */
575 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
577 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
579 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
580 Dmsg1(29, "open failed: %s", errmsg);
582 if ((omode == OPEN_READ_ONLY) && (part == num_parts)) {
583 /* If the last part (on spool), doesn't exists when reading, create it and read from it
584 * (it will report immediately an EOF):
585 * Sometimes it is better to finish with an EOF than with an error. */
586 set_mode(OPEN_READ_WRITE);
587 fd = ::open(archive_name.c_str(), mode, 0640);
588 set_mode(OPEN_READ_ONLY);
591 /* We don't need it. Only the last part is on spool */
592 /*if (omode == OPEN_READ_ONLY) {
593 make_spooled_dvd_filename(this, archive_name);
594 fd = ::open(archive_name.c_str(), mode, 0640); // try on spool
597 Dmsg1(100, "after open fd=%d\n", fd);
599 /* Get size of file */
600 if (fstat(fd, &filestat) < 0) {
603 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
605 Dmsg1(29, "open failed: %s", errmsg);
606 /* Use system close() */
610 part_size = filestat.st_size;
612 update_pos_dev(this); /* update position */
614 /* NB: It seems this code is wrong... part number is incremented in open_next_part, not here */
616 /* Check if just created Volume part */
617 /* if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
620 VolCatInfo.VolCatParts = num_parts;
622 if (part == 0) { // we must have opened the first part
633 * Returns: true on success
636 bool DEVICE::rewind(DCR *dcr)
642 Dmsg3(400, "rewind res=%d fd=%d %s\n", reserved_device, fd, print_name());
644 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
646 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
648 Emsg0(M_ABORT, 0, errmsg);
652 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
653 block_num = file = 0;
657 mt_com.mt_op = MTREW;
659 /* If we get an I/O error on rewind, it is probably because
660 * the drive is actually busy. We loop for (about 5 minutes)
661 * retrying every 5 seconds.
663 for (i=max_rewind_wait; ; i -= 5) {
664 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
667 if (i == max_rewind_wait) {
668 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
671 * This is a gross hack, because if the user has the
672 * device mounted (i.e. open), then uses mtx to load
673 * a tape, the current open file descriptor is invalid.
674 * So, we close the drive and re-open it.
677 int open_mode = openmode;
680 open(dcr, open_mode);
688 if (dev_errno == EIO) {
689 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
693 if (dev_errno == EIO && i > 0) {
694 Dmsg0(200, "Sleeping 5 seconds.\n");
699 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
700 print_name(), be.strerror());
705 } else if (is_file() || is_dvd()) {
706 if (lseek_dev(this, (off_t)0, SEEK_SET) < 0) {
709 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
710 print_name(), be.strerror());
717 void DEVICE::block(int why)
720 block_device(this, why);
724 void DEVICE::unblock()
727 unblock_device(this);
731 const char *DEVICE::print_blocked() const
733 switch (dev_blocked) {
734 case BST_NOT_BLOCKED:
735 return "BST_NOT_BLOCKED";
737 return "BST_UNMOUNTED";
738 case BST_WAITING_FOR_SYSOP:
739 return "BST_WAITING_FOR_SYSOP";
740 case BST_DOING_ACQUIRE:
741 return "BST_DOING_ACQUIRE";
742 case BST_WRITING_LABEL:
743 return "BST_WRITING_LABEL";
744 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
745 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
749 return _("unknown blocked code");
754 * Called to indicate that we have just read an
755 * EOF from the device.
757 void DEVICE::set_ateof()
769 * Called to indicate we are now at the end of the tape, and
770 * writing is not possible.
772 void DEVICE::set_ateot()
774 /* Make tape effectively read-only */
775 state |= (ST_EOF|ST_EOT|ST_WEOT);
780 * Position device to end of medium (end of data)
781 * Returns: true on succes
787 struct mtget mt_stat;
793 Mmsg1(errmsg, _("Bad call to eod_dev. Device %s not open\n"), print_name());
797 #if defined (__digital__) && defined (__unix__)
798 return fsf(VolCatInfo.VolCatFiles);
801 Dmsg0(29, "eod_dev\n");
805 clear_eof(); /* remove EOF flag */
806 block_num = file = 0;
809 if (is_fifo() || is_prog()) {
813 pos = lseek_dev(this, (off_t)0, SEEK_END);
814 // Dmsg1(100, "====== Seek to %lld\n", pos);
816 update_pos_dev(this);
822 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
823 print_name(), be.strerror());
827 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
828 Dmsg0(100,"Using FAST FSF for EOM\n");
829 /* If unknown position, rewind */
830 if (!dev_get_os_pos(this, &mt_stat)) {
835 mt_com.mt_op = MTFSF;
837 * ***FIXME*** fix code to handle case that INT16_MAX is
840 mt_com.mt_count = INT16_MAX; /* use big positive number */
841 if (mt_com.mt_count < 0) {
842 mt_com.mt_count = INT16_MAX; /* brain damaged system */
846 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
847 if (has_cap(CAP_EOM)) {
848 Dmsg0(100,"Using EOM for EOM\n");
849 mt_com.mt_op = MTEOM;
853 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
855 clrerror(mt_com.mt_op);
856 Dmsg1(50, "ioctl error: %s\n", be.strerror());
857 update_pos_dev(this);
858 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
859 print_name(), be.strerror());
863 if (!dev_get_os_pos(this, &mt_stat)) {
866 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
867 print_name(), be.strerror());
870 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
872 file = mt_stat.mt_fileno;
878 * Rewind then use FSF until EOT reached
884 * Move file by file to the end of the tape
887 for (file_num=file; !at_eot(); file_num++) {
888 Dmsg0(200, "eod_dev: doing fsf 1\n");
890 Dmsg0(200, "fsf error.\n");
894 * Avoid infinite loop by ensuring we advance.
896 if (file_num == (int)file) {
897 struct mtget mt_stat;
898 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
900 if (dev_get_os_pos(this, &mt_stat)) {
901 Dmsg2(100, "Adjust file from %d to %d\n", file , mt_stat.mt_fileno);
902 file = mt_stat.mt_fileno;
909 * Some drivers leave us after second EOF when doing
910 * MTEOM, so we must backup so that appending overwrites
913 if (has_cap(CAP_BSFATEOM)) {
914 struct mtget mt_stat;
915 /* Backup over EOF */
917 /* If BSF worked and fileno is known (not -1), set file */
918 if (dev_get_os_pos(this, &mt_stat)) {
919 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , mt_stat.mt_fileno);
920 file = mt_stat.mt_fileno;
922 file++; /* wing it -- not correct on all OSes */
925 update_pos_dev(this); /* update position */
927 Dmsg1(200, "EOD dev->file=%d\n", file);
932 * Set the position of the device -- only for files and DVD
933 * For other devices, there is no generic way to do it.
934 * Returns: true on succes
937 bool update_pos_dev(DEVICE *dev)
943 dev->dev_errno = EBADF;
944 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
945 Emsg0(M_FATAL, 0, dev->errmsg);
949 /* Find out where we are */
950 if (dev->is_file()) {
953 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
956 dev->dev_errno = errno;
957 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
958 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
959 dev->print_name(), be.strerror());
962 dev->file_addr = pos;
963 dev->block_num = (uint32_t)pos;
964 dev->file = (uint32_t)(pos >> 32);
972 * Return the status of the device. This was meant
973 * to be a generic routine. Unfortunately, it doesn't
974 * seem possible (at least I do not know how to do it
975 * currently), which means that for the moment, this
976 * routine has very little value.
980 uint32_t status_dev(DEVICE *dev)
982 struct mtget mt_stat;
985 if (dev->state & (ST_EOT | ST_WEOT)) {
989 if (dev->state & ST_EOF) {
993 if (dev->is_tape()) {
995 Pmsg0(-20,_(" Bacula status:"));
996 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
997 if (tape_ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
999 dev->dev_errno = errno;
1000 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1001 dev->print_name(), be.strerror());
1004 Pmsg0(-20, _(" Device status:"));
1006 #if defined(HAVE_LINUX_OS)
1007 if (GMT_EOF(mt_stat.mt_gstat)) {
1011 if (GMT_BOT(mt_stat.mt_gstat)) {
1015 if (GMT_EOT(mt_stat.mt_gstat)) {
1019 if (GMT_SM(mt_stat.mt_gstat)) {
1023 if (GMT_EOD(mt_stat.mt_gstat)) {
1027 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1028 stat |= BMT_WR_PROT;
1029 Pmsg0(-20, " WR_PROT");
1031 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1033 Pmsg0(-20, " ONLINE");
1035 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1036 stat |= BMT_DR_OPEN;
1037 Pmsg0(-20, " DR_OPEN");
1039 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1040 stat |= BMT_IM_REP_EN;
1041 Pmsg0(-20, " IM_REP_EN");
1043 #elif defined(HAVE_WIN32)
1044 if (GMT_EOF(mt_stat.mt_gstat)) {
1048 if (GMT_BOT(mt_stat.mt_gstat)) {
1052 if (GMT_EOT(mt_stat.mt_gstat)) {
1056 if (GMT_EOD(mt_stat.mt_gstat)) {
1060 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1061 stat |= BMT_WR_PROT;
1062 Pmsg0(-20, " WR_PROT");
1064 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1066 Pmsg0(-20, " ONLINE");
1068 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1069 stat |= BMT_DR_OPEN;
1070 Pmsg0(-20, " DR_OPEN");
1072 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1073 stat |= BMT_IM_REP_EN;
1074 Pmsg0(-20, " IM_REP_EN");
1077 #endif /* !SunOS && !OSF */
1078 if (dev->has_cap(CAP_MTIOCGET)) {
1079 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1081 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1084 stat |= BMT_ONLINE | BMT_BOT;
1091 * Load medium in device
1092 * Returns: true on success
1095 bool load_dev(DEVICE *dev)
1102 dev->dev_errno = EBADF;
1103 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1104 Emsg0(M_FATAL, 0, dev->errmsg);
1107 if (!(dev->is_tape())) {
1111 Dmsg0(200, "stored: MTLOAD command not available\n");
1113 dev->dev_errno = ENOTTY; /* function not available */
1114 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1115 dev->print_name(), be.strerror());
1119 dev->block_num = dev->file = 0;
1122 mt_com.mt_op = MTLOAD;
1123 mt_com.mt_count = 1;
1124 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1126 dev->dev_errno = errno;
1127 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1128 dev->print_name(), be.strerror());
1136 * Rewind device and put it offline
1137 * Returns: true on success
1140 bool DEVICE::offline()
1145 return true; /* device not open */
1148 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1149 block_num = file = 0;
1154 mt_com.mt_op = MTUNLOCK;
1155 mt_com.mt_count = 1;
1156 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1158 mt_com.mt_op = MTOFFL;
1159 mt_com.mt_count = 1;
1160 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
1163 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1164 print_name(), be.strerror());
1167 Dmsg1(100, "Offlined device %s\n", print_name());
1171 bool DEVICE::offline_or_rewind()
1176 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1180 * Note, this rewind probably should not be here (it wasn't
1181 * in prior versions of Bacula), but on FreeBSD, this is
1182 * needed in the case the tape was "frozen" due to an error
1183 * such as backspacing after writing and EOF. If it is not
1184 * done, all future references to the drive get and I/O error.
1187 return rewind(NULL);
1192 * Foward space a file
1193 * Returns: true on success
1196 bool DEVICE::fsf(int num)
1198 struct mtget mt_stat;
1204 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1205 Emsg0(M_FATAL, 0, errmsg);
1214 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1218 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1221 Dmsg0(100, "fsf\n");
1224 * If Fast forward space file is set, then we
1225 * use MTFSF to forward space and MTIOCGET
1226 * to get the file position. We assume that
1227 * the SCSI driver will ensure that we do not
1228 * forward space past the end of the medium.
1230 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1231 mt_com.mt_op = MTFSF;
1232 mt_com.mt_count = num;
1233 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1234 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1237 Dmsg0(200, "Set ST_EOT\n");
1239 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1240 print_name(), be.strerror());
1241 Dmsg1(200, "%s", errmsg);
1244 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1246 file = mt_stat.mt_fileno;
1250 * Here if CAP_FSF is set, and virtually all drives
1251 * these days support it, we read a record, then forward
1252 * space one file. Using this procedure, which is slow,
1253 * is the only way we can be sure that we don't read
1254 * two consecutive EOF marks, which means End of Data.
1256 } else if (has_cap(CAP_FSF)) {
1259 Dmsg0(200, "FSF has cap_fsf\n");
1260 if (max_block_size == 0) {
1261 rbuf_len = DEFAULT_BLOCK_SIZE;
1263 rbuf_len = max_block_size;
1265 rbuf = get_memory(rbuf_len);
1266 mt_com.mt_op = MTFSF;
1267 mt_com.mt_count = 1;
1268 while (num-- && !at_eot()) {
1269 Dmsg0(100, "Doing read before fsf\n");
1270 if ((stat = tape_read(fd, (char *)rbuf, rbuf_len)) < 0) {
1271 if (errno == ENOMEM) { /* tape record exceeds buf len */
1272 stat = rbuf_len; /* This is OK */
1274 * On IBM drives, they return ENOSPC at EOM
1275 * instead of EOF status
1277 } else if (at_eof() && errno == ENOSPC) {
1283 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1285 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1286 print_name(), be.strerror());
1287 Dmsg1(100, "%s", errmsg);
1291 if (stat == 0) { /* EOF */
1292 update_pos_dev(this);
1293 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1294 /* Two reads of zero means end of tape */
1297 Dmsg0(100, "Set ST_EOT\n");
1303 } else { /* Got data */
1308 Dmsg0(100, "Doing MTFSF\n");
1309 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1310 if (stat < 0) { /* error => EOT */
1313 Dmsg0(100, "Set ST_EOT\n");
1315 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1316 print_name(), be.strerror());
1317 Dmsg0(100, "Got < 0 for MTFSF\n");
1318 Dmsg1(100, "%s", errmsg);
1326 * No FSF, so use FSR to simulate it
1329 Dmsg0(200, "Doing FSR for FSF\n");
1330 while (num-- && !at_eot()) {
1331 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1335 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1341 update_pos_dev(this);
1342 Dmsg1(200, "Return %d from FSF\n", stat);
1344 Dmsg0(200, "ST_EOF set on exit FSF\n");
1347 Dmsg0(200, "ST_EOT set on exit FSF\n");
1349 Dmsg1(200, "Return from FSF file=%d\n", file);
1354 * Backward space a file
1355 * Returns: false on failure
1358 bool DEVICE::bsf(int num)
1365 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1366 Emsg0(M_FATAL, 0, errmsg);
1371 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1381 mt_com.mt_op = MTBSF;
1382 mt_com.mt_count = num;
1383 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1387 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1388 print_name(), be.strerror());
1390 update_pos_dev(this);
1396 * Foward space num records
1397 * Returns: false on failure
1400 bool DEVICE::fsr(int num)
1407 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1408 Emsg0(M_FATAL, 0, errmsg);
1415 if (!has_cap(CAP_FSR)) {
1416 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1420 Dmsg1(29, "fsr %d\n", num);
1421 mt_com.mt_op = MTFSR;
1422 mt_com.mt_count = num;
1423 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1429 struct mtget mt_stat;
1431 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1432 if (dev_get_os_pos(this, &mt_stat)) {
1433 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1434 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1435 file = mt_stat.mt_fileno;
1436 block_num = mt_stat.mt_blkno;
1444 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1445 num, print_name(), be.strerror());
1447 update_pos_dev(this);
1452 * Backward space a record
1453 * Returns: false on failure
1456 bool DEVICE::bsr(int num)
1463 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1464 Emsg0(M_FATAL, 0, errmsg);
1472 if (!has_cap(CAP_BSR)) {
1473 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1477 Dmsg0(29, "bsr_dev\n");
1481 mt_com.mt_op = MTBSR;
1482 mt_com.mt_count = num;
1483 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1487 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1488 print_name(), be.strerror());
1490 update_pos_dev(this);
1495 * Reposition the device to file, block
1496 * Returns: false on failure
1499 bool DEVICE::reposition(uint32_t rfile, uint32_t rblock)
1503 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1504 Emsg0(M_FATAL, 0, errmsg);
1509 off_t pos = (((off_t)rfile)<<32) + (off_t)rblock;
1510 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1511 if (lseek_dev(this, pos, SEEK_SET) == (off_t)-1) {
1514 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1515 print_name(), be.strerror());
1523 Dmsg4(100, "reposition from %u:%u to %u:%u\n",
1524 file, block_num, rfile, rblock);
1526 Dmsg0(100, "Rewind\n");
1527 if (!rewind(NULL)) {
1532 Dmsg1(100, "fsf %d\n", rfile-file);
1533 if (!fsf(rfile-file)) {
1534 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1537 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1539 if (rblock < block_num) {
1540 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1541 Dmsg0(100, "bsf 1\n");
1543 Dmsg0(100, "fsf_dev 1\n");
1545 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1547 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1548 /* Ignore errors as Bacula can read to the correct block */
1549 Dmsg1(100, "fsr %d\n", rblock-block_num);
1550 return fsr(rblock-block_num);
1558 * Write an end of file on the device
1559 * Returns: true on success
1562 bool DEVICE::weof(int num)
1566 Dmsg0(129, "weof_dev\n");
1570 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1571 Emsg0(M_FATAL, 0, errmsg);
1579 if (!can_append()) {
1580 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1581 Emsg0(M_FATAL, 0, errmsg);
1587 mt_com.mt_op = MTWEOF;
1588 mt_com.mt_count = num;
1589 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1598 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1599 print_name(), be.strerror());
1607 * If implemented in system, clear the tape
1610 void DEVICE::clrerror(int func)
1612 const char *msg = NULL;
1613 struct mtget mt_stat;
1616 dev_errno = errno; /* save errno */
1618 VolCatInfo.VolCatErrors++;
1624 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1627 break; /* ignore message printed later */
1630 capabilities &= ~CAP_EOF; /* turn off feature */
1635 capabilities &= ~CAP_EOM; /* turn off feature */
1640 capabilities &= ~CAP_FSF; /* turn off feature */
1644 capabilities &= ~CAP_BSF; /* turn off feature */
1648 capabilities &= ~CAP_FSR; /* turn off feature */
1652 capabilities &= ~CAP_BSR; /* turn off feature */
1686 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1692 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1693 Emsg0(M_ERROR, 0, errmsg);
1698 * Now we try different methods of clearing the error
1699 * status on the drive so that it is not locked for
1700 * further operations.
1703 /* On some systems such as NetBSD, this clears all errors */
1704 tape_ioctl(fd, MTIOCGET, (char *)&mt_stat);
1706 /* Found on Linux */
1710 mt_com.mt_op = MTIOCLRERR;
1711 mt_com.mt_count = 1;
1712 /* Clear any error condition on the tape */
1713 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1714 Dmsg0(200, "Did MTIOCLRERR\n");
1718 /* Typically on FreeBSD */
1722 /* Read and clear SCSI error status */
1723 union mterrstat mt_errstat;
1724 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1725 be.strerror(dev_errno));
1726 tape_ioctl(fd, MTIOCERRSTAT, (char *)&mt_errstat);
1730 /* Clear Subsystem Exception OSF1 */
1734 mt_com.mt_op = MTCSE;
1735 mt_com.mt_count = 1;
1736 /* Clear any error condition on the tape */
1737 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1738 Dmsg0(200, "Did MTCSE\n");
1746 void DEVICE::close()
1748 Dmsg1(100, "close_dev %s\n", print_name());
1749 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1759 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1761 return; /* already closed */
1764 if (is_dvd() && !unmount_dvd(this, 1)) {
1765 Dmsg1(0, "Cannot unmount device %s.\n", print_name());
1768 /* Remove the last part file if it is empty */
1769 if (num_parts > 0) {
1771 POOL_MEM archive_name(PM_FNAME);
1773 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", VolCatInfo.VolCatName);
1774 make_spooled_dvd_filename(this, archive_name);
1775 /* Check that the part file is empty */
1776 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1777 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1778 unlink(archive_name.c_str());
1782 /* Clean up device packet so it can be reused */
1784 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1785 label_type = B_BACULA_LABEL;
1786 file = block_num = 0;
1793 EndFile = EndBlock = 0;
1795 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1796 memset(&VolHdr, 0, sizeof(VolHdr));
1798 stop_thread_timer(tid);
1806 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1808 Dmsg1(100, "truncate_dev %s\n", print_name());
1810 return true; /* we don't really truncate tapes */
1811 /* maybe we should rewind and write and eof ???? */
1815 return truncate_dvd(dcr);
1818 if (ftruncate(fd, 0) != 0) {
1820 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1821 print_name(), be.strerror());
1827 /* Mount the device.
1828 * If timeout, wait until the mount command returns 0.
1829 * If !timeout, try to mount the device only once.
1831 bool DEVICE::mount(int timeout)
1833 Dmsg0(190, "Enter mount\n");
1836 } else if (requires_mount()) {
1837 return do_mount(1, timeout);
1842 /* Unmount the device
1843 * If timeout, wait until the unmount command returns 0.
1844 * If !timeout, try to unmount the device only once.
1846 bool DEVICE::unmount(int timeout)
1848 Dmsg0(90, "Enter unmount_dvd\n");
1850 return do_mount(0, timeout);
1855 /* (Un)mount the device */
1856 bool DEVICE::do_mount(int mount, int dotimeout)
1858 POOL_MEM ocmd(PM_FNAME);
1861 int status, timeout;
1863 sm_check(__FILE__, __LINE__, false);
1866 Dmsg0(200, "======= mount=1\n");
1869 icmd = device->mount_command;
1871 if (!is_mounted()) {
1872 Dmsg0(200, "======= mount=0\n");
1875 icmd = device->unmount_command;
1878 edit_mount_codes(ocmd, icmd);
1880 Dmsg2(000, "do_mount_dvd: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1883 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1888 results = get_memory(2000);
1890 /* If busy retry each second */
1891 while ((status = run_program_full_output(ocmd.c_str(),
1892 max_open_wait/2, results)) != 0) {
1893 /* Doesn't work with internationalisation (This is not a problem) */
1894 if (fnmatch("*is already mounted on", results, 0) == 0) {
1897 if (timeout-- > 0) {
1898 /* Sometimes the device cannot be mounted because it is already mounted.
1899 * Try to unmount it, then remount it */
1901 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
1907 Dmsg2(40, "Device %s cannot be mounted. ERR=%s\n", print_name(), results);
1908 Mmsg(errmsg, _("Device %s cannot be mounted. ERR=%s\n"),
1909 print_name(), results);
1911 * Now, just to be sure it is not mounted, try to read the
1915 struct dirent *entry, *result;
1919 name_max = pathconf(".", _PC_NAME_MAX);
1920 if (name_max < 1024) {
1924 if (!(dp = opendir(device->mount_point))) {
1927 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
1928 device->mount_point, print_name(), be.strerror());
1932 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
1935 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
1937 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
1938 device->mount_point, print_name());
1941 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
1942 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
1945 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
1951 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
1954 mount = 1; /* If we got more than ., .. and .keep */
1955 break; /* there must be something mounted */
1959 sm_check(__FILE__, __LINE__, false);
1960 free_pool_memory(results);
1961 Dmsg0(200, "============ mount=0\n");
1965 set_mounted(mount); /* set/clear mounted flag */
1966 free_pool_memory(results);
1967 Dmsg1(200, "============ mount=%d\n", mount);
1972 * Edit codes into (Un)MountCommand, Write(First)PartCommand
1974 * %a = archive device name
1975 * %e = erase (set if cannot mount and first part)
1978 * %v = last part name
1980 * omsg = edited output message
1981 * imsg = input string containing edit codes (%x)
1984 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
1990 POOL_MEM archive_name(PM_FNAME);
1992 omsg.c_str()[0] = 0;
1993 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
1994 for (p=imsg; *p; p++) {
2004 if (num_parts == 0) {
2011 bsnprintf(add, sizeof(add), "%d", part);
2015 str = device->mount_point;
2018 make_spooled_dvd_filename(this, archive_name);
2019 str = archive_name.c_str();
2033 Dmsg1(1900, "add_str %s\n", str);
2034 pm_strcat(omsg, (char *)str);
2035 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2040 /* Return the resource name for the device */
2041 const char *DEVICE::name() const
2043 return device->hdr.name;
2047 dev_vol_name(DEVICE *dev)
2049 return dev->VolCatInfo.VolCatName;
2052 uint32_t dev_block(DEVICE *dev)
2054 update_pos_dev(dev);
2055 return dev->block_num;
2058 uint32_t dev_file(DEVICE *dev)
2060 update_pos_dev(dev);
2065 * Free memory allocated for the device
2067 void DEVICE::term(void)
2069 Dmsg1(900, "term dev: %s\n", print_name());
2072 free_memory(dev_name);
2076 free_memory(prt_name);
2080 free_pool_memory(errmsg);
2083 pthread_mutex_destroy(&mutex);
2084 pthread_cond_destroy(&wait);
2085 pthread_cond_destroy(&wait_next_vol);
2086 pthread_mutex_destroy(&spool_mutex);
2088 if (attached_dcrs) {
2089 delete attached_dcrs;
2090 attached_dcrs = NULL;
2099 * This routine initializes the device wait timers
2101 void init_device_wait_timers(DCR *dcr)
2103 DEVICE *dev = dcr->dev;
2104 JCR *jcr = dcr->jcr;
2106 /* ******FIXME******* put these on config variables */
2107 dev->min_wait = 60 * 60;
2108 dev->max_wait = 24 * 60 * 60;
2109 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2110 dev->wait_sec = dev->min_wait;
2111 dev->rem_wait_sec = dev->wait_sec;
2114 dev->BadVolName[0] = 0;
2116 jcr->min_wait = 60 * 60;
2117 jcr->max_wait = 24 * 60 * 60;
2118 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2119 jcr->wait_sec = jcr->min_wait;
2120 jcr->rem_wait_sec = jcr->wait_sec;
2125 void init_jcr_device_wait_timers(JCR *jcr)
2127 /* ******FIXME******* put these on config variables */
2128 jcr->min_wait = 60 * 60;
2129 jcr->max_wait = 24 * 60 * 60;
2130 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2131 jcr->wait_sec = jcr->min_wait;
2132 jcr->rem_wait_sec = jcr->wait_sec;
2138 * The dev timers are used for waiting on a particular device
2140 * Returns: true if time doubled
2141 * false if max time expired
2143 bool double_dev_wait_time(DEVICE *dev)
2145 dev->wait_sec *= 2; /* double wait time */
2146 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2147 dev->wait_sec = dev->max_wait;
2150 dev->rem_wait_sec = dev->wait_sec;
2151 if (dev->num_wait >= dev->max_num_wait) {
2158 void set_os_device_parameters(DEVICE *dev)
2160 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2162 if (dev->min_block_size == dev->max_block_size &&
2163 dev->min_block_size == 0) { /* variable block mode */
2164 mt_com.mt_op = MTSETBLK;
2165 mt_com.mt_count = 0;
2166 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2167 dev->clrerror(MTSETBLK);
2169 mt_com.mt_op = MTSETDRVBUFFER;
2170 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2171 if (!dev->has_cap(CAP_TWOEOF)) {
2172 mt_com.mt_count |= MT_ST_TWO_FM;
2174 if (dev->has_cap(CAP_EOM)) {
2175 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2177 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2178 dev->clrerror(MTSETBLK);
2184 #ifdef HAVE_NETBSD_OS
2186 if (dev->min_block_size == dev->max_block_size &&
2187 dev->min_block_size == 0) { /* variable block mode */
2188 mt_com.mt_op = MTSETBSIZ;
2189 mt_com.mt_count = 0;
2190 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2191 dev->clrerror(MTSETBSIZ);
2193 /* Get notified at logical end of tape */
2194 mt_com.mt_op = MTEWARN;
2195 mt_com.mt_count = 1;
2196 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2197 dev->clrerror(MTEWARN);
2203 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2205 if (dev->min_block_size == dev->max_block_size &&
2206 dev->min_block_size == 0) { /* variable block mode */
2207 mt_com.mt_op = MTSETBSIZ;
2208 mt_com.mt_count = 0;
2209 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2210 dev->clrerror(MTSETBSIZ);
2218 if (dev->min_block_size == dev->max_block_size &&
2219 dev->min_block_size == 0) { /* variable block mode */
2220 mt_com.mt_op = MTSRSZ;
2221 mt_com.mt_count = 0;
2222 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2223 dev->clrerror(MTSRSZ);
2230 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2232 return dev->has_cap(CAP_MTIOCGET) &&
2233 tape_ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2234 mt_stat->mt_fileno >= 0;
2237 static char *modes[] = {
2238 "CREATE_READ_WRITE",
2245 static char *mode_to_str(int mode)
2247 return modes[mode-1];