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-2005 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 /* Functions in dvd.c */
83 void update_free_space_dev(DEVICE* dev);
86 /* Forward referenced functions */
87 void set_os_device_parameters(DEVICE *dev);
88 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat);
89 static char *mode_to_str(int mode);
92 * Allocate and initialize the DEVICE structure
93 * Note, if dev is non-NULL, it is already allocated,
94 * thus we neither allocate it nor free it. This allows
95 * the caller to put the packet in shared memory.
97 * Note, for a tape, the device->device_name is the device name
98 * (e.g. /dev/nst0), and for a file, the device name
99 * is the directory in which the file will be placed.
103 init_dev(JCR *jcr, DEVRES *device)
111 /* Check that device is available */
112 if (stat(device->device_name, &statp) < 0) {
114 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
115 device->device_name, be.strerror());
122 if (S_ISDIR(statp.st_mode)) {
124 } else if (S_ISCHR(statp.st_mode)) {
126 } else if (S_ISFIFO(statp.st_mode)) {
128 } else if (!(device->cap_bits & CAP_REQMOUNT)) {
129 Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
130 " or have RequiresMount=yes for DVD. st_mode=%x\n"),
131 device->device_name, statp.st_mode);
135 dev = (DEVICE *)get_memory(sizeof(DEVICE));
136 memset(dev, 0, sizeof(DEVICE));
137 dev->state = ST_MALLOC;
139 /* Copy user supplied device parameters from Resource */
140 dev->dev_name = get_memory(strlen(device->device_name)+1);
141 pm_strcpy(dev->dev_name, device->device_name);
142 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
143 /* We edit "Resource-name" (physical-name) */
144 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
145 dev->capabilities = device->cap_bits;
146 dev->min_block_size = device->min_block_size;
147 dev->max_block_size = device->max_block_size;
148 dev->max_volume_size = device->max_volume_size;
149 dev->max_file_size = device->max_file_size;
150 dev->volume_capacity = device->volume_capacity;
151 dev->max_rewind_wait = device->max_rewind_wait;
152 dev->max_open_wait = device->max_open_wait;
153 dev->max_open_vols = device->max_open_vols;
154 dev->vol_poll_interval = device->vol_poll_interval;
155 dev->max_spool_size = device->max_spool_size;
156 dev->drive_index = device->drive_index;
157 dev->autoselect = device->autoselect;
158 if (tape) { /* No parts on tapes */
159 dev->max_part_size = 0;
162 dev->max_part_size = device->max_part_size;
165 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
166 dev->vol_poll_interval = 60;
168 dev->device = device;
171 dev->state |= ST_TAPE;
173 dev->state |= ST_FIFO;
174 dev->capabilities |= CAP_STREAM; /* set stream device */
176 dev->state |= ST_FILE;
179 /* If the device requires mount :
180 * - Check that the mount point is available
181 * - Check that (un)mount commands are defined
183 if (dev->is_file() && dev->requires_mount()) {
184 if (stat(device->mount_point, &statp) < 0) {
186 dev->dev_errno = errno;
187 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat mount point %s: ERR=%s\n"),
188 device->mount_point, be.strerror());
191 if (!device->mount_command || !device->unmount_command) {
192 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
194 if (!device->write_part_command) {
195 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
197 dev->state |= ST_DVD;
200 if (dev->max_block_size > 1000000) {
201 Jmsg3(jcr, M_ERROR, 0, _("Block size %u on device %s is too large, using default %u\n"),
202 dev->max_block_size, dev->print_name(), DEFAULT_BLOCK_SIZE);
203 dev->max_block_size = 0;
205 if (dev->max_block_size % TAPE_BSIZE != 0) {
206 Jmsg2(jcr, M_WARNING, 0, _("Max block size %u not multiple of device %s block size.\n"),
207 dev->max_block_size, dev->print_name());
210 dev->errmsg = get_pool_memory(PM_EMSG);
213 if ((errstat = pthread_mutex_init(&dev->mutex, NULL)) != 0) {
215 dev->dev_errno = errstat;
216 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
217 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
219 if ((errstat = pthread_cond_init(&dev->wait, NULL)) != 0) {
221 dev->dev_errno = errstat;
222 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
223 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
225 if ((errstat = pthread_cond_init(&dev->wait_next_vol, NULL)) != 0) {
227 dev->dev_errno = errstat;
228 Mmsg1(dev->errmsg, _("Unable to init cond variable: ERR=%s\n"), be.strerror(errstat));
229 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
231 if ((errstat = pthread_mutex_init(&dev->spool_mutex, NULL)) != 0) {
233 dev->dev_errno = errstat;
234 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
235 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
237 if ((errstat = rwl_init(&dev->lock)) != 0) {
239 dev->dev_errno = errstat;
240 Mmsg1(dev->errmsg, _("Unable to init mutex: ERR=%s\n"), be.strerror(errstat));
241 Jmsg0(jcr, M_ERROR_TERM, 0, dev->errmsg);
245 dev->attached_dcrs = New(dlist(dcr, &dcr->dev_link));
246 Dmsg2(29, "init_dev: tape=%d dev_name=%s\n", dev->is_tape(), dev->dev_name);
252 * Open the device with the operating system and
253 * initialize buffer pointers.
255 * Returns: -1 on error
258 * Note, for a tape, the VolName is the name we give to the
259 * volume (not really used here), but for a file, the
260 * VolName represents the name of the file to be created/opened.
261 * In the case of a file, the full name is the device name
262 * (archive_name) with the VolName concatenated.
265 DEVICE::open(DCR *dcr, int omode)
268 if (openmode == omode) {
271 ::close(fd); /* use system close so correct mode will be used on open */
275 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
278 Dmsg4(29, "open dev: tape=%d dev_name=%s vol=%s mode=%s\n", is_tape(),
279 dev_name, VolCatInfo.VolCatName, mode_to_str(omode));
280 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
281 label_type = B_BACULA_LABEL;
282 if (is_tape() || is_fifo()) {
283 open_tape_device(omode);
284 } else if (is_dvd()) {
285 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
286 open_dvd_device(dcr, omode);
288 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
289 open_file_device(omode);
294 void DEVICE::set_mode(int new_mode)
297 case CREATE_READ_WRITE:
298 mode = O_CREAT | O_RDWR | O_BINARY;
300 case OPEN_READ_WRITE:
301 if (is_dvd() || is_file()) {
302 mode = O_CREAT | O_RDWR | O_BINARY;
304 mode = O_RDWR | O_BINARY;
308 mode = O_RDONLY | O_BINARY;
310 case OPEN_WRITE_ONLY:
311 mode = O_WRONLY | O_BINARY;
314 Emsg0(M_ABORT, 0, _("Illegal mode given to open dev.\n"));
318 void DEVICE::open_tape_device(int omode)
320 int nonblocking = 0;;
324 Dmsg0(29, "open dev: device is tape\n");
327 timeout = max_open_wait;
330 /* Set wait counters to zero for no wait */
331 timeout = ioerrcnt = 0;
332 /* Open drive in non-block mode */
333 nonblocking = O_NONBLOCK;
335 if (is_fifo() && timeout) {
337 tid = start_thread_timer(pthread_self(), timeout);
339 /* If busy retry each second for max_open_wait seconds */
341 Dmsg1(500, "Try open %s\n", print_name());
342 /* Use system open() */
343 while ((fd = ::open(dev_name, mode, MODE_RW+nonblocking)) < 0) {
345 Dmsg2(500, "Open error errno=%d ERR=%s\n", errno, be.strerror());
346 if (errno == EINTR || errno == EAGAIN) {
347 Dmsg0(500, "Continue open\n");
350 /* Busy wait for specified time (default = 5 mins) */
351 if (errno == EBUSY && timeout-- > 0) {
352 Dmsg2(100, "Device %s busy. ERR=%s\n", print_name(), be.strerror());
356 /* IO error (no volume) try 10 times every 6 seconds */
357 if (errno == EIO && ioerrcnt-- > 0) {
359 Dmsg0(500, "Continue open\n");
363 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
364 print_name(), be.strerror(dev_errno));
365 /* Stop any open timer we set */
367 stop_thread_timer(tid);
370 Emsg0(M_FATAL, 0, errmsg);
374 /* If opened in non-block mode, close it an open it normally */
377 ::close(fd); /* use system close() */
380 openmode = omode; /* save open mode */
381 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
385 update_pos_dev(this); /* update position */
386 set_os_device_parameters(this); /* do system dependent stuff */
387 Dmsg0(500, "Open OK\n");
389 /* Stop any open() timer we started */
391 stop_thread_timer(tid);
394 Dmsg1(29, "open dev: tape %d opened\n", fd);
400 void DEVICE::open_file_device(int omode)
402 POOL_MEM archive_name(PM_FNAME);
405 * Handle opening of File Archive (not a tape)
407 Dmsg3(29, "Enter: open_file_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
408 archive_name.c_str(), mode_to_str(omode));
410 if (VolCatInfo.VolCatName[0] == 0) {
411 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
417 pm_strcpy(archive_name, dev_name);
418 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
419 pm_strcat(archive_name, "/");
421 pm_strcat(archive_name, VolCatInfo.VolCatName);
423 Dmsg3(29, "open dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
424 archive_name.c_str(), mode_to_str(omode));
426 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
429 /* If creating file, give 0640 permissions */
430 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
431 archive_name.c_str(), mode);
432 /* Use system open() */
433 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
436 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
438 Dmsg1(29, "open failed: %s", errmsg);
439 Emsg0(M_FATAL, 0, errmsg);
444 update_pos_dev(this); /* update position */
446 Dmsg5(29, "open dev: %s fd=%d opened, part=%d/%d, part_size=%u\n",
447 is_dvd()?"DVD":"disk", fd, part, num_parts,
452 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName
453 * has the desired Volume name, but there is NO assurance that
454 * any other field of VolCatInfo is correct.
456 void DEVICE::open_dvd_device(DCR *dcr, int omode)
458 POOL_MEM archive_name(PM_FNAME);
459 struct stat filestat;
462 * Handle opening of DVD Volume
464 Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
465 archive_name.c_str(), mode_to_str(omode));
467 if (VolCatInfo.VolCatName[0] == 0) {
468 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
480 if (!mount_dev(this, 1)) {
481 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
482 Emsg0(M_FATAL, 0, errmsg);
487 Dmsg5(29, "open dev: %s dev=%s mode=%s part=%d npart=%d\n",
488 is_dvd()?"DVD":"disk", archive_name.c_str(), mode_to_str(omode),
491 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
494 * If we are not trying to access the last part, set mode to
495 * OPEN_READ_ONLY as writing would be an error.
497 if (part < num_parts) {
498 omode = OPEN_READ_ONLY;
503 * If we are opening it read-only, it is *probably* on the
504 * DVD, so try the DVD first, otherwise look in the spool dir.
506 if (omode == OPEN_READ_ONLY) {
507 make_mounted_dvd_filename(this, archive_name);
509 make_spooled_dvd_filename(this, archive_name);
512 /* If creating file, give 0640 permissions */
513 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
514 archive_name.c_str(), mode);
515 /* Use system open() */
516 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
519 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
521 Dmsg1(29, "open failed: %s", errmsg);
522 if (omode == OPEN_READ_ONLY) {
523 make_spooled_dvd_filename(this, archive_name);
524 /* Use system open() */
525 fd = ::open(archive_name.c_str(), mode, 0640); /* try on spool */
528 Dmsg1(100, "after open fd=%d\n", fd);
530 /* Get size of file */
531 if (fstat(fd, &filestat) < 0) {
534 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
536 Dmsg1(29, "open failed: %s", errmsg);
537 /* Use system close() */
541 part_size = filestat.st_size;
545 update_pos_dev(this); /* update position */
546 /* Check if just created Volume part */
547 if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
550 VolCatInfo.VolCatParts = num_parts;
552 if (part == 0) { /* we must have opened the first part */
558 Dmsg4(29, "open dev: DVD fd=%d opened, part=%d nump=%d, part_size=%u\n",
559 fd, part, num_parts, part_size);
560 if (is_open() && (omode != OPEN_READ_ONLY) &&
561 (free_space_errno == 0 || num_parts == part)) {
562 update_free_space_dev(this);
569 bool _rewind_dev(char *file, int line, DEVICE *dev)
571 Dmsg3(100, "rewind_dev fd=%d called from %s:%d\n", dev->fd, file, line);
572 return rewind_dev(dev);
578 * Returns: true on success
581 bool rewind_dev(DEVICE *dev)
586 Dmsg2(29, "rewind_dev fd=%d %s\n", dev->fd, dev->print_name());
588 dev->dev_errno = EBADF;
589 Mmsg1(dev->errmsg, _("Bad call to rewind_dev. Device %s not open\n"),
591 Emsg0(M_ABORT, 0, dev->errmsg);
594 dev->state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
595 dev->block_num = dev->file = 0;
598 if (dev->is_tape()) {
599 mt_com.mt_op = MTREW;
601 /* If we get an I/O error on rewind, it is probably because
602 * the drive is actually busy. We loop for (about 5 minutes)
603 * retrying every 5 seconds.
605 for (i=dev->max_rewind_wait; ; i -= 5) {
606 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
608 clrerror_dev(dev, MTREW);
609 if (i == dev->max_rewind_wait) {
610 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
612 if (dev->dev_errno == EIO && i > 0) {
613 Dmsg0(200, "Sleeping 5 seconds.\n");
617 Mmsg2(dev->errmsg, _("Rewind error on %s. ERR=%s.\n"),
618 dev->print_name(), be.strerror());
623 } else if (dev->is_file()) {
624 if (lseek_dev(dev, (off_t)0, SEEK_SET) < 0) {
626 dev->dev_errno = errno;
627 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
628 dev->print_name(), be.strerror());
635 void DEVICE::block(int why)
638 block_device(this, why);
642 void DEVICE::unblock()
645 unblock_device(this);
649 const char *DEVICE::print_blocked() const
651 switch (dev_blocked) {
652 case BST_NOT_BLOCKED:
653 return "BST_NOT_BLOCKED";
655 return "BST_UNMOUNTED";
656 case BST_WAITING_FOR_SYSOP:
657 return "BST_WAITING_FOR_SYSOP";
658 case BST_DOING_ACQUIRE:
659 return "BST_DOING_ACQUIRE";
660 case BST_WRITING_LABEL:
661 return "BST_WRITING_LABEL";
662 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
663 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
667 return "unknown blocked code";
672 * Called to indicate that we have just read an
673 * EOF from the device.
675 void DEVICE::set_ateof()
685 * Called to indicate we are now at the end of the tape, and
686 * writing is not possible.
688 void DEVICE::set_ateot()
690 /* Make tape effectively read-only */
691 state |= (ST_EOF|ST_EOT|ST_WEOT);
696 * Position device to end of medium (end of data)
697 * Returns: true on succes
704 struct mtget mt_stat;
709 dev->dev_errno = EBADF;
710 Mmsg1(dev->errmsg, _("Bad call to eod_dev. Device %s not open\n"),
715 #if defined (__digital__) && defined (__unix__)
716 return dev->fsf(dev->VolCatInfo.VolCatFiles);
719 Dmsg0(29, "eod_dev\n");
723 dev->state &= ~(ST_EOF); /* remove EOF flags */
724 dev->block_num = dev->file = 0;
727 if (dev->state & (ST_FIFO | ST_PROG)) {
730 if (!dev->is_tape()) {
731 pos = lseek_dev(dev, (off_t)0, SEEK_END);
732 // Dmsg1(100, "====== Seek to %lld\n", pos);
735 dev->state |= ST_EOT;
738 dev->dev_errno = errno;
740 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
741 dev->print_name(), be.strerror());
745 if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
746 Dmsg0(100,"Using FAST FSF for EOM\n");
747 /* If unknown position, rewind */
748 if (!dev_get_os_pos(dev, &mt_stat)) {
749 if (!rewind_dev(dev)) {
753 mt_com.mt_op = MTFSF;
755 * ***FIXME*** fix code to handle case that INT16_MAX is
758 mt_com.mt_count = INT16_MAX; /* use big positive number */
759 if (mt_com.mt_count < 0) {
760 mt_com.mt_count = INT16_MAX; /* brain damaged system */
764 if (dev_cap(dev, CAP_MTIOCGET) && (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM))) {
765 if (dev_cap(dev, CAP_EOM)) {
766 Dmsg0(100,"Using EOM for EOM\n");
767 mt_com.mt_op = MTEOM;
771 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
773 clrerror_dev(dev, mt_com.mt_op);
774 Dmsg1(50, "ioctl error: %s\n", be.strerror());
776 Mmsg2(dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
777 dev->print_name(), be.strerror());
781 if (!dev_get_os_pos(dev, &mt_stat)) {
783 clrerror_dev(dev, -1);
784 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
785 dev->print_name(), be.strerror());
788 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
790 dev->file = mt_stat.mt_fileno;
796 * Rewind then use FSF until EOT reached
798 if (!rewind_dev(dev)) {
802 * Move file by file to the end of the tape
805 for (file_num=dev->file; !dev->at_eot(); file_num++) {
806 Dmsg0(200, "eod_dev: doing fsf 1\n");
808 Dmsg0(200, "fsf error.\n");
812 * Avoid infinite loop. ***FIXME*** possibly add code
813 * to set EOD or to turn off CAP_FASTFSF if on.
815 if (file_num == (int)dev->file) {
816 struct mtget mt_stat;
817 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
818 if (dev_get_os_pos(dev, &mt_stat)) {
819 Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
821 dev->file = mt_stat.mt_fileno;
828 * Some drivers leave us after second EOF when doing
829 * MTEOM, so we must backup so that appending overwrites
832 if (dev_cap(dev, CAP_BSFATEOM)) {
833 struct mtget mt_stat;
834 /* Backup over EOF */
835 ok = bsf_dev(dev, 1);
836 /* If BSF worked and fileno is known (not -1), set file */
837 if (dev_get_os_pos(dev, &mt_stat)) {
838 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
839 dev->file = mt_stat.mt_fileno;
841 dev->file++; /* wing it -- not correct on all OSes */
844 update_pos_dev(dev); /* update position */
846 Dmsg1(200, "EOD dev->file=%d\n", dev->file);
851 * Set the position of the device -- only for files
852 * For other devices, there is no generic way to do it.
853 * Returns: true on succes
856 bool update_pos_dev(DEVICE *dev)
862 dev->dev_errno = EBADF;
863 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
864 Emsg0(M_FATAL, 0, dev->errmsg);
868 /* Find out where we are */
869 if (dev->is_file()) {
872 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
875 dev->dev_errno = errno;
876 Pmsg1(000, "Seek error: ERR=%s\n", be.strerror());
877 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
878 dev->print_name(), be.strerror());
881 dev->file_addr = pos;
889 * Return the status of the device. This was meant
890 * to be a generic routine. Unfortunately, it doesn't
891 * seem possible (at least I do not know how to do it
892 * currently), which means that for the moment, this
893 * routine has very little value.
897 uint32_t status_dev(DEVICE *dev)
899 struct mtget mt_stat;
902 if (dev->state & (ST_EOT | ST_WEOT)) {
906 if (dev->state & ST_EOF) {
910 if (dev->is_tape()) {
912 Pmsg0(-20," Bacula status:");
913 Pmsg2(-20," file=%d block=%d\n", dev->file, dev->block_num);
914 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
916 dev->dev_errno = errno;
917 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
918 dev->print_name(), be.strerror());
921 Pmsg0(-20, " Device status:");
923 #if defined(HAVE_LINUX_OS)
924 if (GMT_EOF(mt_stat.mt_gstat)) {
928 if (GMT_BOT(mt_stat.mt_gstat)) {
932 if (GMT_EOT(mt_stat.mt_gstat)) {
936 if (GMT_SM(mt_stat.mt_gstat)) {
940 if (GMT_EOD(mt_stat.mt_gstat)) {
944 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
946 Pmsg0(-20, " WR_PROT");
948 if (GMT_ONLINE(mt_stat.mt_gstat)) {
950 Pmsg0(-20, " ONLINE");
952 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
954 Pmsg0(-20, " DR_OPEN");
956 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
957 stat |= BMT_IM_REP_EN;
958 Pmsg0(-20, " IM_REP_EN");
960 #endif /* !SunOS && !OSF */
961 if (dev_cap(dev, CAP_MTIOCGET)) {
962 Pmsg2(-20, " file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
964 Pmsg2(-20, " file=%d block=%d\n", -1, -1);
967 stat |= BMT_ONLINE | BMT_BOT;
974 * Load medium in device
975 * Returns: true on success
978 bool load_dev(DEVICE *dev)
985 dev->dev_errno = EBADF;
986 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
987 Emsg0(M_FATAL, 0, dev->errmsg);
990 if (!(dev->is_tape())) {
994 Dmsg0(200, "stored: MTLOAD command not available\n");
996 dev->dev_errno = ENOTTY; /* function not available */
997 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
998 dev->print_name(), be.strerror());
1002 dev->block_num = dev->file = 0;
1005 mt_com.mt_op = MTLOAD;
1006 mt_com.mt_count = 1;
1007 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1009 dev->dev_errno = errno;
1010 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1011 dev->print_name(), be.strerror());
1019 * Rewind device and put it offline
1020 * Returns: true on success
1023 bool offline_dev(DEVICE *dev)
1028 dev->dev_errno = EBADF;
1029 Mmsg0(dev->errmsg, _("Bad call to offline_dev. Device not open\n"));
1030 Emsg0(M_FATAL, 0, dev->errmsg);
1033 if (!(dev->is_tape())) {
1037 dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1038 dev->block_num = dev->file = 0;
1043 mt_com.mt_op = MTUNLOCK;
1044 mt_com.mt_count = 1;
1045 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1047 mt_com.mt_op = MTOFFL;
1048 mt_com.mt_count = 1;
1049 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1051 dev->dev_errno = errno;
1052 Mmsg2(dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1053 dev->print_name(), be.strerror());
1056 Dmsg1(100, "Offlined device %s\n", dev->print_name());
1060 bool offline_or_rewind_dev(DEVICE *dev)
1065 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1066 return offline_dev(dev);
1069 * Note, this rewind probably should not be here (it wasn't
1070 * in prior versions of Bacula), but on FreeBSD, this is
1071 * needed in the case the tape was "frozen" due to an error
1072 * such as backspacing after writing and EOF. If it is not
1073 * done, all future references to the drive get and I/O error.
1075 clrerror_dev(dev, MTREW);
1076 return rewind_dev(dev);
1081 * Foward space a file
1082 * Returns: true on success
1085 bool DEVICE::fsf(int num)
1087 struct mtget mt_stat;
1093 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1094 Emsg0(M_FATAL, 0, errmsg);
1103 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1107 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1110 Dmsg0(100, "fsf\n");
1113 * If Fast forward space file is set, then we
1114 * use MTFSF to forward space and MTIOCGET
1115 * to get the file position. We assume that
1116 * the SCSI driver will ensure that we do not
1117 * forward space past the end of the medium.
1119 if (dev_cap(this, CAP_FSF) && dev_cap(this, CAP_MTIOCGET) && dev_cap(this, CAP_FASTFSF)) {
1120 mt_com.mt_op = MTFSF;
1121 mt_com.mt_count = num;
1122 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1123 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1126 Dmsg0(200, "Set ST_EOT\n");
1127 clrerror_dev(this, MTFSF);
1128 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1129 print_name(), be.strerror());
1130 Dmsg1(200, "%s", errmsg);
1133 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1135 file = mt_stat.mt_fileno;
1139 * Here if CAP_FSF is set, and virtually all drives
1140 * these days support it, we read a record, then forward
1141 * space one file. Using this procedure, which is slow,
1142 * is the only way we can be sure that we don't read
1143 * two consecutive EOF marks, which means End of Data.
1145 } else if (dev_cap(this, CAP_FSF)) {
1148 Dmsg0(200, "FSF has cap_fsf\n");
1149 if (max_block_size == 0) {
1150 rbuf_len = DEFAULT_BLOCK_SIZE;
1152 rbuf_len = max_block_size;
1154 rbuf = get_memory(rbuf_len);
1155 mt_com.mt_op = MTFSF;
1156 mt_com.mt_count = 1;
1157 while (num-- && !at_eot()) {
1158 Dmsg0(100, "Doing read before fsf\n");
1159 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1160 if (errno == ENOMEM) { /* tape record exceeds buf len */
1161 stat = rbuf_len; /* This is OK */
1163 * On IBM drives, they return ENOSPC at EOM
1164 * instead of EOF status
1166 } else if (at_eof() && errno == ENOSPC) {
1171 clrerror_dev(this, -1);
1172 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1174 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1175 print_name(), be.strerror());
1176 Dmsg1(100, "%s", errmsg);
1180 if (stat == 0) { /* EOF */
1181 update_pos_dev(this);
1182 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1183 /* Two reads of zero means end of tape */
1186 Dmsg0(100, "Set ST_EOT\n");
1192 } else { /* Got data */
1197 Dmsg0(100, "Doing MTFSF\n");
1198 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1199 if (stat < 0) { /* error => EOT */
1202 Dmsg0(100, "Set ST_EOT\n");
1203 clrerror_dev(this, MTFSF);
1204 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1205 print_name(), be.strerror());
1206 Dmsg0(100, "Got < 0 for MTFSF\n");
1207 Dmsg1(100, "%s", errmsg);
1215 * No FSF, so use FSR to simulate it
1218 Dmsg0(200, "Doing FSR for FSF\n");
1219 while (num-- && !at_eot()) {
1220 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1224 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1230 update_pos_dev(this);
1231 Dmsg1(200, "Return %d from FSF\n", stat);
1233 Dmsg0(200, "ST_EOF set on exit FSF\n");
1235 Dmsg0(200, "ST_EOT set on exit FSF\n");
1236 Dmsg1(200, "Return from FSF file=%d\n", file);
1241 * Backward space a file
1242 * Returns: false on failure
1246 bsf_dev(DEVICE *dev, int num)
1252 dev->dev_errno = EBADF;
1253 Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Device not open\n"));
1254 Emsg0(M_FATAL, 0, dev->errmsg);
1258 if (!dev->is_tape()) {
1259 Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1263 Dmsg0(29, "bsf_dev\n");
1264 dev->state &= ~(ST_EOT|ST_EOF);
1268 mt_com.mt_op = MTBSF;
1269 mt_com.mt_count = num;
1270 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1273 clrerror_dev(dev, MTBSF);
1274 Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1275 dev->print_name(), be.strerror());
1277 update_pos_dev(dev);
1283 * Foward space num records
1284 * Returns: false on failure
1287 bool DEVICE::fsr(int num)
1294 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1295 Emsg0(M_FATAL, 0, errmsg);
1302 if (!dev_cap(this, CAP_FSR)) {
1303 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1307 Dmsg1(29, "fsr %d\n", num);
1308 mt_com.mt_op = MTFSR;
1309 mt_com.mt_count = num;
1310 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1316 struct mtget mt_stat;
1317 clrerror_dev(this, MTFSR);
1318 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1319 if (dev_get_os_pos(this, &mt_stat)) {
1320 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1321 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1322 file = mt_stat.mt_fileno;
1323 block_num = mt_stat.mt_blkno;
1331 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1332 num, print_name(), be.strerror());
1334 update_pos_dev(this);
1339 * Backward space a record
1340 * Returns: false on failure
1344 bsr_dev(DEVICE *dev, int num)
1350 dev->dev_errno = EBADF;
1351 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1352 Emsg0(M_FATAL, 0, dev->errmsg);
1356 if (!dev->is_tape()) {
1360 if (!dev_cap(dev, CAP_BSR)) {
1361 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1365 Dmsg0(29, "bsr_dev\n");
1366 dev->block_num -= num;
1367 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1368 mt_com.mt_op = MTBSR;
1369 mt_com.mt_count = num;
1370 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1373 clrerror_dev(dev, MTBSR);
1374 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1375 dev->print_name(), be.strerror());
1377 update_pos_dev(dev);
1382 * Reposition the device to file, block
1383 * Returns: false on failure
1387 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1390 dev->dev_errno = EBADF;
1391 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1392 Emsg0(M_FATAL, 0, dev->errmsg);
1396 if (!dev->is_tape()) {
1397 off_t pos = (((off_t)file)<<32) + block;
1398 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1399 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1401 dev->dev_errno = errno;
1402 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1403 dev->print_name(), be.strerror());
1407 dev->block_num = block;
1408 dev->file_addr = pos;
1411 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1412 dev->file, dev->block_num, file, block);
1413 if (file < dev->file) {
1414 Dmsg0(100, "Rewind_dev\n");
1415 if (!rewind_dev(dev)) {
1419 if (file > dev->file) {
1420 Dmsg1(100, "fsf %d\n", file-dev->file);
1421 if (!dev->fsf(file-dev->file)) {
1422 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1425 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1427 if (block < dev->block_num) {
1428 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1429 Dmsg0(100, "bsf_dev 1\n");
1431 Dmsg0(100, "fsf_dev 1\n");
1433 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1435 if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1436 /* Ignore errors as Bacula can read to the correct block */
1437 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1438 return dev->fsr(block-dev->block_num);
1446 * Write an end of file on the device
1447 * Returns: 0 on success
1448 * non-zero on failure
1451 weof_dev(DEVICE *dev, int num)
1455 Dmsg0(29, "weof_dev\n");
1458 dev->dev_errno = EBADF;
1459 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1460 Emsg0(M_FATAL, 0, dev->errmsg);
1465 if (!dev->is_tape()) {
1468 if (!dev->can_append()) {
1469 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1470 Emsg0(M_FATAL, 0, dev->errmsg);
1474 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1475 mt_com.mt_op = MTWEOF;
1476 mt_com.mt_count = num;
1477 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1484 clrerror_dev(dev, MTWEOF);
1486 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1487 dev->print_name(), be.strerror());
1494 * Return string message with last error in English
1495 * Be careful not to call this routine from within dev.c
1496 * while editing an Mmsg() or you will end up in a recursive
1497 * loop creating a Segmentation Violation.
1500 strerror_dev(DEVICE *dev)
1507 * If implemented in system, clear the tape
1511 clrerror_dev(DEVICE *dev, int func)
1513 const char *msg = NULL;
1514 struct mtget mt_stat;
1517 dev->dev_errno = errno; /* save errno */
1519 dev->VolCatInfo.VolCatErrors++;
1522 if (!dev->is_tape()) {
1525 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1528 Emsg0(M_ABORT, 0, "Got ENOTTY on read/write!\n");
1532 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1537 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1542 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1546 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1550 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1554 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1575 bsnprintf(buf, sizeof(buf), "unknown func code %d", func);
1580 dev->dev_errno = ENOSYS;
1581 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1582 Emsg0(M_ERROR, 0, dev->errmsg);
1585 /* On some systems such as NetBSD, this clears all errors */
1586 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1588 /* Found on Linux */
1592 mt_com.mt_op = MTIOCLRERR;
1593 mt_com.mt_count = 1;
1594 /* Clear any error condition on the tape */
1595 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1596 Dmsg0(200, "Did MTIOCLRERR\n");
1600 /* Typically on FreeBSD */
1603 /* Read and clear SCSI error status */
1604 union mterrstat mt_errstat;
1605 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1606 strerror(dev->dev_errno));
1607 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1611 /* Clear Subsystem Exception OSF1 */
1615 mt_com.mt_op = MTCSE;
1616 mt_com.mt_count = 1;
1617 /* Clear any error condition on the tape */
1618 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1619 Dmsg0(200, "Did MTCSE\n");
1625 * Flush buffer contents
1628 int flush_dev(DEVICE *dev)
1633 static void do_close(DEVICE *dev)
1636 Dmsg1(29, "really close_dev %s\n", dev->print_name());
1641 if (!unmount_dev(dev, 1)) {
1642 Dmsg1(0, "Cannot unmount device %s.\n", dev->print_name());
1645 /* Remove the last part file if it is empty */
1646 if (dev->can_append() && (dev->num_parts > 0)) {
1648 POOL_MEM archive_name(PM_FNAME);
1649 dev->part = dev->num_parts;
1650 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", dev->VolCatInfo.VolCatName);
1651 make_spooled_dvd_filename(dev, archive_name);
1652 /* Check that the part file is empty */
1653 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1654 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1655 unlink(archive_name.c_str());
1659 /* Clean up device packet so it can be reused */
1661 dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1662 dev->label_type = B_BACULA_LABEL;
1663 dev->file = dev->block_num = 0;
1669 dev->part_start = 0;
1670 dev->EndFile = dev->EndBlock = 0;
1671 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1672 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1674 stop_thread_timer(dev->tid);
1684 void DEVICE::close()
1686 /*if (fd >= 0 && use_count == 1) {*/
1687 /* No need to check if fd >= 0: it is checked again
1688 * in do_close, and do_close MUST be called for volumes
1689 * splitted in parts, even if fd == -1. */
1690 if (use_count == 1) {
1692 } else if (use_count > 0) {
1697 ASSERT(use_count >= 0);
1702 bool truncate_dev(DEVICE *dev)
1704 Dmsg1(100, "truncate_dev %s\n", dev->print_name());
1705 if (dev->is_tape()) {
1706 return true; /* we don't really truncate tapes */
1707 /* maybe we should rewind and write and eof ???? */
1710 if (dev->is_dvd()) {
1711 Mmsg1(dev->errmsg, _("Truncate DVD %s not supported.\n"), dev->print_name());
1712 return false; /* we cannot truncate DVDs */
1715 if (ftruncate(dev->fd, 0) != 0) {
1717 Mmsg2(dev->errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1718 dev->print_name(), be.strerror());
1724 /* Return the resource name for the device */
1725 const char *DEVICE::name() const
1727 return device->hdr.name;
1731 dev_vol_name(DEVICE *dev)
1733 return dev->VolCatInfo.VolCatName;
1736 uint32_t dev_block(DEVICE *dev)
1738 update_pos_dev(dev);
1739 return dev->block_num;
1742 uint32_t dev_file(DEVICE *dev)
1744 update_pos_dev(dev);
1749 * Free memory allocated for the device
1752 term_dev(DEVICE *dev)
1755 dev->dev_errno = EBADF;
1756 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1757 Emsg0(M_FATAL, 0, dev->errmsg);
1760 Dmsg1(29, "term_dev: %s\n", dev->print_name());
1762 if (dev->dev_name) {
1763 free_memory(dev->dev_name);
1764 dev->dev_name = NULL;
1766 if (dev->prt_name) {
1767 free_memory(dev->prt_name);
1768 dev->prt_name = NULL;
1771 free_pool_memory(dev->errmsg);
1774 pthread_mutex_destroy(&dev->mutex);
1775 pthread_cond_destroy(&dev->wait);
1776 pthread_cond_destroy(&dev->wait_next_vol);
1777 pthread_mutex_destroy(&dev->spool_mutex);
1778 rwl_destroy(&dev->lock);
1779 if (dev->attached_dcrs) {
1780 delete dev->attached_dcrs;
1781 dev->attached_dcrs = NULL;
1783 if (dev->state & ST_MALLOC) {
1784 free_pool_memory((POOLMEM *)dev);
1789 * This routine initializes the device wait timers
1791 void init_device_wait_timers(DCR *dcr)
1793 DEVICE *dev = dcr->dev;
1794 JCR *jcr = dcr->jcr;
1796 /* ******FIXME******* put these on config variables */
1797 dev->min_wait = 60 * 60;
1798 dev->max_wait = 24 * 60 * 60;
1799 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1800 dev->wait_sec = dev->min_wait;
1801 dev->rem_wait_sec = dev->wait_sec;
1804 dev->BadVolName[0] = 0;
1806 jcr->min_wait = 60 * 60;
1807 jcr->max_wait = 24 * 60 * 60;
1808 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1809 jcr->wait_sec = jcr->min_wait;
1810 jcr->rem_wait_sec = jcr->wait_sec;
1815 void init_jcr_device_wait_timers(JCR *jcr)
1817 /* ******FIXME******* put these on config variables */
1818 jcr->min_wait = 60 * 60;
1819 jcr->max_wait = 24 * 60 * 60;
1820 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1821 jcr->wait_sec = jcr->min_wait;
1822 jcr->rem_wait_sec = jcr->wait_sec;
1828 * The dev timers are used for waiting on a particular device
1830 * Returns: true if time doubled
1831 * false if max time expired
1833 bool double_dev_wait_time(DEVICE *dev)
1835 dev->wait_sec *= 2; /* double wait time */
1836 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
1837 dev->wait_sec = dev->max_wait;
1840 dev->rem_wait_sec = dev->wait_sec;
1841 if (dev->num_wait >= dev->max_num_wait) {
1848 void set_os_device_parameters(DEVICE *dev)
1850 #ifdef HAVE_LINUX_OS
1852 if (dev->min_block_size == dev->max_block_size &&
1853 dev->min_block_size == 0) { /* variable block mode */
1854 mt_com.mt_op = MTSETBLK;
1855 mt_com.mt_count = 0;
1856 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1857 clrerror_dev(dev, MTSETBLK);
1859 mt_com.mt_op = MTSETDRVBUFFER;
1860 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
1861 if (!dev_cap(dev, CAP_TWOEOF)) {
1862 mt_com.mt_count |= MT_ST_TWO_FM;
1864 if (dev_cap(dev, CAP_EOM)) {
1865 mt_com.mt_count |= MT_ST_FAST_MTEOM;
1867 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1868 clrerror_dev(dev, MTSETBLK);
1874 #ifdef HAVE_NETBSD_OS
1876 if (dev->min_block_size == dev->max_block_size &&
1877 dev->min_block_size == 0) { /* variable block mode */
1878 mt_com.mt_op = MTSETBSIZ;
1879 mt_com.mt_count = 0;
1880 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1881 clrerror_dev(dev, MTSETBSIZ);
1883 /* Get notified at logical end of tape */
1884 mt_com.mt_op = MTEWARN;
1885 mt_com.mt_count = 1;
1886 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1887 clrerror_dev(dev, MTEWARN);
1893 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
1895 if (dev->min_block_size == dev->max_block_size &&
1896 dev->min_block_size == 0) { /* variable block mode */
1897 mt_com.mt_op = MTSETBSIZ;
1898 mt_com.mt_count = 0;
1899 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1900 clrerror_dev(dev, MTSETBSIZ);
1908 if (dev->min_block_size == dev->max_block_size &&
1909 dev->min_block_size == 0) { /* variable block mode */
1910 mt_com.mt_op = MTSRSZ;
1911 mt_com.mt_count = 0;
1912 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1913 clrerror_dev(dev, MTSRSZ);
1920 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
1922 return dev_cap(dev, CAP_MTIOCGET) &&
1923 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
1924 mt_stat->mt_fileno >= 0;
1927 static char *modes[] = {
1928 "CREATE_READ_WRITE",
1935 static char *mode_to_str(int mode)
1937 return modes[mode-1];