[mirror_ubuntu-bionic-kernel.git] / drivers / scsi / device_handler / scsi_dh.c

/*
 * 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 <sekharan@us.ibm.com>
 *               Mike Anderson <andmike@linux.vnet.ibm.com>
 */

#include <linux/slab.h>
#include <linux/module.h>
#include <scsi/scsi_dh.h>
#include "../scsi_priv.h"

static DEFINE_SPINLOCK(list_lock);
static LIST_HEAD(scsi_dh_list);

static struct scsi_device_handler *get_device_handler(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;
}

/*
 * device_handler_match_function - Match a device handler to a device
 * @sdev - SCSI device to be tested
 *
 * Tests @sdev against the match function of all registered device_handler.
 * Returns the found device handler or NULL if not found.
 */
static struct scsi_device_handler *
device_handler_match_function(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;
}

/*
 * device_handler_match - Attach a device handler to a device
 * @scsi_dh - The device handler to match against or NULL
 * @sdev - SCSI device to be tested against @scsi_dh
 *
 * Tests @sdev against the device handler @scsi_dh or against
 * all registered device_handler if @scsi_dh == NULL.
 * Returns the found device handler or NULL if not found.
 */
static struct scsi_device_handler *
device_handler_match(struct scsi_device_handler *scsi_dh,
		     struct scsi_device *sdev)
{
	struct scsi_device_handler *found_dh;

	found_dh = device_handler_match_function(sdev);

	if (scsi_dh && found_dh != scsi_dh)
		found_dh = NULL;

	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)
{
	int err = 0;

	if (sdev->scsi_dh_data) {
		if (sdev->scsi_dh_data->scsi_dh != scsi_dh)
			err = -EBUSY;
		else
			kref_get(&sdev->scsi_dh_data->kref);
	} else if (scsi_dh->attach) {
		err = scsi_dh->attach(sdev);
		if (!err) {
			kref_init(&sdev->scsi_dh_data->kref);
			sdev->scsi_dh_data->sdev = sdev;
		}
	}
	return err;
}

static void __detach_handler (struct kref *kref)
{
	struct scsi_dh_data *scsi_dh_data = container_of(kref, struct scsi_dh_data, kref);
	scsi_dh_data->scsi_dh->detach(scsi_dh_data->sdev);
}

/*
 * scsi_dh_handler_detach - Detach a device handler from a device
 * @sdev - SCSI device the device handler should be detached from
 * @scsi_dh - Device handler to be detached
 *
 * Detach from a device handler. If a device handler is specified,
 * only detach if the currently attached handler matches @scsi_dh.
 */
static void scsi_dh_handler_detach(struct scsi_device *sdev,
				   struct scsi_device_handler *scsi_dh)
{
	if (!sdev->scsi_dh_data)
		return;

	if (scsi_dh && scsi_dh != sdev->scsi_dh_data->scsi_dh)
		return;

	if (!scsi_dh)
		scsi_dh = sdev->scsi_dh_data->scsi_dh;

	if (scsi_dh && scsi_dh->detach)
		kref_put(&sdev->scsi_dh_data->kref, __detach_handler);
}

/*
 * 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
		 */
		if (!(scsi_dh = get_device_handler(buf)))
			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, scsi_dh);
			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);

/*
 * scsi_dh_sysfs_attr_add - Callback for scsi_init_dh
 */
static int scsi_dh_sysfs_attr_add(struct device *dev, void *data)
{
	struct scsi_device *sdev;
	int err;

	if (!scsi_is_sdev_device(dev))
		return 0;

	sdev = to_scsi_device(dev);

	err = device_create_file(&sdev->sdev_gendev,
				 &scsi_dh_state_attr);

	return 0;
}

/*
 * scsi_dh_sysfs_attr_remove - Callback for scsi_exit_dh
 */
