1 /* devfs (Device FileSystem) driver.
3 Copyright (C) 1998-2002 Richard Gooch
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.
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.
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.
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.
25 19980110 Richard Gooch <rgooch@atnf.csiro.au>
28 19980111 Richard Gooch <rgooch@atnf.csiro.au>
29 Created per-fs inode table rather than using inode->u.generic_ip
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().
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>.
42 19980113 Richard Gooch <rgooch@atnf.csiro.au>
43 Created <devfs_fill_file> function.
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.
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.
56 19980121 Richard Gooch <rgooch@atnf.csiro.au>
57 Supported creation of sockets.
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).
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.
68 19980124 Richard Gooch <rgooch@atnf.csiro.au>
69 Created <devfs_get_flags> and <devfs_set_flags>.
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.
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).
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).
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>.
100 19980207 Richard Gooch <rgooch@atnf.csiro.au>
101 Call kerneld when looking up unregistered entries.
103 19980326 Richard Gooch <rgooch@atnf.csiro.au>
104 Modified interface to <devfs_find_handle> for symlink traversal.
106 19980331 Richard Gooch <rgooch@atnf.csiro.au>
107 Fixed persistence bug with device numbers for manually created
109 Fixed problem with recreating symlinks with different content.
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.
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.
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.
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.
134 19980427 Richard Gooch <rgooch@atnf.csiro.au>
135 Added DEVFS_FL_AUTO_DEVNUM flag.
137 19980430 Richard Gooch <rgooch@atnf.csiro.au>
138 No longer set unnecessary methods.
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.
148 19980602 Richard Gooch <rgooch@atnf.csiro.au>
149 Support legacy device nodes.
150 Fixed bug where recreated inodes were hidden.
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.
158 19980627 Richard Gooch <rgooch@atnf.csiro.au>
159 Limit auto-device numbering to majors 128 to 239.
161 19980629 Richard Gooch <rgooch@atnf.csiro.au>
162 Fixed inode times persistence problem.
164 19980704 Richard Gooch <rgooch@atnf.csiro.au>
165 Fixed spelling in <devfs_readlink> debug.
166 Fixed bug in <devfs_setup> parsing "dilookup".
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.
172 19980727 Richard Gooch <rgooch@atnf.csiro.au>
173 Removed harmless "unused variable" compiler warning.
174 Fixed modes for manually recreated device nodes.
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.
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.
185 19980802 Richard Gooch <rgooch@atnf.csiro.au>
186 Fixed bugs in recreated directories and symlinks.
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.
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.
201 19980819 Richard Gooch <rgooch@atnf.csiro.au>
202 Added soothing message to warning in <devfs_d_iput>.
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.
209 19980908 Richard Gooch <rgooch@atnf.csiro.au>
210 Moved async open notification to end of <devfs_open>.
212 19980910 Richard Gooch <rgooch@atnf.csiro.au>
213 Prepended "/dev/" to module load request.
214 Renamed <call_kerneld> to <call_kmod>.
216 19980910 Richard Gooch <rgooch@atnf.csiro.au>
217 Fixed typo "AYSNC" -> "ASYNC".
219 19980910 Richard Gooch <rgooch@atnf.csiro.au>
220 Added open flag for files.
222 19980927 Richard Gooch <rgooch@atnf.csiro.au>
223 Set i_blocks=0 and i_blksize=1024 in <devfs_read_inode>.
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.
229 19981006 Richard Gooch <rgooch@atnf.csiro.au>
230 Created <devfs_get_fops>.
232 19981007 Richard Gooch <rgooch@atnf.csiro.au>
233 Limit auto-device numbering to majors 144 to 239.
235 19981010 Richard Gooch <rgooch@atnf.csiro.au>
236 Updated <devfs_follow_link> for VFS change in 2.1.125.
238 19981022 Richard Gooch <rgooch@atnf.csiro.au>
239 Created DEVFS_ FL_COMPAT flag.
241 19981023 Richard Gooch <rgooch@atnf.csiro.au>
242 Created "nocompat" boot option.
244 19981025 Richard Gooch <rgooch@atnf.csiro.au>
245 Replaced "mount" boot option with "nomount".
247 19981110 Richard Gooch <rgooch@atnf.csiro.au>
248 Created "only" boot option.
250 19981112 Richard Gooch <rgooch@atnf.csiro.au>
251 Added DEVFS_FL_REMOVABLE flag.
253 19981114 Richard Gooch <rgooch@atnf.csiro.au>
254 Only call <scan_dir_for_removable> on first call to
257 19981205 Richard Gooch <rgooch@atnf.csiro.au>
258 Updated <devfs_rmdir> for VFS change in 2.1.131.
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>.
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.
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.
275 19990126 Richard Gooch <rgooch@atnf.csiro.au>
276 Switched from PATH_MAX to DEVFS_PATHLEN.
278 19990127 Richard Gooch <rgooch@atnf.csiro.au>
279 Created "nottycompat" boot option.
281 19990318 Richard Gooch <rgooch@atnf.csiro.au>
282 Fixed <devfsd_read> to not overrun event buffer.
284 19990329 Richard Gooch <rgooch@atnf.csiro.au>
285 Created <devfs_auto_unregister>.
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.
293 19990402 Richard Gooch <rgooch@atnf.csiro.au>
294 Don't unregister already unregistered entries in <unregister>.
296 19990510 Richard Gooch <rgooch@atnf.csiro.au>
297 Disable warning messages when unable to read partition table for
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>.
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.
310 19990531 Richard Gooch <rgooch@atnf.csiro.au>
311 Improved debugging in <devfs_register>.
313 19990604 Richard Gooch <rgooch@atnf.csiro.au>
314 Added "diunlink" and "nokmod" boot options.
315 Removed superfluous warning message in <devfs_d_iput>.
317 19990611 Richard Gooch <rgooch@atnf.csiro.au>
318 Took account of change to <d_alloc_root>.
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.
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.
338 19990713 Richard Gooch <rgooch@atnf.csiro.au>
339 Return EISDIR rather than EINVAL for read(2) on directories.
341 19990809 Richard Gooch <rgooch@atnf.csiro.au>
342 Changed <devfs_setup> to new __init scheme.
344 19990901 Richard Gooch <rgooch@atnf.csiro.au>
345 Changed remaining function declarations to new __init scheme.
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.
354 19991017 Richard Gooch <rgooch@atnf.csiro.au>
355 Allow multiple unregistrations.
356 Work sponsored by SGI.
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.
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
367 Work sponsored by SGI.
369 19991031 Richard Gooch <rgooch@atnf.csiro.au>
370 Support "../" when searching devfs namespace.
371 Work sponsored by SGI.
373 19991101 Richard Gooch <rgooch@atnf.csiro.au>
374 Created <devfs_get_unregister_slave>.
375 Work sponsored by SGI.
377 19991103 Richard Gooch <rgooch@atnf.csiro.au>
378 Exported <devfs_get_parent>.
379 Work sponsored by SGI.
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.
390 19991107 Richard Gooch <rgooch@atnf.csiro.au>
391 Added DEVFS_FL_WAIT flag.
392 Work sponsored by SGI.
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.
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.
403 19991204 Richard Gooch <rgooch@atnf.csiro.au>
404 Support fifos when unregistering.
405 Work sponsored by SGI.
407 19991209 Richard Gooch <rgooch@atnf.csiro.au>
408 Removed obsolete DEVFS_ FL_COMPAT and DEVFS_ FL_TOLERANT flags.
409 Work sponsored by SGI.
411 19991214 Richard Gooch <rgooch@atnf.csiro.au>
412 Removed kmod support.
413 Work sponsored by SGI.
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.
420 19991223 Richard Gooch <rgooch@atnf.csiro.au>
421 Created <devfs_get_name>.
422 Work sponsored by SGI.
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.
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
433 Work sponsored by SGI.
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
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.
446 20000424 Richard Gooch <rgooch@atnf.csiro.au>
447 Don't create missing directories in <devfs_find_handle>.
448 Work sponsored by SGI.
450 20000430 Richard Gooch <rgooch@atnf.csiro.au>
451 Added CONFIG_DEVFS_MOUNT.
452 Work sponsored by SGI.
454 20000608 Richard Gooch <rgooch@atnf.csiro.au>
455 Disabled multi-mount capability (use VFS bindings instead).
456 Work sponsored by SGI.
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.
466 20000614 Richard Gooch <rgooch@atnf.csiro.au>
467 Merged devfs inode into devfs entry.
468 Work sponsored by SGI.
470 20000619 Richard Gooch <rgooch@atnf.csiro.au>
471 Removed dead code in <devfs_register> which used to call
473 Work sponsored by SGI.
475 20000621 Richard Gooch <rgooch@atnf.csiro.au>
476 Changed interface to <devfs_register>.
477 Work sponsored by SGI.
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.
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.
495 20010601 Richard Gooch <rgooch@atnf.csiro.au>
496 Fixed handling of inverted options in <devfs_setup>.
498 20010604 Richard Gooch <rgooch@atnf.csiro.au>
499 Adjusted <try_modload> to account for <devfs_generate_path> fix.
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.
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>.
514 20010712 Richard Gooch <rgooch@atnf.csiro.au>
515 Fixed bug in <devfs_setup> which could hang boot process.
517 20010730 Richard Gooch <rgooch@atnf.csiro.au>
518 Added DEVFSD_NOTIFY_DELETE event.
519 20010801 Richard Gooch <rgooch@atnf.csiro.au>
520 Removed #include <asm/segment.h>.
522 20010807 Richard Gooch <rgooch@atnf.csiro.au>
523 Fixed inode table races by removing it and using
524 inode->u.generic_ip instead.
525 Moved <devfs_read_inode> into <get_vfs_inode>.
526 Moved <devfs_write_inode> into <devfs_notify_change>.
528 20010808 Richard Gooch <rgooch@atnf.csiro.au>
529 Fixed race in <devfs_do_symlink> for uni-processor.
531 20010818 Richard Gooch <rgooch@atnf.csiro.au>
532 Removed remnant of multi-mount support in <devfs_mknod>.
533 Removed unused DEVFS_FL_SHOW_UNREG flag.
535 20010820 Richard Gooch <rgooch@atnf.csiro.au>
536 Removed nlink field from struct devfs_inode.
538 20010823 Richard Gooch <rgooch@atnf.csiro.au>
539 Replaced BKL with global rwsem to protect symlink data (quick
542 20010827 Richard Gooch <rgooch@atnf.csiro.au>
543 Replaced global rwsem for symlink with per-link refcount.
545 20010919 Richard Gooch <rgooch@atnf.csiro.au>
546 Set inode->i_mapping->a_ops for block nodes in <get_vfs_inode>.
548 20011008 Richard Gooch <rgooch@atnf.csiro.au>
549 Fixed overrun in <devfs_link> by removing function (not needed).
550 20011009 Richard Gooch <rgooch@atnf.csiro.au>
551 Fixed buffer underrun in <try_modload>.
552 20011029 Richard Gooch <rgooch@atnf.csiro.au>
553 Fixed race in <devfsd_ioctl> when setting event mask.
554 20011114 Richard Gooch <rgooch@atnf.csiro.au>
555 First release of new locking code.
557 20011117 Richard Gooch <rgooch@atnf.csiro.au>
558 Discard temporary buffer, now use "%s" for dentry names.
559 20011118 Richard Gooch <rgooch@atnf.csiro.au>
560 Don't generate path in <try_modload>: use fake entry instead.
561 Use "existing" directory in <_devfs_make_parent_for_leaf>.
562 20011122 Richard Gooch <rgooch@atnf.csiro.au>
563 Use slab cache rather than fixed buffer for devfsd events.
565 20011125 Richard Gooch <rgooch@atnf.csiro.au>
566 Send DEVFSD_NOTIFY_REGISTERED events in <devfs_mk_dir>.
567 20011127 Richard Gooch <rgooch@atnf.csiro.au>
568 Fixed locking bug in <devfs_d_revalidate_wait> due to typo.
569 Do not send CREATE, CHANGE, ASYNC_OPEN or DELETE events from
572 20011202 Richard Gooch <rgooch@atnf.csiro.au>
573 Fixed bug in <devfsd_read>: was dereferencing freed pointer.
575 20011203 Richard Gooch <rgooch@atnf.csiro.au>
576 Fixed bug in <devfsd_close>: was dereferencing freed pointer.
577 Added process group check for devfsd privileges.
579 20011204 Richard Gooch <rgooch@atnf.csiro.au>
580 Use SLAB_ATOMIC in <devfsd_notify_de> from <devfs_d_delete>.
582 20011211 Richard Gooch <rgooch@atnf.csiro.au>
583 Return old entry in <devfs_mk_dir> for 2.4.x kernels.
584 20011212 Richard Gooch <rgooch@atnf.csiro.au>
585 Increment refcount on module in <check_disc_changed>.
586 20011215 Richard Gooch <rgooch@atnf.csiro.au>
587 Created <devfs_get_handle> and exported <devfs_put>.
588 Increment refcount on module in <devfs_get_ops>.
589 Created <devfs_put_ops>.
591 20011216 Richard Gooch <rgooch@atnf.csiro.au>
592 Added poisoning to <devfs_put>.
593 Improved debugging messages.
595 20011221 Richard Gooch <rgooch@atnf.csiro.au>
596 Corrected (made useful) debugging message in <unregister>.
597 Moved <kmem_cache_create> in <mount_devfs_fs> to <init_devfs_fs>
598 20011224 Richard Gooch <rgooch@atnf.csiro.au>
599 Added magic number to guard against scribbling drivers.
600 20011226 Richard Gooch <rgooch@atnf.csiro.au>
601 Only return old entry in <devfs_mk_dir> if a directory.
602 Defined macros for error and debug messages.
604 20020113 Richard Gooch <rgooch@atnf.csiro.au>
605 Fixed (rare, old) race in <devfs_lookup>.
607 20020120 Richard Gooch <rgooch@atnf.csiro.au>
608 Fixed deadlock bug in <devfs_d_revalidate_wait>.
609 Tag VFS deletable in <devfs_mk_symlink> if handle ignored.
611 20020129 Richard Gooch <rgooch@atnf.csiro.au>
612 Added KERN_* to remaining messages.
613 Cleaned up declaration of <stat_read>.
615 20020219 Richard Gooch <rgooch@atnf.csiro.au>
616 Changed <devfs_rmdir> to allow later additions if not yet empty.
618 20020406 Richard Gooch <rgooch@atnf.csiro.au>
619 Removed silently introduced calls to lock_kernel() and
620 unlock_kernel() due to recent VFS locking changes. BKL isn't
623 20020428 Richard Gooch <rgooch@atnf.csiro.au>
624 Removed 2.4.x compatibility code.
626 20020510 Richard Gooch <rgooch@atnf.csiro.au>
627 Added BKL to <devfs_open> because drivers still need it.
629 20020512 Richard Gooch <rgooch@atnf.csiro.au>
630 Protected <scan_dir_for_removable> and <get_removable_partition>
631 from changing directory contents.
633 20020514 Richard Gooch <rgooch@atnf.csiro.au>
634 Minor cleanup of <scan_dir_for_removable>.
636 20020721 Richard Gooch <rgooch@atnf.csiro.au>
637 Switched to ISO C structure field initialisers.
638 Switch to set_current_state() and move before add_wait_queue().
639 20020722 Richard Gooch <rgooch@atnf.csiro.au>
640 Fixed devfs entry leak in <devfs_readdir> when *readdir fails.
642 20020725 Richard Gooch <rgooch@atnf.csiro.au>
643 Created <devfs_find_and_unregister>.
645 20020728 Richard Gooch <rgooch@atnf.csiro.au>
646 Removed deprecated <devfs_find_handle>.
648 20020820 Richard Gooch <rgooch@atnf.csiro.au>
649 Fixed module unload race in <devfs_open>.
651 20021013 Richard Gooch <rgooch@atnf.csiro.au>
652 Removed DEVFS_ FL_AUTO_OWNER.
653 Switched lingering structure field initialiser to ISO C.
654 Added locking when updating FCB flags.
657 #include <linux/types.h>
658 #include <linux/errno.h>
659 #include <linux/time.h>
660 #include <linux/tty.h>
661 #include <linux/timer.h>
662 #include <linux/config.h>
663 #include <linux/kernel.h>
664 #include <linux/wait.h>
665 #include <linux/string.h>
666 #include <linux/slab.h>
667 #include <linux/ioport.h>
668 #include <linux/delay.h>
669 #include <linux/ctype.h>
670 #include <linux/mm.h>
671 #include <linux/module.h>
672 #include <linux/init.h>
673 #include <linux/devfs_fs.h>
674 #include <linux/devfs_fs_kernel.h>
675 #include <linux/smp_lock.h>
676 #include <linux/smp.h>
677 #include <linux/rwsem.h>
678 #include <linux/sched.h>
679 #include <linux/namei.h>
681 #include <asm/uaccess.h>
683 #include <asm/processor.h>
684 #include <asm/system.h>
685 #include <asm/pgtable.h>
686 #include <asm/bitops.h>
687 #include <asm/atomic.h>
689 #define DEVFS_VERSION "2004-01-31"
691 #define DEVFS_NAME "devfs"
693 #define FIRST_INODE 1
695 #define STRING_LENGTH 256
696 #define FAKE_BLOCK_SIZE 1024
697 #define POISON_PTR ( *(void **) poison_array )
698 #define MAGIC_VALUE 0x327db823
705 #define MODE_DIR (S_IFDIR | S_IWUSR | S_IRUGO | S_IXUGO)
707 #define DEBUG_NONE 0x0000000
708 #define DEBUG_MODULE_LOAD 0x0000001
709 #define DEBUG_REGISTER 0x0000002
710 #define DEBUG_UNREGISTER 0x0000004
711 #define DEBUG_FREE 0x0000008
712 #define DEBUG_SET_FLAGS 0x0000010
713 #define DEBUG_S_READ 0x0000100 /* Break */
714 #define DEBUG_I_LOOKUP 0x0001000 /* Break */
715 #define DEBUG_I_CREATE 0x0002000
716 #define DEBUG_I_GET 0x0004000
717 #define DEBUG_I_CHANGE 0x0008000
718 #define DEBUG_I_UNLINK 0x0010000
719 #define DEBUG_I_RLINK 0x0020000
720 #define DEBUG_I_FLINK 0x0040000
721 #define DEBUG_I_MKNOD 0x0080000
722 #define DEBUG_F_READDIR 0x0100000 /* Break */
723 #define DEBUG_D_DELETE 0x1000000 /* Break */
724 #define DEBUG_D_RELEASE 0x2000000
725 #define DEBUG_D_IPUT 0x4000000
726 #define DEBUG_ALL 0xfffffff
727 #define DEBUG_DISABLED DEBUG_NONE
729 #define OPTION_NONE 0x00
730 #define OPTION_MOUNT 0x01
732 #define PRINTK(format, args...) \
733 {printk (KERN_ERR "%s" format, __FUNCTION__ , ## args);}
735 #define OOPS(format, args...) \
736 {printk (KERN_CRIT "%s" format, __FUNCTION__ , ## args); \
737 printk ("Forcing Oops\n"); \
740 #ifdef CONFIG_DEVFS_DEBUG
741 # define VERIFY_ENTRY(de) \
742 {if ((de) && (de)->magic_number != MAGIC_VALUE) \
743 OOPS ("(%p): bad magic value: %x\n", (de), (de)->magic_number);}
744 # define WRITE_ENTRY_MAGIC(de,magic) (de)->magic_number = (magic)
745 # define DPRINTK(flag, format, args...) \
746 {if (devfs_debug & flag) \
747 printk (KERN_INFO "%s" format, __FUNCTION__ , ## args);}
749 # define VERIFY_ENTRY(de)
750 # define WRITE_ENTRY_MAGIC(de,magic)
751 # define DPRINTK(flag, format, args...)
754 typedef struct devfs_entry *devfs_handle_t;
756 struct directory_type {
757 rwlock_t lock; /* Lock for searching(R)/updating(W) */
758 struct devfs_entry *first;
759 struct devfs_entry *last;
760 unsigned char no_more_additions:1;
763 struct symlink_type {
764 unsigned int length; /* Not including the NULL-termimator */
765 char *linkname; /* This is NULL-terminated */
768 struct devfs_inode { /* This structure is for "persistent" inode storage */
769 struct dentry *dentry;
770 struct timespec atime;
771 struct timespec mtime;
772 struct timespec ctime;
773 unsigned int ino; /* Inode number as seen in the VFS */
779 #ifdef CONFIG_DEVFS_DEBUG
780 unsigned int magic_number;
783 atomic_t refcount; /* When this drops to zero, it's unused */
785 struct directory_type dir;
787 struct symlink_type symlink;
788 const char *name; /* Only used for (mode == 0) */
790 struct devfs_entry *prev; /* Previous entry in the parent directory */
791 struct devfs_entry *next; /* Next entry in the parent directory */
792 struct devfs_entry *parent; /* The parent directory */
793 struct devfs_inode inode;
795 unsigned short namelen; /* I think 64k+ filenames are a way off... */
796 unsigned char vfs:1; /* Whether the VFS may delete the entry */
797 char name[1]; /* This is just a dummy: the allocated array
798 is bigger. This is NULL-terminated */
801 /* The root of the device tree */
802 static struct devfs_entry *root_entry;
804 struct devfsd_buf_entry {
805 struct devfs_entry *de; /* The name is generated with this */
806 unsigned short type; /* The type of event */
810 struct devfsd_buf_entry *next;
813 struct fs_info { /* This structure is for the mounted devfs */
814 struct super_block *sb;
815 spinlock_t devfsd_buffer_lock; /* Lock when inserting/deleting events */
816 struct devfsd_buf_entry *devfsd_first_event;
817 struct devfsd_buf_entry *devfsd_last_event;
818 volatile int devfsd_sleeping;
819 volatile struct task_struct *devfsd_task;
820 volatile pid_t devfsd_pgrp;
821 volatile struct file *devfsd_file;
822 struct devfsd_notify_struct *devfsd_info;
823 volatile unsigned long devfsd_event_mask;
824 atomic_t devfsd_overrun_count;
825 wait_queue_head_t devfsd_wait_queue; /* Wake devfsd on input */
826 wait_queue_head_t revalidate_wait_queue; /* Wake when devfsd sleeps */
829 static struct fs_info fs_info = {.devfsd_buffer_lock = SPIN_LOCK_UNLOCKED };
830 static kmem_cache_t *devfsd_buf_cache;
831 #ifdef CONFIG_DEVFS_DEBUG
832 static unsigned int devfs_debug_init __initdata = DEBUG_NONE;
833 static unsigned int devfs_debug = DEBUG_NONE;
834 static spinlock_t stat_lock = SPIN_LOCK_UNLOCKED;
835 static unsigned int stat_num_entries;
836 static unsigned int stat_num_bytes;
838 static unsigned char poison_array[8] =
839 { 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a };
841 #ifdef CONFIG_DEVFS_MOUNT
842 static unsigned int boot_options = OPTION_MOUNT;
844 static unsigned int boot_options = OPTION_NONE;
847 /* Forward function declarations */
848 static devfs_handle_t _devfs_walk_path(struct devfs_entry *dir,
849 const char *name, int namelen,
850 int traverse_symlink);
851 static ssize_t devfsd_read(struct file *file, char *buf, size_t len,
853 static int devfsd_ioctl(struct inode *inode, struct file *file,
854 unsigned int cmd, unsigned long arg);
855 static int devfsd_close(struct inode *inode, struct file *file);
856 #ifdef CONFIG_DEVFS_DEBUG
857 static ssize_t stat_read(struct file *file, char *buf, size_t len,
859 static struct file_operations stat_fops = {
864 /* Devfs daemon file operations */
865 static struct file_operations devfsd_fops = {
867 .ioctl = devfsd_ioctl,
868 .release = devfsd_close,
871 /* Support functions follow */
874 * devfs_get - Get a reference to a devfs entry.
875 * @de: The devfs entry.
878 static struct devfs_entry *devfs_get(struct devfs_entry *de)
882 atomic_inc(&de->refcount);
884 } /* End Function devfs_get */
887 * devfs_put - Put (release) a reference to a devfs entry.
888 * @de: The handle to the devfs entry.
891 static void devfs_put(devfs_handle_t de)
896 if (de->info == POISON_PTR)
897 OOPS("(%p): poisoned pointer\n", de);
898 if (!atomic_dec_and_test(&de->refcount))
900 if (de == root_entry)
901 OOPS("(%p): root entry being freed\n", de);
902 DPRINTK(DEBUG_FREE, "(%s): de: %p, parent: %p \"%s\"\n",
903 de->name, de, de->parent,
904 de->parent ? de->parent->name : "no parent");
905 if (S_ISLNK(de->mode))
906 kfree(de->u.symlink.linkname);
907 WRITE_ENTRY_MAGIC(de, 0);
908 #ifdef CONFIG_DEVFS_DEBUG
909 spin_lock(&stat_lock);
911 stat_num_bytes -= sizeof *de + de->namelen;
912 if (S_ISLNK(de->mode))
913 stat_num_bytes -= de->u.symlink.length + 1;
914 spin_unlock(&stat_lock);
916 de->info = POISON_PTR;
918 } /* End Function devfs_put */
921 * _devfs_search_dir - Search for a devfs entry in a directory.
922 * @dir: The directory to search.
923 * @name: The name of the entry to search for.
924 * @namelen: The number of characters in @name.
926 * Search for a devfs entry in a directory and returns a pointer to the entry
927 * on success, else %NULL. The directory must be locked already.
928 * An implicit devfs_get() is performed on the returned entry.
931 static struct devfs_entry *_devfs_search_dir(struct devfs_entry *dir,
933 unsigned int namelen)
935 struct devfs_entry *curr;
937 if (!S_ISDIR(dir->mode)) {
938 PRINTK("(%s): not a directory\n", dir->name);
941 for (curr = dir->u.dir.first; curr != NULL; curr = curr->next) {
942 if (curr->namelen != namelen)
944 if (memcmp(curr->name, name, namelen) == 0)
946 /* Not found: try the next one */
948 return devfs_get(curr);
949 } /* End Function _devfs_search_dir */
952 * _devfs_alloc_entry - Allocate a devfs entry.
953 * @name: the name of the entry
954 * @namelen: the number of characters in @name
955 * @mode: the mode for the entry
957 * Allocate a devfs entry and returns a pointer to the entry on success, else
961 static struct devfs_entry *_devfs_alloc_entry(const char *name,
962 unsigned int namelen,
965 struct devfs_entry *new;
966 static unsigned long inode_counter = FIRST_INODE;
967 static spinlock_t counter_lock = SPIN_LOCK_UNLOCKED;
969 if (name && (namelen < 1))
970 namelen = strlen(name);
971 if ((new = kmalloc(sizeof *new + namelen, GFP_KERNEL)) == NULL)
973 memset(new, 0, sizeof *new + namelen); /* Will set '\0' on name */
976 rwlock_init(&new->u.dir.lock);
977 atomic_set(&new->refcount, 1);
978 spin_lock(&counter_lock);
979 new->inode.ino = inode_counter++;
980 spin_unlock(&counter_lock);
982 memcpy(new->name, name, namelen);
983 new->namelen = namelen;
984 WRITE_ENTRY_MAGIC(new, MAGIC_VALUE);
985 #ifdef CONFIG_DEVFS_DEBUG
986 spin_lock(&stat_lock);
988 stat_num_bytes += sizeof *new + namelen;
989 spin_unlock(&stat_lock);
992 } /* End Function _devfs_alloc_entry */
995 * _devfs_append_entry - Append a devfs entry to a directory's child list.
996 * @dir: The directory to add to.
997 * @de: The devfs entry to append.
998 * @old_de: If an existing entry exists, it will be written here. This may
999 * be %NULL. An implicit devfs_get() is performed on this entry.
1001 * Append a devfs entry to a directory's list of children, checking first to
1002 * see if an entry of the same name exists. The directory will be locked.
1003 * The value 0 is returned on success, else a negative error code.
1004 * On failure, an implicit devfs_put() is performed on %de.
1007 static int _devfs_append_entry(devfs_handle_t dir, devfs_handle_t de,
1008 devfs_handle_t * old_de)
1014 if (!S_ISDIR(dir->mode)) {
1015 PRINTK("(%s): dir: \"%s\" is not a directory\n", de->name,
1020 write_lock(&dir->u.dir.lock);
1021 if (dir->u.dir.no_more_additions)
1024 struct devfs_entry *old;
1026 old = _devfs_search_dir(dir, de->name, de->namelen);
1033 de->prev = dir->u.dir.last;
1034 /* Append to the directory's list of children */
1035 if (dir->u.dir.first == NULL)
1036 dir->u.dir.first = de;
1038 dir->u.dir.last->next = de;
1039 dir->u.dir.last = de;
1044 write_unlock(&dir->u.dir.lock);
1048 } /* End Function _devfs_append_entry */
1051 * _devfs_get_root_entry - Get the root devfs entry.
1053 * Returns the root devfs entry on success, else %NULL.
1055 * TODO it must be called asynchronously due to the fact
1056 * that devfs is initialized relatively late. Proper way
1057 * is to remove module_init from init_devfs_fs and manually
1058 * call it early enough during system init
1061 static struct devfs_entry *_devfs_get_root_entry(void)
1063 struct devfs_entry *new;
1064 static spinlock_t root_lock = SPIN_LOCK_UNLOCKED;
1069 new = _devfs_alloc_entry(NULL, 0, MODE_DIR);
1073 spin_lock(&root_lock);
1075 spin_unlock(&root_lock);
1080 spin_unlock(&root_lock);
1083 } /* End Function _devfs_get_root_entry */
1086 * _devfs_descend - Descend down a tree using the next component name.
1087 * @dir: The directory to search.
1088 * @name: The component name to search for.
1089 * @namelen: The length of %name.
1090 * @next_pos: The position of the next '/' or '\0' is written here.
1092 * Descend into a directory, searching for a component. This function forms
1093 * the core of a tree-walking algorithm. The directory will be locked.
1094 * The devfs entry corresponding to the component is returned. If there is
1095 * no matching entry, %NULL is returned.
1096 * An implicit devfs_get() is performed on the returned entry.
1099 static struct devfs_entry *_devfs_descend(struct devfs_entry *dir,
1100 const char *name, int namelen,
1103 const char *stop, *ptr;
1104 struct devfs_entry *entry;
1106 if ((namelen >= 3) && (strncmp(name, "../", 3) == 0)) { /* Special-case going to parent directory */
1108 return devfs_get(dir->parent);
1110 stop = name + namelen;
1111 /* Search for a possible '/' */
1112 for (ptr = name; (ptr < stop) && (*ptr != '/'); ++ptr) ;
1113 *next_pos = ptr - name;
1114 read_lock(&dir->u.dir.lock);
1115 entry = _devfs_search_dir(dir, name, *next_pos);
1116 read_unlock(&dir->u.dir.lock);
1118 } /* End Function _devfs_descend */
1120 static devfs_handle_t _devfs_make_parent_for_leaf(struct devfs_entry *dir,
1122 int namelen, int *leaf_pos)
1127 dir = _devfs_get_root_entry();
1131 /* Search for possible trailing component and ignore it */
1132 for (--namelen; (namelen > 0) && (name[namelen] != '/'); --namelen) ;
1133 *leaf_pos = (name[namelen] == '/') ? (namelen + 1) : 0;
1134 for (; namelen > 0; name += next_pos, namelen -= next_pos) {
1135 struct devfs_entry *de, *old = NULL;
1138 _devfs_descend(dir, name, namelen, &next_pos)) == NULL) {
1139 de = _devfs_alloc_entry(name, next_pos, MODE_DIR);
1141 if (!de || _devfs_append_entry(dir, de, &old)) {
1143 if (!old || !S_ISDIR(old->mode)) {
1148 de = old; /* Use the existing directory */
1151 if (de == dir->parent) {
1158 if (name[next_pos] == '/')
1162 } /* End Function _devfs_make_parent_for_leaf */
1164 static devfs_handle_t _devfs_prepare_leaf(devfs_handle_t * dir,
1165 const char *name, umode_t mode)
1167 int namelen, leaf_pos;
1168 struct devfs_entry *de;
1170 namelen = strlen(name);
1171 if ((*dir = _devfs_make_parent_for_leaf(*dir, name, namelen,
1172 &leaf_pos)) == NULL) {
1173 PRINTK("(%s): could not create parent path\n", name);
1176 if ((de = _devfs_alloc_entry(name + leaf_pos, namelen - leaf_pos, mode))
1178 PRINTK("(%s): could not allocate entry\n", name);
1183 } /* End Function _devfs_prepare_leaf */
1185 static devfs_handle_t _devfs_walk_path(struct devfs_entry *dir,
1186 const char *name, int namelen,
1187 int traverse_symlink)
1192 dir = _devfs_get_root_entry();
1196 for (; namelen > 0; name += next_pos, namelen -= next_pos) {
1197 struct devfs_entry *de, *link;
1199 if (!S_ISDIR(dir->mode)) {
1205 _devfs_descend(dir, name, namelen, &next_pos)) == NULL) {
1209 if (S_ISLNK(de->mode) && traverse_symlink) { /* Need to follow the link: this is a stack chomper */
1210 /* FIXME what if it puts outside of mounted tree? */
1211 link = _devfs_walk_path(dir, de->u.symlink.linkname,
1212 de->u.symlink.length, TRUE);
1222 if (name[next_pos] == '/')
1226 } /* End Function _devfs_walk_path */
1229 * _devfs_find_entry - Find a devfs entry.
1230 * @dir: The handle to the parent devfs directory entry. If this is %NULL the
1231 * name is relative to the root of the devfs.
1232 * @name: The name of the entry. This may be %NULL.
1233 * @traverse_symlink: If %TRUE then symbolic links are traversed.
1235 * Returns the devfs_entry pointer on success, else %NULL. An implicit
1236 * devfs_get() is performed.
1239 static struct devfs_entry *_devfs_find_entry(devfs_handle_t dir,
1241 int traverse_symlink)
1243 unsigned int namelen = strlen(name);
1245 if (name[0] == '/') {
1246 /* Skip leading pathname component */
1248 PRINTK("(%s): too short\n", name);
1251 for (++name, --namelen; (*name != '/') && (namelen > 0);
1252 ++name, --namelen) ;
1254 PRINTK("(%s): too short\n", name);
1260 return _devfs_walk_path(dir, name, namelen, traverse_symlink);
1261 } /* End Function _devfs_find_entry */
1263 static struct devfs_entry *get_devfs_entry_from_vfs_inode(struct inode *inode)
1267 VERIFY_ENTRY((struct devfs_entry *)inode->u.generic_ip);
1268 return inode->u.generic_ip;
1269 } /* End Function get_devfs_entry_from_vfs_inode */
1272 * free_dentry - Free the dentry for a device entry and invalidate inode.
1275 * This must only be called after the entry has been unhooked from its
1279 static void free_dentry(struct devfs_entry *de)
1281 struct dentry *dentry = de->inode.dentry;
1285 spin_lock(&dcache_lock);
1286 dget_locked(dentry);
1287 spin_unlock(&dcache_lock);
1288 /* Forcefully remove the inode */
1289 if (dentry->d_inode != NULL)
1290 dentry->d_inode->i_nlink = 0;
1293 } /* End Function free_dentry */
1296 * is_devfsd_or_child - Test if the current process is devfsd or one of its children.
1297 * @fs_info: The filesystem information.
1299 * Returns %TRUE if devfsd or child, else %FALSE.
1302 static int is_devfsd_or_child(struct fs_info *fs_info)
1304 struct task_struct *p = current;
1306 if (p == fs_info->devfsd_task)
1308 if (process_group(p) == fs_info->devfsd_pgrp)
1310 read_lock(&tasklist_lock);
1311 for (; p != &init_task; p = p->real_parent) {
1312 if (p == fs_info->devfsd_task) {
1313 read_unlock(&tasklist_lock);
1317 read_unlock(&tasklist_lock);
1319 } /* End Function is_devfsd_or_child */
1322 * devfsd_queue_empty - Test if devfsd has work pending in its event queue.
1323 * @fs_info: The filesystem information.
1325 * Returns %TRUE if the queue is empty, else %FALSE.
1328 static inline int devfsd_queue_empty(struct fs_info *fs_info)
1330 return (fs_info->devfsd_last_event) ? FALSE : TRUE;
1331 } /* End Function devfsd_queue_empty */
1334 * wait_for_devfsd_finished - Wait for devfsd to finish processing its event queue.
1335 * @fs_info: The filesystem information.
1337 * Returns %TRUE if no more waiting will be required, else %FALSE.
1340 static int wait_for_devfsd_finished(struct fs_info *fs_info)
1342 DECLARE_WAITQUEUE(wait, current);
1344 if (fs_info->devfsd_task == NULL)
1346 if (devfsd_queue_empty(fs_info) && fs_info->devfsd_sleeping)
1348 if (is_devfsd_or_child(fs_info))
1350 set_current_state(TASK_UNINTERRUPTIBLE);
1351 add_wait_queue(&fs_info->revalidate_wait_queue, &wait);
1352 if (!devfsd_queue_empty(fs_info) || !fs_info->devfsd_sleeping)
1353 if (fs_info->devfsd_task)
1355 remove_wait_queue(&fs_info->revalidate_wait_queue, &wait);
1356 __set_current_state(TASK_RUNNING);
1358 } /* End Function wait_for_devfsd_finished */
1361 * devfsd_notify_de - Notify the devfsd daemon of a change.
1362 * @de: The devfs entry that has changed. This and all parent entries will
1363 * have their reference counts incremented if the event was queued.
1364 * @type: The type of change.
1365 * @mode: The mode of the entry.
1366 * @uid: The user ID.
1367 * @gid: The group ID.
1368 * @fs_info: The filesystem info.
1370 * Returns %TRUE if an event was queued and devfsd woken up, else %FALSE.
1373 static int devfsd_notify_de(struct devfs_entry *de,
1374 unsigned short type, umode_t mode,
1375 uid_t uid, gid_t gid, struct fs_info *fs_info)
1377 struct devfsd_buf_entry *entry;
1378 struct devfs_entry *curr;
1380 if (!(fs_info->devfsd_event_mask & (1 << type)))
1382 if ((entry = kmem_cache_alloc(devfsd_buf_cache, SLAB_KERNEL)) == NULL) {
1383 atomic_inc(&fs_info->devfsd_overrun_count);
1386 for (curr = de; curr != NULL; curr = curr->parent)
1394 spin_lock(&fs_info->devfsd_buffer_lock);
1395 if (!fs_info->devfsd_first_event)
1396 fs_info->devfsd_first_event = entry;
1397 if (fs_info->devfsd_last_event)
1398 fs_info->devfsd_last_event->next = entry;
1399 fs_info->devfsd_last_event = entry;
1400 spin_unlock(&fs_info->devfsd_buffer_lock);
1401 wake_up_interruptible(&fs_info->devfsd_wait_queue);
1403 } /* End Function devfsd_notify_de */
1406 * devfsd_notify - Notify the devfsd daemon of a change.
1407 * @de: The devfs entry that has changed.
1408 * @type: The type of change event.
1409 * @wait: If TRUE, the function waits for the daemon to finish processing
1413 static void devfsd_notify(struct devfs_entry *de, unsigned short type)
1415 devfsd_notify_de(de, type, de->mode, current->euid,
1416 current->egid, &fs_info);
1419 static int devfs_mk_dev(dev_t dev, umode_t mode, const char *fmt, va_list args)
1421 struct devfs_entry *dir = NULL, *de;
1425 n = vsnprintf(buf, sizeof(buf), fmt, args);
1426 if (n >= sizeof(buf) || !buf[0]) {
1427 printk(KERN_WARNING "%s: invalid format string %s\n",
1432 de = _devfs_prepare_leaf(&dir, buf, mode);
1434 printk(KERN_WARNING "%s: could not prepare leaf for %s\n",
1436 return -ENOMEM; /* could be more accurate... */
1441 error = _devfs_append_entry(dir, de, NULL);
1443 printk(KERN_WARNING "%s: could not append to parent for %s\n",
1448 devfsd_notify(de, DEVFSD_NOTIFY_REGISTERED);
1454 int devfs_mk_bdev(dev_t dev, umode_t mode, const char *fmt, ...)
1458 if (!S_ISBLK(mode)) {
1459 printk(KERN_WARNING "%s: invalide mode (%u) for %s\n",
1460 __FUNCTION__, mode, fmt);
1464 va_start(args, fmt);
1465 return devfs_mk_dev(dev, mode, fmt, args);
1468 EXPORT_SYMBOL(devfs_mk_bdev);
1470 int devfs_mk_cdev(dev_t dev, umode_t mode, const char *fmt, ...)
1474 if (!S_ISCHR(mode)) {
1475 printk(KERN_WARNING "%s: invalide mode (%u) for %s\n",
1476 __FUNCTION__, mode, fmt);
1480 va_start(args, fmt);
1481 return devfs_mk_dev(dev, mode, fmt, args);
1484 EXPORT_SYMBOL(devfs_mk_cdev);
1487 * _devfs_unhook - Unhook a device entry from its parents list
1488 * @de: The entry to unhook.
1490 * Returns %TRUE if the entry was unhooked, else %FALSE if it was
1491 * previously unhooked.
1492 * The caller must have a write lock on the parent directory.
1495 static int _devfs_unhook(struct devfs_entry *de)
1497 struct devfs_entry *parent;
1499 if (!de || (de->prev == de))
1501 parent = de->parent;
1502 if (de->prev == NULL)
1503 parent->u.dir.first = de->next;
1505 de->prev->next = de->next;
1506 if (de->next == NULL)
1507 parent->u.dir.last = de->prev;
1509 de->next->prev = de->prev;
1510 de->prev = de; /* Indicate we're unhooked */
1511 de->next = NULL; /* Force early termination for <devfs_readdir> */
1513 } /* End Function _devfs_unhook */
1516 * _devfs_unregister - Unregister a device entry from its parent.
1517 * @dir: The parent directory.
1518 * @de: The entry to unregister.
1520 * The caller must have a write lock on the parent directory, which is
1521 * unlocked by this function.
1524 static void _devfs_unregister(struct devfs_entry *dir, struct devfs_entry *de)
1526 int unhooked = _devfs_unhook(de);
1528 write_unlock(&dir->u.dir.lock);
1532 devfsd_notify(de, DEVFSD_NOTIFY_UNREGISTERED);
1535 if (!S_ISDIR(de->mode))
1537 while (TRUE) { /* Recursively unregister: this is a stack chomper */
1538 struct devfs_entry *child;
1540 write_lock(&de->u.dir.lock);
1541 de->u.dir.no_more_additions = TRUE;
1542 child = de->u.dir.first;
1543 VERIFY_ENTRY(child);
1544 _devfs_unregister(de, child);
1547 DPRINTK(DEBUG_UNREGISTER, "(%s): child: %p refcount: %d\n",
1548 child->name, child, atomic_read(&child->refcount));
1551 } /* End Function _devfs_unregister */
1553 static int devfs_do_symlink(devfs_handle_t dir, const char *name,
1554 const char *link, devfs_handle_t * handle)
1557 unsigned int linklength;
1559 struct devfs_entry *de;
1564 PRINTK("(): NULL name pointer\n");
1568 PRINTK("(%s): NULL link pointer\n", name);
1571 linklength = strlen(link);
1572 if ((newlink = kmalloc(linklength + 1, GFP_KERNEL)) == NULL)
1574 memcpy(newlink, link, linklength);
1575 newlink[linklength] = '\0';
1576 if ((de = _devfs_prepare_leaf(&dir, name, S_IFLNK | S_IRUGO | S_IXUGO))
1578 PRINTK("(%s): could not prepare leaf\n", name);
1583 de->u.symlink.linkname = newlink;
1584 de->u.symlink.length = linklength;
1585 if ((err = _devfs_append_entry(dir, de, NULL)) != 0) {
1586 PRINTK("(%s): could not append to parent, err: %d\n", name,
1592 #ifdef CONFIG_DEVFS_DEBUG
1593 spin_lock(&stat_lock);
1594 stat_num_bytes += linklength + 1;
1595 spin_unlock(&stat_lock);
1600 } /* End Function devfs_do_symlink */
1603 * devfs_mk_symlink Create a symbolic link in the devfs namespace.
1604 * @from: The name of the entry.
1605 * @to: Name of the destination
1607 * Returns 0 on success, else a negative error code is returned.
1610 int devfs_mk_symlink(const char *from, const char *to)
1615 err = devfs_do_symlink(NULL, from, to, &de);
1618 devfsd_notify(de, DEVFSD_NOTIFY_REGISTERED);
1625 * devfs_mk_dir - Create a directory in the devfs namespace.
1626 * new name is relative to the root of the devfs.
1627 * @fmt: The name of the entry.
1629 * Use of this function is optional. The devfs_register() function
1630 * will automatically create intermediate directories as needed. This function
1631 * is provided for efficiency reasons, as it provides a handle to a directory.
1632 * On failure %NULL is returned.
1635 int devfs_mk_dir(const char *fmt, ...)
1637 struct devfs_entry *dir = NULL, *de = NULL, *old;
1642 va_start(args, fmt);
1643 n = vsnprintf(buf, 64, fmt, args);
1644 if (n >= 64 || !buf[0]) {
1645 printk(KERN_WARNING "%s: invalid argument.", __FUNCTION__);
1649 de = _devfs_prepare_leaf(&dir, buf, MODE_DIR);
1651 PRINTK("(%s): could not prepare leaf\n", buf);
1655 error = _devfs_append_entry(dir, de, &old);
1656 if (error == -EEXIST && S_ISDIR(old->mode)) {
1658 * devfs_mk_dir() of an already-existing directory will
1664 PRINTK("(%s): could not append to dir: %p \"%s\"\n",
1665 buf, dir, dir->name);
1670 devfsd_notify(de, DEVFSD_NOTIFY_REGISTERED);
1677 void devfs_remove(const char *fmt, ...)
1683 va_start(args, fmt);
1684 n = vsnprintf(buf, sizeof(buf), fmt, args);
1685 if (n < sizeof(buf) && buf[0]) {
1686 devfs_handle_t de = _devfs_find_entry(NULL, buf, 0);
1689 printk(KERN_ERR "%s: %s not found, cannot remove\n",
1695 write_lock(&de->parent->u.dir.lock);
1696 _devfs_unregister(de->parent, de);
1703 * devfs_generate_path - Generate a pathname for an entry, relative to the devfs root.
1704 * @de: The devfs entry.
1705 * @path: The buffer to write the pathname to. The pathname and '\0'
1706 * terminator will be written at the end of the buffer.
1707 * @buflen: The length of the buffer.
1709 * Returns the offset in the buffer where the pathname starts on success,
1710 * else a negative error code.
1713 static int devfs_generate_path(devfs_handle_t de, char *path, int buflen)
1716 #define NAMEOF(de) ( (de)->mode ? (de)->name : (de)->u.name )
1721 if (de->namelen >= buflen)
1722 return -ENAMETOOLONG; /* Must be first */
1723 path[buflen - 1] = '\0';
1724 if (de->parent == NULL)
1725 return buflen - 1; /* Don't prepend root */
1726 pos = buflen - de->namelen - 1;
1727 memcpy(path + pos, NAMEOF(de), de->namelen);
1728 for (de = de->parent; de->parent != NULL; de = de->parent) {
1729 if (pos - de->namelen - 1 < 0)
1730 return -ENAMETOOLONG;
1733 memcpy(path + pos, NAMEOF(de), de->namelen);
1736 } /* End Function devfs_generate_path */
1739 * devfs_setup - Process kernel boot options.
1740 * @str: The boot options after the "devfs=".
1743 static int __init devfs_setup(char *str)
1749 } devfs_options_tab[] __initdata = {
1750 #ifdef CONFIG_DEVFS_DEBUG
1752 "dall", DEBUG_ALL, &devfs_debug_init}, {
1753 "dmod", DEBUG_MODULE_LOAD, &devfs_debug_init}, {
1754 "dreg", DEBUG_REGISTER, &devfs_debug_init}, {
1755 "dunreg", DEBUG_UNREGISTER, &devfs_debug_init}, {
1756 "dfree", DEBUG_FREE, &devfs_debug_init}, {
1757 "diget", DEBUG_I_GET, &devfs_debug_init}, {
1758 "dchange", DEBUG_SET_FLAGS, &devfs_debug_init}, {
1759 "dsread", DEBUG_S_READ, &devfs_debug_init}, {
1760 "dichange", DEBUG_I_CHANGE, &devfs_debug_init}, {
1761 "dimknod", DEBUG_I_MKNOD, &devfs_debug_init}, {
1762 "dilookup", DEBUG_I_LOOKUP, &devfs_debug_init}, {
1763 "diunlink", DEBUG_I_UNLINK, &devfs_debug_init},
1764 #endif /* CONFIG_DEVFS_DEBUG */
1766 "mount", OPTION_MOUNT, &boot_options}, {
1770 while ((*str != '\0') && !isspace(*str)) {
1771 int i, found = 0, invert = 0;
1773 if (strncmp(str, "no", 2) == 0) {
1777 for (i = 0; devfs_options_tab[i].name != NULL; i++) {
1778 int len = strlen(devfs_options_tab[i].name);
1780 if (strncmp(str, devfs_options_tab[i].name, len) == 0) {
1782 *devfs_options_tab[i].opt &=
1783 ~devfs_options_tab[i].mask;
1785 *devfs_options_tab[i].opt |=
1786 devfs_options_tab[i].mask;
1793 return 0; /* No match */
1795 return 0; /* No more options */
1799 } /* End Function devfs_setup */
1801 __setup("devfs=", devfs_setup);
1803 EXPORT_SYMBOL(devfs_mk_symlink);
1804 EXPORT_SYMBOL(devfs_mk_dir);
1805 EXPORT_SYMBOL(devfs_remove);
1808 * try_modload - Notify devfsd of an inode lookup by a non-devfsd process.
1809 * @parent: The parent devfs entry.
1810 * @fs_info: The filesystem info.
1811 * @name: The device name.
1812 * @namelen: The number of characters in @name.
1813 * @buf: A working area that will be used. This must not go out of scope
1814 * until devfsd is idle again.
1816 * Returns 0 on success (event was queued), else a negative error code.
1819 static int try_modload(struct devfs_entry *parent, struct fs_info *fs_info,
1820 const char *name, unsigned namelen,
1821 struct devfs_entry *buf)
1823 if (!(fs_info->devfsd_event_mask & (1 << DEVFSD_NOTIFY_LOOKUP)))
1825 if (is_devfsd_or_child(fs_info))
1827 memset(buf, 0, sizeof *buf);
1828 atomic_set(&buf->refcount, 1);
1829 buf->parent = parent;
1830 buf->namelen = namelen;
1832 WRITE_ENTRY_MAGIC(buf, MAGIC_VALUE);
1833 if (!devfsd_notify_de(buf, DEVFSD_NOTIFY_LOOKUP, 0,
1834 current->euid, current->egid, fs_info))
1836 /* Possible success: event has been queued */
1838 } /* End Function try_modload */
1840 /* Superblock operations follow */
1842 static struct inode_operations devfs_iops;
1843 static struct inode_operations devfs_dir_iops;
1844 static struct file_operations devfs_fops;
1845 static struct file_operations devfs_dir_fops;
1846 static struct inode_operations devfs_symlink_iops;
1848 static int devfs_notify_change(struct dentry *dentry, struct iattr *iattr)
1851 struct devfs_entry *de;
1852 struct inode *inode = dentry->d_inode;
1853 struct fs_info *fs_info = inode->i_sb->s_fs_info;
1855 de = get_devfs_entry_from_vfs_inode(inode);
1858 retval = inode_change_ok(inode, iattr);
1861 retval = inode_setattr(inode, iattr);
1864 DPRINTK(DEBUG_I_CHANGE, "(%d): VFS inode: %p devfs_entry: %p\n",
1865 (int)inode->i_ino, inode, de);
1866 DPRINTK(DEBUG_I_CHANGE, "(): mode: 0%o uid: %d gid: %d\n",
1867 (int)inode->i_mode, (int)inode->i_uid, (int)inode->i_gid);
1868 /* Inode is not on hash chains, thus must save permissions here rather
1869 than in a write_inode() method */
1870 de->mode = inode->i_mode;
1871 de->inode.uid = inode->i_uid;
1872 de->inode.gid = inode->i_gid;
1873 de->inode.atime = inode->i_atime;
1874 de->inode.mtime = inode->i_mtime;
1875 de->inode.ctime = inode->i_ctime;
1876 if ((iattr->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID)) &&
1877 !is_devfsd_or_child(fs_info))
1878 devfsd_notify_de(de, DEVFSD_NOTIFY_CHANGE, inode->i_mode,
1879 inode->i_uid, inode->i_gid, fs_info);
1881 } /* End Function devfs_notify_change */
1883 static struct super_operations devfs_sops = {
1884 .drop_inode = generic_delete_inode,
1885 .statfs = simple_statfs,
1889 * _devfs_get_vfs_inode - Get a VFS inode.
1890 * @sb: The super block.
1891 * @de: The devfs inode.
1892 * @dentry: The dentry to register with the devfs inode.
1894 * Returns the inode on success, else %NULL. An implicit devfs_get() is
1895 * performed if the inode is created.
1898 static struct inode *_devfs_get_vfs_inode(struct super_block *sb,
1899 struct devfs_entry *de,
1900 struct dentry *dentry)
1902 struct inode *inode;
1905 return NULL; /* Quick check to see if unhooked */
1906 if ((inode = new_inode(sb)) == NULL) {
1907 PRINTK("(%s): new_inode() failed, de: %p\n", de->name, de);
1911 read_lock(&de->parent->u.dir.lock);
1913 de->inode.dentry = dentry; /* Not unhooked */
1914 read_unlock(&de->parent->u.dir.lock);
1916 de->inode.dentry = dentry; /* Root: no locking needed */
1917 if (de->inode.dentry != dentry) { /* Must have been unhooked */
1921 /* FIXME where is devfs_put? */
1922 inode->u.generic_ip = devfs_get(de);
1923 inode->i_ino = de->inode.ino;
1924 DPRINTK(DEBUG_I_GET, "(%d): VFS inode: %p devfs_entry: %p\n",
1925 (int)inode->i_ino, inode, de);
1926 inode->i_blocks = 0;
1927 inode->i_blksize = FAKE_BLOCK_SIZE;
1928 inode->i_op = &devfs_iops;
1929 inode->i_mode = de->mode;
1930 if (S_ISDIR(de->mode)) {
1931 inode->i_op = &devfs_dir_iops;
1932 inode->i_fop = &devfs_dir_fops;
1933 } else if (S_ISLNK(de->mode)) {
1934 inode->i_op = &devfs_symlink_iops;
1935 inode->i_size = de->u.symlink.length;
1936 } else if (S_ISCHR(de->mode) || S_ISBLK(de->mode)) {
1937 init_special_inode(inode, de->mode, de->u.dev);
1938 } else if (S_ISFIFO(de->mode) || S_ISSOCK(de->mode)) {
1939 init_special_inode(inode, de->mode, 0);
1941 PRINTK("(%s): unknown mode %o de: %p\n",
1942 de->name, de->mode, de);
1948 inode->i_uid = de->inode.uid;
1949 inode->i_gid = de->inode.gid;
1950 inode->i_atime = de->inode.atime;
1951 inode->i_mtime = de->inode.mtime;
1952 inode->i_ctime = de->inode.ctime;
1953 DPRINTK(DEBUG_I_GET, "(): mode: 0%o uid: %d gid: %d\n",
1954 (int)inode->i_mode, (int)inode->i_uid, (int)inode->i_gid);
1956 } /* End Function _devfs_get_vfs_inode */
1958 /* File operations for device entries follow */
1960 static int devfs_readdir(struct file *file, void *dirent, filldir_t filldir)
1964 struct fs_info *fs_info;
1965 struct devfs_entry *parent, *de, *next = NULL;
1966 struct inode *inode = file->f_dentry->d_inode;
1968 fs_info = inode->i_sb->s_fs_info;
1969 parent = get_devfs_entry_from_vfs_inode(file->f_dentry->d_inode);
1970 if ((long)file->f_pos < 0)
1972 DPRINTK(DEBUG_F_READDIR, "(%s): fs_info: %p pos: %ld\n",
1973 parent->name, fs_info, (long)file->f_pos);
1974 switch ((long)file->f_pos) {
1976 err = (*filldir) (dirent, "..", 2, file->f_pos,
1977 parent_ino(file->f_dentry), DT_DIR);
1987 (*filldir) (dirent, ".", 1, file->f_pos, inode->i_ino,
1998 count = file->f_pos - 2;
1999 read_lock(&parent->u.dir.lock);
2000 for (de = parent->u.dir.first; de && (count > 0); de = de->next)
2003 read_unlock(&parent->u.dir.lock);
2004 /* Now add all remaining entries */
2006 err = (*filldir) (dirent, de->name, de->namelen,
2007 file->f_pos, de->inode.ino,
2019 read_lock(&parent->u.dir.lock);
2020 next = devfs_get(de->next);
2021 read_unlock(&parent->u.dir.lock);
2028 } /* End Function devfs_readdir */
2030 /* Open devfs specific special files */
2031 static int devfs_open(struct inode *inode, struct file *file)
2034 int minor = MINOR(inode->i_rdev);
2035 struct file_operations *old_fops, *new_fops;
2038 case 0: /* /dev/.devfsd */
2039 new_fops = fops_get(&devfsd_fops);
2041 #ifdef CONFIG_DEVFS_DEBUG
2042 case 1: /* /dev/.stat */
2043 new_fops = fops_get(&stat_fops);
2050 if (new_fops == NULL)
2052 old_fops = file->f_op;
2053 file->f_op = new_fops;
2054 err = new_fops->open ? new_fops->open(inode, file) : 0;
2056 file->f_op = old_fops;
2061 } /* End Function devfs_open */
2063 static struct file_operations devfs_fops = {
2067 static struct file_operations devfs_dir_fops = {
2068 .read = generic_read_dir,
2069 .readdir = devfs_readdir,
2072 /* Dentry operations for device entries follow */
2075 * devfs_d_release - Callback for when a dentry is freed.
2076 * @dentry: The dentry.
2079 static void devfs_d_release(struct dentry *dentry)
2081 DPRINTK(DEBUG_D_RELEASE, "(%p): inode: %p\n", dentry, dentry->d_inode);
2082 } /* End Function devfs_d_release */
2085 * devfs_d_iput - Callback for when a dentry loses its inode.
2086 * @dentry: The dentry.
2087 * @inode: The inode.
2090 static void devfs_d_iput(struct dentry *dentry, struct inode *inode)
2092 struct devfs_entry *de;
2094 de = get_devfs_entry_from_vfs_inode(inode);
2095 DPRINTK(DEBUG_D_IPUT,
2096 "(%s): dentry: %p inode: %p de: %p de->dentry: %p\n", de->name,
2097 dentry, inode, de, de->inode.dentry);
2098 if (de->inode.dentry && (de->inode.dentry != dentry))
2099 OOPS("(%s): de: %p dentry: %p de->dentry: %p\n",
2100 de->name, de, dentry, de->inode.dentry);
2101 de->inode.dentry = NULL;
2104 } /* End Function devfs_d_iput */
2106 static int devfs_d_delete(struct dentry *dentry);
2108 static struct dentry_operations devfs_dops = {
2109 .d_delete = devfs_d_delete,
2110 .d_release = devfs_d_release,
2111 .d_iput = devfs_d_iput,
2114 static int devfs_d_revalidate_wait(struct dentry *dentry, struct nameidata *);
2116 static struct dentry_operations devfs_wait_dops = {
2117 .d_delete = devfs_d_delete,
2118 .d_release = devfs_d_release,
2119 .d_iput = devfs_d_iput,
2120 .d_revalidate = devfs_d_revalidate_wait,
2124 * devfs_d_delete - Callback for when all files for a dentry are closed.
2125 * @dentry: The dentry.
2128 static int devfs_d_delete(struct dentry *dentry)
2130 struct inode *inode = dentry->d_inode;
2132 if (dentry->d_op == &devfs_wait_dops)
2133 dentry->d_op = &devfs_dops;
2134 /* Unhash dentry if negative (has no inode) */
2135 if (inode == NULL) {
2136 DPRINTK(DEBUG_D_DELETE, "(%p): dropping negative dentry\n",
2141 } /* End Function devfs_d_delete */
2143 struct devfs_lookup_struct {
2145 wait_queue_head_t wait_queue;
2148 /* XXX: this doesn't handle the case where we got a negative dentry
2149 but a devfs entry has been registered in the meanwhile */
2150 static int devfs_d_revalidate_wait(struct dentry *dentry, struct nameidata *nd)
2152 struct inode *dir = dentry->d_parent->d_inode;
2153 struct fs_info *fs_info = dir->i_sb->s_fs_info;
2154 devfs_handle_t parent = get_devfs_entry_from_vfs_inode(dir);
2155 struct devfs_lookup_struct *lookup_info = dentry->d_fsdata;
2156 DECLARE_WAITQUEUE(wait, current);
2163 * d_instantiate always runs under lock
2164 * we release i_sem lock before going to sleep
2166 * unfortunately sometimes d_revalidate is called with
2167 * and sometimes without i_sem lock held. The following checks
2168 * attempt to deduce when we need to add (and drop resp.) lock
2169 * here. This relies on current (2.6.2) calling coventions:
2171 * lookup_hash is always run under i_sem and is passing NULL
2174 * open(...,O_CREATE,...) calls _lookup_hash under i_sem
2175 * and sets flags to LOOKUP_OPEN|LOOKUP_CREATE
2177 * all other invocations of ->d_revalidate seem to happen
2181 (!(nd->flags & LOOKUP_CREATE) || (nd->flags & LOOKUP_PARENT));
2186 if (is_devfsd_or_child(fs_info)) {
2187 devfs_handle_t de = lookup_info->de;
2188 struct inode *inode;
2190 DPRINTK(DEBUG_I_LOOKUP,
2191 "(%s): dentry: %p inode: %p de: %p by: \"%s\"\n",
2192 dentry->d_name.name, dentry, dentry->d_inode, de,
2194 if (dentry->d_inode)
2197 read_lock(&parent->u.dir.lock);
2198 de = _devfs_search_dir(parent, dentry->d_name.name,
2199 dentry->d_name.len);
2200 read_unlock(&parent->u.dir.lock);
2203 lookup_info->de = de;
2205 /* Create an inode, now that the driver information is available */
2206 inode = _devfs_get_vfs_inode(dir->i_sb, de, dentry);
2209 DPRINTK(DEBUG_I_LOOKUP,
2210 "(%s): new VFS inode(%u): %p de: %p by: \"%s\"\n",
2211 de->name, de->inode.ino, inode, de, current->comm);
2212 d_instantiate(dentry, inode);
2215 if (lookup_info == NULL)
2216 goto out; /* Early termination */
2217 read_lock(&parent->u.dir.lock);
2218 if (dentry->d_fsdata) {
2219 set_current_state(TASK_UNINTERRUPTIBLE);
2220 add_wait_queue(&lookup_info->wait_queue, &wait);
2221 read_unlock(&parent->u.dir.lock);
2222 /* at this point it is always (hopefully) locked */
2227 * This does not need nor should remove wait from wait_queue.
2228 * Wait queue head is never reused - nothing is ever added to it
2229 * after all waiters have been waked up and head itself disappears
2230 * very soon after it. Moreover it is local variable on stack that
2231 * is likely to have already disappeared so any reference to it
2232 * at this point is buggy.
2236 read_unlock(&parent->u.dir.lock);
2242 } /* End Function devfs_d_revalidate_wait */
2244 /* Inode operations for device entries follow */
2246 static struct dentry *devfs_lookup(struct inode *dir, struct dentry *dentry,
2247 struct nameidata *nd)
2249 struct devfs_entry tmp; /* Must stay in scope until devfsd idle again */
2250 struct devfs_lookup_struct lookup_info;
2251 struct fs_info *fs_info = dir->i_sb->s_fs_info;
2252 struct devfs_entry *parent, *de;
2253 struct inode *inode;
2254 struct dentry *retval = NULL;
2256 /* Set up the dentry operations before anything else, to ensure cleaning
2258 dentry->d_op = &devfs_dops;
2259 /* First try to get the devfs entry for this directory */
2260 parent = get_devfs_entry_from_vfs_inode(dir);
2261 DPRINTK(DEBUG_I_LOOKUP, "(%s): dentry: %p parent: %p by: \"%s\"\n",
2262 dentry->d_name.name, dentry, parent, current->comm);
2264 return ERR_PTR(-ENOENT);
2265 read_lock(&parent->u.dir.lock);
2266 de = _devfs_search_dir(parent, dentry->d_name.name, dentry->d_name.len);
2267 read_unlock(&parent->u.dir.lock);
2268 lookup_info.de = de;
2269 init_waitqueue_head(&lookup_info.wait_queue);
2270 dentry->d_fsdata = &lookup_info;
2271 if (de == NULL) { /* Try with devfsd. For any kind of failure, leave a negative dentry
2272 so someone else can deal with it (in the case where the sysadmin
2273 does a mknod()). It's important to do this before hashing the
2274 dentry, so that the devfsd queue is filled before revalidates
2276 if (try_modload(parent, fs_info, dentry->d_name.name, dentry->d_name.len, &tmp) < 0) { /* Lookup event was not queued to devfsd */
2277 d_add(dentry, NULL);
2281 dentry->d_op = &devfs_wait_dops;
2282 d_add(dentry, NULL); /* Open the floodgates */
2283 /* Unlock directory semaphore, which will release any waiters. They
2284 will get the hashed dentry, and may be forced to wait for
2287 wait_for_devfsd_finished(fs_info); /* If I'm not devfsd, must wait */
2288 down(&dir->i_sem); /* Grab it again because them's the rules */
2289 de = lookup_info.de;
2290 /* If someone else has been so kind as to make the inode, we go home
2292 if (dentry->d_inode)
2295 read_lock(&parent->u.dir.lock);
2296 de = _devfs_search_dir(parent, dentry->d_name.name,
2297 dentry->d_name.len);
2298 read_unlock(&parent->u.dir.lock);
2301 /* OK, there's an entry now, but no VFS inode yet */
2303 /* Create an inode, now that the driver information is available */
2304 inode = _devfs_get_vfs_inode(dir->i_sb, de, dentry);
2306 retval = ERR_PTR(-ENOMEM);
2309 DPRINTK(DEBUG_I_LOOKUP,
2310 "(%s): new VFS inode(%u): %p de: %p by: \"%s\"\n", de->name,
2311 de->inode.ino, inode, de, current->comm);
2312 d_instantiate(dentry, inode);
2314 write_lock(&parent->u.dir.lock);
2315 dentry->d_op = &devfs_dops;
2316 dentry->d_fsdata = NULL;
2317 wake_up(&lookup_info.wait_queue);
2318 write_unlock(&parent->u.dir.lock);
2321 } /* End Function devfs_lookup */
2323 static int devfs_unlink(struct inode *dir, struct dentry *dentry)
2326 struct devfs_entry *de;
2327 struct inode *inode = dentry->d_inode;
2328 struct fs_info *fs_info = dir->i_sb->s_fs_info;
2330 de = get_devfs_entry_from_vfs_inode(inode);
2331 DPRINTK(DEBUG_I_UNLINK, "(%s): de: %p\n", dentry->d_name.name, de);
2336 write_lock(&de->parent->u.dir.lock);
2337 unhooked = _devfs_unhook(de);
2338 write_unlock(&de->parent->u.dir.lock);
2341 if (!is_devfsd_or_child(fs_info))
2342 devfsd_notify_de(de, DEVFSD_NOTIFY_DELETE, inode->i_mode,
2343 inode->i_uid, inode->i_gid, fs_info);
2347 } /* End Function devfs_unlink */
2349 static int devfs_symlink(struct inode *dir, struct dentry *dentry,
2350 const char *symname)
2353 struct fs_info *fs_info = dir->i_sb->s_fs_info;
2354 struct devfs_entry *parent, *de;
2355 struct inode *inode;
2357 /* First try to get the devfs entry for this directory */
2358 parent = get_devfs_entry_from_vfs_inode(dir);
2361 err = devfs_do_symlink(parent, dentry->d_name.name, symname, &de);
2362 DPRINTK(DEBUG_DISABLED, "(%s): errcode from <devfs_do_symlink>: %d\n",
2363 dentry->d_name.name, err);
2367 de->inode.uid = current->euid;
2368 de->inode.gid = current->egid;
2369 de->inode.atime = CURRENT_TIME;
2370 de->inode.mtime = CURRENT_TIME;
2371 de->inode.ctime = CURRENT_TIME;
2372 if ((inode = _devfs_get_vfs_inode(dir->i_sb, de, dentry)) == NULL)
2374 DPRINTK(DEBUG_DISABLED, "(%s): new VFS inode(%u): %p dentry: %p\n",
2375 dentry->d_name.name, de->inode.ino, inode, dentry);
2376 d_instantiate(dentry, inode);
2377 if (!is_devfsd_or_child(fs_info))
2378 devfsd_notify_de(de, DEVFSD_NOTIFY_CREATE, inode->i_mode,
2379 inode->i_uid, inode->i_gid, fs_info);
2381 } /* End Function devfs_symlink */
2383 static int devfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
2386 struct fs_info *fs_info = dir->i_sb->s_fs_info;
2387 struct devfs_entry *parent, *de;
2388 struct inode *inode;
2390 mode = (mode & ~S_IFMT) | S_IFDIR; /* VFS doesn't pass S_IFMT part */
2391 parent = get_devfs_entry_from_vfs_inode(dir);
2394 de = _devfs_alloc_entry(dentry->d_name.name, dentry->d_name.len, mode);
2398 if ((err = _devfs_append_entry(parent, de, NULL)) != 0)
2400 de->inode.uid = current->euid;
2401 de->inode.gid = current->egid;
2402 de->inode.atime = CURRENT_TIME;
2403 de->inode.mtime = CURRENT_TIME;
2404 de->inode.ctime = CURRENT_TIME;
2405 if ((inode = _devfs_get_vfs_inode(dir->i_sb, de, dentry)) == NULL)
2407 DPRINTK(DEBUG_DISABLED, "(%s): new VFS inode(%u): %p dentry: %p\n",
2408 dentry->d_name.name, de->inode.ino, inode, dentry);
2409 d_instantiate(dentry, inode);
2410 if (!is_devfsd_or_child(fs_info))
2411 devfsd_notify_de(de, DEVFSD_NOTIFY_CREATE, inode->i_mode,
2412 inode->i_uid, inode->i_gid, fs_info);
2414 } /* End Function devfs_mkdir */
2416 static int devfs_rmdir(struct inode *dir, struct dentry *dentry)
2419 struct devfs_entry *de;
2420 struct fs_info *fs_info = dir->i_sb->s_fs_info;
2421 struct inode *inode = dentry->d_inode;
2423 if (dir->i_sb->s_fs_info != inode->i_sb->s_fs_info)
2425 de = get_devfs_entry_from_vfs_inode(inode);
2428 if (!S_ISDIR(de->mode))
2432 /* First ensure the directory is empty and will stay that way */
2433 write_lock(&de->u.dir.lock);
2434 if (de->u.dir.first)
2437 de->u.dir.no_more_additions = TRUE;
2438 write_unlock(&de->u.dir.lock);
2441 /* Now unhook the directory from its parent */
2442 write_lock(&de->parent->u.dir.lock);
2443 if (!_devfs_unhook(de))
2445 write_unlock(&de->parent->u.dir.lock);
2448 if (!is_devfsd_or_child(fs_info))
2449 devfsd_notify_de(de, DEVFSD_NOTIFY_DELETE, inode->i_mode,
2450 inode->i_uid, inode->i_gid, fs_info);
2454 } /* End Function devfs_rmdir */
2456 static int devfs_mknod(struct inode *dir, struct dentry *dentry, int mode,
2460 struct fs_info *fs_info = dir->i_sb->s_fs_info;
2461 struct devfs_entry *parent, *de;
2462 struct inode *inode;
2464 DPRINTK(DEBUG_I_MKNOD, "(%s): mode: 0%o dev: %u:%u\n",
2465 dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
2466 parent = get_devfs_entry_from_vfs_inode(dir);
2469 de = _devfs_alloc_entry(dentry->d_name.name, dentry->d_name.len, mode);
2473 if (S_ISCHR(mode) || S_ISBLK(mode))
2475 if ((err = _devfs_append_entry(parent, de, NULL)) != 0)
2477 de->inode.uid = current->euid;
2478 de->inode.gid = current->egid;
2479 de->inode.atime = CURRENT_TIME;
2480 de->inode.mtime = CURRENT_TIME;
2481 de->inode.ctime = CURRENT_TIME;
2482 if ((inode = _devfs_get_vfs_inode(dir->i_sb, de, dentry)) == NULL)
2484 DPRINTK(DEBUG_I_MKNOD, ": new VFS inode(%u): %p dentry: %p\n",
2485 de->inode.ino, inode, dentry);
2486 d_instantiate(dentry, inode);
2487 if (!is_devfsd_or_child(fs_info))
2488 devfsd_notify_de(de, DEVFSD_NOTIFY_CREATE, inode->i_mode,
2489 inode->i_uid, inode->i_gid, fs_info);
2491 } /* End Function devfs_mknod */
2493 static int devfs_readlink(struct dentry *dentry, char *buffer, int buflen)
2496 struct devfs_entry *de;
2498 de = get_devfs_entry_from_vfs_inode(dentry->d_inode);
2501 err = vfs_readlink(dentry, buffer, buflen, de->u.symlink.linkname);
2503 } /* End Function devfs_readlink */
2505 static int devfs_follow_link(struct dentry *dentry, struct nameidata *nd)
2508 struct devfs_entry *de;
2510 de = get_devfs_entry_from_vfs_inode(dentry->d_inode);
2513 err = vfs_follow_link(nd, de->u.symlink.linkname);
2515 } /* End Function devfs_follow_link */
2517 static struct inode_operations devfs_iops = {
2518 .setattr = devfs_notify_change,
2521 static struct inode_operations devfs_dir_iops = {
2522 .lookup = devfs_lookup,
2523 .unlink = devfs_unlink,
2524 .symlink = devfs_symlink,
2525 .mkdir = devfs_mkdir,
2526 .rmdir = devfs_rmdir,
2527 .mknod = devfs_mknod,
2528 .setattr = devfs_notify_change,
2531 static struct inode_operations devfs_symlink_iops = {
2532 .readlink = devfs_readlink,
2533 .follow_link = devfs_follow_link,
2534 .setattr = devfs_notify_change,
2537 static int devfs_fill_super(struct super_block *sb, void *data, int silent)
2539 struct inode *root_inode = NULL;
2541 if (_devfs_get_root_entry() == NULL)
2543 atomic_set(&fs_info.devfsd_overrun_count, 0);
2544 init_waitqueue_head(&fs_info.devfsd_wait_queue);
2545 init_waitqueue_head(&fs_info.revalidate_wait_queue);
2547 sb->s_fs_info = &fs_info;
2548 sb->s_blocksize = 1024;
2549 sb->s_blocksize_bits = 10;
2550 sb->s_magic = DEVFS_SUPER_MAGIC;
2551 sb->s_op = &devfs_sops;
2552 if ((root_inode = _devfs_get_vfs_inode(sb, root_entry, NULL)) == NULL)
2554 sb->s_root = d_alloc_root(root_inode);
2557 DPRINTK(DEBUG_S_READ, "(): made devfs ptr: %p\n", sb->s_fs_info);
2561 PRINTK("(): get root inode failed\n");
2565 } /* End Function devfs_fill_super */
2567 static struct super_block *devfs_get_sb(struct file_system_type *fs_type,
2568 int flags, const char *dev_name,
2571 return get_sb_single(fs_type, flags, data, devfs_fill_super);
2574 static struct file_system_type devfs_fs_type = {
2576 .get_sb = devfs_get_sb,
2577 .kill_sb = kill_anon_super,
2580 /* File operations for devfsd follow */
2582 static ssize_t devfsd_read(struct file *file, char *buf, size_t len,
2587 loff_t pos, devname_offset, tlen, rpos;
2589 struct devfsd_buf_entry *entry;
2590 struct fs_info *fs_info = file->f_dentry->d_inode->i_sb->s_fs_info;
2591 struct devfsd_notify_struct *info = fs_info->devfsd_info;
2592 DECLARE_WAITQUEUE(wait, current);
2594 /* Can't seek (pread) on this device */
2595 if (ppos != &file->f_pos)
2597 /* Verify the task has grabbed the queue */
2598 if (fs_info->devfsd_task != current)
2602 /* Block for a new entry */
2603 set_current_state(TASK_INTERRUPTIBLE);
2604 add_wait_queue(&fs_info->devfsd_wait_queue, &wait);
2605 while (devfsd_queue_empty(fs_info)) {
2606 fs_info->devfsd_sleeping = TRUE;
2607 wake_up(&fs_info->revalidate_wait_queue);
2609 fs_info->devfsd_sleeping = FALSE;
2610 if (signal_pending(current)) {
2611 remove_wait_queue(&fs_info->devfsd_wait_queue, &wait);
2612 __set_current_state(TASK_RUNNING);
2615 set_current_state(TASK_INTERRUPTIBLE);
2617 remove_wait_queue(&fs_info->devfsd_wait_queue, &wait);
2618 __set_current_state(TASK_RUNNING);
2619 /* Now play with the data */
2620 ival = atomic_read(&fs_info->devfsd_overrun_count);
2621 info->overrun_count = ival;
2622 entry = fs_info->devfsd_first_event;
2623 info->type = entry->type;
2624 info->mode = entry->mode;
2625 info->uid = entry->uid;
2626 info->gid = entry->gid;
2628 if (S_ISCHR(de->mode) || S_ISBLK(de->mode)) {
2629 info->major = MAJOR(de->u.dev);
2630 info->minor = MINOR(de->u.dev);
2632 pos = devfs_generate_path(de, info->devname, DEVFS_PATHLEN);
2635 info->namelen = DEVFS_PATHLEN - pos - 1;
2636 if (info->mode == 0)
2637 info->mode = de->mode;
2638 devname_offset = info->devname - (char *)info;
2640 if (rpos < devname_offset) {
2641 /* Copy parts of the header */
2642 tlen = devname_offset - rpos;
2645 if (copy_to_user(buf, (char *)info + rpos, tlen)) {
2652 if ((rpos >= devname_offset) && (len > 0)) {
2654 tlen = info->namelen + 1;
2660 (buf, info->devname + pos + rpos - devname_offset, tlen)) {
2665 tlen = rpos - *ppos;
2667 devfs_handle_t parent;
2669 spin_lock(&fs_info->devfsd_buffer_lock);
2670 fs_info->devfsd_first_event = entry->next;
2671 if (entry->next == NULL)
2672 fs_info->devfsd_last_event = NULL;
2673 spin_unlock(&fs_info->devfsd_buffer_lock);
2674 for (; de != NULL; de = parent) {
2675 parent = de->parent;
2678 kmem_cache_free(devfsd_buf_cache, entry);
2680 atomic_sub(ival, &fs_info->devfsd_overrun_count);
2685 } /* End Function devfsd_read */
2687 static int devfsd_ioctl(struct inode *inode, struct file *file,
2688 unsigned int cmd, unsigned long arg)
2691 struct fs_info *fs_info = inode->i_sb->s_fs_info;
2694 case DEVFSDIOC_GET_PROTO_REV:
2695 ival = DEVFSD_PROTOCOL_REVISION_KERNEL;
2696 if (copy_to_user((void *)arg, &ival, sizeof ival))
2699 case DEVFSDIOC_SET_EVENT_MASK:
2700 /* Ensure only one reader has access to the queue. This scheme will
2701 work even if the global kernel lock were to be removed, because it
2702 doesn't matter who gets in first, as long as only one gets it */
2703 if (fs_info->devfsd_task == NULL) {
2704 static spinlock_t lock = SPIN_LOCK_UNLOCKED;
2706 if (!spin_trylock(&lock))
2708 if (fs_info->devfsd_task != NULL) { /* We lost the race... */
2712 fs_info->devfsd_task = current;
2714 fs_info->devfsd_pgrp =
2715 (process_group(current) ==
2716 current->pid) ? process_group(current) : 0;
2717 fs_info->devfsd_file = file;
2718 fs_info->devfsd_info =
2719 kmalloc(sizeof *fs_info->devfsd_info, GFP_KERNEL);
2720 if (!fs_info->devfsd_info) {
2721 devfsd_close(inode, file);
2724 } else if (fs_info->devfsd_task != current)
2726 fs_info->devfsd_event_mask = arg; /* Let the masses come forth */
2728 case DEVFSDIOC_RELEASE_EVENT_QUEUE:
2729 if (fs_info->devfsd_file != file)
2731 return devfsd_close(inode, file);
2733 #ifdef CONFIG_DEVFS_DEBUG
2734 case DEVFSDIOC_SET_DEBUG_MASK:
2735 if (copy_from_user(&ival, (void *)arg, sizeof ival))
2741 return -ENOIOCTLCMD;
2744 } /* End Function devfsd_ioctl */
2746 static int devfsd_close(struct inode *inode, struct file *file)
2748 struct devfsd_buf_entry *entry, *next;
2749 struct fs_info *fs_info = inode->i_sb->s_fs_info;
2751 if (fs_info->devfsd_file != file)
2753 fs_info->devfsd_event_mask = 0;
2754 fs_info->devfsd_file = NULL;
2755 spin_lock(&fs_info->devfsd_buffer_lock);
2756 entry = fs_info->devfsd_first_event;
2757 fs_info->devfsd_first_event = NULL;
2758 fs_info->devfsd_last_event = NULL;
2759 if (fs_info->devfsd_info) {
2760 kfree(fs_info->devfsd_info);
2761 fs_info->devfsd_info = NULL;
2763 spin_unlock(&fs_info->devfsd_buffer_lock);
2764 fs_info->devfsd_pgrp = 0;
2765 fs_info->devfsd_task = NULL;
2766 wake_up(&fs_info->revalidate_wait_queue);
2767 for (; entry; entry = next) {
2769 kmem_cache_free(devfsd_buf_cache, entry);
2772 } /* End Function devfsd_close */
2774 #ifdef CONFIG_DEVFS_DEBUG
2775 static ssize_t stat_read(struct file *file, char *buf, size_t len,
2781 num = sprintf(txt, "Number of entries: %u number of bytes: %u\n",
2782 stat_num_entries, stat_num_bytes) + 1;
2783 /* Can't seek (pread) on this device */
2784 if (ppos != &file->f_pos)
2788 if (*ppos + len > num)
2790 if (copy_to_user(buf, txt + *ppos, len))
2794 } /* End Function stat_read */
2797 static int __init init_devfs_fs(void)
2801 struct devfs_entry *devfsd;
2802 #ifdef CONFIG_DEVFS_DEBUG
2803 struct devfs_entry *stat;
2806 if (_devfs_get_root_entry() == NULL)
2809 printk(KERN_INFO "%s: %s Richard Gooch (rgooch@atnf.csiro.au)\n",
2810 DEVFS_NAME, DEVFS_VERSION);
2811 devfsd_buf_cache = kmem_cache_create("devfsd_event",
2812 sizeof(struct devfsd_buf_entry),
2814 if (!devfsd_buf_cache)
2815 OOPS("(): unable to allocate event slab\n");
2816 #ifdef CONFIG_DEVFS_DEBUG
2817 devfs_debug = devfs_debug_init;
2818 printk(KERN_INFO "%s: devfs_debug: 0x%0x\n", DEVFS_NAME, devfs_debug);
2820 printk(KERN_INFO "%s: boot_options: 0x%0x\n", DEVFS_NAME, boot_options);
2822 /* register special device for devfsd communication */
2823 major = register_chrdev(0, "devfs", &devfs_fops);
2827 /* And create the entry for ".devfsd" */
2828 devfsd = _devfs_alloc_entry(".devfsd", 0, S_IFCHR | S_IRUSR | S_IWUSR);
2831 devfsd->u.dev = MKDEV(major, 0);
2832 _devfs_append_entry(root_entry, devfsd, NULL);
2834 #ifdef CONFIG_DEVFS_DEBUG
2835 stat = _devfs_alloc_entry(".stat", 0, S_IFCHR | S_IRUGO);
2838 stat->u.dev = MKDEV(major, 1);
2839 _devfs_append_entry(root_entry, stat, NULL);
2842 err = register_filesystem(&devfs_fs_type);
2844 } /* End Function init_devfs_fs */
2846 void __init mount_devfs_fs(void)
2850 if (!(boot_options & OPTION_MOUNT))
2852 err = do_mount("none", "/dev", "devfs", 0, NULL);
2854 printk(KERN_INFO "Mounted devfs on /dev\n");
2856 PRINTK("(): unable to mount devfs, err: %d\n", err);
2857 } /* End Function mount_devfs_fs */
2859 module_init(init_devfs_fs)