2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2009 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.
54 * Handling I/O errors and end of tape conditions are a bit tricky.
55 * This is how it is currently done when writing.
56 * On either an I/O error or end of tape,
57 * we will stop writing on the physical device (no I/O recovery is
58 * attempted at least in this daemon). The state flag will be sent
59 * to include ST_EOT, which is ephemeral, and ST_WEOT, which is
60 * persistent. Lots of routines clear ST_EOT, but ST_WEOT is
61 * cleared only when the problem goes away. Now when ST_WEOT
62 * is set all calls to write_block_to_device() call the fix_up
63 * routine. In addition, all threads are blocked
64 * from writing on the tape by calling lock_dev(), and thread other
65 * than the first thread to hit the EOT will block on a condition
66 * variable. The first thread to hit the EOT will continue to
67 * be able to read and write the tape (he sort of tunnels through
68 * the locking mechanism -- see lock_dev() for details).
70 * Now presumably somewhere higher in the chain of command
71 * (device.c), someone will notice the EOT condition and
72 * get a new tape up, get the tape label read, and mark
73 * the label for rewriting. Then this higher level routine
74 * will write the unwritten buffer to the new volume.
75 * Finally, he will release
76 * any blocked threads by doing a broadcast on the condition
77 * variable. At that point, we should be totally back in
78 * business with no lost data.
89 /* Forward referenced functions */
90 void set_os_device_parameters(DCR *dcr);
91 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat);
92 static const char *mode_to_str(int mode);
95 * Allocate and initialize the DEVICE structure
96 * Note, if dev is non-NULL, it is already allocated,
97 * thus we neither allocate it nor free it. This allows
98 * the caller to put the packet in shared memory.
100 * Note, for a tape, the device->device_name is the device name
101 * (e.g. /dev/nst0), and for a file, the device name
102 * is the directory in which the file will be placed.
106 init_dev(JCR *jcr, DEVRES *device)
115 /* If no device type specified, try to guess */
116 if (!device->dev_type) {
117 /* Check that device is available */
118 if (stat(device->device_name, &statp) < 0) {
120 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
121 device->device_name, be.bstrerror());
124 if (S_ISDIR(statp.st_mode)) {
125 device->dev_type = B_FILE_DEV;
126 } else if (S_ISCHR(statp.st_mode)) {
127 device->dev_type = B_TAPE_DEV;
128 } else if (S_ISFIFO(statp.st_mode)) {
129 device->dev_type = B_FIFO_DEV;
131 /* must set DeviceType = Vtape
132 * in normal mode, autodetection is disabled
134 } else if (S_ISREG(statp.st_mode)) {
135 device->dev_type = B_VTAPE_DEV;
137 } else if (!(device->cap_bits & CAP_REQMOUNT)) {
138 Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
139 " or have RequiresMount=yes for DVD. st_mode=%x\n"),
140 device->device_name, statp.st_mode);
143 device->dev_type = B_DVD_DEV;
147 dev = (DEVICE *)malloc(sizeof(DEVICE));
148 memset(dev, 0, sizeof(DEVICE));
149 dev->clear_slot(); /* unknown */
151 /* Copy user supplied device parameters from Resource */
152 dev->dev_name = get_memory(strlen(device->device_name)+1);
153 pm_strcpy(dev->dev_name, device->device_name);
154 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
155 /* We edit "Resource-name" (physical-name) */
156 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
157 Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
158 dev->capabilities = device->cap_bits;
159 dev->min_block_size = device->min_block_size;
160 dev->max_block_size = device->max_block_size;
161 dev->max_volume_size = device->max_volume_size;
162 dev->max_file_size = device->max_file_size;
163 dev->max_concurrent_jobs = device->max_concurrent_jobs;
164 dev->volume_capacity = device->volume_capacity;
165 dev->max_rewind_wait = device->max_rewind_wait;
166 dev->max_open_wait = device->max_open_wait;
167 dev->max_open_vols = device->max_open_vols;
168 dev->vol_poll_interval = device->vol_poll_interval;
169 dev->max_spool_size = device->max_spool_size;
170 dev->drive_index = device->drive_index;
171 dev->autoselect = device->autoselect;
172 dev->dev_type = device->dev_type;
174 if (dev->is_tape()) { /* No parts on tapes */
175 dev->max_part_size = 0;
177 dev->max_part_size = device->max_part_size;
180 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
181 dev->vol_poll_interval = 60;
183 /* Link the dev and device structures together */
184 dev->device = device;
187 if (dev->is_fifo()) {
188 dev->capabilities |= CAP_STREAM; /* set stream device */
191 /* If the device requires mount :
192 * - Check that the mount point is available
193 * - Check that (un)mount commands are defined
195 if ((dev->is_file() || dev->is_dvd()) && dev->requires_mount()) {
196 if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
198 dev->dev_errno = errno;
199 Jmsg2(jcr, M_ERROR_TERM, 0, _("Unable to stat mount point %s: ERR=%s\n"),
200 device->mount_point, be.bstrerror());
203 if (!device->mount_command || !device->unmount_command) {
204 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
208 if (!device->write_part_command) {
209 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
214 if (dev->max_block_size == 0) {
215 max_bs = DEFAULT_BLOCK_SIZE;
217 max_bs = dev->max_block_size;
219 if (dev->min_block_size > max_bs) {
220 Jmsg(jcr, M_ERROR_TERM, 0, _("Min block size > max on device %s\n"),
223 if (dev->max_block_size > 4096000) {
224 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
225 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
226 dev->max_block_size = 0;
228 if (dev->max_block_size % TAPE_BSIZE != 0) {
229 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
230 dev->max_block_size, dev->print_name());
232 if (dev->max_volume_size != 0 && dev->max_volume_size < (dev->max_block_size << 4)) {
233 Jmsg(jcr, M_ERROR_TERM, 0, _("Max Vol Size < 8 * Max Block Size on device %s\n"),
237 dev->errmsg = get_pool_memory(PM_EMSG);
240 if ((errstat = pthread_mutex_init(&dev->m_mutex, NULL)) != 0) {
242 dev->dev_errno = errstat;
243 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
244 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
246 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
248 dev->dev_errno = errstat;
249 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
250 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
252 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
254 dev->dev_errno = errstat;
255 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
256 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
258 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
260 dev->dev_errno = errstat;
261 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
262 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
264 if ((errstat = pthread_mutex_init(&dev->acquire_mutex, NULL)) != 0) {
266 dev->dev_errno = errstat;
267 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
268 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
271 if ((errstat = rwl_init(&dev->lock)) != 0) {
273 dev->dev_errno = errstat;
274 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
275 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
280 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
281 Dmsg2(100, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
282 dev->initiated = true;
287 /* Choose the right backend */
288 void DEVICE::init_backend()
293 d_open = win32_tape_open;
294 d_write = win32_tape_write;
295 d_close = win32_tape_close;
296 d_ioctl = win32_tape_ioctl;
297 d_read = win32_tape_read;
302 d_ioctl = win32_ioctl; /* dummy function */
303 d_write = win32_write; /* win32 read/write are not POSIX */
307 #else /* POSIX / UNIX Interface */
308 if (is_vtape()) { /* test backend */
309 d_open = vtape_open; /* vtape isn't available for WIN32 or FreeBSD */
310 d_write = vtape_write;
311 d_close = vtape_close;
312 d_ioctl = vtape_ioctl;
315 } else { /* tape and file are using normal io */
326 * Open the device with the operating system and
327 * initialize buffer pointers.
329 * Returns: -1 on error
332 * Note, for a tape, the VolName is the name we give to the
333 * volume (not really used here), but for a file, the
334 * VolName represents the name of the file to be created/opened.
335 * In the case of a file, the full name is the device name
336 * (archive_name) with the VolName concatenated.
339 DEVICE::open(DCR *dcr, int omode)
343 if (openmode == omode) {
348 Dmsg0(100, "Close fd for mode change.\n");
349 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
353 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
356 Dmsg4(100, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
357 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
358 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
359 label_type = B_BACULA_LABEL;
360 if (is_tape() || is_fifo()) {
361 open_tape_device(dcr, omode);
362 } else if (is_dvd()) {
363 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
364 open_dvd_device(dcr, omode);
366 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
367 open_file_device(dcr, omode);
369 state |= preserve; /* reset any important state info */
370 Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, m_fd);
374 void DEVICE::set_mode(int new_mode)
377 case CREATE_READ_WRITE:
378 mode = O_CREAT | O_RDWR | O_BINARY;
380 case OPEN_READ_WRITE:
381 mode = O_RDWR | O_BINARY;
384 mode = O_RDONLY | O_BINARY;
386 case OPEN_WRITE_ONLY:
387 mode = O_WRONLY | O_BINARY;
390 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
396 void DEVICE::open_tape_device(DCR *dcr, int omode)
399 int timeout = max_open_wait;
400 #if !defined(HAVE_WIN32)
402 utime_t start_time = time(NULL);
406 Dmsg0(100, "Open dev: device is tape\n");
408 get_autochanger_loaded_slot(dcr);
417 if (is_fifo() && timeout) {
419 tid = start_thread_timer(dcr->jcr, pthread_self(), timeout);
421 Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
422 #if defined(HAVE_WIN32)
425 if ((m_fd = d_open(dev_name, mode)) < 0) {
432 /* If busy retry each second for max_open_wait seconds */
434 /* Try non-blocking open */
435 m_fd = d_open(dev_name, mode+O_NONBLOCK);
439 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
440 print_name(), omode, mode, errno, be.bstrerror());
442 /* Tape open, now rewind it */
443 Dmsg0(100, "Rewind after open\n");
444 mt_com.mt_op = MTREW;
446 /* rewind only if dev is a tape */
447 if (is_tape() && (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0)) {
449 dev_errno = errno; /* set error status from rewind */
452 Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
453 be.bstrerror(dev_errno));
454 /* If we get busy, device is probably rewinding, try again */
455 if (dev_errno != EBUSY) {
456 break; /* error -- no medium */
459 /* Got fd and rewind worked, so we must have medium in drive */
461 m_fd = d_open(dev_name, mode); /* open normally */
465 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
466 print_name(), omode, mode, errno, be.bstrerror());
471 set_os_device_parameters(dcr); /* do system dependent stuff */
472 break; /* Successfully opened and rewound */
476 /* Exceed wait time ? */
477 if (time(NULL) - start_time >= max_open_wait) {
478 break; /* yes, get out */
485 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
486 print_name(), be.bstrerror(dev_errno));
487 Dmsg1(100, "%s", errmsg);
490 /* Stop any open() timer we started */
492 stop_thread_timer(tid);
495 Dmsg1(100, "open dev: tape %d opened\n", m_fd);
502 void DEVICE::open_file_device(DCR *dcr, int omode)
504 POOL_MEM archive_name(PM_FNAME);
506 get_autochanger_loaded_slot(dcr);
509 * Handle opening of File Archive (not a tape)
512 pm_strcpy(archive_name, dev_name);
514 * If this is a virtual autochanger (i.e. changer_res != NULL)
515 * we simply use the device name, assuming it has been
516 * appropriately setup by the "autochanger".
518 if (!device->changer_res || device->changer_command[0] == 0) {
519 if (VolCatInfo.VolCatName[0] == 0) {
520 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
526 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
527 pm_strcat(archive_name, "/");
529 pm_strcat(archive_name, VolCatInfo.VolCatName);
532 mount(1); /* do mount if required */
536 /* If creating file, give 0640 permissions */
537 Dmsg3(100, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
538 archive_name.c_str(), mode);
539 /* Use system open() */
540 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
543 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
545 Dmsg1(100, "open failed: %s", errmsg);
546 // Jmsg1(NULL, M_WARNING, 0, "%s", errmsg);
552 Dmsg4(100, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
553 m_fd, part, num_dvd_parts, part_size);
557 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
558 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
559 * has the desired Volume name, but there is NO assurance that
560 * any other field of VolCatInfo is correct.
562 void DEVICE::open_dvd_device(DCR *dcr, int omode)
564 POOL_MEM archive_name(PM_FNAME);
565 struct stat filestat;
568 * Handle opening of DVD Volume
570 Dmsg2(100, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n",
571 &dcr->VolCatInfo, mode_to_str(omode));
574 * For a DVD we must always pull the state info from dcr->VolCatInfo
575 * This is a bit ugly, but is necessary because we need to open/close/re-open
576 * the dvd file in order to properly mount/unmount and access the
577 * DVD. So we store the state of the DVD as far as is known in the
578 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
579 * copy here, when opening.
581 VolCatInfo = dcr->VolCatInfo; /* structure assignment */
582 Dmsg1(100, "Volume=%s\n", VolCatInfo.VolCatName);
584 if (VolCatInfo.VolCatName[0] == 0) {
585 Dmsg1(10, "Could not open DVD device %s. No Volume name given.\n",
587 Mmsg(errmsg, _("Could not open DVD device %s. No Volume name given.\n"),
594 Dmsg0(100, "Set part=1\n");
595 part = 1; /* count from 1 */
599 if (num_dvd_parts != VolCatInfo.VolCatParts) {
600 num_dvd_parts = VolCatInfo.VolCatParts;
604 * If we are not trying to access the last part, set mode to
605 * OPEN_READ_ONLY as writing would be an error.
607 Dmsg2(100, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
608 /* Now find the name of the part that we want to access */
609 if (part <= num_dvd_parts) {
610 omode = OPEN_READ_ONLY;
611 make_mounted_dvd_filename(this, archive_name);
612 set_part_spooled(false);
614 omode = OPEN_READ_WRITE;
615 make_spooled_dvd_filename(this, archive_name);
616 set_part_spooled(true);
620 // Clear any previous blank_dvd status - we will recalculate it here
623 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
624 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
627 Dmsg0(99, "DVD device mounted.\n");
628 if (num_dvd_parts == 0 && !truncating) {
630 * If we can mount the device, and we are not truncating the DVD,
631 * we usually want to abort. There is one exception, if there is
632 * only one 0-sized file on the DVD, with the right volume name,
633 * we continue (it's the method used by truncate_dvd to truncate a volume).
635 if (!check_can_write_on_non_blank_dvd(dcr)) {
636 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
637 Emsg0(M_FATAL, 0, errmsg);
638 unmount(1); /* Unmount the device, so the operator can change it. */
645 * Ensure that we have the correct DVD loaded by looking for part1.
646 * We only succeed the open if it exists. Failure to do this could
647 * leave us trying to add a part to a different DVD!
649 uint32_t oldpart = part;
651 POOL_MEM part1_name(PM_FNAME);
653 make_mounted_dvd_filename(this, part1_name);
655 if (stat(part1_name.c_str(), &statp) < 0) {
657 Mmsg(errmsg, _("Unable to stat DVD part 1 file %s: ERR=%s\n"),
658 part1_name.c_str(), be.bstrerror());
659 Emsg0(M_FATAL, 0, errmsg);
663 if (!S_ISREG(statp.st_mode)) {
664 /* It is not a regular file */
665 Mmsg(errmsg, _("DVD part 1 is not a regular file %s.\n"),
667 Emsg0(M_FATAL, 0, errmsg);
673 Dmsg0(99, "DVD device mount failed.\n");
674 /* We cannot mount the device */
675 if (num_dvd_parts == 0) {
676 /* Run free space, check there is a media. */
677 if (!update_freespace()) {
678 Emsg0(M_FATAL, 0, errmsg);
683 Dmsg1(100, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
685 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
686 Emsg0(M_FATAL, 0, errmsg);
691 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
692 Emsg0(M_FATAL, 0, errmsg);
698 Dmsg5(100, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
699 archive_name.c_str(), mode_to_str(omode),
700 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
702 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
705 /* If creating file, give 0640 permissions */
706 Dmsg3(100, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
707 archive_name.c_str(), mode);
708 /* Use system open() */
709 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
711 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
713 // Should this be set if we try the create/open below
714 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
715 Dmsg1(100, "open failed: %s", errmsg);
717 /* Previous open failed. See if we can recover */
718 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
719 (part > num_dvd_parts)) {
720 /* If the last part (on spool), doesn't exist when accessing,
721 * create it. In read/write mode a write will be allowed (higher
722 * level software thinks that we are extending a pre-existing
723 * media. Reads for READ_ONLY will report immediately an EOF
724 * Sometimes it is better to finish with an EOF than with an error. */
725 Dmsg1(100, "Creating last part on spool: %s\n", archive_name.c_str());
726 omode = CREATE_READ_WRITE;
727 set_mode(CREATE_READ_WRITE);
728 m_fd = ::open(archive_name.c_str(), mode, 0640);
732 Dmsg1(100, "after open fd=%d\n", m_fd);
734 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
737 /* Get size of file */
738 if (fstat(m_fd, &filestat) < 0) {
741 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
743 Dmsg1(100, "open failed: %s", errmsg);
744 /* Use system close() */
748 part_size = filestat.st_size;
750 update_pos(dcr); /* update position */
758 * Returns: true on success
761 bool DEVICE::rewind(DCR *dcr)
767 Dmsg3(400, "rewind res=%d fd=%d %s\n", num_reserved(), m_fd, print_name());
768 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
769 block_num = file = 0;
773 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
775 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
777 Emsg0(M_ABORT, 0, errmsg);
782 mt_com.mt_op = MTREW;
784 /* If we get an I/O error on rewind, it is probably because
785 * the drive is actually busy. We loop for (about 5 minutes)
786 * retrying every 5 seconds.
788 for (i=max_rewind_wait; ; i -= 5) {
789 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
792 if (i == max_rewind_wait) {
793 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.bstrerror());
796 * This is a gross hack, because if the user has the
797 * device mounted (i.e. open), then uses mtx to load
798 * a tape, the current open file descriptor is invalid.
799 * So, we close the drive and re-open it.
802 int open_mode = openmode;
805 open(dcr, open_mode);
813 if (dev_errno == EIO) {
814 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
818 if (dev_errno == EIO && i > 0) {
819 Dmsg0(200, "Sleeping 5 seconds.\n");
824 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
825 print_name(), be.bstrerror());
830 } else if (is_file() || is_dvd()) {
831 if (lseek(dcr, (boffset_t)0, SEEK_SET) < 0) {
834 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
835 print_name(), be.bstrerror());
844 * Called to indicate that we have just read an
845 * EOF from the device.
847 void DEVICE::set_ateof()
859 * Called to indicate we are now at the end of the tape, and
860 * writing is not possible.
862 void DEVICE::set_ateot()
864 /* Make tape effectively read-only */
865 state |= (ST_EOF|ST_EOT|ST_WEOT);
870 * Position device to end of medium (end of data)
871 * Returns: true on succes
874 bool DEVICE::eod(DCR *dcr)
883 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
887 #if defined (__digital__) && defined (__unix__)
888 return fsf(VolCatInfo.VolCatFiles);
895 clear_eof(); /* remove EOF flag */
896 block_num = file = 0;
903 pos = lseek(dcr, (boffset_t)0, SEEK_END);
904 // Dmsg1(100, "====== Seek to %lld\n", pos);
912 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
913 print_name(), be.bstrerror());
917 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
918 Dmsg0(100,"Using FAST FSF for EOM\n");
919 /* If unknown position, rewind */
920 if (get_os_tape_file() < 0) {
925 mt_com.mt_op = MTFSF;
927 * ***FIXME*** fix code to handle case that INT16_MAX is
930 mt_com.mt_count = INT16_MAX; /* use big positive number */
931 if (mt_com.mt_count < 0) {
932 mt_com.mt_count = INT16_MAX; /* brain damaged system */
936 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
937 if (has_cap(CAP_EOM)) {
938 Dmsg0(100,"Using EOM for EOM\n");
939 mt_com.mt_op = MTEOM;
943 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
945 clrerror(mt_com.mt_op);
946 Dmsg1(50, "ioctl error: %s\n", be.bstrerror());
948 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
949 print_name(), be.bstrerror());
953 os_file = get_os_tape_file();
957 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
958 print_name(), be.bstrerror());
961 Dmsg1(100, "EOD file=%d\n", os_file);
969 * Rewind then use FSF until EOT reached
975 * Move file by file to the end of the tape
978 for (file_num=file; !at_eot(); file_num++) {
979 Dmsg0(200, "eod: doing fsf 1\n");
981 Dmsg0(200, "fsf error.\n");
985 * Avoid infinite loop by ensuring we advance.
987 if (!at_eot() && file_num == (int)file) {
988 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
990 os_file = get_os_tape_file();
992 Dmsg2(100, "Adjust file from %d to %d\n", file_num, os_file);
1000 * Some drivers leave us after second EOF when doing
1001 * MTEOM, so we must backup so that appending overwrites
1004 if (has_cap(CAP_BSFATEOM)) {
1005 /* Backup over EOF */
1007 /* If BSF worked and fileno is known (not -1), set file */
1008 os_file = get_os_tape_file();
1010 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , os_file);
1013 file++; /* wing it -- not correct on all OSes */
1016 update_pos(dcr); /* update position */
1018 Dmsg1(200, "EOD dev->file=%d\n", file);
1023 * Set the position of the device -- only for files and DVD
1024 * For other devices, there is no generic way to do it.
1025 * Returns: true on succes
1028 bool DEVICE::update_pos(DCR *dcr)
1035 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
1036 Emsg1(M_FATAL, 0, "%s", errmsg);
1040 /* Find out where we are */
1041 if (is_file() || is_dvd()) {
1044 pos = lseek(dcr, (boffset_t)0, SEEK_CUR);
1048 Pmsg1(000, _("Seek error: ERR=%s\n"), be.bstrerror());
1049 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1050 print_name(), be.bstrerror());
1054 block_num = (uint32_t)pos;
1055 file = (uint32_t)(pos >> 32);
1062 * Return the status of the device. This was meant
1063 * to be a generic routine. Unfortunately, it doesn't
1064 * seem possible (at least I do not know how to do it
1065 * currently), which means that for the moment, this
1066 * routine has very little value.
1070 uint32_t status_dev(DEVICE *dev)
1072 struct mtget mt_stat;
1075 if (dev->state & (ST_EOT | ST_WEOT)) {
1079 if (dev->state & ST_EOF) {
1083 if (dev->is_tape()) {
1085 Pmsg0(-20,_(" Bacula status:"));
1086 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1087 if (dev->d_ioctl(dev->fd(), MTIOCGET, (char *)&mt_stat) < 0) {
1089 dev->dev_errno = errno;
1090 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1091 dev->print_name(), be.bstrerror());
1094 Pmsg0(-20, _(" Device status:"));
1096 #if defined(HAVE_LINUX_OS)
1097 if (GMT_EOF(mt_stat.mt_gstat)) {
1101 if (GMT_BOT(mt_stat.mt_gstat)) {
1105 if (GMT_EOT(mt_stat.mt_gstat)) {
1109 if (GMT_SM(mt_stat.mt_gstat)) {
1113 if (GMT_EOD(mt_stat.mt_gstat)) {
1117 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1118 stat |= BMT_WR_PROT;
1119 Pmsg0(-20, " WR_PROT");
1121 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1123 Pmsg0(-20, " ONLINE");
1125 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1126 stat |= BMT_DR_OPEN;
1127 Pmsg0(-20, " DR_OPEN");
1129 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1130 stat |= BMT_IM_REP_EN;
1131 Pmsg0(-20, " IM_REP_EN");
1133 #elif defined(HAVE_WIN32)
1134 if (GMT_EOF(mt_stat.mt_gstat)) {
1138 if (GMT_BOT(mt_stat.mt_gstat)) {
1142 if (GMT_EOT(mt_stat.mt_gstat)) {
1146 if (GMT_EOD(mt_stat.mt_gstat)) {
1150 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1151 stat |= BMT_WR_PROT;
1152 Pmsg0(-20, " WR_PROT");
1154 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1156 Pmsg0(-20, " ONLINE");
1158 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1159 stat |= BMT_DR_OPEN;
1160 Pmsg0(-20, " DR_OPEN");
1162 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1163 stat |= BMT_IM_REP_EN;
1164 Pmsg0(-20, " IM_REP_EN");
1167 #endif /* !SunOS && !OSF */
1168 if (dev->has_cap(CAP_MTIOCGET)) {
1169 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1171 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1174 stat |= BMT_ONLINE | BMT_BOT;
1181 * Load medium in device
1182 * Returns: true on success
1185 bool load_dev(DEVICE *dev)
1191 if (dev->fd() < 0) {
1192 dev->dev_errno = EBADF;
1193 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1194 Emsg0(M_FATAL, 0, dev->errmsg);
1197 if (!(dev->is_tape())) {
1201 Dmsg0(200, "stored: MTLOAD command not available\n");
1203 dev->dev_errno = ENOTTY; /* function not available */
1204 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1205 dev->print_name(), be.bstrerror());
1209 dev->block_num = dev->file = 0;
1212 mt_com.mt_op = MTLOAD;
1213 mt_com.mt_count = 1;
1214 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
1216 dev->dev_errno = errno;
1217 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1218 dev->print_name(), be.bstrerror());
1226 * Rewind device and put it offline
1227 * Returns: true on success
1230 bool DEVICE::offline()
1235 return true; /* device not open */
1238 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1239 block_num = file = 0;
1243 mt_com.mt_op = MTOFFL;
1244 mt_com.mt_count = 1;
1245 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
1248 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1249 print_name(), be.bstrerror());
1252 Dmsg1(100, "Offlined device %s\n", print_name());
1256 bool DEVICE::offline_or_rewind()
1261 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1265 * Note, this rewind probably should not be here (it wasn't
1266 * in prior versions of Bacula), but on FreeBSD, this is
1267 * needed in the case the tape was "frozen" due to an error
1268 * such as backspacing after writing and EOF. If it is not
1269 * done, all future references to the drive get and I/O error.
1272 return rewind(NULL);
1277 * Foward space a file
1278 * Returns: true on success
1281 bool DEVICE::fsf(int num)
1283 int32_t os_file = 0;
1289 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1290 Emsg0(M_FATAL, 0, errmsg);
1300 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1304 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1307 Dmsg0(100, "fsf\n");
1310 * If Fast forward space file is set, then we
1311 * use MTFSF to forward space and MTIOCGET
1312 * to get the file position. We assume that
1313 * the SCSI driver will ensure that we do not
1314 * forward space past the end of the medium.
1316 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1318 mt_com.mt_op = MTFSF;
1319 mt_com.mt_count = num;
1320 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1322 my_errno = errno; /* save errno */
1323 } else if ((os_file=get_os_tape_file()) < 0) {
1324 my_errno = errno; /* save errno */
1326 if (my_errno != 0) {
1329 Dmsg0(200, "Set ST_EOT\n");
1331 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1332 print_name(), be.bstrerror(my_errno));
1333 Dmsg1(200, "%s", errmsg);
1337 Dmsg1(200, "fsf file=%d\n", os_file);
1343 * Here if CAP_FSF is set, and virtually all drives
1344 * these days support it, we read a record, then forward
1345 * space one file. Using this procedure, which is slow,
1346 * is the only way we can be sure that we don't read
1347 * two consecutive EOF marks, which means End of Data.
1349 } else if (has_cap(CAP_FSF)) {
1352 Dmsg0(200, "FSF has cap_fsf\n");
1353 if (max_block_size == 0) {
1354 rbuf_len = DEFAULT_BLOCK_SIZE;
1356 rbuf_len = max_block_size;
1358 rbuf = get_memory(rbuf_len);
1359 mt_com.mt_op = MTFSF;
1360 mt_com.mt_count = 1;
1361 while (num-- && !at_eot()) {
1362 Dmsg0(100, "Doing read before fsf\n");
1363 if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1364 if (errno == ENOMEM) { /* tape record exceeds buf len */
1365 stat = rbuf_len; /* This is OK */
1367 * On IBM drives, they return ENOSPC at EOM
1368 * instead of EOF status
1370 } else if (at_eof() && errno == ENOSPC) {
1376 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1378 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1379 print_name(), be.bstrerror());
1380 Dmsg1(100, "%s", errmsg);
1384 if (stat == 0) { /* EOF */
1385 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1386 /* Two reads of zero means end of tape */
1389 Dmsg0(100, "Set ST_EOT\n");
1395 } else { /* Got data */
1400 Dmsg0(100, "Doing MTFSF\n");
1401 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1402 if (stat < 0) { /* error => EOT */
1405 Dmsg0(100, "Set ST_EOT\n");
1407 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1408 print_name(), be.bstrerror());
1409 Dmsg0(100, "Got < 0 for MTFSF\n");
1410 Dmsg1(100, "%s", errmsg);
1418 * No FSF, so use FSR to simulate it
1421 Dmsg0(200, "Doing FSR for FSF\n");
1422 while (num-- && !at_eot()) {
1423 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1427 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1433 Dmsg1(200, "Return %d from FSF\n", stat);
1435 Dmsg0(200, "ST_EOF set on exit FSF\n");
1438 Dmsg0(200, "ST_EOT set on exit FSF\n");
1440 Dmsg1(200, "Return from FSF file=%d\n", file);
1445 * Backward space a file
1446 * Returns: false on failure
1449 bool DEVICE::bsf(int num)
1456 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1457 Emsg0(M_FATAL, 0, errmsg);
1462 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1467 Dmsg0(100, "bsf\n");
1473 mt_com.mt_op = MTBSF;
1474 mt_com.mt_count = num;
1475 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1479 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1480 print_name(), be.bstrerror());
1487 * Foward space num records
1488 * Returns: false on failure
1491 bool DEVICE::fsr(int num)
1498 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1499 Emsg0(M_FATAL, 0, errmsg);
1507 if (!has_cap(CAP_FSR)) {
1508 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1512 Dmsg1(100, "fsr %d\n", num);
1513 mt_com.mt_op = MTFSR;
1514 mt_com.mt_count = num;
1515 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1521 struct mtget mt_stat;
1523 Dmsg1(100, "FSF fail: ERR=%s\n", be.bstrerror());
1524 if (dev_get_os_pos(this, &mt_stat)) {
1525 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1526 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1527 file = mt_stat.mt_fileno;
1528 block_num = mt_stat.mt_blkno;
1536 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1537 num, print_name(), be.bstrerror());
1543 * Backward space a record
1544 * Returns: false on failure
1547 bool DEVICE::bsr(int num)
1554 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1555 Emsg0(M_FATAL, 0, errmsg);
1563 if (!has_cap(CAP_BSR)) {
1564 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1568 Dmsg0(100, "bsr_dev\n");
1572 mt_com.mt_op = MTBSR;
1573 mt_com.mt_count = num;
1574 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1578 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1579 print_name(), be.bstrerror());
1584 void DEVICE::lock_door()
1588 mt_com.mt_op = MTLOCK;
1589 mt_com.mt_count = 1;
1590 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1594 void DEVICE::unlock_door()
1598 mt_com.mt_op = MTUNLOCK;
1599 mt_com.mt_count = 1;
1600 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1604 void DEVICE::set_slot(int32_t slot)
1607 if (vol) vol->clear_slot();
1610 void DEVICE::clear_slot()
1613 if (vol) vol->set_slot(-1);
1619 * Reposition the device to file, block
1620 * Returns: false on failure
1623 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1627 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1628 Emsg0(M_FATAL, 0, errmsg);
1633 boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1634 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1635 if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1638 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1639 print_name(), be.bstrerror());
1648 /* After this point, we are tape only */
1649 Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1651 Dmsg0(100, "Rewind\n");
1652 if (!rewind(NULL)) {
1657 Dmsg1(100, "fsf %d\n", rfile-file);
1658 if (!fsf(rfile-file)) {
1659 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1662 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1664 if (rblock < block_num) {
1665 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1666 Dmsg0(100, "bsf 1\n");
1668 Dmsg0(100, "fsf 1\n");
1670 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1672 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1673 /* Ignore errors as Bacula can read to the correct block */
1674 Dmsg1(100, "fsr %d\n", rblock-block_num);
1675 return fsr(rblock-block_num);
1677 while (rblock > block_num) {
1678 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1681 Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1682 print_name(), be.bstrerror());
1685 Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1694 * Write an end of file on the device
1695 * Returns: true on success
1698 bool DEVICE::weof(int num)
1702 Dmsg1(129, "=== weof_dev=%s\n", print_name());
1706 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1707 Emsg0(M_FATAL, 0, errmsg);
1715 if (!can_append()) {
1716 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1717 Emsg0(M_FATAL, 0, errmsg);
1723 mt_com.mt_op = MTWEOF;
1724 mt_com.mt_count = num;
1725 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1734 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1735 print_name(), be.bstrerror());
1743 * If implemented in system, clear the tape
1746 void DEVICE::clrerror(int func)
1748 const char *msg = NULL;
1751 dev_errno = errno; /* save errno */
1753 VolCatInfo.VolCatErrors++;
1760 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1763 break; /* ignore message printed later */
1766 clear_cap(CAP_EOF); /* turn off feature */
1771 clear_cap(CAP_EOM); /* turn off feature */
1776 clear_cap(CAP_FSF); /* turn off feature */
1780 clear_cap(CAP_BSF); /* turn off feature */
1784 clear_cap(CAP_FSR); /* turn off feature */
1788 clear_cap(CAP_BSR); /* turn off feature */
1798 #ifdef MTSETDRVBUFFER
1799 case MTSETDRVBUFFER:
1800 msg = "MTSETDRVBUFFER";
1833 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1839 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1840 Emsg0(M_ERROR, 0, errmsg);
1845 * Now we try different methods of clearing the error
1846 * status on the drive so that it is not locked for
1847 * further operations.
1850 /* On some systems such as NetBSD, this clears all errors */
1853 /* Found on Solaris */
1856 d_ioctl(m_fd, MTIOCLRERR);
1857 Dmsg0(200, "Did MTIOCLRERR\n");
1861 /* Typically on FreeBSD */
1865 /* Read and clear SCSI error status */
1866 union mterrstat mt_errstat;
1867 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1868 be.bstrerror(dev_errno));
1869 d_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1873 /* Clear Subsystem Exception OSF1 */
1877 mt_com.mt_op = MTCSE;
1878 mt_com.mt_count = 1;
1879 /* Clear any error condition on the tape */
1880 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1881 Dmsg0(200, "Did MTCSE\n");
1888 * Set to unload the current volume in the drive
1890 void DEVICE::set_unload()
1892 if (!m_unload && VolHdr.VolumeName[0] != 0) {
1894 memcpy(UnloadVolName, VolHdr.VolumeName, sizeof(UnloadVolName));
1900 * Clear volume header
1902 void DEVICE::clear_volhdr()
1904 Dmsg1(100, "Clear volhdr vol=%s\n", VolHdr.VolumeName);
1905 memset(&VolHdr, 0, sizeof(VolHdr));
1912 void DEVICE::close()
1914 Dmsg1(100, "close_dev %s\n", print_name());
1915 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1920 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1922 return; /* already closed */
1935 unmount(1); /* do unmount if required */
1942 /* Clean up device packet so it can be reused */
1945 * Be careful not to clear items needed by the DVD driver
1946 * when it is closing a single part.
1948 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF|
1949 ST_MOUNTED|ST_MEDIA|ST_SHORT);
1950 label_type = B_BACULA_LABEL;
1951 file = block_num = 0;
1954 EndFile = EndBlock = 0;
1957 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1959 stop_thread_timer(tid);
1965 * This call closes the device, but it is used in DVD handling
1966 * where we close one part and then open the next part. The
1967 * difference between close_part() and close() is that close_part()
1968 * saves the state information of the device (e.g. the Volume lable,
1969 * the Volume Catalog record, ... This permits opening and closing
1970 * the Volume parts multiple times without losing track of what the
1971 * main Volume parameters are.
1973 void DEVICE::close_part(DCR * /*dcr*/)
1975 VOLUME_LABEL saveVolHdr;
1976 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1979 saveVolHdr = VolHdr; /* structure assignment */
1980 saveVolCatInfo = VolCatInfo; /* structure assignment */
1981 close(); /* close current part */
1982 VolHdr = saveVolHdr; /* structure assignment */
1983 VolCatInfo = saveVolCatInfo; /* structure assignment */
1986 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1990 return lseek_dvd(dcr, offset, whence);
1992 #if defined(HAVE_WIN32)
1993 return ::_lseeki64(m_fd, (__int64)offset, whence);
1995 return ::lseek(m_fd, offset, whence);
2002 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
2006 Dmsg1(100, "truncate %s\n", print_name());
2011 /* maybe we should rewind and write and eof ???? */
2012 return true; /* we don't really truncate tapes */
2014 return truncate_dvd(dcr);
2016 if (ftruncate(m_fd, 0) != 0) {
2018 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
2019 print_name(), be.bstrerror());
2024 * Check for a successful ftruncate() and issue a work-around for devices
2025 * (mostly cheap NAS) that don't support truncation.
2026 * Workaround supplied by Martin Schmid as a solution to bug #1011.
2029 * 3. open new file with same mode
2030 * 4. change ownership to original
2033 if (fstat(m_fd, &st) != 0) {
2035 Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"),
2036 print_name(), be.bstrerror());
2040 if (st.st_size != 0) { /* ftruncate() didn't work */
2041 POOL_MEM archive_name(PM_FNAME);
2043 pm_strcpy(archive_name, dev_name);
2044 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
2045 pm_strcat(archive_name, "/");
2047 pm_strcat(archive_name, dcr->VolumeName);
2049 Mmsg2(errmsg, _("Device %s doesn't support ftruncate(). Recreating file %s.\n"),
2050 print_name(), archive_name.c_str());
2052 /* Close file and blow it away */
2054 ::unlink(archive_name.c_str());
2056 /* Recreate the file -- of course, empty */
2057 set_mode(CREATE_READ_WRITE);
2058 if ((m_fd = ::open(archive_name.c_str(), mode, st.st_mode)) < 0) {
2061 Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), archive_name.c_str(),
2063 Dmsg1(100, "reopen failed: %s", errmsg);
2064 Emsg0(M_FATAL, 0, errmsg);
2068 /* Reset proper owner */
2069 chown(archive_name.c_str(), st.st_uid, st.st_gid);
2077 /* Mount the device.
2078 * If timeout, wait until the mount command returns 0.
2079 * If !timeout, try to mount the device only once.
2081 bool DEVICE::mount(int timeout)
2083 Dmsg0(190, "Enter mount\n");
2086 } else if (requires_mount()) {
2087 return do_mount(1, timeout);
2092 /* Unmount the device
2093 * If timeout, wait until the unmount command returns 0.
2094 * If !timeout, try to unmount the device only once.
2096 bool DEVICE::unmount(int timeout)
2098 Dmsg0(100, "Enter unmount\n");
2099 if (requires_mount() && is_mounted()) {
2100 return do_mount(0, timeout);
2105 /* (Un)mount the device */
2106 bool DEVICE::do_mount(int mount, int dotimeout)
2108 POOL_MEM ocmd(PM_FNAME);
2111 int status, timeout;
2116 Dmsg0(200, "======= mount=1\n");
2119 icmd = device->mount_command;
2121 if (!is_mounted()) {
2122 Dmsg0(200, "======= mount=0\n");
2125 icmd = device->unmount_command;
2128 clear_freespace_ok();
2129 edit_mount_codes(ocmd, icmd);
2131 Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2134 /* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
2139 results = get_memory(4000);
2141 /* If busy retry each second */
2142 Dmsg1(100, "do_mount run_prog=%s\n", ocmd.c_str());
2143 while ((status = run_program_full_output(ocmd.c_str(),
2144 max_open_wait/2, results)) != 0) {
2145 /* Doesn't work with internationalization (This is not a problem) */
2146 if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2149 if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2152 if (timeout-- > 0) {
2153 /* Sometimes the device cannot be mounted because it is already mounted.
2154 * Try to unmount it, then remount it */
2156 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2164 Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2165 (mount ? "" : "un"), status, results, be.bstrerror(status));
2166 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2167 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2169 Dmsg4(100, "Device %s cannot be %smounted. stat=%d ERR=%s\n", print_name(),
2170 (mount ? "" : "un"), status, results);
2171 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2172 print_name(), (mount ? "" : "un"), results);
2175 * Now, just to be sure it is not mounted, try to read the
2179 struct dirent *entry, *result;
2183 name_max = pathconf(".", _PC_NAME_MAX);
2184 if (name_max < 1024) {
2188 if (!(dp = opendir(device->mount_point))) {
2191 Dmsg3(100, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2192 device->mount_point, print_name(), be.bstrerror());
2196 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2199 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2201 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
2202 device->mount_point, print_name());
2205 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2206 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2209 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2215 Dmsg1(100, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2218 /* If we got more than ., .. and .keep */
2219 /* there must be something mounted */
2221 Dmsg1(100, "Did Mount by count=%d\n", count);
2224 /* An unmount request. We failed to unmount - report an error */
2226 free_pool_memory(results);
2227 Dmsg0(200, "== error mount=1 wanted unmount\n");
2233 free_pool_memory(results);
2234 Dmsg0(200, "============ mount=0\n");
2239 set_mounted(mount); /* set/clear mounted flag */
2240 free_pool_memory(results);
2241 /* Do not check free space when unmounting */
2242 if (mount && !update_freespace()) {
2245 Dmsg1(200, "============ mount=%d\n", mount);
2250 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2252 * %a = archive device name
2253 * %e = erase (set if cannot mount and first part)
2256 * %v = last part name
2258 * omsg = edited output message
2259 * imsg = input string containing edit codes (%x)
2262 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2268 POOL_MEM archive_name(PM_FNAME);
2270 omsg.c_str()[0] = 0;
2271 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2272 for (p=imsg; *p; p++) {
2282 if (num_dvd_parts == 0) {
2283 if (truncating || blank_dvd) {
2293 bsnprintf(add, sizeof(add), "%d", part);
2297 str = device->mount_point;
2300 make_spooled_dvd_filename(this, archive_name);
2301 str = archive_name.c_str();
2315 Dmsg1(1900, "add_str %s\n", str);
2316 pm_strcat(omsg, (char *)str);
2317 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2321 /* return the last timer interval (ms)
2322 * or 0 if something goes wrong
2324 btime_t DEVICE::get_timer_count()
2326 btime_t temp = last_timer;
2327 last_timer = get_current_btime();
2328 temp = last_timer - temp; /* get elapsed time */
2329 return (temp>0)?temp:0; /* take care of skewed clock */
2333 ssize_t DEVICE::read(void *buf, size_t len)
2339 read_len = d_read(m_fd, buf, len);
2341 last_tick = get_timer_count();
2343 DevReadTime += last_tick;
2344 VolCatInfo.VolReadTime += last_tick;
2346 if (read_len > 0) { /* skip error */
2347 DevReadBytes += read_len;
2354 ssize_t DEVICE::write(const void *buf, size_t len)
2360 write_len = d_write(m_fd, buf, len);
2362 last_tick = get_timer_count();
2364 DevWriteTime += last_tick;
2365 VolCatInfo.VolWriteTime += last_tick;
2367 if (write_len > 0) { /* skip error */
2368 DevWriteBytes += write_len;
2374 /* Return the resource name for the device */
2375 const char *DEVICE::name() const
2377 return device->hdr.name;
2380 /* Returns file position on tape or -1 */
2381 int32_t DEVICE::get_os_tape_file()
2383 struct mtget mt_stat;
2385 if (has_cap(CAP_MTIOCGET) &&
2386 d_ioctl(m_fd, MTIOCGET, (char *)&mt_stat) == 0) {
2387 return mt_stat.mt_fileno;
2393 dev_vol_name(DEVICE *dev)
2395 return dev->VolCatInfo.VolCatName;
2400 * Free memory allocated for the device
2402 void DEVICE::term(void)
2404 Dmsg1(900, "term dev: %s\n", print_name());
2407 free_memory(dev_name);
2411 free_memory(prt_name);
2415 free_pool_memory(errmsg);
2418 pthread_mutex_destroy(&m_mutex);
2419 pthread_cond_destroy(&wait);
2420 pthread_cond_destroy(&wait_next_vol);
2421 pthread_mutex_destroy(&spool_mutex);
2422 // rwl_destroy(&lock);
2423 if (attached_dcrs) {
2424 delete attached_dcrs;
2425 attached_dcrs = NULL;
2434 * This routine initializes the device wait timers
2436 void init_device_wait_timers(DCR *dcr)
2438 DEVICE *dev = dcr->dev;
2439 JCR *jcr = dcr->jcr;
2441 /* ******FIXME******* put these on config variables */
2442 dev->min_wait = 60 * 60;
2443 dev->max_wait = 24 * 60 * 60;
2444 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2445 dev->wait_sec = dev->min_wait;
2446 dev->rem_wait_sec = dev->wait_sec;
2450 jcr->min_wait = 60 * 60;
2451 jcr->max_wait = 24 * 60 * 60;
2452 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2453 jcr->wait_sec = jcr->min_wait;
2454 jcr->rem_wait_sec = jcr->wait_sec;
2459 void init_jcr_device_wait_timers(JCR *jcr)
2461 /* ******FIXME******* put these on config variables */
2462 jcr->min_wait = 60 * 60;
2463 jcr->max_wait = 24 * 60 * 60;
2464 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2465 jcr->wait_sec = jcr->min_wait;
2466 jcr->rem_wait_sec = jcr->wait_sec;
2472 * The dev timers are used for waiting on a particular device
2474 * Returns: true if time doubled
2475 * false if max time expired
2477 bool double_dev_wait_time(DEVICE *dev)
2479 dev->wait_sec *= 2; /* double wait time */
2480 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2481 dev->wait_sec = dev->max_wait;
2484 dev->rem_wait_sec = dev->wait_sec;
2485 if (dev->num_wait >= dev->max_num_wait) {
2492 void set_os_device_parameters(DCR *dcr)
2494 DEVICE *dev = dcr->dev;
2496 if (strcmp(dev->dev_name, "/dev/null") == 0) {
2497 return; /* no use trying to set /dev/null */
2500 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2503 Dmsg0(100, "In set_os_device_parameters\n");
2504 #if defined(MTSETBLK)
2505 if (dev->min_block_size == dev->max_block_size &&
2506 dev->min_block_size == 0) { /* variable block mode */
2507 mt_com.mt_op = MTSETBLK;
2508 mt_com.mt_count = 0;
2509 Dmsg0(100, "Set block size to zero\n");
2510 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2511 dev->clrerror(MTSETBLK);
2515 #if defined(MTSETDRVBUFFER)
2516 if (getuid() == 0) { /* Only root can do this */
2517 mt_com.mt_op = MTSETDRVBUFFER;
2518 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2519 if (!dev->has_cap(CAP_TWOEOF)) {
2520 mt_com.mt_count |= MT_ST_TWO_FM;
2522 if (dev->has_cap(CAP_EOM)) {
2523 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2525 Dmsg0(100, "MTSETDRVBUFFER\n");
2526 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2527 dev->clrerror(MTSETDRVBUFFER);
2534 #ifdef HAVE_NETBSD_OS
2536 if (dev->min_block_size == dev->max_block_size &&
2537 dev->min_block_size == 0) { /* variable block mode */
2538 mt_com.mt_op = MTSETBSIZ;
2539 mt_com.mt_count = 0;
2540 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2541 dev->clrerror(MTSETBSIZ);
2543 /* Get notified at logical end of tape */
2544 mt_com.mt_op = MTEWARN;
2545 mt_com.mt_count = 1;
2546 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2547 dev->clrerror(MTEWARN);
2553 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2555 if (dev->min_block_size == dev->max_block_size &&
2556 dev->min_block_size == 0) { /* variable block mode */
2557 mt_com.mt_op = MTSETBSIZ;
2558 mt_com.mt_count = 0;
2559 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2560 dev->clrerror(MTSETBSIZ);
2563 #if defined(MTIOCSETEOTMODEL)
2565 if (dev->has_cap(CAP_TWOEOF)) {
2570 if (dev->d_ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2572 dev->dev_errno = errno; /* save errno */
2573 Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2574 dev->print_name(), be.bstrerror(dev->dev_errno));
2575 Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2583 if (dev->min_block_size == dev->max_block_size &&
2584 dev->min_block_size == 0) { /* variable block mode */
2585 mt_com.mt_op = MTSRSZ;
2586 mt_com.mt_count = 0;
2587 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2588 dev->clrerror(MTSRSZ);
2595 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2597 Dmsg0(100, "dev_get_os_pos\n");
2598 return dev->has_cap(CAP_MTIOCGET) &&
2599 dev->d_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2600 mt_stat->mt_fileno >= 0;
2603 static const char *modes[] = {
2604 "CREATE_READ_WRITE",
2611 static const char *mode_to_str(int mode)
2613 static char buf[100];
2614 if (mode < 1 || mode > 4) {
2615 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2618 return modes[mode-1];