static int scsi_dh_sysfs_attr_remove(struct device *dev, void *data)
{
	struct scsi_device *sdev;

	if (!scsi_is_sdev_device(dev))
		return 0;

	sdev = to_scsi_device(dev);

	device_remove_file(&sdev->sdev_gendev,
			   &scsi_dh_state_attr);

	return 0;
}

/*
 * scsi_dh_notifier - notifier chain callback
 */
static int scsi_dh_notifier(struct notifier_block *nb,
			    unsigned long action, void *data)
{
	struct device *dev = data;
	struct scsi_device *sdev;
	int err = 0;
	struct scsi_device_handler *devinfo = NULL;

	if (!scsi_is_sdev_device(dev))
		return 0;

	sdev = to_scsi_device(dev);

	if (action == BUS_NOTIFY_ADD_DEVICE) {
		err = device_create_file(dev, &scsi_dh_state_attr);
		/* don't care about err */
		devinfo = device_handler_match(NULL, sdev);
		if (devinfo)
			err = scsi_dh_handler_attach(sdev, devinfo);
	} else if (action == BUS_NOTIFY_DEL_DEVICE) {
		device_remove_file(dev, &scsi_dh_state_attr);
		scsi_dh_handler_detach(sdev, NULL);
	}
	return err;
}

/*
 * scsi_dh_notifier_add - Callback for scsi_register_device_handler
 */
static int scsi_dh_notifier_add(struct device *dev, void *data)
{
	struct scsi_device_handler *scsi_dh = data;
	struct scsi_device *sdev;

	if (!scsi_is_sdev_device(dev))
		return 0;

	if (!get_device(dev))
		return 0;

	sdev = to_scsi_device(dev);

	if (device_handler_match(scsi_dh, sdev))
		scsi_dh_handler_attach(sdev, scsi_dh);

	put_device(dev);

	return 0;
}

/*
 * scsi_dh_notifier_remove - Callback for scsi_unregister_device_handler
 */
static int scsi_dh_notifier_remove(struct device *dev, void *data)
{
	struct scsi_device_handler *scsi_dh = data;
	struct scsi_device *sdev;

	if (!scsi_is_sdev_device(dev))
		return 0;

	if (!get_device(dev))
		return 0;

	sdev = to_scsi_device(dev);

	scsi_dh_handler_detach(sdev, scsi_dh);

	put_device(dev);

	return 0;
}

/*
 * 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 (get_device_handler(scsi_dh->name))
		return -EBUSY;

	spin_lock(&list_lock);
	list_add(&scsi_dh->list, &scsi_dh_list);
	spin_unlock(&list_lock);

	bus_for_each_dev(&scsi_bus_type, NULL, scsi_dh, scsi_dh_notifier_add);
	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 (!get_device_handler(scsi_dh->name))
		return -ENODEV;

	bus_for_each_dev(&scsi_bus_type, NULL, scsi_dh,
			 scsi_dh_notifier_remove);

	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_handler_exist - Return TRUE(1) if a device handler exists for
 *	the given name. FALSE(0) otherwise.
 * @name - name of the device handler.
 */
int scsi_dh_handler_exist(const char *name)
{
	return (get_device_handler(name) != NULL);
}
EXPORT_SYMBOL_GPL(scsi_dh_handler_exist);

/*
 * scsi_dh_attach - Attach device handler
 * @sdev - sdev 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 = get_device_handler(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) {
		err = scsi_dh_handler_attach(sdev, scsi_dh);
		put_device(&sdev->sdev_gendev);
	}
	return err;
}
EXPORT_SYMBOL_GPL(scsi_dh_attach);

/*
 * scsi_dh_detach - Detach device handler
 * @sdev - sdev the handler should be detached from
 *
 * This function will detach the device handler only
 * if the sdev is not part of the internal list, ie
 * if it has been attached manually.
 */
