3 * dev.c -- low level operations on device (storage device)
7 * NOTE!!!! None of these routines are reentrant. You must
8 * use lock_device() and unlock_device() at a higher level,
9 * or use the xxx_device() equivalents. By moving the
10 * thread synchronization to a higher level, we permit
11 * the higher level routines to "seize" the device and
12 * to carry out operations without worrying about who
13 * set what lock (i.e. race conditions).
15 * Note, this is the device dependent code, and may have
16 * to be modified for each system, but is meant to
17 * be as "generic" as possible.
19 * The purpose of this code is to develop a SIMPLE Storage
20 * daemon. More complicated coding (double buffering, writer
21 * thread, ...) is left for a later version.
23 * Unfortunately, I have had to add more and more complication
24 * to this code. This was not foreseen as noted above, and as
25 * a consequence has lead to something more contorted than is
26 * really necessary -- KES. Note, this contortion has been
27 * corrected to a large extent by a rewrite (Apr MMI).
32 Bacula® - The Network Backup Solution
34 Copyright (C) 2000-2007 Free Software Foundation Europe e.V.
36 The main author of Bacula is Kern Sibbald, with contributions from
37 many others, a complete list can be found in the file AUTHORS.
38 This program is Free Software; you can redistribute it and/or
39 modify it under the terms of version two of the GNU General Public
40 License as published by the Free Software Foundation plus additions
41 that are listed in the file LICENSE.
43 This program is distributed in the hope that it will be useful, but
44 WITHOUT ANY WARRANTY; without even the implied warranty of
45 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
46 General Public License for more details.
48 You should have received a copy of the GNU General Public License
49 along with this program; if not, write to the Free Software
50 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
53 Bacula® is a registered trademark of John Walker.
54 The licensor of Bacula is the Free Software Foundation Europe
55 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
56 Switzerland, email:ftf@fsfeurope.org.
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.strerror());
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.strerror());
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->mutex, NULL)) != 0) {
223 dev->dev_errno = errstat;
224 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(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.strerror(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.strerror(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.strerror(errstat));
243 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
245 if ((errstat = rwl_init(&dev->lock)) != 0) {
247 dev->dev_errno = errstat;
248 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
249 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
253 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
254 Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
260 * Open the device with the operating system and
261 * initialize buffer pointers.
263 * Returns: -1 on error
266 * Note, for a tape, the VolName is the name we give to the
267 * volume (not really used here), but for a file, the
268 * VolName represents the name of the file to be created/opened.
269 * In the case of a file, the full name is the device name
270 * (archive_name) with the VolName concatenated.
273 DEVICE::open(DCR *dcr, int omode)
277 if (openmode == omode) {
286 Dmsg0(100, "Close fd for mode change.\n");
287 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
291 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
294 Dmsg4(29, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
295 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
296 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
297 Slot = -1; /* unknown slot */
298 label_type = B_BACULA_LABEL;
299 if (is_tape() || is_fifo()) {
300 open_tape_device(dcr, omode);
301 } else if (is_dvd()) {
302 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
303 open_dvd_device(dcr, omode);
305 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
306 open_file_device(dcr, omode);
308 state |= preserve; /* reset any important state info */
309 Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, m_fd);
313 void DEVICE::set_mode(int new_mode)
316 case CREATE_READ_WRITE:
317 mode = O_CREAT | O_RDWR | O_BINARY;
319 case OPEN_READ_WRITE:
320 mode = O_RDWR | O_BINARY;
323 mode = O_RDONLY | O_BINARY;
325 case OPEN_WRITE_ONLY:
326 mode = O_WRONLY | O_BINARY;
329 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
335 void DEVICE::open_tape_device(DCR *dcr, int omode)
338 int timeout = max_open_wait;
339 #if !defined(HAVE_WIN32)
341 utime_t start_time = time(NULL);
345 Dmsg0(29, "Open dev: device is tape\n");
347 get_autochanger_loaded_slot(dcr);
356 if (is_fifo() && timeout) {
358 tid = start_thread_timer(pthread_self(), timeout);
360 Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
361 #if defined(HAVE_WIN32)
364 if ((m_fd = tape_open(dev_name, mode)) < 0) {
371 /* If busy retry each second for max_open_wait seconds */
373 /* Try non-blocking open */
374 m_fd = ::open(dev_name, mode+O_NONBLOCK);
378 Dmsg5(050, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
379 print_name(), omode, mode, errno, be.strerror());
381 /* Tape open, now rewind it */
382 Dmsg0(050, "Rewind after open\n");
383 mt_com.mt_op = MTREW;
385 if (ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
387 dev_errno = errno; /* set error status from rewind */
390 Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
391 be.strerror(dev_errno));
392 /* If we get busy, device is probably rewinding, try again */
393 if (dev_errno != EBUSY) {
394 break; /* error -- no medium */
397 /* Got fd and rewind worked, so we must have medium in drive */
399 m_fd = ::open(dev_name, mode); /* open normally */
403 Dmsg5(050, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
404 print_name(), omode, mode, errno, be.strerror());
409 set_os_device_parameters(dcr); /* do system dependent stuff */
410 break; /* Successfully opened and rewound */
414 /* Exceed wait time ? */
415 if (time(NULL) - start_time >= max_open_wait) {
416 break; /* yes, get out */
423 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
424 print_name(), be.strerror(dev_errno));
425 Dmsg1(100, "%s", errmsg);
428 /* Stop any open() timer we started */
430 stop_thread_timer(tid);
433 Dmsg1(29, "open dev: tape %d opened\n", m_fd);
440 void DEVICE::open_file_device(DCR *dcr, int omode)
442 POOL_MEM archive_name(PM_FNAME);
444 get_autochanger_loaded_slot(dcr);
447 * Handle opening of File Archive (not a tape)
450 pm_strcpy(archive_name, dev_name);
452 * If this is a virtual autochanger (i.e. changer_res != NULL)
453 * we simply use the device name, assuming it has been
454 * appropriately setup by the "autochanger".
456 if (!device->changer_res || device->changer_command[0] == 0) {
457 if (VolCatInfo.VolCatName[0] == 0) {
458 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
464 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
465 pm_strcat(archive_name, "/");
467 pm_strcat(archive_name, VolCatInfo.VolCatName);
470 mount(1); /* do mount if required */
474 /* If creating file, give 0640 permissions */
475 Dmsg3(29, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
476 archive_name.c_str(), mode);
477 /* Use system open() */
478 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
481 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
483 Dmsg1(29, "open failed: %s", errmsg);
484 Emsg0(M_FATAL, 0, errmsg);
490 Dmsg4(29, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
491 m_fd, part, num_dvd_parts, part_size);
495 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
496 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
497 * has the desired Volume name, but there is NO assurance that
498 * any other field of VolCatInfo is correct.
500 void DEVICE::open_dvd_device(DCR *dcr, int omode)
502 POOL_MEM archive_name(PM_FNAME);
503 struct stat filestat;
506 * Handle opening of DVD Volume
508 Dmsg2(29, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n",
509 &dcr->VolCatInfo, mode_to_str(omode));
512 * For a DVD we must always pull the state info from dcr->VolCatInfo
513 * This is a bit ugly, but is necessary because we need to open/close/re-open
514 * the dvd file in order to properly mount/unmount and access the
515 * DVD. So we store the state of the DVD as far as is known in the
516 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
517 * copy here, when opening.
519 VolCatInfo = dcr->VolCatInfo; /* structure assignment */
520 Dmsg1(100, "Volume=%s\n", VolCatInfo.VolCatName);
522 if (VolCatInfo.VolCatName[0] == 0) {
523 Dmsg1(10, "Could not open DVD device %s. No Volume name given.\n",
525 Mmsg(errmsg, _("Could not open DVD device %s. No Volume name given.\n"),
532 Dmsg0(100, "Set part=1\n");
533 part = 1; /* count from 1 */
537 if (num_dvd_parts != VolCatInfo.VolCatParts) {
538 num_dvd_parts = VolCatInfo.VolCatParts;
542 * If we are not trying to access the last part, set mode to
543 * OPEN_READ_ONLY as writing would be an error.
545 Dmsg2(29, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
546 /* Now find the name of the part that we want to access */
547 if (part <= num_dvd_parts) {
548 omode = OPEN_READ_ONLY;
549 make_mounted_dvd_filename(this, archive_name);
550 set_part_spooled(false);
552 omode = OPEN_READ_WRITE;
553 make_spooled_dvd_filename(this, archive_name);
554 set_part_spooled(true);
558 // Clear any previous blank_dvd status - we will recalculate it here
561 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
562 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
565 Dmsg0(99, "DVD device mounted.\n");
566 if (num_dvd_parts == 0 && !truncating) {
568 * If we can mount the device, and we are not truncating the DVD,
569 * we usually want to abort. There is one exception, if there is
570 * only one 0-sized file on the DVD, with the right volume name,
571 * we continue (it's the method used by truncate_dvd to truncate a volume).
573 if (!check_can_write_on_non_blank_dvd(dcr)) {
574 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
575 Emsg0(M_FATAL, 0, errmsg);
576 unmount(1); /* Unmount the device, so the operator can change it. */
583 * Ensure that we have the correct DVD loaded by looking for part1.
584 * We only succeed the open if it exists. Failure to do this could
585 * leave us trying to add a part to a different DVD!
587 uint32_t oldpart = part;
589 POOL_MEM part1_name(PM_FNAME);
591 make_mounted_dvd_filename(this, part1_name);
593 if (stat(part1_name.c_str(), &statp) < 0) {
595 Mmsg(errmsg, _("Unable to stat DVD part 1 file %s: ERR=%s\n"),
596 part1_name.c_str(), be.strerror());
597 Emsg0(M_FATAL, 0, errmsg);
601 if (!S_ISREG(statp.st_mode)) {
602 /* It is not a regular file */
603 Mmsg(errmsg, _("DVD part 1 is not a regular file %s.\n"),
605 Emsg0(M_FATAL, 0, errmsg);
611 Dmsg0(99, "DVD device mount failed.\n");
612 /* We cannot mount the device */
613 if (num_dvd_parts == 0) {
614 /* Run free space, check there is a media. */
615 if (!update_freespace()) {
616 Emsg0(M_FATAL, 0, errmsg);
621 Dmsg1(29, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
623 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
624 Emsg0(M_FATAL, 0, errmsg);
629 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
630 Emsg0(M_FATAL, 0, errmsg);
636 Dmsg5(29, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
637 archive_name.c_str(), mode_to_str(omode),
638 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
640 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
643 /* If creating file, give 0640 permissions */
644 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
645 archive_name.c_str(), mode);
646 /* Use system open() */
647 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
649 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
651 // Should this be set if we try the create/open below
652 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
653 Dmsg1(29, "open failed: %s", errmsg);
655 /* Previous open failed. See if we can recover */
656 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
657 (part > num_dvd_parts)) {
658 /* If the last part (on spool), doesn't exist when accessing,
659 * create it. In read/write mode a write will be allowed (higher
660 * level software thinks that we are extending a pre-existing
661 * media. Reads for READ_ONLY will report immediately an EOF
662 * Sometimes it is better to finish with an EOF than with an error. */
663 Dmsg1(29, "Creating last part on spool: %s\n", archive_name.c_str());
664 omode = CREATE_READ_WRITE;
665 set_mode(CREATE_READ_WRITE);
666 m_fd = ::open(archive_name.c_str(), mode, 0640);
670 Dmsg1(100, "after open fd=%d\n", m_fd);
672 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
675 /* Get size of file */
676 if (fstat(m_fd, &filestat) < 0) {
679 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
681 Dmsg1(29, "open failed: %s", errmsg);
682 /* Use system close() */
686 part_size = filestat.st_size;
688 update_pos(dcr); /* update position */
696 * Returns: true on success
699 bool DEVICE::rewind(DCR *dcr)
705 Dmsg3(400, "rewind res=%d fd=%d %s\n", reserved_device, m_fd, print_name());
706 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
707 block_num = file = 0;
711 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
713 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
715 Emsg0(M_ABORT, 0, errmsg);
720 mt_com.mt_op = MTREW;
722 /* If we get an I/O error on rewind, it is probably because
723 * the drive is actually busy. We loop for (about 5 minutes)
724 * retrying every 5 seconds.
726 for (i=max_rewind_wait; ; i -= 5) {
727 if (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
730 if (i == max_rewind_wait) {
731 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
734 * This is a gross hack, because if the user has the
735 * device mounted (i.e. open), then uses mtx to load
736 * a tape, the current open file descriptor is invalid.
737 * So, we close the drive and re-open it.
740 int open_mode = openmode;
743 open(dcr, open_mode);
751 if (dev_errno == EIO) {
752 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
756 if (dev_errno == EIO && i > 0) {
757 Dmsg0(200, "Sleeping 5 seconds.\n");
762 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
763 print_name(), be.strerror());
768 } else if (is_file() || is_dvd()) {
769 if (lseek(dcr, (boffset_t)0, SEEK_SET) < 0) {
772 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
773 print_name(), be.strerror());
780 void DEVICE::block(int why)
783 block_device(this, why);
787 void DEVICE::unblock()
790 unblock_device(this);
794 const char *DEVICE::print_blocked() const
796 switch (dev_blocked) {
797 case BST_NOT_BLOCKED:
798 return "BST_NOT_BLOCKED";
800 return "BST_UNMOUNTED";
801 case BST_WAITING_FOR_SYSOP:
802 return "BST_WAITING_FOR_SYSOP";
803 case BST_DOING_ACQUIRE:
804 return "BST_DOING_ACQUIRE";
805 case BST_WRITING_LABEL:
806 return "BST_WRITING_LABEL";
807 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
808 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
812 return _("unknown blocked code");
817 * Called to indicate that we have just read an
818 * EOF from the device.
820 void DEVICE::set_ateof()
832 * Called to indicate we are now at the end of the tape, and
833 * writing is not possible.
835 void DEVICE::set_ateot()
837 /* Make tape effectively read-only */
838 state |= (ST_EOF|ST_EOT|ST_WEOT);
843 * Position device to end of medium (end of data)
844 * Returns: true on succes
847 bool DEVICE::eod(DCR *dcr)
850 struct mtget mt_stat;
856 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
860 #if defined (__digital__) && defined (__unix__)
861 return fsf(VolCatInfo.VolCatFiles);
868 clear_eof(); /* remove EOF flag */
869 block_num = file = 0;
872 if (is_fifo() || is_prog()) {
876 pos = lseek(dcr, (boffset_t)0, SEEK_END);
877 // Dmsg1(100, "====== Seek to %lld\n", pos);
885 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
886 print_name(), be.strerror());
890 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
891 Dmsg0(100,"Using FAST FSF for EOM\n");
892 /* If unknown position, rewind */
893 if (!dev_get_os_pos(this, &mt_stat)) {
898 mt_com.mt_op = MTFSF;
900 * ***FIXME*** fix code to handle case that INT16_MAX is
903 mt_com.mt_count = INT16_MAX; /* use big positive number */
904 if (mt_com.mt_count < 0) {
905 mt_com.mt_count = INT16_MAX; /* brain damaged system */
909 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
910 if (has_cap(CAP_EOM)) {
911 Dmsg0(100,"Using EOM for EOM\n");
912 mt_com.mt_op = MTEOM;
916 if (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
918 clrerror(mt_com.mt_op);
919 Dmsg1(50, "ioctl error: %s\n", be.strerror());
921 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
922 print_name(), be.strerror());
926 if (!dev_get_os_pos(this, &mt_stat)) {
929 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
930 print_name(), be.strerror());
933 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
935 file = mt_stat.mt_fileno;
941 * Rewind then use FSF until EOT reached
947 * Move file by file to the end of the tape
950 for (file_num=file; !at_eot(); file_num++) {
951 Dmsg0(200, "eod: doing fsf 1\n");
953 Dmsg0(200, "fsf error.\n");
957 * Avoid infinite loop by ensuring we advance.
959 if (!at_eot() && file_num == (int)file) {
960 struct mtget mt_stat;
961 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
963 if (dev_get_os_pos(this, &mt_stat)) {
964 Dmsg2(100, "Adjust file from %d to %d\n", file_num, mt_stat.mt_fileno);
965 file = mt_stat.mt_fileno;
972 * Some drivers leave us after second EOF when doing
973 * MTEOM, so we must backup so that appending overwrites
976 if (has_cap(CAP_BSFATEOM)) {
977 struct mtget mt_stat;
978 /* Backup over EOF */
980 /* If BSF worked and fileno is known (not -1), set file */
981 if (dev_get_os_pos(this, &mt_stat)) {
982 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , mt_stat.mt_fileno);
983 file = mt_stat.mt_fileno;
985 file++; /* wing it -- not correct on all OSes */
988 update_pos(dcr); /* update position */
990 Dmsg1(200, "EOD dev->file=%d\n", file);
995 * Set the position of the device -- only for files and DVD
996 * For other devices, there is no generic way to do it.
997 * Returns: true on succes
1000 bool DEVICE::update_pos(DCR *dcr)
1007 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
1008 Emsg1(M_FATAL, 0, "%s", errmsg);
1012 /* Find out where we are */
1013 if (is_file() || is_dvd()) {
1016 pos = lseek(dcr, (boffset_t)0, SEEK_CUR);
1020 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
1021 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1022 print_name(), be.strerror());
1026 block_num = (uint32_t)pos;
1027 file = (uint32_t)(pos >> 32);
1034 * Return the status of the device. This was meant
1035 * to be a generic routine. Unfortunately, it doesn't
1036 * seem possible (at least I do not know how to do it
1037 * currently), which means that for the moment, this
1038 * routine has very little value.
1042 uint32_t status_dev(DEVICE *dev)
1044 struct mtget mt_stat;
1047 if (dev->state & (ST_EOT | ST_WEOT)) {
1051 if (dev->state & ST_EOF) {
1055 if (dev->is_tape()) {
1057 Pmsg0(-20,_(" Bacula status:"));
1058 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1059 if (tape_ioctl(dev->fd(), MTIOCGET, (char *)&mt_stat) < 0) {
1061 dev->dev_errno = errno;
1062 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1063 dev->print_name(), be.strerror());
1066 Pmsg0(-20, _(" Device status:"));
1068 #if defined(HAVE_LINUX_OS)
1069 if (GMT_EOF(mt_stat.mt_gstat)) {
1073 if (GMT_BOT(mt_stat.mt_gstat)) {
1077 if (GMT_EOT(mt_stat.mt_gstat)) {
1081 if (GMT_SM(mt_stat.mt_gstat)) {
1085 if (GMT_EOD(mt_stat.mt_gstat)) {
1089 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1090 stat |= BMT_WR_PROT;
1091 Pmsg0(-20, " WR_PROT");
1093 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1095 Pmsg0(-20, " ONLINE");
1097 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1098 stat |= BMT_DR_OPEN;
1099 Pmsg0(-20, " DR_OPEN");
1101 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1102 stat |= BMT_IM_REP_EN;
1103 Pmsg0(-20, " IM_REP_EN");
1105 #elif defined(HAVE_WIN32)
1106 if (GMT_EOF(mt_stat.mt_gstat)) {
1110 if (GMT_BOT(mt_stat.mt_gstat)) {
1114 if (GMT_EOT(mt_stat.mt_gstat)) {
1118 if (GMT_EOD(mt_stat.mt_gstat)) {
1122 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1123 stat |= BMT_WR_PROT;
1124 Pmsg0(-20, " WR_PROT");
1126 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1128 Pmsg0(-20, " ONLINE");
1130 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1131 stat |= BMT_DR_OPEN;
1132 Pmsg0(-20, " DR_OPEN");
1134 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1135 stat |= BMT_IM_REP_EN;
1136 Pmsg0(-20, " IM_REP_EN");
1139 #endif /* !SunOS && !OSF */
1140 if (dev->has_cap(CAP_MTIOCGET)) {
1141 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1143 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1146 stat |= BMT_ONLINE | BMT_BOT;
1153 * Load medium in device
1154 * Returns: true on success
1157 bool load_dev(DEVICE *dev)
1163 if (dev->fd() < 0) {
1164 dev->dev_errno = EBADF;
1165 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1166 Emsg0(M_FATAL, 0, dev->errmsg);
1169 if (!(dev->is_tape())) {
1173 Dmsg0(200, "stored: MTLOAD command not available\n");
1175 dev->dev_errno = ENOTTY; /* function not available */
1176 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1177 dev->print_name(), be.strerror());
1181 dev->block_num = dev->file = 0;
1184 mt_com.mt_op = MTLOAD;
1185 mt_com.mt_count = 1;
1186 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
1188 dev->dev_errno = errno;
1189 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1190 dev->print_name(), be.strerror());
1198 * Rewind device and put it offline
1199 * Returns: true on success
1202 bool DEVICE::offline()
1207 return true; /* device not open */
1210 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1211 block_num = file = 0;
1215 mt_com.mt_op = MTOFFL;
1216 mt_com.mt_count = 1;
1217 if (tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
1220 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1221 print_name(), be.strerror());
1224 Dmsg1(100, "Offlined device %s\n", print_name());
1228 bool DEVICE::offline_or_rewind()
1233 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1237 * Note, this rewind probably should not be here (it wasn't
1238 * in prior versions of Bacula), but on FreeBSD, this is
1239 * needed in the case the tape was "frozen" due to an error
1240 * such as backspacing after writing and EOF. If it is not
1241 * done, all future references to the drive get and I/O error.
1244 return rewind(NULL);
1249 * Foward space a file
1250 * Returns: true on success
1253 bool DEVICE::fsf(int num)
1255 struct mtget mt_stat;
1261 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1262 Emsg0(M_FATAL, 0, errmsg);
1272 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1276 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1279 Dmsg0(100, "fsf\n");
1282 * If Fast forward space file is set, then we
1283 * use MTFSF to forward space and MTIOCGET
1284 * to get the file position. We assume that
1285 * the SCSI driver will ensure that we do not
1286 * forward space past the end of the medium.
1288 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1289 mt_com.mt_op = MTFSF;
1290 mt_com.mt_count = num;
1291 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1292 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1295 Dmsg0(200, "Set ST_EOT\n");
1297 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1298 print_name(), be.strerror());
1299 Dmsg1(200, "%s", errmsg);
1302 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1304 file = mt_stat.mt_fileno;
1308 * Here if CAP_FSF is set, and virtually all drives
1309 * these days support it, we read a record, then forward
1310 * space one file. Using this procedure, which is slow,
1311 * is the only way we can be sure that we don't read
1312 * two consecutive EOF marks, which means End of Data.
1314 } else if (has_cap(CAP_FSF)) {
1317 Dmsg0(200, "FSF has cap_fsf\n");
1318 if (max_block_size == 0) {
1319 rbuf_len = DEFAULT_BLOCK_SIZE;
1321 rbuf_len = max_block_size;
1323 rbuf = get_memory(rbuf_len);
1324 mt_com.mt_op = MTFSF;
1325 mt_com.mt_count = 1;
1326 while (num-- && !at_eot()) {
1327 Dmsg0(100, "Doing read before fsf\n");
1328 if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1329 if (errno == ENOMEM) { /* tape record exceeds buf len */
1330 stat = rbuf_len; /* This is OK */
1332 * On IBM drives, they return ENOSPC at EOM
1333 * instead of EOF status
1335 } else if (at_eof() && errno == ENOSPC) {
1341 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1343 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1344 print_name(), be.strerror());
1345 Dmsg1(100, "%s", errmsg);
1349 if (stat == 0) { /* EOF */
1350 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1351 /* Two reads of zero means end of tape */
1354 Dmsg0(100, "Set ST_EOT\n");
1360 } else { /* Got data */
1365 Dmsg0(100, "Doing MTFSF\n");
1366 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1367 if (stat < 0) { /* error => EOT */
1370 Dmsg0(100, "Set ST_EOT\n");
1372 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1373 print_name(), be.strerror());
1374 Dmsg0(100, "Got < 0 for MTFSF\n");
1375 Dmsg1(100, "%s", errmsg);
1383 * No FSF, so use FSR to simulate it
1386 Dmsg0(200, "Doing FSR for FSF\n");
1387 while (num-- && !at_eot()) {
1388 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1392 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1398 Dmsg1(200, "Return %d from FSF\n", stat);
1400 Dmsg0(200, "ST_EOF set on exit FSF\n");
1403 Dmsg0(200, "ST_EOT set on exit FSF\n");
1405 Dmsg1(200, "Return from FSF file=%d\n", file);
1410 * Backward space a file
1411 * Returns: false on failure
1414 bool DEVICE::bsf(int num)
1421 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1422 Emsg0(M_FATAL, 0, errmsg);
1427 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1438 mt_com.mt_op = MTBSF;
1439 mt_com.mt_count = num;
1440 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1444 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1445 print_name(), be.strerror());
1452 * Foward space num records
1453 * Returns: false on failure
1456 bool DEVICE::fsr(int num)
1463 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1464 Emsg0(M_FATAL, 0, errmsg);
1472 if (!has_cap(CAP_FSR)) {
1473 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1477 Dmsg1(29, "fsr %d\n", num);
1478 mt_com.mt_op = MTFSR;
1479 mt_com.mt_count = num;
1480 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1486 struct mtget mt_stat;
1488 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1489 if (dev_get_os_pos(this, &mt_stat)) {
1490 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1491 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1492 file = mt_stat.mt_fileno;
1493 block_num = mt_stat.mt_blkno;
1501 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1502 num, print_name(), be.strerror());
1508 * Backward space a record
1509 * Returns: false on failure
1512 bool DEVICE::bsr(int num)
1519 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1520 Emsg0(M_FATAL, 0, errmsg);
1528 if (!has_cap(CAP_BSR)) {
1529 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1533 Dmsg0(29, "bsr_dev\n");
1537 mt_com.mt_op = MTBSR;
1538 mt_com.mt_count = num;
1539 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1543 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1544 print_name(), be.strerror());
1549 void DEVICE::lock_door()
1553 mt_com.mt_op = MTLOCK;
1554 mt_com.mt_count = 1;
1555 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1559 void DEVICE::unlock_door()
1563 mt_com.mt_op = MTUNLOCK;
1564 mt_com.mt_count = 1;
1565 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1571 * Reposition the device to file, block
1572 * Returns: false on failure
1575 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1579 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1580 Emsg0(M_FATAL, 0, errmsg);
1585 boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1586 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1587 if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1590 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1591 print_name(), be.strerror());
1600 /* After this point, we are tape only */
1601 Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1603 Dmsg0(100, "Rewind\n");
1604 if (!rewind(NULL)) {
1609 Dmsg1(100, "fsf %d\n", rfile-file);
1610 if (!fsf(rfile-file)) {
1611 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1614 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1616 if (rblock < block_num) {
1617 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1618 Dmsg0(100, "bsf 1\n");
1620 Dmsg0(100, "fsf 1\n");
1622 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1624 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1625 /* Ignore errors as Bacula can read to the correct block */
1626 Dmsg1(100, "fsr %d\n", rblock-block_num);
1627 return fsr(rblock-block_num);
1629 while (rblock > block_num) {
1630 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1633 Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1634 print_name(), be.strerror());
1637 Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1646 * Write an end of file on the device
1647 * Returns: true on success
1650 bool DEVICE::weof(int num)
1654 Dmsg0(129, "weof_dev\n");
1658 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1659 Emsg0(M_FATAL, 0, errmsg);
1667 if (!can_append()) {
1668 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1669 Emsg0(M_FATAL, 0, errmsg);
1675 mt_com.mt_op = MTWEOF;
1676 mt_com.mt_count = num;
1677 stat = tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1686 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1687 print_name(), be.strerror());
1695 * If implemented in system, clear the tape
1698 void DEVICE::clrerror(int func)
1700 const char *msg = NULL;
1701 struct mtget mt_stat;
1704 dev_errno = errno; /* save errno */
1706 VolCatInfo.VolCatErrors++;
1713 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1716 break; /* ignore message printed later */
1719 clear_cap(CAP_EOF); /* turn off feature */
1724 clear_cap(CAP_EOM); /* turn off feature */
1729 clear_cap(CAP_FSF); /* turn off feature */
1733 clear_cap(CAP_BSF); /* turn off feature */
1737 clear_cap(CAP_FSR); /* turn off feature */
1741 clear_cap(CAP_BSR); /* turn off feature */
1751 #ifdef MTSETDRVBUFFER
1752 case MTSETDRVBUFFER:
1753 msg = "MTSETDRVBUFFER";
1786 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1792 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1793 Emsg0(M_ERROR, 0, errmsg);
1798 * Now we try different methods of clearing the error
1799 * status on the drive so that it is not locked for
1800 * further operations.
1803 /* On some systems such as NetBSD, this clears all errors */
1804 tape_ioctl(m_fd, MTIOCGET, (char *)&mt_stat);
1806 /* Found on Linux */
1810 mt_com.mt_op = MTIOCLRERR;
1811 mt_com.mt_count = 1;
1812 /* Clear any error condition on the tape */
1813 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1814 Dmsg0(200, "Did MTIOCLRERR\n");
1818 /* Typically on FreeBSD */
1822 /* Read and clear SCSI error status */
1823 union mterrstat mt_errstat;
1824 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1825 be.strerror(dev_errno));
1826 tape_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1830 /* Clear Subsystem Exception OSF1 */
1834 mt_com.mt_op = MTCSE;
1835 mt_com.mt_count = 1;
1836 /* Clear any error condition on the tape */
1837 tape_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1838 Dmsg0(200, "Did MTCSE\n");
1846 void DEVICE::close()
1848 Dmsg1(100, "close_dev %s\n", print_name());
1849 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1854 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1856 return; /* already closed */
1868 /* Clean up device packet so it can be reused */
1870 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1871 label_type = B_BACULA_LABEL;
1872 file = block_num = 0;
1875 EndFile = EndBlock = 0;
1877 Slot = -1; /* unknown slot */
1879 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1880 memset(&VolHdr, 0, sizeof(VolHdr));
1882 stop_thread_timer(tid);
1888 * This call closes the device, but it is used in DVD handling
1889 * where we close one part and then open the next part. The
1890 * difference between close_part() and close() is that close_part()
1891 * saves the state information of the device (e.g. the Volume lable,
1892 * the Volume Catalog record, ... This permits opening and closing
1893 * the Volume parts multiple times without losing track of what the
1894 * main Volume parameters are.
1896 void DEVICE::close_part(DCR *dcr)
1898 VOLUME_LABEL saveVolHdr;
1899 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1902 saveVolHdr = VolHdr; /* structure assignment */
1903 saveVolCatInfo = VolCatInfo; /* structure assignment */
1904 close(); /* close current part */
1905 VolHdr = saveVolHdr; /* structure assignment */
1906 VolCatInfo = saveVolCatInfo; /* structure assignment */
1907 dcr->VolCatInfo = saveVolCatInfo; /* structure assignment */
1910 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1914 return lseek_dvd(dcr, offset, whence);
1916 #if defined(HAVE_WIN32)
1917 return ::_lseeki64(m_fd, (__int64)offset, whence);
1919 return ::lseek(m_fd, (off_t)offset, whence);
1926 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1928 Dmsg1(100, "truncate %s\n", print_name());
1931 /* maybe we should rewind and write and eof ???? */
1932 return true; /* we don't really truncate tapes */
1934 return truncate_dvd(dcr);
1936 /* ***FIXME*** we really need to unlink() the file so that
1937 * its name can be changed for a relabel.
1939 if (ftruncate(m_fd, 0) != 0) {
1941 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1942 print_name(), be.strerror());
1950 /* Mount the device.
1951 * If timeout, wait until the mount command returns 0.
1952 * If !timeout, try to mount the device only once.
1954 bool DEVICE::mount(int timeout)
1956 Dmsg0(190, "Enter mount\n");
1959 } else if (requires_mount()) {
1960 return do_mount(1, timeout);
1965 /* Unmount the device
1966 * If timeout, wait until the unmount command returns 0.
1967 * If !timeout, try to unmount the device only once.
1969 bool DEVICE::unmount(int timeout)
1971 Dmsg0(90, "Enter unmount\n");
1973 return do_mount(0, timeout);
1978 /* (Un)mount the device */
1979 bool DEVICE::do_mount(int mount, int dotimeout)
1981 POOL_MEM ocmd(PM_FNAME);
1984 int status, timeout;
1986 sm_check(__FILE__, __LINE__, false);
1989 Dmsg0(200, "======= mount=1\n");
1992 icmd = device->mount_command;
1994 if (!is_mounted()) {
1995 Dmsg0(200, "======= mount=0\n");
1998 icmd = device->unmount_command;
2001 clear_freespace_ok();
2002 edit_mount_codes(ocmd, icmd);
2004 Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2007 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
2012 results = get_memory(4000);
2015 /* If busy retry each second */
2016 Dmsg1(20, "do_mount run_prog=%s\n", ocmd.c_str());
2017 while ((status = run_program_full_output(ocmd.c_str(),
2018 max_open_wait/2, results)) != 0) {
2019 /* Doesn't work with internationalization (This is not a problem) */
2020 if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2023 if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2026 if (timeout-- > 0) {
2027 /* Sometimes the device cannot be mounted because it is already mounted.
2028 * Try to unmount it, then remount it */
2030 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2038 Dmsg5(40, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2039 (mount ? "" : "un"), status, results, be.strerror(status));
2040 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2041 print_name(), (mount ? "" : "un"), be.strerror(status));
2043 Dmsg4(40, "Device %s cannot be %smounted. stat=%d ERR=%s\n", print_name(),
2044 (mount ? "" : "un"), status, results);
2045 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2046 print_name(), (mount ? "" : "un"), results);
2049 * Now, just to be sure it is not mounted, try to read the
2053 struct dirent *entry, *result;
2057 name_max = pathconf(".", _PC_NAME_MAX);
2058 if (name_max < 1024) {
2062 if (!(dp = opendir(device->mount_point))) {
2065 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2066 device->mount_point, print_name(), be.strerror());
2070 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2073 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2075 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
2076 device->mount_point, print_name());
2079 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2080 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2083 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2089 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2092 /* If we got more than ., .. and .keep */
2093 /* there must be something mounted */
2095 Dmsg1(100, "Did Mount by count=%d\n", count);
2098 /* An unmount request. We failed to unmount - report an error */
2100 free_pool_memory(results);
2101 Dmsg0(200, "== error mount=1 wanted unmount\n");
2107 sm_check(__FILE__, __LINE__, false);
2108 free_pool_memory(results);
2109 Dmsg0(200, "============ mount=0\n");
2113 set_mounted(mount); /* set/clear mounted flag */
2114 free_pool_memory(results);
2115 /* Do not check free space when unmounting */
2116 if (mount && !update_freespace()) {
2119 Dmsg1(200, "============ mount=%d\n", mount);
2124 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2126 * %a = archive device name
2127 * %e = erase (set if cannot mount and first part)
2130 * %v = last part name
2132 * omsg = edited output message
2133 * imsg = input string containing edit codes (%x)
2136 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2142 POOL_MEM archive_name(PM_FNAME);
2144 omsg.c_str()[0] = 0;
2145 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2146 for (p=imsg; *p; p++) {
2156 if (num_dvd_parts == 0) {
2157 if (truncating || blank_dvd) {
2167 bsnprintf(add, sizeof(add), "%d", part);
2171 str = device->mount_point;
2174 make_spooled_dvd_filename(this, archive_name);
2175 str = archive_name.c_str();
2189 Dmsg1(1900, "add_str %s\n", str);
2190 pm_strcat(omsg, (char *)str);
2191 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2195 /* return the last timer interval (ms) */
2196 btime_t DEVICE::get_timer_count()
2198 btime_t old = last_timer;
2199 last_timer = get_current_btime();
2200 return last_timer - old;
2204 ssize_t DEVICE::read(void *buf, size_t len)
2210 if (this->is_tape()) {
2211 read_len = tape_read(m_fd, buf, len);
2213 read_len = ::read(m_fd, buf, len);
2216 last_tick = get_timer_count();
2218 DevReadTime += last_tick;
2219 VolCatInfo.VolReadTime += last_tick;
2221 if (read_len > 0) { /* skip error */
2222 DevReadBytes += read_len;
2229 ssize_t DEVICE::write(const void *buf, size_t len)
2235 if (this->is_tape()) {
2236 write_len = tape_write(m_fd, buf, len);
2238 write_len = ::write(m_fd, buf, len);
2241 last_tick = get_timer_count();
2243 DevWriteTime += last_tick;
2244 VolCatInfo.VolWriteTime += last_tick;
2246 if (write_len > 0) { /* skip error */
2247 DevWriteBytes += write_len;
2253 /* Return the resource name for the device */
2254 const char *DEVICE::name() const
2256 return device->hdr.name;
2260 dev_vol_name(DEVICE *dev)
2262 return dev->VolCatInfo.VolCatName;
2267 * Free memory allocated for the device
2269 void DEVICE::term(void)
2271 Dmsg1(900, "term dev: %s\n", print_name());
2274 free_memory(dev_name);
2278 free_memory(prt_name);
2282 free_pool_memory(errmsg);
2285 pthread_mutex_destroy(&mutex);
2286 pthread_cond_destroy(&wait);
2287 pthread_cond_destroy(&wait_next_vol);
2288 pthread_mutex_destroy(&spool_mutex);
2290 if (attached_dcrs) {
2291 delete attached_dcrs;
2292 attached_dcrs = NULL;
2301 * This routine initializes the device wait timers
2303 void init_device_wait_timers(DCR *dcr)
2305 DEVICE *dev = dcr->dev;
2306 JCR *jcr = dcr->jcr;
2308 /* ******FIXME******* put these on config variables */
2309 dev->min_wait = 60 * 60;
2310 dev->max_wait = 24 * 60 * 60;
2311 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2312 dev->wait_sec = dev->min_wait;
2313 dev->rem_wait_sec = dev->wait_sec;
2316 dev->BadVolName[0] = 0;
2318 jcr->min_wait = 60 * 60;
2319 jcr->max_wait = 24 * 60 * 60;
2320 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2321 jcr->wait_sec = jcr->min_wait;
2322 jcr->rem_wait_sec = jcr->wait_sec;
2327 void init_jcr_device_wait_timers(JCR *jcr)
2329 /* ******FIXME******* put these on config variables */
2330 jcr->min_wait = 60 * 60;
2331 jcr->max_wait = 24 * 60 * 60;
2332 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2333 jcr->wait_sec = jcr->min_wait;
2334 jcr->rem_wait_sec = jcr->wait_sec;
2340 * The dev timers are used for waiting on a particular device
2342 * Returns: true if time doubled
2343 * false if max time expired
2345 bool double_dev_wait_time(DEVICE *dev)
2347 dev->wait_sec *= 2; /* double wait time */
2348 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2349 dev->wait_sec = dev->max_wait;
2352 dev->rem_wait_sec = dev->wait_sec;
2353 if (dev->num_wait >= dev->max_num_wait) {
2360 void set_os_device_parameters(DCR *dcr)
2362 DEVICE *dev = dcr->dev;
2364 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2367 Dmsg0(050, "In set_os_device_parameters\n");
2368 #if defined(MTSETBLK)
2369 if (dev->min_block_size == dev->max_block_size &&
2370 dev->min_block_size == 0) { /* variable block mode */
2371 mt_com.mt_op = MTSETBLK;
2372 mt_com.mt_count = 0;
2373 Dmsg0(050, "Set block size to zero\n");
2374 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2375 dev->clrerror(MTSETBLK);
2379 #if defined(MTSETDRVBUFFER)
2380 if (getpid() == 0) { /* Only root can do this */
2381 mt_com.mt_op = MTSETDRVBUFFER;
2382 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2383 if (!dev->has_cap(CAP_TWOEOF)) {
2384 mt_com.mt_count |= MT_ST_TWO_FM;
2386 if (dev->has_cap(CAP_EOM)) {
2387 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2389 Dmsg0(050, "MTSETDRVBUFFER\n");
2390 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2391 dev->clrerror(MTSETDRVBUFFER);
2398 #ifdef HAVE_NETBSD_OS
2400 if (dev->min_block_size == dev->max_block_size &&
2401 dev->min_block_size == 0) { /* variable block mode */
2402 mt_com.mt_op = MTSETBSIZ;
2403 mt_com.mt_count = 0;
2404 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2405 dev->clrerror(MTSETBSIZ);
2407 /* Get notified at logical end of tape */
2408 mt_com.mt_op = MTEWARN;
2409 mt_com.mt_count = 1;
2410 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2411 dev->clrerror(MTEWARN);
2417 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2419 if (dev->min_block_size == dev->max_block_size &&
2420 dev->min_block_size == 0) { /* variable block mode */
2421 mt_com.mt_op = MTSETBSIZ;
2422 mt_com.mt_count = 0;
2423 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2424 dev->clrerror(MTSETBSIZ);
2427 /* Turn this on later when fully tested */
2428 #if defined(xxxMTIOCSETEOTMODEL)
2430 if (dev->has_cap(CAP_TWOEOF)) {
2435 if (ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2437 dev->dev_errno = errno; /* save errno */
2438 Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2439 dev->print_name(), be.strerror(dev->dev_errno));
2440 Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2448 if (dev->min_block_size == dev->max_block_size &&
2449 dev->min_block_size == 0) { /* variable block mode */
2450 mt_com.mt_op = MTSRSZ;
2451 mt_com.mt_count = 0;
2452 if (tape_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2453 dev->clrerror(MTSRSZ);
2460 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2462 Dmsg0(050, "dev_get_os_pos\n");
2463 return dev->has_cap(CAP_MTIOCGET) &&
2464 tape_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2465 mt_stat->mt_fileno >= 0;
2468 static char *modes[] = {
2469 "CREATE_READ_WRITE",
2476 static char *mode_to_str(int mode)
2478 static char buf[100];
2479 if (mode < 1 || mode > 4) {
2480 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2483 return modes[mode-1];