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) {
267 ::close(fd); /* use system close so correct mode will be used on open */
269 Dmsg0(100, "Close fd for mode change.\n");
270 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
274 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
277 Dmsg4(29, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
278 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
279 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
280 label_type = B_BACULA_LABEL;
281 if (is_tape() || is_fifo()) {
282 open_tape_device(dcr, omode);
283 } else if (is_dvd()) {
284 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
285 open_dvd_device(dcr, omode);
287 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
288 open_file_device(dcr, omode);
290 state |= preserve; /* reset any important state info */
291 Dmsg1(100, "preserve=0x%x\n", preserve);
295 void DEVICE::set_mode(int new_mode)
298 case CREATE_READ_WRITE:
299 mode = O_CREAT | O_RDWR | O_BINARY;
301 case OPEN_READ_WRITE:
302 mode = O_RDWR | O_BINARY;
305 mode = O_RDONLY | O_BINARY;
307 case OPEN_WRITE_ONLY:
308 mode = O_WRONLY | O_BINARY;
311 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
317 void DEVICE::open_tape_device(DCR *dcr, int omode)
321 int nonblocking = O_NONBLOCK;
322 Dmsg0(29, "open dev: device is tape\n");
324 if (is_autochanger()) {
325 get_autochanger_loaded_slot(dcr);
329 timeout = max_open_wait;
331 if (is_fifo() && timeout) {
333 tid = start_thread_timer(pthread_self(), timeout);
335 /* If busy retry each second for max_open_wait seconds */
336 Dmsg3(100, "Try open %s mode=%s nonblocking=%d\n", print_name(),
337 mode_to_str(omode), nonblocking);
338 /* Use system open() */
339 while ((fd = ::open(dev_name, mode+nonblocking)) < 0) {
342 Dmsg5(050, "Open omode=%d mode=%x nonblock=%d error errno=%d ERR=%s\n",
343 omode, mode, nonblocking, errno, be.strerror());
344 if (dev_errno == EINTR || dev_errno == EAGAIN) {
345 Dmsg0(100, "Continue open\n");
348 /* Busy wait for specified time (default = 5 mins) */
349 if (dev_errno == EBUSY && timeout-- > 0) {
350 Dmsg2(100, "Device %s busy. ERR=%s\n", print_name(), be.strerror());
354 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
355 print_name(), be.strerror(dev_errno));
356 /* Stop any open timer we set */
358 stop_thread_timer(tid);
361 Jmsg0(dcr->jcr, M_FATAL, 0, errmsg);
366 openmode = omode; /* save open mode */
368 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
370 update_pos_dev(this); /* update position */
371 set_os_device_parameters(this); /* do system dependent stuff */
376 /* Stop any open() timer we started */
378 stop_thread_timer(tid);
381 Dmsg1(29, "open dev: tape %d opened\n", fd);
384 void DEVICE::set_blocking()
387 /* Try to reset blocking */
389 if ((oflags = fcntl(fd, F_GETFL, 0)) < 0 ||
390 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK) < 0) {
392 ::close(fd); /* use system close() */
393 fd = ::open(dev_name, mode);
394 Dmsg2(100, "fcntl error. ERR=%s. Close-reopen fd=%d\n", be.strerror(), fd);
397 oflags = fcntl(fd, F_GETFL, 0);
398 if (oflags > 0 && (oflags & O_NONBLOCK)) {
399 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK);
406 void DEVICE::open_file_device(DCR *dcr, int omode)
408 POOL_MEM archive_name(PM_FNAME);
410 if (is_autochanger()) {
411 get_autochanger_loaded_slot(dcr);
415 * Handle opening of File Archive (not a tape)
418 pm_strcpy(archive_name, dev_name);
420 * If this is a virtual autochanger (i.e. changer_res != NULL)
421 * we simply use the deviced name, assuming it has been
422 * appropriately setup by the "autochanger".
424 if (!device->changer_res) {
425 if (VolCatInfo.VolCatName[0] == 0) {
426 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
432 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
433 pm_strcat(archive_name, "/");
435 pm_strcat(archive_name, VolCatInfo.VolCatName);
438 mount(1); /* do mount if required */
442 /* If creating file, give 0640 permissions */
443 Dmsg3(29, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
444 archive_name.c_str(), mode);
445 /* Use system open() */
446 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
449 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
451 Dmsg1(29, "open failed: %s", errmsg);
452 Emsg0(M_FATAL, 0, errmsg);
455 update_pos_dev(this); /* update position */
457 Dmsg4(29, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
458 fd, part, num_parts, part_size);
462 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
463 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
464 * has the desired Volume name, but there is NO assurance that
465 * any other field of VolCatInfo is correct.
467 void DEVICE::open_dvd_device(DCR *dcr, int omode)
469 POOL_MEM archive_name(PM_FNAME);
470 struct stat filestat;
473 * Handle opening of DVD Volume
475 Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
476 archive_name.c_str(), mode_to_str(omode));
478 if (VolCatInfo.VolCatName[0] == 0) {
479 Dmsg1(10, "Could not open file device %s. No Volume name given.\n",
481 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
492 Dmsg2(99, "open_dvd_device: num_parts=%d, VolCatInfo.VolCatParts=%d\n",
493 dcr->dev->num_parts, dcr->VolCatInfo.VolCatParts);
494 if (dcr->dev->num_parts < dcr->VolCatInfo.VolCatParts) {
495 Dmsg2(99, "open_dvd_device: num_parts updated to %d (was %d)\n",
496 dcr->VolCatInfo.VolCatParts, dcr->dev->num_parts);
497 dcr->dev->num_parts = dcr->VolCatInfo.VolCatParts;
500 if (mount_dvd(this, 1)) {
501 if ((num_parts == 0) && (!truncating)) {
502 /* If we can mount the device, and we are not truncating the DVD, we usually want to abort. */
503 /* There is one exception, if there is only one 0-sized file on the DVD, with the right volume name,
504 * we continue (it's the method used by truncate_dvd to truncate a volume). */
505 if (!check_can_write_on_non_blank_dvd(dcr)) {
506 Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
507 Emsg0(M_FATAL, 0, errmsg);
508 unmount_dvd(this, 1); /* Unmount the device, so the operator can change it. */
514 /* We cannot mount the device */
515 if (num_parts == 0) {
516 /* Run free space, check there is a media. */
517 update_free_space_dev(this);
519 Dmsg1(29, "Could not mount device %s, this is not a problem (num_parts == 0), and have media.\n", print_name());
522 Mmsg(errmsg, _("There is no valid media in the device %s.\n"), print_name());
523 Emsg0(M_FATAL, 0, errmsg);
529 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
530 Emsg0(M_FATAL, 0, errmsg);
536 Dmsg6(29, "open dev: %s dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
537 is_dvd()?"DVD":"disk", archive_name.c_str(), mode_to_str(omode),
538 part, num_parts, dcr->VolCatInfo.VolCatParts);
540 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
543 * If we are not trying to access the last part, set mode to
544 * OPEN_READ_ONLY as writing would be an error.
546 if (part < num_parts) {
547 omode = OPEN_READ_ONLY;
548 make_mounted_dvd_filename(this, archive_name);
551 make_spooled_dvd_filename(this, archive_name);
555 /* If creating file, give 0640 permissions */
556 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
557 archive_name.c_str(), mode);
558 /* Use system open() */
559 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
561 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
563 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
564 Dmsg1(29, "open failed: %s", errmsg);
566 if ((omode == OPEN_READ_ONLY) && (part == num_parts)) {
567 /* If the last part (on spool), doesn't exists when reading, create it and read from it
568 * (it will report immediately an EOF):
569 * Sometimes it is better to finish with an EOF than with an error. */
570 set_mode(OPEN_READ_WRITE);
571 fd = ::open(archive_name.c_str(), mode, 0640);
572 set_mode(OPEN_READ_ONLY);
575 /* We don't need it. Only the last part is on spool */
576 /*if (omode == OPEN_READ_ONLY) {
577 make_spooled_dvd_filename(this, archive_name);
578 fd = ::open(archive_name.c_str(), mode, 0640); // try on spool
581 Dmsg1(100, "after open fd=%d\n", fd);
583 /* Get size of file */
584 if (fstat(fd, &filestat) < 0) {
587 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
589 Dmsg1(29, "open failed: %s", errmsg);
590 /* Use system close() */
594 part_size = filestat.st_size;
596 update_pos_dev(this); /* update position */
598 /* NB: It seems this code is wrong... part number is incremented in open_next_part, not here */
600 /* Check if just created Volume part */
601 /* if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
604 VolCatInfo.VolCatParts = num_parts;
606 if (part == 0) { // we must have opened the first part
617 * Returns: true on success
620 bool DEVICE::rewind(DCR *dcr)
626 Dmsg3(400, "rewind res=%d fd=%d %s\n", reserved_device, fd, print_name());
628 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
630 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
632 Emsg0(M_ABORT, 0, errmsg);
636 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
637 block_num = file = 0;
641 mt_com.mt_op = MTREW;
643 /* If we get an I/O error on rewind, it is probably because
644 * the drive is actually busy. We loop for (about 5 minutes)
645 * retrying every 5 seconds.
647 for (i=max_rewind_wait; ; i -= 5) {
648 if (ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
651 if (i == max_rewind_wait) {
652 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
655 * This is a gross hack, because if the user has the
656 * device mounted (i.e. open), then uses mtx to load
657 * a tape, the current open file descriptor is invalid.
658 * So, we close the drive and re-open it.
661 int open_mode = openmode;
664 open(dcr, open_mode);
671 if (dev_errno == EIO && i > 0) {
672 Dmsg0(200, "Sleeping 5 seconds.\n");
676 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
677 print_name(), be.strerror());
682 } else if (is_file() || is_dvd()) {
683 if (lseek_dev(this, (off_t)0, SEEK_SET) < 0) {
686 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
687 print_name(), be.strerror());
694 void DEVICE::block(int why)
697 block_device(this, why);
701 void DEVICE::unblock()
704 unblock_device(this);
708 const char *DEVICE::print_blocked() const
710 switch (dev_blocked) {
711 case BST_NOT_BLOCKED:
712 return "BST_NOT_BLOCKED";
714 return "BST_UNMOUNTED";
715 case BST_WAITING_FOR_SYSOP:
716 return "BST_WAITING_FOR_SYSOP";
717 case BST_DOING_ACQUIRE:
718 return "BST_DOING_ACQUIRE";
719 case BST_WRITING_LABEL:
720 return "BST_WRITING_LABEL";
721 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
722 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
726 return _("unknown blocked code");
731 * Called to indicate that we have just read an
732 * EOF from the device.
734 void DEVICE::set_ateof()
746 * Called to indicate we are now at the end of the tape, and
747 * writing is not possible.
749 void DEVICE::set_ateot()
751 /* Make tape effectively read-only */
752 state |= (ST_EOF|ST_EOT|ST_WEOT);
757 * Position device to end of medium (end of data)
758 * Returns: true on succes
764 struct mtget mt_stat;
770 Mmsg1(errmsg, _("Bad call to eod_dev. Device %s not open\n"), print_name());
774 #if defined (__digital__) && defined (__unix__)
775 return fsf(VolCatInfo.VolCatFiles);
778 Dmsg0(29, "eod_dev\n");
782 clear_eof(); /* remove EOF flag */
783 block_num = file = 0;
786 if (is_fifo() || is_prog()) {
790 pos = lseek_dev(this, (off_t)0, SEEK_END);
791 // Dmsg1(100, "====== Seek to %lld\n", pos);
793 update_pos_dev(this);
799 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
800 print_name(), be.strerror());
804 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
805 Dmsg0(100,"Using FAST FSF for EOM\n");
806 /* If unknown position, rewind */
807 if (!dev_get_os_pos(this, &mt_stat)) {
812 mt_com.mt_op = MTFSF;
814 * ***FIXME*** fix code to handle case that INT16_MAX is
817 mt_com.mt_count = INT16_MAX; /* use big positive number */
818 if (mt_com.mt_count < 0) {
819 mt_com.mt_count = INT16_MAX; /* brain damaged system */
823 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
824 if (has_cap(CAP_EOM)) {
825 Dmsg0(100,"Using EOM for EOM\n");
826 mt_com.mt_op = MTEOM;
830 if (ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
832 clrerror(mt_com.mt_op);
833 Dmsg1(50, "ioctl error: %s\n", be.strerror());
834 update_pos_dev(this);
835 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
836 print_name(), be.strerror());
840 if (!dev_get_os_pos(this, &mt_stat)) {
843 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
844 print_name(), be.strerror());
847 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
849 file = mt_stat.mt_fileno;
855 * Rewind then use FSF until EOT reached
861 * Move file by file to the end of the tape
864 for (file_num=file; !at_eot(); file_num++) {
865 Dmsg0(200, "eod_dev: doing fsf 1\n");
867 Dmsg0(200, "fsf error.\n");
871 * Avoid infinite loop by ensuring we advance.
873 if (file_num == (int)file) {
874 struct mtget mt_stat;
875 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
877 if (dev_get_os_pos(this, &mt_stat)) {
878 Dmsg2(100, "Adjust file from %d to %d\n", file , mt_stat.mt_fileno);
879 file = mt_stat.mt_fileno;
886 * Some drivers leave us after second EOF when doing
887 * MTEOM, so we must backup so that appending overwrites
890 if (has_cap(CAP_BSFATEOM)) {
891 struct mtget mt_stat;
892 /* Backup over EOF */
894 /* If BSF worked and fileno is known (not -1), set file */
895 if (dev_get_os_pos(this, &mt_stat)) {
896 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , mt_stat.mt_fileno);
897 file = mt_stat.mt_fileno;
899 file++; /* wing it -- not correct on all OSes */
902 update_pos_dev(this); /* update position */
904 Dmsg1(200, "EOD dev->file=%d\n", file);
909 * Set the position of the device -- only for files and DVD
910 * For other devices, there is no generic way to do it.
911 * Returns: true on succes
914 bool update_pos_dev(DEVICE *dev)
920 dev->dev_errno = EBADF;
921 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
922 Emsg0(M_FATAL, 0, dev->errmsg);
926 /* Find out where we are */
927 if (dev->is_file()) {
930 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
933 dev->dev_errno = errno;
934 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
935 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
936 dev->print_name(), be.strerror());
939 dev->file_addr = pos;
940 dev->block_num = (uint32_t)pos;
941 dev->file = (uint32_t)(pos >> 32);
949 * Return the status of the device. This was meant
950 * to be a generic routine. Unfortunately, it doesn't
951 * seem possible (at least I do not know how to do it
952 * currently), which means that for the moment, this
953 * routine has very little value.
957 uint32_t status_dev(DEVICE *dev)
959 struct mtget mt_stat;
962 if (dev->state & (ST_EOT | ST_WEOT)) {
966 if (dev->state & ST_EOF) {
970 if (dev->is_tape()) {
972 Pmsg0(-20,_(" Bacula status:"));
973 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
974 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
976 dev->dev_errno = errno;
977 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
978 dev->print_name(), be.strerror());
981 Pmsg0(-20, _(" Device status:"));
983 #if defined(HAVE_LINUX_OS)
984 if (GMT_EOF(mt_stat.mt_gstat)) {
988 if (GMT_BOT(mt_stat.mt_gstat)) {
992 if (GMT_EOT(mt_stat.mt_gstat)) {
996 if (GMT_SM(mt_stat.mt_gstat)) {
1000 if (GMT_EOD(mt_stat.mt_gstat)) {
1004 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1005 stat |= BMT_WR_PROT;
1006 Pmsg0(-20, " WR_PROT");
1008 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1010 Pmsg0(-20, " ONLINE");
1012 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1013 stat |= BMT_DR_OPEN;
1014 Pmsg0(-20, " DR_OPEN");
1016 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1017 stat |= BMT_IM_REP_EN;
1018 Pmsg0(-20, " IM_REP_EN");
1020 #endif /* !SunOS && !OSF */
1021 if (dev->has_cap(CAP_MTIOCGET)) {
1022 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1024 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1027 stat |= BMT_ONLINE | BMT_BOT;
1034 * Load medium in device
1035 * Returns: true on success
1038 bool load_dev(DEVICE *dev)
1045 dev->dev_errno = EBADF;
1046 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1047 Emsg0(M_FATAL, 0, dev->errmsg);
1050 if (!(dev->is_tape())) {
1054 Dmsg0(200, "stored: MTLOAD command not available\n");
1056 dev->dev_errno = ENOTTY; /* function not available */
1057 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1058 dev->print_name(), be.strerror());
1062 dev->block_num = dev->file = 0;
1065 mt_com.mt_op = MTLOAD;
1066 mt_com.mt_count = 1;
1067 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1069 dev->dev_errno = errno;
1070 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1071 dev->print_name(), be.strerror());
1079 * Rewind device and put it offline
1080 * Returns: true on success
1083 bool DEVICE::offline()
1088 return true; /* device not open */
1091 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1092 block_num = file = 0;
1097 mt_com.mt_op = MTUNLOCK;
1098 mt_com.mt_count = 1;
1099 ioctl(fd, MTIOCTOP, (char *)&mt_com);
1101 mt_com.mt_op = MTOFFL;
1102 mt_com.mt_count = 1;
1103 if (ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
1106 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1107 print_name(), be.strerror());
1110 Dmsg1(100, "Offlined device %s\n", print_name());
1114 bool DEVICE::offline_or_rewind()
1119 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1123 * Note, this rewind probably should not be here (it wasn't
1124 * in prior versions of Bacula), but on FreeBSD, this is
1125 * needed in the case the tape was "frozen" due to an error
1126 * such as backspacing after writing and EOF. If it is not
1127 * done, all future references to the drive get and I/O error.
1130 return rewind(NULL);
1135 * Foward space a file
1136 * Returns: true on success
1139 bool DEVICE::fsf(int num)
1141 struct mtget mt_stat;
1147 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1148 Emsg0(M_FATAL, 0, errmsg);
1157 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1161 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1164 Dmsg0(100, "fsf\n");
1167 * If Fast forward space file is set, then we
1168 * use MTFSF to forward space and MTIOCGET
1169 * to get the file position. We assume that
1170 * the SCSI driver will ensure that we do not
1171 * forward space past the end of the medium.
1173 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1174 mt_com.mt_op = MTFSF;
1175 mt_com.mt_count = num;
1176 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1177 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1180 Dmsg0(200, "Set ST_EOT\n");
1182 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1183 print_name(), be.strerror());
1184 Dmsg1(200, "%s", errmsg);
1187 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1189 file = mt_stat.mt_fileno;
1193 * Here if CAP_FSF is set, and virtually all drives
1194 * these days support it, we read a record, then forward
1195 * space one file. Using this procedure, which is slow,
1196 * is the only way we can be sure that we don't read
1197 * two consecutive EOF marks, which means End of Data.
1199 } else if (has_cap(CAP_FSF)) {
1202 Dmsg0(200, "FSF has cap_fsf\n");
1203 if (max_block_size == 0) {
1204 rbuf_len = DEFAULT_BLOCK_SIZE;
1206 rbuf_len = max_block_size;
1208 rbuf = get_memory(rbuf_len);
1209 mt_com.mt_op = MTFSF;
1210 mt_com.mt_count = 1;
1211 while (num-- && !at_eot()) {
1212 Dmsg0(100, "Doing read before fsf\n");
1213 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1214 if (errno == ENOMEM) { /* tape record exceeds buf len */
1215 stat = rbuf_len; /* This is OK */
1217 * On IBM drives, they return ENOSPC at EOM
1218 * instead of EOF status
1220 } else if (at_eof() && errno == ENOSPC) {
1226 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1228 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1229 print_name(), be.strerror());
1230 Dmsg1(100, "%s", errmsg);
1234 if (stat == 0) { /* EOF */
1235 update_pos_dev(this);
1236 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1237 /* Two reads of zero means end of tape */
1240 Dmsg0(100, "Set ST_EOT\n");
1246 } else { /* Got data */
1251 Dmsg0(100, "Doing MTFSF\n");
1252 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1253 if (stat < 0) { /* error => EOT */
1256 Dmsg0(100, "Set ST_EOT\n");
1258 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1259 print_name(), be.strerror());
1260 Dmsg0(100, "Got < 0 for MTFSF\n");
1261 Dmsg1(100, "%s", errmsg);
1269 * No FSF, so use FSR to simulate it
1272 Dmsg0(200, "Doing FSR for FSF\n");
1273 while (num-- && !at_eot()) {
1274 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1278 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1284 update_pos_dev(this);
1285 Dmsg1(200, "Return %d from FSF\n", stat);
1287 Dmsg0(200, "ST_EOF set on exit FSF\n");
1290 Dmsg0(200, "ST_EOT set on exit FSF\n");
1292 Dmsg1(200, "Return from FSF file=%d\n", file);
1297 * Backward space a file
1298 * Returns: false on failure
1301 bool DEVICE::bsf(int num)
1308 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1309 Emsg0(M_FATAL, 0, errmsg);
1314 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1324 mt_com.mt_op = MTBSF;
1325 mt_com.mt_count = num;
1326 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1330 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1331 print_name(), be.strerror());
1333 update_pos_dev(this);
1339 * Foward space num records
1340 * Returns: false on failure
1343 bool DEVICE::fsr(int num)
1350 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1351 Emsg0(M_FATAL, 0, errmsg);
1358 if (!has_cap(CAP_FSR)) {
1359 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1363 Dmsg1(29, "fsr %d\n", num);
1364 mt_com.mt_op = MTFSR;
1365 mt_com.mt_count = num;
1366 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1372 struct mtget mt_stat;
1374 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1375 if (dev_get_os_pos(this, &mt_stat)) {
1376 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1377 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1378 file = mt_stat.mt_fileno;
1379 block_num = mt_stat.mt_blkno;
1387 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1388 num, print_name(), be.strerror());
1390 update_pos_dev(this);
1395 * Backward space a record
1396 * Returns: false on failure
1399 bool DEVICE::bsr(int num)
1406 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1407 Emsg0(M_FATAL, 0, errmsg);
1415 if (!has_cap(CAP_BSR)) {
1416 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1420 Dmsg0(29, "bsr_dev\n");
1424 mt_com.mt_op = MTBSR;
1425 mt_com.mt_count = num;
1426 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1430 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1431 print_name(), be.strerror());
1433 update_pos_dev(this);
1438 * Reposition the device to file, block
1439 * Returns: false on failure
1442 bool DEVICE::reposition(uint32_t rfile, uint32_t rblock)
1446 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1447 Emsg0(M_FATAL, 0, errmsg);
1452 off_t pos = (((off_t)rfile)<<32) + (off_t)rblock;
1453 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1454 if (lseek_dev(this, pos, SEEK_SET) == (off_t)-1) {
1457 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1458 print_name(), be.strerror());
1466 Dmsg4(100, "reposition from %u:%u to %u:%u\n",
1467 file, block_num, rfile, rblock);
1469 Dmsg0(100, "Rewind\n");
1470 if (!rewind(NULL)) {
1475 Dmsg1(100, "fsf %d\n", rfile-file);
1476 if (!fsf(rfile-file)) {
1477 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1480 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1482 if (rblock < block_num) {
1483 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1484 Dmsg0(100, "bsf 1\n");
1486 Dmsg0(100, "fsf_dev 1\n");
1488 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1490 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1491 /* Ignore errors as Bacula can read to the correct block */
1492 Dmsg1(100, "fsr %d\n", rblock-block_num);
1493 return fsr(rblock-block_num);
1501 * Write an end of file on the device
1502 * Returns: true on success
1505 bool DEVICE::weof(int num)
1509 Dmsg0(129, "weof_dev\n");
1513 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1514 Emsg0(M_FATAL, 0, errmsg);
1522 if (!can_append()) {
1523 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1524 Emsg0(M_FATAL, 0, errmsg);
1530 mt_com.mt_op = MTWEOF;
1531 mt_com.mt_count = num;
1532 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1541 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1542 print_name(), be.strerror());
1550 * If implemented in system, clear the tape
1553 void DEVICE::clrerror(int func)
1555 const char *msg = NULL;
1556 struct mtget mt_stat;
1559 dev_errno = errno; /* save errno */
1561 VolCatInfo.VolCatErrors++;
1567 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1570 Emsg0(M_ABORT, 0, _("Got ENOTTY on read/write!\n"));
1574 capabilities &= ~CAP_EOF; /* turn off feature */
1579 capabilities &= ~CAP_EOM; /* turn off feature */
1584 capabilities &= ~CAP_FSF; /* turn off feature */
1588 capabilities &= ~CAP_BSF; /* turn off feature */
1592 capabilities &= ~CAP_FSR; /* turn off feature */
1596 capabilities &= ~CAP_BSR; /* turn off feature */
1630 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1636 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1637 Emsg0(M_ERROR, 0, errmsg);
1642 * Now we try different methods of clearing the error
1643 * status on the drive so that it is not locked for
1644 * further operations.
1647 /* On some systems such as NetBSD, this clears all errors */
1648 ioctl(fd, MTIOCGET, (char *)&mt_stat);
1650 /* Found on Linux */
1654 mt_com.mt_op = MTIOCLRERR;
1655 mt_com.mt_count = 1;
1656 /* Clear any error condition on the tape */
1657 ioctl(fd, MTIOCTOP, (char *)&mt_com);
1658 Dmsg0(200, "Did MTIOCLRERR\n");
1662 /* Typically on FreeBSD */
1665 /* Read and clear SCSI error status */
1666 union mterrstat mt_errstat;
1667 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1668 strerror(dev_errno));
1669 ioctl(fd, MTIOCERRSTAT, (char *)&mt_errstat);
1673 /* Clear Subsystem Exception OSF1 */
1677 mt_com.mt_op = MTCSE;
1678 mt_com.mt_count = 1;
1679 /* Clear any error condition on the tape */
1680 ioctl(fd, MTIOCTOP, (char *)&mt_com);
1681 Dmsg0(200, "Did MTCSE\n");
1689 void DEVICE::close()
1691 Dmsg1(100, "close_dev %s\n", print_name());
1692 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1698 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1700 return; /* already closed */
1703 if (is_dvd() && !unmount_dvd(this, 1)) {
1704 Dmsg1(0, "Cannot unmount device %s.\n", print_name());
1707 /* Remove the last part file if it is empty */
1708 if (num_parts > 0) {
1710 POOL_MEM archive_name(PM_FNAME);
1712 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", VolCatInfo.VolCatName);
1713 make_spooled_dvd_filename(this, archive_name);
1714 /* Check that the part file is empty */
1715 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1716 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1717 unlink(archive_name.c_str());
1721 /* Clean up device packet so it can be reused */
1723 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1724 label_type = B_BACULA_LABEL;
1725 file = block_num = 0;
1732 EndFile = EndBlock = 0;
1734 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1735 memset(&VolHdr, 0, sizeof(VolHdr));
1737 stop_thread_timer(tid);
1745 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1747 Dmsg1(100, "truncate_dev %s\n", print_name());
1749 return true; /* we don't really truncate tapes */
1750 /* maybe we should rewind and write and eof ???? */
1754 return truncate_dvd(dcr);
1757 if (ftruncate(fd, 0) != 0) {
1759 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1760 print_name(), be.strerror());
1766 /* Mount the device.
1767 * If timeout, wait until the mount command returns 0.
1768 * If !timeout, try to mount the device only once.
1770 bool DEVICE::mount(int timeout)
1772 Dmsg0(190, "Enter mount\n");
1775 } else if (requires_mount()) {
1776 return do_mount(1, timeout);
1781 /* Unmount the device
1782 * If timeout, wait until the unmount command returns 0.
1783 * If !timeout, try to unmount the device only once.
1785 bool DEVICE::unmount(int timeout)
1787 Dmsg0(90, "Enter unmount_dvd\n");
1789 return do_mount(0, timeout);
1794 /* (Un)mount the device */
1795 bool DEVICE::do_mount(int mount, int dotimeout)
1797 POOL_MEM ocmd(PM_FNAME);
1800 int status, timeout;
1802 sm_check(__FILE__, __LINE__, false);
1805 Dmsg0(200, "======= mount=1\n");
1808 icmd = device->mount_command;
1810 if (!is_mounted()) {
1811 Dmsg0(200, "======= mount=0\n");
1814 icmd = device->unmount_command;
1817 edit_mount_codes(ocmd, icmd);
1819 Dmsg2(000, "do_mount_dvd: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1822 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1827 results = get_memory(2000);
1829 /* If busy retry each second */
1830 while ((status = run_program_full_output(ocmd.c_str(),
1831 max_open_wait/2, results)) != 0) {
1832 /* Doesn't work with internationalisation (This is not a problem) */
1833 if (fnmatch("*is already mounted on", results, 0) == 0) {
1836 if (timeout-- > 0) {
1837 /* Sometimes the device cannot be mounted because it is already mounted.
1838 * Try to unmount it, then remount it */
1840 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
1846 Dmsg2(40, "Device %s cannot be mounted. ERR=%s\n", print_name(), results);
1847 Mmsg(errmsg, _("Device %s cannot be mounted. ERR=%s\n"),
1848 print_name(), results);
1850 * Now, just to be sure it is not mounted, try to read the
1854 struct dirent *entry, *result;
1858 name_max = pathconf(".", _PC_NAME_MAX);
1859 if (name_max < 1024) {
1863 if (!(dp = opendir(device->mount_point))) {
1866 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
1867 device->mount_point, print_name(), be.strerror());
1871 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
1874 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
1876 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
1877 device->mount_point, print_name());
1880 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
1881 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
1884 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
1890 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
1893 mount = 1; /* If we got more than ., .. and .keep */
1894 break; /* there must be something mounted */
1898 sm_check(__FILE__, __LINE__, false);
1899 free_pool_memory(results);
1900 Dmsg0(200, "============ mount=0\n");
1904 set_mounted(mount); /* set/clear mounted flag */
1905 free_pool_memory(results);
1906 Dmsg1(200, "============ mount=%d\n", mount);
1911 * Edit codes into (Un)MountCommand, Write(First)PartCommand
1913 * %a = archive device name
1914 * %e = erase (set if cannot mount and first part)
1917 * %v = last part name
1919 * omsg = edited output message
1920 * imsg = input string containing edit codes (%x)
1923 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
1929 POOL_MEM archive_name(PM_FNAME);
1931 omsg.c_str()[0] = 0;
1932 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
1933 for (p=imsg; *p; p++) {
1943 if (num_parts == 0) {
1950 bsnprintf(add, sizeof(add), "%d", part);
1954 str = device->mount_point;
1957 make_spooled_dvd_filename(this, archive_name);
1958 str = archive_name.c_str();
1972 Dmsg1(1900, "add_str %s\n", str);
1973 pm_strcat(omsg, (char *)str);
1974 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
1979 /* Return the resource name for the device */
1980 const char *DEVICE::name() const
1982 return device->hdr.name;
1986 dev_vol_name(DEVICE *dev)
1988 return dev->VolCatInfo.VolCatName;
1991 uint32_t dev_block(DEVICE *dev)
1993 update_pos_dev(dev);
1994 return dev->block_num;
1997 uint32_t dev_file(DEVICE *dev)
1999 update_pos_dev(dev);
2004 * Free memory allocated for the device
2006 void DEVICE::term(void)
2008 Dmsg1(900, "term dev: %s\n", print_name());
2011 free_memory(dev_name);
2015 free_memory(prt_name);
2019 free_pool_memory(errmsg);
2022 pthread_mutex_destroy(&mutex);
2023 pthread_cond_destroy(&wait);
2024 pthread_cond_destroy(&wait_next_vol);
2025 pthread_mutex_destroy(&spool_mutex);
2027 if (attached_dcrs) {
2028 delete attached_dcrs;
2029 attached_dcrs = NULL;
2038 * This routine initializes the device wait timers
2040 void init_device_wait_timers(DCR *dcr)
2042 DEVICE *dev = dcr->dev;
2043 JCR *jcr = dcr->jcr;
2045 /* ******FIXME******* put these on config variables */
2046 dev->min_wait = 60 * 60;
2047 dev->max_wait = 24 * 60 * 60;
2048 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2049 dev->wait_sec = dev->min_wait;
2050 dev->rem_wait_sec = dev->wait_sec;
2053 dev->BadVolName[0] = 0;
2055 jcr->min_wait = 60 * 60;
2056 jcr->max_wait = 24 * 60 * 60;
2057 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2058 jcr->wait_sec = jcr->min_wait;
2059 jcr->rem_wait_sec = jcr->wait_sec;
2064 void init_jcr_device_wait_timers(JCR *jcr)
2066 /* ******FIXME******* put these on config variables */
2067 jcr->min_wait = 60 * 60;
2068 jcr->max_wait = 24 * 60 * 60;
2069 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2070 jcr->wait_sec = jcr->min_wait;
2071 jcr->rem_wait_sec = jcr->wait_sec;
2077 * The dev timers are used for waiting on a particular device
2079 * Returns: true if time doubled
2080 * false if max time expired
2082 bool double_dev_wait_time(DEVICE *dev)
2084 dev->wait_sec *= 2; /* double wait time */
2085 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2086 dev->wait_sec = dev->max_wait;
2089 dev->rem_wait_sec = dev->wait_sec;
2090 if (dev->num_wait >= dev->max_num_wait) {
2097 void set_os_device_parameters(DEVICE *dev)
2099 #ifdef HAVE_LINUX_OS
2101 if (dev->min_block_size == dev->max_block_size &&
2102 dev->min_block_size == 0) { /* variable block mode */
2103 mt_com.mt_op = MTSETBLK;
2104 mt_com.mt_count = 0;
2105 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2106 dev->clrerror(MTSETBLK);
2108 mt_com.mt_op = MTSETDRVBUFFER;
2109 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2110 if (!dev->has_cap(CAP_TWOEOF)) {
2111 mt_com.mt_count |= MT_ST_TWO_FM;
2113 if (dev->has_cap(CAP_EOM)) {
2114 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2116 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2117 dev->clrerror(MTSETBLK);
2123 #ifdef HAVE_NETBSD_OS
2125 if (dev->min_block_size == dev->max_block_size &&
2126 dev->min_block_size == 0) { /* variable block mode */
2127 mt_com.mt_op = MTSETBSIZ;
2128 mt_com.mt_count = 0;
2129 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2130 dev->clrerror(MTSETBSIZ);
2132 /* Get notified at logical end of tape */
2133 mt_com.mt_op = MTEWARN;
2134 mt_com.mt_count = 1;
2135 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2136 dev->clrerror(MTEWARN);
2142 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2144 if (dev->min_block_size == dev->max_block_size &&
2145 dev->min_block_size == 0) { /* variable block mode */
2146 mt_com.mt_op = MTSETBSIZ;
2147 mt_com.mt_count = 0;
2148 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2149 dev->clrerror(MTSETBSIZ);
2157 if (dev->min_block_size == dev->max_block_size &&
2158 dev->min_block_size == 0) { /* variable block mode */
2159 mt_com.mt_op = MTSRSZ;
2160 mt_com.mt_count = 0;
2161 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2162 dev->clrerror(MTSRSZ);
2169 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2171 return dev->has_cap(CAP_MTIOCGET) &&
2172 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2173 mt_stat->mt_fileno >= 0;
2176 static char *modes[] = {
2177 "CREATE_READ_WRITE",
2184 static char *mode_to_str(int mode)
2186 return modes[mode-1];