2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2010 Free Software Foundation Europe e.V.
6 The main author of Bacula is Kern Sibbald, with contributions from
7 many others, a complete list can be found in the file AUTHORS.
8 This program is Free Software; you can redistribute it and/or
9 modify it under the terms of version two of the GNU General Public
10 License as published by the Free Software Foundation and included
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 Bacula® is a registered trademark of Kern Sibbald.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
30 * dev.c -- low level operations on device (storage device)
34 * NOTE!!!! None of these routines are reentrant. You must
35 * use dev->r_dlock() and dev->unlock() at a higher level,
36 * or use the xxx_device() equivalents. By moving the
37 * thread synchronization to a higher level, we permit
38 * the higher level routines to "seize" the device and
39 * to carry out operations without worrying about who
40 * set what lock (i.e. race conditions).
42 * Note, this is the device dependent code, and may have
43 * to be modified for each system, but is meant to
44 * be as "generic" as possible.
46 * The purpose of this code is to develop a SIMPLE Storage
47 * daemon. More complicated coding (double buffering, writer
48 * thread, ...) is left for a later version.
53 * Handling I/O errors and end of tape conditions are a bit tricky.
54 * This is how it is currently done when writing.
55 * On either an I/O error or end of tape,
56 * we will stop writing on the physical device (no I/O recovery is
57 * attempted at least in this daemon). The state flag will be sent
58 * to include ST_EOT, which is ephemeral, and ST_WEOT, which is
59 * persistent. Lots of routines clear ST_EOT, but ST_WEOT is
60 * cleared only when the problem goes away. Now when ST_WEOT
61 * is set all calls to write_block_to_device() call the fix_up
62 * routine. In addition, all threads are blocked
63 * from writing on the tape by calling lock_dev(), and thread other
64 * than the first thread to hit the EOT will block on a condition
65 * variable. The first thread to hit the EOT will continue to
66 * be able to read and write the tape (he sort of tunnels through
67 * the locking mechanism -- see lock_dev() for details).
69 * Now presumably somewhere higher in the chain of command
70 * (device.c), someone will notice the EOT condition and
71 * get a new tape up, get the tape label read, and mark
72 * the label for rewriting. Then this higher level routine
73 * will write the unwritten buffer to the new volume.
74 * Finally, he will release
75 * any blocked threads by doing a broadcast on the condition
76 * variable. At that point, we should be totally back in
77 * business with no lost data.
88 /* Forward referenced functions */
89 void set_os_device_parameters(DCR *dcr);
90 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat);
91 static const char *mode_to_str(int mode);
94 * Allocate and initialize the DEVICE structure
95 * Note, if dev is non-NULL, it is already allocated,
96 * thus we neither allocate it nor free it. This allows
97 * the caller to put the packet in shared memory.
99 * Note, for a tape, the device->device_name is the device name
100 * (e.g. /dev/nst0), and for a file, the device name
101 * is the directory in which the file will be placed.
105 init_dev(JCR *jcr, DEVRES *device)
114 /* If no device type specified, try to guess */
115 if (!device->dev_type) {
116 /* Check that device is available */
117 if (stat(device->device_name, &statp) < 0) {
119 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
120 device->device_name, be.bstrerror());
123 if (S_ISDIR(statp.st_mode)) {
124 device->dev_type = B_FILE_DEV;
125 } else if (S_ISCHR(statp.st_mode)) {
126 device->dev_type = B_TAPE_DEV;
127 } else if (S_ISFIFO(statp.st_mode)) {
128 device->dev_type = B_FIFO_DEV;
130 /* must set DeviceType = Vtape
131 * in normal mode, autodetection is disabled
133 } else if (S_ISREG(statp.st_mode)) {
134 device->dev_type = B_VTAPE_DEV;
136 } else if (!(device->cap_bits & CAP_REQMOUNT)) {
137 Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
138 " or have RequiresMount=yes for DVD. st_mode=%x\n"),
139 device->device_name, statp.st_mode);
142 device->dev_type = B_DVD_DEV;
146 dev = (DEVICE *)malloc(sizeof(DEVICE));
147 memset(dev, 0, sizeof(DEVICE));
148 dev->clear_slot(); /* unknown */
150 /* Copy user supplied device parameters from Resource */
151 dev->dev_name = get_memory(strlen(device->device_name)+1);
152 pm_strcpy(dev->dev_name, device->device_name);
153 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
154 /* We edit "Resource-name" (physical-name) */
155 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
156 Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
157 dev->capabilities = device->cap_bits;
158 dev->min_block_size = device->min_block_size;
159 dev->max_block_size = device->max_block_size;
160 dev->max_volume_size = device->max_volume_size;
161 dev->max_file_size = device->max_file_size;
162 dev->max_concurrent_jobs = device->max_concurrent_jobs;
163 dev->volume_capacity = device->volume_capacity;
164 dev->max_rewind_wait = device->max_rewind_wait;
165 dev->max_open_wait = device->max_open_wait;
166 dev->max_open_vols = device->max_open_vols;
167 dev->vol_poll_interval = device->vol_poll_interval;
168 dev->max_spool_size = device->max_spool_size;
169 dev->drive_index = device->drive_index;
170 dev->autoselect = device->autoselect;
171 dev->dev_type = device->dev_type;
173 if (dev->is_tape()) { /* No parts on tapes */
174 dev->max_part_size = 0;
176 dev->max_part_size = device->max_part_size;
179 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
180 dev->vol_poll_interval = 60;
182 /* Link the dev and device structures together */
183 dev->device = device;
186 if (dev->is_fifo()) {
187 dev->capabilities |= CAP_STREAM; /* set stream device */
190 /* If the device requires mount :
191 * - Check that the mount point is available
192 * - Check that (un)mount commands are defined
194 if ((dev->is_file() || dev->is_dvd()) && dev->requires_mount()) {
195 if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
197 dev->dev_errno = errno;
198 Jmsg2(jcr, M_ERROR_TERM, 0, _("Unable to stat mount point %s: ERR=%s\n"),
199 device->mount_point, be.bstrerror());
202 if (!device->mount_command || !device->unmount_command) {
203 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
207 if (!device->write_part_command) {
208 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
213 if (dev->max_block_size == 0) {
214 max_bs = DEFAULT_BLOCK_SIZE;
216 max_bs = dev->max_block_size;
218 if (dev->min_block_size > max_bs) {
219 Jmsg(jcr, M_ERROR_TERM, 0, _("Min block size > max on device %s\n"),
222 if (dev->max_block_size > 4096000) {
223 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
224 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
225 dev->max_block_size = 0;
227 if (dev->max_block_size % TAPE_BSIZE != 0) {
228 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
229 dev->max_block_size, dev->print_name());
231 if (dev->max_volume_size != 0 && dev->max_volume_size < (dev->max_block_size << 4)) {
232 Jmsg(jcr, M_ERROR_TERM, 0, _("Max Vol Size < 8 * Max Block Size on device %s\n"),
236 dev->errmsg = get_pool_memory(PM_EMSG);
239 if ((errstat = pthread_mutex_init(&dev->m_mutex, NULL)) != 0) {
241 dev->dev_errno = errstat;
242 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
243 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
245 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
247 dev->dev_errno = errstat;
248 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
249 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
251 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
253 dev->dev_errno = errstat;
254 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
255 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
257 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
259 dev->dev_errno = errstat;
260 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
261 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
263 if ((errstat = pthread_mutex_init(&dev->acquire_mutex, NULL)) != 0) {
265 dev->dev_errno = errstat;
266 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
267 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
269 /* Ensure that we respect this order in P/V operations */
270 bthread_mutex_set_priority(&dev->m_mutex, PRIO_SD_DEV_ACCESS);
271 bthread_mutex_set_priority(&dev->spool_mutex, PRIO_SD_DEV_SPOOL);
272 bthread_mutex_set_priority(&dev->acquire_mutex, PRIO_SD_DEV_ACQUIRE);
274 if ((errstat = rwl_init(&dev->lock)) != 0) {
276 dev->dev_errno = errstat;
277 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
278 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
283 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
284 Dmsg2(100, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
285 dev->initiated = true;
290 /* Choose the right backend */
291 void DEVICE::init_backend()
296 d_open = win32_tape_open;
297 d_write = win32_tape_write;
298 d_close = win32_tape_close;
299 d_ioctl = win32_tape_ioctl;
300 d_read = win32_tape_read;
305 d_ioctl = win32_ioctl; /* dummy function */
306 d_write = win32_write; /* win32 read/write are not POSIX */
310 #else /* POSIX / UNIX Interface */
311 if (is_vtape()) { /* test backend */
312 d_open = vtape_open; /* vtape isn't available for WIN32 or FreeBSD */
313 d_write = vtape_write;
314 d_close = vtape_close;
315 d_ioctl = vtape_ioctl;
318 } else { /* tape and file are using normal io */
329 * Open the device with the operating system and
330 * initialize buffer pointers.
332 * Returns: -1 on error
335 * Note, for a tape, the VolName is the name we give to the
336 * volume (not really used here), but for a file, the
337 * VolName represents the name of the file to be created/opened.
338 * In the case of a file, the full name is the device name
339 * (archive_name) with the VolName concatenated.
342 DEVICE::open(DCR *dcr, int omode)
346 if (openmode == omode) {
351 Dmsg0(100, "Close fd for mode change.\n");
352 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
356 VolCatInfo = dcr->VolCatInfo; /* structure assign */
359 Dmsg4(100, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
360 print_name(), getVolCatName(), mode_to_str(omode));
361 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
362 label_type = B_BACULA_LABEL;
363 if (is_tape() || is_fifo()) {
364 open_tape_device(dcr, omode);
365 } else if (is_dvd()) {
366 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
367 open_dvd_device(dcr, omode);
369 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
370 open_file_device(dcr, omode);
372 state |= preserve; /* reset any important state info */
373 Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, m_fd);
377 void DEVICE::set_mode(int new_mode)
380 case CREATE_READ_WRITE:
381 mode = O_CREAT | O_RDWR | O_BINARY;
383 case OPEN_READ_WRITE:
384 mode = O_RDWR | O_BINARY;
387 mode = O_RDONLY | O_BINARY;
389 case OPEN_WRITE_ONLY:
390 mode = O_WRONLY | O_BINARY;
393 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
399 void DEVICE::open_tape_device(DCR *dcr, int omode)
402 int timeout = max_open_wait;
403 #if !defined(HAVE_WIN32)
405 utime_t start_time = time(NULL);
408 mount(1); /* do mount if required */
410 Dmsg0(100, "Open dev: device is tape\n");
412 get_autochanger_loaded_slot(dcr);
421 if (is_fifo() && timeout) {
423 tid = start_thread_timer(dcr->jcr, pthread_self(), timeout);
425 Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
426 #if defined(HAVE_WIN32)
429 if ((m_fd = d_open(dev_name, mode)) < 0) {
436 /* If busy retry each second for max_open_wait seconds */
438 /* Try non-blocking open */
439 m_fd = d_open(dev_name, mode+O_NONBLOCK);
443 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
444 print_name(), omode, mode, errno, be.bstrerror());
446 /* Tape open, now rewind it */
447 Dmsg0(100, "Rewind after open\n");
448 mt_com.mt_op = MTREW;
450 /* rewind only if dev is a tape */
451 if (is_tape() && (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0)) {
453 dev_errno = errno; /* set error status from rewind */
456 Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
457 be.bstrerror(dev_errno));
458 /* If we get busy, device is probably rewinding, try again */
459 if (dev_errno != EBUSY) {
460 break; /* error -- no medium */
463 /* Got fd and rewind worked, so we must have medium in drive */
465 m_fd = d_open(dev_name, mode); /* open normally */
469 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
470 print_name(), omode, mode, errno, be.bstrerror());
475 set_os_device_parameters(dcr); /* do system dependent stuff */
476 break; /* Successfully opened and rewound */
480 /* Exceed wait time ? */
481 if (time(NULL) - start_time >= max_open_wait) {
482 break; /* yes, get out */
489 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
490 print_name(), be.bstrerror(dev_errno));
491 Dmsg1(100, "%s", errmsg);
494 /* Stop any open() timer we started */
496 stop_thread_timer(tid);
499 Dmsg1(100, "open dev: tape %d opened\n", m_fd);
506 void DEVICE::open_file_device(DCR *dcr, int omode)
508 POOL_MEM archive_name(PM_FNAME);
510 get_autochanger_loaded_slot(dcr);
513 * Handle opening of File Archive (not a tape)
516 pm_strcpy(archive_name, dev_name);
518 * If this is a virtual autochanger (i.e. changer_res != NULL)
519 * we simply use the device name, assuming it has been
520 * appropriately setup by the "autochanger".
522 if (!device->changer_res || device->changer_command[0] == 0) {
523 if (VolCatInfo.VolCatName[0] == 0) {
524 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
530 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
531 pm_strcat(archive_name, "/");
533 pm_strcat(archive_name, getVolCatName());
536 mount(1); /* do mount if required */
540 /* If creating file, give 0640 permissions */
541 Dmsg3(100, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
542 archive_name.c_str(), mode);
543 /* Use system open() */
544 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
547 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
549 Dmsg1(100, "open failed: %s", errmsg);
550 // Jmsg1(NULL, M_WARNING, 0, "%s", errmsg);
556 Dmsg4(100, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
557 m_fd, part, num_dvd_parts, part_size);
561 * Open a DVD device. N.B. at this point, dcr->getVolCatName()
562 * (NB:??? I think it's getVolCatName() that is right)
563 * has the desired Volume name, but there is NO assurance that
564 * any other field of VolCatInfo is correct.
566 void DEVICE::open_dvd_device(DCR *dcr, int omode)
568 POOL_MEM archive_name(PM_FNAME);
569 struct stat filestat;
572 * Handle opening of DVD Volume
574 Dmsg2(100, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n",
575 &dcr->VolCatInfo, mode_to_str(omode));
578 * For a DVD we must always pull the state info from dcr->VolCatInfo
579 * This is a bit ugly, but is necessary because we need to open/close/re-open
580 * the dvd file in order to properly mount/unmount and access the
581 * DVD. So we store the state of the DVD as far as is known in the
582 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
583 * copy here, when opening.
585 VolCatInfo = dcr->VolCatInfo; /* structure assignment */
586 Dmsg1(100, "Volume=%s\n", getVolCatName());
588 if (VolCatInfo.VolCatName[0] == 0) {
589 Dmsg1(10, "Could not open DVD device %s. No Volume name given.\n",
591 Mmsg(errmsg, _("Could not open DVD device %s. No Volume name given.\n"),
598 Dmsg0(100, "Set part=1\n");
599 part = 1; /* count from 1 */
603 if (num_dvd_parts != VolCatInfo.VolCatParts) {
604 num_dvd_parts = VolCatInfo.VolCatParts;
608 * If we are not trying to access the last part, set mode to
609 * OPEN_READ_ONLY as writing would be an error.
611 Dmsg2(100, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
612 /* Now find the name of the part that we want to access */
613 if (part <= num_dvd_parts) {
614 omode = OPEN_READ_ONLY;
615 make_mounted_dvd_filename(this, archive_name);
616 set_part_spooled(false);
618 omode = OPEN_READ_WRITE;
619 make_spooled_dvd_filename(this, archive_name);
620 set_part_spooled(true);
624 // Clear any previous blank_dvd status - we will recalculate it here
627 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
628 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
631 Dmsg0(99, "DVD device mounted.\n");
632 if (num_dvd_parts == 0 && !truncating) {
634 * If we can mount the device, and we are not truncating the DVD,
635 * we usually want to abort. There is one exception, if there is
636 * only one 0-sized file on the DVD, with the right volume name,
637 * we continue (it's the method used by truncate_dvd to truncate a volume).
639 if (!check_can_write_on_non_blank_dvd(dcr)) {
640 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
641 Emsg0(M_FATAL, 0, errmsg);
642 unmount(1); /* Unmount the device, so the operator can change it. */
649 * Ensure that we have the correct DVD loaded by looking for part1.
650 * We only succeed the open if it exists. Failure to do this could
651 * leave us trying to add a part to a different DVD!
653 uint32_t oldpart = part;
655 POOL_MEM part1_name(PM_FNAME);
657 make_mounted_dvd_filename(this, part1_name);
659 if (stat(part1_name.c_str(), &statp) < 0) {
661 Mmsg(errmsg, _("Unable to stat DVD part 1 file %s: ERR=%s\n"),
662 part1_name.c_str(), be.bstrerror());
663 Emsg0(M_FATAL, 0, errmsg);
667 if (!S_ISREG(statp.st_mode)) {
668 /* It is not a regular file */
669 Mmsg(errmsg, _("DVD part 1 is not a regular file %s.\n"),
671 Emsg0(M_FATAL, 0, errmsg);
677 Dmsg0(99, "DVD device mount failed.\n");
678 /* We cannot mount the device */
679 if (num_dvd_parts == 0) {
680 /* Run free space, check there is a media. */
681 if (!update_freespace()) {
682 Emsg0(M_FATAL, 0, errmsg);
687 Dmsg1(100, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
689 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
690 Emsg0(M_FATAL, 0, errmsg);
695 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
696 Emsg0(M_FATAL, 0, errmsg);
702 Dmsg5(100, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
703 archive_name.c_str(), mode_to_str(omode),
704 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
706 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
709 /* If creating file, give 0640 permissions */
710 Dmsg3(100, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
711 archive_name.c_str(), mode);
712 /* Use system open() */
713 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
715 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
717 // Should this be set if we try the create/open below
718 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
719 Dmsg1(100, "open failed: %s", errmsg);
721 /* Previous open failed. See if we can recover */
722 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
723 (part > num_dvd_parts)) {
724 /* If the last part (on spool), doesn't exist when accessing,
725 * create it. In read/write mode a write will be allowed (higher
726 * level software thinks that we are extending a pre-existing
727 * media. Reads for READ_ONLY will report immediately an EOF
728 * Sometimes it is better to finish with an EOF than with an error. */
729 Dmsg1(100, "Creating last part on spool: %s\n", archive_name.c_str());
730 omode = CREATE_READ_WRITE;
731 set_mode(CREATE_READ_WRITE);
732 m_fd = ::open(archive_name.c_str(), mode, 0640);
736 Dmsg1(100, "after open fd=%d\n", m_fd);
738 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
741 /* Get size of file */
742 if (fstat(m_fd, &filestat) < 0) {
745 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
747 Dmsg1(100, "open failed: %s", errmsg);
748 /* Use system close() */
752 part_size = filestat.st_size;
754 update_pos(dcr); /* update position */
762 * Returns: true on success
765 bool DEVICE::rewind(DCR *dcr)
771 Dmsg3(400, "rewind res=%d fd=%d %s\n", num_reserved(), m_fd, print_name());
772 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
773 block_num = file = 0;
777 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
779 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
781 Emsg0(M_ABORT, 0, errmsg);
786 mt_com.mt_op = MTREW;
788 /* If we get an I/O error on rewind, it is probably because
789 * the drive is actually busy. We loop for (about 5 minutes)
790 * retrying every 5 seconds.
792 for (i=max_rewind_wait; ; i -= 5) {
793 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
796 if (i == max_rewind_wait) {
797 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.bstrerror());
800 * This is a gross hack, because if the user has the
801 * device mounted (i.e. open), then uses mtx to load
802 * a tape, the current open file descriptor is invalid.
803 * So, we close the drive and re-open it.
806 int open_mode = openmode;
809 open(dcr, open_mode);
817 if (dev_errno == EIO) {
818 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
822 if (dev_errno == EIO && i > 0) {
823 Dmsg0(200, "Sleeping 5 seconds.\n");
828 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
829 print_name(), be.bstrerror());
834 } else if (is_file() || is_dvd()) {
835 if (lseek(dcr, (boffset_t)0, SEEK_SET) < 0) {
838 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
839 print_name(), be.bstrerror());
848 * Called to indicate that we have just read an
849 * EOF from the device.
851 void DEVICE::set_ateof()
863 * Called to indicate we are now at the end of the tape, and
864 * writing is not possible.
866 void DEVICE::set_ateot()
868 /* Make tape effectively read-only */
869 state |= (ST_EOF|ST_EOT|ST_WEOT);
874 * Position device to end of medium (end of data)
875 * Returns: true on succes
878 bool DEVICE::eod(DCR *dcr)
887 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
891 #if defined (__digital__) && defined (__unix__)
892 return fsf(VolCatInfo.VolCatFiles);
895 Dmsg0(100, "Enter eod\n");
899 clear_eof(); /* remove EOF flag */
900 block_num = file = 0;
907 pos = lseek(dcr, (boffset_t)0, SEEK_END);
908 Dmsg1(200, "====== Seek to %lld\n", pos);
916 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
917 print_name(), be.bstrerror());
922 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
923 Dmsg0(100,"Using FAST FSF for EOM\n");
924 /* If unknown position, rewind */
925 if (get_os_tape_file() < 0) {
927 Dmsg0(100, "Rewind error\n");
931 mt_com.mt_op = MTFSF;
933 * ***FIXME*** fix code to handle case that INT16_MAX is
936 mt_com.mt_count = INT16_MAX; /* use big positive number */
937 if (mt_com.mt_count < 0) {
938 mt_com.mt_count = INT16_MAX; /* brain damaged system */
942 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
943 if (has_cap(CAP_EOM)) {
944 Dmsg0(100,"Using EOM for EOM\n");
945 mt_com.mt_op = MTEOM;
949 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
951 clrerror(mt_com.mt_op);
952 Dmsg1(50, "ioctl error: %s\n", be.bstrerror());
954 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
955 print_name(), be.bstrerror());
960 os_file = get_os_tape_file();
964 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
965 print_name(), be.bstrerror());
969 Dmsg1(100, "EOD file=%d\n", os_file);
977 * Rewind then use FSF until EOT reached
980 Dmsg0(100, "Rewind error.\n");
984 * Move file by file to the end of the tape
987 for (file_num=file; !at_eot(); file_num++) {
988 Dmsg0(200, "eod: doing fsf 1\n");
990 Dmsg0(100, "fsf error.\n");
994 * Avoid infinite loop by ensuring we advance.
996 if (!at_eot() && file_num == (int)file) {
997 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
999 os_file = get_os_tape_file();
1001 Dmsg2(100, "Adjust file from %d to %d\n", file_num, os_file);
1009 * Some drivers leave us after second EOF when doing
1010 * MTEOM, so we must backup so that appending overwrites
1013 if (has_cap(CAP_BSFATEOM)) {
1014 /* Backup over EOF */
1016 /* If BSF worked and fileno is known (not -1), set file */
1017 os_file = get_os_tape_file();
1019 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , os_file);
1022 file++; /* wing it -- not correct on all OSes */
1025 update_pos(dcr); /* update position */
1027 Dmsg1(200, "EOD dev->file=%d\n", file);
1032 * Set the position of the device -- only for files and DVD
1033 * For other devices, there is no generic way to do it.
1034 * Returns: true on succes
1037 bool DEVICE::update_pos(DCR *dcr)
1044 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
1045 Emsg1(M_FATAL, 0, "%s", errmsg);
1049 /* Find out where we are */
1050 if (is_file() || is_dvd()) {
1053 pos = lseek(dcr, (boffset_t)0, SEEK_CUR);
1057 Pmsg1(000, _("Seek error: ERR=%s\n"), be.bstrerror());
1058 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1059 print_name(), be.bstrerror());
1063 block_num = (uint32_t)pos;
1064 file = (uint32_t)(pos >> 32);
1071 * Return the status of the device. This was meant
1072 * to be a generic routine. Unfortunately, it doesn't
1073 * seem possible (at least I do not know how to do it
1074 * currently), which means that for the moment, this
1075 * routine has very little value.
1079 uint32_t status_dev(DEVICE *dev)
1081 struct mtget mt_stat;
1084 if (dev->state & (ST_EOT | ST_WEOT)) {
1088 if (dev->state & ST_EOF) {
1092 if (dev->is_tape()) {
1094 Pmsg0(-20,_(" Bacula status:"));
1095 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1096 if (dev->d_ioctl(dev->fd(), MTIOCGET, (char *)&mt_stat) < 0) {
1098 dev->dev_errno = errno;
1099 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1100 dev->print_name(), be.bstrerror());
1103 Pmsg0(-20, _(" Device status:"));
1105 #if defined(HAVE_LINUX_OS)
1106 if (GMT_EOF(mt_stat.mt_gstat)) {
1110 if (GMT_BOT(mt_stat.mt_gstat)) {
1114 if (GMT_EOT(mt_stat.mt_gstat)) {
1118 if (GMT_SM(mt_stat.mt_gstat)) {
1122 if (GMT_EOD(mt_stat.mt_gstat)) {
1126 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1127 stat |= BMT_WR_PROT;
1128 Pmsg0(-20, " WR_PROT");
1130 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1132 Pmsg0(-20, " ONLINE");
1134 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1135 stat |= BMT_DR_OPEN;
1136 Pmsg0(-20, " DR_OPEN");
1138 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1139 stat |= BMT_IM_REP_EN;
1140 Pmsg0(-20, " IM_REP_EN");
1142 #elif defined(HAVE_WIN32)
1143 if (GMT_EOF(mt_stat.mt_gstat)) {
1147 if (GMT_BOT(mt_stat.mt_gstat)) {
1151 if (GMT_EOT(mt_stat.mt_gstat)) {
1155 if (GMT_EOD(mt_stat.mt_gstat)) {
1159 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1160 stat |= BMT_WR_PROT;
1161 Pmsg0(-20, " WR_PROT");
1163 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1165 Pmsg0(-20, " ONLINE");
1167 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1168 stat |= BMT_DR_OPEN;
1169 Pmsg0(-20, " DR_OPEN");
1171 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1172 stat |= BMT_IM_REP_EN;
1173 Pmsg0(-20, " IM_REP_EN");
1176 #endif /* !SunOS && !OSF */
1177 if (dev->has_cap(CAP_MTIOCGET)) {
1178 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1180 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1183 stat |= BMT_ONLINE | BMT_BOT;
1190 * Load medium in device
1191 * Returns: true on success
1194 bool load_dev(DEVICE *dev)
1200 if (dev->fd() < 0) {
1201 dev->dev_errno = EBADF;
1202 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1203 Emsg0(M_FATAL, 0, dev->errmsg);
1206 if (!(dev->is_tape())) {
1210 Dmsg0(200, "stored: MTLOAD command not available\n");
1212 dev->dev_errno = ENOTTY; /* function not available */
1213 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1214 dev->print_name(), be.bstrerror());
1218 dev->block_num = dev->file = 0;
1221 mt_com.mt_op = MTLOAD;
1222 mt_com.mt_count = 1;
1223 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
1225 dev->dev_errno = errno;
1226 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1227 dev->print_name(), be.bstrerror());
1235 * Rewind device and put it offline
1236 * Returns: true on success
1239 bool DEVICE::offline()
1244 return true; /* device not open */
1247 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1248 block_num = file = 0;
1252 mt_com.mt_op = MTOFFL;
1253 mt_com.mt_count = 1;
1254 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
1257 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1258 print_name(), be.bstrerror());
1261 Dmsg1(100, "Offlined device %s\n", print_name());
1265 bool DEVICE::offline_or_rewind()
1270 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1274 * Note, this rewind probably should not be here (it wasn't
1275 * in prior versions of Bacula), but on FreeBSD, this is
1276 * needed in the case the tape was "frozen" due to an error
1277 * such as backspacing after writing and EOF. If it is not
1278 * done, all future references to the drive get and I/O error.
1281 return rewind(NULL);
1286 * Foward space a file
1287 * Returns: true on success
1290 bool DEVICE::fsf(int num)
1292 int32_t os_file = 0;
1298 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1299 Emsg0(M_FATAL, 0, errmsg);
1309 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1313 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1316 Dmsg0(100, "fsf\n");
1319 * If Fast forward space file is set, then we
1320 * use MTFSF to forward space and MTIOCGET
1321 * to get the file position. We assume that
1322 * the SCSI driver will ensure that we do not
1323 * forward space past the end of the medium.
1325 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1327 mt_com.mt_op = MTFSF;
1328 mt_com.mt_count = num;
1329 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1331 my_errno = errno; /* save errno */
1332 } else if ((os_file=get_os_tape_file()) < 0) {
1333 my_errno = errno; /* save errno */
1335 if (my_errno != 0) {
1338 Dmsg0(200, "Set ST_EOT\n");
1340 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1341 print_name(), be.bstrerror(my_errno));
1342 Dmsg1(200, "%s", errmsg);
1346 Dmsg1(200, "fsf file=%d\n", os_file);
1352 * Here if CAP_FSF is set, and virtually all drives
1353 * these days support it, we read a record, then forward
1354 * space one file. Using this procedure, which is slow,
1355 * is the only way we can be sure that we don't read
1356 * two consecutive EOF marks, which means End of Data.
1358 } else if (has_cap(CAP_FSF)) {
1361 Dmsg0(200, "FSF has cap_fsf\n");
1362 if (max_block_size == 0) {
1363 rbuf_len = DEFAULT_BLOCK_SIZE;
1365 rbuf_len = max_block_size;
1367 rbuf = get_memory(rbuf_len);
1368 mt_com.mt_op = MTFSF;
1369 mt_com.mt_count = 1;
1370 while (num-- && !at_eot()) {
1371 Dmsg0(100, "Doing read before fsf\n");
1372 if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1373 if (errno == ENOMEM) { /* tape record exceeds buf len */
1374 stat = rbuf_len; /* This is OK */
1376 * On IBM drives, they return ENOSPC at EOM
1377 * instead of EOF status
1379 } else if (at_eof() && errno == ENOSPC) {
1385 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1387 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1388 print_name(), be.bstrerror());
1389 Dmsg1(100, "%s", errmsg);
1393 if (stat == 0) { /* EOF */
1394 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1395 /* Two reads of zero means end of tape */
1398 Dmsg0(100, "Set ST_EOT\n");
1404 } else { /* Got data */
1409 Dmsg0(100, "Doing MTFSF\n");
1410 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1411 if (stat < 0) { /* error => EOT */
1414 Dmsg0(100, "Set ST_EOT\n");
1416 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1417 print_name(), be.bstrerror());
1418 Dmsg0(100, "Got < 0 for MTFSF\n");
1419 Dmsg1(100, "%s", errmsg);
1427 * No FSF, so use FSR to simulate it
1430 Dmsg0(200, "Doing FSR for FSF\n");
1431 while (num-- && !at_eot()) {
1432 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1436 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1442 Dmsg1(200, "Return %d from FSF\n", stat);
1444 Dmsg0(200, "ST_EOF set on exit FSF\n");
1447 Dmsg0(200, "ST_EOT set on exit FSF\n");
1449 Dmsg1(200, "Return from FSF file=%d\n", file);
1454 * Backward space a file
1455 * Returns: false on failure
1458 bool DEVICE::bsf(int num)
1465 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1466 Emsg0(M_FATAL, 0, errmsg);
1471 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1476 Dmsg0(100, "bsf\n");
1482 mt_com.mt_op = MTBSF;
1483 mt_com.mt_count = num;
1484 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1488 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1489 print_name(), be.bstrerror());
1496 * Foward space num records
1497 * Returns: false on failure
1500 bool DEVICE::fsr(int num)
1507 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1508 Emsg0(M_FATAL, 0, errmsg);
1516 if (!has_cap(CAP_FSR)) {
1517 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1521 Dmsg1(100, "fsr %d\n", num);
1522 mt_com.mt_op = MTFSR;
1523 mt_com.mt_count = num;
1524 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1530 struct mtget mt_stat;
1532 Dmsg1(100, "FSF fail: ERR=%s\n", be.bstrerror());
1533 if (dev_get_os_pos(this, &mt_stat)) {
1534 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1535 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1536 file = mt_stat.mt_fileno;
1537 block_num = mt_stat.mt_blkno;
1545 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1546 num, print_name(), be.bstrerror());
1552 * Backward space a record
1553 * Returns: false on failure
1556 bool DEVICE::bsr(int num)
1563 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1564 Emsg0(M_FATAL, 0, errmsg);
1572 if (!has_cap(CAP_BSR)) {
1573 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1577 Dmsg0(100, "bsr_dev\n");
1581 mt_com.mt_op = MTBSR;
1582 mt_com.mt_count = num;
1583 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1587 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1588 print_name(), be.bstrerror());
1593 void DEVICE::lock_door()
1597 mt_com.mt_op = MTLOCK;
1598 mt_com.mt_count = 1;
1599 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1603 void DEVICE::unlock_door()
1607 mt_com.mt_op = MTUNLOCK;
1608 mt_com.mt_count = 1;
1609 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1613 void DEVICE::set_slot(int32_t slot)
1616 if (vol) vol->clear_slot();
1619 void DEVICE::clear_slot()
1622 if (vol) vol->set_slot(-1);
1628 * Reposition the device to file, block
1629 * Returns: false on failure
1632 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1636 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1637 Emsg0(M_FATAL, 0, errmsg);
1642 boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1643 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1644 if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1647 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1648 print_name(), be.bstrerror());
1657 /* After this point, we are tape only */
1658 Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1660 Dmsg0(100, "Rewind\n");
1661 if (!rewind(NULL)) {
1666 Dmsg1(100, "fsf %d\n", rfile-file);
1667 if (!fsf(rfile-file)) {
1668 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1671 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1673 if (rblock < block_num) {
1674 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1675 Dmsg0(100, "bsf 1\n");
1677 Dmsg0(100, "fsf 1\n");
1679 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1681 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1682 /* Ignore errors as Bacula can read to the correct block */
1683 Dmsg1(100, "fsr %d\n", rblock-block_num);
1684 return fsr(rblock-block_num);
1686 while (rblock > block_num) {
1687 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1690 Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1691 print_name(), be.bstrerror());
1694 Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1703 * Write an end of file on the device
1704 * Returns: true on success
1707 bool DEVICE::weof(int num)
1711 Dmsg1(129, "=== weof_dev=%s\n", print_name());
1715 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1716 Emsg0(M_FATAL, 0, errmsg);
1724 if (!can_append()) {
1725 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1726 Emsg0(M_FATAL, 0, errmsg);
1732 mt_com.mt_op = MTWEOF;
1733 mt_com.mt_count = num;
1734 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1743 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1744 print_name(), be.bstrerror());
1752 * If implemented in system, clear the tape
1755 void DEVICE::clrerror(int func)
1757 const char *msg = NULL;
1760 dev_errno = errno; /* save errno */
1762 VolCatInfo.VolCatErrors++;
1769 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1772 break; /* ignore message printed later */
1775 clear_cap(CAP_EOF); /* turn off feature */
1780 clear_cap(CAP_EOM); /* turn off feature */
1785 clear_cap(CAP_FSF); /* turn off feature */
1789 clear_cap(CAP_BSF); /* turn off feature */
1793 clear_cap(CAP_FSR); /* turn off feature */
1797 clear_cap(CAP_BSR); /* turn off feature */
1807 #ifdef MTSETDRVBUFFER
1808 case MTSETDRVBUFFER:
1809 msg = "MTSETDRVBUFFER";
1842 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1848 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1849 Emsg0(M_ERROR, 0, errmsg);
1854 * Now we try different methods of clearing the error
1855 * status on the drive so that it is not locked for
1856 * further operations.
1859 /* On some systems such as NetBSD, this clears all errors */
1862 /* Found on Solaris */
1865 d_ioctl(m_fd, MTIOCLRERR);
1866 Dmsg0(200, "Did MTIOCLRERR\n");
1870 /* Typically on FreeBSD */
1874 /* Read and clear SCSI error status */
1875 union mterrstat mt_errstat;
1876 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1877 be.bstrerror(dev_errno));
1878 d_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1882 /* Clear Subsystem Exception OSF1 */
1886 mt_com.mt_op = MTCSE;
1887 mt_com.mt_count = 1;
1888 /* Clear any error condition on the tape */
1889 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1890 Dmsg0(200, "Did MTCSE\n");
1897 * Set to unload the current volume in the drive
1899 void DEVICE::set_unload()
1901 if (!m_unload && VolHdr.VolumeName[0] != 0) {
1903 memcpy(UnloadVolName, VolHdr.VolumeName, sizeof(UnloadVolName));
1909 * Clear volume header
1911 void DEVICE::clear_volhdr()
1913 Dmsg1(100, "Clear volhdr vol=%s\n", VolHdr.VolumeName);
1914 memset(&VolHdr, 0, sizeof(VolHdr));
1915 setVolCatInfo(false);
1922 void DEVICE::close()
1924 Dmsg1(100, "close_dev %s\n", print_name());
1925 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1930 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1932 return; /* already closed */
1945 unmount(1); /* do unmount if required */
1947 /* Clean up device packet so it can be reused */
1950 * Be careful not to clear items needed by the DVD driver
1951 * when it is closing a single part.
1953 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF|
1954 ST_MOUNTED|ST_MEDIA|ST_SHORT);
1955 label_type = B_BACULA_LABEL;
1956 file = block_num = 0;
1959 EndFile = EndBlock = 0;
1962 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1964 stop_thread_timer(tid);
1970 * This call closes the device, but it is used in DVD handling
1971 * where we close one part and then open the next part. The
1972 * difference between close_part() and close() is that close_part()
1973 * saves the state information of the device (e.g. the Volume lable,
1974 * the Volume Catalog record, ... This permits opening and closing
1975 * the Volume parts multiple times without losing track of what the
1976 * main Volume parameters are.
1978 void DEVICE::close_part(DCR * /*dcr*/)
1980 VOLUME_LABEL saveVolHdr;
1981 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1984 saveVolHdr = VolHdr; /* structure assignment */
1985 saveVolCatInfo = VolCatInfo; /* structure assignment */
1986 close(); /* close current part */
1987 VolHdr = saveVolHdr; /* structure assignment */
1988 VolCatInfo = saveVolCatInfo; /* structure assignment */
1991 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1995 return lseek_dvd(dcr, offset, whence);
1997 #if defined(HAVE_WIN32)
1998 return ::_lseeki64(m_fd, (__int64)offset, whence);
2000 return ::lseek(m_fd, offset, whence);
2007 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
2011 Dmsg1(100, "truncate %s\n", print_name());
2016 /* maybe we should rewind and write and eof ???? */
2017 return true; /* we don't really truncate tapes */
2019 return truncate_dvd(dcr);
2021 if (ftruncate(m_fd, 0) != 0) {
2023 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
2024 print_name(), be.bstrerror());
2029 * Check for a successful ftruncate() and issue a work-around for devices
2030 * (mostly cheap NAS) that don't support truncation.
2031 * Workaround supplied by Martin Schmid as a solution to bug #1011.
2034 * 3. open new file with same mode
2035 * 4. change ownership to original
2038 if (fstat(m_fd, &st) != 0) {
2040 Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"),
2041 print_name(), be.bstrerror());
2045 if (st.st_size != 0) { /* ftruncate() didn't work */
2046 POOL_MEM archive_name(PM_FNAME);
2048 pm_strcpy(archive_name, dev_name);
2049 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
2050 pm_strcat(archive_name, "/");
2052 pm_strcat(archive_name, dcr->VolumeName);
2054 Mmsg2(errmsg, _("Device %s doesn't support ftruncate(). Recreating file %s.\n"),
2055 print_name(), archive_name.c_str());
2057 /* Close file and blow it away */
2059 ::unlink(archive_name.c_str());
2061 /* Recreate the file -- of course, empty */
2062 set_mode(CREATE_READ_WRITE);
2063 if ((m_fd = ::open(archive_name.c_str(), mode, st.st_mode)) < 0) {
2066 Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), archive_name.c_str(),
2068 Dmsg1(100, "reopen failed: %s", errmsg);
2069 Emsg0(M_FATAL, 0, errmsg);
2073 /* Reset proper owner */
2074 chown(archive_name.c_str(), st.st_uid, st.st_gid);
2084 * If timeout, wait until the mount command returns 0.
2085 * If !timeout, try to mount the device only once.
2087 bool DEVICE::mount(int timeout)
2089 Dmsg0(190, "Enter mount\n");
2099 if (device->mount_command) {
2100 return do_tape_mount(1, timeout);
2105 if (requires_mount() && device->mount_command) {
2106 return do_file_mount(1, timeout);
2117 * Unmount the device
2118 * If timeout, wait until the unmount command returns 0.
2119 * If !timeout, try to unmount the device only once.
2121 bool DEVICE::unmount(int timeout)
2123 Dmsg0(100, "Enter unmount\n");
2125 if (!is_mounted()) {
2133 if (device->unmount_command) {
2134 return do_tape_mount(0, timeout);
2139 if (requires_mount() && device->unmount_command) {
2140 return do_file_mount(0, timeout);
2151 * (Un)mount the device (for tape devices)
2153 bool DEVICE::do_tape_mount(int mount, int dotimeout)
2155 POOL_MEM ocmd(PM_FNAME);
2163 icmd = device->mount_command;
2165 icmd = device->unmount_command;
2168 edit_mount_codes(ocmd, icmd);
2170 Dmsg2(100, "do_tape_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2173 /* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
2178 results = get_memory(4000);
2180 /* If busy retry each second */
2181 Dmsg1(100, "do_tape_mount run_prog=%s\n", ocmd.c_str());
2182 while ((status = run_program_full_output(ocmd.c_str(), max_open_wait/2, results)) != 0) {
2187 Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2188 (mount ? "" : "un"), status, results, be.bstrerror(status));
2189 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2190 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2193 free_pool_memory(results);
2194 Dmsg0(200, "============ mount=0\n");
2199 set_mounted(mount); /* set/clear mounted flag */
2200 free_pool_memory(results);
2201 Dmsg1(200, "============ mount=%d\n", mount);
2206 * (Un)mount the device (either a FILE or DVD device)
2208 bool DEVICE::do_file_mount(int mount, int dotimeout)
2210 POOL_MEM ocmd(PM_FNAME);
2214 struct dirent *entry, *result;
2215 int status, tries, name_max, count;
2220 icmd = device->mount_command;
2222 icmd = device->unmount_command;
2225 clear_freespace_ok();
2226 edit_mount_codes(ocmd, icmd);
2228 Dmsg2(100, "do_file_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2231 /* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
2236 results = get_memory(4000);
2238 /* If busy retry each second */
2239 Dmsg1(100, "do_file_mount run_prog=%s\n", ocmd.c_str());
2240 while ((status = run_program_full_output(ocmd.c_str(), max_open_wait/2, results)) != 0) {
2241 /* Doesn't work with internationalization (This is not a problem) */
2242 if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2245 if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2249 /* Sometimes the device cannot be mounted because it is already mounted.
2250 * Try to unmount it, then remount it */
2252 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2253 do_file_mount(0, 0);
2258 Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2259 (mount ? "" : "un"), status, results, be.bstrerror(status));
2260 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2261 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2264 * Now, just to be sure it is not mounted, try to read the filesystem.
2266 name_max = pathconf(".", _PC_NAME_MAX);
2267 if (name_max < 1024) {
2271 if (!(dp = opendir(device->mount_point))) {
2274 Dmsg3(100, "do_file_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2275 device->mount_point, print_name(), be.bstrerror());
2279 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2282 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2284 Dmsg2(129, "do_file_mount: failed to find suitable file in dir %s (dev=%s)\n",
2285 device->mount_point, print_name());
2288 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2289 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2292 Dmsg2(129, "do_file_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2298 Dmsg1(100, "do_file_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2301 /* If we got more than ., .. and .keep */
2302 /* there must be something mounted */
2304 Dmsg1(100, "Did Mount by count=%d\n", count);
2307 /* An unmount request. We failed to unmount - report an error */
2309 free_pool_memory(results);
2310 Dmsg0(200, "== error mount=1 wanted unmount\n");
2316 free_pool_memory(results);
2317 Dmsg0(200, "============ mount=0\n");
2322 set_mounted(mount); /* set/clear mounted flag */
2323 free_pool_memory(results);
2324 /* Do not check free space when unmounting */
2325 if (mount && !update_freespace()) {
2328 Dmsg1(200, "============ mount=%d\n", mount);
2333 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2335 * %a = archive device name
2336 * %e = erase (set if cannot mount and first part)
2339 * %v = last part name
2341 * omsg = edited output message
2342 * imsg = input string containing edit codes (%x)
2345 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2351 POOL_MEM archive_name(PM_FNAME);
2353 omsg.c_str()[0] = 0;
2354 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2355 for (p=imsg; *p; p++) {
2365 if (num_dvd_parts == 0) {
2366 if (truncating || blank_dvd) {
2376 bsnprintf(add, sizeof(add), "%d", part);
2380 str = device->mount_point;
2383 make_spooled_dvd_filename(this, archive_name);
2384 str = archive_name.c_str();
2398 Dmsg1(1900, "add_str %s\n", str);
2399 pm_strcat(omsg, (char *)str);
2400 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2404 /* return the last timer interval (ms)
2405 * or 0 if something goes wrong
2407 btime_t DEVICE::get_timer_count()
2409 btime_t temp = last_timer;
2410 last_timer = get_current_btime();
2411 temp = last_timer - temp; /* get elapsed time */
2412 return (temp>0)?temp:0; /* take care of skewed clock */
2416 ssize_t DEVICE::read(void *buf, size_t len)
2422 read_len = d_read(m_fd, buf, len);
2424 last_tick = get_timer_count();
2426 DevReadTime += last_tick;
2427 VolCatInfo.VolReadTime += last_tick;
2429 if (read_len > 0) { /* skip error */
2430 DevReadBytes += read_len;
2437 ssize_t DEVICE::write(const void *buf, size_t len)
2443 write_len = d_write(m_fd, buf, len);
2445 last_tick = get_timer_count();
2447 DevWriteTime += last_tick;
2448 VolCatInfo.VolWriteTime += last_tick;
2450 if (write_len > 0) { /* skip error */
2451 DevWriteBytes += write_len;
2457 /* Return the resource name for the device */
2458 const char *DEVICE::name() const
2460 return device->hdr.name;
2463 /* Returns file position on tape or -1 */
2464 int32_t DEVICE::get_os_tape_file()
2466 struct mtget mt_stat;
2468 if (has_cap(CAP_MTIOCGET) &&
2469 d_ioctl(m_fd, MTIOCGET, (char *)&mt_stat) == 0) {
2470 return mt_stat.mt_fileno;
2476 dev_vol_name(DEVICE *dev)
2478 return dev->getVolCatName();
2483 * Free memory allocated for the device
2485 void DEVICE::term(void)
2487 Dmsg1(900, "term dev: %s\n", print_name());
2490 free_memory(dev_name);
2494 free_memory(prt_name);
2498 free_pool_memory(errmsg);
2501 pthread_mutex_destroy(&m_mutex);
2502 pthread_cond_destroy(&wait);
2503 pthread_cond_destroy(&wait_next_vol);
2504 pthread_mutex_destroy(&spool_mutex);
2505 // rwl_destroy(&lock);
2506 if (attached_dcrs) {
2507 delete attached_dcrs;
2508 attached_dcrs = NULL;
2517 * This routine initializes the device wait timers
2519 void init_device_wait_timers(DCR *dcr)
2521 DEVICE *dev = dcr->dev;
2522 JCR *jcr = dcr->jcr;
2524 /* ******FIXME******* put these on config variables */
2525 dev->min_wait = 60 * 60;
2526 dev->max_wait = 24 * 60 * 60;
2527 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2528 dev->wait_sec = dev->min_wait;
2529 dev->rem_wait_sec = dev->wait_sec;
2533 jcr->min_wait = 60 * 60;
2534 jcr->max_wait = 24 * 60 * 60;
2535 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2536 jcr->wait_sec = jcr->min_wait;
2537 jcr->rem_wait_sec = jcr->wait_sec;
2542 void init_jcr_device_wait_timers(JCR *jcr)
2544 /* ******FIXME******* put these on config variables */
2545 jcr->min_wait = 60 * 60;
2546 jcr->max_wait = 24 * 60 * 60;
2547 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2548 jcr->wait_sec = jcr->min_wait;
2549 jcr->rem_wait_sec = jcr->wait_sec;
2555 * The dev timers are used for waiting on a particular device
2557 * Returns: true if time doubled
2558 * false if max time expired
2560 bool double_dev_wait_time(DEVICE *dev)
2562 dev->wait_sec *= 2; /* double wait time */
2563 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2564 dev->wait_sec = dev->max_wait;
2567 dev->rem_wait_sec = dev->wait_sec;
2568 if (dev->num_wait >= dev->max_num_wait) {
2575 void set_os_device_parameters(DCR *dcr)
2577 DEVICE *dev = dcr->dev;
2579 if (strcmp(dev->dev_name, "/dev/null") == 0) {
2580 return; /* no use trying to set /dev/null */
2583 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2586 Dmsg0(100, "In set_os_device_parameters\n");
2587 #if defined(MTSETBLK)
2588 if (dev->min_block_size == dev->max_block_size &&
2589 dev->min_block_size == 0) { /* variable block mode */
2590 mt_com.mt_op = MTSETBLK;
2591 mt_com.mt_count = 0;
2592 Dmsg0(100, "Set block size to zero\n");
2593 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2594 dev->clrerror(MTSETBLK);
2598 #if defined(MTSETDRVBUFFER)
2599 if (getuid() == 0) { /* Only root can do this */
2600 mt_com.mt_op = MTSETDRVBUFFER;
2601 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2602 if (!dev->has_cap(CAP_TWOEOF)) {
2603 mt_com.mt_count |= MT_ST_TWO_FM;
2605 if (dev->has_cap(CAP_EOM)) {
2606 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2608 Dmsg0(100, "MTSETDRVBUFFER\n");
2609 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2610 dev->clrerror(MTSETDRVBUFFER);
2617 #ifdef HAVE_NETBSD_OS
2619 if (dev->min_block_size == dev->max_block_size &&
2620 dev->min_block_size == 0) { /* variable block mode */
2621 mt_com.mt_op = MTSETBSIZ;
2622 mt_com.mt_count = 0;
2623 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2624 dev->clrerror(MTSETBSIZ);
2626 /* Get notified at logical end of tape */
2627 mt_com.mt_op = MTEWARN;
2628 mt_com.mt_count = 1;
2629 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2630 dev->clrerror(MTEWARN);
2636 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2638 if (dev->min_block_size == dev->max_block_size &&
2639 dev->min_block_size == 0) { /* variable block mode */
2640 mt_com.mt_op = MTSETBSIZ;
2641 mt_com.mt_count = 0;
2642 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2643 dev->clrerror(MTSETBSIZ);
2646 #if defined(MTIOCSETEOTMODEL)
2648 if (dev->has_cap(CAP_TWOEOF)) {
2653 if (dev->d_ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2655 dev->dev_errno = errno; /* save errno */
2656 Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2657 dev->print_name(), be.bstrerror(dev->dev_errno));
2658 Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2666 if (dev->min_block_size == dev->max_block_size &&
2667 dev->min_block_size == 0) { /* variable block mode */
2668 mt_com.mt_op = MTSRSZ;
2669 mt_com.mt_count = 0;
2670 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2671 dev->clrerror(MTSRSZ);
2678 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2680 Dmsg0(100, "dev_get_os_pos\n");
2681 return dev->has_cap(CAP_MTIOCGET) &&
2682 dev->d_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2683 mt_stat->mt_fileno >= 0;
2686 static const char *modes[] = {
2687 "CREATE_READ_WRITE",
2694 static const char *mode_to_str(int mode)
2696 static char buf[100];
2697 if (mode < 1 || mode > 4) {
2698 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2701 return modes[mode-1];