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