]> git.pld-linux.org Git - packages/kernel.git/blame - linux-2.4.17-devfs-v199.7.patch
projects / packages / kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- sparse fixes for 2.4.x <2.4.27
[packages/kernel.git] / linux-2.4.17-devfs-v199.7.patch
CommitLineData
e9d100bb 1diff -urN linux-2.4.18-pre3/Documentation/filesystems/devfs/ChangeLog linux/Documentation/filesystems/devfs/ChangeLog
2--- linux-2.4.18-pre3/Documentation/filesystems/devfs/ChangeLog Fri Dec 21 10:41:53 2001
3+++ linux/Documentation/filesystems/devfs/ChangeLog Sun Jan 13 18:53:59 2002
4@@ -1845,3 +1845,28 @@
5 - Improved debugging messages
6
7 - Fixed unregister bugs in drivers/md/lvm-fs.c
8+===============================================================================
9+Changes for patch v199.6
10+
11+- Corrected (made useful) debugging message in <unregister>
12+
13+- Moved <kmem_cache_create> in <mount_devfs_fs> to <init_devfs_fs>
14+
15+- Fixed drivers/md/lvm-fs.c to create "lvm" entry
16+
17+- Added magic number to guard against scribbling drivers
18+
19+- Only return old entry in <devfs_mk_dir> if a directory
20+
21+- Defined macros for error and debug messages
22+
23+- Updated README from master HTML file
24+===============================================================================
25+Changes for patch v199.7
26+
27+- Unregister /dev/root symlink prior to creating second one (for
28+ initrd)
29+
30+- Added support for multiple Compaq cpqarray controllers
31+
32+- Fixed (rare, old) race in <devfs_lookup>
33diff -urN linux-2.4.18-pre3/Documentation/filesystems/devfs/README linux/Documentation/filesystems/devfs/README
34--- linux-2.4.18-pre3/Documentation/filesystems/devfs/README Fri Dec 21 10:41:53 2001
35+++ linux/Documentation/filesystems/devfs/README Sun Jan 13 18:53:59 2002
36@@ -3,7 +3,7 @@
37
38 Linux Devfs (Device File System) FAQ
39 Richard Gooch
40-13-DEC-2001
41+21-DEC-2001
42
43 -----------------------------------------------------------------------------
44
45@@ -68,6 +68,7 @@
46 Alternatives to devfs
47 What I don't like about devfs
48 How to report bugs
49+Strange kernel messages
50
51
52 Other resources
53@@ -1475,6 +1476,7 @@
54 Alternatives to devfs
55 What I don't like about devfs
56 How to report bugs
57+Strange kernel messages
58
59
60
61@@ -1789,6 +1791,42 @@
62 a bug to report, you should also read
63
64 http://www.chiark.greenend.org.uk/~sgtatham/bugs.html.
65+
66+
67+Strange kernel messages
68+
69+You may see devfs-related messages in your kernel logs. Below are some
70+messages and what they mean (and what you should do about them, if
71+anything).
72+
73+
74+
75+devfs_register(fred): could not append to parent, err: -17
76+
77+You need to check what the error code means, but usually 17 means
78+EEXIST. This means that a driver attempted to create an entry
79+fred in a directory, but there already was an entry with that
80+name. This is often caused by flawed boot scripts which untar a bunch
81+of inodes into /dev, as a way to restore permissions. This
82+message is harmless, as the device nodes will still
83+provide access to the driver (unless you use the devfs=only
84+boot option, which is only for dedicated souls:-). If you want to get
85+rid of these annoying messages, upgrade to devfsd-v1.3.20 and use the
86+recommended RESTORE directive to restore permissions.
87+
88+
89+devfs_mk_dir(bill): using old entry in dir: c1808724 ""
90+
91+This is similar to the message above, except that a driver attempted
92+to create a directory named bill, and the parent directory
93+has an entry with the same name. In this case, to ensure that drivers
94+continue to work properly, the old entry is re-used and given to the
95+driver. In 2.5 kernels, the driver is given a NULL entry, and thus,
96+under rare circumstances, may not create the require device nodes.
97+The solution is the same as above.
98+
99+
100+
101
102 -----------------------------------------------------------------------------
103
104diff -urN linux-2.4.18-pre3/drivers/block/cpqarray.c linux/drivers/block/cpqarray.c
105--- linux-2.4.18-pre3/drivers/block/cpqarray.c Fri Nov 9 15:28:46 2001
106+++ linux/drivers/block/cpqarray.c Sun Jan 13 18:53:59 2002
107@@ -32,6 +32,7 @@
108 #include <linux/blkpg.h>
109 #include <linux/timer.h>
110 #include <linux/proc_fs.h>
111+#include <linux/devfs_fs_kernel.h>
112 #include <linux/init.h>
113 #include <linux/hdreg.h>
114 #include <linux/spinlock.h>
115@@ -70,6 +71,7 @@
116
117 static int nr_ctlr;
118 static ctlr_info_t *hba[MAX_CTLR];
119+static devfs_handle_t de_arr[MAX_CTLR][NWD];
120
121 static int eisa[8];
122
123@@ -338,6 +340,7 @@
124
125 del_gendisk(&ida_gendisk[i]);
126 }
127+ devfs_unregister(devfs_find_handle(NULL, "ida", 0, 0, 0, 0));
128 remove_proc_entry("cpqarray", proc_root_driver);
129 kfree(ida);
130 kfree(ida_sizes);
131@@ -540,6 +543,8 @@
132 ida_gendisk[i].part = ida + (i*256);
133 ida_gendisk[i].sizes = ida_sizes + (i*256);
134 ida_gendisk[i].nr_real = 0;
135+ ida_gendisk[i].de_arr = de_arr[i];
136+ ida_gendisk[i].fops = &ida_fops;
137
138 /* Get on the disk list */
139 add_gendisk(&ida_gendisk[i]);
140@@ -1881,6 +1886,14 @@
141 kfree(id_ldrive);
142 return;
143
144+ }
145+ if (!de_arr[ctlr][log_unit]) {
146+ char txt[16];
147+
148+ sprintf(txt, "ida/c%dd%d", ctlr,
149+ log_unit);
150+ de_arr[ctlr][log_unit] =
151+ devfs_mk_dir(NULL, txt, NULL);
152 }
153 info_p->phys_drives =
154 sense_config_buf->ctlr_phys_drv;
155diff -urN linux-2.4.18-pre3/drivers/md/lvm-fs.c linux/drivers/md/lvm-fs.c
156--- linux-2.4.18-pre3/drivers/md/lvm-fs.c Fri Dec 21 10:41:54 2001
157+++ linux/drivers/md/lvm-fs.c Sun Jan 13 18:53:59 2002
158@@ -65,9 +65,7 @@
159
160 static void _show_uuid(const char *src, char *b, char *e);
161
162-#if 0
163 static devfs_handle_t lvm_devfs_handle;
164-#endif
165 static devfs_handle_t vg_devfs_handle[MAX_VG];
166 static devfs_handle_t ch_devfs_handle[MAX_VG];
167 static devfs_handle_t lv_devfs_handle[MAX_LV];
168@@ -81,13 +79,11 @@
169 void __init lvm_init_fs() {
170 struct proc_dir_entry *pde;
171
172-/* User-space has already registered this */
173-#if 0
174+ /* Must create device node. Think about "devfs=only" situation */
175 lvm_devfs_handle = devfs_register(
176 0 , "lvm", 0, LVM_CHAR_MAJOR, 0,
177 S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP,
178 &lvm_chr_fops, NULL);
179-#endif
180 lvm_proc_dir = create_proc_entry(LVM_DIR, S_IFDIR, &proc_root);
181 if (lvm_proc_dir) {
182 lvm_proc_vg_subdir = create+proc_entry(LVM_VG_SUBDIR, S_IFDIR
183@@ -99,9 +95,7 @@
184 }
185
186 void lvm_fin_fs() {
187-#if 0
188 devfs_unregister (lvm_devfs_handle);
189-#endif
190 remove_proc_entry(LVM_GLOBAL, lvm_proc_dir);
191 remove_proc_entry(LVM_VG_SUBDIR, lvm_proc_dir);
192 remove_proc_entry(LVM_DIR, &proc_root);
193diff -urN linux-2.4.18-pre3/fs/devfs/base.c linux/fs/devfs/base.c
194--- linux-2.4.18-pre3/fs/devfs/base.c Fri Dec 21 10:41:55 2001
195+++ linux/fs/devfs/base.c Sun Jan 13 18:53:59 2002
196@@ -592,6 +592,18 @@
197 Added poisoning to <devfs_put>.
198 Improved debugging messages.
199 v1.7
200+ 20011221 Richard Gooch <rgooch@atnf.csiro.au>
201+ Corrected (made useful) debugging message in <unregister>.
202+ Moved <kmem_cache_create> in <mount_devfs_fs> to <init_devfs_fs>
203+ 20011224 Richard Gooch <rgooch@atnf.csiro.au>
204+ Added magic number to guard against scribbling drivers.
205+ 20011226 Richard Gooch <rgooch@atnf.csiro.au>
206+ Only return old entry in <devfs_mk_dir> if a directory.
207+ Defined macros for error and debug messages.
208+ v1.8
209+ 20020113 Richard Gooch <rgooch@atnf.csiro.au>
210+ Fixed (rare, old) race in <devfs_lookup>.
211+ v1.9
212 */
213 #include <linux/types.h>
214 #include <linux/errno.h>
215@@ -624,7 +636,7 @@
216 #include <asm/bitops.h>
217 #include <asm/atomic.h>
218
219-#define DEVFS_VERSION "1.7 (20011216)"
220+#define DEVFS_VERSION "1.9 (20020113)"
221
222 #define DEVFS_NAME "devfs"
223
224@@ -633,6 +645,7 @@
225 #define STRING_LENGTH 256
226 #define FAKE_BLOCK_SIZE 1024
227 #define POISON_PTR ( *(void **) poison_array )
228+#define MAGIC_VALUE 0x327db823
229
230 #ifndef TRUE
231 # define TRUE 1
232@@ -669,9 +682,28 @@
233 #define OPTION_MOUNT 0x01
234 #define OPTION_ONLY 0x02
235
236-#define OOPS(format, args...) {printk (format, ## args); \
237- printk ("Forcing Oops\n"); \
238- BUG();}
239+#define PRINTK(format, args...) \
240+ {printk (KERN_ERR "%s" format, __FUNCTION__ , ## args);}
241+
242+#define OOPS(format, args...) \
243+ {printk (KERN_CRIT "%s" format, __FUNCTION__ , ## args); \
244+ printk ("Forcing Oops\n"); \
245+ BUG();}
246+
247+#ifdef CONFIG_DEVFS_DEBUG
248+# define VERIFY_ENTRY(de) \
249+ {if ((de) && (de)->magic_number != MAGIC_VALUE) \
250+ OOPS ("(%p): bad magic value: %x\n", (de), (de)->magic_number);}
251+# define WRITE_ENTRY_MAGIC(de,magic) (de)->magic_number = (magic)
252+# define DPRINTK(flag, format, args...) \
253+ {if (devfs_debug & flag) \
254+ printk (KERN_INFO "%s" format, __FUNCTION__ , ## args);}
255+#else
256+# define VERIFY_ENTRY(de)
257+# define WRITE_ENTRY_MAGIC(de,magic)
258+# define DPRINTK(flag, format, args...)
259+#endif
260+
261
262 struct directory_type
263 {
264@@ -728,6 +760,9 @@
265
266 struct devfs_entry
267 {
268+#ifdef CONFIG_DEVFS_DEBUG
269+ unsigned int magic_number;
270+#endif
271 void *info;
272 atomic_t refcount; /* When this drops to zero, it's unused */
273 union
274@@ -837,6 +872,7 @@
275
276 static struct devfs_entry *devfs_get (struct devfs_entry *de)
277 {
278+ VERIFY_ENTRY (de);
279 if (de) atomic_inc (&de->refcount);
280 return de;
281 } /* End Function devfs_get */
282@@ -849,17 +885,13 @@
283 void devfs_put (devfs_handle_t de)
284 {
285 if (!de) return;
286- if (de->info == POISON_PTR)
287- OOPS ("%s: devfs_put(%p): poisoned pointer\n", DEVFS_NAME, de);
288+ VERIFY_ENTRY (de);
289+ if (de->info == POISON_PTR) OOPS ("(%p): poisoned pointer\n", de);
290 if ( !atomic_dec_and_test (&de->refcount) ) return;
291- if (de == root_entry)
292- OOPS ("%s: devfs_put(): root entry being freed\n", DEVFS_NAME);
293-#ifdef CONFIG_DEVFS_DEBUG
294- if (devfs_debug & DEBUG_FREE)
295- printk ("%s: devfs_put(%s): de: %p, parent: %p \"%s\"\n",
296- DEVFS_NAME, de->name, de, de->parent,
297- de->parent ? de->parent->name : "no parent");
298-#endif
299+ if (de == root_entry) OOPS ("(%p): root entry being freed\n", de);
300+ DPRINTK (DEBUG_FREE, "(%s): de: %p, parent: %p \"%s\"\n",
301+ de->name, de, de->parent,
302+ de->parent ? de->parent->name : "no parent");
303 if ( S_ISLNK (de->mode) ) kfree (de->u.symlink.linkname);
304 if ( ( S_ISCHR (de->mode) || S_ISBLK (de->mode) ) && de->u.fcb.autogen )
305 {
306@@ -868,6 +900,7 @@
307 MKDEV (de->u.fcb.u.device.major,
308 de->u.fcb.u.device.minor) );
309 }
310+ WRITE_ENTRY_MAGIC (de, 0);
311 #ifdef CONFIG_DEVFS_DEBUG
312 spin_lock (&stat_lock);
313 --stat_num_entries;
314@@ -898,7 +931,7 @@
315
316 if ( !S_ISDIR (dir->mode) )
317 {
318- printk ("%s: search_dir(%s): not a directory\n", DEVFS_NAME,dir->name);
319+ PRINTK ("(%s): not a directory\n", dir->name);
320 return NULL;
321 }
322 for (curr = dir->u.dir.first; curr != NULL; curr = curr->next)
323@@ -940,6 +973,7 @@
324 spin_unlock (&counter_lock);
325 if (name) memcpy (new->name, name, namelen);
326 new->namelen = namelen;
327+ WRITE_ENTRY_MAGIC (new, MAGIC_VALUE);
328 #ifdef CONFIG_DEVFS_DEBUG
329 spin_lock (&stat_lock);
330 ++stat_num_entries;
331@@ -972,8 +1006,7 @@
332 if (old_de) *old_de = NULL;
333 if ( !S_ISDIR (dir->mode) )
334 {
335- printk ("%s: append_entry(%s): dir: \"%s\" is not a directory\n",
336- DEVFS_NAME, de->name, dir->name);
337+ PRINTK ("(%s): dir: \"%s\" is not a directory\n", de->name, dir->name);
338 devfs_put (de);
339 return -ENOTDIR;
340 }
341@@ -1143,15 +1176,13 @@
342 if ( ( *dir = _devfs_make_parent_for_leaf (*dir, name, namelen,
343 &leaf_pos) ) == NULL )
344 {
345- printk ("%s: prepare_leaf(%s): could not create parent path\n",
346- DEVFS_NAME, name);
347+ PRINTK ("(%s): could not create parent path\n", name);
348 return NULL;
349 }
350 if ( ( de = _devfs_alloc_entry (name + leaf_pos, namelen - leaf_pos,mode) )
351 == NULL )
352 {
353- printk ("%s: prepare_leaf(%s): could not allocate entry\n",
354- DEVFS_NAME, name);
355+ PRINTK ("(%s): could not allocate entry\n", name);
356 devfs_put (*dir);
357 return NULL;
358 }
359@@ -1198,7 +1229,7 @@
360
361
362 /**
363- * find_by_dev - Find a devfs entry in a directory.
364+ * _devfs_find_by_dev - Find a devfs entry in a directory.
365 * @dir: The directory where to search
366 * @major: The major number to search for.
367 * @minor: The minor number to search for.
368@@ -1209,9 +1240,9 @@
369 * devfs_get() is performed.
370 */
371
372-static struct devfs_entry *find_by_dev (struct devfs_entry *dir,
373- unsigned int major, unsigned int minor,
374- char type)
375+static struct devfs_entry *_devfs_find_by_dev (struct devfs_entry *dir,
376+ unsigned int major,
377+ unsigned int minor, char type)
378 {
379 struct devfs_entry *entry, *de;
380
381@@ -1219,7 +1250,7 @@
382 if (dir == NULL) return NULL;
383 if ( !S_ISDIR (dir->mode) )
384 {
385- printk ("%s: find_by_dev(): not a directory\n", DEVFS_NAME);
386+ PRINTK ("(%p): not a directory\n", dir);
387 devfs_put (dir);
388 return NULL;
389 }
390@@ -1244,7 +1275,7 @@
391 for (entry = dir->u.dir.first; entry != NULL; entry = entry->next)
392 {
393 if ( !S_ISDIR (entry->mode) ) continue;
394- de = find_by_dev (entry, major, minor, type);
395+ de = _devfs_find_by_dev (entry, major, minor, type);
396 if (de)
397 {
398 read_unlock (&dir->u.dir.lock);
399@@ -1255,11 +1286,11 @@
400 read_unlock (&dir->u.dir.lock);
401 devfs_put (dir);
402 return NULL;
403-} /* End Function find_by_dev */
404+} /* End Function _devfs_find_by_dev */
405
406
407 /**
408- * find_entry - Find a devfs entry.
409+ * _devfs_find_entry - Find a devfs entry.
410 * @dir: The handle to the parent devfs directory entry. If this is %NULL the
411 * name is relative to the root of the devfs.
412 * @name: The name of the entry. This may be %NULL.
413@@ -1275,9 +1306,11 @@
414 * devfs_get() is performed.
415 */
416
417-static struct devfs_entry *find_entry (devfs_handle_t dir, const char *name,
418- unsigned int major, unsigned int minor,
419- char type, int traverse_symlink)
420+static struct devfs_entry *_devfs_find_entry (devfs_handle_t dir,
421+ const char *name,
422+ unsigned int major,
423+ unsigned int minor,
424+ char type, int traverse_symlink)
425 {
426 struct devfs_entry *entry;
427
428@@ -1290,14 +1323,14 @@
429 /* Skip leading pathname component */
430 if (namelen < 2)
431 {
432- printk ("%s: find_entry(%s): too short\n", DEVFS_NAME, name);
433+ PRINTK ("(%s): too short\n", name);
434 return NULL;
435 }
436 for (++name, --namelen; (*name != '/') && (namelen > 0);
437 ++name, --namelen);
438 if (namelen < 2)
439 {
440- printk ("%s: find_entry(%s): too short\n", DEVFS_NAME, name);
441+ PRINTK ("(%s): too short\n", name);
442 return NULL;
443 }
444 ++name;
445@@ -1308,12 +1341,13 @@
446 }
447 /* Have to search by major and minor: slow */
448 if ( (major == 0) && (minor == 0) ) return NULL;
449- return find_by_dev (root_entry, major, minor, type);
450-} /* End Function find_entry */
451+ return _devfs_find_by_dev (root_entry, major, minor, type);
452+} /* End Function _devfs_find_entry */
453
454 static struct devfs_entry *get_devfs_entry_from_vfs_inode (struct inode *inode)
455 {
456 if (inode == NULL) return NULL;
457+ VERIFY_ENTRY ( (struct devfs_entry *) inode->u.generic_ip );
458 return inode->u.generic_ip;
459 } /* End Function get_devfs_entry_from_vfs_inode */
460
461@@ -1495,7 +1529,7 @@
462
463 if (name == NULL)
464 {
465- printk ("%s: devfs_register(): NULL name pointer\n", DEVFS_NAME);
466+ PRINTK ("(): NULL name pointer\n");
467 return NULL;
468 }
469 if (ops == NULL)
470@@ -1503,23 +1537,19 @@
471 if ( S_ISBLK (mode) ) ops = (void *) get_blkfops (major);
472 if (ops == NULL)
473 {
474- printk ("%s: devfs_register(%s): NULL ops pointer\n",
475- DEVFS_NAME, name);
476+ PRINTK ("(%s): NULL ops pointer\n", name);
477 return NULL;
478 }
479- printk ("%s: devfs_register(%s): NULL ops, got %p from major table\n",
480- DEVFS_NAME, name, ops);
481+ PRINTK ("(%s): NULL ops, got %p from major table\n", name, ops);
482 }
483 if ( S_ISDIR (mode) )
484 {
485- printk("%s: devfs_register(%s): creating directories is not allowed\n",
486- DEVFS_NAME, name);
487+ PRINTK ("(%s): creating directories is not allowed\n", name);
488 return NULL;
489 }
490 if ( S_ISLNK (mode) )
491 {
492- printk ("%s: devfs_register(%s): creating symlinks is not allowed\n",
493- DEVFS_NAME, name);
494+ PRINTK ("(%s): creating symlinks is not allowed\n", name);
495 return NULL;
496 }
497 if ( ( S_ISCHR (mode) || S_ISBLK (mode) ) &&
498@@ -1527,8 +1557,8 @@
499 {
500 if ( ( devnum = devfs_alloc_devnum (devtype) ) == NODEV )
501 {
502- printk ("%s: devfs_register(%s): exhausted %s device numbers\n",
503- DEVFS_NAME, name, S_ISCHR (mode) ? "char" : "block");
504+ PRINTK ("(%s): exhausted %s device numbers\n",
505+ name, S_ISCHR (mode) ? "char" : "block");
506 return NULL;
507 }
508 major = MAJOR (devnum);
509@@ -1536,8 +1566,7 @@
510 }
511 if ( ( de = _devfs_prepare_leaf (&dir, name, mode) ) == NULL )
512 {
513- printk ("%s: devfs_register(%s): could not prepare leaf\n",
514- DEVFS_NAME, name);
515+ PRINTK ("(%s): could not prepare leaf\n", name);
516 if (devnum != NODEV) devfs_dealloc_devnum (devtype, devnum);
517 return NULL;
518 }
519@@ -1549,8 +1578,7 @@
520 }
521 else if ( !S_ISREG (mode) )
522 {
523- printk ("%s: devfs_register(%s): illegal mode: %x\n",
524- DEVFS_NAME, name, mode);
525+ PRINTK ("(%s): illegal mode: %x\n", name, mode);
526 devfs_put (de);
527 devfs_put (dir);
528 return (NULL);
529@@ -1574,17 +1602,13 @@
530 if ( ( err = _devfs_append_entry (dir, de, de->u.fcb.removable, NULL) )
531 != 0 )
532 {
533- printk("%s: devfs_register(%s): could not append to parent, err: %d\n",
534- DEVFS_NAME, name, err);
535+ PRINTK ("(%s): could not append to parent, err: %d\n", name, err);
536 devfs_put (dir);
537 if (devnum != NODEV) devfs_dealloc_devnum (devtype, devnum);
538 return NULL;
539 }
540-#ifdef CONFIG_DEVFS_DEBUG
541- if (devfs_debug & DEBUG_REGISTER)
542- printk ("%s: devfs_register(%s): de: %p dir: %p \"%s\" pp: %p\n",
543- DEVFS_NAME, name, de, dir, dir->name, dir->parent);
544-#endif
545+ DPRINTK (DEBUG_REGISTER, "(%s): de: %p dir: %p \"%s\" pp: %p\n",
546+ name, de, dir, dir->name, dir->parent);
547 devfsd_notify (de, DEVFSD_NOTIFY_REGISTERED, flags & DEVFS_FL_WAIT);
548 devfs_put (dir);
549 return de;
550@@ -1620,7 +1644,7 @@
551
552
553 /**
554- * unregister - Unregister a device entry from it's parent.
555+ * _devfs_unregister - Unregister a device entry from it's parent.
556 * @dir: The parent directory.
557 * @de: The entry to unregister.
558 *
559@@ -1628,7 +1652,7 @@
560 * unlocked by this function.
561 */
562
563-static void unregister (struct devfs_entry *dir, struct devfs_entry *de)
564+static void _devfs_unregister (struct devfs_entry *dir, struct devfs_entry *de)
565 {
566 int unhooked = _devfs_unhook (de);
567
568@@ -1647,17 +1671,14 @@
569 write_lock (&de->u.dir.lock);
570 de->u.dir.no_more_additions = TRUE;
571 child = de->u.dir.first;
572- unregister (de, child);
573+ VERIFY_ENTRY (child);
574+ _devfs_unregister (de, child);
575 if (!child) break;
576-#ifdef CONFIG_DEVFS_DEBUG
577- if (devfs_debug & DEBUG_UNREGISTER)
578- printk ( "%s: unregister(%s): child: %p refcount: %d\n",
579- DEVFS_NAME, child->name, child,
580- atomic_read (&de->refcount) );
581-#endif
582+ DPRINTK (DEBUG_UNREGISTER, "(%s): child: %p refcount: %d\n",
583+ child->name, child, atomic_read (&child->refcount) );
584 devfs_put (child);
585 }
586-} /* End Function unregister */
587+} /* End Function _devfs_unregister */
588
589
590 /**
591@@ -1668,14 +1689,12 @@
592
593 void devfs_unregister (devfs_handle_t de)
594 {
595+ VERIFY_ENTRY (de);
596 if ( (de == NULL) || (de->parent == NULL) ) return;
597-#ifdef CONFIG_DEVFS_DEBUG
598- if (devfs_debug & DEBUG_UNREGISTER)
599- printk ( "%s: devfs_unregister(%s): de: %p refcount: %d\n",
600- DEVFS_NAME, de->name, de, atomic_read (&de->refcount) );
601-#endif
602+ DPRINTK (DEBUG_UNREGISTER, "(%s): de: %p refcount: %d\n",
603+ de->name, de, atomic_read (&de->refcount) );
604 write_lock (&de->parent->u.dir.lock);
605- unregister (de->parent, de);
606+ _devfs_unregister (de->parent, de);
607 devfs_put (de);
608 } /* End Function devfs_unregister */
609
610@@ -1691,16 +1710,12 @@
611 if (handle != NULL) *handle = NULL;
612 if (name == NULL)
613 {
614- printk ("%s: devfs_do_symlink(): NULL name pointer\n", DEVFS_NAME);
615+ PRINTK ("(): NULL name pointer\n");
616 return -EINVAL;
617 }
618-#ifdef CONFIG_DEVFS_DEBUG
619- if (devfs_debug & DEBUG_REGISTER)
620- printk ("%s: devfs_do_symlink(%s)\n", DEVFS_NAME, name);
621-#endif
622 if (link == NULL)
623 {
624- printk ("%s: devfs_do_symlink(): NULL link pointer\n", DEVFS_NAME);
625+ PRINTK ("(%s): NULL link pointer\n", name);
626 return -EINVAL;
627 }
628 linklength = strlen (link);
629@@ -1711,8 +1726,7 @@
630 if ( ( de = _devfs_prepare_leaf (&dir, name, S_IFLNK | S_IRUGO | S_IXUGO) )
631 == NULL )
632 {
633- printk ("%s: devfs_do_symlink(%s): could not prepare leaf\n",
634- DEVFS_NAME, name);
635+ PRINTK ("(%s): could not prepare leaf\n", name);
636 kfree (newlink);
637 return -ENOTDIR;
638 }
639@@ -1722,8 +1736,7 @@
640 de->u.symlink.length = linklength;
641 if ( ( err = _devfs_append_entry (dir, de, FALSE, NULL) ) != 0 )
642 {
643- printk ("%s: devfs_do_symlink(%s): could not append to parent, err: %d\n",
644- DEVFS_NAME, name, err);
645+ PRINTK ("(%s): could not append to parent, err: %d\n", name, err);
646 devfs_put (dir);
647 return err;
648 }
649@@ -1758,6 +1771,7 @@
650 devfs_handle_t de;
651
652 if (handle != NULL) *handle = NULL;
653+ DPRINTK (DEBUG_REGISTER, "(%s)\n", name);
654 err = devfs_do_symlink (dir, name, flags, link, &de, info);
655 if (err) return err;
656 if (handle != NULL) *handle = de;
657@@ -1787,39 +1801,35 @@
658
659 if (name == NULL)
660 {
661- printk ("%s: devfs_mk_dir(): NULL name pointer\n", DEVFS_NAME);
662+ PRINTK ("(): NULL name pointer\n");
663 return NULL;
664 }
665 if ( ( de = _devfs_prepare_leaf (&dir, name, MODE_DIR) ) == NULL )
666 {
667- printk ("%s: devfs_mk_dir(%s): could not prepare leaf\n",
668- DEVFS_NAME, name);
669+ PRINTK ("(%s): could not prepare leaf\n", name);
670 return NULL;
671 }
672 de->info = info;
673 if ( ( err = _devfs_append_entry (dir, de, FALSE, &old) ) != 0 )
674 {
675 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,1)
676- if (old)
677+ if ( old && S_ISDIR (old->mode) )
678 {
679- printk("%s: devfs_mk_dir(%s): using old entry in dir: %p \"%s\"\n",
680- DEVFS_NAME, name, dir, dir->name);
681+ PRINTK ("(%s): using old entry in dir: %p \"%s\"\n",
682+ name, dir, dir->name);
683 old->vfs_created = FALSE;
684 devfs_put (dir);
685 return old;
686 }
687 #endif
688- printk ("%s: devfs_mk_dir(%s): could not append to dir: %p \"%s\", err: %d\n",
689- DEVFS_NAME, name, dir, dir->name, err);
690+ PRINTK ("(%s): could not append to dir: %p \"%s\", err: %d\n",
691+ name, dir, dir->name, err);
692 devfs_put (old);
693 devfs_put (dir);
694 return NULL;
695 }
696-#ifdef CONFIG_DEVFS_DEBUG
697- if (devfs_debug & DEBUG_REGISTER)
698- printk ("%s: devfs_mk_dir(%s): de: %p dir: %p \"%s\"\n",
699- DEVFS_NAME, name, de, dir, dir->name);
700-#endif
701+ DPRINTK (DEBUG_REGISTER, "(%s): de: %p dir: %p \"%s\"\n",
702+ name, de, dir, dir->name);
703 devfsd_notify (de, DEVFSD_NOTIFY_REGISTERED, 0);
704 devfs_put (dir);
705 return de;
706@@ -1850,7 +1860,7 @@
707 char type, int traverse_symlinks)
708 {
709 if ( (name != NULL) && (name[0] == '\0') ) name = NULL;
710- return find_entry (dir, name, major, minor, type, traverse_symlinks);
711+ return _devfs_find_entry (dir, name, major, minor, type,traverse_symlinks);
712 } /* End Function devfs_get_handle */
713
714
715@@ -1881,6 +1891,7 @@
716 unsigned int fl = 0;
717
718 if (de == NULL) return -EINVAL;
719+ VERIFY_ENTRY (de);
720 if (de->hide) fl |= DEVFS_FL_HIDE;
721 if ( S_ISCHR (de->mode) || S_ISBLK (de->mode) || S_ISREG (de->mode) )
722 {
723@@ -1904,11 +1915,8 @@
724 int devfs_set_flags (devfs_handle_t de, unsigned int flags)
725 {
726 if (de == NULL) return -EINVAL;
727-#ifdef CONFIG_DEVFS_DEBUG
728- if (devfs_debug & DEBUG_SET_FLAGS)
729- printk ("%s: devfs_set_flags(): de->name: \"%s\"\n",
730- DEVFS_NAME, de->name);
731-#endif
732+ VERIFY_ENTRY (de);
733+ DPRINTK (DEBUG_SET_FLAGS, "(%s): flags: %x\n", de->name, flags);
734 de->hide = (flags & DEVFS_FL_HIDE) ? TRUE : FALSE;
735 if ( S_ISCHR (de->mode) || S_ISBLK (de->mode) || S_ISREG (de->mode) )
736 {
737@@ -1932,6 +1940,7 @@
738 unsigned int *minor)
739 {
740 if (de == NULL) return -EINVAL;
741+ VERIFY_ENTRY (de);
742 if ( S_ISDIR (de->mode) ) return -EISDIR;
743 if ( !S_ISCHR (de->mode) && !S_ISBLK (de->mode) ) return -EINVAL;
744 if (major != NULL) *major = de->u.fcb.u.device.major;
745@@ -1972,6 +1981,7 @@
746 #define NAMEOF(de) ( (de)->mode ? (de)->name : (de)->u.name )
747
748 if (de == NULL) return -EINVAL;
749+ VERIFY_ENTRY (de);
750 if (de->namelen >= buflen) return -ENAMETOOLONG; /* Must be first */
751 path[buflen - 1] = '\0';
752 if (de->parent == NULL) return buflen - 1; /* Don't prepend root */
753@@ -2001,6 +2011,7 @@
754 struct module *owner;
755
756 if (de == NULL) return NULL;
757+ VERIFY_ENTRY (de);
758 if ( !S_ISCHR (de->mode) && !S_ISBLK (de->mode) && !S_ISREG (de->mode) )
759 return NULL;
760 if (de->u.fcb.ops == NULL) return NULL;
761@@ -2031,6 +2042,7 @@
762 struct module *owner;
763
764 if (de == NULL) return;
765+ VERIFY_ENTRY (de);
766 if ( !S_ISCHR (de->mode) && !S_ISBLK (de->mode) && !S_ISREG (de->mode) )
767 return;
768 if (de->u.fcb.ops == NULL) return;
769@@ -2052,6 +2064,7 @@
770 int devfs_set_file_size (devfs_handle_t de, unsigned long size)
771 {
772 if (de == NULL) return -EINVAL;
773+ VERIFY_ENTRY (de);
774 if ( !S_ISREG (de->mode) ) return -EINVAL;
775 if (de->u.fcb.u.file.size == size) return 0;
776 de->u.fcb.u.file.size = size;
777@@ -2071,6 +2084,7 @@
778 void *devfs_get_info (devfs_handle_t de)
779 {
780 if (de == NULL) return NULL;
781+ VERIFY_ENTRY (de);
782 return de->info;
783 } /* End Function devfs_get_info */
784
785@@ -2085,6 +2099,7 @@
786 int devfs_set_info (devfs_handle_t de, void *info)
787 {
788 if (de == NULL) return -EINVAL;
789+ VERIFY_ENTRY (de);
790 de->info = info;
791 return 0;
792 } /* End Function devfs_set_info */
793@@ -2099,6 +2114,7 @@
794 devfs_handle_t devfs_get_parent (devfs_handle_t de)
795 {
796 if (de == NULL) return NULL;
797+ VERIFY_ENTRY (de);
798 return de->parent;
799 } /* End Function devfs_get_parent */
800
801@@ -2113,6 +2129,7 @@
802 devfs_handle_t devfs_get_first_child (devfs_handle_t de)
803 {
804 if (de == NULL) return NULL;
805+ VERIFY_ENTRY (de);
806 if ( !S_ISDIR (de->mode) ) return NULL;
807 return de->u.dir.first;
808 } /* End Function devfs_get_first_child */
809@@ -2128,6 +2145,7 @@
810 devfs_handle_t devfs_get_next_sibling (devfs_handle_t de)
811 {
812 if (de == NULL) return NULL;
813+ VERIFY_ENTRY (de);
814 return de->next;
815 } /* End Function devfs_get_next_sibling */
816
817@@ -2143,14 +2161,15 @@
818 void devfs_auto_unregister (devfs_handle_t master, devfs_handle_t slave)
819 {
820 if (master == NULL) return;
821+ VERIFY_ENTRY (master);
822+ VERIFY_ENTRY (slave);
823 if (master->slave != NULL)
824 {
825 /* Because of the dumbness of the layers above, ignore duplicates */
826 if (master->slave == slave) return;
827- printk ("%s: devfs_auto_unregister(): only one slave allowed\n",
828- DEVFS_NAME);
829- OOPS (" master: \"%s\" old slave: \"%s\" new slave: \"%s\"\n",
830- master->name, master->slave->name, slave->name);
831+ PRINTK ("(%s): only one slave allowed\n", master->name);
832+ OOPS ("(): old slave: \"%s\" new slave: \"%s\"\n",
833+ master->slave->name, slave->name);
834 }
835 master->slave = slave;
836 } /* End Function devfs_auto_unregister */
837@@ -2166,6 +2185,7 @@
838 devfs_handle_t devfs_get_unregister_slave (devfs_handle_t master)
839 {
840 if (master == NULL) return NULL;
841+ VERIFY_ENTRY (master);
842 return master->slave;
843 } /* End Function devfs_get_unregister_slave */
844
845@@ -2181,6 +2201,7 @@
846 const char *devfs_get_name (devfs_handle_t de, unsigned int *namelen)
847 {
848 if (de == NULL) return NULL;
849+ VERIFY_ENTRY (de);
850 if (namelen != NULL) *namelen = de->namelen;
851 return de->name;
852 } /* End Function devfs_get_name */
853@@ -2360,7 +2381,7 @@
854 * @buf: A working area that will be used. This must not go out of scope
855 * until devfsd is idle again.
856 *
857- * Returns 0 on success, else a negative error code.
858+ * Returns 0 on success (event was queued), else a negative error code.
859 */
860
861 static int try_modload (struct devfs_entry *parent, struct fs_info *fs_info,
862@@ -2375,10 +2396,11 @@
863 buf->parent = parent;
864 buf->namelen = namelen;
865 buf->u.name = name;
866+ WRITE_ENTRY_MAGIC (buf, MAGIC_VALUE);
867 if ( !devfsd_notify_de (buf, DEVFSD_NOTIFY_LOOKUP, 0,
868 current->euid, current->egid, fs_info, 0) )
869 return -ENOENT;
870- /* Possible success */
871+ /* Possible success: event has been queued */
872 return 0;
873 } /* End Function try_modload */
874
875@@ -2487,16 +2509,10 @@
876 if (retval != 0) return retval;
877 retval = inode_setattr (inode, iattr);
878 if (retval != 0) return retval;
879-#ifdef CONFIG_DEVFS_DEBUG
880- if (devfs_debug & DEBUG_I_CHANGE)
881- {
882- printk ("%s: notify_change(%d): VFS inode: %p devfs_entry: %p\n",
883- DEVFS_NAME, (int) inode->i_ino, inode, de);
884- printk ("%s: mode: 0%o uid: %d gid: %d\n",
885- DEVFS_NAME, (int) inode->i_mode,
886- (int) inode->i_uid, (int) inode->i_gid);
887- }
888-#endif
889+ DPRINTK (DEBUG_I_CHANGE, "(%d): VFS inode: %p devfs_entry: %p\n",
890+ (int) inode->i_ino, inode, de);
891+ DPRINTK (DEBUG_I_CHANGE, "(): mode: 0%o uid: %d gid: %d\n",
892+ (int) inode->i_mode, (int) inode->i_uid, (int) inode->i_gid);
893 /* Inode is not on hash chains, thus must save permissions here rather
894 than in a write_inode() method */
895 if ( ( !S_ISREG (inode->i_mode) && !S_ISCHR (inode->i_mode) &&
896@@ -2541,7 +2557,7 @@
897
898
899 /**
900- * get_vfs_inode - Get a VFS inode.
901+ * _devfs_get_vfs_inode - Get a VFS inode.
902 * @sb: The super block.
903 * @de: The devfs inode.
904 * @dentry: The dentry to register with the devfs inode.
905@@ -2550,9 +2566,9 @@
906 * performed if the inode is created.
907 */
908
909-static struct inode *get_vfs_inode (struct super_block *sb,
910- struct devfs_entry *de,
911- struct dentry *dentry)
912+static struct inode *_devfs_get_vfs_inode (struct super_block *sb,
913+ struct devfs_entry *de,
914+ struct dentry *dentry)
915 {
916 int is_fcb = FALSE;
917 struct inode *inode;
918@@ -2560,8 +2576,7 @@
919 if (de->prev == de) return NULL; /* Quick check to see if unhooked */
920 if ( ( inode = new_inode (sb) ) == NULL )
921 {
922- printk ("%s: get_vfs_inode(%s): new_inode() failed, de: %p\n",
923- DEVFS_NAME, de->name, de);
924+ PRINTK ("(%s): new_inode() failed, de: %p\n", de->name, de);
925 return NULL;
926 }
927 if (de->parent)
928@@ -2578,11 +2593,8 @@
929 }
930 inode->u.generic_ip = devfs_get (de);
931 inode->i_ino = de->inode.ino;
932-#ifdef CONFIG_DEVFS_DEBUG
933- if (devfs_debug & DEBUG_I_GET)
934- printk ("%s: get_vfs_inode(%d): VFS inode: %p devfs_entry: %p\n",
935- DEVFS_NAME, (int) inode->i_ino, inode, de);
936-#endif
937+ DPRINTK (DEBUG_I_GET, "(%d): VFS inode: %p devfs_entry: %p\n",
938+ (int) inode->i_ino, inode, de);
939 inode->i_blocks = 0;
940 inode->i_blksize = FAKE_BLOCK_SIZE;
941 inode->i_op = &devfs_iops;
942@@ -2604,8 +2616,7 @@
943 if (!inode->i_bdev->bd_op && de->u.fcb.ops)
944 inode->i_bdev->bd_op = de->u.fcb.ops;
945 }
946- else printk ("%s: get_vfs_inode(%d): no block device from bdget()\n",
947- DEVFS_NAME, (int) inode->i_ino);
948+ else PRINTK ("(%d): no block device from bdget()\n",(int)inode->i_ino);
949 is_fcb = TRUE;
950 }
951 else if ( S_ISFIFO (de->mode) ) inode->i_fop = &def_fifo_fops;
952@@ -2632,14 +2643,10 @@
953 inode->i_atime = de->inode.atime;
954 inode->i_mtime = de->inode.mtime;
955 inode->i_ctime = de->inode.ctime;
956-#ifdef CONFIG_DEVFS_DEBUG
957- if (devfs_debug & DEBUG_I_GET)
958- printk ("%s: mode: 0%o uid: %d gid: %d\n",
959- DEVFS_NAME, (int) inode->i_mode,
960- (int) inode->i_uid, (int) inode->i_gid);
961-#endif
962+ DPRINTK (DEBUG_I_GET, "(): mode: 0%o uid: %d gid: %d\n",
963+ (int) inode->i_mode, (int) inode->i_uid, (int) inode->i_gid);
964 return inode;
965-} /* End Function get_vfs_inode */
966+} /* End Function _devfs_get_vfs_inode */
967
968
969 /* File operations for device entries follow */
970@@ -2655,11 +2662,8 @@
971 fs_info = inode->i_sb->u.generic_sbp;
972 parent = get_devfs_entry_from_vfs_inode (file->f_dentry->d_inode);
973 if ( (long) file->f_pos < 0 ) return -EINVAL;
974-#ifdef CONFIG_DEVFS_DEBUG
975- if (devfs_debug & DEBUG_F_READDIR)
976- printk ("%s: readdir(): fs_info: %p pos: %ld\n", DEVFS_NAME,
977- fs_info, (long) file->f_pos);
978-#endif
979+ DPRINTK (DEBUG_F_READDIR, "(%s): fs_info: %p pos: %ld\n",
980+ parent->name, fs_info, (long) file->f_pos);
981 switch ( (long) file->f_pos )
982 {
983 case 0:
984@@ -2779,13 +2783,7 @@
985
986 static void devfs_d_release (struct dentry *dentry)
987 {
988-#ifdef CONFIG_DEVFS_DEBUG
989- struct inode *inode = dentry->d_inode;
990-
991- if (devfs_debug & DEBUG_D_RELEASE)
992- printk ("%s: d_release(): dentry: %p inode: %p\n",
993- DEVFS_NAME, dentry, inode);
994-#endif
995+ DPRINTK (DEBUG_D_RELEASE, "(%p): inode: %p\n", dentry, dentry->d_inode);
996 } /* End Function devfs_d_release */
997
998 /**
999@@ -2799,14 +2797,11 @@
1000 struct devfs_entry *de;
1001
1002 de = get_devfs_entry_from_vfs_inode (inode);
1003-#ifdef CONFIG_DEVFS_DEBUG
1004- if (devfs_debug & DEBUG_D_IPUT)
1005- printk ("%s: d_iput(): dentry: %p inode: %p de: %p de->dentry: %p\n",
1006- DEVFS_NAME, dentry, inode, de, de->inode.dentry);
1007-#endif
1008+ DPRINTK (DEBUG_D_IPUT,"(%s): dentry: %p inode: %p de: %p de->dentry: %p\n",
1009+ de->name, dentry, inode, de, de->inode.dentry);
1010 if ( de->inode.dentry && (de->inode.dentry != dentry) )
1011- OOPS ("%s: d_iput(%s): de: %p dentry: %p de->dentry: %p\n",
1012- DEVFS_NAME, de->name, de, dentry, de->inode.dentry);
1013+ OOPS ("(%s): de: %p dentry: %p de->dentry: %p\n",
1014+ de->name, de, dentry, de->inode.dentry);
1015 de->inode.dentry = NULL;
1016 iput (inode);
1017 devfs_put (de);
1018@@ -2846,20 +2841,13 @@
1019 /* Unhash dentry if negative (has no inode) */
1020 if (inode == NULL)
1021 {
1022-#ifdef CONFIG_DEVFS_DEBUG
1023- if (devfs_debug & DEBUG_D_DELETE)
1024- printk ("%s: d_delete(): dropping negative dentry: %p\n",
1025- DEVFS_NAME, dentry);
1026-#endif
1027+ DPRINTK (DEBUG_D_DELETE, "(%p): dropping negative dentry\n", dentry);
1028 return 1;
1029 }
1030 fs_info = inode->i_sb->u.generic_sbp;
1031 de = get_devfs_entry_from_vfs_inode (inode);
1032-#ifdef CONFIG_DEVFS_DEBUG
1033- if (devfs_debug & DEBUG_D_DELETE)
1034- printk ("%s: d_delete(): dentry: %p inode: %p devfs_entry: %p\n",
1035- DEVFS_NAME, dentry, inode, de);
1036-#endif
1037+ DPRINTK (DEBUG_D_DELETE, "(%p): inode: %p devfs_entry: %p\n",
1038+ dentry, inode, de);
1039 if (de == NULL) return 0;
1040 if ( !S_ISCHR (de->mode) && !S_ISBLK (de->mode) && !S_ISREG (de->mode) )
1041 return 0;
1042@@ -2876,40 +2864,55 @@
1043 return 0;
1044 } /* End Function devfs_d_delete */
1045
1046+struct devfs_lookup_struct
1047+{
1048+ devfs_handle_t de;
1049+ wait_queue_head_t wait_queue;
1050+};
1051+
1052 static int devfs_d_revalidate_wait (struct dentry *dentry, int flags)
1053 {
1054 struct inode *dir = dentry->d_parent->d_inode;
1055 struct fs_info *fs_info = dir->i_sb->u.generic_sbp;
1056+ devfs_handle_t parent = get_devfs_entry_from_vfs_inode (dir);
1057+ struct devfs_lookup_struct *lookup_info = dentry->d_fsdata;
1058+ DECLARE_WAITQUEUE (wait, current);
1059
1060 if ( !dentry->d_inode && is_devfsd_or_child (fs_info) )
1061 {
1062- devfs_handle_t de;
1063- devfs_handle_t parent = get_devfs_entry_from_vfs_inode (dir);
1064+ devfs_handle_t de = lookup_info->de;
1065 struct inode *inode;
1066
1067-#ifdef CONFIG_DEVFS_DEBUG
1068- if (devfs_debug & DEBUG_I_LOOKUP)
1069- printk ("%s: d_revalidate(%s): dentry: %p by: \"%s\"\n",
1070- DEVFS_NAME, dentry->d_name.name, dentry, current->comm);
1071-#endif
1072- read_lock (&parent->u.dir.lock);
1073- de = _devfs_search_dir (parent, dentry->d_name.name,
1074- dentry->d_name.len);
1075- read_unlock (&parent->u.dir.lock);
1076- if (de == NULL) return 1;
1077+ DPRINTK (DEBUG_I_LOOKUP, "(%s): dentry: %p de: %p by: \"%s\"\n",
1078+ dentry->d_name.name, dentry, de, current->comm);
1079+ if (de == NULL)
1080+ {
1081+ read_lock (&parent->u.dir.lock);
1082+ de = _devfs_search_dir (parent, dentry->d_name.name,
1083+ dentry->d_name.len);
1084+ read_unlock (&parent->u.dir.lock);
1085+ if (de == NULL) return 1;
1086+ lookup_info->de = de;
1087+ }
1088 /* Create an inode, now that the driver information is available */
1089- inode = get_vfs_inode (dir->i_sb, de, dentry);
1090- devfs_put (de);
1091+ inode = _devfs_get_vfs_inode (dir->i_sb, de, dentry);
1092 if (!inode) return 1;
1093-#ifdef CONFIG_DEVFS_DEBUG
1094- if (devfs_debug & DEBUG_I_LOOKUP)
1095- printk ("%s: d_revalidate(): new VFS inode(%u): %p devfs_entry: %p\n",
1096- DEVFS_NAME, de->inode.ino, inode, de);
1097-#endif
1098+ DPRINTK (DEBUG_I_LOOKUP,
1099+ "(%s): new VFS inode(%u): %p de: %p by: \"%s\"\n",
1100+ de->name, de->inode.ino, inode, de, current->comm);
1101 d_instantiate (dentry, inode);
1102 return 1;
1103 }
1104- if ( wait_for_devfsd_finished (fs_info) ) dentry->d_op = &devfs_dops;
1105+ if (lookup_info == NULL) return 1; /* Early termination */
1106+ read_lock (&parent->u.dir.lock);
1107+ if (dentry->d_fsdata)
1108+ {
1109+ add_wait_queue (&lookup_info->wait_queue, &wait);
1110+ current->state = TASK_UNINTERRUPTIBLE;
1111+ read_unlock (&parent->u.dir.lock);
1112+ schedule ();
1113+ }
1114+ else read_unlock (&parent->u.dir.lock);
1115 return 1;
1116 } /* End Function devfs_d_revalidate_wait */
1117
1118@@ -2918,20 +2921,20 @@
1119
1120 static struct dentry *devfs_lookup (struct inode *dir, struct dentry *dentry)
1121 {
1122+ struct devfs_entry tmp; /* Must stay in scope until devfsd idle again */
1123+ struct devfs_lookup_struct lookup_info;
1124 struct fs_info *fs_info = dir->i_sb->u.generic_sbp;
1125 struct devfs_entry *parent, *de;
1126 struct inode *inode;
1127+ struct dentry *retval = NULL;
1128
1129 /* Set up the dentry operations before anything else, to ensure cleaning
1130 up on any error */
1131 dentry->d_op = &devfs_dops;
1132 /* First try to get the devfs entry for this directory */
1133 parent = get_devfs_entry_from_vfs_inode (dir);
1134-#ifdef CONFIG_DEVFS_DEBUG
1135- if (devfs_debug & DEBUG_I_LOOKUP)
1136- printk ("%s: lookup(%s): dentry: %p parent: %p by: \"%s\"\n",
1137- DEVFS_NAME, dentry->d_name.name, dentry, parent,current->comm);
1138-#endif
1139+ DPRINTK (DEBUG_I_LOOKUP, "(%s): dentry: %p parent: %p by: \"%s\"\n",
1140+ dentry->d_name.name, dentry, parent, current->comm);
1141 if (parent == NULL) return ERR_PTR (-ENOENT);
1142 read_lock (&parent->u.dir.lock);
1143 de = _devfs_search_dir (parent, dentry->d_name.name, dentry->d_name.len);
1144@@ -2945,63 +2948,61 @@
1145 dentry->d_name.len);
1146 read_unlock (&parent->u.dir.lock);
1147 }
1148+ lookup_info.de = de;
1149+ init_waitqueue_head (&lookup_info.wait_queue);
1150+ dentry->d_fsdata = &lookup_info;
1151 if (de == NULL)
1152 { /* Try with devfsd. For any kind of failure, leave a negative dentry
1153 so someone else can deal with it (in the case where the sysadmin
1154 does a mknod()). It's important to do this before hashing the
1155 dentry, so that the devfsd queue is filled before revalidates
1156 can start */
1157- struct devfs_entry tmp;
1158-
1159 if (try_modload (parent, fs_info,
1160 dentry->d_name.name, dentry->d_name.len, &tmp) < 0)
1161- {
1162+ { /* Lookup event was not queued to devfsd */
1163 d_add (dentry, NULL);
1164 return NULL;
1165 }
1166- /* devfsd claimed success */
1167- dentry->d_op = &devfs_wait_dops;
1168- d_add (dentry, NULL); /* Open the floodgates */
1169- /* Unlock directory semaphore, which will release any waiters. They
1170- will get the hashed dentry, and may be forced to wait for
1171- revalidation */
1172- up (&dir->i_sem);
1173- devfs_d_revalidate_wait (dentry, 0); /* I might have to wait too */
1174- down (&dir->i_sem); /* Grab it again because them's the rules */
1175- /* If someone else has been so kind as to make the inode, we go home
1176- early */
1177- if (dentry->d_inode) return NULL;
1178+ }
1179+ dentry->d_op = &devfs_wait_dops;
1180+ d_add (dentry, NULL); /* Open the floodgates */
1181+ /* Unlock directory semaphore, which will release any waiters. They
1182+ will get the hashed dentry, and may be forced to wait for
1183+ revalidation */
1184+ up (&dir->i_sem);
1185+ wait_for_devfsd_finished (fs_info); /* If I'm not devfsd, must wait */
1186+ down (&dir->i_sem); /* Grab it again because them's the rules */
1187+ de = lookup_info.de;
1188+ /* If someone else has been so kind as to make the inode, we go home
1189+ early */
1190+ if (dentry->d_inode) goto out;
1191+ if (de == NULL)
1192+ {
1193 read_lock (&parent->u.dir.lock);
1194 de = _devfs_search_dir (parent, dentry->d_name.name,
1195 dentry->d_name.len);
1196 read_unlock (&parent->u.dir.lock);
1197- if (de == NULL) return NULL;
1198+ if (de == NULL) goto out;
1199 /* OK, there's an entry now, but no VFS inode yet */
1200 }
1201- else
1202+ /* Create an inode, now that the driver information is available */
1203+ inode = _devfs_get_vfs_inode (dir->i_sb, de, dentry);
1204+ if (!inode)
1205 {
1206- dentry->d_op = &devfs_wait_dops;
1207- d_add (dentry, NULL); /* Open the floodgates */
1208+ retval = ERR_PTR (-ENOMEM);
1209+ goto out;
1210 }
1211- /* Create an inode, now that the driver information is available */
1212- inode = get_vfs_inode (dir->i_sb, de, dentry);
1213- devfs_put (de);
1214- if (!inode) return ERR_PTR (-ENOMEM);
1215-#ifdef CONFIG_DEVFS_DEBUG
1216- if (devfs_debug & DEBUG_I_LOOKUP)
1217- printk ("%s: lookup(): new VFS inode(%u): %p devfs_entry: %p\n",
1218- DEVFS_NAME, de->inode.ino, inode, de);
1219-#endif
1220+ DPRINTK (DEBUG_I_LOOKUP, "(%s): new VFS inode(%u): %p de: %p by: \"%s\"\n",
1221+ de->name, de->inode.ino, inode, de, current->comm);
1222 d_instantiate (dentry, inode);
1223- if (dentry->d_op == &devfs_wait_dops)
1224- { /* Unlock directory semaphore, which will release any waiters. They
1225- will get the hashed dentry, and may be forced to wait for
1226- revalidation */
1227- up (&dir->i_sem);
1228- devfs_d_revalidate_wait (dentry, 0); /* I might have to wait too */
1229- down (&dir->i_sem); /* Grab it again because them's the rules */
1230- }
1231- return NULL;
1232+out:
1233+ dentry->d_op = &devfs_dops;
1234+ dentry->d_fsdata = NULL;
1235+ write_lock (&parent->u.dir.lock);
1236+ wake_up (&lookup_info.wait_queue);
1237+ write_unlock (&parent->u.dir.lock);
1238+ devfs_put (de);
1239+ return retval;
1240 } /* End Function devfs_lookup */
1241
1242 static int devfs_unlink (struct inode *dir, struct dentry *dentry)
1243@@ -3011,11 +3012,8 @@
1244 struct inode *inode = dentry->d_inode;
1245 struct fs_info *fs_info = dir->i_sb->u.generic_sbp;
1246
1247-#ifdef CONFIG_DEVFS_DEBUG
1248- if (devfs_debug & DEBUG_I_UNLINK)
1249- printk ("%s: unlink(%s)\n", DEVFS_NAME, dentry->d_name.name);
1250-#endif
1251 de = get_devfs_entry_from_vfs_inode (inode);
1252+ DPRINTK (DEBUG_I_UNLINK, "(%s): de: %p\n", dentry->d_name.name, de);
1253 if (de == NULL) return -ENOENT;
1254 if (!de->vfs_created) return -EPERM;
1255 write_lock (&de->parent->u.dir.lock);
1256@@ -3043,11 +3041,8 @@
1257 if (parent == NULL) return -ENOENT;
1258 err = devfs_do_symlink (parent, dentry->d_name.name, DEVFS_FL_NONE,
1259 symname, &de, NULL);
1260-#ifdef CONFIG_DEVFS_DEBUG
1261- if (devfs_debug & DEBUG_DISABLED)
1262- printk ("%s: symlink(): errcode from <devfs_do_symlink>: %d\n",
1263- DEVFS_NAME, err);
1264-#endif
1265+ DPRINTK (DEBUG_DISABLED, "(%s): errcode from <devfs_do_symlink>: %d\n",
1266+ dentry->d_name.name, err);
1267 if (err < 0) return err;
1268 de->vfs_created = TRUE;
1269 de->inode.uid = current->euid;
1270@@ -3055,13 +3050,10 @@
1271 de->inode.atime = CURRENT_TIME;
1272 de->inode.mtime = CURRENT_TIME;
1273 de->inode.ctime = CURRENT_TIME;
1274- if ( ( inode = get_vfs_inode (dir->i_sb, de, dentry) ) == NULL )
1275+ if ( ( inode = _devfs_get_vfs_inode (dir->i_sb, de, dentry) ) == NULL )
1276 return -ENOMEM;
1277-#ifdef CONFIG_DEVFS_DEBUG
1278- if (devfs_debug & DEBUG_DISABLED)
1279- printk ("%s: symlink(): new VFS inode(%u): %p dentry: %p\n",
1280- DEVFS_NAME, de->inode.ino, inode, dentry);
1281-#endif
1282+ DPRINTK (DEBUG_DISABLED, "(%s): new VFS inode(%u): %p dentry: %p\n",
1283+ dentry->d_name.name, de->inode.ino, inode, dentry);
1284 d_instantiate (dentry, inode);
1285 if ( !is_devfsd_or_child (fs_info) )
1286 devfsd_notify_de (de, DEVFSD_NOTIFY_CREATE, inode->i_mode,
1287@@ -3089,13 +3081,10 @@
1288 de->inode.atime = CURRENT_TIME;
1289 de->inode.mtime = CURRENT_TIME;
1290 de->inode.ctime = CURRENT_TIME;
1291- if ( ( inode = get_vfs_inode (dir->i_sb, de, dentry) ) == NULL )
1292+ if ( ( inode = _devfs_get_vfs_inode (dir->i_sb, de, dentry) ) == NULL )
1293 return -ENOMEM;
1294-#ifdef CONFIG_DEVFS_DEBUG
1295- if (devfs_debug & DEBUG_DISABLED)
1296- printk ("%s: mkdir(): new VFS inode(%u): %p dentry: %p\n",
1297- DEVFS_NAME, de->inode.ino, inode, dentry);
1298-#endif
1299+ DPRINTK (DEBUG_DISABLED, "(%s): new VFS inode(%u): %p dentry: %p\n",
1300+ dentry->d_name.name, de->inode.ino, inode, dentry);
1301 d_instantiate (dentry, inode);
1302 if ( !is_devfsd_or_child (fs_info) )
1303 devfsd_notify_de (de, DEVFSD_NOTIFY_CREATE, inode->i_mode,
1304@@ -3142,11 +3131,8 @@
1305 struct devfs_entry *parent, *de;
1306 struct inode *inode;
1307
1308-#ifdef CONFIG_DEVFS_DEBUG
1309- if (devfs_debug & DEBUG_I_MKNOD)
1310- printk ("%s: mknod(%s): mode: 0%o dev: %d\n",
1311- DEVFS_NAME, dentry->d_name.name, mode, rdev);
1312-#endif
1313+ DPRINTK (DEBUG_I_MKNOD, "(%s): mode: 0%o dev: %d\n",
1314+ dentry->d_name.name, mode, rdev);
1315 parent = get_devfs_entry_from_vfs_inode (dir);
1316 if (parent == NULL) return -ENOENT;
1317 de = _devfs_alloc_entry (dentry->d_name.name, dentry->d_name.len, mode);
1318@@ -3164,13 +3150,10 @@
1319 de->inode.atime = CURRENT_TIME;
1320 de->inode.mtime = CURRENT_TIME;
1321 de->inode.ctime = CURRENT_TIME;
1322- if ( ( inode = get_vfs_inode (dir->i_sb, de, dentry) ) == NULL )
1323+ if ( ( inode = _devfs_get_vfs_inode (dir->i_sb, de, dentry) ) == NULL )
1324 return -ENOMEM;
1325-#ifdef CONFIG_DEVFS_DEBUG
1326- if (devfs_debug & DEBUG_I_MKNOD)
1327- printk ("%s: new VFS inode(%u): %p dentry: %p\n",
1328- DEVFS_NAME, de->inode.ino, inode, dentry);
1329-#endif
1330+ DPRINTK (DEBUG_I_MKNOD, ": new VFS inode(%u): %p dentry: %p\n",
1331+ de->inode.ino, inode, dentry);
1332 d_instantiate (dentry, inode);
1333 if ( !is_devfsd_or_child (fs_info) )
1334 devfsd_notify_de (de, DEVFSD_NOTIFY_CREATE, inode->i_mode,
1335@@ -3238,15 +3221,11 @@
1336 sb->s_blocksize_bits = 10;
1337 sb->s_magic = DEVFS_SUPER_MAGIC;
1338 sb->s_op = &devfs_sops;
1339- if ( ( root_inode = get_vfs_inode (sb, root_entry, NULL) ) == NULL )
1340+ if ( ( root_inode = _devfs_get_vfs_inode (sb, root_entry, NULL) ) == NULL )
1341 goto out_no_root;
1342 sb->s_root = d_alloc_root (root_inode);
1343 if (!sb->s_root) goto out_no_root;
1344-#ifdef CONFIG_DEVFS_DEBUG
1345- if (devfs_debug & DEBUG_S_READ)
1346- printk ("%s: read super, made devfs ptr: %p\n",
1347- DEVFS_NAME, sb->u.generic_sbp);
1348-#endif
1349+ DPRINTK (DEBUG_S_READ, "(): made devfs ptr: %p\n", sb->u.generic_sbp);
1350 return sb;
1351
1352 out_no_root:
1353@@ -3479,6 +3458,10 @@
1354
1355 printk ("%s: v%s Richard Gooch (rgooch@atnf.csiro.au)\n",
1356 DEVFS_NAME, DEVFS_VERSION);
1357+ devfsd_buf_cache = kmem_cache_create ("devfsd_event",
1358+ sizeof (struct devfsd_buf_entry),
1359+ 0, 0, NULL, NULL);
1360+ if (!devfsd_buf_cache) OOPS ("(): unable to allocate event slab\n");
1361 #ifdef CONFIG_DEVFS_DEBUG
1362 devfs_debug = devfs_debug_init;
1363 printk ("%s: devfs_debug: 0x%0x\n", DEVFS_NAME, devfs_debug);
1364@@ -3498,9 +3481,6 @@
1365 {
1366 int err;
1367
1368- devfsd_buf_cache = kmem_cache_create ("devfsd_event",
1369- sizeof (struct devfsd_buf_entry),
1370- 0, 0, NULL, NULL);
1371 if ( !(boot_options & OPTION_MOUNT) ) return;
1372 err = do_mount ("none", "/dev", "devfs", 0, "");
1373 if (err == 0) printk ("Mounted devfs on /dev\n");
1374diff -urN linux-2.4.18-pre3/fs/super.c linux/fs/super.c
1375--- linux-2.4.18-pre3/fs/super.c Fri Dec 21 10:42:03 2001
1376+++ linux/fs/super.c Sun Jan 13 18:53:59 2002
1377@@ -1056,6 +1056,7 @@
1378 putname(fs_names);
1379 if (path_start >= 0) {
1380 name = path + path_start;
1381+ devfs_unregister (devfs_find_handle(NULL, "root", 0, 0, 0, 0));
1382 devfs_mk_symlink (NULL, "root", DEVFS_FL_DEFAULT,
1383 name + 5, NULL, NULL);
1384 memcpy (name, "/dev/", 5);
The Linux kernel (the core of the Linux operating system)
This page took 0.327755 seconds and 4 git commands to generate.