void scsi_dh_detach(struct request_queue *q)
{
	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 || !get_device(&sdev->sdev_gendev))
		sdev = NULL;
	spin_unlock_irqrestore(q->queue_lock, flags);

	if (!sdev)
		return;

	if (sdev->scsi_dh_data) {
		scsi_dh = sdev->scsi_dh_data->scsi_dh;
		scsi_dh_handler_detach(sdev, scsi_dh);
	}
	put_device(&sdev->sdev_gendev);
}
EXPORT_SYMBOL_GPL(scsi_dh_detach);

static struct notifier_block scsi_dh_nb = {
	.notifier_call = scsi_dh_notifier
};

static int __init scsi_dh_init(void)
{
	int r;

	r = bus_register_notifier(&scsi_bus_type, &scsi_dh_nb);

	if (!r)
		bus_for_each_dev(&scsi_bus_type, NULL, NULL,
				 scsi_dh_sysfs_attr_add);

	return r;
}

static void __exit scsi_dh_exit(void)
{
	bus_for_each_dev(&scsi_bus_type, NULL, NULL,
			 scsi_dh_sysfs_attr_remove);
	bus_unregister_notifier(&scsi_bus_type, &scsi_dh_nb);
}

module_init(scsi_dh_init);
module_exit(scsi_dh_exit);

MODULE_DESCRIPTION("SCSI device handler");
MODULE_AUTHOR("Chandra Seetharaman <sekharan@us.ibm.com>");
MODULE_LICENSE("GPL");
Commit	Line	Data
a6a8d9f8 CS	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
5a0e3ad6	24	#include <linux/slab.h>
acf3368f	25	#include <linux/module.h>
a6a8d9f8 CS	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	static struct scsi_device_handler get_device_handler(const char name)
	33	{
	34	struct scsi_device_handler tmp, found = NULL;
	35
	36	spin_lock(&list_lock);
	37	list_for_each_entry(tmp, &scsi_dh_list, list) {
765cbc6d	38	if (!strncmp(tmp->name, name, strlen(tmp->name))) {
a6a8d9f8 CS	39	found = tmp;
	40	break;
	41	}
	42	}
	43	spin_unlock(&list_lock);
	44	return found;
	45	}
	46
6c3633d0 HR	47	/*
	48	* device_handler_match_function - Match a device handler to a device
	49	* @sdev - SCSI device to be tested
	50	*
	51	* Tests @sdev against the match function of all registered device_handler.
	52	* Returns the found device handler or NULL if not found.
	53	*/
	54	static struct scsi_device_handler *
	55	device_handler_match_function(struct scsi_device *sdev)
	56	{
	57	struct scsi_device_handler tmp_dh, found_dh = NULL;
	58
	59	spin_lock(&list_lock);
	60	list_for_each_entry(tmp_dh, &scsi_dh_list, list) {
	61	if (tmp_dh->match && tmp_dh->match(sdev)) {
	62	found_dh = tmp_dh;
	63	break;
	64	}
	65	}
	66	spin_unlock(&list_lock);
	67	return found_dh;
	68	}
	69
7c32c7a2 HR	70	/*
	71	* device_handler_match - Attach a device handler to a device
	72	* @scsi_dh - The device handler to match against or NULL
	73	* @sdev - SCSI device to be tested against @scsi_dh
	74	*
	75	* Tests @sdev against the device handler @scsi_dh or against
	76	* all registered device_handler if @scsi_dh == NULL.
	77	* Returns the found device handler or NULL if not found.
	78	*/
	79	static struct scsi_device_handler *
	80	device_handler_match(struct scsi_device_handler *scsi_dh,
	81	struct scsi_device *sdev)
	82	{
6c3633d0	83	struct scsi_device_handler *found_dh;
7c32c7a2	84
6c3633d0	85	found_dh = device_handler_match_function(sdev);
7c32c7a2	86
940d7faa PJ	87	if (scsi_dh && found_dh != scsi_dh)
940d7faa PJ	88	found_dh = NULL;
7c32c7a2 HR	89
7c32c7a2 HR	90	return found_dh;
a6a8d9f8 CS	91	}
	92
	93	/*
765cbc6d HR	94	* scsi_dh_handler_attach - Attach a device handler to a device
	95	* @sdev - SCSI device the device handler should attach to
	96	* @scsi_dh - The device handler to attach
	97	*/
	98	static int scsi_dh_handler_attach(struct scsi_device *sdev,
	99	struct scsi_device_handler *scsi_dh)
	100	{
	101	int err = 0;
	102
	103	if (sdev->scsi_dh_data) {
	104	if (sdev->scsi_dh_data->scsi_dh != scsi_dh)
	105	err = -EBUSY;
6c10db72 CS	106	else
	107	kref_get(&sdev->scsi_dh_data->kref);
	108	} else if (scsi_dh->attach) {
765cbc6d	109	err = scsi_dh->attach(sdev);
6c10db72 CS	110	if (!err) {
	111	kref_init(&sdev->scsi_dh_data->kref);
	112	sdev->scsi_dh_data->sdev = sdev;
	113	}
	114	}
765cbc6d HR	115	return err;
	116	}
	117
