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