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());
204 if (!device->mount_command || !device->unmount_command) {
205 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
207 if (!device->write_part_command) {
208 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
213 if (dev->max_block_size == 0) {
214 max_bs = DEFAULT_BLOCK_SIZE;
216 max_bs = dev->max_block_size;
218 if (dev->min_block_size > max_bs) {
219 Jmsg(jcr, M_ERROR_TERM, 0, _("Min block size > max on device %s\n"),
222 if (dev->max_block_size > 4096000) {
223 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
224 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
225 dev->max_block_size = 0;
227 if (dev->max_block_size % TAPE_BSIZE != 0) {
228 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
229 dev->max_block_size, dev->print_name());
231 if (dev->max_volume_size != 0 && dev->max_volume_size < (dev->max_block_size << 4)) {
232 Jmsg(jcr, M_ERROR_TERM, 0, _("Max Vol Size < 8 * Max Block Size on device %s\n"),
236 dev->errmsg = get_pool_memory(PM_EMSG);
239 if ((errstat = pthread_mutex_init(&dev->m_mutex, NULL)) != 0) {
241 dev->dev_errno = errstat;
242 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
243 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
245 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
247 dev->dev_errno = errstat;
248 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
249 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
251 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
253 dev->dev_errno = errstat;
254 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
255 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
257 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
259 dev->dev_errno = errstat;
260 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
261 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
263 if ((errstat = pthread_mutex_init(&dev->acquire_mutex, NULL)) != 0) {
265 dev->dev_errno = errstat;
266 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
267 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
270 if ((errstat = rwl_init(&dev->lock)) != 0) {
272 dev->dev_errno = errstat;
273 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
274 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
279 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
280 Dmsg2(100, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
281 dev->initiated = true;
286 /* Choose the right backend */
287 void DEVICE::init_backend()
292 d_open = win32_tape_open;
293 d_write = win32_tape_write;
294 d_close = win32_tape_close;
295 d_ioctl = win32_tape_ioctl;
296 d_read = win32_tape_read;
301 d_ioctl = win32_ioctl; /* dummy function */
302 d_write = win32_write; /* win32 read/write are not POSIX */
306 #else /* POSIX / UNIX Interface */
307 if (is_vtape()) { /* test backend */
308 d_open = vtape_open; /* vtape isn't available for WIN32 or FreeBSD */
309 d_write = vtape_write;
310 d_close = vtape_close;
311 d_ioctl = vtape_ioctl;
314 } else { /* tape and file are using normal io */
325 * Open the device with the operating system and
326 * initialize buffer pointers.
328 * Returns: -1 on error
331 * Note, for a tape, the VolName is the name we give to the
332 * volume (not really used here), but for a file, the
333 * VolName represents the name of the file to be created/opened.
334 * In the case of a file, the full name is the device name
335 * (archive_name) with the VolName concatenated.
338 DEVICE::open(DCR *dcr, int omode)
342 if (openmode == omode) {
347 Dmsg0(100, "Close fd for mode change.\n");
348 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
352 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
355 Dmsg4(100, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
356 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
357 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
358 label_type = B_BACULA_LABEL;
359 if (is_tape() || is_fifo()) {
360 open_tape_device(dcr, omode);
361 } else if (is_dvd()) {
362 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
363 open_dvd_device(dcr, omode);
365 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
366 open_file_device(dcr, omode);
368 state |= preserve; /* reset any important state info */
369 Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, m_fd);
373 void DEVICE::set_mode(int new_mode)
376 case CREATE_READ_WRITE:
377 mode = O_CREAT | O_RDWR | O_BINARY;
379 case OPEN_READ_WRITE:
380 mode = O_RDWR | O_BINARY;
383 mode = O_RDONLY | O_BINARY;
385 case OPEN_WRITE_ONLY:
386 mode = O_WRONLY | O_BINARY;
389 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
395 void DEVICE::open_tape_device(DCR *dcr, int omode)
398 int timeout = max_open_wait;
399 #if !defined(HAVE_WIN32)
401 utime_t start_time = time(NULL);
405 Dmsg0(100, "Open dev: device is tape\n");
407 get_autochanger_loaded_slot(dcr);
416 if (is_fifo() && timeout) {
418 tid = start_thread_timer(dcr->jcr, pthread_self(), timeout);
420 Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
421 #if defined(HAVE_WIN32)
424 if ((m_fd = d_open(dev_name, mode)) < 0) {
431 /* If busy retry each second for max_open_wait seconds */
433 /* Try non-blocking open */
434 m_fd = d_open(dev_name, mode+O_NONBLOCK);
438 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
439 print_name(), omode, mode, errno, be.bstrerror());
441 /* Tape open, now rewind it */
442 Dmsg0(100, "Rewind after open\n");
443 mt_com.mt_op = MTREW;
445 /* rewind only if dev is a tape */
446 if (is_tape() && (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0)) {
448 dev_errno = errno; /* set error status from rewind */
451 Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
452 be.bstrerror(dev_errno));
453 /* If we get busy, device is probably rewinding, try again */
454 if (dev_errno != EBUSY) {
455 break; /* error -- no medium */
458 /* Got fd and rewind worked, so we must have medium in drive */
460 m_fd = d_open(dev_name, mode); /* open normally */
464 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
465 print_name(), omode, mode, errno, be.bstrerror());
470 set_os_device_parameters(dcr); /* do system dependent stuff */
471 break; /* Successfully opened and rewound */
475 /* Exceed wait time ? */
476 if (time(NULL) - start_time >= max_open_wait) {
477 break; /* yes, get out */
484 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
485 print_name(), be.bstrerror(dev_errno));
486 Dmsg1(100, "%s", errmsg);
489 /* Stop any open() timer we started */
491 stop_thread_timer(tid);
494 Dmsg1(100, "open dev: tape %d opened\n", m_fd);
501 void DEVICE::open_file_device(DCR *dcr, int omode)
503 POOL_MEM archive_name(PM_FNAME);
505 get_autochanger_loaded_slot(dcr);
508 * Handle opening of File Archive (not a tape)
511 pm_strcpy(archive_name, dev_name);
513 * If this is a virtual autochanger (i.e. changer_res != NULL)
514 * we simply use the device name, assuming it has been
515 * appropriately setup by the "autochanger".
517 if (!device->changer_res || device->changer_command[0] == 0) {
518 if (VolCatInfo.VolCatName[0] == 0) {
519 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
525 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
526 pm_strcat(archive_name, "/");
528 pm_strcat(archive_name, VolCatInfo.VolCatName);
531 mount(1); /* do mount if required */
535 /* If creating file, give 0640 permissions */
536 Dmsg3(100, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
537 archive_name.c_str(), mode);
538 /* Use system open() */
539 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
542 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
544 Dmsg1(100, "open failed: %s", errmsg);
545 // Jmsg1(NULL, M_WARNING, 0, "%s", errmsg);
551 Dmsg4(100, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
552 m_fd, part, num_dvd_parts, part_size);
556 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
557 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
558 * has the desired Volume name, but there is NO assurance that
559 * any other field of VolCatInfo is correct.
561 void DEVICE::open_dvd_device(DCR *dcr, int omode)
563 POOL_MEM archive_name(PM_FNAME);
564 struct stat filestat;
567 * Handle opening of DVD Volume
569 Dmsg2(100, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n",
570 &dcr->VolCatInfo, mode_to_str(omode));
573 * For a DVD we must always pull the state info from dcr->VolCatInfo
574 * This is a bit ugly, but is necessary because we need to open/close/re-open
575 * the dvd file in order to properly mount/unmount and access the
576 * DVD. So we store the state of the DVD as far as is known in the
577 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
578 * copy here, when opening.
580 VolCatInfo = dcr->VolCatInfo; /* structure assignment */
581 Dmsg1(100, "Volume=%s\n", VolCatInfo.VolCatName);
583 if (VolCatInfo.VolCatName[0] == 0) {
584 Dmsg1(10, "Could not open DVD device %s. No Volume name given.\n",
586 Mmsg(errmsg, _("Could not open DVD device %s. No Volume name given.\n"),
593 Dmsg0(100, "Set part=1\n");
594 part = 1; /* count from 1 */
598 if (num_dvd_parts != VolCatInfo.VolCatParts) {
599 num_dvd_parts = VolCatInfo.VolCatParts;
603 * If we are not trying to access the last part, set mode to
604 * OPEN_READ_ONLY as writing would be an error.
606 Dmsg2(100, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
607 /* Now find the name of the part that we want to access */
608 if (part <= num_dvd_parts) {
609 omode = OPEN_READ_ONLY;
610 make_mounted_dvd_filename(this, archive_name);
611 set_part_spooled(false);
613 omode = OPEN_READ_WRITE;
614 make_spooled_dvd_filename(this, archive_name);
615 set_part_spooled(true);
619 // Clear any previous blank_dvd status - we will recalculate it here
622 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
623 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
626 Dmsg0(99, "DVD device mounted.\n");
627 if (num_dvd_parts == 0 && !truncating) {
629 * If we can mount the device, and we are not truncating the DVD,
630 * we usually want to abort. There is one exception, if there is
631 * only one 0-sized file on the DVD, with the right volume name,
632 * we continue (it's the method used by truncate_dvd to truncate a volume).
634 if (!check_can_write_on_non_blank_dvd(dcr)) {
635 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
636 Emsg0(M_FATAL, 0, errmsg);
637 unmount(1); /* Unmount the device, so the operator can change it. */
644 * Ensure that we have the correct DVD loaded by looking for part1.
645 * We only succeed the open if it exists. Failure to do this could
646 * leave us trying to add a part to a different DVD!
648 uint32_t oldpart = part;
650 POOL_MEM part1_name(PM_FNAME);
652 make_mounted_dvd_filename(this, part1_name);
654 if (stat(part1_name.c_str(), &statp) < 0) {
656 Mmsg(errmsg, _("Unable to stat DVD part 1 file %s: ERR=%s\n"),
657 part1_name.c_str(), be.bstrerror());
658 Emsg0(M_FATAL, 0, errmsg);
662 if (!S_ISREG(statp.st_mode)) {
663 /* It is not a regular file */
664 Mmsg(errmsg, _("DVD part 1 is not a regular file %s.\n"),
666 Emsg0(M_FATAL, 0, errmsg);
672 Dmsg0(99, "DVD device mount failed.\n");
673 /* We cannot mount the device */
674 if (num_dvd_parts == 0) {
675 /* Run free space, check there is a media. */
676 if (!update_freespace()) {
677 Emsg0(M_FATAL, 0, errmsg);
682 Dmsg1(100, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
684 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
685 Emsg0(M_FATAL, 0, errmsg);
690 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
691 Emsg0(M_FATAL, 0, errmsg);
697 Dmsg5(100, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
698 archive_name.c_str(), mode_to_str(omode),
699 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
701 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
704 /* If creating file, give 0640 permissions */
705 Dmsg3(100, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
706 archive_name.c_str(), mode);
707 /* Use system open() */
708 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
710 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
712 // Should this be set if we try the create/open below
713 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
714 Dmsg1(100, "open failed: %s", errmsg);
716 /* Previous open failed. See if we can recover */
717 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
718 (part > num_dvd_parts)) {
719 /* If the last part (on spool), doesn't exist when accessing,
720 * create it. In read/write mode a write will be allowed (higher
721 * level software thinks that we are extending a pre-existing
722 * media. Reads for READ_ONLY will report immediately an EOF
723 * Sometimes it is better to finish with an EOF than with an error. */
724 Dmsg1(100, "Creating last part on spool: %s\n", archive_name.c_str());
725 omode = CREATE_READ_WRITE;
726 set_mode(CREATE_READ_WRITE);
727 m_fd = ::open(archive_name.c_str(), mode, 0640);
731 Dmsg1(100, "after open fd=%d\n", m_fd);
733 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
736 /* Get size of file */
737 if (fstat(m_fd, &filestat) < 0) {
740 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
742 Dmsg1(100, "open failed: %s", errmsg);
743 /* Use system close() */
747 part_size = filestat.st_size;
749 update_pos(dcr); /* update position */
757 * Returns: true on success
760 bool DEVICE::rewind(DCR *dcr)
766 Dmsg3(400, "rewind res=%d fd=%d %s\n", num_reserved(), m_fd, print_name());
767 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
768 block_num = file = 0;
772 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
774 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
776 Emsg0(M_ABORT, 0, errmsg);
781 mt_com.mt_op = MTREW;
783 /* If we get an I/O error on rewind, it is probably because
784 * the drive is actually busy. We loop for (about 5 minutes)
785 * retrying every 5 seconds.
787 for (i=max_rewind_wait; ; i -= 5) {
788 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
791 if (i == max_rewind_wait) {
792 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.bstrerror());
795 * This is a gross hack, because if the user has the
796 * device mounted (i.e. open), then uses mtx to load
797 * a tape, the current open file descriptor is invalid.
798 * So, we close the drive and re-open it.
801 int open_mode = openmode;
804 open(dcr, open_mode);
812 if (dev_errno == EIO) {
813 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
817 if (dev_errno == EIO && i > 0) {
818 Dmsg0(200, "Sleeping 5 seconds.\n");
823 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
824 print_name(), be.bstrerror());
829 } else if (is_file() || is_dvd()) {
830 if (lseek(dcr, (boffset_t)0, SEEK_SET) < 0) {
833 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
834 print_name(), be.bstrerror());
843 * Called to indicate that we have just read an
844 * EOF from the device.
846 void DEVICE::set_ateof()
858 * Called to indicate we are now at the end of the tape, and
859 * writing is not possible.
861 void DEVICE::set_ateot()
863 /* Make tape effectively read-only */
864 state |= (ST_EOF|ST_EOT|ST_WEOT);
869 * Position device to end of medium (end of data)
870 * Returns: true on succes
873 bool DEVICE::eod(DCR *dcr)
882 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
886 #if defined (__digital__) && defined (__unix__)
887 return fsf(VolCatInfo.VolCatFiles);
894 clear_eof(); /* remove EOF flag */
895 block_num = file = 0;
902 pos = lseek(dcr, (boffset_t)0, SEEK_END);
903 // Dmsg1(100, "====== Seek to %lld\n", pos);
911 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
912 print_name(), be.bstrerror());
916 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
917 Dmsg0(100,"Using FAST FSF for EOM\n");
918 /* If unknown position, rewind */
919 if (get_os_tape_file() < 0) {
924 mt_com.mt_op = MTFSF;
926 * ***FIXME*** fix code to handle case that INT16_MAX is
929 mt_com.mt_count = INT16_MAX; /* use big positive number */
930 if (mt_com.mt_count < 0) {
931 mt_com.mt_count = INT16_MAX; /* brain damaged system */
935 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
936 if (has_cap(CAP_EOM)) {
937 Dmsg0(100,"Using EOM for EOM\n");
938 mt_com.mt_op = MTEOM;
942 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
944 clrerror(mt_com.mt_op);
945 Dmsg1(50, "ioctl error: %s\n", be.bstrerror());
947 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
948 print_name(), be.bstrerror());
952 os_file = get_os_tape_file();
956 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
957 print_name(), be.bstrerror());
960 Dmsg1(100, "EOD file=%d\n", os_file);
968 * Rewind then use FSF until EOT reached
974 * Move file by file to the end of the tape
977 for (file_num=file; !at_eot(); file_num++) {
978 Dmsg0(200, "eod: doing fsf 1\n");
980 Dmsg0(200, "fsf error.\n");
984 * Avoid infinite loop by ensuring we advance.
986 if (!at_eot() && file_num == (int)file) {
987 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
989 os_file = get_os_tape_file();
991 Dmsg2(100, "Adjust file from %d to %d\n", file_num, os_file);
999 * Some drivers leave us after second EOF when doing
1000 * MTEOM, so we must backup so that appending overwrites
1003 if (has_cap(CAP_BSFATEOM)) {
1004 /* Backup over EOF */
1006 /* If BSF worked and fileno is known (not -1), set file */
1007 os_file = get_os_tape_file();
1009 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , os_file);
1012 file++; /* wing it -- not correct on all OSes */
1015 update_pos(dcr); /* update position */
1017 Dmsg1(200, "EOD dev->file=%d\n", file);
1022 * Set the position of the device -- only for files and DVD
1023 * For other devices, there is no generic way to do it.
1024 * Returns: true on succes
1027 bool DEVICE::update_pos(DCR *dcr)
1034 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
1035 Emsg1(M_FATAL, 0, "%s", errmsg);
1039 /* Find out where we are */
1040 if (is_file() || is_dvd()) {
1043 pos = lseek(dcr, (boffset_t)0, SEEK_CUR);
1047 Pmsg1(000, _("Seek error: ERR=%s\n"), be.bstrerror());
1048 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1049 print_name(), be.bstrerror());
1053 block_num = (uint32_t)pos;
1054 file = (uint32_t)(pos >> 32);
1061 * Return the status of the device. This was meant
1062 * to be a generic routine. Unfortunately, it doesn't
1063 * seem possible (at least I do not know how to do it
1064 * currently), which means that for the moment, this
1065 * routine has very little value.
1069 uint32_t status_dev(DEVICE *dev)
1071 struct mtget mt_stat;
1074 if (dev->state & (ST_EOT | ST_WEOT)) {
1078 if (dev->state & ST_EOF) {
1082 if (dev->is_tape()) {
1084 Pmsg0(-20,_(" Bacula status:"));
1085 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1086 if (dev->d_ioctl(dev->fd(), MTIOCGET, (char *)&mt_stat) < 0) {
1088 dev->dev_errno = errno;
1089 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1090 dev->print_name(), be.bstrerror());
1093 Pmsg0(-20, _(" Device status:"));
1095 #if defined(HAVE_LINUX_OS)
1096 if (GMT_EOF(mt_stat.mt_gstat)) {
1100 if (GMT_BOT(mt_stat.mt_gstat)) {
1104 if (GMT_EOT(mt_stat.mt_gstat)) {
1108 if (GMT_SM(mt_stat.mt_gstat)) {
1112 if (GMT_EOD(mt_stat.mt_gstat)) {
1116 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1117 stat |= BMT_WR_PROT;
1118 Pmsg0(-20, " WR_PROT");
1120 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1122 Pmsg0(-20, " ONLINE");
1124 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1125 stat |= BMT_DR_OPEN;
1126 Pmsg0(-20, " DR_OPEN");
1128 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1129 stat |= BMT_IM_REP_EN;
1130 Pmsg0(-20, " IM_REP_EN");
1132 #elif defined(HAVE_WIN32)
1133 if (GMT_EOF(mt_stat.mt_gstat)) {
1137 if (GMT_BOT(mt_stat.mt_gstat)) {
1141 if (GMT_EOT(mt_stat.mt_gstat)) {
1145 if (GMT_EOD(mt_stat.mt_gstat)) {
1149 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1150 stat |= BMT_WR_PROT;
1151 Pmsg0(-20, " WR_PROT");
1153 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1155 Pmsg0(-20, " ONLINE");
1157 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1158 stat |= BMT_DR_OPEN;
1159 Pmsg0(-20, " DR_OPEN");
1161 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1162 stat |= BMT_IM_REP_EN;
1163 Pmsg0(-20, " IM_REP_EN");
1166 #endif /* !SunOS && !OSF */
1167 if (dev->has_cap(CAP_MTIOCGET)) {
1168 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1170 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1173 stat |= BMT_ONLINE | BMT_BOT;
1180 * Load medium in device
1181 * Returns: true on success
1184 bool load_dev(DEVICE *dev)
1190 if (dev->fd() < 0) {
1191 dev->dev_errno = EBADF;
1192 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1193 Emsg0(M_FATAL, 0, dev->errmsg);
1196 if (!(dev->is_tape())) {
1200 Dmsg0(200, "stored: MTLOAD command not available\n");
1202 dev->dev_errno = ENOTTY; /* function not available */
1203 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1204 dev->print_name(), be.bstrerror());
1208 dev->block_num = dev->file = 0;
1211 mt_com.mt_op = MTLOAD;
1212 mt_com.mt_count = 1;
1213 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
1215 dev->dev_errno = errno;
1216 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1217 dev->print_name(), be.bstrerror());
1225 * Rewind device and put it offline
1226 * Returns: true on success
1229 bool DEVICE::offline()
1234 return true; /* device not open */
1237 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1238 block_num = file = 0;
1242 mt_com.mt_op = MTOFFL;
1243 mt_com.mt_count = 1;
1244 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
1247 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1248 print_name(), be.bstrerror());
1251 Dmsg1(100, "Offlined device %s\n", print_name());
1255 bool DEVICE::offline_or_rewind()
1260 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1264 * Note, this rewind probably should not be here (it wasn't
1265 * in prior versions of Bacula), but on FreeBSD, this is
1266 * needed in the case the tape was "frozen" due to an error
1267 * such as backspacing after writing and EOF. If it is not
1268 * done, all future references to the drive get and I/O error.
1271 return rewind(NULL);
1276 * Foward space a file
1277 * Returns: true on success
1280 bool DEVICE::fsf(int num)
1282 int32_t os_file = 0;
1288 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1289 Emsg0(M_FATAL, 0, errmsg);
1299 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1303 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1306 Dmsg0(100, "fsf\n");
1309 * If Fast forward space file is set, then we
1310 * use MTFSF to forward space and MTIOCGET
1311 * to get the file position. We assume that
1312 * the SCSI driver will ensure that we do not
1313 * forward space past the end of the medium.
1315 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1317 mt_com.mt_op = MTFSF;
1318 mt_com.mt_count = num;
1319 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1321 my_errno = errno; /* save errno */
1322 } else if ((os_file=get_os_tape_file()) < 0) {
1323 my_errno = errno; /* save errno */
1325 if (my_errno != 0) {
1328 Dmsg0(200, "Set ST_EOT\n");
1330 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1331 print_name(), be.bstrerror(my_errno));
1332 Dmsg1(200, "%s", errmsg);
1336 Dmsg1(200, "fsf file=%d\n", os_file);
1342 * Here if CAP_FSF is set, and virtually all drives
1343 * these days support it, we read a record, then forward
1344 * space one file. Using this procedure, which is slow,
1345 * is the only way we can be sure that we don't read
1346 * two consecutive EOF marks, which means End of Data.
1348 } else if (has_cap(CAP_FSF)) {
1351 Dmsg0(200, "FSF has cap_fsf\n");
1352 if (max_block_size == 0) {
1353 rbuf_len = DEFAULT_BLOCK_SIZE;
1355 rbuf_len = max_block_size;
1357 rbuf = get_memory(rbuf_len);
1358 mt_com.mt_op = MTFSF;
1359 mt_com.mt_count = 1;
1360 while (num-- && !at_eot()) {
1361 Dmsg0(100, "Doing read before fsf\n");
1362 if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1363 if (errno == ENOMEM) { /* tape record exceeds buf len */
1364 stat = rbuf_len; /* This is OK */
1366 * On IBM drives, they return ENOSPC at EOM
1367 * instead of EOF status
1369 } else if (at_eof() && errno == ENOSPC) {
1375 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1377 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1378 print_name(), be.bstrerror());
1379 Dmsg1(100, "%s", errmsg);
1383 if (stat == 0) { /* EOF */
1384 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1385 /* Two reads of zero means end of tape */
1388 Dmsg0(100, "Set ST_EOT\n");
1394 } else { /* Got data */
1399 Dmsg0(100, "Doing MTFSF\n");
1400 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1401 if (stat < 0) { /* error => EOT */
1404 Dmsg0(100, "Set ST_EOT\n");
1406 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1407 print_name(), be.bstrerror());
1408 Dmsg0(100, "Got < 0 for MTFSF\n");
1409 Dmsg1(100, "%s", errmsg);
1417 * No FSF, so use FSR to simulate it
1420 Dmsg0(200, "Doing FSR for FSF\n");
1421 while (num-- && !at_eot()) {
1422 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1426 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1432 Dmsg1(200, "Return %d from FSF\n", stat);
1434 Dmsg0(200, "ST_EOF set on exit FSF\n");
1437 Dmsg0(200, "ST_EOT set on exit FSF\n");
1439 Dmsg1(200, "Return from FSF file=%d\n", file);
1444 * Backward space a file
1445 * Returns: false on failure
1448 bool DEVICE::bsf(int num)
1455 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1456 Emsg0(M_FATAL, 0, errmsg);
1461 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1466 Dmsg0(100, "bsf\n");
1472 mt_com.mt_op = MTBSF;
1473 mt_com.mt_count = num;
1474 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1478 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1479 print_name(), be.bstrerror());
1486 * Foward space num records
1487 * Returns: false on failure
1490 bool DEVICE::fsr(int num)
1497 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1498 Emsg0(M_FATAL, 0, errmsg);
1506 if (!has_cap(CAP_FSR)) {
1507 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1511 Dmsg1(100, "fsr %d\n", num);
1512 mt_com.mt_op = MTFSR;
1513 mt_com.mt_count = num;
1514 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1520 struct mtget mt_stat;
1522 Dmsg1(100, "FSF fail: ERR=%s\n", be.bstrerror());
1523 if (dev_get_os_pos(this, &mt_stat)) {
1524 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1525 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1526 file = mt_stat.mt_fileno;
1527 block_num = mt_stat.mt_blkno;
1535 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1536 num, print_name(), be.bstrerror());
1542 * Backward space a record
1543 * Returns: false on failure
1546 bool DEVICE::bsr(int num)
1553 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1554 Emsg0(M_FATAL, 0, errmsg);
1562 if (!has_cap(CAP_BSR)) {
1563 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1567 Dmsg0(100, "bsr_dev\n");
1571 mt_com.mt_op = MTBSR;
1572 mt_com.mt_count = num;
1573 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1577 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1578 print_name(), be.bstrerror());
1583 void DEVICE::lock_door()
1587 mt_com.mt_op = MTLOCK;
1588 mt_com.mt_count = 1;
1589 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1593 void DEVICE::unlock_door()
1597 mt_com.mt_op = MTUNLOCK;
1598 mt_com.mt_count = 1;
1599 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1603 void DEVICE::set_slot(int32_t slot)
1606 if (vol) vol->clear_slot();
1609 void DEVICE::clear_slot()
1612 if (vol) vol->set_slot(-1);
1618 * Reposition the device to file, block
1619 * Returns: false on failure
1622 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1626 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1627 Emsg0(M_FATAL, 0, errmsg);
1632 boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1633 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1634 if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1637 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1638 print_name(), be.bstrerror());
1647 /* After this point, we are tape only */
1648 Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1650 Dmsg0(100, "Rewind\n");
1651 if (!rewind(NULL)) {
1656 Dmsg1(100, "fsf %d\n", rfile-file);
1657 if (!fsf(rfile-file)) {
1658 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1661 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1663 if (rblock < block_num) {
1664 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1665 Dmsg0(100, "bsf 1\n");
1667 Dmsg0(100, "fsf 1\n");
1669 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1671 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1672 /* Ignore errors as Bacula can read to the correct block */
1673 Dmsg1(100, "fsr %d\n", rblock-block_num);
1674 return fsr(rblock-block_num);
1676 while (rblock > block_num) {
1677 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1680 Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1681 print_name(), be.bstrerror());
1684 Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1693 * Write an end of file on the device
1694 * Returns: true on success
1697 bool DEVICE::weof(int num)
1701 Dmsg1(129, "=== weof_dev=%s\n", print_name());
1705 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1706 Emsg0(M_FATAL, 0, errmsg);
1714 if (!can_append()) {
1715 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1716 Emsg0(M_FATAL, 0, errmsg);
1722 mt_com.mt_op = MTWEOF;
1723 mt_com.mt_count = num;
1724 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1733 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1734 print_name(), be.bstrerror());
1742 * If implemented in system, clear the tape
1745 void DEVICE::clrerror(int func)
1747 const char *msg = NULL;
1750 dev_errno = errno; /* save errno */
1752 VolCatInfo.VolCatErrors++;
1759 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1762 break; /* ignore message printed later */
1765 clear_cap(CAP_EOF); /* turn off feature */
1770 clear_cap(CAP_EOM); /* turn off feature */
1775 clear_cap(CAP_FSF); /* turn off feature */
1779 clear_cap(CAP_BSF); /* turn off feature */
1783 clear_cap(CAP_FSR); /* turn off feature */
1787 clear_cap(CAP_BSR); /* turn off feature */
1797 #ifdef MTSETDRVBUFFER
1798 case MTSETDRVBUFFER:
1799 msg = "MTSETDRVBUFFER";
1832 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1838 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1839 Emsg0(M_ERROR, 0, errmsg);
1844 * Now we try different methods of clearing the error
1845 * status on the drive so that it is not locked for
1846 * further operations.
1849 /* On some systems such as NetBSD, this clears all errors */
1852 /* Found on Solaris */
1855 d_ioctl(m_fd, MTIOCLRERR);
1856 Dmsg0(200, "Did MTIOCLRERR\n");
1860 /* Typically on FreeBSD */
1864 /* Read and clear SCSI error status */
1865 union mterrstat mt_errstat;
1866 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1867 be.bstrerror(dev_errno));
1868 d_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1872 /* Clear Subsystem Exception OSF1 */
1876 mt_com.mt_op = MTCSE;
1877 mt_com.mt_count = 1;
1878 /* Clear any error condition on the tape */
1879 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1880 Dmsg0(200, "Did MTCSE\n");
1887 * Set to unload the current volume in the drive
1889 void DEVICE::set_unload()
1891 if (!m_unload && VolHdr.VolumeName[0] != 0) {
1893 memcpy(UnloadVolName, VolHdr.VolumeName, sizeof(UnloadVolName));
1899 * Clear volume header
1901 void DEVICE::clear_volhdr()
1903 Dmsg1(100, "Clear volhdr vol=%s\n", VolHdr.VolumeName);
1904 memset(&VolHdr, 0, sizeof(VolHdr));
1911 void DEVICE::close()
1913 Dmsg1(100, "close_dev %s\n", print_name());
1914 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1919 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1921 return; /* already closed */
1933 /* Clean up device packet so it can be reused */
1936 * Be careful not to clear items needed by the DVD driver
1937 * when it is closing a single part.
1939 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF|
1940 ST_MOUNTED|ST_MEDIA|ST_SHORT);
1941 label_type = B_BACULA_LABEL;
1942 file = block_num = 0;
1945 EndFile = EndBlock = 0;
1948 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1950 stop_thread_timer(tid);
1956 * This call closes the device, but it is used in DVD handling
1957 * where we close one part and then open the next part. The
1958 * difference between close_part() and close() is that close_part()
1959 * saves the state information of the device (e.g. the Volume lable,
1960 * the Volume Catalog record, ... This permits opening and closing
1961 * the Volume parts multiple times without losing track of what the
1962 * main Volume parameters are.
1964 void DEVICE::close_part(DCR * /*dcr*/)
1966 VOLUME_LABEL saveVolHdr;
1967 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1970 saveVolHdr = VolHdr; /* structure assignment */
1971 saveVolCatInfo = VolCatInfo; /* structure assignment */
1972 close(); /* close current part */
1973 VolHdr = saveVolHdr; /* structure assignment */
1974 VolCatInfo = saveVolCatInfo; /* structure assignment */
1977 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1981 return lseek_dvd(dcr, offset, whence);
1983 #if defined(HAVE_WIN32)
1984 return ::_lseeki64(m_fd, (__int64)offset, whence);
1986 return ::lseek(m_fd, offset, whence);
1993 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1997 Dmsg1(100, "truncate %s\n", print_name());
2002 /* maybe we should rewind and write and eof ???? */
2003 return true; /* we don't really truncate tapes */
2005 return truncate_dvd(dcr);
2007 if (ftruncate(m_fd, 0) != 0) {
2009 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
2010 print_name(), be.bstrerror());
2015 * Check for a successful ftruncate() and issue a work-around for devices
2016 * (mostly cheap NAS) that don't support truncation.
2017 * Workaround supplied by Martin Schmid as a solution to bug #1011.
2020 * 3. open new file with same mode
2021 * 4. change ownership to original
2024 if (fstat(m_fd, &st) != 0) {
2026 Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"),
2027 print_name(), be.bstrerror());
2031 if (st.st_size != 0) { /* ftruncate() didn't work */
2032 POOL_MEM archive_name(PM_FNAME);
2034 pm_strcpy(archive_name, dev_name);
2035 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
2036 pm_strcat(archive_name, "/");
2038 pm_strcat(archive_name, dcr->VolumeName);
2040 Mmsg2(errmsg, _("Device %s doesn't support ftruncate(). Recreating file %s.\n"),
2041 print_name(), archive_name.c_str());
2043 /* Close file and blow it away */
2045 ::unlink(archive_name.c_str());
2047 /* Recreate the file -- of course, empty */
2048 set_mode(CREATE_READ_WRITE);
2049 if ((m_fd = ::open(archive_name.c_str(), mode, st.st_mode)) < 0) {
2052 Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), archive_name.c_str(),
2054 Dmsg1(100, "reopen failed: %s", errmsg);
2055 Emsg0(M_FATAL, 0, errmsg);
2059 /* Reset proper owner */
2060 chown(archive_name.c_str(), st.st_uid, st.st_gid);
2068 /* Mount the device.
2069 * If timeout, wait until the mount command returns 0.
2070 * If !timeout, try to mount the device only once.
2072 bool DEVICE::mount(int timeout)
2074 Dmsg0(190, "Enter mount\n");
2077 } else if (requires_mount()) {
2078 return do_mount(1, timeout);
2083 /* Unmount the device
2084 * If timeout, wait until the unmount command returns 0.
2085 * If !timeout, try to unmount the device only once.
2087 bool DEVICE::unmount(int timeout)
2089 Dmsg0(100, "Enter unmount\n");
2091 return do_mount(0, timeout);
2096 /* (Un)mount the device */
2097 bool DEVICE::do_mount(int mount, int dotimeout)
2099 POOL_MEM ocmd(PM_FNAME);
2102 int status, timeout;
2107 Dmsg0(200, "======= mount=1\n");
2110 icmd = device->mount_command;
2112 if (!is_mounted()) {
2113 Dmsg0(200, "======= mount=0\n");
2116 icmd = device->unmount_command;
2119 clear_freespace_ok();
2120 edit_mount_codes(ocmd, icmd);
2122 Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2125 /* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
2130 results = get_memory(4000);
2132 /* If busy retry each second */
2133 Dmsg1(100, "do_mount run_prog=%s\n", ocmd.c_str());
2134 while ((status = run_program_full_output(ocmd.c_str(),
2135 max_open_wait/2, results)) != 0) {
2136 /* Doesn't work with internationalization (This is not a problem) */
2137 if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2140 if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2143 if (timeout-- > 0) {
2144 /* Sometimes the device cannot be mounted because it is already mounted.
2145 * Try to unmount it, then remount it */
2147 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2155 Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2156 (mount ? "" : "un"), status, results, be.bstrerror(status));
2157 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2158 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2160 Dmsg4(100, "Device %s cannot be %smounted. stat=%d ERR=%s\n", print_name(),
2161 (mount ? "" : "un"), status, results);
2162 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2163 print_name(), (mount ? "" : "un"), results);
2166 * Now, just to be sure it is not mounted, try to read the
2170 struct dirent *entry, *result;
2174 name_max = pathconf(".", _PC_NAME_MAX);
2175 if (name_max < 1024) {
2179 if (!(dp = opendir(device->mount_point))) {
2182 Dmsg3(100, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2183 device->mount_point, print_name(), be.bstrerror());
2187 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2190 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2192 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
2193 device->mount_point, print_name());
2196 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2197 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2200 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2206 Dmsg1(100, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2209 /* If we got more than ., .. and .keep */
2210 /* there must be something mounted */
2212 Dmsg1(100, "Did Mount by count=%d\n", count);
2215 /* An unmount request. We failed to unmount - report an error */
2217 free_pool_memory(results);
2218 Dmsg0(200, "== error mount=1 wanted unmount\n");
2224 free_pool_memory(results);
2225 Dmsg0(200, "============ mount=0\n");
2230 set_mounted(mount); /* set/clear mounted flag */
2231 free_pool_memory(results);
2232 /* Do not check free space when unmounting */
2233 if (mount && !update_freespace()) {
2236 Dmsg1(200, "============ mount=%d\n", mount);
2241 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2243 * %a = archive device name
2244 * %e = erase (set if cannot mount and first part)
2247 * %v = last part name
2249 * omsg = edited output message
2250 * imsg = input string containing edit codes (%x)
2253 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2259 POOL_MEM archive_name(PM_FNAME);
2261 omsg.c_str()[0] = 0;
2262 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2263 for (p=imsg; *p; p++) {
2273 if (num_dvd_parts == 0) {
2274 if (truncating || blank_dvd) {
2284 bsnprintf(add, sizeof(add), "%d", part);
2288 str = device->mount_point;
2291 make_spooled_dvd_filename(this, archive_name);
2292 str = archive_name.c_str();
2306 Dmsg1(1900, "add_str %s\n", str);
2307 pm_strcat(omsg, (char *)str);
2308 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2312 /* return the last timer interval (ms)
2313 * or 0 if something goes wrong
2315 btime_t DEVICE::get_timer_count()
2317 btime_t temp = last_timer;
2318 last_timer = get_current_btime();
2319 temp = last_timer - temp; /* get elapsed time */
2320 return (temp>0)?temp:0; /* take care of skewed clock */
2324 ssize_t DEVICE::read(void *buf, size_t len)
2330 read_len = d_read(m_fd, buf, len);
2332 last_tick = get_timer_count();
2334 DevReadTime += last_tick;
2335 VolCatInfo.VolReadTime += last_tick;
2337 if (read_len > 0) { /* skip error */
2338 DevReadBytes += read_len;
2345 ssize_t DEVICE::write(const void *buf, size_t len)
2351 write_len = d_write(m_fd, buf, len);
2353 last_tick = get_timer_count();
2355 DevWriteTime += last_tick;
2356 VolCatInfo.VolWriteTime += last_tick;
2358 if (write_len > 0) { /* skip error */
2359 DevWriteBytes += write_len;
2365 /* Return the resource name for the device */
2366 const char *DEVICE::name() const
2368 return device->hdr.name;
2371 /* Returns file position on tape or -1 */
2372 int32_t DEVICE::get_os_tape_file()
2374 struct mtget mt_stat;
2376 if (has_cap(CAP_MTIOCGET) &&
2377 d_ioctl(m_fd, MTIOCGET, (char *)&mt_stat) == 0) {
2378 return mt_stat.mt_fileno;
2384 dev_vol_name(DEVICE *dev)
2386 return dev->VolCatInfo.VolCatName;
2391 * Free memory allocated for the device
2393 void DEVICE::term(void)
2395 Dmsg1(900, "term dev: %s\n", print_name());
2398 free_memory(dev_name);
2402 free_memory(prt_name);
2406 free_pool_memory(errmsg);
2409 pthread_mutex_destroy(&m_mutex);
2410 pthread_cond_destroy(&wait);
2411 pthread_cond_destroy(&wait_next_vol);
2412 pthread_mutex_destroy(&spool_mutex);
2413 // rwl_destroy(&lock);
2414 if (attached_dcrs) {
2415 delete attached_dcrs;
2416 attached_dcrs = NULL;
2425 * This routine initializes the device wait timers
2427 void init_device_wait_timers(DCR *dcr)
2429 DEVICE *dev = dcr->dev;
2430 JCR *jcr = dcr->jcr;
2432 /* ******FIXME******* put these on config variables */
2433 dev->min_wait = 60 * 60;
2434 dev->max_wait = 24 * 60 * 60;
2435 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2436 dev->wait_sec = dev->min_wait;
2437 dev->rem_wait_sec = dev->wait_sec;
2441 jcr->min_wait = 60 * 60;
2442 jcr->max_wait = 24 * 60 * 60;
2443 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2444 jcr->wait_sec = jcr->min_wait;
2445 jcr->rem_wait_sec = jcr->wait_sec;
2450 void init_jcr_device_wait_timers(JCR *jcr)
2452 /* ******FIXME******* put these on config variables */
2453 jcr->min_wait = 60 * 60;
2454 jcr->max_wait = 24 * 60 * 60;
2455 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2456 jcr->wait_sec = jcr->min_wait;
2457 jcr->rem_wait_sec = jcr->wait_sec;
2463 * The dev timers are used for waiting on a particular device
2465 * Returns: true if time doubled
2466 * false if max time expired
2468 bool double_dev_wait_time(DEVICE *dev)
2470 dev->wait_sec *= 2; /* double wait time */
2471 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2472 dev->wait_sec = dev->max_wait;
2475 dev->rem_wait_sec = dev->wait_sec;
2476 if (dev->num_wait >= dev->max_num_wait) {
2483 void set_os_device_parameters(DCR *dcr)
2485 DEVICE *dev = dcr->dev;
2487 if (strcmp(dev->dev_name, "/dev/null") == 0) {
2488 return; /* no use trying to set /dev/null */
2491 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2494 Dmsg0(100, "In set_os_device_parameters\n");
2495 #if defined(MTSETBLK)
2496 if (dev->min_block_size == dev->max_block_size &&
2497 dev->min_block_size == 0) { /* variable block mode */
2498 mt_com.mt_op = MTSETBLK;
2499 mt_com.mt_count = 0;
2500 Dmsg0(100, "Set block size to zero\n");
2501 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2502 dev->clrerror(MTSETBLK);
2506 #if defined(MTSETDRVBUFFER)
2507 if (getuid() == 0) { /* Only root can do this */
2508 mt_com.mt_op = MTSETDRVBUFFER;
2509 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2510 if (!dev->has_cap(CAP_TWOEOF)) {
2511 mt_com.mt_count |= MT_ST_TWO_FM;
2513 if (dev->has_cap(CAP_EOM)) {
2514 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2516 Dmsg0(100, "MTSETDRVBUFFER\n");
2517 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2518 dev->clrerror(MTSETDRVBUFFER);
2525 #ifdef HAVE_NETBSD_OS
2527 if (dev->min_block_size == dev->max_block_size &&
2528 dev->min_block_size == 0) { /* variable block mode */
2529 mt_com.mt_op = MTSETBSIZ;
2530 mt_com.mt_count = 0;
2531 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2532 dev->clrerror(MTSETBSIZ);
2534 /* Get notified at logical end of tape */
2535 mt_com.mt_op = MTEWARN;
2536 mt_com.mt_count = 1;
2537 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2538 dev->clrerror(MTEWARN);
2544 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2546 if (dev->min_block_size == dev->max_block_size &&
2547 dev->min_block_size == 0) { /* variable block mode */
2548 mt_com.mt_op = MTSETBSIZ;
2549 mt_com.mt_count = 0;
2550 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2551 dev->clrerror(MTSETBSIZ);
2554 #if defined(MTIOCSETEOTMODEL)
2556 if (dev->has_cap(CAP_TWOEOF)) {
2561 if (dev->d_ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2563 dev->dev_errno = errno; /* save errno */
2564 Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2565 dev->print_name(), be.bstrerror(dev->dev_errno));
2566 Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2574 if (dev->min_block_size == dev->max_block_size &&
2575 dev->min_block_size == 0) { /* variable block mode */
2576 mt_com.mt_op = MTSRSZ;
2577 mt_com.mt_count = 0;
2578 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2579 dev->clrerror(MTSRSZ);
2586 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2588 Dmsg0(100, "dev_get_os_pos\n");
2589 return dev->has_cap(CAP_MTIOCGET) &&
2590 dev->d_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2591 mt_stat->mt_fileno >= 0;
2594 static const char *modes[] = {
2595 "CREATE_READ_WRITE",
2602 static const char *mode_to_str(int mode)
2604 static char buf[100];
2605 if (mode < 1 || mode > 4) {
2606 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2609 return modes[mode-1];