6c10db72 CS	118	static void __detach_handler (struct kref *kref)
	119	{
	120	struct scsi_dh_data *scsi_dh_data = container_of(kref, struct scsi_dh_data, kref);
	121	scsi_dh_data->scsi_dh->detach(scsi_dh_data->sdev);
	122	}
	123
765cbc6d HR	124	/*
	125	* scsi_dh_handler_detach - Detach a device handler from a device
	126	* @sdev - SCSI device the device handler should be detached from
	127	* @scsi_dh - Device handler to be detached
a6a8d9f8	128	*
765cbc6d	129	* Detach from a device handler. If a device handler is specified,
4c05ae52	130	* only detach if the currently attached handler matches @scsi_dh.
a6a8d9f8	131	*/
765cbc6d HR	132	static void scsi_dh_handler_detach(struct scsi_device *sdev,
765cbc6d HR	133	struct scsi_device_handler *scsi_dh)
a6a8d9f8	134	{
765cbc6d HR	135	if (!sdev->scsi_dh_data)
765cbc6d HR	136	return;
a6a8d9f8	137
765cbc6d HR	138	if (scsi_dh && scsi_dh != sdev->scsi_dh_data->scsi_dh)
765cbc6d HR	139	return;
a6a8d9f8	140
765cbc6d HR	141	if (!scsi_dh)
	142	scsi_dh = sdev->scsi_dh_data->scsi_dh;
	143
	144	if (scsi_dh && scsi_dh->detach)
6c10db72	145	kref_put(&sdev->scsi_dh_data->kref, __detach_handler);
765cbc6d HR	146	}
765cbc6d HR	147
4c05ae52 HR	148	/*
	149	* Functions for sysfs attribute 'dh_state'
	150	*/
	151	static ssize_t
	152	store_dh_state(struct device dev, struct device_attribute attr,
	153	const char *buf, size_t count)
	154	{
	155	struct scsi_device *sdev = to_scsi_device(dev);
	156	struct scsi_device_handler *scsi_dh;
	157	int err = -EINVAL;
	158
6bc8d2a0 HR	159	if (sdev->sdev_state == SDEV_CANCEL \|\|
	160	sdev->sdev_state == SDEV_DEL)
	161	return -ENODEV;
	162
4c05ae52 HR	163	if (!sdev->scsi_dh_data) {
	164	/*
	165	* Attach to a device handler
	166	*/
	167	if (!(scsi_dh = get_device_handler(buf)))
	168	return err;
	169	err = scsi_dh_handler_attach(sdev, scsi_dh);
	170	} else {
	171	scsi_dh = sdev->scsi_dh_data->scsi_dh;
	172	if (!strncmp(buf, "detach", 6)) {
	173	/*
	174	* Detach from a device handler
	175	*/
	176	scsi_dh_handler_detach(sdev, scsi_dh);
	177	err = 0;
	178	} else if (!strncmp(buf, "activate", 8)) {
	179	/*
	180	* Activate a device handler
	181	*/
	182	if (scsi_dh->activate)
3ae31f6a	183	err = scsi_dh->activate(sdev, NULL, NULL);
4c05ae52 HR	184	else
	185	err = 0;
	186	}
	187	}
	188
	189	return err<0?err:count;
	190	}
	191
	192	static ssize_t
	193	show_dh_state(struct device dev, struct device_attribute attr, char *buf)
	194	{
	195	struct scsi_device *sdev = to_scsi_device(dev);
	196
	197	if (!sdev->scsi_dh_data)
	198	return snprintf(buf, 20, "detached\n");
	199
	200	return snprintf(buf, 20, "%s\n", sdev->scsi_dh_data->scsi_dh->name);
	201	}
	202
	203	static struct device_attribute scsi_dh_state_attr =
	204	__ATTR(dh_state, S_IRUGO \| S_IWUSR, show_dh_state,
	205	store_dh_state);
	206
	207	/*
	208	* scsi_dh_sysfs_attr_add - Callback for scsi_init_dh
	209	*/
	210	static int scsi_dh_sysfs_attr_add(struct device dev, void data)
	211	{
	212	struct scsi_device *sdev;
	213	int err;
	214
	215	if (!scsi_is_sdev_device(dev))
	216	return 0;
	217
	218	sdev = to_scsi_device(dev);
	219
	220	err = device_create_file(&sdev->sdev_gendev,
	221	&scsi_dh_state_attr);
	222
	223	return 0;
	224	}
	225
	226	/*
	227	* scsi_dh_sysfs_attr_remove - Callback for scsi_exit_dh
	228	*/
	229	static int scsi_dh_sysfs_attr_remove(struct device dev, void data)
	230	{
	231	struct scsi_device *sdev;
	232
	233	if (!scsi_is_sdev_device(dev))
	234	return 0;
	235
	236	sdev = to_scsi_device(dev);
	237
	238	device_remove_file(&sdev->sdev_gendev,
	239	&scsi_dh_state_attr);
	240
	241	return 0;
	242	}
	243
