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)
327 int nonblocking = O_NONBLOCK;
328 Dmsg0(29, "open dev: device is tape\n");
330 get_autochanger_loaded_slot(dcr);
333 timeout = max_open_wait;
335 if (is_fifo() && timeout) {
337 tid = start_thread_timer(pthread_self(), timeout);
339 /* If busy retry each second for max_open_wait seconds */
340 Dmsg3(100, "Try open %s mode=%s nonblocking=%d\n", print_name(),
341 mode_to_str(omode), nonblocking);
342 /* Use system open() */
344 #if defined(HAVE_WIN32)
345 if ((fd = tape_open(dev_name, mode)) < 0) {
349 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
350 print_name(), be.strerror(dev_errno));
351 Jmsg0(dcr->jcr, M_FATAL, 0, errmsg);
354 while ((fd = ::open(dev_name, mode+nonblocking)) < 0) {
357 Dmsg5(050, "Open omode=%d mode=%x nonblock=%d error errno=%d ERR=%s\n",
358 omode, mode, nonblocking, errno, be.strerror());
359 if (dev_errno == EINTR || dev_errno == EAGAIN) {
360 Dmsg0(100, "Continue open\n");
363 /* Busy wait for specified time (default = 5 mins) */
364 if (dev_errno == EBUSY && timeout-- > 0) {
365 Dmsg2(100, "Device %s busy. ERR=%s\n", print_name(), be.strerror());
369 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
370 print_name(), be.strerror(dev_errno));
371 /* Stop any open timer we set */
373 stop_thread_timer(tid);
376 Jmsg0(dcr->jcr, M_FATAL, 0, errmsg);
382 openmode = omode; /* save open mode */
384 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
386 update_pos_dev(this); /* update position */
387 set_os_device_parameters(this); /* do system dependent stuff */
392 /* Stop any open() timer we started */
394 stop_thread_timer(tid);
397 Dmsg1(29, "open dev: tape %d opened\n", fd);
400 void DEVICE::set_blocking()
403 /* Try to reset blocking */
405 if ((oflags = fcntl(fd, F_GETFL, 0)) < 0 ||
406 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK) < 0) {
408 ::close(fd); /* use system close() */
409 fd = ::open(dev_name, mode);
410 Dmsg2(100, "fcntl error. ERR=%s. Close-reopen fd=%d\n", be.strerror(), fd);
413 oflags = fcntl(fd, F_GETFL, 0);
414 if (oflags > 0 && (oflags & O_NONBLOCK)) {
415 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK);
422 void DEVICE::open_file_device(DCR *dcr, int omode)
424 POOL_MEM archive_name(PM_FNAME);
426 get_autochanger_loaded_slot(dcr);
429 * Handle opening of File Archive (not a tape)
432 pm_strcpy(archive_name, dev_name);
434 * If this is a virtual autochanger (i.e. changer_res != NULL)
435 * we simply use the deviced name, assuming it has been
436 * appropriately setup by the "autochanger".
438 if (!device->changer_res) {
439 if (VolCatInfo.VolCatName[0] == 0) {
440 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
446 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
447 pm_strcat(archive_name, "/");
449 pm_strcat(archive_name, VolCatInfo.VolCatName);
452 mount(1); /* do mount if required */
456 /* If creating file, give 0640 permissions */
457 Dmsg3(29, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
458 archive_name.c_str(), mode);
459 /* Use system open() */
460 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
463 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
465 Dmsg1(29, "open failed: %s", errmsg);
466 Emsg0(M_FATAL, 0, errmsg);
469 update_pos_dev(this); /* update position */
471 Dmsg4(29, "open dev: disk fd=%d opened, part=%d/%d, part_size=%u\n",
472 fd, part, num_dvd_parts, part_size);
476 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
477 * (NB:??? I think it's VolCatInfo.VolCatName that is right)
478 * has the desired Volume name, but there is NO assurance that
479 * any other field of VolCatInfo is correct.
481 void DEVICE::open_dvd_device(DCR *dcr, int omode)
483 POOL_MEM archive_name(PM_FNAME);
484 struct stat filestat;
487 * Handle opening of DVD Volume
489 Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
490 archive_name.c_str(), mode_to_str(omode));
493 * For a DVD we must alway pull the state info from dcr->VolCatInfo
494 * This is a bit ugly, but is necessary because we need to open/close/re-open
495 * the dvd file in order to properly mount/unmount and access the
496 * DVD. So we store the state of the DVD as far as is known in the
497 * catalog in dcr->VolCatInfo, and thus we refresh the dev->VolCatInfo
498 * copy here, when opening.
500 memcpy(&VolCatInfo, &dcr->VolCatInfo, sizeof(VolCatInfo));
501 Dmsg1(100, "Volume=%s\n", VolCatInfo.VolCatName);
503 if (VolCatInfo.VolCatName[0] == 0) {
504 Dmsg1(10, "Could not open file device %s. No Volume name given.\n",
506 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
513 Dmsg0(100, "Set part=1\n");
514 part = 1; /* count from 1 */
518 if (num_dvd_parts != VolCatInfo.VolCatParts) {
519 num_dvd_parts = VolCatInfo.VolCatParts;
521 // Clear any previous truncated_dvd status - we will recalculate it here
522 truncated_dvd = false;
524 Dmsg3(99, "open_dvd_device: part=%d num_dvd_parts=%d, VolCatInfo.VolCatParts=%d\n",
525 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
527 if (mount_dvd(this, 1)) {
528 Dmsg0(99, "DVD device mounted.\n");
529 if ((num_dvd_parts == 0) && (!truncating)) {
531 * If we can mount the device, and we are not truncating the DVD,
532 * we usually want to abort. There is one exception, if there is
533 * only one 0-sized file on the DVD, with the right volume name,
534 * we continue (it's the method used by truncate_dvd to truncate a volume).
536 if (!check_can_write_on_non_blank_dvd(dcr)) {
537 Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
538 Emsg0(M_FATAL, 0, errmsg);
539 unmount_dvd(this, 1); /* Unmount the device, so the operator can change it. */
543 truncated_dvd = true;
546 Dmsg0(99, "DVD device mount failed.\n");
547 /* We cannot mount the device */
548 if (num_dvd_parts == 0) {
549 /* Run free space, check there is a media. */
550 if (!update_free_space_dev(this)) {
551 Emsg0(M_FATAL, 0, errmsg);
556 Dmsg1(29, "Could not mount device %s, this is not a problem (num_dvd_parts == 0), and have media.\n", print_name());
558 Mmsg(errmsg, _("There is no valid media in the device %s.\n"), print_name());
559 Emsg0(M_FATAL, 0, errmsg);
564 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
565 Emsg0(M_FATAL, 0, errmsg);
571 Dmsg5(29, "open dev: DVD dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
572 archive_name.c_str(), mode_to_str(omode),
573 part, num_dvd_parts, dcr->VolCatInfo.VolCatParts);
575 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
578 * If we are not trying to access the last part, set mode to
579 * OPEN_READ_ONLY as writing would be an error.
581 Dmsg2(29, "open DVD part=%d num_dvd_parts=%d\n", part, num_dvd_parts);
582 if (part <= num_dvd_parts) {
583 omode = OPEN_READ_ONLY;
584 make_mounted_dvd_filename(this, archive_name);
586 make_spooled_dvd_filename(this, archive_name);
590 /* If creating file, give 0640 permissions */
591 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
592 archive_name.c_str(), mode);
593 /* Use system open() */
594 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
596 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
598 // Should this be set if we try the create/open below
599 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
600 Dmsg1(29, "open failed: %s", errmsg);
602 if ((omode == OPEN_READ_ONLY || omode == OPEN_READ_WRITE) &&
603 (part > num_dvd_parts)) {
604 /* If the last part (on spool), doesn't exists when accessing,
605 * create it. In read/write mode a write will be allowed (higher
606 * level software thinks that we are extending a pre-existing
607 * media. Reads for READ_ONLY will report immediately an EOF
608 * Sometimes it is better to finish with an EOF than with an error. */
609 Dmsg1(29, "Creating last part on spool: %s\n", archive_name.c_str());
610 set_mode(CREATE_READ_WRITE);
611 fd = ::open(archive_name.c_str(), mode, 0640);
615 /* We don't need it. Only the last part is on spool */
616 /*if (omode == OPEN_READ_ONLY) {
617 make_spooled_dvd_filename(this, archive_name);
618 fd = ::open(archive_name.c_str(), mode, 0640); // try on spool
621 Dmsg1(100, "after open fd=%d\n", fd);
623 /* Get size of file */
624 if (fstat(fd, &filestat) < 0) {
627 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
629 Dmsg1(29, "open failed: %s", errmsg);
630 /* Use system close() */
634 part_size = filestat.st_size;
636 update_pos_dev(this); /* update position */
638 /* NB: It seems this code is wrong... part number is incremented in open_next_part, not here */
640 /* Check if just created Volume part */
642 * if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
644 * num_dvd_parts = part;
645 * VolCatInfo.VolCatParts = num_dvd_parts;
647 * if (part == 0) { // we must have opened the first part
660 * Returns: true on success
663 bool DEVICE::rewind(DCR *dcr)
669 Dmsg3(400, "rewind res=%d fd=%d %s\n", reserved_device, fd, print_name());
671 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
673 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
675 Emsg0(M_ABORT, 0, errmsg);
679 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
680 block_num = file = 0;
684 mt_com.mt_op = MTREW;
686 /* If we get an I/O error on rewind, it is probably because
687 * the drive is actually busy. We loop for (about 5 minutes)
688 * retrying every 5 seconds.
690 for (i=max_rewind_wait; ; i -= 5) {
691 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
694 if (i == max_rewind_wait) {
695 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
698 * This is a gross hack, because if the user has the
699 * device mounted (i.e. open), then uses mtx to load
700 * a tape, the current open file descriptor is invalid.
701 * So, we close the drive and re-open it.
704 int open_mode = openmode;
707 open(dcr, open_mode);
715 if (dev_errno == EIO) {
716 Mmsg1(errmsg, _("No tape loaded or drive offline on %s.\n"), print_name());
720 if (dev_errno == EIO && i > 0) {
721 Dmsg0(200, "Sleeping 5 seconds.\n");
726 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
727 print_name(), be.strerror());
732 } else if (is_file() || is_dvd()) {
733 if (lseek_dev(this, (off_t)0, SEEK_SET) < 0) {
736 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
737 print_name(), be.strerror());
744 void DEVICE::block(int why)
747 block_device(this, why);
751 void DEVICE::unblock()
754 unblock_device(this);
758 const char *DEVICE::print_blocked() const
760 switch (dev_blocked) {
761 case BST_NOT_BLOCKED:
762 return "BST_NOT_BLOCKED";
764 return "BST_UNMOUNTED";
765 case BST_WAITING_FOR_SYSOP:
766 return "BST_WAITING_FOR_SYSOP";
767 case BST_DOING_ACQUIRE:
768 return "BST_DOING_ACQUIRE";
769 case BST_WRITING_LABEL:
770 return "BST_WRITING_LABEL";
771 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
772 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
776 return _("unknown blocked code");
781 * Called to indicate that we have just read an
782 * EOF from the device.
784 void DEVICE::set_ateof()
796 * Called to indicate we are now at the end of the tape, and
797 * writing is not possible.
799 void DEVICE::set_ateot()
801 /* Make tape effectively read-only */
802 state |= (ST_EOF|ST_EOT|ST_WEOT);
807 * Position device to end of medium (end of data)
808 * Returns: true on succes
814 struct mtget mt_stat;
820 Mmsg1(errmsg, _("Bad call to eod_dev. Device %s not open\n"), print_name());
824 #if defined (__digital__) && defined (__unix__)
825 return fsf(VolCatInfo.VolCatFiles);
828 Dmsg0(29, "eod_dev\n");
832 clear_eof(); /* remove EOF flag */
833 block_num = file = 0;
836 if (is_fifo() || is_prog()) {
840 pos = lseek_dev(this, (off_t)0, SEEK_END);
841 // Dmsg1(100, "====== Seek to %lld\n", pos);
843 update_pos_dev(this);
849 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
850 print_name(), be.strerror());
854 if (has_cap(CAP_FASTFSF) && !has_cap(CAP_EOM)) {
855 Dmsg0(100,"Using FAST FSF for EOM\n");
856 /* If unknown position, rewind */
857 if (!dev_get_os_pos(this, &mt_stat)) {
862 mt_com.mt_op = MTFSF;
864 * ***FIXME*** fix code to handle case that INT16_MAX is
867 mt_com.mt_count = INT16_MAX; /* use big positive number */
868 if (mt_com.mt_count < 0) {
869 mt_com.mt_count = INT16_MAX; /* brain damaged system */
873 if (has_cap(CAP_MTIOCGET) && (has_cap(CAP_FASTFSF) || has_cap(CAP_EOM))) {
874 if (has_cap(CAP_EOM)) {
875 Dmsg0(100,"Using EOM for EOM\n");
876 mt_com.mt_op = MTEOM;
880 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
882 clrerror(mt_com.mt_op);
883 Dmsg1(50, "ioctl error: %s\n", be.strerror());
884 update_pos_dev(this);
885 Mmsg2(errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
886 print_name(), be.strerror());
890 if (!dev_get_os_pos(this, &mt_stat)) {
893 Mmsg2(errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
894 print_name(), be.strerror());
897 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
899 file = mt_stat.mt_fileno;
905 * Rewind then use FSF until EOT reached
911 * Move file by file to the end of the tape
914 for (file_num=file; !at_eot(); file_num++) {
915 Dmsg0(200, "eod_dev: doing fsf 1\n");
917 Dmsg0(200, "fsf error.\n");
921 * Avoid infinite loop by ensuring we advance.
923 if (file_num == (int)file) {
924 struct mtget mt_stat;
925 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
927 if (dev_get_os_pos(this, &mt_stat)) {
928 Dmsg2(100, "Adjust file from %d to %d\n", file , mt_stat.mt_fileno);
929 file = mt_stat.mt_fileno;
936 * Some drivers leave us after second EOF when doing
937 * MTEOM, so we must backup so that appending overwrites
940 if (has_cap(CAP_BSFATEOM)) {
941 struct mtget mt_stat;
942 /* Backup over EOF */
944 /* If BSF worked and fileno is known (not -1), set file */
945 if (dev_get_os_pos(this, &mt_stat)) {
946 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", file , mt_stat.mt_fileno);
947 file = mt_stat.mt_fileno;
949 file++; /* wing it -- not correct on all OSes */
952 update_pos_dev(this); /* update position */
954 Dmsg1(200, "EOD dev->file=%d\n", file);
959 * Set the position of the device -- only for files and DVD
960 * For other devices, there is no generic way to do it.
961 * Returns: true on succes
964 bool update_pos_dev(DEVICE *dev)
970 dev->dev_errno = EBADF;
971 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
972 Emsg0(M_FATAL, 0, dev->errmsg);
976 /* Find out where we are */
977 if (dev->is_file()) {
980 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
983 dev->dev_errno = errno;
984 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
985 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
986 dev->print_name(), be.strerror());
989 dev->file_addr = pos;
990 dev->block_num = (uint32_t)pos;
991 dev->file = (uint32_t)(pos >> 32);
999 * Return the status of the device. This was meant
1000 * to be a generic routine. Unfortunately, it doesn't
1001 * seem possible (at least I do not know how to do it
1002 * currently), which means that for the moment, this
1003 * routine has very little value.
1007 uint32_t status_dev(DEVICE *dev)
1009 struct mtget mt_stat;
1012 if (dev->state & (ST_EOT | ST_WEOT)) {
1016 if (dev->state & ST_EOF) {
1020 if (dev->is_tape()) {
1022 Pmsg0(-20,_(" Bacula status:"));
1023 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
1024 if (tape_ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
1026 dev->dev_errno = errno;
1027 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
1028 dev->print_name(), be.strerror());
1031 Pmsg0(-20, _(" Device status:"));
1033 #if defined(HAVE_LINUX_OS)
1034 if (GMT_EOF(mt_stat.mt_gstat)) {
1038 if (GMT_BOT(mt_stat.mt_gstat)) {
1042 if (GMT_EOT(mt_stat.mt_gstat)) {
1046 if (GMT_SM(mt_stat.mt_gstat)) {
1050 if (GMT_EOD(mt_stat.mt_gstat)) {
1054 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1055 stat |= BMT_WR_PROT;
1056 Pmsg0(-20, " WR_PROT");
1058 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1060 Pmsg0(-20, " ONLINE");
1062 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1063 stat |= BMT_DR_OPEN;
1064 Pmsg0(-20, " DR_OPEN");
1066 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1067 stat |= BMT_IM_REP_EN;
1068 Pmsg0(-20, " IM_REP_EN");
1070 #elif defined(HAVE_WIN32)
1071 if (GMT_EOF(mt_stat.mt_gstat)) {
1075 if (GMT_BOT(mt_stat.mt_gstat)) {
1079 if (GMT_EOT(mt_stat.mt_gstat)) {
1083 if (GMT_EOD(mt_stat.mt_gstat)) {
1087 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1088 stat |= BMT_WR_PROT;
1089 Pmsg0(-20, " WR_PROT");
1091 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1093 Pmsg0(-20, " ONLINE");
1095 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1096 stat |= BMT_DR_OPEN;
1097 Pmsg0(-20, " DR_OPEN");
1099 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1100 stat |= BMT_IM_REP_EN;
1101 Pmsg0(-20, " IM_REP_EN");
1104 #endif /* !SunOS && !OSF */
1105 if (dev->has_cap(CAP_MTIOCGET)) {
1106 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1108 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1111 stat |= BMT_ONLINE | BMT_BOT;
1118 * Load medium in device
1119 * Returns: true on success
1122 bool load_dev(DEVICE *dev)
1129 dev->dev_errno = EBADF;
1130 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1131 Emsg0(M_FATAL, 0, dev->errmsg);
1134 if (!(dev->is_tape())) {
1138 Dmsg0(200, "stored: MTLOAD command not available\n");
1140 dev->dev_errno = ENOTTY; /* function not available */
1141 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1142 dev->print_name(), be.strerror());
1146 dev->block_num = dev->file = 0;
1149 mt_com.mt_op = MTLOAD;
1150 mt_com.mt_count = 1;
1151 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1153 dev->dev_errno = errno;
1154 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1155 dev->print_name(), be.strerror());
1163 * Rewind device and put it offline
1164 * Returns: true on success
1167 bool DEVICE::offline()
1172 return true; /* device not open */
1175 state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1176 block_num = file = 0;
1180 mt_com.mt_op = MTUNLOCK;
1181 mt_com.mt_count = 1;
1182 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1184 mt_com.mt_op = MTOFFL;
1185 mt_com.mt_count = 1;
1186 if (tape_ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
1189 Mmsg2(errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1190 print_name(), be.strerror());
1193 Dmsg1(100, "Offlined device %s\n", print_name());
1197 bool DEVICE::offline_or_rewind()
1202 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1206 * Note, this rewind probably should not be here (it wasn't
1207 * in prior versions of Bacula), but on FreeBSD, this is
1208 * needed in the case the tape was "frozen" due to an error
1209 * such as backspacing after writing and EOF. If it is not
1210 * done, all future references to the drive get and I/O error.
1213 return rewind(NULL);
1218 * Foward space a file
1219 * Returns: true on success
1222 bool DEVICE::fsf(int num)
1224 struct mtget mt_stat;
1230 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1231 Emsg0(M_FATAL, 0, errmsg);
1240 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1244 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1247 Dmsg0(100, "fsf\n");
1250 * If Fast forward space file is set, then we
1251 * use MTFSF to forward space and MTIOCGET
1252 * to get the file position. We assume that
1253 * the SCSI driver will ensure that we do not
1254 * forward space past the end of the medium.
1256 if (has_cap(CAP_FSF) && has_cap(CAP_MTIOCGET) && has_cap(CAP_FASTFSF)) {
1257 mt_com.mt_op = MTFSF;
1258 mt_com.mt_count = num;
1259 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1260 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1263 Dmsg0(200, "Set ST_EOT\n");
1265 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1266 print_name(), be.strerror());
1267 Dmsg1(200, "%s", errmsg);
1270 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1272 file = mt_stat.mt_fileno;
1276 * Here if CAP_FSF is set, and virtually all drives
1277 * these days support it, we read a record, then forward
1278 * space one file. Using this procedure, which is slow,
1279 * is the only way we can be sure that we don't read
1280 * two consecutive EOF marks, which means End of Data.
1282 } else if (has_cap(CAP_FSF)) {
1285 Dmsg0(200, "FSF has cap_fsf\n");
1286 if (max_block_size == 0) {
1287 rbuf_len = DEFAULT_BLOCK_SIZE;
1289 rbuf_len = max_block_size;
1291 rbuf = get_memory(rbuf_len);
1292 mt_com.mt_op = MTFSF;
1293 mt_com.mt_count = 1;
1294 while (num-- && !at_eot()) {
1295 Dmsg0(100, "Doing read before fsf\n");
1296 if ((stat = tape_read(fd, (char *)rbuf, rbuf_len)) < 0) {
1297 if (errno == ENOMEM) { /* tape record exceeds buf len */
1298 stat = rbuf_len; /* This is OK */
1300 * On IBM drives, they return ENOSPC at EOM
1301 * instead of EOF status
1303 } else if (at_eof() && errno == ENOSPC) {
1309 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1311 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1312 print_name(), be.strerror());
1313 Dmsg1(100, "%s", errmsg);
1317 if (stat == 0) { /* EOF */
1318 update_pos_dev(this);
1319 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1320 /* Two reads of zero means end of tape */
1323 Dmsg0(100, "Set ST_EOT\n");
1329 } else { /* Got data */
1334 Dmsg0(100, "Doing MTFSF\n");
1335 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1336 if (stat < 0) { /* error => EOT */
1339 Dmsg0(100, "Set ST_EOT\n");
1341 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1342 print_name(), be.strerror());
1343 Dmsg0(100, "Got < 0 for MTFSF\n");
1344 Dmsg1(100, "%s", errmsg);
1352 * No FSF, so use FSR to simulate it
1355 Dmsg0(200, "Doing FSR for FSF\n");
1356 while (num-- && !at_eot()) {
1357 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1361 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1367 update_pos_dev(this);
1368 Dmsg1(200, "Return %d from FSF\n", stat);
1370 Dmsg0(200, "ST_EOF set on exit FSF\n");
1373 Dmsg0(200, "ST_EOT set on exit FSF\n");
1375 Dmsg1(200, "Return from FSF file=%d\n", file);
1380 * Backward space a file
1381 * Returns: false on failure
1384 bool DEVICE::bsf(int num)
1391 Mmsg0(errmsg, _("Bad call to bsf. Device not open\n"));
1392 Emsg0(M_FATAL, 0, errmsg);
1397 Mmsg1(errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1407 mt_com.mt_op = MTBSF;
1408 mt_com.mt_count = num;
1409 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1413 Mmsg2(errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1414 print_name(), be.strerror());
1416 update_pos_dev(this);
1422 * Foward space num records
1423 * Returns: false on failure
1426 bool DEVICE::fsr(int num)
1433 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1434 Emsg0(M_FATAL, 0, errmsg);
1441 if (!has_cap(CAP_FSR)) {
1442 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1446 Dmsg1(29, "fsr %d\n", num);
1447 mt_com.mt_op = MTFSR;
1448 mt_com.mt_count = num;
1449 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1455 struct mtget mt_stat;
1457 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1458 if (dev_get_os_pos(this, &mt_stat)) {
1459 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1460 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1461 file = mt_stat.mt_fileno;
1462 block_num = mt_stat.mt_blkno;
1470 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1471 num, print_name(), be.strerror());
1473 update_pos_dev(this);
1478 * Backward space a record
1479 * Returns: false on failure
1482 bool DEVICE::bsr(int num)
1489 Mmsg0(errmsg, _("Bad call to bsr_dev. Device not open\n"));
1490 Emsg0(M_FATAL, 0, errmsg);
1498 if (!has_cap(CAP_BSR)) {
1499 Mmsg1(errmsg, _("ioctl MTBSR not permitted on %s.\n"), print_name());
1503 Dmsg0(29, "bsr_dev\n");
1507 mt_com.mt_op = MTBSR;
1508 mt_com.mt_count = num;
1509 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1513 Mmsg2(errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1514 print_name(), be.strerror());
1516 update_pos_dev(this);
1521 * Reposition the device to file, block
1522 * Returns: false on failure
1525 bool DEVICE::reposition(uint32_t rfile, uint32_t rblock)
1529 Mmsg0(errmsg, _("Bad call to reposition. Device not open\n"));
1530 Emsg0(M_FATAL, 0, errmsg);
1535 off_t pos = (((off_t)rfile)<<32) + (off_t)rblock;
1536 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1537 if (lseek_dev(this, pos, SEEK_SET) == (off_t)-1) {
1540 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1541 print_name(), be.strerror());
1549 Dmsg4(100, "reposition from %u:%u to %u:%u\n",
1550 file, block_num, rfile, rblock);
1552 Dmsg0(100, "Rewind\n");
1553 if (!rewind(NULL)) {
1558 Dmsg1(100, "fsf %d\n", rfile-file);
1559 if (!fsf(rfile-file)) {
1560 Dmsg1(100, "fsf failed! ERR=%s\n", bstrerror());
1563 Dmsg2(100, "wanted_file=%d at_file=%d\n", rfile, file);
1565 if (rblock < block_num) {
1566 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1567 Dmsg0(100, "bsf 1\n");
1569 Dmsg0(100, "fsf_dev 1\n");
1571 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", rblock, block_num);
1573 if (has_cap(CAP_POSITIONBLOCKS) && rblock > block_num) {
1574 /* Ignore errors as Bacula can read to the correct block */
1575 Dmsg1(100, "fsr %d\n", rblock-block_num);
1576 return fsr(rblock-block_num);
1584 * Write an end of file on the device
1585 * Returns: true on success
1588 bool DEVICE::weof(int num)
1592 Dmsg0(129, "weof_dev\n");
1596 Mmsg0(errmsg, _("Bad call to weof_dev. Device not open\n"));
1597 Emsg0(M_FATAL, 0, errmsg);
1605 if (!can_append()) {
1606 Mmsg0(errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1607 Emsg0(M_FATAL, 0, errmsg);
1613 mt_com.mt_op = MTWEOF;
1614 mt_com.mt_count = num;
1615 stat = tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1624 Mmsg2(errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1625 print_name(), be.strerror());
1633 * If implemented in system, clear the tape
1636 void DEVICE::clrerror(int func)
1638 const char *msg = NULL;
1639 struct mtget mt_stat;
1642 dev_errno = errno; /* save errno */
1644 VolCatInfo.VolCatErrors++;
1650 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1653 break; /* ignore message printed later */
1656 capabilities &= ~CAP_EOF; /* turn off feature */
1661 capabilities &= ~CAP_EOM; /* turn off feature */
1666 capabilities &= ~CAP_FSF; /* turn off feature */
1670 capabilities &= ~CAP_BSF; /* turn off feature */
1674 capabilities &= ~CAP_FSR; /* turn off feature */
1678 capabilities &= ~CAP_BSR; /* turn off feature */
1712 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1718 Mmsg1(errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1719 Emsg0(M_ERROR, 0, errmsg);
1724 * Now we try different methods of clearing the error
1725 * status on the drive so that it is not locked for
1726 * further operations.
1729 /* On some systems such as NetBSD, this clears all errors */
1730 tape_ioctl(fd, MTIOCGET, (char *)&mt_stat);
1732 /* Found on Linux */
1736 mt_com.mt_op = MTIOCLRERR;
1737 mt_com.mt_count = 1;
1738 /* Clear any error condition on the tape */
1739 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1740 Dmsg0(200, "Did MTIOCLRERR\n");
1744 /* Typically on FreeBSD */
1748 /* Read and clear SCSI error status */
1749 union mterrstat mt_errstat;
1750 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev_errno,
1751 be.strerror(dev_errno));
1752 tape_ioctl(fd, MTIOCERRSTAT, (char *)&mt_errstat);
1756 /* Clear Subsystem Exception OSF1 */
1760 mt_com.mt_op = MTCSE;
1761 mt_com.mt_count = 1;
1762 /* Clear any error condition on the tape */
1763 tape_ioctl(fd, MTIOCTOP, (char *)&mt_com);
1764 Dmsg0(200, "Did MTCSE\n");
1772 void DEVICE::close()
1774 Dmsg1(100, "close_dev %s\n", print_name());
1775 if (has_cap(CAP_OFFLINEUNMOUNT)) {
1785 Dmsg2(100, "device %s already closed vol=%s\n", print_name(),
1787 return; /* already closed */
1790 if (is_dvd() && !unmount_dvd(this, 1)) {
1791 Dmsg1(0, "Cannot unmount device %s.\n", print_name());
1794 /* Remove the last part file if it is empty */
1795 if (num_dvd_parts > 0) {
1797 int part_save = part;
1798 POOL_MEM archive_name(PM_FNAME);
1800 part = num_dvd_parts;
1801 Dmsg3(100, "Remove empty part in close call make_dvd_filename. part=%d num=%d vol=%s\n",
1802 part, num_dvd_parts, VolCatInfo.VolCatName);
1803 make_spooled_dvd_filename(this, archive_name);
1804 /* Check that the part file is empty */
1805 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1806 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1807 unlink(archive_name.c_str());
1809 part = part_save; /* restore part number */
1812 /* Clean up device packet so it can be reused */
1814 state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1815 label_type = B_BACULA_LABEL;
1816 file = block_num = 0;
1819 EndFile = EndBlock = 0;
1820 Slot = -1; /* unknown slot */
1822 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
1823 memset(&VolHdr, 0, sizeof(VolHdr));
1825 stop_thread_timer(tid);
1833 bool DEVICE::truncate(DCR *dcr) /* We need the DCR for DVD-writing */
1835 Dmsg1(100, "truncate_dev %s\n", print_name());
1837 return true; /* we don't really truncate tapes */
1838 /* maybe we should rewind and write and eof ???? */
1842 return truncate_dvd(dcr);
1845 if (ftruncate(fd, 0) != 0) {
1847 Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1848 print_name(), be.strerror());
1854 /* Mount the device.
1855 * If timeout, wait until the mount command returns 0.
1856 * If !timeout, try to mount the device only once.
1858 bool DEVICE::mount(int timeout)
1860 Dmsg0(190, "Enter mount\n");
1863 } else if (requires_mount()) {
1864 return do_mount(1, timeout);
1869 /* Unmount the device
1870 * If timeout, wait until the unmount command returns 0.
1871 * If !timeout, try to unmount the device only once.
1873 bool DEVICE::unmount(int timeout)
1875 Dmsg0(90, "Enter unmount_dvd\n");
1877 return do_mount(0, timeout);
1882 /* (Un)mount the device */
1883 bool DEVICE::do_mount(int mount, int dotimeout)
1885 POOL_MEM ocmd(PM_FNAME);
1888 int status, timeout;
1890 sm_check(__FILE__, __LINE__, false);
1893 Dmsg0(200, "======= mount=1\n");
1896 icmd = device->mount_command;
1898 if (!is_mounted()) {
1899 Dmsg0(200, "======= mount=0\n");
1902 icmd = device->unmount_command;
1905 edit_mount_codes(ocmd, icmd);
1907 Dmsg2(000, "do_mount_dvd: cmd=%s mounted=%d\n", ocmd.c_str(), !!is_mounted());
1910 /* Try at most 1 time to (un)mount the device. This should perhaps be configurable. */
1915 results = get_memory(2000);
1917 /* If busy retry each second */
1918 while ((status = run_program_full_output(ocmd.c_str(),
1919 max_open_wait/2, results)) != 0) {
1920 /* Doesn't work with internationalisation (This is not a problem) */
1921 if (fnmatch("*is already mounted on", results, 0) == 0) {
1924 if (timeout-- > 0) {
1925 /* Sometimes the device cannot be mounted because it is already mounted.
1926 * Try to unmount it, then remount it */
1928 Dmsg1(400, "Trying to unmount the device %s...\n", print_name());
1934 Dmsg2(40, "Device %s cannot be mounted. ERR=%s\n", print_name(), results);
1935 Mmsg(errmsg, _("Device %s cannot be mounted. ERR=%s\n"),
1936 print_name(), results);
1938 * Now, just to be sure it is not mounted, try to read the
1942 struct dirent *entry, *result;
1946 name_max = pathconf(".", _PC_NAME_MAX);
1947 if (name_max < 1024) {
1951 if (!(dp = opendir(device->mount_point))) {
1954 Dmsg3(29, "do_mount: failed to open dir %s (dev=%s), ERR=%s\n",
1955 device->mount_point, print_name(), be.strerror());
1959 entry = (struct dirent *)malloc(sizeof(struct dirent) + name_max + 1000);
1962 if ((readdir_r(dp, entry, &result) != 0) || (result == NULL)) {
1964 Dmsg2(129, "do_mount: failed to find suitable file in dir %s (dev=%s)\n",
1965 device->mount_point, print_name());
1968 if ((strcmp(result->d_name, ".")) && (strcmp(result->d_name, "..")) && (strcmp(result->d_name, ".keep"))) {
1969 count++; /* result->d_name != ., .. or .keep (Gentoo-specific) */
1972 Dmsg2(129, "do_mount: ignoring %s in %s\n", result->d_name, device->mount_point);
1978 Dmsg1(29, "do_mount: got %d files in the mount point (not counting ., .. and .keep)\n", count);
1981 mount = 1; /* If we got more than ., .. and .keep */
1982 break; /* there must be something mounted */
1986 sm_check(__FILE__, __LINE__, false);
1987 free_pool_memory(results);
1988 Dmsg0(200, "============ mount=0\n");
1992 set_mounted(mount); /* set/clear mounted flag */
1993 free_pool_memory(results);
1994 Dmsg1(200, "============ mount=%d\n", mount);
1999 * Edit codes into (Un)MountCommand, Write(First)PartCommand
2001 * %a = archive device name
2002 * %e = erase (set if cannot mount and first part)
2005 * %v = last part name
2007 * omsg = edited output message
2008 * imsg = input string containing edit codes (%x)
2011 void DEVICE::edit_mount_codes(POOL_MEM &omsg, const char *imsg)
2017 POOL_MEM archive_name(PM_FNAME);
2019 omsg.c_str()[0] = 0;
2020 Dmsg1(800, "edit_mount_codes: %s\n", imsg);
2021 for (p=imsg; *p; p++) {
2031 if (num_dvd_parts == 0) {
2032 if (truncating || truncated_dvd) {
2042 bsnprintf(add, sizeof(add), "%d", part);
2046 str = device->mount_point;
2049 make_spooled_dvd_filename(this, archive_name);
2050 str = archive_name.c_str();
2064 Dmsg1(1900, "add_str %s\n", str);
2065 pm_strcat(omsg, (char *)str);
2066 Dmsg1(1800, "omsg=%s\n", omsg.c_str());
2071 /* Return the resource name for the device */
2072 const char *DEVICE::name() const
2074 return device->hdr.name;
2078 dev_vol_name(DEVICE *dev)
2080 return dev->VolCatInfo.VolCatName;
2083 uint32_t dev_block(DEVICE *dev)
2085 update_pos_dev(dev);
2086 return dev->block_num;
2089 uint32_t dev_file(DEVICE *dev)
2091 update_pos_dev(dev);
2096 * Free memory allocated for the device
2098 void DEVICE::term(void)
2100 Dmsg1(900, "term dev: %s\n", print_name());
2103 free_memory(dev_name);
2107 free_memory(prt_name);
2111 free_pool_memory(errmsg);
2114 pthread_mutex_destroy(&mutex);
2115 pthread_cond_destroy(&wait);
2116 pthread_cond_destroy(&wait_next_vol);
2117 pthread_mutex_destroy(&spool_mutex);
2119 if (attached_dcrs) {
2120 delete attached_dcrs;
2121 attached_dcrs = NULL;
2130 * This routine initializes the device wait timers
2132 void init_device_wait_timers(DCR *dcr)
2134 DEVICE *dev = dcr->dev;
2135 JCR *jcr = dcr->jcr;
2137 /* ******FIXME******* put these on config variables */
2138 dev->min_wait = 60 * 60;
2139 dev->max_wait = 24 * 60 * 60;
2140 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2141 dev->wait_sec = dev->min_wait;
2142 dev->rem_wait_sec = dev->wait_sec;
2145 dev->BadVolName[0] = 0;
2147 jcr->min_wait = 60 * 60;
2148 jcr->max_wait = 24 * 60 * 60;
2149 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2150 jcr->wait_sec = jcr->min_wait;
2151 jcr->rem_wait_sec = jcr->wait_sec;
2156 void init_jcr_device_wait_timers(JCR *jcr)
2158 /* ******FIXME******* put these on config variables */
2159 jcr->min_wait = 60 * 60;
2160 jcr->max_wait = 24 * 60 * 60;
2161 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
2162 jcr->wait_sec = jcr->min_wait;
2163 jcr->rem_wait_sec = jcr->wait_sec;
2169 * The dev timers are used for waiting on a particular device
2171 * Returns: true if time doubled
2172 * false if max time expired
2174 bool double_dev_wait_time(DEVICE *dev)
2176 dev->wait_sec *= 2; /* double wait time */
2177 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
2178 dev->wait_sec = dev->max_wait;
2181 dev->rem_wait_sec = dev->wait_sec;
2182 if (dev->num_wait >= dev->max_num_wait) {
2189 void set_os_device_parameters(DEVICE *dev)
2191 #if defined(HAVE_LINUX_OS) || defined(HAVE_WIN32)
2193 if (dev->min_block_size == dev->max_block_size &&
2194 dev->min_block_size == 0) { /* variable block mode */
2195 mt_com.mt_op = MTSETBLK;
2196 mt_com.mt_count = 0;
2197 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2198 dev->clrerror(MTSETBLK);
2200 mt_com.mt_op = MTSETDRVBUFFER;
2201 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
2202 if (!dev->has_cap(CAP_TWOEOF)) {
2203 mt_com.mt_count |= MT_ST_TWO_FM;
2205 if (dev->has_cap(CAP_EOM)) {
2206 mt_com.mt_count |= MT_ST_FAST_MTEOM;
2208 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2209 dev->clrerror(MTSETBLK);
2215 #ifdef HAVE_NETBSD_OS
2217 if (dev->min_block_size == dev->max_block_size &&
2218 dev->min_block_size == 0) { /* variable block mode */
2219 mt_com.mt_op = MTSETBSIZ;
2220 mt_com.mt_count = 0;
2221 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2222 dev->clrerror(MTSETBSIZ);
2224 /* Get notified at logical end of tape */
2225 mt_com.mt_op = MTEWARN;
2226 mt_com.mt_count = 1;
2227 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2228 dev->clrerror(MTEWARN);
2234 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
2236 if (dev->min_block_size == dev->max_block_size &&
2237 dev->min_block_size == 0) { /* variable block mode */
2238 mt_com.mt_op = MTSETBSIZ;
2239 mt_com.mt_count = 0;
2240 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2241 dev->clrerror(MTSETBSIZ);
2249 if (dev->min_block_size == dev->max_block_size &&
2250 dev->min_block_size == 0) { /* variable block mode */
2251 mt_com.mt_op = MTSRSZ;
2252 mt_com.mt_count = 0;
2253 if (tape_ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
2254 dev->clrerror(MTSRSZ);
2261 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
2263 return dev->has_cap(CAP_MTIOCGET) &&
2264 tape_ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
2265 mt_stat->mt_fileno >= 0;
2268 static char *modes[] = {
2269 "CREATE_READ_WRITE",
2276 static char *mode_to_str(int mode)
2278 static char buf[100];
2279 if (mode < 1 || mode > 4) {
2280 bsnprintf(buf, sizeof(buf), "BAD mode=%d", mode);
2283 return modes[mode-1];