3 * dev.c -- low level operations on device (storage device)
7 * NOTE!!!! None of these routines are reentrant. You must
8 * use lock_device() and unlock_device() at a higher level,
9 * or use the xxx_device() equivalents. By moving the
10 * thread synchronization to a higher level, we permit
11 * the higher level routines to "seize" the device and
12 * to carry out operations without worrying about who
13 * set what lock (i.e. race conditions).
15 * Note, this is the device dependent code, and may have
16 * to be modified for each system, but is meant to
17 * be as "generic" as possible.
19 * The purpose of this code is to develop a SIMPLE Storage
20 * daemon. More complicated coding (double buffering, writer
21 * thread, ...) is left for a later version.
23 * Unfortunately, I have had to add more and more complication
24 * to this code. This was not foreseen as noted above, and as
25 * a consequence has lead to something more contorted than is
26 * really necessary -- KES. Note, this contortion has been
27 * corrected to a large extent by a rewrite (Apr MMI).
32 Copyright (C) 2000-2006 Kern Sibbald
34 This program is free software; you can redistribute it and/or
35 modify it under the terms of the GNU General Public License
36 version 2 as amended with additional clauses defined in the
37 file LICENSE in the main source directory.
39 This program is distributed in the hope that it will be useful,
40 but WITHOUT ANY WARRANTY; without even the implied warranty of
41 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
42 the file LICENSE for additional details.
47 * Handling I/O errors and end of tape conditions are a bit tricky.
48 * This is how it is currently done when writting.
49 * On either an I/O error or end of tape,
50 * we will stop writing on the physical device (no I/O recovery is
51 * attempted at least in this daemon). The state flag will be sent
52 * to include ST_EOT, which is ephimeral, and ST_WEOT, which is
53 * persistent. Lots of routines clear ST_EOT, but ST_WEOT is
54 * cleared only when the problem goes away. Now when ST_WEOT
55 * is set all calls to write_block_to_device() call the fix_up
56 * routine. In addition, all threads are blocked
57 * from writing on the tape by calling lock_dev(), and thread other
58 * than the first thread to hit the EOT will block on a condition
59 * variable. The first thread to hit the EOT will continue to
60 * be able to read and write the tape (he sort of tunnels through
61 * the locking mechanism -- see lock_dev() for details).
63 * Now presumably somewhere higher in the chain of command
64 * (device.c), someone will notice the EOT condition and
65 * get a new tape up, get the tape label read, and mark
66 * the label for rewriting. Then this higher level routine
67 * will write the unwritten buffer to the new volume.
68 * Finally, he will release
69 * any blocked threads by doing a broadcast on the condition
70 * variable. At that point, we should be totally back in
71 * business with no lost data.
82 /* Forward referenced functions */
83 void set_os_device_parameters(DEVICE *dev);
84 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat);
85 static char *mode_to_str(int mode);
88 * Allocate and initialize the DEVICE structure
89 * Note, if dev is non-NULL, it is already allocated,
90 * thus we neither allocate it nor free it. This allows
91 * the caller to put the packet in shared memory.
93 * Note, for a tape, the device->device_name is the device name
94 * (e.g. /dev/nst0), and for a file, the device name
95 * is the directory in which the file will be placed.
99 init_dev(JCR *jcr, DEVRES *device)
107 /* If no device type specified, try to guess */
108 if (!device->dev_type) {
109 /* Check that device is available */
110 if (stat(device->device_name, &statp) < 0) {
112 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
113 device->device_name, be.strerror());
116 if (S_ISDIR(statp.st_mode)) {
117 device->dev_type = B_FILE_DEV;
118 } else if (S_ISCHR(statp.st_mode)) {
119 device->dev_type = B_TAPE_DEV;
120 } else if (S_ISFIFO(statp.st_mode)) {
121 device->dev_type = B_FILE_DEV;
122 } else if (!(device->cap_bits & CAP_REQMOUNT)) {
123 Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
124 " or have RequiresMount=yes for DVD. st_mode=%x\n"),
125 device->device_name, statp.st_mode);
128 device->dev_type = B_DVD_DEV;
132 dev = (DEVICE *)malloc(sizeof(DEVICE));
133 memset(dev, 0, sizeof(DEVICE));
134 dev->Slot = -1; /* unknown */
136 /* Copy user supplied device parameters from Resource */
137 dev->dev_name = get_memory(strlen(device->device_name)+1);
138 pm_strcpy(dev->dev_name, device->device_name);
139 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
140 /* We edit "Resource-name" (physical-name) */
141 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
142 Dmsg1(400, "Allocate dev=%s\n", dev->print_name());
143 dev->capabilities = device->cap_bits;
144 dev->min_block_size = device->min_block_size;
145 dev->max_block_size = device->max_block_size;
146 dev->max_volume_size = device->max_volume_size;
147 dev->max_file_size = device->max_file_size;
148 dev->volume_capacity = device->volume_capacity;
149 dev->max_rewind_wait = device->max_rewind_wait;
150 dev->max_open_wait = device->max_open_wait;
151 dev->max_open_vols = device->max_open_vols;
152 dev->vol_poll_interval = device->vol_poll_interval;
153 dev->max_spool_size = device->max_spool_size;
154 dev->drive_index = device->drive_index;
155 dev->autoselect = device->autoselect;
156 dev->dev_type = device->dev_type;
157 if (dev->is_tape()) { /* No parts on tapes */
158 dev->max_part_size = 0;
160 dev->max_part_size = device->max_part_size;
163 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
164 dev->vol_poll_interval = 60;
166 /* Link the dev and device structures together */
167 dev->device = device;
170 if (dev->is_fifo()) {
171 dev->capabilities |= CAP_STREAM; /* set stream device */
174 /* If the device requires mount :
175 * - Check that the mount point is available
176 * - Check that (un)mount commands are defined
178 if ((dev->is_file() || dev->is_dvd()) && dev->requires_mount()) {
179 if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
181 dev->dev_errno = errno;
182 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat mount point %s: ERR=%s\n"),
183 device->mount_point, be.strerror());
188 if (!device->mount_command || !device->unmount_command) {
189 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
191 if (!device->write_part_command) {
192 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
196 if (dev->max_block_size > 1000000) {
197 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
198 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
199 dev->max_block_size = 0;
201 if (dev->max_block_size % TAPE_BSIZE != 0) {
202 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
203 dev->max_block_size, dev->print_name());
206 dev->errmsg = get_pool_memory(PM_EMSG);
209 if ((errstat = pthread_mutex_init(&dev->mutex, NULL)) != 0) {
211 dev->dev_errno = errstat;
212 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
213 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
215 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
217 dev->dev_errno = errstat;
218 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
219 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
221 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
223 dev->dev_errno = errstat;
224 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
225 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
227 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
229 dev->dev_errno = errstat;
230 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
231 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
233 if ((errstat = rwl_init(&dev->lock)) != 0) {
235 dev->dev_errno = errstat;
236 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
237 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
241 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
242 Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
248 * Open the device with the operating system and
249 * initialize buffer pointers.
251 * Returns: -1 on error
254 * Note, for a tape, the VolName is the name we give to the
255 * volume (not really used here), but for a file, the
256 * VolName represents the name of the file to be created/opened.
257 * In the case of a file, the full name is the device name
258 * (archive_name) with the VolName concatenated.
261 DEVICE::open(DCR *dcr, int omode)
265 if (openmode == omode) {
274 Dmsg0(100, "Close fd for mode change.\n");
275 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
279 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
282 Dmsg4(29, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type,
283 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
284 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
285 Slot = -1; /* unknown slot */
286 label_type = B_BACULA_LABEL;
287 if (is_tape() || is_fifo()) {
288 open_tape_device(dcr, omode);
289 } else if (is_dvd()) {
290 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
291 open_dvd_device(dcr, omode);
293 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
294 open_file_device(dcr, omode);
296 state |= preserve; /* reset any important state info */
297 Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, fd);
301 void DEVICE::set_mode(int new_mode)
304 case CREATE_READ_WRITE:
305 mode = O_CREAT | O_RDWR | O_BINARY;
307 case OPEN_READ_WRITE:
308 mode = O_RDWR | O_BINARY;
311 mode = O_RDONLY | O_BINARY;
313 case OPEN_WRITE_ONLY:
314 mode = O_WRONLY | O_BINARY;
317 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
323 void DEVICE::open_tape_device(DCR *dcr, int omode)
326 int timeout = max_open_wait;
328 utime_t start_time = time(NULL);
331 Dmsg0(29, "Open dev: device is tape\n");
333 get_autochanger_loaded_slot(dcr);
340 if (is_fifo() && timeout) {
342 tid = start_thread_timer(pthread_self(), timeout);
344 Dmsg2(100, "Try open %s mode=%s\n", print_name(), mode_to_str(omode));
345 #if defined(HAVE_WIN32)
348 if ((fd = tape_open(dev_name, mode)) < 0) {
355 /* If busy retry each second for max_open_wait seconds */
357 /* Try non-blocking open */
358 fd = ::open(dev_name, mode+O_NONBLOCK);
362 Dmsg5(050, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
363 print_name(), omode, mode, errno, be.strerror());
365 /* Tape open, now rewind it */
366 Dmsg0(050, "Rewind after open\n");
367 mt_com.mt_op = MTREW;
369 if (ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
371 dev_errno = errno; /* set error status from rewind */
374 Dmsg2(100, "Rewind error on %s close: ERR=%s\n", print_name(),
375 be.strerror(dev_errno));
376 /* If we get busy, device is probably rewinding, try again */
377 if (dev_errno != EBUSY) {
378 break; /* error -- no medium */
381 /* Got fd and rewind worked, so we must have medium in drive */
383 fd = ::open(dev_name, mode); /* open normally */
387 Dmsg5(050, "Open error on %s omode=%d mode=%x errno=%d: ERR=%s\n",
388 print_name(), omode, mode, errno, be.strerror());
393 set_os_device_parameters(this); /* do system dependent stuff */
394 break; /* Successfully opened and rewound */
398 /* Exceed wait time ? */
399 if (time(NULL) - start_time >= max_open_wait) {
400 break; /* yes, get out */
407 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
408 print_name(), be.strerror(dev_errno));
409 Dmsg1(100, "%s", errmsg);
412 /* Stop any open() timer we started */
414 stop_thread_timer(tid);
417 Dmsg1(29, "open dev: tape %d opened\n", fd);
424 void DEVICE::open_file_device(DCR *dcr, int omode)
426 POOL_MEM archive_name(PM_FNAME);
428 get_autochanger_loaded_slot(dcr);
431 * Handle opening of File Archive (not a tape)
434 pm_strcpy(archive_name, dev_name);
436 * If this is a virtual autochanger (i.e. changer_res != NULL)
437 * we simply use the device name, assuming it has been
438 * appropriately setup by the "autochanger".
440 if (!device->changer_res) {
441 if (VolCatInfo.VolCatName[0] == 0) {
442 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
448 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
449 pm_strcat(archive_name, "/");
451 pm_strcat(archive_name, VolCatInfo.VolCatName);
454 mount(1); /* do mount if required */
458 /* If creating file, give 0640 permissions */
459 Dmsg3(29, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
460 archive_name.c_str(), mode);
461 /* Use system open() */
462 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
465 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
467 Dmsg1(29, "open failed: %s", errmsg);
468 Emsg0(M_FATAL, 0, errmsg);
474 Dmsg4(29, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
475 fd, part, num_dvd_parts, part_size);
479 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
480 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
481 * has the desired Volume name, but there is NO assurance that
482 * any other field of VolCatInfo is correct.
484 void DEVICE::open_dvd_device(DCR *dcr, int omode)
486 POOL_MEM archive_name(PM_FNAME);
487 struct stat filestat;
490 * Handle opening of DVD Volume
492 Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
493 archive_name.c_str(), mode_to_str(omode));
496 * For a DVD we must always pull the state info from dcr->VolCatInfo
497 * This is a bit ugly, but is necessary because we need to open/close/re-open
498 * the dvd file in order to properly mount/unmount and access the
499 * DVD. So we store the state of the DVD as far as is known in the
500 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
501 * copy here, when opening.
503 VolCatInfo = dcr->VolCatInfo; /* structure assignment */
504 Dmsg1(100, "Volume=%s\n", VolCatInfo.VolCatName);
506 if (VolCatInfo.VolCatName[0] == 0) {
507 Dmsg1(10, "Could not open file device %s. No Volume name given.\n",
509 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
516 Dmsg0(100, "Set part=1\n");
517 part = 1; /* count from 1 */
521 if (num_dvd_parts != VolCatInfo.VolCatParts) {
522 num_dvd_parts = VolCatInfo.VolCatParts;
526 * If we are not trying to access the last part, set mode to
527 * OPEN_READ_ONLY as writing would be an error.
529 Dmsg2(29, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
530 if (part <= num_dvd_parts) {
531 omode = OPEN_READ_ONLY;
532 make_mounted_dvd_filename(this, archive_name);
533 set_part_spooled(false);
535 omode = OPEN_READ_WRITE;
536 make_spooled_dvd_filename(this, archive_name);
537 set_part_spooled(true);
541 // Clear any previous blank_dvd status - we will recalculate it here
544 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
545 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
547 if (mount_dvd(this, 1)) {
548 Dmsg0(99, "DVD device mounted.\n");
549 if (num_dvd_parts == 0 && !truncating) {
551 * If we can mount the device, and we are not truncating the DVD,
552 * we usually want to abort. There is one exception, if there is
553 * only one 0-sized file on the DVD, with the right volume name,
554 * we continue (it's the method used by truncate_dvd to truncate a volume).
556 if (!check_can_write_on_non_blank_dvd(dcr)) {
557 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
558 Emsg0(M_FATAL, 0, errmsg);
559 unmount_dvd(this, 1); /* Unmount the device, so the operator can change it. */
566 Dmsg0(99, "DVD device mount failed.\n");
567 /* We cannot mount the device */
568 if (num_dvd_parts == 0) {
569 /* Run free space, check there is a media. */
570 if (!update_free_space_dev(this)) {
571 Emsg0(M_FATAL, 0, errmsg);
576 Dmsg1(29, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
578 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
579 Emsg0(M_FATAL, 0, errmsg);
584 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
585 Emsg0(M_FATAL, 0, errmsg);
591 Dmsg5(29, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
592 archive_name.c_str(), mode_to_str(omode),
593 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
595 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
598 /* If creating file, give 0640 permissions */
599 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
600 archive_name.c_str(), mode);
601 /* Use system open() */
602 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
604 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
606 // Should this be set if we try the create/open below
607 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
608 Dmsg1(29, "open failed: %s", errmsg);
610 /* Previous open failed. See if we can recover */
611 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
612 (part > num_dvd_parts)) {
613 /* If the last part (on spool), doesn't exist when accessing,
614 * create it. In read/write mode a write will be allowed (higher
615 * level software thinks that we are extending a pre-existing
616 * media. Reads for READ_ONLY will report immediately an EOF
617 * Sometimes it is better to finish with an EOF than with an error. */
618 Dmsg1(29, "Creating last part on spool: %s\n", archive_name.c_str());
619 omode = CREATE_READ_WRITE;
620 set_mode(CREATE_READ_WRITE);
621 fd = ::open(archive_name.c_str(), mode, 0640);
625 Dmsg1(100, "after open fd=%d\n", fd);
627 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
630 /* Get size of file */
631 if (fstat(fd, &filestat) < 0) {
634 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
636 Dmsg1(29, "open failed: %s", errmsg);
637 /* Use system close() */
641 part_size = filestat.st_size;
643 update_pos(dcr); /* update position */
651 * Returns: true on success
654 bool DEVICE::rewind(DCR *dcr)
660 Dmsg3(400, "rewind res=%d fd=%d %s\n", reserved_device, fd, print_name());
661 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
662 block_num = file = 0;
666 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
668 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
670 Emsg0(M_ABORT, 0, errmsg);
675 mt_com.mt_op = MTREW;
677 /* If we get an I/O error on rewind, it is probably because
678 * the drive is actually busy. We loop for (about 5 minutes)
679 * retrying every 5 seconds.
681 for (i=max_rewind_wait; ; i -= 5) {
682 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
685 if (i == max_rewind_wait) {
686 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
689 * This is a gross hack, because if the user has the
690 * device mounted (i.e. open), then uses mtx to load
691 * a tape, the current open file descriptor is invalid.
692 * So, we close the drive and re-open it.
695 int open_mode = openmode;
698 open(dcr, open_mode);
706 if (dev_errno == EIO) {
707 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
711 if (dev_errno == EIO && i > 0) {
712 Dmsg0(200, "Sleeping 5 seconds.\n");
717 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
718 print_name(), be.strerror());
723 } else if (is_file() || is_dvd()) {
724 if (lseek(dcr, (off_t)0, SEEK_SET) < 0) {
727 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
728 print_name(), be.strerror());
735 void DEVICE::block(int why)
738 block_device(this, why);
742 void DEVICE::unblock()
745 unblock_device(this);
749 const char *DEVICE::print_blocked() const
751 switch (dev_blocked) {
752 case BST_NOT_BLOCKED:
753 return "BST_NOT_BLOCKED";
755 return "BST_UNMOUNTED";
756 case BST_WAITING_FOR_SYSOP:
757 return "BST_WAITING_FOR_SYSOP";
758 case BST_DOING_ACQUIRE:
759 return "BST_DOING_ACQUIRE";
760 case BST_WRITING_LABEL:
761 return "BST_WRITING_LABEL";
762 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
763 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
767 return _("unknown blocked code");
772 * Called to indicate that we have just read an
773 * EOF from the device.
775 void DEVICE::set_ateof()
787 * Called to indicate we are now at the end of the tape, and
788 * writing is not possible.
790 void DEVICE::set_ateot()
792 /* Make tape effectively read-only */
793 state |= (ST_EOF|ST_EOT|ST_WEOT);
798 * Position device to end of medium (end of data)
799 * Returns: true on succes
802 bool DEVICE::eod(DCR *dcr)
805 struct mtget mt_stat;
811 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
815 #if defined (__digital__) && defined (__unix__)
816 return fsf(VolCatInfo.VolCatFiles);
823 clear_eof(); /* remove EOF flag */
824 block_num = file = 0;
827 if (is_fifo() || is_prog()) {
831 pos = lseek(dcr, (off_t)0, SEEK_END);
832 // Dmsg1(100, "====== Seek to %lld\n", pos);
840 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
841 print_name(), be.strerror());
845 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
846 Dmsg0(100,"Using FAST FSF for EOM\n");
847 /* If unknown position, rewind */
848 if (!dev_get_os_pos(this, &mt_stat)) {
853 mt_com.mt_op = MTFSF;
855 * ***FIXME*** fix code to handle case that INT16_MAX is
858 mt_com.mt_count = INT16_MAX; /* use big positive number */
859 if (mt_com.mt_count < 0) {
860 mt_com.mt_count = INT16_MAX; /* brain damaged system */
864 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
865 if (has_cap(CAP_EOM)) {
866 Dmsg0(100,"Using EOM for EOM\n");
867 mt_com.mt_op = MTEOM;
871 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
873 clrerror(mt_com.mt_op);
874 Dmsg1(50, "ioctl error: %s\n", be.strerror());
876 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
877 print_name(), be.strerror());
881 if (!dev_get_os_pos(this, &mt_stat)) {
884 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
885 print_name(), be.strerror());
888 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
890 file = mt_stat.mt_fileno;
896 * Rewind then use FSF until EOT reached
902 * Move file by file to the end of the tape
905 for (file_num=file; !at_eot(); file_num++) {
906 Dmsg0(200, "eod: doing fsf 1\n");
908 Dmsg0(200, "fsf error.\n");
912 * Avoid infinite loop by ensuring we advance.
914 if (file_num == (int)file) {
915 struct mtget mt_stat;
916 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
918 if (dev_get_os_pos(this, &mt_stat)) {
919 Dmsg2(100, "Adjust file from %d to %d\n", file , mt_stat.mt_fileno);
920 file = mt_stat.mt_fileno;
927 * Some drivers leave us after second EOF when doing
928 * MTEOM, so we must backup so that appending overwrites
931 if (has_cap(CAP_BSFATEOM)) {
932 struct mtget mt_stat;
933 /* Backup over EOF */
935 /* If BSF worked and fileno is known (not -1), set file */
936 if (dev_get_os_pos(this, &mt_stat)) {
937 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , mt_stat.mt_fileno);
938 file = mt_stat.mt_fileno;
940 file++; /* wing it -- not correct on all OSes */
943 update_pos(dcr); /* update position */
945 Dmsg1(200, "EOD dev->file=%d\n", file);
950 * Set the position of the device -- only for files and DVD
951 * For other devices, there is no generic way to do it.
952 * Returns: true on succes
955 bool DEVICE::update_pos(DCR *dcr)
962 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
963 Emsg1(M_FATAL, 0, "%s", errmsg);
967 /* Find out where we are */
968 if (is_file() || is_dvd()) {
971 pos = lseek(dcr, (off_t)0, SEEK_CUR);
975 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
976 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
977 print_name(), be.strerror());
981 block_num = (uint32_t)pos;
982 file = (uint32_t)(pos >> 32);
989 * Return the status of the device. This was meant
990 * to be a generic routine. Unfortunately, it doesn't
991 * seem possible (at least I do not know how to do it
992 * currently), which means that for the moment, this
993 * routine has very little value.
997 uint32_t status_dev(DEVICE *dev)
999 struct mtget mt_stat;
1002 if (dev->state & (ST_EOT | ST_WEOT)) {
1006 if (dev->state & ST_EOF) {
1010 if (dev->is_tape()) {
1012 Pmsg0(-20,_(" Bacula status:"));
1013 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1014 if (tape_ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
1016 dev->dev_errno = errno;
1017 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1018 dev->print_name(), be.strerror());
1021 Pmsg0(-20, _(" Device status:"));
1023 #if defined(HAVE_LINUX_OS)
1024 if (GMT_EOF(mt_stat.mt_gstat)) {
1028 if (GMT_BOT(mt_stat.mt_gstat)) {
1032 if (GMT_EOT(mt_stat.mt_gstat)) {
1036 if (GMT_SM(mt_stat.mt_gstat)) {
1040 if (GMT_EOD(mt_stat.mt_gstat)) {
1044 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1045 stat |= BMT_WR_PROT;
1046 Pmsg0(-20, " WR_PROT");
1048 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1050 Pmsg0(-20, " ONLINE");
1052 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1053 stat |= BMT_DR_OPEN;
1054 Pmsg0(-20, " DR_OPEN");
1056 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1057 stat |= BMT_IM_REP_EN;
1058 Pmsg0(-20, " IM_REP_EN");
1060 #elif defined(HAVE_WIN32)
1061 if (GMT_EOF(mt_stat.mt_gstat)) {
1065 if (GMT_BOT(mt_stat.mt_gstat)) {
1069 if (GMT_EOT(mt_stat.mt_gstat)) {
1073 if (GMT_EOD(mt_stat.mt_gstat)) {
1077 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1078 stat |= BMT_WR_PROT;
1079 Pmsg0(-20, " WR_PROT");
1081 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1083 Pmsg0(-20, " ONLINE");
1085 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1086 stat |= BMT_DR_OPEN;
1087 Pmsg0(-20, " DR_OPEN");
1089 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1090 stat |= BMT_IM_REP_EN;
1091 Pmsg0(-20, " IM_REP_EN");
1094 #endif /* !SunOS && !OSF */
1095 if (dev->has_cap(CAP_MTIOCGET)) {
1096 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1098 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1101 stat |= BMT_ONLINE | BMT_BOT;
1108 * Load medium in device
1109 * Returns: true on success
1112 bool load_dev(DEVICE *dev)
1119 dev->dev_errno = EBADF;
1120 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1121 Emsg0(M_FATAL, 0, dev->errmsg);
1124 if (!(dev->is_tape())) {
1128 Dmsg0(200, "stored: MTLOAD command not available\n");
1130 dev->dev_errno = ENOTTY; /* function not available */
1131 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1132 dev->print_name(), be.strerror());
1136 dev->block_num = dev->file = 0;
1139 mt_com.mt_op = MTLOAD;
1140 mt_com.mt_count = 1;
1141 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1143 dev->dev_errno = errno;
1144 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1145 dev->print_name(), be.strerror());
1153 * Rewind device and put it offline
1154 * Returns: true on success
1157 bool DEVICE::offline()
1162 return true; /* device not open */
1165 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1166 block_num = file = 0;
1170 mt_com.mt_op = MTOFFL;
1171 mt_com.mt_count = 1;
1172 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
1175 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1176 print_name(), be.strerror());
1179 Dmsg1(100, "Offlined device %s\n", print_name());
1183 bool DEVICE::offline_or_rewind()
1188 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1192 * Note, this rewind probably should not be here (it wasn't
1193 * in prior versions of Bacula), but on FreeBSD, this is
1194 * needed in the case the tape was "frozen" due to an error
1195 * such as backspacing after writing and EOF. If it is not
1196 * done, all future references to the drive get and I/O error.
1199 return rewind(NULL);
1204 * Foward space a file
1205 * Returns: true on success
1208 bool DEVICE::fsf(int num)
1210 struct mtget mt_stat;
1216 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1217 Emsg0(M_FATAL, 0, errmsg);
1227 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1231 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1234 Dmsg0(100, "fsf\n");
1237 * If Fast forward space file is set, then we
1238 * use MTFSF to forward space and MTIOCGET
1239 * to get the file position. We assume that
1240 * the SCSI driver will ensure that we do not
1241 * forward space past the end of the medium.
1243 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1244 mt_com.mt_op = MTFSF;
1245 mt_com.mt_count = num;
1246 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1247 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1250 Dmsg0(200, "Set ST_EOT\n");
1252 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1253 print_name(), be.strerror());
1254 Dmsg1(200, "%s", errmsg);
1257 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1259 file = mt_stat.mt_fileno;
1263 * Here if CAP_FSF is set, and virtually all drives
1264 * these days support it, we read a record, then forward
1265 * space one file. Using this procedure, which is slow,
1266 * is the only way we can be sure that we don't read
1267 * two consecutive EOF marks, which means End of Data.
1269 } else if (has_cap(CAP_FSF)) {
1272 Dmsg0(200, "FSF has cap_fsf\n");
1273 if (max_block_size == 0) {
1274 rbuf_len = DEFAULT_BLOCK_SIZE;
1276 rbuf_len = max_block_size;
1278 rbuf = get_memory(rbuf_len);
1279 mt_com.mt_op = MTFSF;
1280 mt_com.mt_count = 1;
1281 while (num-- && !at_eot()) {
1282 Dmsg0(100, "Doing read before fsf\n");
1283 if ((stat = tape_read(fd, (char *)rbuf, rbuf_len)) < 0) {
1284 if (errno == ENOMEM) { /* tape record exceeds buf len */
1285 stat = rbuf_len; /* This is OK */
1287 * On IBM drives, they return ENOSPC at EOM
1288 * instead of EOF status
1290 } else if (at_eof() && errno == ENOSPC) {
1296 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1298 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1299 print_name(), be.strerror());
1300 Dmsg1(100, "%s", errmsg);
1304 if (stat == 0) { /* EOF */
1305 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1306 /* Two reads of zero means end of tape */
1309 Dmsg0(100, "Set ST_EOT\n");
1315 } else { /* Got data */
1320 Dmsg0(100, "Doing MTFSF\n");
1321 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1322 if (stat < 0) { /* error => EOT */
1325 Dmsg0(100, "Set ST_EOT\n");
1327 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1328 print_name(), be.strerror());
1329 Dmsg0(100, "Got < 0 for MTFSF\n");
1330 Dmsg1(100, "%s", errmsg);
1338 * No FSF, so use FSR to simulate it
1341 Dmsg0(200, "Doing FSR for FSF\n");
1342 while (num-- && !at_eot()) {
1343 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1347 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1353 Dmsg1(200, "Return %d from FSF\n", stat);
1355 Dmsg0(200, "ST_EOF set on exit FSF\n");
1358 Dmsg0(200, "ST_EOT set on exit FSF\n");
1360 Dmsg1(200, "Return from FSF file=%d\n", file);
1365 * Backward space a file
1366 * Returns: false on failure
1369 bool DEVICE::bsf(int num)
1376 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1377 Emsg0(M_FATAL, 0, errmsg);
1382 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1393 mt_com.mt_op = MTBSF;
1394 mt_com.mt_count = num;
1395 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1399 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1400 print_name(), be.strerror());
1407 * Foward space num records
1408 * Returns: false on failure
1411 bool DEVICE::fsr(int num)
1418 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1419 Emsg0(M_FATAL, 0, errmsg);
1427 if (!has_cap(CAP_FSR)) {
1428 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1432 Dmsg1(29, "fsr %d\n", num);
1433 mt_com.mt_op = MTFSR;
1434 mt_com.mt_count = num;
1435 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1441 struct mtget mt_stat;
1443 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1444 if (dev_get_os_pos(this, &mt_stat)) {
1445 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1446 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1447 file = mt_stat.mt_fileno;
1448 block_num = mt_stat.mt_blkno;
1456 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1457 num, print_name(), be.strerror());
1463 * Backward space a record
1464 * Returns: false on failure
1467 bool DEVICE::bsr(int num)
1474 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1475 Emsg0(M_FATAL, 0, errmsg);
1483 if (!has_cap(CAP_BSR)) {
1484 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1488 Dmsg0(29, "bsr_dev\n");
1492 mt_com.mt_op = MTBSR;
1493 mt_com.mt_count = num;
1494 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1498 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1499 print_name(), be.strerror());
1504 void DEVICE::lock_door()
1508 mt_com.mt_op = MTLOCK;
1509 mt_com.mt_count = 1;
1510 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1514 void DEVICE::unlock_door()
1518 mt_com.mt_op = MTUNLOCK;
1519 mt_com.mt_count = 1;
1520 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1526 * Reposition the device to file, block
1527 * Returns: false on failure
1530 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1534 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1535 Emsg0(M_FATAL, 0, errmsg);
1540 off_t pos = (((off_t)rfile)<<32) + (off_t)rblock;
1541 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1542 if (lseek(dcr, pos, SEEK_SET) == (off_t)-1) {
1545 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1546 print_name(), be.strerror());
1555 /* After this point, we are tape only */
1556 Dmsg4(100, "reposition from %u:%u to %u:%u\n",
1557 file, block_num, rfile, rblock);
1559 Dmsg0(100, "Rewind\n");
1560 if (!rewind(NULL)) {
1565 Dmsg1(100, "fsf %d\n", rfile-file);
1566 if (!fsf(rfile-file)) {
1567 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1570 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1572 if (rblock < block_num) {
1573 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1574 Dmsg0(100, "bsf 1\n");
1576 Dmsg0(100, "fsf 1\n");
1578 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1580 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1581 /* Ignore errors as Bacula can read to the correct block */
1582 Dmsg1(100, "fsr %d\n", rblock-block_num);
1583 return fsr(rblock-block_num);
1591 * Write an end of file on the device
1592 * Returns: true on success
1595 bool DEVICE::weof(int num)
1599 Dmsg0(129, "weof_dev\n");
1603 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1604 Emsg0(M_FATAL, 0, errmsg);
1612 if (!can_append()) {
1613 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1614 Emsg0(M_FATAL, 0, errmsg);
1620 mt_com.mt_op = MTWEOF;
1621 mt_com.mt_count = num;
1622 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1631 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1632 print_name(), be.strerror());
1640 * If implemented in system, clear the tape
1643 void DEVICE::clrerror(int func)
1645 const char *msg = NULL;
1646 struct mtget mt_stat;
1649 dev_errno = errno; /* save errno */
1651 VolCatInfo.VolCatErrors++;
1658 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1661 break; /* ignore message printed later */
1664 capabilities &= ~CAP_EOF; /* turn off feature */
1669 capabilities &= ~CAP_EOM; /* turn off feature */
1674 capabilities &= ~CAP_FSF; /* turn off feature */
1678 capabilities &= ~CAP_BSF; /* turn off feature */
1682 capabilities &= ~CAP_FSR; /* turn off feature */
1686 capabilities &= ~CAP_BSR; /* turn off feature */
1696 #ifdef MTSETDRVBUFFER
1697 case MTSETDRVBUFFER:
1698 msg = "MTSETDRVBUFFER";
1731 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1737 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1738 Emsg0(M_ERROR, 0, errmsg);
1743 * Now we try different methods of clearing the error
1744 * status on the drive so that it is not locked for
1745 * further operations.
1748 /* On some systems such as NetBSD, this clears all errors */
1749 tape_ioctl(fd, MTIOCGET, (char *)&mt_stat);
1751 /* Found on Linux */
1755 mt_com.mt_op = MTIOCLRERR;
1756 mt_com.mt_count = 1;
1757 /* Clear any error condition on the tape */
1758 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1759 Dmsg0(200, "Did MTIOCLRERR\n");
1763 /* Typically on FreeBSD */
1767 /* Read and clear SCSI error status */
1768 union mterrstat mt_errstat;
1769 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1770 be.strerror(dev_errno));
1771 tape_ioctl(fd, MTIOCERRSTAT, (char *)&mt_errstat);
1775 /* Clear Subsystem Exception OSF1 */
1779 mt_com.mt_op = MTCSE;
1780 mt_com.mt_count = 1;
1781 /* Clear any error condition on the tape */
1782 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1783 Dmsg0(200, "Did MTCSE\n");
1791 void DEVICE::close()
1793 Dmsg1(100, "close_dev %s\n", print_name());
1794 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1799 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1801 return; /* already closed */
1813 /* Clean up device packet so it can be reused */
1815 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1816 label_type = B_BACULA_LABEL;
1817 file = block_num = 0;
1820 EndFile = EndBlock = 0;
1822 Slot = -1; /* unknown slot */
1824 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1825 memset(&VolHdr, 0, sizeof(VolHdr));
1827 stop_thread_timer(tid);
1833 * This call closes the device, but it is used in DVD handling
1834 * where we close one part and then open the next part. The
1835 * difference between close_part() and close() is that close_part()
1836 * saves the state information of the device (e.g. the Volume lable,
1837 * the Volume Catalog record, ... This permits opening and closing
1838 * the Volume parts multiple times without losing track of what the
1839 * main Volume parameters are.
1841 void DEVICE::close_part(DCR *dcr)
1843 VOLUME_LABEL saveVolHdr;
1844 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1847 saveVolHdr = VolHdr; /* structure assignment */
1848 saveVolCatInfo = VolCatInfo; /* structure assignment */
1849 close(); /* close current part */
1850 VolHdr = saveVolHdr; /* structure assignment */
1851 VolCatInfo = saveVolCatInfo; /* structure assignment */
1852 dcr->VolCatInfo = saveVolCatInfo; /* structure assignment */
1855 off_t DEVICE::lseek(DCR *dcr, off_t offset, int whence)
1859 return lseek_dvd(dcr, offset, whence);
1861 return ::lseek(fd, offset, whence);
1867 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1869 Dmsg1(100, "truncate %s\n", print_name());
1872 /* maybe we should rewind and write and eof ???? */
1873 return true; /* we don't really truncate tapes */
1875 return truncate_dvd(dcr);
1877 /* ***FIXME*** we really need to unlink() the file so that
1878 * its name can be changed for a relabel.
1880 if (ftruncate(fd, 0) != 0) {
1882 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1883 print_name(), be.strerror());
1891 /* Mount the device.
1892 * If timeout, wait until the mount command returns 0.
1893 * If !timeout, try to mount the device only once.
1895 bool DEVICE::mount(int timeout)
1897 Dmsg0(190, "Enter mount\n");
1900 } else if (requires_mount()) {
1901 return do_mount(1, timeout);
1906 /* Unmount the device
1907 * If timeout, wait until the unmount command returns 0.
1908 * If !timeout, try to unmount the device only once.
1910 bool DEVICE::unmount(int timeout)
1912 Dmsg0(90, "Enter unmount_dvd\n");
1914 return do_mount(0, timeout);
1919 /* (Un)mount the device */
1920 bool DEVICE::do_mount(int mount, int dotimeout)
1922 POOL_MEM ocmd(PM_FNAME);
1925 int status, timeout;
1927 sm_check(__FILE__, __LINE__, false);
1930 Dmsg0(200, "======= mount=1\n");
1933 icmd = device->mount_command;
1935 if (!is_mounted()) {
1936 Dmsg0(200, "======= mount=0\n");
1939 icmd = device->unmount_command;
1942 edit_mount_codes(ocmd, icmd);
1944 Dmsg2(100, "do_mount_dvd: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1947 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1952 results = get_memory(2000);
1955 /* If busy retry each second */
1956 Dmsg1(20, "do_mount run_prog=%s\n", ocmd.c_str());
1957 while ((status = run_program_full_output(ocmd.c_str(),
1958 max_open_wait/2, results)) != 0) {
1959 /* Doesn't work with internationalization (This is not a problem) */
1960 if (fnmatch("*is already mounted on", results, 0) == 0) {
1963 if (timeout-- > 0) {
1964 /* Sometimes the device cannot be mounted because it is already mounted.
1965 * Try to unmount it, then remount it */
1967 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
1973 Dmsg2(40, "Device %s cannot be mounted. ERR=%s\n", print_name(), results);
1974 Mmsg(errmsg, _("Device %s cannot be mounted. ERR=%s\n"),
1975 print_name(), results);
1977 * Now, just to be sure it is not mounted, try to read the
1981 struct dirent *entry, *result;
1985 name_max = pathconf(".", _PC_NAME_MAX);
1986 if (name_max < 1024) {
1990 if (!(dp = opendir(device->mount_point))) {
1993 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
1994 device->mount_point, print_name(), be.strerror());
1998 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2001 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2003 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
2004 device->mount_point, print_name());
2007 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2008 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2011 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2017 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2020 mount = 1; /* If we got more than ., .. and .keep */
2021 break; /* there must be something mounted */
2025 sm_check(__FILE__, __LINE__, false);
2026 free_pool_memory(results);
2027 Dmsg0(200, "============ mount=0\n");
2031 set_mounted(mount); /* set/clear mounted flag */
2032 free_pool_memory(results);
2033 Dmsg1(200, "============ mount=%d\n", mount);
2038 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2040 * %a = archive device name
2041 * %e = erase (set if cannot mount and first part)
2044 * %v = last part name
2046 * omsg = edited output message
2047 * imsg = input string containing edit codes (%x)
2050 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2056 POOL_MEM archive_name(PM_FNAME);
2058 omsg.c_str()[0] = 0;
2059 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2060 for (p=imsg; *p; p++) {
2070 if (num_dvd_parts == 0) {
2071 if (truncating || blank_dvd) {
2081 bsnprintf(add, sizeof(add), "%d", part);
2085 str = device->mount_point;
2088 make_spooled_dvd_filename(this, archive_name);
2089 str = archive_name.c_str();
2103 Dmsg1(1900, "add_str %s\n", str);
2104 pm_strcat(omsg, (char *)str);
2105 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2110 /* Return the resource name for the device */
2111 const char *DEVICE::name() const
2113 return device->hdr.name;
2117 dev_vol_name(DEVICE *dev)
2119 return dev->VolCatInfo.VolCatName;
2124 * Free memory allocated for the device
2126 void DEVICE::term(void)
2128 Dmsg1(900, "term dev: %s\n", print_name());
2131 free_memory(dev_name);
2135 free_memory(prt_name);
2139 free_pool_memory(errmsg);
2142 pthread_mutex_destroy(&mutex);
2143 pthread_cond_destroy(&wait);
2144 pthread_cond_destroy(&wait_next_vol);
2145 pthread_mutex_destroy(&spool_mutex);
2147 if (attached_dcrs) {
2148 delete attached_dcrs;
2149 attached_dcrs = NULL;
2158 * This routine initializes the device wait timers
2160 void init_device_wait_timers(DCR *dcr)
2162 DEVICE *dev = dcr->dev;
2163 JCR *jcr = dcr->jcr;
2165 /* ******FIXME******* put these on config variables */
2166 dev->min_wait = 60 * 60;
2167 dev->max_wait = 24 * 60 * 60;
2168 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2169 dev->wait_sec = dev->min_wait;
2170 dev->rem_wait_sec = dev->wait_sec;
2173 dev->BadVolName[0] = 0;
2175 jcr->min_wait = 60 * 60;
2176 jcr->max_wait = 24 * 60 * 60;
2177 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2178 jcr->wait_sec = jcr->min_wait;
2179 jcr->rem_wait_sec = jcr->wait_sec;
2184 void init_jcr_device_wait_timers(JCR *jcr)
2186 /* ******FIXME******* put these on config variables */
2187 jcr->min_wait = 60 * 60;
2188 jcr->max_wait = 24 * 60 * 60;
2189 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2190 jcr->wait_sec = jcr->min_wait;
2191 jcr->rem_wait_sec = jcr->wait_sec;
2197 * The dev timers are used for waiting on a particular device
2199 * Returns: true if time doubled
2200 * false if max time expired
2202 bool double_dev_wait_time(DEVICE *dev)
2204 dev->wait_sec *= 2; /* double wait time */
2205 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2206 dev->wait_sec = dev->max_wait;
2209 dev->rem_wait_sec = dev->wait_sec;
2210 if (dev->num_wait >= dev->max_num_wait) {
2217 void set_os_device_parameters(DEVICE *dev)
2219 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2222 Dmsg0(050, "In set_os_device_parameters\n");
2223 #if defined(MTSETBLK)
2224 if (dev->min_block_size == dev->max_block_size &&
2225 dev->min_block_size == 0) { /* variable block mode */
2226 mt_com.mt_op = MTSETBLK;
2227 mt_com.mt_count = 0;
2228 Dmsg0(050, "Set block size to zero\n");
2229 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2230 dev->clrerror(MTSETBLK);
2234 #if defined(MTSETDRVBUFFER)
2235 if (getpid() == 0) { /* Only root can do this */
2236 mt_com.mt_op = MTSETDRVBUFFER;
2237 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2238 if (!dev->has_cap(CAP_TWOEOF)) {
2239 mt_com.mt_count |= MT_ST_TWO_FM;
2241 if (dev->has_cap(CAP_EOM)) {
2242 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2244 Dmsg0(050, "MTSETDRVBUFFER\n");
2245 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2246 dev->clrerror(MTSETDRVBUFFER);
2253 #ifdef HAVE_NETBSD_OS
2255 if (dev->min_block_size == dev->max_block_size &&
2256 dev->min_block_size == 0) { /* variable block mode */
2257 mt_com.mt_op = MTSETBSIZ;
2258 mt_com.mt_count = 0;
2259 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2260 dev->clrerror(MTSETBSIZ);
2262 /* Get notified at logical end of tape */
2263 mt_com.mt_op = MTEWARN;
2264 mt_com.mt_count = 1;
2265 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2266 dev->clrerror(MTEWARN);
2272 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2274 if (dev->min_block_size == dev->max_block_size &&
2275 dev->min_block_size == 0) { /* variable block mode */
2276 mt_com.mt_op = MTSETBSIZ;
2277 mt_com.mt_count = 0;
2278 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2279 dev->clrerror(MTSETBSIZ);
2287 if (dev->min_block_size == dev->max_block_size &&
2288 dev->min_block_size == 0) { /* variable block mode */
2289 mt_com.mt_op = MTSRSZ;
2290 mt_com.mt_count = 0;
2291 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2292 dev->clrerror(MTSRSZ);
2299 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2301 Dmsg0(050, "dev_get_os_pos\n");
2302 return dev->has_cap(CAP_MTIOCGET) &&
2303 tape_ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2304 mt_stat->mt_fileno >= 0;
2307 static char *modes[] = {
2308 "CREATE_READ_WRITE",
2315 static char *mode_to_str(int mode)
2317 static char buf[100];
2318 if (mode < 1 || mode > 4) {
2319 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2322 return modes[mode-1];