2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2007 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 plus additions
11 that are listed in the file LICENSE.
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.
50 * Unfortunately, I have had to add more and more complication
51 * to this code. This was not foreseen as noted above, and as
52 * a consequence has lead to something more contorted than is
53 * really necessary -- KES. Note, this contortion has been
54 * corrected to a large extent by a rewrite (Apr MMI).
60 * Handling I/O errors and end of tape conditions are a bit tricky.
61 * This is how it is currently done when writting.
62 * On either an I/O error or end of tape,
63 * we will stop writing on the physical device (no I/O recovery is
64 * attempted at least in this daemon). The state flag will be sent
65 * to include ST_EOT, which is ephemeral, and ST_WEOT, which is
66 * persistent. Lots of routines clear ST_EOT, but ST_WEOT is
67 * cleared only when the problem goes away. Now when ST_WEOT
68 * is set all calls to write_block_to_device() call the fix_up
69 * routine. In addition, all threads are blocked
70 * from writing on the tape by calling lock_dev(), and thread other
71 * than the first thread to hit the EOT will block on a condition
72 * variable. The first thread to hit the EOT will continue to
73 * be able to read and write the tape (he sort of tunnels through
74 * the locking mechanism -- see lock_dev() for details).
76 * Now presumably somewhere higher in the chain of command
77 * (device.c), someone will notice the EOT condition and
78 * get a new tape up, get the tape label read, and mark
79 * the label for rewriting. Then this higher level routine
80 * will write the unwritten buffer to the new volume.
81 * Finally, he will release
82 * any blocked threads by doing a broadcast on the condition
83 * variable. At that point, we should be totally back in
84 * business with no lost data.
95 /* Forward referenced functions */
96 void set_os_device_parameters(DCR *dcr);
97 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat);
98 static char *mode_to_str(int mode);
101 * Allocate and initialize the DEVICE structure
102 * Note, if dev is non-NULL, it is already allocated,
103 * thus we neither allocate it nor free it. This allows
104 * the caller to put the packet in shared memory.
106 * Note, for a tape, the device->device_name is the device name
107 * (e.g. /dev/nst0), and for a file, the device name
108 * is the directory in which the file will be placed.
112 init_dev(JCR *jcr, DEVRES *device)
120 /* If no device type specified, try to guess */
121 if (!device->dev_type) {
122 /* Check that device is available */
123 if (stat(device->device_name, &statp) < 0) {
125 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
126 device->device_name, be.bstrerror());
129 if (S_ISDIR(statp.st_mode)) {
130 device->dev_type = B_FILE_DEV;
131 } else if (S_ISCHR(statp.st_mode)) {
132 device->dev_type = B_TAPE_DEV;
133 } else if (S_ISFIFO(statp.st_mode)) {
134 device->dev_type = B_FIFO_DEV;
135 } else if (!(device->cap_bits & CAP_REQMOUNT)) {
136 Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
137 " or have RequiresMount=yes for DVD. st_mode=%x\n"),
138 device->device_name, statp.st_mode);
141 device->dev_type = B_DVD_DEV;
145 dev = (DEVICE *)malloc(sizeof(DEVICE));
146 memset(dev, 0, sizeof(DEVICE));
147 dev->Slot = -1; /* unknown */
149 /* Copy user supplied device parameters from Resource */
150 dev->dev_name = get_memory(strlen(device->device_name)+1);
151 pm_strcpy(dev->dev_name, device->device_name);
152 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
153 /* We edit "Resource-name" (physical-name) */
154 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
155 Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
156 dev->capabilities = device->cap_bits;
157 dev->min_block_size = device->min_block_size;
158 dev->max_block_size = device->max_block_size;
159 dev->max_volume_size = device->max_volume_size;
160 dev->max_file_size = device->max_file_size;
161 dev->volume_capacity = device->volume_capacity;
162 dev->max_rewind_wait = device->max_rewind_wait;
163 dev->max_open_wait = device->max_open_wait;
164 dev->max_open_vols = device->max_open_vols;
165 dev->vol_poll_interval = device->vol_poll_interval;
166 dev->max_spool_size = device->max_spool_size;
167 dev->drive_index = device->drive_index;
168 dev->autoselect = device->autoselect;
169 dev->dev_type = device->dev_type;
170 if (dev->is_tape()) { /* No parts on tapes */
171 dev->max_part_size = 0;
173 dev->max_part_size = device->max_part_size;
176 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
177 dev->vol_poll_interval = 60;
179 /* Link the dev and device structures together */
180 dev->device = device;
183 if (dev->is_fifo()) {
184 dev->capabilities |= CAP_STREAM; /* set stream device */
187 /* If the device requires mount :
188 * - Check that the mount point is available
189 * - Check that (un)mount commands are defined
191 if ((dev->is_file() || dev->is_dvd()) && dev->requires_mount()) {
192 if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
194 dev->dev_errno = errno;
195 Jmsg2(jcr, M_ERROR_TERM, 0, _("Unable to stat mount point %s: ERR=%s\n"),
196 device->mount_point, be.bstrerror());
200 if (!device->mount_command || !device->unmount_command) {
201 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
203 if (!device->write_part_command) {
204 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
208 if (dev->max_block_size > 1000000) {
209 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
210 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
211 dev->max_block_size = 0;
213 if (dev->max_block_size % TAPE_BSIZE != 0) {
214 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
215 dev->max_block_size, dev->print_name());
218 dev->errmsg = get_pool_memory(PM_EMSG);
221 if ((errstat = pthread_mutex_init(&dev->m_mutex, NULL)) != 0) {
223 dev->dev_errno = errstat;
224 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
225 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
227 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
229 dev->dev_errno = errstat;
230 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
231 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
233 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
235 dev->dev_errno = errstat;
236 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
237 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
239 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
241 dev->dev_errno = errstat;
242 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
243 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
246 if ((errstat = rwl_init(&dev->lock)) != 0) {
248 dev->dev_errno = errstat;
249 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
250 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
255 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
256 Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
257 dev->initiated = true;
263 * Open the device with the operating system and
264 * initialize buffer pointers.
266 * Returns: -1 on error
269 * Note, for a tape, the VolName is the name we give to the
270 * volume (not really used here), but for a file, the
271 * VolName represents the name of the file to be created/opened.
272 * In the case of a file, the full name is the device name
273 * (archive_name) with the VolName concatenated.
276 DEVICE::open(DCR *dcr, int omode)
280 if (openmode == omode) {
289 Dmsg0(100, "Close fd for mode change.\n");
290 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
294 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
297 Dmsg4(29, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
298 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
299 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
300 Slot = -1; /* unknown slot */
301 label_type = B_BACULA_LABEL;
302 if (is_tape() || is_fifo()) {
303 open_tape_device(dcr, omode);
304 } else if (is_dvd()) {
305 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
306 open_dvd_device(dcr, omode);
308 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
309 open_file_device(dcr, omode);
311 state |= preserve; /* reset any important state info */
312 Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, m_fd);
316 void DEVICE::set_mode(int new_mode)
319 case CREATE_READ_WRITE:
320 mode = O_CREAT | O_RDWR | O_BINARY;
322 case OPEN_READ_WRITE:
323 mode = O_RDWR | O_BINARY;
326 mode = O_RDONLY | O_BINARY;
328 case OPEN_WRITE_ONLY:
329 mode = O_WRONLY | O_BINARY;
332 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
338 void DEVICE::open_tape_device(DCR *dcr, int omode)
341 int timeout = max_open_wait;
342 #if !defined(HAVE_WIN32)
344 utime_t start_time = time(NULL);
348 Dmsg0(29, "Open dev: device is tape\n");
350 get_autochanger_loaded_slot(dcr);
359 if (is_fifo() && timeout) {
361 tid = start_thread_timer(pthread_self(), timeout);
363 Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
364 #if defined(HAVE_WIN32)
367 if ((m_fd = tape_open(dev_name, mode)) < 0) {
374 /* If busy retry each second for max_open_wait seconds */
376 /* Try non-blocking open */
377 m_fd = ::open(dev_name, mode+O_NONBLOCK);
381 Dmsg5(050, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
382 print_name(), omode, mode, errno, be.bstrerror());
384 /* Tape open, now rewind it */
385 Dmsg0(050, "Rewind after open\n");
386 mt_com.mt_op = MTREW;
388 /* rewind only if dev is a tape */
389 if (is_tape() && (ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0)) {
391 dev_errno = errno; /* set error status from rewind */
394 Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
395 be.bstrerror(dev_errno));
396 /* If we get busy, device is probably rewinding, try again */
397 if (dev_errno != EBUSY) {
398 break; /* error -- no medium */
401 /* Got fd and rewind worked, so we must have medium in drive */
403 m_fd = ::open(dev_name, mode); /* open normally */
407 Dmsg5(050, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
408 print_name(), omode, mode, errno, be.bstrerror());
413 set_os_device_parameters(dcr); /* do system dependent stuff */
414 break; /* Successfully opened and rewound */
418 /* Exceed wait time ? */
419 if (time(NULL) - start_time >= max_open_wait) {
420 break; /* yes, get out */
427 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
428 print_name(), be.bstrerror(dev_errno));
429 Dmsg1(100, "%s", errmsg);
432 /* Stop any open() timer we started */
434 stop_thread_timer(tid);
437 Dmsg1(29, "open dev: tape %d opened\n", m_fd);
444 void DEVICE::open_file_device(DCR *dcr, int omode)
446 POOL_MEM archive_name(PM_FNAME);
448 get_autochanger_loaded_slot(dcr);
451 * Handle opening of File Archive (not a tape)
454 pm_strcpy(archive_name, dev_name);
456 * If this is a virtual autochanger (i.e. changer_res != NULL)
457 * we simply use the device name, assuming it has been
458 * appropriately setup by the "autochanger".
460 if (!device->changer_res || device->changer_command[0] == 0) {
461 if (VolCatInfo.VolCatName[0] == 0) {
462 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
468 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
469 pm_strcat(archive_name, "/");
471 pm_strcat(archive_name, VolCatInfo.VolCatName);
474 mount(1); /* do mount if required */
478 /* If creating file, give 0640 permissions */
479 Dmsg3(29, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
480 archive_name.c_str(), mode);
481 /* Use system open() */
482 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
485 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
487 Dmsg1(29, "open failed: %s", errmsg);
488 Emsg0(M_FATAL, 0, errmsg);
494 Dmsg4(29, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
495 m_fd, part, num_dvd_parts, part_size);
499 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
500 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
501 * has the desired Volume name, but there is NO assurance that
502 * any other field of VolCatInfo is correct.
504 void DEVICE::open_dvd_device(DCR *dcr, int omode)
506 POOL_MEM archive_name(PM_FNAME);
507 struct stat filestat;
510 * Handle opening of DVD Volume
512 Dmsg2(29, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n",
513 &dcr->VolCatInfo, mode_to_str(omode));
516 * For a DVD we must always pull the state info from dcr->VolCatInfo
517 * This is a bit ugly, but is necessary because we need to open/close/re-open
518 * the dvd file in order to properly mount/unmount and access the
519 * DVD. So we store the state of the DVD as far as is known in the
520 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
521 * copy here, when opening.
523 VolCatInfo = dcr->VolCatInfo; /* structure assignment */
524 Dmsg1(100, "Volume=%s\n", VolCatInfo.VolCatName);
526 if (VolCatInfo.VolCatName[0] == 0) {
527 Dmsg1(10, "Could not open DVD device %s. No Volume name given.\n",
529 Mmsg(errmsg, _("Could not open DVD device %s. No Volume name given.\n"),
536 Dmsg0(100, "Set part=1\n");
537 part = 1; /* count from 1 */
541 if (num_dvd_parts != VolCatInfo.VolCatParts) {
542 num_dvd_parts = VolCatInfo.VolCatParts;
546 * If we are not trying to access the last part, set mode to
547 * OPEN_READ_ONLY as writing would be an error.
549 Dmsg2(29, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
550 /* Now find the name of the part that we want to access */
551 if (part <= num_dvd_parts) {
552 omode = OPEN_READ_ONLY;
553 make_mounted_dvd_filename(this, archive_name);
554 set_part_spooled(false);
556 omode = OPEN_READ_WRITE;
557 make_spooled_dvd_filename(this, archive_name);
558 set_part_spooled(true);
562 // Clear any previous blank_dvd status - we will recalculate it here
565 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
566 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
569 Dmsg0(99, "DVD device mounted.\n");
570 if (num_dvd_parts == 0 && !truncating) {
572 * If we can mount the device, and we are not truncating the DVD,
573 * we usually want to abort. There is one exception, if there is
574 * only one 0-sized file on the DVD, with the right volume name,
575 * we continue (it's the method used by truncate_dvd to truncate a volume).
577 if (!check_can_write_on_non_blank_dvd(dcr)) {
578 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
579 Emsg0(M_FATAL, 0, errmsg);
580 unmount(1); /* Unmount the device, so the operator can change it. */
587 * Ensure that we have the correct DVD loaded by looking for part1.
588 * We only succeed the open if it exists. Failure to do this could
589 * leave us trying to add a part to a different DVD!
591 uint32_t oldpart = part;
593 POOL_MEM part1_name(PM_FNAME);
595 make_mounted_dvd_filename(this, part1_name);
597 if (stat(part1_name.c_str(), &statp) < 0) {
599 Mmsg(errmsg, _("Unable to stat DVD part 1 file %s: ERR=%s\n"),
600 part1_name.c_str(), be.bstrerror());
601 Emsg0(M_FATAL, 0, errmsg);
605 if (!S_ISREG(statp.st_mode)) {
606 /* It is not a regular file */
607 Mmsg(errmsg, _("DVD part 1 is not a regular file %s.\n"),
609 Emsg0(M_FATAL, 0, errmsg);
615 Dmsg0(99, "DVD device mount failed.\n");
616 /* We cannot mount the device */
617 if (num_dvd_parts == 0) {
618 /* Run free space, check there is a media. */
619 if (!update_freespace()) {
620 Emsg0(M_FATAL, 0, errmsg);
625 Dmsg1(29, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
627 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
628 Emsg0(M_FATAL, 0, errmsg);
633 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
634 Emsg0(M_FATAL, 0, errmsg);
640 Dmsg5(29, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
641 archive_name.c_str(), mode_to_str(omode),
642 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
644 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
647 /* If creating file, give 0640 permissions */
648 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
649 archive_name.c_str(), mode);
650 /* Use system open() */
651 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
653 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
655 // Should this be set if we try the create/open below
656 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
657 Dmsg1(29, "open failed: %s", errmsg);
659 /* Previous open failed. See if we can recover */
660 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
661 (part > num_dvd_parts)) {
662 /* If the last part (on spool), doesn't exist when accessing,
663 * create it. In read/write mode a write will be allowed (higher
664 * level software thinks that we are extending a pre-existing
665 * media. Reads for READ_ONLY will report immediately an EOF
666 * Sometimes it is better to finish with an EOF than with an error. */
667 Dmsg1(29, "Creating last part on spool: %s\n", archive_name.c_str());
668 omode = CREATE_READ_WRITE;
669 set_mode(CREATE_READ_WRITE);
670 m_fd = ::open(archive_name.c_str(), mode, 0640);
674 Dmsg1(100, "after open fd=%d\n", m_fd);
676 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
679 /* Get size of file */
680 if (fstat(m_fd, &filestat) < 0) {
683 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
685 Dmsg1(29, "open failed: %s", errmsg);
686 /* Use system close() */
690 part_size = filestat.st_size;
692 update_pos(dcr); /* update position */
700 * Returns: true on success
703 bool DEVICE::rewind(DCR *dcr)
709 Dmsg3(400, "rewind res=%d fd=%d %s\n", reserved_device, m_fd, print_name());
710 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
711 block_num = file = 0;
715 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
717 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
719 Emsg0(M_ABORT, 0, errmsg);
724 mt_com.mt_op = MTREW;
726 /* If we get an I/O error on rewind, it is probably because
727 * the drive is actually busy. We loop for (about 5 minutes)
728 * retrying every 5 seconds.
730 for (i=max_rewind_wait; ; i -= 5) {
731 if (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
734 if (i == max_rewind_wait) {
735 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.bstrerror());
738 * This is a gross hack, because if the user has the
739 * device mounted (i.e. open), then uses mtx to load
740 * a tape, the current open file descriptor is invalid.
741 * So, we close the drive and re-open it.
744 int open_mode = openmode;
747 open(dcr, open_mode);
755 if (dev_errno == EIO) {
756 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
760 if (dev_errno == EIO && i > 0) {
761 Dmsg0(200, "Sleeping 5 seconds.\n");
766 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
767 print_name(), be.bstrerror());
772 } else if (is_file() || is_dvd()) {
773 if (lseek(dcr, (boffset_t)0, SEEK_SET) < 0) {
776 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
777 print_name(), be.bstrerror());
784 void DEVICE::block(int why)
786 r_dlock(); /* need recursive lock to block */
787 block_device(this, why);
791 void DEVICE::unblock(bool locked)
796 unblock_device(this);
801 const char *DEVICE::print_blocked() const
804 case BST_NOT_BLOCKED:
805 return "BST_NOT_BLOCKED";
807 return "BST_UNMOUNTED";
808 case BST_WAITING_FOR_SYSOP:
809 return "BST_WAITING_FOR_SYSOP";
810 case BST_DOING_ACQUIRE:
811 return "BST_DOING_ACQUIRE";
812 case BST_WRITING_LABEL:
813 return "BST_WRITING_LABEL";
814 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
815 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
819 return _("unknown blocked code");
824 * Called to indicate that we have just read an
825 * EOF from the device.
827 void DEVICE::set_ateof()
839 * Called to indicate we are now at the end of the tape, and
840 * writing is not possible.
842 void DEVICE::set_ateot()
844 /* Make tape effectively read-only */
845 state |= (ST_EOF|ST_EOT|ST_WEOT);
850 * Position device to end of medium (end of data)
851 * Returns: true on succes
854 bool DEVICE::eod(DCR *dcr)
863 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
867 #if defined (__digital__) && defined (__unix__)
868 return fsf(VolCatInfo.VolCatFiles);
875 clear_eof(); /* remove EOF flag */
876 block_num = file = 0;
879 if (is_fifo() || is_prog()) {
883 pos = lseek(dcr, (boffset_t)0, SEEK_END);
884 // Dmsg1(100, "====== Seek to %lld\n", pos);
892 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
893 print_name(), be.bstrerror());
897 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
898 Dmsg0(100,"Using FAST FSF for EOM\n");
899 /* If unknown position, rewind */
900 if (get_os_tape_file() < 0) {
905 mt_com.mt_op = MTFSF;
907 * ***FIXME*** fix code to handle case that INT16_MAX is
910 mt_com.mt_count = INT16_MAX; /* use big positive number */
911 if (mt_com.mt_count < 0) {
912 mt_com.mt_count = INT16_MAX; /* brain damaged system */
916 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
917 if (has_cap(CAP_EOM)) {
918 Dmsg0(100,"Using EOM for EOM\n");
919 mt_com.mt_op = MTEOM;
923 if (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
925 clrerror(mt_com.mt_op);
926 Dmsg1(50, "ioctl error: %s\n", be.bstrerror());
928 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
929 print_name(), be.bstrerror());
933 os_file = get_os_tape_file();
937 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
938 print_name(), be.bstrerror());
941 Dmsg1(100, "EOD file=%d\n", os_file);
949 * Rewind then use FSF until EOT reached
955 * Move file by file to the end of the tape
958 for (file_num=file; !at_eot(); file_num++) {
959 Dmsg0(200, "eod: doing fsf 1\n");
961 Dmsg0(200, "fsf error.\n");
965 * Avoid infinite loop by ensuring we advance.
967 if (!at_eot() && file_num == (int)file) {
968 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
970 os_file = get_os_tape_file();
972 Dmsg2(100, "Adjust file from %d to %d\n", file_num, os_file);
980 * Some drivers leave us after second EOF when doing
981 * MTEOM, so we must backup so that appending overwrites
984 if (has_cap(CAP_BSFATEOM)) {
985 /* Backup over EOF */
987 /* If BSF worked and fileno is known (not -1), set file */
988 os_file = get_os_tape_file();
990 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , os_file);
993 file++; /* wing it -- not correct on all OSes */
996 update_pos(dcr); /* update position */
998 Dmsg1(200, "EOD dev->file=%d\n", file);
1003 * Set the position of the device -- only for files and DVD
1004 * For other devices, there is no generic way to do it.
1005 * Returns: true on succes
1008 bool DEVICE::update_pos(DCR *dcr)
1015 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
1016 Emsg1(M_FATAL, 0, "%s", errmsg);
1020 /* Find out where we are */
1021 if (is_file() || is_dvd()) {
1024 pos = lseek(dcr, (boffset_t)0, SEEK_CUR);
1028 Pmsg1(000, _("Seek error: ERR=%s\n"), be.bstrerror());
1029 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1030 print_name(), be.bstrerror());
1034 block_num = (uint32_t)pos;
1035 file = (uint32_t)(pos >> 32);
1042 * Return the status of the device. This was meant
1043 * to be a generic routine. Unfortunately, it doesn't
1044 * seem possible (at least I do not know how to do it
1045 * currently), which means that for the moment, this
1046 * routine has very little value.
1050 uint32_t status_dev(DEVICE *dev)
1052 struct mtget mt_stat;
1055 if (dev->state & (ST_EOT | ST_WEOT)) {
1059 if (dev->state & ST_EOF) {
1063 if (dev->is_tape()) {
1065 Pmsg0(-20,_(" Bacula status:"));
1066 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1067 if (tape_ioctl(dev->fd(), MTIOCGET, (char *)&mt_stat) < 0) {
1069 dev->dev_errno = errno;
1070 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1071 dev->print_name(), be.bstrerror());
1074 Pmsg0(-20, _(" Device status:"));
1076 #if defined(HAVE_LINUX_OS)
1077 if (GMT_EOF(mt_stat.mt_gstat)) {
1081 if (GMT_BOT(mt_stat.mt_gstat)) {
1085 if (GMT_EOT(mt_stat.mt_gstat)) {
1089 if (GMT_SM(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");
1113 #elif defined(HAVE_WIN32)
1114 if (GMT_EOF(mt_stat.mt_gstat)) {
1118 if (GMT_BOT(mt_stat.mt_gstat)) {
1122 if (GMT_EOT(mt_stat.mt_gstat)) {
1126 if (GMT_EOD(mt_stat.mt_gstat)) {
1130 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1131 stat |= BMT_WR_PROT;
1132 Pmsg0(-20, " WR_PROT");
1134 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1136 Pmsg0(-20, " ONLINE");
1138 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1139 stat |= BMT_DR_OPEN;
1140 Pmsg0(-20, " DR_OPEN");
1142 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1143 stat |= BMT_IM_REP_EN;
1144 Pmsg0(-20, " IM_REP_EN");
1147 #endif /* !SunOS && !OSF */
1148 if (dev->has_cap(CAP_MTIOCGET)) {
1149 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1151 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1154 stat |= BMT_ONLINE | BMT_BOT;
1161 * Load medium in device
1162 * Returns: true on success
1165 bool load_dev(DEVICE *dev)
1171 if (dev->fd() < 0) {
1172 dev->dev_errno = EBADF;
1173 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1174 Emsg0(M_FATAL, 0, dev->errmsg);
1177 if (!(dev->is_tape())) {
1181 Dmsg0(200, "stored: MTLOAD command not available\n");
1183 dev->dev_errno = ENOTTY; /* function not available */
1184 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1185 dev->print_name(), be.bstrerror());
1189 dev->block_num = dev->file = 0;
1192 mt_com.mt_op = MTLOAD;
1193 mt_com.mt_count = 1;
1194 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
1196 dev->dev_errno = errno;
1197 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1198 dev->print_name(), be.bstrerror());
1206 * Rewind device and put it offline
1207 * Returns: true on success
1210 bool DEVICE::offline()
1215 return true; /* device not open */
1218 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1219 block_num = file = 0;
1223 mt_com.mt_op = MTOFFL;
1224 mt_com.mt_count = 1;
1225 if (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
1228 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1229 print_name(), be.bstrerror());
1232 Dmsg1(100, "Offlined device %s\n", print_name());
1236 bool DEVICE::offline_or_rewind()
1241 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1245 * Note, this rewind probably should not be here (it wasn't
1246 * in prior versions of Bacula), but on FreeBSD, this is
1247 * needed in the case the tape was "frozen" due to an error
1248 * such as backspacing after writing and EOF. If it is not
1249 * done, all future references to the drive get and I/O error.
1252 return rewind(NULL);
1257 * Foward space a file
1258 * Returns: true on success
1261 bool DEVICE::fsf(int num)
1263 int32_t os_file = 0;
1269 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1270 Emsg0(M_FATAL, 0, errmsg);
1280 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1284 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1287 Dmsg0(100, "fsf\n");
1290 * If Fast forward space file is set, then we
1291 * use MTFSF to forward space and MTIOCGET
1292 * to get the file position. We assume that
1293 * the SCSI driver will ensure that we do not
1294 * forward space past the end of the medium.
1296 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1298 mt_com.mt_op = MTFSF;
1299 mt_com.mt_count = num;
1300 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1302 my_errno = errno; /* save errno */
1303 } else if ((os_file=get_os_tape_file()) < 0) {
1304 my_errno = errno; /* save errno */
1306 if (my_errno != 0) {
1309 Dmsg0(200, "Set ST_EOT\n");
1311 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1312 print_name(), be.bstrerror(my_errno));
1313 Dmsg1(200, "%s", errmsg);
1317 Dmsg1(200, "fsf file=%d\n", os_file);
1323 * Here if CAP_FSF is set, and virtually all drives
1324 * these days support it, we read a record, then forward
1325 * space one file. Using this procedure, which is slow,
1326 * is the only way we can be sure that we don't read
1327 * two consecutive EOF marks, which means End of Data.
1329 } else if (has_cap(CAP_FSF)) {
1332 Dmsg0(200, "FSF has cap_fsf\n");
1333 if (max_block_size == 0) {
1334 rbuf_len = DEFAULT_BLOCK_SIZE;
1336 rbuf_len = max_block_size;
1338 rbuf = get_memory(rbuf_len);
1339 mt_com.mt_op = MTFSF;
1340 mt_com.mt_count = 1;
1341 while (num-- && !at_eot()) {
1342 Dmsg0(100, "Doing read before fsf\n");
1343 if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1344 if (errno == ENOMEM) { /* tape record exceeds buf len */
1345 stat = rbuf_len; /* This is OK */
1347 * On IBM drives, they return ENOSPC at EOM
1348 * instead of EOF status
1350 } else if (at_eof() && errno == ENOSPC) {
1356 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1358 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1359 print_name(), be.bstrerror());
1360 Dmsg1(100, "%s", errmsg);
1364 if (stat == 0) { /* EOF */
1365 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1366 /* Two reads of zero means end of tape */
1369 Dmsg0(100, "Set ST_EOT\n");
1375 } else { /* Got data */
1380 Dmsg0(100, "Doing MTFSF\n");
1381 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1382 if (stat < 0) { /* error => EOT */
1385 Dmsg0(100, "Set ST_EOT\n");
1387 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1388 print_name(), be.bstrerror());
1389 Dmsg0(100, "Got < 0 for MTFSF\n");
1390 Dmsg1(100, "%s", errmsg);
1398 * No FSF, so use FSR to simulate it
1401 Dmsg0(200, "Doing FSR for FSF\n");
1402 while (num-- && !at_eot()) {
1403 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1407 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1413 Dmsg1(200, "Return %d from FSF\n", stat);
1415 Dmsg0(200, "ST_EOF set on exit FSF\n");
1418 Dmsg0(200, "ST_EOT set on exit FSF\n");
1420 Dmsg1(200, "Return from FSF file=%d\n", file);
1425 * Backward space a file
1426 * Returns: false on failure
1429 bool DEVICE::bsf(int num)
1436 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1437 Emsg0(M_FATAL, 0, errmsg);
1442 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1453 mt_com.mt_op = MTBSF;
1454 mt_com.mt_count = num;
1455 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1459 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1460 print_name(), be.bstrerror());
1467 * Foward space num records
1468 * Returns: false on failure
1471 bool DEVICE::fsr(int num)
1478 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1479 Emsg0(M_FATAL, 0, errmsg);
1487 if (!has_cap(CAP_FSR)) {
1488 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1492 Dmsg1(29, "fsr %d\n", num);
1493 mt_com.mt_op = MTFSR;
1494 mt_com.mt_count = num;
1495 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1501 struct mtget mt_stat;
1503 Dmsg1(100, "FSF fail: ERR=%s\n", be.bstrerror());
1504 if (dev_get_os_pos(this, &mt_stat)) {
1505 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1506 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1507 file = mt_stat.mt_fileno;
1508 block_num = mt_stat.mt_blkno;
1516 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1517 num, print_name(), be.bstrerror());
1523 * Backward space a record
1524 * Returns: false on failure
1527 bool DEVICE::bsr(int num)
1534 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1535 Emsg0(M_FATAL, 0, errmsg);
1543 if (!has_cap(CAP_BSR)) {
1544 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1548 Dmsg0(29, "bsr_dev\n");
1552 mt_com.mt_op = MTBSR;
1553 mt_com.mt_count = num;
1554 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1558 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1559 print_name(), be.bstrerror());
1564 void DEVICE::lock_door()
1568 mt_com.mt_op = MTLOCK;
1569 mt_com.mt_count = 1;
1570 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1574 void DEVICE::unlock_door()
1578 mt_com.mt_op = MTUNLOCK;
1579 mt_com.mt_count = 1;
1580 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1586 * Reposition the device to file, block
1587 * Returns: false on failure
1590 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1594 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1595 Emsg0(M_FATAL, 0, errmsg);
1600 boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1601 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1602 if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1605 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1606 print_name(), be.bstrerror());
1615 /* After this point, we are tape only */
1616 Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1618 Dmsg0(100, "Rewind\n");
1619 if (!rewind(NULL)) {
1624 Dmsg1(100, "fsf %d\n", rfile-file);
1625 if (!fsf(rfile-file)) {
1626 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1629 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1631 if (rblock < block_num) {
1632 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1633 Dmsg0(100, "bsf 1\n");
1635 Dmsg0(100, "fsf 1\n");
1637 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1639 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1640 /* Ignore errors as Bacula can read to the correct block */
1641 Dmsg1(100, "fsr %d\n", rblock-block_num);
1642 return fsr(rblock-block_num);
1644 while (rblock > block_num) {
1645 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1648 Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1649 print_name(), be.bstrerror());
1652 Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1661 * Write an end of file on the device
1662 * Returns: true on success
1665 bool DEVICE::weof(int num)
1669 Dmsg0(129, "weof_dev\n");
1673 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1674 Emsg0(M_FATAL, 0, errmsg);
1682 if (!can_append()) {
1683 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1684 Emsg0(M_FATAL, 0, errmsg);
1690 mt_com.mt_op = MTWEOF;
1691 mt_com.mt_count = num;
1692 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1701 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1702 print_name(), be.bstrerror());
1710 * If implemented in system, clear the tape
1713 void DEVICE::clrerror(int func)
1715 const char *msg = NULL;
1718 dev_errno = errno; /* save errno */
1720 VolCatInfo.VolCatErrors++;
1727 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1730 break; /* ignore message printed later */
1733 clear_cap(CAP_EOF); /* turn off feature */
1738 clear_cap(CAP_EOM); /* turn off feature */
1743 clear_cap(CAP_FSF); /* turn off feature */
1747 clear_cap(CAP_BSF); /* turn off feature */
1751 clear_cap(CAP_FSR); /* turn off feature */
1755 clear_cap(CAP_BSR); /* turn off feature */
1765 #ifdef MTSETDRVBUFFER
1766 case MTSETDRVBUFFER:
1767 msg = "MTSETDRVBUFFER";
1800 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1806 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1807 Emsg0(M_ERROR, 0, errmsg);
1812 * Now we try different methods of clearing the error
1813 * status on the drive so that it is not locked for
1814 * further operations.
1817 /* On some systems such as NetBSD, this clears all errors */
1820 /* Found on Solaris */
1823 tape_ioctl(m_fd, MTIOCLRERR);
1824 Dmsg0(200, "Did MTIOCLRERR\n");
1828 /* Typically on FreeBSD */
1832 /* Read and clear SCSI error status */
1833 union mterrstat mt_errstat;
1834 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1835 be.bstrerror(dev_errno));
1836 tape_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1840 /* Clear Subsystem Exception OSF1 */
1844 mt_com.mt_op = MTCSE;
1845 mt_com.mt_count = 1;
1846 /* Clear any error condition on the tape */
1847 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1848 Dmsg0(200, "Did MTCSE\n");
1855 * Clear volume header
1857 void DEVICE::clear_volhdr()
1859 /* If we have an unused volume associated with this drive, free it */
1860 if (vol && !is_busy()) {
1863 Dmsg1(100, "Clear volhdr vol=%s\n", VolHdr.VolumeName);
1864 memset(&VolHdr, 0, sizeof(VolHdr));
1871 void DEVICE::close()
1873 Dmsg1(100, "close_dev %s\n", print_name());
1874 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1879 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1881 return; /* already closed */
1893 /* Clean up device packet so it can be reused */
1895 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1896 label_type = B_BACULA_LABEL;
1897 file = block_num = 0;
1900 EndFile = EndBlock = 0;
1902 Slot = -1; /* unknown slot */
1904 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1906 stop_thread_timer(tid);
1912 * This call closes the device, but it is used in DVD handling
1913 * where we close one part and then open the next part. The
1914 * difference between close_part() and close() is that close_part()
1915 * saves the state information of the device (e.g. the Volume lable,
1916 * the Volume Catalog record, ... This permits opening and closing
1917 * the Volume parts multiple times without losing track of what the
1918 * main Volume parameters are.
1920 void DEVICE::close_part(DCR *dcr)
1922 VOLUME_LABEL saveVolHdr;
1923 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1926 saveVolHdr = VolHdr; /* structure assignment */
1927 saveVolCatInfo = VolCatInfo; /* structure assignment */
1928 close(); /* close current part */
1929 VolHdr = saveVolHdr; /* structure assignment */
1930 VolCatInfo = saveVolCatInfo; /* structure assignment */
1931 dcr->VolCatInfo = saveVolCatInfo; /* structure assignment */
1934 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1938 return lseek_dvd(dcr, offset, whence);
1940 #if defined(HAVE_WIN32)
1941 return ::_lseeki64(m_fd, (__int64)offset, whence);
1943 return ::lseek(m_fd, (off_t)offset, whence);
1950 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1952 Dmsg1(100, "truncate %s\n", print_name());
1955 /* maybe we should rewind and write and eof ???? */
1956 return true; /* we don't really truncate tapes */
1958 return truncate_dvd(dcr);
1960 /* ***FIXME*** we really need to unlink() the file so that
1961 * its name can be changed for a relabel.
1963 if (ftruncate(m_fd, 0) != 0) {
1965 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1966 print_name(), be.bstrerror());
1974 /* Mount the device.
1975 * If timeout, wait until the mount command returns 0.
1976 * If !timeout, try to mount the device only once.
1978 bool DEVICE::mount(int timeout)
1980 Dmsg0(190, "Enter mount\n");
1983 } else if (requires_mount()) {
1984 return do_mount(1, timeout);
1989 /* Unmount the device
1990 * If timeout, wait until the unmount command returns 0.
1991 * If !timeout, try to unmount the device only once.
1993 bool DEVICE::unmount(int timeout)
1995 Dmsg0(90, "Enter unmount\n");
1997 return do_mount(0, timeout);
2002 /* (Un)mount the device */
2003 bool DEVICE::do_mount(int mount, int dotimeout)
2005 POOL_MEM ocmd(PM_FNAME);
2008 int status, timeout;
2010 sm_check(__FILE__, __LINE__, false);
2013 Dmsg0(200, "======= mount=1\n");
2016 icmd = device->mount_command;
2018 if (!is_mounted()) {
2019 Dmsg0(200, "======= mount=0\n");
2022 icmd = device->unmount_command;
2025 clear_freespace_ok();
2026 edit_mount_codes(ocmd, icmd);
2028 Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2031 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
2036 results = get_memory(4000);
2039 /* If busy retry each second */
2040 Dmsg1(20, "do_mount run_prog=%s\n", ocmd.c_str());
2041 while ((status = run_program_full_output(ocmd.c_str(),
2042 max_open_wait/2, results)) != 0) {
2043 /* Doesn't work with internationalization (This is not a problem) */
2044 if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2047 if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2050 if (timeout-- > 0) {
2051 /* Sometimes the device cannot be mounted because it is already mounted.
2052 * Try to unmount it, then remount it */
2054 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2062 Dmsg5(40, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2063 (mount ? "" : "un"), status, results, be.bstrerror(status));
2064 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2065 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2067 Dmsg4(40, "Device %s cannot be %smounted. stat=%d ERR=%s\n", print_name(),
2068 (mount ? "" : "un"), status, results);
2069 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2070 print_name(), (mount ? "" : "un"), results);
2073 * Now, just to be sure it is not mounted, try to read the
2077 struct dirent *entry, *result;
2081 name_max = pathconf(".", _PC_NAME_MAX);
2082 if (name_max < 1024) {
2086 if (!(dp = opendir(device->mount_point))) {
2089 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2090 device->mount_point, print_name(), be.bstrerror());
2094 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2097 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2099 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
2100 device->mount_point, print_name());
2103 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2104 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2107 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2113 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2116 /* If we got more than ., .. and .keep */
2117 /* there must be something mounted */
2119 Dmsg1(100, "Did Mount by count=%d\n", count);
2122 /* An unmount request. We failed to unmount - report an error */
2124 free_pool_memory(results);
2125 Dmsg0(200, "== error mount=1 wanted unmount\n");
2131 sm_check(__FILE__, __LINE__, false);
2132 free_pool_memory(results);
2133 Dmsg0(200, "============ mount=0\n");
2137 set_mounted(mount); /* set/clear mounted flag */
2138 free_pool_memory(results);
2139 /* Do not check free space when unmounting */
2140 if (mount && !update_freespace()) {
2143 Dmsg1(200, "============ mount=%d\n", mount);
2148 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2150 * %a = archive device name
2151 * %e = erase (set if cannot mount and first part)
2154 * %v = last part name
2156 * omsg = edited output message
2157 * imsg = input string containing edit codes (%x)
2160 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2166 POOL_MEM archive_name(PM_FNAME);
2168 omsg.c_str()[0] = 0;
2169 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2170 for (p=imsg; *p; p++) {
2180 if (num_dvd_parts == 0) {
2181 if (truncating || blank_dvd) {
2191 bsnprintf(add, sizeof(add), "%d", part);
2195 str = device->mount_point;
2198 make_spooled_dvd_filename(this, archive_name);
2199 str = archive_name.c_str();
2213 Dmsg1(1900, "add_str %s\n", str);
2214 pm_strcat(omsg, (char *)str);
2215 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2219 /* return the last timer interval (ms) */
2220 btime_t DEVICE::get_timer_count()
2222 btime_t old = last_timer;
2223 last_timer = get_current_btime();
2224 return last_timer - old;
2228 ssize_t DEVICE::read(void *buf, size_t len)
2234 if (this->is_tape()) {
2235 read_len = tape_read(m_fd, buf, len);
2237 read_len = ::read(m_fd, buf, len);
2240 last_tick = get_timer_count();
2242 DevReadTime += last_tick;
2243 VolCatInfo.VolReadTime += last_tick;
2245 if (read_len > 0) { /* skip error */
2246 DevReadBytes += read_len;
2253 ssize_t DEVICE::write(const void *buf, size_t len)
2259 if (this->is_tape()) {
2260 write_len = tape_write(m_fd, buf, len);
2262 write_len = ::write(m_fd, buf, len);
2265 last_tick = get_timer_count();
2267 DevWriteTime += last_tick;
2268 VolCatInfo.VolWriteTime += last_tick;
2270 if (write_len > 0) { /* skip error */
2271 DevWriteBytes += write_len;
2277 /* Return the resource name for the device */
2278 const char *DEVICE::name() const
2280 return device->hdr.name;
2283 /* Returns file position on tape or -1 */
2284 int32_t DEVICE::get_os_tape_file()
2286 struct mtget mt_stat;
2288 if (has_cap(CAP_MTIOCGET) &&
2289 tape_ioctl(m_fd, MTIOCGET, (char *)&mt_stat) == 0) {
2290 return mt_stat.mt_fileno;
2296 dev_vol_name(DEVICE *dev)
2298 return dev->VolCatInfo.VolCatName;
2303 * Free memory allocated for the device
2305 void DEVICE::term(void)
2307 Dmsg1(900, "term dev: %s\n", print_name());
2310 free_memory(dev_name);
2314 free_memory(prt_name);
2318 free_pool_memory(errmsg);
2321 pthread_mutex_destroy(&m_mutex);
2322 pthread_cond_destroy(&wait);
2323 pthread_cond_destroy(&wait_next_vol);
2324 pthread_mutex_destroy(&spool_mutex);
2325 // rwl_destroy(&lock);
2326 if (attached_dcrs) {
2327 delete attached_dcrs;
2328 attached_dcrs = NULL;
2337 * This routine initializes the device wait timers
2339 void init_device_wait_timers(DCR *dcr)
2341 DEVICE *dev = dcr->dev;
2342 JCR *jcr = dcr->jcr;
2344 /* ******FIXME******* put these on config variables */
2345 dev->min_wait = 60 * 60;
2346 dev->max_wait = 24 * 60 * 60;
2347 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2348 dev->wait_sec = dev->min_wait;
2349 dev->rem_wait_sec = dev->wait_sec;
2352 dev->BadVolName[0] = 0;
2354 jcr->min_wait = 60 * 60;
2355 jcr->max_wait = 24 * 60 * 60;
2356 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2357 jcr->wait_sec = jcr->min_wait;
2358 jcr->rem_wait_sec = jcr->wait_sec;
2363 void init_jcr_device_wait_timers(JCR *jcr)
2365 /* ******FIXME******* put these on config variables */
2366 jcr->min_wait = 60 * 60;
2367 jcr->max_wait = 24 * 60 * 60;
2368 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2369 jcr->wait_sec = jcr->min_wait;
2370 jcr->rem_wait_sec = jcr->wait_sec;
2376 * The dev timers are used for waiting on a particular device
2378 * Returns: true if time doubled
2379 * false if max time expired
2381 bool double_dev_wait_time(DEVICE *dev)
2383 dev->wait_sec *= 2; /* double wait time */
2384 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2385 dev->wait_sec = dev->max_wait;
2388 dev->rem_wait_sec = dev->wait_sec;
2389 if (dev->num_wait >= dev->max_num_wait) {
2396 void set_os_device_parameters(DCR *dcr)
2398 DEVICE *dev = dcr->dev;
2400 if (strcmp(dev->dev_name, "/dev/null") == 0) {
2401 return; /* no use trying to set /dev/null */
2404 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2407 Dmsg0(050, "In set_os_device_parameters\n");
2408 #if defined(MTSETBLK)
2409 if (dev->min_block_size == dev->max_block_size &&
2410 dev->min_block_size == 0) { /* variable block mode */
2411 mt_com.mt_op = MTSETBLK;
2412 mt_com.mt_count = 0;
2413 Dmsg0(050, "Set block size to zero\n");
2414 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2415 dev->clrerror(MTSETBLK);
2419 #if defined(MTSETDRVBUFFER)
2420 if (getpid() == 0) { /* Only root can do this */
2421 mt_com.mt_op = MTSETDRVBUFFER;
2422 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2423 if (!dev->has_cap(CAP_TWOEOF)) {
2424 mt_com.mt_count |= MT_ST_TWO_FM;
2426 if (dev->has_cap(CAP_EOM)) {
2427 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2429 Dmsg0(050, "MTSETDRVBUFFER\n");
2430 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2431 dev->clrerror(MTSETDRVBUFFER);
2438 #ifdef HAVE_NETBSD_OS
2440 if (dev->min_block_size == dev->max_block_size &&
2441 dev->min_block_size == 0) { /* variable block mode */
2442 mt_com.mt_op = MTSETBSIZ;
2443 mt_com.mt_count = 0;
2444 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2445 dev->clrerror(MTSETBSIZ);
2447 /* Get notified at logical end of tape */
2448 mt_com.mt_op = MTEWARN;
2449 mt_com.mt_count = 1;
2450 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2451 dev->clrerror(MTEWARN);
2457 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2459 if (dev->min_block_size == dev->max_block_size &&
2460 dev->min_block_size == 0) { /* variable block mode */
2461 mt_com.mt_op = MTSETBSIZ;
2462 mt_com.mt_count = 0;
2463 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2464 dev->clrerror(MTSETBSIZ);
2467 #if defined(MTIOCSETEOTMODEL)
2469 if (dev->has_cap(CAP_TWOEOF)) {
2474 if (ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2476 dev->dev_errno = errno; /* save errno */
2477 Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2478 dev->print_name(), be.bstrerror(dev->dev_errno));
2479 Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2487 if (dev->min_block_size == dev->max_block_size &&
2488 dev->min_block_size == 0) { /* variable block mode */
2489 mt_com.mt_op = MTSRSZ;
2490 mt_com.mt_count = 0;
2491 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2492 dev->clrerror(MTSRSZ);
2499 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2501 Dmsg0(050, "dev_get_os_pos\n");
2502 return dev->has_cap(CAP_MTIOCGET) &&
2503 tape_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2504 mt_stat->mt_fileno >= 0;
2507 static char *modes[] = {
2508 "CREATE_READ_WRITE",
2515 static char *mode_to_str(int mode)
2517 static char buf[100];
2518 if (mode < 1 || mode > 4) {
2519 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2522 return modes[mode-1];