v2.4.9.9 -> v2.4.9.10
[opensuse:kernel.git] / fs / devfs / base.c
1 /*  devfs (Device FileSystem) driver.
2
3     Copyright (C) 1998-2001  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 */
515 #include <linux/types.h>
516 #include <linux/errno.h>
517 #include <linux/sched.h>
518 #include <linux/tty.h>
519 #include <linux/timer.h>
520 #include <linux/config.h>
521 #include <linux/kernel.h>
522 #include <linux/wait.h>
523 #include <linux/string.h>
524 #include <linux/slab.h>
525 #include <linux/ioport.h>
526 #include <linux/delay.h>
527 #include <linux/ctype.h>
528 #include <linux/mm.h>
529 #include <linux/module.h>
530 #include <linux/init.h>
531 #include <linux/devfs_fs.h>
532 #include <linux/devfs_fs_kernel.h>
533 #include <linux/smp_lock.h>
534 #include <linux/smp.h>
535 #include <linux/version.h>
536
537 #include <asm/uaccess.h>
538 #include <asm/io.h>
539 #include <asm/processor.h>
540 #include <asm/system.h>
541 #include <asm/pgtable.h>
542 #include <asm/segment.h>
543 #include <asm/bitops.h>
544 #include <asm/atomic.h>
545
546 #define DEVFS_VERSION            "0.107 (20010709)"
547
548 #define DEVFS_NAME "devfs"
549
550 #define INODE_TABLE_INC 250
551 #define FIRST_INODE 1
552
553 #define STRING_LENGTH 256
554
555 #ifndef TRUE
556 #  define TRUE 1
557 #  define FALSE 0
558 #endif
559
560 #define IS_HIDDEN(de) (( ((de)->hide && !is_devfsd_or_child(fs_info)) || (!(de)->registered&& !(de)->show_unreg)))
561
562 #define DEBUG_NONE         0x00000
563 #define DEBUG_MODULE_LOAD  0x00001
564 #define DEBUG_REGISTER     0x00002
565 #define DEBUG_UNREGISTER   0x00004
566 #define DEBUG_SET_FLAGS    0x00008
567 #define DEBUG_S_PUT        0x00010
568 #define DEBUG_I_LOOKUP     0x00020
569 #define DEBUG_I_CREATE     0x00040
570 #define DEBUG_I_READ       0x00080
571 #define DEBUG_I_WRITE      0x00100
572 #define DEBUG_I_UNLINK     0x00200
573 #define DEBUG_I_RLINK      0x00400
574 #define DEBUG_I_FLINK      0x00800
575 #define DEBUG_I_MKNOD      0x01000
576 #define DEBUG_F_READDIR    0x02000
577 #define DEBUG_D_DELETE     0x04000
578 #define DEBUG_D_RELEASE    0x08000
579 #define DEBUG_D_IPUT       0x10000
580 #define DEBUG_ALL          (DEBUG_MODULE_LOAD | DEBUG_REGISTER | \
581                             DEBUG_SET_FLAGS | DEBUG_I_LOOKUP |   \
582                             DEBUG_I_UNLINK | DEBUG_I_MKNOD |     \
583                             DEBUG_D_RELEASE | DEBUG_D_IPUT)
584 #define DEBUG_DISABLED     DEBUG_NONE
585
586 #define OPTION_NONE             0x00
587 #define OPTION_SHOW             0x01
588 #define OPTION_MOUNT            0x02
589 #define OPTION_ONLY             0x04
590
591 #define OOPS(format, args...) {printk (format, ## args); \
592                                printk ("Forcing Oops\n"); \
593                                BUG();}
594
595 struct directory_type
596 {
597     struct devfs_entry *first;
598     struct devfs_entry *last;
599     unsigned int num_removable;
600 };
601
602 struct file_type
603 {
604     unsigned long size;
605 };
606
607 struct device_type
608 {
609     unsigned short major;
610     unsigned short minor;
611 };
612
613 struct fcb_type  /*  File, char, block type  */
614 {
615     uid_t default_uid;
616     gid_t default_gid;
617     void *ops;
618     union 
619     {
620         struct file_type file;
621         struct device_type device;
622     }
623     u;
624     unsigned char auto_owner:1;
625     unsigned char aopen_notify:1;
626     unsigned char removable:1;  /*  Belongs in device_type, but save space   */
627     unsigned char open:1;       /*  Not entirely correct                     */
628     unsigned char autogen:1;    /*  Belongs in device_type, but save space   */
629 };
630
631 struct symlink_type
632 {
633     unsigned int length;  /*  Not including the NULL-termimator  */
634     char *linkname;       /*  This is NULL-terminated            */
635 };
636
637 struct fifo_type
638 {
639     uid_t uid;
640     gid_t gid;
641 };
642
643 struct devfs_inode  /*  This structure is for "persistent" inode storage  */
644 {
645     time_t atime;
646     time_t mtime;
647     time_t ctime;
648     unsigned int ino;          /*  Inode number as seen in the VFS  */
649     struct dentry *dentry;
650     umode_t mode;
651     uid_t uid;
652     gid_t gid;
653     nlink_t nlink;
654 };
655
656 struct devfs_entry
657 {
658     void *info;
659     union 
660     {
661         struct directory_type dir;
662         struct fcb_type fcb;
663         struct symlink_type symlink;
664         struct fifo_type fifo;
665     }
666     u;
667     struct devfs_entry *prev;    /*  Previous entry in the parent directory  */
668     struct devfs_entry *next;    /*  Next entry in the parent directory      */
669     struct devfs_entry *parent;  /*  The parent directory                    */
670     struct devfs_entry *slave;   /*  Another entry to unregister             */
671     struct devfs_inode inode;
672     umode_t mode;
673     unsigned short namelen;  /*  I think 64k+ filenames are a way off...  */
674     unsigned char registered:1;
675     unsigned char show_unreg:1;
676     unsigned char hide:1;
677     unsigned char no_persistence:1;
678     char name[1];            /*  This is just a dummy: the allocated array is
679                                  bigger. This is NULL-terminated  */
680 };
681
682 /*  The root of the device tree  */
683 static struct devfs_entry *root_entry;
684
685 struct devfsd_buf_entry
686 {
687     void *data;
688     unsigned int type;
689     umode_t mode;
690     uid_t uid;
691     gid_t gid;
692 };
693
694 struct fs_info      /*  This structure is for the mounted devfs  */
695 {
696     unsigned int num_inodes;    /*  Number of inodes created         */
697     unsigned int table_size;    /*  Size of the inode pointer table  */
698     struct devfs_entry **table;
699     struct super_block *sb;
700     volatile struct devfsd_buf_entry *devfsd_buffer;
701     spinlock_t devfsd_buffer_lock;
702     volatile unsigned int devfsd_buf_in;
703     volatile unsigned int devfsd_buf_out;
704     volatile int devfsd_sleeping;
705     volatile struct task_struct *devfsd_task;
706     volatile struct file *devfsd_file;
707     struct devfsd_notify_struct *devfsd_info;
708     volatile unsigned long devfsd_event_mask;
709     atomic_t devfsd_overrun_count;
710     wait_queue_head_t devfsd_wait_queue;
711     wait_queue_head_t revalidate_wait_queue;
712 };
713
714 static struct fs_info fs_info = {devfsd_buffer_lock: SPIN_LOCK_UNLOCKED};
715 static const int devfsd_buf_size = PAGE_SIZE / sizeof(struct devfsd_buf_entry);
716 #ifdef CONFIG_DEVFS_DEBUG
717 static unsigned int devfs_debug_init __initdata = DEBUG_NONE;
718 static unsigned int devfs_debug = DEBUG_NONE;
719 #endif
720
721 #ifdef CONFIG_DEVFS_MOUNT
722 static unsigned int boot_options = OPTION_MOUNT;
723 #else
724 static unsigned int boot_options = OPTION_NONE;
725 #endif
726
727 /*  Forward function declarations  */
728 static struct devfs_entry *search_for_entry (struct devfs_entry *dir,
729                                              const char *name,
730                                              unsigned int namelen, int mkdir,
731                                              int mkfile, int *is_new,
732                                              int traverse_symlink);
733 static ssize_t devfsd_read (struct file *file, char *buf, size_t len,
734                             loff_t *ppos);
735 static int devfsd_ioctl (struct inode *inode, struct file *file,
736                          unsigned int cmd, unsigned long arg);
737 static int devfsd_close (struct inode *inode, struct file *file);
738
739
740 /*  Devfs daemon file operations  */
741 static struct file_operations devfsd_fops =
742 {
743     read:    devfsd_read,
744     ioctl:   devfsd_ioctl,
745     release: devfsd_close,
746 };
747
748
749 /*  Support functions follow  */
750
751
752 /**
753  *      search_for_entry_in_dir - Search for a devfs entry inside another devfs entry.
754  *      @parent:  The parent devfs entry.
755  *      @name:  The name of the entry.
756  *      @namelen:  The number of characters in @name.
757  *      @traverse_symlink:  If %TRUE then the entry is traversed if it is a symlink.
758  *
759  *  Search for a devfs entry inside another devfs entry and returns a pointer
760  *   to the entry on success, else %NULL.
761  */
762
763 static struct devfs_entry *search_for_entry_in_dir (struct devfs_entry *parent,
764                                                     const char *name,
765                                                     unsigned int namelen,
766                                                     int traverse_symlink)
767 {
768     struct devfs_entry *curr;
769
770     if ( !S_ISDIR (parent->mode) )
771     {
772         printk ("%s: entry is not a directory\n", DEVFS_NAME);
773         return NULL;
774     }
775     for (curr = parent->u.dir.first; curr != NULL; curr = curr->next)
776     {
777         if (curr->namelen != namelen) continue;
778         if (memcmp (curr->name, name, namelen) == 0) break;
779         /*  Not found: try the next one  */
780     }
781     if (curr == NULL) return NULL;
782     if (!S_ISLNK (curr->mode) || !traverse_symlink) return curr;
783     /*  Need to follow the link: this is a stack chomper  */
784     return search_for_entry (parent,
785                              curr->u.symlink.linkname, curr->u.symlink.length,
786                              FALSE, FALSE, NULL, TRUE);
787 }   /*  End Function search_for_entry_in_dir  */
788
789 static struct devfs_entry *create_entry (struct devfs_entry *parent,
790                                          const char *name,unsigned int namelen)
791 {
792     struct devfs_entry *new, **table;
793
794     /*  First ensure table size is enough  */
795     if (fs_info.num_inodes >= fs_info.table_size)
796     {
797         if ( ( table = kmalloc (sizeof *table *
798                                 (fs_info.table_size + INODE_TABLE_INC),
799                                 GFP_KERNEL) ) == NULL ) return NULL;
800         fs_info.table_size += INODE_TABLE_INC;
801 #ifdef CONFIG_DEVFS_DEBUG
802         if (devfs_debug & DEBUG_I_CREATE)
803             printk ("%s: create_entry(): grew inode table to: %u entries\n",
804                     DEVFS_NAME, fs_info.table_size);
805 #endif
806         if (fs_info.table)
807         {
808             memcpy (table, fs_info.table, sizeof *table *fs_info.num_inodes);
809             kfree (fs_info.table);
810         }
811         fs_info.table = table;
812     }
813     if ( name && (namelen < 1) ) namelen = strlen (name);
814     if ( ( new = kmalloc (sizeof *new + namelen, GFP_KERNEL) ) == NULL )
815         return NULL;
816     /*  Magic: this will set the ctime to zero, thus subsequent lookups will
817         trigger the call to <update_devfs_inode_from_entry>  */
818     memset (new, 0, sizeof *new + namelen);
819     new->parent = parent;
820     if (name) memcpy (new->name, name, namelen);
821     new->namelen = namelen;
822     new->inode.ino = fs_info.num_inodes + FIRST_INODE;
823     new->inode.nlink = 1;
824     fs_info.table[fs_info.num_inodes] = new;
825     ++fs_info.num_inodes;
826     if (parent == NULL) return new;
827     new->prev = parent->u.dir.last;
828     /*  Insert into the parent directory's list of children  */
829     if (parent->u.dir.first == NULL) parent->u.dir.first = new;
830     else parent->u.dir.last->next = new;
831     parent->u.dir.last = new;
832     return new;
833 }   /*  End Function create_entry  */
834
835 static void update_devfs_inode_from_entry (struct devfs_entry *de)
836 {
837     if (de == NULL) return;
838     if ( S_ISDIR (de->mode) )
839     {
840         de->inode.mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
841         de->inode.uid = 0;
842         de->inode.gid = 0;
843     }
844     else if ( S_ISLNK (de->mode) )
845     {
846         de->inode.mode = S_IFLNK | S_IRUGO | S_IXUGO;
847         de->inode.uid = 0;
848         de->inode.gid = 0;
849     }
850     else if ( S_ISFIFO (de->mode) )
851     {
852         de->inode.mode = de->mode;
853         de->inode.uid = de->u.fifo.uid;
854         de->inode.gid = de->u.fifo.gid;
855     }
856     else
857     {
858         if (de->u.fcb.auto_owner)
859             de->inode.mode = (de->mode & ~S_IALLUGO) | S_IRUGO | S_IWUGO;
860         else de->inode.mode = de->mode;
861         de->inode.uid = de->u.fcb.default_uid;
862         de->inode.gid = de->u.fcb.default_gid;
863     }
864 }   /*  End Function update_devfs_inode_from_entry  */
865
866 /**
867  *      get_root_entry - Get the root devfs entry.
868  *
869  *      Returns the root devfs entry on success, else %NULL.
870  */
871
872 static struct devfs_entry *get_root_entry (void)
873 {
874     kdev_t devnum;
875     struct devfs_entry *new;
876
877     /*  Always ensure the root is created  */
878     if (root_entry != NULL) return root_entry;
879     if ( ( root_entry = create_entry (NULL, NULL, 0) ) == NULL ) return NULL;
880     root_entry->mode = S_IFDIR;
881     /*  Force an inode update, because lookup() is never done for the root  */
882     update_devfs_inode_from_entry (root_entry);
883     root_entry->registered = TRUE;
884     /*  And create the entry for ".devfsd"  */
885     if ( ( new = create_entry (root_entry, ".devfsd", 0) ) == NULL )
886         return NULL;
887     devnum = devfs_alloc_devnum (DEVFS_SPECIAL_CHR);
888     new->u.fcb.u.device.major = MAJOR (devnum);
889     new->u.fcb.u.device.minor = MINOR (devnum);
890     new->mode = S_IFCHR | S_IRUSR | S_IWUSR;
891     new->u.fcb.default_uid = 0;
892     new->u.fcb.default_gid = 0;
893     new->u.fcb.ops = &devfsd_fops;
894     new->registered = TRUE;
895     return root_entry;
896 }   /*  End Function get_root_entry  */
897
898
899 /**
900  *      search_for_entry - Search for an entry in the devfs tree.
901  *      @dir: The parent directory to search from. If this is %NULL the root is used
902  *      @name: The name of the entry.
903  *      @namelen: The number of characters in @name.
904  *      @mkdir: If %TRUE intermediate directories are created as needed.
905  *      @mkfile: If %TRUE the file entry is created if it doesn't exist.
906  *      @is_new: If the returned entry was newly made, %TRUE is written here. If
907  *              this is %NULL nothing is written here.
908  *      @traverse_symlink: If %TRUE then symbolic links are traversed.
909  *
910  *      If the entry is created, then it will be in the unregistered state.
911  *      Returns a pointer to the entry on success, else %NULL.
912  */
913
914 static struct devfs_entry *search_for_entry (struct devfs_entry *dir,
915                                              const char *name,
916                                              unsigned int namelen, int mkdir,
917                                              int mkfile, int *is_new,
918                                              int traverse_symlink)
919 {
920     int len;
921     const char *subname, *stop, *ptr;
922     struct devfs_entry *entry;
923
924     if (is_new) *is_new = FALSE;
925     if (dir == NULL) dir = get_root_entry ();
926     if (dir == NULL) return NULL;
927     /*  Extract one filename component  */
928     subname = name;
929     stop = name + namelen;
930     while (subname < stop)
931     {
932         /*  Search for a possible '/'  */
933         for (ptr = subname; (ptr < stop) && (*ptr != '/'); ++ptr);
934         if (ptr >= stop)
935         {
936             /*  Look for trailing component  */
937             len = stop - subname;
938             entry = search_for_entry_in_dir (dir, subname, len,
939                                              traverse_symlink);
940             if (entry != NULL) return entry;
941             if (!mkfile) return NULL;
942             entry = create_entry (dir, subname, len);
943             if (entry && is_new) *is_new = TRUE;
944             return entry;
945         }
946         /*  Found '/': search for directory  */
947         if (strncmp (subname, "../", 3) == 0)
948         {
949             /*  Going up  */
950             dir = dir->parent;
951             if (dir == NULL) return NULL;  /*  Cannot escape from devfs  */
952             subname += 3;
953             continue;
954         }
955         len = ptr - subname;
956         entry = search_for_entry_in_dir (dir, subname, len, traverse_symlink);
957         if (!entry && !mkdir) return NULL;
958         if (entry == NULL)
959         {
960             /*  Make it  */
961             if ( ( entry = create_entry (dir, subname, len) ) == NULL )
962                 return NULL;
963             entry->mode = S_IFDIR | S_IRUGO | S_IXUGO | S_IWUSR;
964             if (is_new) *is_new = TRUE;
965         }
966         if ( !S_ISDIR (entry->mode) )
967         {
968             printk ("%s: existing non-directory entry\n", DEVFS_NAME);
969             return NULL;
970         }
971         /*  Ensure an unregistered entry is re-registered and visible  */
972         entry->hide = FALSE;
973         entry->registered = TRUE;
974         subname = ptr + 1;
975         dir = entry;
976     }
977     return NULL;
978 }   /*  End Function search_for_entry  */
979
980
981 /**
982  *      find_by_dev - Find a devfs entry in a directory.
983  *      @dir: The directory where to search
984  *      @major: The major number to search for.
985  *      @minor: The minor number to search for.
986  *      @type: The type of special file to search for. This may be either
987  *              %DEVFS_SPECIAL_CHR or %DEVFS_SPECIAL_BLK.
988  *
989  *      Returns the devfs_entry pointer on success, else %NULL.
990  */
991
992 static struct devfs_entry *find_by_dev (struct devfs_entry *dir,
993                                         unsigned int major, unsigned int minor,
994                                         char type)
995 {
996     struct devfs_entry *entry, *de;
997
998     if (dir == NULL) return NULL;
999     if ( !S_ISDIR (dir->mode) )
1000     {
1001         printk ("%s: find_by_dev(): not a directory\n", DEVFS_NAME);
1002         return NULL;
1003     }
1004     /*  First search files in this directory  */
1005     for (entry = dir->u.dir.first; entry != NULL; entry = entry->next)
1006     {
1007         if ( !S_ISCHR (entry->mode) && !S_ISBLK (entry->mode) ) continue;
1008         if ( S_ISCHR (entry->mode) && (type != DEVFS_SPECIAL_CHR) ) continue;
1009         if ( S_ISBLK (entry->mode) && (type != DEVFS_SPECIAL_BLK) ) continue;
1010         if ( (entry->u.fcb.u.device.major == major) &&
1011              (entry->u.fcb.u.device.minor == minor) ) return entry;
1012         /*  Not found: try the next one  */
1013     }
1014     /*  Now recursively search the subdirectories: this is a stack chomper  */
1015     for (entry = dir->u.dir.first; entry != NULL; entry = entry->next)
1016     {
1017         if ( !S_ISDIR (entry->mode) ) continue;
1018         de = find_by_dev (entry, major, minor, type);
1019         if (de) return de;
1020     }
1021     return NULL;
1022 }   /*  End Function find_by_dev  */
1023
1024
1025 /**
1026  *      find_entry - Find a devfs entry.
1027  *      @dir: The handle to the parent devfs directory entry. If this is %NULL the
1028  *              name is relative to the root of the devfs.
1029  *      @name: The name of the entry. This is ignored if @handle is not %NULL.
1030  *      @namelen: The number of characters in @name, not including a %NULL
1031  *              terminator. If this is 0, then @name must be %NULL-terminated and the
1032  *              length is computed internally.
1033  *      @major: The major number. This is used if @handle and @name are %NULL.
1034  *      @minor: The minor number. This is used if @handle and @name are %NULL.
1035  *              NOTE: If @major and @minor are both 0, searching by major and minor
1036  *              numbers is disabled.
1037  *      @type: The type of special file to search for. This may be either
1038  *              %DEVFS_SPECIAL_CHR or %DEVFS_SPECIAL_BLK.
1039  *      @traverse_symlink: If %TRUE then symbolic links are traversed.
1040  *
1041  *      FIXME: What the hell is @handle? - ch
1042  *      Returns the devfs_entry pointer on success, else %NULL.
1043  */
1044
1045 static struct devfs_entry *find_entry (devfs_handle_t dir,
1046                                        const char *name, unsigned int namelen,
1047                                        unsigned int major, unsigned int minor,
1048                                        char type, int traverse_symlink)
1049 {
1050     struct devfs_entry *entry;
1051
1052     if (name != NULL)
1053     {
1054         if (namelen < 1) namelen = strlen (name);
1055         if (name[0] == '/')
1056         {
1057             /*  Skip leading pathname component  */
1058             if (namelen < 2)
1059             {
1060                 printk ("%s: find_entry(%s): too short\n", DEVFS_NAME, name);
1061                 return NULL;
1062             }
1063             for (++name, --namelen; (*name != '/') && (namelen > 0);
1064                  ++name, --namelen);
1065             if (namelen < 2)
1066             {
1067                 printk ("%s: find_entry(%s): too short\n", DEVFS_NAME, name);
1068                 return NULL;
1069             }
1070             ++name;
1071             --namelen;
1072         }
1073         entry = search_for_entry (dir, name, namelen, FALSE, FALSE, NULL,
1074                                   traverse_symlink);
1075         if (entry != NULL) return entry;
1076     }
1077     /*  Have to search by major and minor: slow  */
1078     if ( (major == 0) && (minor == 0) ) return NULL;
1079     return find_by_dev (root_entry, major, minor, type);
1080 }   /*  End Function find_entry  */
1081
1082 static struct devfs_entry *get_devfs_entry_from_vfs_inode (struct inode *inode,
1083                                                            int do_check)
1084 {
1085     struct devfs_entry *de;
1086     struct fs_info *fs_info;
1087
1088     if (inode == NULL) return NULL;
1089     if (inode->i_ino < FIRST_INODE) return NULL;
1090     fs_info = inode->i_sb->u.generic_sbp;
1091     if (fs_info == NULL) return NULL;
1092     if (inode->i_ino - FIRST_INODE >= fs_info->num_inodes) return NULL;
1093     de = fs_info->table[inode->i_ino - FIRST_INODE];
1094     if (do_check && de && !de->registered) de = NULL;
1095     return de;
1096 }   /*  End Function get_devfs_entry_from_vfs_inode  */
1097
1098
1099 /**
1100  *      free_dentries - Free the dentries for a device entry and invalidate inodes.
1101  *      @de: The entry.
1102  */
1103
1104 static void free_dentries (struct devfs_entry *de)
1105 {
1106     struct dentry *dentry;
1107
1108     spin_lock (&dcache_lock);
1109     dentry = de->inode.dentry;
1110     if (dentry != NULL)
1111     {
1112         dget_locked (dentry);
1113         de->inode.dentry = NULL;
1114         spin_unlock (&dcache_lock);
1115         /*  Forcefully remove the inode  */
1116         if (dentry->d_inode != NULL) dentry->d_inode->i_nlink = 0;
1117         d_drop (dentry);
1118         dput (dentry);
1119     }
1120     else spin_unlock (&dcache_lock);
1121 }   /*  End Function free_dentries  */
1122
1123
1124 /**
1125  *      is_devfsd_or_child - Test if the current process is devfsd or one of its children.
1126  *      @fs_info: The filesystem information.
1127  *
1128  *      Returns %TRUE if devfsd or child, else %FALSE.
1129  */
1130
1131 static int is_devfsd_or_child (struct fs_info *fs_info)
1132 {
1133     struct task_struct *p;
1134
1135     for (p = current; p != &init_task; p = p->p_opptr)
1136     {
1137         if (p == fs_info->devfsd_task) return (TRUE);
1138     }
1139     return (FALSE);
1140 }   /*  End Function is_devfsd_or_child  */
1141
1142
1143 /**
1144  *      devfsd_queue_empty - Test if devfsd has work pending in its event queue.
1145  *      @fs_info: The filesystem information.
1146  *
1147  *      Returns %TRUE if the queue is empty, else %FALSE.
1148  */
1149
1150 static inline int devfsd_queue_empty (struct fs_info *fs_info)
1151 {
1152     return (fs_info->devfsd_buf_out == fs_info->devfsd_buf_in) ? TRUE : FALSE;
1153 }   /*  End Function devfsd_queue_empty  */
1154
1155
1156 /**
1157  *      wait_for_devfsd_finished - Wait for devfsd to finish processing its event queue.
1158  *      @fs_info: The filesystem information.
1159  *
1160  *      Returns %TRUE if no more waiting will be required, else %FALSE.
1161  */
1162
1163 static int wait_for_devfsd_finished (struct fs_info *fs_info)
1164 {
1165     DECLARE_WAITQUEUE (wait, current);
1166
1167     if (fs_info->devfsd_task == NULL) return (TRUE);
1168     if (devfsd_queue_empty (fs_info) && fs_info->devfsd_sleeping) return TRUE;
1169     if ( is_devfsd_or_child (fs_info) ) return (FALSE);
1170     add_wait_queue (&fs_info->revalidate_wait_queue, &wait);
1171     current->state = TASK_UNINTERRUPTIBLE;
1172     if (!devfsd_queue_empty (fs_info) || !fs_info->devfsd_sleeping)
1173         if (fs_info->devfsd_task) schedule ();
1174     remove_wait_queue (&fs_info->revalidate_wait_queue, &wait);
1175     current->state = TASK_RUNNING;
1176     return (TRUE);
1177 }   /*  End Function wait_for_devfsd_finished  */
1178
1179
1180 /**
1181  *      devfsd_notify_one - Notify a single devfsd daemon of a change.
1182  *      @data: Data to be passed.
1183  *      @type: The type of change.
1184  *      @mode: The mode of the entry.
1185  *      @uid: The user ID.
1186  *      @gid: The group ID.
1187  *      @fs_info: The filesystem info.
1188  *
1189  *      Returns %TRUE if an event was queued and devfsd woken up, else %FALSE.
1190  */
1191
1192 static int devfsd_notify_one (void *data, unsigned int type, umode_t mode,
1193                               uid_t uid, gid_t gid, struct fs_info *fs_info)
1194 {
1195     unsigned int next_pos;
1196     unsigned long flags;
1197     struct devfsd_buf_entry *entry;
1198
1199     if ( !( fs_info->devfsd_event_mask & (1 << type) ) ) return (FALSE);
1200     next_pos = fs_info->devfsd_buf_in + 1;
1201     if (next_pos >= devfsd_buf_size) next_pos = 0;
1202     if (next_pos == fs_info->devfsd_buf_out)
1203     {
1204         /*  Running up the arse of the reader: drop it  */
1205         atomic_inc (&fs_info->devfsd_overrun_count);
1206         return (FALSE);
1207     }
1208     spin_lock_irqsave (&fs_info->devfsd_buffer_lock, flags);
1209     next_pos = fs_info->devfsd_buf_in + 1;
1210     if (next_pos >= devfsd_buf_size) next_pos = 0;
1211     entry = (struct devfsd_buf_entry *) fs_info->devfsd_buffer +
1212         fs_info->devfsd_buf_in;
1213     entry->data = data;
1214     entry->type = type;
1215     entry->mode = mode;
1216     entry->uid = uid;
1217     entry->gid = gid;
1218     fs_info->devfsd_buf_in = next_pos;
1219     spin_unlock_irqrestore (&fs_info->devfsd_buffer_lock, flags);
1220     wake_up_interruptible (&fs_info->devfsd_wait_queue);
1221     return (TRUE);
1222 }   /*  End Function devfsd_notify_one  */
1223
1224
1225 /**
1226  *      devfsd_notify - Notify all devfsd daemons of a change.
1227  *      @de: The devfs entry that has changed.
1228  *      @type: The type of change event.
1229  *      @wait: If TRUE, the functions waits for all daemons to finish processing
1230  *              the event.
1231  */
1232
1233 static void devfsd_notify (struct devfs_entry *de, unsigned int type, int wait)
1234 {
1235     if (devfsd_notify_one (de, type, de->mode, current->euid,
1236                            current->egid, &fs_info) && wait)
1237         wait_for_devfsd_finished (&fs_info);
1238 }   /*  End Function devfsd_notify  */
1239
1240
1241 /**
1242  *      devfs_register - Register a device entry.
1243  *      @dir: The handle to the parent devfs directory entry. If this is %NULL the
1244  *              new name is relative to the root of the devfs.
1245  *      @name: The name of the entry.
1246  *      @flags: A set of bitwise-ORed flags (DEVFS_FL_*).
1247  *      @major: The major number. Not needed for regular files.
1248  *      @minor: The minor number. Not needed for regular files.
1249  *      @mode: The default file mode.
1250  *      @ops: The &file_operations or &block_device_operations structure.
1251  *              This must not be externally deallocated.
1252  *      @info: An arbitrary pointer which will be written to the @private_data
1253  *              field of the &file structure passed to the device driver. You can set
1254  *              this to whatever you like, and change it once the file is opened (the next
1255  *              file opened will not see this change).
1256  *
1257  *      Returns a handle which may later be used in a call to devfs_unregister().
1258  *      On failure %NULL is returned.
1259  */
1260
1261 devfs_handle_t devfs_register (devfs_handle_t dir, const char *name,
1262                                unsigned int flags,
1263                                unsigned int major, unsigned int minor,
1264                                umode_t mode, void *ops, void *info)
1265 {
1266     char devtype = S_ISCHR (mode) ? DEVFS_SPECIAL_CHR : DEVFS_SPECIAL_BLK;
1267     int is_new;
1268     kdev_t devnum = NODEV;
1269     struct devfs_entry *de;
1270
1271     if (name == NULL)
1272     {
1273         printk ("%s: devfs_register(): NULL name pointer\n", DEVFS_NAME);
1274         return NULL;
1275     }
1276     if (ops == NULL)
1277     {
1278         if ( S_ISBLK (mode) ) ops = (void *) get_blkfops (major);
1279         if (ops == NULL)
1280         {
1281             printk ("%s: devfs_register(%s): NULL ops pointer\n",
1282                     DEVFS_NAME, name);
1283             return NULL;
1284         }
1285         printk ("%s: devfs_register(%s): NULL ops, got %p from major table\n",
1286                 DEVFS_NAME, name, ops);
1287     }
1288     if ( S_ISDIR (mode) )
1289     {
1290         printk("%s: devfs_register(%s): creating directories is not allowed\n",
1291                DEVFS_NAME, name);
1292         return NULL;
1293     }
1294     if ( S_ISLNK (mode) )
1295     {
1296         printk ("%s: devfs_register(%s): creating symlinks is not allowed\n",
1297                 DEVFS_NAME, name);
1298         return NULL;
1299     }
1300     if ( ( S_ISCHR (mode) || S_ISBLK (mode) ) &&
1301          (flags & DEVFS_FL_AUTO_DEVNUM) )
1302     {
1303         if ( ( devnum = devfs_alloc_devnum (devtype) ) == NODEV )
1304         {
1305             printk ("%s: devfs_register(%s): exhausted %s device numbers\n",
1306                     DEVFS_NAME, name, S_ISCHR (mode) ? "char" : "block");
1307             return NULL;
1308         }
1309         major = MAJOR (devnum);
1310         minor = MINOR (devnum);
1311     }
1312     de = search_for_entry (dir, name, strlen (name), TRUE, TRUE, &is_new,
1313                            FALSE);
1314     if (de == NULL)
1315     {
1316         printk ("%s: devfs_register(): could not create entry: \"%s\"\n",
1317                 DEVFS_NAME, name);
1318         if (devnum != NODEV) devfs_dealloc_devnum (devtype, devnum);
1319         return NULL;
1320     }
1321 #ifdef CONFIG_DEVFS_DEBUG
1322     if (devfs_debug & DEBUG_REGISTER)
1323         printk ("%s: devfs_register(%s): de: %p %s\n",
1324                 DEVFS_NAME, name, de, is_new ? "new" : "existing");
1325 #endif
1326     if (!is_new)
1327     {
1328         /*  Existing entry  */
1329         if ( !S_ISCHR (de->mode) && !S_ISBLK (de->mode) &&
1330              !S_ISREG (de->mode) )
1331         {
1332             printk ("%s: devfs_register(): existing non-device/file entry: \"%s\"\n",
1333                     DEVFS_NAME, name);
1334             if (devnum != NODEV) devfs_dealloc_devnum (devtype, devnum);
1335             return NULL;
1336         }
1337         if (de->registered)
1338         {
1339             printk("%s: devfs_register(): device already registered: \"%s\"\n",
1340                    DEVFS_NAME, name);
1341             if (devnum != NODEV) devfs_dealloc_devnum (devtype, devnum);
1342             return NULL;
1343         }
1344     }
1345     de->u.fcb.autogen = 0;
1346     if ( S_ISCHR (mode) || S_ISBLK (mode) )
1347     {
1348         de->u.fcb.u.device.major = major;
1349         de->u.fcb.u.device.minor = minor;
1350         de->u.fcb.autogen = (devnum == NODEV) ? 0 : 1;
1351     }
1352     else if ( S_ISREG (mode) ) de->u.fcb.u.file.size = 0;
1353     else
1354     {
1355         printk ("%s: devfs_register(): illegal mode: %x\n",
1356                 DEVFS_NAME, mode);
1357         return (NULL);
1358     }
1359     de->info = info;
1360     de->mode = mode;
1361     if (flags & DEVFS_FL_CURRENT_OWNER)
1362     {
1363         de->u.fcb.default_uid = current->uid;
1364         de->u.fcb.default_gid = current->gid;
1365     }
1366     else
1367     {
1368         de->u.fcb.default_uid = 0;
1369         de->u.fcb.default_gid = 0;
1370     }
1371     de->u.fcb.ops = ops;
1372     de->u.fcb.auto_owner = (flags & DEVFS_FL_AUTO_OWNER) ? TRUE : FALSE;
1373     de->u.fcb.aopen_notify = (flags & DEVFS_FL_AOPEN_NOTIFY) ? TRUE : FALSE;
1374     if (flags & DEVFS_FL_REMOVABLE)
1375     {
1376         de->u.fcb.removable = TRUE;
1377         ++de->parent->u.dir.num_removable;
1378     }
1379     de->u.fcb.open = FALSE;
1380     de->show_unreg = ( (boot_options & OPTION_SHOW)
1381                         || (flags & DEVFS_FL_SHOW_UNREG) ) ? TRUE : FALSE;
1382     de->hide = (flags & DEVFS_FL_HIDE) ? TRUE : FALSE;
1383     de->no_persistence = (flags & DEVFS_FL_NO_PERSISTENCE) ? TRUE : FALSE;
1384     de->registered = TRUE;
1385     devfsd_notify (de, DEVFSD_NOTIFY_REGISTERED, flags & DEVFS_FL_WAIT);
1386     return de;
1387 }   /*  End Function devfs_register  */
1388
1389
1390 /**
1391  *      unregister - Unregister a device entry.
1392  *      @de: The entry to unregister.
1393  */
1394
1395 static void unregister (struct devfs_entry *de)
1396 {
1397     struct devfs_entry *child;
1398
1399     if ( (child = de->slave) != NULL )
1400     {
1401         de->slave = NULL;  /* Unhook first in case slave is parent directory */
1402         unregister (child);
1403     }
1404     if (de->registered)
1405     {
1406         devfsd_notify (de, DEVFSD_NOTIFY_UNREGISTERED, 0);
1407         free_dentries (de);
1408     }
1409     de->info = NULL;
1410     if ( S_ISCHR (de->mode) || S_ISBLK (de->mode) || S_ISREG (de->mode) )
1411     {
1412         de->registered = FALSE;
1413         de->u.fcb.ops = NULL;
1414         if (!S_ISREG (de->mode) && de->u.fcb.autogen)
1415         {
1416             devfs_dealloc_devnum ( S_ISCHR (de->mode) ? DEVFS_SPECIAL_CHR :
1417                                    DEVFS_SPECIAL_BLK,
1418                                    MKDEV (de->u.fcb.u.device.major,
1419                                           de->u.fcb.u.device.minor) );
1420         }
1421         de->u.fcb.autogen = 0;
1422         return;
1423     }
1424     if (S_ISLNK (de->mode) && de->registered)
1425     {
1426         de->registered = FALSE;
1427         kfree (de->u.symlink.linkname);
1428         return;
1429     }
1430     if ( S_ISFIFO (de->mode) )
1431     {
1432         de->registered = FALSE;
1433         return;
1434     }
1435     if (!de->registered) return;
1436     if ( !S_ISDIR (de->mode) )
1437     {
1438         printk ("%s: unregister(): unsupported type\n", DEVFS_NAME);
1439         return;
1440     }
1441     de->registered = FALSE;
1442     /*  Now recursively search the subdirectories: this is a stack chomper  */
1443     for (child = de->u.dir.first; child != NULL; child = child->next)
1444     {
1445 #ifdef CONFIG_DEVFS_DEBUG
1446         if (devfs_debug & DEBUG_UNREGISTER)
1447             printk ("%s: unregister(): child->name: \"%s\" child: %p\n",
1448                     DEVFS_NAME, child->name, child);
1449 #endif
1450         unregister (child);
1451     }
1452 }   /*  End Function unregister  */
1453
1454
1455 /**
1456  *      devfs_unregister - Unregister a device entry.
1457  *      @de: A handle previously created by devfs_register() or returned from
1458  *              devfs_find_handle(). If this is %NULL the routine does nothing.
1459  */
1460
1461 void devfs_unregister (devfs_handle_t de)
1462 {
1463     if (de == NULL) return;
1464 #ifdef CONFIG_DEVFS_DEBUG
1465     if (devfs_debug & DEBUG_UNREGISTER)
1466         printk ("%s: devfs_unregister(): de->name: \"%s\" de: %p\n",
1467                 DEVFS_NAME, de->name, de);
1468 #endif
1469     unregister (de);
1470 }   /*  End Function devfs_unregister  */
1471
1472 static int devfs_do_symlink (devfs_handle_t dir, const char *name,
1473                              unsigned int flags, const char *link,
1474                              devfs_handle_t *handle, void *info)
1475 {
1476     int is_new;
1477     unsigned int linklength;
1478     char *newname;
1479     struct devfs_entry *de;
1480
1481     if (handle != NULL) *handle = NULL;
1482     if (name == NULL)
1483     {
1484         printk ("%s: devfs_do_symlink(): NULL name pointer\n", DEVFS_NAME);
1485         return -EINVAL;
1486     }
1487 #ifdef CONFIG_DEVFS_DEBUG
1488     if (devfs_debug & DEBUG_REGISTER)
1489         printk ("%s: devfs_do_symlink(%s)\n", DEVFS_NAME, name);
1490 #endif
1491     if (link == NULL)
1492     {
1493         printk ("%s: devfs_do_symlink(): NULL link pointer\n", DEVFS_NAME);
1494         return -EINVAL;
1495     }
1496     linklength = strlen (link);
1497     de = search_for_entry (dir, name, strlen (name), TRUE, TRUE, &is_new,
1498                            FALSE);
1499     if (de == NULL) return -ENOMEM;
1500     if (!S_ISLNK (de->mode) && de->registered)
1501     {
1502         printk ("%s: devfs_do_symlink(): non-link entry already exists\n",
1503                 DEVFS_NAME);
1504         return -EEXIST;
1505     }
1506     if (handle != NULL) *handle = de;
1507     de->mode = S_IFLNK | S_IRUGO | S_IXUGO;
1508     de->info = info;
1509     de->show_unreg = ( (boot_options & OPTION_SHOW)
1510                        || (flags & DEVFS_FL_SHOW_UNREG) ) ? TRUE : FALSE;
1511     de->hide = (flags & DEVFS_FL_HIDE) ? TRUE : FALSE;
1512     /*  Note there is no need to fiddle the dentry cache if the symlink changes
1513         as the symlink follow method is called every time it's needed  */
1514     if ( de->registered && (linklength == de->u.symlink.length) )
1515     {
1516         /*  New link is same length as old link  */
1517         if (memcmp (link, de->u.symlink.linkname, linklength) == 0) return 0;
1518         return -EEXIST;  /*  Contents would change  */
1519     }
1520     /*  Have to create/update  */
1521     if (de->registered) return -EEXIST;
1522     if ( ( newname = kmalloc (linklength + 1, GFP_KERNEL) ) == NULL )
1523     {
1524         struct devfs_entry *parent = de->parent;
1525
1526         if (!is_new) return -ENOMEM;
1527         /*  Have to clean up  */
1528         if (de->prev == NULL) parent->u.dir.first = de->next;
1529         else de->prev->next = de->next;
1530         if (de->next == NULL) parent->u.dir.last = de->prev;
1531         else de->next->prev = de->prev;
1532         kfree (de);
1533         return -ENOMEM;
1534     }
1535     de->u.symlink.linkname = newname;
1536     memcpy (de->u.symlink.linkname, link, linklength);
1537     de->u.symlink.linkname[linklength] = '\0';
1538     de->u.symlink.length = linklength;
1539     de->registered = TRUE;
1540     return 0;
1541 }   /*  End Function devfs_do_symlink  */
1542
1543
1544 /**
1545  *      devfs_mk_symlink Create a symbolic link in the devfs namespace.
1546  *      @dir: The handle to the parent devfs directory entry. If this is %NULL the
1547  *              new name is relative to the root of the devfs.
1548  *      @name: The name of the entry.
1549  *      @flags: A set of bitwise-ORed flags (DEVFS_FL_*).
1550  *      @link: The destination name.
1551  *      @handle: The handle to the symlink entry is written here. This may be %NULL.
1552  *      @info: An arbitrary pointer which will be associated with the entry.
1553  *
1554  *      Returns 0 on success, else a negative error code is returned.
1555  */
1556
1557 int devfs_mk_symlink (devfs_handle_t dir, const char *name, unsigned int flags,
1558                       const char *link, devfs_handle_t *handle, void *info)
1559 {
1560     int err;
1561     devfs_handle_t de;
1562
1563     if (handle != NULL) *handle = NULL;
1564     err = devfs_do_symlink (dir, name, flags, link, &de, info);
1565     if (err) return err;
1566     if (handle != NULL) *handle = de;
1567     devfsd_notify (de, DEVFSD_NOTIFY_REGISTERED, flags & DEVFS_FL_WAIT);
1568     return 0;
1569 }   /*  End Function devfs_mk_symlink  */
1570
1571
1572 /**
1573  *      devfs_mk_dir - Create a directory in the devfs namespace.
1574  *      @dir: The handle to the parent devfs directory entry. If this is %NULL the
1575  *              new name is relative to the root of the devfs.
1576  *      @name: The name of the entry.
1577  *      @info: An arbitrary pointer which will be associated with the entry.
1578  *
1579  *      Use of this function is optional. The devfs_register() function
1580  *      will automatically create intermediate directories as needed. This function
1581  *      is provided for efficiency reasons, as it provides a handle to a directory.
1582  *      Returns a handle which may later be used in a call to devfs_unregister().
1583  *      On failure %NULL is returned.
1584  */
1585
1586 devfs_handle_t devfs_mk_dir (devfs_handle_t dir, const char *name, void *info)
1587 {
1588     int is_new;
1589     struct devfs_entry *de;
1590
1591     if (name == NULL)
1592     {
1593         printk ("%s: devfs_mk_dir(): NULL name pointer\n", DEVFS_NAME);
1594         return NULL;
1595     }
1596     de = search_for_entry (dir, name, strlen (name), TRUE, TRUE, &is_new,
1597                            FALSE);
1598     if (de == NULL)
1599     {
1600         printk ("%s: devfs_mk_dir(): could not create entry: \"%s\"\n",
1601                 DEVFS_NAME, name);
1602         return NULL;
1603     }
1604     if (!S_ISDIR (de->mode) && de->registered)
1605     {
1606         printk ("%s: devfs_mk_dir(): existing non-directory entry: \"%s\"\n",
1607                 DEVFS_NAME, name);
1608         return NULL;
1609     }
1610 #ifdef CONFIG_DEVFS_DEBUG
1611     if (devfs_debug & DEBUG_REGISTER)
1612         printk ("%s: devfs_mk_dir(%s): de: %p %s\n",
1613                 DEVFS_NAME, name, de, is_new ? "new" : "existing");
1614 #endif
1615     if (!S_ISDIR (de->mode) && !is_new)
1616     {
1617         /*  Transmogrifying an old entry  */
1618         de->u.dir.first = NULL;
1619         de->u.dir.last = NULL;
1620     }
1621     de->mode = S_IFDIR | S_IRUGO | S_IXUGO;
1622     de->info = info;
1623     if (!de->registered) de->u.dir.num_removable = 0;
1624     de->show_unreg = (boot_options & OPTION_SHOW) ? TRUE : FALSE;
1625     de->hide = FALSE;
1626     de->registered = TRUE;
1627     return de;
1628 }   /*  End Function devfs_mk_dir  */
1629
1630
1631 /**
1632  *      devfs_find_handle - Find the handle of a devfs entry.
1633  *      @dir: The handle to the parent devfs directory entry. If this is %NULL the
1634  *              name is relative to the root of the devfs.
1635  *      @name: The name of the entry.
1636  *      @major: The major number. This is used if @name is %NULL.
1637  *      @minor: The minor number. This is used if @name is %NULL.
1638  *      @type: The type of special file to search for. This may be either
1639  *              %DEVFS_SPECIAL_CHR or %DEVFS_SPECIAL_BLK.
1640  *      @traverse_symlinks: If %TRUE then symlink entries in the devfs namespace are
1641  *              traversed. Symlinks pointing out of the devfs namespace will cause a
1642  *              failure. Symlink traversal consumes stack space.
1643  *
1644  *      Returns a handle which may later be used in a call to devfs_unregister(),
1645  *      devfs_get_flags(), or devfs_set_flags(). On failure %NULL is returned.
1646  */
1647
1648 devfs_handle_t devfs_find_handle (devfs_handle_t dir, const char *name,
1649                                   unsigned int major, unsigned int minor,
1650                                   char type, int traverse_symlinks)
1651 {
1652     devfs_handle_t de;
1653
1654     if ( (name != NULL) && (name[0] == '\0') ) name = NULL;
1655     de = find_entry (dir, name, 0, major, minor, type,
1656                      traverse_symlinks);
1657     if (de == NULL) return NULL;
1658     if (!de->registered) return NULL;
1659     return de;
1660 }   /*  End Function devfs_find_handle  */
1661
1662
1663 /**
1664  *      devfs_get_flags - Get the flags for a devfs entry.
1665  *      @de: The handle to the device entry.
1666  *      @flags: The flags are written here.
1667  *
1668  *      Returns 0 on success, else a negative error code.
1669  */
1670
1671 int devfs_get_flags (devfs_handle_t de, unsigned int *flags)
1672 {
1673     unsigned int fl = 0;
1674
1675     if (de == NULL) return -EINVAL;
1676     if (!de->registered) return -ENODEV;
1677     if (de->show_unreg) fl |= DEVFS_FL_SHOW_UNREG;
1678     if (de->hide) fl |= DEVFS_FL_HIDE;
1679     if ( S_ISCHR (de->mode) || S_ISBLK (de->mode) || S_ISREG (de->mode) )
1680     {
1681         if (de->u.fcb.auto_owner) fl |= DEVFS_FL_AUTO_OWNER;
1682         if (de->u.fcb.aopen_notify) fl |= DEVFS_FL_AOPEN_NOTIFY;
1683         if (de->u.fcb.removable) fl |= DEVFS_FL_REMOVABLE;
1684     }
1685     *flags = fl;
1686     return 0;
1687 }   /*  End Function devfs_get_flags  */
1688
1689
1690 /*
1691  *      devfs_set_flags - Set the flags for a devfs entry.
1692  *      @de: The handle to the device entry.
1693  *      @flags: The flags to set. Unset flags are cleared.
1694  *
1695  *      Returns 0 on success, else a negative error code.
1696  */
1697
1698 int devfs_set_flags (devfs_handle_t de, unsigned int flags)
1699 {
1700     if (de == NULL) return -EINVAL;
1701     if (!de->registered) return -ENODEV;
1702 #ifdef CONFIG_DEVFS_DEBUG
1703     if (devfs_debug & DEBUG_SET_FLAGS)
1704         printk ("%s: devfs_set_flags(): de->name: \"%s\"\n",
1705                 DEVFS_NAME, de->name);
1706 #endif
1707     de->show_unreg = (flags & DEVFS_FL_SHOW_UNREG) ? TRUE : FALSE;
1708     de->hide = (flags & DEVFS_FL_HIDE) ? TRUE : FALSE;
1709     if ( S_ISCHR (de->mode) || S_ISBLK (de->mode) || S_ISREG (de->mode) )
1710     {
1711         de->u.fcb.auto_owner = (flags & DEVFS_FL_AUTO_OWNER) ? TRUE : FALSE;
1712         de->u.fcb.aopen_notify = (flags & DEVFS_FL_AOPEN_NOTIFY) ? TRUE:FALSE;
1713         if ( de->u.fcb.removable && !(flags & DEVFS_FL_REMOVABLE) )
1714         {
1715             de->u.fcb.removable = FALSE;
1716             --de->parent->u.dir.num_removable;
1717         }
1718         else if ( !de->u.fcb.removable && (flags & DEVFS_FL_REMOVABLE) )
1719         {
1720             de->u.fcb.removable = TRUE;
1721             ++de->parent->u.dir.num_removable;
1722         }
1723     }
1724     return 0;
1725 }   /*  End Function devfs_set_flags  */
1726
1727
1728 /**
1729  *      devfs_get_maj_min - Get the major and minor numbers for a devfs entry.
1730  *      @de: The handle to the device entry.
1731  *      @major: The major number is written here. This may be %NULL.
1732  *      @minor: The minor number is written here. This may be %NULL.
1733  *
1734  *      Returns 0 on success, else a negative error code.
1735  */
1736
1737 int devfs_get_maj_min (devfs_handle_t de, unsigned int *major,
1738                        unsigned int *minor)
1739 {
1740     if (de == NULL) return -EINVAL;
1741     if (!de->registered) return -ENODEV;
1742     if ( S_ISDIR (de->mode) ) return -EISDIR;
1743     if ( !S_ISCHR (de->mode) && !S_ISBLK (de->mode) ) return -EINVAL;
1744     if (major != NULL) *major = de->u.fcb.u.device.major;
1745     if (minor != NULL) *minor = de->u.fcb.u.device.minor;
1746     return 0;
1747 }   /*  End Function devfs_get_maj_min  */
1748
1749
1750 /**
1751  *      devfs_get_handle_from_inode - Get the devfs handle for a VFS inode.
1752  *      @inode: The VFS inode.
1753  *
1754  *      Returns the devfs handle on success, else %NULL.
1755  */
1756
1757 devfs_handle_t devfs_get_handle_from_inode (struct inode *inode)
1758 {
1759     if (!inode || !inode->i_sb) return NULL;
1760     if (inode->i_sb->s_magic != DEVFS_SUPER_MAGIC) return NULL;
1761     return get_devfs_entry_from_vfs_inode (inode, TRUE);
1762 }   /*  End Function devfs_get_handle_from_inode  */
1763
1764
1765 /**
1766  *      devfs_generate_path - Generate a pathname for an entry, relative to the devfs root.
1767  *      @de: The devfs entry.
1768  *      @path: The buffer to write the pathname to. The pathname and '\0'
1769  *              terminator will be written at the end of the buffer.
1770  *      @buflen: The length of the buffer.
1771  *
1772  *      Returns the offset in the buffer where the pathname starts on success,
1773  *      else a negative error code.
1774  */
1775
1776 int devfs_generate_path (devfs_handle_t de, char *path, int buflen)
1777 {
1778     int pos;
1779
1780     if (de == NULL) return -EINVAL;
1781     if (de->namelen >= buflen) return -ENAMETOOLONG; /*  Must be first       */
1782     path[buflen - 1] = '\0';
1783     if (de->parent == NULL) return buflen - 1;       /*  Don't prepend root  */
1784     pos = buflen - de->namelen - 1;
1785     memcpy (path + pos, de->name, de->namelen);
1786     for (de = de->parent; de->parent != NULL; de = de->parent)
1787     {
1788         if (pos - de->namelen - 1 < 0) return -ENAMETOOLONG;
1789         path[--pos] = '/';
1790         pos -= de->namelen;
1791         memcpy (path + pos, de->name, de->namelen);
1792     }
1793     return pos;
1794 }   /*  End Function devfs_generate_path  */
1795
1796
1797 /**
1798  *      devfs_get_ops - Get the device operations for a devfs entry.
1799  *      @de: The handle to the device entry.
1800  *
1801  *      Returns a pointer to the device operations on success, else NULL.
1802  */
1803
1804 void *devfs_get_ops (devfs_handle_t de)
1805 {
1806     if (de == NULL) return NULL;
1807     if (!de->registered) return NULL;
1808     if ( S_ISCHR (de->mode) || S_ISBLK (de->mode) || S_ISREG (de->mode) )
1809         return de->u.fcb.ops;
1810     return NULL;
1811 }   /*  End Function devfs_get_ops  */
1812
1813
1814 /**
1815  *      devfs_set_file_size - Set the file size for a devfs regular file.
1816  *      @de: The handle to the device entry.
1817  *      @size: The new file size.
1818  *
1819  *      Returns 0 on success, else a negative error code.
1820  */
1821
1822 int devfs_set_file_size (devfs_handle_t de, unsigned long size)
1823 {
1824     if (de == NULL) return -EINVAL;
1825     if (!de->registered) return -EINVAL;
1826     if ( !S_ISREG (de->mode) ) return -EINVAL;
1827     if (de->u.fcb.u.file.size == size) return 0;
1828     de->u.fcb.u.file.size = size;
1829     if (de->inode.dentry == NULL) return 0;
1830     if (de->inode.dentry->d_inode == NULL) return 0;
1831     de->inode.dentry->d_inode->i_size = size;
1832     return 0;
1833 }   /*  End Function devfs_set_file_size  */
1834
1835
1836 /**
1837  *      devfs_get_info - Get the info pointer written to private_data of @de upon open.
1838  *      @de: The handle to the device entry.
1839  *
1840  *      Returns the info pointer.
1841  */
1842 void *devfs_get_info (devfs_handle_t de)
1843 {
1844     if (de == NULL) return NULL;
1845     if (!de->registered) return NULL;
1846     return de->info;
1847 }   /*  End Function devfs_get_info  */
1848
1849
1850 /**
1851  *      devfs_set_info - Set the info pointer written to private_data upon open.
1852  *      @de: The handle to the device entry.
1853  *      @info: pointer to the data
1854  *
1855  *      Returns 0 on success, else a negative error code.
1856  */
1857 int devfs_set_info (devfs_handle_t de, void *info)
1858 {
1859     if (de == NULL) return -EINVAL;
1860     if (!de->registered) return -EINVAL;
1861     de->info = info;
1862     return 0;
1863 }   /*  End Function devfs_set_info  */
1864
1865
1866 /**
1867  *      devfs_get_parent - Get the parent device entry.
1868  *      @de: The handle to the device entry.
1869  *
1870  *      Returns the parent device entry if it exists, else %NULL.
1871  */
1872 devfs_handle_t devfs_get_parent (devfs_handle_t de)
1873 {
1874     if (de == NULL) return NULL;
1875     if (!de->registered) return NULL;
1876     return de->parent;
1877 }   /*  End Function devfs_get_parent  */
1878
1879
1880 /**
1881  *      devfs_get_first_child - Get the first leaf node in a directory.
1882  *      @de: The handle to the device entry.
1883  *
1884  *      Returns the leaf node device entry if it exists, else %NULL.
1885  */
1886
1887 devfs_handle_t devfs_get_first_child (devfs_handle_t de)
1888 {
1889     if (de == NULL) return NULL;
1890     if (!de->registered) return NULL;
1891     if ( !S_ISDIR (de->mode) ) return NULL;
1892     return de->u.dir.first;
1893 }   /*  End Function devfs_get_first_child  */
1894
1895
1896 /**
1897  *      devfs_get_next_sibling - Get the next sibling leaf node. for a device entry.
1898  *      @de: The handle to the device entry.
1899  *
1900  *      Returns the leaf node device entry if it exists, else %NULL.
1901  */
1902
1903 devfs_handle_t devfs_get_next_sibling (devfs_handle_t de)
1904 {
1905     if (de == NULL) return NULL;
1906     if (!de->registered) return NULL;
1907     return de->next;
1908 }   /*  End Function devfs_get_next_sibling  */
1909
1910
1911 /**
1912  *      devfs_auto_unregister - Configure a devfs entry to be automatically unregistered.
1913  *      @master: The master devfs entry. Only one slave may be registered.
1914  *      @slave: The devfs entry which will be automatically unregistered when the
1915  *              master entry is unregistered. It is illegal to call devfs_unregister()
1916  *              on this entry.
1917  */
1918
1919 void devfs_auto_unregister (devfs_handle_t master, devfs_handle_t slave)
1920 {
1921     if (master == NULL) return;
1922     if (master->slave != NULL)
1923     {
1924         /*  Because of the dumbness of the layers above, ignore duplicates  */
1925         if (master->slave == slave) return;
1926         printk ("%s: devfs_auto_unregister(): only one slave allowed\n",
1927                 DEVFS_NAME);
1928         OOPS ("  master: \"%s\"  old slave: \"%s\"  new slave: \"%s\"\n",
1929               master->name, master->slave->name, slave->name);
1930     }
1931     master->slave = slave;
1932 }   /*  End Function devfs_auto_unregister  */
1933
1934
1935 /**
1936  *      devfs_get_unregister_slave - Get the slave entry which will be automatically unregistered.
1937  *      @master: The master devfs entry.
1938  *
1939  *      Returns the slave which will be unregistered when @master is unregistered.
1940  */
1941
1942 devfs_handle_t devfs_get_unregister_slave (devfs_handle_t master)
1943 {
1944     if (master == NULL) return NULL;
1945     return master->slave;
1946 }   /*  End Function devfs_get_unregister_slave  */
1947
1948
1949 /**
1950  *      devfs_get_name - Get the name for a device entry in its parent directory.
1951  *      @de: The handle to the device entry.
1952  *      @namelen: The length of the name is written here. This may be %NULL.
1953  *
1954  *      Returns the name on success, else %NULL.
1955  */
1956
1957 const char *devfs_get_name (devfs_handle_t de, unsigned int *namelen)
1958 {
1959     if (de == NULL) return NULL;
1960     if (!de->registered) return NULL;
1961     if (namelen != NULL) *namelen = de->namelen;
1962     return de->name;
1963 }   /*  End Function devfs_get_name  */
1964
1965
1966 /**
1967  *      devfs_register_chrdev - Optionally register a conventional character driver.
1968  *      @major: The major number for the driver.
1969  *      @name: The name of the driver (as seen in /proc/devices).
1970  *      @fops: The &file_operations structure pointer.
1971  *
1972  *      This function will register a character driver provided the "devfs=only"
1973  *      option was not provided at boot time.
1974  *      Returns 0 on success, else a negative error code on failure.
1975  */
1976
1977 int devfs_register_chrdev (unsigned int major, const char *name,
1978                            struct file_operations *fops)
1979 {
1980     if (boot_options & OPTION_ONLY) return 0;
1981     return register_chrdev (major, name, fops);
1982 }   /*  End Function devfs_register_chrdev  */
1983
1984
1985 /**
1986  *      devfs_register_blkdev - Optionally register a conventional block driver.
1987  *      @major: The major number for the driver.
1988  *      @name: The name of the driver (as seen in /proc/devices).
1989  *      @bdops: The &block_device_operations structure pointer.
1990  *
1991  *      This function will register a block driver provided the "devfs=only"
1992  *      option was not provided at boot time.
1993  *      Returns 0 on success, else a negative error code on failure.
1994  */
1995
1996 int devfs_register_blkdev (unsigned int major, const char *name,
1997                            struct block_device_operations *bdops)
1998 {
1999     if (boot_options & OPTION_ONLY) return 0;
2000     return register_blkdev (major, name, bdops);
2001 }   /*  End Function devfs_register_blkdev  */
2002
2003
2004 /**
2005  *      devfs_unregister_chrdev - Optionally unregister a conventional character driver.
2006  *      @major: The major number for the driver.
2007  *      @name: The name of the driver (as seen in /proc/devices).
2008  *
2009  *      This function will unregister a character driver provided the "devfs=only"
2010  *      option was not provided at boot time.
2011  *      Returns 0 on success, else a negative error code on failure.
2012  */
2013
2014 int devfs_unregister_chrdev (unsigned int major, const char *name)
2015 {
2016     if (boot_options & OPTION_ONLY) return 0;
2017     return unregister_chrdev (major, name);
2018 }   /*  End Function devfs_unregister_chrdev  */
2019
2020
2021 /**
2022  *      devfs_unregister_blkdev - Optionally unregister a conventional block driver.
2023  *      @major: The major number for the driver.
2024  *      @name: The name of the driver (as seen in /proc/devices).
2025  *
2026  *      This function will unregister a block driver provided the "devfs=only"
2027  *      option was not provided at boot time.
2028  *      Returns 0 on success, else a negative error code on failure.
2029  */
2030
2031 int devfs_unregister_blkdev (unsigned int major, const char *name)
2032 {
2033     if (boot_options & OPTION_ONLY) return 0;
2034     return unregister_blkdev (major, name);
2035 }   /*  End Function devfs_unregister_blkdev  */
2036
2037 /**
2038  *      devfs_setup - Process kernel boot options.
2039  *      @str: The boot options after the "devfs=".
2040  */
2041
2042 static int __init devfs_setup (char *str)
2043 {
2044     static struct
2045     {
2046         char *name;
2047         unsigned int mask;
2048         unsigned int *opt;
2049     } devfs_options_tab[] __initdata =
2050     {
2051 #ifdef CONFIG_DEVFS_DEBUG
2052         {"dall",      DEBUG_ALL,          &devfs_debug_init},
2053         {"dmod",      DEBUG_MODULE_LOAD,  &devfs_debug_init},
2054         {"dreg",      DEBUG_REGISTER,     &devfs_debug_init},
2055         {"dunreg",    DEBUG_UNREGISTER,   &devfs_debug_init},
2056         {"diread",    DEBUG_I_READ,       &devfs_debug_init},
2057         {"dchange",   DEBUG_SET_FLAGS,    &devfs_debug_init},
2058         {"diwrite",   DEBUG_I_WRITE,      &devfs_debug_init},
2059         {"dimknod",   DEBUG_I_MKNOD,      &devfs_debug_init},
2060         {"dilookup",  DEBUG_I_LOOKUP,     &devfs_debug_init},
2061         {"diunlink",  DEBUG_I_UNLINK,     &devfs_debug_init},
2062 #endif  /*  CONFIG_DEVFS_DEBUG  */
2063         {"show",      OPTION_SHOW,        &boot_options},
2064         {"only",      OPTION_ONLY,        &boot_options},
2065         {"mount",     OPTION_MOUNT,       &boot_options},
2066     };
2067
2068     while ( (*str != '\0') && !isspace (*str) )
2069     {
2070         int i, found = 0, invert = 0;
2071
2072         if (strncmp (str, "no", 2) == 0)
2073         {
2074             invert = 1;
2075             str += 2;
2076         }
2077         for (i = 0; i < sizeof (devfs_options_tab); i++)
2078         {
2079             int len = strlen (devfs_options_tab[i].name);
2080
2081             if (strncmp (str, devfs_options_tab[i].name, len) == 0)
2082             {
2083                 if (invert)
2084                     *devfs_options_tab[i].opt &= ~devfs_options_tab[i].mask;
2085                 else
2086                     *devfs_options_tab[i].opt |= devfs_options_tab[i].mask;
2087                 str += len;
2088                 found = 1;
2089                 break;
2090             }
2091         }
2092         if (!found) return 0;       /*  No match         */
2093         if (*str != ',') return 0;  /*  No more options  */
2094         ++str;
2095     }
2096     return 1;
2097 }   /*  End Function devfs_setup  */
2098
2099 __setup("devfs=", devfs_setup);
2100
2101 EXPORT_SYMBOL(devfs_register);
2102 EXPORT_SYMBOL(devfs_unregister);
2103 EXPORT_SYMBOL(devfs_mk_symlink);
2104 EXPORT_SYMBOL(devfs_mk_dir);
2105 EXPORT_SYMBOL(devfs_find_handle);
2106 EXPORT_SYMBOL(devfs_get_flags);
2107 EXPORT_SYMBOL(devfs_set_flags);
2108 EXPORT_SYMBOL(devfs_get_maj_min);
2109 EXPORT_SYMBOL(devfs_get_handle_from_inode);
2110 EXPORT_SYMBOL(devfs_generate_path);
2111 EXPORT_SYMBOL(devfs_get_ops);
2112 EXPORT_SYMBOL(devfs_set_file_size);
2113 EXPORT_SYMBOL(devfs_get_info);
2114 EXPORT_SYMBOL(devfs_set_info);
2115 EXPORT_SYMBOL(devfs_get_parent);
2116 EXPORT_SYMBOL(devfs_get_first_child);
2117 EXPORT_SYMBOL(devfs_get_next_sibling);
2118 EXPORT_SYMBOL(devfs_auto_unregister);
2119 EXPORT_SYMBOL(devfs_get_unregister_slave);
2120 EXPORT_SYMBOL(devfs_get_name);
2121 EXPORT_SYMBOL(devfs_register_chrdev);
2122 EXPORT_SYMBOL(devfs_register_blkdev);
2123 EXPORT_SYMBOL(devfs_unregister_chrdev);
2124 EXPORT_SYMBOL(devfs_unregister_blkdev);
2125
2126
2127 /**
2128  *      try_modload - Notify devfsd of an inode lookup.
2129  *      @parent: The parent devfs entry.
2130  *      @fs_info: The filesystem info.
2131  *      @name: The device name.
2132  *      @namelen: The number of characters in @name.
2133  *      @buf: A working area that will be used. This must not go out of scope until
2134  *              devfsd is idle again.
2135  *
2136  *      Returns 0 on success, else a negative error code.
2137  */
2138
2139 static int try_modload (struct devfs_entry *parent, struct fs_info *fs_info,
2140                         const char *name, unsigned namelen,
2141                         char buf[STRING_LENGTH])
2142 {
2143     int pos = STRING_LENGTH - namelen - 1;
2144
2145     if ( !( fs_info->devfsd_event_mask & (1 << DEVFSD_NOTIFY_LOOKUP) ) )
2146         return -ENOENT;
2147     if ( is_devfsd_or_child (fs_info) ) return -ENOENT;
2148     if (namelen >= STRING_LENGTH) return -ENAMETOOLONG;
2149     memcpy (buf + pos, name, namelen);
2150     buf[STRING_LENGTH - 1] = '\0';
2151     if (parent->parent != NULL) pos = devfs_generate_path (parent, buf, pos);
2152     if (pos < 0) return pos;
2153     buf[STRING_LENGTH - namelen - 2] = '/';
2154     if ( !devfsd_notify_one (buf + pos, DEVFSD_NOTIFY_LOOKUP, 0,
2155                              current->euid, current->egid, fs_info) )
2156         return -ENOENT;
2157     /*  Possible success  */
2158     return 0;
2159 }   /*  End Function try_modload  */
2160
2161
2162 /**
2163  *      check_disc_changed - Check if a removable disc was changed.
2164  *      @de: The device.
2165  *
2166  *      Returns 1 if the media was changed, else 0.
2167  */
2168
2169 static int check_disc_changed (struct devfs_entry *de)
2170 {
2171     int tmp;
2172     kdev_t dev = MKDEV (de->u.fcb.u.device.major, de->u.fcb.u.device.minor);
2173     struct block_device_operations *bdops = de->u.fcb.ops;
2174     extern int warn_no_part;
2175
2176     if ( !S_ISBLK (de->mode) ) return 0;
2177     if (bdops == NULL) return 0;
2178     if (bdops->check_media_change == NULL) return 0;
2179     if ( !bdops->check_media_change (dev) ) return 0;
2180     printk ( KERN_DEBUG "VFS: Disk change detected on device %s\n",
2181              kdevname (dev) );
2182     if (invalidate_device(dev, 0))
2183         printk("VFS: busy inodes on changed media..\n");
2184     /*  Ugly hack to disable messages about unable to read partition table  */
2185     tmp = warn_no_part;
2186     warn_no_part = 0;
2187     if (bdops->revalidate) bdops->revalidate (dev);
2188     warn_no_part = tmp;
2189     return 1;
2190 }   /*  End Function check_disc_changed  */
2191
2192
2193 /**
2194  *      scan_dir_for_removable - Scan a directory for removable media devices and check media.
2195  *      @dir: The directory.
2196  */
2197
2198 static void scan_dir_for_removable (struct devfs_entry *dir)
2199 {
2200     struct devfs_entry *de;
2201
2202     if (dir->u.dir.num_removable < 1) return;
2203     for (de = dir->u.dir.first; de != NULL; de = de->next)
2204     {
2205         if (!de->registered) continue;
2206         if ( !S_ISBLK (de->mode) ) continue;
2207         if (!de->u.fcb.removable) continue;
2208         check_disc_changed (de);
2209     }
2210 }   /*  End Function scan_dir_for_removable  */
2211
2212 /**
2213  *      get_removable_partition - Get removable media partition.
2214  *      @dir: The parent directory.
2215  *      @name: The name of the entry.
2216  *      @namelen: The number of characters in <<name>>.
2217  *
2218  *      Returns 1 if the media was changed, else 0.
2219  */
2220
2221 static int get_removable_partition (struct devfs_entry *dir, const char *name,
2222                                     unsigned int namelen)
2223 {
2224     struct devfs_entry *de;
2225
2226     for (de = dir->u.dir.first; de != NULL; de = de->next)
2227     {
2228         if (!de->registered) continue;
2229         if ( !S_ISBLK (de->mode) ) continue;
2230         if (!de->u.fcb.removable) continue;
2231         if (strcmp (de->name, "disc") == 0) return check_disc_changed (de);
2232         /*  Support for names where the partition is appended to the disc name
2233          */
2234         if (de->namelen >= namelen) continue;
2235         if (strncmp (de->name, name, de->namelen) != 0) continue;
2236         return check_disc_changed (de);
2237     }
2238     return 0;
2239 }   /*  End Function get_removable_partition  */
2240
2241
2242 /*  Superblock operations follow  */
2243
2244 static struct inode_operations devfs_iops;
2245 static struct inode_operations devfs_dir_iops;
2246 static struct file_operations devfs_fops;
2247 static struct file_operations devfs_dir_fops;
2248 static struct inode_operations devfs_symlink_iops;
2249
2250 static void devfs_read_inode (struct inode *inode)
2251 {
2252     struct devfs_entry *de;
2253
2254     de = get_devfs_entry_from_vfs_inode (inode, TRUE);
2255     if (de == NULL)
2256     {
2257         printk ("%s: read_inode(%d): VFS inode: %p  NO devfs_entry\n",
2258                 DEVFS_NAME, (int) inode->i_ino, inode);
2259         return;
2260     }
2261 #ifdef CONFIG_DEVFS_DEBUG
2262     if (devfs_debug & DEBUG_I_READ)
2263         printk ("%s: read_inode(%d): VFS inode: %p  devfs_entry: %p\n",
2264                 DEVFS_NAME, (int) inode->i_ino, inode, de);
2265 #endif
2266     inode->i_blocks = 0;
2267     inode->i_blksize = 1024;
2268     inode->i_op = &devfs_iops;
2269     inode->i_fop = &devfs_fops;
2270     inode->i_rdev = NODEV;
2271     if ( S_ISCHR (de->inode.mode) )
2272     {
2273         inode->i_rdev = MKDEV (de->u.fcb.u.device.major,
2274                                de->u.fcb.u.device.minor);
2275         inode->i_cdev = cdget (kdev_t_to_nr(inode->i_rdev));
2276     }
2277     else if ( S_ISBLK (de->inode.mode) )
2278     {
2279         inode->i_rdev = MKDEV (de->u.fcb.u.device.major,
2280                                de->u.fcb.u.device.minor);
2281         inode->i_bdev = bdget (kdev_t_to_nr(inode->i_rdev));
2282         if (inode->i_bdev)
2283         {
2284             if (!inode->i_bdev->bd_op && de->u.fcb.ops)
2285                 inode->i_bdev->bd_op = de->u.fcb.ops;
2286         }
2287         else printk ("%s: read_inode(%d): no block device from bdget()\n",
2288                      DEVFS_NAME, (int) inode->i_ino);
2289     }
2290     else if ( S_ISFIFO (de->inode.mode) ) inode->i_fop = &def_fifo_fops;
2291     else if ( S_ISREG (de->inode.mode) ) inode->i_size = de->u.fcb.u.file.size;
2292     else if ( S_ISDIR (de->inode.mode) )
2293     {
2294         inode->i_op = &devfs_dir_iops;
2295         inode->i_fop = &devfs_dir_fops;
2296     }
2297     else if ( S_ISLNK (de->inode.mode) )
2298     {
2299         inode->i_op = &devfs_symlink_iops;
2300         inode->i_size = de->u.symlink.length;
2301     }
2302     inode->i_mode = de->inode.mode;
2303     inode->i_uid = de->inode.uid;
2304     inode->i_gid = de->inode.gid;
2305     inode->i_atime = de->inode.atime;
2306     inode->i_mtime = de->inode.mtime;
2307     inode->i_ctime = de->inode.ctime;
2308     inode->i_nlink = de->inode.nlink;
2309 #ifdef CONFIG_DEVFS_DEBUG
2310     if (devfs_debug & DEBUG_I_READ)
2311         printk ("%s:   mode: 0%o  uid: %d  gid: %d\n",
2312                 DEVFS_NAME, (int) inode->i_mode,
2313                 (int) inode->i_uid, (int) inode->i_gid);
2314 #endif
2315 }   /*  End Function devfs_read_inode  */
2316
2317 static void devfs_write_inode (struct inode *inode, int wait)
2318 {
2319     int index;
2320     struct devfs_entry *de;
2321     struct fs_info *fs_info = inode->i_sb->u.generic_sbp;
2322
2323     if (inode->i_ino < FIRST_INODE) return;
2324     index = inode->i_ino - FIRST_INODE;
2325     lock_kernel ();
2326     if (index >= fs_info->num_inodes)
2327     {
2328         printk ("%s: writing inode: %lu for which there is no entry!\n",
2329                 DEVFS_NAME, inode->i_ino);
2330         unlock_kernel ();
2331         return;
2332     }
2333     de = fs_info->table[index];
2334 #ifdef CONFIG_DEVFS_DEBUG
2335     if (devfs_debug & DEBUG_I_WRITE)
2336     {
2337         printk ("%s: write_inode(%d): VFS inode: %p  devfs_entry: %p\n",
2338                 DEVFS_NAME, (int) inode->i_ino, inode, de);
2339         printk ("%s:   mode: 0%o  uid: %d  gid: %d\n",
2340                 DEVFS_NAME, (int) inode->i_mode,
2341                 (int) inode->i_uid, (int) inode->i_gid);
2342     }
2343 #endif
2344     de->inode.mode = inode->i_mode;
2345     de->inode.uid = inode->i_uid;
2346     de->inode.gid = inode->i_gid;
2347     de->inode.atime = inode->i_atime;
2348     de->inode.mtime = inode->i_mtime;
2349     de->inode.ctime = inode->i_ctime;
2350     unlock_kernel ();
2351 }   /*  End Function devfs_write_inode  */
2352
2353 static int devfs_notify_change (struct dentry *dentry, struct iattr *iattr)
2354 {
2355     int retval;
2356     struct devfs_entry *de;
2357     struct inode *inode = dentry->d_inode;
2358     struct fs_info *fs_info = inode->i_sb->u.generic_sbp;
2359
2360     de = get_devfs_entry_from_vfs_inode (inode, TRUE);
2361     if (de == NULL) return -ENODEV;
2362     retval = inode_change_ok (inode, iattr);
2363     if (retval != 0) return retval;
2364     retval = inode_setattr (inode, iattr);
2365     if (retval != 0) return retval;
2366     if ( iattr->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID) )
2367         devfsd_notify_one (de, DEVFSD_NOTIFY_CHANGE, inode->i_mode,
2368                            inode->i_uid, inode->i_gid, fs_info);
2369     return 0;
2370 }   /*  End Function devfs_notify_change  */
2371
2372 static int devfs_statfs (struct super_block *sb, struct statfs *buf)
2373 {
2374     buf->f_type = DEVFS_SUPER_MAGIC;
2375     buf->f_bsize = PAGE_SIZE / sizeof (long);
2376     buf->f_bfree = 0;
2377     buf->f_bavail = 0;
2378     buf->f_ffree = 0;
2379     buf->f_namelen = NAME_MAX;
2380     return 0;
2381 }   /*  End Function devfs_statfs  */
2382
2383 static struct super_operations devfs_sops =
2384
2385     read_inode:    devfs_read_inode,
2386     write_inode:   devfs_write_inode,
2387     statfs:        devfs_statfs,
2388 };
2389
2390
2391 /**
2392  *      get_vfs_inode - Get a VFS inode.
2393  *      @sb: The super block.
2394  *      @de: The devfs inode.
2395  *      @dentry: The dentry to register with the devfs inode.
2396  *
2397  *      Returns the inode on success, else %NULL.
2398  */
2399
2400 static struct inode *get_vfs_inode (struct super_block *sb,
2401                                     struct devfs_entry *de,
2402                                     struct dentry *dentry)
2403 {
2404     struct inode *inode;
2405
2406     if (de->inode.dentry != NULL)
2407     {
2408         printk ("%s: get_vfs_inode(%u): old de->inode.dentry: %p \"%s\"  new dentry: %p \"%s\"\n",
2409                 DEVFS_NAME, de->inode.ino,
2410                 de->inode.dentry, de->inode.dentry->d_name.name,
2411                 dentry, dentry->d_name.name);
2412         printk ("  old inode: %p\n", de->inode.dentry->d_inode);
2413         return NULL;
2414     }
2415     if ( ( inode = iget (sb, de->inode.ino) ) == NULL ) return NULL;
2416     de->inode.dentry = dentry;
2417     return inode;
2418 }   /*  End Function get_vfs_inode  */
2419
2420
2421 /*  File operations for device entries follow  */
2422
2423 static int devfs_readdir (struct file *file, void *dirent, filldir_t filldir)
2424 {
2425     int err, count;
2426     int stored = 0;
2427     struct fs_info *fs_info;
2428     struct devfs_entry *parent, *de;
2429     struct inode *inode = file->f_dentry->d_inode;
2430
2431     fs_info = inode->i_sb->u.generic_sbp;
2432     parent = get_devfs_entry_from_vfs_inode (file->f_dentry->d_inode, TRUE);
2433     if ( (long) file->f_pos < 0 ) return -EINVAL;
2434 #ifdef CONFIG_DEVFS_DEBUG
2435     if (devfs_debug & DEBUG_F_READDIR)
2436         printk ("%s: readdir(): fs_info: %p  pos: %ld\n", DEVFS_NAME,
2437                 fs_info, (long) file->f_pos);
2438 #endif
2439     switch ( (long) file->f_pos )
2440     {
2441       case 0:
2442         scan_dir_for_removable (parent);
2443         err = (*filldir) (dirent, "..", 2, file->f_pos,
2444                           file->f_dentry->d_parent->d_inode->i_ino, DT_DIR);
2445         if (err == -EINVAL) break;
2446         if (err < 0) return err;
2447         file->f_pos++;
2448         ++stored;
2449         /*  Fall through  */
2450       case 1:
2451         err = (*filldir) (dirent, ".", 1, file->f_pos, inode->i_ino, DT_DIR);
2452         if (err == -EINVAL) break;
2453         if (err < 0) return err;
2454         file->f_pos++;
2455         ++stored;
2456         /*  Fall through  */
2457       default:
2458         /*  Skip entries  */
2459         count = file->f_pos - 2;
2460         for (de = parent->u.dir.first; (de != NULL) && (count > 0);
2461              de = de->next)
2462             if ( !IS_HIDDEN (de) ) --count;
2463         /*  Now add all remaining entries  */
2464         for (; de != NULL; de = de->next)
2465         {
2466             if ( IS_HIDDEN (de) ) continue;
2467             err = (*filldir) (dirent, de->name, de->namelen,
2468                               file->f_pos, de->inode.ino, de->mode >> 12);
2469             if (err == -EINVAL) break;
2470             if (err < 0) return err;
2471             file->f_pos++;
2472             ++stored;
2473         }
2474         break;
2475     }
2476     return stored;
2477 }   /*  End Function devfs_readdir  */
2478
2479 static int devfs_open (struct inode *inode, struct file *file)
2480 {
2481     int err;
2482     struct fcb_type *df;
2483     struct devfs_entry *de;
2484     struct fs_info *fs_info = inode->i_sb->u.generic_sbp;
2485
2486     lock_kernel ();
2487     de = get_devfs_entry_from_vfs_inode (inode, TRUE);
2488     err = -ENODEV;
2489     if (de == NULL)
2490         goto out;
2491     err = 0;
2492     if ( S_ISDIR (de->mode) )
2493         goto out;
2494     df = &de->u.fcb;
2495     file->private_data = de->info;
2496     if ( S_ISBLK (inode->i_mode) )
2497     {
2498         file->f_op = &def_blk_fops;
2499         if (df->ops) inode->i_bdev->bd_op = df->ops;
2500     }
2501     else file->f_op = fops_get ( (struct file_operations*) df->ops );
2502     if (file->f_op)
2503         err = file->f_op->open ? (*file->f_op->open) (inode, file) : 0;
2504     else
2505     {
2506         /*  Fallback to legacy scheme  */
2507         if ( S_ISCHR (inode->i_mode) ) err = chrdev_open (inode, file);
2508         else err = -ENODEV;
2509     }
2510     if (err < 0) goto out;
2511     /*  Open was successful  */
2512     err = 0;
2513     if (df->open) goto out;
2514     df->open = TRUE;  /*  This is the first open  */
2515     if (df->auto_owner)
2516     {
2517         /*  Change the ownership/protection  */
2518         de->inode.mode = (de->inode.mode & ~S_IALLUGO) |(de->mode & S_IRWXUGO);
2519         de->inode.uid = current->euid;
2520         de->inode.gid = current->egid;
2521         inode->i_mode = de->inode.mode;
2522         inode->i_uid = de->inode.uid;
2523         inode->i_gid = de->inode.gid;
2524     }
2525     if (df->aopen_notify)
2526         devfsd_notify_one (de, DEVFSD_NOTIFY_ASYNC_OPEN, inode->i_mode,
2527                            current->euid, current->egid, fs_info);
2528 out:
2529     unlock_kernel ();
2530     return err;
2531 }   /*  End Function devfs_open  */
2532
2533 static struct file_operations devfs_fops =
2534 {
2535     open: devfs_open,
2536 };
2537
2538 static struct file_operations devfs_dir_fops =
2539 {
2540     read: generic_read_dir,
2541     readdir: devfs_readdir,
2542     open: devfs_open,
2543 };
2544
2545
2546 /*  Dentry operations for device entries follow  */
2547
2548
2549 /**
2550  *      devfs_d_release - Callback for when a dentry is freed.
2551  *      @dentry: The dentry.
2552  */
2553
2554 static void devfs_d_release (struct dentry *dentry)
2555 {
2556 #ifdef CONFIG_DEVFS_DEBUG
2557     struct inode *inode = dentry->d_inode;
2558
2559     if (devfs_debug & DEBUG_D_RELEASE)
2560         printk ("%s: d_release(): dentry: %p inode: %p\n",
2561                 DEVFS_NAME, dentry, inode);
2562 #endif
2563 }   /*  End Function devfs_d_release  */
2564
2565 /**
2566  *      devfs_d_iput - Callback for when a dentry loses its inode.
2567  *      @dentry: The dentry.
2568  *      @inode: The inode.
2569  */
2570
2571 static void devfs_d_iput (struct dentry *dentry, struct inode *inode)
2572 {
2573     struct devfs_entry *de;
2574
2575     lock_kernel ();
2576     de = get_devfs_entry_from_vfs_inode (inode, FALSE);
2577 #ifdef CONFIG_DEVFS_DEBUG
2578     if (devfs_debug & DEBUG_D_IPUT)
2579         printk ("%s: d_iput(): dentry: %p inode: %p de: %p  de->dentry: %p\n",
2580                 DEVFS_NAME, dentry, inode, de, de->inode.dentry);
2581 #endif
2582     if (de->inode.dentry == dentry) de->inode.dentry = NULL;
2583     unlock_kernel ();
2584     iput (inode);
2585 }   /*  End Function devfs_d_iput  */
2586
2587 static int devfs_d_delete (struct dentry *dentry);
2588
2589 static struct dentry_operations devfs_dops =
2590 {
2591     d_delete:     devfs_d_delete,
2592     d_release:    devfs_d_release,
2593     d_iput:       devfs_d_iput,
2594 };
2595
2596 static int devfs_d_revalidate_wait (struct dentry *dentry, int flags);
2597
2598 static struct dentry_operations devfs_wait_dops =
2599 {
2600     d_delete:     devfs_d_delete,
2601     d_release:    devfs_d_release,
2602     d_iput:       devfs_d_iput,
2603     d_revalidate: devfs_d_revalidate_wait,
2604 };
2605
2606 /**
2607  *      devfs_d_delete - Callback for when all files for a dentry are closed.
2608  *      @dentry: The dentry.
2609  */
2610
2611 static int devfs_d_delete (struct dentry *dentry)
2612 {
2613     struct inode *inode = dentry->d_inode;
2614     struct devfs_entry *de;
2615     struct fs_info *fs_info;
2616
2617     if (dentry->d_op == &devfs_wait_dops) dentry->d_op = &devfs_dops;
2618     /*  Unhash dentry if negative (has no inode)  */
2619     if (inode == NULL)
2620     {
2621 #ifdef CONFIG_DEVFS_DEBUG
2622         if (devfs_debug & DEBUG_D_DELETE)
2623             printk ("%s: d_delete(): dropping negative dentry: %p\n",
2624                     DEVFS_NAME, dentry);
2625 #endif
2626         return 1;
2627     }
2628     fs_info = inode->i_sb->u.generic_sbp;
2629     de = get_devfs_entry_from_vfs_inode (inode, TRUE);
2630 #ifdef CONFIG_DEVFS_DEBUG
2631     if (devfs_debug & DEBUG_D_DELETE)
2632         printk ("%s: d_delete(): dentry: %p  inode: %p  devfs_entry: %p\n",
2633                 DEVFS_NAME, dentry, inode, de);
2634 #endif
2635     if (de == NULL) return 0;
2636     if ( !S_ISCHR (de->mode) && !S_ISBLK (de->mode) && !S_ISREG (de->mode) )
2637         return 0;
2638     if (!de->u.fcb.open) return 0;
2639     de->u.fcb.open = FALSE;
2640     if (de->u.fcb.aopen_notify)
2641         devfsd_notify_one (de, DEVFSD_NOTIFY_CLOSE, inode->i_mode,
2642                            current->euid, current->egid, fs_info);
2643     if (!de->u.fcb.auto_owner) return 0;
2644     /*  Change the ownership/protection back  */
2645     de->inode.mode = (de->inode.mode & ~S_IALLUGO) | S_IRUGO | S_IWUGO;
2646     de->inode.uid = de->u.fcb.default_uid;
2647     de->inode.gid = de->u.fcb.default_gid;
2648     inode->i_mode = de->inode.mode;
2649     inode->i_uid = de->inode.uid;
2650     inode->i_gid = de->inode.gid;
2651     return 0;
2652 }   /*  End Function devfs_d_delete  */
2653
2654 static int devfs_d_revalidate_wait (struct dentry *dentry, int flags)
2655 {
2656     devfs_handle_t de = dentry->d_fsdata;
2657     struct inode *dir;
2658     struct fs_info *fs_info;
2659
2660     lock_kernel ();
2661     dir = dentry->d_parent->d_inode;
2662     fs_info = dir->i_sb->u.generic_sbp;
2663     if (!de || de->registered)
2664     {
2665         if ( !dentry->d_inode && is_devfsd_or_child (fs_info) )
2666         {
2667             struct inode *inode;
2668
2669 #ifdef CONFIG_DEVFS_DEBUG
2670             char txt[STRING_LENGTH];
2671
2672             memset (txt, 0, STRING_LENGTH);
2673             memcpy (txt, dentry->d_name.name,
2674                     (dentry->d_name.len >= STRING_LENGTH) ?
2675                     (STRING_LENGTH - 1) : dentry->d_name.len);
2676             if (devfs_debug & DEBUG_I_LOOKUP)
2677                 printk ("%s: d_revalidate(): dentry: %p name: \"%s\" by: \"%s\"\n",
2678                         DEVFS_NAME, dentry, txt, current->comm);
2679 #endif
2680             if (de == NULL)
2681             {
2682                 devfs_handle_t parent;
2683
2684                 parent = get_devfs_entry_from_vfs_inode (dir, TRUE);
2685                 de = search_for_entry_in_dir (parent, dentry->d_name.name,
2686                                               dentry->d_name.len, FALSE);
2687             }
2688             if (de == NULL) goto out;
2689             /*  Create an inode, now that the driver information is available
2690              */
2691             if (de->no_persistence) update_devfs_inode_from_entry (de);
2692             else if (de->inode.ctime == 0) update_devfs_inode_from_entry (de);
2693             else de->inode.mode =
2694                      (de->mode & ~S_IALLUGO) | (de->inode.mode & S_IALLUGO);
2695             if ( ( inode = get_vfs_inode (dir->i_sb, de, dentry) ) == NULL )
2696                 goto out;
2697 #ifdef CONFIG_DEVFS_DEBUG
2698             if (devfs_debug & DEBUG_I_LOOKUP)
2699                 printk ("%s: d_revalidate(): new VFS inode(%u): %p  devfs_entry: %p\n",
2700                         DEVFS_NAME, de->inode.ino, inode, de);
2701 #endif
2702             d_instantiate (dentry, inode);
2703             goto out;
2704         }
2705     }
2706     if ( wait_for_devfsd_finished (fs_info) ) dentry->d_op = &devfs_dops;
2707 out:
2708     unlock_kernel ();
2709     return 1;
2710 }   /*  End Function devfs_d_revalidate_wait  */
2711
2712
2713 /*  Inode operations for device entries follow  */
2714
2715 static struct dentry *devfs_lookup (struct inode *dir, struct dentry *dentry)
2716 {
2717     struct fs_info *fs_info;
2718     struct devfs_entry *parent, *de;
2719     struct inode *inode;
2720     char txt[STRING_LENGTH];
2721
2722     /*  Set up the dentry operations before anything else, to ensure cleaning
2723         up on any error  */
2724     dentry->d_op = &devfs_dops;
2725     memset (txt, 0, STRING_LENGTH);
2726     memcpy (txt, dentry->d_name.name,
2727             (dentry->d_name.len >= STRING_LENGTH) ?
2728             (STRING_LENGTH - 1) : dentry->d_name.len);
2729 #ifdef CONFIG_DEVFS_DEBUG
2730     if (devfs_debug & DEBUG_I_LOOKUP)
2731         printk ("%s: lookup(%s): dentry: %p by: \"%s\"\n",
2732                 DEVFS_NAME, txt, dentry, current->comm);
2733 #endif
2734     fs_info = dir->i_sb->u.generic_sbp;
2735     /*  First try to get the devfs entry for this directory  */
2736     parent = get_devfs_entry_from_vfs_inode (dir, TRUE);
2737     if (parent == NULL) return ERR_PTR (-ENOENT);
2738     /*  Try to reclaim an existing devfs entry  */
2739     de = search_for_entry_in_dir (parent,
2740                                   dentry->d_name.name, dentry->d_name.len,
2741                                   FALSE);
2742     if ( ( (de == NULL) || !de->registered ) &&
2743          (parent->u.dir.num_removable > 0) &&
2744          get_removable_partition (parent, dentry->d_name.name,
2745                                   dentry->d_name.len) )
2746     {
2747         if (de == NULL)
2748             de = search_for_entry_in_dir (parent, dentry->d_name.name,
2749                                           dentry->d_name.len, FALSE);
2750     }
2751     if ( (de == NULL) || !de->registered )
2752     {
2753         /*  Try with devfsd. For any kind of failure, leave a negative dentry
2754             so someone else can deal with it (in the case where the sysadmin
2755             does a mknod()). It's important to do this before hashing the
2756             dentry, so that the devfsd queue is filled before revalidates
2757             can start  */
2758         if (try_modload (parent, fs_info,
2759                          dentry->d_name.name, dentry->d_name.len, txt) < 0)
2760         {
2761             d_add (dentry, NULL);
2762             return NULL;
2763         }
2764         /*  devfsd claimed success  */
2765         dentry->d_op = &devfs_wait_dops;
2766         dentry->d_fsdata = de;
2767         d_add (dentry, NULL);  /*  Open the floodgates  */
2768         /*  Unlock directory semaphore, which will release any waiters. They
2769             will get the hashed dentry, and may be forced to wait for
2770             revalidation  */
2771         up (&dir->i_sem);
2772         devfs_d_revalidate_wait (dentry, 0);  /*  I might have to wait too  */
2773         down (&dir->i_sem);      /*  Grab it again because them's the rules  */
2774         /*  If someone else has been so kind as to make the inode, we go home
2775             early  */
2776         if (dentry->d_inode) return NULL;
2777         if (de && !de->registered) return NULL;
2778         if (de == NULL)
2779             de = search_for_entry_in_dir (parent, dentry->d_name.name,
2780                                           dentry->d_name.len, FALSE);
2781         if (de == NULL) return NULL;
2782         /*  OK, there's an entry now, but no VFS inode yet  */
2783     }
2784     else
2785     {
2786         dentry->d_op = &devfs_wait_dops;
2787         d_add (dentry, NULL);  /*  Open the floodgates  */
2788     }
2789     /*  Create an inode, now that the driver information is available  */
2790     if (de->no_persistence) update_devfs_inode_from_entry (de);
2791     else if (de->inode.ctime == 0) update_devfs_inode_from_entry (de);
2792     else de->inode.mode =
2793              (de->mode & ~S_IALLUGO) | (de->inode.mode & S_IALLUGO);
2794     if ( ( inode = get_vfs_inode (dir->i_sb, de, dentry) ) == NULL )
2795         return ERR_PTR (-ENOMEM);
2796 #ifdef CONFIG_DEVFS_DEBUG
2797     if (devfs_debug & DEBUG_I_LOOKUP)
2798         printk ("%s: lookup(): new VFS inode(%u): %p  devfs_entry: %p\n",
2799                 DEVFS_NAME, de->inode.ino, inode, de);
2800 #endif
2801     d_instantiate (dentry, inode);
2802     /*  Unlock directory semaphore, which will release any waiters. They will
2803         get the hashed dentry, and may be forced to wait for revalidation  */
2804     up (&dir->i_sem);
2805     if (dentry->d_op == &devfs_wait_dops)
2806         devfs_d_revalidate_wait (dentry, 0);  /*  I might have to wait too  */
2807     down (&dir->i_sem);          /*  Grab it again because them's the rules  */
2808     return NULL;
2809 }   /*  End Function devfs_lookup  */
2810
2811 static int devfs_link (struct dentry *old_dentry, struct inode *dir,
2812                        struct dentry *dentry)
2813 {
2814     /*struct inode *inode = old_dentry->d_inode;*/
2815     char txt[STRING_LENGTH];
2816
2817     memset (txt, 0, STRING_LENGTH);
2818     memcpy (txt, old_dentry->d_name.name, old_dentry->d_name.len);
2819     txt[STRING_LENGTH - 1] = '\0';
2820     printk ("%s: link of \"%s\"\n", DEVFS_NAME, txt);
2821     return -EPERM;
2822 }   /*  End Function devfs_link  */
2823
2824 static int devfs_unlink (struct inode *dir, struct dentry *dentry)
2825 {
2826     struct devfs_entry *de;
2827
2828 #ifdef CONFIG_DEVFS_DEBUG
2829     char txt[STRING_LENGTH];
2830
2831     if (devfs_debug & DEBUG_I_UNLINK)
2832     {
2833         memset (txt, 0, STRING_LENGTH);
2834         memcpy (txt, dentry->d_name.name, dentry->d_name.len);
2835         txt[STRING_LENGTH - 1] = '\0';
2836         printk ("%s: unlink(%s)\n", DEVFS_NAME, txt);
2837     }
2838 #endif
2839
2840     de = get_devfs_entry_from_vfs_inode (dentry->d_inode, TRUE);
2841     if (de == NULL) return -ENOENT;
2842     de->registered = FALSE;
2843     de->hide = TRUE;
2844     if ( S_ISLNK (de->mode) ) kfree (de->u.symlink.linkname);
2845     free_dentries (de);
2846     return 0;
2847 }   /*  End Function devfs_unlink  */
2848
2849 static int devfs_symlink (struct inode *dir, struct dentry *dentry,
2850                           const char *symname)
2851 {
2852     int err;
2853     struct fs_info *fs_info;
2854     struct devfs_entry *parent, *de;
2855     struct inode *inode;
2856
2857     fs_info = dir->i_sb->u.generic_sbp;
2858     /*  First try to get the devfs entry for this directory  */
2859     parent = get_devfs_entry_from_vfs_inode (dir, TRUE);
2860     if (parent == NULL) return -ENOENT;
2861     err = devfs_do_symlink (parent, dentry->d_name.name, DEVFS_FL_NONE,
2862                             symname, &de, NULL);
2863 #ifdef CONFIG_DEVFS_DEBUG
2864     if (devfs_debug & DEBUG_DISABLED)
2865         printk ("%s: symlink(): errcode from <devfs_do_symlink>: %d\n",
2866                 DEVFS_NAME, err);
2867 #endif
2868     if (err < 0) return err;
2869     de->inode.mode = de->mode;
2870     de->inode.atime = CURRENT_TIME;
2871     de->inode.mtime = CURRENT_TIME;
2872     de->inode.ctime = CURRENT_TIME;
2873     if ( ( inode = get_vfs_inode (dir->i_sb, de, dentry) ) == NULL )
2874         return -ENOMEM;
2875 #ifdef CONFIG_DEVFS_DEBUG
2876     if (devfs_debug & DEBUG_DISABLED)
2877         printk ("%s: symlink(): new VFS inode(%u): %p  dentry: %p\n",
2878                 DEVFS_NAME, de->inode.ino, inode, dentry);
2879 #endif
2880     de->hide = FALSE;
2881     d_instantiate (dentry, inode);
2882     devfsd_notify_one (de, DEVFSD_NOTIFY_CREATE, inode->i_mode,
2883                        inode->i_uid, inode->i_gid, fs_info);
2884     return 0;
2885 }   /*  End Function devfs_symlink  */
2886
2887 static int devfs_mkdir (struct inode *dir, struct dentry *dentry, int mode)
2888 {
2889     int is_new;
2890     struct fs_info *fs_info;
2891     struct devfs_entry *parent, *de;
2892     struct inode *inode;
2893
2894     mode = (mode & ~S_IFMT) | S_IFDIR;
2895     fs_info = dir->i_sb->u.generic_sbp;
2896     /*  First try to get the devfs entry for this directory  */
2897     parent = get_devfs_entry_from_vfs_inode (dir, TRUE);
2898     if (parent == NULL) return -ENOENT;
2899     /*  Try to reclaim an existing devfs entry, create if there isn't one  */
2900     de = search_for_entry (parent, dentry->d_name.name, dentry->d_name.len,
2901                            FALSE, TRUE, &is_new, FALSE);