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;
947 * Return the status of the device. This was meant
948 * to be a generic routine. Unfortunately, it doesn't
949 * seem possible (at least I do not know how to do it
950 * currently), which means that for the moment, this
951 * routine has very little value.
955 uint32_t status_dev(DEVICE *dev)
957 struct mtget mt_stat;
960 if (dev->state & (ST_EOT | ST_WEOT)) {
964 if (dev->state & ST_EOF) {
968 if (dev->is_tape()) {
970 Pmsg0(-20,_(" Bacula status:"));
971 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
972 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
974 dev->dev_errno = errno;
975 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
976 dev->print_name(), be.strerror());
979 Pmsg0(-20, _(" Device status:"));
981 #if defined(HAVE_LINUX_OS)
982 if (GMT_EOF(mt_stat.mt_gstat)) {
986 if (GMT_BOT(mt_stat.mt_gstat)) {
990 if (GMT_EOT(mt_stat.mt_gstat)) {
994 if (GMT_SM(mt_stat.mt_gstat)) {
998 if (GMT_EOD(mt_stat.mt_gstat)) {
1002 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1003 stat |= BMT_WR_PROT;
1004 Pmsg0(-20, " WR_PROT");
1006 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1008 Pmsg0(-20, " ONLINE");
1010 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1011 stat |= BMT_DR_OPEN;
1012 Pmsg0(-20, " DR_OPEN");
1014 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1015 stat |= BMT_IM_REP_EN;
1016 Pmsg0(-20, " IM_REP_EN");
1018 #endif /* !SunOS && !OSF */
1019 if (dev->has_cap(CAP_MTIOCGET)) {
1020 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1022 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1025 stat |= BMT_ONLINE | BMT_BOT;
1032 * Load medium in device
1033 * Returns: true on success
1036 bool load_dev(DEVICE *dev)
1043 dev->dev_errno = EBADF;
1044 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1045 Emsg0(M_FATAL, 0, dev->errmsg);
1048 if (!(dev->is_tape())) {
1052 Dmsg0(200, "stored: MTLOAD command not available\n");
1054 dev->dev_errno = ENOTTY; /* function not available */
1055 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1056 dev->print_name(), be.strerror());
1060 dev->block_num = dev->file = 0;
1063 mt_com.mt_op = MTLOAD;
1064 mt_com.mt_count = 1;
1065 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1067 dev->dev_errno = errno;
1068 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1069 dev->print_name(), be.strerror());
1077 * Rewind device and put it offline
1078 * Returns: true on success
1081 bool DEVICE::offline()
1086 return true; /* device not open */
1089 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1090 block_num = file = 0;
1095 mt_com.mt_op = MTUNLOCK;
1096 mt_com.mt_count = 1;
1097 ioctl(fd, MTIOCTOP, (char *)&mt_com);
1099 mt_com.mt_op = MTOFFL;
1100 mt_com.mt_count = 1;
1101 if (ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
1104 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1105 print_name(), be.strerror());
1108 Dmsg1(100, "Offlined device %s\n", print_name());
1112 bool DEVICE::offline_or_rewind()
1117 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1121 * Note, this rewind probably should not be here (it wasn't
1122 * in prior versions of Bacula), but on FreeBSD, this is
1123 * needed in the case the tape was "frozen" due to an error
1124 * such as backspacing after writing and EOF. If it is not
1125 * done, all future references to the drive get and I/O error.
1128 return rewind(NULL);
1133 * Foward space a file
1134 * Returns: true on success
1137 bool DEVICE::fsf(int num)
1139 struct mtget mt_stat;
1145 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1146 Emsg0(M_FATAL, 0, errmsg);
1155 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1159 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1162 Dmsg0(100, "fsf\n");
1165 * If Fast forward space file is set, then we
1166 * use MTFSF to forward space and MTIOCGET
1167 * to get the file position. We assume that
1168 * the SCSI driver will ensure that we do not
1169 * forward space past the end of the medium.
1171 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1172 mt_com.mt_op = MTFSF;
1173 mt_com.mt_count = num;
1174 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1175 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1178 Dmsg0(200, "Set ST_EOT\n");
1180 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1181 print_name(), be.strerror());
1182 Dmsg1(200, "%s", errmsg);
1185 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1187 file = mt_stat.mt_fileno;
1191 * Here if CAP_FSF is set, and virtually all drives
1192 * these days support it, we read a record, then forward
1193 * space one file. Using this procedure, which is slow,
1194 * is the only way we can be sure that we don't read
1195 * two consecutive EOF marks, which means End of Data.
1197 } else if (has_cap(CAP_FSF)) {
1200 Dmsg0(200, "FSF has cap_fsf\n");
1201 if (max_block_size == 0) {
1202 rbuf_len = DEFAULT_BLOCK_SIZE;
1204 rbuf_len = max_block_size;
1206 rbuf = get_memory(rbuf_len);
1207 mt_com.mt_op = MTFSF;
1208 mt_com.mt_count = 1;
1209 while (num-- && !at_eot()) {
1210 Dmsg0(100, "Doing read before fsf\n");
1211 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1212 if (errno == ENOMEM) { /* tape record exceeds buf len */
1213 stat = rbuf_len; /* This is OK */
1215 * On IBM drives, they return ENOSPC at EOM
1216 * instead of EOF status
1218 } else if (at_eof() && errno == ENOSPC) {
1224 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1226 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1227 print_name(), be.strerror());
1228 Dmsg1(100, "%s", errmsg);
1232 if (stat == 0) { /* EOF */
1233 update_pos_dev(this);
1234 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1235 /* Two reads of zero means end of tape */
1238 Dmsg0(100, "Set ST_EOT\n");
1244 } else { /* Got data */
1249 Dmsg0(100, "Doing MTFSF\n");
1250 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1251 if (stat < 0) { /* error => EOT */
1254 Dmsg0(100, "Set ST_EOT\n");
1256 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1257 print_name(), be.strerror());
1258 Dmsg0(100, "Got < 0 for MTFSF\n");
1259 Dmsg1(100, "%s", errmsg);
1267 * No FSF, so use FSR to simulate it
1270 Dmsg0(200, "Doing FSR for FSF\n");
1271 while (num-- && !at_eot()) {
1272 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1276 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1282 update_pos_dev(this);
1283 Dmsg1(200, "Return %d from FSF\n", stat);
1285 Dmsg0(200, "ST_EOF set on exit FSF\n");
1288 Dmsg0(200, "ST_EOT set on exit FSF\n");
1290 Dmsg1(200, "Return from FSF file=%d\n", file);
1295 * Backward space a file
1296 * Returns: false on failure
1299 bool DEVICE::bsf(int num)
1306 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1307 Emsg0(M_FATAL, 0, errmsg);
1312 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1322 mt_com.mt_op = MTBSF;
1323 mt_com.mt_count = num;
1324 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1328 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1329 print_name(), be.strerror());
1331 update_pos_dev(this);
1337 * Foward space num records
1338 * Returns: false on failure
1341 bool DEVICE::fsr(int num)
1348 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1349 Emsg0(M_FATAL, 0, errmsg);
1356 if (!has_cap(CAP_FSR)) {
1357 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1361 Dmsg1(29, "fsr %d\n", num);
1362 mt_com.mt_op = MTFSR;
1363 mt_com.mt_count = num;
1364 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1370 struct mtget mt_stat;
1372 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1373 if (dev_get_os_pos(this, &mt_stat)) {
1374 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1375 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1376 file = mt_stat.mt_fileno;
1377 block_num = mt_stat.mt_blkno;
1385 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1386 num, print_name(), be.strerror());
1388 update_pos_dev(this);
1393 * Backward space a record
1394 * Returns: false on failure
1397 bool DEVICE::bsr(int num)
1404 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1405 Emsg0(M_FATAL, 0, errmsg);
1413 if (!has_cap(CAP_BSR)) {
1414 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1418 Dmsg0(29, "bsr_dev\n");
1422 mt_com.mt_op = MTBSR;
1423 mt_com.mt_count = num;
1424 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1428 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1429 print_name(), be.strerror());
1431 update_pos_dev(this);
1436 * Reposition the device to file, block
1437 * Returns: false on failure
1440 bool DEVICE::reposition(uint32_t rfile, uint32_t rblock)
1444 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1445 Emsg0(M_FATAL, 0, errmsg);
1450 off_t pos = (((off_t)rfile)<<32) + (off_t)rblock;
1451 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1452 if (lseek_dev(this, pos, SEEK_SET) == (off_t)-1) {
1455 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1456 print_name(), be.strerror());
1464 Dmsg4(100, "reposition from %u:%u to %u:%u\n",
1465 file, block_num, rfile, rblock);
1467 Dmsg0(100, "Rewind\n");
1468 if (!rewind(NULL)) {
1473 Dmsg1(100, "fsf %d\n", rfile-file);
1474 if (!fsf(rfile-file)) {
1475 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1478 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1480 if (rblock < block_num) {
1481 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1482 Dmsg0(100, "bsf 1\n");
1484 Dmsg0(100, "fsf_dev 1\n");
1486 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1488 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1489 /* Ignore errors as Bacula can read to the correct block */
1490 Dmsg1(100, "fsr %d\n", rblock-block_num);
1491 return fsr(rblock-block_num);
1499 * Write an end of file on the device
1500 * Returns: true on success
1503 bool DEVICE::weof(int num)
1507 Dmsg0(129, "weof_dev\n");
1511 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1512 Emsg0(M_FATAL, 0, errmsg);
1520 if (!can_append()) {
1521 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1522 Emsg0(M_FATAL, 0, errmsg);
1528 mt_com.mt_op = MTWEOF;
1529 mt_com.mt_count = num;
1530 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1539 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1540 print_name(), be.strerror());
1548 * If implemented in system, clear the tape
1551 void DEVICE::clrerror(int func)
1553 const char *msg = NULL;
1554 struct mtget mt_stat;
1557 dev_errno = errno; /* save errno */
1559 VolCatInfo.VolCatErrors++;
1565 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1568 Emsg0(M_ABORT, 0, _("Got ENOTTY on read/write!\n"));
1572 capabilities &= ~CAP_EOF; /* turn off feature */
1577 capabilities &= ~CAP_EOM; /* turn off feature */
1582 capabilities &= ~CAP_FSF; /* turn off feature */
1586 capabilities &= ~CAP_BSF; /* turn off feature */
1590 capabilities &= ~CAP_FSR; /* turn off feature */
1594 capabilities &= ~CAP_BSR; /* turn off feature */
1628 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1634 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1635 Emsg0(M_ERROR, 0, errmsg);
1640 * Now we try different methods of clearing the error
1641 * status on the drive so that it is not locked for
1642 * further operations.
1645 /* On some systems such as NetBSD, this clears all errors */
1646 ioctl(fd, MTIOCGET, (char *)&mt_stat);
1648 /* Found on Linux */
1652 mt_com.mt_op = MTIOCLRERR;
1653 mt_com.mt_count = 1;
1654 /* Clear any error condition on the tape */
1655 ioctl(fd, MTIOCTOP, (char *)&mt_com);
1656 Dmsg0(200, "Did MTIOCLRERR\n");
1660 /* Typically on FreeBSD */
1663 /* Read and clear SCSI error status */
1664 union mterrstat mt_errstat;
1665 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1666 strerror(dev_errno));
1667 ioctl(fd, MTIOCERRSTAT, (char *)&mt_errstat);
1671 /* Clear Subsystem Exception OSF1 */
1675 mt_com.mt_op = MTCSE;
1676 mt_com.mt_count = 1;
1677 /* Clear any error condition on the tape */
1678 ioctl(fd, MTIOCTOP, (char *)&mt_com);
1679 Dmsg0(200, "Did MTCSE\n");
1687 void DEVICE::close()
1689 Dmsg1(100, "close_dev %s\n", print_name());
1690 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1696 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1698 return; /* already closed */
1701 if (is_dvd() && !unmount_dvd(this, 1)) {
1702 Dmsg1(0, "Cannot unmount device %s.\n", print_name());
1705 /* Remove the last part file if it is empty */
1706 if (num_parts > 0) {
1708 POOL_MEM archive_name(PM_FNAME);
1710 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", VolCatInfo.VolCatName);
1711 make_spooled_dvd_filename(this, archive_name);
1712 /* Check that the part file is empty */
1713 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1714 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1715 unlink(archive_name.c_str());
1719 /* Clean up device packet so it can be reused */
1721 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1722 label_type = B_BACULA_LABEL;
1723 file = block_num = 0;
1730 EndFile = EndBlock = 0;
1732 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1733 memset(&VolHdr, 0, sizeof(VolHdr));
1735 stop_thread_timer(tid);
1743 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1745 Dmsg1(100, "truncate_dev %s\n", print_name());
1747 return true; /* we don't really truncate tapes */
1748 /* maybe we should rewind and write and eof ???? */
1752 return truncate_dvd(dcr);
1755 if (ftruncate(fd, 0) != 0) {
1757 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1758 print_name(), be.strerror());
1764 /* Mount the device.
1765 * If timeout, wait until the mount command returns 0.
1766 * If !timeout, try to mount the device only once.
1768 bool DEVICE::mount(int timeout)
1770 Dmsg0(190, "Enter mount\n");
1773 } else if (requires_mount()) {
1774 return do_mount(1, timeout);
1779 /* Unmount the device
1780 * If timeout, wait until the unmount command returns 0.
1781 * If !timeout, try to unmount the device only once.
1783 bool DEVICE::unmount(int timeout)
1785 Dmsg0(90, "Enter unmount_dvd\n");
1787 return do_mount(0, timeout);
1792 /* (Un)mount the device */
1793 bool DEVICE::do_mount(int mount, int dotimeout)
1795 POOL_MEM ocmd(PM_FNAME);
1798 int status, timeout;
1800 sm_check(__FILE__, __LINE__, false);
1803 Dmsg0(200, "======= mount=1\n");
1806 icmd = device->mount_command;
1808 if (!is_mounted()) {
1809 Dmsg0(200, "======= mount=0\n");
1812 icmd = device->unmount_command;
1815 edit_mount_codes(ocmd, icmd);
1817 Dmsg2(000, "do_mount_dvd: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1820 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1825 results = get_memory(2000);
1827 /* If busy retry each second */
1828 while ((status = run_program_full_output(ocmd.c_str(),
1829 max_open_wait/2, results)) != 0) {
1830 /* Doesn't work with internationalisation (This is not a problem) */
1831 if (fnmatch("*is already mounted on", results, 0) == 0) {
1834 if (timeout-- > 0) {
1835 /* Sometimes the device cannot be mounted because it is already mounted.
1836 * Try to unmount it, then remount it */
1838 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
1844 Dmsg2(40, "Device %s cannot be mounted. ERR=%s\n", print_name(), results);
1845 Mmsg(errmsg, _("Device %s cannot be mounted. ERR=%s\n"),
1846 print_name(), results);
1848 * Now, just to be sure it is not mounted, try to read the
1852 struct dirent *entry, *result;
1856 name_max = pathconf(".", _PC_NAME_MAX);
1857 if (name_max < 1024) {
1861 if (!(dp = opendir(device->mount_point))) {
1864 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
1865 device->mount_point, print_name(), be.strerror());
1869 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
1872 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
1874 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
1875 device->mount_point, print_name());
1878 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
1879 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
1882 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
1888 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
1891 mount = 1; /* If we got more than ., .. and .keep */
1892 break; /* there must be something mounted */
1896 sm_check(__FILE__, __LINE__, false);
1897 free_pool_memory(results);
1898 Dmsg0(200, "============ mount=0\n");
1902 set_mounted(mount); /* set/clear mounted flag */
1903 free_pool_memory(results);
1904 Dmsg1(200, "============ mount=%d\n", mount);
1909 * Edit codes into (Un)MountCommand, Write(First)PartCommand
1911 * %a = archive device name
1912 * %e = erase (set if cannot mount and first part)
1915 * %v = last part name
1917 * omsg = edited output message
1918 * imsg = input string containing edit codes (%x)
1921 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
1927 POOL_MEM archive_name(PM_FNAME);
1929 omsg.c_str()[0] = 0;
1930 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
1931 for (p=imsg; *p; p++) {
1941 if (num_parts == 0) {
1948 bsnprintf(add, sizeof(add), "%d", part);
1952 str = device->mount_point;
1955 make_spooled_dvd_filename(this, archive_name);
1956 str = archive_name.c_str();
1970 Dmsg1(1900, "add_str %s\n", str);
1971 pm_strcat(omsg, (char *)str);
1972 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
1977 /* Return the resource name for the device */
1978 const char *DEVICE::name() const
1980 return device->hdr.name;
1984 dev_vol_name(DEVICE *dev)
1986 return dev->VolCatInfo.VolCatName;
1989 uint32_t dev_block(DEVICE *dev)
1991 update_pos_dev(dev);
1992 return dev->block_num;
1995 uint32_t dev_file(DEVICE *dev)
1997 update_pos_dev(dev);
2002 * Free memory allocated for the device
2004 void DEVICE::term(void)
2006 Dmsg1(900, "term dev: %s\n", print_name());
2009 free_memory(dev_name);
2013 free_memory(prt_name);
2017 free_pool_memory(errmsg);
2020 pthread_mutex_destroy(&mutex);
2021 pthread_cond_destroy(&wait);
2022 pthread_cond_destroy(&wait_next_vol);
2023 pthread_mutex_destroy(&spool_mutex);
2025 if (attached_dcrs) {
2026 delete attached_dcrs;
2027 attached_dcrs = NULL;
2036 * This routine initializes the device wait timers
2038 void init_device_wait_timers(DCR *dcr)
2040 DEVICE *dev = dcr->dev;
2041 JCR *jcr = dcr->jcr;
2043 /* ******FIXME******* put these on config variables */
2044 dev->min_wait = 60 * 60;
2045 dev->max_wait = 24 * 60 * 60;
2046 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2047 dev->wait_sec = dev->min_wait;
2048 dev->rem_wait_sec = dev->wait_sec;
2051 dev->BadVolName[0] = 0;
2053 jcr->min_wait = 60 * 60;
2054 jcr->max_wait = 24 * 60 * 60;
2055 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2056 jcr->wait_sec = jcr->min_wait;
2057 jcr->rem_wait_sec = jcr->wait_sec;
2062 void init_jcr_device_wait_timers(JCR *jcr)
2064 /* ******FIXME******* put these on config variables */
2065 jcr->min_wait = 60 * 60;
2066 jcr->max_wait = 24 * 60 * 60;
2067 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2068 jcr->wait_sec = jcr->min_wait;
2069 jcr->rem_wait_sec = jcr->wait_sec;
2075 * The dev timers are used for waiting on a particular device
2077 * Returns: true if time doubled
2078 * false if max time expired
2080 bool double_dev_wait_time(DEVICE *dev)
2082 dev->wait_sec *= 2; /* double wait time */
2083 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2084 dev->wait_sec = dev->max_wait;
2087 dev->rem_wait_sec = dev->wait_sec;
2088 if (dev->num_wait >= dev->max_num_wait) {
2095 void set_os_device_parameters(DEVICE *dev)
2097 #ifdef HAVE_LINUX_OS
2099 if (dev->min_block_size == dev->max_block_size &&
2100 dev->min_block_size == 0) { /* variable block mode */
2101 mt_com.mt_op = MTSETBLK;
2102 mt_com.mt_count = 0;
2103 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2104 dev->clrerror(MTSETBLK);
2106 mt_com.mt_op = MTSETDRVBUFFER;
2107 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2108 if (!dev->has_cap(CAP_TWOEOF)) {
2109 mt_com.mt_count |= MT_ST_TWO_FM;
2111 if (dev->has_cap(CAP_EOM)) {
2112 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2114 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2115 dev->clrerror(MTSETBLK);
2121 #ifdef HAVE_NETBSD_OS
2123 if (dev->min_block_size == dev->max_block_size &&
2124 dev->min_block_size == 0) { /* variable block mode */
2125 mt_com.mt_op = MTSETBSIZ;
2126 mt_com.mt_count = 0;
2127 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2128 dev->clrerror(MTSETBSIZ);
2130 /* Get notified at logical end of tape */
2131 mt_com.mt_op = MTEWARN;
2132 mt_com.mt_count = 1;
2133 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2134 dev->clrerror(MTEWARN);
2140 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2142 if (dev->min_block_size == dev->max_block_size &&
2143 dev->min_block_size == 0) { /* variable block mode */
2144 mt_com.mt_op = MTSETBSIZ;
2145 mt_com.mt_count = 0;
2146 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2147 dev->clrerror(MTSETBSIZ);
2155 if (dev->min_block_size == dev->max_block_size &&
2156 dev->min_block_size == 0) { /* variable block mode */
2157 mt_com.mt_op = MTSRSZ;
2158 mt_com.mt_count = 0;
2159 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2160 dev->clrerror(MTSRSZ);
2167 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2169 return dev->has_cap(CAP_MTIOCGET) &&
2170 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2171 mt_stat->mt_fileno >= 0;
2174 static char *modes[] = {
2175 "CREATE_READ_WRITE",
2182 static char *mode_to_str(int mode)
2184 return modes[mode-1];