[linux-2.6-block.git] / drivers / scsi / scsi_proc.c

// SPDX-License-Identifier: GPL-2.0
/*
 * linux/drivers/scsi/scsi_proc.c
 *
 * The functions in this file provide an interface between
 * the PROC file system and the SCSI device drivers
 * It is mainly used for debugging, statistics and to pass 
 * information directly to the lowlevel driver.
 *
 * (c) 1995 Michael Neuffer neuffer@goofy.zdv.uni-mainz.de 
 * Version: 0.99.8   last change: 95/09/13
 * 
 * generic command parser provided by: 
 * Andreas Heilwagen <crashcar@informatik.uni-koblenz.de>
 *
 * generic_proc_info() support of xxxx_info() by:
 * Michael A. Griffith <grif@acm.org>
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/proc_fs.h>
#include <linux/errno.h>
#include <linux/blkdev.h>
#include <linux/seq_file.h>
#include <linux/mutex.h>
#include <linux/gfp.h>
#include <linux/uaccess.h>

#include <scsi/scsi.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_transport.h>

#include "scsi_priv.h"
#include "scsi_logging.h"


/* 4K page size, but our output routines, use some slack for overruns */
#define PROC_BLOCK_SIZE (3*1024)

static struct proc_dir_entry *proc_scsi;

/* Protects scsi_proc_list */
static DEFINE_MUTEX(global_host_template_mutex);
static LIST_HEAD(scsi_proc_list);

/**
 * struct scsi_proc_entry - (host template, SCSI proc dir) association
 * @entry: entry in scsi_proc_list.
 * @sht: SCSI host template associated with the procfs directory.
 * @proc_dir: procfs directory associated with the SCSI host template.
 * @present: Number of SCSI hosts instantiated for @sht.
 */
struct scsi_proc_entry {
	struct list_head	entry;
	const struct scsi_host_template *sht;
	struct proc_dir_entry	*proc_dir;
	unsigned int		present;
};

static ssize_t proc_scsi_host_write(struct file *file, const char __user *buf,
                           size_t count, loff_t *ppos)
{
	struct Scsi_Host *shost = pde_data(file_inode(file));
	ssize_t ret = -ENOMEM;
	char *page;
    
	if (count > PROC_BLOCK_SIZE)
		return -EOVERFLOW;

	if (!shost->hostt->write_info)
		return -EINVAL;

	page = (char *)__get_free_page(GFP_KERNEL);
	if (page) {
		ret = -EFAULT;
		if (copy_from_user(page, buf, count))
			goto out;
		ret = shost->hostt->write_info(shost, page, count);
	}
out:
	free_page((unsigned long)page);
	return ret;
}

static int proc_scsi_show(struct seq_file *m, void *v)
{
	struct Scsi_Host *shost = m->private;
	return shost->hostt->show_info(m, shost);
}

static int proc_scsi_host_open(struct inode *inode, struct file *file)
{
	return single_open_size(file, proc_scsi_show, pde_data(inode),
				4 * PAGE_SIZE);
}

static struct scsi_proc_entry *
__scsi_lookup_proc_entry(const struct scsi_host_template *sht)
{
	struct scsi_proc_entry *e;

	lockdep_assert_held(&global_host_template_mutex);

	list_for_each_entry(e, &scsi_proc_list, entry)
		if (e->sht == sht)
			return e;

	return NULL;
}

static struct scsi_proc_entry *
scsi_lookup_proc_entry(const struct scsi_host_template *sht)
{
	struct scsi_proc_entry *e;

	mutex_lock(&global_host_template_mutex);
	e = __scsi_lookup_proc_entry(sht);
	mutex_unlock(&global_host_template_mutex);

	return e;
}

/**
 * scsi_template_proc_dir() - returns the procfs dir for a SCSI host template
 * @sht: SCSI host template pointer.
 */
struct proc_dir_entry *
scsi_template_proc_dir(const struct scsi_host_template *sht)
{
	struct scsi_proc_entry *e = scsi_lookup_proc_entry(sht);

	return e ? e->proc_dir : NULL;
}
EXPORT_SYMBOL_GPL(scsi_template_proc_dir);

static const struct proc_ops proc_scsi_ops = {
	.proc_open	= proc_scsi_host_open,
	.proc_release	= single_release,
	.proc_read	= seq_read,
	.proc_lseek	= seq_lseek,
	.proc_write	= proc_scsi_host_write
};

/**
 * scsi_proc_hostdir_add - Create directory in /proc for a scsi host
 * @sht: owner of this directory
 *
 * Sets sht->proc_dir to the new directory.
 */
