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",                 "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(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         struct scsi_dh_data *d;
 130
 131         if (!try_module_get(scsi_dh->module))
 132                 return -EINVAL;
 133
 134         d = scsi_dh->attach(sdev);
 135         if (IS_ERR(d)) {
 136                 sdev_printk(KERN_ERR, sdev, "%s: Attach failed (%ld)\n",
 137                             scsi_dh->name, PTR_ERR(d));
 138                 module_put(scsi_dh->module);
 139                 return PTR_ERR(d);
 140         }
 141
 142         d->scsi_dh = scsi_dh;
 143         d->sdev = sdev;
 144
 145         spin_lock_irq(sdev->request_queue->queue_lock);
 146         sdev->scsi_dh_data = d;
 147         spin_unlock_irq(sdev->request_queue->queue_lock);
 148         return 0;
 149 }
 150
 151 /*
 152  * scsi_dh_handler_detach - Detach a device handler from a device
 153  * @sdev - SCSI device the device handler should be detached from
 154  */
 155 static void scsi_dh_handler_detach(struct scsi_device *sdev)
 156 {
 157         struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
 158         struct scsi_device_handler *scsi_dh = scsi_dh_data->scsi_dh;
 159
 160         scsi_dh->detach(sdev);
 161
 162         spin_lock_irq(sdev->request_queue->queue_lock);
 163         sdev->scsi_dh_data = NULL;
 164         spin_unlock_irq(sdev->request_queue->queue_lock);
 165
 166         sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", scsi_dh->name);
 167         module_put(scsi_dh->module);
 168 }
 169
 170 /*
 171  * Functions for sysfs attribute 'dh_state'
 172  */
 173 static ssize_t
 174 store_dh_state(struct device *dev, struct device_attribute *attr,
 175                const char *buf, size_t count)
 176 {
 177         struct scsi_device *sdev = to_scsi_device(dev);
 178         struct scsi_device_handler *scsi_dh;
 179         int err = -EINVAL;
 180
 181         if (sdev->sdev_state == SDEV_CANCEL ||
 182             sdev->sdev_state == SDEV_DEL)
 183                 return -ENODEV;
 184
 185         if (!sdev->scsi_dh_data) {
 186                 /*
 187                  * Attach to a device handler
 188                  */
 189                 scsi_dh = scsi_dh_lookup(buf);
 190                 if (!scsi_dh)
 191                         return err;
 192                 err = scsi_dh_handler_attach(sdev, scsi_dh);
 193         } else {
 194                 scsi_dh = sdev->scsi_dh_data->scsi_dh;
 195                 if (!strncmp(buf, "detach", 6)) {
 196                         /*
 197                          * Detach from a device handler
 198                          */
 199                         scsi_dh_handler_detach(sdev);
 200                         err = 0;
 201                 } else if (!strncmp(buf, "activate", 8)) {
 202                         /*
 203                          * Activate a device handler
 204                          */
 205                         if (scsi_dh->activate)
 206                                 err = scsi_dh->activate(sdev, NULL, NULL);
 207                         else
 208                                 err = 0;
 209                 }
 210         }
 211
 212         return err<0?err:count;
 213 }
 214
 215 static ssize_t
 216 show_dh_state(struct device *dev, struct device_attribute *attr, char *buf)
 217 {
 218         struct scsi_device *sdev = to_scsi_device(dev);
 219
 220         if (!sdev->scsi_dh_data)
 221                 return snprintf(buf, 20, "detached\n");
 222
 223         return snprintf(buf, 20, "%s\n", sdev->scsi_dh_data->scsi_dh->name);
 224 }
 225
 226 static struct device_attribute scsi_dh_state_attr =
 227         __ATTR(dh_state, S_IRUGO | S_IWUSR, show_dh_state,
 228                store_dh_state);
 229
 230 int scsi_dh_add_device(struct scsi_device *sdev)
 231 {
 232         struct scsi_device_handler *devinfo = NULL;
 233         const char *drv;
 234         int err;
 235
 236         err = device_create_file(&sdev->sdev_gendev, &scsi_dh_state_attr);
 237         if (err)
 238                 return err;
 239
 240         drv = scsi_dh_find_driver(sdev);
 241         if (drv)
 242                 devinfo = scsi_dh_lookup(drv);
 243         if (devinfo)
 244                 err = scsi_dh_handler_attach(sdev, devinfo);
 245         return err;
 246 }
 247
 248 void scsi_dh_remove_device(struct scsi_device *sdev)
 249 {
 250         if (sdev->scsi_dh_data)
 251                 scsi_dh_handler_detach(sdev);
 252         device_remove_file(&sdev->sdev_gendev, &scsi_dh_state_attr);
 253 }
 254
 255 /*
 256  * scsi_register_device_handler - register a device handler personality
 257  *      module.
 258  * @scsi_dh - device handler to be registered.
 259  *
 260  * Returns 0 on success, -EBUSY if handler already registered.
 261  */
 262 int scsi_register_device_handler(struct scsi_device_handler *scsi_dh)
 263 {
 264         if (__scsi_dh_lookup(scsi_dh->name))
 265                 return -EBUSY;
 266
 267         if (!scsi_dh->attach || !scsi_dh->detach)
 268                 return -EINVAL;
 269
 270         spin_lock(&list_lock);
 271         list_add(&scsi_dh->list, &scsi_dh_list);
 272         spin_unlock(&list_lock);
 273
 274         printk(KERN_INFO "%s: device handler registered\n", scsi_dh->name);
 275
 276         return SCSI_DH_OK;
 277 }
 278 EXPORT_SYMBOL_GPL(scsi_register_device_handler);
 279
 280 /*
 281  * scsi_unregister_device_handler - register a device handler personality
 282  *      module.
 283  * @scsi_dh - device handler to be unregistered.
 284  *
 285  * Returns 0 on success, -ENODEV if handler not registered.
 286  */
 287 int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh)
 288 {
 289         if (!__scsi_dh_lookup(scsi_dh->name))
 290                 return -ENODEV;
 291
 292         spin_lock(&list_lock);
 293         list_del(&scsi_dh->list);
 294         spin_unlock(&list_lock);
 295         printk(KERN_INFO "%s: device handler unregistered\n", scsi_dh->name);
 296
 297         return SCSI_DH_OK;
 298 }
 299 EXPORT_SYMBOL_GPL(scsi_unregister_device_handler);
 300
 301 /*
 302  * scsi_dh_activate - activate the path associated with the scsi_device
 303  *      corresponding to the given request queue.
 304  *     Returns immediately without waiting for activation to be completed.
 305  * @q    - Request queue that is associated with the scsi_device to be
 306  *         activated.
 307  * @fn   - Function to be called upon completion of the activation.
 308  *         Function fn is called with data (below) and the error code.
 309  *         Function fn may be called from the same calling context. So,
 310  *         do not hold the lock in the caller which may be needed in fn.
 311  * @data - data passed to the function fn upon completion.
 312  *
 313  */
 314 int scsi_dh_activate(struct request_queue *q, activate_complete fn, void *data)
 315 {
 316         int err = 0;
 317         unsigned long flags;
 318         struct scsi_device *sdev;
 319         struct scsi_device_handler *scsi_dh = NULL;
 320         struct device *dev = NULL;
 321
 322         spin_lock_irqsave(q->queue_lock, flags);
 323         sdev = q->queuedata;
 324         if (!sdev) {
 325                 spin_unlock_irqrestore(q->queue_lock, flags);
 326                 err = SCSI_DH_NOSYS;
 327                 if (fn)
 328                         fn(data, err);
 329                 return err;
 330         }
 331
 332         if (sdev->scsi_dh_data)
 333                 scsi_dh = sdev->scsi_dh_data->scsi_dh;
 334         dev = get_device(&sdev->sdev_gendev);
 335         if (!scsi_dh || !dev ||
 336             sdev->sdev_state == SDEV_CANCEL ||
 337             sdev->sdev_state == SDEV_DEL)
 338                 err = SCSI_DH_NOSYS;
 339         if (sdev->sdev_state == SDEV_OFFLINE)
 340                 err = SCSI_DH_DEV_OFFLINED;
 341         spin_unlock_irqrestore(q->queue_lock, flags);
 342
 343         if (err) {
 344                 if (fn)
 345                         fn(data, err);
 346                 goto out;
 347         }
 348
 349         if (scsi_dh->activate)
 350                 err = scsi_dh->activate(sdev, fn, data);
 351 out:
 352         put_device(dev);
 353         return err;
 354 }
 355 EXPORT_SYMBOL_GPL(scsi_dh_activate);
 356
 357 /*
 358  * scsi_dh_set_params - set the parameters for the device as per the
 359  *      string specified in params.
 360  * @q - Request queue that is associated with the scsi_device for
 361  *      which the parameters to be set.
 362  * @params - parameters in the following format
 363  *      "no_of_params\0param1\0param2\0param3\0...\0"
 364  *      for example, string for 2 parameters with value 10 and 21
 365  *      is specified as "2\010\021\0".
 366  */
 367 int scsi_dh_set_params(struct request_queue *q, const char *params)
 368 {
 369         int err = -SCSI_DH_NOSYS;
 370         unsigned long flags;
 371         struct scsi_device *sdev;
 372         struct scsi_device_handler *scsi_dh = NULL;
 373
 374         spin_lock_irqsave(q->queue_lock, flags);
 375         sdev = q->queuedata;
 376         if (sdev && sdev->scsi_dh_data)
 377                 scsi_dh = sdev->scsi_dh_data->scsi_dh;
 378         if (scsi_dh && scsi_dh->set_params && get_device(&sdev->sdev_gendev))
 379                 err = 0;
 380         spin_unlock_irqrestore(q->queue_lock, flags);
 381
 382         if (err)
 383                 return err;
 384         err = scsi_dh->set_params(sdev, params);
 385         put_device(&sdev->sdev_gendev);
 386         return err;
 387 }
 388 EXPORT_SYMBOL_GPL(scsi_dh_set_params);
 389
 390 /*
 391  * scsi_dh_attach - Attach device handler
 392  * @q - Request queue that is associated with the scsi_device
 393  *      the handler should be attached to
 394  * @name - name of the handler to attach
 395  */
 396 int scsi_dh_attach(struct request_queue *q, const char *name)
 397 {
 398         unsigned long flags;
 399         struct scsi_device *sdev;
 400         struct scsi_device_handler *scsi_dh;
 401         int err = 0;
 402
 403         scsi_dh = scsi_dh_lookup(name);
 404         if (!scsi_dh)
 405                 return -EINVAL;
 406
 407         spin_lock_irqsave(q->queue_lock, flags);
 408         sdev = q->queuedata;
 409         if (!sdev || !get_device(&sdev->sdev_gendev))
 410                 err = -ENODEV;
 411         spin_unlock_irqrestore(q->queue_lock, flags);
 412
 413         if (err)
 414                 return err;
 415
 416         if (sdev->scsi_dh_data) {
 417                 if (sdev->scsi_dh_data->scsi_dh != scsi_dh)
 418                         err = -EBUSY;
 419                 goto out_put_device;
 420         }
 421
 422         err = scsi_dh_handler_attach(sdev, scsi_dh);
 423
 424 out_put_device:
 425         put_device(&sdev->sdev_gendev);
 426         return err;
 427 }
 428 EXPORT_SYMBOL_GPL(scsi_dh_attach);
 429
 430 /*
 431  * scsi_dh_attached_handler_name - Get attached device handler's name
 432  * @q - Request queue that is associated with the scsi_device
 433  *      that may have a device handler attached
 434  * @gfp - the GFP mask used in the kmalloc() call when allocating memory
 435  *
 436  * Returns name of attached handler, NULL if no handler is attached.
 437  * Caller must take care to free the returned string.
 438  */
 439 const char *scsi_dh_attached_handler_name(struct request_queue *q, gfp_t gfp)
 440 {
 441         unsigned long flags;
 442         struct scsi_device *sdev;
 443         const char *handler_name = NULL;
 444
 445         spin_lock_irqsave(q->queue_lock, flags);
 446         sdev = q->queuedata;
 447         if (!sdev || !get_device(&sdev->sdev_gendev))
 448                 sdev = NULL;
 449         spin_unlock_irqrestore(q->queue_lock, flags);
 450
 451         if (!sdev)
 452                 return NULL;
 453
 454         if (sdev->scsi_dh_data)
 455                 handler_name = kstrdup(sdev->scsi_dh_data->scsi_dh->name, gfp);
 456
 457         put_device(&sdev->sdev_gendev);
 458         return handler_name;
 459 }
 460 EXPORT_SYMBOL_GPL(scsi_dh_attached_handler_name);