2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
6 The main author of Bacula is Kern Sibbald, with contributions from
7 many others, a complete list can be found in the file AUTHORS.
8 This program is Free Software; you can redistribute it and/or
9 modify it under the terms of version two of the GNU General Public
10 License as published by the Free Software Foundation and included
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 Bacula® is a registered trademark of Kern Sibbald.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
30 * dev.c -- low level operations on device (storage device)
34 * NOTE!!!! None of these routines are reentrant. You must
35 * use dev->r_dlock() and dev->unlock() at a higher level,
36 * or use the xxx_device() equivalents. By moving the
37 * thread synchronization to a higher level, we permit
38 * the higher level routines to "seize" the device and
39 * to carry out operations without worrying about who
40 * set what lock (i.e. race conditions).
42 * Note, this is the device dependent code, and may have
43 * to be modified for each system, but is meant to
44 * be as "generic" as possible.
46 * The purpose of this code is to develop a SIMPLE Storage
47 * daemon. More complicated coding (double buffering, writer
48 * thread, ...) is left for a later version.
54 * Handling I/O errors and end of tape conditions are a bit tricky.
55 * This is how it is currently done when writting.
56 * On either an I/O error or end of tape,
57 * we will stop writing on the physical device (no I/O recovery is
58 * attempted at least in this daemon). The state flag will be sent
59 * to include ST_EOT, which is ephemeral, and ST_WEOT, which is
60 * persistent. Lots of routines clear ST_EOT, but ST_WEOT is
61 * cleared only when the problem goes away. Now when ST_WEOT
62 * is set all calls to write_block_to_device() call the fix_up
63 * routine. In addition, all threads are blocked
64 * from writing on the tape by calling lock_dev(), and thread other
65 * than the first thread to hit the EOT will block on a condition
66 * variable. The first thread to hit the EOT will continue to
67 * be able to read and write the tape (he sort of tunnels through
68 * the locking mechanism -- see lock_dev() for details).
70 * Now presumably somewhere higher in the chain of command
71 * (device.c), someone will notice the EOT condition and
72 * get a new tape up, get the tape label read, and mark
73 * the label for rewriting. Then this higher level routine
74 * will write the unwritten buffer to the new volume.
75 * Finally, he will release
76 * any blocked threads by doing a broadcast on the condition
77 * variable. At that point, we should be totally back in
78 * business with no lost data.
89 /* Forward referenced functions */
90 void set_os_device_parameters(DCR *dcr);
91 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat);
92 static const char *mode_to_str(int mode);
95 * Allocate and initialize the DEVICE structure
96 * Note, if dev is non-NULL, it is already allocated,
97 * thus we neither allocate it nor free it. This allows
98 * the caller to put the packet in shared memory.
100 * Note, for a tape, the device->device_name is the device name
101 * (e.g. /dev/nst0), and for a file, the device name
102 * is the directory in which the file will be placed.
106 init_dev(JCR *jcr, DEVRES *device)
115 /* If no device type specified, try to guess */
116 if (!device->dev_type) {
117 /* Check that device is available */
118 if (stat(device->device_name, &statp) < 0) {
120 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
121 device->device_name, be.bstrerror());
124 if (S_ISDIR(statp.st_mode)) {
125 device->dev_type = B_FILE_DEV;
126 } else if (S_ISCHR(statp.st_mode)) {
127 device->dev_type = B_TAPE_DEV;
128 } else if (S_ISFIFO(statp.st_mode)) {
129 device->dev_type = B_FIFO_DEV;
131 /* must set DeviceType = Vtape
132 * in normal mode, autodetection is disabled
134 } else if (S_ISREG(statp.st_mode)) {
135 device->dev_type = B_VTAPE_DEV;
137 } else if (!(device->cap_bits & CAP_REQMOUNT)) {
138 Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
139 " or have RequiresMount=yes for DVD. st_mode=%x\n"),
140 device->device_name, statp.st_mode);
143 device->dev_type = B_DVD_DEV;
147 dev = (DEVICE *)malloc(sizeof(DEVICE));
148 memset(dev, 0, sizeof(DEVICE));
149 dev->clear_slot(); /* unknown */
151 /* Copy user supplied device parameters from Resource */
152 dev->dev_name = get_memory(strlen(device->device_name)+1);
153 pm_strcpy(dev->dev_name, device->device_name);
154 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
155 /* We edit "Resource-name" (physical-name) */
156 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
157 Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
158 dev->capabilities = device->cap_bits;
159 dev->min_block_size = device->min_block_size;
160 dev->max_block_size = device->max_block_size;
161 dev->max_volume_size = device->max_volume_size;
162 dev->max_file_size = device->max_file_size;
163 dev->volume_capacity = device->volume_capacity;
164 dev->max_rewind_wait = device->max_rewind_wait;
165 dev->max_open_wait = device->max_open_wait;
166 dev->max_open_vols = device->max_open_vols;
167 dev->vol_poll_interval = device->vol_poll_interval;
168 dev->max_spool_size = device->max_spool_size;
169 dev->drive_index = device->drive_index;
170 dev->autoselect = device->autoselect;
171 dev->dev_type = device->dev_type;
173 if (dev->is_tape()) { /* No parts on tapes */
174 dev->max_part_size = 0;
176 dev->max_part_size = device->max_part_size;
179 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
180 dev->vol_poll_interval = 60;
182 /* Link the dev and device structures together */
183 dev->device = device;
186 if (dev->is_fifo()) {
187 dev->capabilities |= CAP_STREAM; /* set stream device */
190 /* If the device requires mount :
191 * - Check that the mount point is available
192 * - Check that (un)mount commands are defined
194 if ((dev->is_file() || dev->is_dvd()) && dev->requires_mount()) {
195 if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
197 dev->dev_errno = errno;
198 Jmsg2(jcr, M_ERROR_TERM, 0, _("Unable to stat mount point %s: ERR=%s\n"),
199 device->mount_point, be.bstrerror());
203 if (!device->mount_command || !device->unmount_command) {
204 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
206 if (!device->write_part_command) {
207 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
212 if (dev->max_block_size == 0) {
213 max_bs = DEFAULT_BLOCK_SIZE;
215 max_bs = dev->max_block_size;
217 if (dev->min_block_size > max_bs) {
218 Jmsg(jcr, M_ERROR_TERM, 0, _("Min block size > max on device %s\n"),
221 if (dev->max_block_size > 4096000) {
222 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
223 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
224 dev->max_block_size = 0;
226 if (dev->max_block_size % TAPE_BSIZE != 0) {
227 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
228 dev->max_block_size, dev->print_name());
231 dev->errmsg = get_pool_memory(PM_EMSG);
234 if ((errstat = pthread_mutex_init(&dev->m_mutex, NULL)) != 0) {
236 dev->dev_errno = errstat;
237 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
238 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
240 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
242 dev->dev_errno = errstat;
243 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
244 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
246 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
248 dev->dev_errno = errstat;
249 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
250 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
252 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
254 dev->dev_errno = errstat;
255 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
256 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
259 if ((errstat = rwl_init(&dev->lock)) != 0) {
261 dev->dev_errno = errstat;
262 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
263 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
268 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
269 Dmsg2(100, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
270 dev->initiated = true;
275 /* Choose the right backend */
276 void DEVICE::init_backend()
281 d_open = win32_tape_open;
282 d_write = win32_tape_write;
283 d_close = win32_tape_close;
284 d_ioctl = win32_tape_ioctl;
285 d_read = win32_tape_read;
290 d_ioctl = win32_ioctl; /* dummy function */
291 d_write = win32_write; /* win32 read/write are not POSIX */
295 #else /* POSIX / UNIX Interface */
296 if (is_vtape()) { /* test backend */
297 d_open = vtape_open; /* vtape isn't available for WIN32 or FreeBSD */
298 d_write = vtape_write;
299 d_close = vtape_close;
300 d_ioctl = vtape_ioctl;
303 } else { /* tape and file are using normal io */
314 * Open the device with the operating system and
315 * initialize buffer pointers.
317 * Returns: -1 on error
320 * Note, for a tape, the VolName is the name we give to the
321 * volume (not really used here), but for a file, the
322 * VolName represents the name of the file to be created/opened.
323 * In the case of a file, the full name is the device name
324 * (archive_name) with the VolName concatenated.
327 DEVICE::open(DCR *dcr, int omode)
331 if (openmode == omode) {
336 Dmsg0(100, "Close fd for mode change.\n");
337 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
341 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
344 Dmsg4(100, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
345 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
346 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
347 label_type = B_BACULA_LABEL;
348 if (is_tape() || is_fifo()) {
349 open_tape_device(dcr, omode);
350 } else if (is_dvd()) {
351 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
352 open_dvd_device(dcr, omode);
354 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
355 open_file_device(dcr, omode);
357 state |= preserve; /* reset any important state info */
358 Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, m_fd);
362 void DEVICE::set_mode(int new_mode)
365 case CREATE_READ_WRITE:
366 mode = O_CREAT | O_RDWR | O_BINARY;
368 case OPEN_READ_WRITE:
369 mode = O_RDWR | O_BINARY;
372 mode = O_RDONLY | O_BINARY;
374 case OPEN_WRITE_ONLY:
375 mode = O_WRONLY | O_BINARY;
378 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
384 void DEVICE::open_tape_device(DCR *dcr, int omode)
387 int timeout = max_open_wait;
388 #if !defined(HAVE_WIN32)
390 utime_t start_time = time(NULL);
394 Dmsg0(100, "Open dev: device is tape\n");
396 get_autochanger_loaded_slot(dcr);
405 if (is_fifo() && timeout) {
407 tid = start_thread_timer(dcr->jcr, pthread_self(), timeout);
409 Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
410 #if defined(HAVE_WIN32)
413 if ((m_fd = d_open(dev_name, mode)) < 0) {
420 /* If busy retry each second for max_open_wait seconds */
422 /* Try non-blocking open */
423 m_fd = d_open(dev_name, mode+O_NONBLOCK);
427 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
428 print_name(), omode, mode, errno, be.bstrerror());
430 /* Tape open, now rewind it */
431 Dmsg0(100, "Rewind after open\n");
432 mt_com.mt_op = MTREW;
434 /* rewind only if dev is a tape */
435 if (is_tape() && (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0)) {
437 dev_errno = errno; /* set error status from rewind */
440 Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
441 be.bstrerror(dev_errno));
442 /* If we get busy, device is probably rewinding, try again */
443 if (dev_errno != EBUSY) {
444 break; /* error -- no medium */
447 /* Got fd and rewind worked, so we must have medium in drive */
449 m_fd = d_open(dev_name, mode); /* open normally */
453 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
454 print_name(), omode, mode, errno, be.bstrerror());
459 set_os_device_parameters(dcr); /* do system dependent stuff */
460 break; /* Successfully opened and rewound */
464 /* Exceed wait time ? */
465 if (time(NULL) - start_time >= max_open_wait) {
466 break; /* yes, get out */
473 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
474 print_name(), be.bstrerror(dev_errno));
475 Dmsg1(100, "%s", errmsg);
478 /* Stop any open() timer we started */
480 stop_thread_timer(tid);
483 Dmsg1(100, "open dev: tape %d opened\n", m_fd);
490 void DEVICE::open_file_device(DCR *dcr, int omode)
492 POOL_MEM archive_name(PM_FNAME);
494 get_autochanger_loaded_slot(dcr);
497 * Handle opening of File Archive (not a tape)
500 pm_strcpy(archive_name, dev_name);
502 * If this is a virtual autochanger (i.e. changer_res != NULL)
503 * we simply use the device name, assuming it has been
504 * appropriately setup by the "autochanger".
506 if (!device->changer_res || device->changer_command[0] == 0) {
507 if (VolCatInfo.VolCatName[0] == 0) {
508 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
514 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
515 pm_strcat(archive_name, "/");
517 pm_strcat(archive_name, VolCatInfo.VolCatName);
520 mount(1); /* do mount if required */
524 /* If creating file, give 0640 permissions */
525 Dmsg3(100, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
526 archive_name.c_str(), mode);
527 /* Use system open() */
528 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
531 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
533 Dmsg1(100, "open failed: %s", errmsg);
534 Jmsg1(NULL, M_WARNING, 0, "%s", errmsg);
540 Dmsg4(100, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
541 m_fd, part, num_dvd_parts, part_size);
545 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
546 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
547 * has the desired Volume name, but there is NO assurance that
548 * any other field of VolCatInfo is correct.
550 void DEVICE::open_dvd_device(DCR *dcr, int omode)
552 POOL_MEM archive_name(PM_FNAME);
553 struct stat filestat;
556 * Handle opening of DVD Volume
558 Dmsg2(100, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n",
559 &dcr->VolCatInfo, mode_to_str(omode));
562 * For a DVD we must always pull the state info from dcr->VolCatInfo
563 * This is a bit ugly, but is necessary because we need to open/close/re-open
564 * the dvd file in order to properly mount/unmount and access the
565 * DVD. So we store the state of the DVD as far as is known in the
566 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
567 * copy here, when opening.
569 VolCatInfo = dcr->VolCatInfo; /* structure assignment */
570 Dmsg1(100, "Volume=%s\n", VolCatInfo.VolCatName);
572 if (VolCatInfo.VolCatName[0] == 0) {
573 Dmsg1(10, "Could not open DVD device %s. No Volume name given.\n",
575 Mmsg(errmsg, _("Could not open DVD device %s. No Volume name given.\n"),
582 Dmsg0(100, "Set part=1\n");
583 part = 1; /* count from 1 */
587 if (num_dvd_parts != VolCatInfo.VolCatParts) {
588 num_dvd_parts = VolCatInfo.VolCatParts;
592 * If we are not trying to access the last part, set mode to
593 * OPEN_READ_ONLY as writing would be an error.
595 Dmsg2(100, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
596 /* Now find the name of the part that we want to access */
597 if (part <= num_dvd_parts) {
598 omode = OPEN_READ_ONLY;
599 make_mounted_dvd_filename(this, archive_name);
600 set_part_spooled(false);
602 omode = OPEN_READ_WRITE;
603 make_spooled_dvd_filename(this, archive_name);
604 set_part_spooled(true);
608 // Clear any previous blank_dvd status - we will recalculate it here
611 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
612 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
615 Dmsg0(99, "DVD device mounted.\n");
616 if (num_dvd_parts == 0 && !truncating) {
618 * If we can mount the device, and we are not truncating the DVD,
619 * we usually want to abort. There is one exception, if there is
620 * only one 0-sized file on the DVD, with the right volume name,
621 * we continue (it's the method used by truncate_dvd to truncate a volume).
623 if (!check_can_write_on_non_blank_dvd(dcr)) {
624 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
625 Emsg0(M_FATAL, 0, errmsg);
626 unmount(1); /* Unmount the device, so the operator can change it. */
633 * Ensure that we have the correct DVD loaded by looking for part1.
634 * We only succeed the open if it exists. Failure to do this could
635 * leave us trying to add a part to a different DVD!
637 uint32_t oldpart = part;
639 POOL_MEM part1_name(PM_FNAME);
641 make_mounted_dvd_filename(this, part1_name);
643 if (stat(part1_name.c_str(), &statp) < 0) {
645 Mmsg(errmsg, _("Unable to stat DVD part 1 file %s: ERR=%s\n"),
646 part1_name.c_str(), be.bstrerror());
647 Emsg0(M_FATAL, 0, errmsg);
651 if (!S_ISREG(statp.st_mode)) {
652 /* It is not a regular file */
653 Mmsg(errmsg, _("DVD part 1 is not a regular file %s.\n"),
655 Emsg0(M_FATAL, 0, errmsg);
661 Dmsg0(99, "DVD device mount failed.\n");
662 /* We cannot mount the device */
663 if (num_dvd_parts == 0) {
664 /* Run free space, check there is a media. */
665 if (!update_freespace()) {
666 Emsg0(M_FATAL, 0, errmsg);
671 Dmsg1(100, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
673 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
674 Emsg0(M_FATAL, 0, errmsg);
679 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
680 Emsg0(M_FATAL, 0, errmsg);
686 Dmsg5(100, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
687 archive_name.c_str(), mode_to_str(omode),
688 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
690 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
693 /* If creating file, give 0640 permissions */
694 Dmsg3(100, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
695 archive_name.c_str(), mode);
696 /* Use system open() */
697 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
699 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
701 // Should this be set if we try the create/open below
702 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
703 Dmsg1(100, "open failed: %s", errmsg);
705 /* Previous open failed. See if we can recover */
706 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
707 (part > num_dvd_parts)) {
708 /* If the last part (on spool), doesn't exist when accessing,
709 * create it. In read/write mode a write will be allowed (higher
710 * level software thinks that we are extending a pre-existing
711 * media. Reads for READ_ONLY will report immediately an EOF
712 * Sometimes it is better to finish with an EOF than with an error. */
713 Dmsg1(100, "Creating last part on spool: %s\n", archive_name.c_str());
714 omode = CREATE_READ_WRITE;
715 set_mode(CREATE_READ_WRITE);
716 m_fd = ::open(archive_name.c_str(), mode, 0640);
720 Dmsg1(100, "after open fd=%d\n", m_fd);
722 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
725 /* Get size of file */
726 if (fstat(m_fd, &filestat) < 0) {
729 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
731 Dmsg1(100, "open failed: %s", errmsg);
732 /* Use system close() */
736 part_size = filestat.st_size;
738 update_pos(dcr); /* update position */
746 * Returns: true on success
749 bool DEVICE::rewind(DCR *dcr)
755 Dmsg3(400, "rewind res=%d fd=%d %s\n", num_reserved(), m_fd, print_name());
756 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
757 block_num = file = 0;
761 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
763 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
765 Emsg0(M_ABORT, 0, errmsg);
770 mt_com.mt_op = MTREW;
772 /* If we get an I/O error on rewind, it is probably because
773 * the drive is actually busy. We loop for (about 5 minutes)
774 * retrying every 5 seconds.
776 for (i=max_rewind_wait; ; i -= 5) {
777 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
780 if (i == max_rewind_wait) {
781 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.bstrerror());
784 * This is a gross hack, because if the user has the
785 * device mounted (i.e. open), then uses mtx to load
786 * a tape, the current open file descriptor is invalid.
787 * So, we close the drive and re-open it.
790 int open_mode = openmode;
793 open(dcr, open_mode);
801 if (dev_errno == EIO) {
802 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
806 if (dev_errno == EIO && i > 0) {
807 Dmsg0(200, "Sleeping 5 seconds.\n");
812 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
813 print_name(), be.bstrerror());
818 } else if (is_file() || is_dvd()) {
819 if (lseek(dcr, (boffset_t)0, SEEK_SET) < 0) {
822 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
823 print_name(), be.bstrerror());
832 * Called to indicate that we have just read an
833 * EOF from the device.
835 void DEVICE::set_ateof()
847 * Called to indicate we are now at the end of the tape, and
848 * writing is not possible.
850 void DEVICE::set_ateot()
852 /* Make tape effectively read-only */
853 state |= (ST_EOF|ST_EOT|ST_WEOT);
858 * Position device to end of medium (end of data)
859 * Returns: true on succes
862 bool DEVICE::eod(DCR *dcr)
871 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
875 #if defined (__digital__) && defined (__unix__)
876 return fsf(VolCatInfo.VolCatFiles);
883 clear_eof(); /* remove EOF flag */
884 block_num = file = 0;
891 pos = lseek(dcr, (boffset_t)0, SEEK_END);
892 // Dmsg1(100, "====== Seek to %lld\n", pos);
900 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
901 print_name(), be.bstrerror());
905 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
906 Dmsg0(100,"Using FAST FSF for EOM\n");
907 /* If unknown position, rewind */
908 if (get_os_tape_file() < 0) {
913 mt_com.mt_op = MTFSF;
915 * ***FIXME*** fix code to handle case that INT16_MAX is
918 mt_com.mt_count = INT16_MAX; /* use big positive number */
919 if (mt_com.mt_count < 0) {
920 mt_com.mt_count = INT16_MAX; /* brain damaged system */
924 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
925 if (has_cap(CAP_EOM)) {
926 Dmsg0(100,"Using EOM for EOM\n");
927 mt_com.mt_op = MTEOM;
931 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
933 clrerror(mt_com.mt_op);
934 Dmsg1(50, "ioctl error: %s\n", be.bstrerror());
936 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
937 print_name(), be.bstrerror());
941 os_file = get_os_tape_file();
945 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
946 print_name(), be.bstrerror());
949 Dmsg1(100, "EOD file=%d\n", os_file);
957 * Rewind then use FSF until EOT reached
963 * Move file by file to the end of the tape
966 for (file_num=file; !at_eot(); file_num++) {
967 Dmsg0(200, "eod: doing fsf 1\n");
969 Dmsg0(200, "fsf error.\n");
973 * Avoid infinite loop by ensuring we advance.
975 if (!at_eot() && file_num == (int)file) {
976 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
978 os_file = get_os_tape_file();
980 Dmsg2(100, "Adjust file from %d to %d\n", file_num, os_file);
988 * Some drivers leave us after second EOF when doing
989 * MTEOM, so we must backup so that appending overwrites
992 if (has_cap(CAP_BSFATEOM)) {
993 /* Backup over EOF */
995 /* If BSF worked and fileno is known (not -1), set file */
996 os_file = get_os_tape_file();
998 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , os_file);
1001 file++; /* wing it -- not correct on all OSes */
1004 update_pos(dcr); /* update position */
1006 Dmsg1(200, "EOD dev->file=%d\n", file);
1011 * Set the position of the device -- only for files and DVD
1012 * For other devices, there is no generic way to do it.
1013 * Returns: true on succes
1016 bool DEVICE::update_pos(DCR *dcr)
1023 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
1024 Emsg1(M_FATAL, 0, "%s", errmsg);
1028 /* Find out where we are */
1029 if (is_file() || is_dvd()) {
1032 pos = lseek(dcr, (boffset_t)0, SEEK_CUR);
1036 Pmsg1(000, _("Seek error: ERR=%s\n"), be.bstrerror());
1037 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1038 print_name(), be.bstrerror());
1042 block_num = (uint32_t)pos;
1043 file = (uint32_t)(pos >> 32);
1050 * Return the status of the device. This was meant
1051 * to be a generic routine. Unfortunately, it doesn't
1052 * seem possible (at least I do not know how to do it
1053 * currently), which means that for the moment, this
1054 * routine has very little value.
1058 uint32_t status_dev(DEVICE *dev)
1060 struct mtget mt_stat;
1063 if (dev->state & (ST_EOT | ST_WEOT)) {
1067 if (dev->state & ST_EOF) {
1071 if (dev->is_tape()) {
1073 Pmsg0(-20,_(" Bacula status:"));
1074 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1075 if (dev->d_ioctl(dev->fd(), MTIOCGET, (char *)&mt_stat) < 0) {
1077 dev->dev_errno = errno;
1078 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1079 dev->print_name(), be.bstrerror());
1082 Pmsg0(-20, _(" Device status:"));
1084 #if defined(HAVE_LINUX_OS)
1085 if (GMT_EOF(mt_stat.mt_gstat)) {
1089 if (GMT_BOT(mt_stat.mt_gstat)) {
1093 if (GMT_EOT(mt_stat.mt_gstat)) {
1097 if (GMT_SM(mt_stat.mt_gstat)) {
1101 if (GMT_EOD(mt_stat.mt_gstat)) {
1105 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1106 stat |= BMT_WR_PROT;
1107 Pmsg0(-20, " WR_PROT");
1109 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1111 Pmsg0(-20, " ONLINE");
1113 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1114 stat |= BMT_DR_OPEN;
1115 Pmsg0(-20, " DR_OPEN");
1117 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1118 stat |= BMT_IM_REP_EN;
1119 Pmsg0(-20, " IM_REP_EN");
1121 #elif defined(HAVE_WIN32)
1122 if (GMT_EOF(mt_stat.mt_gstat)) {
1126 if (GMT_BOT(mt_stat.mt_gstat)) {
1130 if (GMT_EOT(mt_stat.mt_gstat)) {
1134 if (GMT_EOD(mt_stat.mt_gstat)) {
1138 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1139 stat |= BMT_WR_PROT;
1140 Pmsg0(-20, " WR_PROT");
1142 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1144 Pmsg0(-20, " ONLINE");
1146 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1147 stat |= BMT_DR_OPEN;
1148 Pmsg0(-20, " DR_OPEN");
1150 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1151 stat |= BMT_IM_REP_EN;
1152 Pmsg0(-20, " IM_REP_EN");
1155 #endif /* !SunOS && !OSF */
1156 if (dev->has_cap(CAP_MTIOCGET)) {
1157 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1159 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1162 stat |= BMT_ONLINE | BMT_BOT;
1169 * Load medium in device
1170 * Returns: true on success
1173 bool load_dev(DEVICE *dev)
1179 if (dev->fd() < 0) {
1180 dev->dev_errno = EBADF;
1181 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1182 Emsg0(M_FATAL, 0, dev->errmsg);
1185 if (!(dev->is_tape())) {
1189 Dmsg0(200, "stored: MTLOAD command not available\n");
1191 dev->dev_errno = ENOTTY; /* function not available */
1192 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1193 dev->print_name(), be.bstrerror());
1197 dev->block_num = dev->file = 0;
1200 mt_com.mt_op = MTLOAD;
1201 mt_com.mt_count = 1;
1202 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
1204 dev->dev_errno = errno;
1205 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1206 dev->print_name(), be.bstrerror());
1214 * Rewind device and put it offline
1215 * Returns: true on success
1218 bool DEVICE::offline()
1223 return true; /* device not open */
1226 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1227 block_num = file = 0;
1231 mt_com.mt_op = MTOFFL;
1232 mt_com.mt_count = 1;
1233 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
1236 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1237 print_name(), be.bstrerror());
1240 Dmsg1(100, "Offlined device %s\n", print_name());
1244 bool DEVICE::offline_or_rewind()
1249 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1253 * Note, this rewind probably should not be here (it wasn't
1254 * in prior versions of Bacula), but on FreeBSD, this is
1255 * needed in the case the tape was "frozen" due to an error
1256 * such as backspacing after writing and EOF. If it is not
1257 * done, all future references to the drive get and I/O error.
1260 return rewind(NULL);
1265 * Foward space a file
1266 * Returns: true on success
1269 bool DEVICE::fsf(int num)
1271 int32_t os_file = 0;
1277 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1278 Emsg0(M_FATAL, 0, errmsg);
1288 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1292 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1295 Dmsg0(100, "fsf\n");
1298 * If Fast forward space file is set, then we
1299 * use MTFSF to forward space and MTIOCGET
1300 * to get the file position. We assume that
1301 * the SCSI driver will ensure that we do not
1302 * forward space past the end of the medium.
1304 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1306 mt_com.mt_op = MTFSF;
1307 mt_com.mt_count = num;
1308 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1310 my_errno = errno; /* save errno */
1311 } else if ((os_file=get_os_tape_file()) < 0) {
1312 my_errno = errno; /* save errno */
1314 if (my_errno != 0) {
1317 Dmsg0(200, "Set ST_EOT\n");
1319 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1320 print_name(), be.bstrerror(my_errno));
1321 Dmsg1(200, "%s", errmsg);
1325 Dmsg1(200, "fsf file=%d\n", os_file);
1331 * Here if CAP_FSF is set, and virtually all drives
1332 * these days support it, we read a record, then forward
1333 * space one file. Using this procedure, which is slow,
1334 * is the only way we can be sure that we don't read
1335 * two consecutive EOF marks, which means End of Data.
1337 } else if (has_cap(CAP_FSF)) {
1340 Dmsg0(200, "FSF has cap_fsf\n");
1341 if (max_block_size == 0) {
1342 rbuf_len = DEFAULT_BLOCK_SIZE;
1344 rbuf_len = max_block_size;
1346 rbuf = get_memory(rbuf_len);
1347 mt_com.mt_op = MTFSF;
1348 mt_com.mt_count = 1;
1349 while (num-- && !at_eot()) {
1350 Dmsg0(100, "Doing read before fsf\n");
1351 if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1352 if (errno == ENOMEM) { /* tape record exceeds buf len */
1353 stat = rbuf_len; /* This is OK */
1355 * On IBM drives, they return ENOSPC at EOM
1356 * instead of EOF status
1358 } else if (at_eof() && errno == ENOSPC) {
1364 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1366 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1367 print_name(), be.bstrerror());
1368 Dmsg1(100, "%s", errmsg);
1372 if (stat == 0) { /* EOF */
1373 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1374 /* Two reads of zero means end of tape */
1377 Dmsg0(100, "Set ST_EOT\n");
1383 } else { /* Got data */
1388 Dmsg0(100, "Doing MTFSF\n");
1389 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1390 if (stat < 0) { /* error => EOT */
1393 Dmsg0(100, "Set ST_EOT\n");
1395 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1396 print_name(), be.bstrerror());
1397 Dmsg0(100, "Got < 0 for MTFSF\n");
1398 Dmsg1(100, "%s", errmsg);
1406 * No FSF, so use FSR to simulate it
1409 Dmsg0(200, "Doing FSR for FSF\n");
1410 while (num-- && !at_eot()) {
1411 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1415 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1421 Dmsg1(200, "Return %d from FSF\n", stat);
1423 Dmsg0(200, "ST_EOF set on exit FSF\n");
1426 Dmsg0(200, "ST_EOT set on exit FSF\n");
1428 Dmsg1(200, "Return from FSF file=%d\n", file);
1433 * Backward space a file
1434 * Returns: false on failure
1437 bool DEVICE::bsf(int num)
1444 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1445 Emsg0(M_FATAL, 0, errmsg);
1450 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1455 Dmsg0(100, "bsf\n");
1461 mt_com.mt_op = MTBSF;
1462 mt_com.mt_count = num;
1463 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1467 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1468 print_name(), be.bstrerror());
1475 * Foward space num records
1476 * Returns: false on failure
1479 bool DEVICE::fsr(int num)
1486 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1487 Emsg0(M_FATAL, 0, errmsg);
1495 if (!has_cap(CAP_FSR)) {
1496 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1500 Dmsg1(100, "fsr %d\n", num);
1501 mt_com.mt_op = MTFSR;
1502 mt_com.mt_count = num;
1503 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1509 struct mtget mt_stat;
1511 Dmsg1(100, "FSF fail: ERR=%s\n", be.bstrerror());
1512 if (dev_get_os_pos(this, &mt_stat)) {
1513 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1514 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1515 file = mt_stat.mt_fileno;
1516 block_num = mt_stat.mt_blkno;
1524 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1525 num, print_name(), be.bstrerror());
1531 * Backward space a record
1532 * Returns: false on failure
1535 bool DEVICE::bsr(int num)
1542 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1543 Emsg0(M_FATAL, 0, errmsg);
1551 if (!has_cap(CAP_BSR)) {
1552 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1556 Dmsg0(100, "bsr_dev\n");
1560 mt_com.mt_op = MTBSR;
1561 mt_com.mt_count = num;
1562 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1566 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1567 print_name(), be.bstrerror());
1572 void DEVICE::lock_door()
1576 mt_com.mt_op = MTLOCK;
1577 mt_com.mt_count = 1;
1578 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1582 void DEVICE::unlock_door()
1586 mt_com.mt_op = MTUNLOCK;
1587 mt_com.mt_count = 1;
1588 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1592 void DEVICE::set_slot(int32_t slot)
1595 if (vol) vol->clear_slot();
1598 void DEVICE::clear_slot()
1601 if (vol) vol->set_slot(-1);
1607 * Reposition the device to file, block
1608 * Returns: false on failure
1611 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1615 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1616 Emsg0(M_FATAL, 0, errmsg);
1621 boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1622 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1623 if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1626 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1627 print_name(), be.bstrerror());
1636 /* After this point, we are tape only */
1637 Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1639 Dmsg0(100, "Rewind\n");
1640 if (!rewind(NULL)) {
1645 Dmsg1(100, "fsf %d\n", rfile-file);
1646 if (!fsf(rfile-file)) {
1647 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1650 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1652 if (rblock < block_num) {
1653 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1654 Dmsg0(100, "bsf 1\n");
1656 Dmsg0(100, "fsf 1\n");
1658 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1660 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1661 /* Ignore errors as Bacula can read to the correct block */
1662 Dmsg1(100, "fsr %d\n", rblock-block_num);
1663 return fsr(rblock-block_num);
1665 while (rblock > block_num) {
1666 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1669 Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1670 print_name(), be.bstrerror());
1673 Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1682 * Write an end of file on the device
1683 * Returns: true on success
1686 bool DEVICE::weof(int num)
1690 Dmsg1(129, "=== weof_dev=%s\n", print_name());
1694 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1695 Emsg0(M_FATAL, 0, errmsg);
1703 if (!can_append()) {
1704 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1705 Emsg0(M_FATAL, 0, errmsg);
1711 mt_com.mt_op = MTWEOF;
1712 mt_com.mt_count = num;
1713 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1722 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1723 print_name(), be.bstrerror());
1731 * If implemented in system, clear the tape
1734 void DEVICE::clrerror(int func)
1736 const char *msg = NULL;
1739 dev_errno = errno; /* save errno */
1741 VolCatInfo.VolCatErrors++;
1748 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1751 break; /* ignore message printed later */
1754 clear_cap(CAP_EOF); /* turn off feature */
1759 clear_cap(CAP_EOM); /* turn off feature */
1764 clear_cap(CAP_FSF); /* turn off feature */
1768 clear_cap(CAP_BSF); /* turn off feature */
1772 clear_cap(CAP_FSR); /* turn off feature */
1776 clear_cap(CAP_BSR); /* turn off feature */
1786 #ifdef MTSETDRVBUFFER
1787 case MTSETDRVBUFFER:
1788 msg = "MTSETDRVBUFFER";
1821 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1827 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1828 Emsg0(M_ERROR, 0, errmsg);
1833 * Now we try different methods of clearing the error
1834 * status on the drive so that it is not locked for
1835 * further operations.
1838 /* On some systems such as NetBSD, this clears all errors */
1841 /* Found on Solaris */
1844 d_ioctl(m_fd, MTIOCLRERR);
1845 Dmsg0(200, "Did MTIOCLRERR\n");
1849 /* Typically on FreeBSD */
1853 /* Read and clear SCSI error status */
1854 union mterrstat mt_errstat;
1855 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1856 be.bstrerror(dev_errno));
1857 d_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1861 /* Clear Subsystem Exception OSF1 */
1865 mt_com.mt_op = MTCSE;
1866 mt_com.mt_count = 1;
1867 /* Clear any error condition on the tape */
1868 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1869 Dmsg0(200, "Did MTCSE\n");
1876 * Set to unload the current volume in the drive
1878 void DEVICE::set_unload()
1880 if (!m_unload && VolHdr.VolumeName[0] != 0) {
1882 memcpy(UnloadVolName, VolHdr.VolumeName, sizeof(UnloadVolName));
1888 * Clear volume header
1890 void DEVICE::clear_volhdr()
1892 Dmsg1(100, "Clear volhdr vol=%s\n", VolHdr.VolumeName);
1893 memset(&VolHdr, 0, sizeof(VolHdr));
1900 void DEVICE::close()
1902 Dmsg1(100, "close_dev %s\n", print_name());
1903 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1908 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1910 return; /* already closed */
1922 /* Clean up device packet so it can be reused */
1925 * Be careful not to clear items needed by the DVD driver
1926 * when it is closing a single part.
1928 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF|
1929 ST_MOUNTED|ST_MEDIA|ST_SHORT);
1930 label_type = B_BACULA_LABEL;
1931 file = block_num = 0;
1934 EndFile = EndBlock = 0;
1937 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1939 stop_thread_timer(tid);
1945 * This call closes the device, but it is used in DVD handling
1946 * where we close one part and then open the next part. The
1947 * difference between close_part() and close() is that close_part()
1948 * saves the state information of the device (e.g. the Volume lable,
1949 * the Volume Catalog record, ... This permits opening and closing
1950 * the Volume parts multiple times without losing track of what the
1951 * main Volume parameters are.
1953 void DEVICE::close_part(DCR * /*dcr*/)
1955 VOLUME_LABEL saveVolHdr;
1956 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1959 saveVolHdr = VolHdr; /* structure assignment */
1960 saveVolCatInfo = VolCatInfo; /* structure assignment */
1961 close(); /* close current part */
1962 VolHdr = saveVolHdr; /* structure assignment */
1963 VolCatInfo = saveVolCatInfo; /* structure assignment */
1966 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1970 return lseek_dvd(dcr, offset, whence);
1972 #if defined(HAVE_WIN32)
1973 return ::_lseeki64(m_fd, (__int64)offset, whence);
1975 return ::lseek(m_fd, offset, whence);
1982 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1986 Dmsg1(100, "truncate %s\n", print_name());
1991 /* maybe we should rewind and write and eof ???? */
1992 return true; /* we don't really truncate tapes */
1994 return truncate_dvd(dcr);
1996 if (ftruncate(m_fd, 0) != 0) {
1998 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1999 print_name(), be.bstrerror());
2004 * Check for a successful ftruncate() and issue a work-around for devices
2005 * (mostly cheap NAS) that don't support truncation.
2006 * Workaround supplied by Martin Schmid as a solution to bug #1011.
2009 * 3. open new file with same mode
2010 * 4. change ownership to original
2013 if (fstat(m_fd, &st) != 0) {
2015 Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"),
2016 print_name(), be.bstrerror());
2020 if (st.st_size != 0) { /* ftruncate() didn't work */
2021 POOL_MEM archive_name(PM_FNAME);
2023 pm_strcpy(archive_name, dev_name);
2024 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
2025 pm_strcat(archive_name, "/");
2027 pm_strcat(archive_name, dcr->VolumeName);
2029 Mmsg2(errmsg, _("Device %s doesn't support ftruncate(). Recreating file %s.\n"),
2030 print_name(), archive_name.c_str());
2032 /* Close file and blow it away */
2034 ::unlink(archive_name.c_str());
2036 /* Recreate the file -- of course, empty */
2037 set_mode(CREATE_READ_WRITE);
2038 if ((m_fd = ::open(archive_name.c_str(), mode, st.st_mode)) < 0) {
2041 Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), archive_name.c_str(),
2043 Dmsg1(100, "reopen failed: %s", errmsg);
2044 Emsg0(M_FATAL, 0, errmsg);
2048 /* Reset proper owner */
2049 chown(archive_name.c_str(), st.st_uid, st.st_gid);
2057 /* Mount the device.
2058 * If timeout, wait until the mount command returns 0.
2059 * If !timeout, try to mount the device only once.
2061 bool DEVICE::mount(int timeout)
2063 Dmsg0(190, "Enter mount\n");
2066 } else if (requires_mount()) {
2067 return do_mount(1, timeout);
2072 /* Unmount the device
2073 * If timeout, wait until the unmount command returns 0.
2074 * If !timeout, try to unmount the device only once.
2076 bool DEVICE::unmount(int timeout)
2078 Dmsg0(100, "Enter unmount\n");
2080 return do_mount(0, timeout);
2085 /* (Un)mount the device */
2086 bool DEVICE::do_mount(int mount, int dotimeout)
2088 POOL_MEM ocmd(PM_FNAME);
2091 int status, timeout;
2096 Dmsg0(200, "======= mount=1\n");
2099 icmd = device->mount_command;
2101 if (!is_mounted()) {
2102 Dmsg0(200, "======= mount=0\n");
2105 icmd = device->unmount_command;
2108 clear_freespace_ok();
2109 edit_mount_codes(ocmd, icmd);
2111 Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2114 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
2119 results = get_memory(4000);
2121 /* If busy retry each second */
2122 Dmsg1(100, "do_mount run_prog=%s\n", ocmd.c_str());
2123 while ((status = run_program_full_output(ocmd.c_str(),
2124 max_open_wait/2, results)) != 0) {
2125 /* Doesn't work with internationalization (This is not a problem) */
2126 if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2129 if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2132 if (timeout-- > 0) {
2133 /* Sometimes the device cannot be mounted because it is already mounted.
2134 * Try to unmount it, then remount it */
2136 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2144 Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2145 (mount ? "" : "un"), status, results, be.bstrerror(status));
2146 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2147 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2149 Dmsg4(100, "Device %s cannot be %smounted. stat=%d ERR=%s\n", print_name(),
2150 (mount ? "" : "un"), status, results);
2151 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2152 print_name(), (mount ? "" : "un"), results);
2155 * Now, just to be sure it is not mounted, try to read the
2159 struct dirent *entry, *result;
2163 name_max = pathconf(".", _PC_NAME_MAX);
2164 if (name_max < 1024) {
2168 if (!(dp = opendir(device->mount_point))) {
2171 Dmsg3(100, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2172 device->mount_point, print_name(), be.bstrerror());
2176 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2179 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2181 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
2182 device->mount_point, print_name());
2185 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2186 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2189 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2195 Dmsg1(100, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2198 /* If we got more than ., .. and .keep */
2199 /* there must be something mounted */
2201 Dmsg1(100, "Did Mount by count=%d\n", count);
2204 /* An unmount request. We failed to unmount - report an error */
2206 free_pool_memory(results);
2207 Dmsg0(200, "== error mount=1 wanted unmount\n");
2213 free_pool_memory(results);
2214 Dmsg0(200, "============ mount=0\n");
2219 set_mounted(mount); /* set/clear mounted flag */
2220 free_pool_memory(results);
2221 /* Do not check free space when unmounting */
2222 if (mount && !update_freespace()) {
2225 Dmsg1(200, "============ mount=%d\n", mount);
2230 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2232 * %a = archive device name
2233 * %e = erase (set if cannot mount and first part)
2236 * %v = last part name
2238 * omsg = edited output message
2239 * imsg = input string containing edit codes (%x)
2242 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2248 POOL_MEM archive_name(PM_FNAME);
2250 omsg.c_str()[0] = 0;
2251 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2252 for (p=imsg; *p; p++) {
2262 if (num_dvd_parts == 0) {
2263 if (truncating || blank_dvd) {
2273 bsnprintf(add, sizeof(add), "%d", part);
2277 str = device->mount_point;
2280 make_spooled_dvd_filename(this, archive_name);
2281 str = archive_name.c_str();
2295 Dmsg1(1900, "add_str %s\n", str);
2296 pm_strcat(omsg, (char *)str);
2297 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2301 /* return the last timer interval (ms)
2302 * or 0 if something goes wrong
2304 btime_t DEVICE::get_timer_count()
2306 btime_t temp = last_timer;
2307 last_timer = get_current_btime();
2308 temp = last_timer - temp; /* get elapsed time */
2309 return (temp>0)?temp:0; /* take care of skewed clock */
2313 ssize_t DEVICE::read(void *buf, size_t len)
2319 read_len = d_read(m_fd, buf, len);
2321 last_tick = get_timer_count();
2323 DevReadTime += last_tick;
2324 VolCatInfo.VolReadTime += last_tick;
2326 if (read_len > 0) { /* skip error */
2327 DevReadBytes += read_len;
2334 ssize_t DEVICE::write(const void *buf, size_t len)
2340 write_len = d_write(m_fd, buf, len);
2342 last_tick = get_timer_count();
2344 DevWriteTime += last_tick;
2345 VolCatInfo.VolWriteTime += last_tick;
2347 if (write_len > 0) { /* skip error */
2348 DevWriteBytes += write_len;
2354 /* Return the resource name for the device */
2355 const char *DEVICE::name() const
2357 return device->hdr.name;
2360 /* Returns file position on tape or -1 */
2361 int32_t DEVICE::get_os_tape_file()
2363 struct mtget mt_stat;
2365 if (has_cap(CAP_MTIOCGET) &&
2366 d_ioctl(m_fd, MTIOCGET, (char *)&mt_stat) == 0) {
2367 return mt_stat.mt_fileno;
2373 dev_vol_name(DEVICE *dev)
2375 return dev->VolCatInfo.VolCatName;
2380 * Free memory allocated for the device
2382 void DEVICE::term(void)
2384 Dmsg1(900, "term dev: %s\n", print_name());
2387 free_memory(dev_name);
2391 free_memory(prt_name);
2395 free_pool_memory(errmsg);
2398 pthread_mutex_destroy(&m_mutex);
2399 pthread_cond_destroy(&wait);
2400 pthread_cond_destroy(&wait_next_vol);
2401 pthread_mutex_destroy(&spool_mutex);
2402 // rwl_destroy(&lock);
2403 if (attached_dcrs) {
2404 delete attached_dcrs;
2405 attached_dcrs = NULL;
2414 * This routine initializes the device wait timers
2416 void init_device_wait_timers(DCR *dcr)
2418 DEVICE *dev = dcr->dev;
2419 JCR *jcr = dcr->jcr;
2421 /* ******FIXME******* put these on config variables */
2422 dev->min_wait = 60 * 60;
2423 dev->max_wait = 24 * 60 * 60;
2424 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2425 dev->wait_sec = dev->min_wait;
2426 dev->rem_wait_sec = dev->wait_sec;
2430 jcr->min_wait = 60 * 60;
2431 jcr->max_wait = 24 * 60 * 60;
2432 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2433 jcr->wait_sec = jcr->min_wait;
2434 jcr->rem_wait_sec = jcr->wait_sec;
2439 void init_jcr_device_wait_timers(JCR *jcr)
2441 /* ******FIXME******* put these on config variables */
2442 jcr->min_wait = 60 * 60;
2443 jcr->max_wait = 24 * 60 * 60;
2444 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2445 jcr->wait_sec = jcr->min_wait;
2446 jcr->rem_wait_sec = jcr->wait_sec;
2452 * The dev timers are used for waiting on a particular device
2454 * Returns: true if time doubled
2455 * false if max time expired
2457 bool double_dev_wait_time(DEVICE *dev)
2459 dev->wait_sec *= 2; /* double wait time */
2460 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2461 dev->wait_sec = dev->max_wait;
2464 dev->rem_wait_sec = dev->wait_sec;
2465 if (dev->num_wait >= dev->max_num_wait) {
2472 void set_os_device_parameters(DCR *dcr)
2474 DEVICE *dev = dcr->dev;
2476 if (strcmp(dev->dev_name, "/dev/null") == 0) {
2477 return; /* no use trying to set /dev/null */
2480 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2483 Dmsg0(100, "In set_os_device_parameters\n");
2484 #if defined(MTSETBLK)
2485 if (dev->min_block_size == dev->max_block_size &&
2486 dev->min_block_size == 0) { /* variable block mode */
2487 mt_com.mt_op = MTSETBLK;
2488 mt_com.mt_count = 0;
2489 Dmsg0(100, "Set block size to zero\n");
2490 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2491 dev->clrerror(MTSETBLK);
2495 #if defined(MTSETDRVBUFFER)
2496 if (getuid() == 0) { /* Only root can do this */
2497 mt_com.mt_op = MTSETDRVBUFFER;
2498 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2499 if (!dev->has_cap(CAP_TWOEOF)) {
2500 mt_com.mt_count |= MT_ST_TWO_FM;
2502 if (dev->has_cap(CAP_EOM)) {
2503 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2505 Dmsg0(100, "MTSETDRVBUFFER\n");
2506 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2507 dev->clrerror(MTSETDRVBUFFER);
2514 #ifdef HAVE_NETBSD_OS
2516 if (dev->min_block_size == dev->max_block_size &&
2517 dev->min_block_size == 0) { /* variable block mode */
2518 mt_com.mt_op = MTSETBSIZ;
2519 mt_com.mt_count = 0;
2520 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2521 dev->clrerror(MTSETBSIZ);
2523 /* Get notified at logical end of tape */
2524 mt_com.mt_op = MTEWARN;
2525 mt_com.mt_count = 1;
2526 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2527 dev->clrerror(MTEWARN);
2533 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2535 if (dev->min_block_size == dev->max_block_size &&
2536 dev->min_block_size == 0) { /* variable block mode */
2537 mt_com.mt_op = MTSETBSIZ;
2538 mt_com.mt_count = 0;
2539 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2540 dev->clrerror(MTSETBSIZ);
2543 #if defined(MTIOCSETEOTMODEL)
2545 if (dev->has_cap(CAP_TWOEOF)) {
2550 if (dev->d_ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2552 dev->dev_errno = errno; /* save errno */
2553 Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2554 dev->print_name(), be.bstrerror(dev->dev_errno));
2555 Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2563 if (dev->min_block_size == dev->max_block_size &&
2564 dev->min_block_size == 0) { /* variable block mode */
2565 mt_com.mt_op = MTSRSZ;
2566 mt_com.mt_count = 0;
2567 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2568 dev->clrerror(MTSRSZ);
2575 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2577 Dmsg0(100, "dev_get_os_pos\n");
2578 return dev->has_cap(CAP_MTIOCGET) &&
2579 dev->d_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2580 mt_stat->mt_fileno >= 0;
2583 static const char *modes[] = {
2584 "CREATE_READ_WRITE",
2591 static const char *mode_to_str(int mode)
2593 static char buf[100];
2594 if (mode < 1 || mode > 4) {
2595 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2598 return modes[mode-1];