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));
134 dev->state = ST_MALLOC;
136 /* Copy user supplied device parameters from Resource */
137 dev->dev_name = get_memory(strlen(device->device_name)+1);
138 pm_strcpy(dev->dev_name, device->device_name);
139 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
140 /* We edit "Resource-name" (physical-name) */
141 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_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 dev->device = device;
167 if (dev->is_fifo()) {
168 dev->capabilities |= CAP_STREAM; /* set stream device */
171 /* If the device requires mount :
172 * - Check that the mount point is available
173 * - Check that (un)mount commands are defined
175 if ((dev->is_file() || dev->is_dvd()) && dev->requires_mount()) {
176 if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
178 dev->dev_errno = errno;
179 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat mount point %s: ERR=%s\n"),
180 device->mount_point, be.strerror());
185 if (!device->mount_command || !device->unmount_command) {
186 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
188 if (!device->write_part_command) {
189 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
193 if (dev->max_block_size > 1000000) {
194 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
195 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
196 dev->max_block_size = 0;
198 if (dev->max_block_size % TAPE_BSIZE != 0) {
199 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
200 dev->max_block_size, dev->print_name());
203 dev->errmsg = get_pool_memory(PM_EMSG);
206 if ((errstat = pthread_mutex_init(&dev->mutex, NULL)) != 0) {
208 dev->dev_errno = errstat;
209 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
210 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
212 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
214 dev->dev_errno = errstat;
215 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
216 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
218 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
220 dev->dev_errno = errstat;
221 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
222 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
224 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
226 dev->dev_errno = errstat;
227 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
228 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
230 if ((errstat = rwl_init(&dev->lock)) != 0) {
232 dev->dev_errno = errstat;
233 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
234 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
238 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
239 Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
245 * Open the device with the operating system and
246 * initialize buffer pointers.
248 * Returns: -1 on error
251 * Note, for a tape, the VolName is the name we give to the
252 * volume (not really used here), but for a file, the
253 * VolName represents the name of the file to be created/opened.
254 * In the case of a file, the full name is the device name
255 * (archive_name) with the VolName concatenated.
258 DEVICE::open(DCR *dcr, int omode)
262 if (openmode == omode) {
265 ::close(fd); /* use system close so correct mode will be used on open */
267 Dmsg0(100, "Close fd for mode change.\n");
268 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
272 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
275 Dmsg4(29, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
276 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
277 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
278 label_type = B_BACULA_LABEL;
279 if (is_tape() || is_fifo()) {
280 open_tape_device(dcr, omode);
281 } else if (is_dvd()) {
282 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
283 open_dvd_device(dcr, omode);
285 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
286 open_file_device(dcr, omode);
288 state |= preserve; /* reset any important state info */
290 Dmsg1(000, "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_tape() && 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);
411 * Handle opening of File Archive (not a tape)
414 if (VolCatInfo.VolCatName[0] == 0) {
415 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
421 pm_strcpy(archive_name, dev_name);
422 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
423 pm_strcat(archive_name, "/");
425 pm_strcat(archive_name, VolCatInfo.VolCatName);
427 mount(1); /* do mount if required */
431 /* If creating file, give 0640 permissions */
432 Dmsg3(29, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
433 archive_name.c_str(), mode);
434 /* Use system open() */
435 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
438 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
440 Dmsg1(29, "open failed: %s", errmsg);
441 Emsg0(M_FATAL, 0, errmsg);
444 update_pos_dev(this); /* update position */
446 Dmsg4(29, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
447 fd, part, num_parts, part_size);
451 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
452 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
453 * has the desired Volume name, but there is NO assurance that
454 * any other field of VolCatInfo is correct.
456 void DEVICE::open_dvd_device(DCR *dcr, int omode)
458 POOL_MEM archive_name(PM_FNAME);
459 struct stat filestat;
462 * Handle opening of DVD Volume
464 Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
465 archive_name.c_str(), mode_to_str(omode));
467 if (VolCatInfo.VolCatName[0] == 0) {
468 Dmsg1(10, "Could not open file device %s. No Volume name given.\n",
470 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
481 Dmsg2(99, "open_dvd_device: num_parts=%d, VolCatInfo.VolCatParts=%d\n",
482 dcr->dev->num_parts, dcr->VolCatInfo.VolCatParts);
483 if (dcr->dev->num_parts < dcr->VolCatInfo.VolCatParts) {
484 Dmsg2(99, "open_dvd_device: num_parts updated to %d (was %d)\n",
485 dcr->VolCatInfo.VolCatParts, dcr->dev->num_parts);
486 dcr->dev->num_parts = dcr->VolCatInfo.VolCatParts;
489 if (mount_dvd(this, 1)) {
490 if ((num_parts == 0) && (!truncating)) {
491 /* If we can mount the device, and we are not truncating the DVD, we usually want to abort. */
492 /* There is one exception, if there is only one 0-sized file on the DVD, with the right volume name,
493 * we continue (it's the method used by truncate_dvd to truncate a volume). */
494 if (!check_can_write_on_non_blank_dvd(dcr)) {
495 Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
496 Emsg0(M_FATAL, 0, errmsg);
497 unmount_dvd(this, 1); /* Unmount the device, so the operator can change it. */
503 /* We cannot mount the device */
504 if (num_parts == 0) {
505 /* Run free space, check there is a media. */
506 update_free_space_dev(this);
508 Dmsg1(29, "Could not mount device %s, this is not a problem (num_parts == 0), and have media.\n", print_name());
511 Mmsg(errmsg, _("There is no valid media in the device %s.\n"), print_name());
512 Emsg0(M_FATAL, 0, errmsg);
518 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
519 Emsg0(M_FATAL, 0, errmsg);
525 Dmsg6(29, "open dev: %s dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
526 is_dvd()?"DVD":"disk", archive_name.c_str(), mode_to_str(omode),
527 part, num_parts, dcr->VolCatInfo.VolCatParts);
529 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
532 * If we are not trying to access the last part, set mode to
533 * OPEN_READ_ONLY as writing would be an error.
535 if (part < num_parts) {
536 omode = OPEN_READ_ONLY;
537 make_mounted_dvd_filename(this, archive_name);
540 make_spooled_dvd_filename(this, archive_name);
544 /* If creating file, give 0640 permissions */
545 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
546 archive_name.c_str(), mode);
547 /* Use system open() */
548 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
550 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
552 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
553 Dmsg1(29, "open failed: %s", errmsg);
555 if ((omode == OPEN_READ_ONLY) && (part == num_parts)) {
556 /* If the last part (on spool), doesn't exists when reading, create it and read from it
557 * (it will report immediately an EOF):
558 * Sometimes it is better to finish with an EOF than with an error. */
559 set_mode(OPEN_READ_WRITE);
560 fd = ::open(archive_name.c_str(), mode, 0640);
561 set_mode(OPEN_READ_ONLY);
564 /* We don't need it. Only the last part is on spool */
565 /*if (omode == OPEN_READ_ONLY) {
566 make_spooled_dvd_filename(this, archive_name);
567 fd = ::open(archive_name.c_str(), mode, 0640); // try on spool
570 Dmsg1(100, "after open fd=%d\n", fd);
572 /* Get size of file */
573 if (fstat(fd, &filestat) < 0) {
576 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
578 Dmsg1(29, "open failed: %s", errmsg);
579 /* Use system close() */
583 part_size = filestat.st_size;
585 update_pos_dev(this); /* update position */
587 /* NB: It seems this code is wrong... part number is incremented in open_next_part, not here */
589 /* Check if just created Volume part */
590 /* if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
593 VolCatInfo.VolCatParts = num_parts;
595 if (part == 0) { // we must have opened the first part
606 * Returns: true on success
609 bool DEVICE::rewind(DCR *dcr)
615 Dmsg3(29, "rewind res=%d fd=%d %s\n", reserved_device, fd, print_name());
617 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
619 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
621 Emsg0(M_ABORT, 0, errmsg);
625 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
626 block_num = file = 0;
630 mt_com.mt_op = MTREW;
632 /* If we get an I/O error on rewind, it is probably because
633 * the drive is actually busy. We loop for (about 5 minutes)
634 * retrying every 5 seconds.
636 for (i=max_rewind_wait; ; i -= 5) {
637 if (ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
639 clrerror_dev(this, MTREW);
640 if (i == max_rewind_wait) {
641 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
644 * This is a gross hack, because if the user has the
645 * device mounted (i.e. open), then uses mtx to load
646 * a tape, the current open file descriptor is invalid.
647 * So, we close the drive and re-open it.
650 int open_mode = openmode;
653 open(dcr, open_mode);
660 if (dev_errno == EIO && i > 0) {
661 Dmsg0(200, "Sleeping 5 seconds.\n");
665 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
666 print_name(), be.strerror());
671 } else if (is_file()) {
672 if (lseek_dev(this, (off_t)0, SEEK_SET) < 0) {
675 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
676 print_name(), be.strerror());
683 void DEVICE::block(int why)
686 block_device(this, why);
690 void DEVICE::unblock()
693 unblock_device(this);
697 const char *DEVICE::print_blocked() const
699 switch (dev_blocked) {
700 case BST_NOT_BLOCKED:
701 return "BST_NOT_BLOCKED";
703 return "BST_UNMOUNTED";
704 case BST_WAITING_FOR_SYSOP:
705 return "BST_WAITING_FOR_SYSOP";
706 case BST_DOING_ACQUIRE:
707 return "BST_DOING_ACQUIRE";
708 case BST_WRITING_LABEL:
709 return "BST_WRITING_LABEL";
710 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
711 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
715 return _("unknown blocked code");
720 * Called to indicate that we have just read an
721 * EOF from the device.
723 void DEVICE::set_ateof()
735 * Called to indicate we are now at the end of the tape, and
736 * writing is not possible.
738 void DEVICE::set_ateot()
740 /* Make tape effectively read-only */
741 state |= (ST_EOF|ST_EOT|ST_WEOT);
746 * Position device to end of medium (end of data)
747 * Returns: true on succes
753 struct mtget mt_stat;
759 Mmsg1(errmsg, _("Bad call to eod_dev. Device %s not open\n"), print_name());
763 #if defined (__digital__) && defined (__unix__)
764 return fsf(VolCatInfo.VolCatFiles);
767 Dmsg0(29, "eod_dev\n");
771 state &= ~(ST_EOF); /* remove EOF flags */
772 block_num = file = 0;
775 if (is_fifo() || is_prog()) {
779 pos = lseek_dev(this, (off_t)0, SEEK_END);
780 // Dmsg1(100, "====== Seek to %lld\n", pos);
782 update_pos_dev(this);
788 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
789 print_name(), be.strerror());
793 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
794 Dmsg0(100,"Using FAST FSF for EOM\n");
795 /* If unknown position, rewind */
796 if (!dev_get_os_pos(this, &mt_stat)) {
801 mt_com.mt_op = MTFSF;
803 * ***FIXME*** fix code to handle case that INT16_MAX is
806 mt_com.mt_count = INT16_MAX; /* use big positive number */
807 if (mt_com.mt_count < 0) {
808 mt_com.mt_count = INT16_MAX; /* brain damaged system */
812 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
813 if (has_cap(CAP_EOM)) {
814 Dmsg0(100,"Using EOM for EOM\n");
815 mt_com.mt_op = MTEOM;
819 if (ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
821 clrerror_dev(this, mt_com.mt_op);
822 Dmsg1(50, "ioctl error: %s\n", be.strerror());
823 update_pos_dev(this);
824 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
825 print_name(), be.strerror());
829 if (!dev_get_os_pos(this, &mt_stat)) {
831 clrerror_dev(this, -1);
832 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
833 print_name(), be.strerror());
836 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
838 file = mt_stat.mt_fileno;
844 * Rewind then use FSF until EOT reached
850 * Move file by file to the end of the tape
853 for (file_num=file; !at_eot(); file_num++) {
854 Dmsg0(200, "eod_dev: doing fsf 1\n");
856 Dmsg0(200, "fsf error.\n");
860 * Avoid infinite loop by ensuring we advance.
862 if (file_num == (int)file) {
863 struct mtget mt_stat;
864 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
866 if (dev_get_os_pos(this, &mt_stat)) {
867 Dmsg2(100, "Adjust file from %d to %d\n", file , mt_stat.mt_fileno);
868 file = mt_stat.mt_fileno;
875 * Some drivers leave us after second EOF when doing
876 * MTEOM, so we must backup so that appending overwrites
879 if (has_cap(CAP_BSFATEOM)) {
880 struct mtget mt_stat;
881 /* Backup over EOF */
883 /* If BSF worked and fileno is known (not -1), set file */
884 if (dev_get_os_pos(this, &mt_stat)) {
885 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , mt_stat.mt_fileno);
886 file = mt_stat.mt_fileno;
888 file++; /* wing it -- not correct on all OSes */
891 update_pos_dev(this); /* update position */
893 Dmsg1(200, "EOD dev->file=%d\n", file);
898 * Set the position of the device -- only for files and DVD
899 * For other devices, there is no generic way to do it.
900 * Returns: true on succes
903 bool update_pos_dev(DEVICE *dev)
909 dev->dev_errno = EBADF;
910 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
911 Emsg0(M_FATAL, 0, dev->errmsg);
915 /* Find out where we are */
916 if (dev->is_file()) {
919 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
922 dev->dev_errno = errno;
923 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
924 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
925 dev->print_name(), be.strerror());
928 dev->file_addr = pos;
936 * Return the status of the device. This was meant
937 * to be a generic routine. Unfortunately, it doesn't
938 * seem possible (at least I do not know how to do it
939 * currently), which means that for the moment, this
940 * routine has very little value.
944 uint32_t status_dev(DEVICE *dev)
946 struct mtget mt_stat;
949 if (dev->state & (ST_EOT | ST_WEOT)) {
953 if (dev->state & ST_EOF) {
957 if (dev->is_tape()) {
959 Pmsg0(-20,_(" Bacula status:"));
960 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
961 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
963 dev->dev_errno = errno;
964 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
965 dev->print_name(), be.strerror());
968 Pmsg0(-20, _(" Device status:"));
970 #if defined(HAVE_LINUX_OS)
971 if (GMT_EOF(mt_stat.mt_gstat)) {
975 if (GMT_BOT(mt_stat.mt_gstat)) {
979 if (GMT_EOT(mt_stat.mt_gstat)) {
983 if (GMT_SM(mt_stat.mt_gstat)) {
987 if (GMT_EOD(mt_stat.mt_gstat)) {
991 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
993 Pmsg0(-20, " WR_PROT");
995 if (GMT_ONLINE(mt_stat.mt_gstat)) {
997 Pmsg0(-20, " ONLINE");
999 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1000 stat |= BMT_DR_OPEN;
1001 Pmsg0(-20, " DR_OPEN");
1003 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1004 stat |= BMT_IM_REP_EN;
1005 Pmsg0(-20, " IM_REP_EN");
1007 #endif /* !SunOS && !OSF */
1008 if (dev->has_cap(CAP_MTIOCGET)) {
1009 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1011 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1014 stat |= BMT_ONLINE | BMT_BOT;
1021 * Load medium in device
1022 * Returns: true on success
1025 bool load_dev(DEVICE *dev)
1032 dev->dev_errno = EBADF;
1033 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1034 Emsg0(M_FATAL, 0, dev->errmsg);
1037 if (!(dev->is_tape())) {
1041 Dmsg0(200, "stored: MTLOAD command not available\n");
1043 dev->dev_errno = ENOTTY; /* function not available */
1044 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1045 dev->print_name(), be.strerror());
1049 dev->block_num = dev->file = 0;
1052 mt_com.mt_op = MTLOAD;
1053 mt_com.mt_count = 1;
1054 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1056 dev->dev_errno = errno;
1057 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1058 dev->print_name(), be.strerror());
1066 * Rewind device and put it offline
1067 * Returns: true on success
1070 bool DEVICE::offline()
1075 return true; /* device not open */
1078 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1079 block_num = file = 0;
1084 mt_com.mt_op = MTUNLOCK;
1085 mt_com.mt_count = 1;
1086 ioctl(fd, MTIOCTOP, (char *)&mt_com);
1088 mt_com.mt_op = MTOFFL;
1089 mt_com.mt_count = 1;
1090 if (ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
1093 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1094 print_name(), be.strerror());
1097 Dmsg1(100, "Offlined device %s\n", print_name());
1101 bool DEVICE::offline_or_rewind()
1106 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1110 * Note, this rewind probably should not be here (it wasn't
1111 * in prior versions of Bacula), but on FreeBSD, this is
1112 * needed in the case the tape was "frozen" due to an error
1113 * such as backspacing after writing and EOF. If it is not
1114 * done, all future references to the drive get and I/O error.
1116 clrerror_dev(this, MTREW);
1117 return rewind(NULL);
1122 * Foward space a file
1123 * Returns: true on success
1126 bool DEVICE::fsf(int num)
1128 struct mtget mt_stat;
1134 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1135 Emsg0(M_FATAL, 0, errmsg);
1144 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1148 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1151 Dmsg0(100, "fsf\n");
1154 * If Fast forward space file is set, then we
1155 * use MTFSF to forward space and MTIOCGET
1156 * to get the file position. We assume that
1157 * the SCSI driver will ensure that we do not
1158 * forward space past the end of the medium.
1160 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1161 mt_com.mt_op = MTFSF;
1162 mt_com.mt_count = num;
1163 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1164 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1167 Dmsg0(200, "Set ST_EOT\n");
1168 clrerror_dev(this, MTFSF);
1169 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1170 print_name(), be.strerror());
1171 Dmsg1(200, "%s", errmsg);
1174 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1176 file = mt_stat.mt_fileno;
1180 * Here if CAP_FSF is set, and virtually all drives
1181 * these days support it, we read a record, then forward
1182 * space one file. Using this procedure, which is slow,
1183 * is the only way we can be sure that we don't read
1184 * two consecutive EOF marks, which means End of Data.
1186 } else if (has_cap(CAP_FSF)) {
1189 Dmsg0(200, "FSF has cap_fsf\n");
1190 if (max_block_size == 0) {
1191 rbuf_len = DEFAULT_BLOCK_SIZE;
1193 rbuf_len = max_block_size;
1195 rbuf = get_memory(rbuf_len);
1196 mt_com.mt_op = MTFSF;
1197 mt_com.mt_count = 1;
1198 while (num-- && !at_eot()) {
1199 Dmsg0(100, "Doing read before fsf\n");
1200 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1201 if (errno == ENOMEM) { /* tape record exceeds buf len */
1202 stat = rbuf_len; /* This is OK */
1204 * On IBM drives, they return ENOSPC at EOM
1205 * instead of EOF status
1207 } else if (at_eof() && errno == ENOSPC) {
1212 clrerror_dev(this, -1);
1213 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1215 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1216 print_name(), be.strerror());
1217 Dmsg1(100, "%s", errmsg);
1221 if (stat == 0) { /* EOF */
1222 update_pos_dev(this);
1223 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1224 /* Two reads of zero means end of tape */
1227 Dmsg0(100, "Set ST_EOT\n");
1233 } else { /* Got data */
1238 Dmsg0(100, "Doing MTFSF\n");
1239 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1240 if (stat < 0) { /* error => EOT */
1243 Dmsg0(100, "Set ST_EOT\n");
1244 clrerror_dev(this, MTFSF);
1245 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1246 print_name(), be.strerror());
1247 Dmsg0(100, "Got < 0 for MTFSF\n");
1248 Dmsg1(100, "%s", errmsg);
1256 * No FSF, so use FSR to simulate it
1259 Dmsg0(200, "Doing FSR for FSF\n");
1260 while (num-- && !at_eot()) {
1261 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1265 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1271 update_pos_dev(this);
1272 Dmsg1(200, "Return %d from FSF\n", stat);
1274 Dmsg0(200, "ST_EOF set on exit FSF\n");
1276 Dmsg0(200, "ST_EOT set on exit FSF\n");
1277 Dmsg1(200, "Return from FSF file=%d\n", file);
1282 * Backward space a file
1283 * Returns: false on failure
1286 bool DEVICE::bsf(int num)
1293 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1294 Emsg0(M_FATAL, 0, errmsg);
1299 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1304 state &= ~(ST_EOT|ST_EOF);
1308 mt_com.mt_op = MTBSF;
1309 mt_com.mt_count = num;
1310 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1313 clrerror_dev(this, MTBSF);
1314 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1315 print_name(), be.strerror());
1317 update_pos_dev(this);
1323 * Foward space num records
1324 * Returns: false on failure
1327 bool DEVICE::fsr(int num)
1334 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1335 Emsg0(M_FATAL, 0, errmsg);
1342 if (!has_cap(CAP_FSR)) {
1343 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1347 Dmsg1(29, "fsr %d\n", num);
1348 mt_com.mt_op = MTFSR;
1349 mt_com.mt_count = num;
1350 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1356 struct mtget mt_stat;
1357 clrerror_dev(this, MTFSR);
1358 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1359 if (dev_get_os_pos(this, &mt_stat)) {
1360 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1361 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1362 file = mt_stat.mt_fileno;
1363 block_num = mt_stat.mt_blkno;
1371 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1372 num, print_name(), be.strerror());
1374 update_pos_dev(this);
1379 * Backward space a record
1380 * Returns: false on failure
1384 bsr_dev(DEVICE *dev, int num)
1390 dev->dev_errno = EBADF;
1391 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1392 Emsg0(M_FATAL, 0, dev->errmsg);
1396 if (!dev->is_tape()) {
1400 if (!dev->has_cap(CAP_BSR)) {
1401 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1405 Dmsg0(29, "bsr_dev\n");
1406 dev->block_num -= num;
1407 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1408 mt_com.mt_op = MTBSR;
1409 mt_com.mt_count = num;
1410 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1413 clrerror_dev(dev, MTBSR);
1414 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1415 dev->print_name(), be.strerror());
1417 update_pos_dev(dev);
1422 * Reposition the device to file, block
1423 * Returns: false on failure
1427 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1430 dev->dev_errno = EBADF;
1431 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1432 Emsg0(M_FATAL, 0, dev->errmsg);
1436 if (!dev->is_tape()) {
1437 off_t pos = (((off_t)file)<<32) + (off_t)block;
1438 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1439 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1441 dev->dev_errno = errno;
1442 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1443 dev->print_name(), be.strerror());
1447 dev->block_num = block;
1448 dev->file_addr = pos;
1451 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1452 dev->file, dev->block_num, file, block);
1453 if (file < dev->file) {
1454 Dmsg0(100, "Rewind\n");
1455 if (!dev->rewind(NULL)) {
1459 if (file > dev->file) {
1460 Dmsg1(100, "fsf %d\n", file-dev->file);
1461 if (!dev->fsf(file-dev->file)) {
1462 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1465 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1467 if (block < dev->block_num) {
1468 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1469 Dmsg0(100, "bsf 1\n");
1471 Dmsg0(100, "fsf_dev 1\n");
1473 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1475 if (dev->has_cap(CAP_POSITIONBLOCKS) && block > dev->block_num) {
1476 /* Ignore errors as Bacula can read to the correct block */
1477 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1478 return dev->fsr(block-dev->block_num);
1486 * Write an end of file on the device
1487 * Returns: 0 on success
1488 * non-zero on failure
1491 weof_dev(DEVICE *dev, int num)
1495 Dmsg0(29, "weof_dev\n");
1498 dev->dev_errno = EBADF;
1499 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1500 Emsg0(M_FATAL, 0, dev->errmsg);
1505 if (!dev->is_tape()) {
1508 if (!dev->can_append()) {
1509 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1510 Emsg0(M_FATAL, 0, dev->errmsg);
1514 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1515 mt_com.mt_op = MTWEOF;
1516 mt_com.mt_count = num;
1517 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1524 clrerror_dev(dev, MTWEOF);
1526 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1527 dev->print_name(), be.strerror());
1534 * Return string message with last error in English
1535 * Be careful not to call this routine from within dev.c
1536 * while editing an Mmsg() or you will end up in a recursive
1537 * loop creating a Segmentation Violation.
1540 strerror_dev(DEVICE *dev)
1547 * If implemented in system, clear the tape
1551 clrerror_dev(DEVICE *dev, int func)
1553 const char *msg = NULL;
1554 struct mtget mt_stat;
1557 dev->dev_errno = errno; /* save errno */
1559 dev->VolCatInfo.VolCatErrors++;
1562 if (!dev->is_tape()) {
1565 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1568 Emsg0(M_ABORT, 0, _("Got ENOTTY on read/write!\n"));
1572 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1577 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1582 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1586 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1590 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1594 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1615 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1620 dev->dev_errno = ENOSYS;
1621 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1622 Emsg0(M_ERROR, 0, dev->errmsg);
1625 /* On some systems such as NetBSD, this clears all errors */
1626 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1628 /* Found on Linux */
1632 mt_com.mt_op = MTIOCLRERR;
1633 mt_com.mt_count = 1;
1634 /* Clear any error condition on the tape */
1635 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1636 Dmsg0(200, "Did MTIOCLRERR\n");
1640 /* Typically on FreeBSD */
1643 /* Read and clear SCSI error status */
1644 union mterrstat mt_errstat;
1645 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1646 strerror(dev->dev_errno));
1647 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1651 /* Clear Subsystem Exception OSF1 */
1655 mt_com.mt_op = MTCSE;
1656 mt_com.mt_count = 1;
1657 /* Clear any error condition on the tape */
1658 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1659 Dmsg0(200, "Did MTCSE\n");
1665 * Flush buffer contents
1668 int flush_dev(DEVICE *dev)
1676 void DEVICE::close()
1678 Dmsg1(100, "close_dev %s\n", print_name());
1679 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1685 return; /* already closed */
1688 if (is_dvd() && !unmount_dvd(this, 1)) {
1689 Dmsg1(0, "Cannot unmount device %s.\n", print_name());
1692 /* Remove the last part file if it is empty */
1693 if (num_parts > 0) {
1695 POOL_MEM archive_name(PM_FNAME);
1697 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", VolCatInfo.VolCatName);
1698 make_spooled_dvd_filename(this, archive_name);
1699 /* Check that the part file is empty */
1700 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1701 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1702 unlink(archive_name.c_str());
1706 /* Clean up device packet so it can be reused */
1708 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1709 label_type = B_BACULA_LABEL;
1710 file = block_num = 0;
1717 EndFile = EndBlock = 0;
1718 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1720 memset(&VolHdr, 0, sizeof(VolHdr));
1722 stop_thread_timer(tid);
1730 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1732 Dmsg1(100, "truncate_dev %s\n", print_name());
1734 return true; /* we don't really truncate tapes */
1735 /* maybe we should rewind and write and eof ???? */
1739 return truncate_dvd(dcr);
1742 if (ftruncate(fd, 0) != 0) {
1744 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1745 print_name(), be.strerror());
1751 /* Mount the device.
1752 * If timeout, wait until the mount command returns 0.
1753 * If !timeout, try to mount the device only once.
1755 bool DEVICE::mount(int timeout)
1757 Dmsg0(90, "Enter mount\n");
1760 } else if (requires_mount()) {
1761 return do_mount(1, timeout);
1766 /* Unmount the device
1767 * If timeout, wait until the unmount command returns 0.
1768 * If !timeout, try to unmount the device only once.
1770 bool DEVICE::unmount(int timeout)
1772 Dmsg0(90, "Enter unmount_dvd\n");
1774 return do_mount(0, timeout);
1779 /* (Un)mount the device */
1780 bool DEVICE::do_mount(int mount, int dotimeout)
1782 POOL_MEM ocmd(PM_FNAME);
1785 int status, timeout;
1787 sm_check(__FILE__, __LINE__, false);
1790 Dmsg0(200, "======= mount=1\n");
1793 icmd = device->mount_command;
1795 if (!is_mounted()) {
1796 Dmsg0(200, "======= mount=0\n");
1799 icmd = device->unmount_command;
1802 edit_mount_codes(ocmd, icmd);
1804 Dmsg2(200, "do_mount_dvd: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1807 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1812 results = get_memory(2000);
1814 /* If busy retry each second */
1815 while ((status = run_program_full_output(ocmd.c_str(),
1816 max_open_wait/2, results)) != 0) {
1817 /* Doesn't work with internationalisation (This is not a problem) */
1818 if (fnmatch("*is already mounted on", results, 0) == 0) {
1821 if (timeout-- > 0) {
1822 /* Sometimes the device cannot be mounted because it is already mounted.
1823 * Try to unmount it, then remount it */
1825 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
1831 Dmsg2(40, "Device %s cannot be mounted. ERR=%s\n", print_name(), results);
1832 Mmsg(errmsg, _("Device %s cannot be mounted. ERR=%s\n"),
1833 print_name(), results);
1835 * Now, just to be sure it is not mounted, try to read the
1839 struct dirent *entry, *result;
1843 name_max = pathconf(".", _PC_NAME_MAX);
1844 if (name_max < 1024) {
1848 if (!(dp = opendir(device->mount_point))) {
1851 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
1852 device->mount_point, print_name(), be.strerror());
1856 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
1859 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
1861 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
1862 device->mount_point, print_name());
1865 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
1866 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
1869 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
1875 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
1878 mount = 1; /* If we got more than ., .. and .keep */
1879 break; /* there must be something mounted */
1883 sm_check(__FILE__, __LINE__, false);
1884 free_pool_memory(results);
1885 Dmsg0(200, "============ mount=0\n");
1889 set_mounted(mount); /* set/clear mounted flag */
1890 free_pool_memory(results);
1891 Dmsg1(200, "============ mount=%d\n", mount);
1896 * Edit codes into (Un)MountCommand, Write(First)PartCommand
1898 * %a = archive device name
1899 * %e = erase (set if cannot mount and first part)
1902 * %v = last part name
1904 * omsg = edited output message
1905 * imsg = input string containing edit codes (%x)
1908 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
1914 POOL_MEM archive_name(PM_FNAME);
1916 omsg.c_str()[0] = 0;
1917 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
1918 for (p=imsg; *p; p++) {
1928 if (num_parts == 0) {
1935 bsnprintf(add, sizeof(add), "%d", part);
1939 str = device->mount_point;
1942 make_spooled_dvd_filename(this, archive_name);
1943 str = archive_name.c_str();
1957 Dmsg1(1900, "add_str %s\n", str);
1958 pm_strcat(omsg, (char *)str);
1959 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
1964 /* Return the resource name for the device */
1965 const char *DEVICE::name() const
1967 return device->hdr.name;
1971 dev_vol_name(DEVICE *dev)
1973 return dev->VolCatInfo.VolCatName;
1976 uint32_t dev_block(DEVICE *dev)
1978 update_pos_dev(dev);
1979 return dev->block_num;
1982 uint32_t dev_file(DEVICE *dev)
1984 update_pos_dev(dev);
1989 * Free memory allocated for the device
1992 term_dev(DEVICE *dev)
1995 dev->dev_errno = EBADF;
1996 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1997 Emsg0(M_FATAL, 0, dev->errmsg);
2000 Dmsg1(29, "term_dev: %s\n", dev->print_name());
2002 if (dev->dev_name) {
2003 free_memory(dev->dev_name);
2004 dev->dev_name = NULL;
2006 if (dev->prt_name) {
2007 free_memory(dev->prt_name);
2008 dev->prt_name = NULL;
2011 free_pool_memory(dev->errmsg);
2014 pthread_mutex_destroy(&dev->mutex);
2015 pthread_cond_destroy(&dev->wait);
2016 pthread_cond_destroy(&dev->wait_next_vol);
2017 pthread_mutex_destroy(&dev->spool_mutex);
2018 rwl_destroy(&dev->lock);
2019 if (dev->attached_dcrs) {
2020 delete dev->attached_dcrs;
2021 dev->attached_dcrs = NULL;
2023 if (dev->state & ST_MALLOC) {
2029 * This routine initializes the device wait timers
2031 void init_device_wait_timers(DCR *dcr)
2033 DEVICE *dev = dcr->dev;
2034 JCR *jcr = dcr->jcr;
2036 /* ******FIXME******* put these on config variables */
2037 dev->min_wait = 60 * 60;
2038 dev->max_wait = 24 * 60 * 60;
2039 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2040 dev->wait_sec = dev->min_wait;
2041 dev->rem_wait_sec = dev->wait_sec;
2044 dev->BadVolName[0] = 0;
2046 jcr->min_wait = 60 * 60;
2047 jcr->max_wait = 24 * 60 * 60;
2048 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2049 jcr->wait_sec = jcr->min_wait;
2050 jcr->rem_wait_sec = jcr->wait_sec;
2055 void init_jcr_device_wait_timers(JCR *jcr)
2057 /* ******FIXME******* put these on config variables */
2058 jcr->min_wait = 60 * 60;
2059 jcr->max_wait = 24 * 60 * 60;
2060 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2061 jcr->wait_sec = jcr->min_wait;
2062 jcr->rem_wait_sec = jcr->wait_sec;
2068 * The dev timers are used for waiting on a particular device
2070 * Returns: true if time doubled
2071 * false if max time expired
2073 bool double_dev_wait_time(DEVICE *dev)
2075 dev->wait_sec *= 2; /* double wait time */
2076 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2077 dev->wait_sec = dev->max_wait;
2080 dev->rem_wait_sec = dev->wait_sec;
2081 if (dev->num_wait >= dev->max_num_wait) {
2088 void set_os_device_parameters(DEVICE *dev)
2090 #ifdef HAVE_LINUX_OS
2092 if (dev->min_block_size == dev->max_block_size &&
2093 dev->min_block_size == 0) { /* variable block mode */
2094 mt_com.mt_op = MTSETBLK;
2095 mt_com.mt_count = 0;
2096 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2097 clrerror_dev(dev, MTSETBLK);
2099 mt_com.mt_op = MTSETDRVBUFFER;
2100 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2101 if (!dev->has_cap(CAP_TWOEOF)) {
2102 mt_com.mt_count |= MT_ST_TWO_FM;
2104 if (dev->has_cap(CAP_EOM)) {
2105 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2107 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2108 clrerror_dev(dev, MTSETBLK);
2114 #ifdef HAVE_NETBSD_OS
2116 if (dev->min_block_size == dev->max_block_size &&
2117 dev->min_block_size == 0) { /* variable block mode */
2118 mt_com.mt_op = MTSETBSIZ;
2119 mt_com.mt_count = 0;
2120 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2121 clrerror_dev(dev, MTSETBSIZ);
2123 /* Get notified at logical end of tape */
2124 mt_com.mt_op = MTEWARN;
2125 mt_com.mt_count = 1;
2126 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2127 clrerror_dev(dev, MTEWARN);
2133 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2135 if (dev->min_block_size == dev->max_block_size &&
2136 dev->min_block_size == 0) { /* variable block mode */
2137 mt_com.mt_op = MTSETBSIZ;
2138 mt_com.mt_count = 0;
2139 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2140 clrerror_dev(dev, MTSETBSIZ);
2148 if (dev->min_block_size == dev->max_block_size &&
2149 dev->min_block_size == 0) { /* variable block mode */
2150 mt_com.mt_op = MTSRSZ;
2151 mt_com.mt_count = 0;
2152 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2153 clrerror_dev(dev, MTSRSZ);
2160 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2162 return dev->has_cap(CAP_MTIOCGET) &&
2163 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2164 mt_stat->mt_fileno >= 0;
2167 static char *modes[] = {
2168 "CREATE_READ_WRITE",
2175 static char *mode_to_str(int mode)
2177 return modes[mode-1];