| 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", "clariion" }, |
| 40 | {"DGC", "DISK", "clariion" }, |
| 41 | {"DGC", "VRAID", "clariion" }, |
| 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; |
| 130 | |
| 131 | if (!try_module_get(scsi_dh->module)) |
| 132 | return -EINVAL; |
| 133 | |
| 134 | error = scsi_dh->attach(sdev); |
| 135 | if (error) { |
| 136 | sdev_printk(KERN_ERR, sdev, "%s: Attach failed (%d)\n", |
| 137 | scsi_dh->name, error); |
| 138 | module_put(scsi_dh->module); |
| 139 | } else |
| 140 | sdev->handler = scsi_dh; |
| 141 | |
| 142 | return error; |
| 143 | } |
| 144 | |
| 145 | /* |
| 146 | * scsi_dh_handler_detach - Detach a device handler from a device |
| 147 | * @sdev - SCSI device the device handler should be detached from |
| 148 | */ |
| 149 | static void scsi_dh_handler_detach(struct scsi_device *sdev) |
| 150 | { |
| 151 | sdev->handler->detach(sdev); |
| 152 | sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", sdev->handler->name); |
| 153 | module_put(sdev->handler->module); |
| 154 | } |
| 155 | |
| 156 | int scsi_dh_add_device(struct scsi_device *sdev) |
| 157 | { |
| 158 | struct scsi_device_handler *devinfo = NULL; |
| 159 | const char *drv; |
| 160 | int err = 0; |
| 161 | |
| 162 | drv = scsi_dh_find_driver(sdev); |
| 163 | if (drv) |
| 164 | devinfo = __scsi_dh_lookup(drv); |
| 165 | if (devinfo) |
| 166 | err = scsi_dh_handler_attach(sdev, devinfo); |
| 167 | return err; |
| 168 | } |
| 169 | |
| 170 | void scsi_dh_release_device(struct scsi_device *sdev) |
| 171 | { |
| 172 | if (sdev->handler) |
| 173 | scsi_dh_handler_detach(sdev); |
| 174 | } |
| 175 | |
| 176 | /* |
| 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 | */ |
| 183 | int scsi_register_device_handler(struct scsi_device_handler *scsi_dh) |
| 184 | { |
| 185 | if (__scsi_dh_lookup(scsi_dh->name)) |
| 186 | return -EBUSY; |
| 187 | |
| 188 | if (!scsi_dh->attach || !scsi_dh->detach) |
| 189 | return -EINVAL; |
| 190 | |
| 191 | spin_lock(&list_lock); |
| 192 | list_add(&scsi_dh->list, &scsi_dh_list); |
| 193 | spin_unlock(&list_lock); |
| 194 | |
| 195 | printk(KERN_INFO "%s: device handler registered\n", scsi_dh->name); |
| 196 | |
| 197 | return SCSI_DH_OK; |
| 198 | } |
| 199 | EXPORT_SYMBOL_GPL(scsi_register_device_handler); |
| 200 | |
| 201 | /* |
| 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 | */ |
| 208 | int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh) |
| 209 | { |
| 210 | if (!__scsi_dh_lookup(scsi_dh->name)) |
| 211 | return -ENODEV; |
| 212 | |
| 213 | spin_lock(&list_lock); |
| 214 | list_del(&scsi_dh->list); |
| 215 | spin_unlock(&list_lock); |
| 216 | printk(KERN_INFO "%s: device handler unregistered\n", scsi_dh->name); |
| 217 | |
| 218 | return SCSI_DH_OK; |
| 219 | } |
| 220 | EXPORT_SYMBOL_GPL(scsi_unregister_device_handler); |
| 221 | |
| 222 | static 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 | |
| 236 | /* |
| 237 | * scsi_dh_activate - activate the path associated with the scsi_device |
| 238 | * corresponding to the given request queue. |
| 239 | * 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 | * |
| 248 | */ |
| 249 | int scsi_dh_activate(struct request_queue *q, activate_complete fn, void *data) |
| 250 | { |
| 251 | struct scsi_device *sdev; |
| 252 | int err = SCSI_DH_NOSYS; |
| 253 | |
| 254 | sdev = get_sdev_from_queue(q); |
| 255 | if (!sdev) { |
| 256 | if (fn) |
| 257 | fn(data, err); |
| 258 | return err; |
| 259 | } |
| 260 | |
| 261 | if (!sdev->handler) |
| 262 | goto out_fn; |
| 263 | err = SCSI_DH_NOTCONN; |
| 264 | if (sdev->sdev_state == SDEV_CANCEL || |
| 265 | sdev->sdev_state == SDEV_DEL) |
| 266 | goto out_fn; |
| 267 | |
| 268 | err = SCSI_DH_DEV_OFFLINED; |
| 269 | if (sdev->sdev_state == SDEV_OFFLINE) |
| 270 | goto out_fn; |
| 271 | |
| 272 | if (sdev->handler->activate) |
| 273 | err = sdev->handler->activate(sdev, fn, data); |
| 274 | |
| 275 | out_put_device: |
| 276 | put_device(&sdev->sdev_gendev); |
| 277 | return err; |
| 278 | |
| 279 | out_fn: |
| 280 | if (fn) |
| 281 | fn(data, err); |
| 282 | goto out_put_device; |
| 283 | } |
| 284 | EXPORT_SYMBOL_GPL(scsi_dh_activate); |
| 285 | |
| 286 | /* |
| 287 | * 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 | */ |
| 296 | int scsi_dh_set_params(struct request_queue *q, const char *params) |
| 297 | { |
| 298 | struct scsi_device *sdev; |
| 299 | int err = -SCSI_DH_NOSYS; |
| 300 | |
| 301 | sdev = get_sdev_from_queue(q); |
| 302 | if (!sdev) |
| 303 | return err; |
| 304 | |
| 305 | if (sdev->handler && sdev->handler->set_params) |
| 306 | err = sdev->handler->set_params(sdev, params); |
| 307 | put_device(&sdev->sdev_gendev); |
| 308 | return err; |
| 309 | } |
| 310 | EXPORT_SYMBOL_GPL(scsi_dh_set_params); |
| 311 | |
| 312 | /* |
| 313 | * scsi_dh_attach - Attach device handler |
| 314 | * @q - Request queue that is associated with the scsi_device |
| 315 | * the handler should be attached to |
| 316 | * @name - name of the handler to attach |
| 317 | */ |
| 318 | int scsi_dh_attach(struct request_queue *q, const char *name) |
| 319 | { |
| 320 | struct scsi_device *sdev; |
| 321 | struct scsi_device_handler *scsi_dh; |
| 322 | int err = 0; |
| 323 | |
| 324 | sdev = get_sdev_from_queue(q); |
| 325 | if (!sdev) |
| 326 | return -ENODEV; |
| 327 | |
| 328 | scsi_dh = scsi_dh_lookup(name); |
| 329 | if (!scsi_dh) { |
| 330 | err = -EINVAL; |
| 331 | goto out_put_device; |
| 332 | } |
| 333 | |
| 334 | if (sdev->handler) { |
| 335 | if (sdev->handler != scsi_dh) |
| 336 | err = -EBUSY; |
| 337 | goto out_put_device; |
| 338 | } |
| 339 | |
| 340 | err = scsi_dh_handler_attach(sdev, scsi_dh); |
| 341 | |
| 342 | out_put_device: |
| 343 | put_device(&sdev->sdev_gendev); |
| 344 | return err; |
| 345 | } |
| 346 | EXPORT_SYMBOL_GPL(scsi_dh_attach); |
| 347 | |
| 348 | /* |
| 349 | * 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 | */ |
| 357 | const char *scsi_dh_attached_handler_name(struct request_queue *q, gfp_t gfp) |
| 358 | { |
| 359 | struct scsi_device *sdev; |
| 360 | const char *handler_name = NULL; |
| 361 | |
| 362 | sdev = get_sdev_from_queue(q); |
| 363 | if (!sdev) |
| 364 | return NULL; |
| 365 | |
| 366 | if (sdev->handler) |
| 367 | handler_name = kstrdup(sdev->handler->name, gfp); |
| 368 | put_device(&sdev->sdev_gendev); |
| 369 | return handler_name; |
| 370 | } |
| 371 | EXPORT_SYMBOL_GPL(scsi_dh_attached_handler_name); |