ACPICA: Fix for resource descriptor optimization issues for _CRS/_SRC
[linux-2.6] / drivers / md / dm-mpath-hp-sw.c
1 /*
2  * Copyright (C) 2005 Mike Christie, All rights reserved.
3  * Copyright (C) 2007 Red Hat, Inc. All rights reserved.
4  * Authors: Mike Christie
5  *          Dave Wysochanski
6  *
7  * This file is released under the GPL.
8  *
9  * This module implements the specific path activation code for
10  * HP StorageWorks and FSC FibreCat Asymmetric (Active/Passive)
11  * storage arrays.
12  * These storage arrays have controller-based failover, not
13  * LUN-based failover.  However, LUN-based failover is the design
14  * of dm-multipath. Thus, this module is written for LUN-based failover.
15  */
16 #include <linux/blkdev.h>
17 #include <linux/list.h>
18 #include <linux/types.h>
19 #include <scsi/scsi.h>
20 #include <scsi/scsi_cmnd.h>
21 #include <scsi/scsi_dbg.h>
22
23 #include "dm.h"
24 #include "dm-hw-handler.h"
25
26 #define DM_MSG_PREFIX "multipath hp-sw"
27 #define DM_HP_HWH_NAME "hp-sw"
28 #define DM_HP_HWH_VER "1.0.0"
29
30 struct hp_sw_context {
31         unsigned char sense[SCSI_SENSE_BUFFERSIZE];
32 };
33
34 /*
35  * hp_sw_error_is_retryable - Is an HP-specific check condition retryable?
36  * @req: path activation request
37  *
38  * Examine error codes of request and determine whether the error is retryable.
39  * Some error codes are already retried by scsi-ml (see
40  * scsi_decide_disposition), but some HP specific codes are not.
41  * The intent of this routine is to supply the logic for the HP specific
42  * check conditions.
43  *
44  * Returns:
45  *  1 - command completed with retryable error
46  *  0 - command completed with non-retryable error
47  *
48  * Possible optimizations
49  * 1. More hardware-specific error codes
50  */
51 static int hp_sw_error_is_retryable(struct request *req)
52 {
53         /*
54          * NOT_READY is known to be retryable
55          * For now we just dump out the sense data and call it retryable
56          */
57         if (status_byte(req->errors) == CHECK_CONDITION)
58                 __scsi_print_sense(DM_HP_HWH_NAME, req->sense, req->sense_len);
59
60         /*
61          * At this point we don't have complete information about all the error
62          * codes from this hardware, so we are just conservative and retry
63          * when in doubt.
64          */
65         return 1;
66 }
67
68 /*
69  * hp_sw_end_io - Completion handler for HP path activation.
70  * @req: path activation request
71  * @error: scsi-ml error
72  *
73  *  Check sense data, free request structure, and notify dm that
74  *  pg initialization has completed.
75  *
76  * Context: scsi-ml softirq
77  *
78  */
79 static void hp_sw_end_io(struct request *req, int error)
80 {
81         struct dm_path *path = req->end_io_data;
82         unsigned err_flags = 0;
83
84         if (!error) {
85                 DMDEBUG("%s path activation command - success",
86                         path->dev->name);
87                 goto out;
88         }
89
90         if (hp_sw_error_is_retryable(req)) {
91                 DMDEBUG("%s path activation command - retry",
92                         path->dev->name);
93                 err_flags = MP_RETRY;
94                 goto out;
95         }
96
97         DMWARN("%s path activation fail - error=0x%x",
98                path->dev->name, error);
99         err_flags = MP_FAIL_PATH;
100
101 out:
102         req->end_io_data = NULL;
103         __blk_put_request(req->q, req);
104         dm_pg_init_complete(path, err_flags);
105 }
106
107 /*
108  * hp_sw_get_request - Allocate an HP specific path activation request
109  * @path: path on which request will be sent (needed for request queue)
110  *
111  * The START command is used for path activation request.
112  * These arrays are controller-based failover, not LUN based.
113  * One START command issued to a single path will fail over all
114  * LUNs for the same controller.
115  *
116  * Possible optimizations
117  * 1. Make timeout configurable
118  * 2. Preallocate request
119  */
120 static struct request *hp_sw_get_request(struct dm_path *path)
121 {
122         struct request *req;
123         struct block_device *bdev = path->dev->bdev;
124         struct request_queue *q = bdev_get_queue(bdev);
125         struct hp_sw_context *h = path->hwhcontext;
126
127         req = blk_get_request(q, WRITE, GFP_NOIO);
128         if (!req)
129                 goto out;
130
131         req->timeout = 60 * HZ;
132
133         req->errors = 0;
134         req->cmd_type = REQ_TYPE_BLOCK_PC;
135         req->cmd_flags |= REQ_FAILFAST | REQ_NOMERGE;
136         req->end_io_data = path;
137         req->sense = h->sense;
138         memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
139
140         memset(&req->cmd, 0, BLK_MAX_CDB);
141         req->cmd[0] = START_STOP;
142         req->cmd[4] = 1;
143         req->cmd_len = COMMAND_SIZE(req->cmd[0]);
144
145 out:
146         return req;
147 }
148
149 /*
150  * hp_sw_pg_init - HP path activation implementation.
151  * @hwh: hardware handler specific data
152  * @bypassed: unused; is the path group bypassed? (see dm-mpath.c)
153  * @path: path to send initialization command
154  *
155  * Send an HP-specific path activation command on 'path'.
156  * Do not try to optimize in any way, just send the activation command.
157  * More than one path activation command may be sent to the same controller.
158  * This seems to work fine for basic failover support.
159  *
160  * Possible optimizations
161  * 1. Detect an in-progress activation request and avoid submitting another one
162  * 2. Model the controller and only send a single activation request at a time
163  * 3. Determine the state of a path before sending an activation request
164  *
165  * Context: kmpathd (see process_queued_ios() in dm-mpath.c)
166  */
167 static void hp_sw_pg_init(struct hw_handler *hwh, unsigned bypassed,
168                           struct dm_path *path)
169 {
170         struct request *req;
171         struct hp_sw_context *h;
172
173         path->hwhcontext = hwh->context;
174         h = hwh->context;
175
176         req = hp_sw_get_request(path);
177         if (!req) {
178                 DMERR("%s path activation command - allocation fail",
179                       path->dev->name);
180                 goto retry;
181         }
182
183         DMDEBUG("%s path activation command - sent", path->dev->name);
184
185         blk_execute_rq_nowait(req->q, NULL, req, 1, hp_sw_end_io);
186         return;
187
188 retry:
189         dm_pg_init_complete(path, MP_RETRY);
190 }
191
192 static int hp_sw_create(struct hw_handler *hwh, unsigned argc, char **argv)
193 {
194         struct hp_sw_context *h;
195
196         h = kmalloc(sizeof(*h), GFP_KERNEL);
197         if (!h)
198                 return -ENOMEM;
199
200         hwh->context = h;
201
202         return 0;
203 }
204
205 static void hp_sw_destroy(struct hw_handler *hwh)
206 {
207         struct hp_sw_context *h = hwh->context;
208
209         kfree(h);
210 }
211
212 static struct hw_handler_type hp_sw_hwh = {
213         .name = DM_HP_HWH_NAME,
214         .module = THIS_MODULE,
215         .create = hp_sw_create,
216         .destroy = hp_sw_destroy,
217         .pg_init = hp_sw_pg_init,
218 };
219
220 static int __init hp_sw_init(void)
221 {
222         int r;
223
224         r = dm_register_hw_handler(&hp_sw_hwh);
225         if (r < 0)
226                 DMERR("register failed %d", r);
227         else
228                 DMINFO("version " DM_HP_HWH_VER " loaded");
229
230         return r;
231 }
232
233 static void __exit hp_sw_exit(void)
234 {
235         int r;
236
237         r = dm_unregister_hw_handler(&hp_sw_hwh);
238         if (r < 0)
239                 DMERR("unregister failed %d", r);
240 }
241
242 module_init(hp_sw_init);
243 module_exit(hp_sw_exit);
244
245 MODULE_DESCRIPTION("DM Multipath HP StorageWorks / FSC FibreCat (A/P) support");
246 MODULE_AUTHOR("Mike Christie, Dave Wysochanski <dm-devel@redhat.com>");
247 MODULE_LICENSE("GPL");
248 MODULE_VERSION(DM_HP_HWH_VER);