drivers/scsi/scsi_dh.c

   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);