kernel26-magellan/patches-2.6.16-r10/0114-2.6.16.12-proc.patch

From: Andrew Morton <akpm@osdl.org>
Date: Fri, 21 Apr 2006 08:51:36 +0000 (-0700)
Subject: [PATCH] Simplify proc/devices and fix early termination regression
X-Git-Url: http://www.kernel.org/git/?p=linux/kernel/git/stable/linux-2.6.16.y.git;a=commitdiff;h=692c0509fd0719406f8f781d9a9f2e19aa6b7c0a

[PATCH] Simplify proc/devices and fix early termination regression

Repair /proc/devices early-termination regression.

2.6.16 broke /proc/devices.  An application often gets an
EOF before the end of data is reached, if that application
uses a series of short read(2)s to access the data.  I have
used read buffers of varying sizes with varying degrees
of unsuccess (larger sizes get further into the data than
smaller sizes, following a simple pattern).  It appears
that the only safe way to get the data is to use a single
read buffer larger than all the data in /proc/devices.

The following example demonstates the problem:

    # dd if=/proc/devices bs=1
    Character devices:
      1 mem
    27+0 records in
    27+0 records out

This patch is a backport of the fix recently accepted to
Linus's tree:

    commit 68eef3b4791572ecb70249c7fb145bb3742dd899
    [PATCH] Simplify proc/devices and fix early termination regression

It replaces the complex, state-machine algorithm introduced
in 2.6.16 with a simple algorithm, modeled on the implementation
of /proc/interrupts.

[akpm@osdl.org: cleanups, simplifications]

Signed-off-by: Joe Korty <joe.korty@ccur.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
---

--- a/block/genhd.c
+++ b/block/genhd.c
@@ -16,8 +16,6 @@
 #include <linux/kobj_map.h>
 #include <linux/buffer_head.h>
 
-#define MAX_PROBE_HASH 255	/* random */
-
 static struct subsystem block_subsys;
 
 static DECLARE_MUTEX(block_subsys_sem);
@@ -30,108 +28,29 @@ static struct blk_major_name {
 	struct blk_major_name *next;
 	int major;
 	char name[16];
-} *major_names[MAX_PROBE_HASH];
+} *major_names[BLKDEV_MAJOR_HASH_SIZE];
 
 /* index in the above - for now: assume no multimajor ranges */
 static inline int major_to_index(int major)
 {
-	return major % MAX_PROBE_HASH;
-}
-
-struct blkdev_info {
-        int index;
-        struct blk_major_name *bd;
-};
-
-/*
- * iterate over a list of blkdev_info structures.  allows
- * the major_names array to be iterated over from outside this file
- * must be called with the block_subsys_sem held
- */
-void *get_next_blkdev(void *dev)
-{
-        struct blkdev_info *info;
-
-        if (dev == NULL) {
-                info = kmalloc(sizeof(*info), GFP_KERNEL);
-                if (!info)
-                        goto out;
-                info->index=0;
-                info->bd = major_names[info->index];
-                if (info->bd)
-                        goto out;
-        } else {
-                info = dev;
-        }
-
-        while (info->index < ARRAY_SIZE(major_names)) {
-                if (info->bd)
-                        info->bd = info->bd->next;
-                if (info->bd)
-                        goto out;
-                /*
-                 * No devices on this chain, move to the next
-                 */
-                info->index++;
-                info->bd = (info->index < ARRAY_SIZE(major_names)) ?
-			major_names[info->index] : NULL;
-                if (info->bd)
-                        goto out;
-        }
-
-out:
-        return info;
-}
-
-void *acquire_blkdev_list(void)
-{
-        down(&block_subsys_sem);
-        return get_next_blkdev(NULL);
-}
-
-void release_blkdev_list(void *dev)
-{
-        up(&block_subsys_sem);
-        kfree(dev);
+	return major % BLKDEV_MAJOR_HASH_SIZE;
 }
 
+#ifdef CONFIG_PROC_FS
 
