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 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;
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());
232 dev->errmsg = get_pool_memory(PM_EMSG);
235 if ((errstat = pthread_mutex_init(&dev->m_mutex, NULL)) != 0) {
237 dev->dev_errno = errstat;
238 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
239 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
241 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
243 dev->dev_errno = errstat;
244 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
245 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
247 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
249 dev->dev_errno = errstat;
250 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
251 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
253 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
255 dev->dev_errno = errstat;
256 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
257 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
260 if ((errstat = rwl_init(&dev->lock)) != 0) {
262 dev->dev_errno = errstat;
263 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
264 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
269 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
270 Dmsg2(100, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
271 dev->initiated = true;
276 /* Choose the right backend */
277 void DEVICE::init_backend()
282 d_open = win32_tape_open;
283 d_write = win32_tape_write;
284 d_close = win32_tape_close;
285 d_ioctl = win32_tape_ioctl;
286 d_read = win32_tape_read;
291 d_ioctl = win32_ioctl; /* dummy function */
292 d_write = win32_write; /* win32 read/write are not POSIX */
296 #else /* POSIX / UNIX Interface */
297 if (is_vtape()) { /* test backend */
298 d_open = vtape_open; /* vtape isn't available for WIN32 or FreeBSD */
299 d_write = vtape_write;
300 d_close = vtape_close;
301 d_ioctl = vtape_ioctl;
304 } else { /* tape and file are using normal io */
315 * Open the device with the operating system and
316 * initialize buffer pointers.
318 * Returns: -1 on error
321 * Note, for a tape, the VolName is the name we give to the
322 * volume (not really used here), but for a file, the
323 * VolName represents the name of the file to be created/opened.
324 * In the case of a file, the full name is the device name
325 * (archive_name) with the VolName concatenated.
328 DEVICE::open(DCR *dcr, int omode)
332 if (openmode == omode) {
337 Dmsg0(100, "Close fd for mode change.\n");
338 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
342 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
345 Dmsg4(100, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
346 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
347 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
348 label_type = B_BACULA_LABEL;
349 if (is_tape() || is_fifo()) {
350 open_tape_device(dcr, omode);
351 } else if (is_dvd()) {
352 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
353 open_dvd_device(dcr, omode);
355 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
356 open_file_device(dcr, omode);
358 state |= preserve; /* reset any important state info */
359 Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, m_fd);
363 void DEVICE::set_mode(int new_mode)
366 case CREATE_READ_WRITE:
367 mode = O_CREAT | O_RDWR | O_BINARY;
369 case OPEN_READ_WRITE:
370 mode = O_RDWR | O_BINARY;
373 mode = O_RDONLY | O_BINARY;
375 case OPEN_WRITE_ONLY:
376 mode = O_WRONLY | O_BINARY;
379 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
385 void DEVICE::open_tape_device(DCR *dcr, int omode)
388 int timeout = max_open_wait;
389 #if !defined(HAVE_WIN32)
391 utime_t start_time = time(NULL);
395 Dmsg0(100, "Open dev: device is tape\n");
397 get_autochanger_loaded_slot(dcr);
406 if (is_fifo() && timeout) {
408 tid = start_thread_timer(dcr->jcr, pthread_self(), timeout);
410 Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
411 #if defined(HAVE_WIN32)
414 if ((m_fd = d_open(dev_name, mode)) < 0) {
421 /* If busy retry each second for max_open_wait seconds */
423 /* Try non-blocking open */
424 m_fd = d_open(dev_name, mode+O_NONBLOCK);
428 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
429 print_name(), omode, mode, errno, be.bstrerror());
431 /* Tape open, now rewind it */
432 Dmsg0(100, "Rewind after open\n");
433 mt_com.mt_op = MTREW;
435 /* rewind only if dev is a tape */
436 if (is_tape() && (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0)) {
438 dev_errno = errno; /* set error status from rewind */
441 Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
442 be.bstrerror(dev_errno));
443 /* If we get busy, device is probably rewinding, try again */
444 if (dev_errno != EBUSY) {
445 break; /* error -- no medium */
448 /* Got fd and rewind worked, so we must have medium in drive */
450 m_fd = d_open(dev_name, mode); /* open normally */
454 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
455 print_name(), omode, mode, errno, be.bstrerror());
460 set_os_device_parameters(dcr); /* do system dependent stuff */
461 break; /* Successfully opened and rewound */
465 /* Exceed wait time ? */
466 if (time(NULL) - start_time >= max_open_wait) {
467 break; /* yes, get out */
474 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
475 print_name(), be.bstrerror(dev_errno));
476 Dmsg1(100, "%s", errmsg);
479 /* Stop any open() timer we started */
481 stop_thread_timer(tid);
484 Dmsg1(100, "open dev: tape %d opened\n", m_fd);
491 void DEVICE::open_file_device(DCR *dcr, int omode)
493 POOL_MEM archive_name(PM_FNAME);
495 get_autochanger_loaded_slot(dcr);
498 * Handle opening of File Archive (not a tape)
501 pm_strcpy(archive_name, dev_name);
503 * If this is a virtual autochanger (i.e. changer_res != NULL)
504 * we simply use the device name, assuming it has been
505 * appropriately setup by the "autochanger".
507 if (!device->changer_res || device->changer_command[0] == 0) {
508 if (VolCatInfo.VolCatName[0] == 0) {
509 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
515 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
516 pm_strcat(archive_name, "/");
518 pm_strcat(archive_name, VolCatInfo.VolCatName);
521 mount(1); /* do mount if required */
525 /* If creating file, give 0640 permissions */
526 Dmsg3(100, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
527 archive_name.c_str(), mode);
528 /* Use system open() */
529 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
532 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
534 Dmsg1(100, "open failed: %s", errmsg);
535 Jmsg1(NULL, M_WARNING, 0, "%s", errmsg);
541 Dmsg4(100, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
542 m_fd, part, num_dvd_parts, part_size);
546 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
547 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
548 * has the desired Volume name, but there is NO assurance that
549 * any other field of VolCatInfo is correct.
551 void DEVICE::open_dvd_device(DCR *dcr, int omode)
553 POOL_MEM archive_name(PM_FNAME);
554 struct stat filestat;
557 * Handle opening of DVD Volume
559 Dmsg2(100, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n",
560 &dcr->VolCatInfo, mode_to_str(omode));
563 * For a DVD we must always pull the state info from dcr->VolCatInfo
564 * This is a bit ugly, but is necessary because we need to open/close/re-open
565 * the dvd file in order to properly mount/unmount and access the
566 * DVD. So we store the state of the DVD as far as is known in the
567 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
568 * copy here, when opening.
570 VolCatInfo = dcr->VolCatInfo; /* structure assignment */
571 Dmsg1(100, "Volume=%s\n", VolCatInfo.VolCatName);
573 if (VolCatInfo.VolCatName[0] == 0) {
574 Dmsg1(10, "Could not open DVD device %s. No Volume name given.\n",
576 Mmsg(errmsg, _("Could not open DVD device %s. No Volume name given.\n"),
583 Dmsg0(100, "Set part=1\n");
584 part = 1; /* count from 1 */
588 if (num_dvd_parts != VolCatInfo.VolCatParts) {
589 num_dvd_parts = VolCatInfo.VolCatParts;
593 * If we are not trying to access the last part, set mode to
594 * OPEN_READ_ONLY as writing would be an error.
596 Dmsg2(100, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
597 /* Now find the name of the part that we want to access */
598 if (part <= num_dvd_parts) {
599 omode = OPEN_READ_ONLY;
600 make_mounted_dvd_filename(this, archive_name);
601 set_part_spooled(false);
603 omode = OPEN_READ_WRITE;
604 make_spooled_dvd_filename(this, archive_name);
605 set_part_spooled(true);
609 // Clear any previous blank_dvd status - we will recalculate it here
612 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
613 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
616 Dmsg0(99, "DVD device mounted.\n");
617 if (num_dvd_parts == 0 && !truncating) {
619 * If we can mount the device, and we are not truncating the DVD,
620 * we usually want to abort. There is one exception, if there is
621 * only one 0-sized file on the DVD, with the right volume name,
622 * we continue (it's the method used by truncate_dvd to truncate a volume).
624 if (!check_can_write_on_non_blank_dvd(dcr)) {
625 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
626 Emsg0(M_FATAL, 0, errmsg);
627 unmount(1); /* Unmount the device, so the operator can change it. */
634 * Ensure that we have the correct DVD loaded by looking for part1.
635 * We only succeed the open if it exists. Failure to do this could
636 * leave us trying to add a part to a different DVD!
638 uint32_t oldpart = part;
640 POOL_MEM part1_name(PM_FNAME);
642 make_mounted_dvd_filename(this, part1_name);
644 if (stat(part1_name.c_str(), &statp) < 0) {
646 Mmsg(errmsg, _("Unable to stat DVD part 1 file %s: ERR=%s\n"),
647 part1_name.c_str(), be.bstrerror());
648 Emsg0(M_FATAL, 0, errmsg);
652 if (!S_ISREG(statp.st_mode)) {
653 /* It is not a regular file */
654 Mmsg(errmsg, _("DVD part 1 is not a regular file %s.\n"),
656 Emsg0(M_FATAL, 0, errmsg);
662 Dmsg0(99, "DVD device mount failed.\n");
663 /* We cannot mount the device */
664 if (num_dvd_parts == 0) {
665 /* Run free space, check there is a media. */
666 if (!update_freespace()) {
667 Emsg0(M_FATAL, 0, errmsg);
672 Dmsg1(100, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
674 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
675 Emsg0(M_FATAL, 0, errmsg);
680 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
681 Emsg0(M_FATAL, 0, errmsg);
687 Dmsg5(100, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
688 archive_name.c_str(), mode_to_str(omode),
689 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
691 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
694 /* If creating file, give 0640 permissions */
695 Dmsg3(100, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
696 archive_name.c_str(), mode);
697 /* Use system open() */
698 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
700 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
702 // Should this be set if we try the create/open below
703 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
704 Dmsg1(100, "open failed: %s", errmsg);
706 /* Previous open failed. See if we can recover */
707 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
708 (part > num_dvd_parts)) {
709 /* If the last part (on spool), doesn't exist when accessing,
710 * create it. In read/write mode a write will be allowed (higher
711 * level software thinks that we are extending a pre-existing
712 * media. Reads for READ_ONLY will report immediately an EOF
713 * Sometimes it is better to finish with an EOF than with an error. */
714 Dmsg1(100, "Creating last part on spool: %s\n", archive_name.c_str());
715 omode = CREATE_READ_WRITE;
716 set_mode(CREATE_READ_WRITE);
717 m_fd = ::open(archive_name.c_str(), mode, 0640);
721 Dmsg1(100, "after open fd=%d\n", m_fd);
723 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
726 /* Get size of file */
727 if (fstat(m_fd, &filestat) < 0) {
730 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
732 Dmsg1(100, "open failed: %s", errmsg);
733 /* Use system close() */
737 part_size = filestat.st_size;
739 update_pos(dcr); /* update position */
747 * Returns: true on success
750 bool DEVICE::rewind(DCR *dcr)
756 Dmsg3(400, "rewind res=%d fd=%d %s\n", num_reserved(), m_fd, print_name());
757 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
758 block_num = file = 0;
762 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
764 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
766 Emsg0(M_ABORT, 0, errmsg);
771 mt_com.mt_op = MTREW;
773 /* If we get an I/O error on rewind, it is probably because
774 * the drive is actually busy. We loop for (about 5 minutes)
775 * retrying every 5 seconds.
777 for (i=max_rewind_wait; ; i -= 5) {
778 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
781 if (i == max_rewind_wait) {
782 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.bstrerror());
785 * This is a gross hack, because if the user has the
786 * device mounted (i.e. open), then uses mtx to load
787 * a tape, the current open file descriptor is invalid.
788 * So, we close the drive and re-open it.
791 int open_mode = openmode;
794 open(dcr, open_mode);
802 if (dev_errno == EIO) {
803 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
807 if (dev_errno == EIO && i > 0) {
808 Dmsg0(200, "Sleeping 5 seconds.\n");
813 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
814 print_name(), be.bstrerror());
819 } else if (is_file() || is_dvd()) {
820 if (lseek(dcr, (boffset_t)0, SEEK_SET) < 0) {
823 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
824 print_name(), be.bstrerror());
833 * Called to indicate that we have just read an
834 * EOF from the device.
836 void DEVICE::set_ateof()
848 * Called to indicate we are now at the end of the tape, and
849 * writing is not possible.
851 void DEVICE::set_ateot()
853 /* Make tape effectively read-only */
854 state |= (ST_EOF|ST_EOT|ST_WEOT);
859 * Position device to end of medium (end of data)
860 * Returns: true on succes
863 bool DEVICE::eod(DCR *dcr)
872 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
876 #if defined (__digital__) && defined (__unix__)
877 return fsf(VolCatInfo.VolCatFiles);
884 clear_eof(); /* remove EOF flag */
885 block_num = file = 0;
892 pos = lseek(dcr, (boffset_t)0, SEEK_END);
893 // Dmsg1(100, "====== Seek to %lld\n", pos);
901 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
902 print_name(), be.bstrerror());
906 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
907 Dmsg0(100,"Using FAST FSF for EOM\n");
908 /* If unknown position, rewind */
909 if (get_os_tape_file() < 0) {
914 mt_com.mt_op = MTFSF;
916 * ***FIXME*** fix code to handle case that INT16_MAX is
919 mt_com.mt_count = INT16_MAX; /* use big positive number */
920 if (mt_com.mt_count < 0) {
921 mt_com.mt_count = INT16_MAX; /* brain damaged system */
925 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
926 if (has_cap(CAP_EOM)) {
927 Dmsg0(100,"Using EOM for EOM\n");
928 mt_com.mt_op = MTEOM;
932 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
934 clrerror(mt_com.mt_op);
935 Dmsg1(50, "ioctl error: %s\n", be.bstrerror());
937 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
938 print_name(), be.bstrerror());
942 os_file = get_os_tape_file();
946 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
947 print_name(), be.bstrerror());
950 Dmsg1(100, "EOD file=%d\n", os_file);
958 * Rewind then use FSF until EOT reached
964 * Move file by file to the end of the tape
967 for (file_num=file; !at_eot(); file_num++) {
968 Dmsg0(200, "eod: doing fsf 1\n");
970 Dmsg0(200, "fsf error.\n");
974 * Avoid infinite loop by ensuring we advance.
976 if (!at_eot() && file_num == (int)file) {
977 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
979 os_file = get_os_tape_file();
981 Dmsg2(100, "Adjust file from %d to %d\n", file_num, os_file);
989 * Some drivers leave us after second EOF when doing
990 * MTEOM, so we must backup so that appending overwrites
993 if (has_cap(CAP_BSFATEOM)) {
994 /* Backup over EOF */
996 /* If BSF worked and fileno is known (not -1), set file */
997 os_file = get_os_tape_file();
999 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , os_file);
1002 file++; /* wing it -- not correct on all OSes */
1005 update_pos(dcr); /* update position */
1007 Dmsg1(200, "EOD dev->file=%d\n", file);
1012 * Set the position of the device -- only for files and DVD
1013 * For other devices, there is no generic way to do it.
1014 * Returns: true on succes
1017 bool DEVICE::update_pos(DCR *dcr)
1024 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
1025 Emsg1(M_FATAL, 0, "%s", errmsg);
1029 /* Find out where we are */
1030 if (is_file() || is_dvd()) {
1033 pos = lseek(dcr, (boffset_t)0, SEEK_CUR);
1037 Pmsg1(000, _("Seek error: ERR=%s\n"), be.bstrerror());
1038 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1039 print_name(), be.bstrerror());
1043 block_num = (uint32_t)pos;
1044 file = (uint32_t)(pos >> 32);
1051 * Return the status of the device. This was meant
1052 * to be a generic routine. Unfortunately, it doesn't
1053 * seem possible (at least I do not know how to do it
1054 * currently), which means that for the moment, this
1055 * routine has very little value.
1059 uint32_t status_dev(DEVICE *dev)
1061 struct mtget mt_stat;
1064 if (dev->state & (ST_EOT | ST_WEOT)) {
1068 if (dev->state & ST_EOF) {
1072 if (dev->is_tape()) {
1074 Pmsg0(-20,_(" Bacula status:"));
1075 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1076 if (dev->d_ioctl(dev->fd(), MTIOCGET, (char *)&mt_stat) < 0) {
1078 dev->dev_errno = errno;
1079 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1080 dev->print_name(), be.bstrerror());
1083 Pmsg0(-20, _(" Device status:"));
1085 #if defined(HAVE_LINUX_OS)
1086 if (GMT_EOF(mt_stat.mt_gstat)) {
1090 if (GMT_BOT(mt_stat.mt_gstat)) {
1094 if (GMT_EOT(mt_stat.mt_gstat)) {
1098 if (GMT_SM(mt_stat.mt_gstat)) {
1102 if (GMT_EOD(mt_stat.mt_gstat)) {
1106 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1107 stat |= BMT_WR_PROT;
1108 Pmsg0(-20, " WR_PROT");
1110 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1112 Pmsg0(-20, " ONLINE");
1114 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1115 stat |= BMT_DR_OPEN;
1116 Pmsg0(-20, " DR_OPEN");
1118 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1119 stat |= BMT_IM_REP_EN;
1120 Pmsg0(-20, " IM_REP_EN");
1122 #elif defined(HAVE_WIN32)
1123 if (GMT_EOF(mt_stat.mt_gstat)) {
1127 if (GMT_BOT(mt_stat.mt_gstat)) {
1131 if (GMT_EOT(mt_stat.mt_gstat)) {
1135 if (GMT_EOD(mt_stat.mt_gstat)) {
1139 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1140 stat |= BMT_WR_PROT;
1141 Pmsg0(-20, " WR_PROT");
1143 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1145 Pmsg0(-20, " ONLINE");
1147 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1148 stat |= BMT_DR_OPEN;
1149 Pmsg0(-20, " DR_OPEN");
1151 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1152 stat |= BMT_IM_REP_EN;
1153 Pmsg0(-20, " IM_REP_EN");
1156 #endif /* !SunOS && !OSF */
1157 if (dev->has_cap(CAP_MTIOCGET)) {
1158 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1160 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1163 stat |= BMT_ONLINE | BMT_BOT;
1170 * Load medium in device
1171 * Returns: true on success
1174 bool load_dev(DEVICE *dev)
1180 if (dev->fd() < 0) {
1181 dev->dev_errno = EBADF;
1182 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1183 Emsg0(M_FATAL, 0, dev->errmsg);
1186 if (!(dev->is_tape())) {
1190 Dmsg0(200, "stored: MTLOAD command not available\n");
1192 dev->dev_errno = ENOTTY; /* function not available */
1193 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1194 dev->print_name(), be.bstrerror());
1198 dev->block_num = dev->file = 0;
1201 mt_com.mt_op = MTLOAD;
1202 mt_com.mt_count = 1;
1203 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
1205 dev->dev_errno = errno;
1206 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1207 dev->print_name(), be.bstrerror());
1215 * Rewind device and put it offline
1216 * Returns: true on success
1219 bool DEVICE::offline()
1224 return true; /* device not open */
1227 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1228 block_num = file = 0;
1232 mt_com.mt_op = MTOFFL;
1233 mt_com.mt_count = 1;
1234 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
1237 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1238 print_name(), be.bstrerror());
1241 Dmsg1(100, "Offlined device %s\n", print_name());
1245 bool DEVICE::offline_or_rewind()
1250 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1254 * Note, this rewind probably should not be here (it wasn't
1255 * in prior versions of Bacula), but on FreeBSD, this is
1256 * needed in the case the tape was "frozen" due to an error
1257 * such as backspacing after writing and EOF. If it is not
1258 * done, all future references to the drive get and I/O error.
1261 return rewind(NULL);
1266 * Foward space a file
1267 * Returns: true on success
1270 bool DEVICE::fsf(int num)
1272 int32_t os_file = 0;
1278 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1279 Emsg0(M_FATAL, 0, errmsg);
1289 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1293 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1296 Dmsg0(100, "fsf\n");
1299 * If Fast forward space file is set, then we
1300 * use MTFSF to forward space and MTIOCGET
1301 * to get the file position. We assume that
1302 * the SCSI driver will ensure that we do not
1303 * forward space past the end of the medium.
1305 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1307 mt_com.mt_op = MTFSF;
1308 mt_com.mt_count = num;
1309 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1311 my_errno = errno; /* save errno */
1312 } else if ((os_file=get_os_tape_file()) < 0) {
1313 my_errno = errno; /* save errno */
1315 if (my_errno != 0) {
1318 Dmsg0(200, "Set ST_EOT\n");
1320 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1321 print_name(), be.bstrerror(my_errno));
1322 Dmsg1(200, "%s", errmsg);
1326 Dmsg1(200, "fsf file=%d\n", os_file);
1332 * Here if CAP_FSF is set, and virtually all drives
1333 * these days support it, we read a record, then forward
1334 * space one file. Using this procedure, which is slow,
1335 * is the only way we can be sure that we don't read
1336 * two consecutive EOF marks, which means End of Data.
1338 } else if (has_cap(CAP_FSF)) {
1341 Dmsg0(200, "FSF has cap_fsf\n");
1342 if (max_block_size == 0) {
1343 rbuf_len = DEFAULT_BLOCK_SIZE;
1345 rbuf_len = max_block_size;
1347 rbuf = get_memory(rbuf_len);
1348 mt_com.mt_op = MTFSF;
1349 mt_com.mt_count = 1;
1350 while (num-- && !at_eot()) {
1351 Dmsg0(100, "Doing read before fsf\n");
1352 if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1353 if (errno == ENOMEM) { /* tape record exceeds buf len */
1354 stat = rbuf_len; /* This is OK */
1356 * On IBM drives, they return ENOSPC at EOM
1357 * instead of EOF status
1359 } else if (at_eof() && errno == ENOSPC) {
1365 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1367 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1368 print_name(), be.bstrerror());
1369 Dmsg1(100, "%s", errmsg);
1373 if (stat == 0) { /* EOF */
1374 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1375 /* Two reads of zero means end of tape */
1378 Dmsg0(100, "Set ST_EOT\n");
1384 } else { /* Got data */
1389 Dmsg0(100, "Doing MTFSF\n");
1390 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1391 if (stat < 0) { /* error => EOT */
1394 Dmsg0(100, "Set ST_EOT\n");
1396 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1397 print_name(), be.bstrerror());
1398 Dmsg0(100, "Got < 0 for MTFSF\n");
1399 Dmsg1(100, "%s", errmsg);
1407 * No FSF, so use FSR to simulate it
1410 Dmsg0(200, "Doing FSR for FSF\n");
1411 while (num-- && !at_eot()) {
1412 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1416 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1422 Dmsg1(200, "Return %d from FSF\n", stat);
1424 Dmsg0(200, "ST_EOF set on exit FSF\n");
1427 Dmsg0(200, "ST_EOT set on exit FSF\n");
1429 Dmsg1(200, "Return from FSF file=%d\n", file);
1434 * Backward space a file
1435 * Returns: false on failure
1438 bool DEVICE::bsf(int num)
1445 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1446 Emsg0(M_FATAL, 0, errmsg);
1451 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1456 Dmsg0(100, "bsf\n");
1462 mt_com.mt_op = MTBSF;
1463 mt_com.mt_count = num;
1464 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1468 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1469 print_name(), be.bstrerror());
1476 * Foward space num records
1477 * Returns: false on failure
1480 bool DEVICE::fsr(int num)
1487 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1488 Emsg0(M_FATAL, 0, errmsg);
1496 if (!has_cap(CAP_FSR)) {
1497 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1501 Dmsg1(100, "fsr %d\n", num);
1502 mt_com.mt_op = MTFSR;
1503 mt_com.mt_count = num;
1504 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1510 struct mtget mt_stat;
1512 Dmsg1(100, "FSF fail: ERR=%s\n", be.bstrerror());
1513 if (dev_get_os_pos(this, &mt_stat)) {
1514 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1515 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1516 file = mt_stat.mt_fileno;
1517 block_num = mt_stat.mt_blkno;
1525 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1526 num, print_name(), be.bstrerror());
1532 * Backward space a record
1533 * Returns: false on failure
1536 bool DEVICE::bsr(int num)
1543 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1544 Emsg0(M_FATAL, 0, errmsg);
1552 if (!has_cap(CAP_BSR)) {
1553 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1557 Dmsg0(100, "bsr_dev\n");
1561 mt_com.mt_op = MTBSR;
1562 mt_com.mt_count = num;
1563 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1567 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1568 print_name(), be.bstrerror());
1573 void DEVICE::lock_door()
1577 mt_com.mt_op = MTLOCK;
1578 mt_com.mt_count = 1;
1579 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1583 void DEVICE::unlock_door()
1587 mt_com.mt_op = MTUNLOCK;
1588 mt_com.mt_count = 1;
1589 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1593 void DEVICE::set_slot(int32_t slot)
1596 if (vol) vol->clear_slot();
1599 void DEVICE::clear_slot()
1602 if (vol) vol->set_slot(-1);
1608 * Reposition the device to file, block
1609 * Returns: false on failure
1612 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1616 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1617 Emsg0(M_FATAL, 0, errmsg);
1622 boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1623 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1624 if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1627 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1628 print_name(), be.bstrerror());
1637 /* After this point, we are tape only */
1638 Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1640 Dmsg0(100, "Rewind\n");
1641 if (!rewind(NULL)) {
1646 Dmsg1(100, "fsf %d\n", rfile-file);
1647 if (!fsf(rfile-file)) {
1648 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1651 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1653 if (rblock < block_num) {
1654 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1655 Dmsg0(100, "bsf 1\n");
1657 Dmsg0(100, "fsf 1\n");
1659 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1661 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1662 /* Ignore errors as Bacula can read to the correct block */
1663 Dmsg1(100, "fsr %d\n", rblock-block_num);
1664 return fsr(rblock-block_num);
1666 while (rblock > block_num) {
1667 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1670 Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1671 print_name(), be.bstrerror());
1674 Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1683 * Write an end of file on the device
1684 * Returns: true on success
1687 bool DEVICE::weof(int num)
1691 Dmsg1(129, "=== weof_dev=%s\n", print_name());
1695 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1696 Emsg0(M_FATAL, 0, errmsg);
1704 if (!can_append()) {
1705 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1706 Emsg0(M_FATAL, 0, errmsg);
1712 mt_com.mt_op = MTWEOF;
1713 mt_com.mt_count = num;
1714 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1723 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1724 print_name(), be.bstrerror());
1732 * If implemented in system, clear the tape
1735 void DEVICE::clrerror(int func)
1737 const char *msg = NULL;
1740 dev_errno = errno; /* save errno */
1742 VolCatInfo.VolCatErrors++;
1749 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1752 break; /* ignore message printed later */
1755 clear_cap(CAP_EOF); /* turn off feature */
1760 clear_cap(CAP_EOM); /* turn off feature */
1765 clear_cap(CAP_FSF); /* turn off feature */
1769 clear_cap(CAP_BSF); /* turn off feature */
1773 clear_cap(CAP_FSR); /* turn off feature */
1777 clear_cap(CAP_BSR); /* turn off feature */
1787 #ifdef MTSETDRVBUFFER
1788 case MTSETDRVBUFFER:
1789 msg = "MTSETDRVBUFFER";
1822 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1828 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1829 Emsg0(M_ERROR, 0, errmsg);
1834 * Now we try different methods of clearing the error
1835 * status on the drive so that it is not locked for
1836 * further operations.
1839 /* On some systems such as NetBSD, this clears all errors */
1842 /* Found on Solaris */
1845 d_ioctl(m_fd, MTIOCLRERR);
1846 Dmsg0(200, "Did MTIOCLRERR\n");
1850 /* Typically on FreeBSD */
1854 /* Read and clear SCSI error status */
1855 union mterrstat mt_errstat;
1856 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1857 be.bstrerror(dev_errno));
1858 d_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1862 /* Clear Subsystem Exception OSF1 */
1866 mt_com.mt_op = MTCSE;
1867 mt_com.mt_count = 1;
1868 /* Clear any error condition on the tape */
1869 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1870 Dmsg0(200, "Did MTCSE\n");
1877 * Set to unload the current volume in the drive
1879 void DEVICE::set_unload()
1881 if (!m_unload && VolHdr.VolumeName[0] != 0) {
1883 memcpy(UnloadVolName, VolHdr.VolumeName, sizeof(UnloadVolName));
1889 * Clear volume header
1891 void DEVICE::clear_volhdr()
1893 Dmsg1(100, "Clear volhdr vol=%s\n", VolHdr.VolumeName);
1894 memset(&VolHdr, 0, sizeof(VolHdr));
1901 void DEVICE::close()
1903 Dmsg1(100, "close_dev %s\n", print_name());
1904 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1909 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1911 return; /* already closed */
1923 /* Clean up device packet so it can be reused */
1926 * Be careful not to clear items needed by the DVD driver
1927 * when it is closing a single part.
1929 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF|
1930 ST_MOUNTED|ST_MEDIA|ST_SHORT);
1931 label_type = B_BACULA_LABEL;
1932 file = block_num = 0;
1935 EndFile = EndBlock = 0;
1938 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1940 stop_thread_timer(tid);
1946 * This call closes the device, but it is used in DVD handling
1947 * where we close one part and then open the next part. The
1948 * difference between close_part() and close() is that close_part()
1949 * saves the state information of the device (e.g. the Volume lable,
1950 * the Volume Catalog record, ... This permits opening and closing
1951 * the Volume parts multiple times without losing track of what the
1952 * main Volume parameters are.
1954 void DEVICE::close_part(DCR * /*dcr*/)
1956 VOLUME_LABEL saveVolHdr;
1957 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1960 saveVolHdr = VolHdr; /* structure assignment */
1961 saveVolCatInfo = VolCatInfo; /* structure assignment */
1962 close(); /* close current part */
1963 VolHdr = saveVolHdr; /* structure assignment */
1964 VolCatInfo = saveVolCatInfo; /* structure assignment */
1967 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1971 return lseek_dvd(dcr, offset, whence);
1973 #if defined(HAVE_WIN32)
1974 return ::_lseeki64(m_fd, (__int64)offset, whence);
1976 return ::lseek(m_fd, offset, whence);
1983 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1987 Dmsg1(100, "truncate %s\n", print_name());
1992 /* maybe we should rewind and write and eof ???? */
1993 return true; /* we don't really truncate tapes */
1995 return truncate_dvd(dcr);
1997 if (ftruncate(m_fd, 0) != 0) {
1999 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
2000 print_name(), be.bstrerror());
2005 * Check for a successful ftruncate() and issue a work-around for devices
2006 * (mostly cheap NAS) that don't support truncation.
2007 * Workaround supplied by Martin Schmid as a solution to bug #1011.
2010 * 3. open new file with same mode
2011 * 4. change ownership to original
2014 if (fstat(m_fd, &st) != 0) {
2016 Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"),
2017 print_name(), be.bstrerror());
2021 if (st.st_size != 0) { /* ftruncate() didn't work */
2022 POOL_MEM archive_name(PM_FNAME);
2024 pm_strcpy(archive_name, dev_name);
2025 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
2026 pm_strcat(archive_name, "/");
2028 pm_strcat(archive_name, dcr->VolumeName);
2030 Mmsg2(errmsg, _("Device %s doesn't support ftruncate(). Recreating file %s.\n"),
2031 print_name(), archive_name.c_str());
2033 /* Close file and blow it away */
2035 ::unlink(archive_name.c_str());
2037 /* Recreate the file -- of course, empty */
2038 set_mode(CREATE_READ_WRITE);
2039 if ((m_fd = ::open(archive_name.c_str(), mode, st.st_mode)) < 0) {
2042 Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), archive_name.c_str(),
2044 Dmsg1(100, "reopen failed: %s", errmsg);
2045 Emsg0(M_FATAL, 0, errmsg);
2049 /* Reset proper owner */
2050 chown(archive_name.c_str(), st.st_uid, st.st_gid);
2058 /* Mount the device.
2059 * If timeout, wait until the mount command returns 0.
2060 * If !timeout, try to mount the device only once.
2062 bool DEVICE::mount(int timeout)
2064 Dmsg0(190, "Enter mount\n");
2067 } else if (requires_mount()) {
2068 return do_mount(1, timeout);
2073 /* Unmount the device
2074 * If timeout, wait until the unmount command returns 0.
2075 * If !timeout, try to unmount the device only once.
2077 bool DEVICE::unmount(int timeout)
2079 Dmsg0(100, "Enter unmount\n");
2081 return do_mount(0, timeout);
2086 /* (Un)mount the device */
2087 bool DEVICE::do_mount(int mount, int dotimeout)
2089 POOL_MEM ocmd(PM_FNAME);
2092 int status, timeout;
2097 Dmsg0(200, "======= mount=1\n");
2100 icmd = device->mount_command;
2102 if (!is_mounted()) {
2103 Dmsg0(200, "======= mount=0\n");
2106 icmd = device->unmount_command;
2109 clear_freespace_ok();
2110 edit_mount_codes(ocmd, icmd);
2112 Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2115 /* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
2120 results = get_memory(4000);
2122 /* If busy retry each second */
2123 Dmsg1(100, "do_mount run_prog=%s\n", ocmd.c_str());
2124 while ((status = run_program_full_output(ocmd.c_str(),
2125 max_open_wait/2, results)) != 0) {
2126 /* Doesn't work with internationalization (This is not a problem) */
2127 if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2130 if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2133 if (timeout-- > 0) {
2134 /* Sometimes the device cannot be mounted because it is already mounted.
2135 * Try to unmount it, then remount it */
2137 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2145 Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2146 (mount ? "" : "un"), status, results, be.bstrerror(status));
2147 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2148 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2150 Dmsg4(100, "Device %s cannot be %smounted. stat=%d ERR=%s\n", print_name(),
2151 (mount ? "" : "un"), status, results);
2152 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2153 print_name(), (mount ? "" : "un"), results);
2156 * Now, just to be sure it is not mounted, try to read the
2160 struct dirent *entry, *result;
2164 name_max = pathconf(".", _PC_NAME_MAX);
2165 if (name_max < 1024) {
2169 if (!(dp = opendir(device->mount_point))) {
2172 Dmsg3(100, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2173 device->mount_point, print_name(), be.bstrerror());
2177 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2180 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2182 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
2183 device->mount_point, print_name());
2186 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2187 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2190 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2196 Dmsg1(100, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2199 /* If we got more than ., .. and .keep */
2200 /* there must be something mounted */
2202 Dmsg1(100, "Did Mount by count=%d\n", count);
2205 /* An unmount request. We failed to unmount - report an error */
2207 free_pool_memory(results);
2208 Dmsg0(200, "== error mount=1 wanted unmount\n");
2214 free_pool_memory(results);
2215 Dmsg0(200, "============ mount=0\n");
2220 set_mounted(mount); /* set/clear mounted flag */
2221 free_pool_memory(results);
2222 /* Do not check free space when unmounting */
2223 if (mount && !update_freespace()) {
2226 Dmsg1(200, "============ mount=%d\n", mount);
2231 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2233 * %a = archive device name
2234 * %e = erase (set if cannot mount and first part)
2237 * %v = last part name
2239 * omsg = edited output message
2240 * imsg = input string containing edit codes (%x)
2243 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2249 POOL_MEM archive_name(PM_FNAME);
2251 omsg.c_str()[0] = 0;
2252 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2253 for (p=imsg; *p; p++) {
2263 if (num_dvd_parts == 0) {
2264 if (truncating || blank_dvd) {
2274 bsnprintf(add, sizeof(add), "%d", part);
2278 str = device->mount_point;
2281 make_spooled_dvd_filename(this, archive_name);
2282 str = archive_name.c_str();
2296 Dmsg1(1900, "add_str %s\n", str);
2297 pm_strcat(omsg, (char *)str);
2298 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2302 /* return the last timer interval (ms)
2303 * or 0 if something goes wrong
2305 btime_t DEVICE::get_timer_count()
2307 btime_t temp = last_timer;
2308 last_timer = get_current_btime();
2309 temp = last_timer - temp; /* get elapsed time */
2310 return (temp>0)?temp:0; /* take care of skewed clock */
2314 ssize_t DEVICE::read(void *buf, size_t len)
2320 read_len = d_read(m_fd, buf, len);
2322 last_tick = get_timer_count();
2324 DevReadTime += last_tick;
2325 VolCatInfo.VolReadTime += last_tick;
2327 if (read_len > 0) { /* skip error */
2328 DevReadBytes += read_len;
2335 ssize_t DEVICE::write(const void *buf, size_t len)
2341 write_len = d_write(m_fd, buf, len);
2343 last_tick = get_timer_count();
2345 DevWriteTime += last_tick;
2346 VolCatInfo.VolWriteTime += last_tick;
2348 if (write_len > 0) { /* skip error */
2349 DevWriteBytes += write_len;
2355 /* Return the resource name for the device */
2356 const char *DEVICE::name() const
2358 return device->hdr.name;
2361 /* Returns file position on tape or -1 */
2362 int32_t DEVICE::get_os_tape_file()
2364 struct mtget mt_stat;
2366 if (has_cap(CAP_MTIOCGET) &&
2367 d_ioctl(m_fd, MTIOCGET, (char *)&mt_stat) == 0) {
2368 return mt_stat.mt_fileno;
2374 dev_vol_name(DEVICE *dev)
2376 return dev->VolCatInfo.VolCatName;
2381 * Free memory allocated for the device
2383 void DEVICE::term(void)
2385 Dmsg1(900, "term dev: %s\n", print_name());
2388 free_memory(dev_name);
2392 free_memory(prt_name);
2396 free_pool_memory(errmsg);
2399 pthread_mutex_destroy(&m_mutex);
2400 pthread_cond_destroy(&wait);
2401 pthread_cond_destroy(&wait_next_vol);
2402 pthread_mutex_destroy(&spool_mutex);
2403 // rwl_destroy(&lock);
2404 if (attached_dcrs) {
2405 delete attached_dcrs;
2406 attached_dcrs = NULL;
2415 * This routine initializes the device wait timers
2417 void init_device_wait_timers(DCR *dcr)
2419 DEVICE *dev = dcr->dev;
2420 JCR *jcr = dcr->jcr;
2422 /* ******FIXME******* put these on config variables */
2423 dev->min_wait = 60 * 60;
2424 dev->max_wait = 24 * 60 * 60;
2425 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2426 dev->wait_sec = dev->min_wait;
2427 dev->rem_wait_sec = dev->wait_sec;
2431 jcr->min_wait = 60 * 60;
2432 jcr->max_wait = 24 * 60 * 60;
2433 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2434 jcr->wait_sec = jcr->min_wait;
2435 jcr->rem_wait_sec = jcr->wait_sec;
2440 void init_jcr_device_wait_timers(JCR *jcr)
2442 /* ******FIXME******* put these on config variables */
2443 jcr->min_wait = 60 * 60;
2444 jcr->max_wait = 24 * 60 * 60;
2445 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2446 jcr->wait_sec = jcr->min_wait;
2447 jcr->rem_wait_sec = jcr->wait_sec;
2453 * The dev timers are used for waiting on a particular device
2455 * Returns: true if time doubled
2456 * false if max time expired
2458 bool double_dev_wait_time(DEVICE *dev)
2460 dev->wait_sec *= 2; /* double wait time */
2461 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2462 dev->wait_sec = dev->max_wait;
2465 dev->rem_wait_sec = dev->wait_sec;
2466 if (dev->num_wait >= dev->max_num_wait) {
2473 void set_os_device_parameters(DCR *dcr)
2475 DEVICE *dev = dcr->dev;
2477 if (strcmp(dev->dev_name, "/dev/null") == 0) {
2478 return; /* no use trying to set /dev/null */
2481 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2484 Dmsg0(100, "In set_os_device_parameters\n");
2485 #if defined(MTSETBLK)
2486 if (dev->min_block_size == dev->max_block_size &&
2487 dev->min_block_size == 0) { /* variable block mode */
2488 mt_com.mt_op = MTSETBLK;
2489 mt_com.mt_count = 0;
2490 Dmsg0(100, "Set block size to zero\n");
2491 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2492 dev->clrerror(MTSETBLK);
2496 #if defined(MTSETDRVBUFFER)
2497 if (getuid() == 0) { /* Only root can do this */
2498 mt_com.mt_op = MTSETDRVBUFFER;
2499 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2500 if (!dev->has_cap(CAP_TWOEOF)) {
2501 mt_com.mt_count |= MT_ST_TWO_FM;
2503 if (dev->has_cap(CAP_EOM)) {
2504 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2506 Dmsg0(100, "MTSETDRVBUFFER\n");
2507 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2508 dev->clrerror(MTSETDRVBUFFER);
2515 #ifdef HAVE_NETBSD_OS
2517 if (dev->min_block_size == dev->max_block_size &&
2518 dev->min_block_size == 0) { /* variable block mode */
2519 mt_com.mt_op = MTSETBSIZ;
2520 mt_com.mt_count = 0;
2521 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2522 dev->clrerror(MTSETBSIZ);
2524 /* Get notified at logical end of tape */
2525 mt_com.mt_op = MTEWARN;
2526 mt_com.mt_count = 1;
2527 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2528 dev->clrerror(MTEWARN);
2534 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2536 if (dev->min_block_size == dev->max_block_size &&
2537 dev->min_block_size == 0) { /* variable block mode */
2538 mt_com.mt_op = MTSETBSIZ;
2539 mt_com.mt_count = 0;
2540 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2541 dev->clrerror(MTSETBSIZ);
2544 #if defined(MTIOCSETEOTMODEL)
2546 if (dev->has_cap(CAP_TWOEOF)) {
2551 if (dev->d_ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2553 dev->dev_errno = errno; /* save errno */
2554 Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2555 dev->print_name(), be.bstrerror(dev->dev_errno));
2556 Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2564 if (dev->min_block_size == dev->max_block_size &&
2565 dev->min_block_size == 0) { /* variable block mode */
2566 mt_com.mt_op = MTSRSZ;
2567 mt_com.mt_count = 0;
2568 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2569 dev->clrerror(MTSRSZ);
2576 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2578 Dmsg0(100, "dev_get_os_pos\n");
2579 return dev->has_cap(CAP_MTIOCGET) &&
2580 dev->d_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2581 mt_stat->mt_fileno >= 0;
2584 static const char *modes[] = {
2585 "CREATE_READ_WRITE",
2592 static const char *mode_to_str(int mode)
2594 static char buf[100];
2595 if (mode < 1 || mode > 4) {
2596 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2599 return modes[mode-1];