PageRenderTime 38ms CodeModel.GetById 21ms app.highlight 14ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/scsi/scsi_proc.c

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t
C | 492 lines | 288 code | 73 blank | 131 comment | 41 complexity | 0133ad3f3e7a8f7bbf1e167e33b757cc MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0
  1/*
  2 * linux/drivers/scsi/scsi_proc.c
  3 *
  4 * The functions in this file provide an interface between
  5 * the PROC file system and the SCSI device drivers
  6 * It is mainly used for debugging, statistics and to pass 
  7 * information directly to the lowlevel driver.
  8 *
  9 * (c) 1995 Michael Neuffer neuffer@goofy.zdv.uni-mainz.de 
 10 * Version: 0.99.8   last change: 95/09/13
 11 * 
 12 * generic command parser provided by: 
 13 * Andreas Heilwagen <crashcar@informatik.uni-koblenz.de>
 14 *
 15 * generic_proc_info() support of xxxx_info() by:
 16 * Michael A. Griffith <grif@acm.org>
 17 */
 18
 19#include <linux/module.h>
 20#include <linux/init.h>
 21#include <linux/string.h>
 22#include <linux/mm.h>
 23#include <linux/proc_fs.h>
 24#include <linux/errno.h>
 25#include <linux/blkdev.h>
 26#include <linux/seq_file.h>
 27#include <linux/mutex.h>
 28#include <linux/gfp.h>
 29#include <asm/uaccess.h>
 30
 31#include <scsi/scsi.h>
 32#include <scsi/scsi_device.h>
 33#include <scsi/scsi_host.h>
 34#include <scsi/scsi_transport.h>
 35
 36#include "scsi_priv.h"
 37#include "scsi_logging.h"
 38
 39
 40/* 4K page size, but our output routines, use some slack for overruns */
 41#define PROC_BLOCK_SIZE (3*1024)
 42
 43static struct proc_dir_entry *proc_scsi;
 44
 45/* Protect sht->present and sht->proc_dir */
 46static DEFINE_MUTEX(global_host_template_mutex);
 47
 48/**
 49 * proc_scsi_read - handle read from /proc by calling host's proc_info() command
 50 * @buffer: passed to proc_info
 51 * @start: passed to proc_info
 52 * @offset: passed to proc_info
 53 * @length: passed to proc_info
 54 * @eof: returns whether length read was less than requested
 55 * @data: pointer to a &struct Scsi_Host
 56 */
 57
 58static int proc_scsi_read(char *buffer, char **start, off_t offset,
 59			  int length, int *eof, void *data)
 60{
 61	struct Scsi_Host *shost = data;
 62	int n;
 63
 64	n = shost->hostt->proc_info(shost, buffer, start, offset, length, 0);
 65	*eof = (n < length);
 66
 67	return n;
 68}
 69
 70/**
 71 * proc_scsi_write_proc - Handle write to /proc by calling host's proc_info()
 72 * @file: not used
 73 * @buf: source of data to write.
 74 * @count: number of bytes (at most PROC_BLOCK_SIZE) to write.
 75 * @data: pointer to &struct Scsi_Host
 76 */
 77static int proc_scsi_write_proc(struct file *file, const char __user *buf,
 78                           unsigned long count, void *data)
 79{
 80	struct Scsi_Host *shost = data;
 81	ssize_t ret = -ENOMEM;
 82	char *page;
 83	char *start;
 84    
 85	if (count > PROC_BLOCK_SIZE)
 86		return -EOVERFLOW;
 87
 88	page = (char *)__get_free_page(GFP_KERNEL);
 89	if (page) {
 90		ret = -EFAULT;
 91		if (copy_from_user(page, buf, count))
 92			goto out;
 93		ret = shost->hostt->proc_info(shost, page, &start, 0, count, 1);
 94	}
 95out:
 96	free_page((unsigned long)page);
 97	return ret;
 98}
 99
