1b2441318SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * linux/drivers/scsi/scsi_proc.c
41da177e4SLinus Torvalds *
51da177e4SLinus Torvalds * The functions in this file provide an interface between
61da177e4SLinus Torvalds * the PROC file system and the SCSI device drivers
71da177e4SLinus Torvalds * It is mainly used for debugging, statistics and to pass
81da177e4SLinus Torvalds * information directly to the lowlevel driver.
91da177e4SLinus Torvalds *
101da177e4SLinus Torvalds * (c) 1995 Michael Neuffer neuffer@goofy.zdv.uni-mainz.de
111da177e4SLinus Torvalds * Version: 0.99.8 last change: 95/09/13
121da177e4SLinus Torvalds *
131da177e4SLinus Torvalds * generic command parser provided by:
141da177e4SLinus Torvalds * Andreas Heilwagen <crashcar@informatik.uni-koblenz.de>
151da177e4SLinus Torvalds *
161da177e4SLinus Torvalds * generic_proc_info() support of xxxx_info() by:
171da177e4SLinus Torvalds * Michael A. Griffith <grif@acm.org>
181da177e4SLinus Torvalds */
191da177e4SLinus Torvalds
201da177e4SLinus Torvalds #include <linux/module.h>
211da177e4SLinus Torvalds #include <linux/init.h>
221da177e4SLinus Torvalds #include <linux/string.h>
231da177e4SLinus Torvalds #include <linux/mm.h>
241da177e4SLinus Torvalds #include <linux/proc_fs.h>
251da177e4SLinus Torvalds #include <linux/errno.h>
261da177e4SLinus Torvalds #include <linux/blkdev.h>
271da177e4SLinus Torvalds #include <linux/seq_file.h>
280b950672SArjan van de Ven #include <linux/mutex.h>
295a0e3ad6STejun Heo #include <linux/gfp.h>
307c0f6ba6SLinus Torvalds #include <linux/uaccess.h>
311da177e4SLinus Torvalds
321da177e4SLinus Torvalds #include <scsi/scsi.h>
331da177e4SLinus Torvalds #include <scsi/scsi_device.h>
341da177e4SLinus Torvalds #include <scsi/scsi_host.h>
35e02f3f59SChristoph Hellwig #include <scsi/scsi_transport.h>
361da177e4SLinus Torvalds
371da177e4SLinus Torvalds #include "scsi_priv.h"
381da177e4SLinus Torvalds #include "scsi_logging.h"
391da177e4SLinus Torvalds
401da177e4SLinus Torvalds
411da177e4SLinus Torvalds /* 4K page size, but our output routines, use some slack for overruns */
421da177e4SLinus Torvalds #define PROC_BLOCK_SIZE (3*1024)
431da177e4SLinus Torvalds
441da177e4SLinus Torvalds static struct proc_dir_entry *proc_scsi;
451da177e4SLinus Torvalds
46036abd61SBart Van Assche /* Protects scsi_proc_list */
470b950672SArjan van de Ven static DEFINE_MUTEX(global_host_template_mutex);
48036abd61SBart Van Assche static LIST_HEAD(scsi_proc_list);
49036abd61SBart Van Assche
50036abd61SBart Van Assche /**
51036abd61SBart Van Assche * struct scsi_proc_entry - (host template, SCSI proc dir) association
52036abd61SBart Van Assche * @entry: entry in scsi_proc_list.
53036abd61SBart Van Assche * @sht: SCSI host template associated with the procfs directory.
54036abd61SBart Van Assche * @proc_dir: procfs directory associated with the SCSI host template.
55036abd61SBart Van Assche * @present: Number of SCSI hosts instantiated for @sht.
56036abd61SBart Van Assche */
57036abd61SBart Van Assche struct scsi_proc_entry {
58036abd61SBart Van Assche struct list_head entry;
59036abd61SBart Van Assche const struct scsi_host_template *sht;
60036abd61SBart Van Assche struct proc_dir_entry *proc_dir;
61036abd61SBart Van Assche unsigned int present;
62036abd61SBart Van Assche };
631da177e4SLinus Torvalds
proc_scsi_host_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)640ffddfbbSAl Viro static ssize_t proc_scsi_host_write(struct file *file, const char __user *buf,
650ffddfbbSAl Viro size_t count, loff_t *ppos)
660ffddfbbSAl Viro {
67359745d7SMuchun Song struct Scsi_Host *shost = pde_data(file_inode(file));
680ffddfbbSAl Viro ssize_t ret = -ENOMEM;
690ffddfbbSAl Viro char *page;
700ffddfbbSAl Viro
710ffddfbbSAl Viro if (count > PROC_BLOCK_SIZE)
720ffddfbbSAl Viro return -EOVERFLOW;
730ffddfbbSAl Viro
740ffddfbbSAl Viro if (!shost->hostt->write_info)
750ffddfbbSAl Viro return -EINVAL;
760ffddfbbSAl Viro
770ffddfbbSAl Viro page = (char *)__get_free_page(GFP_KERNEL);
780ffddfbbSAl Viro if (page) {
790ffddfbbSAl Viro ret = -EFAULT;
800ffddfbbSAl Viro if (copy_from_user(page, buf, count))
810ffddfbbSAl Viro goto out;
820ffddfbbSAl Viro ret = shost->hostt->write_info(shost, page, count);
830ffddfbbSAl Viro }
840ffddfbbSAl Viro out:
850ffddfbbSAl Viro free_page((unsigned long)page);
860ffddfbbSAl Viro return ret;
870ffddfbbSAl Viro }
880ffddfbbSAl Viro
proc_scsi_show(struct seq_file * m,void * v)890ffddfbbSAl Viro static int proc_scsi_show(struct seq_file *m, void *v)
900ffddfbbSAl Viro {
910ffddfbbSAl Viro struct Scsi_Host *shost = m->private;
920ffddfbbSAl Viro return shost->hostt->show_info(m, shost);
930ffddfbbSAl Viro }
940ffddfbbSAl Viro
proc_scsi_host_open(struct inode * inode,struct file * file)950ffddfbbSAl Viro static int proc_scsi_host_open(struct inode *inode, struct file *file)
960ffddfbbSAl Viro {
97359745d7SMuchun Song return single_open_size(file, proc_scsi_show, pde_data(inode),
98859d22f9SAl Viro 4 * PAGE_SIZE);
990ffddfbbSAl Viro }
1000ffddfbbSAl Viro
101036abd61SBart Van Assche static struct scsi_proc_entry *
__scsi_lookup_proc_entry(const struct scsi_host_template * sht)102036abd61SBart Van Assche __scsi_lookup_proc_entry(const struct scsi_host_template *sht)
103036abd61SBart Van Assche {
104036abd61SBart Van Assche struct scsi_proc_entry *e;
105036abd61SBart Van Assche
106036abd61SBart Van Assche lockdep_assert_held(&global_host_template_mutex);
107036abd61SBart Van Assche
108036abd61SBart Van Assche list_for_each_entry(e, &scsi_proc_list, entry)
109036abd61SBart Van Assche if (e->sht == sht)
110036abd61SBart Van Assche return e;
111036abd61SBart Van Assche
112036abd61SBart Van Assche return NULL;
113036abd61SBart Van Assche }
114036abd61SBart Van Assche
115036abd61SBart Van Assche static struct scsi_proc_entry *
scsi_lookup_proc_entry(const struct scsi_host_template * sht)116036abd61SBart Van Assche scsi_lookup_proc_entry(const struct scsi_host_template *sht)
117036abd61SBart Van Assche {
118036abd61SBart Van Assche struct scsi_proc_entry *e;
119036abd61SBart Van Assche
120036abd61SBart Van Assche mutex_lock(&global_host_template_mutex);
121036abd61SBart Van Assche e = __scsi_lookup_proc_entry(sht);
122036abd61SBart Van Assche mutex_unlock(&global_host_template_mutex);
123036abd61SBart Van Assche
124036abd61SBart Van Assche return e;
125036abd61SBart Van Assche }
126036abd61SBart Van Assche
12777916da7SBart Van Assche /**
12877916da7SBart Van Assche * scsi_template_proc_dir() - returns the procfs dir for a SCSI host template
12977916da7SBart Van Assche * @sht: SCSI host template pointer.
13077916da7SBart Van Assche */
13177916da7SBart Van Assche struct proc_dir_entry *
scsi_template_proc_dir(const struct scsi_host_template * sht)13277916da7SBart Van Assche scsi_template_proc_dir(const struct scsi_host_template *sht)
13377916da7SBart Van Assche {
134036abd61SBart Van Assche struct scsi_proc_entry *e = scsi_lookup_proc_entry(sht);
135036abd61SBart Van Assche
136036abd61SBart Van Assche return e ? e->proc_dir : NULL;
13777916da7SBart Van Assche }
13877916da7SBart Van Assche EXPORT_SYMBOL_GPL(scsi_template_proc_dir);
13977916da7SBart Van Assche
14097a32539SAlexey Dobriyan static const struct proc_ops proc_scsi_ops = {
14197a32539SAlexey Dobriyan .proc_open = proc_scsi_host_open,
14297a32539SAlexey Dobriyan .proc_release = single_release,
14397a32539SAlexey Dobriyan .proc_read = seq_read,
14497a32539SAlexey Dobriyan .proc_lseek = seq_lseek,
14597a32539SAlexey Dobriyan .proc_write = proc_scsi_host_write
1460ffddfbbSAl Viro };
1470ffddfbbSAl Viro
148eb44820cSRob Landley /**
149eb44820cSRob Landley * scsi_proc_hostdir_add - Create directory in /proc for a scsi host
150eb44820cSRob Landley * @sht: owner of this directory
151eb44820cSRob Landley *
152eb44820cSRob Landley * Sets sht->proc_dir to the new directory.
153eb44820cSRob Landley */
scsi_proc_hostdir_add(const struct scsi_host_template * sht)154036abd61SBart Van Assche int scsi_proc_hostdir_add(const struct scsi_host_template *sht)
1551da177e4SLinus Torvalds {
156036abd61SBart Van Assche struct scsi_proc_entry *e;
157036abd61SBart Van Assche int ret;
158ecca3f9bSBart Van Assche
15970ef457dSAl Viro if (!sht->show_info)
160ecca3f9bSBart Van Assche return 0;
1611da177e4SLinus Torvalds
1620b950672SArjan van de Ven mutex_lock(&global_host_template_mutex);
163036abd61SBart Van Assche e = __scsi_lookup_proc_entry(sht);
164036abd61SBart Van Assche if (!e) {
165036abd61SBart Van Assche e = kzalloc(sizeof(*e), GFP_KERNEL);
166036abd61SBart Van Assche if (!e) {
167ecca3f9bSBart Van Assche ret = -ENOMEM;
168036abd61SBart Van Assche goto unlock;
169ecca3f9bSBart Van Assche }
1701da177e4SLinus Torvalds }
171036abd61SBart Van Assche if (e->present++)
172036abd61SBart Van Assche goto success;
173036abd61SBart Van Assche e->proc_dir = proc_mkdir(sht->proc_name, proc_scsi);
174036abd61SBart Van Assche if (!e->proc_dir) {
175036abd61SBart Van Assche printk(KERN_ERR "%s: proc_mkdir failed for %s\n", __func__,
176036abd61SBart Van Assche sht->proc_name);
177036abd61SBart Van Assche ret = -ENOMEM;
178036abd61SBart Van Assche goto unlock;
179036abd61SBart Van Assche }
180036abd61SBart Van Assche e->sht = sht;
181036abd61SBart Van Assche list_add_tail(&e->entry, &scsi_proc_list);
182036abd61SBart Van Assche success:
183036abd61SBart Van Assche e = NULL;
184036abd61SBart Van Assche ret = 0;
185036abd61SBart Van Assche unlock:
1860b950672SArjan van de Ven mutex_unlock(&global_host_template_mutex);
187ecca3f9bSBart Van Assche
188036abd61SBart Van Assche kfree(e);
189ecca3f9bSBart Van Assche return ret;
1901da177e4SLinus Torvalds }
1911da177e4SLinus Torvalds
192eb44820cSRob Landley /**
193eb44820cSRob Landley * scsi_proc_hostdir_rm - remove directory in /proc for a scsi host
194eb44820cSRob Landley * @sht: owner of directory
195eb44820cSRob Landley */
scsi_proc_hostdir_rm(const struct scsi_host_template * sht)196036abd61SBart Van Assche void scsi_proc_hostdir_rm(const struct scsi_host_template *sht)
1971da177e4SLinus Torvalds {
198036abd61SBart Van Assche struct scsi_proc_entry *e;
199036abd61SBart Van Assche
20070ef457dSAl Viro if (!sht->show_info)
2011da177e4SLinus Torvalds return;
2021da177e4SLinus Torvalds
2030b950672SArjan van de Ven mutex_lock(&global_host_template_mutex);
204036abd61SBart Van Assche e = __scsi_lookup_proc_entry(sht);
205036abd61SBart Van Assche if (e && !--e->present) {
2061da177e4SLinus Torvalds remove_proc_entry(sht->proc_name, proc_scsi);
207036abd61SBart Van Assche list_del(&e->entry);
208036abd61SBart Van Assche kfree(e);
2091da177e4SLinus Torvalds }
2100b950672SArjan van de Ven mutex_unlock(&global_host_template_mutex);
2111da177e4SLinus Torvalds }
2121da177e4SLinus Torvalds
213eb44820cSRob Landley
214eb44820cSRob Landley /**
215eb44820cSRob Landley * scsi_proc_host_add - Add entry for this host to appropriate /proc dir
216eb44820cSRob Landley * @shost: host to add
217eb44820cSRob Landley */
scsi_proc_host_add(struct Scsi_Host * shost)2181da177e4SLinus Torvalds void scsi_proc_host_add(struct Scsi_Host *shost)
2191da177e4SLinus Torvalds {
220036abd61SBart Van Assche const struct scsi_host_template *sht = shost->hostt;
221036abd61SBart Van Assche struct scsi_proc_entry *e;
2221da177e4SLinus Torvalds struct proc_dir_entry *p;
2231da177e4SLinus Torvalds char name[10];
2241da177e4SLinus Torvalds
225036abd61SBart Van Assche if (!sht->show_info)
2261da177e4SLinus Torvalds return;
2271da177e4SLinus Torvalds
228036abd61SBart Van Assche e = scsi_lookup_proc_entry(sht);
229036abd61SBart Van Assche if (!e)
230036abd61SBart Van Assche goto err;
231036abd61SBart Van Assche
2321da177e4SLinus Torvalds sprintf(name,"%d", shost->host_no);
233036abd61SBart Van Assche p = proc_create_data(name, S_IRUGO | S_IWUSR, e->proc_dir,
234036abd61SBart Van Assche &proc_scsi_ops, shost);
2350ffddfbbSAl Viro if (!p)
236036abd61SBart Van Assche goto err;
237036abd61SBart Van Assche return;
238036abd61SBart Van Assche
239036abd61SBart Van Assche err:
240036abd61SBart Van Assche shost_printk(KERN_ERR, shost,
241036abd61SBart Van Assche "%s: Failed to register host (%s failed)\n", __func__,
242036abd61SBart Van Assche e ? "proc_create_data()" : "scsi_proc_hostdir_add()");
2431da177e4SLinus Torvalds }
2441da177e4SLinus Torvalds
245eb44820cSRob Landley /**
246eb44820cSRob Landley * scsi_proc_host_rm - remove this host's entry from /proc
247eb44820cSRob Landley * @shost: which host
248eb44820cSRob Landley */
scsi_proc_host_rm(struct Scsi_Host * shost)2491da177e4SLinus Torvalds void scsi_proc_host_rm(struct Scsi_Host *shost)
2501da177e4SLinus Torvalds {
251036abd61SBart Van Assche const struct scsi_host_template *sht = shost->hostt;
252036abd61SBart Van Assche struct scsi_proc_entry *e;
2531da177e4SLinus Torvalds char name[10];
2541da177e4SLinus Torvalds
255036abd61SBart Van Assche if (!sht->show_info)
256036abd61SBart Van Assche return;
257036abd61SBart Van Assche
258036abd61SBart Van Assche e = scsi_lookup_proc_entry(sht);
259036abd61SBart Van Assche if (!e)
2601da177e4SLinus Torvalds return;
2611da177e4SLinus Torvalds
2621da177e4SLinus Torvalds sprintf(name,"%d", shost->host_no);
263036abd61SBart Van Assche remove_proc_entry(name, e->proc_dir);
2641da177e4SLinus Torvalds }
265eb44820cSRob Landley /**
266eb44820cSRob Landley * proc_print_scsidevice - return data about this host
267eb44820cSRob Landley * @dev: A scsi device
268eb44820cSRob Landley * @data: &struct seq_file to output to.
269eb44820cSRob Landley *
270eb44820cSRob Landley * Description: prints Host, Channel, Id, Lun, Vendor, Model, Rev, Type,
271eb44820cSRob Landley * and revision.
272eb44820cSRob Landley */
proc_print_scsidevice(struct device * dev,void * data)2731da177e4SLinus Torvalds static int proc_print_scsidevice(struct device *dev, void *data)
2741da177e4SLinus Torvalds {
275b0ed4336SHannes Reinecke struct scsi_device *sdev;
2761da177e4SLinus Torvalds struct seq_file *s = data;
2771da177e4SLinus Torvalds int i;
2781da177e4SLinus Torvalds
279b0ed4336SHannes Reinecke if (!scsi_is_sdev_device(dev))
280b0ed4336SHannes Reinecke goto out;
281b0ed4336SHannes Reinecke
282b0ed4336SHannes Reinecke sdev = to_scsi_device(dev);
2831da177e4SLinus Torvalds seq_printf(s,
2849cb78c16SHannes Reinecke "Host: scsi%d Channel: %02d Id: %02d Lun: %02llu\n Vendor: ",
2851da177e4SLinus Torvalds sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
2861da177e4SLinus Torvalds for (i = 0; i < 8; i++) {
2871da177e4SLinus Torvalds if (sdev->vendor[i] >= 0x20)
28891c40f24SRasmus Villemoes seq_putc(s, sdev->vendor[i]);
2891da177e4SLinus Torvalds else
290f50332ffSRasmus Villemoes seq_putc(s, ' ');
2911da177e4SLinus Torvalds }
2921da177e4SLinus Torvalds
29391c40f24SRasmus Villemoes seq_puts(s, " Model: ");
2941da177e4SLinus Torvalds for (i = 0; i < 16; i++) {
2951da177e4SLinus Torvalds if (sdev->model[i] >= 0x20)
29691c40f24SRasmus Villemoes seq_putc(s, sdev->model[i]);
2971da177e4SLinus Torvalds else
298f50332ffSRasmus Villemoes seq_putc(s, ' ');
2991da177e4SLinus Torvalds }
3001da177e4SLinus Torvalds
30191c40f24SRasmus Villemoes seq_puts(s, " Rev: ");
3021da177e4SLinus Torvalds for (i = 0; i < 4; i++) {
3031da177e4SLinus Torvalds if (sdev->rev[i] >= 0x20)
30491c40f24SRasmus Villemoes seq_putc(s, sdev->rev[i]);
3051da177e4SLinus Torvalds else
306f50332ffSRasmus Villemoes seq_putc(s, ' ');
3071da177e4SLinus Torvalds }
3081da177e4SLinus Torvalds
309f50332ffSRasmus Villemoes seq_putc(s, '\n');
3101da177e4SLinus Torvalds
3114ff36718SMatthew Wilcox seq_printf(s, " Type: %s ", scsi_device_type(sdev->type));
31274feb53eSAlan Stern seq_printf(s, " ANSI SCSI revision: %02x",
31374feb53eSAlan Stern sdev->scsi_level - (sdev->scsi_level > 1));
3141da177e4SLinus Torvalds if (sdev->scsi_level == 2)
31591c40f24SRasmus Villemoes seq_puts(s, " CCS\n");
3161da177e4SLinus Torvalds else
317f50332ffSRasmus Villemoes seq_putc(s, '\n');
3181da177e4SLinus Torvalds
319b0ed4336SHannes Reinecke out:
3201da177e4SLinus Torvalds return 0;
3211da177e4SLinus Torvalds }
3221da177e4SLinus Torvalds
323eb44820cSRob Landley /**
324eb44820cSRob Landley * scsi_add_single_device - Respond to user request to probe for/add device
325eb44820cSRob Landley * @host: user-supplied decimal integer
326eb44820cSRob Landley * @channel: user-supplied decimal integer
327eb44820cSRob Landley * @id: user-supplied decimal integer
328eb44820cSRob Landley * @lun: user-supplied decimal integer
329eb44820cSRob Landley *
330eb44820cSRob Landley * Description: called by writing "scsi add-single-device" to /proc/scsi/scsi.
331eb44820cSRob Landley *
332eb44820cSRob Landley * does scsi_host_lookup() and either user_scan() if that transport
333eb44820cSRob Landley * type supports it, or else scsi_scan_host_selected()
334eb44820cSRob Landley *
335eb44820cSRob Landley * Note: this seems to be aimed exclusively at SCSI parallel busses.
336eb44820cSRob Landley */
337eb44820cSRob Landley
scsi_add_single_device(uint host,uint channel,uint id,uint lun)3381da177e4SLinus Torvalds static int scsi_add_single_device(uint host, uint channel, uint id, uint lun)
3391da177e4SLinus Torvalds {
3401da177e4SLinus Torvalds struct Scsi_Host *shost;
3411da177e4SLinus Torvalds int error = -ENXIO;
3421da177e4SLinus Torvalds
3431da177e4SLinus Torvalds shost = scsi_host_lookup(host);
344315cb0adSJames Smart if (!shost)
345315cb0adSJames Smart return error;
3461da177e4SLinus Torvalds
347e02f3f59SChristoph Hellwig if (shost->transportt->user_scan)
348e02f3f59SChristoph Hellwig error = shost->transportt->user_scan(shost, channel, id, lun);
349e02f3f59SChristoph Hellwig else
3501d645088SHannes Reinecke error = scsi_scan_host_selected(shost, channel, id, lun,
3511d645088SHannes Reinecke SCSI_SCAN_MANUAL);
3521da177e4SLinus Torvalds scsi_host_put(shost);
3531da177e4SLinus Torvalds return error;
3541da177e4SLinus Torvalds }
3551da177e4SLinus Torvalds
356eb44820cSRob Landley /**
357eb44820cSRob Landley * scsi_remove_single_device - Respond to user request to remove a device
358eb44820cSRob Landley * @host: user-supplied decimal integer
359eb44820cSRob Landley * @channel: user-supplied decimal integer
360eb44820cSRob Landley * @id: user-supplied decimal integer
361eb44820cSRob Landley * @lun: user-supplied decimal integer
362eb44820cSRob Landley *
363eb44820cSRob Landley * Description: called by writing "scsi remove-single-device" to
364eb44820cSRob Landley * /proc/scsi/scsi. Does a scsi_device_lookup() and scsi_remove_device()
365eb44820cSRob Landley */
scsi_remove_single_device(uint host,uint channel,uint id,uint lun)3661da177e4SLinus Torvalds static int scsi_remove_single_device(uint host, uint channel, uint id, uint lun)
3671da177e4SLinus Torvalds {
3681da177e4SLinus Torvalds struct scsi_device *sdev;
3691da177e4SLinus Torvalds struct Scsi_Host *shost;
3701da177e4SLinus Torvalds int error = -ENXIO;
3711da177e4SLinus Torvalds
3721da177e4SLinus Torvalds shost = scsi_host_lookup(host);
373315cb0adSJames Smart if (!shost)
374315cb0adSJames Smart return error;
3751da177e4SLinus Torvalds sdev = scsi_device_lookup(shost, channel, id, lun);
3761da177e4SLinus Torvalds if (sdev) {
3771da177e4SLinus Torvalds scsi_remove_device(sdev);
3781da177e4SLinus Torvalds scsi_device_put(sdev);
3791da177e4SLinus Torvalds error = 0;
3801da177e4SLinus Torvalds }
3811da177e4SLinus Torvalds
3821da177e4SLinus Torvalds scsi_host_put(shost);
3831da177e4SLinus Torvalds return error;
3841da177e4SLinus Torvalds }
3851da177e4SLinus Torvalds
386eb44820cSRob Landley /**
387eb44820cSRob Landley * proc_scsi_write - handle writes to /proc/scsi/scsi
388eb44820cSRob Landley * @file: not used
389eb44820cSRob Landley * @buf: buffer to write
390eb44820cSRob Landley * @length: length of buf, at most PAGE_SIZE
391eb44820cSRob Landley * @ppos: not used
392eb44820cSRob Landley *
393eb44820cSRob Landley * Description: this provides a legacy mechanism to add or remove devices by
394eb44820cSRob Landley * Host, Channel, ID, and Lun. To use,
395eb44820cSRob Landley * "echo 'scsi add-single-device 0 1 2 3' > /proc/scsi/scsi" or
396eb44820cSRob Landley * "echo 'scsi remove-single-device 0 1 2 3' > /proc/scsi/scsi" with
397eb44820cSRob Landley * "0 1 2 3" replaced by the Host, Channel, Id, and Lun.
398eb44820cSRob Landley *
399eb44820cSRob Landley * Note: this seems to be aimed at parallel SCSI. Most modern busses (USB,
400eb44820cSRob Landley * SATA, Firewire, Fibre Channel, etc) dynamically assign these values to
401eb44820cSRob Landley * provide a unique identifier and nothing more.
402eb44820cSRob Landley */
403eb44820cSRob Landley
404eb44820cSRob Landley
proc_scsi_write(struct file * file,const char __user * buf,size_t length,loff_t * ppos)4051da177e4SLinus Torvalds static ssize_t proc_scsi_write(struct file *file, const char __user *buf,
4061da177e4SLinus Torvalds size_t length, loff_t *ppos)
4071da177e4SLinus Torvalds {
4081da177e4SLinus Torvalds int host, channel, id, lun;
409*9426d3ceSTony Battersby char *buffer, *end, *p;
4101da177e4SLinus Torvalds int err;
4111da177e4SLinus Torvalds
4121da177e4SLinus Torvalds if (!buf || length > PAGE_SIZE)
4131da177e4SLinus Torvalds return -EINVAL;
4141da177e4SLinus Torvalds
4151da177e4SLinus Torvalds buffer = (char *)__get_free_page(GFP_KERNEL);
4161da177e4SLinus Torvalds if (!buffer)
4171da177e4SLinus Torvalds return -ENOMEM;
4181da177e4SLinus Torvalds
4191da177e4SLinus Torvalds err = -EFAULT;
4201da177e4SLinus Torvalds if (copy_from_user(buffer, buf, length))
4211da177e4SLinus Torvalds goto out;
4221da177e4SLinus Torvalds
4231da177e4SLinus Torvalds err = -EINVAL;
424*9426d3ceSTony Battersby if (length < PAGE_SIZE) {
425*9426d3ceSTony Battersby end = buffer + length;
426*9426d3ceSTony Battersby *end = '\0';
427*9426d3ceSTony Battersby } else {
428*9426d3ceSTony Battersby end = buffer + PAGE_SIZE - 1;
429*9426d3ceSTony Battersby if (*end)
4301da177e4SLinus Torvalds goto out;
431*9426d3ceSTony Battersby }
4321da177e4SLinus Torvalds
4331da177e4SLinus Torvalds /*
4341da177e4SLinus Torvalds * Usage: echo "scsi add-single-device 0 1 2 3" >/proc/scsi/scsi
4351da177e4SLinus Torvalds * with "0 1 2 3" replaced by your "Host Channel Id Lun".
4361da177e4SLinus Torvalds */
4371da177e4SLinus Torvalds if (!strncmp("scsi add-single-device", buffer, 22)) {
4381da177e4SLinus Torvalds p = buffer + 23;
4391da177e4SLinus Torvalds
440*9426d3ceSTony Battersby host = (p < end) ? simple_strtoul(p, &p, 0) : 0;
441*9426d3ceSTony Battersby channel = (p + 1 < end) ? simple_strtoul(p + 1, &p, 0) : 0;
442*9426d3ceSTony Battersby id = (p + 1 < end) ? simple_strtoul(p + 1, &p, 0) : 0;
443*9426d3ceSTony Battersby lun = (p + 1 < end) ? simple_strtoul(p + 1, &p, 0) : 0;
4441da177e4SLinus Torvalds
4451da177e4SLinus Torvalds err = scsi_add_single_device(host, channel, id, lun);
4461da177e4SLinus Torvalds
4471da177e4SLinus Torvalds /*
4481da177e4SLinus Torvalds * Usage: echo "scsi remove-single-device 0 1 2 3" >/proc/scsi/scsi
4491da177e4SLinus Torvalds * with "0 1 2 3" replaced by your "Host Channel Id Lun".
4501da177e4SLinus Torvalds */
4511da177e4SLinus Torvalds } else if (!strncmp("scsi remove-single-device", buffer, 25)) {
4521da177e4SLinus Torvalds p = buffer + 26;
4531da177e4SLinus Torvalds
454*9426d3ceSTony Battersby host = (p < end) ? simple_strtoul(p, &p, 0) : 0;
455*9426d3ceSTony Battersby channel = (p + 1 < end) ? simple_strtoul(p + 1, &p, 0) : 0;
456*9426d3ceSTony Battersby id = (p + 1 < end) ? simple_strtoul(p + 1, &p, 0) : 0;
457*9426d3ceSTony Battersby lun = (p + 1 < end) ? simple_strtoul(p + 1, &p, 0) : 0;
4581da177e4SLinus Torvalds
4591da177e4SLinus Torvalds err = scsi_remove_single_device(host, channel, id, lun);
4601da177e4SLinus Torvalds }
4611da177e4SLinus Torvalds
4622ca48a13SJames Bottomley /*
4632ca48a13SJames Bottomley * convert success returns so that we return the
4642ca48a13SJames Bottomley * number of bytes consumed.
4652ca48a13SJames Bottomley */
4662ca48a13SJames Bottomley if (!err)
4672ca48a13SJames Bottomley err = length;
4682ca48a13SJames Bottomley
4691da177e4SLinus Torvalds out:
4701da177e4SLinus Torvalds free_page((unsigned long)buffer);
4711da177e4SLinus Torvalds return err;
4721da177e4SLinus Torvalds }
4731da177e4SLinus Torvalds
next_scsi_device(struct device * start)474e37c4913SJeff Mahoney static inline struct device *next_scsi_device(struct device *start)
475e37c4913SJeff Mahoney {
4766bf85ba9SSuzuki K Poulose struct device *next = bus_find_next_device(&scsi_bus_type, start);
4776bf85ba9SSuzuki K Poulose
478e37c4913SJeff Mahoney put_device(start);
479e37c4913SJeff Mahoney return next;
480e37c4913SJeff Mahoney }
481e37c4913SJeff Mahoney
scsi_seq_start(struct seq_file * sfile,loff_t * pos)482e37c4913SJeff Mahoney static void *scsi_seq_start(struct seq_file *sfile, loff_t *pos)
483e37c4913SJeff Mahoney {
484e37c4913SJeff Mahoney struct device *dev = NULL;
485e37c4913SJeff Mahoney loff_t n = *pos;
486e37c4913SJeff Mahoney
487e37c4913SJeff Mahoney while ((dev = next_scsi_device(dev))) {
488e37c4913SJeff Mahoney if (!n--)
489e37c4913SJeff Mahoney break;
490e37c4913SJeff Mahoney sfile->private++;
491e37c4913SJeff Mahoney }
492e37c4913SJeff Mahoney return dev;
493e37c4913SJeff Mahoney }
494e37c4913SJeff Mahoney
scsi_seq_next(struct seq_file * sfile,void * v,loff_t * pos)495e37c4913SJeff Mahoney static void *scsi_seq_next(struct seq_file *sfile, void *v, loff_t *pos)
496e37c4913SJeff Mahoney {
497e37c4913SJeff Mahoney (*pos)++;
498e37c4913SJeff Mahoney sfile->private++;
499e37c4913SJeff Mahoney return next_scsi_device(v);
500e37c4913SJeff Mahoney }
501e37c4913SJeff Mahoney
scsi_seq_stop(struct seq_file * sfile,void * v)502e37c4913SJeff Mahoney static void scsi_seq_stop(struct seq_file *sfile, void *v)
503e37c4913SJeff Mahoney {
504e37c4913SJeff Mahoney put_device(v);
505e37c4913SJeff Mahoney }
506e37c4913SJeff Mahoney
scsi_seq_show(struct seq_file * sfile,void * dev)507e37c4913SJeff Mahoney static int scsi_seq_show(struct seq_file *sfile, void *dev)
508e37c4913SJeff Mahoney {
509e37c4913SJeff Mahoney if (!sfile->private)
510e37c4913SJeff Mahoney seq_puts(sfile, "Attached devices:\n");
511e37c4913SJeff Mahoney
512e37c4913SJeff Mahoney return proc_print_scsidevice(dev, sfile);
513e37c4913SJeff Mahoney }
514e37c4913SJeff Mahoney
515e37c4913SJeff Mahoney static const struct seq_operations scsi_seq_ops = {
516e37c4913SJeff Mahoney .start = scsi_seq_start,
517e37c4913SJeff Mahoney .next = scsi_seq_next,
518e37c4913SJeff Mahoney .stop = scsi_seq_stop,
519e37c4913SJeff Mahoney .show = scsi_seq_show
520e37c4913SJeff Mahoney };
521e37c4913SJeff Mahoney
522eb44820cSRob Landley /**
523eb44820cSRob Landley * proc_scsi_open - glue function
524eb44820cSRob Landley * @inode: not used
525eb44820cSRob Landley * @file: passed to single_open()
526eb44820cSRob Landley *
527eb44820cSRob Landley * Associates proc_scsi_show with this file
528eb44820cSRob Landley */
proc_scsi_open(struct inode * inode,struct file * file)5291da177e4SLinus Torvalds static int proc_scsi_open(struct inode *inode, struct file *file)
5301da177e4SLinus Torvalds {
5311da177e4SLinus Torvalds /*
532eb44820cSRob Landley * We don't really need this for the write case but it doesn't
5331da177e4SLinus Torvalds * harm either.
5341da177e4SLinus Torvalds */
535e37c4913SJeff Mahoney return seq_open(file, &scsi_seq_ops);
5361da177e4SLinus Torvalds }
5371da177e4SLinus Torvalds
53897a32539SAlexey Dobriyan static const struct proc_ops scsi_scsi_proc_ops = {
53997a32539SAlexey Dobriyan .proc_open = proc_scsi_open,
54097a32539SAlexey Dobriyan .proc_read = seq_read,
54197a32539SAlexey Dobriyan .proc_write = proc_scsi_write,
54297a32539SAlexey Dobriyan .proc_lseek = seq_lseek,
54397a32539SAlexey Dobriyan .proc_release = seq_release,
5441da177e4SLinus Torvalds };
5451da177e4SLinus Torvalds
546eb44820cSRob Landley /**
547eb44820cSRob Landley * scsi_init_procfs - create scsi and scsi/scsi in procfs
548eb44820cSRob Landley */
scsi_init_procfs(void)5491da177e4SLinus Torvalds int __init scsi_init_procfs(void)
5501da177e4SLinus Torvalds {
5511da177e4SLinus Torvalds struct proc_dir_entry *pde;
5521da177e4SLinus Torvalds
5531da177e4SLinus Torvalds proc_scsi = proc_mkdir("scsi", NULL);
5541da177e4SLinus Torvalds if (!proc_scsi)
5551da177e4SLinus Torvalds goto err1;
5561da177e4SLinus Torvalds
55797a32539SAlexey Dobriyan pde = proc_create("scsi/scsi", 0, NULL, &scsi_scsi_proc_ops);
5581da177e4SLinus Torvalds if (!pde)
5591da177e4SLinus Torvalds goto err2;
5601da177e4SLinus Torvalds
5611da177e4SLinus Torvalds return 0;
5621da177e4SLinus Torvalds
5631da177e4SLinus Torvalds err2:
5641da177e4SLinus Torvalds remove_proc_entry("scsi", NULL);
5651da177e4SLinus Torvalds err1:
5661da177e4SLinus Torvalds return -ENOMEM;
5671da177e4SLinus Torvalds }
5681da177e4SLinus Torvalds
569eb44820cSRob Landley /**
570eb44820cSRob Landley * scsi_exit_procfs - Remove scsi/scsi and scsi from procfs
571eb44820cSRob Landley */
scsi_exit_procfs(void)5721da177e4SLinus Torvalds void scsi_exit_procfs(void)
5731da177e4SLinus Torvalds {
5741da177e4SLinus Torvalds remove_proc_entry("scsi/scsi", NULL);
5751da177e4SLinus Torvalds remove_proc_entry("scsi", NULL);
5761da177e4SLinus Torvalds }
577