3 * dev.c -- low level operations on device (storage device)
7 * NOTE!!!! None of these routines are reentrant. You must
8 * use lock_device() and unlock_device() at a higher level,
9 * or use the xxx_device() equivalents. By moving the
10 * thread synchronization to a higher level, we permit
11 * the higher level routines to "seize" the device and
12 * to carry out operations without worrying about who
13 * set what lock (i.e. race conditions).
15 * Note, this is the device dependent code, and may have
16 * to be modified for each system, but is meant to
17 * be as "generic" as possible.
19 * The purpose of this code is to develop a SIMPLE Storage
20 * daemon. More complicated coding (double buffering, writer
21 * thread, ...) is left for a later version.
23 * Unfortunately, I have had to add more and more complication
24 * to this code. This was not foreseen as noted above, and as
25 * a consequence has lead to something more contorted than is
26 * really necessary -- KES. Note, this contortion has been
27 * corrected to a large extent by a rewrite (Apr MMI).
32 Copyright (C) 2000-2006 Kern Sibbald
34 This program is free software; you can redistribute it and/or
35 modify it under the terms of the GNU General Public License
36 version 2 as amended with additional clauses defined in the
37 file LICENSE in the main source directory.
39 This program is distributed in the hope that it will be useful,
40 but WITHOUT ANY WARRANTY; without even the implied warranty of
41 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
42 the file LICENSE for additional details.
47 * Handling I/O errors and end of tape conditions are a bit tricky.
48 * This is how it is currently done when writting.
49 * On either an I/O error or end of tape,
50 * we will stop writing on the physical device (no I/O recovery is
51 * attempted at least in this daemon). The state flag will be sent
52 * to include ST_EOT, which is ephemeral, 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(DCR *dcr);
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_FIFO_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->Slot = -1; /* unknown */
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 Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
143 dev->capabilities = device->cap_bits;
144 dev->min_block_size = device->min_block_size;
145 dev->max_block_size = device->max_block_size;
146 dev->max_volume_size = device->max_volume_size;
147 dev->max_file_size = device->max_file_size;
148 dev->volume_capacity = device->volume_capacity;
149 dev->max_rewind_wait = device->max_rewind_wait;
150 dev->max_open_wait = device->max_open_wait;
151 dev->max_open_vols = device->max_open_vols;
152 dev->vol_poll_interval = device->vol_poll_interval;
153 dev->max_spool_size = device->max_spool_size;
154 dev->drive_index = device->drive_index;
155 dev->autoselect = device->autoselect;
156 dev->dev_type = device->dev_type;
157 if (dev->is_tape()) { /* No parts on tapes */
158 dev->max_part_size = 0;
160 dev->max_part_size = device->max_part_size;
163 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
164 dev->vol_poll_interval = 60;
166 /* Link the dev and device structures together */
167 dev->device = device;
170 if (dev->is_fifo()) {
171 dev->capabilities |= CAP_STREAM; /* set stream device */
174 /* If the device requires mount :
175 * - Check that the mount point is available
176 * - Check that (un)mount commands are defined
178 if ((dev->is_file() || dev->is_dvd()) && dev->requires_mount()) {
179 if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
181 dev->dev_errno = errno;
182 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat mount point %s: ERR=%s\n"),
183 device->mount_point, be.strerror());
188 if (!device->mount_command || !device->unmount_command) {
189 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
191 if (!device->write_part_command) {
192 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
196 if (dev->max_block_size > 1000000) {
197 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
198 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
199 dev->max_block_size = 0;
201 if (dev->max_block_size % TAPE_BSIZE != 0) {
202 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
203 dev->max_block_size, dev->print_name());
206 dev->errmsg = get_pool_memory(PM_EMSG);
209 if ((errstat = pthread_mutex_init(&dev->mutex, NULL)) != 0) {
211 dev->dev_errno = errstat;
212 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
213 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
215 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
217 dev->dev_errno = errstat;
218 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
219 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
221 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
223 dev->dev_errno = errstat;
224 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
225 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
227 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
229 dev->dev_errno = errstat;
230 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
231 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
233 if ((errstat = rwl_init(&dev->lock)) != 0) {
235 dev->dev_errno = errstat;
236 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
237 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
241 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
242 Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
248 * Open the device with the operating system and
249 * initialize buffer pointers.
251 * Returns: -1 on error
254 * Note, for a tape, the VolName is the name we give to the
255 * volume (not really used here), but for a file, the
256 * VolName represents the name of the file to be created/opened.
257 * In the case of a file, the full name is the device name
258 * (archive_name) with the VolName concatenated.
261 DEVICE::open(DCR *dcr, int omode)
265 if (openmode == omode) {
274 Dmsg0(100, "Close fd for mode change.\n");
275 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
279 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
282 Dmsg4(29, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
283 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
284 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
285 Slot = -1; /* unknown slot */
286 label_type = B_BACULA_LABEL;
287 if (is_tape() || is_fifo()) {
288 open_tape_device(dcr, omode);
289 } else if (is_dvd()) {
290 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
291 open_dvd_device(dcr, omode);
293 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
294 open_file_device(dcr, omode);
296 state |= preserve; /* reset any important state info */
297 Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, fd);
301 void DEVICE::set_mode(int new_mode)
304 case CREATE_READ_WRITE:
305 mode = O_CREAT | O_RDWR | O_BINARY;
307 case OPEN_READ_WRITE:
308 mode = O_RDWR | O_BINARY;
311 mode = O_RDONLY | O_BINARY;
313 case OPEN_WRITE_ONLY:
314 mode = O_WRONLY | O_BINARY;
317 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
323 void DEVICE::open_tape_device(DCR *dcr, int omode)
326 int timeout = max_open_wait;
328 utime_t start_time = time(NULL);
331 Dmsg0(29, "Open dev: device is tape\n");
333 get_autochanger_loaded_slot(dcr);
342 if (is_fifo() && timeout) {
344 tid = start_thread_timer(pthread_self(), timeout);
346 Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
347 #if defined(HAVE_WIN32)
350 if ((fd = tape_open(dev_name, mode)) < 0) {
357 /* If busy retry each second for max_open_wait seconds */
359 /* Try non-blocking open */
360 fd = ::open(dev_name, mode+O_NONBLOCK);
364 Dmsg5(050, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
365 print_name(), omode, mode, errno, be.strerror());
367 /* Tape open, now rewind it */
368 Dmsg0(050, "Rewind after open\n");
369 mt_com.mt_op = MTREW;
371 if (ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
373 dev_errno = errno; /* set error status from rewind */
376 Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
377 be.strerror(dev_errno));
378 /* If we get busy, device is probably rewinding, try again */
379 if (dev_errno != EBUSY) {
380 break; /* error -- no medium */
383 /* Got fd and rewind worked, so we must have medium in drive */
385 fd = ::open(dev_name, mode); /* open normally */
389 Dmsg5(050, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
390 print_name(), omode, mode, errno, be.strerror());
395 set_os_device_parameters(dcr); /* do system dependent stuff */
396 break; /* Successfully opened and rewound */
400 /* Exceed wait time ? */
401 if (time(NULL) - start_time >= max_open_wait) {
402 break; /* yes, get out */
409 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
410 print_name(), be.strerror(dev_errno));
411 Dmsg1(100, "%s", errmsg);
414 /* Stop any open() timer we started */
416 stop_thread_timer(tid);
419 Dmsg1(29, "open dev: tape %d opened\n", fd);
426 void DEVICE::open_file_device(DCR *dcr, int omode)
428 POOL_MEM archive_name(PM_FNAME);
430 get_autochanger_loaded_slot(dcr);
433 * Handle opening of File Archive (not a tape)
436 pm_strcpy(archive_name, dev_name);
438 * If this is a virtual autochanger (i.e. changer_res != NULL)
439 * we simply use the device name, assuming it has been
440 * appropriately setup by the "autochanger".
442 if (!device->changer_res) {
443 if (VolCatInfo.VolCatName[0] == 0) {
444 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
450 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
451 pm_strcat(archive_name, "/");
453 pm_strcat(archive_name, VolCatInfo.VolCatName);
456 mount(1); /* do mount if required */
460 /* If creating file, give 0640 permissions */
461 Dmsg3(29, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
462 archive_name.c_str(), mode);
463 /* Use system open() */
464 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
467 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
469 Dmsg1(29, "open failed: %s", errmsg);
470 Emsg0(M_FATAL, 0, errmsg);
476 Dmsg4(29, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
477 fd, part, num_dvd_parts, part_size);
481 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
482 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
483 * has the desired Volume name, but there is NO assurance that
484 * any other field of VolCatInfo is correct.
486 void DEVICE::open_dvd_device(DCR *dcr, int omode)
488 POOL_MEM archive_name(PM_FNAME);
489 struct stat filestat;
492 * Handle opening of DVD Volume
494 Dmsg2(29, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n",
495 &dcr->VolCatInfo, mode_to_str(omode));
498 * For a DVD we must always pull the state info from dcr->VolCatInfo
499 * This is a bit ugly, but is necessary because we need to open/close/re-open
500 * the dvd file in order to properly mount/unmount and access the
501 * DVD. So we store the state of the DVD as far as is known in the
502 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
503 * copy here, when opening.
505 VolCatInfo = dcr->VolCatInfo; /* structure assignment */
506 Dmsg1(100, "Volume=%s\n", VolCatInfo.VolCatName);
508 if (VolCatInfo.VolCatName[0] == 0) {
509 Dmsg1(10, "Could not open file device %s. No Volume name given.\n",
511 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
518 Dmsg0(100, "Set part=1\n");
519 part = 1; /* count from 1 */
523 if (num_dvd_parts != VolCatInfo.VolCatParts) {
524 num_dvd_parts = VolCatInfo.VolCatParts;
528 * If we are not trying to access the last part, set mode to
529 * OPEN_READ_ONLY as writing would be an error.
531 Dmsg2(29, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
532 /* Now find the name of the part that we want to access */
533 if (part <= num_dvd_parts) {
534 omode = OPEN_READ_ONLY;
535 make_mounted_dvd_filename(this, archive_name);
536 set_part_spooled(false);
538 omode = OPEN_READ_WRITE;
539 make_spooled_dvd_filename(this, archive_name);
540 set_part_spooled(true);
544 // Clear any previous blank_dvd status - we will recalculate it here
547 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
548 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
551 Dmsg0(99, "DVD device mounted.\n");
552 if (num_dvd_parts == 0 && !truncating) {
554 * If we can mount the device, and we are not truncating the DVD,
555 * we usually want to abort. There is one exception, if there is
556 * only one 0-sized file on the DVD, with the right volume name,
557 * we continue (it's the method used by truncate_dvd to truncate a volume).
559 if (!check_can_write_on_non_blank_dvd(dcr)) {
560 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
561 Emsg0(M_FATAL, 0, errmsg);
562 unmount(1); /* Unmount the device, so the operator can change it. */
569 * Ensure that we have the correct DVD loaded by looking for part1.
570 * We only succeed the open if it exists. Failure to do this could
571 * leave us trying to add a part to a different DVD!
573 uint32_t oldpart = part;
575 POOL_MEM part1_name(PM_FNAME);
577 make_mounted_dvd_filename(this, part1_name);
579 if (stat(part1_name.c_str(), &statp) < 0) {
581 Mmsg(errmsg, _("Unable to stat DVD part 1 file %s: ERR=%s\n"),
582 part1_name.c_str(), be.strerror());
583 Emsg0(M_FATAL, 0, errmsg);
587 if (!S_ISREG(statp.st_mode)) {
588 /* It is not a regular file */
589 Mmsg(errmsg, _("DVD part 1 is not a regular file %s.\n"),
591 Emsg0(M_FATAL, 0, errmsg);
597 Dmsg0(99, "DVD device mount failed.\n");
598 /* We cannot mount the device */
599 if (num_dvd_parts == 0) {
600 /* Run free space, check there is a media. */
601 if (!update_freespace()) {
602 Emsg0(M_FATAL, 0, errmsg);
607 Dmsg1(29, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
609 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
610 Emsg0(M_FATAL, 0, errmsg);
615 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
616 Emsg0(M_FATAL, 0, errmsg);
622 Dmsg5(29, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
623 archive_name.c_str(), mode_to_str(omode),
624 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
626 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
629 /* If creating file, give 0640 permissions */
630 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
631 archive_name.c_str(), mode);
632 /* Use system open() */
633 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
635 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
637 // Should this be set if we try the create/open below
638 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
639 Dmsg1(29, "open failed: %s", errmsg);
641 /* Previous open failed. See if we can recover */
642 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
643 (part > num_dvd_parts)) {
644 /* If the last part (on spool), doesn't exist when accessing,
645 * create it. In read/write mode a write will be allowed (higher
646 * level software thinks that we are extending a pre-existing
647 * media. Reads for READ_ONLY will report immediately an EOF
648 * Sometimes it is better to finish with an EOF than with an error. */
649 Dmsg1(29, "Creating last part on spool: %s\n", archive_name.c_str());
650 omode = CREATE_READ_WRITE;
651 set_mode(CREATE_READ_WRITE);
652 fd = ::open(archive_name.c_str(), mode, 0640);
656 Dmsg1(100, "after open fd=%d\n", fd);
658 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
661 /* Get size of file */
662 if (fstat(fd, &filestat) < 0) {
665 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
667 Dmsg1(29, "open failed: %s", errmsg);
668 /* Use system close() */
672 part_size = filestat.st_size;
674 update_pos(dcr); /* update position */
682 * Returns: true on success
685 bool DEVICE::rewind(DCR *dcr)
691 Dmsg3(400, "rewind res=%d fd=%d %s\n", reserved_device, fd, print_name());
692 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
693 block_num = file = 0;
697 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
699 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
701 Emsg0(M_ABORT, 0, errmsg);
706 mt_com.mt_op = MTREW;
708 /* If we get an I/O error on rewind, it is probably because
709 * the drive is actually busy. We loop for (about 5 minutes)
710 * retrying every 5 seconds.
712 for (i=max_rewind_wait; ; i -= 5) {
713 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
716 if (i == max_rewind_wait) {
717 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
720 * This is a gross hack, because if the user has the
721 * device mounted (i.e. open), then uses mtx to load
722 * a tape, the current open file descriptor is invalid.
723 * So, we close the drive and re-open it.
726 int open_mode = openmode;
729 open(dcr, open_mode);
737 if (dev_errno == EIO) {
738 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
742 if (dev_errno == EIO && i > 0) {
743 Dmsg0(200, "Sleeping 5 seconds.\n");
748 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
749 print_name(), be.strerror());
754 } else if (is_file() || is_dvd()) {
755 if (lseek(dcr, (off_t)0, SEEK_SET) < 0) {
758 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
759 print_name(), be.strerror());
766 void DEVICE::block(int why)
769 block_device(this, why);
773 void DEVICE::unblock()
776 unblock_device(this);
780 const char *DEVICE::print_blocked() const
782 switch (dev_blocked) {
783 case BST_NOT_BLOCKED:
784 return "BST_NOT_BLOCKED";
786 return "BST_UNMOUNTED";
787 case BST_WAITING_FOR_SYSOP:
788 return "BST_WAITING_FOR_SYSOP";
789 case BST_DOING_ACQUIRE:
790 return "BST_DOING_ACQUIRE";
791 case BST_WRITING_LABEL:
792 return "BST_WRITING_LABEL";
793 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
794 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
798 return _("unknown blocked code");
803 * Called to indicate that we have just read an
804 * EOF from the device.
806 void DEVICE::set_ateof()
818 * Called to indicate we are now at the end of the tape, and
819 * writing is not possible.
821 void DEVICE::set_ateot()
823 /* Make tape effectively read-only */
824 state |= (ST_EOF|ST_EOT|ST_WEOT);
829 * Position device to end of medium (end of data)
830 * Returns: true on succes
833 bool DEVICE::eod(DCR *dcr)
836 struct mtget mt_stat;
842 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
846 #if defined (__digital__) && defined (__unix__)
847 return fsf(VolCatInfo.VolCatFiles);
854 clear_eof(); /* remove EOF flag */
855 block_num = file = 0;
858 if (is_fifo() || is_prog()) {
862 pos = lseek(dcr, (off_t)0, SEEK_END);
863 // Dmsg1(100, "====== Seek to %lld\n", pos);
871 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
872 print_name(), be.strerror());
876 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
877 Dmsg0(100,"Using FAST FSF for EOM\n");
878 /* If unknown position, rewind */
879 if (!dev_get_os_pos(this, &mt_stat)) {
884 mt_com.mt_op = MTFSF;
886 * ***FIXME*** fix code to handle case that INT16_MAX is
889 mt_com.mt_count = INT16_MAX; /* use big positive number */
890 if (mt_com.mt_count < 0) {
891 mt_com.mt_count = INT16_MAX; /* brain damaged system */
895 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
896 if (has_cap(CAP_EOM)) {
897 Dmsg0(100,"Using EOM for EOM\n");
898 mt_com.mt_op = MTEOM;
902 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
904 clrerror(mt_com.mt_op);
905 Dmsg1(50, "ioctl error: %s\n", be.strerror());
907 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
908 print_name(), be.strerror());
912 if (!dev_get_os_pos(this, &mt_stat)) {
915 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
916 print_name(), be.strerror());
919 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
921 file = mt_stat.mt_fileno;
927 * Rewind then use FSF until EOT reached
933 * Move file by file to the end of the tape
936 for (file_num=file; !at_eot(); file_num++) {
937 Dmsg0(200, "eod: doing fsf 1\n");
939 Dmsg0(200, "fsf error.\n");
943 * Avoid infinite loop by ensuring we advance.
945 if (!at_eot() && file_num == (int)file) {
946 struct mtget mt_stat;
947 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
949 if (dev_get_os_pos(this, &mt_stat)) {
950 Dmsg2(100, "Adjust file from %d to %d\n", file_num, mt_stat.mt_fileno);
951 file = mt_stat.mt_fileno;
958 * Some drivers leave us after second EOF when doing
959 * MTEOM, so we must backup so that appending overwrites
962 if (has_cap(CAP_BSFATEOM)) {
963 struct mtget mt_stat;
964 /* Backup over EOF */
966 /* If BSF worked and fileno is known (not -1), set file */
967 if (dev_get_os_pos(this, &mt_stat)) {
968 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , mt_stat.mt_fileno);
969 file = mt_stat.mt_fileno;
971 file++; /* wing it -- not correct on all OSes */
974 update_pos(dcr); /* update position */
976 Dmsg1(200, "EOD dev->file=%d\n", file);
981 * Set the position of the device -- only for files and DVD
982 * For other devices, there is no generic way to do it.
983 * Returns: true on succes
986 bool DEVICE::update_pos(DCR *dcr)
993 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
994 Emsg1(M_FATAL, 0, "%s", errmsg);
998 /* Find out where we are */
999 if (is_file() || is_dvd()) {
1002 pos = lseek(dcr, (off_t)0, SEEK_CUR);
1006 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
1007 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1008 print_name(), be.strerror());
1012 block_num = (uint32_t)pos;
1013 file = (uint32_t)(pos >> 32);
1020 * Return the status of the device. This was meant
1021 * to be a generic routine. Unfortunately, it doesn't
1022 * seem possible (at least I do not know how to do it
1023 * currently), which means that for the moment, this
1024 * routine has very little value.
1028 uint32_t status_dev(DEVICE *dev)
1030 struct mtget mt_stat;
1033 if (dev->state & (ST_EOT | ST_WEOT)) {
1037 if (dev->state & ST_EOF) {
1041 if (dev->is_tape()) {
1043 Pmsg0(-20,_(" Bacula status:"));
1044 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1045 if (tape_ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
1047 dev->dev_errno = errno;
1048 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1049 dev->print_name(), be.strerror());
1052 Pmsg0(-20, _(" Device status:"));
1054 #if defined(HAVE_LINUX_OS)
1055 if (GMT_EOF(mt_stat.mt_gstat)) {
1059 if (GMT_BOT(mt_stat.mt_gstat)) {
1063 if (GMT_EOT(mt_stat.mt_gstat)) {
1067 if (GMT_SM(mt_stat.mt_gstat)) {
1071 if (GMT_EOD(mt_stat.mt_gstat)) {
1075 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1076 stat |= BMT_WR_PROT;
1077 Pmsg0(-20, " WR_PROT");
1079 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1081 Pmsg0(-20, " ONLINE");
1083 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1084 stat |= BMT_DR_OPEN;
1085 Pmsg0(-20, " DR_OPEN");
1087 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1088 stat |= BMT_IM_REP_EN;
1089 Pmsg0(-20, " IM_REP_EN");
1091 #elif defined(HAVE_WIN32)
1092 if (GMT_EOF(mt_stat.mt_gstat)) {
1096 if (GMT_BOT(mt_stat.mt_gstat)) {
1100 if (GMT_EOT(mt_stat.mt_gstat)) {
1104 if (GMT_EOD(mt_stat.mt_gstat)) {
1108 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1109 stat |= BMT_WR_PROT;
1110 Pmsg0(-20, " WR_PROT");
1112 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1114 Pmsg0(-20, " ONLINE");
1116 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1117 stat |= BMT_DR_OPEN;
1118 Pmsg0(-20, " DR_OPEN");
1120 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1121 stat |= BMT_IM_REP_EN;
1122 Pmsg0(-20, " IM_REP_EN");
1125 #endif /* !SunOS && !OSF */
1126 if (dev->has_cap(CAP_MTIOCGET)) {
1127 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1129 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1132 stat |= BMT_ONLINE | BMT_BOT;
1139 * Load medium in device
1140 * Returns: true on success
1143 bool load_dev(DEVICE *dev)
1150 dev->dev_errno = EBADF;
1151 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1152 Emsg0(M_FATAL, 0, dev->errmsg);
1155 if (!(dev->is_tape())) {
1159 Dmsg0(200, "stored: MTLOAD command not available\n");
1161 dev->dev_errno = ENOTTY; /* function not available */
1162 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1163 dev->print_name(), be.strerror());
1167 dev->block_num = dev->file = 0;
1170 mt_com.mt_op = MTLOAD;
1171 mt_com.mt_count = 1;
1172 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1174 dev->dev_errno = errno;
1175 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1176 dev->print_name(), be.strerror());
1184 * Rewind device and put it offline
1185 * Returns: true on success
1188 bool DEVICE::offline()
1193 return true; /* device not open */
1196 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1197 block_num = file = 0;
1201 mt_com.mt_op = MTOFFL;
1202 mt_com.mt_count = 1;
1203 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
1206 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1207 print_name(), be.strerror());
1210 Dmsg1(100, "Offlined device %s\n", print_name());
1214 bool DEVICE::offline_or_rewind()
1219 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1223 * Note, this rewind probably should not be here (it wasn't
1224 * in prior versions of Bacula), but on FreeBSD, this is
1225 * needed in the case the tape was "frozen" due to an error
1226 * such as backspacing after writing and EOF. If it is not
1227 * done, all future references to the drive get and I/O error.
1230 return rewind(NULL);
1235 * Foward space a file
1236 * Returns: true on success
1239 bool DEVICE::fsf(int num)
1241 struct mtget mt_stat;
1247 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1248 Emsg0(M_FATAL, 0, errmsg);
1258 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1262 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1265 Dmsg0(100, "fsf\n");
1268 * If Fast forward space file is set, then we
1269 * use MTFSF to forward space and MTIOCGET
1270 * to get the file position. We assume that
1271 * the SCSI driver will ensure that we do not
1272 * forward space past the end of the medium.
1274 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1275 mt_com.mt_op = MTFSF;
1276 mt_com.mt_count = num;
1277 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1278 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1281 Dmsg0(200, "Set ST_EOT\n");
1283 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1284 print_name(), be.strerror());
1285 Dmsg1(200, "%s", errmsg);
1288 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1290 file = mt_stat.mt_fileno;
1294 * Here if CAP_FSF is set, and virtually all drives
1295 * these days support it, we read a record, then forward
1296 * space one file. Using this procedure, which is slow,
1297 * is the only way we can be sure that we don't read
1298 * two consecutive EOF marks, which means End of Data.
1300 } else if (has_cap(CAP_FSF)) {
1303 Dmsg0(200, "FSF has cap_fsf\n");
1304 if (max_block_size == 0) {
1305 rbuf_len = DEFAULT_BLOCK_SIZE;
1307 rbuf_len = max_block_size;
1309 rbuf = get_memory(rbuf_len);
1310 mt_com.mt_op = MTFSF;
1311 mt_com.mt_count = 1;
1312 while (num-- && !at_eot()) {
1313 Dmsg0(100, "Doing read before fsf\n");
1314 if ((stat = tape_read(fd, (char *)rbuf, rbuf_len)) < 0) {
1315 if (errno == ENOMEM) { /* tape record exceeds buf len */
1316 stat = rbuf_len; /* This is OK */
1318 * On IBM drives, they return ENOSPC at EOM
1319 * instead of EOF status
1321 } else if (at_eof() && errno == ENOSPC) {
1327 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1329 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1330 print_name(), be.strerror());
1331 Dmsg1(100, "%s", errmsg);
1335 if (stat == 0) { /* EOF */
1336 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1337 /* Two reads of zero means end of tape */
1340 Dmsg0(100, "Set ST_EOT\n");
1346 } else { /* Got data */
1351 Dmsg0(100, "Doing MTFSF\n");
1352 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1353 if (stat < 0) { /* error => EOT */
1356 Dmsg0(100, "Set ST_EOT\n");
1358 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1359 print_name(), be.strerror());
1360 Dmsg0(100, "Got < 0 for MTFSF\n");
1361 Dmsg1(100, "%s", errmsg);
1369 * No FSF, so use FSR to simulate it
1372 Dmsg0(200, "Doing FSR for FSF\n");
1373 while (num-- && !at_eot()) {
1374 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1378 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1384 Dmsg1(200, "Return %d from FSF\n", stat);
1386 Dmsg0(200, "ST_EOF set on exit FSF\n");
1389 Dmsg0(200, "ST_EOT set on exit FSF\n");
1391 Dmsg1(200, "Return from FSF file=%d\n", file);
1396 * Backward space a file
1397 * Returns: false on failure
1400 bool DEVICE::bsf(int num)
1407 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1408 Emsg0(M_FATAL, 0, errmsg);
1413 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1424 mt_com.mt_op = MTBSF;
1425 mt_com.mt_count = num;
1426 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1430 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1431 print_name(), be.strerror());
1438 * Foward space num records
1439 * Returns: false on failure
1442 bool DEVICE::fsr(int num)
1449 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1450 Emsg0(M_FATAL, 0, errmsg);
1458 if (!has_cap(CAP_FSR)) {
1459 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1463 Dmsg1(29, "fsr %d\n", num);
1464 mt_com.mt_op = MTFSR;
1465 mt_com.mt_count = num;
1466 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1472 struct mtget mt_stat;
1474 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1475 if (dev_get_os_pos(this, &mt_stat)) {
1476 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1477 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1478 file = mt_stat.mt_fileno;
1479 block_num = mt_stat.mt_blkno;
1487 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1488 num, print_name(), be.strerror());
1494 * Backward space a record
1495 * Returns: false on failure
1498 bool DEVICE::bsr(int num)
1505 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1506 Emsg0(M_FATAL, 0, errmsg);
1514 if (!has_cap(CAP_BSR)) {
1515 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1519 Dmsg0(29, "bsr_dev\n");
1523 mt_com.mt_op = MTBSR;
1524 mt_com.mt_count = num;
1525 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1529 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1530 print_name(), be.strerror());
1535 void DEVICE::lock_door()
1539 mt_com.mt_op = MTLOCK;
1540 mt_com.mt_count = 1;
1541 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1545 void DEVICE::unlock_door()
1549 mt_com.mt_op = MTUNLOCK;
1550 mt_com.mt_count = 1;
1551 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1557 * Reposition the device to file, block
1558 * Returns: false on failure
1561 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1565 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1566 Emsg0(M_FATAL, 0, errmsg);
1571 off_t pos = (((off_t)rfile)<<32) + (off_t)rblock;
1572 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1573 if (lseek(dcr, pos, SEEK_SET) == (off_t)-1) {
1576 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1577 print_name(), be.strerror());
1586 /* After this point, we are tape only */
1587 Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1589 Dmsg0(100, "Rewind\n");
1590 if (!rewind(NULL)) {
1595 Dmsg1(100, "fsf %d\n", rfile-file);
1596 if (!fsf(rfile-file)) {
1597 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1600 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1602 if (rblock < block_num) {
1603 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1604 Dmsg0(100, "bsf 1\n");
1606 Dmsg0(100, "fsf 1\n");
1608 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1610 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1611 /* Ignore errors as Bacula can read to the correct block */
1612 Dmsg1(100, "fsr %d\n", rblock-block_num);
1613 return fsr(rblock-block_num);
1615 while (rblock > block_num) {
1616 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1619 Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1620 print_name(), be.strerror());
1623 Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1632 * Write an end of file on the device
1633 * Returns: true on success
1636 bool DEVICE::weof(int num)
1640 Dmsg0(129, "weof_dev\n");
1644 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1645 Emsg0(M_FATAL, 0, errmsg);
1653 if (!can_append()) {
1654 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1655 Emsg0(M_FATAL, 0, errmsg);
1661 mt_com.mt_op = MTWEOF;
1662 mt_com.mt_count = num;
1663 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1672 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1673 print_name(), be.strerror());
1681 * If implemented in system, clear the tape
1684 void DEVICE::clrerror(int func)
1686 const char *msg = NULL;
1687 struct mtget mt_stat;
1690 dev_errno = errno; /* save errno */
1692 VolCatInfo.VolCatErrors++;
1699 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1702 break; /* ignore message printed later */
1705 capabilities &= ~CAP_EOF; /* turn off feature */
1710 capabilities &= ~CAP_EOM; /* turn off feature */
1715 capabilities &= ~CAP_FSF; /* turn off feature */
1719 capabilities &= ~CAP_BSF; /* turn off feature */
1723 capabilities &= ~CAP_FSR; /* turn off feature */
1727 capabilities &= ~CAP_BSR; /* turn off feature */
1737 #ifdef MTSETDRVBUFFER
1738 case MTSETDRVBUFFER:
1739 msg = "MTSETDRVBUFFER";
1772 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1778 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1779 Emsg0(M_ERROR, 0, errmsg);
1784 * Now we try different methods of clearing the error
1785 * status on the drive so that it is not locked for
1786 * further operations.
1789 /* On some systems such as NetBSD, this clears all errors */
1790 tape_ioctl(fd, MTIOCGET, (char *)&mt_stat);
1792 /* Found on Linux */
1796 mt_com.mt_op = MTIOCLRERR;
1797 mt_com.mt_count = 1;
1798 /* Clear any error condition on the tape */
1799 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1800 Dmsg0(200, "Did MTIOCLRERR\n");
1804 /* Typically on FreeBSD */
1808 /* Read and clear SCSI error status */
1809 union mterrstat mt_errstat;
1810 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1811 be.strerror(dev_errno));
1812 tape_ioctl(fd, MTIOCERRSTAT, (char *)&mt_errstat);
1816 /* Clear Subsystem Exception OSF1 */
1820 mt_com.mt_op = MTCSE;
1821 mt_com.mt_count = 1;
1822 /* Clear any error condition on the tape */
1823 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1824 Dmsg0(200, "Did MTCSE\n");
1832 void DEVICE::close()
1834 Dmsg1(100, "close_dev %s\n", print_name());
1835 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1840 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1842 return; /* already closed */
1854 /* Clean up device packet so it can be reused */
1856 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1857 label_type = B_BACULA_LABEL;
1858 file = block_num = 0;
1861 EndFile = EndBlock = 0;
1863 Slot = -1; /* unknown slot */
1865 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1866 memset(&VolHdr, 0, sizeof(VolHdr));
1868 stop_thread_timer(tid);
1874 * This call closes the device, but it is used in DVD handling
1875 * where we close one part and then open the next part. The
1876 * difference between close_part() and close() is that close_part()
1877 * saves the state information of the device (e.g. the Volume lable,
1878 * the Volume Catalog record, ... This permits opening and closing
1879 * the Volume parts multiple times without losing track of what the
1880 * main Volume parameters are.
1882 void DEVICE::close_part(DCR *dcr)
1884 VOLUME_LABEL saveVolHdr;
1885 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1888 saveVolHdr = VolHdr; /* structure assignment */
1889 saveVolCatInfo = VolCatInfo; /* structure assignment */
1890 close(); /* close current part */
1891 VolHdr = saveVolHdr; /* structure assignment */
1892 VolCatInfo = saveVolCatInfo; /* structure assignment */
1893 dcr->VolCatInfo = saveVolCatInfo; /* structure assignment */
1896 off_t DEVICE::lseek(DCR *dcr, off_t offset, int whence)
1900 return lseek_dvd(dcr, offset, whence);
1902 return ::lseek(fd, offset, whence);
1908 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1910 Dmsg1(100, "truncate %s\n", print_name());
1913 /* maybe we should rewind and write and eof ???? */
1914 return true; /* we don't really truncate tapes */
1916 return truncate_dvd(dcr);
1918 /* ***FIXME*** we really need to unlink() the file so that
1919 * its name can be changed for a relabel.
1921 if (ftruncate(fd, 0) != 0) {
1923 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1924 print_name(), be.strerror());
1932 /* Mount the device.
1933 * If timeout, wait until the mount command returns 0.
1934 * If !timeout, try to mount the device only once.
1936 bool DEVICE::mount(int timeout)
1938 Dmsg0(190, "Enter mount\n");
1941 } else if (requires_mount()) {
1942 return do_mount(1, timeout);
1947 /* Unmount the device
1948 * If timeout, wait until the unmount command returns 0.
1949 * If !timeout, try to unmount the device only once.
1951 bool DEVICE::unmount(int timeout)
1953 Dmsg0(90, "Enter unmount\n");
1955 return do_mount(0, timeout);
1960 /* (Un)mount the device */
1961 bool DEVICE::do_mount(int mount, int dotimeout)
1963 POOL_MEM ocmd(PM_FNAME);
1966 int status, timeout;
1968 sm_check(__FILE__, __LINE__, false);
1971 Dmsg0(200, "======= mount=1\n");
1974 icmd = device->mount_command;
1976 if (!is_mounted()) {
1977 Dmsg0(200, "======= mount=0\n");
1980 icmd = device->unmount_command;
1983 clear_freespace_ok();
1984 edit_mount_codes(ocmd, icmd);
1986 Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1989 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1994 results = get_memory(4000);
1997 /* If busy retry each second */
1998 Dmsg1(20, "do_mount run_prog=%s\n", ocmd.c_str());
1999 while ((status = run_program_full_output(ocmd.c_str(),
2000 max_open_wait/2, results)) != 0) {
2001 /* Doesn't work with internationalization (This is not a problem) */
2002 if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2005 if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2008 if (timeout-- > 0) {
2009 /* Sometimes the device cannot be mounted because it is already mounted.
2010 * Try to unmount it, then remount it */
2012 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2020 Dmsg5(40, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2021 (mount ? "" : "un"), status, results, be.strerror(status));
2022 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2023 print_name(), (mount ? "" : "un"), be.strerror(status));
2025 Dmsg4(40, "Device %s cannot be %smounted. stat=%d ERR=%s\n", print_name(),
2026 (mount ? "" : "un"), status, results);
2027 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2028 print_name(), (mount ? "" : "un"), results);
2031 * Now, just to be sure it is not mounted, try to read the
2035 struct dirent *entry, *result;
2039 name_max = pathconf(".", _PC_NAME_MAX);
2040 if (name_max < 1024) {
2044 if (!(dp = opendir(device->mount_point))) {
2047 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2048 device->mount_point, print_name(), be.strerror());
2052 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2055 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2057 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
2058 device->mount_point, print_name());
2061 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2062 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2065 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2071 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2074 /* If we got more than ., .. and .keep */
2075 /* there must be something mounted */
2077 Dmsg1(100, "Did Mount by count=%d\n", count);
2080 /* An unmount request. We failed to unmount - report an error */
2082 free_pool_memory(results);
2083 Dmsg0(200, "== error mount=1 wanted unmount\n");
2089 sm_check(__FILE__, __LINE__, false);
2090 free_pool_memory(results);
2091 Dmsg0(200, "============ mount=0\n");
2095 set_mounted(mount); /* set/clear mounted flag */
2096 free_pool_memory(results);
2097 /* Do not check free space when unmounting */
2098 if (mount && !update_freespace()) {
2101 Dmsg1(200, "============ mount=%d\n", mount);
2106 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2108 * %a = archive device name
2109 * %e = erase (set if cannot mount and first part)
2112 * %v = last part name
2114 * omsg = edited output message
2115 * imsg = input string containing edit codes (%x)
2118 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2124 POOL_MEM archive_name(PM_FNAME);
2126 omsg.c_str()[0] = 0;
2127 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2128 for (p=imsg; *p; p++) {
2138 if (num_dvd_parts == 0) {
2139 if (truncating || blank_dvd) {
2149 bsnprintf(add, sizeof(add), "%d", part);
2153 str = device->mount_point;
2156 make_spooled_dvd_filename(this, archive_name);
2157 str = archive_name.c_str();
2171 Dmsg1(1900, "add_str %s\n", str);
2172 pm_strcat(omsg, (char *)str);
2173 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2178 /* Return the resource name for the device */
2179 const char *DEVICE::name() const
2181 return device->hdr.name;
2185 dev_vol_name(DEVICE *dev)
2187 return dev->VolCatInfo.VolCatName;
2192 * Free memory allocated for the device
2194 void DEVICE::term(void)
2196 Dmsg1(900, "term dev: %s\n", print_name());
2199 free_memory(dev_name);
2203 free_memory(prt_name);
2207 free_pool_memory(errmsg);
2210 pthread_mutex_destroy(&mutex);
2211 pthread_cond_destroy(&wait);
2212 pthread_cond_destroy(&wait_next_vol);
2213 pthread_mutex_destroy(&spool_mutex);
2215 if (attached_dcrs) {
2216 delete attached_dcrs;
2217 attached_dcrs = NULL;
2226 * This routine initializes the device wait timers
2228 void init_device_wait_timers(DCR *dcr)
2230 DEVICE *dev = dcr->dev;
2231 JCR *jcr = dcr->jcr;
2233 /* ******FIXME******* put these on config variables */
2234 dev->min_wait = 60 * 60;
2235 dev->max_wait = 24 * 60 * 60;
2236 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2237 dev->wait_sec = dev->min_wait;
2238 dev->rem_wait_sec = dev->wait_sec;
2241 dev->BadVolName[0] = 0;
2243 jcr->min_wait = 60 * 60;
2244 jcr->max_wait = 24 * 60 * 60;
2245 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2246 jcr->wait_sec = jcr->min_wait;
2247 jcr->rem_wait_sec = jcr->wait_sec;
2252 void init_jcr_device_wait_timers(JCR *jcr)
2254 /* ******FIXME******* put these on config variables */
2255 jcr->min_wait = 60 * 60;
2256 jcr->max_wait = 24 * 60 * 60;
2257 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2258 jcr->wait_sec = jcr->min_wait;
2259 jcr->rem_wait_sec = jcr->wait_sec;
2265 * The dev timers are used for waiting on a particular device
2267 * Returns: true if time doubled
2268 * false if max time expired
2270 bool double_dev_wait_time(DEVICE *dev)
2272 dev->wait_sec *= 2; /* double wait time */
2273 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2274 dev->wait_sec = dev->max_wait;
2277 dev->rem_wait_sec = dev->wait_sec;
2278 if (dev->num_wait >= dev->max_num_wait) {
2285 void set_os_device_parameters(DCR *dcr)
2287 DEVICE *dev = dcr->dev;
2289 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2292 Dmsg0(050, "In set_os_device_parameters\n");
2293 #if defined(MTSETBLK)
2294 if (dev->min_block_size == dev->max_block_size &&
2295 dev->min_block_size == 0) { /* variable block mode */
2296 mt_com.mt_op = MTSETBLK;
2297 mt_com.mt_count = 0;
2298 Dmsg0(050, "Set block size to zero\n");
2299 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2300 dev->clrerror(MTSETBLK);
2304 #if defined(MTSETDRVBUFFER)
2305 if (getpid() == 0) { /* Only root can do this */
2306 mt_com.mt_op = MTSETDRVBUFFER;
2307 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2308 if (!dev->has_cap(CAP_TWOEOF)) {
2309 mt_com.mt_count |= MT_ST_TWO_FM;
2311 if (dev->has_cap(CAP_EOM)) {
2312 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2314 Dmsg0(050, "MTSETDRVBUFFER\n");
2315 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2316 dev->clrerror(MTSETDRVBUFFER);
2323 #ifdef HAVE_NETBSD_OS
2325 if (dev->min_block_size == dev->max_block_size &&
2326 dev->min_block_size == 0) { /* variable block mode */
2327 mt_com.mt_op = MTSETBSIZ;
2328 mt_com.mt_count = 0;
2329 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2330 dev->clrerror(MTSETBSIZ);
2332 /* Get notified at logical end of tape */
2333 mt_com.mt_op = MTEWARN;
2334 mt_com.mt_count = 1;
2335 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2336 dev->clrerror(MTEWARN);
2342 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2344 if (dev->min_block_size == dev->max_block_size &&
2345 dev->min_block_size == 0) { /* variable block mode */
2346 mt_com.mt_op = MTSETBSIZ;
2347 mt_com.mt_count = 0;
2348 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2349 dev->clrerror(MTSETBSIZ);
2352 /* Turn this on later when fully tested */
2353 #if defined(xxxMTIOCSETEOTMODEL)
2355 if (dev_cap(dev, CAP_TWOEOF)) {
2360 if (ioctl(dev->fd, MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2362 dev->dev_errno = errno; /* save errno */
2363 Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2364 dev->print_name(), be.strerror(dev->dev_errno));
2365 Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2373 if (dev->min_block_size == dev->max_block_size &&
2374 dev->min_block_size == 0) { /* variable block mode */
2375 mt_com.mt_op = MTSRSZ;
2376 mt_com.mt_count = 0;
2377 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2378 dev->clrerror(MTSRSZ);
2385 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2387 Dmsg0(050, "dev_get_os_pos\n");
2388 return dev->has_cap(CAP_MTIOCGET) &&
2389 tape_ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2390 mt_stat->mt_fileno >= 0;
2393 static char *modes[] = {
2394 "CREATE_READ_WRITE",
2401 static char *mode_to_str(int mode)
2403 static char buf[100];
2404 if (mode < 1 || mode > 4) {
2405 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2408 return modes[mode-1];