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 /* 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 /* Check that device is available */
108 if (stat(device->device_name, &statp) < 0) {
110 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat device %s: ERR=%s\n"),
111 device->device_name, be.strerror());
118 if (S_ISDIR(statp.st_mode)) {
120 } else if (S_ISCHR(statp.st_mode)) {
122 } else if (S_ISFIFO(statp.st_mode)) {
124 } else if (!(device->cap_bits & CAP_REQMOUNT)) {
125 Jmsg2(jcr, M_ERROR, 0, _("%s is an unknown device type. Must be tape or directory\n"
126 " or have RequiresMount=yes for DVD. st_mode=%x\n"),
127 device->device_name, statp.st_mode);
131 dev = (DEVICE *)get_memory(sizeof(DEVICE));
132 memset(dev, 0, sizeof(DEVICE));
133 dev->state = ST_MALLOC;
135 /* Copy user supplied device parameters from Resource */
136 dev->dev_name = get_memory(strlen(device->device_name)+1);
137 pm_strcpy(dev->dev_name, device->device_name);
138 dev->prt_name = get_memory(strlen(device->device_name) + strlen(device->hdr.name) + 20);
139 /* We edit "Resource-name" (physical-name) */
140 Mmsg(dev->prt_name, "\"%s\" (%s)", device->hdr.name, device->device_name);
141 dev->capabilities = device->cap_bits;
142 dev->min_block_size = device->min_block_size;
143 dev->max_block_size = device->max_block_size;
144 dev->max_volume_size = device->max_volume_size;
145 dev->max_file_size = device->max_file_size;
146 dev->volume_capacity = device->volume_capacity;
147 dev->max_rewind_wait = device->max_rewind_wait;
148 dev->max_open_wait = device->max_open_wait;
149 dev->max_open_vols = device->max_open_vols;
150 dev->vol_poll_interval = device->vol_poll_interval;
151 dev->max_spool_size = device->max_spool_size;
152 dev->drive_index = device->drive_index;
153 dev->autoselect = device->autoselect;
154 if (tape) { /* No parts on tapes */
155 dev->max_part_size = 0;
158 dev->max_part_size = device->max_part_size;
161 if (dev->vol_poll_interval && dev->vol_poll_interval < 60) {
162 dev->vol_poll_interval = 60;
164 dev->device = device;
167 dev->state |= ST_TAPE;
169 dev->state |= ST_FIFO;
170 dev->capabilities |= CAP_STREAM; /* set stream device */
172 dev->state |= ST_FILE;
175 /* If the device requires mount :
176 * - Check that the mount point is available
177 * - Check that (un)mount commands are defined
179 if (dev->is_file() && dev->requires_mount()) {
180 if (stat(device->mount_point, &statp) < 0) {
182 dev->dev_errno = errno;
183 Jmsg2(jcr, M_ERROR, 0, _("Unable to stat mount point %s: ERR=%s\n"),
184 device->mount_point, be.strerror());
187 if (!device->mount_command || !device->unmount_command) {
188 Jmsg0(jcr, M_ERROR_TERM, 0, _("Mount and unmount commands must defined for a device which requires mount.\n"));
190 if (!device->write_part_command) {
191 Jmsg0(jcr, M_ERROR_TERM, 0, _("Write part command must be defined for a device which requires mount.\n"));
193 dev->state |= ST_DVD;
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)
264 if (openmode == omode) {
267 ::close(fd); /* use system close so correct mode will be used on open */
269 Dmsg0(100, "Close fd for mode change.\n");
273 bstrncpy(VolCatInfo.VolCatName, dcr->VolumeName, sizeof(VolCatInfo.VolCatName));
276 Dmsg4(29, "open dev: tape=%d dev_name=%s vol=%s mode=%s\n", is_tape(),
277 print_name(), VolCatInfo.VolCatName, mode_to_str(omode));
278 state &= ~(ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF);
279 label_type = B_BACULA_LABEL;
280 if (is_tape() || is_fifo()) {
281 open_tape_device(dcr, omode);
282 } else if (is_dvd()) {
283 Dmsg1(100, "call open_dvd_device mode=%s\n", mode_to_str(omode));
284 open_dvd_device(dcr, omode);
286 Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode));
287 open_file_device(omode);
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"));
317 * If the flage open_nowait is set, which is the case
318 * when the daemon is initially trying to open the device,
319 * we open it with O_NONBLOCK set and O_RONLY, which will
320 * allow us to open normal Linux tape drives with no tape
321 * in the drive without blocking. We then immediately
322 * set blocking status so that if we read from the device they
323 * will be normal blocking reads.
325 * If later, we want to write on the device, it will be freed and
326 * reopened, but hopefully there will be a tape in the drive so
329 void DEVICE::open_tape_device(DCR *dcr, int omode)
335 Dmsg0(29, "open dev: device is tape\n");
337 if (is_tape() && is_autochanger()) {
338 get_autochanger_loaded_slot(dcr);
342 timeout = max_open_wait;
346 /* Set wait counters to zero for no wait */
347 timeout = ioerrcnt = 0;
348 /* Open drive in non-block mode */
349 nonblocking = O_NONBLOCK;
352 if (is_fifo() && timeout) {
354 tid = start_thread_timer(pthread_self(), timeout);
356 /* If busy retry each second for max_open_wait seconds */
357 Dmsg3(100, "Try open %s mode=%s nonblocking=%d\n", print_name(),
358 mode_to_str(omode), nonblocking);
359 /* Use system open() */
360 while ((fd = ::open(dev_name, mode+nonblocking, MODE_RW)) < 0) {
363 Dmsg5(050, "Open omode=%d mode=%x nonblock=%d error errno=%d ERR=%s\n",
364 omode, mode, nonblocking, errno, be.strerror());
365 if (dev_errno == EINTR || dev_errno == EAGAIN) {
366 Dmsg0(100, "Continue open\n");
369 /* Busy wait for specified time (default = 5 mins) */
370 if (dev_errno == EBUSY && timeout-- > 0) {
371 Dmsg2(100, "Device %s busy. ERR=%s\n", print_name(), be.strerror());
375 /* IO error (no volume) try 10 times every 6 seconds */
376 if (dev_errno == EIO && ioerrcnt-- > 0) {
378 Dmsg0(100, "Continue open\n");
381 Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"),
382 print_name(), be.strerror(dev_errno));
383 /* Stop any open timer we set */
385 stop_thread_timer(tid);
388 Jmsg0(dcr->jcr, M_FATAL, 0, errmsg);
397 openmode = omode; /* save open mode */
398 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
402 update_pos_dev(this); /* update position */
403 set_os_device_parameters(this); /* do system dependent stuff */
406 /* Stop any open() timer we started */
408 stop_thread_timer(tid);
411 Dmsg1(29, "open dev: tape %d opened\n", fd);
414 void DEVICE::set_blocking()
417 /* Try to reset blocking */
418 if ((oflags = fcntl(fd, F_GETFL, 0)) < 0 ||
419 fcntl(fd, F_SETFL, oflags & ~O_NONBLOCK) < 0) {
421 ::close(fd); /* use system close() */
422 fd = ::open(dev_name, mode, MODE_RW);
423 Dmsg2(100, "fcntl error. ERR=%s. Close-reopen fd=%d\n", be.strerror(), fd);
430 void DEVICE::open_file_device(int omode)
432 POOL_MEM archive_name(PM_FNAME);
435 * Handle opening of File Archive (not a tape)
437 Dmsg3(29, "Enter: open_file_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
438 archive_name.c_str(), mode_to_str(omode));
440 if (VolCatInfo.VolCatName[0] == 0) {
441 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
447 pm_strcpy(archive_name, dev_name);
448 if (archive_name.c_str()[strlen(archive_name.c_str())-1] != '/') {
449 pm_strcat(archive_name, "/");
451 pm_strcat(archive_name, VolCatInfo.VolCatName);
453 Dmsg3(29, "open dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
454 archive_name.c_str(), mode_to_str(omode));
456 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
459 /* If creating file, give 0640 permissions */
460 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
461 archive_name.c_str(), mode);
462 /* Use system open() */
463 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
466 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
468 Dmsg1(29, "open failed: %s", errmsg);
469 Emsg0(M_FATAL, 0, errmsg);
474 update_pos_dev(this); /* update position */
476 Dmsg5(29, "open dev: %s fd=%d opened, part=%d/%d, part_size=%u\n",
477 is_dvd()?"DVD":"disk", fd, part, num_parts,
482 * Open a DVD device. N.B. at this point, dcr->VolCatInfo.VolCatName (NB:??? I think it's VolCatInfo.VolCatName that is right)
483 * has the desired Volume name, but there is NO assurance that
484 * any other field of VolCatInfo is correct.
486 void DEVICE::open_dvd_device(DCR *dcr, int omode)
488 POOL_MEM archive_name(PM_FNAME);
489 struct stat filestat;
492 * Handle opening of DVD Volume
494 Dmsg3(29, "Enter: open_dvd_dev: %s dev=%s mode=%s\n", is_dvd()?"DVD":"disk",
495 archive_name.c_str(), mode_to_str(omode));
497 if (VolCatInfo.VolCatName[0] == 0) {
498 Dmsg1(10, "Could not open file device %s. No Volume name given.\n",
500 Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"),
511 Dmsg2(99, "open_dvd_device: num_parts=%d, VolCatInfo.VolCatParts=%d\n",
512 dcr->dev->num_parts, dcr->VolCatInfo.VolCatParts);
513 if (dcr->dev->num_parts < dcr->VolCatInfo.VolCatParts) {
514 Dmsg2(99, "open_dvd_device: num_parts updated to %d (was %d)\n",
515 dcr->VolCatInfo.VolCatParts, dcr->dev->num_parts);
516 dcr->dev->num_parts = dcr->VolCatInfo.VolCatParts;
519 if (mount_dev(this, 1)) {
520 if ((num_parts == 0) && (!truncating)) {
521 /* If we can mount the device, and we are not truncating the DVD, we usually want to abort. */
522 /* There is one exception, if there is only one 0-sized file on the DVD, with the right volume name,
523 * we continue (it's the method used by truncate_dvd_dev to truncate a volume). */
524 if (!check_can_write_on_non_blank_dvd(dcr)) {
525 Mmsg(errmsg, _("The media in the device %s is not empty, please blank it before writing anything to it.\n"), print_name());
526 Emsg0(M_FATAL, 0, errmsg);
527 unmount_dev(this, 1); /* Unmount the device, so the operator can change it. */
534 /* We cannot mount the device */
535 if (num_parts == 0) {
536 /* Run free space, check there is a media. */
537 update_free_space_dev(this);
539 Dmsg1(29, "Could not mount device %s, this is not a problem (num_parts == 0), and have media.\n", print_name());
542 Mmsg(errmsg, _("There is no valid media in the device %s.\n"), print_name());
543 Emsg0(M_FATAL, 0, errmsg);
549 Mmsg(errmsg, _("Could not mount device %s.\n"), print_name());
550 Emsg0(M_FATAL, 0, errmsg);
556 Dmsg6(29, "open dev: %s dev=%s mode=%s part=%d npart=%d volcatnparts=%d\n",
557 is_dvd()?"DVD":"disk", archive_name.c_str(), mode_to_str(omode),
558 part, num_parts, dcr->VolCatInfo.VolCatParts);
560 Dmsg2(100, "openmode=%d %s\n", openmode, mode_to_str(openmode));
563 * If we are not trying to access the last part, set mode to
564 * OPEN_READ_ONLY as writing would be an error.
566 if (part < num_parts) {
567 omode = OPEN_READ_ONLY;
568 make_mounted_dvd_filename(this, archive_name);
571 make_spooled_dvd_filename(this, archive_name);
575 /* If creating file, give 0640 permissions */
576 Dmsg3(29, "mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode),
577 archive_name.c_str(), mode);
578 /* Use system open() */
579 if ((fd = ::open(archive_name.c_str(), mode, 0640)) < 0) {
581 Mmsg2(errmsg, _("Could not open: %s, ERR=%s\n"), archive_name.c_str(),
583 dev_errno = EIO; /* Interpreted as no device present by acquire.c:acquire_device_for_read(). */
584 Dmsg1(29, "open failed: %s", errmsg);
586 if ((omode == OPEN_READ_ONLY) && (part == num_parts)) {
587 /* If the last part (on spool), doesn't exists when reading, create it and read from it
588 * (it will report immediately an EOF):
589 * Sometimes it is better to finish with an EOF than with an error. */
590 set_mode(OPEN_READ_WRITE);
591 fd = ::open(archive_name.c_str(), mode, 0640);
592 set_mode(OPEN_READ_ONLY);
595 /* We don't need it. Only the last part is on spool */
596 /*if (omode == OPEN_READ_ONLY) {
597 make_spooled_dvd_filename(this, archive_name);
598 fd = ::open(archive_name.c_str(), mode, 0640); // try on spool
601 Dmsg1(100, "after open fd=%d\n", fd);
603 /* Get size of file */
604 if (fstat(fd, &filestat) < 0) {
607 Mmsg2(errmsg, _("Could not fstat: %s, ERR=%s\n"), archive_name.c_str(),
609 Dmsg1(29, "open failed: %s", errmsg);
610 /* Use system close() */
614 part_size = filestat.st_size;
618 update_pos_dev(this); /* update position */
620 /* NB: It seems this code is wrong... part number is incremented in open_next_part, not here */
622 /* Check if just created Volume part */
623 /* if (omode == OPEN_READ_WRITE && (part == 0 || part_size == 0)) {
626 VolCatInfo.VolCatParts = num_parts;
628 if (part == 0) { // we must have opened the first part
639 bool _rewind_dev(char *file, int line, DEVICE *dev)
641 Dmsg3(100, "rewind_dev fd=%d called from %s:%d\n", dev->fd, file, line);
642 return rewind_dev(dev);
648 * Returns: true on success
651 bool rewind_dev(DEVICE *dev)
656 Dmsg3(29, "rewind_dev res=%d fd=%d %s\n", dev->reserved_device,
657 dev->fd, dev->print_name());
659 if (!dev->is_dvd()) { /* In case of major error, the fd is not open on DVD, so we don't want to abort. */
660 dev->dev_errno = EBADF;
661 Mmsg1(dev->errmsg, _("Bad call to rewind_dev. Device %s not open\n"),
663 Emsg0(M_ABORT, 0, dev->errmsg);
667 dev->state &= ~(ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
668 dev->block_num = dev->file = 0;
671 if (dev->is_tape()) {
672 mt_com.mt_op = MTREW;
674 /* If we get an I/O error on rewind, it is probably because
675 * the drive is actually busy. We loop for (about 5 minutes)
676 * retrying every 5 seconds.
678 for (i=dev->max_rewind_wait; ; i -= 5) {
679 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
681 clrerror_dev(dev, MTREW);
682 if (i == dev->max_rewind_wait) {
683 Dmsg1(200, "Rewind error, %s. retrying ...\n", be.strerror());
685 if (dev->dev_errno == EIO && i > 0) {
686 Dmsg0(200, "Sleeping 5 seconds.\n");
690 Mmsg2(dev->errmsg, _("Rewind error on %s. ERR=%s.\n"),
691 dev->print_name(), be.strerror());
696 } else if (dev->is_file()) {
697 if (lseek_dev(dev, (off_t)0, SEEK_SET) < 0) {
699 dev->dev_errno = errno;
700 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
701 dev->print_name(), be.strerror());
708 void DEVICE::block(int why)
711 block_device(this, why);
715 void DEVICE::unblock()
718 unblock_device(this);
722 const char *DEVICE::print_blocked() const
724 switch (dev_blocked) {
725 case BST_NOT_BLOCKED:
726 return "BST_NOT_BLOCKED";
728 return "BST_UNMOUNTED";
729 case BST_WAITING_FOR_SYSOP:
730 return "BST_WAITING_FOR_SYSOP";
731 case BST_DOING_ACQUIRE:
732 return "BST_DOING_ACQUIRE";
733 case BST_WRITING_LABEL:
734 return "BST_WRITING_LABEL";
735 case BST_UNMOUNTED_WAITING_FOR_SYSOP:
736 return "BST_UNMOUNTED_WAITING_FOR_SYSOP";
740 return _("unknown blocked code");
745 * Called to indicate that we have just read an
746 * EOF from the device.
748 void DEVICE::set_ateof()
760 * Called to indicate we are now at the end of the tape, and
761 * writing is not possible.
763 void DEVICE::set_ateot()
765 /* Make tape effectively read-only */
766 state |= (ST_EOF|ST_EOT|ST_WEOT);
771 * Position device to end of medium (end of data)
772 * Returns: true on succes
779 struct mtget mt_stat;
784 dev->dev_errno = EBADF;
785 Mmsg1(dev->errmsg, _("Bad call to eod_dev. Device %s not open\n"),
790 #if defined (__digital__) && defined (__unix__)
791 return dev->fsf(dev->VolCatInfo.VolCatFiles);
794 Dmsg0(29, "eod_dev\n");
798 dev->state &= ~(ST_EOF); /* remove EOF flags */
799 dev->block_num = dev->file = 0;
802 if (dev->state & (ST_FIFO | ST_PROG)) {
805 if (!dev->is_tape()) {
806 pos = lseek_dev(dev, (off_t)0, SEEK_END);
807 // Dmsg1(100, "====== Seek to %lld\n", pos);
810 dev->state |= ST_EOT;
813 dev->dev_errno = errno;
815 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
816 dev->print_name(), be.strerror());
820 if (dev_cap(dev, CAP_FASTFSF) && !dev_cap(dev, CAP_EOM)) {
821 Dmsg0(100,"Using FAST FSF for EOM\n");
822 /* If unknown position, rewind */
823 if (!dev_get_os_pos(dev, &mt_stat)) {
824 if (!rewind_dev(dev)) {
828 mt_com.mt_op = MTFSF;
830 * ***FIXME*** fix code to handle case that INT16_MAX is
833 mt_com.mt_count = INT16_MAX; /* use big positive number */
834 if (mt_com.mt_count < 0) {
835 mt_com.mt_count = INT16_MAX; /* brain damaged system */
839 if (dev_cap(dev, CAP_MTIOCGET) && (dev_cap(dev, CAP_FASTFSF) || dev_cap(dev, CAP_EOM))) {
840 if (dev_cap(dev, CAP_EOM)) {
841 Dmsg0(100,"Using EOM for EOM\n");
842 mt_com.mt_op = MTEOM;
846 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
848 clrerror_dev(dev, mt_com.mt_op);
849 Dmsg1(50, "ioctl error: %s\n", be.strerror());
851 Mmsg2(dev->errmsg, _("ioctl MTEOM error on %s. ERR=%s.\n"),
852 dev->print_name(), be.strerror());
856 if (!dev_get_os_pos(dev, &mt_stat)) {
858 clrerror_dev(dev, -1);
859 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
860 dev->print_name(), be.strerror());
863 Dmsg2(100, "EOD file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
865 dev->file = mt_stat.mt_fileno;
871 * Rewind then use FSF until EOT reached
873 if (!rewind_dev(dev)) {
877 * Move file by file to the end of the tape
880 for (file_num=dev->file; !dev->at_eot(); file_num++) {
881 Dmsg0(200, "eod_dev: doing fsf 1\n");
883 Dmsg0(200, "fsf error.\n");
887 * Avoid infinite loop by ensuring we advance.
889 if (file_num == (int)dev->file) {
890 struct mtget mt_stat;
891 Dmsg1(100, "fsf did not advance from file %d\n", file_num);
893 if (dev_get_os_pos(dev, &mt_stat)) {
894 Dmsg2(100, "Adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
895 dev->file = mt_stat.mt_fileno;
902 * Some drivers leave us after second EOF when doing
903 * MTEOM, so we must backup so that appending overwrites
906 if (dev_cap(dev, CAP_BSFATEOM)) {
907 struct mtget mt_stat;
908 /* Backup over EOF */
909 ok = bsf_dev(dev, 1);
910 /* If BSF worked and fileno is known (not -1), set file */
911 if (dev_get_os_pos(dev, &mt_stat)) {
912 Dmsg2(100, "BSFATEOF adjust file from %d to %d\n", dev->file , mt_stat.mt_fileno);
913 dev->file = mt_stat.mt_fileno;
915 dev->file++; /* wing it -- not correct on all OSes */
918 update_pos_dev(dev); /* update position */
920 Dmsg1(200, "EOD dev->file=%d\n", dev->file);
925 * Set the position of the device -- only for files and DVD
926 * For other devices, there is no generic way to do it.
927 * Returns: true on succes
930 bool update_pos_dev(DEVICE *dev)
936 dev->dev_errno = EBADF;
937 Mmsg0(dev->errmsg, _("Bad device call. Device not open\n"));
938 Emsg0(M_FATAL, 0, dev->errmsg);
942 /* Find out where we are */
943 if (dev->is_file()) {
946 pos = lseek_dev(dev, (off_t)0, SEEK_CUR);
949 dev->dev_errno = errno;
950 Pmsg1(000, _("Seek error: ERR=%s\n"), be.strerror());
951 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
952 dev->print_name(), be.strerror());
955 dev->file_addr = pos;
963 * Return the status of the device. This was meant
964 * to be a generic routine. Unfortunately, it doesn't
965 * seem possible (at least I do not know how to do it
966 * currently), which means that for the moment, this
967 * routine has very little value.
971 uint32_t status_dev(DEVICE *dev)
973 struct mtget mt_stat;
976 if (dev->state & (ST_EOT | ST_WEOT)) {
980 if (dev->state & ST_EOF) {
984 if (dev->is_tape()) {
986 Pmsg0(-20,_(" Bacula status:"));
987 Pmsg2(-20,_(" file=%d block=%d\n"), dev->file, dev->block_num);
988 if (ioctl(dev->fd, MTIOCGET, (char *)&mt_stat) < 0) {
990 dev->dev_errno = errno;
991 Mmsg2(dev->errmsg, _("ioctl MTIOCGET error on %s. ERR=%s.\n"),
992 dev->print_name(), be.strerror());
995 Pmsg0(-20, _(" Device status:"));
997 #if defined(HAVE_LINUX_OS)
998 if (GMT_EOF(mt_stat.mt_gstat)) {
1002 if (GMT_BOT(mt_stat.mt_gstat)) {
1006 if (GMT_EOT(mt_stat.mt_gstat)) {
1010 if (GMT_SM(mt_stat.mt_gstat)) {
1014 if (GMT_EOD(mt_stat.mt_gstat)) {
1018 if (GMT_WR_PROT(mt_stat.mt_gstat)) {
1019 stat |= BMT_WR_PROT;
1020 Pmsg0(-20, " WR_PROT");
1022 if (GMT_ONLINE(mt_stat.mt_gstat)) {
1024 Pmsg0(-20, " ONLINE");
1026 if (GMT_DR_OPEN(mt_stat.mt_gstat)) {
1027 stat |= BMT_DR_OPEN;
1028 Pmsg0(-20, " DR_OPEN");
1030 if (GMT_IM_REP_EN(mt_stat.mt_gstat)) {
1031 stat |= BMT_IM_REP_EN;
1032 Pmsg0(-20, " IM_REP_EN");
1034 #endif /* !SunOS && !OSF */
1035 if (dev_cap(dev, CAP_MTIOCGET)) {
1036 Pmsg2(-20, _(" file=%d block=%d\n"), mt_stat.mt_fileno, mt_stat.mt_blkno);
1038 Pmsg2(-20, _(" file=%d block=%d\n"), -1, -1);
1041 stat |= BMT_ONLINE | BMT_BOT;
1048 * Load medium in device
1049 * Returns: true on success
1052 bool load_dev(DEVICE *dev)
1059 dev->dev_errno = EBADF;
1060 Mmsg0(dev->errmsg, _("Bad call to load_dev. Device not open\n"));
1061 Emsg0(M_FATAL, 0, dev->errmsg);
1064 if (!(dev->is_tape())) {
1068 Dmsg0(200, "stored: MTLOAD command not available\n");
1070 dev->dev_errno = ENOTTY; /* function not available */
1071 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1072 dev->print_name(), be.strerror());
1076 dev->block_num = dev->file = 0;
1079 mt_com.mt_op = MTLOAD;
1080 mt_com.mt_count = 1;
1081 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1083 dev->dev_errno = errno;
1084 Mmsg2(dev->errmsg, _("ioctl MTLOAD error on %s. ERR=%s.\n"),
1085 dev->print_name(), be.strerror());
1093 * Rewind device and put it offline
1094 * Returns: true on success
1097 bool offline_dev(DEVICE *dev)
1101 if (!dev || dev->fd < 0 || !dev->is_tape()) {
1102 return true; /* device not open */
1105 dev->state &= ~(ST_APPEND|ST_READ|ST_EOT|ST_EOF|ST_WEOT); /* remove EOF/EOT flags */
1106 dev->block_num = dev->file = 0;
1111 mt_com.mt_op = MTUNLOCK;
1112 mt_com.mt_count = 1;
1113 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1115 mt_com.mt_op = MTOFFL;
1116 mt_com.mt_count = 1;
1117 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1119 dev->dev_errno = errno;
1120 Mmsg2(dev->errmsg, _("ioctl MTOFFL error on %s. ERR=%s.\n"),
1121 dev->print_name(), be.strerror());
1124 Dmsg1(100, "Offlined device %s\n", dev->print_name());
1128 bool offline_or_rewind_dev(DEVICE *dev)
1133 if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
1134 return offline_dev(dev);
1137 * Note, this rewind probably should not be here (it wasn't
1138 * in prior versions of Bacula), but on FreeBSD, this is
1139 * needed in the case the tape was "frozen" due to an error
1140 * such as backspacing after writing and EOF. If it is not
1141 * done, all future references to the drive get and I/O error.
1143 clrerror_dev(dev, MTREW);
1144 return rewind_dev(dev);
1149 * Foward space a file
1150 * Returns: true on success
1153 bool DEVICE::fsf(int num)
1155 struct mtget mt_stat;
1161 Mmsg0(errmsg, _("Bad call to fsf_dev. Device not open\n"));
1162 Emsg0(M_FATAL, 0, errmsg);
1171 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1175 Dmsg0(200, "ST_EOF set on entry to FSF\n");
1178 Dmsg0(100, "fsf\n");
1181 * If Fast forward space file is set, then we
1182 * use MTFSF to forward space and MTIOCGET
1183 * to get the file position. We assume that
1184 * the SCSI driver will ensure that we do not
1185 * forward space past the end of the medium.
1187 if (dev_cap(this, CAP_FSF) && dev_cap(this, CAP_MTIOCGET) && dev_cap(this, CAP_FASTFSF)) {
1188 mt_com.mt_op = MTFSF;
1189 mt_com.mt_count = num;
1190 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1191 if (stat < 0 || !dev_get_os_pos(this, &mt_stat)) {
1194 Dmsg0(200, "Set ST_EOT\n");
1195 clrerror_dev(this, MTFSF);
1196 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1197 print_name(), be.strerror());
1198 Dmsg1(200, "%s", errmsg);
1201 Dmsg2(200, "fsf file=%d block=%d\n", mt_stat.mt_fileno, mt_stat.mt_blkno);
1203 file = mt_stat.mt_fileno;
1207 * Here if CAP_FSF is set, and virtually all drives
1208 * these days support it, we read a record, then forward
1209 * space one file. Using this procedure, which is slow,
1210 * is the only way we can be sure that we don't read
1211 * two consecutive EOF marks, which means End of Data.
1213 } else if (dev_cap(this, CAP_FSF)) {
1216 Dmsg0(200, "FSF has cap_fsf\n");
1217 if (max_block_size == 0) {
1218 rbuf_len = DEFAULT_BLOCK_SIZE;
1220 rbuf_len = max_block_size;
1222 rbuf = get_memory(rbuf_len);
1223 mt_com.mt_op = MTFSF;
1224 mt_com.mt_count = 1;
1225 while (num-- && !at_eot()) {
1226 Dmsg0(100, "Doing read before fsf\n");
1227 if ((stat = read(fd, (char *)rbuf, rbuf_len)) < 0) {
1228 if (errno == ENOMEM) { /* tape record exceeds buf len */
1229 stat = rbuf_len; /* This is OK */
1231 * On IBM drives, they return ENOSPC at EOM
1232 * instead of EOF status
1234 } else if (at_eof() && errno == ENOSPC) {
1239 clrerror_dev(this, -1);
1240 Dmsg2(100, "Set ST_EOT read errno=%d. ERR=%s\n", dev_errno,
1242 Mmsg2(errmsg, _("read error on %s. ERR=%s.\n"),
1243 print_name(), be.strerror());
1244 Dmsg1(100, "%s", errmsg);
1248 if (stat == 0) { /* EOF */
1249 update_pos_dev(this);
1250 Dmsg1(100, "End of File mark from read. File=%d\n", file+1);
1251 /* Two reads of zero means end of tape */
1254 Dmsg0(100, "Set ST_EOT\n");
1260 } else { /* Got data */
1265 Dmsg0(100, "Doing MTFSF\n");
1266 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1267 if (stat < 0) { /* error => EOT */
1270 Dmsg0(100, "Set ST_EOT\n");
1271 clrerror_dev(this, MTFSF);
1272 Mmsg2(errmsg, _("ioctl MTFSF error on %s. ERR=%s.\n"),
1273 print_name(), be.strerror());
1274 Dmsg0(100, "Got < 0 for MTFSF\n");
1275 Dmsg1(100, "%s", errmsg);
1283 * No FSF, so use FSR to simulate it
1286 Dmsg0(200, "Doing FSR for FSF\n");
1287 while (num-- && !at_eot()) {
1288 fsr(INT32_MAX); /* returns -1 on EOF or EOT */
1292 Mmsg1(errmsg, _("Device %s at End of Tape.\n"), print_name());
1298 update_pos_dev(this);
1299 Dmsg1(200, "Return %d from FSF\n", stat);
1301 Dmsg0(200, "ST_EOF set on exit FSF\n");
1303 Dmsg0(200, "ST_EOT set on exit FSF\n");
1304 Dmsg1(200, "Return from FSF file=%d\n", file);
1309 * Backward space a file
1310 * Returns: false on failure
1314 bsf_dev(DEVICE *dev, int num)
1320 dev->dev_errno = EBADF;
1321 Mmsg0(dev->errmsg, _("Bad call to bsf_dev. Device not open\n"));
1322 Emsg0(M_FATAL, 0, dev->errmsg);
1326 if (!dev->is_tape()) {
1327 Mmsg1(dev->errmsg, _("Device %s cannot BSF because it is not a tape.\n"),
1331 Dmsg0(29, "bsf_dev\n");
1332 dev->state &= ~(ST_EOT|ST_EOF);
1336 mt_com.mt_op = MTBSF;
1337 mt_com.mt_count = num;
1338 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1341 clrerror_dev(dev, MTBSF);
1342 Mmsg2(dev->errmsg, _("ioctl MTBSF error on %s. ERR=%s.\n"),
1343 dev->print_name(), be.strerror());
1345 update_pos_dev(dev);
1351 * Foward space num records
1352 * Returns: false on failure
1355 bool DEVICE::fsr(int num)
1362 Mmsg0(errmsg, _("Bad call to fsr. Device not open\n"));
1363 Emsg0(M_FATAL, 0, errmsg);
1370 if (!dev_cap(this, CAP_FSR)) {
1371 Mmsg1(errmsg, _("ioctl MTFSR not permitted on %s.\n"), print_name());
1375 Dmsg1(29, "fsr %d\n", num);
1376 mt_com.mt_op = MTFSR;
1377 mt_com.mt_count = num;
1378 stat = ioctl(fd, MTIOCTOP, (char *)&mt_com);
1384 struct mtget mt_stat;
1385 clrerror_dev(this, MTFSR);
1386 Dmsg1(100, "FSF fail: ERR=%s\n", be.strerror());
1387 if (dev_get_os_pos(this, &mt_stat)) {
1388 Dmsg4(100, "Adjust from %d:%d to %d:%d\n", file,
1389 block_num, mt_stat.mt_fileno, mt_stat.mt_blkno);
1390 file = mt_stat.mt_fileno;
1391 block_num = mt_stat.mt_blkno;
1399 Mmsg3(errmsg, _("ioctl MTFSR %d error on %s. ERR=%s.\n"),
1400 num, print_name(), be.strerror());
1402 update_pos_dev(this);
1407 * Backward space a record
1408 * Returns: false on failure
1412 bsr_dev(DEVICE *dev, int num)
1418 dev->dev_errno = EBADF;
1419 Mmsg0(dev->errmsg, _("Bad call to bsr_dev. Device not open\n"));
1420 Emsg0(M_FATAL, 0, dev->errmsg);
1424 if (!dev->is_tape()) {
1428 if (!dev_cap(dev, CAP_BSR)) {
1429 Mmsg1(dev->errmsg, _("ioctl MTBSR not permitted on %s.\n"), dev->print_name());
1433 Dmsg0(29, "bsr_dev\n");
1434 dev->block_num -= num;
1435 dev->state &= ~(ST_EOF|ST_EOT|ST_EOF);
1436 mt_com.mt_op = MTBSR;
1437 mt_com.mt_count = num;
1438 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1441 clrerror_dev(dev, MTBSR);
1442 Mmsg2(dev->errmsg, _("ioctl MTBSR error on %s. ERR=%s.\n"),
1443 dev->print_name(), be.strerror());
1445 update_pos_dev(dev);
1450 * Reposition the device to file, block
1451 * Returns: false on failure
1455 reposition_dev(DEVICE *dev, uint32_t file, uint32_t block)
1458 dev->dev_errno = EBADF;
1459 Mmsg0(dev->errmsg, _("Bad call to reposition_dev. Device not open\n"));
1460 Emsg0(M_FATAL, 0, dev->errmsg);
1464 if (!dev->is_tape()) {
1465 off_t pos = (((off_t)file)<<32) + (off_t)block;
1466 Dmsg1(100, "===== lseek_dev to %d\n", (int)pos);
1467 if (lseek_dev(dev, pos, SEEK_SET) == (off_t)-1) {
1469 dev->dev_errno = errno;
1470 Mmsg2(dev->errmsg, _("lseek_dev error on %s. ERR=%s.\n"),
1471 dev->print_name(), be.strerror());
1475 dev->block_num = block;
1476 dev->file_addr = pos;
1479 Dmsg4(100, "reposition_dev from %u:%u to %u:%u\n",
1480 dev->file, dev->block_num, file, block);
1481 if (file < dev->file) {
1482 Dmsg0(100, "Rewind_dev\n");
1483 if (!rewind_dev(dev)) {
1487 if (file > dev->file) {
1488 Dmsg1(100, "fsf %d\n", file-dev->file);
1489 if (!dev->fsf(file-dev->file)) {
1490 Dmsg1(100, "fsf failed! ERR=%s\n", strerror_dev(dev));
1493 Dmsg2(100, "wanted_file=%d at_file=%d\n", file, dev->file);
1495 if (block < dev->block_num) {
1496 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1497 Dmsg0(100, "bsf_dev 1\n");
1499 Dmsg0(100, "fsf_dev 1\n");
1501 Dmsg2(100, "wanted_blk=%d at_blk=%d\n", block, dev->block_num);
1503 if (dev_cap(dev, CAP_POSITIONBLOCKS) && block > dev->block_num) {
1504 /* Ignore errors as Bacula can read to the correct block */
1505 Dmsg1(100, "fsr %d\n", block-dev->block_num);
1506 return dev->fsr(block-dev->block_num);
1514 * Write an end of file on the device
1515 * Returns: 0 on success
1516 * non-zero on failure
1519 weof_dev(DEVICE *dev, int num)
1523 Dmsg0(29, "weof_dev\n");
1526 dev->dev_errno = EBADF;
1527 Mmsg0(dev->errmsg, _("Bad call to weof_dev. Device not open\n"));
1528 Emsg0(M_FATAL, 0, dev->errmsg);
1533 if (!dev->is_tape()) {
1536 if (!dev->can_append()) {
1537 Mmsg0(dev->errmsg, _("Attempt to WEOF on non-appendable Volume\n"));
1538 Emsg0(M_FATAL, 0, dev->errmsg);
1542 dev->state &= ~(ST_EOT | ST_EOF); /* remove EOF/EOT flags */
1543 mt_com.mt_op = MTWEOF;
1544 mt_com.mt_count = num;
1545 stat = ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1552 clrerror_dev(dev, MTWEOF);
1554 Mmsg2(dev->errmsg, _("ioctl MTWEOF error on %s. ERR=%s.\n"),
1555 dev->print_name(), be.strerror());
1562 * Return string message with last error in English
1563 * Be careful not to call this routine from within dev.c
1564 * while editing an Mmsg() or you will end up in a recursive
1565 * loop creating a Segmentation Violation.
1568 strerror_dev(DEVICE *dev)
1575 * If implemented in system, clear the tape
1579 clrerror_dev(DEVICE *dev, int func)
1581 const char *msg = NULL;
1582 struct mtget mt_stat;
1585 dev->dev_errno = errno; /* save errno */
1587 dev->VolCatInfo.VolCatErrors++;
1590 if (!dev->is_tape()) {
1593 if (errno == ENOTTY || errno == ENOSYS) { /* Function not implemented */
1596 Emsg0(M_ABORT, 0, _("Got ENOTTY on read/write!\n"));
1600 dev->capabilities &= ~CAP_EOF; /* turn off feature */
1605 dev->capabilities &= ~CAP_EOM; /* turn off feature */
1610 dev->capabilities &= ~CAP_FSF; /* turn off feature */
1614 dev->capabilities &= ~CAP_BSF; /* turn off feature */
1618 dev->capabilities &= ~CAP_FSR; /* turn off feature */
1622 dev->capabilities &= ~CAP_BSR; /* turn off feature */
1643 bsnprintf(buf, sizeof(buf), _("unknown func code %d"), func);
1648 dev->dev_errno = ENOSYS;
1649 Mmsg1(dev->errmsg, _("I/O function \"%s\" not supported on this device.\n"), msg);
1650 Emsg0(M_ERROR, 0, dev->errmsg);
1653 /* On some systems such as NetBSD, this clears all errors */
1654 ioctl(dev->fd, MTIOCGET, (char *)&mt_stat);
1656 /* Found on Linux */
1660 mt_com.mt_op = MTIOCLRERR;
1661 mt_com.mt_count = 1;
1662 /* Clear any error condition on the tape */
1663 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1664 Dmsg0(200, "Did MTIOCLRERR\n");
1668 /* Typically on FreeBSD */
1671 /* Read and clear SCSI error status */
1672 union mterrstat mt_errstat;
1673 Dmsg2(200, "Doing MTIOCERRSTAT errno=%d ERR=%s\n", dev->dev_errno,
1674 strerror(dev->dev_errno));
1675 ioctl(dev->fd, MTIOCERRSTAT, (char *)&mt_errstat);
1679 /* Clear Subsystem Exception OSF1 */
1683 mt_com.mt_op = MTCSE;
1684 mt_com.mt_count = 1;
1685 /* Clear any error condition on the tape */
1686 ioctl(dev->fd, MTIOCTOP, (char *)&mt_com);
1687 Dmsg0(200, "Did MTCSE\n");
1693 * Flush buffer contents
1696 int flush_dev(DEVICE *dev)
1701 static void do_close(DEVICE *dev)
1704 Dmsg1(100, "really close_dev %s\n", dev->print_name());
1709 if (!unmount_dev(dev, 1)) {
1710 Dmsg1(0, "Cannot unmount device %s.\n", dev->print_name());
1713 /* Remove the last part file if it is empty */
1714 if (dev->num_parts > 0) {
1716 POOL_MEM archive_name(PM_FNAME);
1717 dev->part = dev->num_parts;
1718 Dmsg1(100, "Call make_dvd_filename. Vol=%s\n", dev->VolCatInfo.VolCatName);
1719 make_spooled_dvd_filename(dev, archive_name);
1720 /* Check that the part file is empty */
1721 if ((stat(archive_name.c_str(), &statp) == 0) && (statp.st_size == 0)) {
1722 Dmsg1(100, "unlink(%s)\n", archive_name.c_str());
1723 unlink(archive_name.c_str());
1727 /* Clean up device packet so it can be reused */
1729 dev->state &= ~(ST_OPENED|ST_LABEL|ST_READ|ST_APPEND|ST_EOT|ST_WEOT|ST_EOF);
1730 dev->label_type = B_BACULA_LABEL;
1731 dev->file = dev->block_num = 0;
1737 dev->part_start = 0;
1738 dev->EndFile = dev->EndBlock = 0;
1739 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
1741 memset(&dev->VolHdr, 0, sizeof(dev->VolHdr));
1743 stop_thread_timer(dev->tid);
1753 void DEVICE::close()
1755 /*if (fd >= 0 && use_count == 1) {*/
1756 /* No need to check if fd >= 0: it is checked again
1757 * in do_close, and do_close MUST be called for volumes
1758 * split in parts, even if fd == -1.
1760 if (use_count == 1) {
1762 } else if (use_count > 0) {
1767 ASSERT(use_count >= 0);
1772 bool truncate_dev(DCR *dcr) /* We need the DCR for DVD-writing */
1774 DEVICE *dev = dcr->dev;
1776 Dmsg1(100, "truncate_dev %s\n", dev->print_name());
1777 if (dev->is_tape()) {
1778 return true; /* we don't really truncate tapes */
1779 /* maybe we should rewind and write and eof ???? */
1782 if (dev->is_dvd()) {
1783 return truncate_dvd_dev(dcr);
1786 if (ftruncate(dev->fd, 0) != 0) {
1788 Mmsg2(dev->errmsg, _("Unable to truncate device %s. ERR=%s\n"),
1789 dev->print_name(), be.strerror());
1795 /* Return the resource name for the device */
1796 const char *DEVICE::name() const
1798 return device->hdr.name;
1802 dev_vol_name(DEVICE *dev)
1804 return dev->VolCatInfo.VolCatName;
1807 uint32_t dev_block(DEVICE *dev)
1809 update_pos_dev(dev);
1810 return dev->block_num;
1813 uint32_t dev_file(DEVICE *dev)
1815 update_pos_dev(dev);
1820 * Free memory allocated for the device
1823 term_dev(DEVICE *dev)
1826 dev->dev_errno = EBADF;
1827 Mmsg0(dev->errmsg, _("Bad call to term_dev. Device not open\n"));
1828 Emsg0(M_FATAL, 0, dev->errmsg);
1831 Dmsg1(29, "term_dev: %s\n", dev->print_name());
1833 if (dev->dev_name) {
1834 free_memory(dev->dev_name);
1835 dev->dev_name = NULL;
1837 if (dev->prt_name) {
1838 free_memory(dev->prt_name);
1839 dev->prt_name = NULL;
1842 free_pool_memory(dev->errmsg);
1845 pthread_mutex_destroy(&dev->mutex);
1846 pthread_cond_destroy(&dev->wait);
1847 pthread_cond_destroy(&dev->wait_next_vol);
1848 pthread_mutex_destroy(&dev->spool_mutex);
1849 rwl_destroy(&dev->lock);
1850 if (dev->attached_dcrs) {
1851 delete dev->attached_dcrs;
1852 dev->attached_dcrs = NULL;
1854 if (dev->state & ST_MALLOC) {
1855 free_pool_memory((POOLMEM *)dev);
1860 * This routine initializes the device wait timers
1862 void init_device_wait_timers(DCR *dcr)
1864 DEVICE *dev = dcr->dev;
1865 JCR *jcr = dcr->jcr;
1867 /* ******FIXME******* put these on config variables */
1868 dev->min_wait = 60 * 60;
1869 dev->max_wait = 24 * 60 * 60;
1870 dev->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1871 dev->wait_sec = dev->min_wait;
1872 dev->rem_wait_sec = dev->wait_sec;
1875 dev->BadVolName[0] = 0;
1877 jcr->min_wait = 60 * 60;
1878 jcr->max_wait = 24 * 60 * 60;
1879 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1880 jcr->wait_sec = jcr->min_wait;
1881 jcr->rem_wait_sec = jcr->wait_sec;
1886 void init_jcr_device_wait_timers(JCR *jcr)
1888 /* ******FIXME******* put these on config variables */
1889 jcr->min_wait = 60 * 60;
1890 jcr->max_wait = 24 * 60 * 60;
1891 jcr->max_num_wait = 9; /* 5 waits =~ 1 day, then 1 day at a time */
1892 jcr->wait_sec = jcr->min_wait;
1893 jcr->rem_wait_sec = jcr->wait_sec;
1899 * The dev timers are used for waiting on a particular device
1901 * Returns: true if time doubled
1902 * false if max time expired
1904 bool double_dev_wait_time(DEVICE *dev)
1906 dev->wait_sec *= 2; /* double wait time */
1907 if (dev->wait_sec > dev->max_wait) { /* but not longer than maxtime */
1908 dev->wait_sec = dev->max_wait;
1911 dev->rem_wait_sec = dev->wait_sec;
1912 if (dev->num_wait >= dev->max_num_wait) {
1919 void set_os_device_parameters(DEVICE *dev)
1921 #ifdef HAVE_LINUX_OS
1923 if (dev->min_block_size == dev->max_block_size &&
1924 dev->min_block_size == 0) { /* variable block mode */
1925 mt_com.mt_op = MTSETBLK;
1926 mt_com.mt_count = 0;
1927 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1928 clrerror_dev(dev, MTSETBLK);
1930 mt_com.mt_op = MTSETDRVBUFFER;
1931 mt_com.mt_count = MT_ST_CLEARBOOLEANS;
1932 if (!dev_cap(dev, CAP_TWOEOF)) {
1933 mt_com.mt_count |= MT_ST_TWO_FM;
1935 if (dev_cap(dev, CAP_EOM)) {
1936 mt_com.mt_count |= MT_ST_FAST_MTEOM;
1938 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1939 clrerror_dev(dev, MTSETBLK);
1945 #ifdef HAVE_NETBSD_OS
1947 if (dev->min_block_size == dev->max_block_size &&
1948 dev->min_block_size == 0) { /* variable block mode */
1949 mt_com.mt_op = MTSETBSIZ;
1950 mt_com.mt_count = 0;
1951 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1952 clrerror_dev(dev, MTSETBSIZ);
1954 /* Get notified at logical end of tape */
1955 mt_com.mt_op = MTEWARN;
1956 mt_com.mt_count = 1;
1957 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1958 clrerror_dev(dev, MTEWARN);
1964 #if HAVE_FREEBSD_OS || HAVE_OPENBSD_OS
1966 if (dev->min_block_size == dev->max_block_size &&
1967 dev->min_block_size == 0) { /* variable block mode */
1968 mt_com.mt_op = MTSETBSIZ;
1969 mt_com.mt_count = 0;
1970 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1971 clrerror_dev(dev, MTSETBSIZ);
1979 if (dev->min_block_size == dev->max_block_size &&
1980 dev->min_block_size == 0) { /* variable block mode */
1981 mt_com.mt_op = MTSRSZ;
1982 mt_com.mt_count = 0;
1983 if (ioctl(dev->fd, MTIOCTOP, (char *)&mt_com) < 0) {
1984 clrerror_dev(dev, MTSRSZ);
1991 static bool dev_get_os_pos(DEVICE *dev, struct mtget *mt_stat)
1993 return dev_cap(dev, CAP_MTIOCGET) &&
1994 ioctl(dev->fd, MTIOCGET, (char *)mt_stat) == 0 &&
1995 mt_stat->mt_fileno >= 0;
1998 static char *modes[] = {
1999 "CREATE_READ_WRITE",
2006 static char *mode_to_str(int mode)
2008 return modes[mode-1];