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_autochanger()) {
325 get_autochanger_loaded_slot(dcr);
329 timeout = max_open_wait;
331 if (is_fifo() && timeout) {
333 tid = start_thread_timer(pthread_self(), timeout);
335 /* If busy retry each second for max_open_wait seconds */
336 Dmsg3(100, "Try open %s mode=%s nonblocking=%d\n", print_name(),
337 mode_to_str(omode), nonblocking);
338 /* Use system open() */
339 while ((fd = ::open(dev_name, mode+nonblocking)) < 0) {
342 Dmsg5(050, "Open omode=%d mode=%x nonblock=%d error errno=%d ERR=%s\n",
343 omode, mode, nonblocking, errno, be.strerror());
344 if (dev_errno == EINTR || dev_errno == EAGAIN) {
345 Dmsg0(100, "Continue open\n");
348 /* Busy wait for specified time (default = 5 mins) */
349 if (dev_errno == EBUSY && timeout-- > 0) {
350 Dmsg2(100, "Device %s busy. ERR=%s\n", print_name(), be.strerror());
354 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
355 print_name(), be.strerror(dev_errno));
356 /* Stop any open timer we set */
358 stop_thread_timer(tid);
361 Jmsg0(dcr->jcr, M_FATAL, 0, errmsg);
366 openmode = omode; /* save open mode */
368 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
370 update_pos_dev(this); /* update position */
371 set_os_device_parameters(this); /* do system dependent stuff */
376 /* Stop any open() timer we started */
378 stop_thread_timer(tid);
381 Dmsg1(29, "open dev: tape %d opened\n", fd);
384 void DEVICE::set_blocking()
387 /* Try to reset blocking */
389 if ((oflags = fcntl(fd, F_GETFL, 0)) < 0 ||
390 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK) < 0) {
392 ::close(fd); /* use system close() */
393 fd = ::open(dev_name, mode);
394 Dmsg2(100, "fcntl error. ERR=%s. Close-reopen fd=%d\n", be.strerror(), fd);
397 oflags = fcntl(fd, F_GETFL, 0);
398 if (oflags > 0 && (oflags & O_NONBLOCK)) {
399 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK);
406 void DEVICE::open_file_device(DCR *dcr, int omode)
408 POOL_MEM archive_name(PM_FNAME);
410 if (is_autochanger()) {
411 get_autochanger_loaded_slot(dcr);
415 * Handle opening of File Archive (not a tape)
418 pm_strcpy(archive_name, dev_name);
420 * If this is a virtual autochanger (i.e. changer_res != NULL)
421 * we simply use the deviced name, assuming it has been
422 * appropriately setup by the "autochanger".
424 if (!device->changer_res) {
425 if (VolCatInfo.VolCatName[0] == 0) {
426 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
432 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
433 pm_strcat(archive_name, "/");
435 pm_strcat(archive_name, VolCatInfo.VolCatName);
438 mount(1); /* do mount if required */
442 /* If creating file, give 0640 permissions */
443 Dmsg3(29, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
444 archive_name.c_str(), mode);
445 /* Use system open() */
446 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
449 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
451 Dmsg1(29, "open failed: %s", errmsg);
452 Emsg0(M_FATAL, 0, errmsg);
455 update_pos_dev(this); /* update position */
457 Dmsg4(29, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
458 fd, part, num_parts, part_size);
462 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
463 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
464 * has the desired Volume name, but there is NO assurance that
465 * any other field of VolCatInfo is correct.
467 void DEVICE::open_dvd_device(DCR *dcr, int omode)
469 POOL_MEM archive_name(PM_FNAME);
470 struct stat filestat;
473 * Handle opening of DVD Volume
475 Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
476 archive_name.c_str(), mode_to_str(omode));
478 if (VolCatInfo.VolCatName[0] == 0) {
479 Dmsg1(10, "Could not open file device %s. No Volume name given.\n",
481 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
492 Dmsg2(99, "open_dvd_device: num_parts=%d, VolCatInfo.VolCatParts=%d\n",
493 dcr->dev->num_parts, dcr->VolCatInfo.VolCatParts);
494 if (dcr->dev->num_parts < dcr->VolCatInfo.VolCatParts) {
495 Dmsg2(99, "open_dvd_device: num_parts updated to %d (was %d)\n",
496 dcr->VolCatInfo.VolCatParts, dcr->dev->num_parts);
497 dcr->dev->num_parts = dcr->VolCatInfo.VolCatParts;
500 if (mount_dvd(this, 1)) {
501 if ((num_parts == 0) && (!truncating)) {
502 /* If we can mount the device, and we are not truncating the DVD, we usually want to abort. */
503 /* There is one exception, if there is only one 0-sized file on the DVD, with the right volume name,
504 * we continue (it's the method used by truncate_dvd to truncate a volume). */
505 if (!check_can_write_on_non_blank_dvd(dcr)) {
506 Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
507 Emsg0(M_FATAL, 0, errmsg);
508 unmount_dvd(this, 1); /* Unmount the device, so the operator can change it. */
514 /* We cannot mount the device */
515 if (num_parts == 0) {
516 /* Run free space, check there is a media. */
517 update_free_space_dev(this);
519 Dmsg1(29, "Could not mount device %s, this is not a problem (num_parts == 0), and have media.\n", print_name());
522 Mmsg(errmsg, _("There is no valid media in the device %s.\n"), print_name());
523 Emsg0(M_FATAL, 0, errmsg);
529 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
530 Emsg0(M_FATAL, 0, errmsg);
536 Dmsg6(29, "open dev: %s dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
537 is_dvd()?"DVD":"disk", archive_name.c_str(), mode_to_str(omode),
538 part, num_parts, dcr->VolCatInfo.VolCatParts);
540 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
543 * If we are not trying to access the last part, set mode to
544 * OPEN_READ_ONLY as writing would be an error.
546 if (part < num_parts) {
547 omode = OPEN_READ_ONLY;
548 make_mounted_dvd_filename(this, archive_name);
551 make_spooled_dvd_filename(this, archive_name);
555 /* If creating file, give 0640 permissions */
556 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
557 archive_name.c_str(), mode);
558 /* Use system open() */
559 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
561 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
563 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
564 Dmsg1(29, "open failed: %s", errmsg);
566 if ((omode == OPEN_READ_ONLY) && (part == num_parts)) {
567 /* If the last part (on spool), doesn't exists when reading, create it and read from it
568 * (it will report immediately an EOF):
569 * Sometimes it is better to finish with an EOF than with an error. */
570 set_mode(OPEN_READ_WRITE);
571 fd = ::open(archive_name.c_str(), mode, 0640);
572 set_mode(OPEN_READ_ONLY);
575 /* We don't need it. Only the last part is on spool */
576 /*if (omode == OPEN_READ_ONLY) {
577 make_spooled_dvd_filename(this, archive_name);
578 fd = ::open(archive_name.c_str(), mode, 0640); // try on spool
581 Dmsg1(100, "after open fd=%d\n", fd);
583 /* Get size of file */
584 if (fstat(fd, &filestat) < 0) {
587 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
589 Dmsg1(29, "open failed: %s", errmsg);
590 /* Use system close() */
594 part_size = filestat.st_size;
596 update_pos_dev(this); /* update position */
598 /* NB: It seems this code is wrong... part number is incremented in open_next_part, not here */
600 /* Check if just created Volume part */
601 /* if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
604 VolCatInfo.VolCatParts = num_parts;
606 if (part == 0) { // we must have opened the first part
617 * Returns: true on success
620 bool DEVICE::rewind(DCR *dcr)
626 Dmsg3(400, "rewind res=%d fd=%d %s\n", reserved_device, fd, print_name());
628 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
630 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
632 Emsg0(M_ABORT, 0, errmsg);
636 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
637 block_num = file = 0;
641 mt_com.mt_op = MTREW;
643 /* If we get an I/O error on rewind, it is probably because
644 * the drive is actually busy. We loop for (about 5 minutes)
645 * retrying every 5 seconds.
647 for (i=max_rewind_wait; ; i -= 5) {
648 if (ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
650 clrerror_dev(this, MTREW);
651 if (i == max_rewind_wait) {
652 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
655 * This is a gross hack, because if the user has the
656 * device mounted (i.e. open), then uses mtx to load
657 * a tape, the current open file descriptor is invalid.
658 * So, we close the drive and re-open it.
661 int open_mode = openmode;
664 open(dcr, open_mode);
671 if (dev_errno == EIO && i > 0) {
672 Dmsg0(200, "Sleeping 5 seconds.\n");
676 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
677 print_name(), be.strerror());
682 } else if (is_file()) {
683 if (lseek_dev(this, (off_t)0, SEEK_SET) < 0) {
686 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
687 print_name(), be.strerror());
694 void DEVICE::block(int why)
697 block_device(this, why);
701 void DEVICE::unblock()
704 unblock_device(this);
708 const char *DEVICE::print_blocked() const
710 switch (dev_blocked) {
711 case BST_NOT_BLOCKED:
712 return "BST_NOT_BLOCKED";
714 return "BST_UNMOUNTED";
715 case BST_WAITING_FOR_SYSOP:
716 return "BST_WAITING_FOR_SYSOP";
717 case BST_DOING_ACQUIRE:
718 return "BST_DOING_ACQUIRE";
719 case BST_WRITING_LABEL:
720 return "BST_WRITING_LABEL";
721 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
722 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
726 return _("unknown blocked code");
731 * Called to indicate that we have just read an
732 * EOF from the device.
734 void DEVICE::set_ateof()
746 * Called to indicate we are now at the end of the tape, and
747 * writing is not possible.
749 void DEVICE::set_ateot()
751 /* Make tape effectively read-only */
752 state |= (ST_EOF|ST_EOT|ST_WEOT);
757 * Position device to end of medium (end of data)
758 * Returns: true on succes
764 struct mtget mt_stat;
770 Mmsg1(errmsg, _("Bad call to eod_dev. Device %s not open\n"), print_name());
774 #if defined (__digital__) && defined (__unix__)
775 return fsf(VolCatInfo.VolCatFiles);
778 Dmsg0(29, "eod_dev\n");
782 state &= ~(ST_EOF); /* remove EOF flags */
783 block_num = file = 0;
786 if (is_fifo() || is_prog()) {
790 pos = lseek_dev(this, (off_t)0, SEEK_END);
791 // Dmsg1(100, "====== Seek to %lld\n", pos);
793 update_pos_dev(this);
799 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
800 print_name(), be.strerror());
804 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
805 Dmsg0(100,"Using FAST FSF for EOM\n");
806 /* If unknown position, rewind */
807 if (!dev_get_os_pos(this, &mt_stat)) {
812 mt_com.mt_op = MTFSF;
814 * ***FIXME*** fix code to handle case that INT16_MAX is
817 mt_com.mt_count = INT16_MAX; /* use big positive number */
818 if (mt_com.mt_count < 0) {
819 mt_com.mt_count = INT16_MAX; /* brain damaged system */
823 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
824 if (has_cap(CAP_EOM)) {
825 Dmsg0(100,"Using EOM for EOM\n");
826 mt_com.mt_op = MTEOM;
830 if (ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
832 clrerror_dev(this, mt_com.mt_op);
833 Dmsg1(50, "ioctl error: %s\n", be.strerror());
834 update_pos_dev(this);
835 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
836 print_name(), be.strerror());
840 if (!dev_get_os_pos(this, &mt_stat)) {
842 clrerror_dev(this, -1);
843 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
844 print_name(), be.strerror());
847 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
849 file = mt_stat.mt_fileno;
855 * Rewind then use FSF until EOT reached
861 * Move file by file to the end of the tape
864 for (file_num=file; !at_eot(); file_num++) {
865 Dmsg0(200, "eod_dev: doing fsf 1\n");
867 Dmsg0(200, "fsf error.\n");
871 * Avoid infinite loop by ensuring we advance.
873 if (file_num == (int)file) {
874 struct mtget mt_stat;
875 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
877 if (dev_get_os_pos(this, &mt_stat)) {
878 Dmsg2(100, "Adjust file from %d to %d\n", file , mt_stat.mt_fileno);
879 file = mt_stat.mt_fileno;
886 * Some drivers leave us after second EOF when doing
887 * MTEOM, so we must backup so that appending overwrites
890 if (has_cap(CAP_BSFATEOM)) {
891 struct mtget mt_stat;
892 /* Backup over EOF */
894 /* If BSF worked and fileno is known (not -1), set file */
895 if (dev_get_os_pos(this, &mt_stat)) {
896 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , mt_stat.mt_fileno);
897 file = mt_stat.mt_fileno;
899 file++; /* wing it -- not correct on all OSes */
902 update_pos_dev(this); /* update position */
904 Dmsg1(200, "EOD dev->file=%d\n", file);
909 * Set the position of the device -- only for files and DVD
910 * For other devices, there is no generic way to do it.
911 * Returns: true on succes
914 bool update_pos_dev(DEVICE *dev)
920 dev->dev_errno = EBADF;
921 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
922 Emsg0(M_FATAL, 0, dev->errmsg);
926 /* Find out where we are */
927 if (dev->is_file()) {
930 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
933 dev->dev_errno = errno;
934 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
935 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
936 dev->print_name(), be.strerror());
939 dev->file_addr = pos;
947 * Return the status of the device. This was meant
948 * to be a generic routine. Unfortunately, it doesn't
949 * seem possible (at least I do not know how to do it
950 * currently), which means that for the moment, this
951 * routine has very little value.
955 uint32_t status_dev(DEVICE *dev)
957 struct mtget mt_stat;
960 if (dev->state & (ST_EOT | ST_WEOT)) {
964 if (dev->state & ST_EOF) {
968 if (dev->is_tape()) {
970 Pmsg0(-20,_(" Bacula status:"));
971 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
972 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
974 dev->dev_errno = errno;
975 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
976 dev->print_name(), be.strerror());
979 Pmsg0(-20, _(" Device status:"));
981 #if defined(HAVE_LINUX_OS)
982 if (GMT_EOF(mt_stat.mt_gstat)) {
986 if (GMT_BOT(mt_stat.mt_gstat)) {
990 if (GMT_EOT(mt_stat.mt_gstat)) {
994 if (GMT_SM(mt_stat.mt_gstat)) {
998 if (GMT_EOD(mt_stat.mt_gstat)) {
1002 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1003 stat |= BMT_WR_PROT;
1004 Pmsg0(-20, " WR_PROT");
1006 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1008 Pmsg0(-20, " ONLINE");
1010 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1011 stat |= BMT_DR_OPEN;
1012 Pmsg0(-20, " DR_OPEN");
1014 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1015 stat |= BMT_IM_REP_EN;
1016 Pmsg0(-20, " IM_REP_EN");
1018 #endif /* !SunOS && !OSF */
1019 if (dev->has_cap(CAP_MTIOCGET)) {
1020 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1022 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1025 stat |= BMT_ONLINE | BMT_BOT;
1032 * Load medium in device
1033 * Returns: true on success
1036 bool load_dev(DEVICE *dev)
1043 dev->dev_errno = EBADF;
1044 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1045 Emsg0(M_FATAL, 0, dev->errmsg);
1048 if (!(dev->is_tape())) {
1052 Dmsg0(200, "stored: MTLOAD command not available\n");
1054 dev->dev_errno = ENOTTY; /* function not available */
1055 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1056 dev->print_name(), be.strerror());
1060 dev->block_num = dev->file = 0;
1063 mt_com.mt_op = MTLOAD;
1064 mt_com.mt_count = 1;
1065 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1067 dev->dev_errno = errno;
1068 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1069 dev->print_name(), be.strerror());
1077 * Rewind device and put it offline
1078 * Returns: true on success
1081 bool DEVICE::offline()
1086 return true; /* device not open */
1089 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1090 block_num = file = 0;
1095 mt_com.mt_op = MTUNLOCK;
1096 mt_com.mt_count = 1;
1097 ioctl(fd, MTIOCTOP, (char *)&mt_com);
1099 mt_com.mt_op = MTOFFL;
1100 mt_com.mt_count = 1;
1101 if (ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
1104 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1105 print_name(), be.strerror());
1108 Dmsg1(100, "Offlined device %s\n", print_name());
1112 bool DEVICE::offline_or_rewind()
1117 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1121 * Note, this rewind probably should not be here (it wasn't
1122 * in prior versions of Bacula), but on FreeBSD, this is
1123 * needed in the case the tape was "frozen" due to an error
1124 * such as backspacing after writing and EOF. If it is not
1125 * done, all future references to the drive get and I/O error.
1127 clrerror_dev(this, MTREW);
1128 return rewind(NULL);
1133 * Foward space a file
1134 * Returns: true on success
1137 bool DEVICE::fsf(int num)
1139 struct mtget mt_stat;
1145 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1146 Emsg0(M_FATAL, 0, errmsg);
1155 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1159 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1162 Dmsg0(100, "fsf\n");
1165 * If Fast forward space file is set, then we
1166 * use MTFSF to forward space and MTIOCGET
1167 * to get the file position. We assume that
1168 * the SCSI driver will ensure that we do not
1169 * forward space past the end of the medium.
1171 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1172 mt_com.mt_op = MTFSF;
1173 mt_com.mt_count = num;
1174 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1175 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1178 Dmsg0(200, "Set ST_EOT\n");
1179 clrerror_dev(this, MTFSF);
1180 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1181 print_name(), be.strerror());
1182 Dmsg1(200, "%s", errmsg);
1185 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1187 file = mt_stat.mt_fileno;
1191 * Here if CAP_FSF is set, and virtually all drives
1192 * these days support it, we read a record, then forward
1193 * space one file. Using this procedure, which is slow,
1194 * is the only way we can be sure that we don't read
1195 * two consecutive EOF marks, which means End of Data.
1197 } else if (has_cap(CAP_FSF)) {
1200 Dmsg0(200, "FSF has cap_fsf\n");
1201 if (max_block_size == 0) {
1202 rbuf_len = DEFAULT_BLOCK_SIZE;
1204 rbuf_len = max_block_size;
1206 rbuf = get_memory(rbuf_len);
1207 mt_com.mt_op = MTFSF;
1208 mt_com.mt_count = 1;
1209 while (num-- && !at_eot()) {
1210 Dmsg0(100, "Doing read before fsf\n");
1211 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1212 if (errno == ENOMEM) { /* tape record exceeds buf len */
1213 stat = rbuf_len; /* This is OK */
1215 * On IBM drives, they return ENOSPC at EOM
1216 * instead of EOF status
1218 } else if (at_eof() && errno == ENOSPC) {
1223 clrerror_dev(this, -1);
1224 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1226 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1227 print_name(), be.strerror());
1228 Dmsg1(100, "%s", errmsg);
1232 if (stat == 0) { /* EOF */
1233 update_pos_dev(this);
1234 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1235 /* Two reads of zero means end of tape */
1238 Dmsg0(100, "Set ST_EOT\n");
1244 } else { /* Got data */
1249 Dmsg0(100, "Doing MTFSF\n");
1250 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1251 if (stat < 0) { /* error => EOT */
1254 Dmsg0(100, "Set ST_EOT\n");
1255 clrerror_dev(this, MTFSF);
1256 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1257 print_name(), be.strerror());
1258 Dmsg0(100, "Got < 0 for MTFSF\n");
1259 Dmsg1(100, "%s", errmsg);
1267 * No FSF, so use FSR to simulate it
1270 Dmsg0(200, "Doing FSR for FSF\n");
1271 while (num-- && !at_eot()) {
1272 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1276 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1282 update_pos_dev(this);
1283 Dmsg1(200, "Return %d from FSF\n", stat);
1285 Dmsg0(200, "ST_EOF set on exit FSF\n");
1287 Dmsg0(200, "ST_EOT set on exit FSF\n");
1288 Dmsg1(200, "Return from FSF file=%d\n", file);
1293 * Backward space a file
1294 * Returns: false on failure
1297 bool DEVICE::bsf(int num)
1304 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1305 Emsg0(M_FATAL, 0, errmsg);
1310 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1315 state &= ~(ST_EOT|ST_EOF);
1319 mt_com.mt_op = MTBSF;
1320 mt_com.mt_count = num;
1321 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1324 clrerror_dev(this, MTBSF);
1325 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1326 print_name(), be.strerror());
1328 update_pos_dev(this);
1334 * Foward space num records
1335 * Returns: false on failure
1338 bool DEVICE::fsr(int num)
1345 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1346 Emsg0(M_FATAL, 0, errmsg);
1353 if (!has_cap(CAP_FSR)) {
1354 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1358 Dmsg1(29, "fsr %d\n", num);
1359 mt_com.mt_op = MTFSR;
1360 mt_com.mt_count = num;
1361 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1367 struct mtget mt_stat;
1368 clrerror_dev(this, MTFSR);
1369 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1370 if (dev_get_os_pos(this, &mt_stat)) {
1371 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1372 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1373 file = mt_stat.mt_fileno;
1374 block_num = mt_stat.mt_blkno;
1382 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1383 num, print_name(), be.strerror());
1385 update_pos_dev(this);
1390 * Backward space a record
1391 * Returns: false on failure
1395 bsr_dev(DEVICE *dev, int num)
1401 dev->dev_errno = EBADF;
1402 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1403 Emsg0(M_FATAL, 0, dev->errmsg);
1407 if (!dev->is_tape()) {
1411 if (!dev->has_cap(CAP_BSR)) {
1412 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1416 Dmsg0(29, "bsr_dev\n");
1417 dev->block_num -= num;
1418 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1419 mt_com.mt_op = MTBSR;
1420 mt_com.mt_count = num;
1421 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1424 clrerror_dev(dev, MTBSR);
1425 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1426 dev->print_name(), be.strerror());
1428 update_pos_dev(dev);
1433 * Reposition the device to file, block
1434 * Returns: false on failure
1438 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1441 dev->dev_errno = EBADF;
1442 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1443 Emsg0(M_FATAL, 0, dev->errmsg);
1447 if (!dev->is_tape()) {
1448 off_t pos = (((off_t)file)<<32) + (off_t)block;
1449 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1450 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1452 dev->dev_errno = errno;
1453 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1454 dev->print_name(), be.strerror());
1458 dev->block_num = block;
1459 dev->file_addr = pos;
1462 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1463 dev->file, dev->block_num, file, block);
1464 if (file < dev->file) {
1465 Dmsg0(100, "Rewind\n");
1466 if (!dev->rewind(NULL)) {
1470 if (file > dev->file) {
1471 Dmsg1(100, "fsf %d\n", file-dev->file);
1472 if (!dev->fsf(file-dev->file)) {
1473 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1476 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1478 if (block < dev->block_num) {
1479 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->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", block, dev->block_num);
1486 if (dev->has_cap(CAP_POSITIONBLOCKS) && block > dev->block_num) {
1487 /* Ignore errors as Bacula can read to the correct block */
1488 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1489 return dev->fsr(block-dev->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());
1545 * Return string message with last error in English
1546 * Be careful not to call this routine from within dev.c
1547 * while editing an Mmsg() or you will end up in a recursive
1548 * loop creating a Segmentation Violation.
1551 strerror_dev(DEVICE *dev)
1558 * If implemented in system, clear the tape
1562 clrerror_dev(DEVICE *dev, int func)
1564 const char *msg = NULL;
1565 struct mtget mt_stat;
1568 dev->dev_errno = errno; /* save errno */
1570 dev->VolCatInfo.VolCatErrors++;
1573 if (!dev->is_tape()) {
1576 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1579 Emsg0(M_ABORT, 0, _("Got ENOTTY on read/write!\n"));
1583 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1588 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1593 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1597 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1601 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1605 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1626 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1631 dev->dev_errno = ENOSYS;
1632 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1633 Emsg0(M_ERROR, 0, dev->errmsg);
1636 /* On some systems such as NetBSD, this clears all errors */
1637 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1639 /* Found on Linux */
1643 mt_com.mt_op = MTIOCLRERR;
1644 mt_com.mt_count = 1;
1645 /* Clear any error condition on the tape */
1646 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1647 Dmsg0(200, "Did MTIOCLRERR\n");
1651 /* Typically on FreeBSD */
1654 /* Read and clear SCSI error status */
1655 union mterrstat mt_errstat;
1656 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1657 strerror(dev->dev_errno));
1658 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1662 /* Clear Subsystem Exception OSF1 */
1666 mt_com.mt_op = MTCSE;
1667 mt_com.mt_count = 1;
1668 /* Clear any error condition on the tape */
1669 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1670 Dmsg0(200, "Did MTCSE\n");
1676 * Flush buffer contents
1679 int flush_dev(DEVICE *dev)
1687 void DEVICE::close()
1689 Dmsg1(100, "close_dev %s\n", print_name());
1690 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1696 return; /* already closed */
1699 if (is_dvd() && !unmount_dvd(this, 1)) {
1700 Dmsg1(0, "Cannot unmount device %s.\n", print_name());
1703 /* Remove the last part file if it is empty */
1704 if (num_parts > 0) {
1706 POOL_MEM archive_name(PM_FNAME);
1708 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", VolCatInfo.VolCatName);
1709 make_spooled_dvd_filename(this, archive_name);
1710 /* Check that the part file is empty */
1711 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1712 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1713 unlink(archive_name.c_str());
1717 /* Clean up device packet so it can be reused */
1719 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1720 label_type = B_BACULA_LABEL;
1721 file = block_num = 0;
1728 EndFile = EndBlock = 0;
1729 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1731 memset(&VolHdr, 0, sizeof(VolHdr));
1733 stop_thread_timer(tid);
1741 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1743 Dmsg1(100, "truncate_dev %s\n", print_name());
1745 return true; /* we don't really truncate tapes */
1746 /* maybe we should rewind and write and eof ???? */
1750 return truncate_dvd(dcr);
1753 if (ftruncate(fd, 0) != 0) {
1755 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1756 print_name(), be.strerror());
1762 /* Mount the device.
1763 * If timeout, wait until the mount command returns 0.
1764 * If !timeout, try to mount the device only once.
1766 bool DEVICE::mount(int timeout)
1768 Dmsg0(90, "Enter mount\n");
1771 } else if (requires_mount()) {
1772 return do_mount(1, timeout);
1777 /* Unmount the device
1778 * If timeout, wait until the unmount command returns 0.
1779 * If !timeout, try to unmount the device only once.
1781 bool DEVICE::unmount(int timeout)
1783 Dmsg0(90, "Enter unmount_dvd\n");
1785 return do_mount(0, timeout);
1790 /* (Un)mount the device */
1791 bool DEVICE::do_mount(int mount, int dotimeout)
1793 POOL_MEM ocmd(PM_FNAME);
1796 int status, timeout;
1798 sm_check(__FILE__, __LINE__, false);
1801 Dmsg0(200, "======= mount=1\n");
1804 icmd = device->mount_command;
1806 if (!is_mounted()) {
1807 Dmsg0(200, "======= mount=0\n");
1810 icmd = device->unmount_command;
1813 edit_mount_codes(ocmd, icmd);
1815 Dmsg2(000, "do_mount_dvd: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1818 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1823 results = get_memory(2000);
1825 /* If busy retry each second */
1826 while ((status = run_program_full_output(ocmd.c_str(),
1827 max_open_wait/2, results)) != 0) {
1828 /* Doesn't work with internationalisation (This is not a problem) */
1829 if (fnmatch("*is already mounted on", results, 0) == 0) {
1832 if (timeout-- > 0) {
1833 /* Sometimes the device cannot be mounted because it is already mounted.
1834 * Try to unmount it, then remount it */
1836 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
1842 Dmsg2(40, "Device %s cannot be mounted. ERR=%s\n", print_name(), results);
1843 Mmsg(errmsg, _("Device %s cannot be mounted. ERR=%s\n"),
1844 print_name(), results);
1846 * Now, just to be sure it is not mounted, try to read the
1850 struct dirent *entry, *result;
1854 name_max = pathconf(".", _PC_NAME_MAX);
1855 if (name_max < 1024) {
1859 if (!(dp = opendir(device->mount_point))) {
1862 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
1863 device->mount_point, print_name(), be.strerror());
1867 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
1870 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
1872 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
1873 device->mount_point, print_name());
1876 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
1877 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
1880 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
1886 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
1889 mount = 1; /* If we got more than ., .. and .keep */
1890 break; /* there must be something mounted */
1894 sm_check(__FILE__, __LINE__, false);
1895 free_pool_memory(results);
1896 Dmsg0(200, "============ mount=0\n");
1900 set_mounted(mount); /* set/clear mounted flag */
1901 free_pool_memory(results);
1902 Dmsg1(200, "============ mount=%d\n", mount);
1907 * Edit codes into (Un)MountCommand, Write(First)PartCommand
1909 * %a = archive device name
1910 * %e = erase (set if cannot mount and first part)
1913 * %v = last part name
1915 * omsg = edited output message
1916 * imsg = input string containing edit codes (%x)
1919 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
1925 POOL_MEM archive_name(PM_FNAME);
1927 omsg.c_str()[0] = 0;
1928 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
1929 for (p=imsg; *p; p++) {
1939 if (num_parts == 0) {
1946 bsnprintf(add, sizeof(add), "%d", part);
1950 str = device->mount_point;
1953 make_spooled_dvd_filename(this, archive_name);
1954 str = archive_name.c_str();
1968 Dmsg1(1900, "add_str %s\n", str);
1969 pm_strcat(omsg, (char *)str);
1970 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
1975 /* Return the resource name for the device */
1976 const char *DEVICE::name() const
1978 return device->hdr.name;
1982 dev_vol_name(DEVICE *dev)
1984 return dev->VolCatInfo.VolCatName;
1987 uint32_t dev_block(DEVICE *dev)
1989 update_pos_dev(dev);
1990 return dev->block_num;
1993 uint32_t dev_file(DEVICE *dev)
1995 update_pos_dev(dev);
2000 * Free memory allocated for the device
2003 term_dev(DEVICE *dev)
2006 dev->dev_errno = EBADF;
2007 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
2008 Emsg0(M_FATAL, 0, dev->errmsg);
2011 Dmsg1(29, "term_dev: %s\n", dev->print_name());
2013 if (dev->dev_name) {
2014 free_memory(dev->dev_name);
2015 dev->dev_name = NULL;
2017 if (dev->prt_name) {
2018 free_memory(dev->prt_name);
2019 dev->prt_name = NULL;
2022 free_pool_memory(dev->errmsg);
2025 pthread_mutex_destroy(&dev->mutex);
2026 pthread_cond_destroy(&dev->wait);
2027 pthread_cond_destroy(&dev->wait_next_vol);
2028 pthread_mutex_destroy(&dev->spool_mutex);
2029 rwl_destroy(&dev->lock);
2030 if (dev->attached_dcrs) {
2031 delete dev->attached_dcrs;
2032 dev->attached_dcrs = NULL;
2034 if (dev->state & ST_MALLOC) {
2040 * This routine initializes the device wait timers
2042 void init_device_wait_timers(DCR *dcr)
2044 DEVICE *dev = dcr->dev;
2045 JCR *jcr = dcr->jcr;
2047 /* ******FIXME******* put these on config variables */
2048 dev->min_wait = 60 * 60;
2049 dev->max_wait = 24 * 60 * 60;
2050 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2051 dev->wait_sec = dev->min_wait;
2052 dev->rem_wait_sec = dev->wait_sec;
2055 dev->BadVolName[0] = 0;
2057 jcr->min_wait = 60 * 60;
2058 jcr->max_wait = 24 * 60 * 60;
2059 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2060 jcr->wait_sec = jcr->min_wait;
2061 jcr->rem_wait_sec = jcr->wait_sec;
2066 void init_jcr_device_wait_timers(JCR *jcr)
2068 /* ******FIXME******* put these on config variables */
2069 jcr->min_wait = 60 * 60;
2070 jcr->max_wait = 24 * 60 * 60;
2071 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2072 jcr->wait_sec = jcr->min_wait;
2073 jcr->rem_wait_sec = jcr->wait_sec;
2079 * The dev timers are used for waiting on a particular device
2081 * Returns: true if time doubled
2082 * false if max time expired
2084 bool double_dev_wait_time(DEVICE *dev)
2086 dev->wait_sec *= 2; /* double wait time */
2087 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2088 dev->wait_sec = dev->max_wait;
2091 dev->rem_wait_sec = dev->wait_sec;
2092 if (dev->num_wait >= dev->max_num_wait) {
2099 void set_os_device_parameters(DEVICE *dev)
2101 #ifdef HAVE_LINUX_OS
2103 if (dev->min_block_size == dev->max_block_size &&
2104 dev->min_block_size == 0) { /* variable block mode */
2105 mt_com.mt_op = MTSETBLK;
2106 mt_com.mt_count = 0;
2107 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2108 clrerror_dev(dev, MTSETBLK);
2110 mt_com.mt_op = MTSETDRVBUFFER;
2111 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2112 if (!dev->has_cap(CAP_TWOEOF)) {
2113 mt_com.mt_count |= MT_ST_TWO_FM;
2115 if (dev->has_cap(CAP_EOM)) {
2116 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2118 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2119 clrerror_dev(dev, MTSETBLK);
2125 #ifdef HAVE_NETBSD_OS
2127 if (dev->min_block_size == dev->max_block_size &&
2128 dev->min_block_size == 0) { /* variable block mode */
2129 mt_com.mt_op = MTSETBSIZ;
2130 mt_com.mt_count = 0;
2131 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2132 clrerror_dev(dev, MTSETBSIZ);
2134 /* Get notified at logical end of tape */
2135 mt_com.mt_op = MTEWARN;
2136 mt_com.mt_count = 1;
2137 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2138 clrerror_dev(dev, MTEWARN);
2144 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2146 if (dev->min_block_size == dev->max_block_size &&
2147 dev->min_block_size == 0) { /* variable block mode */
2148 mt_com.mt_op = MTSETBSIZ;
2149 mt_com.mt_count = 0;
2150 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2151 clrerror_dev(dev, MTSETBSIZ);
2159 if (dev->min_block_size == dev->max_block_size &&
2160 dev->min_block_size == 0) { /* variable block mode */
2161 mt_com.mt_op = MTSRSZ;
2162 mt_com.mt_count = 0;
2163 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2164 clrerror_dev(dev, MTSRSZ);
2171 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2173 return dev->has_cap(CAP_MTIOCGET) &&
2174 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2175 mt_stat->mt_fileno >= 0;
2178 static char *modes[] = {
2179 "CREATE_READ_WRITE",
2186 static char *mode_to_str(int mode)
2188 return modes[mode-1];