linux-2.4.17-devfs-v199.7.patch

   1 diff -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>
  33 diff -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
 104 diff -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;
 155 diff -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);
 193 diff -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");
1374 diff -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);