s390: convert /proc/cio_ignore.
Subsystems (2)
PATCH 15/17 s390: convert /proc/cio_ignore.
From: Cornelia Huck <[email protected]>
[patch 15/17] s390: convert /proc/cio_ignore.
Convert /proc/cio_ignore to a sequential file. This makes multiple subchannel sets support easier.
---
drivers/s390/cio/blacklist.c | 124 ++++++++++++++++++++++++++++++++----------- 1 files changed, 93 insertions(+), 31 deletions(-)
drivers/s390/cio/blacklist.c +93 -31
@@ -15,6 +15,7 @@#include <linux/vmalloc.h> #include <linux/slab.h> #include <linux/proc_fs.h> +#include <linux/seq_file.h> #include <linux/ctype.h> #include <linux/device.h>
@@ -279,41 +280,82 @@ blacklist_parse_proc_parameters (char *bs390_redo_validation (); } -/* FIXME: These should be real bus ids and not home-grown ones! */ -static int cio_ignore_read (char *page,char **start,off_t off, -int count,int *eof,void *data) -{ -const unsigned int entry_size =18 ;/* "0.0.ABCD-0.0.EFGH\n" */ -long devno; -int len; - - len =0 ; -for (devno = off;/* abuse the page variable -* as counter, see fs/proc/generic.c */ - devno < __MAX_SUBCHANNEL && len + entry_size < count; devno++) { -if (!test_bit (devno, bl_dev)) -continue ; - len +=sprintf (page + len,"0.0.%04lx" , devno); -if (test_bit (devno +1 , bl_dev)) {/* print range */ -while (++devno < __MAX_SUBCHANNEL) -if (!test_bit (devno, bl_dev)) -break ; - len +=sprintf (page + len,"-0.0.%04lx" , --devno); - } - len +=sprintf (page + len,"\n" ); - } +/* Iterator struct for all devices. */ +struct ccwdev_iter { +int devno; +int in_range; +}; + +static void * +cio_ignore_proc_seq_start (struct seq_file *s,loff_t *offset) +{ +struct ccwdev_iter *iter; + +if (*offset > __MAX_SUBCHANNEL) +return NULL ; + iter =kmalloc (sizeof (struct ccwdev_iter ),GFP_KERNEL ); +if (!iter) +return ERR_PTR (-ENOMEM ); +memset (iter,0 ,sizeof (struct ccwdev_iter )); + iter->devno = *offset; +return iter; +} + +static void +cio_ignore_proc_seq_stop (struct seq_file *s,void *it) +{ +if (!IS_ERR (it)) +kfree (it); +} + +static void * +cio_ignore_proc_seq_next (struct seq_file *s,void *it,loff_t *offset) +{ +struct ccwdev_iter *iter; + +if (*offset > __MAX_SUBCHANNEL) +return NULL ; + iter = (struct ccwdev_iter *)it; + iter->devno++; + (*offset)++; +return iter; +} -if (devno < __MAX_SUBCHANNEL) - *eof =1 ; - *start = (char *) (devno - off);/* number of checked entries */ -return len; +static int +cio_ignore_proc_seq_show (struct seq_file *s,void *it) +{ +struct ccwdev_iter *iter; + + iter = (struct ccwdev_iter *)it; +if (!is_blacklisted (iter->devno)) +/* Not blacklisted, nothing to output. */ +return 0 ; +if (!iter->in_range) { +/* First device in range. */ +if ((iter->devno == __MAX_SUBCHANNEL) || + !is_blacklisted (iter->devno +1 )) +/* Singular device. */ +return seq_printf (s,"0.0.%04x\n" , iter->devno); + iter->in_range =1 ; +return seq_printf (s,"0.0.%04x-" , iter->devno); + } +if ((iter->devno == __MAX_SUBCHANNEL) || + !is_blacklisted (iter->devno +1 )) { +/* Last device in range. */ + iter->in_range =0 ; +return seq_printf (s,"0.0.%04x\n" , iter->devno); + } +return 0 ; } -static int cio_ignore_write (struct file *file,const char __user *user_buf, -unsigned long user_len,void *data) +static ssize_t +cio_ignore_write (struct file *file,const char __user *user_buf, +size_t user_len,loff_t *offset) {char *buf; +if (*offset) +return -EINVAL ;if (user_len >65536 ) user_len =65536 ; buf =vmalloc (user_len +1 );/* maybe better use the stack? */
@@ -331,6 +373,27 @@ static int cio_ignore_write(struct filereturn user_len; } +static struct seq_operations cio_ignore_proc_seq_ops = { + .start = cio_ignore_proc_seq_start, + .stop = cio_ignore_proc_seq_stop, + .next = cio_ignore_proc_seq_next, + .show = cio_ignore_proc_seq_show, +}; + +static int +cio_ignore_proc_open (struct inode *inode,struct file *file) +{ +return seq_open (file, &cio_ignore_proc_seq_ops); +} + +static struct file_operations cio_ignore_proc_fops = { + .open = cio_ignore_proc_open, + .read = seq_read, + .llseek = seq_lseek, + .release = seq_release, + .write = cio_ignore_write, +}; +static int cio_ignore_proc_init (void ) {
@@ -341,8 +404,7 @@ cio_ignore_proc_init (void)if (!entry)return 0 ; - entry->read_proc = cio_ignore_read; - entry->write_proc = cio_ignore_write; + entry->proc_fops = &cio_ignore_proc_fops;return 1 ; }
Quoted 12 lines · Martin Schwidefsky
+static void *
+cio_ignore_proc_seq_start(structseq_file*s,loff_t*offset) +{
+ structccwdev_iter*iter;
+
+ if (*offset >__MAX_SUBCHANNEL)
+ return NULL;
+ iter =kmalloc(sizeof(struct ccwdev_iter), GFP_KERNEL);
+ if (!iter)
+ returnERR_PTR(-ENOMEM);
+memset(iter, 0, sizeof(struct ccwdev_iter));
kzalloc()
Quoted 11 lines
+
iter->devno= *offset;
+ return iter;
+}
+
+static void
+cio_ignore_proc_seq_stop(structseq_file*s, void *it) +{
+ if (!IS_ERR(it))
+ kfree(it);
+}
+
Quoted 8 lines
+static void *
+cio_ignore_proc_seq_next(structseq_file*s, void *it,loff_t*offset) +{
+ structccwdev_iter*iter;
+
+ if (*offset >__MAX_SUBCHANNEL)
+ return NULL;
+ iter = (structccwdev_iter*)it;
Unneeded (and undesirable) cast of void*.
Quoted 4 lines
+ iter->devno++;
+ (*offset)++;
+ return iter;
+}
2005/12/10, Andrew Morton <[email protected]>:
Quoted 14 lines
Quoted 12 lines · Martin Schwidefsky
+static void *
+cio_ignore_proc_seq_start(structseq_file*s,loff_t*offset) +{
+ structccwdev_iter*iter;
+
+ if (*offset >__MAX_SUBCHANNEL)
+ return NULL;
+ iter =kmalloc(sizeof(struct ccwdev_iter), GFP_KERNEL);
+ if (!iter)
+ returnERR_PTR(-ENOMEM);
+memset(iter, 0, sizeof(struct ccwdev_iter));
Quoted 1 line
kzalloc()
OK, will do.
Quoted 21 lines
Quoted 12 lines
+
iter->devno= *offset;
+ return iter;
+}
+
+static void
+cio_ignore_proc_seq_stop(structseq_file*s, void *it) +{
+ if (!IS_ERR(it))
+ kfree(it);
+}
+Quoted 8 lines
+static void *
+cio_ignore_proc_seq_next(structseq_file*s, void *it,loff_t*offset) +{
+ structccwdev_iter*iter;
+
+ if (*offset >__MAX_SUBCHANNEL)
+ return NULL;
+ iter = (structccwdev_iter*)it;
Quoted 1 line
Unneeded (and undesirable) cast of void*.
Some people seem to prefer explicit casts to make the type more clear. Is there any concensus on this? (I don't care either way ;))
Cornelia
Quoted 6 lines · Cornelia Huck
Quoted 2 lines
Unneeded (and undesirable) cast of void*.
Some people seem to prefer explicit casts to make the type more clear. Is there any concensus on this? (I don't care either way ;))
It's better to omit the casts because
a) they're ugly and
b) If someone changes the type of the RHS from void* to anything else, we'll get a warning, probably leading us to a bug. The cast would have prevented that warning. IOW, omitting the cast is more type-safe.