2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2009 Free Software Foundation Europe e.V.
6 The main author of Bacula is Kern Sibbald, with contributions from
7 many others, a complete list can be found in the file AUTHORS.
8 This program is Free Software; you can redistribute it and/or
9 modify it under the terms of version two of the GNU General Public
10 License as published by the Free Software Foundation and included
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 Bacula® is a registered trademark of Kern Sibbald.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
30 * dev.c -- low level operations on device (storage device)
34 * NOTE!!!! None of these routines are reentrant. You must
35 * use dev->r_dlock() and dev->unlock() at a higher level,
36 * or use the xxx_device() equivalents. By moving the
37 * thread synchronization to a higher level, we permit
38 * the higher level routines to "seize" the device and
39 * to carry out operations without worrying about who
40 * set what lock (i.e. race conditions).
42 * Note, this is the device dependent code, and may have
43 * to be modified for each system, but is meant to
44 * be as "generic" as possible.
46 * The purpose of this code is to develop a SIMPLE Storage
47 * daemon. More complicated coding (double buffering, writer
48 * thread, ...) is left for a later version.
54 * Handling I/O errors and end of tape conditions are a bit tricky.
55 * This is how it is currently done when writing.
56 * On either an I/O error or end of tape,
57 * we will stop writing on the physical device (no I/O recovery is
58 * attempted at least in this daemon). The state flag will be sent
59 * to include ST_EOT, which is ephemeral, and ST_WEOT, which is
60 * persistent. Lots of routines clear ST_EOT, but ST_WEOT is
61 * cleared only when the problem goes away. Now when ST_WEOT
62 * is set all calls to write_block_to_device() call the fix_up
63 * routine. In addition, all threads are blocked
64 * from writing on the tape by calling lock_dev(), and thread other
65 * than the first thread to hit the EOT will block on a condition
66 * variable. The first thread to hit the EOT will continue to
67 * be able to read and write the tape (he sort of tunnels through
68 * the locking mechanism -- see lock_dev() for details).
70 * Now presumably somewhere higher in the chain of command
71 * (device.c), someone will notice the EOT condition and
72 * get a new tape up, get the tape label read, and mark
73 * the label for rewriting. Then this higher level routine
74 * will write the unwritten buffer to the new volume.
75 * Finally, he will release
76 * any blocked threads by doing a broadcast on the condition
77 * variable. At that point, we should be totally back in
78 * business with no lost data.
89 /* Forward referenced functions */
90 void set_os_device_parameters(DCR *dcr);
91 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat);
92 static const char *mode_to_str(int mode);
95 * Allocate and initialize the DEVICE structure
96 * Note, if dev is non-NULL, it is already allocated,
97 * thus we neither allocate it nor free it. This allows
98 * the caller to put the packet in shared memory.
100 * Note, for a tape, the device->device_name is the device name
101 * (e.g. /dev/nst0), and for a file, the device name
102 * is the directory in which the file will be placed.
106 init_dev(JCR *jcr, DEVRES *device)
115 /* If no device type specified, try to guess */
116 if (!device->dev_type) {
117 /* Check that device is available */
118 if (stat(device->device_name, &statp) < 0) {
120 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
121 device->device_name, be.bstrerror());
124 if (S_ISDIR(statp.st_mode)) {
125 device->dev_type = B_FILE_DEV;
126 } else if (S_ISCHR(statp.st_mode)) {
127 device->dev_type = B_TAPE_DEV;
128 } else if (S_ISFIFO(statp.st_mode)) {
129 device->dev_type = B_FIFO_DEV;
131 /* must set DeviceType = Vtape
132 * in normal mode, autodetection is disabled
134 } else if (S_ISREG(statp.st_mode)) {
135 device->dev_type = B_VTAPE_DEV;
137 } else if (!(device->cap_bits & CAP_REQMOUNT)) {
138 Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
139 " or have RequiresMount=yes for DVD. st_mode=%x\n"),
140 device->device_name, statp.st_mode);
143 device->dev_type = B_DVD_DEV;
147 dev = (DEVICE *)malloc(sizeof(DEVICE));
148 memset(dev, 0, sizeof(DEVICE));
149 dev->clear_slot(); /* unknown */
151 /* Copy user supplied device parameters from Resource */
152 dev->dev_name = get_memory(strlen(device->device_name)+1);
153 pm_strcpy(dev->dev_name, device->device_name);
154 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
155 /* We edit "Resource-name" (physical-name) */
156 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
157 Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
158 dev->capabilities = device->cap_bits;
159 dev->min_block_size = device->min_block_size;
160 dev->max_block_size = device->max_block_size;
161 dev->max_volume_size = device->max_volume_size;
162 dev->max_file_size = device->max_file_size;
163 dev->max_concurrent_jobs = device->max_concurrent_jobs;
164 dev->volume_capacity = device->volume_capacity;
165 dev->max_rewind_wait = device->max_rewind_wait;
166 dev->max_open_wait = device->max_open_wait;
167 dev->max_open_vols = device->max_open_vols;
168 dev->vol_poll_interval = device->vol_poll_interval;
169 dev->max_spool_size = device->max_spool_size;
170 dev->drive_index = device->drive_index;
171 dev->autoselect = device->autoselect;
172 dev->dev_type = device->dev_type;
174 if (dev->is_tape()) { /* No parts on tapes */
175 dev->max_part_size = 0;
177 dev->max_part_size = device->max_part_size;
180 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
181 dev->vol_poll_interval = 60;
183 /* Link the dev and device structures together */
184 dev->device = device;
187 if (dev->is_fifo()) {
188 dev->capabilities |= CAP_STREAM; /* set stream device */
191 /* If the device requires mount :
192 * - Check that the mount point is available
193 * - Check that (un)mount commands are defined
195 if ((dev->is_file() || dev->is_dvd()) && dev->requires_mount()) {
196 if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
198 dev->dev_errno = errno;
199 Jmsg2(jcr, M_ERROR_TERM, 0, _("Unable to stat mount point %s: ERR=%s\n"),
200 device->mount_point, be.bstrerror());
204 if (!device->mount_command || !device->unmount_command) {
205 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
207 if (!device->write_part_command) {
208 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
213 if (dev->max_block_size == 0) {
214 max_bs = DEFAULT_BLOCK_SIZE;
216 max_bs = dev->max_block_size;
218 if (dev->min_block_size > max_bs) {
219 Jmsg(jcr, M_ERROR_TERM, 0, _("Min block size > max on device %s\n"),
222 if (dev->max_block_size > 4096000) {
223 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
224 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
225 dev->max_block_size = 0;
227 if (dev->max_block_size % TAPE_BSIZE != 0) {
228 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
229 dev->max_block_size, dev->print_name());
232 dev->errmsg = get_pool_memory(PM_EMSG);
235 if ((errstat = pthread_mutex_init(&dev->m_mutex, NULL)) != 0) {
237 dev->dev_errno = errstat;
238 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
239 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
241 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
243 dev->dev_errno = errstat;
244 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
245 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
247 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
249 dev->dev_errno = errstat;
250 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
251 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
253 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
255 dev->dev_errno = errstat;
256 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
257 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
259 if ((errstat = pthread_mutex_init(&dev->acquire_mutex, NULL)) != 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);
266 if ((errstat = rwl_init(&dev->lock)) != 0) {
268 dev->dev_errno = errstat;
269 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
270 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
275 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
276 Dmsg2(100, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
277 dev->initiated = true;
282 /* Choose the right backend */
283 void DEVICE::init_backend()
288 d_open = win32_tape_open;
289 d_write = win32_tape_write;
290 d_close = win32_tape_close;
291 d_ioctl = win32_tape_ioctl;
292 d_read = win32_tape_read;
297 d_ioctl = win32_ioctl; /* dummy function */
298 d_write = win32_write; /* win32 read/write are not POSIX */
302 #else /* POSIX / UNIX Interface */
303 if (is_vtape()) { /* test backend */
304 d_open = vtape_open; /* vtape isn't available for WIN32 or FreeBSD */
305 d_write = vtape_write;
306 d_close = vtape_close;
307 d_ioctl = vtape_ioctl;
310 } else { /* tape and file are using normal io */
321 * Open the device with the operating system and
322 * initialize buffer pointers.
324 * Returns: -1 on error
327 * Note, for a tape, the VolName is the name we give to the
328 * volume (not really used here), but for a file, the
329 * VolName represents the name of the file to be created/opened.
330 * In the case of a file, the full name is the device name
331 * (archive_name) with the VolName concatenated.
334 DEVICE::open(DCR *dcr, int omode)
338 if (openmode == omode) {
343 Dmsg0(100, "Close fd for mode change.\n");
344 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
348 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
351 Dmsg4(100, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
352 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
353 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
354 label_type = B_BACULA_LABEL;
355 if (is_tape() || is_fifo()) {
356 open_tape_device(dcr, omode);
357 } else if (is_dvd()) {
358 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
359 open_dvd_device(dcr, omode);
361 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
362 open_file_device(dcr, omode);
364 state |= preserve; /* reset any important state info */
365 Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, m_fd);
369 void DEVICE::set_mode(int new_mode)
372 case CREATE_READ_WRITE:
373 mode = O_CREAT | O_RDWR | O_BINARY;
375 case OPEN_READ_WRITE:
376 mode = O_RDWR | O_BINARY;
379 mode = O_RDONLY | O_BINARY;
381 case OPEN_WRITE_ONLY:
382 mode = O_WRONLY | O_BINARY;
385 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
391 void DEVICE::open_tape_device(DCR *dcr, int omode)
394 int timeout = max_open_wait;
395 #if !defined(HAVE_WIN32)
397 utime_t start_time = time(NULL);
401 Dmsg0(100, "Open dev: device is tape\n");
403 get_autochanger_loaded_slot(dcr);
412 if (is_fifo() && timeout) {
414 tid = start_thread_timer(dcr->jcr, pthread_self(), timeout);
416 Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
417 #if defined(HAVE_WIN32)
420 if ((m_fd = d_open(dev_name, mode)) < 0) {
427 /* If busy retry each second for max_open_wait seconds */
429 /* Try non-blocking open */
430 m_fd = d_open(dev_name, mode+O_NONBLOCK);
434 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
435 print_name(), omode, mode, errno, be.bstrerror());
437 /* Tape open, now rewind it */
438 Dmsg0(100, "Rewind after open\n");
439 mt_com.mt_op = MTREW;
441 /* rewind only if dev is a tape */
442 if (is_tape() && (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0)) {
444 dev_errno = errno; /* set error status from rewind */
447 Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
448 be.bstrerror(dev_errno));
449 /* If we get busy, device is probably rewinding, try again */
450 if (dev_errno != EBUSY) {
451 break; /* error -- no medium */
454 /* Got fd and rewind worked, so we must have medium in drive */
456 m_fd = d_open(dev_name, mode); /* open normally */
460 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
461 print_name(), omode, mode, errno, be.bstrerror());
466 set_os_device_parameters(dcr); /* do system dependent stuff */
467 break; /* Successfully opened and rewound */
471 /* Exceed wait time ? */
472 if (time(NULL) - start_time >= max_open_wait) {
473 break; /* yes, get out */
480 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
481 print_name(), be.bstrerror(dev_errno));
482 Dmsg1(100, "%s", errmsg);
485 /* Stop any open() timer we started */
487 stop_thread_timer(tid);
490 Dmsg1(100, "open dev: tape %d opened\n", m_fd);
497 void DEVICE::open_file_device(DCR *dcr, int omode)
499 POOL_MEM archive_name(PM_FNAME);
501 get_autochanger_loaded_slot(dcr);
504 * Handle opening of File Archive (not a tape)
507 pm_strcpy(archive_name, dev_name);
509 * If this is a virtual autochanger (i.e. changer_res != NULL)
510 * we simply use the device name, assuming it has been
511 * appropriately setup by the "autochanger".
513 if (!device->changer_res || device->changer_command[0] == 0) {
514 if (VolCatInfo.VolCatName[0] == 0) {
515 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
521 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
522 pm_strcat(archive_name, "/");
524 pm_strcat(archive_name, VolCatInfo.VolCatName);
527 mount(1); /* do mount if required */
531 /* If creating file, give 0640 permissions */
532 Dmsg3(100, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
533 archive_name.c_str(), mode);
534 /* Use system open() */
535 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
538 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
540 Dmsg1(100, "open failed: %s", errmsg);
541 Jmsg1(NULL, M_WARNING, 0, "%s", errmsg);
547 Dmsg4(100, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
548 m_fd, part, num_dvd_parts, part_size);
552 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
553 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
554 * has the desired Volume name, but there is NO assurance that
555 * any other field of VolCatInfo is correct.
557 void DEVICE::open_dvd_device(DCR *dcr, int omode)
559 POOL_MEM archive_name(PM_FNAME);
560 struct stat filestat;
563 * Handle opening of DVD Volume
565 Dmsg2(100, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n",
566 &dcr->VolCatInfo, mode_to_str(omode));
569 * For a DVD we must always pull the state info from dcr->VolCatInfo
570 * This is a bit ugly, but is necessary because we need to open/close/re-open
571 * the dvd file in order to properly mount/unmount and access the
572 * DVD. So we store the state of the DVD as far as is known in the
573 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
574 * copy here, when opening.
576 VolCatInfo = dcr->VolCatInfo; /* structure assignment */
577 Dmsg1(100, "Volume=%s\n", VolCatInfo.VolCatName);
579 if (VolCatInfo.VolCatName[0] == 0) {
580 Dmsg1(10, "Could not open DVD device %s. No Volume name given.\n",
582 Mmsg(errmsg, _("Could not open DVD device %s. No Volume name given.\n"),
589 Dmsg0(100, "Set part=1\n");
590 part = 1; /* count from 1 */
594 if (num_dvd_parts != VolCatInfo.VolCatParts) {
595 num_dvd_parts = VolCatInfo.VolCatParts;
599 * If we are not trying to access the last part, set mode to
600 * OPEN_READ_ONLY as writing would be an error.
602 Dmsg2(100, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
603 /* Now find the name of the part that we want to access */
604 if (part <= num_dvd_parts) {
605 omode = OPEN_READ_ONLY;
606 make_mounted_dvd_filename(this, archive_name);
607 set_part_spooled(false);
609 omode = OPEN_READ_WRITE;
610 make_spooled_dvd_filename(this, archive_name);
611 set_part_spooled(true);
615 // Clear any previous blank_dvd status - we will recalculate it here
618 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
619 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
622 Dmsg0(99, "DVD device mounted.\n");
623 if (num_dvd_parts == 0 && !truncating) {
625 * If we can mount the device, and we are not truncating the DVD,
626 * we usually want to abort. There is one exception, if there is
627 * only one 0-sized file on the DVD, with the right volume name,
628 * we continue (it's the method used by truncate_dvd to truncate a volume).
630 if (!check_can_write_on_non_blank_dvd(dcr)) {
631 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
632 Emsg0(M_FATAL, 0, errmsg);
633 unmount(1); /* Unmount the device, so the operator can change it. */
640 * Ensure that we have the correct DVD loaded by looking for part1.
641 * We only succeed the open if it exists. Failure to do this could
642 * leave us trying to add a part to a different DVD!
644 uint32_t oldpart = part;
646 POOL_MEM part1_name(PM_FNAME);
648 make_mounted_dvd_filename(this, part1_name);
650 if (stat(part1_name.c_str(), &statp) < 0) {
652 Mmsg(errmsg, _("Unable to stat DVD part 1 file %s: ERR=%s\n"),
653 part1_name.c_str(), be.bstrerror());
654 Emsg0(M_FATAL, 0, errmsg);
658 if (!S_ISREG(statp.st_mode)) {
659 /* It is not a regular file */
660 Mmsg(errmsg, _("DVD part 1 is not a regular file %s.\n"),
662 Emsg0(M_FATAL, 0, errmsg);
668 Dmsg0(99, "DVD device mount failed.\n");
669 /* We cannot mount the device */
670 if (num_dvd_parts == 0) {
671 /* Run free space, check there is a media. */
672 if (!update_freespace()) {
673 Emsg0(M_FATAL, 0, errmsg);
678 Dmsg1(100, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
680 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
681 Emsg0(M_FATAL, 0, errmsg);
686 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
687 Emsg0(M_FATAL, 0, errmsg);
693 Dmsg5(100, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
694 archive_name.c_str(), mode_to_str(omode),
695 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
697 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
700 /* If creating file, give 0640 permissions */
701 Dmsg3(100, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
702 archive_name.c_str(), mode);
703 /* Use system open() */
704 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
706 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
708 // Should this be set if we try the create/open below
709 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
710 Dmsg1(100, "open failed: %s", errmsg);
712 /* Previous open failed. See if we can recover */
713 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
714 (part > num_dvd_parts)) {
715 /* If the last part (on spool), doesn't exist when accessing,
716 * create it. In read/write mode a write will be allowed (higher
717 * level software thinks that we are extending a pre-existing
718 * media. Reads for READ_ONLY will report immediately an EOF
719 * Sometimes it is better to finish with an EOF than with an error. */
720 Dmsg1(100, "Creating last part on spool: %s\n", archive_name.c_str());
721 omode = CREATE_READ_WRITE;
722 set_mode(CREATE_READ_WRITE);
723 m_fd = ::open(archive_name.c_str(), mode, 0640);
727 Dmsg1(100, "after open fd=%d\n", m_fd);
729 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
732 /* Get size of file */
733 if (fstat(m_fd, &filestat) < 0) {
736 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
738 Dmsg1(100, "open failed: %s", errmsg);
739 /* Use system close() */
743 part_size = filestat.st_size;
745 update_pos(dcr); /* update position */
753 * Returns: true on success
756 bool DEVICE::rewind(DCR *dcr)
762 Dmsg3(400, "rewind res=%d fd=%d %s\n", num_reserved(), m_fd, print_name());
763 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
764 block_num = file = 0;
768 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
770 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
772 Emsg0(M_ABORT, 0, errmsg);
777 mt_com.mt_op = MTREW;
779 /* If we get an I/O error on rewind, it is probably because
780 * the drive is actually busy. We loop for (about 5 minutes)
781 * retrying every 5 seconds.
783 for (i=max_rewind_wait; ; i -= 5) {
784 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
787 if (i == max_rewind_wait) {
788 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.bstrerror());
791 * This is a gross hack, because if the user has the
792 * device mounted (i.e. open), then uses mtx to load
793 * a tape, the current open file descriptor is invalid.
794 * So, we close the drive and re-open it.
797 int open_mode = openmode;
800 open(dcr, open_mode);
808 if (dev_errno == EIO) {
809 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
813 if (dev_errno == EIO && i > 0) {
814 Dmsg0(200, "Sleeping 5 seconds.\n");
819 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
820 print_name(), be.bstrerror());
825 } else if (is_file() || is_dvd()) {
826 if (lseek(dcr, (boffset_t)0, SEEK_SET) < 0) {
829 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
830 print_name(), be.bstrerror());
839 * Called to indicate that we have just read an
840 * EOF from the device.
842 void DEVICE::set_ateof()
854 * Called to indicate we are now at the end of the tape, and
855 * writing is not possible.
857 void DEVICE::set_ateot()
859 /* Make tape effectively read-only */
860 state |= (ST_EOF|ST_EOT|ST_WEOT);
865 * Position device to end of medium (end of data)
866 * Returns: true on succes
869 bool DEVICE::eod(DCR *dcr)
878 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
882 #if defined (__digital__) && defined (__unix__)
883 return fsf(VolCatInfo.VolCatFiles);
890 clear_eof(); /* remove EOF flag */
891 block_num = file = 0;
898 pos = lseek(dcr, (boffset_t)0, SEEK_END);
899 // Dmsg1(100, "====== Seek to %lld\n", pos);
907 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
908 print_name(), be.bstrerror());
912 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
913 Dmsg0(100,"Using FAST FSF for EOM\n");
914 /* If unknown position, rewind */
915 if (get_os_tape_file() < 0) {
920 mt_com.mt_op = MTFSF;
922 * ***FIXME*** fix code to handle case that INT16_MAX is
925 mt_com.mt_count = INT16_MAX; /* use big positive number */
926 if (mt_com.mt_count < 0) {
927 mt_com.mt_count = INT16_MAX; /* brain damaged system */
931 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
932 if (has_cap(CAP_EOM)) {
933 Dmsg0(100,"Using EOM for EOM\n");
934 mt_com.mt_op = MTEOM;
938 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
940 clrerror(mt_com.mt_op);
941 Dmsg1(50, "ioctl error: %s\n", be.bstrerror());
943 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
944 print_name(), be.bstrerror());
948 os_file = get_os_tape_file();
952 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
953 print_name(), be.bstrerror());
956 Dmsg1(100, "EOD file=%d\n", os_file);
964 * Rewind then use FSF until EOT reached
970 * Move file by file to the end of the tape
973 for (file_num=file; !at_eot(); file_num++) {
974 Dmsg0(200, "eod: doing fsf 1\n");
976 Dmsg0(200, "fsf error.\n");
980 * Avoid infinite loop by ensuring we advance.
982 if (!at_eot() && file_num == (int)file) {
983 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
985 os_file = get_os_tape_file();
987 Dmsg2(100, "Adjust file from %d to %d\n", file_num, os_file);
995 * Some drivers leave us after second EOF when doing
996 * MTEOM, so we must backup so that appending overwrites
999 if (has_cap(CAP_BSFATEOM)) {
1000 /* Backup over EOF */
1002 /* If BSF worked and fileno is known (not -1), set file */
1003 os_file = get_os_tape_file();
1005 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , os_file);
1008 file++; /* wing it -- not correct on all OSes */
1011 update_pos(dcr); /* update position */
1013 Dmsg1(200, "EOD dev->file=%d\n", file);
1018 * Set the position of the device -- only for files and DVD
1019 * For other devices, there is no generic way to do it.
1020 * Returns: true on succes
1023 bool DEVICE::update_pos(DCR *dcr)
1030 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
1031 Emsg1(M_FATAL, 0, "%s", errmsg);
1035 /* Find out where we are */
1036 if (is_file() || is_dvd()) {
1039 pos = lseek(dcr, (boffset_t)0, SEEK_CUR);
1043 Pmsg1(000, _("Seek error: ERR=%s\n"), be.bstrerror());
1044 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1045 print_name(), be.bstrerror());
1049 block_num = (uint32_t)pos;
1050 file = (uint32_t)(pos >> 32);
1057 * Return the status of the device. This was meant
1058 * to be a generic routine. Unfortunately, it doesn't
1059 * seem possible (at least I do not know how to do it
1060 * currently), which means that for the moment, this
1061 * routine has very little value.
1065 uint32_t status_dev(DEVICE *dev)
1067 struct mtget mt_stat;
1070 if (dev->state & (ST_EOT | ST_WEOT)) {
1074 if (dev->state & ST_EOF) {
1078 if (dev->is_tape()) {
1080 Pmsg0(-20,_(" Bacula status:"));
1081 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1082 if (dev->d_ioctl(dev->fd(), MTIOCGET, (char *)&mt_stat) < 0) {
1084 dev->dev_errno = errno;
1085 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1086 dev->print_name(), be.bstrerror());
1089 Pmsg0(-20, _(" Device status:"));
1091 #if defined(HAVE_LINUX_OS)
1092 if (GMT_EOF(mt_stat.mt_gstat)) {
1096 if (GMT_BOT(mt_stat.mt_gstat)) {
1100 if (GMT_EOT(mt_stat.mt_gstat)) {
1104 if (GMT_SM(mt_stat.mt_gstat)) {
1108 if (GMT_EOD(mt_stat.mt_gstat)) {
1112 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1113 stat |= BMT_WR_PROT;
1114 Pmsg0(-20, " WR_PROT");
1116 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1118 Pmsg0(-20, " ONLINE");
1120 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1121 stat |= BMT_DR_OPEN;
1122 Pmsg0(-20, " DR_OPEN");
1124 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1125 stat |= BMT_IM_REP_EN;
1126 Pmsg0(-20, " IM_REP_EN");
1128 #elif defined(HAVE_WIN32)
1129 if (GMT_EOF(mt_stat.mt_gstat)) {
1133 if (GMT_BOT(mt_stat.mt_gstat)) {
1137 if (GMT_EOT(mt_stat.mt_gstat)) {
1141 if (GMT_EOD(mt_stat.mt_gstat)) {
1145 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1146 stat |= BMT_WR_PROT;
1147 Pmsg0(-20, " WR_PROT");
1149 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1151 Pmsg0(-20, " ONLINE");
1153 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1154 stat |= BMT_DR_OPEN;
1155 Pmsg0(-20, " DR_OPEN");
1157 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1158 stat |= BMT_IM_REP_EN;
1159 Pmsg0(-20, " IM_REP_EN");
1162 #endif /* !SunOS && !OSF */
1163 if (dev->has_cap(CAP_MTIOCGET)) {
1164 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1166 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1169 stat |= BMT_ONLINE | BMT_BOT;
1176 * Load medium in device
1177 * Returns: true on success
1180 bool load_dev(DEVICE *dev)
1186 if (dev->fd() < 0) {
1187 dev->dev_errno = EBADF;
1188 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1189 Emsg0(M_FATAL, 0, dev->errmsg);
1192 if (!(dev->is_tape())) {
1196 Dmsg0(200, "stored: MTLOAD command not available\n");
1198 dev->dev_errno = ENOTTY; /* function not available */
1199 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1200 dev->print_name(), be.bstrerror());
1204 dev->block_num = dev->file = 0;
1207 mt_com.mt_op = MTLOAD;
1208 mt_com.mt_count = 1;
1209 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
1211 dev->dev_errno = errno;
1212 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1213 dev->print_name(), be.bstrerror());
1221 * Rewind device and put it offline
1222 * Returns: true on success
1225 bool DEVICE::offline()
1230 return true; /* device not open */
1233 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1234 block_num = file = 0;
1238 mt_com.mt_op = MTOFFL;
1239 mt_com.mt_count = 1;
1240 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
1243 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1244 print_name(), be.bstrerror());
1247 Dmsg1(100, "Offlined device %s\n", print_name());
1251 bool DEVICE::offline_or_rewind()
1256 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1260 * Note, this rewind probably should not be here (it wasn't
1261 * in prior versions of Bacula), but on FreeBSD, this is
1262 * needed in the case the tape was "frozen" due to an error
1263 * such as backspacing after writing and EOF. If it is not
1264 * done, all future references to the drive get and I/O error.
1267 return rewind(NULL);
1272 * Foward space a file
1273 * Returns: true on success
1276 bool DEVICE::fsf(int num)
1278 int32_t os_file = 0;
1284 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1285 Emsg0(M_FATAL, 0, errmsg);
1295 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1299 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1302 Dmsg0(100, "fsf\n");
1305 * If Fast forward space file is set, then we
1306 * use MTFSF to forward space and MTIOCGET
1307 * to get the file position. We assume that
1308 * the SCSI driver will ensure that we do not
1309 * forward space past the end of the medium.
1311 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1313 mt_com.mt_op = MTFSF;
1314 mt_com.mt_count = num;
1315 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1317 my_errno = errno; /* save errno */
1318 } else if ((os_file=get_os_tape_file()) < 0) {
1319 my_errno = errno; /* save errno */
1321 if (my_errno != 0) {
1324 Dmsg0(200, "Set ST_EOT\n");
1326 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1327 print_name(), be.bstrerror(my_errno));
1328 Dmsg1(200, "%s", errmsg);
1332 Dmsg1(200, "fsf file=%d\n", os_file);
1338 * Here if CAP_FSF is set, and virtually all drives
1339 * these days support it, we read a record, then forward
1340 * space one file. Using this procedure, which is slow,
1341 * is the only way we can be sure that we don't read
1342 * two consecutive EOF marks, which means End of Data.
1344 } else if (has_cap(CAP_FSF)) {
1347 Dmsg0(200, "FSF has cap_fsf\n");
1348 if (max_block_size == 0) {
1349 rbuf_len = DEFAULT_BLOCK_SIZE;
1351 rbuf_len = max_block_size;
1353 rbuf = get_memory(rbuf_len);
1354 mt_com.mt_op = MTFSF;
1355 mt_com.mt_count = 1;
1356 while (num-- && !at_eot()) {
1357 Dmsg0(100, "Doing read before fsf\n");
1358 if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1359 if (errno == ENOMEM) { /* tape record exceeds buf len */
1360 stat = rbuf_len; /* This is OK */
1362 * On IBM drives, they return ENOSPC at EOM
1363 * instead of EOF status
1365 } else if (at_eof() && errno == ENOSPC) {
1371 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1373 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1374 print_name(), be.bstrerror());
1375 Dmsg1(100, "%s", errmsg);
1379 if (stat == 0) { /* EOF */
1380 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1381 /* Two reads of zero means end of tape */
1384 Dmsg0(100, "Set ST_EOT\n");
1390 } else { /* Got data */
1395 Dmsg0(100, "Doing MTFSF\n");
1396 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1397 if (stat < 0) { /* error => EOT */
1400 Dmsg0(100, "Set ST_EOT\n");
1402 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1403 print_name(), be.bstrerror());
1404 Dmsg0(100, "Got < 0 for MTFSF\n");
1405 Dmsg1(100, "%s", errmsg);
1413 * No FSF, so use FSR to simulate it
1416 Dmsg0(200, "Doing FSR for FSF\n");
1417 while (num-- && !at_eot()) {
1418 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1422 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1428 Dmsg1(200, "Return %d from FSF\n", stat);
1430 Dmsg0(200, "ST_EOF set on exit FSF\n");
1433 Dmsg0(200, "ST_EOT set on exit FSF\n");
1435 Dmsg1(200, "Return from FSF file=%d\n", file);
1440 * Backward space a file
1441 * Returns: false on failure
1444 bool DEVICE::bsf(int num)
1451 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1452 Emsg0(M_FATAL, 0, errmsg);
1457 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1462 Dmsg0(100, "bsf\n");
1468 mt_com.mt_op = MTBSF;
1469 mt_com.mt_count = num;
1470 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1474 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1475 print_name(), be.bstrerror());
1482 * Foward space num records
1483 * Returns: false on failure
1486 bool DEVICE::fsr(int num)
1493 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1494 Emsg0(M_FATAL, 0, errmsg);
1502 if (!has_cap(CAP_FSR)) {
1503 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1507 Dmsg1(100, "fsr %d\n", num);
1508 mt_com.mt_op = MTFSR;
1509 mt_com.mt_count = num;
1510 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1516 struct mtget mt_stat;
1518 Dmsg1(100, "FSF fail: ERR=%s\n", be.bstrerror());
1519 if (dev_get_os_pos(this, &mt_stat)) {
1520 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1521 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1522 file = mt_stat.mt_fileno;
1523 block_num = mt_stat.mt_blkno;
1531 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1532 num, print_name(), be.bstrerror());
1538 * Backward space a record
1539 * Returns: false on failure
1542 bool DEVICE::bsr(int num)
1549 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1550 Emsg0(M_FATAL, 0, errmsg);
1558 if (!has_cap(CAP_BSR)) {
1559 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1563 Dmsg0(100, "bsr_dev\n");
1567 mt_com.mt_op = MTBSR;
1568 mt_com.mt_count = num;
1569 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1573 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1574 print_name(), be.bstrerror());
1579 void DEVICE::lock_door()
1583 mt_com.mt_op = MTLOCK;
1584 mt_com.mt_count = 1;
1585 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1589 void DEVICE::unlock_door()
1593 mt_com.mt_op = MTUNLOCK;
1594 mt_com.mt_count = 1;
1595 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1599 void DEVICE::set_slot(int32_t slot)
1602 if (vol) vol->clear_slot();
1605 void DEVICE::clear_slot()
1608 if (vol) vol->set_slot(-1);
1614 * Reposition the device to file, block
1615 * Returns: false on failure
1618 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1622 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1623 Emsg0(M_FATAL, 0, errmsg);
1628 boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1629 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1630 if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1633 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1634 print_name(), be.bstrerror());
1643 /* After this point, we are tape only */
1644 Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1646 Dmsg0(100, "Rewind\n");
1647 if (!rewind(NULL)) {
1652 Dmsg1(100, "fsf %d\n", rfile-file);
1653 if (!fsf(rfile-file)) {
1654 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1657 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1659 if (rblock < block_num) {
1660 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1661 Dmsg0(100, "bsf 1\n");
1663 Dmsg0(100, "fsf 1\n");
1665 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1667 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1668 /* Ignore errors as Bacula can read to the correct block */
1669 Dmsg1(100, "fsr %d\n", rblock-block_num);
1670 return fsr(rblock-block_num);
1672 while (rblock > block_num) {
1673 if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
1676 Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1677 print_name(), be.bstrerror());
1680 Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1689 * Write an end of file on the device
1690 * Returns: true on success
1693 bool DEVICE::weof(int num)
1697 Dmsg1(129, "=== weof_dev=%s\n", print_name());
1701 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1702 Emsg0(M_FATAL, 0, errmsg);
1710 if (!can_append()) {
1711 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1712 Emsg0(M_FATAL, 0, errmsg);
1718 mt_com.mt_op = MTWEOF;
1719 mt_com.mt_count = num;
1720 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1729 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1730 print_name(), be.bstrerror());
1738 * If implemented in system, clear the tape
1741 void DEVICE::clrerror(int func)
1743 const char *msg = NULL;
1746 dev_errno = errno; /* save errno */
1748 VolCatInfo.VolCatErrors++;
1755 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1758 break; /* ignore message printed later */
1761 clear_cap(CAP_EOF); /* turn off feature */
1766 clear_cap(CAP_EOM); /* turn off feature */
1771 clear_cap(CAP_FSF); /* turn off feature */
1775 clear_cap(CAP_BSF); /* turn off feature */
1779 clear_cap(CAP_FSR); /* turn off feature */
1783 clear_cap(CAP_BSR); /* turn off feature */
1793 #ifdef MTSETDRVBUFFER
1794 case MTSETDRVBUFFER:
1795 msg = "MTSETDRVBUFFER";
1828 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1834 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1835 Emsg0(M_ERROR, 0, errmsg);
1840 * Now we try different methods of clearing the error
1841 * status on the drive so that it is not locked for
1842 * further operations.
1845 /* On some systems such as NetBSD, this clears all errors */
1848 /* Found on Solaris */
1851 d_ioctl(m_fd, MTIOCLRERR);
1852 Dmsg0(200, "Did MTIOCLRERR\n");
1856 /* Typically on FreeBSD */
1860 /* Read and clear SCSI error status */
1861 union mterrstat mt_errstat;
1862 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1863 be.bstrerror(dev_errno));
1864 d_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1868 /* Clear Subsystem Exception OSF1 */
1872 mt_com.mt_op = MTCSE;
1873 mt_com.mt_count = 1;
1874 /* Clear any error condition on the tape */
1875 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1876 Dmsg0(200, "Did MTCSE\n");
1883 * Set to unload the current volume in the drive
1885 void DEVICE::set_unload()
1887 if (!m_unload && VolHdr.VolumeName[0] != 0) {
1889 memcpy(UnloadVolName, VolHdr.VolumeName, sizeof(UnloadVolName));
1895 * Clear volume header
1897 void DEVICE::clear_volhdr()
1899 Dmsg1(100, "Clear volhdr vol=%s\n", VolHdr.VolumeName);
1900 memset(&VolHdr, 0, sizeof(VolHdr));
1907 void DEVICE::close()
1909 Dmsg1(100, "close_dev %s\n", print_name());
1910 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1915 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1917 return; /* already closed */
1929 /* Clean up device packet so it can be reused */
1932 * Be careful not to clear items needed by the DVD driver
1933 * when it is closing a single part.
1935 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF|
1936 ST_MOUNTED|ST_MEDIA|ST_SHORT);
1937 label_type = B_BACULA_LABEL;
1938 file = block_num = 0;
1941 EndFile = EndBlock = 0;
1944 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1946 stop_thread_timer(tid);
1952 * This call closes the device, but it is used in DVD handling
1953 * where we close one part and then open the next part. The
1954 * difference between close_part() and close() is that close_part()
1955 * saves the state information of the device (e.g. the Volume lable,
1956 * the Volume Catalog record, ... This permits opening and closing
1957 * the Volume parts multiple times without losing track of what the
1958 * main Volume parameters are.
1960 void DEVICE::close_part(DCR * /*dcr*/)
1962 VOLUME_LABEL saveVolHdr;
1963 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1966 saveVolHdr = VolHdr; /* structure assignment */
1967 saveVolCatInfo = VolCatInfo; /* structure assignment */
1968 close(); /* close current part */
1969 VolHdr = saveVolHdr; /* structure assignment */
1970 VolCatInfo = saveVolCatInfo; /* structure assignment */
1973 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1977 return lseek_dvd(dcr, offset, whence);
1979 #if defined(HAVE_WIN32)
1980 return ::_lseeki64(m_fd, (__int64)offset, whence);
1982 return ::lseek(m_fd, offset, whence);
1989 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1993 Dmsg1(100, "truncate %s\n", print_name());
1998 /* maybe we should rewind and write and eof ???? */
1999 return true; /* we don't really truncate tapes */
2001 return truncate_dvd(dcr);
2003 if (ftruncate(m_fd, 0) != 0) {
2005 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
2006 print_name(), be.bstrerror());
2011 * Check for a successful ftruncate() and issue a work-around for devices
2012 * (mostly cheap NAS) that don't support truncation.
2013 * Workaround supplied by Martin Schmid as a solution to bug #1011.
2016 * 3. open new file with same mode
2017 * 4. change ownership to original
2020 if (fstat(m_fd, &st) != 0) {
2022 Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"),
2023 print_name(), be.bstrerror());
2027 if (st.st_size != 0) { /* ftruncate() didn't work */
2028 POOL_MEM archive_name(PM_FNAME);
2030 pm_strcpy(archive_name, dev_name);
2031 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
2032 pm_strcat(archive_name, "/");
2034 pm_strcat(archive_name, dcr->VolumeName);
2036 Mmsg2(errmsg, _("Device %s doesn't support ftruncate(). Recreating file %s.\n"),
2037 print_name(), archive_name.c_str());
2039 /* Close file and blow it away */
2041 ::unlink(archive_name.c_str());
2043 /* Recreate the file -- of course, empty */
2044 set_mode(CREATE_READ_WRITE);
2045 if ((m_fd = ::open(archive_name.c_str(), mode, st.st_mode)) < 0) {
2048 Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), archive_name.c_str(),
2050 Dmsg1(100, "reopen failed: %s", errmsg);
2051 Emsg0(M_FATAL, 0, errmsg);
2055 /* Reset proper owner */
2056 chown(archive_name.c_str(), st.st_uid, st.st_gid);
2064 /* Mount the device.
2065 * If timeout, wait until the mount command returns 0.
2066 * If !timeout, try to mount the device only once.
2068 bool DEVICE::mount(int timeout)
2070 Dmsg0(190, "Enter mount\n");
2073 } else if (requires_mount()) {
2074 return do_mount(1, timeout);
2079 /* Unmount the device
2080 * If timeout, wait until the unmount command returns 0.
2081 * If !timeout, try to unmount the device only once.
2083 bool DEVICE::unmount(int timeout)
2085 Dmsg0(100, "Enter unmount\n");
2087 return do_mount(0, timeout);
2092 /* (Un)mount the device */
2093 bool DEVICE::do_mount(int mount, int dotimeout)
2095 POOL_MEM ocmd(PM_FNAME);
2098 int status, timeout;
2103 Dmsg0(200, "======= mount=1\n");
2106 icmd = device->mount_command;
2108 if (!is_mounted()) {
2109 Dmsg0(200, "======= mount=0\n");
2112 icmd = device->unmount_command;
2115 clear_freespace_ok();
2116 edit_mount_codes(ocmd, icmd);
2118 Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2121 /* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
2126 results = get_memory(4000);
2128 /* If busy retry each second */
2129 Dmsg1(100, "do_mount run_prog=%s\n", ocmd.c_str());
2130 while ((status = run_program_full_output(ocmd.c_str(),
2131 max_open_wait/2, results)) != 0) {
2132 /* Doesn't work with internationalization (This is not a problem) */
2133 if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2136 if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2139 if (timeout-- > 0) {
2140 /* Sometimes the device cannot be mounted because it is already mounted.
2141 * Try to unmount it, then remount it */
2143 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2151 Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2152 (mount ? "" : "un"), status, results, be.bstrerror(status));
2153 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2154 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2156 Dmsg4(100, "Device %s cannot be %smounted. stat=%d ERR=%s\n", print_name(),
2157 (mount ? "" : "un"), status, results);
2158 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2159 print_name(), (mount ? "" : "un"), results);
2162 * Now, just to be sure it is not mounted, try to read the
2166 struct dirent *entry, *result;
2170 name_max = pathconf(".", _PC_NAME_MAX);
2171 if (name_max < 1024) {
2175 if (!(dp = opendir(device->mount_point))) {
2178 Dmsg3(100, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2179 device->mount_point, print_name(), be.bstrerror());
2183 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2186 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2188 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
2189 device->mount_point, print_name());
2192 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2193 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2196 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2202 Dmsg1(100, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2205 /* If we got more than ., .. and .keep */
2206 /* there must be something mounted */
2208 Dmsg1(100, "Did Mount by count=%d\n", count);
2211 /* An unmount request. We failed to unmount - report an error */
2213 free_pool_memory(results);
2214 Dmsg0(200, "== error mount=1 wanted unmount\n");
2220 free_pool_memory(results);
2221 Dmsg0(200, "============ mount=0\n");
2226 set_mounted(mount); /* set/clear mounted flag */
2227 free_pool_memory(results);
2228 /* Do not check free space when unmounting */
2229 if (mount && !update_freespace()) {
2232 Dmsg1(200, "============ mount=%d\n", mount);
2237 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2239 * %a = archive device name
2240 * %e = erase (set if cannot mount and first part)
2243 * %v = last part name
2245 * omsg = edited output message
2246 * imsg = input string containing edit codes (%x)
2249 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2255 POOL_MEM archive_name(PM_FNAME);
2257 omsg.c_str()[0] = 0;
2258 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2259 for (p=imsg; *p; p++) {
2269 if (num_dvd_parts == 0) {
2270 if (truncating || blank_dvd) {
2280 bsnprintf(add, sizeof(add), "%d", part);
2284 str = device->mount_point;
2287 make_spooled_dvd_filename(this, archive_name);
2288 str = archive_name.c_str();
2302 Dmsg1(1900, "add_str %s\n", str);
2303 pm_strcat(omsg, (char *)str);
2304 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2308 /* return the last timer interval (ms)
2309 * or 0 if something goes wrong
2311 btime_t DEVICE::get_timer_count()
2313 btime_t temp = last_timer;
2314 last_timer = get_current_btime();
2315 temp = last_timer - temp; /* get elapsed time */
2316 return (temp>0)?temp:0; /* take care of skewed clock */
2320 ssize_t DEVICE::read(void *buf, size_t len)
2326 read_len = d_read(m_fd, buf, len);
2328 last_tick = get_timer_count();
2330 DevReadTime += last_tick;
2331 VolCatInfo.VolReadTime += last_tick;
2333 if (read_len > 0) { /* skip error */
2334 DevReadBytes += read_len;
2341 ssize_t DEVICE::write(const void *buf, size_t len)
2347 write_len = d_write(m_fd, buf, len);
2349 last_tick = get_timer_count();
2351 DevWriteTime += last_tick;
2352 VolCatInfo.VolWriteTime += last_tick;
2354 if (write_len > 0) { /* skip error */
2355 DevWriteBytes += write_len;
2361 /* Return the resource name for the device */
2362 const char *DEVICE::name() const
2364 return device->hdr.name;
2367 /* Returns file position on tape or -1 */
2368 int32_t DEVICE::get_os_tape_file()
2370 struct mtget mt_stat;
2372 if (has_cap(CAP_MTIOCGET) &&
2373 d_ioctl(m_fd, MTIOCGET, (char *)&mt_stat) == 0) {
2374 return mt_stat.mt_fileno;
2380 dev_vol_name(DEVICE *dev)
2382 return dev->VolCatInfo.VolCatName;
2387 * Free memory allocated for the device
2389 void DEVICE::term(void)
2391 Dmsg1(900, "term dev: %s\n", print_name());
2394 free_memory(dev_name);
2398 free_memory(prt_name);
2402 free_pool_memory(errmsg);
2405 pthread_mutex_destroy(&m_mutex);
2406 pthread_cond_destroy(&wait);
2407 pthread_cond_destroy(&wait_next_vol);
2408 pthread_mutex_destroy(&spool_mutex);
2409 // rwl_destroy(&lock);
2410 if (attached_dcrs) {
2411 delete attached_dcrs;
2412 attached_dcrs = NULL;
2421 * This routine initializes the device wait timers
2423 void init_device_wait_timers(DCR *dcr)
2425 DEVICE *dev = dcr->dev;
2426 JCR *jcr = dcr->jcr;
2428 /* ******FIXME******* put these on config variables */
2429 dev->min_wait = 60 * 60;
2430 dev->max_wait = 24 * 60 * 60;
2431 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2432 dev->wait_sec = dev->min_wait;
2433 dev->rem_wait_sec = dev->wait_sec;
2437 jcr->min_wait = 60 * 60;
2438 jcr->max_wait = 24 * 60 * 60;
2439 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2440 jcr->wait_sec = jcr->min_wait;
2441 jcr->rem_wait_sec = jcr->wait_sec;
2446 void init_jcr_device_wait_timers(JCR *jcr)
2448 /* ******FIXME******* put these on config variables */
2449 jcr->min_wait = 60 * 60;
2450 jcr->max_wait = 24 * 60 * 60;
2451 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2452 jcr->wait_sec = jcr->min_wait;
2453 jcr->rem_wait_sec = jcr->wait_sec;
2459 * The dev timers are used for waiting on a particular device
2461 * Returns: true if time doubled
2462 * false if max time expired
2464 bool double_dev_wait_time(DEVICE *dev)
2466 dev->wait_sec *= 2; /* double wait time */
2467 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2468 dev->wait_sec = dev->max_wait;
2471 dev->rem_wait_sec = dev->wait_sec;
2472 if (dev->num_wait >= dev->max_num_wait) {
2479 void set_os_device_parameters(DCR *dcr)
2481 DEVICE *dev = dcr->dev;
2483 if (strcmp(dev->dev_name, "/dev/null") == 0) {
2484 return; /* no use trying to set /dev/null */
2487 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2490 Dmsg0(100, "In set_os_device_parameters\n");
2491 #if defined(MTSETBLK)
2492 if (dev->min_block_size == dev->max_block_size &&
2493 dev->min_block_size == 0) { /* variable block mode */
2494 mt_com.mt_op = MTSETBLK;
2495 mt_com.mt_count = 0;
2496 Dmsg0(100, "Set block size to zero\n");
2497 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2498 dev->clrerror(MTSETBLK);
2502 #if defined(MTSETDRVBUFFER)
2503 if (getuid() == 0) { /* Only root can do this */
2504 mt_com.mt_op = MTSETDRVBUFFER;
2505 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2506 if (!dev->has_cap(CAP_TWOEOF)) {
2507 mt_com.mt_count |= MT_ST_TWO_FM;
2509 if (dev->has_cap(CAP_EOM)) {
2510 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2512 Dmsg0(100, "MTSETDRVBUFFER\n");
2513 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2514 dev->clrerror(MTSETDRVBUFFER);
2521 #ifdef HAVE_NETBSD_OS
2523 if (dev->min_block_size == dev->max_block_size &&
2524 dev->min_block_size == 0) { /* variable block mode */
2525 mt_com.mt_op = MTSETBSIZ;
2526 mt_com.mt_count = 0;
2527 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2528 dev->clrerror(MTSETBSIZ);
2530 /* Get notified at logical end of tape */
2531 mt_com.mt_op = MTEWARN;
2532 mt_com.mt_count = 1;
2533 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2534 dev->clrerror(MTEWARN);
2540 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2542 if (dev->min_block_size == dev->max_block_size &&
2543 dev->min_block_size == 0) { /* variable block mode */
2544 mt_com.mt_op = MTSETBSIZ;
2545 mt_com.mt_count = 0;
2546 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2547 dev->clrerror(MTSETBSIZ);
2550 #if defined(MTIOCSETEOTMODEL)
2552 if (dev->has_cap(CAP_TWOEOF)) {
2557 if (dev->d_ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2559 dev->dev_errno = errno; /* save errno */
2560 Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2561 dev->print_name(), be.bstrerror(dev->dev_errno));
2562 Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2570 if (dev->min_block_size == dev->max_block_size &&
2571 dev->min_block_size == 0) { /* variable block mode */
2572 mt_com.mt_op = MTSRSZ;
2573 mt_com.mt_count = 0;
2574 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2575 dev->clrerror(MTSRSZ);
2582 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2584 Dmsg0(100, "dev_get_os_pos\n");
2585 return dev->has_cap(CAP_MTIOCGET) &&
2586 dev->d_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2587 mt_stat->mt_fileno >= 0;
2590 static const char *modes[] = {
2591 "CREATE_READ_WRITE",
2598 static const char *mode_to_str(int mode)
2600 static char buf[100];
2601 if (mode < 1 || mode > 4) {
2602 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2605 return modes[mode-1];