xref: /openbmc/linux/drivers/scsi/scsi_dh.c (revision bbecb07f)
1 /*
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 
24 #include <linux/slab.h>
25 #include <linux/module.h>
26 #include <scsi/scsi_dh.h>
27 #include "scsi_priv.h"
28 
29 static DEFINE_SPINLOCK(list_lock);
30 static LIST_HEAD(scsi_dh_list);
31 
32 struct scsi_dh_blist {
33 	const char *vendor;
34 	const char *model;
35 	const char *driver;
36 };
37 
38 static const struct scsi_dh_blist scsi_dh_blist[] = {
39 	{"DGC", "RAID",			"emc" },
40 	{"DGC", "DISK",			"emc" },
41 	{"DGC", "VRAID",		"emc" },
42 
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 
75 static const char *
76 scsi_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 
93 static struct scsi_device_handler *__scsi_dh_lookup(const char *name)
94 {
95 	struct scsi_device_handler *tmp, *found = NULL;
96 
97 	spin_lock(&list_lock);
98 	list_for_each_entry(tmp, &scsi_dh_list, list) {
99 		if (!strncmp(tmp->name, name, strlen(tmp->name))) {
100 			found = tmp;
101 			break;
102 		}
103 	}
104 	spin_unlock(&list_lock);
105 	return found;
106 }
107 
108 static 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) {
114 		request_module("scsi_dh_%s", name);
115 		dh = __scsi_dh_lookup(name);
116 	}
117 
118 	return dh;
119 }
120 
121 /*
122  * 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  */
126 static int scsi_dh_handler_attach(struct scsi_device *sdev,
127 				  struct scsi_device_handler *scsi_dh)
128 {
129 	int error, ret = 0;
130 
131 	if (!try_module_get(scsi_dh->module))
132 		return -EINVAL;
133 
134 	error = scsi_dh->attach(sdev);
135 	if (error != SCSI_DH_OK) {
136 		switch (error) {
137 		case SCSI_DH_NOMEM:
138 			ret = -ENOMEM;
139 			break;
140 		case SCSI_DH_RES_TEMP_UNAVAIL:
141 			ret = -EAGAIN;
142 			break;
143 		case SCSI_DH_DEV_UNSUPP:
144 		case SCSI_DH_NOSYS:
145 			ret = -ENODEV;
146 			break;
147 		default:
148 			ret = -EINVAL;
149 			break;
150 		}
151 		if (ret != -ENODEV)
152 			sdev_printk(KERN_ERR, sdev, "%s: Attach failed (%d)\n",
153 				    scsi_dh->name, error);
154 		module_put(scsi_dh->module);
155 	} else
156 		sdev->handler = scsi_dh;
157 
158 	return ret;
159 }
160 
161 /*
162  * scsi_dh_handler_detach - Detach a device handler from a device
163  * @sdev - SCSI device the device handler should be detached from
164  */
165 static void scsi_dh_handler_detach(struct scsi_device *sdev)
166 {
167 	sdev->handler->detach(sdev);
168 	sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", sdev->handler->name);
169 	module_put(sdev->handler->module);
170 }
171 
172 void scsi_dh_add_device(struct scsi_device *sdev)
173 {
174 	struct scsi_device_handler *devinfo = NULL;
175 	const char *drv;
176 
177 	drv = scsi_dh_find_driver(sdev);
178 	if (drv)
179 		devinfo = __scsi_dh_lookup(drv);
180 	/*
181 	 * device_handler is optional, so ignore errors
182 	 * from scsi_dh_handler_attach()
183 	 */
184 	if (devinfo)
185 		(void)scsi_dh_handler_attach(sdev, devinfo);
186 }
187 
188 void scsi_dh_release_device(struct scsi_device *sdev)
189 {
190 	if (sdev->handler)
191 		scsi_dh_handler_detach(sdev);
192 }
193 
194 /*
195  * scsi_register_device_handler - register a device handler personality
196  *      module.
197  * @scsi_dh - device handler to be registered.
198  *
199  * Returns 0 on success, -EBUSY if handler already registered.
200  */
201 int scsi_register_device_handler(struct scsi_device_handler *scsi_dh)
202 {
203 	if (__scsi_dh_lookup(scsi_dh->name))
204 		return -EBUSY;
205 
206 	if (!scsi_dh->attach || !scsi_dh->detach)
207 		return -EINVAL;
208 
209 	spin_lock(&list_lock);
210 	list_add(&scsi_dh->list, &scsi_dh_list);
211 	spin_unlock(&list_lock);
212 
213 	printk(KERN_INFO "%s: device handler registered\n", scsi_dh->name);
214 
215 	return SCSI_DH_OK;
216 }
217 EXPORT_SYMBOL_GPL(scsi_register_device_handler);
218 
219 /*
220  * scsi_unregister_device_handler - register a device handler personality
221  *      module.
222  * @scsi_dh - device handler to be unregistered.
223  *
224  * Returns 0 on success, -ENODEV if handler not registered.
225  */
226 int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh)
227 {
228 	if (!__scsi_dh_lookup(scsi_dh->name))
229 		return -ENODEV;
230 
231 	spin_lock(&list_lock);
232 	list_del(&scsi_dh->list);
233 	spin_unlock(&list_lock);
234 	printk(KERN_INFO "%s: device handler unregistered\n", scsi_dh->name);
235 
236 	return SCSI_DH_OK;
237 }
238 EXPORT_SYMBOL_GPL(scsi_unregister_device_handler);
239 
240 /*
241  * scsi_dh_activate - activate the path associated with the scsi_device
242  *      corresponding to the given request queue.
243  *     Returns immediately without waiting for activation to be completed.
244  * @q    - Request queue that is associated with the scsi_device to be
245  *         activated.
246  * @fn   - Function to be called upon completion of the activation.
247  *         Function fn is called with data (below) and the error code.
248  *         Function fn may be called from the same calling context. So,
249  *         do not hold the lock in the caller which may be needed in fn.
250  * @data - data passed to the function fn upon completion.
251  *
252  */
253 int scsi_dh_activate(struct request_queue *q, activate_complete fn, void *data)
254 {
255 	struct scsi_device *sdev;
256 	int err = SCSI_DH_NOSYS;
257 
258 	sdev = scsi_device_from_queue(q);
259 	if (!sdev) {
260 		if (fn)
261 			fn(data, err);
262 		return err;
263 	}
264 
265 	if (!sdev->handler)
266 		goto out_fn;
267 	err = SCSI_DH_NOTCONN;
268 	if (sdev->sdev_state == SDEV_CANCEL ||
269 	    sdev->sdev_state == SDEV_DEL)
270 		goto out_fn;
271 
272 	err = SCSI_DH_DEV_OFFLINED;
273 	if (sdev->sdev_state == SDEV_OFFLINE)
274 		goto out_fn;
275 
276 	if (sdev->handler->activate)
277 		err = sdev->handler->activate(sdev, fn, data);
278 
279 out_put_device:
280 	put_device(&sdev->sdev_gendev);
281 	return err;
282 
283 out_fn:
284 	if (fn)
285 		fn(data, err);
286 	goto out_put_device;
287 }
288 EXPORT_SYMBOL_GPL(scsi_dh_activate);
289 
290 /*
291  * scsi_dh_set_params - set the parameters for the device as per the
292  *      string specified in params.
293  * @q - Request queue that is associated with the scsi_device for
294  *      which the parameters to be set.
295  * @params - parameters in the following format
296  *      "no_of_params\0param1\0param2\0param3\0...\0"
297  *      for example, string for 2 parameters with value 10 and 21
298  *      is specified as "2\010\021\0".
299  */
300 int scsi_dh_set_params(struct request_queue *q, const char *params)
301 {
302 	struct scsi_device *sdev;
303 	int err = -SCSI_DH_NOSYS;
304 
305 	sdev = scsi_device_from_queue(q);
306 	if (!sdev)
307 		return err;
308 
309 	if (sdev->handler && sdev->handler->set_params)
310 		err = sdev->handler->set_params(sdev, params);
311 	put_device(&sdev->sdev_gendev);
312 	return err;
313 }
314 EXPORT_SYMBOL_GPL(scsi_dh_set_params);
315 
316 /*
317  * scsi_dh_attach - Attach device handler
318  * @q - Request queue that is associated with the scsi_device
319  *      the handler should be attached to
320  * @name - name of the handler to attach
321  */
322 int scsi_dh_attach(struct request_queue *q, const char *name)
323 {
324 	struct scsi_device *sdev;
325 	struct scsi_device_handler *scsi_dh;
326 	int err = 0;
327 
328 	sdev = scsi_device_from_queue(q);
329 	if (!sdev)
330 		return -ENODEV;
331 
332 	scsi_dh = scsi_dh_lookup(name);
333 	if (!scsi_dh) {
334 		err = -EINVAL;
335 		goto out_put_device;
336 	}
337 
338 	if (sdev->handler) {
339 		if (sdev->handler != scsi_dh)
340 			err = -EBUSY;
341 		goto out_put_device;
342 	}
343 
344 	err = scsi_dh_handler_attach(sdev, scsi_dh);
345 
346 out_put_device:
347 	put_device(&sdev->sdev_gendev);
348 	return err;
349 }
350 EXPORT_SYMBOL_GPL(scsi_dh_attach);
351 
352 /*
353  * scsi_dh_attached_handler_name - Get attached device handler's name
354  * @q - Request queue that is associated with the scsi_device
355  *      that may have a device handler attached
356  * @gfp - the GFP mask used in the kmalloc() call when allocating memory
357  *
358  * Returns name of attached handler, NULL if no handler is attached.
359  * Caller must take care to free the returned string.
360  */
361 const char *scsi_dh_attached_handler_name(struct request_queue *q, gfp_t gfp)
362 {
363 	struct scsi_device *sdev;
364 	const char *handler_name = NULL;
365 
366 	sdev = scsi_device_from_queue(q);
367 	if (!sdev)
368 		return NULL;
369 
370 	if (sdev->handler)
371 		handler_name = kstrdup(sdev->handler->name, gfp);
372 	put_device(&sdev->sdev_gendev);
373 	return handler_name;
374 }
375 EXPORT_SYMBOL_GPL(scsi_dh_attached_handler_name);
376