libata-link: update EH to deal with PMP links
[linux-2.6] / drivers / md / dm-emc.c
1 /*
2  * Copyright (C) 2004 SUSE LINUX Products GmbH. All rights reserved.
3  * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
4  *
5  * This file is released under the GPL.
6  *
7  * Multipath support for EMC CLARiiON AX/CX-series hardware.
8  */
9
10 #include "dm.h"
11 #include "dm-hw-handler.h"
12 #include <scsi/scsi.h>
13 #include <scsi/scsi_cmnd.h>
14
15 #define DM_MSG_PREFIX "multipath emc"
16
17 struct emc_handler {
18         spinlock_t lock;
19
20         /* Whether we should send the short trespass command (FC-series)
21          * or the long version (default for AX/CX CLARiiON arrays). */
22         unsigned short_trespass;
23         /* Whether or not to honor SCSI reservations when initiating a
24          * switch-over. Default: Don't. */
25         unsigned hr;
26
27         unsigned char sense[SCSI_SENSE_BUFFERSIZE];
28 };
29
30 #define TRESPASS_PAGE 0x22
31 #define EMC_FAILOVER_TIMEOUT (60 * HZ)
32
33 /* Code borrowed from dm-lsi-rdac by Mike Christie */
34
35 static inline void free_bio(struct bio *bio)
36 {
37         __free_page(bio->bi_io_vec[0].bv_page);
38         bio_put(bio);
39 }
40
41 static void emc_endio(struct bio *bio, int error)
42 {
43         struct dm_path *path = bio->bi_private;
44
45         /* We also need to look at the sense keys here whether or not to
46          * switch to the next PG etc.
47          *
48          * For now simple logic: either it works or it doesn't.
49          */
50         if (error)
51                 dm_pg_init_complete(path, MP_FAIL_PATH);
52         else
53                 dm_pg_init_complete(path, 0);
54
55         /* request is freed in block layer */
56         free_bio(bio);
57
58         return 0;
59 }
60
61 static struct bio *get_failover_bio(struct dm_path *path, unsigned data_size)
62 {
63         struct bio *bio;
64         struct page *page;
65
66         bio = bio_alloc(GFP_ATOMIC, 1);
67         if (!bio) {
68                 DMERR("get_failover_bio: bio_alloc() failed.");
69                 return NULL;
70         }
71
72         bio->bi_rw |= (1 << BIO_RW);
73         bio->bi_bdev = path->dev->bdev;
74         bio->bi_sector = 0;
75         bio->bi_private = path;
76         bio->bi_end_io = emc_endio;
77
78         page = alloc_page(GFP_ATOMIC);
79         if (!page) {
80                 DMERR("get_failover_bio: alloc_page() failed.");
81                 bio_put(bio);
82                 return NULL;
83         }
84
85         if (bio_add_page(bio, page, data_size, 0) != data_size) {
86                 DMERR("get_failover_bio: alloc_page() failed.");
87                 __free_page(page);
88                 bio_put(bio);
89                 return NULL;
90         }
91
92         return bio;
93 }
94
95 static struct request *get_failover_req(struct emc_handler *h,
96                                         struct bio *bio, struct dm_path *path)
97 {
98         struct request *rq;
99         struct block_device *bdev = bio->bi_bdev;
100         struct request_queue *q = bdev_get_queue(bdev);
101
102         /* FIXME: Figure out why it fails with GFP_ATOMIC. */
103         rq = blk_get_request(q, WRITE, __GFP_WAIT);
104         if (!rq) {
105                 DMERR("get_failover_req: blk_get_request failed");
106                 return NULL;
107         }
108
109         blk_rq_append_bio(q, rq, bio);
110
111         rq->sense = h->sense;
112         memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
113         rq->sense_len = 0;
114
115         memset(&rq->cmd, 0, BLK_MAX_CDB);
116
117         rq->timeout = EMC_FAILOVER_TIMEOUT;
118         rq->cmd_type = REQ_TYPE_BLOCK_PC;
119         rq->cmd_flags |= REQ_FAILFAST | REQ_NOMERGE;
120
121         return rq;
122 }
123
124 static struct request *emc_trespass_get(struct emc_handler *h,
125                                         struct dm_path *path)
126 {
127         struct bio *bio;
128         struct request *rq;
129         unsigned char *page22;
130         unsigned char long_trespass_pg[] = {
131                 0, 0, 0, 0,
132                 TRESPASS_PAGE,        /* Page code */
133                 0x09,                 /* Page length - 2 */
134                 h->hr ? 0x01 : 0x81,  /* Trespass code + Honor reservation bit */
135                 0xff, 0xff,           /* Trespass target */
136                 0, 0, 0, 0, 0, 0      /* Reserved bytes / unknown */
137                 };
138         unsigned char short_trespass_pg[] = {
139                 0, 0, 0, 0,
140                 TRESPASS_PAGE,        /* Page code */
141                 0x02,                 /* Page length - 2 */
142                 h->hr ? 0x01 : 0x81,  /* Trespass code + Honor reservation bit */
143                 0xff,                 /* Trespass target */
144                 };
145         unsigned data_size = h->short_trespass ? sizeof(short_trespass_pg) :
146                                 sizeof(long_trespass_pg);
147
148         /* get bio backing */
149         if (data_size > PAGE_SIZE)
150                 /* this should never happen */
151                 return NULL;
152
153         bio = get_failover_bio(path, data_size);
154         if (!bio) {
155                 DMERR("emc_trespass_get: no bio");
156                 return NULL;
157         }
158
159         page22 = (unsigned char *)bio_data(bio);
160         memset(page22, 0, data_size);
161
162         memcpy(page22, h->short_trespass ?
163                 short_trespass_pg : long_trespass_pg, data_size);
164
165         /* get request for block layer packet command */
166         rq = get_failover_req(h, bio, path);
167         if (!rq) {
168                 DMERR("emc_trespass_get: no rq");
169                 free_bio(bio);
170                 return NULL;
171         }
172
173         /* Prepare the command. */
174         rq->cmd[0] = MODE_SELECT;
175         rq->cmd[1] = 0x10;
176         rq->cmd[4] = data_size;
177         rq->cmd_len = COMMAND_SIZE(rq->cmd[0]);
178
179         return rq;
180 }
181
182 static void emc_pg_init(struct hw_handler *hwh, unsigned bypassed,
183                         struct dm_path *path)
184 {
185         struct request *rq;
186         struct request_queue *q = bdev_get_queue(path->dev->bdev);
187
188         /*
189          * We can either blindly init the pg (then look at the sense),
190          * or we can send some commands to get the state here (then
191          * possibly send the fo cmnd), or we can also have the
192          * initial state passed into us and then get an update here.
193          */
194         if (!q) {
195                 DMINFO("emc_pg_init: no queue");
196                 goto fail_path;
197         }
198
199         /* FIXME: The request should be pre-allocated. */
200         rq = emc_trespass_get(hwh->context, path);
201         if (!rq) {
202                 DMERR("emc_pg_init: no rq");
203                 goto fail_path;
204         }
205
206         DMINFO("emc_pg_init: sending switch-over command");
207         elv_add_request(q, rq, ELEVATOR_INSERT_FRONT, 1);
208         return;
209
210 fail_path:
211         dm_pg_init_complete(path, MP_FAIL_PATH);
212 }
213
214 static struct emc_handler *alloc_emc_handler(void)
215 {
216         struct emc_handler *h = kmalloc(sizeof(*h), GFP_KERNEL);
217
218         if (h) {
219                 memset(h, 0, sizeof(*h));
220                 spin_lock_init(&h->lock);
221         }
222
223         return h;
224 }
225
226 static int emc_create(struct hw_handler *hwh, unsigned argc, char **argv)
227 {
228         struct emc_handler *h;
229         unsigned hr, short_trespass;
230
231         if (argc == 0) {
232                 /* No arguments: use defaults */
233                 hr = 0;
234                 short_trespass = 0;
235         } else if (argc != 2) {
236                 DMWARN("incorrect number of arguments");
237                 return -EINVAL;
238         } else {
239                 if ((sscanf(argv[0], "%u", &short_trespass) != 1)
240                         || (short_trespass > 1)) {
241                         DMWARN("invalid trespass mode selected");
242                         return -EINVAL;
243                 }
244
245                 if ((sscanf(argv[1], "%u", &hr) != 1)
246                         || (hr > 1)) {
247                         DMWARN("invalid honor reservation flag selected");
248                         return -EINVAL;
249                 }
250         }
251
252         h = alloc_emc_handler();
253         if (!h)
254                 return -ENOMEM;
255
256         hwh->context = h;
257
258         if ((h->short_trespass = short_trespass))
259                 DMWARN("short trespass command will be send");
260         else
261                 DMWARN("long trespass command will be send");
262
263         if ((h->hr = hr))
264                 DMWARN("honor reservation bit will be set");
265         else
266                 DMWARN("honor reservation bit will not be set (default)");
267
268         return 0;
269 }
270
271 static void emc_destroy(struct hw_handler *hwh)
272 {
273         struct emc_handler *h = (struct emc_handler *) hwh->context;
274
275         kfree(h);
276         hwh->context = NULL;
277 }
278
279 static unsigned emc_error(struct hw_handler *hwh, struct bio *bio)
280 {
281         /* FIXME: Patch from axboe still missing */
282 #if 0
283         int sense;
284
285         if (bio->bi_error & BIO_SENSE) {
286                 sense = bio->bi_error & 0xffffff; /* sense key / asc / ascq */
287
288                 if (sense == 0x020403) {
289                         /* LUN Not Ready - Manual Intervention Required
290                          * indicates this is a passive path.
291                          *
292                          * FIXME: However, if this is seen and EVPD C0
293                          * indicates that this is due to a NDU in
294                          * progress, we should set FAIL_PATH too.
295                          * This indicates we might have to do a SCSI
296                          * inquiry in the end_io path. Ugh. */
297                         return MP_BYPASS_PG | MP_RETRY_IO;
298                 } else if (sense == 0x052501) {
299                         /* An array based copy is in progress. Do not
300                          * fail the path, do not bypass to another PG,
301                          * do not retry. Fail the IO immediately.
302                          * (Actually this is the same conclusion as in
303                          * the default handler, but lets make sure.) */
304                         return 0;
305                 } else if (sense == 0x062900) {
306                         /* Unit Attention Code. This is the first IO
307                          * to the new path, so just retry. */
308                         return MP_RETRY_IO;
309                 }
310         }
311 #endif
312
313         /* Try default handler */
314         return dm_scsi_err_handler(hwh, bio);
315 }
316
317 static struct hw_handler_type emc_hwh = {
318         .name = "emc",
319         .module = THIS_MODULE,
320         .create = emc_create,
321         .destroy = emc_destroy,
322         .pg_init = emc_pg_init,
323         .error = emc_error,
324 };
325
326 static int __init dm_emc_init(void)
327 {
328         int r = dm_register_hw_handler(&emc_hwh);
329
330         if (r < 0)
331                 DMERR("register failed %d", r);
332
333         DMINFO("version 0.0.3 loaded");
334
335         return r;
336 }
337
338 static void __exit dm_emc_exit(void)
339 {
340         int r = dm_unregister_hw_handler(&emc_hwh);
341
342         if (r < 0)
343                 DMERR("unregister failed %d", r);
344 }
345
346 module_init(dm_emc_init);
347 module_exit(dm_emc_exit);
348
349 MODULE_DESCRIPTION(DM_NAME " EMC CX/AX/FC-family multipath");
350 MODULE_AUTHOR("Lars Marowsky-Bree <lmb@suse.de>");
351 MODULE_LICENSE("GPL");