int scsi_proc_hostdir_add(const struct scsi_host_template *sht)
{
	struct scsi_proc_entry *e;
	int ret;

	if (!sht->show_info)
		return 0;

	mutex_lock(&global_host_template_mutex);
	e = __scsi_lookup_proc_entry(sht);
	if (!e) {
		e = kzalloc(sizeof(*e), GFP_KERNEL);
		if (!e) {
			ret = -ENOMEM;
			goto unlock;
		}
	}
	if (e->present++)
		goto success;
	e->proc_dir = proc_mkdir(sht->proc_name, proc_scsi);
	if (!e->proc_dir) {
		printk(KERN_ERR "%s: proc_mkdir failed for %s\n", __func__,
		       sht->proc_name);
		ret = -ENOMEM;
		goto unlock;
	}
	e->sht = sht;
	list_add_tail(&e->entry, &scsi_proc_list);
success:
	e = NULL;
	ret = 0;
unlock:
	mutex_unlock(&global_host_template_mutex);

	kfree(e);
	return ret;
}

/**
 * scsi_proc_hostdir_rm - remove directory in /proc for a scsi host
 * @sht: owner of directory
 */
void scsi_proc_hostdir_rm(const struct scsi_host_template *sht)
{
	struct scsi_proc_entry *e;

	if (!sht->show_info)
		return;

	mutex_lock(&global_host_template_mutex);
	e = __scsi_lookup_proc_entry(sht);
	if (e && !--e->present) {
		remove_proc_entry(sht->proc_name, proc_scsi);
		list_del(&e->entry);
		kfree(e);
	}
	mutex_unlock(&global_host_template_mutex);
}


/**
 * scsi_proc_host_add - Add entry for this host to appropriate /proc dir
 * @shost: host to add
 */
void scsi_proc_host_add(struct Scsi_Host *shost)
{
	const struct scsi_host_template *sht = shost->hostt;
	struct scsi_proc_entry *e;
	struct proc_dir_entry *p;
	char name[10];

	if (!sht->show_info)
		return;

	e = scsi_lookup_proc_entry(sht);
	if (!e)
		goto err;

	sprintf(name,"%d", shost->host_no);
	p = proc_create_data(name, S_IRUGO | S_IWUSR, e->proc_dir,
			     &proc_scsi_ops, shost);
	if (!p)
		goto err;
	return;

err:
	shost_printk(KERN_ERR, shost,
		     "%s: Failed to register host (%s failed)\n", __func__,
		     e ? "proc_create_data()" : "scsi_proc_hostdir_add()");
}

/**
 * scsi_proc_host_rm - remove this host's entry from /proc
 * @shost: which host
 */
void scsi_proc_host_rm(struct Scsi_Host *shost)
{
	const struct scsi_host_template *sht = shost->hostt;
	struct scsi_proc_entry *e;
	char name[10];

	if (!sht->show_info)
		return;

	e = scsi_lookup_proc_entry(sht);
	if (!e)
		return;

	sprintf(name,"%d", shost->host_no);
	remove_proc_entry(name, e->proc_dir);
}
/**
 * proc_print_scsidevice - return data about this host
 * @dev: A scsi device
 * @data: &struct seq_file to output to.
 *
 * Description: prints Host, Channel, Id, Lun, Vendor, Model, Rev, Type,
 * and revision.
 */
