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) {
652 clrerror_dev(this, MTREW);
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_dev(this, 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)) {
844 clrerror_dev(this, -1);
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.
1129 clrerror_dev(this, MTREW);
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");
1181 clrerror_dev(this, MTFSF);
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) {
1225 clrerror_dev(this, -1);
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");
1257 clrerror_dev(this, MTFSF);
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);
1326 clrerror_dev(this, MTBSF);
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;
1370 clrerror_dev(this, MTFSR);
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);
1425 clrerror_dev(this, MTBSR);
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: 0 on success
1499 * non-zero on failure
1502 weof_dev(DEVICE *dev, int num)
1506 Dmsg0(29, "weof_dev\n");
1509 dev->dev_errno = EBADF;
1510 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1511 Emsg0(M_FATAL, 0, dev->errmsg);
1516 if (!dev->is_tape()) {
1519 if (!dev->can_append()) {
1520 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1521 Emsg0(M_FATAL, 0, dev->errmsg);
1525 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1526 mt_com.mt_op = MTWEOF;
1527 mt_com.mt_count = num;
1528 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1535 clrerror_dev(dev, MTWEOF);
1537 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1538 dev->print_name(), be.strerror());
1546 * If implemented in system, clear the tape
1550 clrerror_dev(DEVICE *dev, int func)
1552 const char *msg = NULL;
1553 struct mtget mt_stat;
1556 dev->dev_errno = errno; /* save errno */
1558 dev->VolCatInfo.VolCatErrors++;
1561 if (!dev->is_tape()) {
1564 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1567 Emsg0(M_ABORT, 0, _("Got ENOTTY on read/write!\n"));
1571 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1576 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1581 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1585 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1589 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1593 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1614 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1619 dev->dev_errno = ENOSYS;
1620 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1621 Emsg0(M_ERROR, 0, dev->errmsg);
1624 /* On some systems such as NetBSD, this clears all errors */
1625 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1627 /* Found on Linux */
1631 mt_com.mt_op = MTIOCLRERR;
1632 mt_com.mt_count = 1;
1633 /* Clear any error condition on the tape */
1634 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1635 Dmsg0(200, "Did MTIOCLRERR\n");
1639 /* Typically on FreeBSD */
1642 /* Read and clear SCSI error status */
1643 union mterrstat mt_errstat;
1644 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1645 strerror(dev->dev_errno));
1646 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1650 /* Clear Subsystem Exception OSF1 */
1654 mt_com.mt_op = MTCSE;
1655 mt_com.mt_count = 1;
1656 /* Clear any error condition on the tape */
1657 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1658 Dmsg0(200, "Did MTCSE\n");
1666 void DEVICE::close()
1668 Dmsg1(100, "close_dev %s\n", print_name());
1669 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1675 return; /* already closed */
1678 if (is_dvd() && !unmount_dvd(this, 1)) {
1679 Dmsg1(0, "Cannot unmount device %s.\n", print_name());
1682 /* Remove the last part file if it is empty */
1683 if (num_parts > 0) {
1685 POOL_MEM archive_name(PM_FNAME);
1687 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", VolCatInfo.VolCatName);
1688 make_spooled_dvd_filename(this, archive_name);
1689 /* Check that the part file is empty */
1690 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1691 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1692 unlink(archive_name.c_str());
1696 /* Clean up device packet so it can be reused */
1698 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1699 label_type = B_BACULA_LABEL;
1700 file = block_num = 0;
1707 EndFile = EndBlock = 0;
1708 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1710 memset(&VolHdr, 0, sizeof(VolHdr));
1712 stop_thread_timer(tid);
1720 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1722 Dmsg1(100, "truncate_dev %s\n", print_name());
1724 return true; /* we don't really truncate tapes */
1725 /* maybe we should rewind and write and eof ???? */
1729 return truncate_dvd(dcr);
1732 if (ftruncate(fd, 0) != 0) {
1734 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1735 print_name(), be.strerror());
1741 /* Mount the device.
1742 * If timeout, wait until the mount command returns 0.
1743 * If !timeout, try to mount the device only once.
1745 bool DEVICE::mount(int timeout)
1747 Dmsg0(90, "Enter mount\n");
1750 } else if (requires_mount()) {
1751 return do_mount(1, timeout);
1756 /* Unmount the device
1757 * If timeout, wait until the unmount command returns 0.
1758 * If !timeout, try to unmount the device only once.
1760 bool DEVICE::unmount(int timeout)
1762 Dmsg0(90, "Enter unmount_dvd\n");
1764 return do_mount(0, timeout);
1769 /* (Un)mount the device */
1770 bool DEVICE::do_mount(int mount, int dotimeout)
1772 POOL_MEM ocmd(PM_FNAME);
1775 int status, timeout;
1777 sm_check(__FILE__, __LINE__, false);
1780 Dmsg0(200, "======= mount=1\n");
1783 icmd = device->mount_command;
1785 if (!is_mounted()) {
1786 Dmsg0(200, "======= mount=0\n");
1789 icmd = device->unmount_command;
1792 edit_mount_codes(ocmd, icmd);
1794 Dmsg2(000, "do_mount_dvd: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1797 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1802 results = get_memory(2000);
1804 /* If busy retry each second */
1805 while ((status = run_program_full_output(ocmd.c_str(),
1806 max_open_wait/2, results)) != 0) {
1807 /* Doesn't work with internationalisation (This is not a problem) */
1808 if (fnmatch("*is already mounted on", results, 0) == 0) {
1811 if (timeout-- > 0) {
1812 /* Sometimes the device cannot be mounted because it is already mounted.
1813 * Try to unmount it, then remount it */
1815 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
1821 Dmsg2(40, "Device %s cannot be mounted. ERR=%s\n", print_name(), results);
1822 Mmsg(errmsg, _("Device %s cannot be mounted. ERR=%s\n"),
1823 print_name(), results);
1825 * Now, just to be sure it is not mounted, try to read the
1829 struct dirent *entry, *result;
1833 name_max = pathconf(".", _PC_NAME_MAX);
1834 if (name_max < 1024) {
1838 if (!(dp = opendir(device->mount_point))) {
1841 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
1842 device->mount_point, print_name(), be.strerror());
1846 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
1849 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
1851 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
1852 device->mount_point, print_name());
1855 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
1856 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
1859 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
1865 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
1868 mount = 1; /* If we got more than ., .. and .keep */
1869 break; /* there must be something mounted */
1873 sm_check(__FILE__, __LINE__, false);
1874 free_pool_memory(results);
1875 Dmsg0(200, "============ mount=0\n");
1879 set_mounted(mount); /* set/clear mounted flag */
1880 free_pool_memory(results);
1881 Dmsg1(200, "============ mount=%d\n", mount);
1886 * Edit codes into (Un)MountCommand, Write(First)PartCommand
1888 * %a = archive device name
1889 * %e = erase (set if cannot mount and first part)
1892 * %v = last part name
1894 * omsg = edited output message
1895 * imsg = input string containing edit codes (%x)
1898 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
1904 POOL_MEM archive_name(PM_FNAME);
1906 omsg.c_str()[0] = 0;
1907 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
1908 for (p=imsg; *p; p++) {
1918 if (num_parts == 0) {
1925 bsnprintf(add, sizeof(add), "%d", part);
1929 str = device->mount_point;
1932 make_spooled_dvd_filename(this, archive_name);
1933 str = archive_name.c_str();
1947 Dmsg1(1900, "add_str %s\n", str);
1948 pm_strcat(omsg, (char *)str);
1949 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
1954 /* Return the resource name for the device */
1955 const char *DEVICE::name() const
1957 return device->hdr.name;
1961 dev_vol_name(DEVICE *dev)
1963 return dev->VolCatInfo.VolCatName;
1966 uint32_t dev_block(DEVICE *dev)
1968 update_pos_dev(dev);
1969 return dev->block_num;
1972 uint32_t dev_file(DEVICE *dev)
1974 update_pos_dev(dev);
1979 * Free memory allocated for the device
1981 void DEVICE::term(void)
1983 Dmsg1(900, "term dev: %s\n", print_name());
1986 free_memory(dev_name);
1990 free_memory(prt_name);
1994 free_pool_memory(errmsg);
1997 pthread_mutex_destroy(&mutex);
1998 pthread_cond_destroy(&wait);
1999 pthread_cond_destroy(&wait_next_vol);
2000 pthread_mutex_destroy(&spool_mutex);
2002 if (attached_dcrs) {
2003 delete attached_dcrs;
2004 attached_dcrs = NULL;
2013 * This routine initializes the device wait timers
2015 void init_device_wait_timers(DCR *dcr)
2017 DEVICE *dev = dcr->dev;
2018 JCR *jcr = dcr->jcr;
2020 /* ******FIXME******* put these on config variables */
2021 dev->min_wait = 60 * 60;
2022 dev->max_wait = 24 * 60 * 60;
2023 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2024 dev->wait_sec = dev->min_wait;
2025 dev->rem_wait_sec = dev->wait_sec;
2028 dev->BadVolName[0] = 0;
2030 jcr->min_wait = 60 * 60;
2031 jcr->max_wait = 24 * 60 * 60;
2032 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2033 jcr->wait_sec = jcr->min_wait;
2034 jcr->rem_wait_sec = jcr->wait_sec;
2039 void init_jcr_device_wait_timers(JCR *jcr)
2041 /* ******FIXME******* put these on config variables */
2042 jcr->min_wait = 60 * 60;
2043 jcr->max_wait = 24 * 60 * 60;
2044 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2045 jcr->wait_sec = jcr->min_wait;
2046 jcr->rem_wait_sec = jcr->wait_sec;
2052 * The dev timers are used for waiting on a particular device
2054 * Returns: true if time doubled
2055 * false if max time expired
2057 bool double_dev_wait_time(DEVICE *dev)
2059 dev->wait_sec *= 2; /* double wait time */
2060 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2061 dev->wait_sec = dev->max_wait;
2064 dev->rem_wait_sec = dev->wait_sec;
2065 if (dev->num_wait >= dev->max_num_wait) {
2072 void set_os_device_parameters(DEVICE *dev)
2074 #ifdef HAVE_LINUX_OS
2076 if (dev->min_block_size == dev->max_block_size &&
2077 dev->min_block_size == 0) { /* variable block mode */
2078 mt_com.mt_op = MTSETBLK;
2079 mt_com.mt_count = 0;
2080 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2081 clrerror_dev(dev, MTSETBLK);
2083 mt_com.mt_op = MTSETDRVBUFFER;
2084 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2085 if (!dev->has_cap(CAP_TWOEOF)) {
2086 mt_com.mt_count |= MT_ST_TWO_FM;
2088 if (dev->has_cap(CAP_EOM)) {
2089 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2091 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2092 clrerror_dev(dev, MTSETBLK);
2098 #ifdef HAVE_NETBSD_OS
2100 if (dev->min_block_size == dev->max_block_size &&
2101 dev->min_block_size == 0) { /* variable block mode */
2102 mt_com.mt_op = MTSETBSIZ;
2103 mt_com.mt_count = 0;
2104 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2105 clrerror_dev(dev, MTSETBSIZ);
2107 /* Get notified at logical end of tape */
2108 mt_com.mt_op = MTEWARN;
2109 mt_com.mt_count = 1;
2110 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2111 clrerror_dev(dev, MTEWARN);
2117 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2119 if (dev->min_block_size == dev->max_block_size &&
2120 dev->min_block_size == 0) { /* variable block mode */
2121 mt_com.mt_op = MTSETBSIZ;
2122 mt_com.mt_count = 0;
2123 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2124 clrerror_dev(dev, MTSETBSIZ);
2132 if (dev->min_block_size == dev->max_block_size &&
2133 dev->min_block_size == 0) { /* variable block mode */
2134 mt_com.mt_op = MTSRSZ;
2135 mt_com.mt_count = 0;
2136 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2137 clrerror_dev(dev, MTSRSZ);
2144 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2146 return dev->has_cap(CAP_MTIOCGET) &&
2147 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2148 mt_stat->mt_fileno >= 0;
2151 static char *modes[] = {
2152 "CREATE_READ_WRITE",
2159 static char *mode_to_str(int mode)
2161 return modes[mode-1];