fs/devfs/base.c

   1 /*  devfs (Device FileSystem) driver.
   2
   3     Copyright (C) 1998-2002  Richard Gooch
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Library General Public
   7     License as published by the Free Software Foundation; either
   8     version 2 of the License, or (at your option) any later version.
   9
  10     This library is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13     Library General Public License for more details.
  14
  15     You should have received a copy of the GNU Library General Public
  16     License along with this library; if not, write to the Free
  17     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19     Richard Gooch may be reached by email at  rgooch@atnf.csiro.au
  20     The postal address is:
  21       Richard Gooch, c/o ATNF, P. O. Box 76, Epping, N.S.W., 2121, Australia.
  22
  23     ChangeLog
  24
  25     19980110   Richard Gooch <rgooch@atnf.csiro.au>
  26                Original version.
  27   v0.1
  28     19980111   Richard Gooch <rgooch@atnf.csiro.au>
  29                Created per-fs inode table rather than using inode->u.generic_ip
  30   v0.2
  31     19980111   Richard Gooch <rgooch@atnf.csiro.au>
  32                Created .epoch inode which has a ctime of 0.
  33                Fixed loss of named pipes when dentries lost.
  34                Fixed loss of inode data when devfs_register() follows mknod().
  35   v0.3
  36     19980111   Richard Gooch <rgooch@atnf.csiro.au>
  37                Fix for when compiling with CONFIG_KERNELD.
  38     19980112   Richard Gooch <rgooch@atnf.csiro.au>
  39                Fix for readdir() which sometimes didn't show entries.
  40                Added <<tolerant>> option to <devfs_register>.
  41   v0.4
  42     19980113   Richard Gooch <rgooch@atnf.csiro.au>
  43                Created <devfs_fill_file> function.
  44   v0.5
  45     19980115   Richard Gooch <rgooch@atnf.csiro.au>
  46                Added subdirectory support. Major restructuring.
  47     19980116   Richard Gooch <rgooch@atnf.csiro.au>
  48                Fixed <find_by_dev> to not search major=0,minor=0.
  49                Added symlink support.
  50   v0.6
  51     19980120   Richard Gooch <rgooch@atnf.csiro.au>
  52                Created <devfs_mk_dir> function and support directory unregister
  53     19980120   Richard Gooch <rgooch@atnf.csiro.au>
  54                Auto-ownership uses real uid/gid rather than effective uid/gid.
  55   v0.7
  56     19980121   Richard Gooch <rgooch@atnf.csiro.au>
  57                Supported creation of sockets.
  58   v0.8
  59     19980122   Richard Gooch <rgooch@atnf.csiro.au>
  60                Added DEVFS_FL_HIDE_UNREG flag.
  61                Interface change to <devfs_mk_symlink>.
  62                Created <devfs_symlink> to support symlink(2).
  63   v0.9
  64     19980123   Richard Gooch <rgooch@atnf.csiro.au>
  65                Added check to <devfs_fill_file> to check inode is in devfs.
  66                Added optional traversal of symlinks.
  67   v0.10
  68     19980124   Richard Gooch <rgooch@atnf.csiro.au>
  69                Created <devfs_get_flags> and <devfs_set_flags>.
  70   v0.11
  71     19980125   C. Scott Ananian <cananian@alumni.princeton.edu>
  72                Created <devfs_find_handle>.
  73     19980125   Richard Gooch <rgooch@atnf.csiro.au>
  74                Allow removal of symlinks.
  75   v0.12
  76     19980125   Richard Gooch <rgooch@atnf.csiro.au>
  77                Created <devfs_set_symlink_destination>.
  78     19980126   Richard Gooch <rgooch@atnf.csiro.au>
  79                Moved DEVFS_SUPER_MAGIC into header file.
  80                Added DEVFS_FL_HIDE flag.
  81                Created <devfs_get_maj_min>.
  82                Created <devfs_get_handle_from_inode>.
  83                Fixed minor bug in <find_by_dev>.
  84     19980127   Richard Gooch <rgooch@atnf.csiro.au>
  85                Changed interface to <find_by_dev>, <find_entry>,
  86                <devfs_unregister>, <devfs_fill_file> and <devfs_find_handle>.
  87                Fixed inode times when symlink created with symlink(2).
  88   v0.13
  89     19980129   C. Scott Ananian <cananian@alumni.princeton.edu>
  90                Exported <devfs_set_symlink_destination>, <devfs_get_maj_min>
  91                and <devfs_get_handle_from_inode>.
  92     19980129   Richard Gooch <rgooch@atnf.csiro.au>
  93                Created <devfs_unlink> to support unlink(2).
  94   v0.14
  95     19980129   Richard Gooch <rgooch@atnf.csiro.au>
  96                Fixed kerneld support for entries in devfs subdirectories.
  97     19980130   Richard Gooch <rgooch@atnf.csiro.au>
  98                Bugfixes in <call_kerneld>.
  99   v0.15
 100     19980207   Richard Gooch <rgooch@atnf.csiro.au>
 101                Call kerneld when looking up unregistered entries.
 102   v0.16
 103     19980326   Richard Gooch <rgooch@atnf.csiro.au>
 104                Modified interface to <devfs_find_handle> for symlink traversal.
 105   v0.17
 106     19980331   Richard Gooch <rgooch@atnf.csiro.au>
 107                Fixed persistence bug with device numbers for manually created
 108                device files.
 109                Fixed problem with recreating symlinks with different content.
 110   v0.18
 111     19980401   Richard Gooch <rgooch@atnf.csiro.au>
 112                Changed to CONFIG_KMOD.
 113                Hide entries which are manually unlinked.
 114                Always invalidate devfs dentry cache when registering entries.
 115                Created <devfs_rmdir> to support rmdir(2).
 116                Ensure directories created by <devfs_mk_dir> are visible.
 117   v0.19
 118     19980402   Richard Gooch <rgooch@atnf.csiro.au>
 119                Invalidate devfs dentry cache when making directories.
 120                Invalidate devfs dentry cache when removing entries.
 121                Fixed persistence bug with fifos.
 122   v0.20
 123     19980421   Richard Gooch <rgooch@atnf.csiro.au>
 124                Print process command when debugging kerneld/kmod.
 125                Added debugging for register/unregister/change operations.
 126     19980422   Richard Gooch <rgooch@atnf.csiro.au>
 127                Added "devfs=" boot options.
 128   v0.21
 129     19980426   Richard Gooch <rgooch@atnf.csiro.au>
 130                No longer lock/unlock superblock in <devfs_put_super>.
 131                Drop negative dentries when they are released.
 132                Manage dcache more efficiently.
 133   v0.22
 134     19980427   Richard Gooch <rgooch@atnf.csiro.au>
 135                Added DEVFS_FL_AUTO_DEVNUM flag.
 136   v0.23
 137     19980430   Richard Gooch <rgooch@atnf.csiro.au>
 138                No longer set unnecessary methods.
 139   v0.24
 140     19980504   Richard Gooch <rgooch@atnf.csiro.au>
 141                Added PID display to <call_kerneld> debugging message.
 142                Added "after" debugging message to <call_kerneld>.
 143     19980519   Richard Gooch <rgooch@atnf.csiro.au>
 144                Added "diread" and "diwrite" boot options.
 145     19980520   Richard Gooch <rgooch@atnf.csiro.au>
 146                Fixed persistence problem with permissions.
 147   v0.25
 148     19980602   Richard Gooch <rgooch@atnf.csiro.au>
 149                Support legacy device nodes.
 150                Fixed bug where recreated inodes were hidden.
 151   v0.26
 152     19980602   Richard Gooch <rgooch@atnf.csiro.au>
 153                Improved debugging in <get_vfs_inode>.
 154     19980607   Richard Gooch <rgooch@atnf.csiro.au>
 155                No longer free old dentries in <devfs_mk_dir>.
 156                Free all dentries for a given entry when deleting inodes.
 157   v0.27
 158     19980627   Richard Gooch <rgooch@atnf.csiro.au>
 159                Limit auto-device numbering to majors 128 to 239.
 160   v0.28
 161     19980629   Richard Gooch <rgooch@atnf.csiro.au>
 162                Fixed inode times persistence problem.
 163   v0.29
 164     19980704   Richard Gooch <rgooch@atnf.csiro.au>
 165                Fixed spelling in <devfs_readlink> debug.
 166                Fixed bug in <devfs_setup> parsing "dilookup".
 167   v0.30
 168     19980705   Richard Gooch <rgooch@atnf.csiro.au>
 169                Fixed devfs inode leak when manually recreating inodes.
 170                Fixed permission persistence problem when recreating inodes.
 171   v0.31
 172     19980727   Richard Gooch <rgooch@atnf.csiro.au>
 173                Removed harmless "unused variable" compiler warning.
 174                Fixed modes for manually recreated device nodes.
 175   v0.32
 176     19980728   Richard Gooch <rgooch@atnf.csiro.au>
 177                Added NULL devfs inode warning in <devfs_read_inode>.
 178                Force all inode nlink values to 1.
 179   v0.33
 180     19980730   Richard Gooch <rgooch@atnf.csiro.au>
 181                Added "dimknod" boot option.
 182                Set inode nlink to 0 when freeing dentries.
 183                Fixed modes for manually recreated symlinks.
 184   v0.34
 185     19980802   Richard Gooch <rgooch@atnf.csiro.au>
 186                Fixed bugs in recreated directories and symlinks.
 187   v0.35
 188     19980806   Richard Gooch <rgooch@atnf.csiro.au>
 189                Fixed bugs in recreated device nodes.
 190     19980807   Richard Gooch <rgooch@atnf.csiro.au>
 191                Fixed bug in currently unused <devfs_get_handle_from_inode>.
 192                Defined new <devfs_handle_t> type.
 193                Improved debugging when getting entries.
 194                Fixed bug where directories could be emptied.
 195   v0.36
 196     19980809   Richard Gooch <rgooch@atnf.csiro.au>
 197                Replaced dummy .epoch inode with .devfsd character device.
 198     19980810   Richard Gooch <rgooch@atnf.csiro.au>
 199                Implemented devfsd protocol revision 0.
 200   v0.37
 201     19980819   Richard Gooch <rgooch@atnf.csiro.au>
 202                Added soothing message to warning in <devfs_d_iput>.
 203   v0.38
 204     19980829   Richard Gooch <rgooch@atnf.csiro.au>
 205                Use GCC extensions for structure initialisations.
 206                Implemented async open notification.
 207                Incremented devfsd protocol revision to 1.
 208   v0.39
 209     19980908   Richard Gooch <rgooch@atnf.csiro.au>
 210                Moved async open notification to end of <devfs_open>.
 211   v0.40
 212     19980910   Richard Gooch <rgooch@atnf.csiro.au>
 213                Prepended "/dev/" to module load request.
 214                Renamed <call_kerneld> to <call_kmod>.
 215   v0.41
 216     19980910   Richard Gooch <rgooch@atnf.csiro.au>
 217                Fixed typo "AYSNC" -> "ASYNC".
 218   v0.42
 219     19980910   Richard Gooch <rgooch@atnf.csiro.au>
 220                Added open flag for files.
 221   v0.43
 222     19980927   Richard Gooch <rgooch@atnf.csiro.au>
 223                Set i_blocks=0 and i_blksize=1024 in <devfs_read_inode>.
 224   v0.44
 225     19981005   Richard Gooch <rgooch@atnf.csiro.au>
 226                Added test for empty <<name>> in <devfs_find_handle>.
 227                Renamed <generate_path> to <devfs_generate_path> and published.
 228   v0.45
 229     19981006   Richard Gooch <rgooch@atnf.csiro.au>
 230                Created <devfs_get_fops>.
 231   v0.46
 232     19981007   Richard Gooch <rgooch@atnf.csiro.au>
 233                Limit auto-device numbering to majors 144 to 239.
 234   v0.47
 235     19981010   Richard Gooch <rgooch@atnf.csiro.au>
 236                Updated <devfs_follow_link> for VFS change in 2.1.125.
 237   v0.48
 238     19981022   Richard Gooch <rgooch@atnf.csiro.au>
 239                Created DEVFS_ FL_COMPAT flag.
 240   v0.49
 241     19981023   Richard Gooch <rgooch@atnf.csiro.au>
 242                Created "nocompat" boot option.
 243   v0.50
 244     19981025   Richard Gooch <rgooch@atnf.csiro.au>
 245                Replaced "mount" boot option with "nomount".
 246   v0.51
 247     19981110   Richard Gooch <rgooch@atnf.csiro.au>
 248                Created "only" boot option.
 249   v0.52
 250     19981112   Richard Gooch <rgooch@atnf.csiro.au>
 251                Added DEVFS_FL_REMOVABLE flag.
 252   v0.53
 253     19981114   Richard Gooch <rgooch@atnf.csiro.au>
 254                Only call <scan_dir_for_removable> on first call to
 255                <devfs_readdir>.
 256   v0.54
 257     19981205   Richard Gooch <rgooch@atnf.csiro.au>
 258                Updated <devfs_rmdir> for VFS change in 2.1.131.
 259   v0.55
 260     19981218   Richard Gooch <rgooch@atnf.csiro.au>
 261                Created <devfs_mk_compat>.
 262     19981220   Richard Gooch <rgooch@atnf.csiro.au>
 263                Check for partitions on removable media in <devfs_lookup>.
 264   v0.56
 265     19990118   Richard Gooch <rgooch@atnf.csiro.au>
 266                Added support for registering regular files.
 267                Created <devfs_set_file_size>.
 268                Update devfs inodes from entries if not changed through FS.
 269   v0.57
 270     19990124   Richard Gooch <rgooch@atnf.csiro.au>
 271                Fixed <devfs_fill_file> to only initialise temporary inodes.
 272                Trap for NULL fops in <devfs_register>.
 273                Return -ENODEV in <devfs_fill_file> for non-driver inodes.
 274   v0.58
 275     19990126   Richard Gooch <rgooch@atnf.csiro.au>
 276                Switched from PATH_MAX to DEVFS_PATHLEN.
 277   v0.59
 278     19990127   Richard Gooch <rgooch@atnf.csiro.au>
 279                Created "nottycompat" boot option.
 280   v0.60
 281     19990318   Richard Gooch <rgooch@atnf.csiro.au>
 282                Fixed <devfsd_read> to not overrun event buffer.
 283   v0.61
 284     19990329   Richard Gooch <rgooch@atnf.csiro.au>
 285                Created <devfs_auto_unregister>.
 286   v0.62
 287     19990330   Richard Gooch <rgooch@atnf.csiro.au>
 288                Don't return unregistred entries in <devfs_find_handle>.
 289                Panic in <devfs_unregister> if entry unregistered.
 290     19990401   Richard Gooch <rgooch@atnf.csiro.au>
 291                Don't panic in <devfs_auto_unregister> for duplicates.
 292   v0.63
 293     19990402   Richard Gooch <rgooch@atnf.csiro.au>
 294                Don't unregister already unregistered entries in <unregister>.
 295   v0.64
 296     19990510   Richard Gooch <rgooch@atnf.csiro.au>
 297                Disable warning messages when unable to read partition table for
 298                removable media.
 299   v0.65
 300     19990512   Richard Gooch <rgooch@atnf.csiro.au>
 301                Updated <devfs_lookup> for VFS change in 2.3.1-pre1.
 302                Created "oops-on-panic" boot option.
 303                Improved debugging in <devfs_register> and <devfs_unregister>.
 304   v0.66
 305     19990519   Richard Gooch <rgooch@atnf.csiro.au>
 306                Added documentation for some functions.
 307     19990525   Richard Gooch <rgooch@atnf.csiro.au>
 308                Removed "oops-on-panic" boot option: now always Oops.
 309   v0.67
 310     19990531   Richard Gooch <rgooch@atnf.csiro.au>
 311                Improved debugging in <devfs_register>.
 312   v0.68
 313     19990604   Richard Gooch <rgooch@atnf.csiro.au>
 314                Added "diunlink" and "nokmod" boot options.
 315                Removed superfluous warning message in <devfs_d_iput>.
 316   v0.69
 317     19990611   Richard Gooch <rgooch@atnf.csiro.au>
 318                Took account of change to <d_alloc_root>.
 319   v0.70
 320     19990614   Richard Gooch <rgooch@atnf.csiro.au>
 321                Created separate event queue for each mounted devfs.
 322                Removed <devfs_invalidate_dcache>.
 323                Created new ioctl()s.
 324                Incremented devfsd protocol revision to 3.
 325                Fixed bug when re-creating directories: contents were lost.
 326                Block access to inodes until devfsd updates permissions.
 327     19990615   Richard Gooch <rgooch@atnf.csiro.au>
 328                Support 2.2.x kernels.
 329   v0.71
 330     19990623   Richard Gooch <rgooch@atnf.csiro.au>
 331                Switched to sending process uid/gid to devfsd.
 332                Renamed <call_kmod> to <try_modload>.
 333                Added DEVFSD_NOTIFY_LOOKUP event.
 334     19990624   Richard Gooch <rgooch@atnf.csiro.au>
 335                Added DEVFSD_NOTIFY_CHANGE event.
 336                Incremented devfsd protocol revision to 4.
 337   v0.72
 338     19990713   Richard Gooch <rgooch@atnf.csiro.au>
 339                Return EISDIR rather than EINVAL for read(2) on directories.
 340   v0.73
 341     19990809   Richard Gooch <rgooch@atnf.csiro.au>
 342                Changed <devfs_setup> to new __init scheme.
 343   v0.74
 344     19990901   Richard Gooch <rgooch@atnf.csiro.au>
 345                Changed remaining function declarations to new __init scheme.
 346   v0.75
 347     19991013   Richard Gooch <rgooch@atnf.csiro.au>
 348                Created <devfs_get_info>, <devfs_set_info>,
 349                <devfs_get_first_child> and <devfs_get_next_sibling>.
 350                Added <<dir>> parameter to <devfs_register>, <devfs_mk_compat>,
 351                <devfs_mk_dir> and <devfs_find_handle>.
 352                Work sponsored by SGI.
 353   v0.76
 354     19991017   Richard Gooch <rgooch@atnf.csiro.au>
 355                Allow multiple unregistrations.
 356                Work sponsored by SGI.
 357   v0.77
 358     19991026   Richard Gooch <rgooch@atnf.csiro.au>
 359                Added major and minor number to devfsd protocol.
 360                Incremented devfsd protocol revision to 5.
 361                Work sponsored by SGI.
 362   v0.78
 363     19991030   Richard Gooch <rgooch@atnf.csiro.au>
 364                Support info pointer for all devfs entry types.
 365                Added <<info>> parameter to <devfs_mk_dir> and
 366                <devfs_mk_symlink>.
 367                Work sponsored by SGI.
 368   v0.79
 369     19991031   Richard Gooch <rgooch@atnf.csiro.au>
 370                Support "../" when searching devfs namespace.
 371                Work sponsored by SGI.
 372   v0.80
 373     19991101   Richard Gooch <rgooch@atnf.csiro.au>
 374                Created <devfs_get_unregister_slave>.
 375                Work sponsored by SGI.
 376   v0.81
 377     19991103   Richard Gooch <rgooch@atnf.csiro.au>
 378                Exported <devfs_get_parent>.
 379                Work sponsored by SGI.
 380   v0.82
 381     19991104   Richard Gooch <rgooch@atnf.csiro.au>
 382                Removed unused <devfs_set_symlink_destination>.
 383     19991105   Richard Gooch <rgooch@atnf.csiro.au>
 384                Do not hide entries from devfsd or children.
 385                Removed DEVFS_ FL_TTY_COMPAT flag.
 386                Removed "nottycompat" boot option.
 387                Removed <devfs_mk_compat>.
 388                Work sponsored by SGI.
 389   v0.83
 390     19991107   Richard Gooch <rgooch@atnf.csiro.au>
 391                Added DEVFS_FL_WAIT flag.
 392                Work sponsored by SGI.
 393   v0.84
 394     19991107   Richard Gooch <rgooch@atnf.csiro.au>
 395                Support new "disc" naming scheme in <get_removable_partition>.
 396                Allow NULL fops in <devfs_register>.
 397                Work sponsored by SGI.
 398   v0.85
 399     19991110   Richard Gooch <rgooch@atnf.csiro.au>
 400                Fall back to major table if NULL fops given to <devfs_register>.
 401                Work sponsored by SGI.
 402   v0.86
 403     19991204   Richard Gooch <rgooch@atnf.csiro.au>
 404                Support fifos when unregistering.
 405                Work sponsored by SGI.
 406   v0.87
 407     19991209   Richard Gooch <rgooch@atnf.csiro.au>
 408                Removed obsolete DEVFS_ FL_COMPAT and DEVFS_ FL_TOLERANT flags.
 409                Work sponsored by SGI.
 410   v0.88
 411     19991214   Richard Gooch <rgooch@atnf.csiro.au>
 412                Removed kmod support.
 413                Work sponsored by SGI.
 414   v0.89
 415     19991216   Richard Gooch <rgooch@atnf.csiro.au>
 416                Improved debugging in <get_vfs_inode>.
 417                Ensure dentries created by devfsd will be cleaned up.
 418                Work sponsored by SGI.
 419   v0.90
 420     19991223   Richard Gooch <rgooch@atnf.csiro.au>
 421                Created <devfs_get_name>.
 422                Work sponsored by SGI.
 423   v0.91
 424     20000203   Richard Gooch <rgooch@atnf.csiro.au>
 425                Ported to kernel 2.3.42.
 426                Removed <devfs_fill_file>.
 427                Work sponsored by SGI.
 428   v0.92
 429     20000306   Richard Gooch <rgooch@atnf.csiro.au>
 430                Added DEVFS_ FL_NO_PERSISTENCE flag.
 431                Removed unnecessary call to <update_devfs_inode_from_entry> in
 432                <devfs_readdir>.
 433                Work sponsored by SGI.
 434   v0.93
 435     20000413   Richard Gooch <rgooch@atnf.csiro.au>
 436                Set inode->i_size to correct size for symlinks.
 437     20000414   Richard Gooch <rgooch@atnf.csiro.au>
 438                Only give lookup() method to directories to comply with new VFS
 439                assumptions.
 440                Work sponsored by SGI.
 441     20000415   Richard Gooch <rgooch@atnf.csiro.au>
 442                Remove unnecessary tests in symlink methods.
 443                Don't kill existing block ops in <devfs_read_inode>.
 444                Work sponsored by SGI.
 445   v0.94
 446     20000424   Richard Gooch <rgooch@atnf.csiro.au>
 447                Don't create missing directories in <devfs_find_handle>.
 448                Work sponsored by SGI.
 449   v0.95
 450     20000430   Richard Gooch <rgooch@atnf.csiro.au>
 451                Added CONFIG_DEVFS_MOUNT.
 452                Work sponsored by SGI.
 453   v0.96
 454     20000608   Richard Gooch <rgooch@atnf.csiro.au>
 455                Disabled multi-mount capability (use VFS bindings instead).
 456                Work sponsored by SGI.
 457   v0.97
 458     20000610   Richard Gooch <rgooch@atnf.csiro.au>
 459                Switched to FS_SINGLE to disable multi-mounts.
 460     20000612   Richard Gooch <rgooch@atnf.csiro.au>
 461                Removed module support.
 462                Removed multi-mount code.
 463                Removed compatibility macros: VFS has changed too much.
 464                Work sponsored by SGI.
 465   v0.98
 466     20000614   Richard Gooch <rgooch@atnf.csiro.au>
 467                Merged devfs inode into devfs entry.
 468                Work sponsored by SGI.
 469   v0.99
 470     20000619   Richard Gooch <rgooch@atnf.csiro.au>
 471                Removed dead code in <devfs_register> which used to call
 472                <free_dentries>.
 473                Work sponsored by SGI.
 474   v0.100
 475     20000621   Richard Gooch <rgooch@atnf.csiro.au>
 476                Changed interface to <devfs_register>.
 477                Work sponsored by SGI.
 478   v0.101
 479     20000622   Richard Gooch <rgooch@atnf.csiro.au>
 480                Simplified interface to <devfs_mk_symlink> and <devfs_mk_dir>.
 481                Simplified interface to <devfs_find_handle>.
 482                Work sponsored by SGI.
 483   v0.102
 484     20010519   Richard Gooch <rgooch@atnf.csiro.au>
 485                Ensure <devfs_generate_path> terminates string for root entry.
 486                Exported <devfs_get_name> to modules.
 487     20010520   Richard Gooch <rgooch@atnf.csiro.au>
 488                Make <devfs_mk_symlink> send events to devfsd.
 489                Cleaned up option processing in <devfs_setup>.
 490     20010521   Richard Gooch <rgooch@atnf.csiro.au>
 491                Fixed bugs in handling symlinks: could leak or cause Oops.
 492     20010522   Richard Gooch <rgooch@atnf.csiro.au>
 493                Cleaned up directory handling by separating fops.
 494   v0.103
 495     20010601   Richard Gooch <rgooch@atnf.csiro.au>
 496                Fixed handling of inverted options in <devfs_setup>.
 497   v0.104
 498     20010604   Richard Gooch <rgooch@atnf.csiro.au>
 499                Adjusted <try_modload> to account for <devfs_generate_path> fix.
 500   v0.105
 501     20010617   Richard Gooch <rgooch@atnf.csiro.au>
 502                Answered question posed by Al Viro and removed his comments.
 503                Moved setting of registered flag after other fields are changed.
 504                Fixed race between <devfsd_close> and <devfsd_notify_one>.
 505                Global VFS changes added bogus BKL to <devfsd_close>: removed.
 506                Widened locking in <devfs_readlink> and <devfs_follow_link>.
 507                Replaced <devfsd_read> stack usage with <devfsd_ioctl> kmalloc.
 508                Simplified locking in <devfsd_ioctl> and fixed memory leak.
 509   v0.106
 510     20010709   Richard Gooch <rgooch@atnf.csiro.au>
 511                Removed broken devnum allocation and use <devfs_alloc_devnum>.
 512                Fixed old devnum leak by calling new <devfs_dealloc_devnum>.
 513   v0.107
 514     20010712   Richard Gooch <rgooch@atnf.csiro.au>
 515                Fixed bug in <devfs_setup> which could hang boot process.
 516   v0.108
 517     20010730   Richard Gooch <rgooch@atnf.csiro.au>
 518                Added DEVFSD_NOTIFY_DELETE event.
 519     20010801   Richard Gooch <rgooch@atnf.csiro.au>
 520                Removed #include <asm/segment.h>.
 521   v0.109
 522     20010807   Richard Gooch <rgooch@atnf.csiro.au>
 523                Fixed inode table races by removing it and using
 524                inode->u.generic_ip instead.
 525                Moved <devfs_read_inode> into <get_vfs_inode>.
 526                Moved <devfs_write_inode> into <devfs_notify_change>.
 527   v0.110
 528     20010808   Richard Gooch <rgooch@atnf.csiro.au>
 529                Fixed race in <devfs_do_symlink> for uni-processor.
 530   v0.111
 531     20010818   Richard Gooch <rgooch@atnf.csiro.au>
 532                Removed remnant of multi-mount support in <devfs_mknod>.
 533                Removed unused DEVFS_FL_SHOW_UNREG flag.
 534   v0.112
 535     20010820   Richard Gooch <rgooch@atnf.csiro.au>
 536                Removed nlink field from struct devfs_inode.
 537   v0.113
 538     20010823   Richard Gooch <rgooch@atnf.csiro.au>
 539                Replaced BKL with global rwsem to protect symlink data (quick
 540                and dirty hack).
 541   v0.114
 542     20010827   Richard Gooch <rgooch@atnf.csiro.au>
 543                Replaced global rwsem for symlink with per-link refcount.
 544   v0.115
 545     20010919   Richard Gooch <rgooch@atnf.csiro.au>
 546                Set inode->i_mapping->a_ops for block nodes in <get_vfs_inode>.
 547   v0.116
 548     20011008   Richard Gooch <rgooch@atnf.csiro.au>
 549                Fixed overrun in <devfs_link> by removing function (not needed).
 550     20011009   Richard Gooch <rgooch@atnf.csiro.au>
 551                Fixed buffer underrun in <try_modload>.
 552     20011029   Richard Gooch <rgooch@atnf.csiro.au>
 553                Fixed race in <devfsd_ioctl> when setting event mask.
 554     20011114   Richard Gooch <rgooch@atnf.csiro.au>
 555                First release of new locking code.
 556   v1.0
 557     20011117   Richard Gooch <rgooch@atnf.csiro.au>
 558                Discard temporary buffer, now use "%s" for dentry names.
 559     20011118   Richard Gooch <rgooch@atnf.csiro.au>
 560                Don't generate path in <try_modload>: use fake entry instead.
 561                Use "existing" directory in <_devfs_make_parent_for_leaf>.
 562     20011122   Richard Gooch <rgooch@atnf.csiro.au>
 563                Use slab cache rather than fixed buffer for devfsd events.
 564   v1.1
 565     20011125   Richard Gooch <rgooch@atnf.csiro.au>
 566                Send DEVFSD_NOTIFY_REGISTERED events in <devfs_mk_dir>.
 567     20011127   Richard Gooch <rgooch@atnf.csiro.au>
 568                Fixed locking bug in <devfs_d_revalidate_wait> due to typo.
 569                Do not send CREATE, CHANGE, ASYNC_OPEN or DELETE events from
 570                devfsd or children.
 571   v1.2
 572     20011202   Richard Gooch <rgooch@atnf.csiro.au>
 573                Fixed bug in <devfsd_read>: was dereferencing freed pointer.
 574   v1.3
 575     20011203   Richard Gooch <rgooch@atnf.csiro.au>
 576                Fixed bug in <devfsd_close>: was dereferencing freed pointer.
 577                Added process group check for devfsd privileges.
 578   v1.4
 579     20011204   Richard Gooch <rgooch@atnf.csiro.au>
 580                Use SLAB_ATOMIC in <devfsd_notify_de> from <devfs_d_delete>.
 581   v1.5
 582     20011211   Richard Gooch <rgooch@atnf.csiro.au>
 583                Return old entry in <devfs_mk_dir> for 2.4.x kernels.
 584     20011212   Richard Gooch <rgooch@atnf.csiro.au>
 585                Increment refcount on module in <check_disc_changed>.
 586     20011215   Richard Gooch <rgooch@atnf.csiro.au>
 587                Created <devfs_get_handle> and exported <devfs_put>.
 588                Increment refcount on module in <devfs_get_ops>.
 589                Created <devfs_put_ops>.
 590   v1.6
 591     20011216   Richard Gooch <rgooch@atnf.csiro.au>
 592                Added poisoning to <devfs_put>.
 593                Improved debugging messages.
 594   v1.7
 595     20011221   Richard Gooch <rgooch@atnf.csiro.au>
 596                Corrected (made useful) debugging message in <unregister>.
 597                Moved <kmem_cache_create> in <mount_devfs_fs> to <init_devfs_fs>
 598     20011224   Richard Gooch <rgooch@atnf.csiro.au>
 599                Added magic number to guard against scribbling drivers.
 600     20011226   Richard Gooch <rgooch@atnf.csiro.au>
 601                Only return old entry in <devfs_mk_dir> if a directory.
 602                Defined macros for error and debug messages.
 603   v1.8
 604     20020113   Richard Gooch <rgooch@atnf.csiro.au>
 605                Fixed (rare, old) race in <devfs_lookup>.
 606   v1.9
 607     20020120   Richard Gooch <rgooch@atnf.csiro.au>
 608                Fixed deadlock bug in <devfs_d_revalidate_wait>.
 609                Tag VFS deletable in <devfs_mk_symlink> if handle ignored.
 610   v1.10
 611     20020129   Richard Gooch <rgooch@atnf.csiro.au>
 612                Added KERN_* to remaining messages.
 613                Cleaned up declaration of <stat_read>.
 614   v1.11
 615     20020219   Richard Gooch <rgooch@atnf.csiro.au>
 616                Changed <devfs_rmdir> to allow later additions if not yet empty.
 617   v1.12
 618     20020406   Richard Gooch <rgooch@atnf.csiro.au>
 619                Removed silently introduced calls to lock_kernel() and
 620                unlock_kernel() due to recent VFS locking changes. BKL isn't
 621                required in devfs.
 622   v1.13
 623     20020428   Richard Gooch <rgooch@atnf.csiro.au>
 624                Removed 2.4.x compatibility code.
 625   v1.14
 626     20020510   Richard Gooch <rgooch@atnf.csiro.au>
 627                Added BKL to <devfs_open> because drivers still need it.
 628   v1.15
 629     20020512   Richard Gooch <rgooch@atnf.csiro.au>
 630                Protected <scan_dir_for_removable> and <get_removable_partition>
 631                from changing directory contents.
 632   v1.16
 633     20020514   Richard Gooch <rgooch@atnf.csiro.au>
 634                Minor cleanup of <scan_dir_for_removable>.
 635   v1.17
 636     20020721   Richard Gooch <rgooch@atnf.csiro.au>
 637                Switched to ISO C structure field initialisers.
 638                Switch to set_current_state() and move before add_wait_queue().
 639     20020722   Richard Gooch <rgooch@atnf.csiro.au>
 640                Fixed devfs entry leak in <devfs_readdir> when *readdir fails.
 641   v1.18
 642     20020725   Richard Gooch <rgooch@atnf.csiro.au>
 643                Created <devfs_find_and_unregister>.
 644   v1.19
 645     20020728   Richard Gooch <rgooch@atnf.csiro.au>
 646                Removed deprecated <devfs_find_handle>.
 647   v1.20
 648     20020820   Richard Gooch <rgooch@atnf.csiro.au>
 649                Fixed module unload race in <devfs_open>.
 650   v1.21
 651     20021013   Richard Gooch <rgooch@atnf.csiro.au>
 652                Removed DEVFS_ FL_AUTO_OWNER.
 653                Switched lingering structure field initialiser to ISO C.
 654                Added locking when updating FCB flags.
 655   v1.22
 656 */
 657 #include <linux/types.h>
 658 #include <linux/errno.h>
 659 #include <linux/time.h>
 660 #include <linux/tty.h>
 661 #include <linux/timer.h>
 662 #include <linux/config.h>
 663 #include <linux/kernel.h>
 664 #include <linux/wait.h>
 665 #include <linux/string.h>
 666 #include <linux/slab.h>
 667 #include <linux/ioport.h>
 668 #include <linux/delay.h>
 669 #include <linux/ctype.h>
 670 #include <linux/mm.h>
 671 #include <linux/module.h>
 672 #include <linux/init.h>
 673 #include <linux/devfs_fs.h>
 674 #include <linux/devfs_fs_kernel.h>
 675 #include <linux/smp_lock.h>
 676 #include <linux/smp.h>
 677 #include <linux/rwsem.h>
 678 #include <linux/sched.h>
 679 #include <linux/namei.h>
 680
 681 #include <asm/uaccess.h>
 682 #include <asm/io.h>
 683 #include <asm/processor.h>
 684 #include <asm/system.h>
 685 #include <asm/pgtable.h>
 686 #include <asm/bitops.h>
 687 #include <asm/atomic.h>
 688
 689 #define DEVFS_VERSION            "2004-01-31"
 690
 691 #define DEVFS_NAME "devfs"
 692
 693 #define FIRST_INODE 1
 694
 695 #define STRING_LENGTH 256
 696 #define FAKE_BLOCK_SIZE 1024
 697 #define POISON_PTR ( *(void **) poison_array )
 698 #define MAGIC_VALUE 0x327db823
 699
 700 #ifndef TRUE
 701 #  define TRUE 1
 702 #  define FALSE 0
 703 #endif
 704
 705 #define MODE_DIR (S_IFDIR | S_IWUSR | S_IRUGO | S_IXUGO)
 706
 707 #define DEBUG_NONE         0x0000000
 708 #define DEBUG_MODULE_LOAD  0x0000001
 709 #define DEBUG_REGISTER     0x0000002
 710 #define DEBUG_UNREGISTER   0x0000004
 711 #define DEBUG_FREE         0x0000008
 712 #define DEBUG_SET_FLAGS    0x0000010
 713 #define DEBUG_S_READ       0x0000100    /*  Break  */
 714 #define DEBUG_I_LOOKUP     0x0001000    /*  Break  */
 715 #define DEBUG_I_CREATE     0x0002000
 716 #define DEBUG_I_GET        0x0004000
 717 #define DEBUG_I_CHANGE     0x0008000
 718 #define DEBUG_I_UNLINK     0x0010000
 719 #define DEBUG_I_RLINK      0x0020000
 720 #define DEBUG_I_FLINK      0x0040000
 721 #define DEBUG_I_MKNOD      0x0080000
 722 #define DEBUG_F_READDIR    0x0100000    /*  Break  */
 723 #define DEBUG_D_DELETE     0x1000000    /*  Break  */
 724 #define DEBUG_D_RELEASE    0x2000000
 725 #define DEBUG_D_IPUT       0x4000000
 726 #define DEBUG_ALL          0xfffffff
 727 #define DEBUG_DISABLED     DEBUG_NONE
 728
 729 #define OPTION_NONE             0x00
 730 #define OPTION_MOUNT            0x01
 731
 732 #define PRINTK(format, args...) \
 733    {printk (KERN_ERR "%s" format, __FUNCTION__ , ## args);}
 734
 735 #define OOPS(format, args...) \
 736    {printk (KERN_CRIT "%s" format, __FUNCTION__ , ## args); \
 737     printk ("Forcing Oops\n"); \
 738     BUG();}
 739
 740 #ifdef CONFIG_DEVFS_DEBUG
 741 #  define VERIFY_ENTRY(de) \
 742    {if ((de) && (de)->magic_number != MAGIC_VALUE) \
 743         OOPS ("(%p): bad magic value: %x\n", (de), (de)->magic_number);}
 744 #  define WRITE_ENTRY_MAGIC(de,magic) (de)->magic_number = (magic)
 745 #  define DPRINTK(flag, format, args...) \
 746    {if (devfs_debug & flag) \
 747         printk (KERN_INFO "%s" format, __FUNCTION__ , ## args);}
 748 #else
 749 #  define VERIFY_ENTRY(de)
 750 #  define WRITE_ENTRY_MAGIC(de,magic)
 751 #  define DPRINTK(flag, format, args...)
 752 #endif
 753
 754 typedef struct devfs_entry *devfs_handle_t;
 755
 756 struct directory_type {
 757         rwlock_t lock;          /*  Lock for searching(R)/updating(W)   */
 758         struct devfs_entry *first;
 759         struct devfs_entry *last;
 760         unsigned char no_more_additions:1;
 761 };
 762
 763 struct symlink_type {
 764         unsigned int length;    /*  Not including the NULL-termimator       */
 765         char *linkname;         /*  This is NULL-terminated                 */
 766 };
 767
 768 struct devfs_inode {            /*  This structure is for "persistent" inode storage  */
 769         struct dentry *dentry;
 770         struct timespec atime;
 771         struct timespec mtime;
 772         struct timespec ctime;
 773         unsigned int ino;       /*  Inode number as seen in the VFS         */
 774         uid_t uid;
 775         gid_t gid;
 776 };
 777
 778 struct devfs_entry {
 779 #ifdef CONFIG_DEVFS_DEBUG
 780         unsigned int magic_number;
 781 #endif
 782         void *info;
 783         atomic_t refcount;      /*  When this drops to zero, it's unused    */
 784         union {
 785                 struct directory_type dir;
 786                 dev_t dev;
 787                 struct symlink_type symlink;
 788                 const char *name;       /*  Only used for (mode == 0)               */
 789         } u;
 790         struct devfs_entry *prev;       /*  Previous entry in the parent directory  */
 791         struct devfs_entry *next;       /*  Next entry in the parent directory      */
 792         struct devfs_entry *parent;     /*  The parent directory                    */
 793         struct devfs_inode inode;
 794         umode_t mode;
 795         unsigned short namelen; /*  I think 64k+ filenames are a way off... */
 796         unsigned char vfs:1;    /*  Whether the VFS may delete the entry   */
 797         char name[1];           /*  This is just a dummy: the allocated array
 798                                    is bigger. This is NULL-terminated      */
 799 };
 800
 801 /*  The root of the device tree  */
 802 static struct devfs_entry *root_entry;
 803
 804 struct devfsd_buf_entry {
 805         struct devfs_entry *de; /*  The name is generated with this         */
 806         unsigned short type;    /*  The type of event                       */
 807         umode_t mode;
 808         uid_t uid;
 809         gid_t gid;
 810         struct devfsd_buf_entry *next;
 811 };
 812
 813 struct fs_info {                /*  This structure is for the mounted devfs  */
 814         struct super_block *sb;
 815         spinlock_t devfsd_buffer_lock;  /*  Lock when inserting/deleting events  */
 816         struct devfsd_buf_entry *devfsd_first_event;
 817         struct devfsd_buf_entry *devfsd_last_event;
 818         volatile int devfsd_sleeping;
 819         volatile struct task_struct *devfsd_task;
 820         volatile pid_t devfsd_pgrp;
 821         volatile struct file *devfsd_file;
 822         struct devfsd_notify_struct *devfsd_info;
 823         volatile unsigned long devfsd_event_mask;
 824         atomic_t devfsd_overrun_count;
 825         wait_queue_head_t devfsd_wait_queue;    /*  Wake devfsd on input       */
 826         wait_queue_head_t revalidate_wait_queue;        /*  Wake when devfsd sleeps    */
 827 };
 828
 829 static struct fs_info fs_info = {.devfsd_buffer_lock = SPIN_LOCK_UNLOCKED };
 830 static kmem_cache_t *devfsd_buf_cache;
 831 #ifdef CONFIG_DEVFS_DEBUG
 832 static unsigned int devfs_debug_init __initdata = DEBUG_NONE;
 833 static unsigned int devfs_debug = DEBUG_NONE;
 834 static spinlock_t stat_lock = SPIN_LOCK_UNLOCKED;
 835 static unsigned int stat_num_entries;
 836 static unsigned int stat_num_bytes;
 837 #endif
 838 static unsigned char poison_array[8] =
 839     { 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a };
 840
 841 #ifdef CONFIG_DEVFS_MOUNT
 842 static unsigned int boot_options = OPTION_MOUNT;
 843 #else
 844 static unsigned int boot_options = OPTION_NONE;
 845 #endif
 846
 847 /*  Forward function declarations  */
 848 static devfs_handle_t _devfs_walk_path(struct devfs_entry *dir,
 849                                        const char *name, int namelen,
 850                                        int traverse_symlink);
 851 static ssize_t devfsd_read(struct file *file, char __user *buf, size_t len,
 852                            loff_t * ppos);
 853 static int devfsd_ioctl(struct inode *inode, struct file *file,
 854                         unsigned int cmd, unsigned long arg);
 855 static int devfsd_close(struct inode *inode, struct file *file);
 856 #ifdef CONFIG_DEVFS_DEBUG
 857 static ssize_t stat_read(struct file *file, char __user *buf, size_t len,
 858                          loff_t * ppos);
 859 static struct file_operations stat_fops = {
 860         .open = nonseekable_open,
 861         .read = stat_read,
 862 };
 863 #endif
 864
 865 /*  Devfs daemon file operations  */
 866 static struct file_operations devfsd_fops = {
 867         .open = nonseekable_open,
 868         .read = devfsd_read,
 869         .ioctl = devfsd_ioctl,
 870         .release = devfsd_close,
 871 };
 872
 873 /*  Support functions follow  */
 874
 875 /**
 876  *      devfs_get - Get a reference to a devfs entry.
 877  *      @de:  The devfs entry.
 878  */
 879
 880 static struct devfs_entry *devfs_get(struct devfs_entry *de)
 881 {
 882         VERIFY_ENTRY(de);
 883         if (de)
 884                 atomic_inc(&de->refcount);
 885         return de;
 886 }                               /*  End Function devfs_get  */
 887
 888 /**
 889  *      devfs_put - Put (release) a reference to a devfs entry.
 890  *      @de:  The handle to the devfs entry.
 891  */
 892
 893 static void devfs_put(devfs_handle_t de)
 894 {
 895         if (!de)
 896                 return;
 897         VERIFY_ENTRY(de);
 898         if (de->info == POISON_PTR)
 899                 OOPS("(%p): poisoned pointer\n", de);
 900         if (!atomic_dec_and_test(&de->refcount))
 901                 return;
 902         if (de == root_entry)
 903                 OOPS("(%p): root entry being freed\n", de);
 904         DPRINTK(DEBUG_FREE, "(%s): de: %p, parent: %p \"%s\"\n",
 905                 de->name, de, de->parent,
 906                 de->parent ? de->parent->name : "no parent");
 907         if (S_ISLNK(de->mode))
 908                 kfree(de->u.symlink.linkname);
 909         WRITE_ENTRY_MAGIC(de, 0);
 910 #ifdef CONFIG_DEVFS_DEBUG
 911         spin_lock(&stat_lock);
 912         --stat_num_entries;
 913         stat_num_bytes -= sizeof *de + de->namelen;
 914         if (S_ISLNK(de->mode))
 915                 stat_num_bytes -= de->u.symlink.length + 1;
 916         spin_unlock(&stat_lock);
 917 #endif
 918         de->info = POISON_PTR;
 919         kfree(de);
 920 }                               /*  End Function devfs_put  */
 921
 922 /**
 923  *      _devfs_search_dir - Search for a devfs entry in a directory.
 924  *      @dir:  The directory to search.
 925  *      @name:  The name of the entry to search for.
 926  *      @namelen:  The number of characters in @name.
 927  *
 928  *  Search for a devfs entry in a directory and returns a pointer to the entry
 929  *   on success, else %NULL. The directory must be locked already.
 930  *   An implicit devfs_get() is performed on the returned entry.
 931  */
 932
 933 static struct devfs_entry *_devfs_search_dir(struct devfs_entry *dir,
 934                                              const char *name,
 935                                              unsigned int namelen)
 936 {
 937         struct devfs_entry *curr;
 938
 939         if (!S_ISDIR(dir->mode)) {
 940                 PRINTK("(%s): not a directory\n", dir->name);
 941                 return NULL;
 942         }
 943         for (curr = dir->u.dir.first; curr != NULL; curr = curr->next) {
 944                 if (curr->namelen != namelen)
 945                         continue;
 946                 if (memcmp(curr->name, name, namelen) == 0)
 947                         break;
 948                 /*  Not found: try the next one  */
 949         }
 950         return devfs_get(curr);
 951 }                               /*  End Function _devfs_search_dir  */
 952
 953 /**
 954  *      _devfs_alloc_entry - Allocate a devfs entry.
 955  *      @name:     the name of the entry
 956  *      @namelen:  the number of characters in @name
 957  *      @mode:     the mode for the entry
 958  *
 959  *  Allocate a devfs entry and returns a pointer to the entry on success, else
 960  *   %NULL.
 961  */
 962
 963 static struct devfs_entry *_devfs_alloc_entry(const char *name,
 964                                               unsigned int namelen,
 965                                               umode_t mode)
 966 {
 967         struct devfs_entry *new;
 968         static unsigned long inode_counter = FIRST_INODE;
 969         static spinlock_t counter_lock = SPIN_LOCK_UNLOCKED;
 970
 971         if (name && (namelen < 1))
 972                 namelen = strlen(name);
 973         if ((new = kmalloc(sizeof *new + namelen, GFP_KERNEL)) == NULL)
 974                 return NULL;
 975         memset(new, 0, sizeof *new + namelen);  /*  Will set '\0' on name  */
 976         new->mode = mode;
 977         if (S_ISDIR(mode))
 978                 rwlock_init(&new->u.dir.lock);
 979         atomic_set(&new->refcount, 1);
 980         spin_lock(&counter_lock);
 981         new->inode.ino = inode_counter++;
 982         spin_unlock(&counter_lock);
 983         if (name)
 984                 memcpy(new->name, name, namelen);
 985         new->namelen = namelen;
 986         WRITE_ENTRY_MAGIC(new, MAGIC_VALUE);
 987 #ifdef CONFIG_DEVFS_DEBUG
 988         spin_lock(&stat_lock);
 989         ++stat_num_entries;
 990         stat_num_bytes += sizeof *new + namelen;
 991         spin_unlock(&stat_lock);
 992 #endif
 993         return new;
 994 }                               /*  End Function _devfs_alloc_entry  */
 995
 996 /**
 997  *      _devfs_append_entry - Append a devfs entry to a directory's child list.
 998  *      @dir:  The directory to add to.
 999  *      @de:  The devfs entry to append.
1000  *      @old_de: If an existing entry exists, it will be written here. This may
1001  *               be %NULL. An implicit devfs_get() is performed on this entry.
1002  *
1003  *  Append a devfs entry to a directory's list of children, checking first to
1004  *   see if an entry of the same name exists. The directory will be locked.
1005  *   The value 0 is returned on success, else a negative error code.
1006  *   On failure, an implicit devfs_put() is performed on %de.
1007  */
1008
1009 static int _devfs_append_entry(devfs_handle_t dir, devfs_handle_t de,
1010                                devfs_handle_t * old_de)
1011 {
1012         int retval;
1013
1014         if (old_de)
1015                 *old_de = NULL;
1016         if (!S_ISDIR(dir->mode)) {
1017                 PRINTK("(%s): dir: \"%s\" is not a directory\n", de->name,
1018                        dir->name);
1019                 devfs_put(de);
1020                 return -ENOTDIR;
1021         }
1022         write_lock(&dir->u.dir.lock);
1023         if (dir->u.dir.no_more_additions)
1024                 retval = -ENOENT;
1025         else {
1026                 struct devfs_entry *old;
1027
1028                 old = _devfs_search_dir(dir, de->name, de->namelen);
1029                 if (old_de)
1030                         *old_de = old;
1031                 else
1032                         devfs_put(old);
1033                 if (old == NULL) {
1034                         de->parent = dir;
1035                         de->prev = dir->u.dir.last;
1036                         /*  Append to the directory's list of children  */
1037                         if (dir->u.dir.first == NULL)
1038                                 dir->u.dir.first = de;
1039                         else
1040                                 dir->u.dir.last->next = de;
1041                         dir->u.dir.last = de;
1042                         retval = 0;
1043                 } else
1044                         retval = -EEXIST;
1045         }
1046         write_unlock(&dir->u.dir.lock);
1047         if (retval)
1048                 devfs_put(de);
1049         return retval;
1050 }                               /*  End Function _devfs_append_entry  */
1051
1052 /**
1053  *      _devfs_get_root_entry - Get the root devfs entry.
1054  *
1055  *      Returns the root devfs entry on success, else %NULL.
1056  *
1057  *      TODO it must be called asynchronously due to the fact
1058  *      that devfs is initialized relatively late. Proper way
1059  *      is to remove module_init from init_devfs_fs and manually
1060  *      call it early enough during system init
1061  */
1062
1063 static struct devfs_entry *_devfs_get_root_entry(void)
1064 {
1065         struct devfs_entry *new;
1066         static spinlock_t root_lock = SPIN_LOCK_UNLOCKED;
1067
1068         if (root_entry)
1069                 return root_entry;
1070
1071         new = _devfs_alloc_entry(NULL, 0, MODE_DIR);
1072         if (new == NULL)
1073                 return NULL;
1074
1075         spin_lock(&root_lock);
1076         if (root_entry) {
1077                 spin_unlock(&root_lock);
1078                 devfs_put(new);
1079                 return root_entry;
1080         }
1081         root_entry = new;
1082         spin_unlock(&root_lock);
1083
1084         return root_entry;
1085 }                               /*  End Function _devfs_get_root_entry  */
1086
1087 /**
1088  *      _devfs_descend - Descend down a tree using the next component name.
1089  *      @dir:  The directory to search.
1090  *      @name:  The component name to search for.
1091  *      @namelen:  The length of %name.
1092  *      @next_pos:  The position of the next '/' or '\0' is written here.
1093  *
1094  *  Descend into a directory, searching for a component. This function forms
1095  *   the core of a tree-walking algorithm. The directory will be locked.
1096  *   The devfs entry corresponding to the component is returned. If there is
1097  *   no matching entry, %NULL is returned.
1098  *   An implicit devfs_get() is performed on the returned entry.
1099  */
1100
1101 static struct devfs_entry *_devfs_descend(struct devfs_entry *dir,
1102                                           const char *name, int namelen,
1103                                           int *next_pos)
1104 {
1105         const char *stop, *ptr;
1106         struct devfs_entry *entry;
1107
1108         if ((namelen >= 3) && (strncmp(name, "../", 3) == 0)) { /*  Special-case going to parent directory  */
1109                 *next_pos = 3;
1110                 return devfs_get(dir->parent);
1111         }
1112         stop = name + namelen;
1113         /*  Search for a possible '/'  */
1114         for (ptr = name; (ptr < stop) && (*ptr != '/'); ++ptr) ;
1115         *next_pos = ptr - name;
1116         read_lock(&dir->u.dir.lock);
1117         entry = _devfs_search_dir(dir, name, *next_pos);
1118         read_unlock(&dir->u.dir.lock);
1119         return entry;
1120 }                               /*  End Function _devfs_descend  */
1121
1122 static devfs_handle_t _devfs_make_parent_for_leaf(struct devfs_entry *dir,
1123                                                   const char *name,
1124                                                   int namelen, int *leaf_pos)
1125 {
1126         int next_pos = 0;
1127
1128         if (dir == NULL)
1129                 dir = _devfs_get_root_entry();
1130         if (dir == NULL)
1131                 return NULL;
1132         devfs_get(dir);
1133         /*  Search for possible trailing component and ignore it  */
1134         for (--namelen; (namelen > 0) && (name[namelen] != '/'); --namelen) ;
1135         *leaf_pos = (name[namelen] == '/') ? (namelen + 1) : 0;
1136         for (; namelen > 0; name += next_pos, namelen -= next_pos) {
1137                 struct devfs_entry *de, *old = NULL;
1138
1139                 if ((de =
1140                      _devfs_descend(dir, name, namelen, &next_pos)) == NULL) {
1141                         de = _devfs_alloc_entry(name, next_pos, MODE_DIR);
1142                         devfs_get(de);
1143                         if (!de || _devfs_append_entry(dir, de, &old)) {
1144                                 devfs_put(de);
1145                                 if (!old || !S_ISDIR(old->mode)) {
1146                                         devfs_put(old);
1147                                         devfs_put(dir);
1148                                         return NULL;
1149                                 }
1150                                 de = old;       /*  Use the existing directory  */
1151                         }
1152                 }
1153                 if (de == dir->parent) {
1154                         devfs_put(dir);
1155                         devfs_put(de);
1156                         return NULL;
1157                 }
1158                 devfs_put(dir);
1159                 dir = de;
1160                 if (name[next_pos] == '/')
1161                         ++next_pos;
1162         }
1163         return dir;
1164 }                               /*  End Function _devfs_make_parent_for_leaf  */
1165
1166 static devfs_handle_t _devfs_prepare_leaf(devfs_handle_t * dir,
1167                                           const char *name, umode_t mode)
1168 {
1169         int namelen, leaf_pos;
1170         struct devfs_entry *de;
1171
1172         namelen = strlen(name);
1173         if ((*dir = _devfs_make_parent_for_leaf(*dir, name, namelen,
1174                                                 &leaf_pos)) == NULL) {
1175                 PRINTK("(%s): could not create parent path\n", name);
1176                 return NULL;
1177         }
1178         if ((de = _devfs_alloc_entry(name + leaf_pos, namelen - leaf_pos, mode))
1179             == NULL) {
1180                 PRINTK("(%s): could not allocate entry\n", name);
1181                 devfs_put(*dir);
1182                 return NULL;
1183         }
1184         return de;
1185 }                               /*  End Function _devfs_prepare_leaf  */
1186
1187 static devfs_handle_t _devfs_walk_path(struct devfs_entry *dir,
1188                                        const char *name, int namelen,
1189                                        int traverse_symlink)
1190 {
1191         int next_pos = 0;
1192
1193         if (dir == NULL)
1194                 dir = _devfs_get_root_entry();
1195         if (dir == NULL)
1196                 return NULL;
1197         devfs_get(dir);
1198         for (; namelen > 0; name += next_pos, namelen -= next_pos) {
1199                 struct devfs_entry *de, *link;
1200
1201                 if (!S_ISDIR(dir->mode)) {
1202                         devfs_put(dir);
1203                         return NULL;
1204                 }
1205
1206                 if ((de =
1207                      _devfs_descend(dir, name, namelen, &next_pos)) == NULL) {
1208                         devfs_put(dir);
1209                         return NULL;
1210                 }
1211                 if (S_ISLNK(de->mode) && traverse_symlink) {    /*  Need to follow the link: this is a stack chomper  */
1212                         /* FIXME what if it puts outside of mounted tree? */
1213                         link = _devfs_walk_path(dir, de->u.symlink.linkname,
1214                                                 de->u.symlink.length, TRUE);
1215                         devfs_put(de);
1216                         if (!link) {
1217                                 devfs_put(dir);
1218                                 return NULL;
1219                         }
1220                         de = link;
1221                 }
1222                 devfs_put(dir);
1223                 dir = de;
1224                 if (name[next_pos] == '/')
1225                         ++next_pos;
1226         }
1227         return dir;
1228 }                               /*  End Function _devfs_walk_path  */
1229
1230 /**
1231  *      _devfs_find_entry - Find a devfs entry.
1232  *      @dir: The handle to the parent devfs directory entry. If this is %NULL the
1233  *              name is relative to the root of the devfs.
1234  *      @name: The name of the entry. This may be %NULL.
1235  *      @traverse_symlink: If %TRUE then symbolic links are traversed.
1236  *
1237  *      Returns the devfs_entry pointer on success, else %NULL. An implicit
1238  *      devfs_get() is performed.
1239  */
1240
1241 static struct devfs_entry *_devfs_find_entry(devfs_handle_t dir,
1242                                              const char *name,
1243                                              int traverse_symlink)
1244 {
1245         unsigned int namelen = strlen(name);
1246
1247         if (name[0] == '/') {
1248                 /*  Skip leading pathname component  */
1249                 if (namelen < 2) {
1250                         PRINTK("(%s): too short\n", name);
1251                         return NULL;
1252                 }
1253                 for (++name, --namelen; (*name != '/') && (namelen > 0);
1254                      ++name, --namelen) ;
1255                 if (namelen < 2) {
1256                         PRINTK("(%s): too short\n", name);
1257                         return NULL;
1258                 }
1259                 ++name;
1260                 --namelen;
1261         }
1262         return _devfs_walk_path(dir, name, namelen, traverse_symlink);
1263 }                               /*  End Function _devfs_find_entry  */
1264
1265 static struct devfs_entry *get_devfs_entry_from_vfs_inode(struct inode *inode)
1266 {
1267         if (inode == NULL)
1268                 return NULL;
1269         VERIFY_ENTRY((struct devfs_entry *)inode->u.generic_ip);
1270         return inode->u.generic_ip;
1271 }                               /*  End Function get_devfs_entry_from_vfs_inode  */
1272
1273 /**
1274  *      free_dentry - Free the dentry for a device entry and invalidate inode.
1275  *      @de: The entry.
1276  *
1277  *      This must only be called after the entry has been unhooked from its
1278  *       parent directory.
1279  */
1280
1281 static void free_dentry(struct devfs_entry *de)
1282 {
1283         struct dentry *dentry = de->inode.dentry;
1284
1285         if (!dentry)
1286                 return;
1287         spin_lock(&dcache_lock);
1288         dget_locked(dentry);
1289         spin_unlock(&dcache_lock);
1290         /*  Forcefully remove the inode  */
1291         if (dentry->d_inode != NULL)
1292                 dentry->d_inode->i_nlink = 0;
1293         d_drop(dentry);
1294         dput(dentry);
1295 }                               /*  End Function free_dentry  */
1296
1297 /**
1298  *      is_devfsd_or_child - Test if the current process is devfsd or one of its children.
1299  *      @fs_info: The filesystem information.
1300  *
1301  *      Returns %TRUE if devfsd or child, else %FALSE.
1302  */
1303
1304 static int is_devfsd_or_child(struct fs_info *fs_info)
1305 {
1306         struct task_struct *p = current;
1307
1308         if (p == fs_info->devfsd_task)
1309                 return (TRUE);
1310         if (process_group(p) == fs_info->devfsd_pgrp)
1311                 return (TRUE);
1312         read_lock(&tasklist_lock);
1313         for (; p != &init_task; p = p->real_parent) {
1314                 if (p == fs_info->devfsd_task) {
1315                         read_unlock(&tasklist_lock);
1316                         return (TRUE);
1317                 }
1318         }
1319         read_unlock(&tasklist_lock);
1320         return (FALSE);
1321 }                               /*  End Function is_devfsd_or_child  */
1322
1323 /**
1324  *      devfsd_queue_empty - Test if devfsd has work pending in its event queue.
1325  *      @fs_info: The filesystem information.
1326  *
1327  *      Returns %TRUE if the queue is empty, else %FALSE.
1328  */
1329
1330 static inline int devfsd_queue_empty(struct fs_info *fs_info)
1331 {
1332         return (fs_info->devfsd_last_event) ? FALSE : TRUE;
1333 }                               /*  End Function devfsd_queue_empty  */
1334
1335 /**
1336  *      wait_for_devfsd_finished - Wait for devfsd to finish processing its event queue.
1337  *      @fs_info: The filesystem information.
1338  *
1339  *      Returns %TRUE if no more waiting will be required, else %FALSE.
1340  */
1341
1342 static int wait_for_devfsd_finished(struct fs_info *fs_info)
1343 {
1344         DECLARE_WAITQUEUE(wait, current);
1345
1346         if (fs_info->devfsd_task == NULL)
1347                 return (TRUE);
1348         if (devfsd_queue_empty(fs_info) && fs_info->devfsd_sleeping)
1349                 return TRUE;
1350         if (is_devfsd_or_child(fs_info))
1351                 return (FALSE);
1352         set_current_state(TASK_UNINTERRUPTIBLE);
1353         add_wait_queue(&fs_info->revalidate_wait_queue, &wait);
1354         if (!devfsd_queue_empty(fs_info) || !fs_info->devfsd_sleeping)
1355                 if (fs_info->devfsd_task)
1356                         schedule();
1357         remove_wait_queue(&fs_info->revalidate_wait_queue, &wait);
1358         __set_current_state(TASK_RUNNING);
1359         return (TRUE);
1360 }                               /*  End Function wait_for_devfsd_finished  */
1361
1362 /**
1363  *      devfsd_notify_de - Notify the devfsd daemon of a change.
1364  *      @de: The devfs entry that has changed. This and all parent entries will
1365  *            have their reference counts incremented if the event was queued.
1366  *      @type: The type of change.
1367  *      @mode: The mode of the entry.
1368  *      @uid: The user ID.
1369  *      @gid: The group ID.
1370  *      @fs_info: The filesystem info.
1371  *
1372  *      Returns %TRUE if an event was queued and devfsd woken up, else %FALSE.
1373  */
1374
1375 static int devfsd_notify_de(struct devfs_entry *de,
1376                             unsigned short type, umode_t mode,
1377                             uid_t uid, gid_t gid, struct fs_info *fs_info)
1378 {
1379         struct devfsd_buf_entry *entry;
1380         struct devfs_entry *curr;
1381
1382         if (!(fs_info->devfsd_event_mask & (1 << type)))
1383                 return (FALSE);
1384         if ((entry = kmem_cache_alloc(devfsd_buf_cache, SLAB_KERNEL)) == NULL) {
1385                 atomic_inc(&fs_info->devfsd_overrun_count);
1386                 return (FALSE);
1387         }
1388         for (curr = de; curr != NULL; curr = curr->parent)
1389                 devfs_get(curr);
1390         entry->de = de;
1391         entry->type = type;
1392         entry->mode = mode;
1393         entry->uid = uid;
1394         entry->gid = gid;
1395         entry->next = NULL;
1396         spin_lock(&fs_info->devfsd_buffer_lock);
1397         if (!fs_info->devfsd_first_event)
1398                 fs_info->devfsd_first_event = entry;
1399         if (fs_info->devfsd_last_event)
1400                 fs_info->devfsd_last_event->next = entry;
1401         fs_info->devfsd_last_event = entry;
1402         spin_unlock(&fs_info->devfsd_buffer_lock);
1403         wake_up_interruptible(&fs_info->devfsd_wait_queue);
1404         return (TRUE);
1405 }                               /*  End Function devfsd_notify_de  */
1406
1407 /**
1408  *      devfsd_notify - Notify the devfsd daemon of a change.
1409  *      @de: The devfs entry that has changed.
1410  *      @type: The type of change event.
1411  *      @wait: If TRUE, the function waits for the daemon to finish processing
1412  *              the event.
1413  */
1414
1415 static void devfsd_notify(struct devfs_entry *de, unsigned short type)
1416 {
1417         devfsd_notify_de(de, type, de->mode, current->euid,
1418                          current->egid, &fs_info);
1419 }
1420
1421 static int devfs_mk_dev(dev_t dev, umode_t mode, const char *fmt, va_list args)
1422 {
1423         struct devfs_entry *dir = NULL, *de;
1424         char buf[64];
1425         int error, n;
1426
1427         n = vsnprintf(buf, sizeof(buf), fmt, args);
1428         if (n >= sizeof(buf) || !buf[0]) {
1429                 printk(KERN_WARNING "%s: invalid format string %s\n",
1430                        __FUNCTION__, fmt);
1431                 return -EINVAL;
1432         }
1433
1434         de = _devfs_prepare_leaf(&dir, buf, mode);
1435         if (!de) {
1436                 printk(KERN_WARNING "%s: could not prepare leaf for %s\n",
1437                        __FUNCTION__, buf);
1438                 return -ENOMEM; /* could be more accurate... */
1439         }
1440
1441         de->u.dev = dev;
1442
1443         error = _devfs_append_entry(dir, de, NULL);
1444         if (error) {
1445                 printk(KERN_WARNING "%s: could not append to parent for %s\n",
1446                        __FUNCTION__, buf);
1447                 goto out;
1448         }
1449
1450         devfsd_notify(de, DEVFSD_NOTIFY_REGISTERED);
1451       out:
1452         devfs_put(dir);
1453         return error;
1454 }
1455
1456 int devfs_mk_bdev(dev_t dev, umode_t mode, const char *fmt, ...)
1457 {
1458         va_list args;
1459
1460         if (!S_ISBLK(mode)) {
1461                 printk(KERN_WARNING "%s: invalide mode (%u) for %s\n",
1462                        __FUNCTION__, mode, fmt);
1463                 return -EINVAL;
1464         }
1465
1466         va_start(args, fmt);
1467         return devfs_mk_dev(dev, mode, fmt, args);
1468 }
1469
1470 EXPORT_SYMBOL(devfs_mk_bdev);
1471
1472 int devfs_mk_cdev(dev_t dev, umode_t mode, const char *fmt, ...)
1473 {
1474         va_list args;
1475
1476         if (!S_ISCHR(mode)) {
1477                 printk(KERN_WARNING "%s: invalide mode (%u) for %s\n",
1478                        __FUNCTION__, mode, fmt);
1479                 return -EINVAL;
1480         }
1481
1482         va_start(args, fmt);
1483         return devfs_mk_dev(dev, mode, fmt, args);
1484 }
1485
1486 EXPORT_SYMBOL(devfs_mk_cdev);
1487
1488 /**
1489  *      _devfs_unhook - Unhook a device entry from its parents list
1490  *      @de: The entry to unhook.
1491  *
1492  *      Returns %TRUE if the entry was unhooked, else %FALSE if it was
1493  *              previously unhooked.
1494  *      The caller must have a write lock on the parent directory.
1495  */
1496
1497 static int _devfs_unhook(struct devfs_entry *de)
1498 {
1499         struct devfs_entry *parent;
1500
1501         if (!de || (de->prev == de))
1502                 return FALSE;
1503         parent = de->parent;
1504         if (de->prev == NULL)
1505                 parent->u.dir.first = de->next;
1506         else
1507                 de->prev->next = de->next;
1508         if (de->next == NULL)
1509                 parent->u.dir.last = de->prev;
1510         else
1511                 de->next->prev = de->prev;
1512         de->prev = de;          /*  Indicate we're unhooked                      */
1513         de->next = NULL;        /*  Force early termination for <devfs_readdir>  */
1514         return TRUE;
1515 }                               /*  End Function _devfs_unhook  */
1516
1517 /**
1518  *      _devfs_unregister - Unregister a device entry from its parent.
1519  *      @dir: The parent directory.
1520  *      @de: The entry to unregister.
1521  *
1522  *      The caller must have a write lock on the parent directory, which is
1523  *      unlocked by this function.
1524  */
1525
1526 static void _devfs_unregister(struct devfs_entry *dir, struct devfs_entry *de)
1527 {
1528         int unhooked = _devfs_unhook(de);
1529
1530         write_unlock(&dir->u.dir.lock);
1531         if (!unhooked)
1532                 return;
1533         devfs_get(dir);
1534         devfsd_notify(de, DEVFSD_NOTIFY_UNREGISTERED);
1535         free_dentry(de);
1536         devfs_put(dir);
1537         if (!S_ISDIR(de->mode))
1538                 return;
1539         while (TRUE) {          /*  Recursively unregister: this is a stack chomper  */
1540                 struct devfs_entry *child;
1541
1542                 write_lock(&de->u.dir.lock);
1543                 de->u.dir.no_more_additions = TRUE;
1544                 child = de->u.dir.first;
1545                 VERIFY_ENTRY(child);
1546                 _devfs_unregister(de, child);
1547                 if (!child)
1548                         break;
1549                 DPRINTK(DEBUG_UNREGISTER, "(%s): child: %p  refcount: %d\n",
1550                         child->name, child, atomic_read(&child->refcount));
1551                 devfs_put(child);
1552         }
1553 }                               /*  End Function _devfs_unregister  */
1554
1555 static int devfs_do_symlink(devfs_handle_t dir, const char *name,
1556                             const char *link, devfs_handle_t * handle)
1557 {
1558         int err;
1559         unsigned int linklength;
1560         char *newlink;
1561         struct devfs_entry *de;
1562
1563         if (handle != NULL)
1564                 *handle = NULL;
1565         if (name == NULL) {
1566                 PRINTK("(): NULL name pointer\n");
1567                 return -EINVAL;
1568         }
1569         if (link == NULL) {
1570                 PRINTK("(%s): NULL link pointer\n", name);
1571                 return -EINVAL;
1572         }
1573         linklength = strlen(link);
1574         if ((newlink = kmalloc(linklength + 1, GFP_KERNEL)) == NULL)
1575                 return -ENOMEM;
1576         memcpy(newlink, link, linklength);
1577         newlink[linklength] = '\0';
1578         if ((de = _devfs_prepare_leaf(&dir, name, S_IFLNK | S_IRUGO | S_IXUGO))
1579             == NULL) {
1580                 PRINTK("(%s): could not prepare leaf\n", name);
1581                 kfree(newlink);
1582                 return -ENOTDIR;
1583         }
1584         de->info = NULL;
1585         de->u.symlink.linkname = newlink;
1586         de->u.symlink.length = linklength;
1587         if ((err = _devfs_append_entry(dir, de, NULL)) != 0) {
1588                 PRINTK("(%s): could not append to parent, err: %d\n", name,
1589                        err);
1590                 devfs_put(dir);
1591                 return err;
1592         }
1593         devfs_put(dir);
1594 #ifdef CONFIG_DEVFS_DEBUG
1595         spin_lock(&stat_lock);
1596         stat_num_bytes += linklength + 1;
1597         spin_unlock(&stat_lock);
1598 #endif
1599         if (handle != NULL)
1600                 *handle = de;
1601         return 0;
1602 }                               /*  End Function devfs_do_symlink  */
1603
1604 /**
1605  *      devfs_mk_symlink Create a symbolic link in the devfs namespace.
1606  *      @from: The name of the entry.
1607  *      @to: Name of the destination
1608  *
1609  *      Returns 0 on success, else a negative error code is returned.
1610  */
1611
1612 int devfs_mk_symlink(const char *from, const char *to)
1613 {
1614         devfs_handle_t de;
1615         int err;
1616
1617         err = devfs_do_symlink(NULL, from, to, &de);
1618         if (!err) {
1619                 de->vfs = TRUE;
1620                 devfsd_notify(de, DEVFSD_NOTIFY_REGISTERED);
1621         }
1622
1623         return err;
1624 }
1625
1626 /**
1627  *      devfs_mk_dir - Create a directory in the devfs namespace.
1628  *              new name is relative to the root of the devfs.
1629  *      @fmt: The name of the entry.
1630  *
1631  *      Use of this function is optional. The devfs_register() function
1632  *      will automatically create intermediate directories as needed. This function
1633  *      is provided for efficiency reasons, as it provides a handle to a directory.
1634  *      On failure %NULL is returned.
1635  */
1636
1637 int devfs_mk_dir(const char *fmt, ...)
1638 {
1639         struct devfs_entry *dir = NULL, *de = NULL, *old;
1640         char buf[64];
1641         va_list args;
1642         int error, n;
1643
1644         va_start(args, fmt);
1645         n = vsnprintf(buf, 64, fmt, args);
1646         if (n >= 64 || !buf[0]) {
1647                 printk(KERN_WARNING "%s: invalid argument.", __FUNCTION__);
1648                 return -EINVAL;
1649         }
1650
1651         de = _devfs_prepare_leaf(&dir, buf, MODE_DIR);
1652         if (!de) {
1653                 PRINTK("(%s): could not prepare leaf\n", buf);
1654                 return -EINVAL;
1655         }
1656
1657         error = _devfs_append_entry(dir, de, &old);
1658         if (error == -EEXIST && S_ISDIR(old->mode)) {
1659                 /*
1660                  * devfs_mk_dir() of an already-existing directory will
1661                  * return success.
1662                  */
1663                 error = 0;
1664                 goto out_put;
1665         } else if (error) {
1666                 PRINTK("(%s): could not append to dir: %p \"%s\"\n",
1667                        buf, dir, dir->name);
1668                 devfs_put(old);
1669                 goto out_put;
1670         }
1671
1672         devfsd_notify(de, DEVFSD_NOTIFY_REGISTERED);
1673
1674       out_put:
1675         devfs_put(dir);
1676         return error;
1677 }
1678
1679 void devfs_remove(const char *fmt, ...)
1680 {
1681         char buf[64];
1682         va_list args;
1683         int n;
1684
1685         va_start(args, fmt);
1686         n = vsnprintf(buf, sizeof(buf), fmt, args);
1687         if (n < sizeof(buf) && buf[0]) {
1688                 devfs_handle_t de = _devfs_find_entry(NULL, buf, 0);
1689
1690                 if (!de) {
1691                         printk(KERN_ERR "%s: %s not found, cannot remove\n",
1692                                __FUNCTION__, buf);
1693                         dump_stack();
1694                         return;
1695                 }
1696
1697                 write_lock(&de->parent->u.dir.lock);
1698                 _devfs_unregister(de->parent, de);
1699                 devfs_put(de);
1700                 devfs_put(de);
1701         }
1702 }
1703
1704 /**
1705  *      devfs_generate_path - Generate a pathname for an entry, relative to the devfs root.
1706  *      @de: The devfs entry.
1707  *      @path: The buffer to write the pathname to. The pathname and '\0'
1708  *              terminator will be written at the end of the buffer.
1709  *      @buflen: The length of the buffer.
1710  *
1711  *      Returns the offset in the buffer where the pathname starts on success,
1712  *      else a negative error code.
1713  */
1714
1715 static int devfs_generate_path(devfs_handle_t de, char *path, int buflen)
1716 {
1717         int pos;
1718 #define NAMEOF(de) ( (de)->mode ? (de)->name : (de)->u.name )
1719
1720         if (de == NULL)
1721                 return -EINVAL;
1722         VERIFY_ENTRY(de);
1723         if (de->namelen >= buflen)
1724                 return -ENAMETOOLONG;   /*  Must be first       */
1725         path[buflen - 1] = '\0';
1726         if (de->parent == NULL)
1727                 return buflen - 1;      /*  Don't prepend root  */
1728         pos = buflen - de->namelen - 1;
1729         memcpy(path + pos, NAMEOF(de), de->namelen);
1730         for (de = de->parent; de->parent != NULL; de = de->parent) {
1731                 if (pos - de->namelen - 1 < 0)
1732                         return -ENAMETOOLONG;
1733                 path[--pos] = '/';
1734                 pos -= de->namelen;
1735                 memcpy(path + pos, NAMEOF(de), de->namelen);
1736         }
1737         return pos;
1738 }                               /*  End Function devfs_generate_path  */
1739
1740 /**
1741  *      devfs_setup - Process kernel boot options.
1742  *      @str: The boot options after the "devfs=".
1743  */
1744
1745 static int __init devfs_setup(char *str)
1746 {
1747         static struct {
1748                 char *name;
1749                 unsigned int mask;
1750                 unsigned int *opt;
1751         } devfs_options_tab[] __initdata = {
1752 #ifdef CONFIG_DEVFS_DEBUG
1753                 {
1754                 "dall", DEBUG_ALL, &devfs_debug_init}, {
1755                 "dmod", DEBUG_MODULE_LOAD, &devfs_debug_init}, {
1756                 "dreg", DEBUG_REGISTER, &devfs_debug_init}, {
1757                 "dunreg", DEBUG_UNREGISTER, &devfs_debug_init}, {
1758                 "dfree", DEBUG_FREE, &devfs_debug_init}, {
1759                 "diget", DEBUG_I_GET, &devfs_debug_init}, {
1760                 "dchange", DEBUG_SET_FLAGS, &devfs_debug_init}, {
1761                 "dsread", DEBUG_S_READ, &devfs_debug_init}, {
1762                 "dichange", DEBUG_I_CHANGE, &devfs_debug_init}, {
1763                 "dimknod", DEBUG_I_MKNOD, &devfs_debug_init}, {
1764                 "dilookup", DEBUG_I_LOOKUP, &devfs_debug_init}, {
1765                 "diunlink", DEBUG_I_UNLINK, &devfs_debug_init},
1766 #endif                          /*  CONFIG_DEVFS_DEBUG  */
1767                 {
1768                 "mount", OPTION_MOUNT, &boot_options}, {
1769                 NULL, 0, NULL}
1770         };
1771
1772         while ((*str != '\0') && !isspace(*str)) {
1773                 int i, found = 0, invert = 0;
1774
1775                 if (strncmp(str, "no", 2) == 0) {
1776                         invert = 1;
1777                         str += 2;
1778                 }
1779                 for (i = 0; devfs_options_tab[i].name != NULL; i++) {
1780                         int len = strlen(devfs_options_tab[i].name);
1781
1782                         if (strncmp(str, devfs_options_tab[i].name, len) == 0) {
1783                                 if (invert)
1784                                         *devfs_options_tab[i].opt &=
1785                                             ~devfs_options_tab[i].mask;
1786                                 else
1787                                         *devfs_options_tab[i].opt |=
1788                                             devfs_options_tab[i].mask;
1789                                 str += len;
1790                                 found = 1;
1791                                 break;
1792                         }
1793                 }
1794                 if (!found)
1795                         return 0;       /*  No match         */
1796                 if (*str != ',')
1797                         return 0;       /*  No more options  */
1798                 ++str;
1799         }
1800         return 1;
1801 }                               /*  End Function devfs_setup  */
1802
1803 __setup("devfs=", devfs_setup);
1804
1805 EXPORT_SYMBOL(devfs_mk_symlink);
1806 EXPORT_SYMBOL(devfs_mk_dir);
1807 EXPORT_SYMBOL(devfs_remove);
1808
1809 /**
1810  *      try_modload - Notify devfsd of an inode lookup by a non-devfsd process.
1811  *      @parent: The parent devfs entry.
1812  *      @fs_info: The filesystem info.
1813  *      @name: The device name.
1814  *      @namelen: The number of characters in @name.
1815  *      @buf: A working area that will be used. This must not go out of scope
1816  *            until devfsd is idle again.
1817  *
1818  *      Returns 0 on success (event was queued), else a negative error code.
1819  */
1820
1821 static int try_modload(struct devfs_entry *parent, struct fs_info *fs_info,
1822                        const char *name, unsigned namelen,
1823                        struct devfs_entry *buf)
1824 {
1825         if (!(fs_info->devfsd_event_mask & (1 << DEVFSD_NOTIFY_LOOKUP)))
1826                 return -ENOENT;
1827         if (is_devfsd_or_child(fs_info))
1828                 return -ENOENT;
1829         memset(buf, 0, sizeof *buf);
1830         atomic_set(&buf->refcount, 1);
1831         buf->parent = parent;
1832         buf->namelen = namelen;
1833         buf->u.name = name;
1834         WRITE_ENTRY_MAGIC(buf, MAGIC_VALUE);
1835         if (!devfsd_notify_de(buf, DEVFSD_NOTIFY_LOOKUP, 0,
1836                               current->euid, current->egid, fs_info))
1837                 return -ENOENT;
1838         /*  Possible success: event has been queued  */
1839         return 0;
1840 }                               /*  End Function try_modload  */
1841
1842 /*  Superblock operations follow  */
1843
1844 static struct inode_operations devfs_iops;
1845 static struct inode_operations devfs_dir_iops;
1846 static struct file_operations devfs_fops;
1847 static struct file_operations devfs_dir_fops;
1848 static struct inode_operations devfs_symlink_iops;
1849
1850 static int devfs_notify_change(struct dentry *dentry, struct iattr *iattr)
1851 {
1852         int retval;
1853         struct devfs_entry *de;
1854         struct inode *inode = dentry->d_inode;
1855         struct fs_info *fs_info = inode->i_sb->s_fs_info;
1856
1857         de = get_devfs_entry_from_vfs_inode(inode);
1858         if (de == NULL)
1859                 return -ENODEV;
1860         retval = inode_change_ok(inode, iattr);
1861         if (retval != 0)
1862                 return retval;
1863         retval = inode_setattr(inode, iattr);
1864         if (retval != 0)
1865                 return retval;
1866         DPRINTK(DEBUG_I_CHANGE, "(%d): VFS inode: %p  devfs_entry: %p\n",
1867                 (int)inode->i_ino, inode, de);
1868         DPRINTK(DEBUG_I_CHANGE, "():   mode: 0%o  uid: %d  gid: %d\n",
1869                 (int)inode->i_mode, (int)inode->i_uid, (int)inode->i_gid);
1870         /*  Inode is not on hash chains, thus must save permissions here rather
1871            than in a write_inode() method  */
1872         de->mode = inode->i_mode;
1873         de->inode.uid = inode->i_uid;
1874         de->inode.gid = inode->i_gid;
1875         de->inode.atime = inode->i_atime;
1876         de->inode.mtime = inode->i_mtime;
1877         de->inode.ctime = inode->i_ctime;
1878         if ((iattr->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID)) &&
1879             !is_devfsd_or_child(fs_info))
1880                 devfsd_notify_de(de, DEVFSD_NOTIFY_CHANGE, inode->i_mode,
1881                                  inode->i_uid, inode->i_gid, fs_info);
1882         return 0;
1883 }                               /*  End Function devfs_notify_change  */
1884
1885 static struct super_operations devfs_sops = {
1886         .drop_inode = generic_delete_inode,
1887         .statfs = simple_statfs,
1888 };
1889
1890 /**
1891  *      _devfs_get_vfs_inode - Get a VFS inode.
1892  *      @sb: The super block.
1893  *      @de: The devfs inode.
1894  *      @dentry: The dentry to register with the devfs inode.
1895  *
1896  *      Returns the inode on success, else %NULL. An implicit devfs_get() is
1897  *       performed if the inode is created.
1898  */
1899
1900 static struct inode *_devfs_get_vfs_inode(struct super_block *sb,
1901                                           struct devfs_entry *de,
1902                                           struct dentry *dentry)
1903 {
1904         struct inode *inode;
1905
1906         if (de->prev == de)
1907                 return NULL;    /*  Quick check to see if unhooked  */
1908         if ((inode = new_inode(sb)) == NULL) {
1909                 PRINTK("(%s): new_inode() failed, de: %p\n", de->name, de);
1910                 return NULL;
1911         }
1912         if (de->parent) {
1913                 read_lock(&de->parent->u.dir.lock);
1914                 if (de->prev != de)
1915                         de->inode.dentry = dentry;      /*      Not unhooked  */
1916                 read_unlock(&de->parent->u.dir.lock);
1917         } else
1918                 de->inode.dentry = dentry;      /*  Root: no locking needed  */
1919         if (de->inode.dentry != dentry) {       /*  Must have been unhooked  */
1920                 iput(inode);
1921                 return NULL;
1922         }
1923         /* FIXME where is devfs_put? */
1924         inode->u.generic_ip = devfs_get(de);
1925         inode->i_ino = de->inode.ino;
1926         DPRINTK(DEBUG_I_GET, "(%d): VFS inode: %p  devfs_entry: %p\n",
1927                 (int)inode->i_ino, inode, de);
1928         inode->i_blocks = 0;
1929         inode->i_blksize = FAKE_BLOCK_SIZE;
1930         inode->i_op = &devfs_iops;
1931         inode->i_mode = de->mode;
1932         if (S_ISDIR(de->mode)) {
1933                 inode->i_op = &devfs_dir_iops;
1934                 inode->i_fop = &devfs_dir_fops;
1935         } else if (S_ISLNK(de->mode)) {
1936                 inode->i_op = &devfs_symlink_iops;
1937                 inode->i_size = de->u.symlink.length;
1938         } else if (S_ISCHR(de->mode) || S_ISBLK(de->mode)) {
1939                 init_special_inode(inode, de->mode, de->u.dev);
1940         } else if (S_ISFIFO(de->mode) || S_ISSOCK(de->mode)) {
1941                 init_special_inode(inode, de->mode, 0);
1942         } else {
1943                 PRINTK("(%s): unknown mode %o de: %p\n",
1944                        de->name, de->mode, de);
1945                 iput(inode);
1946                 devfs_put(de);
1947                 return NULL;
1948         }
1949
1950         inode->i_uid = de->inode.uid;
1951         inode->i_gid = de->inode.gid;
1952         inode->i_atime = de->inode.atime;
1953         inode->i_mtime = de->inode.mtime;
1954         inode->i_ctime = de->inode.ctime;
1955         DPRINTK(DEBUG_I_GET, "():   mode: 0%o  uid: %d  gid: %d\n",
1956                 (int)inode->i_mode, (int)inode->i_uid, (int)inode->i_gid);
1957         return inode;
1958 }                               /*  End Function _devfs_get_vfs_inode  */
1959
1960 /*  File operations for device entries follow  */
1961
1962 static int devfs_readdir(struct file *file, void *dirent, filldir_t filldir)
1963 {
1964         int err, count;
1965         int stored = 0;
1966         struct fs_info *fs_info;
1967         struct devfs_entry *parent, *de, *next = NULL;
1968         struct inode *inode = file->f_dentry->d_inode;
1969
1970         fs_info = inode->i_sb->s_fs_info;
1971         parent = get_devfs_entry_from_vfs_inode(file->f_dentry->d_inode);
1972         if ((long)file->f_pos < 0)
1973                 return -EINVAL;
1974         DPRINTK(DEBUG_F_READDIR, "(%s): fs_info: %p  pos: %ld\n",
1975                 parent->name, fs_info, (long)file->f_pos);
1976         switch ((long)file->f_pos) {
1977         case 0:
1978                 err = (*filldir) (dirent, "..", 2, file->f_pos,
1979                                   parent_ino(file->f_dentry), DT_DIR);
1980                 if (err == -EINVAL)
1981                         break;
1982                 if (err < 0)
1983                         return err;
1984                 file->f_pos++;
1985                 ++stored;
1986                 /*  Fall through  */
1987         case 1:
1988                 err =
1989                     (*filldir) (dirent, ".", 1, file->f_pos, inode->i_ino,
1990                                 DT_DIR);
1991                 if (err == -EINVAL)
1992                         break;
1993                 if (err < 0)
1994                         return err;
1995                 file->f_pos++;
1996                 ++stored;
1997                 /*  Fall through  */
1998         default:
1999                 /*  Skip entries  */
2000                 count = file->f_pos - 2;
2001                 read_lock(&parent->u.dir.lock);
2002                 for (de = parent->u.dir.first; de && (count > 0); de = de->next)
2003                         --count;
2004                 devfs_get(de);
2005                 read_unlock(&parent->u.dir.lock);
2006                 /*  Now add all remaining entries  */
2007                 while (de) {
2008                         err = (*filldir) (dirent, de->name, de->namelen,
2009                                           file->f_pos, de->inode.ino,
2010                                           de->mode >> 12);
2011                         if (err < 0)
2012                                 devfs_put(de);
2013                         else {
2014                                 file->f_pos++;
2015                                 ++stored;
2016                         }
2017                         if (err == -EINVAL)
2018                                 break;
2019                         if (err < 0)
2020                                 return err;
2021                         read_lock(&parent->u.dir.lock);
2022                         next = devfs_get(de->next);
2023                         read_unlock(&parent->u.dir.lock);
2024                         devfs_put(de);
2025                         de = next;
2026                 }
2027                 break;
2028         }
2029         return stored;
2030 }                               /*  End Function devfs_readdir  */
2031
2032 /* Open devfs specific special files */
2033 static int devfs_open(struct inode *inode, struct file *file)
2034 {
2035         int err;
2036         int minor = MINOR(inode->i_rdev);
2037         struct file_operations *old_fops, *new_fops;
2038
2039         switch (minor) {
2040         case 0:         /* /dev/.devfsd */
2041                 new_fops = fops_get(&devfsd_fops);
2042                 break;
2043 #ifdef CONFIG_DEVFS_DEBUG
2044         case 1:         /* /dev/.stat */
2045                 new_fops = fops_get(&stat_fops);
2046                 break;
2047 #endif
2048         default:
2049                 return -ENODEV;
2050         }
2051
2052         if (new_fops == NULL)
2053                 return -ENODEV;
2054         old_fops = file->f_op;
2055         file->f_op = new_fops;
2056         err = new_fops->open ? new_fops->open(inode, file) : 0;
2057         if (err) {
2058                 file->f_op = old_fops;
2059                 fops_put(new_fops);
2060         } else
2061                 fops_put(old_fops);
2062         return err;
2063 }                               /*  End Function devfs_open  */
2064
2065 static struct file_operations devfs_fops = {
2066         .open = devfs_open,
2067 };
2068
2069 static struct file_operations devfs_dir_fops = {
2070         .read = generic_read_dir,
2071         .readdir = devfs_readdir,
2072 };
2073
2074 /*  Dentry operations for device entries follow  */
2075
2076 /**
2077  *      devfs_d_release - Callback for when a dentry is freed.
2078  *      @dentry: The dentry.
2079  */
2080
2081 static void devfs_d_release(struct dentry *dentry)
2082 {
2083         DPRINTK(DEBUG_D_RELEASE, "(%p): inode: %p\n", dentry, dentry->d_inode);
2084 }                               /*  End Function devfs_d_release  */
2085
2086 /**
2087  *      devfs_d_iput - Callback for when a dentry loses its inode.
2088  *      @dentry: The dentry.
2089  *      @inode: The inode.
2090  */
2091
2092 static void devfs_d_iput(struct dentry *dentry, struct inode *inode)
2093 {
2094         struct devfs_entry *de;
2095
2096         de = get_devfs_entry_from_vfs_inode(inode);
2097         DPRINTK(DEBUG_D_IPUT,
2098                 "(%s): dentry: %p inode: %p de: %p de->dentry: %p\n", de->name,
2099                 dentry, inode, de, de->inode.dentry);
2100         if (de->inode.dentry && (de->inode.dentry != dentry))
2101                 OOPS("(%s): de: %p dentry: %p de->dentry: %p\n",
2102                      de->name, de, dentry, de->inode.dentry);
2103         de->inode.dentry = NULL;
2104         iput(inode);
2105         devfs_put(de);
2106 }                               /*  End Function devfs_d_iput  */
2107
2108 static int devfs_d_delete(struct dentry *dentry);
2109
2110 static struct dentry_operations devfs_dops = {
2111         .d_delete = devfs_d_delete,
2112         .d_release = devfs_d_release,
2113         .d_iput = devfs_d_iput,
2114 };
2115
2116 static int devfs_d_revalidate_wait(struct dentry *dentry, struct nameidata *);
2117
2118 static struct dentry_operations devfs_wait_dops = {
2119         .d_delete = devfs_d_delete,
2120         .d_release = devfs_d_release,
2121         .d_iput = devfs_d_iput,
2122         .d_revalidate = devfs_d_revalidate_wait,
2123 };
2124
2125 /**
2126  *      devfs_d_delete - Callback for when all files for a dentry are closed.
2127  *      @dentry: The dentry.
2128  */
2129
2130 static int devfs_d_delete(struct dentry *dentry)
2131 {
2132         struct inode *inode = dentry->d_inode;
2133
2134         if (dentry->d_op == &devfs_wait_dops)
2135                 dentry->d_op = &devfs_dops;
2136         /*  Unhash dentry if negative (has no inode)  */
2137         if (inode == NULL) {
2138                 DPRINTK(DEBUG_D_DELETE, "(%p): dropping negative dentry\n",
2139                         dentry);
2140                 return 1;
2141         }
2142         return 0;
2143 }                               /*  End Function devfs_d_delete  */
2144
2145 struct devfs_lookup_struct {
2146         devfs_handle_t de;
2147         wait_queue_head_t wait_queue;
2148 };
2149
2150 /* XXX: this doesn't handle the case where we got a negative dentry
2151         but a devfs entry has been registered in the meanwhile */
2152 static int devfs_d_revalidate_wait(struct dentry *dentry, struct nameidata *nd)
2153 {
2154         struct inode *dir = dentry->d_parent->d_inode;
2155         struct fs_info *fs_info = dir->i_sb->s_fs_info;
2156         devfs_handle_t parent = get_devfs_entry_from_vfs_inode(dir);
2157         struct devfs_lookup_struct *lookup_info = dentry->d_fsdata;
2158         DECLARE_WAITQUEUE(wait, current);
2159         int need_lock;
2160
2161         /*
2162          * FIXME HACK
2163          *
2164          * make sure that
2165          *   d_instantiate always runs under lock
2166          *   we release i_sem lock before going to sleep
2167          *
2168          * unfortunately sometimes d_revalidate is called with
2169          * and sometimes without i_sem lock held. The following checks
2170          * attempt to deduce when we need to add (and drop resp.) lock
2171          * here. This relies on current (2.6.2) calling coventions:
2172          *
2173          *   lookup_hash is always run under i_sem and is passing NULL
2174          *   as nd
2175          *
2176          *   open(...,O_CREATE,...) calls _lookup_hash under i_sem
2177          *   and sets flags to LOOKUP_OPEN|LOOKUP_CREATE
2178          *
2179          *   all other invocations of ->d_revalidate seem to happen
2180          *   outside of i_sem
2181          */
2182         need_lock = nd &&
2183             (!(nd->flags & LOOKUP_CREATE) || (nd->flags & LOOKUP_PARENT));
2184
2185         if (need_lock)
2186                 down(&dir->i_sem);
2187
2188         if (is_devfsd_or_child(fs_info)) {
2189                 devfs_handle_t de = lookup_info->de;
2190                 struct inode *inode;
2191
2192                 DPRINTK(DEBUG_I_LOOKUP,
2193                         "(%s): dentry: %p inode: %p de: %p by: \"%s\"\n",
2194                         dentry->d_name.name, dentry, dentry->d_inode, de,
2195                         current->comm);
2196                 if (dentry->d_inode)
2197                         goto out;
2198                 if (de == NULL) {
2199                         read_lock(&parent->u.dir.lock);
2200                         de = _devfs_search_dir(parent, dentry->d_name.name,
2201                                                dentry->d_name.len);
2202                         read_unlock(&parent->u.dir.lock);
2203                         if (de == NULL)
2204                                 goto out;
2205                         lookup_info->de = de;
2206                 }
2207                 /*  Create an inode, now that the driver information is available  */
2208                 inode = _devfs_get_vfs_inode(dir->i_sb, de, dentry);
2209                 if (!inode)
2210                         goto out;
2211                 DPRINTK(DEBUG_I_LOOKUP,
2212                         "(%s): new VFS inode(%u): %p de: %p by: \"%s\"\n",
2213                         de->name, de->inode.ino, inode, de, current->comm);
2214                 d_instantiate(dentry, inode);
2215                 goto out;
2216         }
2217         if (lookup_info == NULL)
2218                 goto out;       /*  Early termination  */
2219         read_lock(&parent->u.dir.lock);
2220         if (dentry->d_fsdata) {
2221                 set_current_state(TASK_UNINTERRUPTIBLE);
2222                 add_wait_queue(&lookup_info->wait_queue, &wait);
2223                 read_unlock(&parent->u.dir.lock);
2224                 /* at this point it is always (hopefully) locked */
2225                 up(&dir->i_sem);
2226                 schedule();
2227                 down(&dir->i_sem);
2228                 /*
2229                  * This does not need nor should remove wait from wait_queue.
2230                  * Wait queue head is never reused - nothing is ever added to it
2231                  * after all waiters have been waked up and head itself disappears
2232                  * very soon after it. Moreover it is local variable on stack that
2233                  * is likely to have already disappeared so any reference to it
2234                  * at this point is buggy.
2235                  */
2236
2237         } else
2238                 read_unlock(&parent->u.dir.lock);
2239
2240       out:
2241         if (need_lock)
2242                 up(&dir->i_sem);
2243         return 1;
2244 }                               /*  End Function devfs_d_revalidate_wait  */
2245
2246 /*  Inode operations for device entries follow  */
2247
2248 static struct dentry *devfs_lookup(struct inode *dir, struct dentry *dentry,
2249                                    struct nameidata *nd)
2250 {
2251         struct devfs_entry tmp; /*  Must stay in scope until devfsd idle again  */
2252         struct devfs_lookup_struct lookup_info;
2253         struct fs_info *fs_info = dir->i_sb->s_fs_info;
2254         struct devfs_entry *parent, *de;
2255         struct inode *inode;
2256         struct dentry *retval = NULL;
2257
2258         /*  Set up the dentry operations before anything else, to ensure cleaning
2259            up on any error  */
2260         dentry->d_op = &devfs_dops;
2261         /*  First try to get the devfs entry for this directory  */
2262         parent = get_devfs_entry_from_vfs_inode(dir);
2263         DPRINTK(DEBUG_I_LOOKUP, "(%s): dentry: %p parent: %p by: \"%s\"\n",
2264                 dentry->d_name.name, dentry, parent, current->comm);
2265         if (parent == NULL)
2266                 return ERR_PTR(-ENOENT);
2267         read_lock(&parent->u.dir.lock);
2268         de = _devfs_search_dir(parent, dentry->d_name.name, dentry->d_name.len);
2269         read_unlock(&parent->u.dir.lock);
2270         lookup_info.de = de;
2271         init_waitqueue_head(&lookup_info.wait_queue);
2272         dentry->d_fsdata = &lookup_info;
2273         if (de == NULL) {       /*  Try with devfsd. For any kind of failure, leave a negative dentry
2274                                    so someone else can deal with it (in the case where the sysadmin
2275                                    does a mknod()). It's important to do this before hashing the
2276                                    dentry, so that the devfsd queue is filled before revalidates
2277                                    can start  */
2278                 if (try_modload(parent, fs_info, dentry->d_name.name, dentry->d_name.len, &tmp) < 0) {  /*  Lookup event was not queued to devfsd  */
2279                         d_add(dentry, NULL);
2280                         return NULL;
2281                 }
2282         }
2283         dentry->d_op = &devfs_wait_dops;
2284         d_add(dentry, NULL);    /*  Open the floodgates  */
2285         /*  Unlock directory semaphore, which will release any waiters. They
2286            will get the hashed dentry, and may be forced to wait for
2287            revalidation  */
2288         up(&dir->i_sem);
2289         wait_for_devfsd_finished(fs_info);      /*  If I'm not devfsd, must wait  */
2290         down(&dir->i_sem);      /*  Grab it again because them's the rules  */
2291         de = lookup_info.de;
2292         /*  If someone else has been so kind as to make the inode, we go home
2293            early  */
2294         if (dentry->d_inode)
2295                 goto out;
2296         if (de == NULL) {
2297                 read_lock(&parent->u.dir.lock);
2298                 de = _devfs_search_dir(parent, dentry->d_name.name,
2299                                        dentry->d_name.len);
2300                 read_unlock(&parent->u.dir.lock);
2301                 if (de == NULL)
2302                         goto out;
2303                 /*  OK, there's an entry now, but no VFS inode yet  */
2304         }
2305         /*  Create an inode, now that the driver information is available  */
2306         inode = _devfs_get_vfs_inode(dir->i_sb, de, dentry);
2307         if (!inode) {
2308                 retval = ERR_PTR(-ENOMEM);
2309                 goto out;
2310         }
2311         DPRINTK(DEBUG_I_LOOKUP,
2312                 "(%s): new VFS inode(%u): %p de: %p by: \"%s\"\n", de->name,
2313                 de->inode.ino, inode, de, current->comm);
2314         d_instantiate(dentry, inode);
2315       out:
2316         write_lock(&parent->u.dir.lock);
2317         dentry->d_op = &devfs_dops;
2318         dentry->d_fsdata = NULL;
2319         wake_up(&lookup_info.wait_queue);
2320         write_unlock(&parent->u.dir.lock);
2321         devfs_put(de);
2322         return retval;
2323 }                               /*  End Function devfs_lookup  */
2324
2325 static int devfs_unlink(struct inode *dir, struct dentry *dentry)
2326 {
2327         int unhooked;
2328         struct devfs_entry *de;
2329         struct inode *inode = dentry->d_inode;
2330         struct fs_info *fs_info = dir->i_sb->s_fs_info;
2331
2332         de = get_devfs_entry_from_vfs_inode(inode);
2333         DPRINTK(DEBUG_I_UNLINK, "(%s): de: %p\n", dentry->d_name.name, de);
2334         if (de == NULL)
2335                 return -ENOENT;
2336         if (!de->vfs)
2337                 return -EPERM;
2338         write_lock(&de->parent->u.dir.lock);
2339         unhooked = _devfs_unhook(de);
2340         write_unlock(&de->parent->u.dir.lock);
2341         if (!unhooked)
2342                 return -ENOENT;
2343         if (!is_devfsd_or_child(fs_info))
2344                 devfsd_notify_de(de, DEVFSD_NOTIFY_DELETE, inode->i_mode,
2345                                  inode->i_uid, inode->i_gid, fs_info);
2346         free_dentry(de);
2347         devfs_put(de);
2348         return 0;
2349 }                               /*  End Function devfs_unlink  */
2350
2351 static int devfs_symlink(struct inode *dir, struct dentry *dentry,
2352                          const char *symname)
2353 {
2354         int err;
2355         struct fs_info *fs_info = dir->i_sb->s_fs_info;
2356         struct devfs_entry *parent, *de;
2357         struct inode *inode;
2358
2359         /*  First try to get the devfs entry for this directory  */
2360         parent = get_devfs_entry_from_vfs_inode(dir);
2361         if (parent == NULL)
2362                 return -ENOENT;
2363         err = devfs_do_symlink(parent, dentry->d_name.name, symname, &de);
2364         DPRINTK(DEBUG_DISABLED, "(%s): errcode from <devfs_do_symlink>: %d\n",
2365                 dentry->d_name.name, err);
2366         if (err < 0)
2367                 return err;
2368         de->vfs = TRUE;
2369         de->inode.uid = current->euid;
2370         de->inode.gid = current->egid;
2371         de->inode.atime = CURRENT_TIME;
2372         de->inode.mtime = CURRENT_TIME;
2373         de->inode.ctime = CURRENT_TIME;
2374         if ((inode = _devfs_get_vfs_inode(dir->i_sb, de, dentry)) == NULL)
2375                 return -ENOMEM;
2376         DPRINTK(DEBUG_DISABLED, "(%s): new VFS inode(%u): %p  dentry: %p\n",
2377                 dentry->d_name.name, de->inode.ino, inode, dentry);
2378         d_instantiate(dentry, inode);
2379         if (!is_devfsd_or_child(fs_info))
2380                 devfsd_notify_de(de, DEVFSD_NOTIFY_CREATE, inode->i_mode,
2381                                  inode->i_uid, inode->i_gid, fs_info);
2382         return 0;
2383 }                               /*  End Function devfs_symlink  */
2384
2385 static int devfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
2386 {
2387         int err;
2388         struct fs_info *fs_info = dir->i_sb->s_fs_info;
2389         struct devfs_entry *parent, *de;
2390         struct inode *inode;
2391
2392         mode = (mode & ~S_IFMT) | S_IFDIR;      /*  VFS doesn't pass S_IFMT part  */
2393         parent = get_devfs_entry_from_vfs_inode(dir);
2394         if (parent == NULL)
2395                 return -ENOENT;
2396         de = _devfs_alloc_entry(dentry->d_name.name, dentry->d_name.len, mode);
2397         if (!de)
2398                 return -ENOMEM;
2399         de->vfs = TRUE;
2400         if ((err = _devfs_append_entry(parent, de, NULL)) != 0)
2401                 return err;
2402         de->inode.uid = current->euid;
2403         de->inode.gid = current->egid;
2404         de->inode.atime = CURRENT_TIME;
2405         de->inode.mtime = CURRENT_TIME;
2406         de->inode.ctime = CURRENT_TIME;
2407         if ((inode = _devfs_get_vfs_inode(dir->i_sb, de, dentry)) == NULL)
2408                 return -ENOMEM;
2409         DPRINTK(DEBUG_DISABLED, "(%s): new VFS inode(%u): %p  dentry: %p\n",
2410                 dentry->d_name.name, de->inode.ino, inode, dentry);
2411         d_instantiate(dentry, inode);
2412         if (!is_devfsd_or_child(fs_info))
2413                 devfsd_notify_de(de, DEVFSD_NOTIFY_CREATE, inode->i_mode,
2414                                  inode->i_uid, inode->i_gid, fs_info);
2415         return 0;
2416 }                               /*  End Function devfs_mkdir  */
2417
2418 static int devfs_rmdir(struct inode *dir, struct dentry *dentry)
2419 {
2420         int err = 0;
2421         struct devfs_entry *de;
2422         struct fs_info *fs_info = dir->i_sb->s_fs_info;
2423         struct inode *inode = dentry->d_inode;
2424
2425         if (dir->i_sb->s_fs_info != inode->i_sb->s_fs_info)
2426                 return -EINVAL;
2427         de = get_devfs_entry_from_vfs_inode(inode);
2428         if (de == NULL)
2429                 return -ENOENT;
2430         if (!S_ISDIR(de->mode))
2431                 return -ENOTDIR;
2432         if (!de->vfs)
2433                 return -EPERM;
2434         /*  First ensure the directory is empty and will stay that way  */
2435         write_lock(&de->u.dir.lock);
2436         if (de->u.dir.first)
2437                 err = -ENOTEMPTY;
2438         else
2439                 de->u.dir.no_more_additions = TRUE;
2440         write_unlock(&de->u.dir.lock);
2441         if (err)
2442                 return err;
2443         /*  Now unhook the directory from its parent  */
2444         write_lock(&de->parent->u.dir.lock);
2445         if (!_devfs_unhook(de))
2446                 err = -ENOENT;
2447         write_unlock(&de->parent->u.dir.lock);
2448         if (err)
2449                 return err;
2450         if (!is_devfsd_or_child(fs_info))
2451                 devfsd_notify_de(de, DEVFSD_NOTIFY_DELETE, inode->i_mode,
2452                                  inode->i_uid, inode->i_gid, fs_info);
2453         free_dentry(de);
2454         devfs_put(de);
2455         return 0;
2456 }                               /*  End Function devfs_rmdir  */
2457
2458 static int devfs_mknod(struct inode *dir, struct dentry *dentry, int mode,
2459                        dev_t rdev)
2460 {
2461         int err;
2462         struct fs_info *fs_info = dir->i_sb->s_fs_info;
2463         struct devfs_entry *parent, *de;
2464         struct inode *inode;
2465
2466         DPRINTK(DEBUG_I_MKNOD, "(%s): mode: 0%o  dev: %u:%u\n",
2467                 dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
2468         parent = get_devfs_entry_from_vfs_inode(dir);
2469         if (parent == NULL)
2470                 return -ENOENT;
2471         de = _devfs_alloc_entry(dentry->d_name.name, dentry->d_name.len, mode);
2472         if (!de)
2473                 return -ENOMEM;
2474         de->vfs = TRUE;
2475         if (S_ISCHR(mode) || S_ISBLK(mode))
2476                 de->u.dev = rdev;
2477         if ((err = _devfs_append_entry(parent, de, NULL)) != 0)
2478                 return err;
2479         de->inode.uid = current->euid;
2480         de->inode.gid = current->egid;
2481         de->inode.atime = CURRENT_TIME;
2482         de->inode.mtime = CURRENT_TIME;
2483         de->inode.ctime = CURRENT_TIME;
2484         if ((inode = _devfs_get_vfs_inode(dir->i_sb, de, dentry)) == NULL)
2485                 return -ENOMEM;
2486         DPRINTK(DEBUG_I_MKNOD, ":   new VFS inode(%u): %p  dentry: %p\n",
2487                 de->inode.ino, inode, dentry);
2488         d_instantiate(dentry, inode);
2489         if (!is_devfsd_or_child(fs_info))
2490                 devfsd_notify_de(de, DEVFSD_NOTIFY_CREATE, inode->i_mode,
2491                                  inode->i_uid, inode->i_gid, fs_info);
2492         return 0;
2493 }                               /*  End Function devfs_mknod  */
2494
2495 static int devfs_follow_link(struct dentry *dentry, struct nameidata *nd)
2496 {
2497         struct devfs_entry *p = get_devfs_entry_from_vfs_inode(dentry->d_inode);
2498         nd_set_link(nd, p ? p->u.symlink.linkname : ERR_PTR(-ENODEV));
2499         return 0;
2500 }                               /*  End Function devfs_follow_link  */
2501
2502 static struct inode_operations devfs_iops = {
2503         .setattr = devfs_notify_change,
2504 };
2505
2506 static struct inode_operations devfs_dir_iops = {
2507         .lookup = devfs_lookup,
2508         .unlink = devfs_unlink,
2509         .symlink = devfs_symlink,
2510         .mkdir = devfs_mkdir,
2511         .rmdir = devfs_rmdir,
2512         .mknod = devfs_mknod,
2513         .setattr = devfs_notify_change,
2514 };
2515
2516 static struct inode_operations devfs_symlink_iops = {
2517         .readlink = generic_readlink,
2518         .follow_link = devfs_follow_link,
2519         .setattr = devfs_notify_change,
2520 };
2521
2522 static int devfs_fill_super(struct super_block *sb, void *data, int silent)
2523 {
2524         struct inode *root_inode = NULL;
2525
2526         if (_devfs_get_root_entry() == NULL)
2527                 goto out_no_root;
2528         atomic_set(&fs_info.devfsd_overrun_count, 0);
2529         init_waitqueue_head(&fs_info.devfsd_wait_queue);
2530         init_waitqueue_head(&fs_info.revalidate_wait_queue);
2531         fs_info.sb = sb;
2532         sb->s_fs_info = &fs_info;
2533         sb->s_blocksize = 1024;
2534         sb->s_blocksize_bits = 10;
2535         sb->s_magic = DEVFS_SUPER_MAGIC;
2536         sb->s_op = &devfs_sops;
2537         if ((root_inode = _devfs_get_vfs_inode(sb, root_entry, NULL)) == NULL)
2538                 goto out_no_root;
2539         sb->s_root = d_alloc_root(root_inode);
2540         if (!sb->s_root)
2541                 goto out_no_root;
2542         DPRINTK(DEBUG_S_READ, "(): made devfs ptr: %p\n", sb->s_fs_info);
2543         return 0;
2544
2545       out_no_root:
2546         PRINTK("(): get root inode failed\n");
2547         if (root_inode)
2548                 iput(root_inode);
2549         return -EINVAL;
2550 }                               /*  End Function devfs_fill_super  */
2551
2552 static struct super_block *devfs_get_sb(struct file_system_type *fs_type,
2553                                         int flags, const char *dev_name,
2554                                         void *data)
2555 {
2556         return get_sb_single(fs_type, flags, data, devfs_fill_super);
2557 }
2558
2559 static struct file_system_type devfs_fs_type = {
2560         .name = DEVFS_NAME,
2561         .get_sb = devfs_get_sb,
2562         .kill_sb = kill_anon_super,
2563 };
2564
2565 /*  File operations for devfsd follow  */
2566
2567 static ssize_t devfsd_read(struct file *file, char __user *buf, size_t len,
2568                            loff_t * ppos)
2569 {
2570         int done = FALSE;
2571         int ival;
2572         loff_t pos, devname_offset, tlen, rpos;
2573         devfs_handle_t de;
2574         struct devfsd_buf_entry *entry;
2575         struct fs_info *fs_info = file->f_dentry->d_inode->i_sb->s_fs_info;
2576         struct devfsd_notify_struct *info = fs_info->devfsd_info;
2577         DECLARE_WAITQUEUE(wait, current);
2578
2579         /*  Verify the task has grabbed the queue  */
2580         if (fs_info->devfsd_task != current)
2581                 return -EPERM;
2582         info->major = 0;
2583         info->minor = 0;
2584         /*  Block for a new entry  */
2585         set_current_state(TASK_INTERRUPTIBLE);
2586         add_wait_queue(&fs_info->devfsd_wait_queue, &wait);
2587         while (devfsd_queue_empty(fs_info)) {
2588                 fs_info->devfsd_sleeping = TRUE;
2589                 wake_up(&fs_info->revalidate_wait_queue);
2590                 schedule();
2591                 fs_info->devfsd_sleeping = FALSE;
2592                 if (signal_pending(current)) {
2593                         remove_wait_queue(&fs_info->devfsd_wait_queue, &wait);
2594                         __set_current_state(TASK_RUNNING);
2595                         return -EINTR;
2596                 }
2597                 set_current_state(TASK_INTERRUPTIBLE);
2598         }
2599         remove_wait_queue(&fs_info->devfsd_wait_queue, &wait);
2600         __set_current_state(TASK_RUNNING);
2601         /*  Now play with the data  */
2602         ival = atomic_read(&fs_info->devfsd_overrun_count);
2603         info->overrun_count = ival;
2604         entry = fs_info->devfsd_first_event;
2605         info->type = entry->type;
2606         info->mode = entry->mode;
2607         info->uid = entry->uid;
2608         info->gid = entry->gid;
2609         de = entry->de;
2610         if (S_ISCHR(de->mode) || S_ISBLK(de->mode)) {
2611                 info->major = MAJOR(de->u.dev);
2612                 info->minor = MINOR(de->u.dev);
2613         }
2614         pos = devfs_generate_path(de, info->devname, DEVFS_PATHLEN);
2615         if (pos < 0)
2616                 return pos;
2617         info->namelen = DEVFS_PATHLEN - pos - 1;
2618         if (info->mode == 0)
2619                 info->mode = de->mode;
2620         devname_offset = info->devname - (char *)info;
2621         rpos = *ppos;
2622         if (rpos < devname_offset) {
2623                 /*  Copy parts of the header  */
2624                 tlen = devname_offset - rpos;
2625                 if (tlen > len)
2626                         tlen = len;
2627                 if (copy_to_user(buf, (char *)info + rpos, tlen)) {
2628                         return -EFAULT;
2629                 }
2630                 rpos += tlen;
2631                 buf += tlen;
2632                 len -= tlen;
2633         }
2634         if ((rpos >= devname_offset) && (len > 0)) {
2635                 /*  Copy the name  */
2636                 tlen = info->namelen + 1;
2637                 if (tlen > len)
2638                         tlen = len;
2639                 else
2640                         done = TRUE;
2641                 if (copy_to_user
2642                     (buf, info->devname + pos + rpos - devname_offset, tlen)) {
2643                         return -EFAULT;
2644                 }
2645                 rpos += tlen;
2646         }
2647         tlen = rpos - *ppos;
2648         if (done) {
2649                 devfs_handle_t parent;
2650
2651                 spin_lock(&fs_info->devfsd_buffer_lock);
2652                 fs_info->devfsd_first_event = entry->next;
2653                 if (entry->next == NULL)
2654                         fs_info->devfsd_last_event = NULL;
2655                 spin_unlock(&fs_info->devfsd_buffer_lock);
2656                 for (; de != NULL; de = parent) {
2657                         parent = de->parent;
2658                         devfs_put(de);
2659                 }
2660                 kmem_cache_free(devfsd_buf_cache, entry);
2661                 if (ival > 0)
2662                         atomic_sub(ival, &fs_info->devfsd_overrun_count);
2663                 *ppos = 0;
2664         } else
2665                 *ppos = rpos;
2666         return tlen;
2667 }                               /*  End Function devfsd_read  */
2668
2669 static int devfsd_ioctl(struct inode *inode, struct file *file,
2670                         unsigned int cmd, unsigned long arg)
2671 {
2672         int ival;
2673         struct fs_info *fs_info = inode->i_sb->s_fs_info;
2674
2675         switch (cmd) {
2676         case DEVFSDIOC_GET_PROTO_REV:
2677                 ival = DEVFSD_PROTOCOL_REVISION_KERNEL;
2678                 if (copy_to_user((void __user *)arg, &ival, sizeof ival))
2679                         return -EFAULT;
2680                 break;
2681         case DEVFSDIOC_SET_EVENT_MASK:
2682                 /*  Ensure only one reader has access to the queue. This scheme will
2683                    work even if the global kernel lock were to be removed, because it
2684                    doesn't matter who gets in first, as long as only one gets it  */
2685                 if (fs_info->devfsd_task == NULL) {
2686                         static spinlock_t lock = SPIN_LOCK_UNLOCKED;
2687
2688                         if (!spin_trylock(&lock))
2689                                 return -EBUSY;
2690                         if (fs_info->devfsd_task != NULL) {     /*  We lost the race...  */
2691                                 spin_unlock(&lock);
2692                                 return -EBUSY;
2693                         }
2694                         fs_info->devfsd_task = current;
2695                         spin_unlock(&lock);
2696                         fs_info->devfsd_pgrp =
2697                             (process_group(current) ==
2698                              current->pid) ? process_group(current) : 0;
2699                         fs_info->devfsd_file = file;
2700                         fs_info->devfsd_info =
2701                             kmalloc(sizeof *fs_info->devfsd_info, GFP_KERNEL);
2702                         if (!fs_info->devfsd_info) {
2703                                 devfsd_close(inode, file);
2704                                 return -ENOMEM;
2705                         }
2706                 } else if (fs_info->devfsd_task != current)
2707                         return -EBUSY;
2708                 fs_info->devfsd_event_mask = arg;       /*  Let the masses come forth  */
2709                 break;
2710         case DEVFSDIOC_RELEASE_EVENT_QUEUE:
2711                 if (fs_info->devfsd_file != file)
2712                         return -EPERM;
2713                 return devfsd_close(inode, file);
2714                 /*break; */
2715 #ifdef CONFIG_DEVFS_DEBUG
2716         case DEVFSDIOC_SET_DEBUG_MASK:
2717                 if (copy_from_user(&ival, (void __user *)arg, sizeof ival))
2718                         return -EFAULT;
2719                 devfs_debug = ival;
2720                 break;
2721 #endif
2722         default:
2723                 return -ENOIOCTLCMD;
2724         }
2725         return 0;
2726 }                               /*  End Function devfsd_ioctl  */
2727
2728 static int devfsd_close(struct inode *inode, struct file *file)
2729 {
2730         struct devfsd_buf_entry *entry, *next;
2731         struct fs_info *fs_info = inode->i_sb->s_fs_info;
2732
2733         if (fs_info->devfsd_file != file)
2734                 return 0;
2735         fs_info->devfsd_event_mask = 0;
2736         fs_info->devfsd_file = NULL;
2737         spin_lock(&fs_info->devfsd_buffer_lock);
2738         entry = fs_info->devfsd_first_event;
2739         fs_info->devfsd_first_event = NULL;
2740         fs_info->devfsd_last_event = NULL;
2741         if (fs_info->devfsd_info) {
2742                 kfree(fs_info->devfsd_info);
2743                 fs_info->devfsd_info = NULL;
2744         }
2745         spin_unlock(&fs_info->devfsd_buffer_lock);
2746         fs_info->devfsd_pgrp = 0;
2747         fs_info->devfsd_task = NULL;
2748         wake_up(&fs_info->revalidate_wait_queue);
2749         for (; entry; entry = next) {
2750                 next = entry->next;
2751                 kmem_cache_free(devfsd_buf_cache, entry);
2752         }
2753         return 0;
2754 }                               /*  End Function devfsd_close  */
2755
2756 #ifdef CONFIG_DEVFS_DEBUG
2757 static ssize_t stat_read(struct file *file, char __user *buf, size_t len,
2758                          loff_t * ppos)
2759 {
2760         ssize_t num;
2761         char txt[80];
2762
2763         num = sprintf(txt, "Number of entries: %u  number of bytes: %u\n",
2764                       stat_num_entries, stat_num_bytes) + 1;
2765         if (*ppos >= num)
2766                 return 0;
2767         if (*ppos + len > num)
2768                 len = num - *ppos;
2769         if (copy_to_user(buf, txt + *ppos, len))
2770                 return -EFAULT;
2771         *ppos += len;
2772         return len;
2773 }                               /*  End Function stat_read  */
2774 #endif
2775
2776 static int __init init_devfs_fs(void)
2777 {
2778         int err;
2779         int major;
2780         struct devfs_entry *devfsd;
2781 #ifdef CONFIG_DEVFS_DEBUG
2782         struct devfs_entry *stat;
2783 #endif
2784
2785         if (_devfs_get_root_entry() == NULL)
2786                 return -ENOMEM;
2787
2788         printk(KERN_INFO "%s: %s Richard Gooch (rgooch@atnf.csiro.au)\n",
2789                DEVFS_NAME, DEVFS_VERSION);
2790         devfsd_buf_cache = kmem_cache_create("devfsd_event",
2791                                              sizeof(struct devfsd_buf_entry),
2792                                              0, 0, NULL, NULL);
2793         if (!devfsd_buf_cache)
2794                 OOPS("(): unable to allocate event slab\n");
2795 #ifdef CONFIG_DEVFS_DEBUG
2796         devfs_debug = devfs_debug_init;
2797         printk(KERN_INFO "%s: devfs_debug: 0x%0x\n", DEVFS_NAME, devfs_debug);
2798 #endif
2799         printk(KERN_INFO "%s: boot_options: 0x%0x\n", DEVFS_NAME, boot_options);
2800
2801         /* register special device for devfsd communication */
2802         major = register_chrdev(0, "devfs", &devfs_fops);
2803         if (major < 0)
2804                 return major;
2805
2806         /*  And create the entry for ".devfsd"  */
2807         devfsd = _devfs_alloc_entry(".devfsd", 0, S_IFCHR | S_IRUSR | S_IWUSR);
2808         if (devfsd == NULL)
2809                 return -ENOMEM;
2810         devfsd->u.dev = MKDEV(major, 0);
2811         _devfs_append_entry(root_entry, devfsd, NULL);
2812
2813 #ifdef CONFIG_DEVFS_DEBUG
2814         stat = _devfs_alloc_entry(".stat", 0, S_IFCHR | S_IRUGO);
2815         if (stat == NULL)
2816                 return -ENOMEM;
2817         stat->u.dev = MKDEV(major, 1);
2818         _devfs_append_entry(root_entry, stat, NULL);
2819 #endif
2820
2821         err = register_filesystem(&devfs_fs_type);
2822         return err;
2823 }                               /*  End Function init_devfs_fs  */
2824
2825 void __init mount_devfs_fs(void)
2826 {
2827         int err;
2828
2829         if (!(boot_options & OPTION_MOUNT))
2830                 return;
2831         err = do_mount("none", "/dev", "devfs", 0, NULL);
2832         if (err == 0)
2833                 printk(KERN_INFO "Mounted devfs on /dev\n");
2834         else
2835                 PRINTK("(): unable to mount devfs, err: %d\n", err);
2836 }                               /*  End Function mount_devfs_fs  */
2837
2838 module_init(init_devfs_fs)