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);
900 clear_eof(); /* remove EOF flag */
901 block_num = file = 0;
908 pos = lseek(dcr, (boffset_t)0, SEEK_END);
909 // Dmsg1(100, "====== Seek to %lld\n", pos);
917 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
918 print_name(), be.bstrerror());
922 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
923 Dmsg0(100,"Using FAST FSF for EOM\n");
924 /* If unknown position, rewind */
925 if (get_os_tape_file() < 0) {
930 mt_com.mt_op = MTFSF;
932 * ***FIXME*** fix code to handle case that INT16_MAX is
935 mt_com.mt_count = INT16_MAX; /* use big positive number */
936 if (mt_com.mt_count < 0) {
937 mt_com.mt_count = INT16_MAX; /* brain damaged system */
941 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
942 if (has_cap(CAP_EOM)) {
943 Dmsg0(100,"Using EOM for EOM\n");
944 mt_com.mt_op = MTEOM;
948 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
950 clrerror(mt_com.mt_op);
951 Dmsg1(50, "ioctl error: %s\n", be.bstrerror());
953 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
954 print_name(), be.bstrerror());
958 os_file = get_os_tape_file();
962 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
963 print_name(), be.bstrerror());
966 Dmsg1(100, "EOD file=%d\n", os_file);
974 * Rewind then use FSF until EOT reached
980 * Move file by file to the end of the tape
983 for (file_num=file; !at_eot(); file_num++) {
984 Dmsg0(200, "eod: doing fsf 1\n");
986 Dmsg0(200, "fsf error.\n");
990 * Avoid infinite loop by ensuring we advance.
992 if (!at_eot() && file_num == (int)file) {
993 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
995 os_file = get_os_tape_file();
997 Dmsg2(100, "Adjust file from %d to %d\n", file_num, os_file);
1005 * Some drivers leave us after second EOF when doing
1006 * MTEOM, so we must backup so that appending overwrites
1009 if (has_cap(CAP_BSFATEOM)) {
1010 /* Backup over EOF */
1012 /* If BSF worked and fileno is known (not -1), set file */
1013 os_file = get_os_tape_file();
1015 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , os_file);
1018 file++; /* wing it -- not correct on all OSes */
1021 update_pos(dcr); /* update position */
1023 Dmsg1(200, "EOD dev->file=%d\n", file);
1028 * Set the position of the device -- only for files and DVD
1029 * For other devices, there is no generic way to do it.
1030 * Returns: true on succes
1033 bool DEVICE::update_pos(DCR *dcr)
1040 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
1041 Emsg1(M_FATAL, 0, "%s", errmsg);
1045 /* Find out where we are */
1046 if (is_file() || is_dvd()) {
1049 pos = lseek(dcr, (boffset_t)0, SEEK_CUR);
1053 Pmsg1(000, _("Seek error: ERR=%s\n"), be.bstrerror());
1054 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1055 print_name(), be.bstrerror());
1059 block_num = (uint32_t)pos;
1060 file = (uint32_t)(pos >> 32);
1067 * Return the status of the device. This was meant
1068 * to be a generic routine. Unfortunately, it doesn't
1069 * seem possible (at least I do not know how to do it
1070 * currently), which means that for the moment, this
1071 * routine has very little value.
1075 uint32_t status_dev(DEVICE *dev)
1077 struct mtget mt_stat;
1080 if (dev->state & (ST_EOT | ST_WEOT)) {
1084 if (dev->state & ST_EOF) {
1088 if (dev->is_tape()) {
1090 Pmsg0(-20,_(" Bacula status:"));
1091 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1092 if (dev->d_ioctl(dev->fd(), MTIOCGET, (char *)&mt_stat) < 0) {
1094 dev->dev_errno = errno;
1095 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1096 dev->print_name(), be.bstrerror());
1099 Pmsg0(-20, _(" Device status:"));
1101 #if defined(HAVE_LINUX_OS)
1102 if (GMT_EOF(mt_stat.mt_gstat)) {
1106 if (GMT_BOT(mt_stat.mt_gstat)) {
1110 if (GMT_EOT(mt_stat.mt_gstat)) {
1114 if (GMT_SM(mt_stat.mt_gstat)) {
1118 if (GMT_EOD(mt_stat.mt_gstat)) {
1122 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1123 stat |= BMT_WR_PROT;
1124 Pmsg0(-20, " WR_PROT");
1126 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1128 Pmsg0(-20, " ONLINE");
1130 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1131 stat |= BMT_DR_OPEN;
1132 Pmsg0(-20, " DR_OPEN");
1134 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1135 stat |= BMT_IM_REP_EN;
1136 Pmsg0(-20, " IM_REP_EN");
1138 #elif defined(HAVE_WIN32)
1139 if (GMT_EOF(mt_stat.mt_gstat)) {
1143 if (GMT_BOT(mt_stat.mt_gstat)) {
1147 if (GMT_EOT(mt_stat.mt_gstat)) {
1151 if (GMT_EOD(mt_stat.mt_gstat)) {
1155 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1156 stat |= BMT_WR_PROT;
1157 Pmsg0(-20, " WR_PROT");
1159 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1161 Pmsg0(-20, " ONLINE");
1163 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1164 stat |= BMT_DR_OPEN;
1165 Pmsg0(-20, " DR_OPEN");
1167 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1168 stat |= BMT_IM_REP_EN;
1169 Pmsg0(-20, " IM_REP_EN");
1172 #endif /* !SunOS && !OSF */
1173 if (dev->has_cap(CAP_MTIOCGET)) {
1174 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1176 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1179 stat |= BMT_ONLINE | BMT_BOT;
1186 * Load medium in device
1187 * Returns: true on success
1190 bool load_dev(DEVICE *dev)
1196 if (dev->fd() < 0) {
1197 dev->dev_errno = EBADF;
1198 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1199 Emsg0(M_FATAL, 0, dev->errmsg);
1202 if (!(dev->is_tape())) {
1206 Dmsg0(200, "stored: MTLOAD command not available\n");
1208 dev->dev_errno = ENOTTY; /* function not available */
1209 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1210 dev->print_name(), be.bstrerror());
1214 dev->block_num = dev->file = 0;
1217 mt_com.mt_op = MTLOAD;
1218 mt_com.mt_count = 1;
1219 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
1221 dev->dev_errno = errno;
1222 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1223 dev->print_name(), be.bstrerror());
1231 * Rewind device and put it offline
1232 * Returns: true on success
1235 bool DEVICE::offline()
1240 return true; /* device not open */
1243 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1244 block_num = file = 0;
1248 mt_com.mt_op = MTOFFL;
1249 mt_com.mt_count = 1;
1250 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
1253 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1254 print_name(), be.bstrerror());
1257 Dmsg1(100, "Offlined device %s\n", print_name());
1261 bool DEVICE::offline_or_rewind()
1266 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1270 * Note, this rewind probably should not be here (it wasn't
1271 * in prior versions of Bacula), but on FreeBSD, this is
1272 * needed in the case the tape was "frozen" due to an error
1273 * such as backspacing after writing and EOF. If it is not
1274 * done, all future references to the drive get and I/O error.
1277 return rewind(NULL);
1282 * Foward space a file
1283 * Returns: true on success
1286 bool DEVICE::fsf(int num)
1288 int32_t os_file = 0;
1294 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1295 Emsg0(M_FATAL, 0, errmsg);
1305 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1309 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1312 Dmsg0(100, "fsf\n");
1315 * If Fast forward space file is set, then we
1316 * use MTFSF to forward space and MTIOCGET
1317 * to get the file position. We assume that
1318 * the SCSI driver will ensure that we do not
1319 * forward space past the end of the medium.
1321 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1323 mt_com.mt_op = MTFSF;
1324 mt_com.mt_count = num;
1325 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1327 my_errno = errno; /* save errno */
1328 } else if ((os_file=get_os_tape_file()) < 0) {
1329 my_errno = errno; /* save errno */
1331 if (my_errno != 0) {
1334 Dmsg0(200, "Set ST_EOT\n");
1336 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1337 print_name(), be.bstrerror(my_errno));
1338 Dmsg1(200, "%s", errmsg);
1342 Dmsg1(200, "fsf file=%d\n", os_file);
1348 * Here if CAP_FSF is set, and virtually all drives
1349 * these days support it, we read a record, then forward
1350 * space one file. Using this procedure, which is slow,
1351 * is the only way we can be sure that we don't read
1352 * two consecutive EOF marks, which means End of Data.
1354 } else if (has_cap(CAP_FSF)) {
1357 Dmsg0(200, "FSF has cap_fsf\n");
1358 if (max_block_size == 0) {
1359 rbuf_len = DEFAULT_BLOCK_SIZE;
1361 rbuf_len = max_block_size;
1363 rbuf = get_memory(rbuf_len);
1364 mt_com.mt_op = MTFSF;
1365 mt_com.mt_count = 1;
1366 while (num-- && !at_eot()) {
1367 Dmsg0(100, "Doing read before fsf\n");
1368 if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1369 if (errno == ENOMEM) { /* tape record exceeds buf len */
1370 stat = rbuf_len; /* This is OK */
1372 * On IBM drives, they return ENOSPC at EOM
1373 * instead of EOF status
1375 } else if (at_eof() && errno == ENOSPC) {
1381 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1383 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1384 print_name(), be.bstrerror());
1385 Dmsg1(100, "%s", errmsg);
1389 if (stat == 0) { /* EOF */
1390 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1391 /* Two reads of zero means end of tape */
1394 Dmsg0(100, "Set ST_EOT\n");
1400 } else { /* Got data */
1405 Dmsg0(100, "Doing MTFSF\n");
1406 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1407 if (stat < 0) { /* error => EOT */
1410 Dmsg0(100, "Set ST_EOT\n");
1412 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1413 print_name(), be.bstrerror());
1414 Dmsg0(100, "Got < 0 for MTFSF\n");
1415 Dmsg1(100, "%s", errmsg);
1423 * No FSF, so use FSR to simulate it
1426 Dmsg0(200, "Doing FSR for FSF\n");
1427 while (num-- && !at_eot()) {
1428 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1432 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1438 Dmsg1(200, "Return %d from FSF\n", stat);
1440 Dmsg0(200, "ST_EOF set on exit FSF\n");
1443 Dmsg0(200, "ST_EOT set on exit FSF\n");
1445 Dmsg1(200, "Return from FSF file=%d\n", file);
1450 * Backward space a file
1451 * Returns: false on failure
1454 bool DEVICE::bsf(int num)
1461 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1462 Emsg0(M_FATAL, 0, errmsg);
1467 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1472 Dmsg0(100, "bsf\n");
1478 mt_com.mt_op = MTBSF;
1479 mt_com.mt_count = num;
1480 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1484 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1485 print_name(), be.bstrerror());
1492 * Foward space num records
1493 * Returns: false on failure
1496 bool DEVICE::fsr(int num)
1503 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1504 Emsg0(M_FATAL, 0, errmsg);
1512 if (!has_cap(CAP_FSR)) {
1513 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1517 Dmsg1(100, "fsr %d\n", num);
1518 mt_com.mt_op = MTFSR;
1519 mt_com.mt_count = num;
1520 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1526 struct mtget mt_stat;
1528 Dmsg1(100, "FSF fail: ERR=%s\n", be.bstrerror());
1529 if (dev_get_os_pos(this, &mt_stat)) {
1530 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1531 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1532 file = mt_stat.mt_fileno;
1533 block_num = mt_stat.mt_blkno;
1541 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1542 num, print_name(), be.bstrerror());
1548 * Backward space a record
1549 * Returns: false on failure
1552 bool DEVICE::bsr(int num)
1559 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1560 Emsg0(M_FATAL, 0, errmsg);
1568 if (!has_cap(CAP_BSR)) {
1569 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1573 Dmsg0(100, "bsr_dev\n");
1577 mt_com.mt_op = MTBSR;
1578 mt_com.mt_count = num;
1579 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1583 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1584 print_name(), be.bstrerror());
1589 void DEVICE::lock_door()
1593 mt_com.mt_op = MTLOCK;
1594 mt_com.mt_count = 1;
1595 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1599 void DEVICE::unlock_door()
1603 mt_com.mt_op = MTUNLOCK;
1604 mt_com.mt_count = 1;
1605 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1609 void DEVICE::set_slot(int32_t slot)
1612 if (vol) vol->clear_slot();
1615 void DEVICE::clear_slot()
1618 if (vol) vol->set_slot(-1);
1624 * Reposition the device to file, block
1625 * Returns: false on failure
1628 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1632 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1633 Emsg0(M_FATAL, 0, errmsg);
1638 boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1639 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1640 if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1643 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1644 print_name(), be.bstrerror());
1653 /* After this point, we are tape only */
1654 Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1656 Dmsg0(100, "Rewind\n");
1657 if (!rewind(NULL)) {
1662 Dmsg1(100, "fsf %d\n", rfile-file);
1663 if (!fsf(rfile-file)) {
1664 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1667 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1669 if (rblock < block_num) {
1670 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1671 Dmsg0(100, "bsf 1\n");
1673 Dmsg0(100, "fsf 1\n");
1675 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1677 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1678 /* Ignore errors as Bacula can read to the correct block */
1679 Dmsg1(100, "fsr %d\n", rblock-block_num);
1680 return fsr(rblock-block_num);
1682 while (rblock > block_num) {
1683 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1686 Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1687 print_name(), be.bstrerror());
1690 Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1699 * Write an end of file on the device
1700 * Returns: true on success
1703 bool DEVICE::weof(int num)
1707 Dmsg1(129, "=== weof_dev=%s\n", print_name());
1711 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1712 Emsg0(M_FATAL, 0, errmsg);
1720 if (!can_append()) {
1721 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1722 Emsg0(M_FATAL, 0, errmsg);
1728 mt_com.mt_op = MTWEOF;
1729 mt_com.mt_count = num;
1730 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1739 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1740 print_name(), be.bstrerror());
1748 * If implemented in system, clear the tape
1751 void DEVICE::clrerror(int func)
1753 const char *msg = NULL;
1756 dev_errno = errno; /* save errno */
1758 VolCatInfo.VolCatErrors++;
1765 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1768 break; /* ignore message printed later */
1771 clear_cap(CAP_EOF); /* turn off feature */
1776 clear_cap(CAP_EOM); /* turn off feature */
1781 clear_cap(CAP_FSF); /* turn off feature */
1785 clear_cap(CAP_BSF); /* turn off feature */
1789 clear_cap(CAP_FSR); /* turn off feature */
1793 clear_cap(CAP_BSR); /* turn off feature */
1803 #ifdef MTSETDRVBUFFER
1804 case MTSETDRVBUFFER:
1805 msg = "MTSETDRVBUFFER";
1838 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1844 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1845 Emsg0(M_ERROR, 0, errmsg);
1850 * Now we try different methods of clearing the error
1851 * status on the drive so that it is not locked for
1852 * further operations.
1855 /* On some systems such as NetBSD, this clears all errors */
1858 /* Found on Solaris */
1861 d_ioctl(m_fd, MTIOCLRERR);
1862 Dmsg0(200, "Did MTIOCLRERR\n");
1866 /* Typically on FreeBSD */
1870 /* Read and clear SCSI error status */
1871 union mterrstat mt_errstat;
1872 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1873 be.bstrerror(dev_errno));
1874 d_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1878 /* Clear Subsystem Exception OSF1 */
1882 mt_com.mt_op = MTCSE;
1883 mt_com.mt_count = 1;
1884 /* Clear any error condition on the tape */
1885 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1886 Dmsg0(200, "Did MTCSE\n");
1893 * Set to unload the current volume in the drive
1895 void DEVICE::set_unload()
1897 if (!m_unload && VolHdr.VolumeName[0] != 0) {
1899 memcpy(UnloadVolName, VolHdr.VolumeName, sizeof(UnloadVolName));
1905 * Clear volume header
1907 void DEVICE::clear_volhdr()
1909 Dmsg1(100, "Clear volhdr vol=%s\n", VolHdr.VolumeName);
1910 memset(&VolHdr, 0, sizeof(VolHdr));
1917 void DEVICE::close()
1919 Dmsg1(100, "close_dev %s\n", print_name());
1920 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1925 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1927 return; /* already closed */
1940 unmount(1); /* do unmount if required */
1942 /* Clean up device packet so it can be reused */
1945 * Be careful not to clear items needed by the DVD driver
1946 * when it is closing a single part.
1948 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF|
1949 ST_MOUNTED|ST_MEDIA|ST_SHORT);
1950 label_type = B_BACULA_LABEL;
1951 file = block_num = 0;
1954 EndFile = EndBlock = 0;
1957 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1959 stop_thread_timer(tid);
1965 * This call closes the device, but it is used in DVD handling
1966 * where we close one part and then open the next part. The
1967 * difference between close_part() and close() is that close_part()
1968 * saves the state information of the device (e.g. the Volume lable,
1969 * the Volume Catalog record, ... This permits opening and closing
1970 * the Volume parts multiple times without losing track of what the
1971 * main Volume parameters are.
1973 void DEVICE::close_part(DCR * /*dcr*/)
1975 VOLUME_LABEL saveVolHdr;
1976 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1979 saveVolHdr = VolHdr; /* structure assignment */
1980 saveVolCatInfo = VolCatInfo; /* structure assignment */
1981 close(); /* close current part */
1982 VolHdr = saveVolHdr; /* structure assignment */
1983 VolCatInfo = saveVolCatInfo; /* structure assignment */
1986 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1990 return lseek_dvd(dcr, offset, whence);
1992 #if defined(HAVE_WIN32)
1993 return ::_lseeki64(m_fd, (__int64)offset, whence);
1995 return ::lseek(m_fd, offset, whence);
2002 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
2006 Dmsg1(100, "truncate %s\n", print_name());
2011 /* maybe we should rewind and write and eof ???? */
2012 return true; /* we don't really truncate tapes */
2014 return truncate_dvd(dcr);
2016 if (ftruncate(m_fd, 0) != 0) {
2018 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
2019 print_name(), be.bstrerror());
2024 * Check for a successful ftruncate() and issue a work-around for devices
2025 * (mostly cheap NAS) that don't support truncation.
2026 * Workaround supplied by Martin Schmid as a solution to bug #1011.
2029 * 3. open new file with same mode
2030 * 4. change ownership to original
2033 if (fstat(m_fd, &st) != 0) {
2035 Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"),
2036 print_name(), be.bstrerror());
2040 if (st.st_size != 0) { /* ftruncate() didn't work */
2041 POOL_MEM archive_name(PM_FNAME);
2043 pm_strcpy(archive_name, dev_name);
2044 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
2045 pm_strcat(archive_name, "/");
2047 pm_strcat(archive_name, dcr->VolumeName);
2049 Mmsg2(errmsg, _("Device %s doesn't support ftruncate(). Recreating file %s.\n"),
2050 print_name(), archive_name.c_str());
2052 /* Close file and blow it away */
2054 ::unlink(archive_name.c_str());
2056 /* Recreate the file -- of course, empty */
2057 set_mode(CREATE_READ_WRITE);
2058 if ((m_fd = ::open(archive_name.c_str(), mode, st.st_mode)) < 0) {
2061 Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), archive_name.c_str(),
2063 Dmsg1(100, "reopen failed: %s", errmsg);
2064 Emsg0(M_FATAL, 0, errmsg);
2068 /* Reset proper owner */
2069 chown(archive_name.c_str(), st.st_uid, st.st_gid);
2079 * If timeout, wait until the mount command returns 0.
2080 * If !timeout, try to mount the device only once.
2082 bool DEVICE::mount(int timeout)
2084 Dmsg0(190, "Enter mount\n");
2094 if (device->mount_command) {
2095 return do_tape_mount(1, timeout);
2100 if (requires_mount() && device->mount_command) {
2101 return do_file_mount(1, timeout);
2112 * Unmount the device
2113 * If timeout, wait until the unmount command returns 0.
2114 * If !timeout, try to unmount the device only once.
2116 bool DEVICE::unmount(int timeout)
2118 Dmsg0(100, "Enter unmount\n");
2120 if (!is_mounted()) {
2128 if (device->unmount_command) {
2129 return do_tape_mount(0, timeout);
2134 if (requires_mount() && device->unmount_command) {
2135 return do_file_mount(0, timeout);
2146 * (Un)mount the device (for tape devices)
2148 bool DEVICE::do_tape_mount(int mount, int dotimeout)
2150 POOL_MEM ocmd(PM_FNAME);
2158 icmd = device->mount_command;
2160 icmd = device->unmount_command;
2163 edit_mount_codes(ocmd, icmd);
2165 Dmsg2(100, "do_tape_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2168 /* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
2173 results = get_memory(4000);
2175 /* If busy retry each second */
2176 Dmsg1(100, "do_tape_mount run_prog=%s\n", ocmd.c_str());
2177 while ((status = run_program_full_output(ocmd.c_str(), max_open_wait/2, results)) != 0) {
2182 Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2183 (mount ? "" : "un"), status, results, be.bstrerror(status));
2184 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2185 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2188 free_pool_memory(results);
2189 Dmsg0(200, "============ mount=0\n");
2194 set_mounted(mount); /* set/clear mounted flag */
2195 free_pool_memory(results);
2196 Dmsg1(200, "============ mount=%d\n", mount);
2201 * (Un)mount the device (either a FILE or DVD device)
2203 bool DEVICE::do_file_mount(int mount, int dotimeout)
2205 POOL_MEM ocmd(PM_FNAME);
2209 struct dirent *entry, *result;
2210 int status, tries, name_max, count;
2215 icmd = device->mount_command;
2217 icmd = device->unmount_command;
2220 clear_freespace_ok();
2221 edit_mount_codes(ocmd, icmd);
2223 Dmsg2(100, "do_file_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2226 /* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
2231 results = get_memory(4000);
2233 /* If busy retry each second */
2234 Dmsg1(100, "do_file_mount run_prog=%s\n", ocmd.c_str());
2235 while ((status = run_program_full_output(ocmd.c_str(), max_open_wait/2, results)) != 0) {
2236 /* Doesn't work with internationalization (This is not a problem) */
2237 if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2240 if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2244 /* Sometimes the device cannot be mounted because it is already mounted.
2245 * Try to unmount it, then remount it */
2247 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2248 do_file_mount(0, 0);
2253 Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2254 (mount ? "" : "un"), status, results, be.bstrerror(status));
2255 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2256 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2259 * Now, just to be sure it is not mounted, try to read the filesystem.
2261 name_max = pathconf(".", _PC_NAME_MAX);
2262 if (name_max < 1024) {
2266 if (!(dp = opendir(device->mount_point))) {
2269 Dmsg3(100, "do_file_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2270 device->mount_point, print_name(), be.bstrerror());
2274 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2277 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2279 Dmsg2(129, "do_file_mount: failed to find suitable file in dir %s (dev=%s)\n",
2280 device->mount_point, print_name());
2283 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2284 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2287 Dmsg2(129, "do_file_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2293 Dmsg1(100, "do_file_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2296 /* If we got more than ., .. and .keep */
2297 /* there must be something mounted */
2299 Dmsg1(100, "Did Mount by count=%d\n", count);
2302 /* An unmount request. We failed to unmount - report an error */
2304 free_pool_memory(results);
2305 Dmsg0(200, "== error mount=1 wanted unmount\n");
2311 free_pool_memory(results);
2312 Dmsg0(200, "============ mount=0\n");
2317 set_mounted(mount); /* set/clear mounted flag */
2318 free_pool_memory(results);
2319 /* Do not check free space when unmounting */
2320 if (mount && !update_freespace()) {
2323 Dmsg1(200, "============ mount=%d\n", mount);
2328 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2330 * %a = archive device name
2331 * %e = erase (set if cannot mount and first part)
2334 * %v = last part name
2336 * omsg = edited output message
2337 * imsg = input string containing edit codes (%x)
2340 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2346 POOL_MEM archive_name(PM_FNAME);
2348 omsg.c_str()[0] = 0;
2349 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2350 for (p=imsg; *p; p++) {
2360 if (num_dvd_parts == 0) {
2361 if (truncating || blank_dvd) {
2371 bsnprintf(add, sizeof(add), "%d", part);
2375 str = device->mount_point;
2378 make_spooled_dvd_filename(this, archive_name);
2379 str = archive_name.c_str();
2393 Dmsg1(1900, "add_str %s\n", str);
2394 pm_strcat(omsg, (char *)str);
2395 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2399 /* return the last timer interval (ms)
2400 * or 0 if something goes wrong
2402 btime_t DEVICE::get_timer_count()
2404 btime_t temp = last_timer;
2405 last_timer = get_current_btime();
2406 temp = last_timer - temp; /* get elapsed time */
2407 return (temp>0)?temp:0; /* take care of skewed clock */
2411 ssize_t DEVICE::read(void *buf, size_t len)
2417 read_len = d_read(m_fd, buf, len);
2419 last_tick = get_timer_count();
2421 DevReadTime += last_tick;
2422 VolCatInfo.VolReadTime += last_tick;
2424 if (read_len > 0) { /* skip error */
2425 DevReadBytes += read_len;
2432 ssize_t DEVICE::write(const void *buf, size_t len)
2438 write_len = d_write(m_fd, buf, len);
2440 last_tick = get_timer_count();
2442 DevWriteTime += last_tick;
2443 VolCatInfo.VolWriteTime += last_tick;
2445 if (write_len > 0) { /* skip error */
2446 DevWriteBytes += write_len;
2452 /* Return the resource name for the device */
2453 const char *DEVICE::name() const
2455 return device->hdr.name;
2458 /* Returns file position on tape or -1 */
2459 int32_t DEVICE::get_os_tape_file()
2461 struct mtget mt_stat;
2463 if (has_cap(CAP_MTIOCGET) &&
2464 d_ioctl(m_fd, MTIOCGET, (char *)&mt_stat) == 0) {
2465 return mt_stat.mt_fileno;
2471 dev_vol_name(DEVICE *dev)
2473 return dev->VolCatInfo.VolCatName;
2478 * Free memory allocated for the device
2480 void DEVICE::term(void)
2482 Dmsg1(900, "term dev: %s\n", print_name());
2485 free_memory(dev_name);
2489 free_memory(prt_name);
2493 free_pool_memory(errmsg);
2496 pthread_mutex_destroy(&m_mutex);
2497 pthread_cond_destroy(&wait);
2498 pthread_cond_destroy(&wait_next_vol);
2499 pthread_mutex_destroy(&spool_mutex);
2500 // rwl_destroy(&lock);
2501 if (attached_dcrs) {
2502 delete attached_dcrs;
2503 attached_dcrs = NULL;
2512 * This routine initializes the device wait timers
2514 void init_device_wait_timers(DCR *dcr)
2516 DEVICE *dev = dcr->dev;
2517 JCR *jcr = dcr->jcr;
2519 /* ******FIXME******* put these on config variables */
2520 dev->min_wait = 60 * 60;
2521 dev->max_wait = 24 * 60 * 60;
2522 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2523 dev->wait_sec = dev->min_wait;
2524 dev->rem_wait_sec = dev->wait_sec;
2528 jcr->min_wait = 60 * 60;
2529 jcr->max_wait = 24 * 60 * 60;
2530 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2531 jcr->wait_sec = jcr->min_wait;
2532 jcr->rem_wait_sec = jcr->wait_sec;
2537 void init_jcr_device_wait_timers(JCR *jcr)
2539 /* ******FIXME******* put these on config variables */
2540 jcr->min_wait = 60 * 60;
2541 jcr->max_wait = 24 * 60 * 60;
2542 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2543 jcr->wait_sec = jcr->min_wait;
2544 jcr->rem_wait_sec = jcr->wait_sec;
2550 * The dev timers are used for waiting on a particular device
2552 * Returns: true if time doubled
2553 * false if max time expired
2555 bool double_dev_wait_time(DEVICE *dev)
2557 dev->wait_sec *= 2; /* double wait time */
2558 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2559 dev->wait_sec = dev->max_wait;
2562 dev->rem_wait_sec = dev->wait_sec;
2563 if (dev->num_wait >= dev->max_num_wait) {
2570 void set_os_device_parameters(DCR *dcr)
2572 DEVICE *dev = dcr->dev;
2574 if (strcmp(dev->dev_name, "/dev/null") == 0) {
2575 return; /* no use trying to set /dev/null */
2578 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2581 Dmsg0(100, "In set_os_device_parameters\n");
2582 #if defined(MTSETBLK)
2583 if (dev->min_block_size == dev->max_block_size &&
2584 dev->min_block_size == 0) { /* variable block mode */
2585 mt_com.mt_op = MTSETBLK;
2586 mt_com.mt_count = 0;
2587 Dmsg0(100, "Set block size to zero\n");
2588 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2589 dev->clrerror(MTSETBLK);
2593 #if defined(MTSETDRVBUFFER)
2594 if (getuid() == 0) { /* Only root can do this */
2595 mt_com.mt_op = MTSETDRVBUFFER;
2596 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2597 if (!dev->has_cap(CAP_TWOEOF)) {
2598 mt_com.mt_count |= MT_ST_TWO_FM;
2600 if (dev->has_cap(CAP_EOM)) {
2601 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2603 Dmsg0(100, "MTSETDRVBUFFER\n");
2604 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2605 dev->clrerror(MTSETDRVBUFFER);
2612 #ifdef HAVE_NETBSD_OS
2614 if (dev->min_block_size == dev->max_block_size &&
2615 dev->min_block_size == 0) { /* variable block mode */
2616 mt_com.mt_op = MTSETBSIZ;
2617 mt_com.mt_count = 0;
2618 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2619 dev->clrerror(MTSETBSIZ);
2621 /* Get notified at logical end of tape */
2622 mt_com.mt_op = MTEWARN;
2623 mt_com.mt_count = 1;
2624 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2625 dev->clrerror(MTEWARN);
2631 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2633 if (dev->min_block_size == dev->max_block_size &&
2634 dev->min_block_size == 0) { /* variable block mode */
2635 mt_com.mt_op = MTSETBSIZ;
2636 mt_com.mt_count = 0;
2637 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2638 dev->clrerror(MTSETBSIZ);
2641 #if defined(MTIOCSETEOTMODEL)
2643 if (dev->has_cap(CAP_TWOEOF)) {
2648 if (dev->d_ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2650 dev->dev_errno = errno; /* save errno */
2651 Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2652 dev->print_name(), be.bstrerror(dev->dev_errno));
2653 Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2661 if (dev->min_block_size == dev->max_block_size &&
2662 dev->min_block_size == 0) { /* variable block mode */
2663 mt_com.mt_op = MTSRSZ;
2664 mt_com.mt_count = 0;
2665 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2666 dev->clrerror(MTSRSZ);
2673 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2675 Dmsg0(100, "dev_get_os_pos\n");
2676 return dev->has_cap(CAP_MTIOCGET) &&
2677 dev->d_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2678 mt_stat->mt_fileno >= 0;
2681 static const char *modes[] = {
2682 "CREATE_READ_WRITE",
2689 static const char *mode_to_str(int mode)
2691 static char buf[100];
2692 if (mode < 1 || mode > 4) {
2693 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2696 return modes[mode-1];