100/**
101 * scsi_proc_hostdir_add - Create directory in /proc for a scsi host
102 * @sht: owner of this directory
103 *
104 * Sets sht->proc_dir to the new directory.
105 */
106
107void scsi_proc_hostdir_add(struct scsi_host_template *sht)
108{
109	if (!sht->proc_info)
110		return;
111
112	mutex_lock(&global_host_template_mutex);
113	if (!sht->present++) {
114		sht->proc_dir = proc_mkdir(sht->proc_name, proc_scsi);
115        	if (!sht->proc_dir)
116			printk(KERN_ERR "%s: proc_mkdir failed for %s\n",
117			       __func__, sht->proc_name);
118	}
119	mutex_unlock(&global_host_template_mutex);
120}
121
122/**
123 * scsi_proc_hostdir_rm - remove directory in /proc for a scsi host
124 * @sht: owner of directory
125 */
126void scsi_proc_hostdir_rm(struct scsi_host_template *sht)
127{
128	if (!sht->proc_info)
129		return;
130
131	mutex_lock(&global_host_template_mutex);
132	if (!--sht->present && sht->proc_dir) {
133		remove_proc_entry(sht->proc_name, proc_scsi);
134		sht->proc_dir = NULL;
135	}
136	mutex_unlock(&global_host_template_mutex);
137}
138
139
140/**
141 * scsi_proc_host_add - Add entry for this host to appropriate /proc dir
142 * @shost: host to add
143 */
144void scsi_proc_host_add(struct Scsi_Host *shost)
145{
146	struct scsi_host_template *sht = shost->hostt;
147	struct proc_dir_entry *p;
148	char name[10];
149
150	if (!sht->proc_dir)
151		return;
152
153	sprintf(name,"%d", shost->host_no);
154	p = create_proc_read_entry(name, S_IFREG | S_IRUGO | S_IWUSR,
155			sht->proc_dir, proc_scsi_read, shost);
156	if (!p) {
157		printk(KERN_ERR "%s: Failed to register host %d in"
158		       "%s\n", __func__, shost->host_no,
159		       sht->proc_name);
160		return;
161	} 
162
163	p->write_proc = proc_scsi_write_proc;
164}
165
166/**
167 * scsi_proc_host_rm - remove this host's entry from /proc
168 * @shost: which host
169 */
170void scsi_proc_host_rm(struct Scsi_Host *shost)
171{
172	char name[10];
173
174	if (!shost->hostt->proc_dir)
175		return;
176
177	sprintf(name,"%d", shost->host_no);
178	remove_proc_entry(name, shost->hostt->proc_dir);
179}
180/**
181 * proc_print_scsidevice - return data about this host
182 * @dev: A scsi device
183 * @data: &struct seq_file to output to.
184 *
185 * Description: prints Host, Channel, Id, Lun, Vendor, Model, Rev, Type,
186 * and revision.
187 */
188static int proc_print_scsidevice(struct device *dev, void *data)
189{
190	struct scsi_device *sdev;
191	struct seq_file *s = data;
192	int i;
193
194	if (!scsi_is_sdev_device(dev))
195		goto out;
196
197	sdev = to_scsi_device(dev);
198	seq_printf(s,
199		"Host: scsi%d Channel: %02d Id: %02d Lun: %02d\n  Vendor: ",
200		sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
201	for (i = 0; i < 8; i++) {
202		if (sdev->vendor[i] >= 0x20)
203			seq_printf(s, "%c", sdev->vendor[i]);
204		else
205			seq_printf(s, " ");
206	}
207
208	seq_printf(s, " Model: ");
209	for (i = 0; i < 16; i++) {
210		if (sdev->model[i] >= 0x20)
211			seq_printf(s, "%c", sdev->model[i]);
212		else
213			seq_printf(s, " ");
214	}
215
216	seq_printf(s, " Rev: ");
217	for (i = 0; i < 4; i++) {
218		if (sdev->rev[i] >= 0x20)
219			seq_printf(s, "%c", sdev->rev[i]);
220		else
221			seq_printf(s, " ");
222	}
223
224	seq_printf(s, "\n");
225
226	seq_printf(s, "  Type:   %s ", scsi_device_type(sdev->type));
227	seq_printf(s, "               ANSI  SCSI revision: %02x",
228			sdev->scsi_level - (sdev->scsi_level > 1));
229	if (sdev->scsi_level == 2)
230		seq_printf(s, " CCS\n");
231	else
232		seq_printf(s, "\n");
233
234out:
235	return 0;
236}
237
238/**
239 * scsi_add_single_device - Respond to user request to probe for/add device
240 * @host: user-supplied decimal integer
241 * @channel: user-supplied decimal integer
242 * @id: user-supplied decimal integer
243 * @lun: user-supplied decimal integer
244 *
245 * Description: called by writing "scsi add-single-device" to /proc/scsi/scsi.
246 *
247 * does scsi_host_lookup() and either user_scan() if that transport
248 * type supports it, or else scsi_scan_host_selected()
249 *
250 * Note: this seems to be aimed exclusively at SCSI parallel busses.
251 */
252
253static int scsi_add_single_device(uint host, uint channel, uint id, uint lun)
254{
255	struct Scsi_Host *shost;
256	int error = -ENXIO;
257
258	shost = scsi_host_lookup(host);
259	if (!shost)
260		return error;
261
262	if (shost->transportt->user_scan)
263		error = shost->transportt->user_scan(shost, channel, id, lun);
264	else
265		error = scsi_scan_host_selected(shost, channel, id, lun, 1);
266	scsi_host_put(shost);
267	return error;
268}
269
270/**
271 * scsi_remove_single_device - Respond to user request to remove a device
272 * @host: user-supplied decimal integer
273 * @channel: user-supplied decimal integer
274 * @id: user-supplied decimal integer
275 * @lun: user-supplied decimal integer
276 *
277 * Description: called by writing "scsi remove-single-device" to
278 * /proc/scsi/scsi.  Does a scsi_device_lookup() and scsi_remove_device()
279 */
280static int scsi_remove_single_device(uint host, uint channel, uint id, uint lun)
281{
282	struct scsi_device *sdev;
283	struct Scsi_Host *shost;
284	int error = -ENXIO;
285
286	shost = scsi_host_lookup(host);
287	if (!shost)
288		return error;
289	sdev = scsi_device_lookup(shost, channel, id, lun);
290	if (sdev) {
291		scsi_remove_device(sdev);
292		scsi_device_put(sdev);
293		error = 0;
294	}
295
296	scsi_host_put(shost);
297	return error;
298}
299
300/**
301 * proc_scsi_write - handle writes to /proc/scsi/scsi
302 * @file: not used
303 * @buf: buffer to write
304 * @length: length of buf, at most PAGE_SIZE
305 * @ppos: not used
306 *
307 * Description: this provides a legacy mechanism to add or remove devices by
308 * Host, Channel, ID, and Lun.  To use,
309 * "echo 'scsi add-single-device 0 1 2 3' > /proc/scsi/scsi" or
310 * "echo 'scsi remove-single-device 0 1 2 3' > /proc/scsi/scsi" with
311 * "0 1 2 3" replaced by the Host, Channel, Id, and Lun.
312 *
313 * Note: this seems to be aimed at parallel SCSI. Most modern busses (USB,
314 * SATA, Firewire, Fibre Channel, etc) dynamically assign these values to
315 * provide a unique identifier and nothing more.
316 */
317
318
319static ssize_t proc_scsi_write(struct file *file, const char __user *buf,
320			       size_t length, loff_t *ppos)
321{
322	int host, channel, id, lun;
323	char *buffer, *p;
324	int err;
325
326	if (!buf || length > PAGE_SIZE)
327		return -EINVAL;
328
329	buffer = (char *)__get_free_page(GFP_KERNEL);
330	if (!buffer)
331		return -ENOMEM;
332
333	err = -EFAULT;
334	if (copy_from_user(buffer, buf, length))
335		goto out;
336
337	err = -EINVAL;
338	if (length < PAGE_SIZE)
339		buffer[length] = '\0';
340	else if (buffer[PAGE_SIZE-1])
341		goto out;
342
343	/*
344	 * Usage: echo "scsi add-single-device 0 1 2 3" >/proc/scsi/scsi
345	 * with  "0 1 2 3" replaced by your "Host Channel Id Lun".
346	 */
347	if (!strncmp("scsi add-single-device", buffer, 22)) {
348		p = buffer + 23;
349
350		host = simple_strtoul(p, &p, 0);
351		channel = simple_strtoul(p + 1, &p, 0);
352		id = simple_strtoul(p + 1, &p, 0);
353		lun = simple_strtoul(p + 1, &p, 0);
354
355		err = scsi_add_single_device(host, channel, id, lun);
356
357	/*
358	 * Usage: echo "scsi remove-single-device 0 1 2 3" >/proc/scsi/scsi
359	 * with  "0 1 2 3" replaced by your "Host Channel Id Lun".
360	 */
361	} else if (!strncmp("scsi remove-single-device", buffer, 25)) {
362		p = buffer + 26;
363
364		host = simple_strtoul(p, &p, 0);
365		channel = simple_strtoul(p + 1, &p, 0);
366		id = simple_strtoul(p + 1, &p, 0);
367		lun = simple_strtoul(p + 1, &p, 0);
368
369		err = scsi_remove_single_device(host, channel, id, lun);
370	}
371
372	/*
373	 * convert success returns so that we return the 
374	 * number of bytes consumed.
375	 */
376	if (!err)
377		err = length;
378
379 out:
380	free_page((unsigned long)buffer);
381	return err;
382}
383
384static int always_match(struct device *dev, void *data)
385{
386	return 1;
387}
388
389static inline struct device *next_scsi_device(struct device *start)
390{
391	struct device *next = bus_find_device(&scsi_bus_type, start, NULL,
392					      always_match);
393	put_device(start);
394	return next;
395}
396
397static void *scsi_seq_start(struct seq_file *sfile, loff_t *pos)
398{
399	struct device *dev = NULL;
400	loff_t n = *pos;
401
402	while ((dev = next_scsi_device(dev))) {
403		if (!n--)
404			break;
405		sfile->private++;
406	}
407	return dev;
408}
409
410static void *scsi_seq_next(struct seq_file *sfile, void *v, loff_t *pos)
411{
412	(*pos)++;
413	sfile->private++;
414	return next_scsi_device(v);
415}
416
417static void scsi_seq_stop(struct seq_file *sfile, void *v)
418{
419	put_device(v);
420}
421
422static int scsi_seq_show(struct seq_file *sfile, void *dev)
423{
424	if (!sfile->private)
425		seq_puts(sfile, "Attached devices:\n");
426
427	return proc_print_scsidevice(dev, sfile);
428}
429
430static const struct seq_operations scsi_seq_ops = {
431	.start	= scsi_seq_start,
432	.next	= scsi_seq_next,
433	.stop	= scsi_seq_stop,
434	.show	= scsi_seq_show
435};
436
437/**
438 * proc_scsi_open - glue function
439 * @inode: not used
440 * @file: passed to single_open()
441 *
442 * Associates proc_scsi_show with this file
443 */
444static int proc_scsi_open(struct inode *inode, struct file *file)
445{
446	/*
447	 * We don't really need this for the write case but it doesn't
448	 * harm either.
449	 */
450	return seq_open(file, &scsi_seq_ops);
451}
452
453static const struct file_operations proc_scsi_operations = {
454	.owner		= THIS_MODULE,
455	.open		= proc_scsi_open,
456	.read		= seq_read,
457	.write		= proc_scsi_write,
458	.llseek		= seq_lseek,
459	.release	= seq_release,
460};
461
462/**
463 * scsi_init_procfs - create scsi and scsi/scsi in procfs
464 */
465int __init scsi_init_procfs(void)
466{
467	struct proc_dir_entry *pde;
468
469	proc_scsi = proc_mkdir("scsi", NULL);
470	if (!proc_scsi)
471		goto err1;
472
473	pde = proc_create("scsi/scsi", 0, NULL, &proc_scsi_operations);
474	if (!pde)
475		goto err2;
476
477	return 0;
478
479err2:
480	remove_proc_entry("scsi", NULL);
481err1:
482	return -ENOMEM;
483}
484
485/**
486 * scsi_exit_procfs - Remove scsi/scsi and scsi from procfs
487 */
488void scsi_exit_procfs(void)
489{
490	remove_proc_entry("scsi/scsi", NULL);
491	remove_proc_entry("scsi", NULL);
492}