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