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>
680 #include <asm/uaccess.h>
682 #include <asm/processor.h>
683 #include <asm/system.h>
684 #include <asm/pgtable.h>
685 #include <asm/bitops.h>
686 #include <asm/atomic.h>
688 #include "internal.h"
690 #define DEVFS_VERSION "1.22 (20021013)"
692 #define DEVFS_NAME "devfs"
694 #define FIRST_INODE 1
696 #define STRING_LENGTH 256
697 #define FAKE_BLOCK_SIZE 1024
698 #define POISON_PTR ( *(void **) poison_array )
699 #define MAGIC_VALUE 0x327db823
706 #define MODE_DIR (S_IFDIR | S_IWUSR | S_IRUGO | S_IXUGO)
708 #define DEBUG_NONE 0x0000000
709 #define DEBUG_MODULE_LOAD 0x0000001
710 #define DEBUG_REGISTER 0x0000002
711 #define DEBUG_UNREGISTER 0x0000004
712 #define DEBUG_FREE 0x0000008
713 #define DEBUG_SET_FLAGS 0x0000010
714 #define DEBUG_S_READ 0x0000100 /* Break */
715 #define DEBUG_I_LOOKUP 0x0001000 /* Break */
716 #define DEBUG_I_CREATE 0x0002000
717 #define DEBUG_I_GET 0x0004000
718 #define DEBUG_I_CHANGE 0x0008000
719 #define DEBUG_I_UNLINK 0x0010000
720 #define DEBUG_I_RLINK 0x0020000
721 #define DEBUG_I_FLINK 0x0040000
722 #define DEBUG_I_MKNOD 0x0080000
723 #define DEBUG_F_READDIR 0x0100000 /* Break */
724 #define DEBUG_D_DELETE 0x1000000 /* Break */
725 #define DEBUG_D_RELEASE 0x2000000
726 #define DEBUG_D_IPUT 0x4000000
727 #define DEBUG_ALL 0xfffffff
728 #define DEBUG_DISABLED DEBUG_NONE
730 #define OPTION_NONE 0x00
731 #define OPTION_MOUNT 0x01
733 #define PRINTK(format, args...) \
734 {printk (KERN_ERR "%s" format, __FUNCTION__ , ## args);}
736 #define OOPS(format, args...) \
737 {printk (KERN_CRIT "%s" format, __FUNCTION__ , ## args); \
738 printk ("Forcing Oops\n"); \
741 #ifdef CONFIG_DEVFS_DEBUG
742 # define VERIFY_ENTRY(de) \
743 {if ((de) && (de)->magic_number != MAGIC_VALUE) \
744 OOPS ("(%p): bad magic value: %x\n", (de), (de)->magic_number);}
745 # define WRITE_ENTRY_MAGIC(de,magic) (de)->magic_number = (magic)
746 # define DPRINTK(flag, format, args...) \
747 {if (devfs_debug & flag) \
748 printk (KERN_INFO "%s" format, __FUNCTION__ , ## args);}
750 # define VERIFY_ENTRY(de)
751 # define WRITE_ENTRY_MAGIC(de,magic)
752 # define DPRINTK(flag, format, args...)
755 typedef struct devfs_entry *devfs_handle_t;
757 struct directory_type
759 rwlock_t lock; /* Lock for searching(R)/updating(W) */
760 struct devfs_entry *first;
761 struct devfs_entry *last;
762 unsigned char no_more_additions:1;
772 struct file_operations *ops;
774 unsigned char autogen:1;
779 unsigned int length; /* Not including the NULL-termimator */
780 char *linkname; /* This is NULL-terminated */
783 struct devfs_inode /* This structure is for "persistent" inode storage */
785 struct dentry *dentry;
786 struct timespec atime;
787 struct timespec mtime;
788 struct timespec ctime;
789 unsigned int ino; /* Inode number as seen in the VFS */
796 #ifdef CONFIG_DEVFS_DEBUG
797 unsigned int magic_number;
800 atomic_t refcount; /* When this drops to zero, it's unused */
803 struct directory_type dir;
804 struct bdev_type bdev;
805 struct cdev_type cdev;
806 struct symlink_type symlink;
807 const char *name; /* Only used for (mode == 0) */
810 struct devfs_entry *prev; /* Previous entry in the parent directory */
811 struct devfs_entry *next; /* Next entry in the parent directory */
812 struct devfs_entry *parent; /* The parent directory */
813 struct devfs_inode inode;
815 unsigned short namelen; /* I think 64k+ filenames are a way off... */
816 unsigned char vfs_deletable:1;/* Whether the VFS may delete the entry */
817 char name[1]; /* This is just a dummy: the allocated array
818 is bigger. This is NULL-terminated */
821 /* The root of the device tree */
822 static struct devfs_entry *root_entry;
824 struct devfsd_buf_entry
826 struct devfs_entry *de; /* The name is generated with this */
827 unsigned short type; /* The type of event */
831 struct devfsd_buf_entry *next;
834 struct fs_info /* This structure is for the mounted devfs */
836 struct super_block *sb;
837 spinlock_t devfsd_buffer_lock; /* Lock when inserting/deleting events */
838 struct devfsd_buf_entry *devfsd_first_event;
839 struct devfsd_buf_entry *devfsd_last_event;
840 volatile int devfsd_sleeping;
841 volatile struct task_struct *devfsd_task;
842 volatile pid_t devfsd_pgrp;
843 volatile struct file *devfsd_file;
844 struct devfsd_notify_struct *devfsd_info;
845 volatile unsigned long devfsd_event_mask;
846 atomic_t devfsd_overrun_count;
847 wait_queue_head_t devfsd_wait_queue; /* Wake devfsd on input */
848 wait_queue_head_t revalidate_wait_queue; /* Wake when devfsd sleeps */
851 static struct fs_info fs_info = {.devfsd_buffer_lock = SPIN_LOCK_UNLOCKED};
852 static kmem_cache_t *devfsd_buf_cache;
853 #ifdef CONFIG_DEVFS_DEBUG
854 static unsigned int devfs_debug_init __initdata = DEBUG_NONE;
855 static unsigned int devfs_debug = DEBUG_NONE;
856 static spinlock_t stat_lock = SPIN_LOCK_UNLOCKED;
857 static unsigned int stat_num_entries;
858 static unsigned int stat_num_bytes;
860 static unsigned char poison_array[8] =
861 {0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a};
863 #ifdef CONFIG_DEVFS_MOUNT
864 static unsigned int boot_options = OPTION_MOUNT;
866 static unsigned int boot_options = OPTION_NONE;
869 /* Forward function declarations */
870 static devfs_handle_t _devfs_walk_path (struct devfs_entry *dir,
871 const char *name, int namelen,
872 int traverse_symlink);
873 static ssize_t devfsd_read (struct file *file, char *buf, size_t len,
875 static int devfsd_ioctl (struct inode *inode, struct file *file,
876 unsigned int cmd, unsigned long arg);
877 static int devfsd_close (struct inode *inode, struct file *file);
878 #ifdef CONFIG_DEVFS_DEBUG
879 static ssize_t stat_read (struct file *file, char *buf, size_t len,
881 static struct file_operations stat_fops =
888 /* Devfs daemon file operations */
889 static struct file_operations devfsd_fops =
892 .ioctl = devfsd_ioctl,
893 .release = devfsd_close,
897 /* Support functions follow */
901 * devfs_get - Get a reference to a devfs entry.
902 * @de: The devfs entry.
905 static struct devfs_entry *devfs_get (struct devfs_entry *de)
908 if (de) atomic_inc (&de->refcount);
910 } /* End Function devfs_get */
913 * devfs_put - Put (release) a reference to a devfs entry.
914 * @de: The handle to the devfs entry.
917 static void devfs_put (devfs_handle_t de)
921 if (de->info == POISON_PTR) OOPS ("(%p): poisoned pointer\n", de);
922 if ( !atomic_dec_and_test (&de->refcount) ) return;
923 if (de == root_entry) OOPS ("(%p): root entry being freed\n", de);
924 DPRINTK (DEBUG_FREE, "(%s): de: %p, parent: %p \"%s\"\n",
925 de->name, de, de->parent,
926 de->parent ? de->parent->name : "no parent");
927 if ( S_ISLNK (de->mode) ) kfree (de->u.symlink.linkname);
928 if ( S_ISCHR (de->mode) && de->u.cdev.autogen )
929 devfs_dealloc_devnum (de->mode, de->u.cdev.dev);
930 WRITE_ENTRY_MAGIC (de, 0);
931 #ifdef CONFIG_DEVFS_DEBUG
932 spin_lock (&stat_lock);
934 stat_num_bytes -= sizeof *de + de->namelen;
935 if ( S_ISLNK (de->mode) ) stat_num_bytes -= de->u.symlink.length + 1;
936 spin_unlock (&stat_lock);
938 de->info = POISON_PTR;
940 } /* End Function devfs_put */
943 * _devfs_search_dir - Search for a devfs entry in a directory.
944 * @dir: The directory to search.
945 * @name: The name of the entry to search for.
946 * @namelen: The number of characters in @name.
948 * Search for a devfs entry in a directory and returns a pointer to the entry
949 * on success, else %NULL. The directory must be locked already.
950 * An implicit devfs_get() is performed on the returned entry.
953 static struct devfs_entry *_devfs_search_dir (struct devfs_entry *dir,
955 unsigned int namelen)
957 struct devfs_entry *curr;
959 if ( !S_ISDIR (dir->mode) )
961 PRINTK ("(%s): not a directory\n", dir->name);
964 for (curr = dir->u.dir.first; curr != NULL; curr = curr->next)
966 if (curr->namelen != namelen) continue;
967 if (memcmp (curr->name, name, namelen) == 0) break;
968 /* Not found: try the next one */
970 return devfs_get (curr);
971 } /* End Function _devfs_search_dir */
975 * _devfs_alloc_entry - Allocate a devfs entry.
976 * @name: the name of the entry
977 * @namelen: the number of characters in @name
978 * @mode: the mode for the entry
980 * Allocate a devfs entry and returns a pointer to the entry on success, else
984 static struct devfs_entry *_devfs_alloc_entry (const char *name,
985 unsigned int namelen,
988 struct devfs_entry *new;
989 static unsigned long inode_counter = FIRST_INODE;
990 static spinlock_t counter_lock = SPIN_LOCK_UNLOCKED;
992 if ( name && (namelen < 1) ) namelen = strlen (name);
993 if ( ( new = kmalloc (sizeof *new + namelen, GFP_KERNEL) ) == NULL )
995 memset (new, 0, sizeof *new + namelen); /* Will set '\0' on name */
997 if ( S_ISDIR (mode) ) rwlock_init (&new->u.dir.lock);
998 atomic_set (&new->refcount, 1);
999 spin_lock (&counter_lock);
1000 new->inode.ino = inode_counter++;
1001 spin_unlock (&counter_lock);
1002 if (name) memcpy (new->name, name, namelen);
1003 new->namelen = namelen;
1004 WRITE_ENTRY_MAGIC (new, MAGIC_VALUE);
1005 #ifdef CONFIG_DEVFS_DEBUG
1006 spin_lock (&stat_lock);
1008 stat_num_bytes += sizeof *new + namelen;
1009 spin_unlock (&stat_lock);
1012 } /* End Function _devfs_alloc_entry */
1016 * _devfs_append_entry - Append a devfs entry to a directory's child list.
1017 * @dir: The directory to add to.
1018 * @de: The devfs entry to append.
1019 * @old_de: If an existing entry exists, it will be written here. This may
1020 * be %NULL. An implicit devfs_get() is performed on this entry.
1022 * Append a devfs entry to a directory's list of children, checking first to
1023 * see if an entry of the same name exists. The directory will be locked.
1024 * The value 0 is returned on success, else a negative error code.
1025 * On failure, an implicit devfs_put() is performed on %de.
1028 static int _devfs_append_entry (devfs_handle_t dir, devfs_handle_t de,
1029 devfs_handle_t *old_de)
1033 if (old_de) *old_de = NULL;
1034 if ( !S_ISDIR (dir->mode) )
1036 PRINTK ("(%s): dir: \"%s\" is not a directory\n", de->name, dir->name);
1040 write_lock (&dir->u.dir.lock);
1041 if (dir->u.dir.no_more_additions) retval = -ENOENT;
1044 struct devfs_entry *old;
1046 old = _devfs_search_dir (dir, de->name, de->namelen);
1047 if (old_de) *old_de = old;
1048 else devfs_put (old);
1052 de->prev = dir->u.dir.last;
1053 /* Append to the directory's list of children */
1054 if (dir->u.dir.first == NULL) dir->u.dir.first = de;
1055 else dir->u.dir.last->next = de;
1056 dir->u.dir.last = de;
1059 else retval = -EEXIST;
1061 write_unlock (&dir->u.dir.lock);
1062 if (retval) devfs_put (de);
1064 } /* End Function _devfs_append_entry */
1068 * _devfs_get_root_entry - Get the root devfs entry.
1070 * Returns the root devfs entry on success, else %NULL.
1073 static struct devfs_entry *_devfs_get_root_entry (void)
1075 struct devfs_entry *new;
1076 static spinlock_t root_lock = SPIN_LOCK_UNLOCKED;
1078 /* Always ensure the root is created */
1079 if (root_entry) return root_entry;
1080 if ( ( new = _devfs_alloc_entry (NULL, 0,MODE_DIR) ) == NULL ) return NULL;
1081 spin_lock (&root_lock);
1084 spin_unlock (&root_lock);
1086 return (root_entry);
1089 spin_unlock (&root_lock);
1090 /* And create the entry for ".devfsd" */
1091 if ( ( new = _devfs_alloc_entry (".devfsd", 0, S_IFCHR |S_IRUSR |S_IWUSR) )
1092 == NULL ) return NULL;
1093 new->u.cdev.dev = devfs_alloc_devnum (S_IFCHR |S_IRUSR |S_IWUSR);
1094 new->u.cdev.ops = &devfsd_fops;
1095 _devfs_append_entry (root_entry, new, NULL);
1096 #ifdef CONFIG_DEVFS_DEBUG
1097 if ( ( new = _devfs_alloc_entry (".stat", 0, S_IFCHR | S_IRUGO | S_IWUGO) )
1098 == NULL ) return NULL;
1099 new->u.cdev.dev = devfs_alloc_devnum (S_IFCHR | S_IRUGO | S_IWUGO);
1100 new->u.cdev.ops = &stat_fops;
1101 _devfs_append_entry (root_entry, new, NULL);
1104 } /* End Function _devfs_get_root_entry */
1108 * _devfs_descend - Descend down a tree using the next component name.
1109 * @dir: The directory to search.
1110 * @name: The component name to search for.
1111 * @namelen: The length of %name.
1112 * @next_pos: The position of the next '/' or '\0' is written here.
1114 * Descend into a directory, searching for a component. This function forms
1115 * the core of a tree-walking algorithm. The directory will be locked.
1116 * The devfs entry corresponding to the component is returned. If there is
1117 * no matching entry, %NULL is returned.
1118 * An implicit devfs_get() is performed on the returned entry.
1121 static struct devfs_entry *_devfs_descend (struct devfs_entry *dir,
1122 const char *name, int namelen,
1125 const char *stop, *ptr;
1126 struct devfs_entry *entry;
1128 if ( (namelen >= 3) && (strncmp (name, "../", 3) == 0) )
1129 { /* Special-case going to parent directory */
1131 return devfs_get (dir->parent);
1133 stop = name + namelen;
1134 /* Search for a possible '/' */
1135 for (ptr = name; (ptr < stop) && (*ptr != '/'); ++ptr);
1136 *next_pos = ptr - name;
1137 read_lock (&dir->u.dir.lock);
1138 entry = _devfs_search_dir (dir, name, *next_pos);
1139 read_unlock (&dir->u.dir.lock);
1141 } /* End Function _devfs_descend */
1144 static devfs_handle_t _devfs_make_parent_for_leaf (struct devfs_entry *dir,
1146 int namelen, int *leaf_pos)
1150 if (dir == NULL) dir = _devfs_get_root_entry ();
1151 if (dir == NULL) return NULL;
1153 /* Search for possible trailing component and ignore it */
1154 for (--namelen; (namelen > 0) && (name[namelen] != '/'); --namelen);
1155 *leaf_pos = (name[namelen] == '/') ? (namelen + 1) : 0;
1156 for (; namelen > 0; name += next_pos, namelen -= next_pos)
1158 struct devfs_entry *de, *old = NULL;
1160 if ( ( de = _devfs_descend (dir, name, namelen, &next_pos) ) == NULL )
1162 de = _devfs_alloc_entry (name, next_pos, MODE_DIR);
1164 if ( !de || _devfs_append_entry (dir, de, &old) )
1167 if ( !old || !S_ISDIR (old->mode) )
1173 de = old; /* Use the existing directory */
1176 if (de == dir->parent)
1184 if (name[next_pos] == '/') ++next_pos;
1187 } /* End Function _devfs_make_parent_for_leaf */
1190 static devfs_handle_t _devfs_prepare_leaf (devfs_handle_t *dir,
1191 const char *name, umode_t mode)
1193 int namelen, leaf_pos;
1194 struct devfs_entry *de;
1196 namelen = strlen (name);
1197 if ( ( *dir = _devfs_make_parent_for_leaf (*dir, name, namelen,
1198 &leaf_pos) ) == NULL )
1200 PRINTK ("(%s): could not create parent path\n", name);
1203 if ( ( de = _devfs_alloc_entry (name + leaf_pos, namelen - leaf_pos,mode) )
1206 PRINTK ("(%s): could not allocate entry\n", name);
1211 } /* End Function _devfs_prepare_leaf */
1214 static devfs_handle_t _devfs_walk_path (struct devfs_entry *dir,
1215 const char *name, int namelen,
1216 int traverse_symlink)
1220 if (dir == NULL) dir = _devfs_get_root_entry ();
1221 if (dir == NULL) return NULL;
1223 for (; namelen > 0; name += next_pos, namelen -= next_pos)
1225 struct devfs_entry *de, *link;
1227 if (!S_ISDIR (dir->mode))
1233 if ( ( de = _devfs_descend (dir, name, namelen, &next_pos) ) == NULL )
1238 if (S_ISLNK (de->mode) && traverse_symlink)
1239 { /* Need to follow the link: this is a stack chomper */
1240 link = _devfs_walk_path (dir, de->u.symlink.linkname,
1241 de->u.symlink.length, TRUE);
1252 if (name[next_pos] == '/') ++next_pos;
1255 } /* End Function _devfs_walk_path */
1258 * _devfs_find_entry - Find a devfs entry.
1259 * @dir: The handle to the parent devfs directory entry. If this is %NULL the
1260 * name is relative to the root of the devfs.
1261 * @name: The name of the entry. This may be %NULL.
1262 * @traverse_symlink: If %TRUE then symbolic links are traversed.
1264 * Returns the devfs_entry pointer on success, else %NULL. An implicit
1265 * devfs_get() is performed.
1268 static struct devfs_entry *_devfs_find_entry (devfs_handle_t dir,
1270 int traverse_symlink)
1272 unsigned int namelen = strlen (name);
1276 /* Skip leading pathname component */
1279 PRINTK ("(%s): too short\n", name);
1282 for (++name, --namelen; (*name != '/') && (namelen > 0);
1286 PRINTK ("(%s): too short\n", name);
1292 return _devfs_walk_path (dir, name, namelen, traverse_symlink);
1293 } /* End Function _devfs_find_entry */
1295 static struct devfs_entry *get_devfs_entry_from_vfs_inode (struct inode *inode)
1297 if (inode == NULL) return NULL;
1298 VERIFY_ENTRY ( (struct devfs_entry *) inode->u.generic_ip );
1299 return inode->u.generic_ip;
1300 } /* End Function get_devfs_entry_from_vfs_inode */
1304 * free_dentry - Free the dentry for a device entry and invalidate inode.
1307 * This must only be called after the entry has been unhooked from its
1311 static void free_dentry (struct devfs_entry *de)
1313 struct dentry *dentry = de->inode.dentry;
1315 if (!dentry) return;
1316 spin_lock (&dcache_lock);
1317 dget_locked (dentry);
1318 spin_unlock (&dcache_lock);
1319 /* Forcefully remove the inode */
1320 if (dentry->d_inode != NULL) dentry->d_inode->i_nlink = 0;
1323 } /* End Function free_dentry */
1327 * is_devfsd_or_child - Test if the current process is devfsd or one of its children.
1328 * @fs_info: The filesystem information.
1330 * Returns %TRUE if devfsd or child, else %FALSE.
1333 static int is_devfsd_or_child (struct fs_info *fs_info)
1335 struct task_struct *p = current;
1337 if (p == fs_info->devfsd_task) return (TRUE);
1338 if (process_group(p) == fs_info->devfsd_pgrp) return (TRUE);
1339 read_lock(&tasklist_lock);
1340 for ( ; p != &init_task; p = p->real_parent)
1342 if (p == fs_info->devfsd_task)
1344 read_unlock (&tasklist_lock);
1348 read_unlock (&tasklist_lock);
1350 } /* End Function is_devfsd_or_child */
1354 * devfsd_queue_empty - Test if devfsd has work pending in its event queue.
1355 * @fs_info: The filesystem information.
1357 * Returns %TRUE if the queue is empty, else %FALSE.
1360 static inline int devfsd_queue_empty (struct fs_info *fs_info)
1362 return (fs_info->devfsd_last_event) ? FALSE : TRUE;
1363 } /* End Function devfsd_queue_empty */
1367 * wait_for_devfsd_finished - Wait for devfsd to finish processing its event queue.
1368 * @fs_info: The filesystem information.
1370 * Returns %TRUE if no more waiting will be required, else %FALSE.
1373 static int wait_for_devfsd_finished (struct fs_info *fs_info)
1375 DECLARE_WAITQUEUE (wait, current);
1377 if (fs_info->devfsd_task == NULL) return (TRUE);
1378 if (devfsd_queue_empty (fs_info) && fs_info->devfsd_sleeping) return TRUE;
1379 if ( is_devfsd_or_child (fs_info) ) return (FALSE);
1380 set_current_state (TASK_UNINTERRUPTIBLE);
1381 add_wait_queue (&fs_info->revalidate_wait_queue, &wait);
1382 if (!devfsd_queue_empty (fs_info) || !fs_info->devfsd_sleeping)
1383 if (fs_info->devfsd_task) schedule ();
1384 remove_wait_queue (&fs_info->revalidate_wait_queue, &wait);
1385 __set_current_state (TASK_RUNNING);
1387 } /* End Function wait_for_devfsd_finished */
1391 * devfsd_notify_de - Notify the devfsd daemon of a change.
1392 * @de: The devfs entry that has changed. This and all parent entries will
1393 * have their reference counts incremented if the event was queued.
1394 * @type: The type of change.
1395 * @mode: The mode of the entry.
1396 * @uid: The user ID.
1397 * @gid: The group ID.
1398 * @fs_info: The filesystem info.
1400 * Returns %TRUE if an event was queued and devfsd woken up, else %FALSE.
1403 static int devfsd_notify_de (struct devfs_entry *de,
1404 unsigned short type, umode_t mode,
1405 uid_t uid, gid_t gid, struct fs_info *fs_info)
1407 struct devfsd_buf_entry *entry;
1408 struct devfs_entry *curr;
1410 if ( !( fs_info->devfsd_event_mask & (1 << type) ) ) return (FALSE);
1411 if ( ( entry = kmem_cache_alloc (devfsd_buf_cache, SLAB_KERNEL) ) == NULL )
1413 atomic_inc (&fs_info->devfsd_overrun_count);
1416 for (curr = de; curr != NULL; curr = curr->parent) devfs_get (curr);
1423 spin_lock (&fs_info->devfsd_buffer_lock);
1424 if (!fs_info->devfsd_first_event) fs_info->devfsd_first_event = entry;
1425 if (fs_info->devfsd_last_event) fs_info->devfsd_last_event->next = entry;
1426 fs_info->devfsd_last_event = entry;
1427 spin_unlock (&fs_info->devfsd_buffer_lock);
1428 wake_up_interruptible (&fs_info->devfsd_wait_queue);
1430 } /* End Function devfsd_notify_de */
1434 * devfsd_notify - Notify the devfsd daemon of a change.
1435 * @de: The devfs entry that has changed.
1436 * @type: The type of change event.
1437 * @wait: If TRUE, the function waits for the daemon to finish processing
1441 static void devfsd_notify (struct devfs_entry *de,unsigned short type)
1443 devfsd_notify_de(de, type, de->mode, current->euid,
1444 current->egid, &fs_info);
1447 int devfs_mk_bdev(dev_t dev, umode_t mode, const char *fmt, ...)
1449 struct devfs_entry *dir = NULL, *de;
1454 va_start(args, fmt);
1455 n = vsnprintf(buf, 64, fmt, args);
1456 if (n >= 64 || !buf[0]) {
1457 printk(KERN_WARNING "%s: invalid format string\n",
1462 if (!S_ISBLK(mode)) {
1463 printk(KERN_WARNING "%s: invalide mode (%u) for %s\n",
1464 __FUNCTION__, mode, buf);
1468 de = _devfs_prepare_leaf(&dir, buf, mode);
1470 printk(KERN_WARNING "%s: could not prepare leaf for %s\n",
1472 return -ENOMEM; /* could be more accurate... */
1475 de->u.bdev.dev = dev;
1477 error = _devfs_append_entry(dir, de, NULL);
1479 printk(KERN_WARNING "%s: could not append to parent for %s\n",
1484 devfsd_notify(de, DEVFSD_NOTIFY_REGISTERED);
1490 EXPORT_SYMBOL(devfs_mk_bdev);
1493 int devfs_mk_cdev(dev_t dev, umode_t mode, const char *fmt, ...)
1495 struct devfs_entry *dir = NULL, *de;
1500 va_start(args, fmt);
1501 n = vsnprintf(buf, 64, fmt, args);
1502 if (n >= 64 || !buf[0]) {
1503 printk(KERN_WARNING "%s: invalid format string\n",
1508 if (!S_ISCHR(mode)) {
1509 printk(KERN_WARNING "%s: invalide mode (%u) for %s\n",
1510 __FUNCTION__, mode, buf);
1514 de = _devfs_prepare_leaf(&dir, buf, mode);
1516 printk(KERN_WARNING "%s: could not prepare leaf for %s\n",
1518 return -ENOMEM; /* could be more accurate... */
1521 de->u.cdev.dev = dev;
1523 error = _devfs_append_entry(dir, de, NULL);
1525 printk(KERN_WARNING "%s: could not append to parent for %s\n",
1530 devfsd_notify(de, DEVFSD_NOTIFY_REGISTERED);
1536 EXPORT_SYMBOL(devfs_mk_cdev);
1540 * _devfs_unhook - Unhook a device entry from its parents list
1541 * @de: The entry to unhook.
1543 * Returns %TRUE if the entry was unhooked, else %FALSE if it was
1544 * previously unhooked.
1545 * The caller must have a write lock on the parent directory.
1548 static int _devfs_unhook (struct devfs_entry *de)
1550 struct devfs_entry *parent;
1552 if ( !de || (de->prev == de) ) return FALSE;
1553 parent = de->parent;
1554 if (de->prev == NULL) parent->u.dir.first = de->next;
1555 else de->prev->next = de->next;
1556 if (de->next == NULL) parent->u.dir.last = de->prev;
1557 else de->next->prev = de->prev;
1558 de->prev = de; /* Indicate we're unhooked */
1559 de->next = NULL; /* Force early termination for <devfs_readdir> */
1561 } /* End Function _devfs_unhook */
1565 * _devfs_unregister - Unregister a device entry from its parent.
1566 * @dir: The parent directory.
1567 * @de: The entry to unregister.
1569 * The caller must have a write lock on the parent directory, which is
1570 * unlocked by this function.
1573 static void _devfs_unregister (struct devfs_entry *dir, struct devfs_entry *de)
1575 int unhooked = _devfs_unhook (de);
1577 write_unlock (&dir->u.dir.lock);
1578 if (!unhooked) return;
1580 devfsd_notify (de, DEVFSD_NOTIFY_UNREGISTERED);
1583 if ( !S_ISDIR (de->mode) ) return;
1584 while (TRUE) /* Recursively unregister: this is a stack chomper */
1586 struct devfs_entry *child;
1588 write_lock (&de->u.dir.lock);
1589 de->u.dir.no_more_additions = TRUE;
1590 child = de->u.dir.first;
1591 VERIFY_ENTRY (child);
1592 _devfs_unregister (de, child);
1594 DPRINTK (DEBUG_UNREGISTER, "(%s): child: %p refcount: %d\n",
1595 child->name, child, atomic_read (&child->refcount) );
1598 } /* End Function _devfs_unregister */
1600 static int devfs_do_symlink (devfs_handle_t dir, const char *name,
1601 const char *link, devfs_handle_t *handle)
1604 unsigned int linklength;
1606 struct devfs_entry *de;
1608 if (handle != NULL) *handle = NULL;
1611 PRINTK ("(): NULL name pointer\n");
1616 PRINTK ("(%s): NULL link pointer\n", name);
1619 linklength = strlen (link);
1620 if ( ( newlink = kmalloc (linklength + 1, GFP_KERNEL) ) == NULL )
1622 memcpy (newlink, link, linklength);
1623 newlink[linklength] = '\0';
1624 if ( ( de = _devfs_prepare_leaf (&dir, name, S_IFLNK | S_IRUGO | S_IXUGO) )
1627 PRINTK ("(%s): could not prepare leaf\n", name);
1632 de->u.symlink.linkname = newlink;
1633 de->u.symlink.length = linklength;
1634 if ( ( err = _devfs_append_entry (dir, de, NULL) ) != 0 )
1636 PRINTK ("(%s): could not append to parent, err: %d\n", name, err);
1641 #ifdef CONFIG_DEVFS_DEBUG
1642 spin_lock (&stat_lock);
1643 stat_num_bytes += linklength + 1;
1644 spin_unlock (&stat_lock);
1646 if (handle != NULL) *handle = de;
1648 } /* End Function devfs_do_symlink */
1652 * devfs_mk_symlink Create a symbolic link in the devfs namespace.
1653 * @from: The name of the entry.
1654 * @to: Name of the destination
1656 * Returns 0 on success, else a negative error code is returned.
1659 int devfs_mk_symlink(const char *from, const char *to)
1664 err = devfs_do_symlink(NULL, from, to, &de);
1666 de->vfs_deletable = TRUE;
1667 devfsd_notify(de, DEVFSD_NOTIFY_REGISTERED);
1675 * devfs_mk_dir - Create a directory in the devfs namespace.
1676 * new name is relative to the root of the devfs.
1677 * @fmt: The name of the entry.
1679 * Use of this function is optional. The devfs_register() function
1680 * will automatically create intermediate directories as needed. This function
1681 * is provided for efficiency reasons, as it provides a handle to a directory.
1682 * On failure %NULL is returned.
1685 int devfs_mk_dir(const char *fmt, ...)
1687 struct devfs_entry *dir = NULL, *de = NULL, *old;
1692 va_start(args, fmt);
1693 n = vsnprintf(buf, 64, fmt, args);
1694 if (n >= 64 || !buf[0]) {
1695 printk(KERN_WARNING "%s: invalid argument.", __FUNCTION__);
1699 de = _devfs_prepare_leaf(&dir, buf, MODE_DIR);
1701 PRINTK("(%s): could not prepare leaf\n", buf);
1705 error = _devfs_append_entry(dir, de, &old);
1706 if (error == -EEXIST && S_ISDIR(old->mode)) {
1708 * devfs_mk_dir() of an already-existing directory will
1714 PRINTK("(%s): could not append to dir: %p \"%s\"\n",
1715 buf, dir, dir->name);
1720 devfsd_notify(de, DEVFSD_NOTIFY_REGISTERED);
1728 void devfs_remove(const char *fmt, ...)
1734 va_start(args, fmt);
1735 n = vsnprintf(buf, 64, fmt, args);
1736 if (n < 64 && buf[0]) {
1737 devfs_handle_t de = _devfs_find_entry(NULL, buf, 0);
1740 printk(KERN_ERR "%s: %s not found, cannot remove\n",
1746 write_lock(&de->parent->u.dir.lock);
1747 _devfs_unregister(de->parent, de);
1755 * devfs_generate_path - Generate a pathname for an entry, relative to the devfs root.
1756 * @de: The devfs entry.
1757 * @path: The buffer to write the pathname to. The pathname and '\0'
1758 * terminator will be written at the end of the buffer.
1759 * @buflen: The length of the buffer.
1761 * Returns the offset in the buffer where the pathname starts on success,
1762 * else a negative error code.
1765 static int devfs_generate_path (devfs_handle_t de, char *path, int buflen)
1768 #define NAMEOF(de) ( (de)->mode ? (de)->name : (de)->u.name )
1770 if (de == NULL) return -EINVAL;
1772 if (de->namelen >= buflen) return -ENAMETOOLONG; /* Must be first */
1773 path[buflen - 1] = '\0';
1774 if (de->parent == NULL) return buflen - 1; /* Don't prepend root */
1775 pos = buflen - de->namelen - 1;
1776 memcpy (path + pos, NAMEOF (de), de->namelen);
1777 for (de = de->parent; de->parent != NULL; de = de->parent)
1779 if (pos - de->namelen - 1 < 0) return -ENAMETOOLONG;
1782 memcpy (path + pos, NAMEOF (de), de->namelen);
1785 } /* End Function devfs_generate_path */
1789 * devfs_get_ops - Get the device operations for a devfs entry.
1790 * @de: The handle to the device entry.
1792 * Returns a pointer to the device operations on success, else NULL.
1793 * The use count for the module owning the operations will be incremented.
1796 static struct file_operations *devfs_get_ops (devfs_handle_t de)
1798 struct file_operations *ops = de->u.cdev.ops;
1799 struct module *owner;
1804 read_lock (&de->parent->u.dir.lock); /* Prevent module from unloading */
1805 if ( (de->next == de) || !try_module_get (owner) )
1806 { /* Entry is already unhooked or module is unloading */
1807 read_unlock (&de->parent->u.dir.lock);
1810 read_unlock (&de->parent->u.dir.lock); /* Module can continue unloading*/
1812 } /* End Function devfs_get_ops */
1815 * devfs_setup - Process kernel boot options.
1816 * @str: The boot options after the "devfs=".
1819 static int __init devfs_setup (char *str)
1826 } devfs_options_tab[] __initdata =
1828 #ifdef CONFIG_DEVFS_DEBUG
1829 {"dall", DEBUG_ALL, &devfs_debug_init},
1830 {"dmod", DEBUG_MODULE_LOAD, &devfs_debug_init},
1831 {"dreg", DEBUG_REGISTER, &devfs_debug_init},
1832 {"dunreg", DEBUG_UNREGISTER, &devfs_debug_init},
1833 {"dfree", DEBUG_FREE, &devfs_debug_init},
1834 {"diget", DEBUG_I_GET, &devfs_debug_init},
1835 {"dchange", DEBUG_SET_FLAGS, &devfs_debug_init},
1836 {"dsread", DEBUG_S_READ, &devfs_debug_init},
1837 {"dichange", DEBUG_I_CHANGE, &devfs_debug_init},
1838 {"dimknod", DEBUG_I_MKNOD, &devfs_debug_init},
1839 {"dilookup", DEBUG_I_LOOKUP, &devfs_debug_init},
1840 {"diunlink", DEBUG_I_UNLINK, &devfs_debug_init},
1841 #endif /* CONFIG_DEVFS_DEBUG */
1842 {"mount", OPTION_MOUNT, &boot_options},
1846 while ( (*str != '\0') && !isspace (*str) )
1848 int i, found = 0, invert = 0;
1850 if (strncmp (str, "no", 2) == 0)
1855 for (i = 0; devfs_options_tab[i].name != NULL; i++)
1857 int len = strlen (devfs_options_tab[i].name);
1859 if (strncmp (str, devfs_options_tab[i].name, len) == 0)
1862 *devfs_options_tab[i].opt &= ~devfs_options_tab[i].mask;
1864 *devfs_options_tab[i].opt |= devfs_options_tab[i].mask;
1870 if (!found) return 0; /* No match */
1871 if (*str != ',') return 0; /* No more options */
1875 } /* End Function devfs_setup */
1877 __setup("devfs=", devfs_setup);
1879 EXPORT_SYMBOL(devfs_put);
1880 EXPORT_SYMBOL(devfs_mk_symlink);
1881 EXPORT_SYMBOL(devfs_mk_dir);
1882 EXPORT_SYMBOL(devfs_remove);
1886 * try_modload - Notify devfsd of an inode lookup by a non-devfsd process.
1887 * @parent: The parent devfs entry.
1888 * @fs_info: The filesystem info.
1889 * @name: The device name.
1890 * @namelen: The number of characters in @name.
1891 * @buf: A working area that will be used. This must not go out of scope
1892 * until devfsd is idle again.
1894 * Returns 0 on success (event was queued), else a negative error code.
1897 static int try_modload (struct devfs_entry *parent, struct fs_info *fs_info,
1898 const char *name, unsigned namelen,
1899 struct devfs_entry *buf)
1901 if ( !( fs_info->devfsd_event_mask & (1 << DEVFSD_NOTIFY_LOOKUP) ) )
1903 if ( is_devfsd_or_child (fs_info) ) return -ENOENT;
1904 memset (buf, 0, sizeof *buf);
1905 atomic_set (&buf->refcount, 1);
1906 buf->parent = parent;
1907 buf->namelen = namelen;
1909 WRITE_ENTRY_MAGIC (buf, MAGIC_VALUE);
1910 if ( !devfsd_notify_de (buf, DEVFSD_NOTIFY_LOOKUP, 0,
1911 current->euid, current->egid, fs_info) )
1913 /* Possible success: event has been queued */
1915 } /* End Function try_modload */
1918 /* Superblock operations follow */
1920 static struct inode_operations devfs_iops;
1921 static struct inode_operations devfs_dir_iops;
1922 static struct file_operations devfs_fops;
1923 static struct file_operations devfs_dir_fops;
1924 static struct inode_operations devfs_symlink_iops;
1926 static int devfs_notify_change (struct dentry *dentry, struct iattr *iattr)
1929 struct devfs_entry *de;
1930 struct inode *inode = dentry->d_inode;
1931 struct fs_info *fs_info = inode->i_sb->s_fs_info;
1933 de = get_devfs_entry_from_vfs_inode (inode);
1934 if (de == NULL) return -ENODEV;
1935 retval = inode_change_ok (inode, iattr);
1936 if (retval != 0) return retval;
1937 retval = inode_setattr (inode, iattr);
1938 if (retval != 0) return retval;
1939 DPRINTK (DEBUG_I_CHANGE, "(%d): VFS inode: %p devfs_entry: %p\n",
1940 (int) inode->i_ino, inode, de);
1941 DPRINTK (DEBUG_I_CHANGE, "(): mode: 0%o uid: %d gid: %d\n",
1942 (int) inode->i_mode, (int) inode->i_uid, (int) inode->i_gid);
1943 /* Inode is not on hash chains, thus must save permissions here rather
1944 than in a write_inode() method */
1945 de->mode = inode->i_mode;
1946 de->inode.uid = inode->i_uid;
1947 de->inode.gid = inode->i_gid;
1948 de->inode.atime = inode->i_atime;
1949 de->inode.mtime = inode->i_mtime;
1950 de->inode.ctime = inode->i_ctime;
1951 if ( ( iattr->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID) ) &&
1952 !is_devfsd_or_child (fs_info) )
1953 devfsd_notify_de (de, DEVFSD_NOTIFY_CHANGE, inode->i_mode,
1954 inode->i_uid, inode->i_gid, fs_info);
1956 } /* End Function devfs_notify_change */
1958 static struct super_operations devfs_sops =
1960 .drop_inode = generic_delete_inode,
1961 .statfs = simple_statfs,
1966 * _devfs_get_vfs_inode - Get a VFS inode.
1967 * @sb: The super block.
1968 * @de: The devfs inode.
1969 * @dentry: The dentry to register with the devfs inode.
1971 * Returns the inode on success, else %NULL. An implicit devfs_get() is
1972 * performed if the inode is created.
1975 static struct inode *_devfs_get_vfs_inode (struct super_block *sb,
1976 struct devfs_entry *de,
1977 struct dentry *dentry)
1979 struct inode *inode;
1981 if (de->prev == de) return NULL; /* Quick check to see if unhooked */
1982 if ( ( inode = new_inode (sb) ) == NULL )
1984 PRINTK ("(%s): new_inode() failed, de: %p\n", de->name, de);
1989 read_lock (&de->parent->u.dir.lock);
1990 if (de->prev != de) de->inode.dentry = dentry; /* Not unhooked */
1991 read_unlock (&de->parent->u.dir.lock);
1993 else de->inode.dentry = dentry; /* Root: no locking needed */
1994 if (de->inode.dentry != dentry)
1995 { /* Must have been unhooked */
1999 inode->u.generic_ip = devfs_get (de);
2000 inode->i_ino = de->inode.ino;
2001 DPRINTK (DEBUG_I_GET, "(%d): VFS inode: %p devfs_entry: %p\n",
2002 (int) inode->i_ino, inode, de);
2003 inode->i_blocks = 0;
2004 inode->i_blksize = FAKE_BLOCK_SIZE;
2005 inode->i_op = &devfs_iops;
2006 inode->i_fop = &devfs_fops;
2007 if ( S_ISCHR (de->mode) )
2009 inode->i_rdev = de->u.cdev.dev;
2011 else if ( S_ISBLK (de->mode) )
2012 init_special_inode(inode, de->mode, de->u.bdev.dev);
2013 else if ( S_ISFIFO (de->mode) )
2014 inode->i_fop = &def_fifo_fops;
2015 else if ( S_ISDIR (de->mode) )
2017 inode->i_op = &devfs_dir_iops;
2018 inode->i_fop = &devfs_dir_fops;
2020 else if ( S_ISLNK (de->mode) )
2022 inode->i_op = &devfs_symlink_iops;
2023 inode->i_size = de->u.symlink.length;
2025 inode->i_mode = de->mode;
2026 inode->i_uid = de->inode.uid;
2027 inode->i_gid = de->inode.gid;
2028 inode->i_atime = de->inode.atime;
2029 inode->i_mtime = de->inode.mtime;
2030 inode->i_ctime = de->inode.ctime;
2031 DPRINTK (DEBUG_I_GET, "(): mode: 0%o uid: %d gid: %d\n",
2032 (int) inode->i_mode, (int) inode->i_uid, (int) inode->i_gid);
2034 } /* End Function _devfs_get_vfs_inode */
2037 /* File operations for device entries follow */
2039 static int devfs_readdir (struct file *file, void *dirent, filldir_t filldir)
2043 struct fs_info *fs_info;
2044 struct devfs_entry *parent, *de, *next = NULL;
2045 struct inode *inode = file->f_dentry->d_inode;
2047 fs_info = inode->i_sb->s_fs_info;
2048 parent = get_devfs_entry_from_vfs_inode (file->f_dentry->d_inode);
2049 if ( (long) file->f_pos < 0 ) return -EINVAL;
2050 DPRINTK (DEBUG_F_READDIR, "(%s): fs_info: %p pos: %ld\n",
2051 parent->name, fs_info, (long) file->f_pos);
2052 switch ( (long) file->f_pos )
2055 err = (*filldir) (dirent, "..", 2, file->f_pos,
2056 parent_ino (file->f_dentry), DT_DIR);
2057 if (err == -EINVAL) break;
2058 if (err < 0) return err;
2063 err = (*filldir) (dirent, ".", 1, file->f_pos, inode->i_ino, DT_DIR);
2064 if (err == -EINVAL) break;
2065 if (err < 0) return err;
2071 count = file->f_pos - 2;
2072 read_lock (&parent->u.dir.lock);
2073 for (de = parent->u.dir.first; de && (count > 0); de = de->next)
2076 read_unlock (&parent->u.dir.lock);
2077 /* Now add all remaining entries */
2080 err = (*filldir) (dirent, de->name, de->namelen,
2081 file->f_pos, de->inode.ino, de->mode >> 12);
2082 if (err < 0) devfs_put (de);
2088 if (err == -EINVAL) break;
2089 if (err < 0) return err;
2090 read_lock (&parent->u.dir.lock);
2091 next = devfs_get (de->next);
2092 read_unlock (&parent->u.dir.lock);
2099 } /* End Function devfs_readdir */
2101 static int devfs_open (struct inode *inode, struct file *file)
2104 struct devfs_entry *de;
2105 struct file_operations *ops;
2107 de = get_devfs_entry_from_vfs_inode (inode);
2108 if (de == NULL) return -ENODEV;
2109 if ( S_ISDIR (de->mode) ) return 0;
2110 file->private_data = de->info;
2111 if (S_ISCHR(inode->i_mode)) {
2112 ops = devfs_get_ops (de); /* Now have module refcount */
2117 err = file->f_op->open ? (*file->f_op->open) (inode, file) : 0;
2121 err = chrdev_open (inode, file);
2124 } /* End Function devfs_open */
2126 static struct file_operations devfs_fops =
2131 static struct file_operations devfs_dir_fops =
2133 .read = generic_read_dir,
2134 .readdir = devfs_readdir,
2139 /* Dentry operations for device entries follow */
2143 * devfs_d_release - Callback for when a dentry is freed.
2144 * @dentry: The dentry.
2147 static void devfs_d_release (struct dentry *dentry)
2149 DPRINTK (DEBUG_D_RELEASE, "(%p): inode: %p\n", dentry, dentry->d_inode);
2150 } /* End Function devfs_d_release */
2153 * devfs_d_iput - Callback for when a dentry loses its inode.
2154 * @dentry: The dentry.
2155 * @inode: The inode.
2158 static void devfs_d_iput (struct dentry *dentry, struct inode *inode)
2160 struct devfs_entry *de;
2162 de = get_devfs_entry_from_vfs_inode (inode);
2163 DPRINTK (DEBUG_D_IPUT,"(%s): dentry: %p inode: %p de: %p de->dentry: %p\n",
2164 de->name, dentry, inode, de, de->inode.dentry);
2165 if ( de->inode.dentry && (de->inode.dentry != dentry) )
2166 OOPS ("(%s): de: %p dentry: %p de->dentry: %p\n",
2167 de->name, de, dentry, de->inode.dentry);
2168 de->inode.dentry = NULL;
2171 } /* End Function devfs_d_iput */
2173 static int devfs_d_delete (struct dentry *dentry);
2175 static struct dentry_operations devfs_dops =
2177 .d_delete = devfs_d_delete,
2178 .d_release = devfs_d_release,
2179 .d_iput = devfs_d_iput,
2182 static int devfs_d_revalidate_wait (struct dentry *dentry, struct nameidata *);
2184 static struct dentry_operations devfs_wait_dops =
2186 .d_delete = devfs_d_delete,
2187 .d_release = devfs_d_release,
2188 .d_iput = devfs_d_iput,
2189 .d_revalidate = devfs_d_revalidate_wait,
2193 * devfs_d_delete - Callback for when all files for a dentry are closed.
2194 * @dentry: The dentry.
2197 static int devfs_d_delete (struct dentry *dentry)
2199 struct inode *inode = dentry->d_inode;
2201 if (dentry->d_op == &devfs_wait_dops) dentry->d_op = &devfs_dops;
2202 /* Unhash dentry if negative (has no inode) */
2205 DPRINTK (DEBUG_D_DELETE, "(%p): dropping negative dentry\n", dentry);
2209 } /* End Function devfs_d_delete */
2211 struct devfs_lookup_struct
2214 wait_queue_head_t wait_queue;
2217 /* XXX: this doesn't handle the case where we got a negative dentry
2218 but a devfs entry has been registered in the meanwhile */
2219 static int devfs_d_revalidate_wait (struct dentry *dentry, struct nameidata *nd)
2221 struct inode *dir = dentry->d_parent->d_inode;
2222 struct fs_info *fs_info = dir->i_sb->s_fs_info;
2223 devfs_handle_t parent = get_devfs_entry_from_vfs_inode (dir);
2224 struct devfs_lookup_struct *lookup_info = dentry->d_fsdata;
2225 DECLARE_WAITQUEUE (wait, current);
2227 if ( is_devfsd_or_child (fs_info) )
2229 devfs_handle_t de = lookup_info->de;
2230 struct inode *inode;
2232 DPRINTK (DEBUG_I_LOOKUP,
2233 "(%s): dentry: %p inode: %p de: %p by: \"%s\"\n",
2234 dentry->d_name.name, dentry, dentry->d_inode, de,
2236 if (dentry->d_inode) return 1;
2239 read_lock (&parent->u.dir.lock);
2240 de = _devfs_search_dir (parent, dentry->d_name.name,
2241 dentry->d_name.len);
2242 read_unlock (&parent->u.dir.lock);
2243 if (de == NULL) return 1;
2244 lookup_info->de = de;
2246 /* Create an inode, now that the driver information is available */
2247 inode = _devfs_get_vfs_inode (dir->i_sb, de, dentry);
2248 if (!inode) return 1;
2249 DPRINTK (DEBUG_I_LOOKUP,
2250 "(%s): new VFS inode(%u): %p de: %p by: \"%s\"\n",
2251 de->name, de->inode.ino, inode, de, current->comm);
2252 d_instantiate (dentry, inode);
2255 if (lookup_info == NULL) return 1; /* Early termination */
2256 read_lock (&parent->u.dir.lock);
2257 if (dentry->d_fsdata)
2259 set_current_state (TASK_UNINTERRUPTIBLE);
2260 add_wait_queue (&lookup_info->wait_queue, &wait);
2261 read_unlock (&parent->u.dir.lock);
2264 * This does not need nor should remove wait from wait_queue.
2265 * Wait queue head is never reused - nothing is ever added to it
2266 * after all waiters have been waked up and head itself disappears
2267 * very soon after it. Moreover it is local variable on stack that
2268 * is likely to have already disappeared so any reference to it
2269 * at this point is buggy.
2273 else read_unlock (&parent->u.dir.lock);
2275 } /* End Function devfs_d_revalidate_wait */
2278 /* Inode operations for device entries follow */
2280 static struct dentry *devfs_lookup (struct inode *dir, struct dentry *dentry, struct nameidata *nd)
2282 struct devfs_entry tmp; /* Must stay in scope until devfsd idle again */
2283 struct devfs_lookup_struct lookup_info;
2284 struct fs_info *fs_info = dir->i_sb->s_fs_info;
2285 struct devfs_entry *parent, *de;
2286 struct inode *inode;
2287 struct dentry *retval = NULL;
2289 /* Set up the dentry operations before anything else, to ensure cleaning
2291 dentry->d_op = &devfs_dops;
2292 /* First try to get the devfs entry for this directory */
2293 parent = get_devfs_entry_from_vfs_inode (dir);
2294 DPRINTK (DEBUG_I_LOOKUP, "(%s): dentry: %p parent: %p by: \"%s\"\n",
2295 dentry->d_name.name, dentry, parent, current->comm);
2296 if (parent == NULL) return ERR_PTR (-ENOENT);
2297 read_lock (&parent->u.dir.lock);
2298 de = _devfs_search_dir (parent, dentry->d_name.name, dentry->d_name.len);
2299 read_unlock (&parent->u.dir.lock);
2300 lookup_info.de = de;
2301 init_waitqueue_head (&lookup_info.wait_queue);
2302 dentry->d_fsdata = &lookup_info;
2304 { /* Try with devfsd. For any kind of failure, leave a negative dentry
2305 so someone else can deal with it (in the case where the sysadmin
2306 does a mknod()). It's important to do this before hashing the
2307 dentry, so that the devfsd queue is filled before revalidates
2309 if (try_modload (parent, fs_info,
2310 dentry->d_name.name, dentry->d_name.len, &tmp) < 0)
2311 { /* Lookup event was not queued to devfsd */
2312 d_add (dentry, NULL);
2316 dentry->d_op = &devfs_wait_dops;
2317 d_add (dentry, NULL); /* Open the floodgates */
2318 /* Unlock directory semaphore, which will release any waiters. They
2319 will get the hashed dentry, and may be forced to wait for
2322 wait_for_devfsd_finished (fs_info); /* If I'm not devfsd, must wait */
2323 de = lookup_info.de;
2324 /* If someone else has been so kind as to make the inode, we go home
2326 if (dentry->d_inode) goto out;
2329 read_lock (&parent->u.dir.lock);
2330 de = _devfs_search_dir (parent, dentry->d_name.name,
2331 dentry->d_name.len);
2332 read_unlock (&parent->u.dir.lock);
2333 if (de == NULL) goto out;
2334 /* OK, there's an entry now, but no VFS inode yet */
2336 /* Create an inode, now that the driver information is available */
2337 inode = _devfs_get_vfs_inode (dir->i_sb, de, dentry);
2340 retval = ERR_PTR (-ENOMEM);
2343 DPRINTK (DEBUG_I_LOOKUP, "(%s): new VFS inode(%u): %p de: %p by: \"%s\"\n",
2344 de->name, de->inode.ino, inode, de, current->comm);
2345 d_instantiate (dentry, inode);
2347 write_lock (&parent->u.dir.lock);
2348 dentry->d_op = &devfs_dops;
2349 dentry->d_fsdata = NULL;
2350 wake_up (&lookup_info.wait_queue);
2351 write_unlock (&parent->u.dir.lock);
2352 down (&dir->i_sem); /* Grab it again because them's the rules */
2355 } /* End Function devfs_lookup */
2357 static int devfs_unlink (struct inode *dir, struct dentry *dentry)
2360 struct devfs_entry *de;
2361 struct inode *inode = dentry->d_inode;
2362 struct fs_info *fs_info = dir->i_sb->s_fs_info;
2364 de = get_devfs_entry_from_vfs_inode (inode);
2365 DPRINTK (DEBUG_I_UNLINK, "(%s): de: %p\n", dentry->d_name.name, de);
2366 if (de == NULL) return -ENOENT;
2367 if (!de->vfs_deletable) return -EPERM;
2368 write_lock (&de->parent->u.dir.lock);
2369 unhooked = _devfs_unhook (de);
2370 write_unlock (&de->parent->u.dir.lock);
2371 if (!unhooked) return -ENOENT;
2372 if ( !is_devfsd_or_child (fs_info) )
2373 devfsd_notify_de (de, DEVFSD_NOTIFY_DELETE, inode->i_mode,
2374 inode->i_uid, inode->i_gid, fs_info);
2378 } /* End Function devfs_unlink */
2380 static int devfs_symlink (struct inode *dir, struct dentry *dentry,
2381 const char *symname)
2384 struct fs_info *fs_info = dir->i_sb->s_fs_info;
2385 struct devfs_entry *parent, *de;
2386 struct inode *inode;
2388 /* First try to get the devfs entry for this directory */
2389 parent = get_devfs_entry_from_vfs_inode (dir);
2390 if (parent == NULL) return -ENOENT;
2391 err = devfs_do_symlink (parent, dentry->d_name.name, symname, &de);
2392 DPRINTK (DEBUG_DISABLED, "(%s): errcode from <devfs_do_symlink>: %d\n",
2393 dentry->d_name.name, err);
2394 if (err < 0) return err;
2395 de->vfs_deletable = TRUE;
2396 de->inode.uid = current->euid;
2397 de->inode.gid = current->egid;
2398 de->inode.atime = CURRENT_TIME;
2399 de->inode.mtime = CURRENT_TIME;
2400 de->inode.ctime = CURRENT_TIME;
2401 if ( ( inode = _devfs_get_vfs_inode (dir->i_sb, de, dentry) ) == NULL )
2403 DPRINTK (DEBUG_DISABLED, "(%s): new VFS inode(%u): %p dentry: %p\n",
2404 dentry->d_name.name, de->inode.ino, inode, dentry);
2405 d_instantiate (dentry, inode);
2406 if ( !is_devfsd_or_child (fs_info) )
2407 devfsd_notify_de (de, DEVFSD_NOTIFY_CREATE, inode->i_mode,
2408 inode->i_uid, inode->i_gid, fs_info);
2410 } /* End Function devfs_symlink */
2412 static int devfs_mkdir (struct inode *dir, struct dentry *dentry, int mode)
2415 struct fs_info *fs_info = dir->i_sb->s_fs_info;
2416 struct devfs_entry *parent, *de;
2417 struct inode *inode;
2419 mode = (mode & ~S_IFMT) | S_IFDIR; /* VFS doesn't pass S_IFMT part */
2420 parent = get_devfs_entry_from_vfs_inode (dir);
2421 if (parent == NULL) return -ENOENT;
2422 de = _devfs_alloc_entry (dentry->d_name.name, dentry->d_name.len, mode);
2423 if (!de) return -ENOMEM;
2424 de->vfs_deletable = TRUE;
2425 if ( ( err = _devfs_append_entry (parent, de, NULL) ) != 0 )
2427 de->inode.uid = current->euid;
2428 de->inode.gid = current->egid;
2429 de->inode.atime = CURRENT_TIME;
2430 de->inode.mtime = CURRENT_TIME;
2431 de->inode.ctime = CURRENT_TIME;
2432 if ( ( inode = _devfs_get_vfs_inode (dir->i_sb, de, dentry) ) == NULL )
2434 DPRINTK (DEBUG_DISABLED, "(%s): new VFS inode(%u): %p dentry: %p\n",
2435 dentry->d_name.name, de->inode.ino, inode, dentry);
2436 d_instantiate (dentry, inode);
2437 if ( !is_devfsd_or_child (fs_info) )
2438 devfsd_notify_de (de, DEVFSD_NOTIFY_CREATE, inode->i_mode,
2439 inode->i_uid, inode->i_gid, fs_info);
2441 } /* End Function devfs_mkdir */
2443 static int devfs_rmdir (struct inode *dir, struct dentry *dentry)
2446 struct devfs_entry *de;
2447 struct fs_info *fs_info = dir->i_sb->s_fs_info;
2448 struct inode *inode = dentry->d_inode;
2450 if (dir->i_sb->s_fs_info != inode->i_sb->s_fs_info) return -EINVAL;
2451 de = get_devfs_entry_from_vfs_inode (inode);
2452 if (de == NULL) return -ENOENT;
2453 if ( !S_ISDIR (de->mode) ) return -ENOTDIR;
2454 if (!de->vfs_deletable) return -EPERM;
2455 /* First ensure the directory is empty and will stay that way */
2456 write_lock (&de->u.dir.lock);
2457 if (de->u.dir.first) err = -ENOTEMPTY;
2458 else de->u.dir.no_more_additions = TRUE;
2459 write_unlock (&de->u.dir.lock);
2460 if (err) return err;
2461 /* Now unhook the directory from its parent */
2462 write_lock (&de->parent->u.dir.lock);
2463 if ( !_devfs_unhook (de) ) err = -ENOENT;
2464 write_unlock (&de->parent->u.dir.lock);
2465 if (err) return err;
2466 if ( !is_devfsd_or_child (fs_info) )
2467 devfsd_notify_de (de, DEVFSD_NOTIFY_DELETE, inode->i_mode,
2468 inode->i_uid, inode->i_gid, fs_info);
2472 } /* End Function devfs_rmdir */
2474 static int devfs_mknod (struct inode *dir, struct dentry *dentry, int mode,
2478 struct fs_info *fs_info = dir->i_sb->s_fs_info;
2479 struct devfs_entry *parent, *de;
2480 struct inode *inode;
2482 DPRINTK (DEBUG_I_MKNOD, "(%s): mode: 0%o dev: %u:%u\n",
2483 dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
2484 parent = get_devfs_entry_from_vfs_inode (dir);
2485 if (parent == NULL) return -ENOENT;
2486 de = _devfs_alloc_entry (dentry->d_name.name, dentry->d_name.len, mode);
2487 if (!de) return -ENOMEM;
2488 de->vfs_deletable = TRUE;
2490 de->u.cdev.dev = rdev;
2491 else if (S_ISBLK (mode))
2492 de->u.bdev.dev = rdev;
2493 if ( ( err = _devfs_append_entry (parent, de, NULL) ) != 0 )
2495 de->inode.uid = current->euid;
2496 de->inode.gid = current->egid;
2497 de->inode.atime = CURRENT_TIME;
2498 de->inode.mtime = CURRENT_TIME;
2499 de->inode.ctime = CURRENT_TIME;
2500 if ( ( inode = _devfs_get_vfs_inode (dir->i_sb, de, dentry) ) == NULL )
2502 DPRINTK (DEBUG_I_MKNOD, ": new VFS inode(%u): %p dentry: %p\n",
2503 de->inode.ino, inode, dentry);
2504 d_instantiate (dentry, inode);
2505 if ( !is_devfsd_or_child (fs_info) )
2506 devfsd_notify_de (de, DEVFSD_NOTIFY_CREATE, inode->i_mode,
2507 inode->i_uid, inode->i_gid, fs_info);
2509 } /* End Function devfs_mknod */
2511 static int devfs_readlink (struct dentry *dentry, char *buffer, int buflen)
2514 struct devfs_entry *de;
2516 de = get_devfs_entry_from_vfs_inode (dentry->d_inode);
2517 if (!de) return -ENODEV;
2518 err = vfs_readlink (dentry, buffer, buflen, de->u.symlink.linkname);
2520 } /* End Function devfs_readlink */
2522 static int devfs_follow_link (struct dentry *dentry, struct nameidata *nd)
2525 struct devfs_entry *de;
2527 de = get_devfs_entry_from_vfs_inode (dentry->d_inode);
2528 if (!de) return -ENODEV;
2529 err = vfs_follow_link (nd, de->u.symlink.linkname);
2531 } /* End Function devfs_follow_link */
2533 static struct inode_operations devfs_iops =
2535 .setattr = devfs_notify_change,
2538 static struct inode_operations devfs_dir_iops =
2540 .lookup = devfs_lookup,
2541 .unlink = devfs_unlink,
2542 .symlink = devfs_symlink,
2543 .mkdir = devfs_mkdir,
2544 .rmdir = devfs_rmdir,
2545 .mknod = devfs_mknod,
2546 .setattr = devfs_notify_change,
2549 static struct inode_operations devfs_symlink_iops =
2551 .readlink = devfs_readlink,
2552 .follow_link = devfs_follow_link,
2553 .setattr = devfs_notify_change,
2556 static int devfs_fill_super (struct super_block *sb, void *data, int silent)
2558 struct inode *root_inode = NULL;
2560 if (_devfs_get_root_entry () == NULL) goto out_no_root;
2561 atomic_set (&fs_info.devfsd_overrun_count, 0);
2562 init_waitqueue_head (&fs_info.devfsd_wait_queue);
2563 init_waitqueue_head (&fs_info.revalidate_wait_queue);
2565 sb->s_fs_info = &fs_info;
2566 sb->s_blocksize = 1024;
2567 sb->s_blocksize_bits = 10;
2568 sb->s_magic = DEVFS_SUPER_MAGIC;
2569 sb->s_op = &devfs_sops;
2570 if ( ( root_inode = _devfs_get_vfs_inode (sb, root_entry, NULL) ) == NULL )
2572 sb->s_root = d_alloc_root (root_inode);
2573 if (!sb->s_root) goto out_no_root;
2574 DPRINTK (DEBUG_S_READ, "(): made devfs ptr: %p\n", sb->s_fs_info);
2578 PRINTK ("(): get root inode failed\n");
2579 if (root_inode) iput (root_inode);
2581 } /* End Function devfs_fill_super */
2583 static struct super_block *
2584 devfs_get_sb (struct file_system_type *fs_type, int flags,
2585 const char *dev_name, void *data)
2587 return get_sb_single (fs_type, flags, data, devfs_fill_super);
2590 static struct file_system_type devfs_fs_type =
2593 .get_sb = devfs_get_sb,
2594 .kill_sb = kill_anon_super,
2597 /* File operations for devfsd follow */
2599 static ssize_t devfsd_read (struct file *file, char *buf, size_t len,
2604 loff_t pos, devname_offset, tlen, rpos;
2606 struct devfsd_buf_entry *entry;
2607 struct fs_info *fs_info = file->f_dentry->d_inode->i_sb->s_fs_info;
2608 struct devfsd_notify_struct *info = fs_info->devfsd_info;
2609 DECLARE_WAITQUEUE (wait, current);
2611 /* Can't seek (pread) on this device */
2612 if (ppos != &file->f_pos) return -ESPIPE;
2613 /* Verify the task has grabbed the queue */
2614 if (fs_info->devfsd_task != current) return -EPERM;
2617 /* Block for a new entry */
2618 set_current_state (TASK_INTERRUPTIBLE);
2619 add_wait_queue (&fs_info->devfsd_wait_queue, &wait);
2620 while ( devfsd_queue_empty (fs_info) )
2622 fs_info->devfsd_sleeping = TRUE;
2623 wake_up (&fs_info->revalidate_wait_queue);
2625 fs_info->devfsd_sleeping = FALSE;
2626 if ( signal_pending (current) )
2628 remove_wait_queue (&fs_info->devfsd_wait_queue, &wait);
2629 __set_current_state (TASK_RUNNING);
2632 set_current_state (TASK_INTERRUPTIBLE);
2634 remove_wait_queue (&fs_info->devfsd_wait_queue, &wait);
2635 __set_current_state (TASK_RUNNING);
2636 /* Now play with the data */
2637 ival = atomic_read (&fs_info->devfsd_overrun_count);
2638 info->overrun_count = ival;
2639 entry = fs_info->devfsd_first_event;
2640 info->type = entry->type;
2641 info->mode = entry->mode;
2642 info->uid = entry->uid;
2643 info->gid = entry->gid;
2645 if (S_ISCHR(de->mode)) {
2646 info->major = MAJOR(de->u.cdev.dev);
2647 info->minor = MINOR(de->u.cdev.dev);
2648 } else if (S_ISBLK (de->mode)) {
2649 info->major = MAJOR(de->u.bdev.dev);
2650 info->minor = MINOR(de->u.bdev.dev);
2652 pos = devfs_generate_path (de, info->devname, DEVFS_PATHLEN);
2653 if (pos < 0) return pos;
2654 info->namelen = DEVFS_PATHLEN - pos - 1;
2655 if (info->mode == 0) info->mode = de->mode;
2656 devname_offset = info->devname - (char *) info;
2658 if (rpos < devname_offset)
2660 /* Copy parts of the header */
2661 tlen = devname_offset - rpos;
2662 if (tlen > len) tlen = len;
2663 if ( copy_to_user (buf, (char *) info + rpos, tlen) )
2671 if ( (rpos >= devname_offset) && (len > 0) )
2674 tlen = info->namelen + 1;
2675 if (tlen > len) tlen = len;
2677 if ( copy_to_user (buf, info->devname + pos + rpos - devname_offset,
2684 tlen = rpos - *ppos;
2687 devfs_handle_t parent;
2689 spin_lock (&fs_info->devfsd_buffer_lock);
2690 fs_info->devfsd_first_event = entry->next;
2691 if (entry->next == NULL) fs_info->devfsd_last_event = NULL;
2692 spin_unlock (&fs_info->devfsd_buffer_lock);
2693 for (; de != NULL; de = parent)
2695 parent = de->parent;
2698 kmem_cache_free (devfsd_buf_cache, entry);
2699 if (ival > 0) atomic_sub (ival, &fs_info->devfsd_overrun_count);
2704 } /* End Function devfsd_read */
2706 static int devfsd_ioctl (struct inode *inode, struct file *file,
2707 unsigned int cmd, unsigned long arg)
2710 struct fs_info *fs_info = inode->i_sb->s_fs_info;
2714 case DEVFSDIOC_GET_PROTO_REV:
2715 ival = DEVFSD_PROTOCOL_REVISION_KERNEL;
2716 if ( copy_to_user ( (void *)arg, &ival, sizeof ival ) ) return -EFAULT;
2718 case DEVFSDIOC_SET_EVENT_MASK:
2719 /* Ensure only one reader has access to the queue. This scheme will
2720 work even if the global kernel lock were to be removed, because it
2721 doesn't matter who gets in first, as long as only one gets it */
2722 if (fs_info->devfsd_task == NULL)
2724 static spinlock_t lock = SPIN_LOCK_UNLOCKED;
2726 if ( !spin_trylock (&lock) ) return -EBUSY;
2727 if (fs_info->devfsd_task != NULL)
2728 { /* We lost the race... */
2729 spin_unlock (&lock);
2732 fs_info->devfsd_task = current;
2733 spin_unlock (&lock);
2734 fs_info->devfsd_pgrp = (process_group(current) == current->pid) ?
2735 process_group(current) : 0;
2736 fs_info->devfsd_file = file;
2737 fs_info->devfsd_info = kmalloc (sizeof *fs_info->devfsd_info,
2739 if (!fs_info->devfsd_info)
2741 devfsd_close (inode, file);
2745 else if (fs_info->devfsd_task != current) return -EBUSY;
2746 fs_info->devfsd_event_mask = arg; /* Let the masses come forth */
2748 case DEVFSDIOC_RELEASE_EVENT_QUEUE:
2749 if (fs_info->devfsd_file != file) return -EPERM;
2750 return devfsd_close (inode, file);
2752 #ifdef CONFIG_DEVFS_DEBUG
2753 case DEVFSDIOC_SET_DEBUG_MASK:
2754 if ( copy_from_user (&ival, (void *) arg, sizeof ival) )return -EFAULT;
2759 return -ENOIOCTLCMD;
2762 } /* End Function devfsd_ioctl */
2764 static int devfsd_close (struct inode *inode, struct file *file)
2766 struct devfsd_buf_entry *entry, *next;
2767 struct fs_info *fs_info = inode->i_sb->s_fs_info;
2769 if (fs_info->devfsd_file != file) return 0;
2770 fs_info->devfsd_event_mask = 0;
2771 fs_info->devfsd_file = NULL;
2772 spin_lock (&fs_info->devfsd_buffer_lock);
2773 entry = fs_info->devfsd_first_event;
2774 fs_info->devfsd_first_event = NULL;
2775 fs_info->devfsd_last_event = NULL;
2776 if (fs_info->devfsd_info)
2778 kfree (fs_info->devfsd_info);
2779 fs_info->devfsd_info = NULL;
2781 spin_unlock (&fs_info->devfsd_buffer_lock);
2782 fs_info->devfsd_pgrp = 0;
2783 fs_info->devfsd_task = NULL;
2784 wake_up (&fs_info->revalidate_wait_queue);
2785 for (; entry; entry = next)
2788 kmem_cache_free (devfsd_buf_cache, entry);
2791 } /* End Function devfsd_close */
2793 #ifdef CONFIG_DEVFS_DEBUG
2794 static ssize_t stat_read (struct file *file, char *buf, size_t len,
2800 num = sprintf (txt, "Number of entries: %u number of bytes: %u\n",
2801 stat_num_entries, stat_num_bytes) + 1;
2802 /* Can't seek (pread) on this device */
2803 if (ppos != &file->f_pos) return -ESPIPE;
2804 if (*ppos >= num) return 0;
2805 if (*ppos + len > num) len = num - *ppos;
2806 if ( copy_to_user (buf, txt + *ppos, len) ) return -EFAULT;
2809 } /* End Function stat_read */
2813 static int __init init_devfs_fs (void)
2817 printk (KERN_INFO "%s: v%s Richard Gooch (rgooch@atnf.csiro.au)\n",
2818 DEVFS_NAME, DEVFS_VERSION);
2819 devfsd_buf_cache = kmem_cache_create ("devfsd_event",
2820 sizeof (struct devfsd_buf_entry),
2822 if (!devfsd_buf_cache) OOPS ("(): unable to allocate event slab\n");
2823 #ifdef CONFIG_DEVFS_DEBUG
2824 devfs_debug = devfs_debug_init;
2825 printk (KERN_INFO "%s: devfs_debug: 0x%0x\n", DEVFS_NAME, devfs_debug);
2827 printk (KERN_INFO "%s: boot_options: 0x%0x\n", DEVFS_NAME, boot_options);
2828 err = register_filesystem (&devfs_fs_type);
2831 struct vfsmount *devfs_mnt = kern_mount (&devfs_fs_type);
2832 err = PTR_ERR (devfs_mnt);
2833 if ( !IS_ERR (devfs_mnt) ) err = 0;
2836 } /* End Function init_devfs_fs */
2838 void __init mount_devfs_fs (void)
2842 if ( !(boot_options & OPTION_MOUNT) ) return;
2843 err = do_mount ("none", "/dev", "devfs", 0, NULL);
2844 if (err == 0) printk (KERN_INFO "Mounted devfs on /dev\n");
2845 else PRINTK ("(): unable to mount devfs, err: %d\n", err);
2846 } /* End Function mount_devfs_fs */
2848 module_init(init_devfs_fs)