blob: b8d3b97b217ac552ed6166e4ebe2a1c1483e5ca2 [file] [log] [blame]
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -07001/*
2 * SCSI device handler infrastruture.
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by the
6 * Free Software Foundation; either version 2 of the License, or (at your
7 * option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17 *
18 * Copyright IBM Corporation, 2007
19 * Authors:
20 * Chandra Seetharaman <sekharan@us.ibm.com>
21 * Mike Anderson <andmike@linux.vnet.ibm.com>
22 */
23
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090024#include <linux/slab.h>
Paul Gortmakeracf3368f2011-05-27 09:47:43 -040025#include <linux/module.h>
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -070026#include <scsi/scsi_dh.h>
Christoph Hellwigdaaa8582015-08-27 14:16:56 +020027#include "scsi_priv.h"
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -070028
29static DEFINE_SPINLOCK(list_lock);
30static LIST_HEAD(scsi_dh_list);
31
Christoph Hellwigd95dbff2015-08-27 14:16:58 +020032struct scsi_dh_blist {
33 const char *vendor;
34 const char *model;
35 const char *driver;
36};
37
38static const struct scsi_dh_blist scsi_dh_blist[] = {
Xose Vazquez Perez0ba43a82016-10-07 18:19:57 +020039 {"DGC", "RAID", "emc" },
40 {"DGC", "DISK", "emc" },
41 {"DGC", "VRAID", "emc" },
Christoph Hellwigd95dbff2015-08-27 14:16:58 +020042
43 {"COMPAQ", "MSA1000 VOLUME", "hp_sw" },
44 {"COMPAQ", "HSV110", "hp_sw" },
45 {"HP", "HSV100", "hp_sw"},
46 {"DEC", "HSG80", "hp_sw"},
47
48 {"IBM", "1722", "rdac", },
49 {"IBM", "1724", "rdac", },
50 {"IBM", "1726", "rdac", },
51 {"IBM", "1742", "rdac", },
52 {"IBM", "1745", "rdac", },
53 {"IBM", "1746", "rdac", },
54 {"IBM", "1813", "rdac", },
55 {"IBM", "1814", "rdac", },
56 {"IBM", "1815", "rdac", },
57 {"IBM", "1818", "rdac", },
58 {"IBM", "3526", "rdac", },
59 {"SGI", "TP9", "rdac", },
60 {"SGI", "IS", "rdac", },
61 {"STK", "OPENstorage D280", "rdac", },
62 {"STK", "FLEXLINE 380", "rdac", },
63 {"SUN", "CSM", "rdac", },
64 {"SUN", "LCSM100", "rdac", },
65 {"SUN", "STK6580_6780", "rdac", },
66 {"SUN", "SUN_6180", "rdac", },
67 {"SUN", "ArrayStorage", "rdac", },
68 {"DELL", "MD3", "rdac", },
69 {"NETAPP", "INF-01-00", "rdac", },
70 {"LSI", "INF-01-00", "rdac", },
71 {"ENGENIO", "INF-01-00", "rdac", },
72 {NULL, NULL, NULL },
73};
74
75static const char *
76scsi_dh_find_driver(struct scsi_device *sdev)
77{
78 const struct scsi_dh_blist *b;
79
80 if (scsi_device_tpgs(sdev))
81 return "alua";
82
83 for (b = scsi_dh_blist; b->vendor; b++) {
84 if (!strncmp(sdev->vendor, b->vendor, strlen(b->vendor)) &&
85 !strncmp(sdev->model, b->model, strlen(b->model))) {
86 return b->driver;
87 }
88 }
89 return NULL;
90}
91
92
Christoph Hellwig566079c2015-08-27 14:16:55 +020093static struct scsi_device_handler *__scsi_dh_lookup(const char *name)
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -070094{
95 struct scsi_device_handler *tmp, *found = NULL;
96
97 spin_lock(&list_lock);
98 list_for_each_entry(tmp, &scsi_dh_list, list) {
Hannes Reinecke765cbc62008-07-17 16:52:51 -070099 if (!strncmp(tmp->name, name, strlen(tmp->name))) {
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700100 found = tmp;
101 break;
102 }
103 }
104 spin_unlock(&list_lock);
105 return found;
106}
107
Christoph Hellwig566079c2015-08-27 14:16:55 +0200108static struct scsi_device_handler *scsi_dh_lookup(const char *name)
109{
110 struct scsi_device_handler *dh;
111
112 dh = __scsi_dh_lookup(name);
113 if (!dh) {
Paul Mackerras13788892015-09-26 10:19:15 +1000114 request_module("scsi_dh_%s", name);
Christoph Hellwig566079c2015-08-27 14:16:55 +0200115 dh = __scsi_dh_lookup(name);
116 }
117
118 return dh;
119}
120
Hannes Reinecke6c3633d2011-08-24 10:51:15 +0200121/*
Hannes Reinecke765cbc62008-07-17 16:52:51 -0700122 * scsi_dh_handler_attach - Attach a device handler to a device
123 * @sdev - SCSI device the device handler should attach to
124 * @scsi_dh - The device handler to attach
125 */
126static int scsi_dh_handler_attach(struct scsi_device *sdev,
127 struct scsi_device_handler *scsi_dh)
128{
Christoph Hellwigee14c672015-08-27 14:16:59 +0200129 int error;
Hannes Reinecke765cbc62008-07-17 16:52:51 -0700130
Christoph Hellwig1f12ffa2014-09-13 20:08:44 -0700131 if (!try_module_get(scsi_dh->module))
132 return -EINVAL;
Christoph Hellwig27c888f2014-09-13 19:41:16 -0700133
Christoph Hellwigee14c672015-08-27 14:16:59 +0200134 error = scsi_dh->attach(sdev);
135 if (error) {
136 sdev_printk(KERN_ERR, sdev, "%s: Attach failed (%d)\n",
137 scsi_dh->name, error);
Christoph Hellwig1f12ffa2014-09-13 20:08:44 -0700138 module_put(scsi_dh->module);
Christoph Hellwigee14c672015-08-27 14:16:59 +0200139 } else
140 sdev->handler = scsi_dh;
Christoph Hellwig1f12ffa2014-09-13 20:08:44 -0700141
Christoph Hellwigee14c672015-08-27 14:16:59 +0200142 return error;
Hannes Reinecke765cbc62008-07-17 16:52:51 -0700143}
144
Christoph Hellwig1bab0de2015-08-27 14:16:54 +0200145/*
146 * scsi_dh_handler_detach - Detach a device handler from a device
147 * @sdev - SCSI device the device handler should be detached from
148 */
149static void scsi_dh_handler_detach(struct scsi_device *sdev)
Chandra Seetharaman6c10db72009-06-26 19:30:06 -0700150{
Christoph Hellwigee14c672015-08-27 14:16:59 +0200151 sdev->handler->detach(sdev);
152 sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", sdev->handler->name);
153 module_put(sdev->handler->module);
Chandra Seetharaman6c10db72009-06-26 19:30:06 -0700154}
155
Christoph Hellwig086b91d2015-08-27 14:16:57 +0200156int scsi_dh_add_device(struct scsi_device *sdev)
Hannes Reinecke4c05ae52008-07-17 16:52:57 -0700157{
Christoph Hellwigd95dbff2015-08-27 14:16:58 +0200158 struct scsi_device_handler *devinfo = NULL;
159 const char *drv;
Hannes Reinecke41f95dd2015-12-01 10:16:41 +0100160 int err = 0;
Hannes Reinecke4c05ae52008-07-17 16:52:57 -0700161
Christoph Hellwigd95dbff2015-08-27 14:16:58 +0200162 drv = scsi_dh_find_driver(sdev);
163 if (drv)
Christoph Hellwigd6a32b92015-10-08 09:25:32 +0100164 devinfo = __scsi_dh_lookup(drv);
Christoph Hellwig086b91d2015-08-27 14:16:57 +0200165 if (devinfo)
166 err = scsi_dh_handler_attach(sdev, devinfo);
Hannes Reinecke765cbc62008-07-17 16:52:51 -0700167 return err;
168}
169
Junichi Nomura23695e42015-10-06 04:32:57 +0000170void scsi_dh_release_device(struct scsi_device *sdev)
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700171{
Christoph Hellwigee14c672015-08-27 14:16:59 +0200172 if (sdev->handler)
Christoph Hellwig1bab0de2015-08-27 14:16:54 +0200173 scsi_dh_handler_detach(sdev);
Junichi Nomura23695e42015-10-06 04:32:57 +0000174}
175
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700176/*
177 * scsi_register_device_handler - register a device handler personality
178 * module.
179 * @scsi_dh - device handler to be registered.
180 *
181 * Returns 0 on success, -EBUSY if handler already registered.
182 */
183int scsi_register_device_handler(struct scsi_device_handler *scsi_dh)
184{
Christoph Hellwig566079c2015-08-27 14:16:55 +0200185 if (__scsi_dh_lookup(scsi_dh->name))
Hannes Reinecke765cbc62008-07-17 16:52:51 -0700186 return -EBUSY;
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700187
Christoph Hellwig1f12ffa2014-09-13 20:08:44 -0700188 if (!scsi_dh->attach || !scsi_dh->detach)
189 return -EINVAL;
190
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700191 spin_lock(&list_lock);
192 list_add(&scsi_dh->list, &scsi_dh_list);
193 spin_unlock(&list_lock);
Peter Jones940d7fa2011-01-06 15:38:24 -0500194
Hannes Reinecke765cbc62008-07-17 16:52:51 -0700195 printk(KERN_INFO "%s: device handler registered\n", scsi_dh->name);
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700196
Hannes Reinecke765cbc62008-07-17 16:52:51 -0700197 return SCSI_DH_OK;
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700198}
199EXPORT_SYMBOL_GPL(scsi_register_device_handler);
200
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700201/*
202 * scsi_unregister_device_handler - register a device handler personality
203 * module.
204 * @scsi_dh - device handler to be unregistered.
205 *
206 * Returns 0 on success, -ENODEV if handler not registered.
207 */
208int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh)
209{
Christoph Hellwig566079c2015-08-27 14:16:55 +0200210 if (!__scsi_dh_lookup(scsi_dh->name))
Hannes Reinecke765cbc62008-07-17 16:52:51 -0700211 return -ENODEV;
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700212
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700213 spin_lock(&list_lock);
214 list_del(&scsi_dh->list);
215 spin_unlock(&list_lock);
Hannes Reinecke765cbc62008-07-17 16:52:51 -0700216 printk(KERN_INFO "%s: device handler unregistered\n", scsi_dh->name);
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700217
Hannes Reinecke765cbc62008-07-17 16:52:51 -0700218 return SCSI_DH_OK;
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700219}
220EXPORT_SYMBOL_GPL(scsi_unregister_device_handler);
221
Christoph Hellwige959ed92015-08-27 14:17:00 +0200222static struct scsi_device *get_sdev_from_queue(struct request_queue *q)
223{
224 struct scsi_device *sdev;
225 unsigned long flags;
226
227 spin_lock_irqsave(q->queue_lock, flags);
228 sdev = q->queuedata;
229 if (!sdev || !get_device(&sdev->sdev_gendev))
230 sdev = NULL;
231 spin_unlock_irqrestore(q->queue_lock, flags);
232
233 return sdev;
234}
235
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700236/*
237 * scsi_dh_activate - activate the path associated with the scsi_device
238 * corresponding to the given request queue.
Chandra Seetharaman3ae31f62009-10-21 09:22:46 -0700239 * Returns immediately without waiting for activation to be completed.
240 * @q - Request queue that is associated with the scsi_device to be
241 * activated.
242 * @fn - Function to be called upon completion of the activation.
243 * Function fn is called with data (below) and the error code.
244 * Function fn may be called from the same calling context. So,
245 * do not hold the lock in the caller which may be needed in fn.
246 * @data - data passed to the function fn upon completion.
247 *
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700248 */
Chandra Seetharaman3ae31f62009-10-21 09:22:46 -0700249int scsi_dh_activate(struct request_queue *q, activate_complete fn, void *data)
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700250{
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700251 struct scsi_device *sdev;
Christoph Hellwige959ed92015-08-27 14:17:00 +0200252 int err = SCSI_DH_NOSYS;
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700253
Christoph Hellwige959ed92015-08-27 14:17:00 +0200254 sdev = get_sdev_from_queue(q);
Moger, Babua18a9202011-10-26 14:29:38 -0400255 if (!sdev) {
Moger, Babua18a9202011-10-26 14:29:38 -0400256 if (fn)
257 fn(data, err);
258 return err;
259 }
260
Christoph Hellwige959ed92015-08-27 14:17:00 +0200261 if (!sdev->handler)
262 goto out_fn;
Hannes Reinecke710105f2015-08-27 14:17:02 +0200263 err = SCSI_DH_NOTCONN;
Christoph Hellwige959ed92015-08-27 14:17:00 +0200264 if (sdev->sdev_state == SDEV_CANCEL ||
Menny Hamburgerdb422312010-12-16 14:57:07 -0500265 sdev->sdev_state == SDEV_DEL)
Christoph Hellwige959ed92015-08-27 14:17:00 +0200266 goto out_fn;
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700267
Christoph Hellwige959ed92015-08-27 14:17:00 +0200268 err = SCSI_DH_DEV_OFFLINED;
269 if (sdev->sdev_state == SDEV_OFFLINE)
270 goto out_fn;
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700271
Christoph Hellwigee14c672015-08-27 14:16:59 +0200272 if (sdev->handler->activate)
273 err = sdev->handler->activate(sdev, fn, data);
Christoph Hellwige959ed92015-08-27 14:17:00 +0200274
275out_put_device:
276 put_device(&sdev->sdev_gendev);
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700277 return err;
Christoph Hellwige959ed92015-08-27 14:17:00 +0200278
279out_fn:
280 if (fn)
281 fn(data, err);
282 goto out_put_device;
Chandra Seetharamana6a8d9f2008-05-01 14:49:46 -0700283}
284EXPORT_SYMBOL_GPL(scsi_dh_activate);
285
286/*
Chandra Seetharaman18ee70c2009-08-03 12:42:33 -0700287 * scsi_dh_set_params - set the parameters for the device as per the
288 * string specified in params.
289 * @q - Request queue that is associated with the scsi_device for
290 * which the parameters to be set.
291 * @params - parameters in the following format
292 * "no_of_params\0param1\0param2\0param3\0...\0"
293 * for example, string for 2 parameters with value 10 and 21
294 * is specified as "2\010\021\0".
295 */
296int scsi_dh_set_params(struct request_queue *q, const char *params)
297{
Chandra Seetharaman18ee70c2009-08-03 12:42:33 -0700298 struct scsi_device *sdev;
Christoph Hellwige959ed92015-08-27 14:17:00 +0200299 int err = -SCSI_DH_NOSYS;
Chandra Seetharaman18ee70c2009-08-03 12:42:33 -0700300
Christoph Hellwige959ed92015-08-27 14:17:00 +0200301 sdev = get_sdev_from_queue(q);
302 if (!sdev)
Chandra Seetharaman18ee70c2009-08-03 12:42:33 -0700303 return err;
Christoph Hellwige959ed92015-08-27 14:17:00 +0200304
305 if (sdev->handler && sdev->handler->set_params)
306 err = sdev->handler->set_params(sdev, params);
Chandra Seetharaman18ee70c2009-08-03 12:42:33 -0700307 put_device(&sdev->sdev_gendev);
308 return err;
309}
310EXPORT_SYMBOL_GPL(scsi_dh_set_params);
311
312/*
Hannes Reinecke2a9ab402011-08-24 10:51:14 +0200313 * scsi_dh_attach - Attach device handler
Mike Snitzer7e8a74b2012-06-26 14:32:03 -0400314 * @q - Request queue that is associated with the scsi_device
315 * the handler should be attached to
Hannes Reineckeae11b1b2008-07-17 17:49:02 -0700316 * @name - name of the handler to attach
317 */
318int scsi_dh_attach(struct request_queue *q, const char *name)
319{
Hannes Reineckeae11b1b2008-07-17 17:49:02 -0700320 struct scsi_device *sdev;
321 struct scsi_device_handler *scsi_dh;
322 int err = 0;
323
Christoph Hellwige959ed92015-08-27 14:17:00 +0200324 sdev = get_sdev_from_queue(q);
325 if (!sdev)
326 return -ENODEV;
327
Christoph Hellwig566079c2015-08-27 14:16:55 +0200328 scsi_dh = scsi_dh_lookup(name);
Christoph Hellwige959ed92015-08-27 14:17:00 +0200329 if (!scsi_dh) {
330 err = -EINVAL;
331 goto out_put_device;
332 }
Christoph Hellwig1bab0de2015-08-27 14:16:54 +0200333
Christoph Hellwigee14c672015-08-27 14:16:59 +0200334 if (sdev->handler) {
335 if (sdev->handler != scsi_dh)
Christoph Hellwig1bab0de2015-08-27 14:16:54 +0200336 err = -EBUSY;
337 goto out_put_device;
Hannes Reineckeae11b1b2008-07-17 17:49:02 -0700338 }
Christoph Hellwig1bab0de2015-08-27 14:16:54 +0200339
340 err = scsi_dh_handler_attach(sdev, scsi_dh);
341
342out_put_device:
343 put_device(&sdev->sdev_gendev);
Hannes Reineckeae11b1b2008-07-17 17:49:02 -0700344 return err;
345}
346EXPORT_SYMBOL_GPL(scsi_dh_attach);
347
348/*
Mike Snitzer7e8a74b2012-06-26 14:32:03 -0400349 * scsi_dh_attached_handler_name - Get attached device handler's name
350 * @q - Request queue that is associated with the scsi_device
351 * that may have a device handler attached
352 * @gfp - the GFP mask used in the kmalloc() call when allocating memory
353 *
354 * Returns name of attached handler, NULL if no handler is attached.
355 * Caller must take care to free the returned string.
356 */
357const char *scsi_dh_attached_handler_name(struct request_queue *q, gfp_t gfp)
358{
Mike Snitzer7e8a74b2012-06-26 14:32:03 -0400359 struct scsi_device *sdev;
360 const char *handler_name = NULL;
361
Christoph Hellwige959ed92015-08-27 14:17:00 +0200362 sdev = get_sdev_from_queue(q);
Mike Snitzer7e8a74b2012-06-26 14:32:03 -0400363 if (!sdev)
364 return NULL;
365
Christoph Hellwigee14c672015-08-27 14:16:59 +0200366 if (sdev->handler)
367 handler_name = kstrdup(sdev->handler->name, gfp);
Mike Snitzer7e8a74b2012-06-26 14:32:03 -0400368 put_device(&sdev->sdev_gendev);
369 return handler_name;
370}
371EXPORT_SYMBOL_GPL(scsi_dh_attached_handler_name);