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 Bacula® - The Network Backup Solution
34 Copyright (C) 2000-2007 Free Software Foundation Europe e.V.
36 The main author of Bacula is Kern Sibbald, with contributions from
37 many others, a complete list can be found in the file AUTHORS.
38 This program is Free Software; you can redistribute it and/or
39 modify it under the terms of version two of the GNU General Public
40 License as published by the Free Software Foundation plus additions
41 that are listed in the file LICENSE.
43 This program is distributed in the hope that it will be useful, but
44 WITHOUT ANY WARRANTY; without even the implied warranty of
45 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
46 General Public License for more details.
48 You should have received a copy of the GNU General Public License
49 along with this program; if not, write to the Free Software
50 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
53 Bacula® is a registered trademark of John Walker.
54 The licensor of Bacula is the Free Software Foundation Europe
55 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
56 Switzerland, email:ftf@fsfeurope.org.
60 * Handling I/O errors and end of tape conditions are a bit tricky.
61 * This is how it is currently done when writting.
62 * On either an I/O error or end of tape,
63 * we will stop writing on the physical device (no I/O recovery is
64 * attempted at least in this daemon). The state flag will be sent
65 * to include ST_EOT, which is ephemeral, and ST_WEOT, which is
66 * persistent. Lots of routines clear ST_EOT, but ST_WEOT is
67 * cleared only when the problem goes away. Now when ST_WEOT
68 * is set all calls to write_block_to_device() call the fix_up
69 * routine. In addition, all threads are blocked
70 * from writing on the tape by calling lock_dev(), and thread other
71 * than the first thread to hit the EOT will block on a condition
72 * variable. The first thread to hit the EOT will continue to
73 * be able to read and write the tape (he sort of tunnels through
74 * the locking mechanism -- see lock_dev() for details).
76 * Now presumably somewhere higher in the chain of command
77 * (device.c), someone will notice the EOT condition and
78 * get a new tape up, get the tape label read, and mark
79 * the label for rewriting. Then this higher level routine
80 * will write the unwritten buffer to the new volume.
81 * Finally, he will release
82 * any blocked threads by doing a broadcast on the condition
83 * variable. At that point, we should be totally back in
84 * business with no lost data.
95 /* Forward referenced functions */
96 void set_os_device_parameters(DCR *dcr);
97 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat);
98 static char *mode_to_str(int mode);
101 * Allocate and initialize the DEVICE structure
102 * Note, if dev is non-NULL, it is already allocated,
103 * thus we neither allocate it nor free it. This allows
104 * the caller to put the packet in shared memory.
106 * Note, for a tape, the device->device_name is the device name
107 * (e.g. /dev/nst0), and for a file, the device name
108 * is the directory in which the file will be placed.
112 init_dev(JCR *jcr, DEVRES *device)
120 /* If no device type specified, try to guess */
121 if (!device->dev_type) {
122 /* Check that device is available */
123 if (stat(device->device_name, &statp) < 0) {
125 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
126 device->device_name, be.strerror());
129 if (S_ISDIR(statp.st_mode)) {
130 device->dev_type = B_FILE_DEV;
131 } else if (S_ISCHR(statp.st_mode)) {
132 device->dev_type = B_TAPE_DEV;
133 } else if (S_ISFIFO(statp.st_mode)) {
134 device->dev_type = B_FIFO_DEV;
135 } else if (!(device->cap_bits & CAP_REQMOUNT)) {
136 Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
137 " or have RequiresMount=yes for DVD. st_mode=%x\n"),
138 device->device_name, statp.st_mode);
141 device->dev_type = B_DVD_DEV;
145 dev = (DEVICE *)malloc(sizeof(DEVICE));
146 memset(dev, 0, sizeof(DEVICE));
147 dev->Slot = -1; /* unknown */
149 /* Copy user supplied device parameters from Resource */
150 dev->dev_name = get_memory(strlen(device->device_name)+1);
151 pm_strcpy(dev->dev_name, device->device_name);
152 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
153 /* We edit "Resource-name" (physical-name) */
154 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
155 Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
156 dev->capabilities = device->cap_bits;
157 dev->min_block_size = device->min_block_size;
158 dev->max_block_size = device->max_block_size;
159 dev->max_volume_size = device->max_volume_size;
160 dev->max_file_size = device->max_file_size;
161 dev->volume_capacity = device->volume_capacity;
162 dev->max_rewind_wait = device->max_rewind_wait;
163 dev->max_open_wait = device->max_open_wait;
164 dev->max_open_vols = device->max_open_vols;
165 dev->vol_poll_interval = device->vol_poll_interval;
166 dev->max_spool_size = device->max_spool_size;
167 dev->drive_index = device->drive_index;
168 dev->autoselect = device->autoselect;
169 dev->dev_type = device->dev_type;
170 if (dev->is_tape()) { /* No parts on tapes */
171 dev->max_part_size = 0;
173 dev->max_part_size = device->max_part_size;
176 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
177 dev->vol_poll_interval = 60;
179 /* Link the dev and device structures together */
180 dev->device = device;
183 if (dev->is_fifo()) {
184 dev->capabilities |= CAP_STREAM; /* set stream device */
187 /* If the device requires mount :
188 * - Check that the mount point is available
189 * - Check that (un)mount commands are defined
191 if ((dev->is_file() || dev->is_dvd()) && dev->requires_mount()) {
192 if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
194 dev->dev_errno = errno;
195 Jmsg2(jcr, M_ERROR_TERM, 0, _("Unable to stat mount point %s: ERR=%s\n"),
196 device->mount_point, be.strerror());
200 if (!device->mount_command || !device->unmount_command) {
201 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
203 if (!device->write_part_command) {
204 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
208 if (dev->max_block_size > 1000000) {
209 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
210 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
211 dev->max_block_size = 0;
213 if (dev->max_block_size % TAPE_BSIZE != 0) {
214 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
215 dev->max_block_size, dev->print_name());
218 dev->errmsg = get_pool_memory(PM_EMSG);
221 if ((errstat = pthread_mutex_init(&dev->m_mutex, NULL)) != 0) {
223 dev->dev_errno = errstat;
224 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
225 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
227 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
229 dev->dev_errno = errstat;
230 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
231 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
233 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
235 dev->dev_errno = errstat;
236 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
237 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
239 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
241 dev->dev_errno = errstat;
242 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
243 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
246 if ((errstat = rwl_init(&dev->lock)) != 0) {
248 dev->dev_errno = errstat;
249 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
250 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
255 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
256 Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
262 * Open the device with the operating system and
263 * initialize buffer pointers.
265 * Returns: -1 on error
268 * Note, for a tape, the VolName is the name we give to the
269 * volume (not really used here), but for a file, the
270 * VolName represents the name of the file to be created/opened.
271 * In the case of a file, the full name is the device name
272 * (archive_name) with the VolName concatenated.
275 DEVICE::open(DCR *dcr, int omode)
279 if (openmode == omode) {
288 Dmsg0(100, "Close fd for mode change.\n");
289 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
293 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
296 Dmsg4(29, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
297 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
298 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
299 Slot = -1; /* unknown slot */
300 label_type = B_BACULA_LABEL;
301 if (is_tape() || is_fifo()) {
302 open_tape_device(dcr, omode);
303 } else if (is_dvd()) {
304 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
305 open_dvd_device(dcr, omode);
307 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
308 open_file_device(dcr, omode);
310 state |= preserve; /* reset any important state info */
311 Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, m_fd);
315 void DEVICE::set_mode(int new_mode)
318 case CREATE_READ_WRITE:
319 mode = O_CREAT | O_RDWR | O_BINARY;
321 case OPEN_READ_WRITE:
322 mode = O_RDWR | O_BINARY;
325 mode = O_RDONLY | O_BINARY;
327 case OPEN_WRITE_ONLY:
328 mode = O_WRONLY | O_BINARY;
331 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
337 void DEVICE::open_tape_device(DCR *dcr, int omode)
340 int timeout = max_open_wait;
341 #if !defined(HAVE_WIN32)
343 utime_t start_time = time(NULL);
347 Dmsg0(29, "Open dev: device is tape\n");
349 get_autochanger_loaded_slot(dcr);
358 if (is_fifo() && timeout) {
360 tid = start_thread_timer(pthread_self(), timeout);
362 Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
363 #if defined(HAVE_WIN32)
366 if ((m_fd = tape_open(dev_name, mode)) < 0) {
373 /* If busy retry each second for max_open_wait seconds */
375 /* Try non-blocking open */
376 m_fd = ::open(dev_name, mode+O_NONBLOCK);
380 Dmsg5(050, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
381 print_name(), omode, mode, errno, be.strerror());
383 /* Tape open, now rewind it */
384 Dmsg0(050, "Rewind after open\n");
385 mt_com.mt_op = MTREW;
387 /* rewind only if dev is a tape */
388 if (is_tape() && (ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0)) {
390 dev_errno = errno; /* set error status from rewind */
393 Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
394 be.strerror(dev_errno));
395 /* If we get busy, device is probably rewinding, try again */
396 if (dev_errno != EBUSY) {
397 break; /* error -- no medium */
400 /* Got fd and rewind worked, so we must have medium in drive */
402 m_fd = ::open(dev_name, mode); /* open normally */
406 Dmsg5(050, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
407 print_name(), omode, mode, errno, be.strerror());
412 set_os_device_parameters(dcr); /* do system dependent stuff */
413 break; /* Successfully opened and rewound */
417 /* Exceed wait time ? */
418 if (time(NULL) - start_time >= max_open_wait) {
419 break; /* yes, get out */
426 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
427 print_name(), be.strerror(dev_errno));
428 Dmsg1(100, "%s", errmsg);
431 /* Stop any open() timer we started */
433 stop_thread_timer(tid);
436 Dmsg1(29, "open dev: tape %d opened\n", m_fd);
443 void DEVICE::open_file_device(DCR *dcr, int omode)
445 POOL_MEM archive_name(PM_FNAME);
447 get_autochanger_loaded_slot(dcr);
450 * Handle opening of File Archive (not a tape)
453 pm_strcpy(archive_name, dev_name);
455 * If this is a virtual autochanger (i.e. changer_res != NULL)
456 * we simply use the device name, assuming it has been
457 * appropriately setup by the "autochanger".
459 if (!device->changer_res || device->changer_command[0] == 0) {
460 if (VolCatInfo.VolCatName[0] == 0) {
461 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
467 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
468 pm_strcat(archive_name, "/");
470 pm_strcat(archive_name, VolCatInfo.VolCatName);
473 mount(1); /* do mount if required */
477 /* If creating file, give 0640 permissions */
478 Dmsg3(29, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
479 archive_name.c_str(), mode);
480 /* Use system open() */
481 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
484 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
486 Dmsg1(29, "open failed: %s", errmsg);
487 Emsg0(M_FATAL, 0, errmsg);
493 Dmsg4(29, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
494 m_fd, part, num_dvd_parts, part_size);
498 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
499 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
500 * has the desired Volume name, but there is NO assurance that
501 * any other field of VolCatInfo is correct.
503 void DEVICE::open_dvd_device(DCR *dcr, int omode)
505 POOL_MEM archive_name(PM_FNAME);
506 struct stat filestat;
509 * Handle opening of DVD Volume
511 Dmsg2(29, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n",
512 &dcr->VolCatInfo, mode_to_str(omode));
515 * For a DVD we must always pull the state info from dcr->VolCatInfo
516 * This is a bit ugly, but is necessary because we need to open/close/re-open
517 * the dvd file in order to properly mount/unmount and access the
518 * DVD. So we store the state of the DVD as far as is known in the
519 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
520 * copy here, when opening.
522 VolCatInfo = dcr->VolCatInfo; /* structure assignment */
523 Dmsg1(100, "Volume=%s\n", VolCatInfo.VolCatName);
525 if (VolCatInfo.VolCatName[0] == 0) {
526 Dmsg1(10, "Could not open DVD device %s. No Volume name given.\n",
528 Mmsg(errmsg, _("Could not open DVD device %s. No Volume name given.\n"),
535 Dmsg0(100, "Set part=1\n");
536 part = 1; /* count from 1 */
540 if (num_dvd_parts != VolCatInfo.VolCatParts) {
541 num_dvd_parts = VolCatInfo.VolCatParts;
545 * If we are not trying to access the last part, set mode to
546 * OPEN_READ_ONLY as writing would be an error.
548 Dmsg2(29, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
549 /* Now find the name of the part that we want to access */
550 if (part <= num_dvd_parts) {
551 omode = OPEN_READ_ONLY;
552 make_mounted_dvd_filename(this, archive_name);
553 set_part_spooled(false);
555 omode = OPEN_READ_WRITE;
556 make_spooled_dvd_filename(this, archive_name);
557 set_part_spooled(true);
561 // Clear any previous blank_dvd status - we will recalculate it here
564 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
565 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
568 Dmsg0(99, "DVD device mounted.\n");
569 if (num_dvd_parts == 0 && !truncating) {
571 * If we can mount the device, and we are not truncating the DVD,
572 * we usually want to abort. There is one exception, if there is
573 * only one 0-sized file on the DVD, with the right volume name,
574 * we continue (it's the method used by truncate_dvd to truncate a volume).
576 if (!check_can_write_on_non_blank_dvd(dcr)) {
577 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
578 Emsg0(M_FATAL, 0, errmsg);
579 unmount(1); /* Unmount the device, so the operator can change it. */
586 * Ensure that we have the correct DVD loaded by looking for part1.
587 * We only succeed the open if it exists. Failure to do this could
588 * leave us trying to add a part to a different DVD!
590 uint32_t oldpart = part;
592 POOL_MEM part1_name(PM_FNAME);
594 make_mounted_dvd_filename(this, part1_name);
596 if (stat(part1_name.c_str(), &statp) < 0) {
598 Mmsg(errmsg, _("Unable to stat DVD part 1 file %s: ERR=%s\n"),
599 part1_name.c_str(), be.strerror());
600 Emsg0(M_FATAL, 0, errmsg);
604 if (!S_ISREG(statp.st_mode)) {
605 /* It is not a regular file */
606 Mmsg(errmsg, _("DVD part 1 is not a regular file %s.\n"),
608 Emsg0(M_FATAL, 0, errmsg);
614 Dmsg0(99, "DVD device mount failed.\n");
615 /* We cannot mount the device */
616 if (num_dvd_parts == 0) {
617 /* Run free space, check there is a media. */
618 if (!update_freespace()) {
619 Emsg0(M_FATAL, 0, errmsg);
624 Dmsg1(29, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
626 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
627 Emsg0(M_FATAL, 0, errmsg);
632 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
633 Emsg0(M_FATAL, 0, errmsg);
639 Dmsg5(29, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
640 archive_name.c_str(), mode_to_str(omode),
641 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
643 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
646 /* If creating file, give 0640 permissions */
647 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
648 archive_name.c_str(), mode);
649 /* Use system open() */
650 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
652 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
654 // Should this be set if we try the create/open below
655 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
656 Dmsg1(29, "open failed: %s", errmsg);
658 /* Previous open failed. See if we can recover */
659 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
660 (part > num_dvd_parts)) {
661 /* If the last part (on spool), doesn't exist when accessing,
662 * create it. In read/write mode a write will be allowed (higher
663 * level software thinks that we are extending a pre-existing
664 * media. Reads for READ_ONLY will report immediately an EOF
665 * Sometimes it is better to finish with an EOF than with an error. */
666 Dmsg1(29, "Creating last part on spool: %s\n", archive_name.c_str());
667 omode = CREATE_READ_WRITE;
668 set_mode(CREATE_READ_WRITE);
669 m_fd = ::open(archive_name.c_str(), mode, 0640);
673 Dmsg1(100, "after open fd=%d\n", m_fd);
675 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
678 /* Get size of file */
679 if (fstat(m_fd, &filestat) < 0) {
682 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
684 Dmsg1(29, "open failed: %s", errmsg);
685 /* Use system close() */
689 part_size = filestat.st_size;
691 update_pos(dcr); /* update position */
699 * Returns: true on success
702 bool DEVICE::rewind(DCR *dcr)
708 Dmsg3(400, "rewind res=%d fd=%d %s\n", reserved_device, m_fd, print_name());
709 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
710 block_num = file = 0;
714 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
716 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
718 Emsg0(M_ABORT, 0, errmsg);
723 mt_com.mt_op = MTREW;
725 /* If we get an I/O error on rewind, it is probably because
726 * the drive is actually busy. We loop for (about 5 minutes)
727 * retrying every 5 seconds.
729 for (i=max_rewind_wait; ; i -= 5) {
730 if (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
733 if (i == max_rewind_wait) {
734 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
737 * This is a gross hack, because if the user has the
738 * device mounted (i.e. open), then uses mtx to load
739 * a tape, the current open file descriptor is invalid.
740 * So, we close the drive and re-open it.
743 int open_mode = openmode;
746 open(dcr, open_mode);
754 if (dev_errno == EIO) {
755 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
759 if (dev_errno == EIO && i > 0) {
760 Dmsg0(200, "Sleeping 5 seconds.\n");
765 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
766 print_name(), be.strerror());
771 } else if (is_file() || is_dvd()) {
772 if (lseek(dcr, (boffset_t)0, SEEK_SET) < 0) {
775 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
776 print_name(), be.strerror());
783 void DEVICE::block(int why)
786 block_device(this, why);
790 void DEVICE::unblock()
793 unblock_device(this);
797 const char *DEVICE::print_blocked() const
800 case BST_NOT_BLOCKED:
801 return "BST_NOT_BLOCKED";
803 return "BST_UNMOUNTED";
804 case BST_WAITING_FOR_SYSOP:
805 return "BST_WAITING_FOR_SYSOP";
806 case BST_DOING_ACQUIRE:
807 return "BST_DOING_ACQUIRE";
808 case BST_WRITING_LABEL:
809 return "BST_WRITING_LABEL";
810 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
811 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
815 return _("unknown blocked code");
820 * Called to indicate that we have just read an
821 * EOF from the device.
823 void DEVICE::set_ateof()
835 * Called to indicate we are now at the end of the tape, and
836 * writing is not possible.
838 void DEVICE::set_ateot()
840 /* Make tape effectively read-only */
841 state |= (ST_EOF|ST_EOT|ST_WEOT);
846 * Position device to end of medium (end of data)
847 * Returns: true on succes
850 bool DEVICE::eod(DCR *dcr)
853 struct mtget mt_stat;
859 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
863 #if defined (__digital__) && defined (__unix__)
864 return fsf(VolCatInfo.VolCatFiles);
871 clear_eof(); /* remove EOF flag */
872 block_num = file = 0;
875 if (is_fifo() || is_prog()) {
879 pos = lseek(dcr, (boffset_t)0, SEEK_END);
880 // Dmsg1(100, "====== Seek to %lld\n", pos);
888 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
889 print_name(), be.strerror());
893 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
894 Dmsg0(100,"Using FAST FSF for EOM\n");
895 /* If unknown position, rewind */
896 if (!dev_get_os_pos(this, &mt_stat)) {
901 mt_com.mt_op = MTFSF;
903 * ***FIXME*** fix code to handle case that INT16_MAX is
906 mt_com.mt_count = INT16_MAX; /* use big positive number */
907 if (mt_com.mt_count < 0) {
908 mt_com.mt_count = INT16_MAX; /* brain damaged system */
912 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
913 if (has_cap(CAP_EOM)) {
914 Dmsg0(100,"Using EOM for EOM\n");
915 mt_com.mt_op = MTEOM;
919 if (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
921 clrerror(mt_com.mt_op);
922 Dmsg1(50, "ioctl error: %s\n", be.strerror());
924 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
925 print_name(), be.strerror());
929 if (!dev_get_os_pos(this, &mt_stat)) {
932 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
933 print_name(), be.strerror());
936 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
938 file = mt_stat.mt_fileno;
944 * Rewind then use FSF until EOT reached
950 * Move file by file to the end of the tape
953 for (file_num=file; !at_eot(); file_num++) {
954 Dmsg0(200, "eod: doing fsf 1\n");
956 Dmsg0(200, "fsf error.\n");
960 * Avoid infinite loop by ensuring we advance.
962 if (!at_eot() && file_num == (int)file) {
963 struct mtget mt_stat;
964 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
966 if (dev_get_os_pos(this, &mt_stat)) {
967 Dmsg2(100, "Adjust file from %d to %d\n", file_num, mt_stat.mt_fileno);
968 file = mt_stat.mt_fileno;
975 * Some drivers leave us after second EOF when doing
976 * MTEOM, so we must backup so that appending overwrites
979 if (has_cap(CAP_BSFATEOM)) {
980 struct mtget mt_stat;
981 /* Backup over EOF */
983 /* If BSF worked and fileno is known (not -1), set file */
984 if (dev_get_os_pos(this, &mt_stat)) {
985 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , mt_stat.mt_fileno);
986 file = mt_stat.mt_fileno;
988 file++; /* wing it -- not correct on all OSes */
991 update_pos(dcr); /* update position */
993 Dmsg1(200, "EOD dev->file=%d\n", file);
998 * Set the position of the device -- only for files and DVD
999 * For other devices, there is no generic way to do it.
1000 * Returns: true on succes
1003 bool DEVICE::update_pos(DCR *dcr)
1010 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
1011 Emsg1(M_FATAL, 0, "%s", errmsg);
1015 /* Find out where we are */
1016 if (is_file() || is_dvd()) {
1019 pos = lseek(dcr, (boffset_t)0, SEEK_CUR);
1023 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
1024 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1025 print_name(), be.strerror());
1029 block_num = (uint32_t)pos;
1030 file = (uint32_t)(pos >> 32);
1037 * Return the status of the device. This was meant
1038 * to be a generic routine. Unfortunately, it doesn't
1039 * seem possible (at least I do not know how to do it
1040 * currently), which means that for the moment, this
1041 * routine has very little value.
1045 uint32_t status_dev(DEVICE *dev)
1047 struct mtget mt_stat;
1050 if (dev->state & (ST_EOT | ST_WEOT)) {
1054 if (dev->state & ST_EOF) {
1058 if (dev->is_tape()) {
1060 Pmsg0(-20,_(" Bacula status:"));
1061 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1062 if (tape_ioctl(dev->fd(), MTIOCGET, (char *)&mt_stat) < 0) {
1064 dev->dev_errno = errno;
1065 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1066 dev->print_name(), be.strerror());
1069 Pmsg0(-20, _(" Device status:"));
1071 #if defined(HAVE_LINUX_OS)
1072 if (GMT_EOF(mt_stat.mt_gstat)) {
1076 if (GMT_BOT(mt_stat.mt_gstat)) {
1080 if (GMT_EOT(mt_stat.mt_gstat)) {
1084 if (GMT_SM(mt_stat.mt_gstat)) {
1088 if (GMT_EOD(mt_stat.mt_gstat)) {
1092 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1093 stat |= BMT_WR_PROT;
1094 Pmsg0(-20, " WR_PROT");
1096 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1098 Pmsg0(-20, " ONLINE");
1100 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1101 stat |= BMT_DR_OPEN;
1102 Pmsg0(-20, " DR_OPEN");
1104 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1105 stat |= BMT_IM_REP_EN;
1106 Pmsg0(-20, " IM_REP_EN");
1108 #elif defined(HAVE_WIN32)
1109 if (GMT_EOF(mt_stat.mt_gstat)) {
1113 if (GMT_BOT(mt_stat.mt_gstat)) {
1117 if (GMT_EOT(mt_stat.mt_gstat)) {
1121 if (GMT_EOD(mt_stat.mt_gstat)) {
1125 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1126 stat |= BMT_WR_PROT;
1127 Pmsg0(-20, " WR_PROT");
1129 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1131 Pmsg0(-20, " ONLINE");
1133 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1134 stat |= BMT_DR_OPEN;
1135 Pmsg0(-20, " DR_OPEN");
1137 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1138 stat |= BMT_IM_REP_EN;
1139 Pmsg0(-20, " IM_REP_EN");
1142 #endif /* !SunOS && !OSF */
1143 if (dev->has_cap(CAP_MTIOCGET)) {
1144 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1146 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1149 stat |= BMT_ONLINE | BMT_BOT;
1156 * Load medium in device
1157 * Returns: true on success
1160 bool load_dev(DEVICE *dev)
1166 if (dev->fd() < 0) {
1167 dev->dev_errno = EBADF;
1168 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1169 Emsg0(M_FATAL, 0, dev->errmsg);
1172 if (!(dev->is_tape())) {
1176 Dmsg0(200, "stored: MTLOAD command not available\n");
1178 dev->dev_errno = ENOTTY; /* function not available */
1179 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1180 dev->print_name(), be.strerror());
1184 dev->block_num = dev->file = 0;
1187 mt_com.mt_op = MTLOAD;
1188 mt_com.mt_count = 1;
1189 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
1191 dev->dev_errno = errno;
1192 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1193 dev->print_name(), be.strerror());
1201 * Rewind device and put it offline
1202 * Returns: true on success
1205 bool DEVICE::offline()
1210 return true; /* device not open */
1213 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1214 block_num = file = 0;
1218 mt_com.mt_op = MTOFFL;
1219 mt_com.mt_count = 1;
1220 if (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
1223 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1224 print_name(), be.strerror());
1227 Dmsg1(100, "Offlined device %s\n", print_name());
1231 bool DEVICE::offline_or_rewind()
1236 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1240 * Note, this rewind probably should not be here (it wasn't
1241 * in prior versions of Bacula), but on FreeBSD, this is
1242 * needed in the case the tape was "frozen" due to an error
1243 * such as backspacing after writing and EOF. If it is not
1244 * done, all future references to the drive get and I/O error.
1247 return rewind(NULL);
1252 * Foward space a file
1253 * Returns: true on success
1256 bool DEVICE::fsf(int num)
1258 struct mtget mt_stat;
1264 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1265 Emsg0(M_FATAL, 0, errmsg);
1275 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1279 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1282 Dmsg0(100, "fsf\n");
1285 * If Fast forward space file is set, then we
1286 * use MTFSF to forward space and MTIOCGET
1287 * to get the file position. We assume that
1288 * the SCSI driver will ensure that we do not
1289 * forward space past the end of the medium.
1291 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1292 mt_com.mt_op = MTFSF;
1293 mt_com.mt_count = num;
1294 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1295 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1298 Dmsg0(200, "Set ST_EOT\n");
1300 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1301 print_name(), be.strerror());
1302 Dmsg1(200, "%s", errmsg);
1305 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1307 file = mt_stat.mt_fileno;
1311 * Here if CAP_FSF is set, and virtually all drives
1312 * these days support it, we read a record, then forward
1313 * space one file. Using this procedure, which is slow,
1314 * is the only way we can be sure that we don't read
1315 * two consecutive EOF marks, which means End of Data.
1317 } else if (has_cap(CAP_FSF)) {
1320 Dmsg0(200, "FSF has cap_fsf\n");
1321 if (max_block_size == 0) {
1322 rbuf_len = DEFAULT_BLOCK_SIZE;
1324 rbuf_len = max_block_size;
1326 rbuf = get_memory(rbuf_len);
1327 mt_com.mt_op = MTFSF;
1328 mt_com.mt_count = 1;
1329 while (num-- && !at_eot()) {
1330 Dmsg0(100, "Doing read before fsf\n");
1331 if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1332 if (errno == ENOMEM) { /* tape record exceeds buf len */
1333 stat = rbuf_len; /* This is OK */
1335 * On IBM drives, they return ENOSPC at EOM
1336 * instead of EOF status
1338 } else if (at_eof() && errno == ENOSPC) {
1344 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1346 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1347 print_name(), be.strerror());
1348 Dmsg1(100, "%s", errmsg);
1352 if (stat == 0) { /* EOF */
1353 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1354 /* Two reads of zero means end of tape */
1357 Dmsg0(100, "Set ST_EOT\n");
1363 } else { /* Got data */
1368 Dmsg0(100, "Doing MTFSF\n");
1369 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1370 if (stat < 0) { /* error => EOT */
1373 Dmsg0(100, "Set ST_EOT\n");
1375 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1376 print_name(), be.strerror());
1377 Dmsg0(100, "Got < 0 for MTFSF\n");
1378 Dmsg1(100, "%s", errmsg);
1386 * No FSF, so use FSR to simulate it
1389 Dmsg0(200, "Doing FSR for FSF\n");
1390 while (num-- && !at_eot()) {
1391 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1395 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1401 Dmsg1(200, "Return %d from FSF\n", stat);
1403 Dmsg0(200, "ST_EOF set on exit FSF\n");
1406 Dmsg0(200, "ST_EOT set on exit FSF\n");
1408 Dmsg1(200, "Return from FSF file=%d\n", file);
1413 * Backward space a file
1414 * Returns: false on failure
1417 bool DEVICE::bsf(int num)
1424 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1425 Emsg0(M_FATAL, 0, errmsg);
1430 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1441 mt_com.mt_op = MTBSF;
1442 mt_com.mt_count = num;
1443 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1447 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1448 print_name(), be.strerror());
1455 * Foward space num records
1456 * Returns: false on failure
1459 bool DEVICE::fsr(int num)
1466 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1467 Emsg0(M_FATAL, 0, errmsg);
1475 if (!has_cap(CAP_FSR)) {
1476 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1480 Dmsg1(29, "fsr %d\n", num);
1481 mt_com.mt_op = MTFSR;
1482 mt_com.mt_count = num;
1483 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1489 struct mtget mt_stat;
1491 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1492 if (dev_get_os_pos(this, &mt_stat)) {
1493 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1494 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1495 file = mt_stat.mt_fileno;
1496 block_num = mt_stat.mt_blkno;
1504 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1505 num, print_name(), be.strerror());
1511 * Backward space a record
1512 * Returns: false on failure
1515 bool DEVICE::bsr(int num)
1522 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1523 Emsg0(M_FATAL, 0, errmsg);
1531 if (!has_cap(CAP_BSR)) {
1532 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1536 Dmsg0(29, "bsr_dev\n");
1540 mt_com.mt_op = MTBSR;
1541 mt_com.mt_count = num;
1542 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1546 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1547 print_name(), be.strerror());
1552 void DEVICE::lock_door()
1556 mt_com.mt_op = MTLOCK;
1557 mt_com.mt_count = 1;
1558 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1562 void DEVICE::unlock_door()
1566 mt_com.mt_op = MTUNLOCK;
1567 mt_com.mt_count = 1;
1568 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1574 * Reposition the device to file, block
1575 * Returns: false on failure
1578 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1582 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1583 Emsg0(M_FATAL, 0, errmsg);
1588 boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1589 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1590 if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1593 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1594 print_name(), be.strerror());
1603 /* After this point, we are tape only */
1604 Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1606 Dmsg0(100, "Rewind\n");
1607 if (!rewind(NULL)) {
1612 Dmsg1(100, "fsf %d\n", rfile-file);
1613 if (!fsf(rfile-file)) {
1614 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1617 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1619 if (rblock < block_num) {
1620 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1621 Dmsg0(100, "bsf 1\n");
1623 Dmsg0(100, "fsf 1\n");
1625 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1627 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1628 /* Ignore errors as Bacula can read to the correct block */
1629 Dmsg1(100, "fsr %d\n", rblock-block_num);
1630 return fsr(rblock-block_num);
1632 while (rblock > block_num) {
1633 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1636 Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1637 print_name(), be.strerror());
1640 Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1649 * Write an end of file on the device
1650 * Returns: true on success
1653 bool DEVICE::weof(int num)
1657 Dmsg0(129, "weof_dev\n");
1661 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1662 Emsg0(M_FATAL, 0, errmsg);
1670 if (!can_append()) {
1671 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1672 Emsg0(M_FATAL, 0, errmsg);
1678 mt_com.mt_op = MTWEOF;
1679 mt_com.mt_count = num;
1680 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1689 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1690 print_name(), be.strerror());
1698 * If implemented in system, clear the tape
1701 void DEVICE::clrerror(int func)
1703 const char *msg = NULL;
1704 struct mtget mt_stat;
1707 dev_errno = errno; /* save errno */
1709 VolCatInfo.VolCatErrors++;
1716 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1719 break; /* ignore message printed later */
1722 clear_cap(CAP_EOF); /* turn off feature */
1727 clear_cap(CAP_EOM); /* turn off feature */
1732 clear_cap(CAP_FSF); /* turn off feature */
1736 clear_cap(CAP_BSF); /* turn off feature */
1740 clear_cap(CAP_FSR); /* turn off feature */
1744 clear_cap(CAP_BSR); /* turn off feature */
1754 #ifdef MTSETDRVBUFFER
1755 case MTSETDRVBUFFER:
1756 msg = "MTSETDRVBUFFER";
1789 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1795 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1796 Emsg0(M_ERROR, 0, errmsg);
1801 * Now we try different methods of clearing the error
1802 * status on the drive so that it is not locked for
1803 * further operations.
1806 /* On some systems such as NetBSD, this clears all errors */
1807 tape_ioctl(m_fd, MTIOCGET, (char *)&mt_stat);
1809 /* Found on Linux */
1813 mt_com.mt_op = MTIOCLRERR;
1814 mt_com.mt_count = 1;
1815 /* Clear any error condition on the tape */
1816 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1817 Dmsg0(200, "Did MTIOCLRERR\n");
1821 /* Typically on FreeBSD */
1825 /* Read and clear SCSI error status */
1826 union mterrstat mt_errstat;
1827 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1828 be.strerror(dev_errno));
1829 tape_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1833 /* Clear Subsystem Exception OSF1 */
1837 mt_com.mt_op = MTCSE;
1838 mt_com.mt_count = 1;
1839 /* Clear any error condition on the tape */
1840 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1841 Dmsg0(200, "Did MTCSE\n");
1849 void DEVICE::close()
1851 Dmsg1(100, "close_dev %s\n", print_name());
1852 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1857 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1859 return; /* already closed */
1871 /* Clean up device packet so it can be reused */
1873 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1874 label_type = B_BACULA_LABEL;
1875 file = block_num = 0;
1878 EndFile = EndBlock = 0;
1880 Slot = -1; /* unknown slot */
1882 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1883 memset(&VolHdr, 0, sizeof(VolHdr));
1885 stop_thread_timer(tid);
1891 * This call closes the device, but it is used in DVD handling
1892 * where we close one part and then open the next part. The
1893 * difference between close_part() and close() is that close_part()
1894 * saves the state information of the device (e.g. the Volume lable,
1895 * the Volume Catalog record, ... This permits opening and closing
1896 * the Volume parts multiple times without losing track of what the
1897 * main Volume parameters are.
1899 void DEVICE::close_part(DCR *dcr)
1901 VOLUME_LABEL saveVolHdr;
1902 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1905 saveVolHdr = VolHdr; /* structure assignment */
1906 saveVolCatInfo = VolCatInfo; /* structure assignment */
1907 close(); /* close current part */
1908 VolHdr = saveVolHdr; /* structure assignment */
1909 VolCatInfo = saveVolCatInfo; /* structure assignment */
1910 dcr->VolCatInfo = saveVolCatInfo; /* structure assignment */
1913 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1917 return lseek_dvd(dcr, offset, whence);
1919 #if defined(HAVE_WIN32)
1920 return ::_lseeki64(m_fd, (__int64)offset, whence);
1922 return ::lseek(m_fd, (off_t)offset, whence);
1929 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1931 Dmsg1(100, "truncate %s\n", print_name());
1934 /* maybe we should rewind and write and eof ???? */
1935 return true; /* we don't really truncate tapes */
1937 return truncate_dvd(dcr);
1939 /* ***FIXME*** we really need to unlink() the file so that
1940 * its name can be changed for a relabel.
1942 if (ftruncate(m_fd, 0) != 0) {
1944 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1945 print_name(), be.strerror());
1953 /* Mount the device.
1954 * If timeout, wait until the mount command returns 0.
1955 * If !timeout, try to mount the device only once.
1957 bool DEVICE::mount(int timeout)
1959 Dmsg0(190, "Enter mount\n");
1962 } else if (requires_mount()) {
1963 return do_mount(1, timeout);
1968 /* Unmount the device
1969 * If timeout, wait until the unmount command returns 0.
1970 * If !timeout, try to unmount the device only once.
1972 bool DEVICE::unmount(int timeout)
1974 Dmsg0(90, "Enter unmount\n");
1976 return do_mount(0, timeout);
1981 /* (Un)mount the device */
1982 bool DEVICE::do_mount(int mount, int dotimeout)
1984 POOL_MEM ocmd(PM_FNAME);
1987 int status, timeout;
1989 sm_check(__FILE__, __LINE__, false);
1992 Dmsg0(200, "======= mount=1\n");
1995 icmd = device->mount_command;
1997 if (!is_mounted()) {
1998 Dmsg0(200, "======= mount=0\n");
2001 icmd = device->unmount_command;
2004 clear_freespace_ok();
2005 edit_mount_codes(ocmd, icmd);
2007 Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2010 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
2015 results = get_memory(4000);
2018 /* If busy retry each second */
2019 Dmsg1(20, "do_mount run_prog=%s\n", ocmd.c_str());
2020 while ((status = run_program_full_output(ocmd.c_str(),
2021 max_open_wait/2, results)) != 0) {
2022 /* Doesn't work with internationalization (This is not a problem) */
2023 if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2026 if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2029 if (timeout-- > 0) {
2030 /* Sometimes the device cannot be mounted because it is already mounted.
2031 * Try to unmount it, then remount it */
2033 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2041 Dmsg5(40, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2042 (mount ? "" : "un"), status, results, be.strerror(status));
2043 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2044 print_name(), (mount ? "" : "un"), be.strerror(status));
2046 Dmsg4(40, "Device %s cannot be %smounted. stat=%d ERR=%s\n", print_name(),
2047 (mount ? "" : "un"), status, results);
2048 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2049 print_name(), (mount ? "" : "un"), results);
2052 * Now, just to be sure it is not mounted, try to read the
2056 struct dirent *entry, *result;
2060 name_max = pathconf(".", _PC_NAME_MAX);
2061 if (name_max < 1024) {
2065 if (!(dp = opendir(device->mount_point))) {
2068 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2069 device->mount_point, print_name(), be.strerror());
2073 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2076 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2078 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
2079 device->mount_point, print_name());
2082 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2083 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2086 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2092 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2095 /* If we got more than ., .. and .keep */
2096 /* there must be something mounted */
2098 Dmsg1(100, "Did Mount by count=%d\n", count);
2101 /* An unmount request. We failed to unmount - report an error */
2103 free_pool_memory(results);
2104 Dmsg0(200, "== error mount=1 wanted unmount\n");
2110 sm_check(__FILE__, __LINE__, false);
2111 free_pool_memory(results);
2112 Dmsg0(200, "============ mount=0\n");
2116 set_mounted(mount); /* set/clear mounted flag */
2117 free_pool_memory(results);
2118 /* Do not check free space when unmounting */
2119 if (mount && !update_freespace()) {
2122 Dmsg1(200, "============ mount=%d\n", mount);
2127 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2129 * %a = archive device name
2130 * %e = erase (set if cannot mount and first part)
2133 * %v = last part name
2135 * omsg = edited output message
2136 * imsg = input string containing edit codes (%x)
2139 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2145 POOL_MEM archive_name(PM_FNAME);
2147 omsg.c_str()[0] = 0;
2148 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2149 for (p=imsg; *p; p++) {
2159 if (num_dvd_parts == 0) {
2160 if (truncating || blank_dvd) {
2170 bsnprintf(add, sizeof(add), "%d", part);
2174 str = device->mount_point;
2177 make_spooled_dvd_filename(this, archive_name);
2178 str = archive_name.c_str();
2192 Dmsg1(1900, "add_str %s\n", str);
2193 pm_strcat(omsg, (char *)str);
2194 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2198 /* return the last timer interval (ms) */
2199 btime_t DEVICE::get_timer_count()
2201 btime_t old = last_timer;
2202 last_timer = get_current_btime();
2203 return last_timer - old;
2207 ssize_t DEVICE::read(void *buf, size_t len)
2213 if (this->is_tape()) {
2214 read_len = tape_read(m_fd, buf, len);
2216 read_len = ::read(m_fd, buf, len);
2219 last_tick = get_timer_count();
2221 DevReadTime += last_tick;
2222 VolCatInfo.VolReadTime += last_tick;
2224 if (read_len > 0) { /* skip error */
2225 DevReadBytes += read_len;
2232 ssize_t DEVICE::write(const void *buf, size_t len)
2238 if (this->is_tape()) {
2239 write_len = tape_write(m_fd, buf, len);
2241 write_len = ::write(m_fd, buf, len);
2244 last_tick = get_timer_count();
2246 DevWriteTime += last_tick;
2247 VolCatInfo.VolWriteTime += last_tick;
2249 if (write_len > 0) { /* skip error */
2250 DevWriteBytes += write_len;
2256 /* Return the resource name for the device */
2257 const char *DEVICE::name() const
2259 return device->hdr.name;
2263 dev_vol_name(DEVICE *dev)
2265 return dev->VolCatInfo.VolCatName;
2270 * Free memory allocated for the device
2272 void DEVICE::term(void)
2274 Dmsg1(900, "term dev: %s\n", print_name());
2277 free_memory(dev_name);
2281 free_memory(prt_name);
2285 free_pool_memory(errmsg);
2288 pthread_mutex_destroy(&m_mutex);
2289 pthread_cond_destroy(&wait);
2290 pthread_cond_destroy(&wait_next_vol);
2291 pthread_mutex_destroy(&spool_mutex);
2292 // rwl_destroy(&lock);
2293 if (attached_dcrs) {
2294 delete attached_dcrs;
2295 attached_dcrs = NULL;
2304 * This routine initializes the device wait timers
2306 void init_device_wait_timers(DCR *dcr)
2308 DEVICE *dev = dcr->dev;
2309 JCR *jcr = dcr->jcr;
2311 /* ******FIXME******* put these on config variables */
2312 dev->min_wait = 60 * 60;
2313 dev->max_wait = 24 * 60 * 60;
2314 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2315 dev->wait_sec = dev->min_wait;
2316 dev->rem_wait_sec = dev->wait_sec;
2319 dev->BadVolName[0] = 0;
2321 jcr->min_wait = 60 * 60;
2322 jcr->max_wait = 24 * 60 * 60;
2323 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2324 jcr->wait_sec = jcr->min_wait;
2325 jcr->rem_wait_sec = jcr->wait_sec;
2330 void init_jcr_device_wait_timers(JCR *jcr)
2332 /* ******FIXME******* put these on config variables */
2333 jcr->min_wait = 60 * 60;
2334 jcr->max_wait = 24 * 60 * 60;
2335 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2336 jcr->wait_sec = jcr->min_wait;
2337 jcr->rem_wait_sec = jcr->wait_sec;
2343 * The dev timers are used for waiting on a particular device
2345 * Returns: true if time doubled
2346 * false if max time expired
2348 bool double_dev_wait_time(DEVICE *dev)
2350 dev->wait_sec *= 2; /* double wait time */
2351 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2352 dev->wait_sec = dev->max_wait;
2355 dev->rem_wait_sec = dev->wait_sec;
2356 if (dev->num_wait >= dev->max_num_wait) {
2363 void set_os_device_parameters(DCR *dcr)
2365 DEVICE *dev = dcr->dev;
2367 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2370 Dmsg0(050, "In set_os_device_parameters\n");
2371 #if defined(MTSETBLK)
2372 if (dev->min_block_size == dev->max_block_size &&
2373 dev->min_block_size == 0) { /* variable block mode */
2374 mt_com.mt_op = MTSETBLK;
2375 mt_com.mt_count = 0;
2376 Dmsg0(050, "Set block size to zero\n");
2377 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2378 dev->clrerror(MTSETBLK);
2382 #if defined(MTSETDRVBUFFER)
2383 if (getpid() == 0) { /* Only root can do this */
2384 mt_com.mt_op = MTSETDRVBUFFER;
2385 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2386 if (!dev->has_cap(CAP_TWOEOF)) {
2387 mt_com.mt_count |= MT_ST_TWO_FM;
2389 if (dev->has_cap(CAP_EOM)) {
2390 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2392 Dmsg0(050, "MTSETDRVBUFFER\n");
2393 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2394 dev->clrerror(MTSETDRVBUFFER);
2401 #ifdef HAVE_NETBSD_OS
2403 if (dev->min_block_size == dev->max_block_size &&
2404 dev->min_block_size == 0) { /* variable block mode */
2405 mt_com.mt_op = MTSETBSIZ;
2406 mt_com.mt_count = 0;
2407 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2408 dev->clrerror(MTSETBSIZ);
2410 /* Get notified at logical end of tape */
2411 mt_com.mt_op = MTEWARN;
2412 mt_com.mt_count = 1;
2413 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2414 dev->clrerror(MTEWARN);
2420 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2422 if (dev->min_block_size == dev->max_block_size &&
2423 dev->min_block_size == 0) { /* variable block mode */
2424 mt_com.mt_op = MTSETBSIZ;
2425 mt_com.mt_count = 0;
2426 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2427 dev->clrerror(MTSETBSIZ);
2430 /* Turn this on later when fully tested */
2431 #if defined(xxxMTIOCSETEOTMODEL)
2433 if (dev->has_cap(CAP_TWOEOF)) {
2438 if (ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2440 dev->dev_errno = errno; /* save errno */
2441 Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2442 dev->print_name(), be.strerror(dev->dev_errno));
2443 Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2451 if (dev->min_block_size == dev->max_block_size &&
2452 dev->min_block_size == 0) { /* variable block mode */
2453 mt_com.mt_op = MTSRSZ;
2454 mt_com.mt_count = 0;
2455 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2456 dev->clrerror(MTSRSZ);
2463 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2465 Dmsg0(050, "dev_get_os_pos\n");
2466 return dev->has_cap(CAP_MTIOCGET) &&
2467 tape_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2468 mt_stat->mt_fileno >= 0;
2471 static char *modes[] = {
2472 "CREATE_READ_WRITE",
2479 static char *mode_to_str(int mode)
2481 static char buf[100];
2482 if (mode < 1 || mode > 4) {
2483 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2486 return modes[mode-1];