git.oblomov.eu Git - linux-2.6/blob - 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");