-/*
- * Count the number of records in the blkdev_list.
- * must be called with the block_subsys_sem held
- */
-int count_blkdev_list(void)
+void blkdev_show(struct seq_file *f, off_t offset)
 {
-	struct blk_major_name *n;
-	int i, count;
-
-	count = 0;
+	struct blk_major_name *dp;
 
-	for (i = 0; i < ARRAY_SIZE(major_names); i++) {
-		for (n = major_names[i]; n; n = n->next)
-				count++;
+	if (offset < BLKDEV_MAJOR_HASH_SIZE) {
+		down(&block_subsys_sem);
+		for (dp = major_names[offset]; dp; dp = dp->next)
+			seq_printf(f, "%3d %s\n", dp->major, dp->name);
+		up(&block_subsys_sem);
 	}
-
-	return count;
-}
-
-/*
- * extract the major and name values from a blkdev_info struct
- * passed in as a void to *dev.  Must be called with
- * block_subsys_sem held
- */
-int get_blkdev_info(void *dev, int *major, char **name)
-{
-        struct blkdev_info *info = dev;
-
-        if (info->bd == NULL)
-                return 1;
-
-        *major = info->bd->major;
-        *name = info->bd->name;
-        return 0;
 }
 
+#endif /* CONFIG_PROC_FS */
 
 int register_blkdev(unsigned int major, const char *name)
 {
--- a/fs/char_dev.c
+++ b/fs/char_dev.c
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/smp_lock.h>
 #include <linux/devfs_fs_kernel.h>
+#include <linux/seq_file.h>
 
 #include <linux/kobject.h>
 #include <linux/kobj_map.h>
@@ -26,8 +27,6 @@
 
 static struct kobj_map *cdev_map;
 
-#define MAX_PROBE_HASH 255	/* random */
-
 static DECLARE_MUTEX(chrdevs_lock);
 
 static struct char_device_struct {
@@ -38,93 +37,29 @@ static struct char_device_struct {
 	char name[64];
 	struct file_operations *fops;
 	struct cdev *cdev;		/* will die */
-} *chrdevs[MAX_PROBE_HASH];
+} *chrdevs[CHRDEV_MAJOR_HASH_SIZE];
 
 /* index in the above */
 static inline int major_to_index(int major)
 {
-	return major % MAX_PROBE_HASH;
-}
-
-struct chrdev_info {
-	int index;
-	struct char_device_struct *cd;
-};
-
-void *get_next_chrdev(void *dev)
-{
-	struct chrdev_info *info;
-
-	if (dev == NULL) {
-		info = kmalloc(sizeof(*info), GFP_KERNEL);
-		if (!info)
-			goto out;
-		info->index=0;
-		info->cd = chrdevs[info->index];
-		if (info->cd)
-			goto out;
-	} else {
-		info = dev;
-	}
-
-	while (info->index < ARRAY_SIZE(chrdevs)) {
-		if (info->cd)
-			info->cd = info->cd->next;
-		if (info->cd)
-			goto out;
-		/*
-		 * No devices on this chain, move to the next
-		 */
-		info->index++;
-		info->cd = (info->index < ARRAY_SIZE(chrdevs)) ?
-			chrdevs[info->index] : NULL;
-		if (info->cd)
-			goto out;
-	}
-
-out:
-	return info;
-}
-
-void *acquire_chrdev_list(void)
-{
-	down(&chrdevs_lock);
-	return get_next_chrdev(NULL);
-}
-
-void release_chrdev_list(void *dev)
-{
-	up(&chrdevs_lock);
-	kfree(dev);
+	return major % CHRDEV_MAJOR_HASH_SIZE;
 }
 
+#ifdef CONFIG_PROC_FS
 
-int count_chrdev_list(void)
+void chrdev_show(struct seq_file *f, off_t offset)
 {
 	struct char_device_struct *cd;
-	int i, count;
-
-	count = 0;
 
-	for (i = 0; i < ARRAY_SIZE(chrdevs) ; i++) {
-		for (cd = chrdevs[i]; cd; cd = cd->next)
-			count++;
+	if (offset < CHRDEV_MAJOR_HASH_SIZE) {
+		down(&chrdevs_lock);
+		for (cd = chrdevs[offset]; cd; cd = cd->next)
+			seq_printf(f, "%3d %s\n", cd->major, cd->name);
+		up(&chrdevs_lock);
 	}
-
-	return count;
 }
 
-int get_chrdev_info(void *dev, int *major, char **name)
-{
-	struct chrdev_info *info = dev;
-
-	if (info->cd == NULL)
-		return 1;
-
-	*major = info->cd->major;
-	*name = info->cd->name;
-	return 0;
-}
+#endif /* CONFIG_PROC_FS */
 
 /*
  * Register a single major with a specified minor range.
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -249,144 +249,60 @@ static int cpuinfo_open(struct inode *in
 	return seq_open(file, &cpuinfo_op);
 }
 
-enum devinfo_states {
-	CHR_HDR,
-	CHR_LIST,
-	BLK_HDR,
-	BLK_LIST,
-	DEVINFO_DONE
-};
-
-struct devinfo_state {
-	void *chrdev;
-	void *blkdev;
-	unsigned int num_records;
-	unsigned int cur_record;
-	enum devinfo_states state;
+static struct file_operations proc_cpuinfo_operations = {
+	.open		= cpuinfo_open,
+	.read		= seq_read,
+	.llseek		= seq_lseek,
+	.release	= seq_release,
 };
 
-static void *devinfo_start(struct seq_file *f, loff_t *pos)
+static int devinfo_show(struct seq_file *f, void *v)
 {
-	struct devinfo_state *info = f->private;
+	int i = *(loff_t *) v;
 
-	if (*pos) {
-		if ((info) && (*pos <= info->num_records))
-			return info;
-		return NULL;
+	if (i < CHRDEV_MAJOR_HASH_SIZE) {
+		if (i == 0)
+			seq_printf(f, "Character devices:\n");
+		chrdev_show(f, i);
+	} else {
+		i -= CHRDEV_MAJOR_HASH_SIZE;
+		if (i == 0)
+			seq_printf(f, "\nBlock devices:\n");
+		blkdev_show(f, i);
 	}
-	info = kmalloc(sizeof(*info), GFP_KERNEL);
-	f->private = info;
-	info->chrdev = acquire_chrdev_list();
-	info->blkdev = acquire_blkdev_list();
-	info->state = CHR_HDR;
-	info->num_records = count_chrdev_list();
-	info->num_records += count_blkdev_list();
-	info->num_records += 2; /* Character and Block headers */
-	*pos = 1;
-	info->cur_record = *pos;
-	return info;
+	return 0;
 }
 
-static void *devinfo_next(struct seq_file *f, void *v, loff_t *pos)
+static void *devinfo_start(struct seq_file *f, loff_t *pos)
 {
-	int idummy;
-	char *ndummy;
-	struct devinfo_state *info = f->private;
-
-	switch (info->state) {
-		case CHR_HDR:
-			info->state = CHR_LIST;
-			(*pos)++;
-			/*fallthrough*/
-		case CHR_LIST:
-			if (get_chrdev_info(info->chrdev,&idummy,&ndummy)) {
-				/*
-				 * The character dev list is complete
-				 */
-				info->state = BLK_HDR;
-			} else {
-				info->chrdev = get_next_chrdev(info->chrdev);
-			}
-			(*pos)++;
-			break;
-		case BLK_HDR:
-			info->state = BLK_LIST;
-			(*pos)++;
-			/*fallthrough*/
-		case BLK_LIST:
-			if (get_blkdev_info(info->blkdev,&idummy,&ndummy)) {
-				/*
-				 * The block dev list is complete
-				 */
-				info->state = DEVINFO_DONE;
-			} else {
-				info->blkdev = get_next_blkdev(info->blkdev);
-			}
-			(*pos)++;
-			break;
-		case DEVINFO_DONE:
-			(*pos)++;
-			info->cur_record = *pos;
-			info = NULL;
-			break;
-		default:
-			break;
-	}
-	if (info)
-		info->cur_record = *pos;
-	return info;
+	if (*pos < (BLKDEV_MAJOR_HASH_SIZE + CHRDEV_MAJOR_HASH_SIZE))
+		return pos;
+	return NULL;
 }
 
-static void devinfo_stop(struct seq_file *f, void *v)
+static void *devinfo_next(struct seq_file *f, void *v, loff_t *pos)
 {
-	struct devinfo_state *info = f->private;
-
-	if (info) {
-		release_chrdev_list(info->chrdev);
-		release_blkdev_list(info->blkdev);
-		f->private = NULL;
-		kfree(info);
-	}
+	(*pos)++;
+	if (*pos >= (BLKDEV_MAJOR_HASH_SIZE + CHRDEV_MAJOR_HASH_SIZE))
+		return NULL;
+	return pos;
 }
 
-static int devinfo_show(struct seq_file *f, void *arg)
+static void devinfo_stop(struct seq_file *f, void *v)
 {
-	int major;
-	char *name;
-	struct devinfo_state *info = f->private;
-
-	switch(info->state) {
-		case CHR_HDR:
-			seq_printf(f,"Character devices:\n");
-			/* fallthrough */
-		case CHR_LIST:
-			if (!get_chrdev_info(info->chrdev,&major,&name))
-				seq_printf(f,"%3d %s\n",major,name);
-			break;
-		case BLK_HDR:
-			seq_printf(f,"\nBlock devices:\n");
-			/* fallthrough */
-		case BLK_LIST:
-			if (!get_blkdev_info(info->blkdev,&major,&name))
-				seq_printf(f,"%3d %s\n",major,name);
-			break;
-		default:
-			break;
-	}
-
-	return 0;
+	/* Nothing to do */
 }
 
-static  struct seq_operations devinfo_op = {
-	.start  = devinfo_start,
-	.next   = devinfo_next,
-	.stop   = devinfo_stop,
-	.show   = devinfo_show,
+static struct seq_operations devinfo_ops = {
+	.start = devinfo_start,
+	.next  = devinfo_next,
+	.stop  = devinfo_stop,
+	.show  = devinfo_show
 };
 
-static int devinfo_open(struct inode *inode, struct file *file)
+static int devinfo_open(struct inode *inode, struct file *filp)
 {
-	return seq_open(file, &devinfo_op);
+	return seq_open(filp, &devinfo_ops);
 }
 
 static struct file_operations proc_devinfo_operations = {
@@ -396,13 +312,6 @@ static struct file_operations proc_devin
 	.release	= seq_release,
 };
 
-static struct file_operations proc_cpuinfo_operations = {
-	.open		= cpuinfo_open,
-	.read		= seq_read,
-	.llseek		= seq_lseek,
-	.release	= seq_release,
-};
-
 extern struct seq_operations vmstat_op;
 static int vmstat_open(struct inode *inode, struct file *file)
 {
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1383,6 +1383,7 @@ extern int bd_claim(struct block_device 
 extern void bd_release(struct block_device *);
 
 /* fs/char_dev.c */
+#define CHRDEV_MAJOR_HASH_SIZE	255
 extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
 extern int register_chrdev_region(dev_t, unsigned, const char *);
 extern int register_chrdev(unsigned int, const char *,
@@ -1390,25 +1391,17 @@ extern int register_chrdev(unsigned int,
 extern int unregister_chrdev(unsigned int, const char *);
 extern void unregister_chrdev_region(dev_t, unsigned);
 extern int chrdev_open(struct inode *, struct file *);
-extern int get_chrdev_list(char *);
-extern void *acquire_chrdev_list(void);
-extern int count_chrdev_list(void);
-extern void *get_next_chrdev(void *);
-extern int get_chrdev_info(void *, int *, char **);
-extern void release_chrdev_list(void *);
+extern void chrdev_show(struct seq_file *,off_t);
 
 /* fs/block_dev.c */
+#define BLKDEV_MAJOR_HASH_SIZE	255
 #define BDEVNAME_SIZE	32	/* Largest string for a blockdev identifier */
 extern const char *__bdevname(dev_t, char *buffer);
 extern const char *bdevname(struct block_device *bdev, char *buffer);
 extern struct block_device *lookup_bdev(const char *);
 extern struct block_device *open_bdev_excl(const char *, int, void *);
 extern void close_bdev_excl(struct block_device *);
-extern void *acquire_blkdev_list(void);
-extern int count_blkdev_list(void);
-extern void *get_next_blkdev(void *);
-extern int get_blkdev_info(void *, int *, char **);
-extern void release_blkdev_list(void *);
+extern void blkdev_show(struct seq_file *,off_t);
 
 extern void init_special_inode(struct inode *, umode_t, dev_t);
 
1	From: Andrew Morton <akpm@osdl.org>
2	Date: Fri, 21 Apr 2006 08:51:36 +0000 (-0700)
3	Subject: [PATCH] Simplify proc/devices and fix early termination regression
4	X-Git-Url: http://www.kernel.org/git/?p=linux/kernel/git/stable/linux-2.6.16.y.git;a=commitdiff;h=692c0509fd0719406f8f781d9a9f2e19aa6b7c0a
5
6	[PATCH] Simplify proc/devices and fix early termination regression
7
8	Repair /proc/devices early-termination regression.
9
10	2.6.16 broke /proc/devices. An application often gets an
11	EOF before the end of data is reached, if that application
12	uses a series of short read(2)s to access the data. I have
13	used read buffers of varying sizes with varying degrees
14	of unsuccess (larger sizes get further into the data than
15	smaller sizes, following a simple pattern). It appears
16	that the only safe way to get the data is to use a single
17	read buffer larger than all the data in /proc/devices.
18
19	The following example demonstates the problem:
20
21	# dd if=/proc/devices bs=1
22	Character devices:
23	1 mem
24	27+0 records in
25	27+0 records out
26
27	This patch is a backport of the fix recently accepted to
28	Linus's tree:
29
30	commit 68eef3b4791572ecb70249c7fb145bb3742dd899
31	[PATCH] Simplify proc/devices and fix early termination regression
32
33	It replaces the complex, state-machine algorithm introduced
34	in 2.6.16 with a simple algorithm, modeled on the implementation
35	of /proc/interrupts.
36
37	[akpm@osdl.org: cleanups, simplifications]
38
39	Signed-off-by: Joe Korty <joe.korty@ccur.com>
40	Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
41	---
42
43	--- a/block/genhd.c
44	+++ b/block/genhd.c
45	@@ -16,8 +16,6 @@
46	#include <linux/kobj_map.h>
47	#include <linux/buffer_head.h>
48
49	-#define MAX_PROBE_HASH 255 /* random */
50	-
51	static struct subsystem block_subsys;
52
53	static DECLARE_MUTEX(block_subsys_sem);
54	@@ -30,108 +28,29 @@ static struct blk_major_name {
55	struct blk_major_name *next;
56	int major;
57	char name[16];
58	-} *major_names[MAX_PROBE_HASH];
59	+} *major_names[BLKDEV_MAJOR_HASH_SIZE];
60
61	/* index in the above - for now: assume no multimajor ranges */
62	static inline int major_to_index(int major)
63	{
64	- return major % MAX_PROBE_HASH;
65	-}
66	-
67	-struct blkdev_info {
68	- int index;
69	- struct blk_major_name *bd;
70	-};
71	-
72	-/*
73	- * iterate over a list of blkdev_info structures. allows
74	- * the major_names array to be iterated over from outside this file
75	- * must be called with the block_subsys_sem held
76	- */
77	-void get_next_blkdev(void dev)
78	-{
79	- struct blkdev_info *info;
80	-
81	- if (dev == NULL) {
82	- info = kmalloc(sizeof(*info), GFP_KERNEL);
83	- if (!info)
84	- goto out;
85	- info->index=0;
86	- info->bd = major_names[info->index];
87	- if (info->bd)
88	- goto out;
89	- } else {
90	- info = dev;
91	- }
92	-
93	- while (info->index < ARRAY_SIZE(major_names)) {
94	- if (info->bd)
95	- info->bd = info->bd->next;
96	- if (info->bd)
97	- goto out;
98	- /*
99	- * No devices on this chain, move to the next
100	- */
101	- info->index++;
102	- info->bd = (info->index < ARRAY_SIZE(major_names)) ?
103	- major_names[info->index] : NULL;
104	- if (info->bd)
105	- goto out;
106	- }
107	-
108	-out:
109	- return info;
110	-}
111	-
112	-void *acquire_blkdev_list(void)
113	-{
114	- down(&block_subsys_sem);
115	- return get_next_blkdev(NULL);
116	-}
117	-
118	-void release_blkdev_list(void *dev)
119	-{
120	- up(&block_subsys_sem);
121	- kfree(dev);
122	+ return major % BLKDEV_MAJOR_HASH_SIZE;
123	}
124
125	+#ifdef CONFIG_PROC_FS
126
127	-/*
128	- * Count the number of records in the blkdev_list.
129	- * must be called with the block_subsys_sem held
130	- */
131	-int count_blkdev_list(void)
132	+void blkdev_show(struct seq_file *f, off_t offset)
133	{
134	- struct blk_major_name *n;
135	- int i, count;
136	-
137	- count = 0;
138	+ struct blk_major_name *dp;
139
140	- for (i = 0; i < ARRAY_SIZE(major_names); i++) {
141	- for (n = major_names[i]; n; n = n->next)
142	- count++;
143	+ if (offset < BLKDEV_MAJOR_HASH_SIZE) {
144	+ down(&block_subsys_sem);
145	+ for (dp = major_names[offset]; dp; dp = dp->next)
146	+ seq_printf(f, "%3d %s\n", dp->major, dp->name);
147	+ up(&block_subsys_sem);
148	}
149	-
150	- return count;
151	-}
152	-
153	-/*
154	- * extract the major and name values from a blkdev_info struct
155	- * passed in as a void to *dev. Must be called with
156	- * block_subsys_sem held
157	- */
158	-int get_blkdev_info(void dev, int major, char **name)
159	-{
160	- struct blkdev_info *info = dev;
161	-
162	- if (info->bd == NULL)
163	- return 1;
164	-
165	- *major = info->bd->major;
166	- *name = info->bd->name;
167	- return 0;
168	}
169
170	+#endif /* CONFIG_PROC_FS */
171
172	int register_blkdev(unsigned int major, const char *name)
173	{
174	--- a/fs/char_dev.c
175	+++ b/fs/char_dev.c
176	@@ -15,6 +15,7 @@
177	#include <linux/module.h>
178	#include <linux/smp_lock.h>
179	#include <linux/devfs_fs_kernel.h>
180	+#include <linux/seq_file.h>
181
182	#include <linux/kobject.h>
183	#include <linux/kobj_map.h>
184	@@ -26,8 +27,6 @@
185
186	static struct kobj_map *cdev_map;
187
188	-#define MAX_PROBE_HASH 255 /* random */
189	-
190	static DECLARE_MUTEX(chrdevs_lock);
191
192	static struct char_device_struct {
193	@@ -38,93 +37,29 @@ static struct char_device_struct {
194	char name[64];
195	struct file_operations *fops;
196	struct cdev cdev; / will die */
197	-} *chrdevs[MAX_PROBE_HASH];
198	+} *chrdevs[CHRDEV_MAJOR_HASH_SIZE];
199
200	/* index in the above */
201	static inline int major_to_index(int major)
202	{
203	- return major % MAX_PROBE_HASH;
204	-}
205	-
206	-struct chrdev_info {
207	- int index;
208	- struct char_device_struct *cd;
209	-};
210	-
211	-void get_next_chrdev(void dev)
212	-{
213	- struct chrdev_info *info;
214	-
215	- if (dev == NULL) {
216	- info = kmalloc(sizeof(*info), GFP_KERNEL);
217	- if (!info)
218	- goto out;
219	- info->index=0;
220	- info->cd = chrdevs[info->index];
221	- if (info->cd)
222	- goto out;
223	- } else {
224	- info = dev;
225	- }
226	-
227	- while (info->index < ARRAY_SIZE(chrdevs)) {
228	- if (info->cd)
229	- info->cd = info->cd->next;
230	- if (info->cd)
231	- goto out;
232	- /*
233	- * No devices on this chain, move to the next
234	- */
235	- info->index++;
236	- info->cd = (info->index < ARRAY_SIZE(chrdevs)) ?
237	- chrdevs[info->index] : NULL;
238	- if (info->cd)
239	- goto out;
240	- }
241	-
242	-out:
243	- return info;
244	-}
245	-
246	-void *acquire_chrdev_list(void)
247	-{
248	- down(&chrdevs_lock);
249	- return get_next_chrdev(NULL);
250	-}
251	-
252	-void release_chrdev_list(void *dev)
253	-{
254	- up(&chrdevs_lock);
255	- kfree(dev);
256	+ return major % CHRDEV_MAJOR_HASH_SIZE;
257	}
258
259	+#ifdef CONFIG_PROC_FS
260
261	-int count_chrdev_list(void)
262	+void chrdev_show(struct seq_file *f, off_t offset)
263	{
264	struct char_device_struct *cd;
265	- int i, count;
266	-
267	- count = 0;
268
269	- for (i = 0; i < ARRAY_SIZE(chrdevs) ; i++) {
270	- for (cd = chrdevs[i]; cd; cd = cd->next)
271	- count++;
272	+ if (offset < CHRDEV_MAJOR_HASH_SIZE) {
273	+ down(&chrdevs_lock);
274	+ for (cd = chrdevs[offset]; cd; cd = cd->next)
275	+ seq_printf(f, "%3d %s\n", cd->major, cd->name);
276	+ up(&chrdevs_lock);
277	}
278	-
279	- return count;
280	}
281
282	-int get_chrdev_info(void dev, int major, char **name)
283	-{
284	- struct chrdev_info *info = dev;
285	-
286	- if (info->cd == NULL)
287	- return 1;
288	-
289	- *major = info->cd->major;
290	- *name = info->cd->name;
291	- return 0;
292	-}
293	+#endif /* CONFIG_PROC_FS */
294
295	/*
296	* Register a single major with a specified minor range.
297	--- a/fs/proc/proc_misc.c
298	+++ b/fs/proc/proc_misc.c
299	@@ -249,144 +249,60 @@ static int cpuinfo_open(struct inode *in
300	return seq_open(file, &cpuinfo_op);
301	}
302
303	-enum devinfo_states {
304	- CHR_HDR,
305	- CHR_LIST,
306	- BLK_HDR,
307	- BLK_LIST,
308	- DEVINFO_DONE
309	-};
310	-
311	-struct devinfo_state {
312	- void *chrdev;
313	- void *blkdev;
314	- unsigned int num_records;
315	- unsigned int cur_record;
316	- enum devinfo_states state;
317	+static struct file_operations proc_cpuinfo_operations = {
318	+ .open = cpuinfo_open,
319	+ .read = seq_read,
320	+ .llseek = seq_lseek,
321	+ .release = seq_release,
322	};
323
324	-static void devinfo_start(struct seq_file f, loff_t *pos)
325	+static int devinfo_show(struct seq_file f, void v)
326	{
327	- struct devinfo_state *info = f->private;
328	+ int i = (loff_t ) v;
329
330	- if (*pos) {
331	- if ((info) && (*pos <= info->num_records))
332	- return info;
333	- return NULL;
334	+ if (i < CHRDEV_MAJOR_HASH_SIZE) {
335	+ if (i == 0)
336	+ seq_printf(f, "Character devices:\n");
337	+ chrdev_show(f, i);
338	+ } else {
339	+ i -= CHRDEV_MAJOR_HASH_SIZE;
340	+ if (i == 0)
341	+ seq_printf(f, "\nBlock devices:\n");
342	+ blkdev_show(f, i);
343	}
344	- info = kmalloc(sizeof(*info), GFP_KERNEL);
345	- f->private = info;
346	- info->chrdev = acquire_chrdev_list();
347	- info->blkdev = acquire_blkdev_list();
348	- info->state = CHR_HDR;
349	- info->num_records = count_chrdev_list();
350	- info->num_records += count_blkdev_list();
351	- info->num_records += 2; /* Character and Block headers */
352	- *pos = 1;
353	- info->cur_record = *pos;
354	- return info;
355	+ return 0;
356	}
357
358	-static void devinfo_next(struct seq_file f, void v, loff_t pos)
359	+static void devinfo_start(struct seq_file f, loff_t *pos)
360	{
361	- int idummy;
362	- char *ndummy;
363	- struct devinfo_state *info = f->private;
364	-
365	- switch (info->state) {
366	- case CHR_HDR:
367	- info->state = CHR_LIST;
368	- (*pos)++;
369	- /fallthrough/
370	- case CHR_LIST:
371	- if (get_chrdev_info(info->chrdev,&idummy,&ndummy)) {
372	- /*
373	- * The character dev list is complete
374	- */
375	- info->state = BLK_HDR;
376	- } else {
377	- info->chrdev = get_next_chrdev(info->chrdev);
378	- }
379	- (*pos)++;
380	- break;
381	- case BLK_HDR:
382	- info->state = BLK_LIST;
383	- (*pos)++;
384	- /fallthrough/
385	- case BLK_LIST:
386	- if (get_blkdev_info(info->blkdev,&idummy,&ndummy)) {
387	- /*
388	- * The block dev list is complete
389	- */
390	- info->state = DEVINFO_DONE;
391	- } else {
392	- info->blkdev = get_next_blkdev(info->blkdev);
393	- }
394	- (*pos)++;
395	- break;
396	- case DEVINFO_DONE:
397	- (*pos)++;
398	- info->cur_record = *pos;
399	- info = NULL;
400	- break;
401	- default:
402	- break;
403	- }
404	- if (info)
405	- info->cur_record = *pos;
406	- return info;
407	+ if (*pos < (BLKDEV_MAJOR_HASH_SIZE + CHRDEV_MAJOR_HASH_SIZE))
408	+ return pos;
409	+ return NULL;
410	}
411
412	-static void devinfo_stop(struct seq_file f, void v)
413	+static void devinfo_next(struct seq_file f, void v, loff_t pos)
414	{
415	- struct devinfo_state *info = f->private;
416	-
417	- if (info) {
418	- release_chrdev_list(info->chrdev);
419	- release_blkdev_list(info->blkdev);
420	- f->private = NULL;
421	- kfree(info);
422	- }
423	+ (*pos)++;
424	+ if (*pos >= (BLKDEV_MAJOR_HASH_SIZE + CHRDEV_MAJOR_HASH_SIZE))
425	+ return NULL;
426	+ return pos;
427	}
428
429	-static int devinfo_show(struct seq_file f, void arg)
430	+static void devinfo_stop(struct seq_file f, void v)
431	{
432	- int major;
433	- char *name;
434	- struct devinfo_state *info = f->private;
435	-
436	- switch(info->state) {
437	- case CHR_HDR:
438	- seq_printf(f,"Character devices:\n");
439	- /* fallthrough */
440	- case CHR_LIST:
441	- if (!get_chrdev_info(info->chrdev,&major,&name))
442	- seq_printf(f,"%3d %s\n",major,name);
443	- break;
444	- case BLK_HDR:
445	- seq_printf(f,"\nBlock devices:\n");
446	- /* fallthrough */
447	- case BLK_LIST:
448	- if (!get_blkdev_info(info->blkdev,&major,&name))
449	- seq_printf(f,"%3d %s\n",major,name);
450	- break;
451	- default:
452	- break;
453	- }
454	-
455	- return 0;
456	+ /* Nothing to do */
457	}
458
459	-static struct seq_operations devinfo_op = {
460	- .start = devinfo_start,
461	- .next = devinfo_next,
462	- .stop = devinfo_stop,
463	- .show = devinfo_show,
464	+static struct seq_operations devinfo_ops = {
465	+ .start = devinfo_start,
466	+ .next = devinfo_next,
467	+ .stop = devinfo_stop,
468	+ .show = devinfo_show
469	};
470
471	-static int devinfo_open(struct inode inode, struct file file)
472	+static int devinfo_open(struct inode inode, struct file filp)
473	{
474	- return seq_open(file, &devinfo_op);
475	+ return seq_open(filp, &devinfo_ops);
476	}
477
478	static struct file_operations proc_devinfo_operations = {
479	@@ -396,13 +312,6 @@ static struct file_operations proc_devin
480	.release = seq_release,
481	};
482
483	-static struct file_operations proc_cpuinfo_operations = {
484	- .open = cpuinfo_open,
485	- .read = seq_read,
486	- .llseek = seq_lseek,
487	- .release = seq_release,
488	-};
489	-
490	extern struct seq_operations vmstat_op;
491	static int vmstat_open(struct inode inode, struct file file)
492	{
493	--- a/include/linux/fs.h
494	+++ b/include/linux/fs.h
495	@@ -1383,6 +1383,7 @@ extern int bd_claim(struct block_device
496	extern void bd_release(struct block_device *);
497
498	/* fs/char_dev.c */
499	+#define CHRDEV_MAJOR_HASH_SIZE 255
500	extern int alloc_chrdev_region(dev_t , unsigned, unsigned, const char );
501	extern int register_chrdev_region(dev_t, unsigned, const char *);
502	extern int register_chrdev(unsigned int, const char *,
503	@@ -1390,25 +1391,17 @@ extern int register_chrdev(unsigned int,
504	extern int unregister_chrdev(unsigned int, const char *);
505	extern void unregister_chrdev_region(dev_t, unsigned);
506	extern int chrdev_open(struct inode , struct file );
507	-extern int get_chrdev_list(char *);
508	-extern void *acquire_chrdev_list(void);
509	-extern int count_chrdev_list(void);
510	-extern void get_next_chrdev(void );
511	-extern int get_chrdev_info(void , int , char **);
512	-extern void release_chrdev_list(void *);
513	+extern void chrdev_show(struct seq_file *,off_t);
514
515	/* fs/block_dev.c */
516	+#define BLKDEV_MAJOR_HASH_SIZE 255
517	#define BDEVNAME_SIZE 32 /* Largest string for a blockdev identifier */
518	extern const char __bdevname(dev_t, char buffer);
519	extern const char bdevname(struct block_device bdev, char *buffer);
520	extern struct block_device lookup_bdev(const char );
521	extern struct block_device open_bdev_excl(const char , int, void *);
522	extern void close_bdev_excl(struct block_device *);
523	-extern void *acquire_blkdev_list(void);
524	-extern int count_blkdev_list(void);
525	-extern void get_next_blkdev(void );
526	-extern int get_blkdev_info(void , int , char **);
527	-extern void release_blkdev_list(void *);
528	+extern void blkdev_show(struct seq_file *,off_t);
529
530	extern void init_special_inode(struct inode *, umode_t, dev_t);
531