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