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 my 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 *)get_memory(sizeof(DEVICE));
133 memset(dev, 0, sizeof(DEVICE));
134 dev->state = ST_MALLOC;
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 dev->capabilities = device->cap_bits;
143 dev->min_block_size = device->min_block_size;
144 dev->max_block_size = device->max_block_size;
145 dev->max_volume_size = device->max_volume_size;
146 dev->max_file_size = device->max_file_size;
147 dev->volume_capacity = device->volume_capacity;
148 dev->max_rewind_wait = device->max_rewind_wait;
149 dev->max_open_wait = device->max_open_wait;
150 dev->max_open_vols = device->max_open_vols;
151 dev->vol_poll_interval = device->vol_poll_interval;
152 dev->max_spool_size = device->max_spool_size;
153 dev->drive_index = device->drive_index;
154 dev->autoselect = device->autoselect;
155 dev->dev_type = device->dev_type;
156 if (dev->is_tape()) { /* No parts on tapes */
157 dev->max_part_size = 0;
159 dev->max_part_size = device->max_part_size;
162 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
163 dev->vol_poll_interval = 60;
165 dev->device = device;
167 if (dev->is_fifo()) {
168 dev->capabilities |= CAP_STREAM; /* set stream device */
171 /* If the device requires mount :
172 * - Check that the mount point is available
173 * - Check that (un)mount commands are defined
175 if ((dev->is_file() || dev->is_dvd()) && dev->requires_mount()) {
176 if (!device->mount_point || stat(device->mount_point, &statp) < 0) {
178 dev->dev_errno = errno;
179 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat mount point %s: ERR=%s\n"),
180 device->mount_point, be.strerror());
185 if (!device->mount_command || !device->unmount_command) {
186 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
188 if (!device->write_part_command) {
189 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
193 if (dev->max_block_size > 1000000) {
194 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
195 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
196 dev->max_block_size = 0;
198 if (dev->max_block_size % TAPE_BSIZE != 0) {
199 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
200 dev->max_block_size, dev->print_name());
203 dev->errmsg = get_pool_memory(PM_EMSG);
206 if ((errstat = pthread_mutex_init(&dev->mutex, NULL)) != 0) {
208 dev->dev_errno = errstat;
209 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
210 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
212 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
214 dev->dev_errno = errstat;
215 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
216 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
218 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
220 dev->dev_errno = errstat;
221 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
222 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
224 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
226 dev->dev_errno = errstat;
227 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
228 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
230 if ((errstat = rwl_init(&dev->lock)) != 0) {
232 dev->dev_errno = errstat;
233 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
234 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
238 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
239 Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
245 * Open the device with the operating system and
246 * initialize buffer pointers.
248 * Returns: -1 on error
251 * Note, for a tape, the VolName is the name we give to the
252 * volume (not really used here), but for a file, the
253 * VolName represents the name of the file to be created/opened.
254 * In the case of a file, the full name is the device name
255 * (archive_name) with the VolName concatenated.
258 DEVICE::open(DCR *dcr, int omode)
262 if (openmode == omode) {
265 ::close(fd); /* use system close so correct mode will be used on open */
267 Dmsg0(100, "Close fd for mode change.\n");
268 preserve = state & (ST_LABEL|ST_APPEND|ST_READ);
272 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
275 Dmsg4(29, "open dev: tape=%d dev_name=%s vol=%s mode=%s\n", is_tape(),
276 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
277 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
278 label_type = B_BACULA_LABEL;
279 if (is_tape() || is_fifo()) {
280 open_tape_device(dcr, omode);
281 } else if (is_dvd()) {
282 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
283 open_dvd_device(dcr, omode);
285 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
286 open_file_device(omode);
288 state |= preserve; /* reset any important state info */
292 void DEVICE::set_mode(int new_mode)
295 case CREATE_READ_WRITE:
296 mode = O_CREAT | O_RDWR | O_BINARY;
298 case OPEN_READ_WRITE:
299 if (is_dvd() || is_file()) {
300 mode = O_CREAT | O_RDWR | O_BINARY;
302 mode = O_RDWR | O_BINARY;
306 mode = O_RDONLY | O_BINARY;
308 case OPEN_WRITE_ONLY:
309 mode = O_WRONLY | O_BINARY;
312 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
318 void DEVICE::open_tape_device(DCR *dcr, int omode)
322 int nonblocking = O_NONBLOCK;
323 Dmsg0(29, "open dev: device is tape\n");
325 if (is_autochanger()) {
326 get_autochanger_loaded_slot(dcr);
330 timeout = max_open_wait;
332 if (is_fifo() && timeout) {
334 tid = start_thread_timer(pthread_self(), timeout);
336 /* If busy retry each second for max_open_wait seconds */
337 Dmsg3(100, "Try open %s mode=%s nonblocking=%d\n", print_name(),
338 mode_to_str(omode), nonblocking);
339 /* Use system open() */
340 while ((fd = ::open(dev_name, mode+nonblocking)) < 0) {
343 Dmsg5(050, "Open omode=%d mode=%x nonblock=%d error errno=%d ERR=%s\n",
344 omode, mode, nonblocking, errno, be.strerror());
345 if (dev_errno == EINTR || dev_errno == EAGAIN) {
346 Dmsg0(100, "Continue open\n");
349 /* Busy wait for specified time (default = 5 mins) */
350 if (dev_errno == EBUSY && timeout-- > 0) {
351 Dmsg2(100, "Device %s busy. ERR=%s\n", print_name(), be.strerror());
355 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
356 print_name(), be.strerror(dev_errno));
357 /* Stop any open timer we set */
359 stop_thread_timer(tid);
362 Jmsg0(dcr->jcr, M_FATAL, 0, errmsg);
367 openmode = omode; /* save open mode */
369 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
371 update_pos_dev(this); /* update position */
372 set_os_device_parameters(this); /* do system dependent stuff */
377 /* Stop any open() timer we started */
379 stop_thread_timer(tid);
382 Dmsg1(29, "open dev: tape %d opened\n", fd);
385 void DEVICE::set_blocking()
388 /* Try to reset blocking */
390 if ((oflags = fcntl(fd, F_GETFL, 0)) < 0 ||
391 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK) < 0) {
393 ::close(fd); /* use system close() */
394 fd = ::open(dev_name, mode);
395 Dmsg2(100, "fcntl error. ERR=%s. Close-reopen fd=%d\n", be.strerror(), fd);
398 oflags = fcntl(fd, F_GETFL, 0);
399 if (oflags > 0 && (oflags & O_NONBLOCK)) {
400 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK);
407 void DEVICE::open_file_device(int omode)
409 POOL_MEM archive_name(PM_FNAME);
412 * Handle opening of File Archive (not a tape)
415 pm_strcpy(archive_name, dev_name);
417 * If this is a virtual autochanger (i.e. changer_res != NULL)
418 * we simply use the deviced name, assuming it has been
419 * appropriately setup by the "autochanger".
421 if (!device->changer_res) {
422 if (VolCatInfo.VolCatName[0] == 0) {
423 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
429 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
430 pm_strcat(archive_name, "/");
432 pm_strcat(archive_name, VolCatInfo.VolCatName);
436 Dmsg3(29, "open dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
437 archive_name.c_str(), mode_to_str(omode));
439 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
442 /* If creating file, give 0640 permissions */
443 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
444 archive_name.c_str(), mode);
445 /* Use system open() */
446 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
449 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
451 Dmsg1(29, "open failed: %s", errmsg);
452 Emsg0(M_FATAL, 0, errmsg);
455 update_pos_dev(this); /* update position */
457 Dmsg5(29, "open dev: %s fd=%d opened, part=%d/%d, part_size=%u\n",
458 is_dvd()?"DVD":"disk", fd, part, num_parts,
463 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName (NB:??? I think it's VolCatInfo.VolCatName that is right)
464 * has the desired Volume name, but there is NO assurance that
465 * any other field of VolCatInfo is correct.
467 void DEVICE::open_dvd_device(DCR *dcr, int omode)
469 POOL_MEM archive_name(PM_FNAME);
470 struct stat filestat;
473 * Handle opening of DVD Volume
475 Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
476 archive_name.c_str(), mode_to_str(omode));
478 if (VolCatInfo.VolCatName[0] == 0) {
479 Dmsg1(10, "Could not open file device %s. No Volume name given.\n",
481 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
492 Dmsg2(99, "open_dvd_device: num_parts=%d, VolCatInfo.VolCatParts=%d\n",
493 dcr->dev->num_parts, dcr->VolCatInfo.VolCatParts);
494 if (dcr->dev->num_parts < dcr->VolCatInfo.VolCatParts) {
495 Dmsg2(99, "open_dvd_device: num_parts updated to %d (was %d)\n",
496 dcr->VolCatInfo.VolCatParts, dcr->dev->num_parts);
497 dcr->dev->num_parts = dcr->VolCatInfo.VolCatParts;
500 if (mount_dev(this, 1)) {
501 if ((num_parts == 0) && (!truncating)) {
502 /* If we can mount the device, and we are not truncating the DVD, we usually want to abort. */
503 /* There is one exception, if there is only one 0-sized file on the DVD, with the right volume name,
504 * we continue (it's the method used by truncate_dvd_dev to truncate a volume). */
505 if (!check_can_write_on_non_blank_dvd(dcr)) {
506 Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
507 Emsg0(M_FATAL, 0, errmsg);
508 unmount_dev(this, 1); /* Unmount the device, so the operator can change it. */
515 /* We cannot mount the device */
516 if (num_parts == 0) {
517 /* Run free space, check there is a media. */
518 update_free_space_dev(this);
520 Dmsg1(29, "Could not mount device %s, this is not a problem (num_parts == 0), and have media.\n", print_name());
523 Mmsg(errmsg, _("There is no valid media in the device %s.\n"), print_name());
524 Emsg0(M_FATAL, 0, errmsg);
530 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
531 Emsg0(M_FATAL, 0, errmsg);
537 Dmsg6(29, "open dev: %s dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
538 is_dvd()?"DVD":"disk", archive_name.c_str(), mode_to_str(omode),
539 part, num_parts, dcr->VolCatInfo.VolCatParts);
541 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
544 * If we are not trying to access the last part, set mode to
545 * OPEN_READ_ONLY as writing would be an error.
547 if (part < num_parts) {
548 omode = OPEN_READ_ONLY;
549 make_mounted_dvd_filename(this, archive_name);
552 make_spooled_dvd_filename(this, archive_name);
556 /* If creating file, give 0640 permissions */
557 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
558 archive_name.c_str(), mode);
559 /* Use system open() */
560 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
562 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
564 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
565 Dmsg1(29, "open failed: %s", errmsg);
567 if ((omode == OPEN_READ_ONLY) && (part == num_parts)) {
568 /* If the last part (on spool), doesn't exists when reading, create it and read from it
569 * (it will report immediately an EOF):
570 * Sometimes it is better to finish with an EOF than with an error. */
571 set_mode(OPEN_READ_WRITE);
572 fd = ::open(archive_name.c_str(), mode, 0640);
573 set_mode(OPEN_READ_ONLY);
576 /* We don't need it. Only the last part is on spool */
577 /*if (omode == OPEN_READ_ONLY) {
578 make_spooled_dvd_filename(this, archive_name);
579 fd = ::open(archive_name.c_str(), mode, 0640); // try on spool
582 Dmsg1(100, "after open fd=%d\n", fd);
584 /* Get size of file */
585 if (fstat(fd, &filestat) < 0) {
588 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
590 Dmsg1(29, "open failed: %s", errmsg);
591 /* Use system close() */
595 part_size = filestat.st_size;
597 update_pos_dev(this); /* update position */
599 /* NB: It seems this code is wrong... part number is incremented in open_next_part, not here */
601 /* Check if just created Volume part */
602 /* if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
605 VolCatInfo.VolCatParts = num_parts;
607 if (part == 0) { // we must have opened the first part
618 * Returns: true on success
621 bool DEVICE::rewind(DCR *dcr)
627 Dmsg3(29, "rewind res=%d fd=%d %s\n", reserved_device, fd, print_name());
629 if (!is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
631 Mmsg1(errmsg, _("Bad call to rewind. Device %s not open\n"),
633 Emsg0(M_ABORT, 0, errmsg);
637 state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
638 block_num = file = 0;
642 mt_com.mt_op = MTREW;
644 /* If we get an I/O error on rewind, it is probably because
645 * the drive is actually busy. We loop for (about 5 minutes)
646 * retrying every 5 seconds.
648 for (i=max_rewind_wait; ; i -= 5) {
649 if (ioctl(fd, MTIOCTOP, (char *)&mt_com) < 0) {
651 clrerror_dev(this, MTREW);
652 if (i == max_rewind_wait) {
653 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
656 * This is a gross hack, because if the user has the
657 * device mounted (i.e. open), then uses mtx to load
658 * a tape, the current open file descriptor is invalid.
659 * So, we close the drive and re-open it.
662 int open_mode = openmode;
665 open(dcr, open_mode);
672 if (dev_errno == EIO && i > 0) {
673 Dmsg0(200, "Sleeping 5 seconds.\n");
677 Mmsg2(errmsg, _("Rewind error on %s. ERR=%s.\n"),
678 print_name(), be.strerror());
683 } else if (is_file() || is_dvd()) {
684 if (lseek_dev(this, (off_t)0, SEEK_SET) < 0) {
687 Mmsg2(errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
688 print_name(), be.strerror());
695 void DEVICE::block(int why)
698 block_device(this, why);
702 void DEVICE::unblock()
705 unblock_device(this);
709 const char *DEVICE::print_blocked() const
711 switch (dev_blocked) {
712 case BST_NOT_BLOCKED:
713 return "BST_NOT_BLOCKED";
715 return "BST_UNMOUNTED";
716 case BST_WAITING_FOR_SYSOP:
717 return "BST_WAITING_FOR_SYSOP";
718 case BST_DOING_ACQUIRE:
719 return "BST_DOING_ACQUIRE";
720 case BST_WRITING_LABEL:
721 return "BST_WRITING_LABEL";
722 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
723 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
727 return _("unknown blocked code");
732 * Called to indicate that we have just read an
733 * EOF from the device.
735 void DEVICE::set_ateof()
747 * Called to indicate we are now at the end of the tape, and
748 * writing is not possible.
750 void DEVICE::set_ateot()
752 /* Make tape effectively read-only */
753 state |= (ST_EOF|ST_EOT|ST_WEOT);
758 * Position device to end of medium (end of data)
759 * Returns: true on succes
766 struct mtget mt_stat;
771 dev->dev_errno = EBADF;
772 Mmsg1(dev->errmsg, _("Bad call to eod_dev. Device %s not open\n"),
777 #if defined (__digital__) && defined (__unix__)
778 return dev->fsf(dev->VolCatInfo.VolCatFiles);
781 Dmsg0(29, "eod_dev\n");
785 dev->state &= ~(ST_EOF); /* remove EOF flags */
786 dev->block_num = dev->file = 0;
789 if (dev->is_fifo() || dev->is_prog()) {
792 if (!dev->is_tape()) {
793 pos = lseek_dev(dev, (off_t)0, SEEK_END);
794 // Dmsg1(100, "====== Seek to %lld\n", pos);
797 dev->state |= ST_EOT;
800 dev->dev_errno = errno;
802 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
803 dev->print_name(), be.strerror());
807 if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
808 Dmsg0(100,"Using FAST FSF for EOM\n");
809 /* If unknown position, rewind */
810 if (!dev_get_os_pos(dev, &mt_stat)) {
811 if (!dev->rewind(NULL)) {
815 mt_com.mt_op = MTFSF;
817 * ***FIXME*** fix code to handle case that INT16_MAX is
820 mt_com.mt_count = INT16_MAX; /* use big positive number */
821 if (mt_com.mt_count < 0) {
822 mt_com.mt_count = INT16_MAX; /* brain damaged system */
826 if (dev_cap(dev, CAP_MTIOCGET) && (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM))) {
827 if (dev_cap(dev, CAP_EOM)) {
828 Dmsg0(100,"Using EOM for EOM\n");
829 mt_com.mt_op = MTEOM;
833 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
835 clrerror_dev(dev, mt_com.mt_op);
836 Dmsg1(50, "ioctl error: %s\n", be.strerror());
838 Mmsg2(dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
839 dev->print_name(), be.strerror());
843 if (!dev_get_os_pos(dev, &mt_stat)) {
845 clrerror_dev(dev, -1);
846 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
847 dev->print_name(), be.strerror());
850 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
852 dev->file = mt_stat.mt_fileno;
858 * Rewind then use FSF until EOT reached
860 if (!dev->rewind(NULL)) {
864 * Move file by file to the end of the tape
867 for (file_num=dev->file; !dev->at_eot(); file_num++) {
868 Dmsg0(200, "eod_dev: doing fsf 1\n");
870 Dmsg0(200, "fsf error.\n");
874 * Avoid infinite loop by ensuring we advance.
876 if (file_num == (int)dev->file) {
877 struct mtget mt_stat;
878 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
880 if (dev_get_os_pos(dev, &mt_stat)) {
881 Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
882 dev->file = mt_stat.mt_fileno;
889 * Some drivers leave us after second EOF when doing
890 * MTEOM, so we must backup so that appending overwrites
893 if (dev_cap(dev, CAP_BSFATEOM)) {
894 struct mtget mt_stat;
895 /* Backup over EOF */
896 ok = bsf_dev(dev, 1);
897 /* If BSF worked and fileno is known (not -1), set file */
898 if (dev_get_os_pos(dev, &mt_stat)) {
899 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
900 dev->file = mt_stat.mt_fileno;
902 dev->file++; /* wing it -- not correct on all OSes */
905 update_pos_dev(dev); /* update position */
907 Dmsg1(200, "EOD dev->file=%d\n", dev->file);
912 * Set the position of the device -- only for files and DVD
913 * For other devices, there is no generic way to do it.
914 * Returns: true on succes
917 bool update_pos_dev(DEVICE *dev)
923 dev->dev_errno = EBADF;
924 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
925 Emsg0(M_FATAL, 0, dev->errmsg);
929 /* Find out where we are */
930 if (dev->is_file()) {
933 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
936 dev->dev_errno = errno;
937 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
938 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
939 dev->print_name(), be.strerror());
942 dev->file_addr = pos;
950 * Return the status of the device. This was meant
951 * to be a generic routine. Unfortunately, it doesn't
952 * seem possible (at least I do not know how to do it
953 * currently), which means that for the moment, this
954 * routine has very little value.
958 uint32_t status_dev(DEVICE *dev)
960 struct mtget mt_stat;
963 if (dev->state & (ST_EOT | ST_WEOT)) {
967 if (dev->state & ST_EOF) {
971 if (dev->is_tape()) {
973 Pmsg0(-20,_(" Bacula status:"));
974 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
975 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
977 dev->dev_errno = errno;
978 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
979 dev->print_name(), be.strerror());
982 Pmsg0(-20, _(" Device status:"));
984 #if defined(HAVE_LINUX_OS)
985 if (GMT_EOF(mt_stat.mt_gstat)) {
989 if (GMT_BOT(mt_stat.mt_gstat)) {
993 if (GMT_EOT(mt_stat.mt_gstat)) {
997 if (GMT_SM(mt_stat.mt_gstat)) {
1001 if (GMT_EOD(mt_stat.mt_gstat)) {
1005 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1006 stat |= BMT_WR_PROT;
1007 Pmsg0(-20, " WR_PROT");
1009 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1011 Pmsg0(-20, " ONLINE");
1013 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1014 stat |= BMT_DR_OPEN;
1015 Pmsg0(-20, " DR_OPEN");
1017 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1018 stat |= BMT_IM_REP_EN;
1019 Pmsg0(-20, " IM_REP_EN");
1021 #endif /* !SunOS && !OSF */
1022 if (dev_cap(dev, CAP_MTIOCGET)) {
1023 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1025 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1028 stat |= BMT_ONLINE | BMT_BOT;
1035 * Load medium in device
1036 * Returns: true on success
1039 bool load_dev(DEVICE *dev)
1046 dev->dev_errno = EBADF;
1047 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1048 Emsg0(M_FATAL, 0, dev->errmsg);
1051 if (!(dev->is_tape())) {
1055 Dmsg0(200, "stored: MTLOAD command not available\n");
1057 dev->dev_errno = ENOTTY; /* function not available */
1058 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1059 dev->print_name(), be.strerror());
1063 dev->block_num = dev->file = 0;
1066 mt_com.mt_op = MTLOAD;
1067 mt_com.mt_count = 1;
1068 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1070 dev->dev_errno = errno;
1071 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1072 dev->print_name(), be.strerror());
1080 * Rewind device and put it offline
1081 * Returns: true on success
1084 bool offline_dev(DEVICE *dev)
1088 if (!dev || dev->fd < 0 || !dev->is_tape()) {
1089 return true; /* device not open */
1092 dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1093 dev->block_num = dev->file = 0;
1098 mt_com.mt_op = MTUNLOCK;
1099 mt_com.mt_count = 1;
1100 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1102 mt_com.mt_op = MTOFFL;
1103 mt_com.mt_count = 1;
1104 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1106 dev->dev_errno = errno;
1107 Mmsg2(dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1108 dev->print_name(), be.strerror());
1111 Dmsg1(100, "Offlined device %s\n", dev->print_name());
1115 bool offline_or_rewind_dev(DEVICE *dev)
1120 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1121 return offline_dev(dev);
1124 * Note, this rewind probably should not be here (it wasn't
1125 * in prior versions of Bacula), but on FreeBSD, this is
1126 * needed in the case the tape was "frozen" due to an error
1127 * such as backspacing after writing and EOF. If it is not
1128 * done, all future references to the drive get and I/O error.
1130 clrerror_dev(dev, MTREW);
1131 return dev->rewind(NULL);
1136 * Foward space a file
1137 * Returns: true on success
1140 bool DEVICE::fsf(int num)
1142 struct mtget mt_stat;
1148 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1149 Emsg0(M_FATAL, 0, errmsg);
1158 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1162 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1165 Dmsg0(100, "fsf\n");
1168 * If Fast forward space file is set, then we
1169 * use MTFSF to forward space and MTIOCGET
1170 * to get the file position. We assume that
1171 * the SCSI driver will ensure that we do not
1172 * forward space past the end of the medium.
1174 if (dev_cap(this, CAP_FSF) && dev_cap(this, CAP_MTIOCGET) && dev_cap(this, CAP_FASTFSF)) {
1175 mt_com.mt_op = MTFSF;
1176 mt_com.mt_count = num;
1177 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1178 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1181 Dmsg0(200, "Set ST_EOT\n");
1182 clrerror_dev(this, MTFSF);
1183 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1184 print_name(), be.strerror());
1185 Dmsg1(200, "%s", errmsg);
1188 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1190 file = mt_stat.mt_fileno;
1194 * Here if CAP_FSF is set, and virtually all drives
1195 * these days support it, we read a record, then forward
1196 * space one file. Using this procedure, which is slow,
1197 * is the only way we can be sure that we don't read
1198 * two consecutive EOF marks, which means End of Data.
1200 } else if (dev_cap(this, CAP_FSF)) {
1203 Dmsg0(200, "FSF has cap_fsf\n");
1204 if (max_block_size == 0) {
1205 rbuf_len = DEFAULT_BLOCK_SIZE;
1207 rbuf_len = max_block_size;
1209 rbuf = get_memory(rbuf_len);
1210 mt_com.mt_op = MTFSF;
1211 mt_com.mt_count = 1;
1212 while (num-- && !at_eot()) {
1213 Dmsg0(100, "Doing read before fsf\n");
1214 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1215 if (errno == ENOMEM) { /* tape record exceeds buf len */
1216 stat = rbuf_len; /* This is OK */
1218 * On IBM drives, they return ENOSPC at EOM
1219 * instead of EOF status
1221 } else if (at_eof() && errno == ENOSPC) {
1226 clrerror_dev(this, -1);
1227 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1229 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1230 print_name(), be.strerror());
1231 Dmsg1(100, "%s", errmsg);
1235 if (stat == 0) { /* EOF */
1236 update_pos_dev(this);
1237 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1238 /* Two reads of zero means end of tape */
1241 Dmsg0(100, "Set ST_EOT\n");
1247 } else { /* Got data */
1252 Dmsg0(100, "Doing MTFSF\n");
1253 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1254 if (stat < 0) { /* error => EOT */
1257 Dmsg0(100, "Set ST_EOT\n");
1258 clrerror_dev(this, MTFSF);
1259 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1260 print_name(), be.strerror());
1261 Dmsg0(100, "Got < 0 for MTFSF\n");
1262 Dmsg1(100, "%s", errmsg);
1270 * No FSF, so use FSR to simulate it
1273 Dmsg0(200, "Doing FSR for FSF\n");
1274 while (num-- && !at_eot()) {
1275 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1279 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1285 update_pos_dev(this);
1286 Dmsg1(200, "Return %d from FSF\n", stat);
1288 Dmsg0(200, "ST_EOF set on exit FSF\n");
1290 Dmsg0(200, "ST_EOT set on exit FSF\n");
1291 Dmsg1(200, "Return from FSF file=%d\n", file);
1296 * Backward space a file
1297 * Returns: false on failure
1301 bsf_dev(DEVICE *dev, int num)
1307 dev->dev_errno = EBADF;
1308 Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Device not open\n"));
1309 Emsg0(M_FATAL, 0, dev->errmsg);
1313 if (!dev->is_tape()) {
1314 Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1318 Dmsg0(29, "bsf_dev\n");
1319 dev->state &= ~(ST_EOT|ST_EOF);
1323 mt_com.mt_op = MTBSF;
1324 mt_com.mt_count = num;
1325 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1328 clrerror_dev(dev, MTBSF);
1329 Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1330 dev->print_name(), be.strerror());
1332 update_pos_dev(dev);
1338 * Foward space num records
1339 * Returns: false on failure
1342 bool DEVICE::fsr(int num)
1349 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1350 Emsg0(M_FATAL, 0, errmsg);
1357 if (!dev_cap(this, CAP_FSR)) {
1358 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1362 Dmsg1(29, "fsr %d\n", num);
1363 mt_com.mt_op = MTFSR;
1364 mt_com.mt_count = num;
1365 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1371 struct mtget mt_stat;
1372 clrerror_dev(this, MTFSR);
1373 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1374 if (dev_get_os_pos(this, &mt_stat)) {
1375 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1376 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1377 file = mt_stat.mt_fileno;
1378 block_num = mt_stat.mt_blkno;
1386 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1387 num, print_name(), be.strerror());
1389 update_pos_dev(this);
1394 * Backward space a record
1395 * Returns: false on failure
1399 bsr_dev(DEVICE *dev, int num)
1405 dev->dev_errno = EBADF;
1406 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1407 Emsg0(M_FATAL, 0, dev->errmsg);
1411 if (!dev->is_tape()) {
1415 if (!dev_cap(dev, CAP_BSR)) {
1416 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1420 Dmsg0(29, "bsr_dev\n");
1421 dev->block_num -= num;
1422 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1423 mt_com.mt_op = MTBSR;
1424 mt_com.mt_count = num;
1425 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1428 clrerror_dev(dev, MTBSR);
1429 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1430 dev->print_name(), be.strerror());
1432 update_pos_dev(dev);
1437 * Reposition the device to file, block
1438 * Returns: false on failure
1442 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1445 dev->dev_errno = EBADF;
1446 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1447 Emsg0(M_FATAL, 0, dev->errmsg);
1451 if (!dev->is_tape()) {
1452 off_t pos = (((off_t)file)<<32) + (off_t)block;
1453 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1454 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1456 dev->dev_errno = errno;
1457 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1458 dev->print_name(), be.strerror());
1462 dev->block_num = block;
1463 dev->file_addr = pos;
1466 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1467 dev->file, dev->block_num, file, block);
1468 if (file < dev->file) {
1469 Dmsg0(100, "Rewind\n");
1470 if (!dev->rewind(NULL)) {
1474 if (file > dev->file) {
1475 Dmsg1(100, "fsf %d\n", file-dev->file);
1476 if (!dev->fsf(file-dev->file)) {
1477 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1480 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1482 if (block < dev->block_num) {
1483 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1484 Dmsg0(100, "bsf_dev 1\n");
1486 Dmsg0(100, "fsf_dev 1\n");
1488 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1490 if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1491 /* Ignore errors as Bacula can read to the correct block */
1492 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1493 return dev->fsr(block-dev->block_num);
1501 * Write an end of file on the device
1502 * Returns: 0 on success
1503 * non-zero on failure
1506 weof_dev(DEVICE *dev, int num)
1510 Dmsg0(29, "weof_dev\n");
1513 dev->dev_errno = EBADF;
1514 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1515 Emsg0(M_FATAL, 0, dev->errmsg);
1520 if (!dev->is_tape()) {
1523 if (!dev->can_append()) {
1524 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1525 Emsg0(M_FATAL, 0, dev->errmsg);
1529 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1530 mt_com.mt_op = MTWEOF;
1531 mt_com.mt_count = num;
1532 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1539 clrerror_dev(dev, MTWEOF);
1541 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1542 dev->print_name(), be.strerror());
1549 * Return string message with last error in English
1550 * Be careful not to call this routine from within dev.c
1551 * while editing an Mmsg() or you will end up in a recursive
1552 * loop creating a Segmentation Violation.
1555 strerror_dev(DEVICE *dev)
1562 * If implemented in system, clear the tape
1566 clrerror_dev(DEVICE *dev, int func)
1568 const char *msg = NULL;
1569 struct mtget mt_stat;
1572 dev->dev_errno = errno; /* save errno */
1574 dev->VolCatInfo.VolCatErrors++;
1577 if (!dev->is_tape()) {
1580 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1583 Emsg0(M_ABORT, 0, _("Got ENOTTY on read/write!\n"));
1587 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1592 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1597 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1601 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1605 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1609 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1630 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1635 dev->dev_errno = ENOSYS;
1636 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1637 Emsg0(M_ERROR, 0, dev->errmsg);
1640 /* On some systems such as NetBSD, this clears all errors */
1641 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1643 /* Found on Linux */
1647 mt_com.mt_op = MTIOCLRERR;
1648 mt_com.mt_count = 1;
1649 /* Clear any error condition on the tape */
1650 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1651 Dmsg0(200, "Did MTIOCLRERR\n");
1655 /* Typically on FreeBSD */
1658 /* Read and clear SCSI error status */
1659 union mterrstat mt_errstat;
1660 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1661 strerror(dev->dev_errno));
1662 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1666 /* Clear Subsystem Exception OSF1 */
1670 mt_com.mt_op = MTCSE;
1671 mt_com.mt_count = 1;
1672 /* Clear any error condition on the tape */
1673 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1674 Dmsg0(200, "Did MTCSE\n");
1680 * Flush buffer contents
1683 int flush_dev(DEVICE *dev)
1688 static void do_close(DEVICE *dev)
1691 Dmsg1(100, "really close_dev %s\n", dev->print_name());
1696 if (!unmount_dev(dev, 1)) {
1697 Dmsg1(0, "Cannot unmount device %s.\n", dev->print_name());
1700 /* Remove the last part file if it is empty */
1701 if (dev->num_parts > 0) {
1703 POOL_MEM archive_name(PM_FNAME);
1704 dev->part = dev->num_parts;
1705 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", dev->VolCatInfo.VolCatName);
1706 make_spooled_dvd_filename(dev, archive_name);
1707 /* Check that the part file is empty */
1708 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1709 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1710 unlink(archive_name.c_str());
1714 /* Clean up device packet so it can be reused */
1715 dev->clear_opened();
1716 dev->state &= ~(ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1717 dev->label_type = B_BACULA_LABEL;
1718 dev->file = dev->block_num = 0;
1724 dev->part_start = 0;
1725 dev->EndFile = dev->EndBlock = 0;
1727 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1728 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1730 stop_thread_timer(dev->tid);
1739 void DEVICE::close()
1745 bool truncate_dev(DCR *dcr) /* We need the DCR for DVD-writing */
1747 DEVICE *dev = dcr->dev;
1749 Dmsg1(100, "truncate_dev %s\n", dev->print_name());
1750 if (dev->is_tape()) {
1751 return true; /* we don't really truncate tapes */
1752 /* maybe we should rewind and write and eof ???? */
1755 if (dev->is_dvd()) {
1756 return truncate_dvd_dev(dcr);
1759 if (ftruncate(dev->fd, 0) != 0) {
1761 Mmsg2(dev->errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1762 dev->print_name(), be.strerror());
1768 /* Return the resource name for the device */
1769 const char *DEVICE::name() const
1771 return device->hdr.name;
1775 dev_vol_name(DEVICE *dev)
1777 return dev->VolCatInfo.VolCatName;
1780 uint32_t dev_block(DEVICE *dev)
1782 update_pos_dev(dev);
1783 return dev->block_num;
1786 uint32_t dev_file(DEVICE *dev)
1788 update_pos_dev(dev);
1793 * Free memory allocated for the device
1796 term_dev(DEVICE *dev)
1799 dev->dev_errno = EBADF;
1800 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1801 Emsg0(M_FATAL, 0, dev->errmsg);
1804 Dmsg1(29, "term_dev: %s\n", dev->print_name());
1806 if (dev->dev_name) {
1807 free_memory(dev->dev_name);
1808 dev->dev_name = NULL;
1810 if (dev->prt_name) {
1811 free_memory(dev->prt_name);
1812 dev->prt_name = NULL;
1815 free_pool_memory(dev->errmsg);
1818 pthread_mutex_destroy(&dev->mutex);
1819 pthread_cond_destroy(&dev->wait);
1820 pthread_cond_destroy(&dev->wait_next_vol);
1821 pthread_mutex_destroy(&dev->spool_mutex);
1822 rwl_destroy(&dev->lock);
1823 if (dev->attached_dcrs) {
1824 delete dev->attached_dcrs;
1825 dev->attached_dcrs = NULL;
1827 if (dev->state & ST_MALLOC) {
1828 free_pool_memory((POOLMEM *)dev);
1833 * This routine initializes the device wait timers
1835 void init_device_wait_timers(DCR *dcr)
1837 DEVICE *dev = dcr->dev;
1838 JCR *jcr = dcr->jcr;
1840 /* ******FIXME******* put these on config variables */
1841 dev->min_wait = 60 * 60;
1842 dev->max_wait = 24 * 60 * 60;
1843 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1844 dev->wait_sec = dev->min_wait;
1845 dev->rem_wait_sec = dev->wait_sec;
1848 dev->BadVolName[0] = 0;
1850 jcr->min_wait = 60 * 60;
1851 jcr->max_wait = 24 * 60 * 60;
1852 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1853 jcr->wait_sec = jcr->min_wait;
1854 jcr->rem_wait_sec = jcr->wait_sec;
1859 void init_jcr_device_wait_timers(JCR *jcr)
1861 /* ******FIXME******* put these on config variables */
1862 jcr->min_wait = 60 * 60;
1863 jcr->max_wait = 24 * 60 * 60;
1864 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1865 jcr->wait_sec = jcr->min_wait;
1866 jcr->rem_wait_sec = jcr->wait_sec;
1872 * The dev timers are used for waiting on a particular device
1874 * Returns: true if time doubled
1875 * false if max time expired
1877 bool double_dev_wait_time(DEVICE *dev)
1879 dev->wait_sec *= 2; /* double wait time */
1880 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
1881 dev->wait_sec = dev->max_wait;
1884 dev->rem_wait_sec = dev->wait_sec;
1885 if (dev->num_wait >= dev->max_num_wait) {
1892 void set_os_device_parameters(DEVICE *dev)
1894 #ifdef HAVE_LINUX_OS
1896 if (dev->min_block_size == dev->max_block_size &&
1897 dev->min_block_size == 0) { /* variable block mode */
1898 mt_com.mt_op = MTSETBLK;
1899 mt_com.mt_count = 0;
1900 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1901 clrerror_dev(dev, MTSETBLK);
1903 mt_com.mt_op = MTSETDRVBUFFER;
1904 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
1905 if (!dev_cap(dev, CAP_TWOEOF)) {
1906 mt_com.mt_count |= MT_ST_TWO_FM;
1908 if (dev_cap(dev, CAP_EOM)) {
1909 mt_com.mt_count |= MT_ST_FAST_MTEOM;
1911 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1912 clrerror_dev(dev, MTSETBLK);
1918 #ifdef HAVE_NETBSD_OS
1920 if (dev->min_block_size == dev->max_block_size &&
1921 dev->min_block_size == 0) { /* variable block mode */
1922 mt_com.mt_op = MTSETBSIZ;
1923 mt_com.mt_count = 0;
1924 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1925 clrerror_dev(dev, MTSETBSIZ);
1927 /* Get notified at logical end of tape */
1928 mt_com.mt_op = MTEWARN;
1929 mt_com.mt_count = 1;
1930 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1931 clrerror_dev(dev, MTEWARN);
1937 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
1939 if (dev->min_block_size == dev->max_block_size &&
1940 dev->min_block_size == 0) { /* variable block mode */
1941 mt_com.mt_op = MTSETBSIZ;
1942 mt_com.mt_count = 0;
1943 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1944 clrerror_dev(dev, MTSETBSIZ);
1952 if (dev->min_block_size == dev->max_block_size &&
1953 dev->min_block_size == 0) { /* variable block mode */
1954 mt_com.mt_op = MTSRSZ;
1955 mt_com.mt_count = 0;
1956 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1957 clrerror_dev(dev, MTSRSZ);
1964 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
1966 return dev_cap(dev, CAP_MTIOCGET) &&
1967 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
1968 mt_stat->mt_fileno >= 0;
1971 static char *modes[] = {
1972 "CREATE_READ_WRITE",
1979 static char *mode_to_str(int mode)
1981 return modes[mode-1];