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 dcr->setVolCatName(dcr->VolumeName);
357 VolCatInfo = dcr->VolCatInfo; /* structure assign */
360 Dmsg4(100, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
361 print_name(), getVolCatName(), mode_to_str(omode));
362 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
363 label_type = B_BACULA_LABEL;
364 if (is_tape() || is_fifo()) {
365 open_tape_device(dcr, omode);
366 } else if (is_dvd()) {
367 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
368 open_dvd_device(dcr, omode);
370 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
371 open_file_device(dcr, omode);
373 state |= preserve; /* reset any important state info */
374 Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, m_fd);
378 void DEVICE::set_mode(int new_mode)
381 case CREATE_READ_WRITE:
382 mode = O_CREAT | O_RDWR | O_BINARY;
384 case OPEN_READ_WRITE:
385 mode = O_RDWR | O_BINARY;
388 mode = O_RDONLY | O_BINARY;
390 case OPEN_WRITE_ONLY:
391 mode = O_WRONLY | O_BINARY;
394 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
400 void DEVICE::open_tape_device(DCR *dcr, int omode)
403 int timeout = max_open_wait;
404 #if !defined(HAVE_WIN32)
406 utime_t start_time = time(NULL);
409 mount(1); /* do mount if required */
411 Dmsg0(100, "Open dev: device is tape\n");
413 get_autochanger_loaded_slot(dcr);
422 if (is_fifo() && timeout) {
424 tid = start_thread_timer(dcr->jcr, pthread_self(), timeout);
426 Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
427 #if defined(HAVE_WIN32)
430 if ((m_fd = d_open(dev_name, mode)) < 0) {
437 /* If busy retry each second for max_open_wait seconds */
439 /* Try non-blocking open */
440 m_fd = d_open(dev_name, mode+O_NONBLOCK);
444 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
445 print_name(), omode, mode, errno, be.bstrerror());
447 /* Tape open, now rewind it */
448 Dmsg0(100, "Rewind after open\n");
449 mt_com.mt_op = MTREW;
451 /* rewind only if dev is a tape */
452 if (is_tape() && (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0)) {
454 dev_errno = errno; /* set error status from rewind */
457 Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
458 be.bstrerror(dev_errno));
459 /* If we get busy, device is probably rewinding, try again */
460 if (dev_errno != EBUSY) {
461 break; /* error -- no medium */
464 /* Got fd and rewind worked, so we must have medium in drive */
466 m_fd = d_open(dev_name, mode); /* open normally */
470 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
471 print_name(), omode, mode, errno, be.bstrerror());
476 set_os_device_parameters(dcr); /* do system dependent stuff */
477 break; /* Successfully opened and rewound */
481 /* Exceed wait time ? */
482 if (time(NULL) - start_time >= max_open_wait) {
483 break; /* yes, get out */
490 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
491 print_name(), be.bstrerror(dev_errno));
492 Dmsg1(100, "%s", errmsg);
495 /* Stop any open() timer we started */
497 stop_thread_timer(tid);
500 Dmsg1(100, "open dev: tape %d opened\n", m_fd);
507 void DEVICE::open_file_device(DCR *dcr, int omode)
509 POOL_MEM archive_name(PM_FNAME);
511 get_autochanger_loaded_slot(dcr);
514 * Handle opening of File Archive (not a tape)
517 pm_strcpy(archive_name, dev_name);
519 * If this is a virtual autochanger (i.e. changer_res != NULL)
520 * we simply use the device name, assuming it has been
521 * appropriately setup by the "autochanger".
523 if (!device->changer_res || device->changer_command[0] == 0) {
524 if (VolCatInfo.VolCatName[0] == 0) {
525 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
531 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
532 pm_strcat(archive_name, "/");
534 pm_strcat(archive_name, getVolCatName());
537 mount(1); /* do mount if required */
541 /* If creating file, give 0640 permissions */
542 Dmsg3(100, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
543 archive_name.c_str(), mode);
544 /* Use system open() */
545 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
548 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
550 Dmsg1(100, "open failed: %s", errmsg);
551 // Jmsg1(NULL, M_WARNING, 0, "%s", errmsg);
557 Dmsg4(100, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
558 m_fd, part, num_dvd_parts, part_size);
562 * Open a DVD device. N.B. at this point, dcr->getVolCatName()
563 * (NB:??? I think it's getVolCatName() that is right)
564 * has the desired Volume name, but there is NO assurance that
565 * any other field of VolCatInfo is correct.
567 void DEVICE::open_dvd_device(DCR *dcr, int omode)
569 POOL_MEM archive_name(PM_FNAME);
570 struct stat filestat;
573 * Handle opening of DVD Volume
575 Dmsg2(100, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n",
576 &dcr->VolCatInfo, mode_to_str(omode));
579 * For a DVD we must always pull the state info from dcr->VolCatInfo
580 * This is a bit ugly, but is necessary because we need to open/close/re-open
581 * the dvd file in order to properly mount/unmount and access the
582 * DVD. So we store the state of the DVD as far as is known in the
583 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
584 * copy here, when opening.
586 VolCatInfo = dcr->VolCatInfo; /* structure assignment */
587 Dmsg1(100, "Volume=%s\n", getVolCatName());
589 if (VolCatInfo.VolCatName[0] == 0) {
590 Dmsg1(10, "Could not open DVD device %s. No Volume name given.\n",
592 Mmsg(errmsg, _("Could not open DVD device %s. No Volume name given.\n"),
599 Dmsg0(100, "Set part=1\n");
600 part = 1; /* count from 1 */
604 if (num_dvd_parts != VolCatInfo.VolCatParts) {
605 num_dvd_parts = VolCatInfo.VolCatParts;
609 * If we are not trying to access the last part, set mode to
610 * OPEN_READ_ONLY as writing would be an error.
612 Dmsg2(100, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
613 /* Now find the name of the part that we want to access */
614 if (part <= num_dvd_parts) {
615 omode = OPEN_READ_ONLY;
616 make_mounted_dvd_filename(this, archive_name);
617 set_part_spooled(false);
619 omode = OPEN_READ_WRITE;
620 make_spooled_dvd_filename(this, archive_name);
621 set_part_spooled(true);
625 // Clear any previous blank_dvd status - we will recalculate it here
628 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
629 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
632 Dmsg0(99, "DVD device mounted.\n");
633 if (num_dvd_parts == 0 && !truncating) {
635 * If we can mount the device, and we are not truncating the DVD,
636 * we usually want to abort. There is one exception, if there is
637 * only one 0-sized file on the DVD, with the right volume name,
638 * we continue (it's the method used by truncate_dvd to truncate a volume).
640 if (!check_can_write_on_non_blank_dvd(dcr)) {
641 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
642 Emsg0(M_FATAL, 0, errmsg);
643 unmount(1); /* Unmount the device, so the operator can change it. */
650 * Ensure that we have the correct DVD loaded by looking for part1.
651 * We only succeed the open if it exists. Failure to do this could
652 * leave us trying to add a part to a different DVD!
654 uint32_t oldpart = part;
656 POOL_MEM part1_name(PM_FNAME);
658 make_mounted_dvd_filename(this, part1_name);
660 if (stat(part1_name.c_str(), &statp) < 0) {
662 Mmsg(errmsg, _("Unable to stat DVD part 1 file %s: ERR=%s\n"),
663 part1_name.c_str(), be.bstrerror());
664 Emsg0(M_FATAL, 0, errmsg);
668 if (!S_ISREG(statp.st_mode)) {
669 /* It is not a regular file */
670 Mmsg(errmsg, _("DVD part 1 is not a regular file %s.\n"),
672 Emsg0(M_FATAL, 0, errmsg);
678 Dmsg0(99, "DVD device mount failed.\n");
679 /* We cannot mount the device */
680 if (num_dvd_parts == 0) {
681 /* Run free space, check there is a media. */
682 if (!update_freespace()) {
683 Emsg0(M_FATAL, 0, errmsg);
688 Dmsg1(100, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
690 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
691 Emsg0(M_FATAL, 0, errmsg);
696 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
697 Emsg0(M_FATAL, 0, errmsg);
703 Dmsg5(100, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
704 archive_name.c_str(), mode_to_str(omode),
705 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
707 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
710 /* If creating file, give 0640 permissions */
711 Dmsg3(100, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
712 archive_name.c_str(), mode);
713 /* Use system open() */
714 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
716 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
718 // Should this be set if we try the create/open below
719 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
720 Dmsg1(100, "open failed: %s", errmsg);
722 /* Previous open failed. See if we can recover */
723 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
724 (part > num_dvd_parts)) {
725 /* If the last part (on spool), doesn't exist when accessing,
726 * create it. In read/write mode a write will be allowed (higher
727 * level software thinks that we are extending a pre-existing
728 * media. Reads for READ_ONLY will report immediately an EOF
729 * Sometimes it is better to finish with an EOF than with an error. */
730 Dmsg1(100, "Creating last part on spool: %s\n", archive_name.c_str());
731 omode = CREATE_READ_WRITE;
732 set_mode(CREATE_READ_WRITE);
733 m_fd = ::open(archive_name.c_str(), mode, 0640);
737 Dmsg1(100, "after open fd=%d\n", m_fd);
739 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
742 /* Get size of file */
743 if (fstat(m_fd, &filestat) < 0) {
746 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
748 Dmsg1(100, "open failed: %s", errmsg);
749 /* Use system close() */
753 part_size = filestat.st_size;
755 update_pos(dcr); /* update position */
763 * Returns: true on success
766 bool DEVICE::rewind(DCR *dcr)
772 Dmsg3(400, "rewind res=%d fd=%d %s\n", num_reserved(), m_fd, print_name());
773 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
774 block_num = file = 0;
778 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
780 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
782 Emsg0(M_ABORT, 0, errmsg);
787 mt_com.mt_op = MTREW;
789 /* If we get an I/O error on rewind, it is probably because
790 * the drive is actually busy. We loop for (about 5 minutes)
791 * retrying every 5 seconds.
793 for (i=max_rewind_wait; ; i -= 5) {
794 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
797 if (i == max_rewind_wait) {
798 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.bstrerror());
801 * This is a gross hack, because if the user has the
802 * device mounted (i.e. open), then uses mtx to load
803 * a tape, the current open file descriptor is invalid.
804 * So, we close the drive and re-open it.
807 int open_mode = openmode;
810 open(dcr, open_mode);
818 if (dev_errno == EIO) {
819 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
823 if (dev_errno == EIO && i > 0) {
824 Dmsg0(200, "Sleeping 5 seconds.\n");
829 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
830 print_name(), be.bstrerror());
835 } else if (is_file() || is_dvd()) {
836 if (lseek(dcr, (boffset_t)0, SEEK_SET) < 0) {
839 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
840 print_name(), be.bstrerror());
849 * Called to indicate that we have just read an
850 * EOF from the device.
852 void DEVICE::set_ateof()
864 * Called to indicate we are now at the end of the tape, and
865 * writing is not possible.
867 void DEVICE::set_ateot()
869 /* Make tape effectively read-only */
870 state |= (ST_EOF|ST_EOT|ST_WEOT);
875 * Position device to end of medium (end of data)
876 * Returns: true on succes
879 bool DEVICE::eod(DCR *dcr)
888 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
892 #if defined (__digital__) && defined (__unix__)
893 return fsf(VolCatInfo.VolCatFiles);
896 Dmsg0(100, "Enter eod\n");
900 clear_eof(); /* remove EOF flag */
901 block_num = file = 0;
908 pos = lseek(dcr, (boffset_t)0, SEEK_END);
909 Dmsg1(200, "====== Seek to %lld\n", pos);
917 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
918 print_name(), be.bstrerror());
923 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
924 Dmsg0(100,"Using FAST FSF for EOM\n");
925 /* If unknown position, rewind */
926 if (get_os_tape_file() < 0) {
928 Dmsg0(100, "Rewind error\n");
932 mt_com.mt_op = MTFSF;
934 * ***FIXME*** fix code to handle case that INT16_MAX is
937 mt_com.mt_count = INT16_MAX; /* use big positive number */
938 if (mt_com.mt_count < 0) {
939 mt_com.mt_count = INT16_MAX; /* brain damaged system */
943 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
944 if (has_cap(CAP_EOM)) {
945 Dmsg0(100,"Using EOM for EOM\n");
946 mt_com.mt_op = MTEOM;
950 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
952 clrerror(mt_com.mt_op);
953 Dmsg1(50, "ioctl error: %s\n", be.bstrerror());
955 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
956 print_name(), be.bstrerror());
961 os_file = get_os_tape_file();
965 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
966 print_name(), be.bstrerror());
970 Dmsg1(100, "EOD file=%d\n", os_file);
978 * Rewind then use FSF until EOT reached
981 Dmsg0(100, "Rewind error.\n");
985 * Move file by file to the end of the tape
988 for (file_num=file; !at_eot(); file_num++) {
989 Dmsg0(200, "eod: doing fsf 1\n");
991 Dmsg0(100, "fsf error.\n");
995 * Avoid infinite loop by ensuring we advance.
997 if (!at_eot() && file_num == (int)file) {
998 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
1000 os_file = get_os_tape_file();
1002 Dmsg2(100, "Adjust file from %d to %d\n", file_num, os_file);
1010 * Some drivers leave us after second EOF when doing
1011 * MTEOM, so we must backup so that appending overwrites
1014 if (has_cap(CAP_BSFATEOM)) {
1015 /* Backup over EOF */
1017 /* If BSF worked and fileno is known (not -1), set file */
1018 os_file = get_os_tape_file();
1020 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , os_file);
1023 file++; /* wing it -- not correct on all OSes */
1026 update_pos(dcr); /* update position */
1028 Dmsg1(200, "EOD dev->file=%d\n", file);
1033 * Set the position of the device -- only for files and DVD
1034 * For other devices, there is no generic way to do it.
1035 * Returns: true on succes
1038 bool DEVICE::update_pos(DCR *dcr)
1045 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
1046 Emsg1(M_FATAL, 0, "%s", errmsg);
1050 /* Find out where we are */
1051 if (is_file() || is_dvd()) {
1054 pos = lseek(dcr, (boffset_t)0, SEEK_CUR);
1058 Pmsg1(000, _("Seek error: ERR=%s\n"), be.bstrerror());
1059 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1060 print_name(), be.bstrerror());
1064 block_num = (uint32_t)pos;
1065 file = (uint32_t)(pos >> 32);
1072 * Return the status of the device. This was meant
1073 * to be a generic routine. Unfortunately, it doesn't
1074 * seem possible (at least I do not know how to do it
1075 * currently), which means that for the moment, this
1076 * routine has very little value.
1080 uint32_t status_dev(DEVICE *dev)
1082 struct mtget mt_stat;
1085 if (dev->state & (ST_EOT | ST_WEOT)) {
1089 if (dev->state & ST_EOF) {
1093 if (dev->is_tape()) {
1095 Pmsg0(-20,_(" Bacula status:"));
1096 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1097 if (dev->d_ioctl(dev->fd(), MTIOCGET, (char *)&mt_stat) < 0) {
1099 dev->dev_errno = errno;
1100 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1101 dev->print_name(), be.bstrerror());
1104 Pmsg0(-20, _(" Device status:"));
1106 #if defined(HAVE_LINUX_OS)
1107 if (GMT_EOF(mt_stat.mt_gstat)) {
1111 if (GMT_BOT(mt_stat.mt_gstat)) {
1115 if (GMT_EOT(mt_stat.mt_gstat)) {
1119 if (GMT_SM(mt_stat.mt_gstat)) {
1123 if (GMT_EOD(mt_stat.mt_gstat)) {
1127 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1128 stat |= BMT_WR_PROT;
1129 Pmsg0(-20, " WR_PROT");
1131 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1133 Pmsg0(-20, " ONLINE");
1135 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1136 stat |= BMT_DR_OPEN;
1137 Pmsg0(-20, " DR_OPEN");
1139 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1140 stat |= BMT_IM_REP_EN;
1141 Pmsg0(-20, " IM_REP_EN");
1143 #elif defined(HAVE_WIN32)
1144 if (GMT_EOF(mt_stat.mt_gstat)) {
1148 if (GMT_BOT(mt_stat.mt_gstat)) {
1152 if (GMT_EOT(mt_stat.mt_gstat)) {
1156 if (GMT_EOD(mt_stat.mt_gstat)) {
1160 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1161 stat |= BMT_WR_PROT;
1162 Pmsg0(-20, " WR_PROT");
1164 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1166 Pmsg0(-20, " ONLINE");
1168 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1169 stat |= BMT_DR_OPEN;
1170 Pmsg0(-20, " DR_OPEN");
1172 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1173 stat |= BMT_IM_REP_EN;
1174 Pmsg0(-20, " IM_REP_EN");
1177 #endif /* !SunOS && !OSF */
1178 if (dev->has_cap(CAP_MTIOCGET)) {
1179 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1181 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1184 stat |= BMT_ONLINE | BMT_BOT;
1191 * Load medium in device
1192 * Returns: true on success
1195 bool load_dev(DEVICE *dev)
1201 if (dev->fd() < 0) {
1202 dev->dev_errno = EBADF;
1203 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1204 Emsg0(M_FATAL, 0, dev->errmsg);
1207 if (!(dev->is_tape())) {
1211 Dmsg0(200, "stored: MTLOAD command not available\n");
1213 dev->dev_errno = ENOTTY; /* function not available */
1214 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1215 dev->print_name(), be.bstrerror());
1219 dev->block_num = dev->file = 0;
1222 mt_com.mt_op = MTLOAD;
1223 mt_com.mt_count = 1;
1224 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
1226 dev->dev_errno = errno;
1227 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1228 dev->print_name(), be.bstrerror());
1236 * Rewind device and put it offline
1237 * Returns: true on success
1240 bool DEVICE::offline()
1245 return true; /* device not open */
1248 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1249 block_num = file = 0;
1253 mt_com.mt_op = MTOFFL;
1254 mt_com.mt_count = 1;
1255 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
1258 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1259 print_name(), be.bstrerror());
1262 Dmsg1(100, "Offlined device %s\n", print_name());
1266 bool DEVICE::offline_or_rewind()
1271 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1275 * Note, this rewind probably should not be here (it wasn't
1276 * in prior versions of Bacula), but on FreeBSD, this is
1277 * needed in the case the tape was "frozen" due to an error
1278 * such as backspacing after writing and EOF. If it is not
1279 * done, all future references to the drive get and I/O error.
1282 return rewind(NULL);
1287 * Foward space a file
1288 * Returns: true on success
1291 bool DEVICE::fsf(int num)
1293 int32_t os_file = 0;
1299 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1300 Emsg0(M_FATAL, 0, errmsg);
1310 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1314 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1317 Dmsg0(100, "fsf\n");
1320 * If Fast forward space file is set, then we
1321 * use MTFSF to forward space and MTIOCGET
1322 * to get the file position. We assume that
1323 * the SCSI driver will ensure that we do not
1324 * forward space past the end of the medium.
1326 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1328 mt_com.mt_op = MTFSF;
1329 mt_com.mt_count = num;
1330 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1332 my_errno = errno; /* save errno */
1333 } else if ((os_file=get_os_tape_file()) < 0) {
1334 my_errno = errno; /* save errno */
1336 if (my_errno != 0) {
1339 Dmsg0(200, "Set ST_EOT\n");
1341 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1342 print_name(), be.bstrerror(my_errno));
1343 Dmsg1(200, "%s", errmsg);
1347 Dmsg1(200, "fsf file=%d\n", os_file);
1353 * Here if CAP_FSF is set, and virtually all drives
1354 * these days support it, we read a record, then forward
1355 * space one file. Using this procedure, which is slow,
1356 * is the only way we can be sure that we don't read
1357 * two consecutive EOF marks, which means End of Data.
1359 } else if (has_cap(CAP_FSF)) {
1362 Dmsg0(200, "FSF has cap_fsf\n");
1363 if (max_block_size == 0) {
1364 rbuf_len = DEFAULT_BLOCK_SIZE;
1366 rbuf_len = max_block_size;
1368 rbuf = get_memory(rbuf_len);
1369 mt_com.mt_op = MTFSF;
1370 mt_com.mt_count = 1;
1371 while (num-- && !at_eot()) {
1372 Dmsg0(100, "Doing read before fsf\n");
1373 if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1374 if (errno == ENOMEM) { /* tape record exceeds buf len */
1375 stat = rbuf_len; /* This is OK */
1377 * On IBM drives, they return ENOSPC at EOM
1378 * instead of EOF status
1380 } else if (at_eof() && errno == ENOSPC) {
1386 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1388 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1389 print_name(), be.bstrerror());
1390 Dmsg1(100, "%s", errmsg);
1394 if (stat == 0) { /* EOF */
1395 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1396 /* Two reads of zero means end of tape */
1399 Dmsg0(100, "Set ST_EOT\n");
1405 } else { /* Got data */
1410 Dmsg0(100, "Doing MTFSF\n");
1411 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1412 if (stat < 0) { /* error => EOT */
1415 Dmsg0(100, "Set ST_EOT\n");
1417 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1418 print_name(), be.bstrerror());
1419 Dmsg0(100, "Got < 0 for MTFSF\n");
1420 Dmsg1(100, "%s", errmsg);
1428 * No FSF, so use FSR to simulate it
1431 Dmsg0(200, "Doing FSR for FSF\n");
1432 while (num-- && !at_eot()) {
1433 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1437 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1443 Dmsg1(200, "Return %d from FSF\n", stat);
1445 Dmsg0(200, "ST_EOF set on exit FSF\n");
1448 Dmsg0(200, "ST_EOT set on exit FSF\n");
1450 Dmsg1(200, "Return from FSF file=%d\n", file);
1455 * Backward space a file
1456 * Returns: false on failure
1459 bool DEVICE::bsf(int num)
1466 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1467 Emsg0(M_FATAL, 0, errmsg);
1472 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1477 Dmsg0(100, "bsf\n");
1483 mt_com.mt_op = MTBSF;
1484 mt_com.mt_count = num;
1485 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1489 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1490 print_name(), be.bstrerror());
1497 * Foward space num records
1498 * Returns: false on failure
1501 bool DEVICE::fsr(int num)
1508 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1509 Emsg0(M_FATAL, 0, errmsg);
1517 if (!has_cap(CAP_FSR)) {
1518 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1522 Dmsg1(100, "fsr %d\n", num);
1523 mt_com.mt_op = MTFSR;
1524 mt_com.mt_count = num;
1525 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1531 struct mtget mt_stat;
1533 Dmsg1(100, "FSF fail: ERR=%s\n", be.bstrerror());
1534 if (dev_get_os_pos(this, &mt_stat)) {
1535 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1536 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1537 file = mt_stat.mt_fileno;
1538 block_num = mt_stat.mt_blkno;
1546 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1547 num, print_name(), be.bstrerror());
1553 * Backward space a record
1554 * Returns: false on failure
1557 bool DEVICE::bsr(int num)
1564 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1565 Emsg0(M_FATAL, 0, errmsg);
1573 if (!has_cap(CAP_BSR)) {
1574 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1578 Dmsg0(100, "bsr_dev\n");
1582 mt_com.mt_op = MTBSR;
1583 mt_com.mt_count = num;
1584 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1588 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1589 print_name(), be.bstrerror());
1594 void DEVICE::lock_door()
1598 mt_com.mt_op = MTLOCK;
1599 mt_com.mt_count = 1;
1600 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1604 void DEVICE::unlock_door()
1608 mt_com.mt_op = MTUNLOCK;
1609 mt_com.mt_count = 1;
1610 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1614 void DEVICE::set_slot(int32_t slot)
1617 if (vol) vol->clear_slot();
1620 void DEVICE::clear_slot()
1623 if (vol) vol->set_slot(-1);
1629 * Reposition the device to file, block
1630 * Returns: false on failure
1633 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1637 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1638 Emsg0(M_FATAL, 0, errmsg);
1643 boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1644 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1645 if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1648 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1649 print_name(), be.bstrerror());
1658 /* After this point, we are tape only */
1659 Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1661 Dmsg0(100, "Rewind\n");
1662 if (!rewind(NULL)) {
1667 Dmsg1(100, "fsf %d\n", rfile-file);
1668 if (!fsf(rfile-file)) {
1669 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1672 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1674 if (rblock < block_num) {
1675 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1676 Dmsg0(100, "bsf 1\n");
1678 Dmsg0(100, "fsf 1\n");
1680 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1682 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1683 /* Ignore errors as Bacula can read to the correct block */
1684 Dmsg1(100, "fsr %d\n", rblock-block_num);
1685 return fsr(rblock-block_num);
1687 while (rblock > block_num) {
1688 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1691 Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1692 print_name(), be.bstrerror());
1695 Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1704 * Write an end of file on the device
1705 * Returns: true on success
1708 bool DEVICE::weof(int num)
1712 Dmsg1(129, "=== weof_dev=%s\n", print_name());
1716 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1717 Emsg0(M_FATAL, 0, errmsg);
1725 if (!can_append()) {
1726 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1727 Emsg0(M_FATAL, 0, errmsg);
1733 mt_com.mt_op = MTWEOF;
1734 mt_com.mt_count = num;
1735 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1744 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1745 print_name(), be.bstrerror());
1753 * If implemented in system, clear the tape
1756 void DEVICE::clrerror(int func)
1758 const char *msg = NULL;
1761 dev_errno = errno; /* save errno */
1763 VolCatInfo.VolCatErrors++;
1770 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1773 break; /* ignore message printed later */
1776 clear_cap(CAP_EOF); /* turn off feature */
1781 clear_cap(CAP_EOM); /* turn off feature */
1786 clear_cap(CAP_FSF); /* turn off feature */
1790 clear_cap(CAP_BSF); /* turn off feature */
1794 clear_cap(CAP_FSR); /* turn off feature */
1798 clear_cap(CAP_BSR); /* turn off feature */
1808 #ifdef MTSETDRVBUFFER
1809 case MTSETDRVBUFFER:
1810 msg = "MTSETDRVBUFFER";
1843 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1849 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1850 Emsg0(M_ERROR, 0, errmsg);
1855 * Now we try different methods of clearing the error
1856 * status on the drive so that it is not locked for
1857 * further operations.
1860 /* On some systems such as NetBSD, this clears all errors */
1863 /* Found on Solaris */
1866 d_ioctl(m_fd, MTIOCLRERR);
1867 Dmsg0(200, "Did MTIOCLRERR\n");
1871 /* Typically on FreeBSD */
1875 /* Read and clear SCSI error status */
1876 union mterrstat mt_errstat;
1877 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1878 be.bstrerror(dev_errno));
1879 d_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1883 /* Clear Subsystem Exception OSF1 */
1887 mt_com.mt_op = MTCSE;
1888 mt_com.mt_count = 1;
1889 /* Clear any error condition on the tape */
1890 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1891 Dmsg0(200, "Did MTCSE\n");
1898 * Set to unload the current volume in the drive
1900 void DEVICE::set_unload()
1902 if (!m_unload && VolHdr.VolumeName[0] != 0) {
1904 memcpy(UnloadVolName, VolHdr.VolumeName, sizeof(UnloadVolName));
1910 * Clear volume header
1912 void DEVICE::clear_volhdr()
1914 Dmsg1(100, "Clear volhdr vol=%s\n", VolHdr.VolumeName);
1915 memset(&VolHdr, 0, sizeof(VolHdr));
1916 setVolCatInfo(false);
1923 void DEVICE::close()
1925 Dmsg1(100, "close_dev %s\n", print_name());
1926 offline_or_rewind();
1929 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1931 return; /* already closed */
1944 unmount(1); /* do unmount if required */
1946 /* Clean up device packet so it can be reused */
1949 * Be careful not to clear items needed by the DVD driver
1950 * when it is closing a single part.
1952 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF|
1953 ST_MOUNTED|ST_MEDIA|ST_SHORT);
1954 label_type = B_BACULA_LABEL;
1955 file = block_num = 0;
1958 EndFile = EndBlock = 0;
1961 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1963 stop_thread_timer(tid);
1969 * This call closes the device, but it is used in DVD handling
1970 * where we close one part and then open the next part. The
1971 * difference between close_part() and close() is that close_part()
1972 * saves the state information of the device (e.g. the Volume lable,
1973 * the Volume Catalog record, ... This permits opening and closing
1974 * the Volume parts multiple times without losing track of what the
1975 * main Volume parameters are.
1977 void DEVICE::close_part(DCR * /*dcr*/)
1979 VOLUME_LABEL saveVolHdr;
1980 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1983 saveVolHdr = VolHdr; /* structure assignment */
1984 saveVolCatInfo = VolCatInfo; /* structure assignment */
1985 close(); /* close current part */
1986 VolHdr = saveVolHdr; /* structure assignment */
1987 VolCatInfo = saveVolCatInfo; /* structure assignment */
1990 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1994 return lseek_dvd(dcr, offset, whence);
1996 #if defined(HAVE_WIN32)
1997 return ::_lseeki64(m_fd, (__int64)offset, whence);
1999 return ::lseek(m_fd, offset, whence);
2006 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
2010 Dmsg1(100, "truncate %s\n", print_name());
2015 /* maybe we should rewind and write and eof ???? */
2016 return true; /* we don't really truncate tapes */
2018 return truncate_dvd(dcr);
2020 if (ftruncate(m_fd, 0) != 0) {
2022 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
2023 print_name(), be.bstrerror());
2028 * Check for a successful ftruncate() and issue a work-around for devices
2029 * (mostly cheap NAS) that don't support truncation.
2030 * Workaround supplied by Martin Schmid as a solution to bug #1011.
2033 * 3. open new file with same mode
2034 * 4. change ownership to original
2037 if (fstat(m_fd, &st) != 0) {
2039 Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"),
2040 print_name(), be.bstrerror());
2044 if (st.st_size != 0) { /* ftruncate() didn't work */
2045 POOL_MEM archive_name(PM_FNAME);
2047 pm_strcpy(archive_name, dev_name);
2048 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
2049 pm_strcat(archive_name, "/");
2051 pm_strcat(archive_name, dcr->VolumeName);
2053 Mmsg2(errmsg, _("Device %s doesn't support ftruncate(). Recreating file %s.\n"),
2054 print_name(), archive_name.c_str());
2056 /* Close file and blow it away */
2058 ::unlink(archive_name.c_str());
2060 /* Recreate the file -- of course, empty */
2061 set_mode(CREATE_READ_WRITE);
2062 if ((m_fd = ::open(archive_name.c_str(), mode, st.st_mode)) < 0) {
2065 Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), archive_name.c_str(),
2067 Dmsg1(100, "reopen failed: %s", errmsg);
2068 Emsg0(M_FATAL, 0, errmsg);
2072 /* Reset proper owner */
2073 chown(archive_name.c_str(), st.st_uid, st.st_gid);
2083 * If timeout, wait until the mount command returns 0.
2084 * If !timeout, try to mount the device only once.
2086 bool DEVICE::mount(int timeout)
2088 Dmsg0(190, "Enter mount\n");
2098 if (device->mount_command) {
2099 return do_tape_mount(1, timeout);
2104 if (requires_mount() && device->mount_command) {
2105 return do_file_mount(1, timeout);
2116 * Unmount the device
2117 * If timeout, wait until the unmount command returns 0.
2118 * If !timeout, try to unmount the device only once.
2120 bool DEVICE::unmount(int timeout)
2122 Dmsg0(100, "Enter unmount\n");
2124 if (!is_mounted()) {
2132 if (device->unmount_command) {
2133 return do_tape_mount(0, timeout);
2138 if (requires_mount() && device->unmount_command) {
2139 return do_file_mount(0, timeout);
2150 * (Un)mount the device (for tape devices)
2152 bool DEVICE::do_tape_mount(int mount, int dotimeout)
2154 POOL_MEM ocmd(PM_FNAME);
2162 icmd = device->mount_command;
2164 icmd = device->unmount_command;
2167 edit_mount_codes(ocmd, icmd);
2169 Dmsg2(100, "do_tape_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2172 /* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
2177 results = get_memory(4000);
2179 /* If busy retry each second */
2180 Dmsg1(100, "do_tape_mount run_prog=%s\n", ocmd.c_str());
2181 while ((status = run_program_full_output(ocmd.c_str(), max_open_wait/2, results)) != 0) {
2186 Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2187 (mount ? "" : "un"), status, results, be.bstrerror(status));
2188 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2189 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2192 free_pool_memory(results);
2193 Dmsg0(200, "============ mount=0\n");
2198 set_mounted(mount); /* set/clear mounted flag */
2199 free_pool_memory(results);
2200 Dmsg1(200, "============ mount=%d\n", mount);
2205 * (Un)mount the device (either a FILE or DVD device)
2207 bool DEVICE::do_file_mount(int mount, int dotimeout)
2209 POOL_MEM ocmd(PM_FNAME);
2213 struct dirent *entry, *result;
2214 int status, tries, name_max, count;
2219 icmd = device->mount_command;
2221 icmd = device->unmount_command;
2224 clear_freespace_ok();
2225 edit_mount_codes(ocmd, icmd);
2227 Dmsg2(100, "do_file_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2230 /* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
2235 results = get_memory(4000);
2237 /* If busy retry each second */
2238 Dmsg1(100, "do_file_mount run_prog=%s\n", ocmd.c_str());
2239 while ((status = run_program_full_output(ocmd.c_str(), max_open_wait/2, results)) != 0) {
2240 /* Doesn't work with internationalization (This is not a problem) */
2241 if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2244 if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2248 /* Sometimes the device cannot be mounted because it is already mounted.
2249 * Try to unmount it, then remount it */
2251 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2252 do_file_mount(0, 0);
2257 Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2258 (mount ? "" : "un"), status, results, be.bstrerror(status));
2259 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2260 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2263 * Now, just to be sure it is not mounted, try to read the filesystem.
2265 name_max = pathconf(".", _PC_NAME_MAX);
2266 if (name_max < 1024) {
2270 if (!(dp = opendir(device->mount_point))) {
2273 Dmsg3(100, "do_file_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2274 device->mount_point, print_name(), be.bstrerror());
2278 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2281 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2283 Dmsg2(129, "do_file_mount: failed to find suitable file in dir %s (dev=%s)\n",
2284 device->mount_point, print_name());
2287 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2288 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2291 Dmsg2(129, "do_file_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2297 Dmsg1(100, "do_file_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2300 /* If we got more than ., .. and .keep */
2301 /* there must be something mounted */
2303 Dmsg1(100, "Did Mount by count=%d\n", count);
2306 /* An unmount request. We failed to unmount - report an error */
2308 free_pool_memory(results);
2309 Dmsg0(200, "== error mount=1 wanted unmount\n");
2315 free_pool_memory(results);
2316 Dmsg0(200, "============ mount=0\n");
2321 set_mounted(mount); /* set/clear mounted flag */
2322 free_pool_memory(results);
2323 /* Do not check free space when unmounting */
2324 if (mount && !update_freespace()) {
2327 Dmsg1(200, "============ mount=%d\n", mount);
2332 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2334 * %a = archive device name
2335 * %e = erase (set if cannot mount and first part)
2338 * %v = last part name
2340 * omsg = edited output message
2341 * imsg = input string containing edit codes (%x)
2344 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2350 POOL_MEM archive_name(PM_FNAME);
2352 omsg.c_str()[0] = 0;
2353 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2354 for (p=imsg; *p; p++) {
2364 if (num_dvd_parts == 0) {
2365 if (truncating || blank_dvd) {
2375 bsnprintf(add, sizeof(add), "%d", part);
2379 str = device->mount_point;
2382 make_spooled_dvd_filename(this, archive_name);
2383 str = archive_name.c_str();
2397 Dmsg1(1900, "add_str %s\n", str);
2398 pm_strcat(omsg, (char *)str);
2399 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2403 /* return the last timer interval (ms)
2404 * or 0 if something goes wrong
2406 btime_t DEVICE::get_timer_count()
2408 btime_t temp = last_timer;
2409 last_timer = get_current_btime();
2410 temp = last_timer - temp; /* get elapsed time */
2411 return (temp>0)?temp:0; /* take care of skewed clock */
2415 ssize_t DEVICE::read(void *buf, size_t len)
2421 read_len = d_read(m_fd, buf, len);
2423 last_tick = get_timer_count();
2425 DevReadTime += last_tick;
2426 VolCatInfo.VolReadTime += last_tick;
2428 if (read_len > 0) { /* skip error */
2429 DevReadBytes += read_len;
2436 ssize_t DEVICE::write(const void *buf, size_t len)
2442 write_len = d_write(m_fd, buf, len);
2444 last_tick = get_timer_count();
2446 DevWriteTime += last_tick;
2447 VolCatInfo.VolWriteTime += last_tick;
2449 if (write_len > 0) { /* skip error */
2450 DevWriteBytes += write_len;
2456 /* Return the resource name for the device */
2457 const char *DEVICE::name() const
2459 return device->hdr.name;
2462 /* Returns file position on tape or -1 */
2463 int32_t DEVICE::get_os_tape_file()
2465 struct mtget mt_stat;
2467 if (has_cap(CAP_MTIOCGET) &&
2468 d_ioctl(m_fd, MTIOCGET, (char *)&mt_stat) == 0) {
2469 return mt_stat.mt_fileno;
2475 dev_vol_name(DEVICE *dev)
2477 return dev->getVolCatName();
2482 * Free memory allocated for the device
2484 void DEVICE::term(void)
2486 Dmsg1(900, "term dev: %s\n", print_name());
2489 free_memory(dev_name);
2493 free_memory(prt_name);
2497 free_pool_memory(errmsg);
2500 pthread_mutex_destroy(&m_mutex);
2501 pthread_cond_destroy(&wait);
2502 pthread_cond_destroy(&wait_next_vol);
2503 pthread_mutex_destroy(&spool_mutex);
2504 // rwl_destroy(&lock);
2505 if (attached_dcrs) {
2506 delete attached_dcrs;
2507 attached_dcrs = NULL;
2516 * This routine initializes the device wait timers
2518 void init_device_wait_timers(DCR *dcr)
2520 DEVICE *dev = dcr->dev;
2521 JCR *jcr = dcr->jcr;
2523 /* ******FIXME******* put these on config variables */
2524 dev->min_wait = 60 * 60;
2525 dev->max_wait = 24 * 60 * 60;
2526 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2527 dev->wait_sec = dev->min_wait;
2528 dev->rem_wait_sec = dev->wait_sec;
2532 jcr->min_wait = 60 * 60;
2533 jcr->max_wait = 24 * 60 * 60;
2534 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2535 jcr->wait_sec = jcr->min_wait;
2536 jcr->rem_wait_sec = jcr->wait_sec;
2541 void init_jcr_device_wait_timers(JCR *jcr)
2543 /* ******FIXME******* put these on config variables */
2544 jcr->min_wait = 60 * 60;
2545 jcr->max_wait = 24 * 60 * 60;
2546 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2547 jcr->wait_sec = jcr->min_wait;
2548 jcr->rem_wait_sec = jcr->wait_sec;
2554 * The dev timers are used for waiting on a particular device
2556 * Returns: true if time doubled
2557 * false if max time expired
2559 bool double_dev_wait_time(DEVICE *dev)
2561 dev->wait_sec *= 2; /* double wait time */
2562 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2563 dev->wait_sec = dev->max_wait;
2566 dev->rem_wait_sec = dev->wait_sec;
2567 if (dev->num_wait >= dev->max_num_wait) {
2574 void set_os_device_parameters(DCR *dcr)
2576 DEVICE *dev = dcr->dev;
2578 if (strcmp(dev->dev_name, "/dev/null") == 0) {
2579 return; /* no use trying to set /dev/null */
2582 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2585 Dmsg0(100, "In set_os_device_parameters\n");
2586 #if defined(MTSETBLK)
2587 if (dev->min_block_size == dev->max_block_size &&
2588 dev->min_block_size == 0) { /* variable block mode */
2589 mt_com.mt_op = MTSETBLK;
2590 mt_com.mt_count = 0;
2591 Dmsg0(100, "Set block size to zero\n");
2592 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2593 dev->clrerror(MTSETBLK);
2597 #if defined(MTSETDRVBUFFER)
2598 if (getuid() == 0) { /* Only root can do this */
2599 mt_com.mt_op = MTSETDRVBUFFER;
2600 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2601 if (!dev->has_cap(CAP_TWOEOF)) {
2602 mt_com.mt_count |= MT_ST_TWO_FM;
2604 if (dev->has_cap(CAP_EOM)) {
2605 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2607 Dmsg0(100, "MTSETDRVBUFFER\n");
2608 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2609 dev->clrerror(MTSETDRVBUFFER);
2616 #ifdef HAVE_NETBSD_OS
2618 if (dev->min_block_size == dev->max_block_size &&
2619 dev->min_block_size == 0) { /* variable block mode */
2620 mt_com.mt_op = MTSETBSIZ;
2621 mt_com.mt_count = 0;
2622 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2623 dev->clrerror(MTSETBSIZ);
2625 /* Get notified at logical end of tape */
2626 mt_com.mt_op = MTEWARN;
2627 mt_com.mt_count = 1;
2628 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2629 dev->clrerror(MTEWARN);
2635 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2637 if (dev->min_block_size == dev->max_block_size &&
2638 dev->min_block_size == 0) { /* variable block mode */
2639 mt_com.mt_op = MTSETBSIZ;
2640 mt_com.mt_count = 0;
2641 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2642 dev->clrerror(MTSETBSIZ);
2645 #if defined(MTIOCSETEOTMODEL)
2647 if (dev->has_cap(CAP_TWOEOF)) {
2652 if (dev->d_ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2654 dev->dev_errno = errno; /* save errno */
2655 Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2656 dev->print_name(), be.bstrerror(dev->dev_errno));
2657 Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2665 if (dev->min_block_size == dev->max_block_size &&
2666 dev->min_block_size == 0) { /* variable block mode */
2667 mt_com.mt_op = MTSRSZ;
2668 mt_com.mt_count = 0;
2669 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2670 dev->clrerror(MTSRSZ);
2677 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2679 Dmsg0(100, "dev_get_os_pos\n");
2680 return dev->has_cap(CAP_MTIOCGET) &&
2681 dev->d_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2682 mt_stat->mt_fileno >= 0;
2685 static const char *modes[] = {
2686 "CREATE_READ_WRITE",
2693 static const char *mode_to_str(int mode)
2695 static char buf[100];
2696 if (mode < 1 || mode > 4) {
2697 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2700 return modes[mode-1];