libmultipath/checkers/rdac.c

   1 /*
   2  * Copyright (c) 2005 Christophe Varoqui
   3  */
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <sys/types.h>
   8 #include <sys/stat.h>
   9 #include <unistd.h>
  10 #include <fcntl.h>
  11 #include <sys/ioctl.h>
  12 #include <errno.h>
  13
  14 #include "checkers.h"
  15 #include "debug.h"
  16
  17 #include "../libmultipath/sg_include.h"
  18
  19 #define INQUIRY_CMDLEN          6
  20 #define INQUIRY_CMD             0x12
  21 #define MODE_SENSE_CMD          0x5a
  22 #define MODE_SELECT_CMD         0x55
  23 #define MODE_SEN_SEL_CMDLEN     10
  24 #define SENSE_BUFF_LEN          32
  25 #define SCSI_CHECK_CONDITION    0x2
  26 #define SCSI_COMMAND_TERMINATED 0x22
  27 #define SG_ERR_DRIVER_SENSE     0x08
  28 #define RECOVERED_ERROR         0x01
  29
  30
  31 #define CURRENT_PAGE_CODE_VALUES        0
  32 #define CHANGEABLE_PAGE_CODE_VALUES     1
  33
  34 #define MSG_RDAC_DOWN  " reports path is down"
  35 #define MSG_RDAC_DOWN_TYPE(STR) MSG_RDAC_DOWN": "STR
  36
  37 #define RTPG_UNAVAILABLE        0x3
  38 #define RTPG_OFFLINE            0xE
  39 #define RTPG_TRANSITIONING      0xF
  40
  41 #define RTPG_UNAVAIL_NON_RESPONSIVE     0x2
  42 #define RTPG_UNAVAIL_IN_RESET           0x3
  43 #define RTPG_UNAVAIL_CFW_DL1            0x4
  44 #define RTPG_UNAVAIL_CFW_DL2            0x5
  45 #define RTPG_UNAVAIL_QUIESCED           0x6
  46 #define RTPG_UNAVAIL_SERVICE_MODE       0x7
  47
  48 struct control_mode_page {
  49         unsigned char header[8];
  50         unsigned char page_code;
  51         unsigned char page_len;
  52         unsigned char dontcare0[3];
  53         unsigned char tas_bit;
  54         unsigned char dontcare1[6];
  55 };
  56
  57 struct rdac_checker_context {
  58         void * dummy;
  59 };
  60
  61 int libcheck_init (struct checker * c)
  62 {
  63         unsigned char cmd[MODE_SEN_SEL_CMDLEN];
  64         unsigned char sense_b[SENSE_BUFF_LEN];
  65         struct sg_io_hdr io_hdr;
  66         struct control_mode_page current, changeable;
  67         int set = 0;
  68
  69         memset(cmd, 0, MODE_SEN_SEL_CMDLEN);
  70         cmd[0] = MODE_SENSE_CMD;
  71         cmd[1] = 0x08; /* DBD bit on */
  72         cmd[2] = 0xA + (CURRENT_PAGE_CODE_VALUES << 6);
  73         cmd[8] = (sizeof(struct control_mode_page) &  0xff);
  74
  75         memset(&io_hdr, 0, sizeof(struct sg_io_hdr));
  76         memset(sense_b, 0, SENSE_BUFF_LEN);
  77         memset(&current, 0, sizeof(struct control_mode_page));
  78
  79         io_hdr.interface_id = 'S';
  80         io_hdr.cmd_len = MODE_SEN_SEL_CMDLEN;
  81         io_hdr.mx_sb_len = sizeof(sense_b);
  82         io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
  83         io_hdr.dxfer_len = (sizeof(struct control_mode_page) &  0xff);
  84         io_hdr.dxferp = &current;
  85         io_hdr.cmdp = cmd;
  86         io_hdr.sbp = sense_b;
  87         io_hdr.timeout = c->timeout * 1000;
  88
  89         if (ioctl(c->fd, SG_IO, &io_hdr) < 0)
  90                 goto out;
  91
  92         /* check the TAS bit to see if it is already set */
  93         if ((current.tas_bit >> 6) & 0x1) {
  94                 set = 1;
  95                 goto out;
  96         }
  97
  98         /* get the changeble values */
  99         cmd[2] = 0xA + (CHANGEABLE_PAGE_CODE_VALUES << 6);
 100         io_hdr.dxferp = &changeable;
 101         memset(&changeable, 0, sizeof(struct control_mode_page));
 102
 103         if (ioctl(c->fd, SG_IO, &io_hdr) < 0)
 104                 goto out;
 105
 106         /* if TAS bit is not settable exit */
 107         if (((changeable.tas_bit >> 6) & 0x1) == 0)
 108                 goto out;
 109
 110         /* Now go ahead and set it */
 111         memset(cmd, 0, MODE_SEN_SEL_CMDLEN);
 112         cmd[0] = MODE_SELECT_CMD;
 113         cmd[1] = 0x1; /* set SP bit on */
 114         cmd[8] = (sizeof(struct control_mode_page) &  0xff);
 115
 116         /* use the same buffer as current, only set the tas bit */
 117         current.page_code = 0xA;
 118         current.page_len = 0xA;
 119         current.tas_bit |= (1 << 6);
 120
 121         io_hdr.dxfer_direction = SG_DXFER_TO_DEV;
 122         io_hdr.dxferp = &current;
 123
 124         if (ioctl(c->fd, SG_IO, &io_hdr) < 0)
 125                 goto out;
 126
 127         /* Success */
 128         set = 1;
 129 out:
 130         if (set == 0)
 131                 condlog(3, "rdac checker failed to set TAS bit");
 132         return 0;
 133 }
 134
 135 void libcheck_free (struct checker * c)
 136 {
 137         return;
 138 }
 139
 140 static int
 141 do_inq(int sg_fd, unsigned int pg_op, void *resp, int mx_resp_len,
 142        unsigned int timeout)
 143 {
 144         unsigned char inqCmdBlk[INQUIRY_CMDLEN] = { INQUIRY_CMD, 1, 0, 0, 0, 0 };
 145         unsigned char sense_b[SENSE_BUFF_LEN];
 146         struct sg_io_hdr io_hdr;
 147         int retry_rdac = 5;
 148
 149 retry:
 150         inqCmdBlk[2] = (unsigned char) pg_op;
 151         inqCmdBlk[4] = (unsigned char) (mx_resp_len & 0xff);
 152         memset(&io_hdr, 0, sizeof (struct sg_io_hdr));
 153         memset(sense_b, 0, SENSE_BUFF_LEN);
 154
 155         io_hdr.interface_id = 'S';
 156         io_hdr.cmd_len = sizeof (inqCmdBlk);
 157         io_hdr.mx_sb_len = sizeof (sense_b);
 158         io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
 159         io_hdr.dxfer_len = mx_resp_len;
 160         io_hdr.dxferp = resp;
 161         io_hdr.cmdp = inqCmdBlk;
 162         io_hdr.sbp = sense_b;
 163         io_hdr.timeout = timeout * 1000;
 164
 165         if (ioctl(sg_fd, SG_IO, &io_hdr) < 0)
 166                 return 1;
 167
 168         /* treat SG_ERR here to get rid of sg_err.[ch] */
 169         io_hdr.status &= 0x7e;
 170         if ((0 == io_hdr.status) && (0 == io_hdr.host_status) &&
 171             (0 == io_hdr.driver_status))
 172                 return 0;
 173
 174         /* check if we need to retry this error */
 175         if (io_hdr.info & SG_INFO_OK_MASK) {
 176                 switch (io_hdr.host_status) {
 177                 case DID_BUS_BUSY:
 178                 case DID_ERROR:
 179                 case DID_SOFT_ERROR:
 180                 case DID_TRANSPORT_DISRUPTED:
 181                         /* Transport error, retry */
 182                         if (--retry_rdac)
 183                                 goto retry;
 184                         break;
 185                 default:
 186                         break;
 187                 }
 188         }
 189
 190         if ((SCSI_CHECK_CONDITION == io_hdr.status) ||
 191             (SCSI_COMMAND_TERMINATED == io_hdr.status) ||
 192             (SG_ERR_DRIVER_SENSE == (0xf & io_hdr.driver_status))) {
 193                 if (io_hdr.sbp && (io_hdr.sb_len_wr > 2)) {
 194                         int sense_key;
 195                         unsigned char * sense_buffer = io_hdr.sbp;
 196                         if (sense_buffer[0] & 0x2)
 197                                 sense_key = sense_buffer[1] & 0xf;
 198                         else
 199                                 sense_key = sense_buffer[2] & 0xf;
 200                         if (RECOVERED_ERROR == sense_key)
 201                                 return 0;
 202                 }
 203         }
 204         return 1;
 205 }
 206
 207 struct volume_access_inq
 208 {
 209         char PQ_PDT;
 210         char dontcare0[7];
 211         char avtcvp;
 212         char vol_ppp;
 213         char aas_cur;
 214         char vendor_specific_cur;
 215         char aas_alt;
 216         char vendor_specific_alt;
 217         char dontcare1[34];
 218 };
 219
 220 enum {
 221         RDAC_MSGID_NOT_CONN = CHECKER_FIRST_MSGID,
 222         RDAC_MSGID_IN_STARTUP,
 223         RDAC_MSGID_NON_RESPONSIVE,
 224         RDAC_MSGID_IN_RESET,
 225         RDAC_MSGID_FW_DOWNLOADING,
 226         RDAC_MSGID_QUIESCED,
 227         RDAC_MSGID_SERVICE_MODE,
 228         RDAC_MSGID_UNAVAILABLE,
 229         RDAC_MSGID_INQUIRY_FAILED,
 230 };
 231
 232 #define _IDX(x) (RDAC_MSGID_##x - CHECKER_FIRST_MSGID)
 233 const char *libcheck_msgtable[] = {
 234         [_IDX(NOT_CONN)] = MSG_RDAC_DOWN_TYPE("lun not connected"),
 235         [_IDX(IN_STARTUP)] = MSG_RDAC_DOWN_TYPE("ctlr is in startup sequence"),
 236         [_IDX(NON_RESPONSIVE)] =
 237         MSG_RDAC_DOWN_TYPE("non-responsive to queries"),
 238         [_IDX(IN_RESET)] = MSG_RDAC_DOWN_TYPE("ctlr held in reset"),
 239         [_IDX(FW_DOWNLOADING)] =
 240         MSG_RDAC_DOWN_TYPE("ctlr firmware downloading"),
 241         [_IDX(QUIESCED)] = MSG_RDAC_DOWN_TYPE("ctlr quiesced by admin request"),
 242         [_IDX(SERVICE_MODE)] = MSG_RDAC_DOWN_TYPE("ctlr is in service mode"),
 243         [_IDX(UNAVAILABLE)] = MSG_RDAC_DOWN_TYPE("ctlr is unavailable"),
 244         [_IDX(INQUIRY_FAILED)] = MSG_RDAC_DOWN_TYPE("inquiry failed"),
 245         NULL,
 246 };
 247
 248 static int
 249 checker_msg_string(const struct volume_access_inq *inq)
 250 {
 251         /* lun not connected */
 252         if (((inq->PQ_PDT & 0xE0) == 0x20) || (inq->PQ_PDT & 0x7f))
 253                 return RDAC_MSGID_NOT_CONN;
 254
 255         /* if no tpg data is available, give the generic path down message */
 256         if (!(inq->avtcvp & 0x10))
 257                 return CHECKER_MSGID_DOWN;
 258
 259         /* controller is booting up */
 260         if (((inq->aas_cur & 0x0F) == RTPG_TRANSITIONING) &&
 261                 (inq->aas_alt & 0x0F) != RTPG_TRANSITIONING)
 262                 return RDAC_MSGID_IN_STARTUP;
 263
 264         /* if not unavailable, give generic message */
 265         if ((inq->aas_cur & 0x0F) != RTPG_UNAVAILABLE)
 266                 return CHECKER_MSGID_DOWN;
 267
 268         /* target port group unavailable */
 269         switch (inq->vendor_specific_cur) {
 270         case RTPG_UNAVAIL_NON_RESPONSIVE:
 271                 return RDAC_MSGID_NON_RESPONSIVE;
 272         case RTPG_UNAVAIL_IN_RESET:
 273                 return RDAC_MSGID_IN_RESET;
 274         case RTPG_UNAVAIL_CFW_DL1:
 275         case RTPG_UNAVAIL_CFW_DL2:
 276                 return RDAC_MSGID_FW_DOWNLOADING;
 277         case RTPG_UNAVAIL_QUIESCED:
 278                 return RDAC_MSGID_QUIESCED;
 279         case RTPG_UNAVAIL_SERVICE_MODE:
 280                 return RDAC_MSGID_SERVICE_MODE;
 281         default:
 282                 return RDAC_MSGID_UNAVAILABLE;
 283         }
 284 }
 285
 286 int libcheck_check(struct checker * c)
 287 {
 288         struct volume_access_inq inq;
 289         int ret, inqfail;
 290
 291         inqfail = 0;
 292         memset(&inq, 0, sizeof(struct volume_access_inq));
 293         if (0 != do_inq(c->fd, 0xC9, &inq, sizeof(struct volume_access_inq),
 294                         c->timeout)) {
 295                 ret = PATH_DOWN;
 296                 inqfail = 1;
 297                 goto done;
 298         } else if (((inq.PQ_PDT & 0xE0) == 0x20) || (inq.PQ_PDT & 0x7f)) {
 299                 /* LUN not connected*/
 300                 ret = PATH_DOWN;
 301                 goto done;
 302         }
 303
 304         /* If TPGDE bit set, evaluate TPG information */
 305         if ((inq.avtcvp & 0x10)) {
 306                 switch (inq.aas_cur & 0x0F) {
 307                 /* Never use the path if it reports unavailable */
 308                 case RTPG_UNAVAILABLE:
 309                         ret = PATH_DOWN;
 310                         goto done;
 311                 /*
 312                  * If both controllers report transitioning, it
 313                  * means mode select or STPG is being processed.
 314                  *
 315                  * If this controller alone is transitioning, it's
 316                  * booting and we shouldn't use it yet.
 317                  */
 318                 case RTPG_TRANSITIONING:
 319                         if ((inq.aas_alt & 0xF) != RTPG_TRANSITIONING) {
 320                                 ret = PATH_DOWN;
 321                                 goto done;
 322                         }
 323                         break;
 324                 }
 325         }
 326
 327         /* If owner set or ioship mode is enabled return PATH_UP always */
 328         if ((inq.avtcvp & 0x1) || ((inq.avtcvp >> 5) & 0x1))
 329                 ret = PATH_UP;
 330         else
 331                 ret = PATH_GHOST;
 332
 333 done:
 334         switch (ret) {
 335         case PATH_DOWN:
 336                 c->msgid = (inqfail ? RDAC_MSGID_INQUIRY_FAILED :
 337                             checker_msg_string(&inq));
 338                 break;
 339         case PATH_UP:
 340                 c->msgid = CHECKER_MSGID_UP;
 341                 break;
 342         case PATH_GHOST:
 343                 c->msgid = CHECKER_MSGID_GHOST;
 344                 break;
 345         }
 346
 347         return ret;
 348 }