765cbc6d HR	244	/*
	245	* scsi_dh_notifier - notifier chain callback
	246	*/
	247	static int scsi_dh_notifier(struct notifier_block *nb,
	248	unsigned long action, void *data)
	249	{
	250	struct device *dev = data;
	251	struct scsi_device *sdev;
	252	int err = 0;
7c32c7a2	253	struct scsi_device_handler *devinfo = NULL;
765cbc6d HR	254
	255	if (!scsi_is_sdev_device(dev))
	256	return 0;
	257
	258	sdev = to_scsi_device(dev);
a6a8d9f8	259
765cbc6d	260	if (action == BUS_NOTIFY_ADD_DEVICE) {
5917290c CS	261	err = device_create_file(dev, &scsi_dh_state_attr);
5917290c CS	262	/* don't care about err */
7c32c7a2	263	devinfo = device_handler_match(NULL, sdev);
5917290c CS	264	if (devinfo)
5917290c CS	265	err = scsi_dh_handler_attach(sdev, devinfo);
765cbc6d	266	} else if (action == BUS_NOTIFY_DEL_DEVICE) {
4c05ae52	267	device_remove_file(dev, &scsi_dh_state_attr);
765cbc6d HR	268	scsi_dh_handler_detach(sdev, NULL);
765cbc6d HR	269	}
765cbc6d	270	return err;
a6a8d9f8	271	}
a6a8d9f8	272
765cbc6d HR	273	/*
	274	* scsi_dh_notifier_add - Callback for scsi_register_device_handler
	275	*/
	276	static int scsi_dh_notifier_add(struct device dev, void data)
	277	{
	278	struct scsi_device_handler *scsi_dh = data;
	279	struct scsi_device *sdev;
	280
	281	if (!scsi_is_sdev_device(dev))
	282	return 0;
	283
	284	if (!get_device(dev))
	285	return 0;
	286
	287	sdev = to_scsi_device(dev);
	288
	289	if (device_handler_match(scsi_dh, sdev))
	290	scsi_dh_handler_attach(sdev, scsi_dh);
	291
	292	put_device(dev);
	293
	294	return 0;
	295	}
	296
	297	/*
	298	* scsi_dh_notifier_remove - Callback for scsi_unregister_device_handler
	299	*/
