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 my 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 */
292 Dmsg1(000, "preserve=0x%x\n", preserve);
297 void DEVICE::set_mode(int new_mode)
300 case CREATE_READ_WRITE:
301 mode = O_CREAT | O_RDWR | O_BINARY;
303 case OPEN_READ_WRITE:
304 mode = O_RDWR | O_BINARY;
307 mode = O_RDONLY | O_BINARY;
309 case OPEN_WRITE_ONLY:
310 mode = O_WRONLY | O_BINARY;
313 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
319 void DEVICE::open_tape_device(DCR *dcr, int omode)
323 int nonblocking = O_NONBLOCK;
324 Dmsg0(29, "open dev: device is tape\n");
326 if (is_autochanger()) {
327 get_autochanger_loaded_slot(dcr);
331 timeout = max_open_wait;
333 if (is_fifo() && timeout) {
335 tid = start_thread_timer(pthread_self(), timeout);
337 /* If busy retry each second for max_open_wait seconds */
338 Dmsg3(100, "Try open %s mode=%s nonblocking=%d\n", print_name(),
339 mode_to_str(omode), nonblocking);
340 /* Use system open() */
341 while ((fd = ::open(dev_name, mode+nonblocking)) < 0) {
344 Dmsg5(050, "Open omode=%d mode=%x nonblock=%d error errno=%d ERR=%s\n",
345 omode, mode, nonblocking, errno, be.strerror());
346 if (dev_errno == EINTR || dev_errno == EAGAIN) {
347 Dmsg0(100, "Continue open\n");
350 /* Busy wait for specified time (default = 5 mins) */
351 if (dev_errno == EBUSY && timeout-- > 0) {
352 Dmsg2(100, "Device %s busy. ERR=%s\n", print_name(), be.strerror());
356 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
357 print_name(), be.strerror(dev_errno));
358 /* Stop any open timer we set */
360 stop_thread_timer(tid);
363 Jmsg0(dcr->jcr, M_FATAL, 0, errmsg);
368 openmode = omode; /* save open mode */
370 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
372 update_pos_dev(this); /* update position */
373 set_os_device_parameters(this); /* do system dependent stuff */
378 /* Stop any open() timer we started */
380 stop_thread_timer(tid);
383 Dmsg1(29, "open dev: tape %d opened\n", fd);
386 void DEVICE::set_blocking()
389 /* Try to reset blocking */
391 if ((oflags = fcntl(fd, F_GETFL, 0)) < 0 ||
392 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK) < 0) {
394 ::close(fd); /* use system close() */
395 fd = ::open(dev_name, mode);
396 Dmsg2(100, "fcntl error. ERR=%s. Close-reopen fd=%d\n", be.strerror(), fd);
399 oflags = fcntl(fd, F_GETFL, 0);
400 if (oflags > 0 && (oflags & O_NONBLOCK)) {
401 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK);
408 void DEVICE::open_file_device(DCR *dcr, int omode)
410 POOL_MEM archive_name(PM_FNAME);
412 if (is_autochanger()) {
413 get_autochanger_loaded_slot(dcr);
417 * Handle opening of File Archive (not a tape)
420 pm_strcpy(archive_name, dev_name);
422 * If this is a virtual autochanger (i.e. changer_res != NULL)
423 * we simply use the deviced name, assuming it has been
424 * appropriately setup by the "autochanger".
426 if (!device->changer_res) {
427 if (VolCatInfo.VolCatName[0] == 0) {
428 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
434 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
435 pm_strcat(archive_name, "/");
437 pm_strcat(archive_name, VolCatInfo.VolCatName);
440 mount(1); /* do mount if required */
444 /* If creating file, give 0640 permissions */
445 Dmsg3(29, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
446 archive_name.c_str(), mode);
447 /* Use system open() */
448 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
451 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
453 Dmsg1(29, "open failed: %s", errmsg);
454 Emsg0(M_FATAL, 0, errmsg);
457 update_pos_dev(this); /* update position */
459 Dmsg4(29, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
460 fd, part, num_parts, part_size);
464 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
465 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
466 * has the desired Volume name, but there is NO assurance that
467 * any other field of VolCatInfo is correct.
469 void DEVICE::open_dvd_device(DCR *dcr, int omode)
471 POOL_MEM archive_name(PM_FNAME);
472 struct stat filestat;
475 * Handle opening of DVD Volume
477 Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
478 archive_name.c_str(), mode_to_str(omode));
480 if (VolCatInfo.VolCatName[0] == 0) {
481 Dmsg1(10, "Could not open file device %s. No Volume name given.\n",
483 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
494 Dmsg2(99, "open_dvd_device: num_parts=%d, VolCatInfo.VolCatParts=%d\n",
495 dcr->dev->num_parts, dcr->VolCatInfo.VolCatParts);
496 if (dcr->dev->num_parts < dcr->VolCatInfo.VolCatParts) {
497 Dmsg2(99, "open_dvd_device: num_parts updated to %d (was %d)\n",
498 dcr->VolCatInfo.VolCatParts, dcr->dev->num_parts);
499 dcr->dev->num_parts = dcr->VolCatInfo.VolCatParts;
502 if (mount_dvd(this, 1)) {
503 if ((num_parts == 0) && (!truncating)) {
504 /* If we can mount the device, and we are not truncating the DVD, we usually want to abort. */
505 /* There is one exception, if there is only one 0-sized file on the DVD, with the right volume name,
506 * we continue (it's the method used by truncate_dvd to truncate a volume). */
507 if (!check_can_write_on_non_blank_dvd(dcr)) {
508 Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
509 Emsg0(M_FATAL, 0, errmsg);
510 unmount_dvd(this, 1); /* Unmount the device, so the operator can change it. */
516 /* We cannot mount the device */
517 if (num_parts == 0) {
518 /* Run free space, check there is a media. */
519 update_free_space_dev(this);
521 Dmsg1(29, "Could not mount device %s, this is not a problem (num_parts == 0), and have media.\n", print_name());
524 Mmsg(errmsg, _("There is no valid media in the device %s.\n"), print_name());
525 Emsg0(M_FATAL, 0, errmsg);
531 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
532 Emsg0(M_FATAL, 0, errmsg);
538 Dmsg6(29, "open dev: %s dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
539 is_dvd()?"DVD":"disk", archive_name.c_str(), mode_to_str(omode),
540 part, num_parts, dcr->VolCatInfo.VolCatParts);
542 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
545 * If we are not trying to access the last part, set mode to
546 * OPEN_READ_ONLY as writing would be an error.
548 if (part < num_parts) {
549 omode = OPEN_READ_ONLY;
550 make_mounted_dvd_filename(this, archive_name);
553 make_spooled_dvd_filename(this, archive_name);
557 /* If creating file, give 0640 permissions */
558 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
559 archive_name.c_str(), mode);
560 /* Use system open() */
561 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
563 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
565 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
566 Dmsg1(29, "open failed: %s", errmsg);
568 if ((omode == OPEN_READ_ONLY) && (part == num_parts)) {
569 /* If the last part (on spool), doesn't exists when reading, create it and read from it
570 * (it will report immediately an EOF):
571 * Sometimes it is better to finish with an EOF than with an error. */
572 set_mode(OPEN_READ_WRITE);
573 fd = ::open(archive_name.c_str(), mode, 0640);
574 set_mode(OPEN_READ_ONLY);
577 /* We don't need it. Only the last part is on spool */
578 /*if (omode == OPEN_READ_ONLY) {
579 make_spooled_dvd_filename(this, archive_name);
580 fd = ::open(archive_name.c_str(), mode, 0640); // try on spool
583 Dmsg1(100, "after open fd=%d\n", fd);
585 /* Get size of file */
586 if (fstat(fd, &filestat) < 0) {
589 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
591 Dmsg1(29, "open failed: %s", errmsg);
592 /* Use system close() */
596 part_size = filestat.st_size;
598 update_pos_dev(this); /* update position */
600 /* NB: It seems this code is wrong... part number is incremented in open_next_part, not here */
602 /* Check if just created Volume part */
603 /* if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
606 VolCatInfo.VolCatParts = num_parts;
608 if (part == 0) { // we must have opened the first part
619 * Returns: true on success
622 bool DEVICE::rewind(DCR *dcr)
628 Dmsg3(400, "rewind res=%d fd=%d %s\n", reserved_device, fd, print_name());
630 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
632 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
634 Emsg0(M_ABORT, 0, errmsg);
638 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
639 block_num = file = 0;
643 mt_com.mt_op = MTREW;
645 /* If we get an I/O error on rewind, it is probably because
646 * the drive is actually busy. We loop for (about 5 minutes)
647 * retrying every 5 seconds.
649 for (i=max_rewind_wait; ; i -= 5) {
650 if (ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
653 if (i == max_rewind_wait) {
654 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
657 * This is a gross hack, because if the user has the
658 * device mounted (i.e. open), then uses mtx to load
659 * a tape, the current open file descriptor is invalid.
660 * So, we close the drive and re-open it.
663 int open_mode = openmode;
666 open(dcr, open_mode);
673 if (dev_errno == EIO && i > 0) {
674 Dmsg0(200, "Sleeping 5 seconds.\n");
678 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
679 print_name(), be.strerror());
684 } else if (is_file()) {
685 if (lseek_dev(this, (off_t)0, SEEK_SET) < 0) {
688 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
689 print_name(), be.strerror());
696 void DEVICE::block(int why)
699 block_device(this, why);
703 void DEVICE::unblock()
706 unblock_device(this);
710 const char *DEVICE::print_blocked() const
712 switch (dev_blocked) {
713 case BST_NOT_BLOCKED:
714 return "BST_NOT_BLOCKED";
716 return "BST_UNMOUNTED";
717 case BST_WAITING_FOR_SYSOP:
718 return "BST_WAITING_FOR_SYSOP";
719 case BST_DOING_ACQUIRE:
720 return "BST_DOING_ACQUIRE";
721 case BST_WRITING_LABEL:
722 return "BST_WRITING_LABEL";
723 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
724 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
728 return _("unknown blocked code");
733 * Called to indicate that we have just read an
734 * EOF from the device.
736 void DEVICE::set_ateof()
748 * Called to indicate we are now at the end of the tape, and
749 * writing is not possible.
751 void DEVICE::set_ateot()
753 /* Make tape effectively read-only */
754 state |= (ST_EOF|ST_EOT|ST_WEOT);
759 * Position device to end of medium (end of data)
760 * Returns: true on succes
766 struct mtget mt_stat;
772 Mmsg1(errmsg, _("Bad call to eod_dev. Device %s not open\n"), print_name());
776 #if defined (__digital__) && defined (__unix__)
777 return fsf(VolCatInfo.VolCatFiles);
780 Dmsg0(29, "eod_dev\n");
784 state &= ~(ST_EOF); /* remove EOF flags */
785 block_num = file = 0;
788 if (is_fifo() || is_prog()) {
792 pos = lseek_dev(this, (off_t)0, SEEK_END);
793 // Dmsg1(100, "====== Seek to %lld\n", pos);
795 update_pos_dev(this);
801 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
802 print_name(), be.strerror());
806 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
807 Dmsg0(100,"Using FAST FSF for EOM\n");
808 /* If unknown position, rewind */
809 if (!dev_get_os_pos(this, &mt_stat)) {
814 mt_com.mt_op = MTFSF;
816 * ***FIXME*** fix code to handle case that INT16_MAX is
819 mt_com.mt_count = INT16_MAX; /* use big positive number */
820 if (mt_com.mt_count < 0) {
821 mt_com.mt_count = INT16_MAX; /* brain damaged system */
825 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
826 if (has_cap(CAP_EOM)) {
827 Dmsg0(100,"Using EOM for EOM\n");
828 mt_com.mt_op = MTEOM;
832 if (ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
834 clrerror(mt_com.mt_op);
835 Dmsg1(50, "ioctl error: %s\n", be.strerror());
836 update_pos_dev(this);
837 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
838 print_name(), be.strerror());
842 if (!dev_get_os_pos(this, &mt_stat)) {
845 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
846 print_name(), be.strerror());
849 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
851 file = mt_stat.mt_fileno;
857 * Rewind then use FSF until EOT reached
863 * Move file by file to the end of the tape
866 for (file_num=file; !at_eot(); file_num++) {
867 Dmsg0(200, "eod_dev: doing fsf 1\n");
869 Dmsg0(200, "fsf error.\n");
873 * Avoid infinite loop by ensuring we advance.
875 if (file_num == (int)file) {
876 struct mtget mt_stat;
877 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
879 if (dev_get_os_pos(this, &mt_stat)) {
880 Dmsg2(100, "Adjust file from %d to %d\n", file , mt_stat.mt_fileno);
881 file = mt_stat.mt_fileno;
888 * Some drivers leave us after second EOF when doing
889 * MTEOM, so we must backup so that appending overwrites
892 if (has_cap(CAP_BSFATEOM)) {
893 struct mtget mt_stat;
894 /* Backup over EOF */
896 /* If BSF worked and fileno is known (not -1), set file */
897 if (dev_get_os_pos(this, &mt_stat)) {
898 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , mt_stat.mt_fileno);
899 file = mt_stat.mt_fileno;
901 file++; /* wing it -- not correct on all OSes */
904 update_pos_dev(this); /* update position */
906 Dmsg1(200, "EOD dev->file=%d\n", file);
911 * Set the position of the device -- only for files and DVD
912 * For other devices, there is no generic way to do it.
913 * Returns: true on succes
916 bool update_pos_dev(DEVICE *dev)
922 dev->dev_errno = EBADF;
923 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
924 Emsg0(M_FATAL, 0, dev->errmsg);
928 /* Find out where we are */
929 if (dev->is_file()) {
932 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
935 dev->dev_errno = errno;
936 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
937 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
938 dev->print_name(), be.strerror());
941 dev->file_addr = pos;
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");
1289 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"),
1317 state &= ~(ST_EOT|ST_EOF);
1321 mt_com.mt_op = MTBSF;
1322 mt_com.mt_count = num;
1323 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1327 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1328 print_name(), be.strerror());
1330 update_pos_dev(this);
1336 * Foward space num records
1337 * Returns: false on failure
1340 bool DEVICE::fsr(int num)
1347 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1348 Emsg0(M_FATAL, 0, errmsg);
1355 if (!has_cap(CAP_FSR)) {
1356 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1360 Dmsg1(29, "fsr %d\n", num);
1361 mt_com.mt_op = MTFSR;
1362 mt_com.mt_count = num;
1363 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1369 struct mtget mt_stat;
1371 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1372 if (dev_get_os_pos(this, &mt_stat)) {
1373 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1374 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1375 file = mt_stat.mt_fileno;
1376 block_num = mt_stat.mt_blkno;
1384 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1385 num, print_name(), be.strerror());
1387 update_pos_dev(this);
1392 * Backward space a record
1393 * Returns: false on failure
1396 bool DEVICE::bsr(int num)
1403 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1404 Emsg0(M_FATAL, 0, errmsg);
1412 if (!has_cap(CAP_BSR)) {
1413 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1417 Dmsg0(29, "bsr_dev\n");
1419 state &= ~(ST_EOF|ST_EOT|ST_EOF);
1420 mt_com.mt_op = MTBSR;
1421 mt_com.mt_count = num;
1422 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1426 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1427 print_name(), be.strerror());
1429 update_pos_dev(this);
1434 * Reposition the device to file, block
1435 * Returns: false on failure
1438 bool DEVICE::reposition(uint32_t rfile, uint32_t rblock)
1442 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1443 Emsg0(M_FATAL, 0, errmsg);
1448 off_t pos = (((off_t)rfile)<<32) + (off_t)rblock;
1449 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1450 if (lseek_dev(this, pos, SEEK_SET) == (off_t)-1) {
1453 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1454 print_name(), be.strerror());
1462 Dmsg4(100, "reposition from %u:%u to %u:%u\n",
1463 file, block_num, rfile, rblock);
1465 Dmsg0(100, "Rewind\n");
1466 if (!rewind(NULL)) {
1471 Dmsg1(100, "fsf %d\n", rfile-file);
1472 if (!fsf(rfile-file)) {
1473 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1476 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1478 if (rblock < block_num) {
1479 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1480 Dmsg0(100, "bsf 1\n");
1482 Dmsg0(100, "fsf_dev 1\n");
1484 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1486 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1487 /* Ignore errors as Bacula can read to the correct block */
1488 Dmsg1(100, "fsr %d\n", rblock-block_num);
1489 return fsr(rblock-block_num);
1497 * Write an end of file on the device
1498 * Returns: true on success
1501 bool DEVICE::weof(int num)
1505 Dmsg0(129, "weof_dev\n");
1509 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1510 Emsg0(M_FATAL, 0, errmsg);
1518 if (!can_append()) {
1519 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1520 Emsg0(M_FATAL, 0, errmsg);
1524 state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1525 mt_com.mt_op = MTWEOF;
1526 mt_com.mt_count = num;
1527 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1536 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1537 print_name(), be.strerror());
1545 * If implemented in system, clear the tape
1548 void DEVICE::clrerror(int func)
1550 const char *msg = NULL;
1551 struct mtget mt_stat;
1554 dev_errno = errno; /* save errno */
1556 VolCatInfo.VolCatErrors++;
1562 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1565 Emsg0(M_ABORT, 0, _("Got ENOTTY on read/write!\n"));
1569 capabilities &= ~CAP_EOF; /* turn off feature */
1574 capabilities &= ~CAP_EOM; /* turn off feature */
1579 capabilities &= ~CAP_FSF; /* turn off feature */
1583 capabilities &= ~CAP_BSF; /* turn off feature */
1587 capabilities &= ~CAP_FSR; /* turn off feature */
1591 capabilities &= ~CAP_BSR; /* turn off feature */
1625 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1631 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1632 Emsg0(M_ERROR, 0, errmsg);
1637 * Now we try different methods of clearing the error
1638 * status on the drive so that it is not locked for
1639 * further operations.
1642 /* On some systems such as NetBSD, this clears all errors */
1643 ioctl(fd, MTIOCGET, (char *)&mt_stat);
1645 /* Found on Linux */
1649 mt_com.mt_op = MTIOCLRERR;
1650 mt_com.mt_count = 1;
1651 /* Clear any error condition on the tape */
1652 ioctl(fd, MTIOCTOP, (char *)&mt_com);
1653 Dmsg0(200, "Did MTIOCLRERR\n");
1657 /* Typically on FreeBSD */
1660 /* Read and clear SCSI error status */
1661 union mterrstat mt_errstat;
1662 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1663 strerror(dev_errno));
1664 ioctl(fd, MTIOCERRSTAT, (char *)&mt_errstat);
1668 /* Clear Subsystem Exception OSF1 */
1672 mt_com.mt_op = MTCSE;
1673 mt_com.mt_count = 1;
1674 /* Clear any error condition on the tape */
1675 ioctl(fd, MTIOCTOP, (char *)&mt_com);
1676 Dmsg0(200, "Did MTCSE\n");
1684 void DEVICE::close()
1686 Dmsg1(100, "close_dev %s\n", print_name());
1687 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1693 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1695 return; /* already closed */
1698 if (is_dvd() && !unmount_dvd(this, 1)) {
1699 Dmsg1(0, "Cannot unmount device %s.\n", print_name());
1702 /* Remove the last part file if it is empty */
1703 if (num_parts > 0) {
1705 POOL_MEM archive_name(PM_FNAME);
1707 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", VolCatInfo.VolCatName);
1708 make_spooled_dvd_filename(this, archive_name);
1709 /* Check that the part file is empty */
1710 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1711 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1712 unlink(archive_name.c_str());
1716 /* Clean up device packet so it can be reused */
1718 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1719 label_type = B_BACULA_LABEL;
1720 file = block_num = 0;
1727 EndFile = EndBlock = 0;
1729 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1730 memset(&VolHdr, 0, sizeof(VolHdr));
1732 stop_thread_timer(tid);
1740 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1742 Dmsg1(100, "truncate_dev %s\n", print_name());
1744 return true; /* we don't really truncate tapes */
1745 /* maybe we should rewind and write and eof ???? */
1749 return truncate_dvd(dcr);
1752 if (ftruncate(fd, 0) != 0) {
1754 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1755 print_name(), be.strerror());
1761 /* Mount the device.
1762 * If timeout, wait until the mount command returns 0.
1763 * If !timeout, try to mount the device only once.
1765 bool DEVICE::mount(int timeout)
1767 Dmsg0(190, "Enter mount\n");
1770 } else if (requires_mount()) {
1771 return do_mount(1, timeout);
1776 /* Unmount the device
1777 * If timeout, wait until the unmount command returns 0.
1778 * If !timeout, try to unmount the device only once.
1780 bool DEVICE::unmount(int timeout)
1782 Dmsg0(90, "Enter unmount_dvd\n");
1784 return do_mount(0, timeout);
1789 /* (Un)mount the device */
1790 bool DEVICE::do_mount(int mount, int dotimeout)
1792 POOL_MEM ocmd(PM_FNAME);
1795 int status, timeout;
1797 sm_check(__FILE__, __LINE__, false);
1800 Dmsg0(200, "======= mount=1\n");
1803 icmd = device->mount_command;
1805 if (!is_mounted()) {
1806 Dmsg0(200, "======= mount=0\n");
1809 icmd = device->unmount_command;
1812 edit_mount_codes(ocmd, icmd);
1814 Dmsg2(000, "do_mount_dvd: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1817 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1822 results = get_memory(2000);
1824 /* If busy retry each second */
1825 while ((status = run_program_full_output(ocmd.c_str(),
1826 max_open_wait/2, results)) != 0) {
1827 /* Doesn't work with internationalisation (This is not a problem) */
1828 if (fnmatch("*is already mounted on", results, 0) == 0) {
1831 if (timeout-- > 0) {
1832 /* Sometimes the device cannot be mounted because it is already mounted.
1833 * Try to unmount it, then remount it */
1835 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
1841 Dmsg2(40, "Device %s cannot be mounted. ERR=%s\n", print_name(), results);
1842 Mmsg(errmsg, _("Device %s cannot be mounted. ERR=%s\n"),
1843 print_name(), results);
1845 * Now, just to be sure it is not mounted, try to read the
1849 struct dirent *entry, *result;
1853 name_max = pathconf(".", _PC_NAME_MAX);
1854 if (name_max < 1024) {
1858 if (!(dp = opendir(device->mount_point))) {
1861 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
1862 device->mount_point, print_name(), be.strerror());
1866 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
1869 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
1871 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
1872 device->mount_point, print_name());
1875 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
1876 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
1879 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
1885 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
1888 mount = 1; /* If we got more than ., .. and .keep */
1889 break; /* there must be something mounted */
1893 sm_check(__FILE__, __LINE__, false);
1894 free_pool_memory(results);
1895 Dmsg0(200, "============ mount=0\n");
1899 set_mounted(mount); /* set/clear mounted flag */
1900 free_pool_memory(results);
1901 Dmsg1(200, "============ mount=%d\n", mount);
1906 * Edit codes into (Un)MountCommand, Write(First)PartCommand
1908 * %a = archive device name
1909 * %e = erase (set if cannot mount and first part)
1912 * %v = last part name
1914 * omsg = edited output message
1915 * imsg = input string containing edit codes (%x)
1918 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
1924 POOL_MEM archive_name(PM_FNAME);
1926 omsg.c_str()[0] = 0;
1927 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
1928 for (p=imsg; *p; p++) {
1938 if (num_parts == 0) {
1945 bsnprintf(add, sizeof(add), "%d", part);
1949 str = device->mount_point;
1952 make_spooled_dvd_filename(this, archive_name);
1953 str = archive_name.c_str();
1967 Dmsg1(1900, "add_str %s\n", str);
1968 pm_strcat(omsg, (char *)str);
1969 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
1974 /* Return the resource name for the device */
1975 const char *DEVICE::name() const
1977 return device->hdr.name;
1981 dev_vol_name(DEVICE *dev)
1983 return dev->VolCatInfo.VolCatName;
1986 uint32_t dev_block(DEVICE *dev)
1988 update_pos_dev(dev);
1989 return dev->block_num;
1992 uint32_t dev_file(DEVICE *dev)
1994 update_pos_dev(dev);
1999 * Free memory allocated for the device
2001 void DEVICE::term(void)
2003 Dmsg1(900, "term dev: %s\n", print_name());
2006 free_memory(dev_name);
2010 free_memory(prt_name);
2014 free_pool_memory(errmsg);
2017 pthread_mutex_destroy(&mutex);
2018 pthread_cond_destroy(&wait);
2019 pthread_cond_destroy(&wait_next_vol);
2020 pthread_mutex_destroy(&spool_mutex);
2022 if (attached_dcrs) {
2023 delete attached_dcrs;
2024 attached_dcrs = NULL;
2033 * This routine initializes the device wait timers
2035 void init_device_wait_timers(DCR *dcr)
2037 DEVICE *dev = dcr->dev;
2038 JCR *jcr = dcr->jcr;
2040 /* ******FIXME******* put these on config variables */
2041 dev->min_wait = 60 * 60;
2042 dev->max_wait = 24 * 60 * 60;
2043 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2044 dev->wait_sec = dev->min_wait;
2045 dev->rem_wait_sec = dev->wait_sec;
2048 dev->BadVolName[0] = 0;
2050 jcr->min_wait = 60 * 60;
2051 jcr->max_wait = 24 * 60 * 60;
2052 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2053 jcr->wait_sec = jcr->min_wait;
2054 jcr->rem_wait_sec = jcr->wait_sec;
2059 void init_jcr_device_wait_timers(JCR *jcr)
2061 /* ******FIXME******* put these on config variables */
2062 jcr->min_wait = 60 * 60;
2063 jcr->max_wait = 24 * 60 * 60;
2064 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2065 jcr->wait_sec = jcr->min_wait;
2066 jcr->rem_wait_sec = jcr->wait_sec;
2072 * The dev timers are used for waiting on a particular device
2074 * Returns: true if time doubled
2075 * false if max time expired
2077 bool double_dev_wait_time(DEVICE *dev)
2079 dev->wait_sec *= 2; /* double wait time */
2080 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2081 dev->wait_sec = dev->max_wait;
2084 dev->rem_wait_sec = dev->wait_sec;
2085 if (dev->num_wait >= dev->max_num_wait) {
2092 void set_os_device_parameters(DEVICE *dev)
2094 #ifdef HAVE_LINUX_OS
2096 if (dev->min_block_size == dev->max_block_size &&
2097 dev->min_block_size == 0) { /* variable block mode */
2098 mt_com.mt_op = MTSETBLK;
2099 mt_com.mt_count = 0;
2100 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2101 dev->clrerror(MTSETBLK);
2103 mt_com.mt_op = MTSETDRVBUFFER;
2104 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2105 if (!dev->has_cap(CAP_TWOEOF)) {
2106 mt_com.mt_count |= MT_ST_TWO_FM;
2108 if (dev->has_cap(CAP_EOM)) {
2109 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2111 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2112 dev->clrerror(MTSETBLK);
2118 #ifdef HAVE_NETBSD_OS
2120 if (dev->min_block_size == dev->max_block_size &&
2121 dev->min_block_size == 0) { /* variable block mode */
2122 mt_com.mt_op = MTSETBSIZ;
2123 mt_com.mt_count = 0;
2124 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2125 dev->clrerror(MTSETBSIZ);
2127 /* Get notified at logical end of tape */
2128 mt_com.mt_op = MTEWARN;
2129 mt_com.mt_count = 1;
2130 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2131 dev->clrerror(MTEWARN);
2137 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2139 if (dev->min_block_size == dev->max_block_size &&
2140 dev->min_block_size == 0) { /* variable block mode */
2141 mt_com.mt_op = MTSETBSIZ;
2142 mt_com.mt_count = 0;
2143 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2144 dev->clrerror(MTSETBSIZ);
2152 if (dev->min_block_size == dev->max_block_size &&
2153 dev->min_block_size == 0) { /* variable block mode */
2154 mt_com.mt_op = MTSRSZ;
2155 mt_com.mt_count = 0;
2156 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2157 dev->clrerror(MTSRSZ);
2164 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2166 return dev->has_cap(CAP_MTIOCGET) &&
2167 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2168 mt_stat->mt_fileno >= 0;
2171 static char *modes[] = {
2172 "CREATE_READ_WRITE",
2179 static char *mode_to_str(int mode)
2181 return modes[mode-1];