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