a6a8d9f8 CS	300	static int scsi_dh_notifier_remove(struct device dev, void data)
	301	{
	302	struct scsi_device_handler *scsi_dh = data;
765cbc6d HR	303	struct scsi_device *sdev;
	304
	305	if (!scsi_is_sdev_device(dev))
	306	return 0;
	307
	308	if (!get_device(dev))
	309	return 0;
	310
	311	sdev = to_scsi_device(dev);
	312
	313	scsi_dh_handler_detach(sdev, scsi_dh);
	314
	315	put_device(dev);
a6a8d9f8	316
a6a8d9f8 CS	317	return 0;
	318	}
	319
765cbc6d HR	320	/*
	321	* scsi_register_device_handler - register a device handler personality
	322	* module.
	323	* @scsi_dh - device handler to be registered.
	324	*
	325	* Returns 0 on success, -EBUSY if handler already registered.
	326	*/
	327	int scsi_register_device_handler(struct scsi_device_handler *scsi_dh)
	328	{
940d7faa	329
765cbc6d HR	330	if (get_device_handler(scsi_dh->name))
	331	return -EBUSY;
	332
	333	spin_lock(&list_lock);
	334	list_add(&scsi_dh->list, &scsi_dh_list);
	335	spin_unlock(&list_lock);
940d7faa	336
765cbc6d HR	337	bus_for_each_dev(&scsi_bus_type, NULL, scsi_dh, scsi_dh_notifier_add);
	338	printk(KERN_INFO "%s: device handler registered\n", scsi_dh->name);
	339
	340	return SCSI_DH_OK;
	341	}
	342	EXPORT_SYMBOL_GPL(scsi_register_device_handler);
	343
