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);
405 mount(1); /* do mount if required */
407 Dmsg0(100, "Open dev: device is tape\n");
409 get_autochanger_loaded_slot(dcr);
418 if (is_fifo() && timeout) {
420 tid = start_thread_timer(dcr->jcr, pthread_self(), timeout);
422 Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
423 #if defined(HAVE_WIN32)
426 if ((m_fd = d_open(dev_name, mode)) < 0) {
433 /* If busy retry each second for max_open_wait seconds */
435 /* Try non-blocking open */
436 m_fd = d_open(dev_name, mode+O_NONBLOCK);
440 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
441 print_name(), omode, mode, errno, be.bstrerror());
443 /* Tape open, now rewind it */
444 Dmsg0(100, "Rewind after open\n");
445 mt_com.mt_op = MTREW;
447 /* rewind only if dev is a tape */
448 if (is_tape() && (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0)) {
450 dev_errno = errno; /* set error status from rewind */
453 Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
454 be.bstrerror(dev_errno));
455 /* If we get busy, device is probably rewinding, try again */
456 if (dev_errno != EBUSY) {
457 break; /* error -- no medium */
460 /* Got fd and rewind worked, so we must have medium in drive */
462 m_fd = d_open(dev_name, mode); /* open normally */
466 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
467 print_name(), omode, mode, errno, be.bstrerror());
472 set_os_device_parameters(dcr); /* do system dependent stuff */
473 break; /* Successfully opened and rewound */
477 /* Exceed wait time ? */
478 if (time(NULL) - start_time >= max_open_wait) {
479 break; /* yes, get out */
486 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
487 print_name(), be.bstrerror(dev_errno));
488 Dmsg1(100, "%s", errmsg);
491 /* Stop any open() timer we started */
493 stop_thread_timer(tid);
496 Dmsg1(100, "open dev: tape %d opened\n", m_fd);
503 void DEVICE::open_file_device(DCR *dcr, int omode)
505 POOL_MEM archive_name(PM_FNAME);
507 get_autochanger_loaded_slot(dcr);
510 * Handle opening of File Archive (not a tape)
513 pm_strcpy(archive_name, dev_name);
515 * If this is a virtual autochanger (i.e. changer_res != NULL)
516 * we simply use the device name, assuming it has been
517 * appropriately setup by the "autochanger".
519 if (!device->changer_res || device->changer_command[0] == 0) {
520 if (VolCatInfo.VolCatName[0] == 0) {
521 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
527 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
528 pm_strcat(archive_name, "/");
530 pm_strcat(archive_name, VolCatInfo.VolCatName);
533 mount(1); /* do mount if required */
537 /* If creating file, give 0640 permissions */
538 Dmsg3(100, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
539 archive_name.c_str(), mode);
540 /* Use system open() */
541 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
544 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
546 Dmsg1(100, "open failed: %s", errmsg);
547 // Jmsg1(NULL, M_WARNING, 0, "%s", errmsg);
553 Dmsg4(100, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
554 m_fd, part, num_dvd_parts, part_size);
558 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
559 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
560 * has the desired Volume name, but there is NO assurance that
561 * any other field of VolCatInfo is correct.
563 void DEVICE::open_dvd_device(DCR *dcr, int omode)
565 POOL_MEM archive_name(PM_FNAME);
566 struct stat filestat;
569 * Handle opening of DVD Volume
571 Dmsg2(100, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n",
572 &dcr->VolCatInfo, mode_to_str(omode));
575 * For a DVD we must always pull the state info from dcr->VolCatInfo
576 * This is a bit ugly, but is necessary because we need to open/close/re-open
577 * the dvd file in order to properly mount/unmount and access the
578 * DVD. So we store the state of the DVD as far as is known in the
579 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
580 * copy here, when opening.
582 VolCatInfo = dcr->VolCatInfo; /* structure assignment */
583 Dmsg1(100, "Volume=%s\n", VolCatInfo.VolCatName);
585 if (VolCatInfo.VolCatName[0] == 0) {
586 Dmsg1(10, "Could not open DVD device %s. No Volume name given.\n",
588 Mmsg(errmsg, _("Could not open DVD device %s. No Volume name given.\n"),
595 Dmsg0(100, "Set part=1\n");
596 part = 1; /* count from 1 */
600 if (num_dvd_parts != VolCatInfo.VolCatParts) {
601 num_dvd_parts = VolCatInfo.VolCatParts;
605 * If we are not trying to access the last part, set mode to
606 * OPEN_READ_ONLY as writing would be an error.
608 Dmsg2(100, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
609 /* Now find the name of the part that we want to access */
610 if (part <= num_dvd_parts) {
611 omode = OPEN_READ_ONLY;
612 make_mounted_dvd_filename(this, archive_name);
613 set_part_spooled(false);
615 omode = OPEN_READ_WRITE;
616 make_spooled_dvd_filename(this, archive_name);
617 set_part_spooled(true);
621 // Clear any previous blank_dvd status - we will recalculate it here
624 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
625 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
628 Dmsg0(99, "DVD device mounted.\n");
629 if (num_dvd_parts == 0 && !truncating) {
631 * If we can mount the device, and we are not truncating the DVD,
632 * we usually want to abort. There is one exception, if there is
633 * only one 0-sized file on the DVD, with the right volume name,
634 * we continue (it's the method used by truncate_dvd to truncate a volume).
636 if (!check_can_write_on_non_blank_dvd(dcr)) {
637 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
638 Emsg0(M_FATAL, 0, errmsg);
639 unmount(1); /* Unmount the device, so the operator can change it. */
646 * Ensure that we have the correct DVD loaded by looking for part1.
647 * We only succeed the open if it exists. Failure to do this could
648 * leave us trying to add a part to a different DVD!
650 uint32_t oldpart = part;
652 POOL_MEM part1_name(PM_FNAME);
654 make_mounted_dvd_filename(this, part1_name);
656 if (stat(part1_name.c_str(), &statp) < 0) {
658 Mmsg(errmsg, _("Unable to stat DVD part 1 file %s: ERR=%s\n"),
659 part1_name.c_str(), be.bstrerror());
660 Emsg0(M_FATAL, 0, errmsg);
664 if (!S_ISREG(statp.st_mode)) {
665 /* It is not a regular file */
666 Mmsg(errmsg, _("DVD part 1 is not a regular file %s.\n"),
668 Emsg0(M_FATAL, 0, errmsg);
674 Dmsg0(99, "DVD device mount failed.\n");
675 /* We cannot mount the device */
676 if (num_dvd_parts == 0) {
677 /* Run free space, check there is a media. */
678 if (!update_freespace()) {
679 Emsg0(M_FATAL, 0, errmsg);
684 Dmsg1(100, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
686 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
687 Emsg0(M_FATAL, 0, errmsg);
692 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
693 Emsg0(M_FATAL, 0, errmsg);
699 Dmsg5(100, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
700 archive_name.c_str(), mode_to_str(omode),
701 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
703 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
706 /* If creating file, give 0640 permissions */
707 Dmsg3(100, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
708 archive_name.c_str(), mode);
709 /* Use system open() */
710 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
712 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
714 // Should this be set if we try the create/open below
715 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
716 Dmsg1(100, "open failed: %s", errmsg);
718 /* Previous open failed. See if we can recover */
719 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
720 (part > num_dvd_parts)) {
721 /* If the last part (on spool), doesn't exist when accessing,
722 * create it. In read/write mode a write will be allowed (higher
723 * level software thinks that we are extending a pre-existing
724 * media. Reads for READ_ONLY will report immediately an EOF
725 * Sometimes it is better to finish with an EOF than with an error. */
726 Dmsg1(100, "Creating last part on spool: %s\n", archive_name.c_str());
727 omode = CREATE_READ_WRITE;
728 set_mode(CREATE_READ_WRITE);
729 m_fd = ::open(archive_name.c_str(), mode, 0640);
733 Dmsg1(100, "after open fd=%d\n", m_fd);
735 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
738 /* Get size of file */
739 if (fstat(m_fd, &filestat) < 0) {
742 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
744 Dmsg1(100, "open failed: %s", errmsg);
745 /* Use system close() */
749 part_size = filestat.st_size;
751 update_pos(dcr); /* update position */
759 * Returns: true on success
762 bool DEVICE::rewind(DCR *dcr)
768 Dmsg3(400, "rewind res=%d fd=%d %s\n", num_reserved(), m_fd, print_name());
769 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
770 block_num = file = 0;
774 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
776 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
778 Emsg0(M_ABORT, 0, errmsg);
783 mt_com.mt_op = MTREW;
785 /* If we get an I/O error on rewind, it is probably because
786 * the drive is actually busy. We loop for (about 5 minutes)
787 * retrying every 5 seconds.
789 for (i=max_rewind_wait; ; i -= 5) {
790 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
793 if (i == max_rewind_wait) {
794 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.bstrerror());
797 * This is a gross hack, because if the user has the
798 * device mounted (i.e. open), then uses mtx to load
799 * a tape, the current open file descriptor is invalid.
800 * So, we close the drive and re-open it.
803 int open_mode = openmode;
806 open(dcr, open_mode);
814 if (dev_errno == EIO) {
815 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
819 if (dev_errno == EIO && i > 0) {
820 Dmsg0(200, "Sleeping 5 seconds.\n");
825 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
826 print_name(), be.bstrerror());
831 } else if (is_file() || is_dvd()) {
832 if (lseek(dcr, (boffset_t)0, SEEK_SET) < 0) {
835 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
836 print_name(), be.bstrerror());
845 * Called to indicate that we have just read an
846 * EOF from the device.
848 void DEVICE::set_ateof()
860 * Called to indicate we are now at the end of the tape, and
861 * writing is not possible.
863 void DEVICE::set_ateot()
865 /* Make tape effectively read-only */
866 state |= (ST_EOF|ST_EOT|ST_WEOT);
871 * Position device to end of medium (end of data)
872 * Returns: true on succes
875 bool DEVICE::eod(DCR *dcr)
884 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
888 #if defined (__digital__) && defined (__unix__)
889 return fsf(VolCatInfo.VolCatFiles);
896 clear_eof(); /* remove EOF flag */
897 block_num = file = 0;
904 pos = lseek(dcr, (boffset_t)0, SEEK_END);
905 // Dmsg1(100, "====== Seek to %lld\n", pos);
913 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
914 print_name(), be.bstrerror());
918 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
919 Dmsg0(100,"Using FAST FSF for EOM\n");
920 /* If unknown position, rewind */
921 if (get_os_tape_file() < 0) {
926 mt_com.mt_op = MTFSF;
928 * ***FIXME*** fix code to handle case that INT16_MAX is
931 mt_com.mt_count = INT16_MAX; /* use big positive number */
932 if (mt_com.mt_count < 0) {
933 mt_com.mt_count = INT16_MAX; /* brain damaged system */
937 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
938 if (has_cap(CAP_EOM)) {
939 Dmsg0(100,"Using EOM for EOM\n");
940 mt_com.mt_op = MTEOM;
944 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
946 clrerror(mt_com.mt_op);
947 Dmsg1(50, "ioctl error: %s\n", be.bstrerror());
949 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
950 print_name(), be.bstrerror());
954 os_file = get_os_tape_file();
958 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
959 print_name(), be.bstrerror());
962 Dmsg1(100, "EOD file=%d\n", os_file);
970 * Rewind then use FSF until EOT reached
976 * Move file by file to the end of the tape
979 for (file_num=file; !at_eot(); file_num++) {
980 Dmsg0(200, "eod: doing fsf 1\n");
982 Dmsg0(200, "fsf error.\n");
986 * Avoid infinite loop by ensuring we advance.
988 if (!at_eot() && file_num == (int)file) {
989 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
991 os_file = get_os_tape_file();
993 Dmsg2(100, "Adjust file from %d to %d\n", file_num, os_file);
1001 * Some drivers leave us after second EOF when doing
1002 * MTEOM, so we must backup so that appending overwrites
1005 if (has_cap(CAP_BSFATEOM)) {
1006 /* Backup over EOF */
1008 /* If BSF worked and fileno is known (not -1), set file */
1009 os_file = get_os_tape_file();
1011 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , os_file);
1014 file++; /* wing it -- not correct on all OSes */
1017 update_pos(dcr); /* update position */
1019 Dmsg1(200, "EOD dev->file=%d\n", file);
1024 * Set the position of the device -- only for files and DVD
1025 * For other devices, there is no generic way to do it.
1026 * Returns: true on succes
1029 bool DEVICE::update_pos(DCR *dcr)
1036 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
1037 Emsg1(M_FATAL, 0, "%s", errmsg);
1041 /* Find out where we are */
1042 if (is_file() || is_dvd()) {
1045 pos = lseek(dcr, (boffset_t)0, SEEK_CUR);
1049 Pmsg1(000, _("Seek error: ERR=%s\n"), be.bstrerror());
1050 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1051 print_name(), be.bstrerror());
1055 block_num = (uint32_t)pos;
1056 file = (uint32_t)(pos >> 32);
1063 * Return the status of the device. This was meant
1064 * to be a generic routine. Unfortunately, it doesn't
1065 * seem possible (at least I do not know how to do it
1066 * currently), which means that for the moment, this
1067 * routine has very little value.
1071 uint32_t status_dev(DEVICE *dev)
1073 struct mtget mt_stat;
1076 if (dev->state & (ST_EOT | ST_WEOT)) {
1080 if (dev->state & ST_EOF) {
1084 if (dev->is_tape()) {
1086 Pmsg0(-20,_(" Bacula status:"));
1087 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1088 if (dev->d_ioctl(dev->fd(), MTIOCGET, (char *)&mt_stat) < 0) {
1090 dev->dev_errno = errno;
1091 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1092 dev->print_name(), be.bstrerror());
1095 Pmsg0(-20, _(" Device status:"));
1097 #if defined(HAVE_LINUX_OS)
1098 if (GMT_EOF(mt_stat.mt_gstat)) {
1102 if (GMT_BOT(mt_stat.mt_gstat)) {
1106 if (GMT_EOT(mt_stat.mt_gstat)) {
1110 if (GMT_SM(mt_stat.mt_gstat)) {
1114 if (GMT_EOD(mt_stat.mt_gstat)) {
1118 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1119 stat |= BMT_WR_PROT;
1120 Pmsg0(-20, " WR_PROT");
1122 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1124 Pmsg0(-20, " ONLINE");
1126 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1127 stat |= BMT_DR_OPEN;
1128 Pmsg0(-20, " DR_OPEN");
1130 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1131 stat |= BMT_IM_REP_EN;
1132 Pmsg0(-20, " IM_REP_EN");
1134 #elif defined(HAVE_WIN32)
1135 if (GMT_EOF(mt_stat.mt_gstat)) {
1139 if (GMT_BOT(mt_stat.mt_gstat)) {
1143 if (GMT_EOT(mt_stat.mt_gstat)) {
1147 if (GMT_EOD(mt_stat.mt_gstat)) {
1151 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1152 stat |= BMT_WR_PROT;
1153 Pmsg0(-20, " WR_PROT");
1155 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1157 Pmsg0(-20, " ONLINE");
1159 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1160 stat |= BMT_DR_OPEN;
1161 Pmsg0(-20, " DR_OPEN");
1163 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1164 stat |= BMT_IM_REP_EN;
1165 Pmsg0(-20, " IM_REP_EN");
1168 #endif /* !SunOS && !OSF */
1169 if (dev->has_cap(CAP_MTIOCGET)) {
1170 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1172 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1175 stat |= BMT_ONLINE | BMT_BOT;
1182 * Load medium in device
1183 * Returns: true on success
1186 bool load_dev(DEVICE *dev)
1192 if (dev->fd() < 0) {
1193 dev->dev_errno = EBADF;
1194 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1195 Emsg0(M_FATAL, 0, dev->errmsg);
1198 if (!(dev->is_tape())) {
1202 Dmsg0(200, "stored: MTLOAD command not available\n");
1204 dev->dev_errno = ENOTTY; /* function not available */
1205 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1206 dev->print_name(), be.bstrerror());
1210 dev->block_num = dev->file = 0;
1213 mt_com.mt_op = MTLOAD;
1214 mt_com.mt_count = 1;
1215 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
1217 dev->dev_errno = errno;
1218 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1219 dev->print_name(), be.bstrerror());
1227 * Rewind device and put it offline
1228 * Returns: true on success
1231 bool DEVICE::offline()
1236 return true; /* device not open */
1239 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1240 block_num = file = 0;
1244 mt_com.mt_op = MTOFFL;
1245 mt_com.mt_count = 1;
1246 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
1249 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1250 print_name(), be.bstrerror());
1253 Dmsg1(100, "Offlined device %s\n", print_name());
1257 bool DEVICE::offline_or_rewind()
1262 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1266 * Note, this rewind probably should not be here (it wasn't
1267 * in prior versions of Bacula), but on FreeBSD, this is
1268 * needed in the case the tape was "frozen" due to an error
1269 * such as backspacing after writing and EOF. If it is not
1270 * done, all future references to the drive get and I/O error.
1273 return rewind(NULL);
1278 * Foward space a file
1279 * Returns: true on success
1282 bool DEVICE::fsf(int num)
1284 int32_t os_file = 0;
1290 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1291 Emsg0(M_FATAL, 0, errmsg);
1301 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1305 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1308 Dmsg0(100, "fsf\n");
1311 * If Fast forward space file is set, then we
1312 * use MTFSF to forward space and MTIOCGET
1313 * to get the file position. We assume that
1314 * the SCSI driver will ensure that we do not
1315 * forward space past the end of the medium.
1317 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1319 mt_com.mt_op = MTFSF;
1320 mt_com.mt_count = num;
1321 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1323 my_errno = errno; /* save errno */
1324 } else if ((os_file=get_os_tape_file()) < 0) {
1325 my_errno = errno; /* save errno */
1327 if (my_errno != 0) {
1330 Dmsg0(200, "Set ST_EOT\n");
1332 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1333 print_name(), be.bstrerror(my_errno));
1334 Dmsg1(200, "%s", errmsg);
1338 Dmsg1(200, "fsf file=%d\n", os_file);
1344 * Here if CAP_FSF is set, and virtually all drives
1345 * these days support it, we read a record, then forward
1346 * space one file. Using this procedure, which is slow,
1347 * is the only way we can be sure that we don't read
1348 * two consecutive EOF marks, which means End of Data.
1350 } else if (has_cap(CAP_FSF)) {
1353 Dmsg0(200, "FSF has cap_fsf\n");
1354 if (max_block_size == 0) {
1355 rbuf_len = DEFAULT_BLOCK_SIZE;
1357 rbuf_len = max_block_size;
1359 rbuf = get_memory(rbuf_len);
1360 mt_com.mt_op = MTFSF;
1361 mt_com.mt_count = 1;
1362 while (num-- && !at_eot()) {
1363 Dmsg0(100, "Doing read before fsf\n");
1364 if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1365 if (errno == ENOMEM) { /* tape record exceeds buf len */
1366 stat = rbuf_len; /* This is OK */
1368 * On IBM drives, they return ENOSPC at EOM
1369 * instead of EOF status
1371 } else if (at_eof() && errno == ENOSPC) {
1377 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1379 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1380 print_name(), be.bstrerror());
1381 Dmsg1(100, "%s", errmsg);
1385 if (stat == 0) { /* EOF */
1386 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1387 /* Two reads of zero means end of tape */
1390 Dmsg0(100, "Set ST_EOT\n");
1396 } else { /* Got data */
1401 Dmsg0(100, "Doing MTFSF\n");
1402 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1403 if (stat < 0) { /* error => EOT */
1406 Dmsg0(100, "Set ST_EOT\n");
1408 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1409 print_name(), be.bstrerror());
1410 Dmsg0(100, "Got < 0 for MTFSF\n");
1411 Dmsg1(100, "%s", errmsg);
1419 * No FSF, so use FSR to simulate it
1422 Dmsg0(200, "Doing FSR for FSF\n");
1423 while (num-- && !at_eot()) {
1424 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1428 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1434 Dmsg1(200, "Return %d from FSF\n", stat);
1436 Dmsg0(200, "ST_EOF set on exit FSF\n");
1439 Dmsg0(200, "ST_EOT set on exit FSF\n");
1441 Dmsg1(200, "Return from FSF file=%d\n", file);
1446 * Backward space a file
1447 * Returns: false on failure
1450 bool DEVICE::bsf(int num)
1457 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1458 Emsg0(M_FATAL, 0, errmsg);
1463 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1468 Dmsg0(100, "bsf\n");
1474 mt_com.mt_op = MTBSF;
1475 mt_com.mt_count = num;
1476 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1480 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1481 print_name(), be.bstrerror());
1488 * Foward space num records
1489 * Returns: false on failure
1492 bool DEVICE::fsr(int num)
1499 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1500 Emsg0(M_FATAL, 0, errmsg);
1508 if (!has_cap(CAP_FSR)) {
1509 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1513 Dmsg1(100, "fsr %d\n", num);
1514 mt_com.mt_op = MTFSR;
1515 mt_com.mt_count = num;
1516 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1522 struct mtget mt_stat;
1524 Dmsg1(100, "FSF fail: ERR=%s\n", be.bstrerror());
1525 if (dev_get_os_pos(this, &mt_stat)) {
1526 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1527 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1528 file = mt_stat.mt_fileno;
1529 block_num = mt_stat.mt_blkno;
1537 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1538 num, print_name(), be.bstrerror());
1544 * Backward space a record
1545 * Returns: false on failure
1548 bool DEVICE::bsr(int num)
1555 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1556 Emsg0(M_FATAL, 0, errmsg);
1564 if (!has_cap(CAP_BSR)) {
1565 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1569 Dmsg0(100, "bsr_dev\n");
1573 mt_com.mt_op = MTBSR;
1574 mt_com.mt_count = num;
1575 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1579 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1580 print_name(), be.bstrerror());
1585 void DEVICE::lock_door()
1589 mt_com.mt_op = MTLOCK;
1590 mt_com.mt_count = 1;
1591 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1595 void DEVICE::unlock_door()
1599 mt_com.mt_op = MTUNLOCK;
1600 mt_com.mt_count = 1;
1601 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1605 void DEVICE::set_slot(int32_t slot)
1608 if (vol) vol->clear_slot();
1611 void DEVICE::clear_slot()
1614 if (vol) vol->set_slot(-1);
1620 * Reposition the device to file, block
1621 * Returns: false on failure
1624 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1628 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1629 Emsg0(M_FATAL, 0, errmsg);
1634 boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1635 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1636 if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1639 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1640 print_name(), be.bstrerror());
1649 /* After this point, we are tape only */
1650 Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1652 Dmsg0(100, "Rewind\n");
1653 if (!rewind(NULL)) {
1658 Dmsg1(100, "fsf %d\n", rfile-file);
1659 if (!fsf(rfile-file)) {
1660 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1663 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1665 if (rblock < block_num) {
1666 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1667 Dmsg0(100, "bsf 1\n");
1669 Dmsg0(100, "fsf 1\n");
1671 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1673 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1674 /* Ignore errors as Bacula can read to the correct block */
1675 Dmsg1(100, "fsr %d\n", rblock-block_num);
1676 return fsr(rblock-block_num);
1678 while (rblock > block_num) {
1679 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1682 Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1683 print_name(), be.bstrerror());
1686 Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1695 * Write an end of file on the device
1696 * Returns: true on success
1699 bool DEVICE::weof(int num)
1703 Dmsg1(129, "=== weof_dev=%s\n", print_name());
1707 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1708 Emsg0(M_FATAL, 0, errmsg);
1716 if (!can_append()) {
1717 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1718 Emsg0(M_FATAL, 0, errmsg);
1724 mt_com.mt_op = MTWEOF;
1725 mt_com.mt_count = num;
1726 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1735 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1736 print_name(), be.bstrerror());
1744 * If implemented in system, clear the tape
1747 void DEVICE::clrerror(int func)
1749 const char *msg = NULL;
1752 dev_errno = errno; /* save errno */
1754 VolCatInfo.VolCatErrors++;
1761 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1764 break; /* ignore message printed later */
1767 clear_cap(CAP_EOF); /* turn off feature */
1772 clear_cap(CAP_EOM); /* turn off feature */
1777 clear_cap(CAP_FSF); /* turn off feature */
1781 clear_cap(CAP_BSF); /* turn off feature */
1785 clear_cap(CAP_FSR); /* turn off feature */
1789 clear_cap(CAP_BSR); /* turn off feature */
1799 #ifdef MTSETDRVBUFFER
1800 case MTSETDRVBUFFER:
1801 msg = "MTSETDRVBUFFER";
1834 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1840 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1841 Emsg0(M_ERROR, 0, errmsg);
1846 * Now we try different methods of clearing the error
1847 * status on the drive so that it is not locked for
1848 * further operations.
1851 /* On some systems such as NetBSD, this clears all errors */
1854 /* Found on Solaris */
1857 d_ioctl(m_fd, MTIOCLRERR);
1858 Dmsg0(200, "Did MTIOCLRERR\n");
1862 /* Typically on FreeBSD */
1866 /* Read and clear SCSI error status */
1867 union mterrstat mt_errstat;
1868 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1869 be.bstrerror(dev_errno));
1870 d_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1874 /* Clear Subsystem Exception OSF1 */
1878 mt_com.mt_op = MTCSE;
1879 mt_com.mt_count = 1;
1880 /* Clear any error condition on the tape */
1881 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1882 Dmsg0(200, "Did MTCSE\n");
1889 * Set to unload the current volume in the drive
1891 void DEVICE::set_unload()
1893 if (!m_unload && VolHdr.VolumeName[0] != 0) {
1895 memcpy(UnloadVolName, VolHdr.VolumeName, sizeof(UnloadVolName));
1901 * Clear volume header
1903 void DEVICE::clear_volhdr()
1905 Dmsg1(100, "Clear volhdr vol=%s\n", VolHdr.VolumeName);
1906 memset(&VolHdr, 0, sizeof(VolHdr));
1913 void DEVICE::close()
1915 Dmsg1(100, "close_dev %s\n", print_name());
1916 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1921 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1923 return; /* already closed */
1936 unmount(1); /* do unmount if required */
1938 /* Clean up device packet so it can be reused */
1941 * Be careful not to clear items needed by the DVD driver
1942 * when it is closing a single part.
1944 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF|
1945 ST_MOUNTED|ST_MEDIA|ST_SHORT);
1946 label_type = B_BACULA_LABEL;
1947 file = block_num = 0;
1950 EndFile = EndBlock = 0;
1953 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1955 stop_thread_timer(tid);
1961 * This call closes the device, but it is used in DVD handling
1962 * where we close one part and then open the next part. The
1963 * difference between close_part() and close() is that close_part()
1964 * saves the state information of the device (e.g. the Volume lable,
1965 * the Volume Catalog record, ... This permits opening and closing
1966 * the Volume parts multiple times without losing track of what the
1967 * main Volume parameters are.
1969 void DEVICE::close_part(DCR * /*dcr*/)
1971 VOLUME_LABEL saveVolHdr;
1972 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1975 saveVolHdr = VolHdr; /* structure assignment */
1976 saveVolCatInfo = VolCatInfo; /* structure assignment */
1977 close(); /* close current part */
1978 VolHdr = saveVolHdr; /* structure assignment */
1979 VolCatInfo = saveVolCatInfo; /* structure assignment */
1982 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1986 return lseek_dvd(dcr, offset, whence);
1988 #if defined(HAVE_WIN32)
1989 return ::_lseeki64(m_fd, (__int64)offset, whence);
1991 return ::lseek(m_fd, offset, whence);
1998 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
2002 Dmsg1(100, "truncate %s\n", print_name());
2007 /* maybe we should rewind and write and eof ???? */
2008 return true; /* we don't really truncate tapes */
2010 return truncate_dvd(dcr);
2012 if (ftruncate(m_fd, 0) != 0) {
2014 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
2015 print_name(), be.bstrerror());
2020 * Check for a successful ftruncate() and issue a work-around for devices
2021 * (mostly cheap NAS) that don't support truncation.
2022 * Workaround supplied by Martin Schmid as a solution to bug #1011.
2025 * 3. open new file with same mode
2026 * 4. change ownership to original
2029 if (fstat(m_fd, &st) != 0) {
2031 Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"),
2032 print_name(), be.bstrerror());
2036 if (st.st_size != 0) { /* ftruncate() didn't work */
2037 POOL_MEM archive_name(PM_FNAME);
2039 pm_strcpy(archive_name, dev_name);
2040 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
2041 pm_strcat(archive_name, "/");
2043 pm_strcat(archive_name, dcr->VolumeName);
2045 Mmsg2(errmsg, _("Device %s doesn't support ftruncate(). Recreating file %s.\n"),
2046 print_name(), archive_name.c_str());
2048 /* Close file and blow it away */
2050 ::unlink(archive_name.c_str());
2052 /* Recreate the file -- of course, empty */
2053 set_mode(CREATE_READ_WRITE);
2054 if ((m_fd = ::open(archive_name.c_str(), mode, st.st_mode)) < 0) {
2057 Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), archive_name.c_str(),
2059 Dmsg1(100, "reopen failed: %s", errmsg);
2060 Emsg0(M_FATAL, 0, errmsg);
2064 /* Reset proper owner */
2065 chown(archive_name.c_str(), st.st_uid, st.st_gid);
2075 * If timeout, wait until the mount command returns 0.
2076 * If !timeout, try to mount the device only once.
2078 bool DEVICE::mount(int timeout)
2080 Dmsg0(190, "Enter mount\n");
2090 if (device->mount_command) {
2091 return do_tape_mount(1, timeout);
2096 if (requires_mount() && device->mount_command) {
2097 return do_file_mount(1, timeout);
2108 * Unmount the device
2109 * If timeout, wait until the unmount command returns 0.
2110 * If !timeout, try to unmount the device only once.
2112 bool DEVICE::unmount(int timeout)
2114 Dmsg0(100, "Enter unmount\n");
2116 if (!is_mounted()) {
2124 if (device->unmount_command) {
2125 return do_tape_mount(0, timeout);
2130 if (requires_mount() && device->unmount_command) {
2131 return do_file_mount(0, timeout);
2142 * (Un)mount the device (for tape devices)
2144 bool DEVICE::do_tape_mount(int mount, int dotimeout)
2146 POOL_MEM ocmd(PM_FNAME);
2154 icmd = device->mount_command;
2156 icmd = device->unmount_command;
2159 edit_mount_codes(ocmd, icmd);
2161 Dmsg2(100, "do_tape_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2164 /* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
2169 results = get_memory(4000);
2171 /* If busy retry each second */
2172 Dmsg1(100, "do_tape_mount run_prog=%s\n", ocmd.c_str());
2173 while ((status = run_program_full_output(ocmd.c_str(), max_open_wait/2, results)) != 0) {
2178 Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2179 (mount ? "" : "un"), status, results, be.bstrerror(status));
2180 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2181 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2184 free_pool_memory(results);
2185 Dmsg0(200, "============ mount=0\n");
2190 set_mounted(mount); /* set/clear mounted flag */
2191 free_pool_memory(results);
2192 Dmsg1(200, "============ mount=%d\n", mount);
2197 * (Un)mount the device (either a FILE or DVD device)
2199 bool DEVICE::do_file_mount(int mount, int dotimeout)
2201 POOL_MEM ocmd(PM_FNAME);
2205 struct dirent *entry, *result;
2206 int status, tries, name_max, count;
2211 icmd = device->mount_command;
2213 icmd = device->unmount_command;
2216 clear_freespace_ok();
2217 edit_mount_codes(ocmd, icmd);
2219 Dmsg2(100, "do_file_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2222 /* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
2227 results = get_memory(4000);
2229 /* If busy retry each second */
2230 Dmsg1(100, "do_file_mount run_prog=%s\n", ocmd.c_str());
2231 while ((status = run_program_full_output(ocmd.c_str(), max_open_wait/2, results)) != 0) {
2232 /* Doesn't work with internationalization (This is not a problem) */
2233 if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2236 if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2240 /* Sometimes the device cannot be mounted because it is already mounted.
2241 * Try to unmount it, then remount it */
2243 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2244 do_file_mount(0, 0);
2249 Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2250 (mount ? "" : "un"), status, results, be.bstrerror(status));
2251 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2252 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2255 * Now, just to be sure it is not mounted, try to read the filesystem.
2257 name_max = pathconf(".", _PC_NAME_MAX);
2258 if (name_max < 1024) {
2262 if (!(dp = opendir(device->mount_point))) {
2265 Dmsg3(100, "do_file_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2266 device->mount_point, print_name(), be.bstrerror());
2270 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2273 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2275 Dmsg2(129, "do_file_mount: failed to find suitable file in dir %s (dev=%s)\n",
2276 device->mount_point, print_name());
2279 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2280 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2283 Dmsg2(129, "do_file_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2289 Dmsg1(100, "do_file_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2292 /* If we got more than ., .. and .keep */
2293 /* there must be something mounted */
2295 Dmsg1(100, "Did Mount by count=%d\n", count);
2298 /* An unmount request. We failed to unmount - report an error */
2300 free_pool_memory(results);
2301 Dmsg0(200, "== error mount=1 wanted unmount\n");
2307 free_pool_memory(results);
2308 Dmsg0(200, "============ mount=0\n");
2313 set_mounted(mount); /* set/clear mounted flag */
2314 free_pool_memory(results);
2315 /* Do not check free space when unmounting */
2316 if (mount && !update_freespace()) {
2319 Dmsg1(200, "============ mount=%d\n", mount);
2324 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2326 * %a = archive device name
2327 * %e = erase (set if cannot mount and first part)
2330 * %v = last part name
2332 * omsg = edited output message
2333 * imsg = input string containing edit codes (%x)
2336 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2342 POOL_MEM archive_name(PM_FNAME);
2344 omsg.c_str()[0] = 0;
2345 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2346 for (p=imsg; *p; p++) {
2356 if (num_dvd_parts == 0) {
2357 if (truncating || blank_dvd) {
2367 bsnprintf(add, sizeof(add), "%d", part);
2371 str = device->mount_point;
2374 make_spooled_dvd_filename(this, archive_name);
2375 str = archive_name.c_str();
2389 Dmsg1(1900, "add_str %s\n", str);
2390 pm_strcat(omsg, (char *)str);
2391 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2395 /* return the last timer interval (ms)
2396 * or 0 if something goes wrong
2398 btime_t DEVICE::get_timer_count()
2400 btime_t temp = last_timer;
2401 last_timer = get_current_btime();
2402 temp = last_timer - temp; /* get elapsed time */
2403 return (temp>0)?temp:0; /* take care of skewed clock */
2407 ssize_t DEVICE::read(void *buf, size_t len)
2413 read_len = d_read(m_fd, buf, len);
2415 last_tick = get_timer_count();
2417 DevReadTime += last_tick;
2418 VolCatInfo.VolReadTime += last_tick;
2420 if (read_len > 0) { /* skip error */
2421 DevReadBytes += read_len;
2428 ssize_t DEVICE::write(const void *buf, size_t len)
2434 write_len = d_write(m_fd, buf, len);
2436 last_tick = get_timer_count();
2438 DevWriteTime += last_tick;
2439 VolCatInfo.VolWriteTime += last_tick;
2441 if (write_len > 0) { /* skip error */
2442 DevWriteBytes += write_len;
2448 /* Return the resource name for the device */
2449 const char *DEVICE::name() const
2451 return device->hdr.name;
2454 /* Returns file position on tape or -1 */
2455 int32_t DEVICE::get_os_tape_file()
2457 struct mtget mt_stat;
2459 if (has_cap(CAP_MTIOCGET) &&
2460 d_ioctl(m_fd, MTIOCGET, (char *)&mt_stat) == 0) {
2461 return mt_stat.mt_fileno;
2467 dev_vol_name(DEVICE *dev)
2469 return dev->VolCatInfo.VolCatName;
2474 * Free memory allocated for the device
2476 void DEVICE::term(void)
2478 Dmsg1(900, "term dev: %s\n", print_name());
2481 free_memory(dev_name);
2485 free_memory(prt_name);
2489 free_pool_memory(errmsg);
2492 pthread_mutex_destroy(&m_mutex);
2493 pthread_cond_destroy(&wait);
2494 pthread_cond_destroy(&wait_next_vol);
2495 pthread_mutex_destroy(&spool_mutex);
2496 // rwl_destroy(&lock);
2497 if (attached_dcrs) {
2498 delete attached_dcrs;
2499 attached_dcrs = NULL;
2508 * This routine initializes the device wait timers
2510 void init_device_wait_timers(DCR *dcr)
2512 DEVICE *dev = dcr->dev;
2513 JCR *jcr = dcr->jcr;
2515 /* ******FIXME******* put these on config variables */
2516 dev->min_wait = 60 * 60;
2517 dev->max_wait = 24 * 60 * 60;
2518 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2519 dev->wait_sec = dev->min_wait;
2520 dev->rem_wait_sec = dev->wait_sec;
2524 jcr->min_wait = 60 * 60;
2525 jcr->max_wait = 24 * 60 * 60;
2526 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2527 jcr->wait_sec = jcr->min_wait;
2528 jcr->rem_wait_sec = jcr->wait_sec;
2533 void init_jcr_device_wait_timers(JCR *jcr)
2535 /* ******FIXME******* put these on config variables */
2536 jcr->min_wait = 60 * 60;
2537 jcr->max_wait = 24 * 60 * 60;
2538 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2539 jcr->wait_sec = jcr->min_wait;
2540 jcr->rem_wait_sec = jcr->wait_sec;
2546 * The dev timers are used for waiting on a particular device
2548 * Returns: true if time doubled
2549 * false if max time expired
2551 bool double_dev_wait_time(DEVICE *dev)
2553 dev->wait_sec *= 2; /* double wait time */
2554 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2555 dev->wait_sec = dev->max_wait;
2558 dev->rem_wait_sec = dev->wait_sec;
2559 if (dev->num_wait >= dev->max_num_wait) {
2566 void set_os_device_parameters(DCR *dcr)
2568 DEVICE *dev = dcr->dev;
2570 if (strcmp(dev->dev_name, "/dev/null") == 0) {
2571 return; /* no use trying to set /dev/null */
2574 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2577 Dmsg0(100, "In set_os_device_parameters\n");
2578 #if defined(MTSETBLK)
2579 if (dev->min_block_size == dev->max_block_size &&
2580 dev->min_block_size == 0) { /* variable block mode */
2581 mt_com.mt_op = MTSETBLK;
2582 mt_com.mt_count = 0;
2583 Dmsg0(100, "Set block size to zero\n");
2584 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2585 dev->clrerror(MTSETBLK);
2589 #if defined(MTSETDRVBUFFER)
2590 if (getuid() == 0) { /* Only root can do this */
2591 mt_com.mt_op = MTSETDRVBUFFER;
2592 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2593 if (!dev->has_cap(CAP_TWOEOF)) {
2594 mt_com.mt_count |= MT_ST_TWO_FM;
2596 if (dev->has_cap(CAP_EOM)) {
2597 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2599 Dmsg0(100, "MTSETDRVBUFFER\n");
2600 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2601 dev->clrerror(MTSETDRVBUFFER);
2608 #ifdef HAVE_NETBSD_OS
2610 if (dev->min_block_size == dev->max_block_size &&
2611 dev->min_block_size == 0) { /* variable block mode */
2612 mt_com.mt_op = MTSETBSIZ;
2613 mt_com.mt_count = 0;
2614 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2615 dev->clrerror(MTSETBSIZ);
2617 /* Get notified at logical end of tape */
2618 mt_com.mt_op = MTEWARN;
2619 mt_com.mt_count = 1;
2620 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2621 dev->clrerror(MTEWARN);
2627 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2629 if (dev->min_block_size == dev->max_block_size &&
2630 dev->min_block_size == 0) { /* variable block mode */
2631 mt_com.mt_op = MTSETBSIZ;
2632 mt_com.mt_count = 0;
2633 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2634 dev->clrerror(MTSETBSIZ);
2637 #if defined(MTIOCSETEOTMODEL)
2639 if (dev->has_cap(CAP_TWOEOF)) {
2644 if (dev->d_ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2646 dev->dev_errno = errno; /* save errno */
2647 Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2648 dev->print_name(), be.bstrerror(dev->dev_errno));
2649 Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2657 if (dev->min_block_size == dev->max_block_size &&
2658 dev->min_block_size == 0) { /* variable block mode */
2659 mt_com.mt_op = MTSRSZ;
2660 mt_com.mt_count = 0;
2661 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2662 dev->clrerror(MTSRSZ);
2669 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2671 Dmsg0(100, "dev_get_os_pos\n");
2672 return dev->has_cap(CAP_MTIOCGET) &&
2673 dev->d_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2674 mt_stat->mt_fileno >= 0;
2677 static const char *modes[] = {
2678 "CREATE_READ_WRITE",
2685 static const char *mode_to_str(int mode)
2687 static char buf[100];
2688 if (mode < 1 || mode > 4) {
2689 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2692 return modes[mode-1];