static int proc_print_scsidevice(struct device *dev, void *data)
{
	struct scsi_device *sdev;
	struct seq_file *s = data;
	int i;

	if (!scsi_is_sdev_device(dev))
		goto out;

	sdev = to_scsi_device(dev);
	seq_printf(s,
		"Host: scsi%d Channel: %02d Id: %02d Lun: %02llu\n  Vendor: ",
		sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
	for (i = 0; i < 8; i++) {
		if (sdev->vendor[i] >= 0x20)
			seq_putc(s, sdev->vendor[i]);
		else
			seq_putc(s, ' ');
	}

	seq_puts(s, " Model: ");
	for (i = 0; i < 16; i++) {
		if (sdev->model[i] >= 0x20)
			seq_putc(s, sdev->model[i]);
		else
			seq_putc(s, ' ');
	}

	seq_puts(s, " Rev: ");
	for (i = 0; i < 4; i++) {
		if (sdev->rev[i] >= 0x20)
			seq_putc(s, sdev->rev[i]);
		else
			seq_putc(s, ' ');
	}

	seq_putc(s, '\n');

	seq_printf(s, "  Type:   %s ", scsi_device_type(sdev->type));
	seq_printf(s, "               ANSI  SCSI revision: %02x",
			sdev->scsi_level - (sdev->scsi_level > 1));
	if (sdev->scsi_level == 2)
		seq_puts(s, " CCS\n");
	else
		seq_putc(s, '\n');

out:
	return 0;
}

/**
 * scsi_add_single_device - Respond to user request to probe for/add device
 * @host: user-supplied decimal integer
 * @channel: user-supplied decimal integer
 * @id: user-supplied decimal integer
 * @lun: user-supplied decimal integer
 *
 * Description: called by writing "scsi add-single-device" to /proc/scsi/scsi.
 *
 * does scsi_host_lookup() and either user_scan() if that transport
 * type supports it, or else scsi_scan_host_selected()
 *
 * Note: this seems to be aimed exclusively at SCSI parallel busses.
 */

static int scsi_add_single_device(uint host, uint channel, uint id, uint lun)
{
	struct Scsi_Host *shost;
	int error = -ENXIO;

	shost = scsi_host_lookup(host);
	if (!shost)
		return error;

	if (shost->transportt->user_scan)
		error = shost->transportt->user_scan(shost, channel, id, lun);
	else
		error = scsi_scan_host_selected(shost, channel, id, lun,
						SCSI_SCAN_MANUAL);
	scsi_host_put(shost);
	return error;
}

/**
 * scsi_remove_single_device - Respond to user request to remove a device
 * @host: user-supplied decimal integer
 * @channel: user-supplied decimal integer
 * @id: user-supplied decimal integer
 * @lun: user-supplied decimal integer
 *
 * Description: called by writing "scsi remove-single-device" to
 * /proc/scsi/scsi.  Does a scsi_device_lookup() and scsi_remove_device()
 */
static int scsi_remove_single_device(uint host, uint channel, uint id, uint lun)
{
	struct scsi_device *sdev;
	struct Scsi_Host *shost;
	int error = -ENXIO;

	shost = scsi_host_lookup(host);
	if (!shost)
		return error;
	sdev = scsi_device_lookup(shost, channel, id, lun);
	if (sdev) {
		scsi_remove_device(sdev);
		scsi_device_put(sdev);
		error = 0;
	}

	scsi_host_put(shost);
	return error;
}

/**
 * proc_scsi_write - handle writes to /proc/scsi/scsi
 * @file: not used
 * @buf: buffer to write
 * @length: length of buf, at most PAGE_SIZE
 * @ppos: not used
 *
 * Description: this provides a legacy mechanism to add or remove devices by
 * Host, Channel, ID, and Lun.  To use,
 * "echo 'scsi add-single-device 0 1 2 3' > /proc/scsi/scsi" or
 * "echo 'scsi remove-single-device 0 1 2 3' > /proc/scsi/scsi" with
 * "0 1 2 3" replaced by the Host, Channel, Id, and Lun.
 *
 * Note: this seems to be aimed at parallel SCSI. Most modern busses (USB,
 * SATA, Firewire, Fibre Channel, etc) dynamically assign these values to
 * provide a unique identifier and nothing more.
 */


static ssize_t proc_scsi_write(struct file *file, const char __user *buf,
			       size_t length, loff_t *ppos)
{
	int host, channel, id, lun;
	char *buffer, *p;
	int err;

	if (!buf || length > PAGE_SIZE)
		return -EINVAL;

	buffer = (char *)__get_free_page(GFP_KERNEL);
	if (!buffer)
		return -ENOMEM;

	err = -EFAULT;
	if (copy_from_user(buffer, buf, length))
		goto out;

	err = -EINVAL;
	if (length < PAGE_SIZE)
		buffer[length] = '\0';
	else if (buffer[PAGE_SIZE-1])
		goto out;

	/*
	 * Usage: echo "scsi add-single-device 0 1 2 3" >/proc/scsi/scsi
	 * with  "0 1 2 3" replaced by your "Host Channel Id Lun".
	 */
	if (!strncmp("scsi add-single-device", buffer, 22)) {
		p = buffer + 23;

		host = simple_strtoul(p, &p, 0);
		channel = simple_strtoul(p + 1, &p, 0);
		id = simple_strtoul(p + 1, &p, 0);
		lun = simple_strtoul(p + 1, &p, 0);

		err = scsi_add_single_device(host, channel, id, lun);

	/*
	 * Usage: echo "scsi remove-single-device 0 1 2 3" >/proc/scsi/scsi
	 * with  "0 1 2 3" replaced by your "Host Channel Id Lun".
	 */
	} else if (!strncmp("scsi remove-single-device", buffer, 25)) {
		p = buffer + 26;

		host = simple_strtoul(p, &p, 0);
		channel = simple_strtoul(p + 1, &p, 0);
		id = simple_strtoul(p + 1, &p, 0);
		lun = simple_strtoul(p + 1, &p, 0);

		err = scsi_remove_single_device(host, channel, id, lun);
	}

	/*
	 * convert success returns so that we return the 
	 * number of bytes consumed.
	 */
	if (!err)
		err = length;

 out:
	free_page((unsigned long)buffer);
	return err;
}

static inline struct device *next_scsi_device(struct device *start)
{
	struct device *next = bus_find_next_device(&scsi_bus_type, start);

	put_device(start);
	return next;
}

static void *scsi_seq_start(struct seq_file *sfile, loff_t *pos)
{
	struct device *dev = NULL;
	loff_t n = *pos;

	while ((dev = next_scsi_device(dev))) {
		if (!n--)
			break;
		sfile->private++;
	}
	return dev;
}

static void *scsi_seq_next(struct seq_file *sfile, void *v, loff_t *pos)
{
	(*pos)++;
	sfile->private++;
	return next_scsi_device(v);
}

static void scsi_seq_stop(struct seq_file *sfile, void *v)
{
	put_device(v);
}

static int scsi_seq_show(struct seq_file *sfile, void *dev)
{
	if (!sfile->private)
		seq_puts(sfile, "Attached devices:\n");

	return proc_print_scsidevice(dev, sfile);
}

static const struct seq_operations scsi_seq_ops = {
	.start	= scsi_seq_start,
	.next	= scsi_seq_next,
	.stop	= scsi_seq_stop,
	.show	= scsi_seq_show
};

/**
 * proc_scsi_open - glue function
 * @inode: not used
 * @file: passed to single_open()
 *
 * Associates proc_scsi_show with this file
 */
static int proc_scsi_open(struct inode *inode, struct file *file)
{
	/*
	 * We don't really need this for the write case but it doesn't
	 * harm either.
	 */
	return seq_open(file, &scsi_seq_ops);
}

static const struct proc_ops scsi_scsi_proc_ops = {
	.proc_open	= proc_scsi_open,
	.proc_read	= seq_read,
	.proc_write	= proc_scsi_write,
	.proc_lseek	= seq_lseek,
	.proc_release	= seq_release,
};

/**
 * scsi_init_procfs - create scsi and scsi/scsi in procfs
 */
int __init scsi_init_procfs(void)
{
	struct proc_dir_entry *pde;

	proc_scsi = proc_mkdir("scsi", NULL);
	if (!proc_scsi)
		goto err1;

	pde = proc_create("scsi/scsi", 0, NULL, &scsi_scsi_proc_ops);
	if (!pde)
		goto err2;

	return 0;

err2:
	remove_proc_entry("scsi", NULL);
err1:
	return -ENOMEM;
}

/**
 * scsi_exit_procfs - Remove scsi/scsi and scsi from procfs
 */
void scsi_exit_procfs(void)
{
	remove_proc_entry("scsi/scsi", NULL);
	remove_proc_entry("scsi", NULL);
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4 LT	2	/*
	3	* linux/drivers/scsi/scsi_proc.c
	4	*
	5	* The functions in this file provide an interface between
	6	* the PROC file system and the SCSI device drivers
	7	* It is mainly used for debugging, statistics and to pass
	8	* information directly to the lowlevel driver.
	9	*
	10	* (c) 1995 Michael Neuffer neuffer@goofy.zdv.uni-mainz.de
	11	* Version: 0.99.8 last change: 95/09/13
	12	*
	13	* generic command parser provided by:
	14	* Andreas Heilwagen <crashcar@informatik.uni-koblenz.de>
	15	*
	16	* generic_proc_info() support of xxxx_info() by:
	17	* Michael A. Griffith <grif@acm.org>
	18	*/
	19
	20	#include <linux/module.h>
	21	#include <linux/init.h>
	22	#include <linux/string.h>
	23	#include <linux/mm.h>
1da177e4 LT	24	#include <linux/proc_fs.h>
	25	#include <linux/errno.h>
	26	#include <linux/blkdev.h>
	27	#include <linux/seq_file.h>
0b950672	28	#include <linux/mutex.h>
5a0e3ad6	29	#include <linux/gfp.h>
7c0f6ba6	30	#include <linux/uaccess.h>
1da177e4 LT	31
	32	#include <scsi/scsi.h>
	33	#include <scsi/scsi_device.h>
	34	#include <scsi/scsi_host.h>
e02f3f59	35	#include <scsi/scsi_transport.h>
1da177e4 LT	36
	37	#include "scsi_priv.h"
	38	#include "scsi_logging.h"
	39
	40
	41	/* 4K page size, but our output routines, use some slack for overruns */
	42	#define PROC_BLOCK_SIZE (3*1024)
	43
	44	static struct proc_dir_entry *proc_scsi;
	45
036abd61	46	/* Protects scsi_proc_list */
0b950672	47	static DEFINE_MUTEX(global_host_template_mutex);
036abd61 BVA	48	static LIST_HEAD(scsi_proc_list);
	49
	50	/**
	51	* struct scsi_proc_entry - (host template, SCSI proc dir) association
	52	* @entry: entry in scsi_proc_list.
	53	* @sht: SCSI host template associated with the procfs directory.
	54	* @proc_dir: procfs directory associated with the SCSI host template.
	55	* @present: Number of SCSI hosts instantiated for @sht.
	56	*/
	57	struct scsi_proc_entry {
	58	struct list_head entry;
	59	const struct scsi_host_template *sht;
	60	struct proc_dir_entry *proc_dir;
	61	unsigned int present;
	62	};
1da177e4	63
0ffddfbb AV	64	static ssize_t proc_scsi_host_write(struct file file, const char __user buf,
	65	size_t count, loff_t *ppos)
	66	{
359745d7	67	struct Scsi_Host *shost = pde_data(file_inode(file));
0ffddfbb AV	68	ssize_t ret = -ENOMEM;
	69	char *page;
	70
	71	if (count > PROC_BLOCK_SIZE)
	72	return -EOVERFLOW;
	73
	74	if (!shost->hostt->write_info)
	75	return -EINVAL;
	76
	77	page = (char *)__get_free_page(GFP_KERNEL);
	78	if (page) {
	79	ret = -EFAULT;
	80	if (copy_from_user(page, buf, count))
	81	goto out;
	82	ret = shost->hostt->write_info(shost, page, count);
	83	}
	84	out:
	85	free_page((unsigned long)page);
	86	return ret;
	87	}
	88
	89	static int proc_scsi_show(struct seq_file m, void v)
	90	{
	91	struct Scsi_Host *shost = m->private;
	92	return shost->hostt->show_info(m, shost);
	93	}
	94
	95	static int proc_scsi_host_open(struct inode inode, struct file file)
	96	{
359745d7	97	return single_open_size(file, proc_scsi_show, pde_data(inode),
859d22f9	98	4 * PAGE_SIZE);
0ffddfbb AV	99	}
0ffddfbb AV	100
036abd61 BVA	101	static struct scsi_proc_entry *
	102	__scsi_lookup_proc_entry(const struct scsi_host_template *sht)
	103	{
	104	struct scsi_proc_entry *e;
	105
	106	lockdep_assert_held(&global_host_template_mutex);
	107
	108	list_for_each_entry(e, &scsi_proc_list, entry)
	109	if (e->sht == sht)
	110	return e;
	111
	112	return NULL;
	113	}
	114
	115	static struct scsi_proc_entry *
	116	scsi_lookup_proc_entry(const struct scsi_host_template *sht)
	117	{
	118	struct scsi_proc_entry *e;
	119
	120	mutex_lock(&global_host_template_mutex);
	121	e = __scsi_lookup_proc_entry(sht);
	122	mutex_unlock(&global_host_template_mutex);
	123
	124	return e;
	125	}
	126
77916da7 BVA	127	/**
	128	* scsi_template_proc_dir() - returns the procfs dir for a SCSI host template
	129	* @sht: SCSI host template pointer.
	130	*/
	131	struct proc_dir_entry *
	132	scsi_template_proc_dir(const struct scsi_host_template *sht)
	133	{
036abd61 BVA	134	struct scsi_proc_entry *e = scsi_lookup_proc_entry(sht);
	135
	136	return e ? e->proc_dir : NULL;
77916da7 BVA	137	}
	138	EXPORT_SYMBOL_GPL(scsi_template_proc_dir);
	139
97a32539 AD	140	static const struct proc_ops proc_scsi_ops = {
	141	.proc_open = proc_scsi_host_open,
	142	.proc_release = single_release,
	143	.proc_read = seq_read,
	144	.proc_lseek = seq_lseek,
	145	.proc_write = proc_scsi_host_write
0ffddfbb AV	146	};
0ffddfbb AV	147
eb44820c RL	148	/**
	149	* scsi_proc_hostdir_add - Create directory in /proc for a scsi host
	150	* @sht: owner of this directory
	151	*
	152	* Sets sht->proc_dir to the new directory.
	153	*/
036abd61	154	int scsi_proc_hostdir_add(const struct scsi_host_template *sht)
1da177e4	155	{
036abd61 BVA	156	struct scsi_proc_entry *e;
036abd61 BVA	157	int ret;
ecca3f9b	158
70ef457d	159	if (!sht->show_info)
ecca3f9b	160	return 0;
1da177e4	161
0b950672	162	mutex_lock(&global_host_template_mutex);
036abd61 BVA	163	e = __scsi_lookup_proc_entry(sht);
	164	if (!e) {
	165	e = kzalloc(sizeof(*e), GFP_KERNEL);
	166	if (!e) {
ecca3f9b	167	ret = -ENOMEM;
036abd61	168	goto unlock;
ecca3f9b	169	}
1da177e4	170	}
036abd61 BVA	171	if (e->present++)
	172	goto success;
	173	e->proc_dir = proc_mkdir(sht->proc_name, proc_scsi);
	174	if (!e->proc_dir) {
	175	printk(KERN_ERR "%s: proc_mkdir failed for %s\n", __func__,
	176	sht->proc_name);
	177	ret = -ENOMEM;
	178	goto unlock;
	179	}
	180	e->sht = sht;
	181	list_add_tail(&e->entry, &scsi_proc_list);
	182	success:
	183	e = NULL;
	184	ret = 0;
	185	unlock:
0b950672	186	mutex_unlock(&global_host_template_mutex);
ecca3f9b	187
036abd61	188	kfree(e);
ecca3f9b	189	return ret;
1da177e4 LT	190	}
1da177e4 LT	191
eb44820c RL	192	/**
	193	* scsi_proc_hostdir_rm - remove directory in /proc for a scsi host
	194	* @sht: owner of directory
	195	*/
036abd61	196	void scsi_proc_hostdir_rm(const struct scsi_host_template *sht)
1da177e4	197	{
036abd61 BVA	198	struct scsi_proc_entry *e;
036abd61 BVA	199
70ef457d	200	if (!sht->show_info)
1da177e4 LT	201	return;
1da177e4 LT	202
0b950672	203	mutex_lock(&global_host_template_mutex);
036abd61 BVA	204	e = __scsi_lookup_proc_entry(sht);
036abd61 BVA	205	if (e && !--e->present) {
1da177e4	206	remove_proc_entry(sht->proc_name, proc_scsi);
036abd61 BVA	207	list_del(&e->entry);
036abd61 BVA	208	kfree(e);
1da177e4	209	}
0b950672	210	mutex_unlock(&global_host_template_mutex);
1da177e4 LT	211	}
1da177e4 LT	212
eb44820c RL	213
	214	/**
	215	* scsi_proc_host_add - Add entry for this host to appropriate /proc dir
	216	* @shost: host to add
	217	*/
1da177e4 LT	218	void scsi_proc_host_add(struct Scsi_Host *shost)
1da177e4 LT	219	{
036abd61 BVA	220	const struct scsi_host_template *sht = shost->hostt;
036abd61 BVA	221	struct scsi_proc_entry *e;
1da177e4 LT	222	struct proc_dir_entry *p;
	223	char name[10];
	224
036abd61	225	if (!sht->show_info)
1da177e4 LT	226	return;
1da177e4 LT	227
036abd61 BVA	228	e = scsi_lookup_proc_entry(sht);
	229	if (!e)
	230	goto err;
	231
1da177e4	232	sprintf(name,"%d", shost->host_no);
036abd61 BVA	233	p = proc_create_data(name, S_IRUGO \| S_IWUSR, e->proc_dir,
036abd61 BVA	234	&proc_scsi_ops, shost);
70ef457d	235	if (!p)
036abd61 BVA	236	goto err;
	237	return;
	238
	239	err:
	240	shost_printk(KERN_ERR, shost,
	241	"%s: Failed to register host (%s failed)\n", __func__,
	242	e ? "proc_create_data()" : "scsi_proc_hostdir_add()");
1da177e4 LT	243	}
1da177e4 LT	244
eb44820c RL	245	/**
	246	* scsi_proc_host_rm - remove this host's entry from /proc
	247	* @shost: which host
	248	*/
1da177e4 LT	249	void scsi_proc_host_rm(struct Scsi_Host *shost)
1da177e4 LT	250	{
036abd61 BVA	251	const struct scsi_host_template *sht = shost->hostt;
036abd61 BVA	252	struct scsi_proc_entry *e;
1da177e4 LT	253	char name[10];
1da177e4 LT	254
036abd61 BVA	255	if (!sht->show_info)
	256	return;
	257
	258	e = scsi_lookup_proc_entry(sht);
	259	if (!e)
1da177e4 LT	260	return;
	261
	262	sprintf(name,"%d", shost->host_no);
036abd61	263	remove_proc_entry(name, e->proc_dir);
1da177e4	264	}
eb44820c RL	265	/**
	266	* proc_print_scsidevice - return data about this host
	267	* @dev: A scsi device
	268	* @data: &struct seq_file to output to.
	269	*
	270	* Description: prints Host, Channel, Id, Lun, Vendor, Model, Rev, Type,
	271	* and revision.
	272	*/
1da177e4 LT	273	static int proc_print_scsidevice(struct device dev, void data)
1da177e4 LT	274	{
b0ed4336	275	struct scsi_device *sdev;
1da177e4 LT	276	struct seq_file *s = data;
	277	int i;
	278
b0ed4336 HR	279	if (!scsi_is_sdev_device(dev))
	280	goto out;
	281
	282	sdev = to_scsi_device(dev);
1da177e4	283	seq_printf(s,
9cb78c16	284	"Host: scsi%d Channel: %02d Id: %02d Lun: %02llu\n Vendor: ",
1da177e4 LT	285	sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
	286	for (i = 0; i < 8; i++) {
	287	if (sdev->vendor[i] >= 0x20)
91c40f24	288	seq_putc(s, sdev->vendor[i]);
1da177e4	289	else
f50332ff	290	seq_putc(s, ' ');
1da177e4 LT	291	}
1da177e4 LT	292
91c40f24	293	seq_puts(s, " Model: ");
1da177e4 LT	294	for (i = 0; i < 16; i++) {
1da177e4 LT	295	if (sdev->model[i] >= 0x20)
91c40f24	296	seq_putc(s, sdev->model[i]);
1da177e4	297	else
f50332ff	298	seq_putc(s, ' ');
1da177e4 LT	299	}
1da177e4 LT	300
91c40f24	301	seq_puts(s, " Rev: ");
1da177e4 LT	302	for (i = 0; i < 4; i++) {
1da177e4 LT	303	if (sdev->rev[i] >= 0x20)
91c40f24	304	seq_putc(s, sdev->rev[i]);
1da177e4	305	else
f50332ff	306	seq_putc(s, ' ');
1da177e4 LT	307	}
1da177e4 LT	308
f50332ff	309	seq_putc(s, '\n');
1da177e4	310
4ff36718	311	seq_printf(s, " Type: %s ", scsi_device_type(sdev->type));
74feb53e AS	312	seq_printf(s, " ANSI SCSI revision: %02x",
74feb53e AS	313	sdev->scsi_level - (sdev->scsi_level > 1));
1da177e4	314	if (sdev->scsi_level == 2)
91c40f24	315	seq_puts(s, " CCS\n");
1da177e4	316	else
f50332ff	317	seq_putc(s, '\n');
1da177e4	318
b0ed4336	319	out:
1da177e4 LT	320	return 0;
	321	}
	322
eb44820c RL	323	/**
	324	* scsi_add_single_device - Respond to user request to probe for/add device
	325	* @host: user-supplied decimal integer
	326	* @channel: user-supplied decimal integer
	327	* @id: user-supplied decimal integer
	328	* @lun: user-supplied decimal integer
	329	*
	330	* Description: called by writing "scsi add-single-device" to /proc/scsi/scsi.
	331	*
	332	* does scsi_host_lookup() and either user_scan() if that transport
	333	* type supports it, or else scsi_scan_host_selected()
	334	*
	335	* Note: this seems to be aimed exclusively at SCSI parallel busses.
	336	*/
	337
1da177e4 LT	338	static int scsi_add_single_device(uint host, uint channel, uint id, uint lun)
	339	{
	340	struct Scsi_Host *shost;
	341	int error = -ENXIO;
	342
	343	shost = scsi_host_lookup(host);
315cb0ad JS	344	if (!shost)
315cb0ad JS	345	return error;
1da177e4	346
e02f3f59 CH	347	if (shost->transportt->user_scan)
	348	error = shost->transportt->user_scan(shost, channel, id, lun);
	349	else
1d645088 HR	350	error = scsi_scan_host_selected(shost, channel, id, lun,
1d645088 HR	351	SCSI_SCAN_MANUAL);
1da177e4 LT	352	scsi_host_put(shost);
	353	return error;
	354	}
	355
eb44820c RL	356	/**
	357	* scsi_remove_single_device - Respond to user request to remove a device
	358	* @host: user-supplied decimal integer
	359	* @channel: user-supplied decimal integer
	360	* @id: user-supplied decimal integer
	361	* @lun: user-supplied decimal integer
	362	*
	363	* Description: called by writing "scsi remove-single-device" to
	364	* /proc/scsi/scsi. Does a scsi_device_lookup() and scsi_remove_device()
	365	*/
1da177e4 LT	366	static int scsi_remove_single_device(uint host, uint channel, uint id, uint lun)
	367	{
	368	struct scsi_device *sdev;
	369	struct Scsi_Host *shost;
	370	int error = -ENXIO;
	371
	372	shost = scsi_host_lookup(host);
315cb0ad JS	373	if (!shost)
315cb0ad JS	374	return error;
1da177e4 LT	375	sdev = scsi_device_lookup(shost, channel, id, lun);
	376	if (sdev) {
	377	scsi_remove_device(sdev);
	378	scsi_device_put(sdev);
	379	error = 0;
	380	}
	381
	382	scsi_host_put(shost);
	383	return error;
	384	}
	385
eb44820c RL	386	/**
	387	* proc_scsi_write - handle writes to /proc/scsi/scsi
	388	* @file: not used
	389	* @buf: buffer to write
	390	* @length: length of buf, at most PAGE_SIZE
	391	* @ppos: not used
	392	*
	393	* Description: this provides a legacy mechanism to add or remove devices by
	394	* Host, Channel, ID, and Lun. To use,
	395	* "echo 'scsi add-single-device 0 1 2 3' > /proc/scsi/scsi" or
	396	* "echo 'scsi remove-single-device 0 1 2 3' > /proc/scsi/scsi" with
	397	* "0 1 2 3" replaced by the Host, Channel, Id, and Lun.
	398	*
	399	* Note: this seems to be aimed at parallel SCSI. Most modern busses (USB,
	400	* SATA, Firewire, Fibre Channel, etc) dynamically assign these values to
	401	* provide a unique identifier and nothing more.
	402	*/
	403
	404
1da177e4 LT	405	static ssize_t proc_scsi_write(struct file file, const char __user buf,
	406	size_t length, loff_t *ppos)
	407	{
	408	int host, channel, id, lun;
	409	char buffer, p;
	410	int err;
	411
	412	if (!buf \|\| length > PAGE_SIZE)
	413	return -EINVAL;
	414
	415	buffer = (char *)__get_free_page(GFP_KERNEL);
	416	if (!buffer)
	417	return -ENOMEM;
	418
	419	err = -EFAULT;
	420	if (copy_from_user(buffer, buf, length))
	421	goto out;
	422
	423	err = -EINVAL;
	424	if (length < PAGE_SIZE)
	425	buffer[length] = '\0';
	426	else if (buffer[PAGE_SIZE-1])
	427	goto out;
	428
	429	/*
	430	* Usage: echo "scsi add-single-device 0 1 2 3" >/proc/scsi/scsi
	431	* with "0 1 2 3" replaced by your "Host Channel Id Lun".
	432	*/
	433	if (!strncmp("scsi add-single-device", buffer, 22)) {
	434	p = buffer + 23;
	435
	436	host = simple_strtoul(p, &p, 0);
	437	channel = simple_strtoul(p + 1, &p, 0);
	438	id = simple_strtoul(p + 1, &p, 0);
	439	lun = simple_strtoul(p + 1, &p, 0);
	440
	441	err = scsi_add_single_device(host, channel, id, lun);
1da177e4 LT	442
	443	/*
	444	* Usage: echo "scsi remove-single-device 0 1 2 3" >/proc/scsi/scsi
	445	* with "0 1 2 3" replaced by your "Host Channel Id Lun".
	446	*/
	447	} else if (!strncmp("scsi remove-single-device", buffer, 25)) {
	448	p = buffer + 26;
	449
	450	host = simple_strtoul(p, &p, 0);
	451	channel = simple_strtoul(p + 1, &p, 0);
	452	id = simple_strtoul(p + 1, &p, 0);
	453	lun = simple_strtoul(p + 1, &p, 0);
	454
	455	err = scsi_remove_single_device(host, channel, id, lun);
	456	}
	457
2ca48a13 JB	458	/*
	459	* convert success returns so that we return the
	460	* number of bytes consumed.
	461	*/
	462	if (!err)
	463	err = length;
	464
1da177e4 LT	465	out:
	466	free_page((unsigned long)buffer);
	467	return err;
	468	}
	469
e37c4913 JM	470	static inline struct device next_scsi_device(struct device start)
e37c4913 JM	471	{
6bf85ba9 SP	472	struct device *next = bus_find_next_device(&scsi_bus_type, start);
6bf85ba9 SP	473
e37c4913 JM	474	put_device(start);
e37c4913 JM	475	return next;
1da177e4 LT	476	}
1da177e4 LT	477
e37c4913 JM	478	static void scsi_seq_start(struct seq_file sfile, loff_t *pos)
	479	{
	480	struct device *dev = NULL;
	481	loff_t n = *pos;
	482
	483	while ((dev = next_scsi_device(dev))) {
	484	if (!n--)
	485	break;
	486	sfile->private++;
	487	}
	488	return dev;
	489	}
	490
	491	static void scsi_seq_next(struct seq_file sfile, void v, loff_t pos)
	492	{
	493	(*pos)++;
	494	sfile->private++;
	495	return next_scsi_device(v);
	496	}
	497
	498	static void scsi_seq_stop(struct seq_file sfile, void v)
	499	{
	500	put_device(v);
	501	}
	502
	503	static int scsi_seq_show(struct seq_file sfile, void dev)
	504	{
	505	if (!sfile->private)
	506	seq_puts(sfile, "Attached devices:\n");
	507
	508	return proc_print_scsidevice(dev, sfile);
	509	}
	510
	511	static const struct seq_operations scsi_seq_ops = {
	512	.start = scsi_seq_start,
	513	.next = scsi_seq_next,
	514	.stop = scsi_seq_stop,
	515	.show = scsi_seq_show
	516	};
	517
eb44820c RL	518	/**
	519	* proc_scsi_open - glue function
	520	* @inode: not used
	521	* @file: passed to single_open()
	522	*
	523	* Associates proc_scsi_show with this file
	524	*/
1da177e4 LT	525	static int proc_scsi_open(struct inode inode, struct file file)
	526	{
	527	/*
eb44820c	528	* We don't really need this for the write case but it doesn't
1da177e4 LT	529	* harm either.
1da177e4 LT	530	*/
e37c4913	531	return seq_open(file, &scsi_seq_ops);
1da177e4 LT	532	}
1da177e4 LT	533
97a32539 AD	534	static const struct proc_ops scsi_scsi_proc_ops = {
	535	.proc_open = proc_scsi_open,
	536	.proc_read = seq_read,
	537	.proc_write = proc_scsi_write,
	538	.proc_lseek = seq_lseek,
	539	.proc_release = seq_release,
1da177e4 LT	540	};
1da177e4 LT	541
eb44820c RL	542	/**
	543	* scsi_init_procfs - create scsi and scsi/scsi in procfs
	544	*/
1da177e4 LT	545	int __init scsi_init_procfs(void)
	546	{
	547	struct proc_dir_entry *pde;
	548
	549	proc_scsi = proc_mkdir("scsi", NULL);
	550	if (!proc_scsi)
	551	goto err1;
	552
97a32539	553	pde = proc_create("scsi/scsi", 0, NULL, &scsi_scsi_proc_ops);
1da177e4 LT	554	if (!pde)
1da177e4 LT	555	goto err2;
1da177e4 LT	556
	557	return 0;
	558
	559	err2:
	560	remove_proc_entry("scsi", NULL);
	561	err1:
	562	return -ENOMEM;
	563	}
	564
eb44820c RL	565	/**
	566	* scsi_exit_procfs - Remove scsi/scsi and scsi from procfs
	567	*/
1da177e4 LT	568	void scsi_exit_procfs(void)
	569	{
	570	remove_proc_entry("scsi/scsi", NULL);
	571	remove_proc_entry("scsi", NULL);
	572	}