a6a8d9f8 CS	344	/*
	345	* scsi_unregister_device_handler - register a device handler personality
	346	* module.
	347	* @scsi_dh - device handler to be unregistered.
	348	*
	349	* Returns 0 on success, -ENODEV if handler not registered.
	350	*/
	351	int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh)
	352	{
7c32c7a2	353
765cbc6d HR	354	if (!get_device_handler(scsi_dh->name))
765cbc6d HR	355	return -ENODEV;
a6a8d9f8 CS	356
a6a8d9f8 CS	357	bus_for_each_dev(&scsi_bus_type, NULL, scsi_dh,
765cbc6d HR	358	scsi_dh_notifier_remove);
765cbc6d HR	359
a6a8d9f8 CS	360	spin_lock(&list_lock);
	361	list_del(&scsi_dh->list);
	362	spin_unlock(&list_lock);
765cbc6d	363	printk(KERN_INFO "%s: device handler unregistered\n", scsi_dh->name);
a6a8d9f8	364
765cbc6d	365	return SCSI_DH_OK;
a6a8d9f8 CS	366	}
	367	EXPORT_SYMBOL_GPL(scsi_unregister_device_handler);
	368
	369	/*
	370	* scsi_dh_activate - activate the path associated with the scsi_device
	371	* corresponding to the given request queue.
3ae31f6a CS	372	* Returns immediately without waiting for activation to be completed.
	373	* @q - Request queue that is associated with the scsi_device to be
	374	* activated.
	375	* @fn - Function to be called upon completion of the activation.
	376	* Function fn is called with data (below) and the error code.
	377	* Function fn may be called from the same calling context. So,
	378	* do not hold the lock in the caller which may be needed in fn.
	379	* @data - data passed to the function fn upon completion.
	380	*
a6a8d9f8	381	*/
3ae31f6a	382	int scsi_dh_activate(struct request_queue q, activate_complete fn, void data)
a6a8d9f8 CS	383	{
	384	int err = 0;
	385	unsigned long flags;
	386	struct scsi_device *sdev;
	387	struct scsi_device_handler *scsi_dh = NULL;
0b839357	388	struct device *dev = NULL;
a6a8d9f8 CS	389
	390	spin_lock_irqsave(q->queue_lock, flags);
	391	sdev = q->queuedata;
a18a920c MB	392	if (!sdev) {
	393	spin_unlock_irqrestore(q->queue_lock, flags);
	394	err = SCSI_DH_NOSYS;
	395	if (fn)
	396	fn(data, err);
	397	return err;
	398	}
	399
	400	if (sdev->scsi_dh_data)
a6a8d9f8	401	scsi_dh = sdev->scsi_dh_data->scsi_dh;
0b839357 MS	402	dev = get_device(&sdev->sdev_gendev);
0b839357 MS	403	if (!scsi_dh \|\| !dev \|\|
db422318 MH	404	sdev->sdev_state == SDEV_CANCEL \|\|
db422318 MH	405	sdev->sdev_state == SDEV_DEL)
a6a8d9f8	406	err = SCSI_DH_NOSYS;
db422318 MH	407	if (sdev->sdev_state == SDEV_OFFLINE)
db422318 MH	408	err = SCSI_DH_DEV_OFFLINED;
a6a8d9f8 CS	409	spin_unlock_irqrestore(q->queue_lock, flags);
a6a8d9f8 CS	410
db422318 MH	411	if (err) {
	412	if (fn)
	413	fn(data, err);
0b839357	414	goto out;
db422318	415	}
a6a8d9f8 CS	416
a6a8d9f8 CS	417	if (scsi_dh->activate)
3ae31f6a	418	err = scsi_dh->activate(sdev, fn, data);
0b839357 MS	419	out:
0b839357 MS	420	put_device(dev);
a6a8d9f8 CS	421	return err;
	422	}
	423	EXPORT_SYMBOL_GPL(scsi_dh_activate);
	424
18ee70c9 CS	425	/*
	426	* scsi_dh_set_params - set the parameters for the device as per the
	427	* string specified in params.
	428	* @q - Request queue that is associated with the scsi_device for
	429	* which the parameters to be set.
	430	* @params - parameters in the following format
	431	* "no_of_params\0param1\0param2\0param3\0...\0"
	432	* for example, string for 2 parameters with value 10 and 21
	433	* is specified as "2\010\021\0".
	434	*/
	435	int scsi_dh_set_params(struct request_queue q, const char params)
	436	{
	437	int err = -SCSI_DH_NOSYS;
	438	unsigned long flags;
	439	struct scsi_device *sdev;
	440	struct scsi_device_handler *scsi_dh = NULL;
	441
	442	spin_lock_irqsave(q->queue_lock, flags);
	443	sdev = q->queuedata;
	444	if (sdev && sdev->scsi_dh_data)
	445	scsi_dh = sdev->scsi_dh_data->scsi_dh;
	446	if (scsi_dh && scsi_dh->set_params && get_device(&sdev->sdev_gendev))
	447	err = 0;
	448	spin_unlock_irqrestore(q->queue_lock, flags);
	449
	450	if (err)
	451	return err;
	452	err = scsi_dh->set_params(sdev, params);
	453	put_device(&sdev->sdev_gendev);
	454	return err;
	455	}
	456	EXPORT_SYMBOL_GPL(scsi_dh_set_params);
	457
a6a8d9f8 CS	458	/*
	459	* scsi_dh_handler_exist - Return TRUE(1) if a device handler exists for
	460	* the given name. FALSE(0) otherwise.
	461	* @name - name of the device handler.
	462	*/
	463	int scsi_dh_handler_exist(const char *name)
	464	{
	465	return (get_device_handler(name) != NULL);
	466	}
	467	EXPORT_SYMBOL_GPL(scsi_dh_handler_exist);
	468
