Linux kernel & device driver programming

Cross-Referenced Linux and Device Driver Code

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]
  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/slab.h>
 24 #include <linux/proc_fs.h>
 25 #include <linux/errno.h>
 26 #include <linux/blkdev.h>
 27 #include <linux/seq_file.h>
 28 #include <linux/mutex.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 
 43 static struct proc_dir_entry *proc_scsi;
 44 
 45 /* Protect sht->present and sht->proc_dir */
 46 static 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 
 58 static 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  */
 77 static 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         }
 95 out:
 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 
107 void 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                                __FUNCTION__, sht->proc_name);
118                 else
119                         sht->proc_dir->owner = sht->module;
120         }
121         mutex_unlock(&global_host_template_mutex);
122 }
123 
124 /**
125  * scsi_proc_hostdir_rm - remove directory in /proc for a scsi host
126  * @sht: owner of directory
127  */
128 void scsi_proc_hostdir_rm(struct scsi_host_template *sht)
129 {
130         if (!sht->proc_info)
131                 return;
132 
133         mutex_lock(&global_host_template_mutex);
134         if (!--sht->present && sht->proc_dir) {
135                 remove_proc_entry(sht->proc_name, proc_scsi);
136                 sht->proc_dir = NULL;
137         }
138         mutex_unlock(&global_host_template_mutex);
139 }
140 
141 
142 /**
143  * scsi_proc_host_add - Add entry for this host to appropriate /proc dir
144  * @shost: host to add
145  */
146 void scsi_proc_host_add(struct Scsi_Host *shost)
147 {
148         struct scsi_host_template *sht = shost->hostt;
149         struct proc_dir_entry *p;
150         char name[10];
151 
152         if (!sht->proc_dir)
153                 return;
154 
155         sprintf(name,"%d", shost->host_no);
156         p = create_proc_read_entry(name, S_IFREG | S_IRUGO | S_IWUSR,
157                         sht->proc_dir, proc_scsi_read, shost);
158         if (!p) {
159                 printk(KERN_ERR "%s: Failed to register host %d in"
160                        "%s\n", __FUNCTION__, shost->host_no,
161                        sht->proc_name);
162                 return;
163         } 
164 
165         p->write_proc = proc_scsi_write_proc;
166         p->owner = sht->module;
167 }
168 
169 /**
170  * scsi_proc_host_rm - remove this host's entry from /proc
171  * @shost: which host
172  */
173 void scsi_proc_host_rm(struct Scsi_Host *shost)
174 {
175         char name[10];
176 
177         if (!shost->hostt->proc_dir)
178                 return;
179 
180         sprintf(name,"%d", shost->host_no);
181         remove_proc_entry(name, shost->hostt->proc_dir);
182 }
183 /**
184  * proc_print_scsidevice - return data about this host
185  * @dev: A scsi device
186  * @data: &struct seq_file to output to.
187  *
188  * Description: prints Host, Channel, Id, Lun, Vendor, Model, Rev, Type,
189  * and revision.
190  */
191 static int proc_print_scsidevice(struct device *dev, void *data)
192 {
193         struct scsi_device *sdev = to_scsi_device(dev);
194         struct seq_file *s = data;
195         int i;
196 
197         seq_printf(s,
198                 "Host: scsi%d Channel: %02d Id: %02d Lun: %02d\n  Vendor: ",
199                 sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
200         for (i = 0; i < 8; i++) {
201                 if (sdev->vendor[i] >= 0x20)
202                         seq_printf(s, "%c", sdev->vendor[i]);
203                 else
204                         seq_printf(s, " ");
205         }
206 
207         seq_printf(s, " Model: ");
208         for (i = 0; i < 16; i++) {
209                 if (sdev->model[i] >= 0x20)
210                         seq_printf(s, "%c", sdev->model[i]);
211                 else
212                         seq_printf(s, " ");
213         }
214 
215         seq_printf(s, " Rev: ");
216         for (i = 0; i < 4; i++) {
217                 if (sdev->rev[i] >= 0x20)
218                         seq_printf(s, "%c", sdev->rev[i]);
219                 else
220                         seq_printf(s, " ");
221         }
222 
223         seq_printf(s, "\n");
224 
225         seq_printf(s, "  Type:   %s ", scsi_device_type(sdev->type));
226         seq_printf(s, "               ANSI  SCSI revision: %02x",
227                         sdev->scsi_level - (sdev->scsi_level > 1));
228         if (sdev->scsi_level == 2)
229                 seq_printf(s, " CCS\n");
230         else
231                 seq_printf(s, "\n");
232 
233         return 0;
234 }
235 
236 /**
237  * scsi_add_single_device - Respond to user request to probe for/add device
238  * @host: user-supplied decimal integer
239  * @channel: user-supplied decimal integer
240  * @id: user-supplied decimal integer
241  * @lun: user-supplied decimal integer
242  *
243  * Description: called by writing "scsi add-single-device" to /proc/scsi/scsi.
244  *
245  * does scsi_host_lookup() and either user_scan() if that transport
246  * type supports it, or else scsi_scan_host_selected()
247  *
248  * Note: this seems to be aimed exclusively at SCSI parallel busses.
249  */
250 
251 static int scsi_add_single_device(uint host, uint channel, uint id, uint lun)
252 {
253         struct Scsi_Host *shost;
254         int error = -ENXIO;
255 
256         shost = scsi_host_lookup(host);
257         if (IS_ERR(shost))
258                 return PTR_ERR(shost);
259 
260         if (shost->transportt->user_scan)
261                 error = shost->transportt->user_scan(shost, channel, id, lun);
262         else
263                 error = scsi_scan_host_selected(shost, channel, id, lun, 1);
264         scsi_host_put(shost);
265         return error;
266 }
267 
268 /**
269  * scsi_remove_single_device - Respond to user request to remove a device
270  * @host: user-supplied decimal integer
271  * @channel: user-supplied decimal integer
272  * @id: user-supplied decimal integer
273  * @lun: user-supplied decimal integer
274  *
275  * Description: called by writing "scsi remove-single-device" to
276  * /proc/scsi/scsi.  Does a scsi_device_lookup() and scsi_remove_device()
277  */
278 static int scsi_remove_single_device(uint host, uint channel, uint id, uint lun)
279 {
280         struct scsi_device *sdev;
281         struct Scsi_Host *shost;
282         int error = -ENXIO;
283 
284         shost = scsi_host_lookup(host);
285         if (IS_ERR(shost))
286                 return PTR_ERR(shost);
287         sdev = scsi_device_lookup(shost, channel, id, lun);
288         if (sdev) {
289                 scsi_remove_device(sdev);
290                 scsi_device_put(sdev);
291                 error = 0;
292         }
293 
294         scsi_host_put(shost);
295         return error;
296 }
297 
298 /**
299  * proc_scsi_write - handle writes to /proc/scsi/scsi
300  * @file: not used
301  * @buf: buffer to write
302  * @length: length of buf, at most PAGE_SIZE
303  * @ppos: not used
304  *
305  * Description: this provides a legacy mechanism to add or remove devices by
306  * Host, Channel, ID, and Lun.  To use,
307  * "echo 'scsi add-single-device 0 1 2 3' > /proc/scsi/scsi" or
308  * "echo 'scsi remove-single-device 0 1 2 3' > /proc/scsi/scsi" with
309  * "0 1 2 3" replaced by the Host, Channel, Id, and Lun.
310  *
311  * Note: this seems to be aimed at parallel SCSI. Most modern busses (USB,
312  * SATA, Firewire, Fibre Channel, etc) dynamically assign these values to
313  * provide a unique identifier and nothing more.
314  */
315 
316 
317 static ssize_t proc_scsi_write(struct file *file, const char __user *buf,
318                                size_t length, loff_t *ppos)
319 {
320         int host, channel, id, lun;
321         char *buffer, *p;
322         int err;
323 
324         if (!buf || length > PAGE_SIZE)
325                 return -EINVAL;
326 
327         buffer = (char *)__get_free_page(GFP_KERNEL);
328         if (!buffer)
329                 return -ENOMEM;
330 
331         err = -EFAULT;
332         if (copy_from_user(buffer, buf, length))
333                 goto out;
334 
335         err = -EINVAL;
336         if (length < PAGE_SIZE)
337                 buffer[length] = '\0';
338         else if (buffer[PAGE_SIZE-1])
339                 goto out;
340 
341         /*
342          * Usage: echo "scsi add-single-device 0 1 2 3" >/proc/scsi/scsi
343          * with  "0 1 2 3" replaced by your "Host Channel Id Lun".
344          */
345         if (!strncmp("scsi add-single-device", buffer, 22)) {
346                 p = buffer + 23;
347 
348                 host = simple_strtoul(p, &p, 0);
349                 channel = simple_strtoul(p + 1, &p, 0);
350                 id = simple_strtoul(p + 1, &p, 0);
351                 lun = simple_strtoul(p + 1, &p, 0);
352 
353                 err = scsi_add_single_device(host, channel, id, lun);
354 
355         /*
356          * Usage: echo "scsi remove-single-device 0 1 2 3" >/proc/scsi/scsi
357          * with  "0 1 2 3" replaced by your "Host Channel Id Lun".
358          */
359         } else if (!strncmp("scsi remove-single-device", buffer, 25)) {
360                 p = buffer + 26;
361 
362                 host = simple_strtoul(p, &p, 0);
363                 channel = simple_strtoul(p + 1, &p, 0);
364                 id = simple_strtoul(p + 1, &p, 0);
365                 lun = simple_strtoul(p + 1, &p, 0);
366 
367                 err = scsi_remove_single_device(host, channel, id, lun);
368         }
369 
370         /*
371          * convert success returns so that we return the 
372          * number of bytes consumed.
373          */
374         if (!err)
375                 err = length;
376 
377  out:
378         free_page((unsigned long)buffer);
379         return err;
380 }
381 
382 /**
383  * proc_scsi_show - show contents of /proc/scsi/scsi (attached devices)
384  * @s: output goes here
385  * @p: not used
386  */
387 static int proc_scsi_show(struct seq_file *s, void *p)
388 {
389         seq_printf(s, "Attached devices:\n");
390         bus_for_each_dev(&scsi_bus_type, NULL, s, proc_print_scsidevice);
391         return 0;
392 }
393 
394 /**
395  * proc_scsi_open - glue function
396  * @inode: not used
397  * @file: passed to single_open()
398  *
399  * Associates proc_scsi_show with this file
400  */
401 static int proc_scsi_open(struct inode *inode, struct file *file)
402 {
403         /*
404          * We don't really need this for the write case but it doesn't
405          * harm either.
406          */
407         return single_open(file, proc_scsi_show, NULL);
408 }
409 
410 static const struct file_operations proc_scsi_operations = {
411         .open           = proc_scsi_open,
412         .read           = seq_read,
413         .write          = proc_scsi_write,
414         .llseek         = seq_lseek,
415         .release        = single_release,
416 };
417 
418 /**
419  * scsi_init_procfs - create scsi and scsi/scsi in procfs
420  */
421 int __init scsi_init_procfs(void)
422 {
423         struct proc_dir_entry *pde;
424 
425         proc_scsi = proc_mkdir("scsi", NULL);
426         if (!proc_scsi)
427                 goto err1;
428 
429         pde = create_proc_entry("scsi/scsi", 0, NULL);
430         if (!pde)
431                 goto err2;
432         pde->proc_fops = &proc_scsi_operations;
433 
434         return 0;
435 
436 err2:
437         remove_proc_entry("scsi", NULL);
438 err1:
439         return -ENOMEM;
440 }
441 
442 /**
443  * scsi_exit_procfs - Remove scsi/scsi and scsi from procfs
444  */
445 void scsi_exit_procfs(void)
446 {
447         remove_proc_entry("scsi/scsi", NULL);
448         remove_proc_entry("scsi", NULL);
449 }
450 
  This page was automatically generated by the LXR engine.