2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2008 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 John Walker.
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 writting.
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;
130 } else if (!(device->cap_bits & CAP_REQMOUNT)) {
131 Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
132 " or have RequiresMount=yes for DVD. st_mode=%x\n"),
133 device->device_name, statp.st_mode);
136 device->dev_type = B_DVD_DEV;
140 dev = (DEVICE *)malloc(sizeof(DEVICE));
141 memset(dev, 0, sizeof(DEVICE));
142 dev->Slot = -1; /* unknown */
144 /* Copy user supplied device parameters from Resource */
145 dev->dev_name = get_memory(strlen(device->device_name)+1);
146 pm_strcpy(dev->dev_name, device->device_name);
147 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
148 /* We edit "Resource-name" (physical-name) */
149 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
150 Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
151 dev->capabilities = device->cap_bits;
152 dev->min_block_size = device->min_block_size;
153 dev->max_block_size = device->max_block_size;
154 dev->max_volume_size = device->max_volume_size;
155 dev->max_file_size = device->max_file_size;
156 dev->volume_capacity = device->volume_capacity;
157 dev->max_rewind_wait = device->max_rewind_wait;
158 dev->max_open_wait = device->max_open_wait;
159 dev->max_open_vols = device->max_open_vols;
160 dev->vol_poll_interval = device->vol_poll_interval;
161 dev->max_spool_size = device->max_spool_size;
162 dev->drive_index = device->drive_index;
163 dev->autoselect = device->autoselect;
164 dev->dev_type = device->dev_type;
165 if (dev->is_tape()) { /* No parts on tapes */
166 dev->max_part_size = 0;
168 dev->max_part_size = device->max_part_size;
171 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
172 dev->vol_poll_interval = 60;
174 /* Link the dev and device structures together */
175 dev->device = device;
178 if (dev->is_fifo()) {
179 dev->capabilities |= CAP_STREAM; /* set stream device */
182 /* If the device requires mount :
183 * - Check that the mount point is available
184 * - Check that (un)mount commands are defined
186 if ((dev->is_file() || dev->is_dvd()) && dev->requires_mount()) {
187 if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
189 dev->dev_errno = errno;
190 Jmsg2(jcr, M_ERROR_TERM, 0, _("Unable to stat mount point %s: ERR=%s\n"),
191 device->mount_point, be.bstrerror());
195 if (!device->mount_command || !device->unmount_command) {
196 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
198 if (!device->write_part_command) {
199 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
204 if (dev->max_block_size == 0) {
205 max_bs = DEFAULT_BLOCK_SIZE;
207 max_bs = dev->max_block_size;
209 if (dev->min_block_size > max_bs) {
210 Jmsg(jcr, M_ERROR_TERM, 0, _("Min block size > max on device %s\n"),
213 if (dev->max_block_size > 4096000) {
214 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
215 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
216 dev->max_block_size = 0;
218 if (dev->max_block_size % TAPE_BSIZE != 0) {
219 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
220 dev->max_block_size, dev->print_name());
223 dev->errmsg = get_pool_memory(PM_EMSG);
226 if ((errstat = pthread_mutex_init(&dev->m_mutex, NULL)) != 0) {
228 dev->dev_errno = errstat;
229 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
230 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
232 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
234 dev->dev_errno = errstat;
235 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
236 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
238 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
240 dev->dev_errno = errstat;
241 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
242 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
244 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
246 dev->dev_errno = errstat;
247 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
248 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
251 if ((errstat = rwl_init(&dev->lock)) != 0) {
253 dev->dev_errno = errstat;
254 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
255 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
260 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
261 Dmsg2(100, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
262 dev->initiated = true;
268 * Open the device with the operating system and
269 * initialize buffer pointers.
271 * Returns: -1 on error
274 * Note, for a tape, the VolName is the name we give to the
275 * volume (not really used here), but for a file, the
276 * VolName represents the name of the file to be created/opened.
277 * In the case of a file, the full name is the device name
278 * (archive_name) with the VolName concatenated.
281 DEVICE::open(DCR *dcr, int omode)
285 if (openmode == omode) {
294 Dmsg0(100, "Close fd for mode change.\n");
295 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
299 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
302 Dmsg4(100, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
303 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
304 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
305 Slot = -1; /* unknown slot */
306 label_type = B_BACULA_LABEL;
307 if (is_tape() || is_fifo()) {
308 open_tape_device(dcr, omode);
309 } else if (is_dvd()) {
310 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
311 open_dvd_device(dcr, omode);
313 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
314 open_file_device(dcr, omode);
316 state |= preserve; /* reset any important state info */
317 Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, m_fd);
321 void DEVICE::set_mode(int new_mode)
324 case CREATE_READ_WRITE:
325 mode = O_CREAT | O_RDWR | O_BINARY;
327 case OPEN_READ_WRITE:
328 mode = O_RDWR | O_BINARY;
331 mode = O_RDONLY | O_BINARY;
333 case OPEN_WRITE_ONLY:
334 mode = O_WRONLY | O_BINARY;
337 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
343 void DEVICE::open_tape_device(DCR *dcr, int omode)
346 int timeout = max_open_wait;
347 #if !defined(HAVE_WIN32)
349 utime_t start_time = time(NULL);
353 Dmsg0(100, "Open dev: device is tape\n");
355 get_autochanger_loaded_slot(dcr);
364 if (is_fifo() && timeout) {
366 tid = start_thread_timer(dcr->jcr, pthread_self(), timeout);
368 Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
369 #if defined(HAVE_WIN32)
372 if ((m_fd = tape_open(dev_name, mode)) < 0) {
379 /* If busy retry each second for max_open_wait seconds */
381 /* Try non-blocking open */
382 m_fd = tape_open(dev_name, mode+O_NONBLOCK);
386 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
387 print_name(), omode, mode, errno, be.bstrerror());
389 /* Tape open, now rewind it */
390 Dmsg0(100, "Rewind after open\n");
391 mt_com.mt_op = MTREW;
393 /* rewind only if dev is a tape */
394 if (is_tape() && (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0)) {
396 dev_errno = errno; /* set error status from rewind */
399 Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
400 be.bstrerror(dev_errno));
401 /* If we get busy, device is probably rewinding, try again */
402 if (dev_errno != EBUSY) {
403 break; /* error -- no medium */
406 /* Got fd and rewind worked, so we must have medium in drive */
408 m_fd = tape_open(dev_name, mode); /* open normally */
412 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
413 print_name(), omode, mode, errno, be.bstrerror());
418 set_os_device_parameters(dcr); /* do system dependent stuff */
419 break; /* Successfully opened and rewound */
423 /* Exceed wait time ? */
424 if (time(NULL) - start_time >= max_open_wait) {
425 break; /* yes, get out */
432 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
433 print_name(), be.bstrerror(dev_errno));
434 Dmsg1(100, "%s", errmsg);
437 /* Stop any open() timer we started */
439 stop_thread_timer(tid);
442 Dmsg1(100, "open dev: tape %d opened\n", m_fd);
449 void DEVICE::open_file_device(DCR *dcr, int omode)
451 POOL_MEM archive_name(PM_FNAME);
453 get_autochanger_loaded_slot(dcr);
456 * Handle opening of File Archive (not a tape)
459 pm_strcpy(archive_name, dev_name);
461 * If this is a virtual autochanger (i.e. changer_res != NULL)
462 * we simply use the device name, assuming it has been
463 * appropriately setup by the "autochanger".
465 if (!device->changer_res || device->changer_command[0] == 0) {
466 if (VolCatInfo.VolCatName[0] == 0) {
467 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
473 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
474 pm_strcat(archive_name, "/");
476 pm_strcat(archive_name, VolCatInfo.VolCatName);
479 mount(1); /* do mount if required */
483 /* If creating file, give 0640 permissions */
484 Dmsg3(100, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
485 archive_name.c_str(), mode);
486 /* Use system open() */
487 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
490 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
492 Dmsg1(100, "open failed: %s", errmsg);
493 Jmsg1(NULL, M_WARNING, 0, "%s", errmsg);
499 Dmsg4(100, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
500 m_fd, part, num_dvd_parts, part_size);
504 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
505 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
506 * has the desired Volume name, but there is NO assurance that
507 * any other field of VolCatInfo is correct.
509 void DEVICE::open_dvd_device(DCR *dcr, int omode)
511 POOL_MEM archive_name(PM_FNAME);
512 struct stat filestat;
515 * Handle opening of DVD Volume
517 Dmsg2(100, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n",
518 &dcr->VolCatInfo, mode_to_str(omode));
521 * For a DVD we must always pull the state info from dcr->VolCatInfo
522 * This is a bit ugly, but is necessary because we need to open/close/re-open
523 * the dvd file in order to properly mount/unmount and access the
524 * DVD. So we store the state of the DVD as far as is known in the
525 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
526 * copy here, when opening.
528 VolCatInfo = dcr->VolCatInfo; /* structure assignment */
529 Dmsg1(100, "Volume=%s\n", VolCatInfo.VolCatName);
531 if (VolCatInfo.VolCatName[0] == 0) {
532 Dmsg1(10, "Could not open DVD device %s. No Volume name given.\n",
534 Mmsg(errmsg, _("Could not open DVD device %s. No Volume name given.\n"),
541 Dmsg0(100, "Set part=1\n");
542 part = 1; /* count from 1 */
546 if (num_dvd_parts != VolCatInfo.VolCatParts) {
547 num_dvd_parts = VolCatInfo.VolCatParts;
551 * If we are not trying to access the last part, set mode to
552 * OPEN_READ_ONLY as writing would be an error.
554 Dmsg2(100, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
555 /* Now find the name of the part that we want to access */
556 if (part <= num_dvd_parts) {
557 omode = OPEN_READ_ONLY;
558 make_mounted_dvd_filename(this, archive_name);
559 set_part_spooled(false);
561 omode = OPEN_READ_WRITE;
562 make_spooled_dvd_filename(this, archive_name);
563 set_part_spooled(true);
567 // Clear any previous blank_dvd status - we will recalculate it here
570 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
571 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
574 Dmsg0(99, "DVD device mounted.\n");
575 if (num_dvd_parts == 0 && !truncating) {
577 * If we can mount the device, and we are not truncating the DVD,
578 * we usually want to abort. There is one exception, if there is
579 * only one 0-sized file on the DVD, with the right volume name,
580 * we continue (it's the method used by truncate_dvd to truncate a volume).
582 if (!check_can_write_on_non_blank_dvd(dcr)) {
583 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
584 Emsg0(M_FATAL, 0, errmsg);
585 unmount(1); /* Unmount the device, so the operator can change it. */
592 * Ensure that we have the correct DVD loaded by looking for part1.
593 * We only succeed the open if it exists. Failure to do this could
594 * leave us trying to add a part to a different DVD!
596 uint32_t oldpart = part;
598 POOL_MEM part1_name(PM_FNAME);
600 make_mounted_dvd_filename(this, part1_name);
602 if (stat(part1_name.c_str(), &statp) < 0) {
604 Mmsg(errmsg, _("Unable to stat DVD part 1 file %s: ERR=%s\n"),
605 part1_name.c_str(), be.bstrerror());
606 Emsg0(M_FATAL, 0, errmsg);
610 if (!S_ISREG(statp.st_mode)) {
611 /* It is not a regular file */
612 Mmsg(errmsg, _("DVD part 1 is not a regular file %s.\n"),
614 Emsg0(M_FATAL, 0, errmsg);
620 Dmsg0(99, "DVD device mount failed.\n");
621 /* We cannot mount the device */
622 if (num_dvd_parts == 0) {
623 /* Run free space, check there is a media. */
624 if (!update_freespace()) {
625 Emsg0(M_FATAL, 0, errmsg);
630 Dmsg1(100, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
632 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
633 Emsg0(M_FATAL, 0, errmsg);
638 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
639 Emsg0(M_FATAL, 0, errmsg);
645 Dmsg5(100, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
646 archive_name.c_str(), mode_to_str(omode),
647 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
649 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
652 /* If creating file, give 0640 permissions */
653 Dmsg3(100, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
654 archive_name.c_str(), mode);
655 /* Use system open() */
656 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
658 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
660 // Should this be set if we try the create/open below
661 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
662 Dmsg1(100, "open failed: %s", errmsg);
664 /* Previous open failed. See if we can recover */
665 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
666 (part > num_dvd_parts)) {
667 /* If the last part (on spool), doesn't exist when accessing,
668 * create it. In read/write mode a write will be allowed (higher
669 * level software thinks that we are extending a pre-existing
670 * media. Reads for READ_ONLY will report immediately an EOF
671 * Sometimes it is better to finish with an EOF than with an error. */
672 Dmsg1(100, "Creating last part on spool: %s\n", archive_name.c_str());
673 omode = CREATE_READ_WRITE;
674 set_mode(CREATE_READ_WRITE);
675 m_fd = ::open(archive_name.c_str(), mode, 0640);
679 Dmsg1(100, "after open fd=%d\n", m_fd);
681 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
684 /* Get size of file */
685 if (fstat(m_fd, &filestat) < 0) {
688 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
690 Dmsg1(100, "open failed: %s", errmsg);
691 /* Use system close() */
695 part_size = filestat.st_size;
697 update_pos(dcr); /* update position */
705 * Returns: true on success
708 bool DEVICE::rewind(DCR *dcr)
714 Dmsg3(400, "rewind res=%d fd=%d %s\n", num_reserved(), m_fd, print_name());
715 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
716 block_num = file = 0;
720 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
722 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
724 Emsg0(M_ABORT, 0, errmsg);
729 mt_com.mt_op = MTREW;
731 /* If we get an I/O error on rewind, it is probably because
732 * the drive is actually busy. We loop for (about 5 minutes)
733 * retrying every 5 seconds.
735 for (i=max_rewind_wait; ; i -= 5) {
736 if (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
739 if (i == max_rewind_wait) {
740 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.bstrerror());
743 * This is a gross hack, because if the user has the
744 * device mounted (i.e. open), then uses mtx to load
745 * a tape, the current open file descriptor is invalid.
746 * So, we close the drive and re-open it.
749 int open_mode = openmode;
752 open(dcr, open_mode);
760 if (dev_errno == EIO) {
761 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
765 if (dev_errno == EIO && i > 0) {
766 Dmsg0(200, "Sleeping 5 seconds.\n");
771 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
772 print_name(), be.bstrerror());
777 } else if (is_file() || is_dvd()) {
778 if (lseek(dcr, (boffset_t)0, SEEK_SET) < 0) {
781 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
782 print_name(), be.bstrerror());
791 * Called to indicate that we have just read an
792 * EOF from the device.
794 void DEVICE::set_ateof()
806 * Called to indicate we are now at the end of the tape, and
807 * writing is not possible.
809 void DEVICE::set_ateot()
811 /* Make tape effectively read-only */
812 state |= (ST_EOF|ST_EOT|ST_WEOT);
817 * Position device to end of medium (end of data)
818 * Returns: true on succes
821 bool DEVICE::eod(DCR *dcr)
830 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
834 #if defined (__digital__) && defined (__unix__)
835 return fsf(VolCatInfo.VolCatFiles);
842 clear_eof(); /* remove EOF flag */
843 block_num = file = 0;
850 pos = lseek(dcr, (boffset_t)0, SEEK_END);
851 // Dmsg1(100, "====== Seek to %lld\n", pos);
859 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
860 print_name(), be.bstrerror());
864 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
865 Dmsg0(100,"Using FAST FSF for EOM\n");
866 /* If unknown position, rewind */
867 if (get_os_tape_file() < 0) {
872 mt_com.mt_op = MTFSF;
874 * ***FIXME*** fix code to handle case that INT16_MAX is
877 mt_com.mt_count = INT16_MAX; /* use big positive number */
878 if (mt_com.mt_count < 0) {
879 mt_com.mt_count = INT16_MAX; /* brain damaged system */
883 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
884 if (has_cap(CAP_EOM)) {
885 Dmsg0(100,"Using EOM for EOM\n");
886 mt_com.mt_op = MTEOM;
890 if (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
892 clrerror(mt_com.mt_op);
893 Dmsg1(50, "ioctl error: %s\n", be.bstrerror());
895 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
896 print_name(), be.bstrerror());
900 os_file = get_os_tape_file();
904 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
905 print_name(), be.bstrerror());
908 Dmsg1(100, "EOD file=%d\n", os_file);
916 * Rewind then use FSF until EOT reached
922 * Move file by file to the end of the tape
925 for (file_num=file; !at_eot(); file_num++) {
926 Dmsg0(200, "eod: doing fsf 1\n");
928 Dmsg0(200, "fsf error.\n");
932 * Avoid infinite loop by ensuring we advance.
934 if (!at_eot() && file_num == (int)file) {
935 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
937 os_file = get_os_tape_file();
939 Dmsg2(100, "Adjust file from %d to %d\n", file_num, os_file);
947 * Some drivers leave us after second EOF when doing
948 * MTEOM, so we must backup so that appending overwrites
951 if (has_cap(CAP_BSFATEOM)) {
952 /* Backup over EOF */
954 /* If BSF worked and fileno is known (not -1), set file */
955 os_file = get_os_tape_file();
957 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , os_file);
960 file++; /* wing it -- not correct on all OSes */
963 update_pos(dcr); /* update position */
965 Dmsg1(200, "EOD dev->file=%d\n", file);
970 * Set the position of the device -- only for files and DVD
971 * For other devices, there is no generic way to do it.
972 * Returns: true on succes
975 bool DEVICE::update_pos(DCR *dcr)
982 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
983 Emsg1(M_FATAL, 0, "%s", errmsg);
987 /* Find out where we are */
988 if (is_file() || is_dvd()) {
991 pos = lseek(dcr, (boffset_t)0, SEEK_CUR);
995 Pmsg1(000, _("Seek error: ERR=%s\n"), be.bstrerror());
996 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
997 print_name(), be.bstrerror());
1001 block_num = (uint32_t)pos;
1002 file = (uint32_t)(pos >> 32);
1009 * Return the status of the device. This was meant
1010 * to be a generic routine. Unfortunately, it doesn't
1011 * seem possible (at least I do not know how to do it
1012 * currently), which means that for the moment, this
1013 * routine has very little value.
1017 uint32_t status_dev(DEVICE *dev)
1019 struct mtget mt_stat;
1022 if (dev->state & (ST_EOT | ST_WEOT)) {
1026 if (dev->state & ST_EOF) {
1030 if (dev->is_tape()) {
1032 Pmsg0(-20,_(" Bacula status:"));
1033 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1034 if (tape_ioctl(dev->fd(), MTIOCGET, (char *)&mt_stat) < 0) {
1036 dev->dev_errno = errno;
1037 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1038 dev->print_name(), be.bstrerror());
1041 Pmsg0(-20, _(" Device status:"));
1043 #if defined(HAVE_LINUX_OS)
1044 if (GMT_EOF(mt_stat.mt_gstat)) {
1048 if (GMT_BOT(mt_stat.mt_gstat)) {
1052 if (GMT_EOT(mt_stat.mt_gstat)) {
1056 if (GMT_SM(mt_stat.mt_gstat)) {
1060 if (GMT_EOD(mt_stat.mt_gstat)) {
1064 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1065 stat |= BMT_WR_PROT;
1066 Pmsg0(-20, " WR_PROT");
1068 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1070 Pmsg0(-20, " ONLINE");
1072 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1073 stat |= BMT_DR_OPEN;
1074 Pmsg0(-20, " DR_OPEN");
1076 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1077 stat |= BMT_IM_REP_EN;
1078 Pmsg0(-20, " IM_REP_EN");
1080 #elif defined(HAVE_WIN32)
1081 if (GMT_EOF(mt_stat.mt_gstat)) {
1085 if (GMT_BOT(mt_stat.mt_gstat)) {
1089 if (GMT_EOT(mt_stat.mt_gstat)) {
1093 if (GMT_EOD(mt_stat.mt_gstat)) {
1097 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1098 stat |= BMT_WR_PROT;
1099 Pmsg0(-20, " WR_PROT");
1101 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1103 Pmsg0(-20, " ONLINE");
1105 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1106 stat |= BMT_DR_OPEN;
1107 Pmsg0(-20, " DR_OPEN");
1109 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1110 stat |= BMT_IM_REP_EN;
1111 Pmsg0(-20, " IM_REP_EN");
1114 #endif /* !SunOS && !OSF */
1115 if (dev->has_cap(CAP_MTIOCGET)) {
1116 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1118 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1121 stat |= BMT_ONLINE | BMT_BOT;
1128 * Load medium in device
1129 * Returns: true on success
1132 bool load_dev(DEVICE *dev)
1138 if (dev->fd() < 0) {
1139 dev->dev_errno = EBADF;
1140 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1141 Emsg0(M_FATAL, 0, dev->errmsg);
1144 if (!(dev->is_tape())) {
1148 Dmsg0(200, "stored: MTLOAD command not available\n");
1150 dev->dev_errno = ENOTTY; /* function not available */
1151 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1152 dev->print_name(), be.bstrerror());
1156 dev->block_num = dev->file = 0;
1159 mt_com.mt_op = MTLOAD;
1160 mt_com.mt_count = 1;
1161 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
1163 dev->dev_errno = errno;
1164 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1165 dev->print_name(), be.bstrerror());
1173 * Rewind device and put it offline
1174 * Returns: true on success
1177 bool DEVICE::offline()
1182 return true; /* device not open */
1185 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1186 block_num = file = 0;
1190 mt_com.mt_op = MTOFFL;
1191 mt_com.mt_count = 1;
1192 if (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
1195 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1196 print_name(), be.bstrerror());
1199 Dmsg1(100, "Offlined device %s\n", print_name());
1203 bool DEVICE::offline_or_rewind()
1208 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1212 * Note, this rewind probably should not be here (it wasn't
1213 * in prior versions of Bacula), but on FreeBSD, this is
1214 * needed in the case the tape was "frozen" due to an error
1215 * such as backspacing after writing and EOF. If it is not
1216 * done, all future references to the drive get and I/O error.
1219 return rewind(NULL);
1224 * Foward space a file
1225 * Returns: true on success
1228 bool DEVICE::fsf(int num)
1230 int32_t os_file = 0;
1236 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1237 Emsg0(M_FATAL, 0, errmsg);
1247 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1251 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1254 Dmsg0(100, "fsf\n");
1257 * If Fast forward space file is set, then we
1258 * use MTFSF to forward space and MTIOCGET
1259 * to get the file position. We assume that
1260 * the SCSI driver will ensure that we do not
1261 * forward space past the end of the medium.
1263 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1265 mt_com.mt_op = MTFSF;
1266 mt_com.mt_count = num;
1267 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1269 my_errno = errno; /* save errno */
1270 } else if ((os_file=get_os_tape_file()) < 0) {
1271 my_errno = errno; /* save errno */
1273 if (my_errno != 0) {
1276 Dmsg0(200, "Set ST_EOT\n");
1278 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1279 print_name(), be.bstrerror(my_errno));
1280 Dmsg1(200, "%s", errmsg);
1284 Dmsg1(200, "fsf file=%d\n", os_file);
1290 * Here if CAP_FSF is set, and virtually all drives
1291 * these days support it, we read a record, then forward
1292 * space one file. Using this procedure, which is slow,
1293 * is the only way we can be sure that we don't read
1294 * two consecutive EOF marks, which means End of Data.
1296 } else if (has_cap(CAP_FSF)) {
1299 Dmsg0(200, "FSF has cap_fsf\n");
1300 if (max_block_size == 0) {
1301 rbuf_len = DEFAULT_BLOCK_SIZE;
1303 rbuf_len = max_block_size;
1305 rbuf = get_memory(rbuf_len);
1306 mt_com.mt_op = MTFSF;
1307 mt_com.mt_count = 1;
1308 while (num-- && !at_eot()) {
1309 Dmsg0(100, "Doing read before fsf\n");
1310 if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1311 if (errno == ENOMEM) { /* tape record exceeds buf len */
1312 stat = rbuf_len; /* This is OK */
1314 * On IBM drives, they return ENOSPC at EOM
1315 * instead of EOF status
1317 } else if (at_eof() && errno == ENOSPC) {
1323 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1325 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1326 print_name(), be.bstrerror());
1327 Dmsg1(100, "%s", errmsg);
1331 if (stat == 0) { /* EOF */
1332 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1333 /* Two reads of zero means end of tape */
1336 Dmsg0(100, "Set ST_EOT\n");
1342 } else { /* Got data */
1347 Dmsg0(100, "Doing MTFSF\n");
1348 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1349 if (stat < 0) { /* error => EOT */
1352 Dmsg0(100, "Set ST_EOT\n");
1354 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1355 print_name(), be.bstrerror());
1356 Dmsg0(100, "Got < 0 for MTFSF\n");
1357 Dmsg1(100, "%s", errmsg);
1365 * No FSF, so use FSR to simulate it
1368 Dmsg0(200, "Doing FSR for FSF\n");
1369 while (num-- && !at_eot()) {
1370 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1374 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1380 Dmsg1(200, "Return %d from FSF\n", stat);
1382 Dmsg0(200, "ST_EOF set on exit FSF\n");
1385 Dmsg0(200, "ST_EOT set on exit FSF\n");
1387 Dmsg1(200, "Return from FSF file=%d\n", file);
1392 * Backward space a file
1393 * Returns: false on failure
1396 bool DEVICE::bsf(int num)
1403 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1404 Emsg0(M_FATAL, 0, errmsg);
1409 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1414 Dmsg0(100, "bsf\n");
1420 mt_com.mt_op = MTBSF;
1421 mt_com.mt_count = num;
1422 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1426 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1427 print_name(), be.bstrerror());
1434 * Foward space num records
1435 * Returns: false on failure
1438 bool DEVICE::fsr(int num)
1445 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1446 Emsg0(M_FATAL, 0, errmsg);
1454 if (!has_cap(CAP_FSR)) {
1455 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1459 Dmsg1(100, "fsr %d\n", num);
1460 mt_com.mt_op = MTFSR;
1461 mt_com.mt_count = num;
1462 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1468 struct mtget mt_stat;
1470 Dmsg1(100, "FSF fail: ERR=%s\n", be.bstrerror());
1471 if (dev_get_os_pos(this, &mt_stat)) {
1472 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1473 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1474 file = mt_stat.mt_fileno;
1475 block_num = mt_stat.mt_blkno;
1483 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1484 num, print_name(), be.bstrerror());
1490 * Backward space a record
1491 * Returns: false on failure
1494 bool DEVICE::bsr(int num)
1501 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1502 Emsg0(M_FATAL, 0, errmsg);
1510 if (!has_cap(CAP_BSR)) {
1511 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1515 Dmsg0(100, "bsr_dev\n");
1519 mt_com.mt_op = MTBSR;
1520 mt_com.mt_count = num;
1521 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1525 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1526 print_name(), be.bstrerror());
1531 void DEVICE::lock_door()
1535 mt_com.mt_op = MTLOCK;
1536 mt_com.mt_count = 1;
1537 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1541 void DEVICE::unlock_door()
1545 mt_com.mt_op = MTUNLOCK;
1546 mt_com.mt_count = 1;
1547 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1553 * Reposition the device to file, block
1554 * Returns: false on failure
1557 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1561 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1562 Emsg0(M_FATAL, 0, errmsg);
1567 boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1568 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1569 if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1572 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1573 print_name(), be.bstrerror());
1582 /* After this point, we are tape only */
1583 Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1585 Dmsg0(100, "Rewind\n");
1586 if (!rewind(NULL)) {
1591 Dmsg1(100, "fsf %d\n", rfile-file);
1592 if (!fsf(rfile-file)) {
1593 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1596 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1598 if (rblock < block_num) {
1599 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1600 Dmsg0(100, "bsf 1\n");
1602 Dmsg0(100, "fsf 1\n");
1604 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1606 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1607 /* Ignore errors as Bacula can read to the correct block */
1608 Dmsg1(100, "fsr %d\n", rblock-block_num);
1609 return fsr(rblock-block_num);
1611 while (rblock > block_num) {
1612 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1615 Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1616 print_name(), be.bstrerror());
1619 Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1628 * Write an end of file on the device
1629 * Returns: true on success
1632 bool DEVICE::weof(int num)
1636 Dmsg0(129, "weof_dev\n");
1640 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1641 Emsg0(M_FATAL, 0, errmsg);
1649 if (!can_append()) {
1650 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1651 Emsg0(M_FATAL, 0, errmsg);
1657 mt_com.mt_op = MTWEOF;
1658 mt_com.mt_count = num;
1659 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1668 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1669 print_name(), be.bstrerror());
1677 * If implemented in system, clear the tape
1680 void DEVICE::clrerror(int func)
1682 const char *msg = NULL;
1685 dev_errno = errno; /* save errno */
1687 VolCatInfo.VolCatErrors++;
1694 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1697 break; /* ignore message printed later */
1700 clear_cap(CAP_EOF); /* turn off feature */
1705 clear_cap(CAP_EOM); /* turn off feature */
1710 clear_cap(CAP_FSF); /* turn off feature */
1714 clear_cap(CAP_BSF); /* turn off feature */
1718 clear_cap(CAP_FSR); /* turn off feature */
1722 clear_cap(CAP_BSR); /* turn off feature */
1732 #ifdef MTSETDRVBUFFER
1733 case MTSETDRVBUFFER:
1734 msg = "MTSETDRVBUFFER";
1767 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1773 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1774 Emsg0(M_ERROR, 0, errmsg);
1779 * Now we try different methods of clearing the error
1780 * status on the drive so that it is not locked for
1781 * further operations.
1784 /* On some systems such as NetBSD, this clears all errors */
1787 /* Found on Solaris */
1790 tape_ioctl(m_fd, MTIOCLRERR);
1791 Dmsg0(200, "Did MTIOCLRERR\n");
1795 /* Typically on FreeBSD */
1799 /* Read and clear SCSI error status */
1800 union mterrstat mt_errstat;
1801 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1802 be.bstrerror(dev_errno));
1803 tape_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1807 /* Clear Subsystem Exception OSF1 */
1811 mt_com.mt_op = MTCSE;
1812 mt_com.mt_count = 1;
1813 /* Clear any error condition on the tape */
1814 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1815 Dmsg0(200, "Did MTCSE\n");
1822 * Clear volume header
1824 void DEVICE::clear_volhdr()
1826 Dmsg1(100, "Clear volhdr vol=%s\n", VolHdr.VolumeName);
1827 memset(&VolHdr, 0, sizeof(VolHdr));
1834 void DEVICE::close()
1836 Dmsg1(100, "close_dev %s\n", print_name());
1837 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1842 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1844 return; /* already closed */
1857 /* Clean up device packet so it can be reused */
1860 * Be careful not to clear items needed by the DVD driver
1861 * when it is closing a single part.
1863 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF|
1864 ST_MOUNTED|ST_MEDIA|ST_SHORT);
1865 label_type = B_BACULA_LABEL;
1866 file = block_num = 0;
1869 EndFile = EndBlock = 0;
1871 Slot = -1; /* unknown slot */
1873 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1875 stop_thread_timer(tid);
1881 * This call closes the device, but it is used in DVD handling
1882 * where we close one part and then open the next part. The
1883 * difference between close_part() and close() is that close_part()
1884 * saves the state information of the device (e.g. the Volume lable,
1885 * the Volume Catalog record, ... This permits opening and closing
1886 * the Volume parts multiple times without losing track of what the
1887 * main Volume parameters are.
1889 void DEVICE::close_part(DCR * /*dcr*/)
1891 VOLUME_LABEL saveVolHdr;
1892 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1895 saveVolHdr = VolHdr; /* structure assignment */
1896 saveVolCatInfo = VolCatInfo; /* structure assignment */
1897 close(); /* close current part */
1898 VolHdr = saveVolHdr; /* structure assignment */
1899 VolCatInfo = saveVolCatInfo; /* structure assignment */
1902 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1906 return lseek_dvd(dcr, offset, whence);
1908 #if defined(HAVE_WIN32)
1909 return ::_lseeki64(m_fd, (__int64)offset, whence);
1911 return ::lseek(m_fd, (off_t)offset, whence);
1918 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1922 Dmsg1(100, "truncate %s\n", print_name());
1926 /* maybe we should rewind and write and eof ???? */
1927 return true; /* we don't really truncate tapes */
1929 return truncate_dvd(dcr);
1931 if (ftruncate(m_fd, 0) != 0) {
1933 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1934 print_name(), be.bstrerror());
1939 * Check for a successful ftruncate() and issue a work-around for devices
1940 * (mostly cheap NAS) that don't support truncation.
1941 * Workaround supplied by Martin Schmid as a solution to bug #1011.
1944 * 3. open new file with same mode
1945 * 4. change ownership to original
1948 if (fstat(m_fd, &st) != 0) {
1950 Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"),
1951 print_name(), be.bstrerror());
1955 if (st.st_size != 0) { /* ftruncate() didn't work */
1956 POOL_MEM archive_name(PM_FNAME);
1958 pm_strcpy(archive_name, dev_name);
1959 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
1960 pm_strcat(archive_name, "/");
1962 pm_strcat(archive_name, dcr->VolumeName);
1964 Mmsg2(errmsg, _("Device %s doesn't support ftruncate(). Recreating file %s.\n"),
1965 print_name(), archive_name.c_str());
1967 /* Close file and blow it away */
1969 ::unlink(archive_name.c_str());
1971 /* Recreate the file -- of course, empty */
1972 set_mode(CREATE_READ_WRITE);
1973 if ((m_fd = ::open(archive_name.c_str(), mode, st.st_mode)) < 0) {
1976 Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), archive_name.c_str(),
1978 Dmsg1(100, "reopen failed: %s", errmsg);
1979 Emsg0(M_FATAL, 0, errmsg);
1983 /* Reset proper owner */
1984 chown(archive_name.c_str(), st.st_uid, st.st_gid);
1992 /* Mount the device.
1993 * If timeout, wait until the mount command returns 0.
1994 * If !timeout, try to mount the device only once.
1996 bool DEVICE::mount(int timeout)
1998 Dmsg0(190, "Enter mount\n");
2001 } else if (requires_mount()) {
2002 return do_mount(1, timeout);
2007 /* Unmount the device
2008 * If timeout, wait until the unmount command returns 0.
2009 * If !timeout, try to unmount the device only once.
2011 bool DEVICE::unmount(int timeout)
2013 Dmsg0(100, "Enter unmount\n");
2015 return do_mount(0, timeout);
2020 /* (Un)mount the device */
2021 bool DEVICE::do_mount(int mount, int dotimeout)
2023 POOL_MEM ocmd(PM_FNAME);
2026 int status, timeout;
2031 Dmsg0(200, "======= mount=1\n");
2034 icmd = device->mount_command;
2036 if (!is_mounted()) {
2037 Dmsg0(200, "======= mount=0\n");
2040 icmd = device->unmount_command;
2043 clear_freespace_ok();
2044 edit_mount_codes(ocmd, icmd);
2046 Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2049 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
2054 results = get_memory(4000);
2056 /* If busy retry each second */
2057 Dmsg1(100, "do_mount run_prog=%s\n", ocmd.c_str());
2058 while ((status = run_program_full_output(ocmd.c_str(),
2059 max_open_wait/2, results)) != 0) {
2060 /* Doesn't work with internationalization (This is not a problem) */
2061 if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2064 if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2067 if (timeout-- > 0) {
2068 /* Sometimes the device cannot be mounted because it is already mounted.
2069 * Try to unmount it, then remount it */
2071 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2079 Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2080 (mount ? "" : "un"), status, results, be.bstrerror(status));
2081 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2082 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2084 Dmsg4(100, "Device %s cannot be %smounted. stat=%d ERR=%s\n", print_name(),
2085 (mount ? "" : "un"), status, results);
2086 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2087 print_name(), (mount ? "" : "un"), results);
2090 * Now, just to be sure it is not mounted, try to read the
2094 struct dirent *entry, *result;
2098 name_max = pathconf(".", _PC_NAME_MAX);
2099 if (name_max < 1024) {
2103 if (!(dp = opendir(device->mount_point))) {
2106 Dmsg3(100, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2107 device->mount_point, print_name(), be.bstrerror());
2111 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2114 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2116 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
2117 device->mount_point, print_name());
2120 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2121 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2124 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2130 Dmsg1(100, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2133 /* If we got more than ., .. and .keep */
2134 /* there must be something mounted */
2136 Dmsg1(100, "Did Mount by count=%d\n", count);
2139 /* An unmount request. We failed to unmount - report an error */
2141 free_pool_memory(results);
2142 Dmsg0(200, "== error mount=1 wanted unmount\n");
2148 free_pool_memory(results);
2149 Dmsg0(200, "============ mount=0\n");
2154 set_mounted(mount); /* set/clear mounted flag */
2155 free_pool_memory(results);
2156 /* Do not check free space when unmounting */
2157 if (mount && !update_freespace()) {
2160 Dmsg1(200, "============ mount=%d\n", mount);
2165 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2167 * %a = archive device name
2168 * %e = erase (set if cannot mount and first part)
2171 * %v = last part name
2173 * omsg = edited output message
2174 * imsg = input string containing edit codes (%x)
2177 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2183 POOL_MEM archive_name(PM_FNAME);
2185 omsg.c_str()[0] = 0;
2186 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2187 for (p=imsg; *p; p++) {
2197 if (num_dvd_parts == 0) {
2198 if (truncating || blank_dvd) {
2208 bsnprintf(add, sizeof(add), "%d", part);
2212 str = device->mount_point;
2215 make_spooled_dvd_filename(this, archive_name);
2216 str = archive_name.c_str();
2230 Dmsg1(1900, "add_str %s\n", str);
2231 pm_strcat(omsg, (char *)str);
2232 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2236 /* return the last timer interval (ms)
2237 * or 0 if something goes wrong
2239 btime_t DEVICE::get_timer_count()
2241 btime_t temp = last_timer;
2242 last_timer = get_current_btime();
2243 temp = last_timer - temp; /* get elapsed time */
2244 return (temp>0)?temp:0; /* take care of skewed clock */
2248 ssize_t DEVICE::read(void *buf, size_t len)
2254 if (this->is_tape()) {
2255 read_len = tape_read(m_fd, buf, len);
2257 read_len = ::read(m_fd, buf, len);
2260 last_tick = get_timer_count();
2262 DevReadTime += last_tick;
2263 VolCatInfo.VolReadTime += last_tick;
2265 if (read_len > 0) { /* skip error */
2266 DevReadBytes += read_len;
2273 ssize_t DEVICE::write(const void *buf, size_t len)
2279 if (this->is_tape()) {
2280 write_len = tape_write(m_fd, buf, len);
2282 write_len = ::write(m_fd, buf, len);
2285 last_tick = get_timer_count();
2287 DevWriteTime += last_tick;
2288 VolCatInfo.VolWriteTime += last_tick;
2290 if (write_len > 0) { /* skip error */
2291 DevWriteBytes += write_len;
2297 /* Return the resource name for the device */
2298 const char *DEVICE::name() const
2300 return device->hdr.name;
2303 /* Returns file position on tape or -1 */
2304 int32_t DEVICE::get_os_tape_file()
2306 struct mtget mt_stat;
2308 if (has_cap(CAP_MTIOCGET) &&
2309 tape_ioctl(m_fd, MTIOCGET, (char *)&mt_stat) == 0) {
2310 return mt_stat.mt_fileno;
2316 dev_vol_name(DEVICE *dev)
2318 return dev->VolCatInfo.VolCatName;
2323 * Free memory allocated for the device
2325 void DEVICE::term(void)
2327 Dmsg1(900, "term dev: %s\n", print_name());
2330 free_memory(dev_name);
2334 free_memory(prt_name);
2338 free_pool_memory(errmsg);
2341 pthread_mutex_destroy(&m_mutex);
2342 pthread_cond_destroy(&wait);
2343 pthread_cond_destroy(&wait_next_vol);
2344 pthread_mutex_destroy(&spool_mutex);
2345 // rwl_destroy(&lock);
2346 if (attached_dcrs) {
2347 delete attached_dcrs;
2348 attached_dcrs = NULL;
2357 * This routine initializes the device wait timers
2359 void init_device_wait_timers(DCR *dcr)
2361 DEVICE *dev = dcr->dev;
2362 JCR *jcr = dcr->jcr;
2364 /* ******FIXME******* put these on config variables */
2365 dev->min_wait = 60 * 60;
2366 dev->max_wait = 24 * 60 * 60;
2367 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2368 dev->wait_sec = dev->min_wait;
2369 dev->rem_wait_sec = dev->wait_sec;
2372 dev->BadVolName[0] = 0;
2374 jcr->min_wait = 60 * 60;
2375 jcr->max_wait = 24 * 60 * 60;
2376 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2377 jcr->wait_sec = jcr->min_wait;
2378 jcr->rem_wait_sec = jcr->wait_sec;
2383 void init_jcr_device_wait_timers(JCR *jcr)
2385 /* ******FIXME******* put these on config variables */
2386 jcr->min_wait = 60 * 60;
2387 jcr->max_wait = 24 * 60 * 60;
2388 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2389 jcr->wait_sec = jcr->min_wait;
2390 jcr->rem_wait_sec = jcr->wait_sec;
2396 * The dev timers are used for waiting on a particular device
2398 * Returns: true if time doubled
2399 * false if max time expired
2401 bool double_dev_wait_time(DEVICE *dev)
2403 dev->wait_sec *= 2; /* double wait time */
2404 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2405 dev->wait_sec = dev->max_wait;
2408 dev->rem_wait_sec = dev->wait_sec;
2409 if (dev->num_wait >= dev->max_num_wait) {
2416 void set_os_device_parameters(DCR *dcr)
2418 DEVICE *dev = dcr->dev;
2420 if (strcmp(dev->dev_name, "/dev/null") == 0) {
2421 return; /* no use trying to set /dev/null */
2424 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2427 Dmsg0(100, "In set_os_device_parameters\n");
2428 #if defined(MTSETBLK)
2429 if (dev->min_block_size == dev->max_block_size &&
2430 dev->min_block_size == 0) { /* variable block mode */
2431 mt_com.mt_op = MTSETBLK;
2432 mt_com.mt_count = 0;
2433 Dmsg0(100, "Set block size to zero\n");
2434 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2435 dev->clrerror(MTSETBLK);
2439 #if defined(MTSETDRVBUFFER)
2440 if (getuid() == 0) { /* Only root can do this */
2441 mt_com.mt_op = MTSETDRVBUFFER;
2442 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2443 if (!dev->has_cap(CAP_TWOEOF)) {
2444 mt_com.mt_count |= MT_ST_TWO_FM;
2446 if (dev->has_cap(CAP_EOM)) {
2447 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2449 Dmsg0(100, "MTSETDRVBUFFER\n");
2450 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2451 dev->clrerror(MTSETDRVBUFFER);
2458 #ifdef HAVE_NETBSD_OS
2460 if (dev->min_block_size == dev->max_block_size &&
2461 dev->min_block_size == 0) { /* variable block mode */
2462 mt_com.mt_op = MTSETBSIZ;
2463 mt_com.mt_count = 0;
2464 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2465 dev->clrerror(MTSETBSIZ);
2467 /* Get notified at logical end of tape */
2468 mt_com.mt_op = MTEWARN;
2469 mt_com.mt_count = 1;
2470 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2471 dev->clrerror(MTEWARN);
2477 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2479 if (dev->min_block_size == dev->max_block_size &&
2480 dev->min_block_size == 0) { /* variable block mode */
2481 mt_com.mt_op = MTSETBSIZ;
2482 mt_com.mt_count = 0;
2483 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2484 dev->clrerror(MTSETBSIZ);
2487 #if defined(MTIOCSETEOTMODEL)
2489 if (dev->has_cap(CAP_TWOEOF)) {
2494 if (tape_ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2496 dev->dev_errno = errno; /* save errno */
2497 Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2498 dev->print_name(), be.bstrerror(dev->dev_errno));
2499 Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2507 if (dev->min_block_size == dev->max_block_size &&
2508 dev->min_block_size == 0) { /* variable block mode */
2509 mt_com.mt_op = MTSRSZ;
2510 mt_com.mt_count = 0;
2511 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2512 dev->clrerror(MTSRSZ);
2519 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2521 Dmsg0(100, "dev_get_os_pos\n");
2522 return dev->has_cap(CAP_MTIOCGET) &&
2523 tape_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2524 mt_stat->mt_fileno >= 0;
2527 static const char *modes[] = {
2528 "CREATE_READ_WRITE",
2535 static const char *mode_to_str(int mode)
2537 static char buf[100];
2538 if (mode < 1 || mode > 4) {
2539 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2542 return modes[mode-1];