ae11b1b3	469	/*
2a9ab40f	470	* scsi_dh_attach - Attach device handler
ae11b1b3 HR	471	* @sdev - sdev the handler should be attached to
	472	* @name - name of the handler to attach
	473	*/
	474	int scsi_dh_attach(struct request_queue q, const char name)
	475	{
	476	unsigned long flags;
	477	struct scsi_device *sdev;
	478	struct scsi_device_handler *scsi_dh;
	479	int err = 0;
	480
	481	scsi_dh = get_device_handler(name);
	482	if (!scsi_dh)
	483	return -EINVAL;
	484
	485	spin_lock_irqsave(q->queue_lock, flags);
	486	sdev = q->queuedata;
	487	if (!sdev \|\| !get_device(&sdev->sdev_gendev))
	488	err = -ENODEV;
	489	spin_unlock_irqrestore(q->queue_lock, flags);
	490
	491	if (!err) {
	492	err = scsi_dh_handler_attach(sdev, scsi_dh);
ae11b1b3 HR	493	put_device(&sdev->sdev_gendev);
	494	}
	495	return err;
	496	}
	497	EXPORT_SYMBOL_GPL(scsi_dh_attach);
	498
	499	/*
2a9ab40f	500	* scsi_dh_detach - Detach device handler
ae11b1b3 HR	501	* @sdev - sdev the handler should be detached from
	502	*
	503	* This function will detach the device handler only
	504	* if the sdev is not part of the internal list, ie
	505	* if it has been attached manually.
	506	*/
	507	void scsi_dh_detach(struct request_queue *q)
	508	{
	509	unsigned long flags;
	510	struct scsi_device *sdev;
	511	struct scsi_device_handler *scsi_dh = NULL;
	512
	513	spin_lock_irqsave(q->queue_lock, flags);
	514	sdev = q->queuedata;
	515	if (!sdev \|\| !get_device(&sdev->sdev_gendev))
	516	sdev = NULL;
	517	spin_unlock_irqrestore(q->queue_lock, flags);
	518
	519	if (!sdev)
	520	return;
	521
	522	if (sdev->scsi_dh_data) {
ae11b1b3	523	scsi_dh = sdev->scsi_dh_data->scsi_dh;
6c10db72	524	scsi_dh_handler_detach(sdev, scsi_dh);
ae11b1b3 HR	525	}
	526	put_device(&sdev->sdev_gendev);
	527	}
	528	EXPORT_SYMBOL_GPL(scsi_dh_detach);
	529
765cbc6d HR	530	static struct notifier_block scsi_dh_nb = {
	531	.notifier_call = scsi_dh_notifier
	532	};
	533
	534	static int __init scsi_dh_init(void)
	535	{
	536	int r;
	537
	538	r = bus_register_notifier(&scsi_bus_type, &scsi_dh_nb);
	539
4c05ae52 HR	540	if (!r)
	541	bus_for_each_dev(&scsi_bus_type, NULL, NULL,
	542	scsi_dh_sysfs_attr_add);
	543
765cbc6d HR	544	return r;
	545	}
	546
	547	static void __exit scsi_dh_exit(void)
	548	{
4c05ae52 HR	549	bus_for_each_dev(&scsi_bus_type, NULL, NULL,
4c05ae52 HR	550	scsi_dh_sysfs_attr_remove);
765cbc6d HR	551	bus_unregister_notifier(&scsi_bus_type, &scsi_dh_nb);
	552	}
	553
	554	module_init(scsi_dh_init);
	555	module_exit(scsi_dh_exit);
	556
a6a8d9f8 CS	557	MODULE_DESCRIPTION("SCSI device handler");
	558	MODULE_AUTHOR("Chandra Seetharaman <sekharan@us.ibm.com>");
	559	MODULE_LICENSE("GPL");