/* * SCSI device handler infrastruture. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the * Free Software Foundation; either version 2 of the License, or (at your * option) any later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * Copyright IBM Corporation, 2007 * Authors: * Chandra Seetharaman * Mike Anderson */ #include #include #include #include "scsi_priv.h" static DEFINE_SPINLOCK(list_lock); static LIST_HEAD(scsi_dh_list); static struct scsi_device_handler *__scsi_dh_lookup(const char *name) { struct scsi_device_handler *tmp, *found = NULL; spin_lock(&list_lock); list_for_each_entry(tmp, &scsi_dh_list, list) { if (!strncmp(tmp->name, name, strlen(tmp->name))) { found = tmp; break; } } spin_unlock(&list_lock); return found; } static struct scsi_device_handler *scsi_dh_lookup(const char *name) { struct scsi_device_handler *dh; dh = __scsi_dh_lookup(name); if (!dh) { request_module(name); dh = __scsi_dh_lookup(name); } return dh; } static struct scsi_device_handler * device_handler_match(struct scsi_device *sdev) { struct scsi_device_handler *tmp_dh, *found_dh = NULL; spin_lock(&list_lock); list_for_each_entry(tmp_dh, &scsi_dh_list, list) { if (tmp_dh->match && tmp_dh->match(sdev)) { found_dh = tmp_dh; break; } } spin_unlock(&list_lock); return found_dh; } /* * scsi_dh_handler_attach - Attach a device handler to a device * @sdev - SCSI device the device handler should attach to * @scsi_dh - The device handler to attach */ static int scsi_dh_handler_attach(struct scsi_device *sdev, struct scsi_device_handler *scsi_dh) { struct scsi_dh_data *d; if (!try_module_get(scsi_dh->module)) return -EINVAL; d = scsi_dh->attach(sdev); if (IS_ERR(d)) { sdev_printk(KERN_ERR, sdev, "%s: Attach failed (%ld)\n", scsi_dh->name, PTR_ERR(d)); module_put(scsi_dh->module); return PTR_ERR(d); } d->scsi_dh = scsi_dh; d->sdev = sdev; spin_lock_irq(sdev->request_queue->queue_lock); sdev->scsi_dh_data = d; spin_unlock_irq(sdev->request_queue->queue_lock); return 0; } /* * scsi_dh_handler_detach - Detach a device handler from a device * @sdev - SCSI device the device handler should be detached from */ static void scsi_dh_handler_detach(struct scsi_device *sdev) { struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data; struct scsi_device_handler *scsi_dh = scsi_dh_data->scsi_dh; scsi_dh->detach(sdev); spin_lock_irq(sdev->request_queue->queue_lock); sdev->scsi_dh_data = NULL; spin_unlock_irq(sdev->request_queue->queue_lock); sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", scsi_dh->name); module_put(scsi_dh->module); } /* * Functions for sysfs attribute 'dh_state' */ static ssize_t store_dh_state(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct scsi_device *sdev = to_scsi_device(dev); struct scsi_device_handler *scsi_dh; int err = -EINVAL; if (sdev->sdev_state == SDEV_CANCEL || sdev->sdev_state == SDEV_DEL) return -ENODEV; if (!sdev->scsi_dh_data) { /* * Attach to a device handler */ scsi_dh = scsi_dh_lookup(buf); if (!scsi_dh) return err; err = scsi_dh_handler_attach(sdev, scsi_dh); } else { scsi_dh = sdev->scsi_dh_data->scsi_dh; if (!strncmp(buf, "detach", 6)) { /* * Detach from a device handler */ scsi_dh_handler_detach(sdev); err = 0; } else if (!strncmp(buf, "activate", 8)) { /* * Activate a device handler */ if (scsi_dh->activate) err = scsi_dh->activate(sdev, NULL, NULL); else err = 0; } } return err<0?err:count; } static ssize_t show_dh_state(struct device *dev, struct device_attribute *attr, char *buf) { struct scsi_device *sdev = to_scsi_device(dev); if (!sdev->scsi_dh_data) return snprintf(buf, 20, "detached\n"); return snprintf(buf, 20, "%s\n", sdev->scsi_dh_data->scsi_dh->name); } static struct device_attribute scsi_dh_state_attr = __ATTR(dh_state, S_IRUGO | S_IWUSR, show_dh_state, store_dh_state); int scsi_dh_add_device(struct scsi_device *sdev) { struct scsi_device_handler *devinfo; int err; err = device_create_file(&sdev->sdev_gendev, &scsi_dh_state_attr); if (err) return err; devinfo = device_handler_match(sdev); if (devinfo) err = scsi_dh_handler_attach(sdev, devinfo); return err; } void scsi_dh_remove_device(struct scsi_device *sdev) { if (sdev->scsi_dh_data) scsi_dh_handler_detach(sdev); device_remove_file(&sdev->sdev_gendev, &scsi_dh_state_attr); } /* * scsi_register_device_handler - register a device handler personality * module. * @scsi_dh - device handler to be registered. * * Returns 0 on success, -EBUSY if handler already registered. */ int scsi_register_device_handler(struct scsi_device_handler *scsi_dh) { if (__scsi_dh_lookup(scsi_dh->name)) return -EBUSY; if (!scsi_dh->attach || !scsi_dh->detach) return -EINVAL; spin_lock(&list_lock); list_add(&scsi_dh->list, &scsi_dh_list); spin_unlock(&list_lock); printk(KERN_INFO "%s: device handler registered\n", scsi_dh->name); return SCSI_DH_OK; } EXPORT_SYMBOL_GPL(scsi_register_device_handler); /* * scsi_unregister_device_handler - register a device handler personality * module. * @scsi_dh - device handler to be unregistered. * * Returns 0 on success, -ENODEV if handler not registered. */ int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh) { if (!__scsi_dh_lookup(scsi_dh->name)) return -ENODEV; spin_lock(&list_lock); list_del(&scsi_dh->list); spin_unlock(&list_lock); printk(KERN_INFO "%s: device handler unregistered\n", scsi_dh->name); return SCSI_DH_OK; } EXPORT_SYMBOL_GPL(scsi_unregister_device_handler); /* * scsi_dh_activate - activate the path associated with the scsi_device * corresponding to the given request queue. * Returns immediately without waiting for activation to be completed. * @q - Request queue that is associated with the scsi_device to be * activated. * @fn - Function to be called upon completion of the activation. * Function fn is called with data (below) and the error code. * Function fn may be called from the same calling context. So, * do not hold the lock in the caller which may be needed in fn. * @data - data passed to the function fn upon completion. * */ int scsi_dh_activate(struct request_queue *q, activate_complete fn, void *data) { int err = 0; unsigned long flags; struct scsi_device *sdev; struct scsi_device_handler *scsi_dh = NULL; struct device *dev = NULL; spin_lock_irqsave(q->queue_lock, flags); sdev = q->queuedata; if (!sdev) { spin_unlock_irqrestore(q->queue_lock, flags); err = SCSI_DH_NOSYS; if (fn) fn(data, err); return err; } if (sdev->scsi_dh_data) scsi_dh = sdev->scsi_dh_data->scsi_dh; dev = get_device(&sdev->sdev_gendev); if (!scsi_dh || !dev || sdev->sdev_state == SDEV_CANCEL || sdev->sdev_state == SDEV_DEL) err = SCSI_DH_NOSYS; if (sdev->sdev_state == SDEV_OFFLINE) err = SCSI_DH_DEV_OFFLINED; spin_unlock_irqrestore(q->queue_lock, flags); if (err) { if (fn) fn(data, err); goto out; } if (scsi_dh->activate) err = scsi_dh->activate(sdev, fn, data); out: put_device(dev); return err; } EXPORT_SYMBOL_GPL(scsi_dh_activate); /* * scsi_dh_set_params - set the parameters for the device as per the * string specified in params. * @q - Request queue that is associated with the scsi_device for * which the parameters to be set. * @params - parameters in the following format * "no_of_params\0param1\0param2\0param3\0...\0" * for example, string for 2 parameters with value 10 and 21 * is specified as "2\010\021\0". */ int scsi_dh_set_params(struct request_queue *q, const char *params) { int err = -SCSI_DH_NOSYS; unsigned long flags; struct scsi_device *sdev; struct scsi_device_handler *scsi_dh = NULL; spin_lock_irqsave(q->queue_lock, flags); sdev = q->queuedata; if (sdev && sdev->scsi_dh_data) scsi_dh = sdev->scsi_dh_data->scsi_dh; if (scsi_dh && scsi_dh->set_params && get_device(&sdev->sdev_gendev)) err = 0; spin_unlock_irqrestore(q->queue_lock, flags); if (err) return err; err = scsi_dh->set_params(sdev, params); put_device(&sdev->sdev_gendev); return err; } EXPORT_SYMBOL_GPL(scsi_dh_set_params); /* * scsi_dh_attach - Attach device handler * @q - Request queue that is associated with the scsi_device * the handler should be attached to * @name - name of the handler to attach */ int scsi_dh_attach(struct request_queue *q, const char *name) { unsigned long flags; struct scsi_device *sdev; struct scsi_device_handler *scsi_dh; int err = 0; scsi_dh = scsi_dh_lookup(name); if (!scsi_dh) return -EINVAL; spin_lock_irqsave(q->queue_lock, flags); sdev = q->queuedata; if (!sdev || !get_device(&sdev->sdev_gendev)) err = -ENODEV; spin_unlock_irqrestore(q->queue_lock, flags); if (err) return err; if (sdev->scsi_dh_data) { if (sdev->scsi_dh_data->scsi_dh != scsi_dh) err = -EBUSY; goto out_put_device; } err = scsi_dh_handler_attach(sdev, scsi_dh); out_put_device: put_device(&sdev->sdev_gendev); return err; } EXPORT_SYMBOL_GPL(scsi_dh_attach); /* * scsi_dh_attached_handler_name - Get attached device handler's name * @q - Request queue that is associated with the scsi_device * that may have a device handler attached * @gfp - the GFP mask used in the kmalloc() call when allocating memory * * Returns name of attached handler, NULL if no handler is attached. * Caller must take care to free the returned string. */ const char *scsi_dh_attached_handler_name(struct request_queue *q, gfp_t gfp) { unsigned long flags; struct scsi_device *sdev; const char *handler_name = NULL; spin_lock_irqsave(q->queue_lock, flags); sdev = q->queuedata; if (!sdev || !get_device(&sdev->sdev_gendev)) sdev = NULL; spin_unlock_irqrestore(q->queue_lock, flags); if (!sdev) return NULL; if (sdev->scsi_dh_data) handler_name = kstrdup(sdev->scsi_dh_data->scsi_dh->name, gfp); put_device(&sdev->sdev_gendev); return handler_name; } EXPORT_SYMBOL_GPL(scsi_dh_attached_handler_name);