2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2012 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 three of the GNU Affero 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 Affero 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.
53 * Handling I/O errors and end of tape conditions are a bit tricky.
54 * This is how it is currently done when writing.
55 * On either an I/O error or end of tape,
56 * we will stop writing on the physical device (no I/O recovery is
57 * attempted at least in this daemon). The state flag will be sent
58 * to include ST_EOT, which is ephemeral, and ST_WEOT, which is
59 * persistent. Lots of routines clear ST_EOT, but ST_WEOT is
60 * cleared only when the problem goes away. Now when ST_WEOT
61 * is set all calls to write_block_to_device() call the fix_up
62 * routine. In addition, all threads are blocked
63 * from writing on the tape by calling lock_dev(), and thread other
64 * than the first thread to hit the EOT will block on a condition
65 * variable. The first thread to hit the EOT will continue to
66 * be able to read and write the tape (he sort of tunnels through
67 * the locking mechanism -- see lock_dev() for details).
69 * Now presumably somewhere higher in the chain of command
70 * (device.c), someone will notice the EOT condition and
71 * get a new tape up, get the tape label read, and mark
72 * the label for rewriting. Then this higher level routine
73 * will write the unwritten buffer to the new volume.
74 * Finally, he will release
75 * any blocked threads by doing a broadcast on the condition
76 * variable. At that point, we should be totally back in
77 * business with no lost data.
88 /* Forward referenced functions */
89 void set_os_device_parameters(DCR *dcr);
90 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat);
91 static const char *mode_to_str(int mode);
92 static DEVICE *m_init_dev(JCR *jcr, DEVRES *device, bool new_init);
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)
108 DEVICE *dev = m_init_dev(jcr, device, false);
113 m_init_dev(JCR *jcr, DEVRES *device, bool new_init)
122 /* If no device type specified, try to guess */
123 if (!device->dev_type) {
124 /* Check that device is available */
125 if (stat(device->device_name, &statp) < 0) {
127 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
128 device->device_name, be.bstrerror());
131 if (S_ISDIR(statp.st_mode)) {
132 device->dev_type = B_FILE_DEV;
133 } else if (S_ISCHR(statp.st_mode)) {
134 device->dev_type = B_TAPE_DEV;
135 } else if (S_ISFIFO(statp.st_mode)) {
136 device->dev_type = B_FIFO_DEV;
138 /* must set DeviceType = Vtape
139 * in normal mode, autodetection is disabled
141 } else if (S_ISREG(statp.st_mode)) {
142 device->dev_type = B_VTAPE_DEV;
144 } else if (!(device->cap_bits & CAP_REQMOUNT)) {
145 Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
146 " or have RequiresMount=yes for DVD. st_mode=%x\n"),
147 device->device_name, statp.st_mode);
150 device->dev_type = B_DVD_DEV;
153 switch (device->dev_type) {
155 Jmsg0(jcr, M_FATAL, 0, _("DVD support is now deprecated\n"));
162 dev = New(ftp_device);
166 /* TODO: defined in src/win32/stored/mtops.cpp */
168 dev = New(win32_tape_device);
171 dev = New(win32_file_device);
183 dev->clear_slot(); /* unknown */
185 /* Copy user supplied device parameters from Resource */
186 dev->dev_name = get_memory(strlen(device->device_name)+1);
187 pm_strcpy(dev->dev_name, device->device_name);
188 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
189 /* We edit "Resource-name" (physical-name) */
190 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
191 Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
192 dev->capabilities = device->cap_bits;
193 dev->min_block_size = device->min_block_size;
194 dev->max_block_size = device->max_block_size;
195 dev->max_volume_size = device->max_volume_size;
196 dev->max_file_size = device->max_file_size;
197 dev->max_concurrent_jobs = device->max_concurrent_jobs;
198 dev->volume_capacity = device->volume_capacity;
199 dev->max_rewind_wait = device->max_rewind_wait;
200 dev->max_open_wait = device->max_open_wait;
201 dev->max_open_vols = device->max_open_vols;
202 dev->vol_poll_interval = device->vol_poll_interval;
203 dev->max_spool_size = device->max_spool_size;
204 dev->drive_index = device->drive_index;
205 dev->autoselect = device->autoselect;
206 dev->dev_type = device->dev_type;
207 dev->device = device;
208 if (dev->is_tape()) { /* No parts on tapes */
209 dev->max_part_size = 0;
211 dev->max_part_size = device->max_part_size;
214 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
215 dev->vol_poll_interval = 60;
219 if (dev->is_fifo()) {
220 dev->capabilities |= CAP_STREAM; /* set stream device */
223 /* If the device requires mount :
224 * - Check that the mount point is available
225 * - Check that (un)mount commands are defined
227 if (dev->is_file() && dev->requires_mount()) {
228 if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
230 dev->dev_errno = errno;
231 Jmsg2(jcr, M_ERROR_TERM, 0, _("Unable to stat mount point %s: ERR=%s\n"),
232 device->mount_point, be.bstrerror());
235 if (!device->mount_command || !device->unmount_command) {
236 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
241 if (dev->max_block_size == 0) {
242 max_bs = DEFAULT_BLOCK_SIZE;
244 max_bs = dev->max_block_size;
246 if (dev->min_block_size > max_bs) {
247 Jmsg(jcr, M_ERROR_TERM, 0, _("Min block size > max on device %s\n"),
250 if (dev->max_block_size > 4096000) {
251 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
252 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
253 dev->max_block_size = 0;
255 if (dev->max_block_size % TAPE_BSIZE != 0) {
256 Jmsg3(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size=%d.\n"),
257 dev->max_block_size, dev->print_name(), TAPE_BSIZE);
259 if (dev->max_volume_size != 0 && dev->max_volume_size < (dev->max_block_size << 4)) {
260 Jmsg(jcr, M_ERROR_TERM, 0, _("Max Vol Size < 8 * Max Block Size for device %s\n"),
264 dev->errmsg = get_pool_memory(PM_EMSG);
267 if ((errstat = pthread_mutex_init(&dev->m_mutex, NULL)) != 0) {
269 dev->dev_errno = errstat;
270 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
271 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
273 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
275 dev->dev_errno = errstat;
276 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
277 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
279 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
281 dev->dev_errno = errstat;
282 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.bstrerror(errstat));
283 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
285 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
287 dev->dev_errno = errstat;
288 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
289 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
291 if ((errstat = pthread_mutex_init(&dev->acquire_mutex, NULL)) != 0) {
293 dev->dev_errno = errstat;
294 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
295 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
297 /* Ensure that we respect this order in P/V operations */
298 bthread_mutex_set_priority(&dev->m_mutex, PRIO_SD_DEV_ACCESS);
299 bthread_mutex_set_priority(&dev->spool_mutex, PRIO_SD_DEV_SPOOL);
300 bthread_mutex_set_priority(&dev->acquire_mutex, PRIO_SD_DEV_ACQUIRE);
301 if ((errstat = pthread_mutex_init(&dev->read_acquire_mutex, NULL)) != 0) {
303 dev->dev_errno = errstat;
304 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
305 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
308 if ((errstat = rwl_init(&dev->lock)) != 0) {
310 dev->dev_errno = errstat;
311 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.bstrerror(errstat));
312 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
317 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
318 Dmsg2(100, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
319 dev->initiated = true;
324 /* default primitives are designed for file */
325 int DEVICE::d_open(const char *pathname, int flags)
327 return ::open(pathname, flags);
330 int DEVICE::d_close(int fd)
335 int DEVICE::d_ioctl(int fd, ioctl_req_t request, char *mt_com)
337 return ::ioctl(fd, request, mt_com);
340 ssize_t DEVICE::d_read(int fd, void *buffer, size_t count)
342 return ::read(fd, buffer, count);
345 ssize_t DEVICE::d_write(int fd, const void *buffer, size_t count)
347 return ::write(fd, buffer, count);
351 * Open the device with the operating system and
352 * initialize buffer pointers.
354 * Returns: true on success
357 * Note, for a tape, the VolName is the name we give to the
358 * volume (not really used here), but for a file, the
359 * VolName represents the name of the file to be created/opened.
360 * In the case of a file, the full name is the device name
361 * (archive_name) with the VolName concatenated.
364 DEVICE::open(DCR *dcr, int omode)
368 if (openmode == omode) {
373 Dmsg0(100, "Close fd for mode change.\n");
374 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
378 dcr->setVolCatName(dcr->VolumeName);
379 VolCatInfo = dcr->VolCatInfo; /* structure assign */
382 Dmsg4(100, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
383 print_name(), getVolCatName(), mode_to_str(omode));
384 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
385 label_type = B_BACULA_LABEL;
387 if (is_tape() || is_fifo()) {
388 open_tape_device(dcr, omode);
389 } else if (is_ftp()) {
390 open_device(dcr, omode);
392 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
393 open_file_device(dcr, omode);
395 state |= preserve; /* reset any important state info */
396 Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, m_fd);
400 void DEVICE::set_mode(int new_mode)
403 case CREATE_READ_WRITE:
404 mode = O_CREAT | O_RDWR | O_BINARY;
406 case OPEN_READ_WRITE:
407 mode = O_RDWR | O_BINARY;
410 mode = O_RDONLY | O_BINARY;
412 case OPEN_WRITE_ONLY:
413 mode = O_WRONLY | O_BINARY;
416 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
422 void DEVICE::open_tape_device(DCR *dcr, int omode)
425 int timeout = max_open_wait;
426 #if !defined(HAVE_WIN32)
428 utime_t start_time = time(NULL);
431 mount(1); /* do mount if required */
433 Dmsg0(100, "Open dev: device is tape\n");
435 get_autochanger_loaded_slot(dcr);
444 if (is_fifo() && timeout) {
446 tid = start_thread_timer(dcr->jcr, pthread_self(), timeout);
448 Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
449 #if defined(HAVE_WIN32)
452 if ((m_fd = d_open(dev_name, mode)) < 0) {
459 /* If busy retry each second for max_open_wait seconds */
461 /* Try non-blocking open */
462 m_fd = d_open(dev_name, mode+O_NONBLOCK);
466 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
467 print_name(), omode, mode, errno, be.bstrerror());
469 /* Tape open, now rewind it */
470 Dmsg0(100, "Rewind after open\n");
471 mt_com.mt_op = MTREW;
473 /* rewind only if dev is a tape */
474 if (is_tape() && (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0)) {
476 dev_errno = errno; /* set error status from rewind */
479 Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
480 be.bstrerror(dev_errno));
481 /* If we get busy, device is probably rewinding, try again */
482 if (dev_errno != EBUSY) {
483 break; /* error -- no medium */
486 /* Got fd and rewind worked, so we must have medium in drive */
488 m_fd = d_open(dev_name, mode); /* open normally */
492 Dmsg5(100, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
493 print_name(), omode, mode, errno, be.bstrerror());
498 set_os_device_parameters(dcr); /* do system dependent stuff */
499 break; /* Successfully opened and rewound */
503 /* Exceed wait time ? */
504 if (time(NULL) - start_time >= max_open_wait) {
505 break; /* yes, get out */
512 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
513 print_name(), be.bstrerror(dev_errno));
514 Dmsg1(100, "%s", errmsg);
517 /* Stop any open() timer we started */
519 stop_thread_timer(tid);
522 Dmsg1(100, "open dev: tape %d opened\n", m_fd);
525 void DEVICE::open_device(DCR *dcr, int omode)
527 /* do nothing waiting to split open_file/tape_device */
531 * Open a file device.
533 void DEVICE::open_file_device(DCR *dcr, int omode)
535 POOL_MEM archive_name(PM_FNAME);
537 get_autochanger_loaded_slot(dcr);
540 * Handle opening of File Archive (not a tape)
543 pm_strcpy(archive_name, dev_name);
545 * If this is a virtual autochanger (i.e. changer_res != NULL)
546 * we simply use the device name, assuming it has been
547 * appropriately setup by the "autochanger".
549 if (!device->changer_res || device->changer_command[0] == 0) {
550 if (VolCatInfo.VolCatName[0] == 0) {
551 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
557 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
558 pm_strcat(archive_name, "/");
560 pm_strcat(archive_name, getVolCatName());
563 mount(1); /* do mount if required */
567 /* If creating file, give 0640 permissions */
568 Dmsg3(100, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
569 archive_name.c_str(), mode);
570 /* Use system open() */
571 if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
574 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
576 Dmsg1(100, "open failed: %s", errmsg);
583 Dmsg4(100, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
584 m_fd, part, num_dvd_parts, part_size);
589 * Returns: true on success
592 bool DEVICE::rewind(DCR *dcr)
598 Dmsg3(400, "rewind res=%d fd=%d %s\n", num_reserved(), m_fd, print_name());
599 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
600 block_num = file = 0;
607 mt_com.mt_op = MTREW;
609 /* If we get an I/O error on rewind, it is probably because
610 * the drive is actually busy. We loop for (about 5 minutes)
611 * retrying every 5 seconds.
613 for (i=max_rewind_wait; ; i -= 5) {
614 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
617 if (i == max_rewind_wait) {
618 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.bstrerror());
621 * This is a gross hack, because if the user has the
622 * device mounted (i.e. open), then uses mtx to load
623 * a tape, the current open file descriptor is invalid.
624 * So, we close the drive and re-open it.
627 int open_mode = openmode;
630 open(dcr, open_mode);
638 if (dev_errno == EIO) {
639 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
643 if (dev_errno == EIO && i > 0) {
644 Dmsg0(200, "Sleeping 5 seconds.\n");
649 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
650 print_name(), be.bstrerror());
655 } else if (is_file()) {
656 if (lseek(dcr, (boffset_t)0, SEEK_SET) < 0) {
659 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
660 print_name(), be.bstrerror());
669 * Called to indicate that we have just read an
670 * EOF from the device.
672 void DEVICE::set_ateof()
684 * Called to indicate we are now at the end of the tape, and
685 * writing is not possible.
687 void DEVICE::set_ateot()
689 /* Make tape effectively read-only */
690 state |= (ST_EOF|ST_EOT|ST_WEOT);
695 * Position device to end of medium (end of data)
696 * Returns: true on succes
699 bool DEVICE::eod(DCR *dcr)
708 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
712 #if defined (__digital__) && defined (__unix__)
713 return fsf(VolCatInfo.VolCatFiles);
716 Dmsg0(100, "Enter eod\n");
720 clear_eof(); /* remove EOF flag */
721 block_num = file = 0;
728 pos = lseek(dcr, (boffset_t)0, SEEK_END);
729 Dmsg1(200, "====== Seek to %lld\n", pos);
737 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
738 print_name(), be.bstrerror());
743 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
744 Dmsg0(100,"Using FAST FSF for EOM\n");
745 /* If unknown position, rewind */
746 if (get_os_tape_file() < 0) {
748 Dmsg0(100, "Rewind error\n");
752 mt_com.mt_op = MTFSF;
754 * ***FIXME*** fix code to handle case that INT16_MAX is
757 mt_com.mt_count = INT16_MAX; /* use big positive number */
758 if (mt_com.mt_count < 0) {
759 mt_com.mt_count = INT16_MAX; /* brain damaged system */
763 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
764 if (has_cap(CAP_EOM)) {
765 Dmsg0(100,"Using EOM for EOM\n");
766 mt_com.mt_op = MTEOM;
770 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
772 clrerror(mt_com.mt_op);
773 Dmsg1(50, "ioctl error: %s\n", be.bstrerror());
775 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
776 print_name(), be.bstrerror());
781 os_file = get_os_tape_file();
785 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
786 print_name(), be.bstrerror());
790 Dmsg1(100, "EOD file=%d\n", os_file);
798 * Rewind then use FSF until EOT reached
801 Dmsg0(100, "Rewind error.\n");
805 * Move file by file to the end of the tape
808 for (file_num=file; !at_eot(); file_num++) {
809 Dmsg0(200, "eod: doing fsf 1\n");
811 Dmsg0(100, "fsf error.\n");
815 * Avoid infinite loop by ensuring we advance.
817 if (!at_eot() && file_num == (int)file) {
818 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
820 os_file = get_os_tape_file();
822 Dmsg2(100, "Adjust file from %d to %d\n", file_num, os_file);
830 * Some drivers leave us after second EOF when doing
831 * MTEOM, so we must backup so that appending overwrites
834 if (has_cap(CAP_BSFATEOM)) {
835 /* Backup over EOF */
837 /* If BSF worked and fileno is known (not -1), set file */
838 os_file = get_os_tape_file();
840 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , os_file);
843 file++; /* wing it -- not correct on all OSes */
846 update_pos(dcr); /* update position */
848 Dmsg1(200, "EOD dev->file=%d\n", file);
853 * Set the position of the device -- only for files and DVD
854 * For other devices, there is no generic way to do it.
855 * Returns: true on succes
858 bool DEVICE::update_pos(DCR *dcr)
865 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
866 Emsg1(M_FATAL, 0, "%s", errmsg);
873 pos = lseek(dcr, (boffset_t)0, SEEK_CUR);
877 Pmsg1(000, _("Seek error: ERR=%s\n"), be.bstrerror());
878 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
879 print_name(), be.bstrerror());
883 block_num = (uint32_t)pos;
884 file = (uint32_t)(pos >> 32);
891 * Return the status of the device. This was meant
892 * to be a generic routine. Unfortunately, it doesn't
893 * seem possible (at least I do not know how to do it
894 * currently), which means that for the moment, this
895 * routine has very little value.
899 uint32_t status_dev(DEVICE *dev)
901 struct mtget mt_stat;
904 if (dev->state & (ST_EOT | ST_WEOT)) {
908 if (dev->state & ST_EOF) {
912 if (dev->is_tape()) {
914 Pmsg0(-20,_(" Bacula status:"));
915 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
916 if (dev->d_ioctl(dev->fd(), MTIOCGET, (char *)&mt_stat) < 0) {
918 dev->dev_errno = errno;
919 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
920 dev->print_name(), be.bstrerror());
923 Pmsg0(-20, _(" Device status:"));
925 #if defined(HAVE_LINUX_OS)
926 if (GMT_EOF(mt_stat.mt_gstat)) {
930 if (GMT_BOT(mt_stat.mt_gstat)) {
934 if (GMT_EOT(mt_stat.mt_gstat)) {
938 if (GMT_SM(mt_stat.mt_gstat)) {
942 if (GMT_EOD(mt_stat.mt_gstat)) {
946 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
948 Pmsg0(-20, " WR_PROT");
950 if (GMT_ONLINE(mt_stat.mt_gstat)) {
952 Pmsg0(-20, " ONLINE");
954 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
956 Pmsg0(-20, " DR_OPEN");
958 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
959 stat |= BMT_IM_REP_EN;
960 Pmsg0(-20, " IM_REP_EN");
962 #elif defined(HAVE_WIN32)
963 if (GMT_EOF(mt_stat.mt_gstat)) {
967 if (GMT_BOT(mt_stat.mt_gstat)) {
971 if (GMT_EOT(mt_stat.mt_gstat)) {
975 if (GMT_EOD(mt_stat.mt_gstat)) {
979 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
981 Pmsg0(-20, " WR_PROT");
983 if (GMT_ONLINE(mt_stat.mt_gstat)) {
985 Pmsg0(-20, " ONLINE");
987 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
989 Pmsg0(-20, " DR_OPEN");
991 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
992 stat |= BMT_IM_REP_EN;
993 Pmsg0(-20, " IM_REP_EN");
996 #endif /* !SunOS && !OSF */
997 if (dev->has_cap(CAP_MTIOCGET)) {
998 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1000 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1003 stat |= BMT_ONLINE | BMT_BOT;
1010 * Load medium in device
1011 * Returns: true on success
1014 bool load_dev(DEVICE *dev)
1020 if (dev->fd() < 0) {
1021 dev->dev_errno = EBADF;
1022 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1023 Emsg0(M_FATAL, 0, dev->errmsg);
1026 if (!(dev->is_tape())) {
1030 Dmsg0(200, "stored: MTLOAD command not available\n");
1032 dev->dev_errno = ENOTTY; /* function not available */
1033 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1034 dev->print_name(), be.bstrerror());
1038 dev->block_num = dev->file = 0;
1041 mt_com.mt_op = MTLOAD;
1042 mt_com.mt_count = 1;
1043 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
1045 dev->dev_errno = errno;
1046 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1047 dev->print_name(), be.bstrerror());
1055 * Rewind device and put it offline
1056 * Returns: true on success
1059 bool DEVICE::offline()
1064 return true; /* device not open */
1067 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1068 block_num = file = 0;
1072 mt_com.mt_op = MTOFFL;
1073 mt_com.mt_count = 1;
1074 if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) {
1077 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1078 print_name(), be.bstrerror());
1081 Dmsg1(100, "Offlined device %s\n", print_name());
1085 bool DEVICE::offline_or_rewind()
1090 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1094 * Note, this rewind probably should not be here (it wasn't
1095 * in prior versions of Bacula), but on FreeBSD, this is
1096 * needed in the case the tape was "frozen" due to an error
1097 * such as backspacing after writing and EOF. If it is not
1098 * done, all future references to the drive get and I/O error.
1101 return rewind(NULL);
1106 * Foward space a file
1107 * Returns: true on success
1110 bool DEVICE::fsf(int num)
1112 int32_t os_file = 0;
1118 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1119 Emsg0(M_FATAL, 0, errmsg);
1129 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1133 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1136 Dmsg0(100, "fsf\n");
1139 * If Fast forward space file is set, then we
1140 * use MTFSF to forward space and MTIOCGET
1141 * to get the file position. We assume that
1142 * the SCSI driver will ensure that we do not
1143 * forward space past the end of the medium.
1145 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1147 mt_com.mt_op = MTFSF;
1148 mt_com.mt_count = num;
1149 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1151 my_errno = errno; /* save errno */
1152 } else if ((os_file=get_os_tape_file()) < 0) {
1153 my_errno = errno; /* save errno */
1155 if (my_errno != 0) {
1158 Dmsg0(200, "Set ST_EOT\n");
1160 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1161 print_name(), be.bstrerror(my_errno));
1162 Dmsg1(200, "%s", errmsg);
1166 Dmsg1(200, "fsf file=%d\n", os_file);
1172 * Here if CAP_FSF is set, and virtually all drives
1173 * these days support it, we read a record, then forward
1174 * space one file. Using this procedure, which is slow,
1175 * is the only way we can be sure that we don't read
1176 * two consecutive EOF marks, which means End of Data.
1178 } else if (has_cap(CAP_FSF)) {
1181 Dmsg0(200, "FSF has cap_fsf\n");
1182 if (max_block_size == 0) {
1183 rbuf_len = DEFAULT_BLOCK_SIZE;
1185 rbuf_len = max_block_size;
1187 rbuf = get_memory(rbuf_len);
1188 mt_com.mt_op = MTFSF;
1189 mt_com.mt_count = 1;
1190 while (num-- && !at_eot()) {
1191 Dmsg0(100, "Doing read before fsf\n");
1192 if ((stat = this->read((char *)rbuf, rbuf_len)) < 0) {
1193 if (errno == ENOMEM) { /* tape record exceeds buf len */
1194 stat = rbuf_len; /* This is OK */
1196 * On IBM drives, they return ENOSPC at EOM
1197 * instead of EOF status
1199 } else if (at_eof() && errno == ENOSPC) {
1205 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1207 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1208 print_name(), be.bstrerror());
1209 Dmsg1(100, "%s", errmsg);
1213 if (stat == 0) { /* EOF */
1214 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1215 /* Two reads of zero means end of tape */
1218 Dmsg0(100, "Set ST_EOT\n");
1224 } else { /* Got data */
1229 Dmsg0(100, "Doing MTFSF\n");
1230 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1231 if (stat < 0) { /* error => EOT */
1234 Dmsg0(100, "Set ST_EOT\n");
1236 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1237 print_name(), be.bstrerror());
1238 Dmsg0(100, "Got < 0 for MTFSF\n");
1239 Dmsg1(100, "%s", errmsg);
1247 * No FSF, so use FSR to simulate it
1250 Dmsg0(200, "Doing FSR for FSF\n");
1251 while (num-- && !at_eot()) {
1252 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1256 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1262 Dmsg1(200, "Return %d from FSF\n", stat);
1264 Dmsg0(200, "ST_EOF set on exit FSF\n");
1267 Dmsg0(200, "ST_EOT set on exit FSF\n");
1269 Dmsg1(200, "Return from FSF file=%d\n", file);
1274 * Backward space a file
1275 * Returns: false on failure
1278 bool DEVICE::bsf(int num)
1285 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1286 Emsg0(M_FATAL, 0, errmsg);
1291 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1296 Dmsg0(100, "bsf\n");
1302 mt_com.mt_op = MTBSF;
1303 mt_com.mt_count = num;
1304 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1308 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1309 print_name(), be.bstrerror());
1316 * Foward space num records
1317 * Returns: false on failure
1320 bool DEVICE::fsr(int num)
1327 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1328 Emsg0(M_FATAL, 0, errmsg);
1336 if (!has_cap(CAP_FSR)) {
1337 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1341 Dmsg1(100, "fsr %d\n", num);
1342 mt_com.mt_op = MTFSR;
1343 mt_com.mt_count = num;
1344 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1350 struct mtget mt_stat;
1352 Dmsg1(100, "FSF fail: ERR=%s\n", be.bstrerror());
1353 if (dev_get_os_pos(this, &mt_stat)) {
1354 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1355 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1356 file = mt_stat.mt_fileno;
1357 block_num = mt_stat.mt_blkno;
1365 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1366 num, print_name(), be.bstrerror());
1372 * Backward space a record
1373 * Returns: false on failure
1376 bool DEVICE::bsr(int num)
1383 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1384 Emsg0(M_FATAL, 0, errmsg);
1392 if (!has_cap(CAP_BSR)) {
1393 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1397 Dmsg0(100, "bsr_dev\n");
1401 mt_com.mt_op = MTBSR;
1402 mt_com.mt_count = num;
1403 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1407 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1408 print_name(), be.bstrerror());
1413 void DEVICE::lock_door()
1417 if (!is_tape()) return;
1418 mt_com.mt_op = MTLOCK;
1419 mt_com.mt_count = 1;
1420 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1424 void DEVICE::unlock_door()
1428 if (!is_tape()) return;
1429 mt_com.mt_op = MTUNLOCK;
1430 mt_com.mt_count = 1;
1431 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1435 void DEVICE::set_slot(int32_t slot)
1438 if (vol) vol->clear_slot();
1441 void DEVICE::clear_slot()
1444 if (vol) vol->set_slot(-1);
1450 * Reposition the device to file, block
1451 * Returns: false on failure
1454 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1458 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1459 Emsg0(M_FATAL, 0, errmsg);
1464 boffset_t pos = (((boffset_t)rfile)<<32) | rblock;
1465 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1466 if (lseek(dcr, pos, SEEK_SET) == (boffset_t)-1) {
1469 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1470 print_name(), be.bstrerror());
1479 /* After this point, we are tape only */
1480 Dmsg4(100, "reposition from %u:%u to %u:%u\n", file, block_num, rfile, rblock);
1482 Dmsg0(100, "Rewind\n");
1483 if (!rewind(NULL)) {
1488 Dmsg1(100, "fsf %d\n", rfile-file);
1489 if (!fsf(rfile-file)) {
1490 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1493 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1495 if (rblock < block_num) {
1496 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1497 Dmsg0(100, "bsf 1\n");
1499 Dmsg0(100, "fsf 1\n");
1501 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1503 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1504 /* Ignore errors as Bacula can read to the correct block */
1505 Dmsg1(100, "fsr %d\n", rblock-block_num);
1506 return fsr(rblock-block_num);
1508 while (rblock > block_num) {
1509 if (!dcr->read_block_from_dev(NO_BLOCK_NUMBER_CHECK)) {
1512 Dmsg2(30, "Failed to find requested block on %s: ERR=%s",
1513 print_name(), be.bstrerror());
1516 Dmsg2(300, "moving forward wanted_blk=%d at_blk=%d\n", rblock, block_num);
1525 * Write an end of file on the device
1526 * Returns: true on success
1529 bool DEVICE::weof(int num)
1533 Dmsg1(129, "=== weof_dev=%s\n", print_name());
1537 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1538 Emsg0(M_FATAL, 0, errmsg);
1546 if (!can_append()) {
1547 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1548 Emsg0(M_FATAL, 0, errmsg);
1554 mt_com.mt_op = MTWEOF;
1555 mt_com.mt_count = num;
1556 stat = d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1565 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1566 print_name(), be.bstrerror());
1574 * If implemented in system, clear the tape
1577 void DEVICE::clrerror(int func)
1579 const char *msg = NULL;
1582 dev_errno = errno; /* save errno */
1584 VolCatInfo.VolCatErrors++;
1591 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1594 break; /* ignore message printed later */
1597 clear_cap(CAP_EOF); /* turn off feature */
1602 clear_cap(CAP_EOM); /* turn off feature */
1607 clear_cap(CAP_FSF); /* turn off feature */
1611 clear_cap(CAP_BSF); /* turn off feature */
1615 clear_cap(CAP_FSR); /* turn off feature */
1619 clear_cap(CAP_BSR); /* turn off feature */
1629 #ifdef MTSETDRVBUFFER
1630 case MTSETDRVBUFFER:
1631 msg = "MTSETDRVBUFFER";
1664 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1670 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1671 Emsg0(M_ERROR, 0, errmsg);
1676 * Now we try different methods of clearing the error
1677 * status on the drive so that it is not locked for
1678 * further operations.
1681 /* On some systems such as NetBSD, this clears all errors */
1684 /* Found on Solaris */
1687 d_ioctl(m_fd, MTIOCLRERR);
1688 Dmsg0(200, "Did MTIOCLRERR\n");
1692 /* Typically on FreeBSD */
1696 /* Read and clear SCSI error status */
1697 union mterrstat mt_errstat;
1698 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1699 be.bstrerror(dev_errno));
1700 d_ioctl(m_fd, MTIOCERRSTAT, (char *)&mt_errstat);
1704 /* Clear Subsystem Exception TRU64 */
1708 mt_com.mt_op = MTCSE;
1709 mt_com.mt_count = 1;
1710 /* Clear any error condition on the tape */
1711 d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com);
1712 Dmsg0(200, "Did MTCSE\n");
1719 * Set to unload the current volume in the drive
1721 void DEVICE::set_unload()
1723 if (!m_unload && VolHdr.VolumeName[0] != 0) {
1725 memcpy(UnloadVolName, VolHdr.VolumeName, sizeof(UnloadVolName));
1731 * Clear volume header
1733 void DEVICE::clear_volhdr()
1735 Dmsg1(100, "Clear volhdr vol=%s\n", VolHdr.VolumeName);
1736 memset(&VolHdr, 0, sizeof(VolHdr));
1737 setVolCatInfo(false);
1744 void DEVICE::close()
1746 Dmsg1(100, "close_dev %s\n", print_name());
1747 offline_or_rewind();
1750 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1752 return; /* already closed */
1760 /* Fall through wanted */
1766 unmount(1); /* do unmount if required */
1768 /* Clean up device packet so it can be reused */
1771 * Be careful not to clear items needed by the DVD driver
1772 * when it is closing a single part.
1774 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF|
1775 ST_MOUNTED|ST_MEDIA|ST_SHORT);
1776 label_type = B_BACULA_LABEL;
1777 file = block_num = 0;
1780 EndFile = EndBlock = 0;
1783 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1785 stop_thread_timer(tid);
1791 * This call closes the device, but it is used in DVD handling
1792 * where we close one part and then open the next part. The
1793 * difference between close_part() and close() is that close_part()
1794 * saves the state information of the device (e.g. the Volume lable,
1795 * the Volume Catalog record, ... This permits opening and closing
1796 * the Volume parts multiple times without losing track of what the
1797 * main Volume parameters are.
1799 void DEVICE::close_part(DCR * /*dcr*/)
1801 VOLUME_LABEL saveVolHdr;
1802 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1805 saveVolHdr = VolHdr; /* structure assignment */
1806 saveVolCatInfo = VolCatInfo; /* structure assignment */
1807 close(); /* close current part */
1808 VolHdr = saveVolHdr; /* structure assignment */
1809 VolCatInfo = saveVolCatInfo; /* structure assignment */
1812 boffset_t DEVICE::lseek(DCR *dcr, boffset_t offset, int whence)
1816 #if defined(HAVE_WIN32)
1817 return ::_lseeki64(m_fd, (__int64)offset, whence);
1819 return ::lseek(m_fd, offset, whence);
1826 * Truncate a volume.
1828 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1833 Dmsg1(100, "truncate %s\n", print_name());
1838 /* maybe we should rewind and write and eof ???? */
1839 return true; /* we don't really truncate tapes */
1842 if (ftruncate(dev->m_fd, 0) != 0) {
1844 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1845 print_name(), be.bstrerror());
1850 * Check for a successful ftruncate() and issue a work-around for devices
1851 * (mostly cheap NAS) that don't support truncation.
1852 * Workaround supplied by Martin Schmid as a solution to bug #1011.
1855 * 3. open new file with same mode
1856 * 4. change ownership to original
1859 if (fstat(dev->m_fd, &st) != 0) {
1861 Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"),
1862 print_name(), be.bstrerror());
1866 if (st.st_size != 0) { /* ftruncate() didn't work */
1867 POOL_MEM archive_name(PM_FNAME);
1869 pm_strcpy(archive_name, dev_name);
1870 if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) {
1871 pm_strcat(archive_name, "/");
1873 pm_strcat(archive_name, dcr->VolumeName);
1875 Mmsg2(errmsg, _("Device %s doesn't support ftruncate(). Recreating file %s.\n"),
1876 print_name(), archive_name.c_str());
1878 /* Close file and blow it away */
1880 ::unlink(archive_name.c_str());
1882 /* Recreate the file -- of course, empty */
1883 dev->set_mode(CREATE_READ_WRITE);
1884 if ((dev->m_fd = ::open(archive_name.c_str(), mode, st.st_mode)) < 0) {
1887 Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), archive_name.c_str(),
1889 Dmsg1(100, "reopen failed: %s", errmsg);
1890 Emsg0(M_FATAL, 0, errmsg);
1894 /* Reset proper owner */
1895 chown(archive_name.c_str(), st.st_uid, st.st_gid);
1906 * If timeout, wait until the mount command returns 0.
1907 * If !timeout, try to mount the device only once.
1909 bool DEVICE::mount(int timeout)
1911 Dmsg0(190, "Enter mount\n");
1921 if (device->mount_command) {
1922 return do_tape_mount(1, timeout);
1926 if (requires_mount() && device->mount_command) {
1927 return do_file_mount(1, timeout);
1938 * Unmount the device
1939 * If timeout, wait until the unmount command returns 0.
1940 * If !timeout, try to unmount the device only once.
1942 bool DEVICE::unmount(int timeout)
1944 Dmsg0(100, "Enter unmount\n");
1946 if (!is_mounted()) {
1954 if (device->unmount_command) {
1955 return do_tape_mount(0, timeout);
1960 if (requires_mount() && device->unmount_command) {
1961 return do_file_mount(0, timeout);
1972 * (Un)mount the device (for tape devices)
1974 bool DEVICE::do_tape_mount(int mount, int dotimeout)
1976 POOL_MEM ocmd(PM_FNAME);
1984 icmd = device->mount_command;
1986 icmd = device->unmount_command;
1989 edit_mount_codes(ocmd, icmd);
1991 Dmsg2(100, "do_tape_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1994 /* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
1999 results = get_memory(4000);
2001 /* If busy retry each second */
2002 Dmsg1(100, "do_tape_mount run_prog=%s\n", ocmd.c_str());
2003 while ((status = run_program_full_output(ocmd.c_str(), max_open_wait/2, results)) != 0) {
2008 Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2009 (mount ? "" : "un"), status, results, be.bstrerror(status));
2010 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2011 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2014 free_pool_memory(results);
2015 Dmsg0(200, "============ mount=0\n");
2020 set_mounted(mount); /* set/clear mounted flag */
2021 free_pool_memory(results);
2022 Dmsg1(200, "============ mount=%d\n", mount);
2027 * (Un)mount the device (either a FILE or DVD device)
2029 bool DEVICE::do_file_mount(int mount, int dotimeout)
2031 POOL_MEM ocmd(PM_FNAME);
2035 struct dirent *entry, *result;
2036 int status, tries, name_max, count;
2041 icmd = device->mount_command;
2043 icmd = device->unmount_command;
2046 clear_freespace_ok();
2047 edit_mount_codes(ocmd, icmd);
2049 Dmsg2(100, "do_file_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
2052 /* Try at most 10 times to (un)mount the device. This should perhaps be configurable. */
2057 results = get_memory(4000);
2059 /* If busy retry each second */
2060 Dmsg1(100, "do_file_mount run_prog=%s\n", ocmd.c_str());
2061 while ((status = run_program_full_output(ocmd.c_str(), max_open_wait/2, results)) != 0) {
2062 /* Doesn't work with internationalization (This is not a problem) */
2063 if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
2066 if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
2070 /* Sometimes the device cannot be mounted because it is already mounted.
2071 * Try to unmount it, then remount it */
2073 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2074 do_file_mount(0, 0);
2079 Dmsg5(100, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2080 (mount ? "" : "un"), status, results, be.bstrerror(status));
2081 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2082 print_name(), (mount ? "" : "un"), be.bstrerror(status));
2085 * Now, just to be sure it is not mounted, try to read the filesystem.
2087 name_max = pathconf(".", _PC_NAME_MAX);
2088 if (name_max < 1024) {
2092 if (!(dp = opendir(device->mount_point))) {
2095 Dmsg3(100, "do_file_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2096 device->mount_point, print_name(), be.bstrerror());
2100 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2103 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2105 Dmsg2(129, "do_file_mount: failed to find suitable file in dir %s (dev=%s)\n",
2106 device->mount_point, print_name());
2109 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2110 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2113 Dmsg2(129, "do_file_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2119 Dmsg1(100, "do_file_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2122 /* If we got more than ., .. and .keep */
2123 /* there must be something mounted */
2125 Dmsg1(100, "Did Mount by count=%d\n", count);
2128 /* An unmount request. We failed to unmount - report an error */
2130 free_pool_memory(results);
2131 Dmsg0(200, "== error mount=1 wanted unmount\n");
2137 free_pool_memory(results);
2138 Dmsg0(200, "============ mount=0\n");
2143 set_mounted(mount); /* set/clear mounted flag */
2144 free_pool_memory(results);
2145 /* Do not check free space when unmounting */
2146 if (mount && !update_freespace()) {
2149 Dmsg1(200, "============ mount=%d\n", mount);
2154 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2156 * %a = archive device name
2157 * %e = erase (set if cannot mount and first part)
2160 * %v = last part name
2162 * omsg = edited output message
2163 * imsg = input string containing edit codes (%x)
2166 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2172 POOL_MEM archive_name(PM_FNAME);
2174 omsg.c_str()[0] = 0;
2175 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2176 for (p=imsg; *p; p++) {
2186 if (num_dvd_parts == 0) {
2187 if (truncating || blank_dvd) {
2197 bsnprintf(add, sizeof(add), "%d", part);
2201 str = device->mount_point;
2204 make_spooled_dvd_filename(this, archive_name);
2205 str = archive_name.c_str();
2219 Dmsg1(1900, "add_str %s\n", str);
2220 pm_strcat(omsg, (char *)str);
2221 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2225 /* return the last timer interval (ms)
2226 * or 0 if something goes wrong
2228 btime_t DEVICE::get_timer_count()
2230 btime_t temp = last_timer;
2231 last_timer = get_current_btime();
2232 temp = last_timer - temp; /* get elapsed time */
2233 return (temp>0)?temp:0; /* take care of skewed clock */
2237 ssize_t DEVICE::read(void *buf, size_t len)
2243 read_len = d_read(m_fd, buf, len);
2245 last_tick = get_timer_count();
2247 DevReadTime += last_tick;
2248 VolCatInfo.VolReadTime += last_tick;
2250 if (read_len > 0) { /* skip error */
2251 DevReadBytes += read_len;
2258 ssize_t DEVICE::write(const void *buf, size_t len)
2264 write_len = d_write(m_fd, buf, len);
2266 last_tick = get_timer_count();
2268 DevWriteTime += last_tick;
2269 VolCatInfo.VolWriteTime += last_tick;
2271 if (write_len > 0) { /* skip error */
2272 DevWriteBytes += write_len;
2278 /* Return the resource name for the device */
2279 const char *DEVICE::name() const
2281 return device->hdr.name;
2284 /* Returns file position on tape or -1 */
2285 int32_t DEVICE::get_os_tape_file()
2287 struct mtget mt_stat;
2289 if (has_cap(CAP_MTIOCGET) &&
2290 d_ioctl(m_fd, MTIOCGET, (char *)&mt_stat) == 0) {
2291 return mt_stat.mt_fileno;
2297 dev_vol_name(DEVICE *dev)
2299 return dev->getVolCatName();
2304 * Free memory allocated for the device
2306 void DEVICE::term(void)
2309 Dmsg1(900, "term dev: %s\n", print_name());
2312 free_memory(dev_name);
2316 free_memory(prt_name);
2320 free_pool_memory(errmsg);
2323 pthread_mutex_destroy(&m_mutex);
2324 pthread_cond_destroy(&wait);
2325 pthread_cond_destroy(&wait_next_vol);
2326 pthread_mutex_destroy(&spool_mutex);
2327 // rwl_destroy(&lock);
2328 if (attached_dcrs) {
2329 delete attached_dcrs;
2330 attached_dcrs = NULL;
2342 * This routine initializes the device wait timers
2344 void init_device_wait_timers(DCR *dcr)
2346 DEVICE *dev = dcr->dev;
2347 JCR *jcr = dcr->jcr;
2349 /* ******FIXME******* put these on config variables */
2350 dev->min_wait = 60 * 60;
2351 dev->max_wait = 24 * 60 * 60;
2352 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2353 dev->wait_sec = dev->min_wait;
2354 dev->rem_wait_sec = dev->wait_sec;
2358 jcr->min_wait = 60 * 60;
2359 jcr->max_wait = 24 * 60 * 60;
2360 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2361 jcr->wait_sec = jcr->min_wait;
2362 jcr->rem_wait_sec = jcr->wait_sec;
2367 void init_jcr_device_wait_timers(JCR *jcr)
2369 /* ******FIXME******* put these on config variables */
2370 jcr->min_wait = 60 * 60;
2371 jcr->max_wait = 24 * 60 * 60;
2372 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2373 jcr->wait_sec = jcr->min_wait;
2374 jcr->rem_wait_sec = jcr->wait_sec;
2380 * The dev timers are used for waiting on a particular device
2382 * Returns: true if time doubled
2383 * false if max time expired
2385 bool double_dev_wait_time(DEVICE *dev)
2387 dev->wait_sec *= 2; /* double wait time */
2388 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2389 dev->wait_sec = dev->max_wait;
2392 dev->rem_wait_sec = dev->wait_sec;
2393 if (dev->num_wait >= dev->max_num_wait) {
2400 void set_os_device_parameters(DCR *dcr)
2402 DEVICE *dev = dcr->dev;
2404 if (strcmp(dev->dev_name, "/dev/null") == 0) {
2405 return; /* no use trying to set /dev/null */
2408 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2411 Dmsg0(100, "In set_os_device_parameters\n");
2412 #if defined(MTSETBLK)
2413 if (dev->min_block_size == dev->max_block_size &&
2414 dev->min_block_size == 0) { /* variable block mode */
2415 mt_com.mt_op = MTSETBLK;
2416 mt_com.mt_count = 0;
2417 Dmsg0(100, "Set block size to zero\n");
2418 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2419 dev->clrerror(MTSETBLK);
2423 #if defined(MTSETDRVBUFFER)
2424 if (getuid() == 0) { /* Only root can do this */
2425 mt_com.mt_op = MTSETDRVBUFFER;
2426 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2427 if (!dev->has_cap(CAP_TWOEOF)) {
2428 mt_com.mt_count |= MT_ST_TWO_FM;
2430 if (dev->has_cap(CAP_EOM)) {
2431 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2433 Dmsg0(100, "MTSETDRVBUFFER\n");
2434 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2435 dev->clrerror(MTSETDRVBUFFER);
2442 #ifdef HAVE_NETBSD_OS
2444 if (dev->min_block_size == dev->max_block_size &&
2445 dev->min_block_size == 0) { /* variable block mode */
2446 mt_com.mt_op = MTSETBSIZ;
2447 mt_com.mt_count = 0;
2448 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2449 dev->clrerror(MTSETBSIZ);
2451 /* Get notified at logical end of tape */
2452 mt_com.mt_op = MTEWARN;
2453 mt_com.mt_count = 1;
2454 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2455 dev->clrerror(MTEWARN);
2461 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2463 if (dev->min_block_size == dev->max_block_size &&
2464 dev->min_block_size == 0) { /* variable block mode */
2465 mt_com.mt_op = MTSETBSIZ;
2466 mt_com.mt_count = 0;
2467 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2468 dev->clrerror(MTSETBSIZ);
2471 #if defined(MTIOCSETEOTMODEL)
2473 if (dev->has_cap(CAP_TWOEOF)) {
2478 if (dev->d_ioctl(dev->fd(), MTIOCSETEOTMODEL, (caddr_t)&neof) < 0) {
2480 dev->dev_errno = errno; /* save errno */
2481 Mmsg2(dev->errmsg, _("Unable to set eotmodel on device %s: ERR=%s\n"),
2482 dev->print_name(), be.bstrerror(dev->dev_errno));
2483 Jmsg(dcr->jcr, M_FATAL, 0, dev->errmsg);
2491 if (dev->min_block_size == dev->max_block_size &&
2492 dev->min_block_size == 0) { /* variable block mode */
2493 mt_com.mt_op = MTSRSZ;
2494 mt_com.mt_count = 0;
2495 if (dev->d_ioctl(dev->fd(), MTIOCTOP, (char *)&mt_com) < 0) {
2496 dev->clrerror(MTSRSZ);
2503 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2505 Dmsg0(100, "dev_get_os_pos\n");
2506 return dev->has_cap(CAP_MTIOCGET) &&
2507 dev->d_ioctl(dev->fd(), MTIOCGET, (char *)mt_stat) == 0 &&
2508 mt_stat->mt_fileno >= 0;
2511 static const char *modes[] = {
2512 "CREATE_READ_WRITE",
2519 static const char *mode_to_str(int mode)
2521 static char buf[100];
2522 if (mode < 1 || mode > 4) {
2523 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2526 return modes[mode-1];