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 ephemeral, 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 Dmsg2(29, "Enter: open_dvd_dev: DVD vol=%s mode=%s\n",
493 &dcr->VolCatInfo, 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 /* Now find the name of the part that we want to access */
531 if (part <= num_dvd_parts) {
532 omode = OPEN_READ_ONLY;
533 make_mounted_dvd_filename(this, archive_name);
534 set_part_spooled(false);
536 omode = OPEN_READ_WRITE;
537 make_spooled_dvd_filename(this, archive_name);
538 set_part_spooled(true);
542 // Clear any previous blank_dvd status - we will recalculate it here
545 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
546 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
549 Dmsg0(99, "DVD device mounted.\n");
550 if (num_dvd_parts == 0 && !truncating) {
552 * If we can mount the device, and we are not truncating the DVD,
553 * we usually want to abort. There is one exception, if there is
554 * only one 0-sized file on the DVD, with the right volume name,
555 * we continue (it's the method used by truncate_dvd to truncate a volume).
557 if (!check_can_write_on_non_blank_dvd(dcr)) {
558 Mmsg(errmsg, _("The DVD in device %s contains data, please blank it before writing.\n"), print_name());
559 Emsg0(M_FATAL, 0, errmsg);
560 unmount(1); /* Unmount the device, so the operator can change it. */
567 * Ensure that we have the correct DVD loaded by looking for part1.
568 * We only succeed the open if it exists. Failure to do this could
569 * leave us trying to add a part to a different DVD!
571 uint32_t oldpart = part;
573 POOL_MEM part1_name(PM_FNAME);
575 make_mounted_dvd_filename(this, part1_name);
577 if (stat(part1_name.c_str(), &statp) < 0) {
579 Mmsg(errmsg, _("Unable to stat DVD part 1 file %s: ERR=%s\n"),
580 part1_name.c_str(), be.strerror());
581 Emsg0(M_FATAL, 0, errmsg);
585 if (!S_ISREG(statp.st_mode)) {
586 /* It is not a regular file */
587 Mmsg(errmsg, _("DVD part 1 is not a regular file %s.\n"),
589 Emsg0(M_FATAL, 0, errmsg);
595 Dmsg0(99, "DVD device mount failed.\n");
596 /* We cannot mount the device */
597 if (num_dvd_parts == 0) {
598 /* Run free space, check there is a media. */
599 if (!update_freespace()) {
600 Emsg0(M_FATAL, 0, errmsg);
605 Dmsg1(29, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
607 Mmsg(errmsg, _("There is no valid DVD in device %s.\n"), print_name());
608 Emsg0(M_FATAL, 0, errmsg);
613 Mmsg(errmsg, _("Could not mount DVD device %s.\n"), print_name());
614 Emsg0(M_FATAL, 0, errmsg);
620 Dmsg5(29, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
621 archive_name.c_str(), mode_to_str(omode),
622 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
624 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
627 /* If creating file, give 0640 permissions */
628 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
629 archive_name.c_str(), mode);
630 /* Use system open() */
631 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
633 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
635 // Should this be set if we try the create/open below
636 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
637 Dmsg1(29, "open failed: %s", errmsg);
639 /* Previous open failed. See if we can recover */
640 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
641 (part > num_dvd_parts)) {
642 /* If the last part (on spool), doesn't exist when accessing,
643 * create it. In read/write mode a write will be allowed (higher
644 * level software thinks that we are extending a pre-existing
645 * media. Reads for READ_ONLY will report immediately an EOF
646 * Sometimes it is better to finish with an EOF than with an error. */
647 Dmsg1(29, "Creating last part on spool: %s\n", archive_name.c_str());
648 omode = CREATE_READ_WRITE;
649 set_mode(CREATE_READ_WRITE);
650 fd = ::open(archive_name.c_str(), mode, 0640);
654 Dmsg1(100, "after open fd=%d\n", fd);
656 if (omode == OPEN_READ_WRITE || omode == CREATE_READ_WRITE) {
659 /* Get size of file */
660 if (fstat(fd, &filestat) < 0) {
663 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
665 Dmsg1(29, "open failed: %s", errmsg);
666 /* Use system close() */
670 part_size = filestat.st_size;
672 update_pos(dcr); /* update position */
680 * Returns: true on success
683 bool DEVICE::rewind(DCR *dcr)
689 Dmsg3(400, "rewind res=%d fd=%d %s\n", reserved_device, fd, print_name());
690 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
691 block_num = file = 0;
695 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
697 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
699 Emsg0(M_ABORT, 0, errmsg);
704 mt_com.mt_op = MTREW;
706 /* If we get an I/O error on rewind, it is probably because
707 * the drive is actually busy. We loop for (about 5 minutes)
708 * retrying every 5 seconds.
710 for (i=max_rewind_wait; ; i -= 5) {
711 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
714 if (i == max_rewind_wait) {
715 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
718 * This is a gross hack, because if the user has the
719 * device mounted (i.e. open), then uses mtx to load
720 * a tape, the current open file descriptor is invalid.
721 * So, we close the drive and re-open it.
724 int open_mode = openmode;
727 open(dcr, open_mode);
735 if (dev_errno == EIO) {
736 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
740 if (dev_errno == EIO && i > 0) {
741 Dmsg0(200, "Sleeping 5 seconds.\n");
746 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
747 print_name(), be.strerror());
752 } else if (is_file() || is_dvd()) {
753 if (lseek(dcr, (off_t)0, SEEK_SET) < 0) {
756 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
757 print_name(), be.strerror());
764 void DEVICE::block(int why)
767 block_device(this, why);
771 void DEVICE::unblock()
774 unblock_device(this);
778 const char *DEVICE::print_blocked() const
780 switch (dev_blocked) {
781 case BST_NOT_BLOCKED:
782 return "BST_NOT_BLOCKED";
784 return "BST_UNMOUNTED";
785 case BST_WAITING_FOR_SYSOP:
786 return "BST_WAITING_FOR_SYSOP";
787 case BST_DOING_ACQUIRE:
788 return "BST_DOING_ACQUIRE";
789 case BST_WRITING_LABEL:
790 return "BST_WRITING_LABEL";
791 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
792 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
796 return _("unknown blocked code");
801 * Called to indicate that we have just read an
802 * EOF from the device.
804 void DEVICE::set_ateof()
816 * Called to indicate we are now at the end of the tape, and
817 * writing is not possible.
819 void DEVICE::set_ateot()
821 /* Make tape effectively read-only */
822 state |= (ST_EOF|ST_EOT|ST_WEOT);
827 * Position device to end of medium (end of data)
828 * Returns: true on succes
831 bool DEVICE::eod(DCR *dcr)
834 struct mtget mt_stat;
840 Mmsg1(errmsg, _("Bad call to eod. Device %s not open\n"), print_name());
844 #if defined (__digital__) && defined (__unix__)
845 return fsf(VolCatInfo.VolCatFiles);
852 clear_eof(); /* remove EOF flag */
853 block_num = file = 0;
856 if (is_fifo() || is_prog()) {
860 pos = lseek(dcr, (off_t)0, SEEK_END);
861 // Dmsg1(100, "====== Seek to %lld\n", pos);
869 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
870 print_name(), be.strerror());
874 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
875 Dmsg0(100,"Using FAST FSF for EOM\n");
876 /* If unknown position, rewind */
877 if (!dev_get_os_pos(this, &mt_stat)) {
882 mt_com.mt_op = MTFSF;
884 * ***FIXME*** fix code to handle case that INT16_MAX is
887 mt_com.mt_count = INT16_MAX; /* use big positive number */
888 if (mt_com.mt_count < 0) {
889 mt_com.mt_count = INT16_MAX; /* brain damaged system */
893 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
894 if (has_cap(CAP_EOM)) {
895 Dmsg0(100,"Using EOM for EOM\n");
896 mt_com.mt_op = MTEOM;
900 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
902 clrerror(mt_com.mt_op);
903 Dmsg1(50, "ioctl error: %s\n", be.strerror());
905 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
906 print_name(), be.strerror());
910 if (!dev_get_os_pos(this, &mt_stat)) {
913 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
914 print_name(), be.strerror());
917 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
919 file = mt_stat.mt_fileno;
925 * Rewind then use FSF until EOT reached
931 * Move file by file to the end of the tape
934 for (file_num=file; !at_eot(); file_num++) {
935 Dmsg0(200, "eod: doing fsf 1\n");
937 Dmsg0(200, "fsf error.\n");
941 * Avoid infinite loop by ensuring we advance.
943 if (file_num == (int)file) {
944 struct mtget mt_stat;
945 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
947 if (dev_get_os_pos(this, &mt_stat)) {
948 Dmsg2(100, "Adjust file from %d to %d\n", file , mt_stat.mt_fileno);
949 file = mt_stat.mt_fileno;
956 * Some drivers leave us after second EOF when doing
957 * MTEOM, so we must backup so that appending overwrites
960 if (has_cap(CAP_BSFATEOM)) {
961 struct mtget mt_stat;
962 /* Backup over EOF */
964 /* If BSF worked and fileno is known (not -1), set file */
965 if (dev_get_os_pos(this, &mt_stat)) {
966 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , mt_stat.mt_fileno);
967 file = mt_stat.mt_fileno;
969 file++; /* wing it -- not correct on all OSes */
972 update_pos(dcr); /* update position */
974 Dmsg1(200, "EOD dev->file=%d\n", file);
979 * Set the position of the device -- only for files and DVD
980 * For other devices, there is no generic way to do it.
981 * Returns: true on succes
984 bool DEVICE::update_pos(DCR *dcr)
991 Mmsg0(errmsg, _("Bad device call. Device not open\n"));
992 Emsg1(M_FATAL, 0, "%s", errmsg);
996 /* Find out where we are */
997 if (is_file() || is_dvd()) {
1000 pos = lseek(dcr, (off_t)0, SEEK_CUR);
1004 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
1005 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1006 print_name(), be.strerror());
1010 block_num = (uint32_t)pos;
1011 file = (uint32_t)(pos >> 32);
1018 * Return the status of the device. This was meant
1019 * to be a generic routine. Unfortunately, it doesn't
1020 * seem possible (at least I do not know how to do it
1021 * currently), which means that for the moment, this
1022 * routine has very little value.
1026 uint32_t status_dev(DEVICE *dev)
1028 struct mtget mt_stat;
1031 if (dev->state & (ST_EOT | ST_WEOT)) {
1035 if (dev->state & ST_EOF) {
1039 if (dev->is_tape()) {
1041 Pmsg0(-20,_(" Bacula status:"));
1042 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1043 if (tape_ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
1045 dev->dev_errno = errno;
1046 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1047 dev->print_name(), be.strerror());
1050 Pmsg0(-20, _(" Device status:"));
1052 #if defined(HAVE_LINUX_OS)
1053 if (GMT_EOF(mt_stat.mt_gstat)) {
1057 if (GMT_BOT(mt_stat.mt_gstat)) {
1061 if (GMT_EOT(mt_stat.mt_gstat)) {
1065 if (GMT_SM(mt_stat.mt_gstat)) {
1069 if (GMT_EOD(mt_stat.mt_gstat)) {
1073 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1074 stat |= BMT_WR_PROT;
1075 Pmsg0(-20, " WR_PROT");
1077 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1079 Pmsg0(-20, " ONLINE");
1081 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1082 stat |= BMT_DR_OPEN;
1083 Pmsg0(-20, " DR_OPEN");
1085 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1086 stat |= BMT_IM_REP_EN;
1087 Pmsg0(-20, " IM_REP_EN");
1089 #elif defined(HAVE_WIN32)
1090 if (GMT_EOF(mt_stat.mt_gstat)) {
1094 if (GMT_BOT(mt_stat.mt_gstat)) {
1098 if (GMT_EOT(mt_stat.mt_gstat)) {
1102 if (GMT_EOD(mt_stat.mt_gstat)) {
1106 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1107 stat |= BMT_WR_PROT;
1108 Pmsg0(-20, " WR_PROT");
1110 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1112 Pmsg0(-20, " ONLINE");
1114 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1115 stat |= BMT_DR_OPEN;
1116 Pmsg0(-20, " DR_OPEN");
1118 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1119 stat |= BMT_IM_REP_EN;
1120 Pmsg0(-20, " IM_REP_EN");
1123 #endif /* !SunOS && !OSF */
1124 if (dev->has_cap(CAP_MTIOCGET)) {
1125 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1127 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1130 stat |= BMT_ONLINE | BMT_BOT;
1137 * Load medium in device
1138 * Returns: true on success
1141 bool load_dev(DEVICE *dev)
1148 dev->dev_errno = EBADF;
1149 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1150 Emsg0(M_FATAL, 0, dev->errmsg);
1153 if (!(dev->is_tape())) {
1157 Dmsg0(200, "stored: MTLOAD command not available\n");
1159 dev->dev_errno = ENOTTY; /* function not available */
1160 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1161 dev->print_name(), be.strerror());
1165 dev->block_num = dev->file = 0;
1168 mt_com.mt_op = MTLOAD;
1169 mt_com.mt_count = 1;
1170 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1172 dev->dev_errno = errno;
1173 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1174 dev->print_name(), be.strerror());
1182 * Rewind device and put it offline
1183 * Returns: true on success
1186 bool DEVICE::offline()
1191 return true; /* device not open */
1194 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1195 block_num = file = 0;
1199 mt_com.mt_op = MTOFFL;
1200 mt_com.mt_count = 1;
1201 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
1204 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1205 print_name(), be.strerror());
1208 Dmsg1(100, "Offlined device %s\n", print_name());
1212 bool DEVICE::offline_or_rewind()
1217 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1221 * Note, this rewind probably should not be here (it wasn't
1222 * in prior versions of Bacula), but on FreeBSD, this is
1223 * needed in the case the tape was "frozen" due to an error
1224 * such as backspacing after writing and EOF. If it is not
1225 * done, all future references to the drive get and I/O error.
1228 return rewind(NULL);
1233 * Foward space a file
1234 * Returns: true on success
1237 bool DEVICE::fsf(int num)
1239 struct mtget mt_stat;
1245 Mmsg0(errmsg, _("Bad call to fsf. Device not open\n"));
1246 Emsg0(M_FATAL, 0, errmsg);
1256 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1260 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1263 Dmsg0(100, "fsf\n");
1266 * If Fast forward space file is set, then we
1267 * use MTFSF to forward space and MTIOCGET
1268 * to get the file position. We assume that
1269 * the SCSI driver will ensure that we do not
1270 * forward space past the end of the medium.
1272 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1273 mt_com.mt_op = MTFSF;
1274 mt_com.mt_count = num;
1275 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1276 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1279 Dmsg0(200, "Set ST_EOT\n");
1281 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1282 print_name(), be.strerror());
1283 Dmsg1(200, "%s", errmsg);
1286 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1288 file = mt_stat.mt_fileno;
1292 * Here if CAP_FSF is set, and virtually all drives
1293 * these days support it, we read a record, then forward
1294 * space one file. Using this procedure, which is slow,
1295 * is the only way we can be sure that we don't read
1296 * two consecutive EOF marks, which means End of Data.
1298 } else if (has_cap(CAP_FSF)) {
1301 Dmsg0(200, "FSF has cap_fsf\n");
1302 if (max_block_size == 0) {
1303 rbuf_len = DEFAULT_BLOCK_SIZE;
1305 rbuf_len = max_block_size;
1307 rbuf = get_memory(rbuf_len);
1308 mt_com.mt_op = MTFSF;
1309 mt_com.mt_count = 1;
1310 while (num-- && !at_eot()) {
1311 Dmsg0(100, "Doing read before fsf\n");
1312 if ((stat = tape_read(fd, (char *)rbuf, rbuf_len)) < 0) {
1313 if (errno == ENOMEM) { /* tape record exceeds buf len */
1314 stat = rbuf_len; /* This is OK */
1316 * On IBM drives, they return ENOSPC at EOM
1317 * instead of EOF status
1319 } else if (at_eof() && errno == ENOSPC) {
1325 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1327 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1328 print_name(), be.strerror());
1329 Dmsg1(100, "%s", errmsg);
1333 if (stat == 0) { /* EOF */
1334 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1335 /* Two reads of zero means end of tape */
1338 Dmsg0(100, "Set ST_EOT\n");
1344 } else { /* Got data */
1349 Dmsg0(100, "Doing MTFSF\n");
1350 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1351 if (stat < 0) { /* error => EOT */
1354 Dmsg0(100, "Set ST_EOT\n");
1356 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1357 print_name(), be.strerror());
1358 Dmsg0(100, "Got < 0 for MTFSF\n");
1359 Dmsg1(100, "%s", errmsg);
1367 * No FSF, so use FSR to simulate it
1370 Dmsg0(200, "Doing FSR for FSF\n");
1371 while (num-- && !at_eot()) {
1372 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1376 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1382 Dmsg1(200, "Return %d from FSF\n", stat);
1384 Dmsg0(200, "ST_EOF set on exit FSF\n");
1387 Dmsg0(200, "ST_EOT set on exit FSF\n");
1389 Dmsg1(200, "Return from FSF file=%d\n", file);
1394 * Backward space a file
1395 * Returns: false on failure
1398 bool DEVICE::bsf(int num)
1405 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1406 Emsg0(M_FATAL, 0, errmsg);
1411 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1422 mt_com.mt_op = MTBSF;
1423 mt_com.mt_count = num;
1424 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1428 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1429 print_name(), be.strerror());
1436 * Foward space num records
1437 * Returns: false on failure
1440 bool DEVICE::fsr(int num)
1447 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1448 Emsg0(M_FATAL, 0, errmsg);
1456 if (!has_cap(CAP_FSR)) {
1457 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1461 Dmsg1(29, "fsr %d\n", num);
1462 mt_com.mt_op = MTFSR;
1463 mt_com.mt_count = num;
1464 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1470 struct mtget mt_stat;
1472 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1473 if (dev_get_os_pos(this, &mt_stat)) {
1474 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1475 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1476 file = mt_stat.mt_fileno;
1477 block_num = mt_stat.mt_blkno;
1485 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1486 num, print_name(), be.strerror());
1492 * Backward space a record
1493 * Returns: false on failure
1496 bool DEVICE::bsr(int num)
1503 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1504 Emsg0(M_FATAL, 0, errmsg);
1512 if (!has_cap(CAP_BSR)) {
1513 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1517 Dmsg0(29, "bsr_dev\n");
1521 mt_com.mt_op = MTBSR;
1522 mt_com.mt_count = num;
1523 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1527 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1528 print_name(), be.strerror());
1533 void DEVICE::lock_door()
1537 mt_com.mt_op = MTLOCK;
1538 mt_com.mt_count = 1;
1539 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1543 void DEVICE::unlock_door()
1547 mt_com.mt_op = MTUNLOCK;
1548 mt_com.mt_count = 1;
1549 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1555 * Reposition the device to file, block
1556 * Returns: false on failure
1559 bool DEVICE::reposition(DCR *dcr, uint32_t rfile, uint32_t rblock)
1563 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1564 Emsg0(M_FATAL, 0, errmsg);
1569 off_t pos = (((off_t)rfile)<<32) + (off_t)rblock;
1570 Dmsg1(100, "===== lseek to %d\n", (int)pos);
1571 if (lseek(dcr, pos, SEEK_SET) == (off_t)-1) {
1574 Mmsg2(errmsg, _("lseek error on %s. ERR=%s.\n"),
1575 print_name(), be.strerror());
1584 /* After this point, we are tape only */
1585 Dmsg4(100, "reposition from %u:%u to %u:%u\n",
1586 file, block_num, rfile, rblock);
1588 Dmsg0(100, "Rewind\n");
1589 if (!rewind(NULL)) {
1594 Dmsg1(100, "fsf %d\n", rfile-file);
1595 if (!fsf(rfile-file)) {
1596 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1599 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1601 if (rblock < block_num) {
1602 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1603 Dmsg0(100, "bsf 1\n");
1605 Dmsg0(100, "fsf 1\n");
1607 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1609 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1610 /* Ignore errors as Bacula can read to the correct block */
1611 Dmsg1(100, "fsr %d\n", rblock-block_num);
1612 return fsr(rblock-block_num);
1620 * Write an end of file on the device
1621 * Returns: true on success
1624 bool DEVICE::weof(int num)
1628 Dmsg0(129, "weof_dev\n");
1632 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1633 Emsg0(M_FATAL, 0, errmsg);
1641 if (!can_append()) {
1642 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1643 Emsg0(M_FATAL, 0, errmsg);
1649 mt_com.mt_op = MTWEOF;
1650 mt_com.mt_count = num;
1651 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1660 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1661 print_name(), be.strerror());
1669 * If implemented in system, clear the tape
1672 void DEVICE::clrerror(int func)
1674 const char *msg = NULL;
1675 struct mtget mt_stat;
1678 dev_errno = errno; /* save errno */
1680 VolCatInfo.VolCatErrors++;
1687 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1690 break; /* ignore message printed later */
1693 capabilities &= ~CAP_EOF; /* turn off feature */
1698 capabilities &= ~CAP_EOM; /* turn off feature */
1703 capabilities &= ~CAP_FSF; /* turn off feature */
1707 capabilities &= ~CAP_BSF; /* turn off feature */
1711 capabilities &= ~CAP_FSR; /* turn off feature */
1715 capabilities &= ~CAP_BSR; /* turn off feature */
1725 #ifdef MTSETDRVBUFFER
1726 case MTSETDRVBUFFER:
1727 msg = "MTSETDRVBUFFER";
1760 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1766 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1767 Emsg0(M_ERROR, 0, errmsg);
1772 * Now we try different methods of clearing the error
1773 * status on the drive so that it is not locked for
1774 * further operations.
1777 /* On some systems such as NetBSD, this clears all errors */
1778 tape_ioctl(fd, MTIOCGET, (char *)&mt_stat);
1780 /* Found on Linux */
1784 mt_com.mt_op = MTIOCLRERR;
1785 mt_com.mt_count = 1;
1786 /* Clear any error condition on the tape */
1787 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1788 Dmsg0(200, "Did MTIOCLRERR\n");
1792 /* Typically on FreeBSD */
1796 /* Read and clear SCSI error status */
1797 union mterrstat mt_errstat;
1798 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1799 be.strerror(dev_errno));
1800 tape_ioctl(fd, MTIOCERRSTAT, (char *)&mt_errstat);
1804 /* Clear Subsystem Exception OSF1 */
1808 mt_com.mt_op = MTCSE;
1809 mt_com.mt_count = 1;
1810 /* Clear any error condition on the tape */
1811 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1812 Dmsg0(200, "Did MTCSE\n");
1820 void DEVICE::close()
1822 Dmsg1(100, "close_dev %s\n", print_name());
1823 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1828 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1830 return; /* already closed */
1842 /* Clean up device packet so it can be reused */
1844 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1845 label_type = B_BACULA_LABEL;
1846 file = block_num = 0;
1849 EndFile = EndBlock = 0;
1851 Slot = -1; /* unknown slot */
1853 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1854 memset(&VolHdr, 0, sizeof(VolHdr));
1856 stop_thread_timer(tid);
1862 * This call closes the device, but it is used in DVD handling
1863 * where we close one part and then open the next part. The
1864 * difference between close_part() and close() is that close_part()
1865 * saves the state information of the device (e.g. the Volume lable,
1866 * the Volume Catalog record, ... This permits opening and closing
1867 * the Volume parts multiple times without losing track of what the
1868 * main Volume parameters are.
1870 void DEVICE::close_part(DCR *dcr)
1872 VOLUME_LABEL saveVolHdr;
1873 VOLUME_CAT_INFO saveVolCatInfo; /* Volume Catalog Information */
1876 saveVolHdr = VolHdr; /* structure assignment */
1877 saveVolCatInfo = VolCatInfo; /* structure assignment */
1878 close(); /* close current part */
1879 VolHdr = saveVolHdr; /* structure assignment */
1880 VolCatInfo = saveVolCatInfo; /* structure assignment */
1881 dcr->VolCatInfo = saveVolCatInfo; /* structure assignment */
1884 off_t DEVICE::lseek(DCR *dcr, off_t offset, int whence)
1888 return lseek_dvd(dcr, offset, whence);
1890 return ::lseek(fd, offset, whence);
1896 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1898 Dmsg1(100, "truncate %s\n", print_name());
1901 /* maybe we should rewind and write and eof ???? */
1902 return true; /* we don't really truncate tapes */
1904 return truncate_dvd(dcr);
1906 /* ***FIXME*** we really need to unlink() the file so that
1907 * its name can be changed for a relabel.
1909 if (ftruncate(fd, 0) != 0) {
1911 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1912 print_name(), be.strerror());
1920 /* Mount the device.
1921 * If timeout, wait until the mount command returns 0.
1922 * If !timeout, try to mount the device only once.
1924 bool DEVICE::mount(int timeout)
1926 Dmsg0(190, "Enter mount\n");
1929 } else if (requires_mount()) {
1930 return do_mount(1, timeout);
1935 /* Unmount the device
1936 * If timeout, wait until the unmount command returns 0.
1937 * If !timeout, try to unmount the device only once.
1939 bool DEVICE::unmount(int timeout)
1941 Dmsg0(90, "Enter unmount\n");
1943 return do_mount(0, timeout);
1948 /* (Un)mount the device */
1949 bool DEVICE::do_mount(int mount, int dotimeout)
1951 POOL_MEM ocmd(PM_FNAME);
1954 int status, timeout;
1956 sm_check(__FILE__, __LINE__, false);
1959 Dmsg0(200, "======= mount=1\n");
1962 icmd = device->mount_command;
1964 if (!is_mounted()) {
1965 Dmsg0(200, "======= mount=0\n");
1968 icmd = device->unmount_command;
1971 clear_freespace_ok();
1972 edit_mount_codes(ocmd, icmd);
1974 Dmsg2(100, "do_mount: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1977 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1982 results = get_memory(4000);
1985 /* If busy retry each second */
1986 Dmsg1(20, "do_mount run_prog=%s\n", ocmd.c_str());
1987 while ((status = run_program_full_output(ocmd.c_str(),
1988 max_open_wait/2, results)) != 0) {
1989 /* Doesn't work with internationalization (This is not a problem) */
1990 if (mount && fnmatch("*is already mounted on*", results, 0) == 0) {
1993 if (!mount && fnmatch("* not mounted*", results, 0) == 0) {
1996 if (timeout-- > 0) {
1997 /* Sometimes the device cannot be mounted because it is already mounted.
1998 * Try to unmount it, then remount it */
2000 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
2008 Dmsg5(40, "Device %s cannot be %smounted. stat=%d result=%s ERR=%s\n", print_name(),
2009 (mount ? "" : "un"), status, results, be.strerror(status));
2010 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2011 print_name(), (mount ? "" : "un"), be.strerror(status));
2013 Dmsg4(40, "Device %s cannot be %smounted. stat=%d ERR=%s\n", print_name(),
2014 (mount ? "" : "un"), status, results);
2015 Mmsg(errmsg, _("Device %s cannot be %smounted. ERR=%s\n"),
2016 print_name(), (mount ? "" : "un"), results);
2019 * Now, just to be sure it is not mounted, try to read the
2023 struct dirent *entry, *result;
2027 name_max = pathconf(".", _PC_NAME_MAX);
2028 if (name_max < 1024) {
2032 if (!(dp = opendir(device->mount_point))) {
2035 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
2036 device->mount_point, print_name(), be.strerror());
2040 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
2043 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
2045 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
2046 device->mount_point, print_name());
2049 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
2050 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
2053 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
2059 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
2062 /* If we got more than ., .. and .keep */
2063 /* there must be something mounted */
2065 Dmsg1(100, "Did Mount by count=%d\n", count);
2068 /* An unmount request. We failed to unmount - report an error */
2070 free_pool_memory(results);
2071 Dmsg0(200, "== error mount=1 wanted unmount\n");
2077 sm_check(__FILE__, __LINE__, false);
2078 free_pool_memory(results);
2079 Dmsg0(200, "============ mount=0\n");
2083 set_mounted(mount); /* set/clear mounted flag */
2084 free_pool_memory(results);
2085 /* Do not check free space when unmounting */
2086 if (mount && !update_freespace()) {
2089 Dmsg1(200, "============ mount=%d\n", mount);
2094 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2096 * %a = archive device name
2097 * %e = erase (set if cannot mount and first part)
2100 * %v = last part name
2102 * omsg = edited output message
2103 * imsg = input string containing edit codes (%x)
2106 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2112 POOL_MEM archive_name(PM_FNAME);
2114 omsg.c_str()[0] = 0;
2115 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2116 for (p=imsg; *p; p++) {
2126 if (num_dvd_parts == 0) {
2127 if (truncating || blank_dvd) {
2137 bsnprintf(add, sizeof(add), "%d", part);
2141 str = device->mount_point;
2144 make_spooled_dvd_filename(this, archive_name);
2145 str = archive_name.c_str();
2159 Dmsg1(1900, "add_str %s\n", str);
2160 pm_strcat(omsg, (char *)str);
2161 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2166 /* Return the resource name for the device */
2167 const char *DEVICE::name() const
2169 return device->hdr.name;
2173 dev_vol_name(DEVICE *dev)
2175 return dev->VolCatInfo.VolCatName;
2180 * Free memory allocated for the device
2182 void DEVICE::term(void)
2184 Dmsg1(900, "term dev: %s\n", print_name());
2187 free_memory(dev_name);
2191 free_memory(prt_name);
2195 free_pool_memory(errmsg);
2198 pthread_mutex_destroy(&mutex);
2199 pthread_cond_destroy(&wait);
2200 pthread_cond_destroy(&wait_next_vol);
2201 pthread_mutex_destroy(&spool_mutex);
2203 if (attached_dcrs) {
2204 delete attached_dcrs;
2205 attached_dcrs = NULL;
2214 * This routine initializes the device wait timers
2216 void init_device_wait_timers(DCR *dcr)
2218 DEVICE *dev = dcr->dev;
2219 JCR *jcr = dcr->jcr;
2221 /* ******FIXME******* put these on config variables */
2222 dev->min_wait = 60 * 60;
2223 dev->max_wait = 24 * 60 * 60;
2224 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2225 dev->wait_sec = dev->min_wait;
2226 dev->rem_wait_sec = dev->wait_sec;
2229 dev->BadVolName[0] = 0;
2231 jcr->min_wait = 60 * 60;
2232 jcr->max_wait = 24 * 60 * 60;
2233 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2234 jcr->wait_sec = jcr->min_wait;
2235 jcr->rem_wait_sec = jcr->wait_sec;
2240 void init_jcr_device_wait_timers(JCR *jcr)
2242 /* ******FIXME******* put these on config variables */
2243 jcr->min_wait = 60 * 60;
2244 jcr->max_wait = 24 * 60 * 60;
2245 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2246 jcr->wait_sec = jcr->min_wait;
2247 jcr->rem_wait_sec = jcr->wait_sec;
2253 * The dev timers are used for waiting on a particular device
2255 * Returns: true if time doubled
2256 * false if max time expired
2258 bool double_dev_wait_time(DEVICE *dev)
2260 dev->wait_sec *= 2; /* double wait time */
2261 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2262 dev->wait_sec = dev->max_wait;
2265 dev->rem_wait_sec = dev->wait_sec;
2266 if (dev->num_wait >= dev->max_num_wait) {
2273 void set_os_device_parameters(DEVICE *dev)
2275 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2278 Dmsg0(050, "In set_os_device_parameters\n");
2279 #if defined(MTSETBLK)
2280 if (dev->min_block_size == dev->max_block_size &&
2281 dev->min_block_size == 0) { /* variable block mode */
2282 mt_com.mt_op = MTSETBLK;
2283 mt_com.mt_count = 0;
2284 Dmsg0(050, "Set block size to zero\n");
2285 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2286 dev->clrerror(MTSETBLK);
2290 #if defined(MTSETDRVBUFFER)
2291 if (getpid() == 0) { /* Only root can do this */
2292 mt_com.mt_op = MTSETDRVBUFFER;
2293 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2294 if (!dev->has_cap(CAP_TWOEOF)) {
2295 mt_com.mt_count |= MT_ST_TWO_FM;
2297 if (dev->has_cap(CAP_EOM)) {
2298 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2300 Dmsg0(050, "MTSETDRVBUFFER\n");
2301 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2302 dev->clrerror(MTSETDRVBUFFER);
2309 #ifdef HAVE_NETBSD_OS
2311 if (dev->min_block_size == dev->max_block_size &&
2312 dev->min_block_size == 0) { /* variable block mode */
2313 mt_com.mt_op = MTSETBSIZ;
2314 mt_com.mt_count = 0;
2315 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2316 dev->clrerror(MTSETBSIZ);
2318 /* Get notified at logical end of tape */
2319 mt_com.mt_op = MTEWARN;
2320 mt_com.mt_count = 1;
2321 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2322 dev->clrerror(MTEWARN);
2328 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2330 if (dev->min_block_size == dev->max_block_size &&
2331 dev->min_block_size == 0) { /* variable block mode */
2332 mt_com.mt_op = MTSETBSIZ;
2333 mt_com.mt_count = 0;
2334 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2335 dev->clrerror(MTSETBSIZ);
2343 if (dev->min_block_size == dev->max_block_size &&
2344 dev->min_block_size == 0) { /* variable block mode */
2345 mt_com.mt_op = MTSRSZ;
2346 mt_com.mt_count = 0;
2347 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2348 dev->clrerror(MTSRSZ);
2355 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2357 Dmsg0(050, "dev_get_os_pos\n");
2358 return dev->has_cap(CAP_MTIOCGET) &&
2359 tape_ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2360 mt_stat->mt_fileno >= 0;
2363 static char *modes[] = {
2364 "CREATE_READ_WRITE",
2371 static char *mode_to_str(int mode)
2373 static char buf[100];
2374 if (mode < 1 || mode > 4) {
2375 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2378 return modes[mode-1];