266f8e1090821987e37cbc38c6c904ae0abf3bca
[multipath-tools/.git] / 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 }