git.gag.com Git - debian/amanda/blob - device-src/tape-posix.c

   1 /*
   2  * Copyright (c) 2007, 2008, 2009, 2010 Zmanda, Inc.  All Rights Reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License version 2 as published
   6  * by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  10  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  11  * for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16  *
  17  * Contact information: Zmanda Inc., 465 S. Mathilda Ave., Suite 300
  18  * Sunnyvale, CA 94085, USA, or: http://www.zmanda.com
  19  */
  20
  21 #include "amanda.h"
  22 #include "util.h"
  23 #include "tape-ops.h"
  24 #include "property.h"
  25 #include <glob.h>
  26
  27 /* Having one name for every operation would be too easy. */
  28 #if !defined(MTCOMPRESSION) && defined(MTCOMP)
  29 # define MTCOMPRESSION MTCOMP
  30 #endif
  31
  32 #if !defined(MTSETBLK) && defined(MTSETBSIZ)
  33 # define MTSETBLK MTSETBSIZ
  34 #endif
  35
  36 #if !defined(MTEOM) && defined(MTEOD)
  37 # define MTEOM MTEOD
  38 #endif
  39
  40 #ifdef HAVE_LIMITS_H
  41 # include <limits.h>
  42 #endif
  43
  44 gboolean tape_rewind(int fd) {
  45     int count = 5;
  46     time_t stop_time;
  47
  48     /* We will retry this for up to 30 seconds or 5 retries,
  49        whichever is less, because some hardware/software combinations
  50        (notably EXB-8200 on FreeBSD) can fail to rewind. */
  51     stop_time = time(NULL) + 30;
  52
  53     while (--count >= 0 && time(NULL) < stop_time) {
  54         struct mtop mt;
  55         mt.mt_op = MTREW;
  56         mt.mt_count = 1;
  57
  58         if (0 == ioctl(fd, MTIOCTOP, &mt))
  59             return TRUE;
  60
  61         sleep(3);
  62     }
  63
  64     return FALSE;
  65 }
  66
  67 gboolean tape_fsf(int fd, guint count) {
  68     struct mtop mt;
  69     mt.mt_op = MTFSF;
  70     mt.mt_count = count;
  71     return 0 == ioctl(fd, MTIOCTOP, &mt);
  72 }
  73
  74 gboolean tape_bsf(int fd, guint count) {
  75     struct mtop mt;
  76     mt.mt_op = MTBSF;
  77     mt.mt_count = count;
  78     return 0 == ioctl(fd, MTIOCTOP, &mt);
  79 }
  80
  81 gboolean tape_fsr(int fd, guint count) {
  82     struct mtop mt;
  83     mt.mt_op = MTFSR;
  84     mt.mt_count = count;
  85     return 0 == ioctl(fd, MTIOCTOP, &mt);
  86 }
  87
  88 gboolean tape_bsr(int fd, guint count) {
  89     struct mtop mt;
  90     mt.mt_op = MTBSR;
  91     mt.mt_count = count;
  92     return 0 == ioctl(fd, MTIOCTOP, &mt);
  93 }
  94
  95 gint tape_fileno(int fd) {
  96     struct mtget get;
  97
  98     if (0 != ioctl(fd, MTIOCGET, &get))
  99         return TAPE_POSITION_UNKNOWN;
 100     if (get.mt_fileno < 0)
 101         return TAPE_POSITION_UNKNOWN;
 102     else
 103         return get.mt_fileno;
 104 }
 105
 106 gint tape_eod(int fd) {
 107     struct mtop mt;
 108     struct mtget get;
 109     mt.mt_op = MTEOM;
 110     mt.mt_count = 1;
 111     if (0 != ioctl(fd, MTIOCTOP, &mt))
 112         return TAPE_OP_ERROR;
 113
 114     /* Ignored result. This is just to flush buffers. */
 115     mt.mt_op = MTNOP;
 116     ioctl(fd, MTIOCTOP, &mt);
 117
 118     if (0 != ioctl(fd, MTIOCGET, &get))
 119         return TAPE_POSITION_UNKNOWN;
 120     if (get.mt_fileno < 0)
 121         return TAPE_POSITION_UNKNOWN;
 122     else
 123         return get.mt_fileno;
 124 }
 125
 126 gboolean tape_weof(int fd, guint8 count) {
 127     struct mtop mt;
 128     mt.mt_op = MTWEOF;
 129     mt.mt_count = count;
 130     return 0 == ioctl(fd, MTIOCTOP, &mt);
 131 }
 132
 133 gboolean tape_setcompression(int fd G_GNUC_UNUSED,
 134         gboolean on G_GNUC_UNUSED) {
 135 #ifdef MTCOMPRESSION
 136     struct mtop mt;
 137     mt.mt_op = MTCOMPRESSION;
 138     mt.mt_count = on;
 139     return 0 == ioctl(fd, MTIOCTOP, &mt);
 140 #else
 141     return 0;
 142 #endif
 143 }
 144
 145 gboolean tape_offl(int fd) {
 146     struct mtop mt;
 147     int safe_errno;
 148
 149     mt.mt_op = MTOFFL;
 150     mt.mt_count = 1;
 151     if (0 == ioctl(fd, MTIOCTOP, &mt))
 152         return TRUE;
 153
 154     safe_errno = errno;
 155     g_debug("tape_off: ioctl(MTIOCTOP/MTOFFL) failed: %s", strerror(errno));
 156     errno = safe_errno;
 157
 158     return FALSE;
 159 }
 160
 161 DeviceStatusFlags tape_is_tape_device(int fd) {
 162     struct mtop mt;
 163     mt.mt_op = MTNOP;
 164     mt.mt_count = 1;
 165     if (0 == ioctl(fd, MTIOCTOP, &mt)) {
 166         return DEVICE_STATUS_SUCCESS;
 167 #ifdef ENOMEDIUM
 168     } else if (errno == ENOMEDIUM) {
 169         return DEVICE_STATUS_VOLUME_MISSING;
 170 #endif
 171     } else {
 172         g_debug("tape_is_tape_device: ioctl(MTIOCTOP/MTNOP) failed: %s",
 173                  strerror(errno));
 174         if (errno == EIO) {
 175             /* some devices return EIO while the drive is busy loading */
 176             return DEVICE_STATUS_DEVICE_ERROR|DEVICE_STATUS_DEVICE_BUSY;
 177         } else {
 178             return DEVICE_STATUS_DEVICE_ERROR;
 179         }
 180     }
 181 }
 182
 183 DeviceStatusFlags tape_is_ready(int fd, TapeDevice *t_self G_GNUC_UNUSED) {
 184     struct mtget get;
 185     if (0 == ioctl(fd, MTIOCGET, &get)) {
 186 #if defined(GMT_ONLINE) || defined(GMT_DR_OPEN)
 187         if (1
 188 #ifdef GMT_ONLINE
 189             && (t_self->broken_gmt_online || GMT_ONLINE(get.mt_gstat))
 190 #endif
 191 #ifdef GMT_DR_OPEN
 192             && !GMT_DR_OPEN(get.mt_gstat)
 193 #endif
 194             ) {
 195             return DEVICE_STATUS_SUCCESS;
 196         } else {
 197             return DEVICE_STATUS_VOLUME_MISSING;
 198         }
 199 #else /* Neither macro is defined. */
 200         return DEVICE_STATUS_SUCCESS;
 201 #endif
 202     } else {
 203         return DEVICE_STATUS_VOLUME_ERROR;
 204     }
 205 }
 206
 207 void tape_device_detect_capabilities(TapeDevice * t_self) {
 208     tape_device_set_capabilities(t_self,
 209         TRUE,  PROPERTY_SURETY_BAD, PROPERTY_SOURCE_DEFAULT, /* fsf*/
 210         DEFAULT_FSF_AFTER_FILEMARK, PROPERTY_SURETY_BAD, PROPERTY_SOURCE_DEFAULT, /* fsf_after_filemark*/
 211         TRUE,  PROPERTY_SURETY_BAD, PROPERTY_SOURCE_DEFAULT, /* bsf*/
 212         TRUE,  PROPERTY_SURETY_BAD, PROPERTY_SOURCE_DEFAULT, /* fsr*/
 213         TRUE,  PROPERTY_SURETY_BAD, PROPERTY_SOURCE_DEFAULT, /* bsr*/
 214         TRUE,  PROPERTY_SURETY_BAD, PROPERTY_SOURCE_DEFAULT, /* eom*/
 215         FALSE, PROPERTY_SURETY_BAD, PROPERTY_SOURCE_DEFAULT, /* bsf_after_eom*/
 216         2,     PROPERTY_SURETY_BAD, PROPERTY_SOURCE_DEFAULT  /* final_filemarks*/
 217         );
 218 }