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 20020514 Richard Gooch <rgooch@atnf.csiro.au>
619 Added BKL to <devfs_open> because drivers still need it.
620 Protected <scan_dir_for_removable> and <get_removable_partition>
621 from changing directory contents.
622 v1.12a
623 20020721 Richard Gooch <rgooch@atnf.csiro.au>
624 Switched to ISO C structure field initialisers.
625 Switch to set_current_state() and move before add_wait_queue().
626 20020722 Richard Gooch <rgooch@atnf.csiro.au>
627 Fixed devfs entry leak in <devfs_readdir> when *readdir fails.
628 v1.12b
629 20020818 Richard Gooch <rgooch@atnf.csiro.au>
630 Fixed module unload race in <devfs_open>.
631 v1.12c
632 */
633 #include <linux/types.h>
634 #include <linux/errno.h>
635 #include <linux/sched.h>
636 #include <linux/tty.h>
637 #include <linux/timer.h>
638 #include <linux/config.h>
639 #include <linux/kernel.h>
640 #include <linux/wait.h>
641 #include <linux/string.h>
642 #include <linux/slab.h>
643 #include <linux/ioport.h>
644 #include <linux/delay.h>
645 #include <linux/ctype.h>
646 #include <linux/mm.h>
647 #include <linux/module.h>
648 #include <linux/init.h>
649 #include <linux/devfs_fs.h>
650 #include <linux/devfs_fs_kernel.h>
651 #include <linux/smp_lock.h>
652 #include <linux/smp.h>
653 #include <linux/version.h>
654 #include <linux/rwsem.h>
655
656 #include <asm/uaccess.h>
657 #include <asm/io.h>
658 #include <asm/processor.h>
659 #include <asm/system.h>
660 #include <asm/pgtable.h>
661 #include <asm/bitops.h>
662 #include <asm/atomic.h>
663
664 #define DEVFS_VERSION "1.12c (20020818)"
665
666 #define DEVFS_NAME "devfs"
667
668 #define FIRST_INODE 1
669
670 #define STRING_LENGTH 256
671 #define FAKE_BLOCK_SIZE 1024
672 #define POISON_PTR ( *(void **) poison_array )
673 #define MAGIC_VALUE 0x327db823
674
675 #ifndef TRUE
676 # define TRUE 1
677 # define FALSE 0
678 #endif
679
680 #define MODE_DIR (S_IFDIR | S_IWUSR | S_IRUGO | S_IXUGO)
681
682 #define IS_HIDDEN(de) ( (de)->hide && !is_devfsd_or_child(fs_info) )
683
684 #define DEBUG_NONE 0x0000000
685 #define DEBUG_MODULE_LOAD 0x0000001
686 #define DEBUG_REGISTER 0x0000002
687 #define DEBUG_UNREGISTER 0x0000004
688 #define DEBUG_FREE 0x0000008
689 #define DEBUG_SET_FLAGS 0x0000010
690 #define DEBUG_S_READ 0x0000100 /* Break */
691 #define DEBUG_I_LOOKUP 0x0001000 /* Break */
692 #define DEBUG_I_CREATE 0x0002000
693 #define DEBUG_I_GET 0x0004000
694 #define DEBUG_I_CHANGE 0x0008000
695 #define DEBUG_I_UNLINK 0x0010000
696 #define DEBUG_I_RLINK 0x0020000
697 #define DEBUG_I_FLINK 0x0040000
698 #define DEBUG_I_MKNOD 0x0080000
699 #define DEBUG_F_READDIR 0x0100000 /* Break */
700 #define DEBUG_D_DELETE 0x1000000 /* Break */
701 #define DEBUG_D_RELEASE 0x2000000
702 #define DEBUG_D_IPUT 0x4000000
703 #define DEBUG_ALL 0xfffffff
704 #define DEBUG_DISABLED DEBUG_NONE
705
706 #define OPTION_NONE 0x00
707 #define OPTION_MOUNT 0x01
708 #define OPTION_ONLY 0x02
709
710 #define PRINTK(format, args...) \
711 {printk (KERN_ERR "%s" format, __FUNCTION__ , ## args);}
712
713 #define OOPS(format, args...) \
714 {printk (KERN_CRIT "%s" format, __FUNCTION__ , ## args); \
715 printk ("Forcing Oops\n"); \
716 BUG();}
717
718 #ifdef CONFIG_DEVFS_DEBUG
719 # define VERIFY_ENTRY(de) \
720 {if ((de) && (de)->magic_number != MAGIC_VALUE) \
721 OOPS ("(%p): bad magic value: %x\n", (de), (de)->magic_number);}
722 # define WRITE_ENTRY_MAGIC(de,magic) (de)->magic_number = (magic)
723 # define DPRINTK(flag, format, args...) \
724 {if (devfs_debug & flag) \
725 printk (KERN_INFO "%s" format, __FUNCTION__ , ## args);}
726 #else
727 # define VERIFY_ENTRY(de)
728 # define WRITE_ENTRY_MAGIC(de,magic)
729 # define DPRINTK(flag, format, args...)
730 #endif
731
732
733 struct directory_type
734 {
735 rwlock_t lock; /* Lock for searching(R)/updating(W) */
736 struct devfs_entry *first;
737 struct devfs_entry *last;
738 unsigned short num_removable; /* Lock for writing but not reading */
739 unsigned char no_more_additions:1;
740 };
741
742 struct file_type
743 {
744 unsigned long size;
745 };
746
747 struct device_type
748 {
749 unsigned short major;
750 unsigned short minor;
751 };
752
753 struct fcb_type /* File, char, block type */
754 {
755 void *ops;
756 union
757 {
758 struct file_type file;
759 struct device_type device;
760 }
761 u;
762 unsigned char auto_owner:1;
763 unsigned char aopen_notify:1;
764 unsigned char removable:1; /* Belongs in device_type, but save space */
765 unsigned char open:1; /* Not entirely correct */
766 unsigned char autogen:1; /* Belongs in device_type, but save space */
767 };
768
769 struct symlink_type
770 {
771 unsigned int length; /* Not including the NULL-termimator */
772 char *linkname; /* This is NULL-terminated */
773 };
774
775 struct devfs_inode /* This structure is for "persistent" inode storage */
776 {
777 struct dentry *dentry;
778 time_t atime;
779 time_t mtime;
780 time_t ctime;
781 unsigned int ino; /* Inode number as seen in the VFS */
782 uid_t uid;
783 gid_t gid;
784 };
785
786 struct devfs_entry
787 {
788 #ifdef CONFIG_DEVFS_DEBUG
789 unsigned int magic_number;
790 #endif
791 void *info;
792 atomic_t refcount; /* When this drops to zero, it's unused */
793 union
794 {
795 struct directory_type dir;
796 struct fcb_type fcb;
797 struct symlink_type symlink;
798 const char *name; /* Only used for (mode == 0) */
799 }
800 u;
801 struct devfs_entry *prev; /* Previous entry in the parent directory */
802 struct devfs_entry *next; /* Next entry in the parent directory */
803 struct devfs_entry *parent; /* The parent directory */
804 struct devfs_entry *slave; /* Another entry to unregister */
805 struct devfs_inode inode;
806 umode_t mode;
807 unsigned short namelen; /* I think 64k+ filenames are a way off... */
808 unsigned char hide:1;
809 unsigned char vfs_deletable:1;/* Whether the VFS may delete the entry */
810 char name[1]; /* This is just a dummy: the allocated array
811 is bigger. This is NULL-terminated */
812 };
813
814 /* The root of the device tree */
815 static struct devfs_entry *root_entry;
816
817 struct devfsd_buf_entry
818 {
819 struct devfs_entry *de; /* The name is generated with this */
820 unsigned short type; /* The type of event */
821 umode_t mode;
822 uid_t uid;
823 gid_t gid;
824 struct devfsd_buf_entry *next;
825 };
826
827 struct fs_info /* This structure is for the mounted devfs */
828 {
829 struct super_block *sb;
830 spinlock_t devfsd_buffer_lock; /* Lock when inserting/deleting events */
831 struct devfsd_buf_entry *devfsd_first_event;
832 struct devfsd_buf_entry *devfsd_last_event;
833 volatile int devfsd_sleeping;
834 volatile struct task_struct *devfsd_task;
835 volatile pid_t devfsd_pgrp;
836 volatile struct file *devfsd_file;
837 struct devfsd_notify_struct *devfsd_info;
838 volatile unsigned long devfsd_event_mask;
839 atomic_t devfsd_overrun_count;
840 wait_queue_head_t devfsd_wait_queue; /* Wake devfsd on input */
841 wait_queue_head_t revalidate_wait_queue; /* Wake when devfsd sleeps */
842 };
843
844 static struct fs_info fs_info = {devfsd_buffer_lock: SPIN_LOCK_UNLOCKED};
845 static kmem_cache_t *devfsd_buf_cache;
846 #ifdef CONFIG_DEVFS_DEBUG
847 static unsigned int devfs_debug_init __initdata = DEBUG_NONE;
848 static unsigned int devfs_debug = DEBUG_NONE;
849 static spinlock_t stat_lock = SPIN_LOCK_UNLOCKED;
850 static unsigned int stat_num_entries;
851 static unsigned int stat_num_bytes;
852 #endif
853 static unsigned char poison_array[8] =
854 {0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a};
855
856 #ifdef CONFIG_DEVFS_MOUNT
857 static unsigned int boot_options = OPTION_MOUNT;
858 #else
859 static unsigned int boot_options = OPTION_NONE;
860 #endif
861
862 /* Forward function declarations */
863 static devfs_handle_t _devfs_walk_path (struct devfs_entry *dir,
864 const char *name, int namelen,
865 int traverse_symlink);
866 static ssize_t devfsd_read (struct file *file, char *buf, size_t len,
867 loff_t *ppos);
868 static int devfsd_ioctl (struct inode *inode, struct file *file,
869 unsigned int cmd, unsigned long arg);
870 static int devfsd_close (struct inode *inode, struct file *file);
871 #ifdef CONFIG_DEVFS_DEBUG
872 static ssize_t stat_read (struct file *file, char *buf, size_t len,
873 loff_t *ppos);
874 static struct file_operations stat_fops =
875 {
876 .read = stat_read,
877 };
878 #endif
879
880
881 /* Devfs daemon file operations */
882 static struct file_operations devfsd_fops =
883 {
884 .read = devfsd_read,
885 .ioctl = devfsd_ioctl,
886 .release = devfsd_close,
887 };
888
889
890 /* Support functions follow */
891
892
893 /**
894 * devfs_get - Get a reference to a devfs entry.
895 * @de: The devfs entry.
896 */
897
devfs_get(struct devfs_entry * de)898 static struct devfs_entry *devfs_get (struct devfs_entry *de)
899 {
900 VERIFY_ENTRY (de);
901 if (de) atomic_inc (&de->refcount);
902 return de;
903 } /* End Function devfs_get */
904
905 /**
906 * devfs_put - Put (release) a reference to a devfs entry.
907 * @de: The handle to the devfs entry.
908 */
909
devfs_put(devfs_handle_t de)910 void devfs_put (devfs_handle_t de)
911 {
912 if (!de) return;
913 VERIFY_ENTRY (de);
914 if (de->info == POISON_PTR) OOPS ("(%p): poisoned pointer\n", de);
915 if ( !atomic_dec_and_test (&de->refcount) ) return;
916 if (de == root_entry) OOPS ("(%p): root entry being freed\n", de);
917 DPRINTK (DEBUG_FREE, "(%s): de: %p, parent: %p \"%s\"\n",
918 de->name, de, de->parent,
919 de->parent ? de->parent->name : "no parent");
920 if ( S_ISLNK (de->mode) ) kfree (de->u.symlink.linkname);
921 if ( ( S_ISCHR (de->mode) || S_ISBLK (de->mode) ) && de->u.fcb.autogen )
922 {
923 devfs_dealloc_devnum ( S_ISCHR (de->mode) ? DEVFS_SPECIAL_CHR :
924 DEVFS_SPECIAL_BLK,
925 mk_kdev (de->u.fcb.u.device.major,
926 de->u.fcb.u.device.minor) );
927 }
928 WRITE_ENTRY_MAGIC (de, 0);
929 #ifdef CONFIG_DEVFS_DEBUG
930 spin_lock (&stat_lock);
931 --stat_num_entries;
932 stat_num_bytes -= sizeof *de + de->namelen;
933 if ( S_ISLNK (de->mode) ) stat_num_bytes -= de->u.symlink.length + 1;
934 spin_unlock (&stat_lock);
935 #endif
936 de->info = POISON_PTR;
937 kfree (de);
938 } /* End Function devfs_put */
939
940 /**
941 * _devfs_search_dir - Search for a devfs entry in a directory.
942 * @dir: The directory to search.
943 * @name: The name of the entry to search for.
944 * @namelen: The number of characters in @name.
945 *
946 * Search for a devfs entry in a directory and returns a pointer to the entry
947 * on success, else %NULL. The directory must be locked already.
948 * An implicit devfs_get() is performed on the returned entry.
949 */
950
_devfs_search_dir(struct devfs_entry * dir,const char * name,unsigned int namelen)951 static struct devfs_entry *_devfs_search_dir (struct devfs_entry *dir,
952 const char *name,
953 unsigned int namelen)
954 {
955 struct devfs_entry *curr;
956
957 if ( !S_ISDIR (dir->mode) )
958 {
959 PRINTK ("(%s): not a directory\n", dir->name);
960 return NULL;
961 }
962 for (curr = dir->u.dir.first; curr != NULL; curr = curr->next)
963 {
964 if (curr->namelen != namelen) continue;
965 if (memcmp (curr->name, name, namelen) == 0) break;
966 /* Not found: try the next one */
967 }
968 return devfs_get (curr);
969 } /* End Function _devfs_search_dir */
970
971
972 /**
973 * _devfs_alloc_entry - Allocate a devfs entry.
974 * @name: The name of the entry.
975 * @namelen: The number of characters in @name.
976 *
977 * Allocate a devfs entry and returns a pointer to the entry on success, else
978 * %NULL.
979 */
980
_devfs_alloc_entry(const char * name,unsigned int namelen,umode_t mode)981 static struct devfs_entry *_devfs_alloc_entry (const char *name,
982 unsigned int namelen,
983 umode_t mode)
984 {
985 struct devfs_entry *new;
986 static unsigned long inode_counter = FIRST_INODE;
987 static spinlock_t counter_lock = SPIN_LOCK_UNLOCKED;
988
989 if ( name && (namelen < 1) ) namelen = strlen (name);
990 if ( ( new = kmalloc (sizeof *new + namelen, GFP_KERNEL) ) == NULL )
991 return NULL;
992 memset (new, 0, sizeof *new + namelen); /* Will set '\0' on name */
993 new->mode = mode;
994 if ( S_ISDIR (mode) ) rwlock_init (&new->u.dir.lock);
995 atomic_set (&new->refcount, 1);
996 spin_lock (&counter_lock);
997 new->inode.ino = inode_counter++;
998 spin_unlock (&counter_lock);
999 if (name) memcpy (new->name, name, namelen);
1000 new->namelen = namelen;
1001 WRITE_ENTRY_MAGIC (new, MAGIC_VALUE);
1002 #ifdef CONFIG_DEVFS_DEBUG
1003 spin_lock (&stat_lock);
1004 ++stat_num_entries;
1005 stat_num_bytes += sizeof *new + namelen;
1006 spin_unlock (&stat_lock);
1007 #endif
1008 return new;
1009 } /* End Function _devfs_alloc_entry */
1010
1011
1012 /**
1013 * _devfs_append_entry - Append a devfs entry to a directory's child list.
1014 * @dir: The directory to add to.
1015 * @de: The devfs entry to append.
1016 * @removable: If TRUE, increment the count of removable devices for %dir.
1017 * @old_de: If an existing entry exists, it will be written here. This may
1018 * be %NULL. An implicit devfs_get() is performed on this entry.
1019 *
1020 * Append a devfs entry to a directory's list of children, checking first to
1021 * see if an entry of the same name exists. The directory will be locked.
1022 * The value 0 is returned on success, else a negative error code.
1023 * On failure, an implicit devfs_put() is performed on %de.
1024 */
1025
_devfs_append_entry(devfs_handle_t dir,devfs_handle_t de,int removable,devfs_handle_t * old_de)1026 static int _devfs_append_entry (devfs_handle_t dir, devfs_handle_t de,
1027 int removable, devfs_handle_t *old_de)
1028 {
1029 int retval;
1030
1031 if (old_de) *old_de = NULL;
1032 if ( !S_ISDIR (dir->mode) )
1033 {
1034 PRINTK ("(%s): dir: \"%s\" is not a directory\n", de->name, dir->name);
1035 devfs_put (de);
1036 return -ENOTDIR;
1037 }
1038 write_lock (&dir->u.dir.lock);
1039 if (dir->u.dir.no_more_additions) retval = -ENOENT;
1040 else
1041 {
1042 struct devfs_entry *old;
1043
1044 old = _devfs_search_dir (dir, de->name, de->namelen);
1045 if (old_de) *old_de = old;
1046 else devfs_put (old);
1047 if (old == NULL)
1048 {
1049 de->parent = dir;
1050 de->prev = dir->u.dir.last;
1051 /* Append to the directory's list of children */
1052 if (dir->u.dir.first == NULL) dir->u.dir.first = de;
1053 else dir->u.dir.last->next = de;
1054 dir->u.dir.last = de;
1055 if (removable) ++dir->u.dir.num_removable;
1056 retval = 0;
1057 }
1058 else retval = -EEXIST;
1059 }
1060 write_unlock (&dir->u.dir.lock);
1061 if (retval) devfs_put (de);
1062 return retval;
1063 } /* End Function _devfs_append_entry */
1064
1065
1066 /**
1067 * _devfs_get_root_entry - Get the root devfs entry.
1068 *
1069 * Returns the root devfs entry on success, else %NULL.
1070 */
1071
_devfs_get_root_entry(void)1072 static struct devfs_entry *_devfs_get_root_entry (void)
1073 {
1074 kdev_t devnum;
1075 struct devfs_entry *new;
1076 static spinlock_t root_lock = SPIN_LOCK_UNLOCKED;
1077
1078 /* Always ensure the root is created */
1079 if (root_entry) return root_entry;
1080 if ( ( new = _devfs_alloc_entry (NULL, 0,MODE_DIR) ) == NULL ) return NULL;
1081 spin_lock (&root_lock);
1082 if (root_entry)
1083 {
1084 spin_unlock (&root_lock);
1085 devfs_put (new);
1086 return (root_entry);
1087 }
1088 root_entry = new;
1089 spin_unlock (&root_lock);
1090 /* And create the entry for ".devfsd" */
1091 if ( ( new = _devfs_alloc_entry (".devfsd", 0, S_IFCHR |S_IRUSR |S_IWUSR) )
1092 == NULL ) return NULL;
1093 devnum = devfs_alloc_devnum (DEVFS_SPECIAL_CHR);
1094 new->u.fcb.u.device.major = major (devnum);
1095 new->u.fcb.u.device.minor = minor (devnum);
1096 new->u.fcb.ops = &devfsd_fops;
1097 _devfs_append_entry (root_entry, new, FALSE, NULL);
1098 #ifdef CONFIG_DEVFS_DEBUG
1099 if ( ( new = _devfs_alloc_entry (".stat", 0, S_IFCHR | S_IRUGO | S_IWUGO) )
1100 == NULL ) return NULL;
1101 devnum = devfs_alloc_devnum (DEVFS_SPECIAL_CHR);
1102 new->u.fcb.u.device.major = major (devnum);
1103 new->u.fcb.u.device.minor = minor (devnum);
1104 new->u.fcb.ops = &stat_fops;
1105 _devfs_append_entry (root_entry, new, FALSE, NULL);
1106 #endif
1107 return root_entry;
1108 } /* End Function _devfs_get_root_entry */
1109
1110
1111 /**
1112 * _devfs_descend - Descend down a tree using the next component name.
1113 * @dir: The directory to search.
1114 * @name: The component name to search for.
1115 * @namelen: The length of %name.
1116 * @next_pos: The position of the next '/' or '\0' is written here.
1117 *
1118 * Descend into a directory, searching for a component. This function forms
1119 * the core of a tree-walking algorithm. The directory will be locked.
1120 * The devfs entry corresponding to the component is returned. If there is
1121 * no matching entry, %NULL is returned.
1122 * An implicit devfs_get() is performed on the returned entry.
1123 */
1124
_devfs_descend(struct devfs_entry * dir,const char * name,int namelen,int * next_pos)1125 static struct devfs_entry *_devfs_descend (struct devfs_entry *dir,
1126 const char *name, int namelen,
1127 int *next_pos)
1128 {
1129 const char *stop, *ptr;
1130 struct devfs_entry *entry;
1131
1132 if ( (namelen >= 3) && (strncmp (name, "../", 3) == 0) )
1133 { /* Special-case going to parent directory */
1134 *next_pos = 3;
1135 return devfs_get (dir->parent);
1136 }
1137 stop = name + namelen;
1138 /* Search for a possible '/' */
1139 for (ptr = name; (ptr < stop) && (*ptr != '/'); ++ptr);
1140 *next_pos = ptr - name;
1141 read_lock (&dir->u.dir.lock);
1142 entry = _devfs_search_dir (dir, name, *next_pos);
1143 read_unlock (&dir->u.dir.lock);
1144 return entry;
1145 } /* End Function _devfs_descend */
1146
1147
_devfs_make_parent_for_leaf(struct devfs_entry * dir,const char * name,int namelen,int * leaf_pos)1148 static devfs_handle_t _devfs_make_parent_for_leaf (struct devfs_entry *dir,
1149 const char *name,
1150 int namelen, int *leaf_pos)
1151 {
1152 int next_pos = 0;
1153
1154 if (dir == NULL) dir = _devfs_get_root_entry ();
1155 if (dir == NULL) return NULL;
1156 devfs_get (dir);
1157 /* Search for possible trailing component and ignore it */
1158 for (--namelen; (namelen > 0) && (name[namelen] != '/'); --namelen);
1159 *leaf_pos = (name[namelen] == '/') ? (namelen + 1) : 0;
1160 for (; namelen > 0; name += next_pos, namelen -= next_pos)
1161 {
1162 struct devfs_entry *de, *old;
1163
1164 if ( ( de = _devfs_descend (dir, name, namelen, &next_pos) ) == NULL )
1165 {
1166 de = _devfs_alloc_entry (name, next_pos, MODE_DIR);
1167 devfs_get (de);
1168 if ( !de || _devfs_append_entry (dir, de, FALSE, &old) )
1169 {
1170 devfs_put (de);
1171 if ( !old || !S_ISDIR (old->mode) )
1172 {
1173 devfs_put (old);
1174 devfs_put (dir);
1175 return NULL;
1176 }
1177 de = old; /* Use the existing directory */
1178 }
1179 }
1180 if (de == dir->parent)
1181 {
1182 devfs_put (dir);
1183 devfs_put (de);
1184 return NULL;
1185 }
1186 devfs_put (dir);
1187 dir = de;
1188 if (name[next_pos] == '/') ++next_pos;
1189 }
1190 return dir;
1191 } /* End Function _devfs_make_parent_for_leaf */
1192
1193
_devfs_prepare_leaf(devfs_handle_t * dir,const char * name,umode_t mode)1194 static devfs_handle_t _devfs_prepare_leaf (devfs_handle_t *dir,
1195 const char *name, umode_t mode)
1196 {
1197 int namelen, leaf_pos;
1198 struct devfs_entry *de;
1199
1200 namelen = strlen (name);
1201 if ( ( *dir = _devfs_make_parent_for_leaf (*dir, name, namelen,
1202 &leaf_pos) ) == NULL )
1203 {
1204 PRINTK ("(%s): could not create parent path\n", name);
1205 return NULL;
1206 }
1207 if ( ( de = _devfs_alloc_entry (name + leaf_pos, namelen - leaf_pos,mode) )
1208 == NULL )
1209 {
1210 PRINTK ("(%s): could not allocate entry\n", name);
1211 devfs_put (*dir);
1212 return NULL;
1213 }
1214 return de;
1215 } /* End Function _devfs_prepare_leaf */
1216
1217
_devfs_walk_path(struct devfs_entry * dir,const char * name,int namelen,int traverse_symlink)1218 static devfs_handle_t _devfs_walk_path (struct devfs_entry *dir,
1219 const char *name, int namelen,
1220 int traverse_symlink)
1221 {
1222 int next_pos = 0;
1223
1224 if (dir == NULL) dir = _devfs_get_root_entry ();
1225 if (dir == NULL) return NULL;
1226 devfs_get (dir);
1227 for (; namelen > 0; name += next_pos, namelen -= next_pos)
1228 {
1229 struct devfs_entry *de, *link;
1230
1231 if ( ( de = _devfs_descend (dir, name, namelen, &next_pos) ) == NULL )
1232 {
1233 devfs_put (dir);
1234 return NULL;
1235 }
1236 if (S_ISLNK (de->mode) && traverse_symlink)
1237 { /* Need to follow the link: this is a stack chomper */
1238 link = _devfs_walk_path (dir, de->u.symlink.linkname,
1239 de->u.symlink.length, TRUE);
1240 devfs_put (de);
1241 if (!link)
1242 {
1243 devfs_put (dir);
1244 return NULL;
1245 }
1246 de = link;
1247 }
1248 devfs_put (dir);
1249 dir = de;
1250 if (name[next_pos] == '/') ++next_pos;
1251 }
1252 return dir;
1253 } /* End Function _devfs_walk_path */
1254
1255
1256 /**
1257 * _devfs_find_by_dev - Find a devfs entry in a directory.
1258 * @dir: The directory where to search
1259 * @major: The major number to search for.
1260 * @minor: The minor number to search for.
1261 * @type: The type of special file to search for. This may be either
1262 * %DEVFS_SPECIAL_CHR or %DEVFS_SPECIAL_BLK.
1263 *
1264 * Returns the devfs_entry pointer on success, else %NULL. An implicit
1265 * devfs_get() is performed.
1266 */
1267
_devfs_find_by_dev(struct devfs_entry * dir,unsigned int major,unsigned int minor,char type)1268 static struct devfs_entry *_devfs_find_by_dev (struct devfs_entry *dir,
1269 unsigned int major,
1270 unsigned int minor, char type)
1271 {
1272 struct devfs_entry *entry, *de;
1273
1274 devfs_get (dir);
1275 if (dir == NULL) return NULL;
1276 if ( !S_ISDIR (dir->mode) )
1277 {
1278 PRINTK ("(%p): not a directory\n", dir);
1279 devfs_put (dir);
1280 return NULL;
1281 }
1282 /* First search files in this directory */
1283 read_lock (&dir->u.dir.lock);
1284 for (entry = dir->u.dir.first; entry != NULL; entry = entry->next)
1285 {
1286 if ( !S_ISCHR (entry->mode) && !S_ISBLK (entry->mode) ) continue;
1287 if ( S_ISCHR (entry->mode) && (type != DEVFS_SPECIAL_CHR) ) continue;
1288 if ( S_ISBLK (entry->mode) && (type != DEVFS_SPECIAL_BLK) ) continue;
1289 if ( (entry->u.fcb.u.device.major == major) &&
1290 (entry->u.fcb.u.device.minor == minor) )
1291 {
1292 devfs_get (entry);
1293 read_unlock (&dir->u.dir.lock);
1294 devfs_put (dir);
1295 return entry;
1296 }
1297 /* Not found: try the next one */
1298 }
1299 /* Now recursively search the subdirectories: this is a stack chomper */
1300 for (entry = dir->u.dir.first; entry != NULL; entry = entry->next)
1301 {
1302 if ( !S_ISDIR (entry->mode) ) continue;
1303 de = _devfs_find_by_dev (entry, major, minor, type);
1304 if (de)
1305 {
1306 read_unlock (&dir->u.dir.lock);
1307 devfs_put (dir);
1308 return de;
1309 }
1310 }
1311 read_unlock (&dir->u.dir.lock);
1312 devfs_put (dir);
1313 return NULL;
1314 } /* End Function _devfs_find_by_dev */
1315
1316
1317 /**
1318 * _devfs_find_entry - Find a devfs entry.
1319 * @dir: The handle to the parent devfs directory entry. If this is %NULL the
1320 * name is relative to the root of the devfs.
1321 * @name: The name of the entry. This may be %NULL.
1322 * @major: The major number. This is used if lookup by @name fails.
1323 * @minor: The minor number. This is used if lookup by @name fails.
1324 * NOTE: If @major and @minor are both 0, searching by major and minor
1325 * numbers is disabled.
1326 * @type: The type of special file to search for. This may be either
1327 * %DEVFS_SPECIAL_CHR or %DEVFS_SPECIAL_BLK.
1328 * @traverse_symlink: If %TRUE then symbolic links are traversed.
1329 *
1330 * Returns the devfs_entry pointer on success, else %NULL. An implicit
1331 * devfs_get() is performed.
1332 */
1333
_devfs_find_entry(devfs_handle_t dir,const char * name,unsigned int major,unsigned int minor,char type,int traverse_symlink)1334 static struct devfs_entry *_devfs_find_entry (devfs_handle_t dir,
1335 const char *name,
1336 unsigned int major,
1337 unsigned int minor,
1338 char type, int traverse_symlink)
1339 {
1340 struct devfs_entry *entry;
1341
1342 if (name != NULL)
1343 {
1344 unsigned int namelen = strlen (name);
1345
1346 if (name[0] == '/')
1347 {
1348 /* Skip leading pathname component */
1349 if (namelen < 2)
1350 {
1351 PRINTK ("(%s): too short\n", name);
1352 return NULL;
1353 }
1354 for (++name, --namelen; (*name != '/') && (namelen > 0);
1355 ++name, --namelen);
1356 if (namelen < 2)
1357 {
1358 PRINTK ("(%s): too short\n", name);
1359 return NULL;
1360 }
1361 ++name;
1362 --namelen;
1363 }
1364 entry = _devfs_walk_path (dir, name, namelen, traverse_symlink);
1365 if (entry != NULL) return entry;
1366 }
1367 /* Have to search by major and minor: slow */
1368 if ( (major == 0) && (minor == 0) ) return NULL;
1369 return _devfs_find_by_dev (root_entry, major, minor, type);
1370 } /* End Function _devfs_find_entry */
1371
get_devfs_entry_from_vfs_inode(struct inode * inode)1372 static struct devfs_entry *get_devfs_entry_from_vfs_inode (struct inode *inode)
1373 {
1374 if (inode == NULL) return NULL;
1375 VERIFY_ENTRY ( (struct devfs_entry *) inode->u.generic_ip );
1376 return inode->u.generic_ip;
1377 } /* End Function get_devfs_entry_from_vfs_inode */
1378
1379
1380 /**
1381 * free_dentry - Free the dentry for a device entry and invalidate inode.
1382 * @de: The entry.
1383 *
1384 * This must only be called after the entry has been unhooked from it's
1385 * parent directory.
1386 */
1387
free_dentry(struct devfs_entry * de)1388 static void free_dentry (struct devfs_entry *de)
1389 {
1390 struct dentry *dentry = de->inode.dentry;
1391
1392 if (!dentry) return;
1393 spin_lock (&dcache_lock);
1394 dget_locked (dentry);
1395 spin_unlock (&dcache_lock);
1396 /* Forcefully remove the inode */
1397 if (dentry->d_inode != NULL) dentry->d_inode->i_nlink = 0;
1398 d_drop (dentry);
1399 dput (dentry);
1400 } /* End Function free_dentry */
1401
1402
1403 /**
1404 * is_devfsd_or_child - Test if the current process is devfsd or one of its children.
1405 * @fs_info: The filesystem information.
1406 *
1407 * Returns %TRUE if devfsd or child, else %FALSE.
1408 */
1409
is_devfsd_or_child(struct fs_info * fs_info)1410 static int is_devfsd_or_child (struct fs_info *fs_info)
1411 {
1412 struct task_struct *p;
1413
1414 if (current == fs_info->devfsd_task) return (TRUE);
1415 if (current->pgrp == fs_info->devfsd_pgrp) return (TRUE);
1416 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,1)
1417 for (p = current->p_opptr; p != &init_task; p = p->p_opptr)
1418 {
1419 if (p == fs_info->devfsd_task) return (TRUE);
1420 }
1421 #endif
1422 return (FALSE);
1423 } /* End Function is_devfsd_or_child */
1424
1425
1426 /**
1427 * devfsd_queue_empty - Test if devfsd has work pending in its event queue.
1428 * @fs_info: The filesystem information.
1429 *
1430 * Returns %TRUE if the queue is empty, else %FALSE.
1431 */
1432
devfsd_queue_empty(struct fs_info * fs_info)1433 static inline int devfsd_queue_empty (struct fs_info *fs_info)
1434 {
1435 return (fs_info->devfsd_last_event) ? FALSE : TRUE;
1436 } /* End Function devfsd_queue_empty */
1437
1438
1439 /**
1440 * wait_for_devfsd_finished - Wait for devfsd to finish processing its event queue.
1441 * @fs_info: The filesystem information.
1442 *
1443 * Returns %TRUE if no more waiting will be required, else %FALSE.
1444 */
1445
wait_for_devfsd_finished(struct fs_info * fs_info)1446 static int wait_for_devfsd_finished (struct fs_info *fs_info)
1447 {
1448 DECLARE_WAITQUEUE (wait, current);
1449
1450 if (fs_info->devfsd_task == NULL) return (TRUE);
1451 if (devfsd_queue_empty (fs_info) && fs_info->devfsd_sleeping) return TRUE;
1452 if ( is_devfsd_or_child (fs_info) ) return (FALSE);
1453 set_current_state (TASK_UNINTERRUPTIBLE);
1454 add_wait_queue (&fs_info->revalidate_wait_queue, &wait);
1455 if (!devfsd_queue_empty (fs_info) || !fs_info->devfsd_sleeping)
1456 if (fs_info->devfsd_task) schedule ();
1457 remove_wait_queue (&fs_info->revalidate_wait_queue, &wait);
1458 __set_current_state (TASK_RUNNING);
1459 return (TRUE);
1460 } /* End Function wait_for_devfsd_finished */
1461
1462
1463 /**
1464 * devfsd_notify_de - Notify the devfsd daemon of a change.
1465 * @de: The devfs entry that has changed. This and all parent entries will
1466 * have their reference counts incremented if the event was queued.
1467 * @type: The type of change.
1468 * @mode: The mode of the entry.
1469 * @uid: The user ID.
1470 * @gid: The group ID.
1471 * @fs_info: The filesystem info.
1472 *
1473 * Returns %TRUE if an event was queued and devfsd woken up, else %FALSE.
1474 */
1475
devfsd_notify_de(struct devfs_entry * de,unsigned short type,umode_t mode,uid_t uid,gid_t gid,struct fs_info * fs_info,int atomic)1476 static int devfsd_notify_de (struct devfs_entry *de,
1477 unsigned short type, umode_t mode,
1478 uid_t uid, gid_t gid, struct fs_info *fs_info,
1479 int atomic)
1480 {
1481 struct devfsd_buf_entry *entry;
1482 struct devfs_entry *curr;
1483
1484 if ( !( fs_info->devfsd_event_mask & (1 << type) ) ) return (FALSE);
1485 if ( ( entry = kmem_cache_alloc (devfsd_buf_cache,
1486 atomic ? SLAB_ATOMIC : SLAB_KERNEL) )
1487 == NULL )
1488 {
1489 atomic_inc (&fs_info->devfsd_overrun_count);
1490 return (FALSE);
1491 }
1492 for (curr = de; curr != NULL; curr = curr->parent) devfs_get (curr);
1493 entry->de = de;
1494 entry->type = type;
1495 entry->mode = mode;
1496 entry->uid = uid;
1497 entry->gid = gid;
1498 entry->next = NULL;
1499 spin_lock (&fs_info->devfsd_buffer_lock);
1500 if (!fs_info->devfsd_first_event) fs_info->devfsd_first_event = entry;
1501 if (fs_info->devfsd_last_event) fs_info->devfsd_last_event->next = entry;
1502 fs_info->devfsd_last_event = entry;
1503 spin_unlock (&fs_info->devfsd_buffer_lock);
1504 wake_up_interruptible (&fs_info->devfsd_wait_queue);
1505 return (TRUE);
1506 } /* End Function devfsd_notify_de */
1507
1508
1509 /**
1510 * devfsd_notify - Notify the devfsd daemon of a change.
1511 * @de: The devfs entry that has changed.
1512 * @type: The type of change event.
1513 * @wait: If TRUE, the function waits for the daemon to finish processing
1514 * the event.
1515 */
1516
devfsd_notify(struct devfs_entry * de,unsigned short type,int wait)1517 static void devfsd_notify (struct devfs_entry *de,unsigned short type,int wait)
1518 {
1519 if (devfsd_notify_de (de, type, de->mode, current->euid,
1520 current->egid, &fs_info, 0) && wait)
1521 wait_for_devfsd_finished (&fs_info);
1522 } /* End Function devfsd_notify */
1523
1524
1525 /**
1526 * devfs_register - Register a device entry.
1527 * @dir: The handle to the parent devfs directory entry. If this is %NULL the
1528 * new name is relative to the root of the devfs.
1529 * @name: The name of the entry.
1530 * @flags: A set of bitwise-ORed flags (DEVFS_FL_*).
1531 * @major: The major number. Not needed for regular files.
1532 * @minor: The minor number. Not needed for regular files.
1533 * @mode: The default file mode.
1534 * @ops: The &file_operations or &block_device_operations structure.
1535 * This must not be externally deallocated.
1536 * @info: An arbitrary pointer which will be written to the @private_data
1537 * field of the &file structure passed to the device driver. You can set
1538 * this to whatever you like, and change it once the file is opened (the next
1539 * file opened will not see this change).
1540 *
1541 * Returns a handle which may later be used in a call to devfs_unregister().
1542 * On failure %NULL is returned.
1543 */
1544
devfs_register(devfs_handle_t dir,const char * name,unsigned int flags,unsigned int major,unsigned int minor,umode_t mode,void * ops,void * info)1545 devfs_handle_t devfs_register (devfs_handle_t dir, const char *name,
1546 unsigned int flags,
1547 unsigned int major, unsigned int minor,
1548 umode_t mode, void *ops, void *info)
1549 {
1550 char devtype = S_ISCHR (mode) ? DEVFS_SPECIAL_CHR : DEVFS_SPECIAL_BLK;
1551 int err;
1552 kdev_t devnum = NODEV;
1553 struct devfs_entry *de;
1554
1555 if (name == NULL)
1556 {
1557 PRINTK ("(): NULL name pointer\n");
1558 return NULL;
1559 }
1560 if (ops == NULL)
1561 {
1562 if ( S_ISBLK (mode) ) ops = (void *) get_blkfops (major);
1563 if (ops == NULL)
1564 {
1565 PRINTK ("(%s): NULL ops pointer\n", name);
1566 return NULL;
1567 }
1568 PRINTK ("(%s): NULL ops, got %p from major table\n", name, ops);
1569 }
1570 if ( S_ISDIR (mode) )
1571 {
1572 PRINTK ("(%s): creating directories is not allowed\n", name);
1573 return NULL;
1574 }
1575 if ( S_ISLNK (mode) )
1576 {
1577 PRINTK ("(%s): creating symlinks is not allowed\n", name);
1578 return NULL;
1579 }
1580 if ( ( S_ISCHR (mode) || S_ISBLK (mode) ) &&
1581 (flags & DEVFS_FL_AUTO_DEVNUM) )
1582 {
1583 if ( kdev_none ( devnum = devfs_alloc_devnum (devtype) ) )
1584 {
1585 PRINTK ("(%s): exhausted %s device numbers\n",
1586 name, S_ISCHR (mode) ? "char" : "block");
1587 return NULL;
1588 }
1589 major = major (devnum);
1590 minor = minor (devnum);
1591 }
1592 if ( ( de = _devfs_prepare_leaf (&dir, name, mode) ) == NULL )
1593 {
1594 PRINTK ("(%s): could not prepare leaf\n", name);
1595 if ( !kdev_none (devnum) ) devfs_dealloc_devnum (devtype, devnum);
1596 return NULL;
1597 }
1598 if ( S_ISCHR (mode) || S_ISBLK (mode) )
1599 {
1600 de->u.fcb.u.device.major = major;
1601 de->u.fcb.u.device.minor = minor;
1602 de->u.fcb.autogen = kdev_none (devnum) ? FALSE : TRUE;
1603 }
1604 else if ( !S_ISREG (mode) )
1605 {
1606 PRINTK ("(%s): illegal mode: %x\n", name, mode);
1607 devfs_put (de);
1608 devfs_put (dir);
1609 return (NULL);
1610 }
1611 de->info = info;
1612 if (flags & DEVFS_FL_CURRENT_OWNER)
1613 {
1614 de->inode.uid = current->uid;
1615 de->inode.gid = current->gid;
1616 }
1617 else
1618 {
1619 de->inode.uid = 0;
1620 de->inode.gid = 0;
1621 }
1622 de->u.fcb.ops = ops;
1623 de->u.fcb.auto_owner = (flags & DEVFS_FL_AUTO_OWNER) ? TRUE : FALSE;
1624 de->u.fcb.aopen_notify = (flags & DEVFS_FL_AOPEN_NOTIFY) ? TRUE : FALSE;
1625 de->hide = (flags & DEVFS_FL_HIDE) ? TRUE : FALSE;
1626 if (flags & DEVFS_FL_REMOVABLE) de->u.fcb.removable = TRUE;
1627 if ( ( err = _devfs_append_entry (dir, de, de->u.fcb.removable, NULL) )
1628 != 0 )
1629 {
1630 PRINTK ("(%s): could not append to parent, err: %d\n", name, err);
1631 devfs_put (dir);
1632 if ( !kdev_none (devnum) ) devfs_dealloc_devnum (devtype, devnum);
1633 return NULL;
1634 }
1635 DPRINTK (DEBUG_REGISTER, "(%s): de: %p dir: %p \"%s\" pp: %p\n",
1636 name, de, dir, dir->name, dir->parent);
1637 devfsd_notify (de, DEVFSD_NOTIFY_REGISTERED, flags & DEVFS_FL_WAIT);
1638 devfs_put (dir);
1639 return de;
1640 } /* End Function devfs_register */
1641
1642
1643 /**
1644 * _devfs_unhook - Unhook a device entry from its parents list
1645 * @de: The entry to unhook.
1646 *
1647 * Returns %TRUE if the entry was unhooked, else %FALSE if it was
1648 * previously unhooked.
1649 * The caller must have a write lock on the parent directory.
1650 */
1651
_devfs_unhook(struct devfs_entry * de)1652 static int _devfs_unhook (struct devfs_entry *de)
1653 {
1654 struct devfs_entry *parent;
1655
1656 if ( !de || (de->prev == de) ) return FALSE;
1657 parent = de->parent;
1658 if (de->prev == NULL) parent->u.dir.first = de->next;
1659 else de->prev->next = de->next;
1660 if (de->next == NULL) parent->u.dir.last = de->prev;
1661 else de->next->prev = de->prev;
1662 de->prev = de; /* Indicate we're unhooked */
1663 de->next = NULL; /* Force early termination for <devfs_readdir> */
1664 if ( ( S_ISREG (de->mode) || S_ISCHR (de->mode) || S_ISBLK (de->mode) ) &&
1665 de->u.fcb.removable )
1666 --parent->u.dir.num_removable;
1667 return TRUE;
1668 } /* End Function _devfs_unhook */
1669
1670
1671 /**
1672 * _devfs_unregister - Unregister a device entry from it's parent.
1673 * @dir: The parent directory.
1674 * @de: The entry to unregister.
1675 *
1676 * The caller must have a write lock on the parent directory, which is
1677 * unlocked by this function.
1678 */
1679
_devfs_unregister(struct devfs_entry * dir,struct devfs_entry * de)1680 static void _devfs_unregister (struct devfs_entry *dir, struct devfs_entry *de)
1681 {
1682 int unhooked = _devfs_unhook (de);
1683
1684 write_unlock (&dir->u.dir.lock);
1685 if (!unhooked) return;
1686 devfs_get (dir);
1687 devfs_unregister (de->slave); /* Let it handle the locking */
1688 devfsd_notify (de, DEVFSD_NOTIFY_UNREGISTERED, 0);
1689 free_dentry (de);
1690 devfs_put (dir);
1691 if ( !S_ISDIR (de->mode) ) return;
1692 while (TRUE) /* Recursively unregister: this is a stack chomper */
1693 {
1694 struct devfs_entry *child;
1695
1696 write_lock (&de->u.dir.lock);
1697 de->u.dir.no_more_additions = TRUE;
1698 child = de->u.dir.first;
1699 VERIFY_ENTRY (child);
1700 _devfs_unregister (de, child);
1701 if (!child) break;
1702 DPRINTK (DEBUG_UNREGISTER, "(%s): child: %p refcount: %d\n",
1703 child->name, child, atomic_read (&child->refcount) );
1704 devfs_put (child);
1705 }
1706 } /* End Function _devfs_unregister */
1707
1708
1709 /**
1710 * devfs_unregister - Unregister a device entry.
1711 * @de: A handle previously created by devfs_register() or returned from
1712 * devfs_get_handle(). If this is %NULL the routine does nothing.
1713 */
1714
devfs_unregister(devfs_handle_t de)1715 void devfs_unregister (devfs_handle_t de)
1716 {
1717 VERIFY_ENTRY (de);
1718 if ( (de == NULL) || (de->parent == NULL) ) return;
1719 DPRINTK (DEBUG_UNREGISTER, "(%s): de: %p refcount: %d\n",
1720 de->name, de, atomic_read (&de->refcount) );
1721 write_lock (&de->parent->u.dir.lock);
1722 _devfs_unregister (de->parent, de);
1723 devfs_put (de);
1724 } /* End Function devfs_unregister */
1725
devfs_do_symlink(devfs_handle_t dir,const char * name,unsigned int flags,const char * link,devfs_handle_t * handle,void * info)1726 static int devfs_do_symlink (devfs_handle_t dir, const char *name,
1727 unsigned int flags, const char *link,
1728 devfs_handle_t *handle, void *info)
1729 {
1730 int err;
1731 unsigned int linklength;
1732 char *newlink;
1733 struct devfs_entry *de;
1734
1735 if (handle != NULL) *handle = NULL;
1736 if (name == NULL)
1737 {
1738 PRINTK ("(): NULL name pointer\n");
1739 return -EINVAL;
1740 }
1741 if (link == NULL)
1742 {
1743 PRINTK ("(%s): NULL link pointer\n", name);
1744 return -EINVAL;
1745 }
1746 linklength = strlen (link);
1747 if ( ( newlink = kmalloc (linklength + 1, GFP_KERNEL) ) == NULL )
1748 return -ENOMEM;
1749 memcpy (newlink, link, linklength);
1750 newlink[linklength] = '\0';
1751 if ( ( de = _devfs_prepare_leaf (&dir, name, S_IFLNK | S_IRUGO | S_IXUGO) )
1752 == NULL )
1753 {
1754 PRINTK ("(%s): could not prepare leaf\n", name);
1755 kfree (newlink);
1756 return -ENOTDIR;
1757 }
1758 de->info = info;
1759 de->hide = (flags & DEVFS_FL_HIDE) ? TRUE : FALSE;
1760 de->u.symlink.linkname = newlink;
1761 de->u.symlink.length = linklength;
1762 if ( ( err = _devfs_append_entry (dir, de, FALSE, NULL) ) != 0 )
1763 {
1764 PRINTK ("(%s): could not append to parent, err: %d\n", name, err);
1765 devfs_put (dir);
1766 return err;
1767 }
1768 devfs_put (dir);
1769 #ifdef CONFIG_DEVFS_DEBUG
1770 spin_lock (&stat_lock);
1771 stat_num_bytes += linklength + 1;
1772 spin_unlock (&stat_lock);
1773 #endif
1774 if (handle != NULL) *handle = de;
1775 return 0;
1776 } /* End Function devfs_do_symlink */
1777
1778
1779 /**
1780 * devfs_mk_symlink Create a symbolic link in the devfs namespace.
1781 * @dir: The handle to the parent devfs directory entry. If this is %NULL the
1782 * new name is relative to the root of the devfs.
1783 * @name: The name of the entry.
1784 * @flags: A set of bitwise-ORed flags (DEVFS_FL_*).
1785 * @link: The destination name.
1786 * @handle: The handle to the symlink entry is written here. This may be %NULL.
1787 * @info: An arbitrary pointer which will be associated with the entry.
1788 *
1789 * Returns 0 on success, else a negative error code is returned.
1790 */
1791
devfs_mk_symlink(devfs_handle_t dir,const char * name,unsigned int flags,const char * link,devfs_handle_t * handle,void * info)1792 int devfs_mk_symlink (devfs_handle_t dir, const char *name, unsigned int flags,
1793 const char *link, devfs_handle_t *handle, void *info)
1794 {
1795 int err;
1796 devfs_handle_t de;
1797
1798 if (handle != NULL) *handle = NULL;
1799 DPRINTK (DEBUG_REGISTER, "(%s)\n", name);
1800 err = devfs_do_symlink (dir, name, flags, link, &de, info);
1801 if (err) return err;
1802 if (handle == NULL) de->vfs_deletable = TRUE;
1803 else *handle = de;
1804 devfsd_notify (de, DEVFSD_NOTIFY_REGISTERED, flags & DEVFS_FL_WAIT);
1805 return 0;
1806 } /* End Function devfs_mk_symlink */
1807
1808
1809 /**
1810 * devfs_mk_dir - Create a directory in the devfs namespace.
1811 * @dir: The handle to the parent devfs directory entry. If this is %NULL the
1812 * new name is relative to the root of the devfs.
1813 * @name: The name of the entry.
1814 * @info: An arbitrary pointer which will be associated with the entry.
1815 *
1816 * Use of this function is optional. The devfs_register() function
1817 * will automatically create intermediate directories as needed. This function
1818 * is provided for efficiency reasons, as it provides a handle to a directory.
1819 * Returns a handle which may later be used in a call to devfs_unregister().
1820 * On failure %NULL is returned.
1821 */
1822
devfs_mk_dir(devfs_handle_t dir,const char * name,void * info)1823 devfs_handle_t devfs_mk_dir (devfs_handle_t dir, const char *name, void *info)
1824 {
1825 int err;
1826 struct devfs_entry *de, *old;
1827
1828 if (name == NULL)
1829 {
1830 PRINTK ("(): NULL name pointer\n");
1831 return NULL;
1832 }
1833 if ( ( de = _devfs_prepare_leaf (&dir, name, MODE_DIR) ) == NULL )
1834 {
1835 PRINTK ("(%s): could not prepare leaf\n", name);
1836 return NULL;
1837 }
1838 de->info = info;
1839 if ( ( err = _devfs_append_entry (dir, de, FALSE, &old) ) != 0 )
1840 {
1841 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,1)
1842 if ( old && S_ISDIR (old->mode) )
1843 {
1844 PRINTK ("(%s): using old entry in dir: %p \"%s\"\n",
1845 name, dir, dir->name);
1846 old->vfs_deletable = FALSE;
1847 devfs_put (dir);
1848 return old;
1849 }
1850 #endif
1851 PRINTK ("(%s): could not append to dir: %p \"%s\", err: %d\n",
1852 name, dir, dir->name, err);
1853 devfs_put (old);
1854 devfs_put (dir);
1855 return NULL;
1856 }
1857 DPRINTK (DEBUG_REGISTER, "(%s): de: %p dir: %p \"%s\"\n",
1858 name, de, dir, dir->name);
1859 devfsd_notify (de, DEVFSD_NOTIFY_REGISTERED, 0);
1860 devfs_put (dir);
1861 return de;
1862 } /* End Function devfs_mk_dir */
1863
1864
1865 /**
1866 * devfs_get_handle - Find the handle of a devfs entry.
1867 * @dir: The handle to the parent devfs directory entry. If this is %NULL the
1868 * name is relative to the root of the devfs.
1869 * @name: The name of the entry.
1870 * @major: The major number. This is used if @name is %NULL.
1871 * @minor: The minor number. This is used if @name is %NULL.
1872 * @type: The type of special file to search for. This may be either
1873 * %DEVFS_SPECIAL_CHR or %DEVFS_SPECIAL_BLK.
1874 * @traverse_symlinks: If %TRUE then symlink entries in the devfs namespace are
1875 * traversed. Symlinks pointing out of the devfs namespace will cause a
1876 * failure. Symlink traversal consumes stack space.
1877 *
1878 * Returns a handle which may later be used in a call to
1879 * devfs_unregister(), devfs_get_flags(), or devfs_set_flags(). A
1880 * subsequent devfs_put() is required to decrement the refcount.
1881 * On failure %NULL is returned.
1882 */
1883
devfs_get_handle(devfs_handle_t dir,const char * name,unsigned int major,unsigned int minor,char type,int traverse_symlinks)1884 devfs_handle_t devfs_get_handle (devfs_handle_t dir, const char *name,
1885 unsigned int major, unsigned int minor,
1886 char type, int traverse_symlinks)
1887 {
1888 if ( (name != NULL) && (name[0] == '\0') ) name = NULL;
1889 return _devfs_find_entry (dir, name, major, minor, type,traverse_symlinks);
1890 } /* End Function devfs_get_handle */
1891
1892
1893 /* Compatibility function. Will be removed in sometime in 2.5 */
1894
devfs_find_handle(devfs_handle_t dir,const char * name,unsigned int major,unsigned int minor,char type,int traverse_symlinks)1895 devfs_handle_t devfs_find_handle (devfs_handle_t dir, const char *name,
1896 unsigned int major, unsigned int minor,
1897 char type, int traverse_symlinks)
1898 {
1899 devfs_handle_t de;
1900
1901 de = devfs_get_handle (dir, name, major, minor, type, traverse_symlinks);
1902 devfs_put (de);
1903 return de;
1904 } /* End Function devfs_find_handle */
1905
1906
1907 /**
1908 * devfs_get_flags - Get the flags for a devfs entry.
1909 * @de: The handle to the device entry.
1910 * @flags: The flags are written here.
1911 *
1912 * Returns 0 on success, else a negative error code.
1913 */
1914
devfs_get_flags(devfs_handle_t de,unsigned int * flags)1915 int devfs_get_flags (devfs_handle_t de, unsigned int *flags)
1916 {
1917 unsigned int fl = 0;
1918
1919 if (de == NULL) return -EINVAL;
1920 VERIFY_ENTRY (de);
1921 if (de->hide) fl |= DEVFS_FL_HIDE;
1922 if ( S_ISCHR (de->mode) || S_ISBLK (de->mode) || S_ISREG (de->mode) )
1923 {
1924 if (de->u.fcb.auto_owner) fl |= DEVFS_FL_AUTO_OWNER;
1925 if (de->u.fcb.aopen_notify) fl |= DEVFS_FL_AOPEN_NOTIFY;
1926 if (de->u.fcb.removable) fl |= DEVFS_FL_REMOVABLE;
1927 }
1928 *flags = fl;
1929 return 0;
1930 } /* End Function devfs_get_flags */
1931
1932
1933 /*
1934 * devfs_set_flags - Set the flags for a devfs entry.
1935 * @de: The handle to the device entry.
1936 * @flags: The flags to set. Unset flags are cleared.
1937 *
1938 * Returns 0 on success, else a negative error code.
1939 */
1940
devfs_set_flags(devfs_handle_t de,unsigned int flags)1941 int devfs_set_flags (devfs_handle_t de, unsigned int flags)
1942 {
1943 if (de == NULL) return -EINVAL;
1944 VERIFY_ENTRY (de);
1945 DPRINTK (DEBUG_SET_FLAGS, "(%s): flags: %x\n", de->name, flags);
1946 de->hide = (flags & DEVFS_FL_HIDE) ? TRUE : FALSE;
1947 if ( S_ISCHR (de->mode) || S_ISBLK (de->mode) || S_ISREG (de->mode) )
1948 {
1949 de->u.fcb.auto_owner = (flags & DEVFS_FL_AUTO_OWNER) ? TRUE : FALSE;
1950 de->u.fcb.aopen_notify = (flags & DEVFS_FL_AOPEN_NOTIFY) ? TRUE:FALSE;
1951 }
1952 return 0;
1953 } /* End Function devfs_set_flags */
1954
1955
1956 /**
1957 * devfs_get_maj_min - Get the major and minor numbers for a devfs entry.
1958 * @de: The handle to the device entry.
1959 * @major: The major number is written here. This may be %NULL.
1960 * @minor: The minor number is written here. This may be %NULL.
1961 *
1962 * Returns 0 on success, else a negative error code.
1963 */
1964
devfs_get_maj_min(devfs_handle_t de,unsigned int * major,unsigned int * minor)1965 int devfs_get_maj_min (devfs_handle_t de, unsigned int *major,
1966 unsigned int *minor)
1967 {
1968 if (de == NULL) return -EINVAL;
1969 VERIFY_ENTRY (de);
1970 if ( S_ISDIR (de->mode) ) return -EISDIR;
1971 if ( !S_ISCHR (de->mode) && !S_ISBLK (de->mode) ) return -EINVAL;
1972 if (major != NULL) *major = de->u.fcb.u.device.major;
1973 if (minor != NULL) *minor = de->u.fcb.u.device.minor;
1974 return 0;
1975 } /* End Function devfs_get_maj_min */
1976
1977
1978 /**
1979 * devfs_get_handle_from_inode - Get the devfs handle for a VFS inode.
1980 * @inode: The VFS inode.
1981 *
1982 * Returns the devfs handle on success, else %NULL.
1983 */
1984
devfs_get_handle_from_inode(struct inode * inode)1985 devfs_handle_t devfs_get_handle_from_inode (struct inode *inode)
1986 {
1987 if (!inode || !inode->i_sb) return NULL;
1988 if (inode->i_sb->s_magic != DEVFS_SUPER_MAGIC) return NULL;
1989 return get_devfs_entry_from_vfs_inode (inode);
1990 } /* End Function devfs_get_handle_from_inode */
1991
1992
1993 /**
1994 * devfs_generate_path - Generate a pathname for an entry, relative to the devfs root.
1995 * @de: The devfs entry.
1996 * @path: The buffer to write the pathname to. The pathname and '\0'
1997 * terminator will be written at the end of the buffer.
1998 * @buflen: The length of the buffer.
1999 *
2000 * Returns the offset in the buffer where the pathname starts on success,
2001 * else a negative error code.
2002 */
2003
devfs_generate_path(devfs_handle_t de,char * path,int buflen)2004 int devfs_generate_path (devfs_handle_t de, char *path, int buflen)
2005 {
2006 int pos;
2007 #define NAMEOF(de) ( (de)->mode ? (de)->name : (de)->u.name )
2008
2009 if (de == NULL) return -EINVAL;
2010 VERIFY_ENTRY (de);
2011 if (de->namelen >= buflen) return -ENAMETOOLONG; /* Must be first */
2012 path[buflen - 1] = '\0';
2013 if (de->parent == NULL) return buflen - 1; /* Don't prepend root */
2014 pos = buflen - de->namelen - 1;
2015 memcpy (path + pos, NAMEOF (de), de->namelen);
2016 for (de = de->parent; de->parent != NULL; de = de->parent)
2017 {
2018 if (pos - de->namelen - 1 < 0) return -ENAMETOOLONG;
2019 path[--pos] = '/';
2020 pos -= de->namelen;
2021 memcpy (path + pos, NAMEOF (de), de->namelen);
2022 }
2023 return pos;
2024 } /* End Function devfs_generate_path */
2025
2026
2027 /**
2028 * devfs_get_ops - Get the device operations for a devfs entry.
2029 * @de: The handle to the device entry.
2030 *
2031 * Returns a pointer to the device operations on success, else NULL.
2032 * The use count for the module owning the operations will be incremented.
2033 */
2034
devfs_get_ops(devfs_handle_t de)2035 void *devfs_get_ops (devfs_handle_t de)
2036 {
2037 struct module *owner;
2038
2039 if (de == NULL) return NULL;
2040 VERIFY_ENTRY (de);
2041 if ( !S_ISCHR (de->mode) && !S_ISBLK (de->mode) && !S_ISREG (de->mode) )
2042 return NULL;
2043 if (de->u.fcb.ops == NULL) return NULL;
2044 read_lock (&de->parent->u.dir.lock); /* Prevent module from unloading */
2045 if (de->next == de) owner = NULL; /* Ops pointer is already stale */
2046 else if ( S_ISCHR (de->mode) || S_ISREG (de->mode) )
2047 owner = ( (struct file_operations *) de->u.fcb.ops )->owner;
2048 else owner = ( (struct block_device_operations *) de->u.fcb.ops )->owner;
2049 if ( (de->next == de) || !try_inc_mod_count (owner) )
2050 { /* Entry is already unhooked or module is unloading */
2051 read_unlock (&de->parent->u.dir.lock);
2052 return NULL;
2053 }
2054 read_unlock (&de->parent->u.dir.lock); /* Module can continue unloading*/
2055 return de->u.fcb.ops;
2056 } /* End Function devfs_get_ops */
2057
2058
2059 /**
2060 * devfs_put_ops - Put the device operations for a devfs entry.
2061 * @de: The handle to the device entry.
2062 *
2063 * The use count for the module owning the operations will be decremented.
2064 */
2065
devfs_put_ops(devfs_handle_t de)2066 void devfs_put_ops (devfs_handle_t de)
2067 {
2068 struct module *owner;
2069
2070 if (de == NULL) return;
2071 VERIFY_ENTRY (de);
2072 if ( !S_ISCHR (de->mode) && !S_ISBLK (de->mode) && !S_ISREG (de->mode) )
2073 return;
2074 if (de->u.fcb.ops == NULL) return;
2075 if ( S_ISCHR (de->mode) || S_ISREG (de->mode) )
2076 owner = ( (struct file_operations *) de->u.fcb.ops )->owner;
2077 else owner = ( (struct block_device_operations *) de->u.fcb.ops )->owner;
2078 if (owner) __MOD_DEC_USE_COUNT (owner);
2079 } /* End Function devfs_put_ops */
2080
2081
2082 /**
2083 * devfs_set_file_size - Set the file size for a devfs regular file.
2084 * @de: The handle to the device entry.
2085 * @size: The new file size.
2086 *
2087 * Returns 0 on success, else a negative error code.
2088 */
2089
devfs_set_file_size(devfs_handle_t de,unsigned long size)2090 int devfs_set_file_size (devfs_handle_t de, unsigned long size)
2091 {
2092 if (de == NULL) return -EINVAL;
2093 VERIFY_ENTRY (de);
2094 if ( !S_ISREG (de->mode) ) return -EINVAL;
2095 if (de->u.fcb.u.file.size == size) return 0;
2096 de->u.fcb.u.file.size = size;
2097 if (de->inode.dentry == NULL) return 0;
2098 if (de->inode.dentry->d_inode == NULL) return 0;
2099 de->inode.dentry->d_inode->i_size = size;
2100 return 0;
2101 } /* End Function devfs_set_file_size */
2102
2103
2104 /**
2105 * devfs_get_info - Get the info pointer written to private_data of @de upon open.
2106 * @de: The handle to the device entry.
2107 *
2108 * Returns the info pointer.
2109 */
devfs_get_info(devfs_handle_t de)2110 void *devfs_get_info (devfs_handle_t de)
2111 {
2112 if (de == NULL) return NULL;
2113 VERIFY_ENTRY (de);
2114 return de->info;
2115 } /* End Function devfs_get_info */
2116
2117
2118 /**
2119 * devfs_set_info - Set the info pointer written to private_data upon open.
2120 * @de: The handle to the device entry.
2121 * @info: pointer to the data
2122 *
2123 * Returns 0 on success, else a negative error code.
2124 */
devfs_set_info(devfs_handle_t de,void * info)2125 int devfs_set_info (devfs_handle_t de, void *info)
2126 {
2127 if (de == NULL) return -EINVAL;
2128 VERIFY_ENTRY (de);
2129 de->info = info;
2130 return 0;
2131 } /* End Function devfs_set_info */
2132
2133
2134 /**
2135 * devfs_get_parent - Get the parent device entry.
2136 * @de: The handle to the device entry.
2137 *
2138 * Returns the parent device entry if it exists, else %NULL.
2139 */
devfs_get_parent(devfs_handle_t de)2140 devfs_handle_t devfs_get_parent (devfs_handle_t de)
2141 {
2142 if (de == NULL) return NULL;
2143 VERIFY_ENTRY (de);
2144 return de->parent;
2145 } /* End Function devfs_get_parent */
2146
2147
2148 /**
2149 * devfs_get_first_child - Get the first leaf node in a directory.
2150 * @de: The handle to the device entry.
2151 *
2152 * Returns the leaf node device entry if it exists, else %NULL.
2153 */
2154
devfs_get_first_child(devfs_handle_t de)2155 devfs_handle_t devfs_get_first_child (devfs_handle_t de)
2156 {
2157 if (de == NULL) return NULL;
2158 VERIFY_ENTRY (de);
2159 if ( !S_ISDIR (de->mode) ) return NULL;
2160 return de->u.dir.first;
2161 } /* End Function devfs_get_first_child */
2162
2163
2164 /**
2165 * devfs_get_next_sibling - Get the next sibling leaf node. for a device entry.
2166 * @de: The handle to the device entry.
2167 *
2168 * Returns the leaf node device entry if it exists, else %NULL.
2169 */
2170
devfs_get_next_sibling(devfs_handle_t de)2171 devfs_handle_t devfs_get_next_sibling (devfs_handle_t de)
2172 {
2173 if (de == NULL) return NULL;
2174 VERIFY_ENTRY (de);
2175 return de->next;
2176 } /* End Function devfs_get_next_sibling */
2177
2178
2179 /**
2180 * devfs_auto_unregister - Configure a devfs entry to be automatically unregistered.
2181 * @master: The master devfs entry. Only one slave may be registered.
2182 * @slave: The devfs entry which will be automatically unregistered when the
2183 * master entry is unregistered. It is illegal to call devfs_unregister()
2184 * on this entry.
2185 */
2186
devfs_auto_unregister(devfs_handle_t master,devfs_handle_t slave)2187 void devfs_auto_unregister (devfs_handle_t master, devfs_handle_t slave)
2188 {
2189 if (master == NULL) return;
2190 VERIFY_ENTRY (master);
2191 VERIFY_ENTRY (slave);
2192 if (master->slave != NULL)
2193 {
2194 /* Because of the dumbness of the layers above, ignore duplicates */
2195 if (master->slave == slave) return;
2196 PRINTK ("(%s): only one slave allowed\n", master->name);
2197 OOPS ("(): old slave: \"%s\" new slave: \"%s\"\n",
2198 master->slave->name, slave->name);
2199 }
2200 master->slave = slave;
2201 } /* End Function devfs_auto_unregister */
2202
2203
2204 /**
2205 * devfs_get_unregister_slave - Get the slave entry which will be automatically unregistered.
2206 * @master: The master devfs entry.
2207 *
2208 * Returns the slave which will be unregistered when @master is unregistered.
2209 */
2210
devfs_get_unregister_slave(devfs_handle_t master)2211 devfs_handle_t devfs_get_unregister_slave (devfs_handle_t master)
2212 {
2213 if (master == NULL) return NULL;
2214 VERIFY_ENTRY (master);
2215 return master->slave;
2216 } /* End Function devfs_get_unregister_slave */
2217
2218
2219 /**
2220 * devfs_get_name - Get the name for a device entry in its parent directory.
2221 * @de: The handle to the device entry.
2222 * @namelen: The length of the name is written here. This may be %NULL.
2223 *
2224 * Returns the name on success, else %NULL.
2225 */
2226
devfs_get_name(devfs_handle_t de,unsigned int * namelen)2227 const char *devfs_get_name (devfs_handle_t de, unsigned int *namelen)
2228 {
2229 if (de == NULL) return NULL;
2230 VERIFY_ENTRY (de);
2231 if (namelen != NULL) *namelen = de->namelen;
2232 return de->name;
2233 } /* End Function devfs_get_name */
2234
2235
2236 /**
2237 * devfs_register_chrdev - Optionally register a conventional character driver.
2238 * @major: The major number for the driver.
2239 * @name: The name of the driver (as seen in /proc/devices).
2240 * @fops: The &file_operations structure pointer.
2241 *
2242 * This function will register a character driver provided the "devfs=only"
2243 * option was not provided at boot time.
2244 * Returns 0 on success, else a negative error code on failure.
2245 */
2246
devfs_register_chrdev(unsigned int major,const char * name,struct file_operations * fops)2247 int devfs_register_chrdev (unsigned int major, const char *name,
2248 struct file_operations *fops)
2249 {
2250 if (boot_options & OPTION_ONLY) return 0;
2251 return register_chrdev (major, name, fops);
2252 } /* End Function devfs_register_chrdev */
2253
2254
2255 /**
2256 * devfs_register_blkdev - Optionally register a conventional block driver.
2257 * @major: The major number for the driver.
2258 * @name: The name of the driver (as seen in /proc/devices).
2259 * @bdops: The &block_device_operations structure pointer.
2260 *
2261 * This function will register a block driver provided the "devfs=only"
2262 * option was not provided at boot time.
2263 * Returns 0 on success, else a negative error code on failure.
2264 */
2265
devfs_register_blkdev(unsigned int major,const char * name,struct block_device_operations * bdops)2266 int devfs_register_blkdev (unsigned int major, const char *name,
2267 struct block_device_operations *bdops)
2268 {
2269 if (boot_options & OPTION_ONLY) return 0;
2270 return register_blkdev (major, name, bdops);
2271 } /* End Function devfs_register_blkdev */
2272
2273
2274 /**
2275 * devfs_unregister_chrdev - Optionally unregister a conventional character driver.
2276 * @major: The major number for the driver.
2277 * @name: The name of the driver (as seen in /proc/devices).
2278 *
2279 * This function will unregister a character driver provided the "devfs=only"
2280 * option was not provided at boot time.
2281 * Returns 0 on success, else a negative error code on failure.
2282 */
2283
devfs_unregister_chrdev(unsigned int major,const char * name)2284 int devfs_unregister_chrdev (unsigned int major, const char *name)
2285 {
2286 if (boot_options & OPTION_ONLY) return 0;
2287 return unregister_chrdev (major, name);
2288 } /* End Function devfs_unregister_chrdev */
2289
2290
2291 /**
2292 * devfs_unregister_blkdev - Optionally unregister a conventional block driver.
2293 * @major: The major number for the driver.
2294 * @name: The name of the driver (as seen in /proc/devices).
2295 *
2296 * This function will unregister a block driver provided the "devfs=only"
2297 * option was not provided at boot time.
2298 * Returns 0 on success, else a negative error code on failure.
2299 */
2300
devfs_unregister_blkdev(unsigned int major,const char * name)2301 int devfs_unregister_blkdev (unsigned int major, const char *name)
2302 {
2303 if (boot_options & OPTION_ONLY) return 0;
2304 return unregister_blkdev (major, name);
2305 } /* End Function devfs_unregister_blkdev */
2306
2307 /**
2308 * devfs_setup - Process kernel boot options.
2309 * @str: The boot options after the "devfs=".
2310 */
2311
devfs_setup(char * str)2312 static int __init devfs_setup (char *str)
2313 {
2314 static struct
2315 {
2316 char *name;
2317 unsigned int mask;
2318 unsigned int *opt;
2319 } devfs_options_tab[] __initdata =
2320 {
2321 #ifdef CONFIG_DEVFS_DEBUG
2322 {"dall", DEBUG_ALL, &devfs_debug_init},
2323 {"dmod", DEBUG_MODULE_LOAD, &devfs_debug_init},
2324 {"dreg", DEBUG_REGISTER, &devfs_debug_init},
2325 {"dunreg", DEBUG_UNREGISTER, &devfs_debug_init},
2326 {"dfree", DEBUG_FREE, &devfs_debug_init},
2327 {"diget", DEBUG_I_GET, &devfs_debug_init},
2328 {"dchange", DEBUG_SET_FLAGS, &devfs_debug_init},
2329 {"dsread", DEBUG_S_READ, &devfs_debug_init},
2330 {"dichange", DEBUG_I_CHANGE, &devfs_debug_init},
2331 {"dimknod", DEBUG_I_MKNOD, &devfs_debug_init},
2332 {"dilookup", DEBUG_I_LOOKUP, &devfs_debug_init},
2333 {"diunlink", DEBUG_I_UNLINK, &devfs_debug_init},
2334 #endif /* CONFIG_DEVFS_DEBUG */
2335 {"only", OPTION_ONLY, &boot_options},
2336 {"mount", OPTION_MOUNT, &boot_options},
2337 {NULL, 0, NULL}
2338 };
2339
2340 while ( (*str != '\0') && !isspace (*str) )
2341 {
2342 int i, found = 0, invert = 0;
2343
2344 if (strncmp (str, "no", 2) == 0)
2345 {
2346 invert = 1;
2347 str += 2;
2348 }
2349 for (i = 0; devfs_options_tab[i].name != NULL; i++)
2350 {
2351 int len = strlen (devfs_options_tab[i].name);
2352
2353 if (strncmp (str, devfs_options_tab[i].name, len) == 0)
2354 {
2355 if (invert)
2356 *devfs_options_tab[i].opt &= ~devfs_options_tab[i].mask;
2357 else
2358 *devfs_options_tab[i].opt |= devfs_options_tab[i].mask;
2359 str += len;
2360 found = 1;
2361 break;
2362 }
2363 }
2364 if (!found) return 0; /* No match */
2365 if (*str != ',') return 0; /* No more options */
2366 ++str;
2367 }
2368 return 1;
2369 } /* End Function devfs_setup */
2370
2371 __setup("devfs=", devfs_setup);
2372
2373 EXPORT_SYMBOL(devfs_put);
2374 EXPORT_SYMBOL(devfs_register);
2375 EXPORT_SYMBOL(devfs_unregister);
2376 EXPORT_SYMBOL(devfs_mk_symlink);
2377 EXPORT_SYMBOL(devfs_mk_dir);
2378 EXPORT_SYMBOL(devfs_get_handle);
2379 EXPORT_SYMBOL(devfs_find_handle);
2380 EXPORT_SYMBOL(devfs_get_flags);
2381 EXPORT_SYMBOL(devfs_set_flags);
2382 EXPORT_SYMBOL(devfs_get_maj_min);
2383 EXPORT_SYMBOL(devfs_get_handle_from_inode);
2384 EXPORT_SYMBOL(devfs_generate_path);
2385 EXPORT_SYMBOL(devfs_get_ops);
2386 EXPORT_SYMBOL(devfs_set_file_size);
2387 EXPORT_SYMBOL(devfs_get_info);
2388 EXPORT_SYMBOL(devfs_set_info);
2389 EXPORT_SYMBOL(devfs_get_parent);
2390 EXPORT_SYMBOL(devfs_get_first_child);
2391 EXPORT_SYMBOL(devfs_get_next_sibling);
2392 EXPORT_SYMBOL(devfs_auto_unregister);
2393 EXPORT_SYMBOL(devfs_get_unregister_slave);
2394 EXPORT_SYMBOL(devfs_get_name);
2395 EXPORT_SYMBOL(devfs_register_chrdev);
2396 EXPORT_SYMBOL(devfs_register_blkdev);
2397 EXPORT_SYMBOL(devfs_unregister_chrdev);
2398 EXPORT_SYMBOL(devfs_unregister_blkdev);
2399
2400
2401 /**
2402 * try_modload - Notify devfsd of an inode lookup by a non-devfsd process.
2403 * @parent: The parent devfs entry.
2404 * @fs_info: The filesystem info.
2405 * @name: The device name.
2406 * @namelen: The number of characters in @name.
2407 * @buf: A working area that will be used. This must not go out of scope
2408 * until devfsd is idle again.
2409 *
2410 * Returns 0 on success (event was queued), else a negative error code.
2411 */
2412
try_modload(struct devfs_entry * parent,struct fs_info * fs_info,const char * name,unsigned namelen,struct devfs_entry * buf)2413 static int try_modload (struct devfs_entry *parent, struct fs_info *fs_info,
2414 const char *name, unsigned namelen,
2415 struct devfs_entry *buf)
2416 {
2417 if ( !( fs_info->devfsd_event_mask & (1 << DEVFSD_NOTIFY_LOOKUP) ) )
2418 return -ENOENT;
2419 if ( is_devfsd_or_child (fs_info) ) return -ENOENT;
2420 memset (buf, 0, sizeof *buf);
2421 atomic_set (&buf->refcount, 1);
2422 buf->parent = parent;
2423 buf->namelen = namelen;
2424 buf->u.name = name;
2425 WRITE_ENTRY_MAGIC (buf, MAGIC_VALUE);
2426 if ( !devfsd_notify_de (buf, DEVFSD_NOTIFY_LOOKUP, 0,
2427 current->euid, current->egid, fs_info, 0) )
2428 return -ENOENT;
2429 /* Possible success: event has been queued */
2430 return 0;
2431 } /* End Function try_modload */
2432
2433
2434 /**
2435 * check_disc_changed - Check if a removable disc was changed.
2436 * @de: The device.
2437 *
2438 * Returns 1 if the media was changed, else 0.
2439 *
2440 * This function may block, and may indirectly cause the parent directory
2441 * contents to be changed due to partition re-reading.
2442 */
2443
check_disc_changed(struct devfs_entry * de)2444 static int check_disc_changed (struct devfs_entry *de)
2445 {
2446 int tmp;
2447 int retval = 0;
2448 kdev_t dev = mk_kdev (de->u.fcb.u.device.major, de->u.fcb.u.device.minor);
2449 struct block_device_operations *bdops;
2450 extern int warn_no_part;
2451
2452 if ( !S_ISBLK (de->mode) ) return 0;
2453 bdops = devfs_get_ops (de);
2454 if (!bdops) return 0;
2455 if (bdops->check_media_change == NULL) goto out;
2456 if ( !bdops->check_media_change (dev) ) goto out;
2457 retval = 1;
2458 printk (KERN_DEBUG "VFS: Disk change detected on device %s\n",
2459 kdevname (dev) );
2460 if ( invalidate_device (dev, 0) )
2461 printk (KERN_WARNING "VFS: busy inodes on changed media..\n");
2462 /* Ugly hack to disable messages about unable to read partition table */
2463 tmp = warn_no_part;
2464 warn_no_part = 0;
2465 if (bdops->revalidate) bdops->revalidate (dev);
2466 warn_no_part = tmp;
2467 out:
2468 devfs_put_ops (de);
2469 return retval;
2470 } /* End Function check_disc_changed */
2471
2472
2473 /**
2474 * scan_dir_for_removable - Scan a directory for removable media devices and check media.
2475 * @dir: The directory.
2476 *
2477 * This function may block, and may indirectly cause the directory
2478 * contents to be changed due to partition re-reading. The directory will
2479 * be locked for reading.
2480 */
2481
scan_dir_for_removable(struct devfs_entry * dir)2482 static void scan_dir_for_removable (struct devfs_entry *dir)
2483 {
2484 struct devfs_entry *de;
2485
2486 read_lock (&dir->u.dir.lock);
2487 if (dir->u.dir.num_removable < 1) de = NULL;
2488 else
2489 {
2490 for (de = dir->u.dir.first; de != NULL; de = de->next)
2491 {
2492 if (S_ISBLK (de->mode) && de->u.fcb.removable) break;
2493 }
2494 devfs_get (de);
2495 }
2496 read_unlock (&dir->u.dir.lock);
2497 if (de) check_disc_changed (de);
2498 devfs_put (de);
2499 } /* End Function scan_dir_for_removable */
2500
2501 /**
2502 * get_removable_partition - Get removable media partition.
2503 * @dir: The parent directory.
2504 * @name: The name of the entry.
2505 * @namelen: The number of characters in <<name>>.
2506 *
2507 * Returns 1 if the media was changed, else 0.
2508 *
2509 * This function may block, and may indirectly cause the directory
2510 * contents to be changed due to partition re-reading. The directory must
2511 * be locked for reading upon entry, and will be unlocked upon exit.
2512 */
2513
get_removable_partition(struct devfs_entry * dir,const char * name,unsigned int namelen)2514 static int get_removable_partition (struct devfs_entry *dir, const char *name,
2515 unsigned int namelen)
2516 {
2517 int retval;
2518 struct devfs_entry *de;
2519
2520 if (dir->u.dir.num_removable < 1)
2521 {
2522 read_unlock (&dir->u.dir.lock);
2523 return 0;
2524 }
2525 for (de = dir->u.dir.first; de != NULL; de = de->next)
2526 {
2527 if (!S_ISBLK (de->mode) || !de->u.fcb.removable) continue;
2528 if (strcmp (de->name, "disc") == 0) break;
2529 /* Support for names where the partition is appended to the disc name
2530 */
2531 if (de->namelen >= namelen) continue;
2532 if (strncmp (de->name, name, de->namelen) == 0) break;
2533 }
2534 devfs_get (de);
2535 read_unlock (&dir->u.dir.lock);
2536 retval = de ? check_disc_changed (de) : 0;
2537 devfs_put (de);
2538 return retval;
2539 } /* End Function get_removable_partition */
2540
2541
2542 /* Superblock operations follow */
2543
2544 static struct inode_operations devfs_iops;
2545 static struct inode_operations devfs_dir_iops;
2546 static struct file_operations devfs_fops;
2547 static struct file_operations devfs_dir_fops;
2548 static struct inode_operations devfs_symlink_iops;
2549
devfs_notify_change(struct dentry * dentry,struct iattr * iattr)2550 static int devfs_notify_change (struct dentry *dentry, struct iattr *iattr)
2551 {
2552 int retval;
2553 struct devfs_entry *de;
2554 struct inode *inode = dentry->d_inode;
2555 struct fs_info *fs_info = inode->i_sb->u.generic_sbp;
2556
2557 de = get_devfs_entry_from_vfs_inode (inode);
2558 if (de == NULL) return -ENODEV;
2559 retval = inode_change_ok (inode, iattr);
2560 if (retval != 0) return retval;
2561 retval = inode_setattr (inode, iattr);
2562 if (retval != 0) return retval;
2563 DPRINTK (DEBUG_I_CHANGE, "(%d): VFS inode: %p devfs_entry: %p\n",
2564 (int) inode->i_ino, inode, de);
2565 DPRINTK (DEBUG_I_CHANGE, "(): mode: 0%o uid: %d gid: %d\n",
2566 (int) inode->i_mode, (int) inode->i_uid, (int) inode->i_gid);
2567 /* Inode is not on hash chains, thus must save permissions here rather
2568 than in a write_inode() method */
2569 if ( ( !S_ISREG (inode->i_mode) && !S_ISCHR (inode->i_mode) &&
2570 !S_ISBLK (inode->i_mode) ) || !de->u.fcb.auto_owner )
2571 {
2572 de->mode = inode->i_mode;
2573 de->inode.uid = inode->i_uid;
2574 de->inode.gid = inode->i_gid;
2575 }
2576 de->inode.atime = inode->i_atime;
2577 de->inode.mtime = inode->i_mtime;
2578 de->inode.ctime = inode->i_ctime;
2579 if ( ( iattr->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID) ) &&
2580 !is_devfsd_or_child (fs_info) )
2581 devfsd_notify_de (de, DEVFSD_NOTIFY_CHANGE, inode->i_mode,
2582 inode->i_uid, inode->i_gid, fs_info, 0);
2583 return 0;
2584 } /* End Function devfs_notify_change */
2585
devfs_statfs(struct super_block * sb,struct statfs * buf)2586 static int devfs_statfs (struct super_block *sb, struct statfs *buf)
2587 {
2588 buf->f_type = DEVFS_SUPER_MAGIC;
2589 buf->f_bsize = FAKE_BLOCK_SIZE;
2590 buf->f_bfree = 0;
2591 buf->f_bavail = 0;
2592 buf->f_ffree = 0;
2593 buf->f_namelen = NAME_MAX;
2594 return 0;
2595 } /* End Function devfs_statfs */
2596
devfs_clear_inode(struct inode * inode)2597 static void devfs_clear_inode (struct inode *inode)
2598 {
2599 if ( S_ISBLK (inode->i_mode) ) bdput (inode->i_bdev);
2600 } /* End Function devfs_clear_inode */
2601
2602 static struct super_operations devfs_sops =
2603 {
2604 .put_inode = force_delete,
2605 .clear_inode = devfs_clear_inode,
2606 .statfs = devfs_statfs,
2607 };
2608
2609
2610 /**
2611 * _devfs_get_vfs_inode - Get a VFS inode.
2612 * @sb: The super block.
2613 * @de: The devfs inode.
2614 * @dentry: The dentry to register with the devfs inode.
2615 *
2616 * Returns the inode on success, else %NULL. An implicit devfs_get() is
2617 * performed if the inode is created.
2618 */
2619
_devfs_get_vfs_inode(struct super_block * sb,struct devfs_entry * de,struct dentry * dentry)2620 static struct inode *_devfs_get_vfs_inode (struct super_block *sb,
2621 struct devfs_entry *de,
2622 struct dentry *dentry)
2623 {
2624 int is_fcb = FALSE;
2625 struct inode *inode;
2626
2627 if (de->prev == de) return NULL; /* Quick check to see if unhooked */
2628 if ( ( inode = new_inode (sb) ) == NULL )
2629 {
2630 PRINTK ("(%s): new_inode() failed, de: %p\n", de->name, de);
2631 return NULL;
2632 }
2633 if (de->parent)
2634 {
2635 read_lock (&de->parent->u.dir.lock);
2636 if (de->prev != de) de->inode.dentry = dentry; /* Not unhooked */
2637 read_unlock (&de->parent->u.dir.lock);
2638 }
2639 else de->inode.dentry = dentry; /* Root: no locking needed */
2640 if (de->inode.dentry != dentry)
2641 { /* Must have been unhooked */
2642 iput (inode);
2643 return NULL;
2644 }
2645 inode->u.generic_ip = devfs_get (de);
2646 inode->i_ino = de->inode.ino;
2647 DPRINTK (DEBUG_I_GET, "(%d): VFS inode: %p devfs_entry: %p\n",
2648 (int) inode->i_ino, inode, de);
2649 inode->i_blocks = 0;
2650 inode->i_blksize = FAKE_BLOCK_SIZE;
2651 inode->i_op = &devfs_iops;
2652 inode->i_fop = &devfs_fops;
2653 inode->i_rdev = NODEV;
2654 if ( S_ISCHR (de->mode) )
2655 {
2656 inode->i_rdev = mk_kdev (de->u.fcb.u.device.major,
2657 de->u.fcb.u.device.minor);
2658 inode->i_cdev = cdget ( kdev_t_to_nr (inode->i_rdev) );
2659 is_fcb = TRUE;
2660 }
2661 else if ( S_ISBLK (de->mode) )
2662 {
2663 inode->i_rdev = mk_kdev (de->u.fcb.u.device.major,
2664 de->u.fcb.u.device.minor);
2665 if (bd_acquire (inode) == 0)
2666 {
2667 if (!inode->i_bdev->bd_op && de->u.fcb.ops)
2668 inode->i_bdev->bd_op = de->u.fcb.ops;
2669 }
2670 else PRINTK ("(%d): no block device from bdget()\n",(int)inode->i_ino);
2671 is_fcb = TRUE;
2672 }
2673 else if ( S_ISFIFO (de->mode) ) inode->i_fop = &def_fifo_fops;
2674 else if ( S_ISREG (de->mode) )
2675 {
2676 inode->i_size = de->u.fcb.u.file.size;
2677 is_fcb = TRUE;
2678 }
2679 else if ( S_ISDIR (de->mode) )
2680 {
2681 inode->i_op = &devfs_dir_iops;
2682 inode->i_fop = &devfs_dir_fops;
2683 }
2684 else if ( S_ISLNK (de->mode) )
2685 {
2686 inode->i_op = &devfs_symlink_iops;
2687 inode->i_size = de->u.symlink.length;
2688 }
2689 if (is_fcb && de->u.fcb.auto_owner)
2690 inode->i_mode = (de->mode & S_IFMT) | S_IRUGO | S_IWUGO;
2691 else inode->i_mode = de->mode;
2692 inode->i_uid = de->inode.uid;
2693 inode->i_gid = de->inode.gid;
2694 inode->i_atime = de->inode.atime;
2695 inode->i_mtime = de->inode.mtime;
2696 inode->i_ctime = de->inode.ctime;
2697 DPRINTK (DEBUG_I_GET, "(): mode: 0%o uid: %d gid: %d\n",
2698 (int) inode->i_mode, (int) inode->i_uid, (int) inode->i_gid);
2699 return inode;
2700 } /* End Function _devfs_get_vfs_inode */
2701
2702
2703 /* File operations for device entries follow */
2704
devfs_readdir(struct file * file,void * dirent,filldir_t filldir)2705 static int devfs_readdir (struct file *file, void *dirent, filldir_t filldir)
2706 {
2707 int err, count;
2708 int stored = 0;
2709 struct fs_info *fs_info;
2710 struct devfs_entry *parent, *de, *next = NULL;
2711 struct inode *inode = file->f_dentry->d_inode;
2712
2713 fs_info = inode->i_sb->u.generic_sbp;
2714 parent = get_devfs_entry_from_vfs_inode (file->f_dentry->d_inode);
2715 if ( (long) file->f_pos < 0 ) return -EINVAL;
2716 DPRINTK (DEBUG_F_READDIR, "(%s): fs_info: %p pos: %ld\n",
2717 parent->name, fs_info, (long) file->f_pos);
2718 switch ( (long) file->f_pos )
2719 {
2720 case 0:
2721 scan_dir_for_removable (parent);
2722 err = (*filldir) (dirent, "..", 2, file->f_pos,
2723 file->f_dentry->d_parent->d_inode->i_ino, DT_DIR);
2724 if (err == -EINVAL) break;
2725 if (err < 0) return err;
2726 file->f_pos++;
2727 ++stored;
2728 /* Fall through */
2729 case 1:
2730 err = (*filldir) (dirent, ".", 1, file->f_pos, inode->i_ino, DT_DIR);
2731 if (err == -EINVAL) break;
2732 if (err < 0) return err;
2733 file->f_pos++;
2734 ++stored;
2735 /* Fall through */
2736 default:
2737 /* Skip entries */
2738 count = file->f_pos - 2;
2739 read_lock (&parent->u.dir.lock);
2740 for (de = parent->u.dir.first; de && (count > 0); de = de->next)
2741 if ( !IS_HIDDEN (de) ) --count;
2742 devfs_get (de);
2743 read_unlock (&parent->u.dir.lock);
2744 /* Now add all remaining entries */
2745 while (de)
2746 {
2747 if ( IS_HIDDEN (de) ) err = 0;
2748 else
2749 {
2750 err = (*filldir) (dirent, de->name, de->namelen,
2751 file->f_pos, de->inode.ino, de->mode >> 12);
2752 if (err < 0) devfs_put (de);
2753 else
2754 {
2755 file->f_pos++;
2756 ++stored;
2757 }
2758 }
2759 if (err == -EINVAL) break;
2760 if (err < 0) return err;
2761 read_lock (&parent->u.dir.lock);
2762 next = devfs_get (de->next);
2763 read_unlock (&parent->u.dir.lock);
2764 devfs_put (de);
2765 de = next;
2766 }
2767 break;
2768 }
2769 return stored;
2770 } /* End Function devfs_readdir */
2771
devfs_open(struct inode * inode,struct file * file)2772 static int devfs_open (struct inode *inode, struct file *file)
2773 {
2774 int err;
2775 struct fcb_type *df;
2776 struct devfs_entry *de;
2777 struct fs_info *fs_info = inode->i_sb->u.generic_sbp;
2778 void *ops;
2779
2780 de = get_devfs_entry_from_vfs_inode (inode);
2781 if (de == NULL) return -ENODEV;
2782 if ( S_ISDIR (de->mode) ) return 0;
2783 df = &de->u.fcb;
2784 file->private_data = de->info;
2785 ops = devfs_get_ops (de); /* Now have module refcount */
2786 if ( S_ISBLK (inode->i_mode) )
2787 {
2788 file->f_op = &def_blk_fops;
2789 if (ops) inode->i_bdev->bd_op = ops;
2790 err = def_blk_fops.open (inode, file); /* This bumps module refcount */
2791 devfs_put_ops (de); /* So drop my refcount */
2792 }
2793 else
2794 {
2795 file->f_op = ops;
2796 if (file->f_op)
2797 {
2798 lock_kernel ();
2799 err = file->f_op->open ? (*file->f_op->open) (inode, file) : 0;
2800 unlock_kernel ();
2801 }
2802 else
2803 { /* Fallback to legacy scheme (I don't have a module refcount) */
2804 if ( S_ISCHR (inode->i_mode) ) err = chrdev_open (inode, file);
2805 else err = -ENODEV;
2806 }
2807 }
2808 if (err < 0) return err;
2809 /* Open was successful */
2810 if (df->open) return 0;
2811 df->open = TRUE; /* This is the first open */
2812 if (df->auto_owner)
2813 {
2814 /* Change the ownership/protection to what driver specified */
2815 inode->i_mode = de->mode;
2816 inode->i_uid = current->euid;
2817 inode->i_gid = current->egid;
2818 }
2819 if ( df->aopen_notify && !is_devfsd_or_child (fs_info) )
2820 devfsd_notify_de (de, DEVFSD_NOTIFY_ASYNC_OPEN, inode->i_mode,
2821 current->euid, current->egid, fs_info, 0);
2822 return 0;
2823 } /* End Function devfs_open */
2824
2825 static struct file_operations devfs_fops =
2826 {
2827 .open = devfs_open,
2828 };
2829
2830 static struct file_operations devfs_dir_fops =
2831 {
2832 .read = generic_read_dir,
2833 .readdir = devfs_readdir,
2834 .open = devfs_open,
2835 };
2836
2837
2838 /* Dentry operations for device entries follow */
2839
2840
2841 /**
2842 * devfs_d_release - Callback for when a dentry is freed.
2843 * @dentry: The dentry.
2844 */
2845
devfs_d_release(struct dentry * dentry)2846 static void devfs_d_release (struct dentry *dentry)
2847 {
2848 DPRINTK (DEBUG_D_RELEASE, "(%p): inode: %p\n", dentry, dentry->d_inode);
2849 } /* End Function devfs_d_release */
2850
2851 /**
2852 * devfs_d_iput - Callback for when a dentry loses its inode.
2853 * @dentry: The dentry.
2854 * @inode: The inode.
2855 */
2856
devfs_d_iput(struct dentry * dentry,struct inode * inode)2857 static void devfs_d_iput (struct dentry *dentry, struct inode *inode)
2858 {
2859 struct devfs_entry *de;
2860
2861 de = get_devfs_entry_from_vfs_inode (inode);
2862 DPRINTK (DEBUG_D_IPUT,"(%s): dentry: %p inode: %p de: %p de->dentry: %p\n",
2863 de->name, dentry, inode, de, de->inode.dentry);
2864 if ( de->inode.dentry && (de->inode.dentry != dentry) )
2865 OOPS ("(%s): de: %p dentry: %p de->dentry: %p\n",
2866 de->name, de, dentry, de->inode.dentry);
2867 de->inode.dentry = NULL;
2868 iput (inode);
2869 devfs_put (de);
2870 } /* End Function devfs_d_iput */
2871
2872 static int devfs_d_delete (struct dentry *dentry);
2873
2874 static struct dentry_operations devfs_dops =
2875 {
2876 .d_delete = devfs_d_delete,
2877 .d_release = devfs_d_release,
2878 .d_iput = devfs_d_iput,
2879 };
2880
2881 static int devfs_d_revalidate_wait (struct dentry *dentry, int flags);
2882
2883 static struct dentry_operations devfs_wait_dops =
2884 {
2885 .d_delete = devfs_d_delete,
2886 .d_release = devfs_d_release,
2887 .d_iput = devfs_d_iput,
2888 .d_revalidate = devfs_d_revalidate_wait,
2889 };
2890
2891 /**
2892 * devfs_d_delete - Callback for when all files for a dentry are closed.
2893 * @dentry: The dentry.
2894 */
2895
devfs_d_delete(struct dentry * dentry)2896 static int devfs_d_delete (struct dentry *dentry)
2897 {
2898 struct inode *inode = dentry->d_inode;
2899 struct devfs_entry *de;
2900 struct fs_info *fs_info;
2901
2902 if (dentry->d_op == &devfs_wait_dops) dentry->d_op = &devfs_dops;
2903 /* Unhash dentry if negative (has no inode) */
2904 if (inode == NULL)
2905 {
2906 DPRINTK (DEBUG_D_DELETE, "(%p): dropping negative dentry\n", dentry);
2907 return 1;
2908 }
2909 fs_info = inode->i_sb->u.generic_sbp;
2910 de = get_devfs_entry_from_vfs_inode (inode);
2911 DPRINTK (DEBUG_D_DELETE, "(%p): inode: %p devfs_entry: %p\n",
2912 dentry, inode, de);
2913 if (de == NULL) return 0;
2914 if ( !S_ISCHR (de->mode) && !S_ISBLK (de->mode) && !S_ISREG (de->mode) )
2915 return 0;
2916 if (!de->u.fcb.open) return 0;
2917 de->u.fcb.open = FALSE;
2918 if (de->u.fcb.aopen_notify)
2919 devfsd_notify_de (de, DEVFSD_NOTIFY_CLOSE, inode->i_mode,
2920 current->euid, current->egid, fs_info, 1);
2921 if (!de->u.fcb.auto_owner) return 0;
2922 /* Change the ownership/protection back */
2923 inode->i_mode = (de->mode & S_IFMT) | S_IRUGO | S_IWUGO;
2924 inode->i_uid = de->inode.uid;
2925 inode->i_gid = de->inode.gid;
2926 return 0;
2927 } /* End Function devfs_d_delete */
2928
2929 struct devfs_lookup_struct
2930 {
2931 devfs_handle_t de;
2932 wait_queue_head_t wait_queue;
2933 };
2934
devfs_d_revalidate_wait(struct dentry * dentry,int flags)2935 static int devfs_d_revalidate_wait (struct dentry *dentry, int flags)
2936 {
2937 struct inode *dir = dentry->d_parent->d_inode;
2938 struct fs_info *fs_info = dir->i_sb->u.generic_sbp;
2939 devfs_handle_t parent = get_devfs_entry_from_vfs_inode (dir);
2940 struct devfs_lookup_struct *lookup_info = dentry->d_fsdata;
2941 DECLARE_WAITQUEUE (wait, current);
2942
2943 if ( is_devfsd_or_child (fs_info) )
2944 {
2945 devfs_handle_t de = lookup_info->de;
2946 struct inode *inode;
2947
2948 DPRINTK (DEBUG_I_LOOKUP,
2949 "(%s): dentry: %p inode: %p de: %p by: \"%s\"\n",
2950 dentry->d_name.name, dentry, dentry->d_inode, de,
2951 current->comm);
2952 if (dentry->d_inode) return 1;
2953 if (de == NULL)
2954 {
2955 read_lock (&parent->u.dir.lock);
2956 de = _devfs_search_dir (parent, dentry->d_name.name,
2957 dentry->d_name.len);
2958 read_unlock (&parent->u.dir.lock);
2959 if (de == NULL) return 1;
2960 lookup_info->de = de;
2961 }
2962 /* Create an inode, now that the driver information is available */
2963 inode = _devfs_get_vfs_inode (dir->i_sb, de, dentry);
2964 if (!inode) return 1;
2965 DPRINTK (DEBUG_I_LOOKUP,
2966 "(%s): new VFS inode(%u): %p de: %p by: \"%s\"\n",
2967 de->name, de->inode.ino, inode, de, current->comm);
2968 d_instantiate (dentry, inode);
2969 return 1;
2970 }
2971 if (lookup_info == NULL) return 1; /* Early termination */
2972 read_lock (&parent->u.dir.lock);
2973 if (dentry->d_fsdata)
2974 {
2975 set_current_state (TASK_UNINTERRUPTIBLE);
2976 add_wait_queue (&lookup_info->wait_queue, &wait);
2977 read_unlock (&parent->u.dir.lock);
2978 schedule ();
2979 }
2980 else read_unlock (&parent->u.dir.lock);
2981 return 1;
2982 } /* End Function devfs_d_revalidate_wait */
2983
2984
2985 /* Inode operations for device entries follow */
2986
devfs_lookup(struct inode * dir,struct dentry * dentry)2987 static struct dentry *devfs_lookup (struct inode *dir, struct dentry *dentry)
2988 {
2989 struct devfs_entry tmp; /* Must stay in scope until devfsd idle again */
2990 struct devfs_lookup_struct lookup_info;
2991 struct fs_info *fs_info = dir->i_sb->u.generic_sbp;
2992 struct devfs_entry *parent, *de;
2993 struct inode *inode;
2994 struct dentry *retval = NULL;
2995
2996 /* Set up the dentry operations before anything else, to ensure cleaning
2997 up on any error */
2998 dentry->d_op = &devfs_dops;
2999 /* First try to get the devfs entry for this directory */
3000 parent = get_devfs_entry_from_vfs_inode (dir);
3001 DPRINTK (DEBUG_I_LOOKUP, "(%s): dentry: %p parent: %p by: \"%s\"\n",
3002 dentry->d_name.name, dentry, parent, current->comm);
3003 if (parent == NULL) return ERR_PTR (-ENOENT);
3004 read_lock (&parent->u.dir.lock);
3005 de = _devfs_search_dir (parent, dentry->d_name.name, dentry->d_name.len);
3006 if (de) read_unlock (&parent->u.dir.lock);
3007 else
3008 { /* Try re-reading the partition (media may have changed) */
3009 if ( get_removable_partition (parent, dentry->d_name.name,
3010 dentry->d_name.len) ) /* Unlocks */
3011 { /* Media did change */
3012 read_lock (&parent->u.dir.lock);
3013 de = _devfs_search_dir (parent, dentry->d_name.name,
3014 dentry->d_name.len);
3015 read_unlock (&parent->u.dir.lock);
3016 }
3017 }
3018 lookup_info.de = de;
3019 init_waitqueue_head (&lookup_info.wait_queue);
3020 dentry->d_fsdata = &lookup_info;
3021 if (de == NULL)
3022 { /* Try with devfsd. For any kind of failure, leave a negative dentry
3023 so someone else can deal with it (in the case where the sysadmin
3024 does a mknod()). It's important to do this before hashing the
3025 dentry, so that the devfsd queue is filled before revalidates
3026 can start */
3027 if (try_modload (parent, fs_info,
3028 dentry->d_name.name, dentry->d_name.len, &tmp) < 0)
3029 { /* Lookup event was not queued to devfsd */
3030 d_add (dentry, NULL);
3031 return NULL;
3032 }
3033 }
3034 dentry->d_op = &devfs_wait_dops;
3035 d_add (dentry, NULL); /* Open the floodgates */
3036 /* Unlock directory semaphore, which will release any waiters. They
3037 will get the hashed dentry, and may be forced to wait for
3038 revalidation */
3039 up (&dir->i_sem);
3040 wait_for_devfsd_finished (fs_info); /* If I'm not devfsd, must wait */
3041 down (&dir->i_sem); /* Grab it again because them's the rules */
3042 de = lookup_info.de;
3043 /* If someone else has been so kind as to make the inode, we go home
3044 early */
3045 if (dentry->d_inode) goto out;
3046 if (de == NULL)
3047 {
3048 read_lock (&parent->u.dir.lock);
3049 de = _devfs_search_dir (parent, dentry->d_name.name,
3050 dentry->d_name.len);
3051 read_unlock (&parent->u.dir.lock);
3052 if (de == NULL) goto out;
3053 /* OK, there's an entry now, but no VFS inode yet */
3054 }
3055 /* Create an inode, now that the driver information is available */
3056 inode = _devfs_get_vfs_inode (dir->i_sb, de, dentry);
3057 if (!inode)
3058 {
3059 retval = ERR_PTR (-ENOMEM);
3060 goto out;
3061 }
3062 DPRINTK (DEBUG_I_LOOKUP, "(%s): new VFS inode(%u): %p de: %p by: \"%s\"\n",
3063 de->name, de->inode.ino, inode, de, current->comm);
3064 d_instantiate (dentry, inode);
3065 out:
3066 dentry->d_op = &devfs_dops;
3067 dentry->d_fsdata = NULL;
3068 write_lock (&parent->u.dir.lock);
3069 wake_up (&lookup_info.wait_queue);
3070 write_unlock (&parent->u.dir.lock);
3071 devfs_put (de);
3072 return retval;
3073 } /* End Function devfs_lookup */
3074
devfs_unlink(struct inode * dir,struct dentry * dentry)3075 static int devfs_unlink (struct inode *dir, struct dentry *dentry)
3076 {
3077 int unhooked;
3078 struct devfs_entry *de;
3079 struct inode *inode = dentry->d_inode;
3080 struct fs_info *fs_info = dir->i_sb->u.generic_sbp;
3081
3082 de = get_devfs_entry_from_vfs_inode (inode);
3083 DPRINTK (DEBUG_I_UNLINK, "(%s): de: %p\n", dentry->d_name.name, de);
3084 if (de == NULL) return -ENOENT;
3085 if (!de->vfs_deletable) return -EPERM;
3086 write_lock (&de->parent->u.dir.lock);
3087 unhooked = _devfs_unhook (de);
3088 write_unlock (&de->parent->u.dir.lock);
3089 if (!unhooked) return -ENOENT;
3090 if ( !is_devfsd_or_child (fs_info) )
3091 devfsd_notify_de (de, DEVFSD_NOTIFY_DELETE, inode->i_mode,
3092 inode->i_uid, inode->i_gid, fs_info, 0);
3093 free_dentry (de);
3094 devfs_put (de);
3095 return 0;
3096 } /* End Function devfs_unlink */
3097
devfs_symlink(struct inode * dir,struct dentry * dentry,const char * symname)3098 static int devfs_symlink (struct inode *dir, struct dentry *dentry,
3099 const char *symname)
3100 {
3101 int err;
3102 struct fs_info *fs_info = dir->i_sb->u.generic_sbp;
3103 struct devfs_entry *parent, *de;
3104 struct inode *inode;
3105
3106 /* First try to get the devfs entry for this directory */
3107 parent = get_devfs_entry_from_vfs_inode (dir);
3108 if (parent == NULL) return -ENOENT;
3109 err = devfs_do_symlink (parent, dentry->d_name.name, DEVFS_FL_NONE,
3110 symname, &de, NULL);
3111 DPRINTK (DEBUG_DISABLED, "(%s): errcode from <devfs_do_symlink>: %d\n",
3112 dentry->d_name.name, err);
3113 if (err < 0) return err;
3114 de->vfs_deletable = TRUE;
3115 de->inode.uid = current->euid;
3116 de->inode.gid = current->egid;
3117 de->inode.atime = CURRENT_TIME;
3118 de->inode.mtime = CURRENT_TIME;
3119 de->inode.ctime = CURRENT_TIME;
3120 if ( ( inode = _devfs_get_vfs_inode (dir->i_sb, de, dentry) ) == NULL )
3121 return -ENOMEM;
3122 DPRINTK (DEBUG_DISABLED, "(%s): new VFS inode(%u): %p dentry: %p\n",
3123 dentry->d_name.name, de->inode.ino, inode, dentry);
3124 d_instantiate (dentry, inode);
3125 if ( !is_devfsd_or_child (fs_info) )
3126 devfsd_notify_de (de, DEVFSD_NOTIFY_CREATE, inode->i_mode,
3127 inode->i_uid, inode->i_gid, fs_info, 0);
3128 return 0;
3129 } /* End Function devfs_symlink */
3130
devfs_mkdir(struct inode * dir,struct dentry * dentry,int mode)3131 static int devfs_mkdir (struct inode *dir, struct dentry *dentry, int mode)
3132 {
3133 int err;
3134 struct fs_info *fs_info = dir->i_sb->u.generic_sbp;
3135 struct devfs_entry *parent, *de;
3136 struct inode *inode;
3137
3138 mode = (mode & ~S_IFMT) | S_IFDIR; /* VFS doesn't pass S_IFMT part */
3139 parent = get_devfs_entry_from_vfs_inode (dir);
3140 if (parent == NULL) return -ENOENT;
3141 de = _devfs_alloc_entry (dentry->d_name.name, dentry->d_name.len, mode);
3142 if (!de) return -ENOMEM;
3143 de->vfs_deletable = TRUE;
3144 if ( ( err = _devfs_append_entry (parent, de, FALSE, NULL) ) != 0 )
3145 return err;
3146 de->inode.uid = current->euid;
3147 de->inode.gid = current->egid;
3148 de->inode.atime = CURRENT_TIME;
3149 de->inode.mtime = CURRENT_TIME;
3150 de->inode.ctime = CURRENT_TIME;
3151 if ( ( inode = _devfs_get_vfs_inode (dir->i_sb, de, dentry) ) == NULL )
3152 return -ENOMEM;
3153 DPRINTK (DEBUG_DISABLED, "(%s): new VFS inode(%u): %p dentry: %p\n",
3154 dentry->d_name.name, de->inode.ino, inode, dentry);
3155 d_instantiate (dentry, inode);
3156 if ( !is_devfsd_or_child (fs_info) )
3157 devfsd_notify_de (de, DEVFSD_NOTIFY_CREATE, inode->i_mode,
3158 inode->i_uid, inode->i_gid, fs_info, 0);
3159 return 0;
3160 } /* End Function devfs_mkdir */
3161
devfs_rmdir(struct inode * dir,struct dentry * dentry)3162 static int devfs_rmdir (struct inode *dir, struct dentry *dentry)
3163 {
3164 int err = 0;
3165 struct devfs_entry *de;
3166 struct fs_info *fs_info = dir->i_sb->u.generic_sbp;
3167 struct inode *inode = dentry->d_inode;
3168
3169 if (dir->i_sb->u.generic_sbp != inode->i_sb->u.generic_sbp) return -EINVAL;
3170 de = get_devfs_entry_from_vfs_inode (inode);
3171 if (de == NULL) return -ENOENT;
3172 if ( !S_ISDIR (de->mode) ) return -ENOTDIR;
3173 if (!de->vfs_deletable) return -EPERM;
3174 /* First ensure the directory is empty and will stay that way */
3175 write_lock (&de->u.dir.lock);
3176 if (de->u.dir.first) err = -ENOTEMPTY;
3177 else de->u.dir.no_more_additions = TRUE;
3178 write_unlock (&de->u.dir.lock);
3179 if (err) return err;
3180 /* Now unhook the directory from it's parent */
3181 write_lock (&de->parent->u.dir.lock);
3182 if ( !_devfs_unhook (de) ) err = -ENOENT;
3183 write_unlock (&de->parent->u.dir.lock);
3184 if (err) return err;
3185 if ( !is_devfsd_or_child (fs_info) )
3186 devfsd_notify_de (de, DEVFSD_NOTIFY_DELETE, inode->i_mode,
3187 inode->i_uid, inode->i_gid, fs_info, 0);
3188 free_dentry (de);
3189 devfs_put (de);
3190 return 0;
3191 } /* End Function devfs_rmdir */
3192
devfs_mknod(struct inode * dir,struct dentry * dentry,int mode,int rdev)3193 static int devfs_mknod (struct inode *dir, struct dentry *dentry, int mode,
3194 int rdev)
3195 {
3196 int err;
3197 struct fs_info *fs_info = dir->i_sb->u.generic_sbp;
3198 struct devfs_entry *parent, *de;
3199 struct inode *inode;
3200
3201 DPRINTK (DEBUG_I_MKNOD, "(%s): mode: 0%o dev: %d\n",
3202 dentry->d_name.name, mode, rdev);
3203 parent = get_devfs_entry_from_vfs_inode (dir);
3204 if (parent == NULL) return -ENOENT;
3205 de = _devfs_alloc_entry (dentry->d_name.name, dentry->d_name.len, mode);
3206 if (!de) return -ENOMEM;
3207 de->vfs_deletable = TRUE;
3208 if ( S_ISBLK (mode) || S_ISCHR (mode) )
3209 {
3210 de->u.fcb.u.device.major = MAJOR (rdev);
3211 de->u.fcb.u.device.minor = MINOR (rdev);
3212 }
3213 if ( ( err = _devfs_append_entry (parent, de, FALSE, NULL) ) != 0 )
3214 return err;
3215 de->inode.uid = current->euid;
3216 de->inode.gid = current->egid;
3217 de->inode.atime = CURRENT_TIME;
3218 de->inode.mtime = CURRENT_TIME;
3219 de->inode.ctime = CURRENT_TIME;
3220 if ( ( inode = _devfs_get_vfs_inode (dir->i_sb, de, dentry) ) == NULL )
3221 return -ENOMEM;
3222 DPRINTK (DEBUG_I_MKNOD, ": new VFS inode(%u): %p dentry: %p\n",
3223 de->inode.ino, inode, dentry);
3224 d_instantiate (dentry, inode);
3225 if ( !is_devfsd_or_child (fs_info) )
3226 devfsd_notify_de (de, DEVFSD_NOTIFY_CREATE, inode->i_mode,
3227 inode->i_uid, inode->i_gid, fs_info, 0);
3228 return 0;
3229 } /* End Function devfs_mknod */
3230
devfs_readlink(struct dentry * dentry,char * buffer,int buflen)3231 static int devfs_readlink (struct dentry *dentry, char *buffer, int buflen)
3232 {
3233 int err;
3234 struct devfs_entry *de;
3235
3236 de = get_devfs_entry_from_vfs_inode (dentry->d_inode);
3237 if (!de) return -ENODEV;
3238 err = vfs_readlink (dentry, buffer, buflen, de->u.symlink.linkname);
3239 return err;
3240 } /* End Function devfs_readlink */
3241
devfs_follow_link(struct dentry * dentry,struct nameidata * nd)3242 static int devfs_follow_link (struct dentry *dentry, struct nameidata *nd)
3243 {
3244 int err;
3245 struct devfs_entry *de;
3246
3247 de = get_devfs_entry_from_vfs_inode (dentry->d_inode);
3248 if (!de) return -ENODEV;
3249 err = vfs_follow_link (nd, de->u.symlink.linkname);
3250 return err;
3251 } /* End Function devfs_follow_link */
3252
3253 static struct inode_operations devfs_iops =
3254 {
3255 .setattr = devfs_notify_change,
3256 };
3257
3258 static struct inode_operations devfs_dir_iops =
3259 {
3260 .lookup = devfs_lookup,
3261 .unlink = devfs_unlink,
3262 .symlink = devfs_symlink,
3263 .mkdir = devfs_mkdir,
3264 .rmdir = devfs_rmdir,
3265 .mknod = devfs_mknod,
3266 .setattr = devfs_notify_change,
3267 };
3268
3269 static struct inode_operations devfs_symlink_iops =
3270 {
3271 .readlink = devfs_readlink,
3272 .follow_link = devfs_follow_link,
3273 .setattr = devfs_notify_change,
3274 };
3275
devfs_read_super(struct super_block * sb,void * data,int silent)3276 static struct super_block *devfs_read_super (struct super_block *sb,
3277 void *data, int silent)
3278 {
3279 struct inode *root_inode = NULL;
3280
3281 if (_devfs_get_root_entry () == NULL) goto out_no_root;
3282 atomic_set (&fs_info.devfsd_overrun_count, 0);
3283 init_waitqueue_head (&fs_info.devfsd_wait_queue);
3284 init_waitqueue_head (&fs_info.revalidate_wait_queue);
3285 fs_info.sb = sb;
3286 sb->u.generic_sbp = &fs_info;
3287 sb->s_blocksize = 1024;
3288 sb->s_blocksize_bits = 10;
3289 sb->s_magic = DEVFS_SUPER_MAGIC;
3290 sb->s_op = &devfs_sops;
3291 if ( ( root_inode = _devfs_get_vfs_inode (sb, root_entry, NULL) ) == NULL )
3292 goto out_no_root;
3293 sb->s_root = d_alloc_root (root_inode);
3294 if (!sb->s_root) goto out_no_root;
3295 DPRINTK (DEBUG_S_READ, "(): made devfs ptr: %p\n", sb->u.generic_sbp);
3296 return sb;
3297
3298 out_no_root:
3299 PRINTK ("(): get root inode failed\n");
3300 if (root_inode) iput (root_inode);
3301 return NULL;
3302 } /* End Function devfs_read_super */
3303
3304
3305 static DECLARE_FSTYPE (devfs_fs_type, DEVFS_NAME, devfs_read_super, FS_SINGLE);
3306
3307
3308 /* File operations for devfsd follow */
3309
devfsd_read(struct file * file,char * buf,size_t len,loff_t * ppos)3310 static ssize_t devfsd_read (struct file *file, char *buf, size_t len,
3311 loff_t *ppos)
3312 {
3313 int done = FALSE;
3314 int ival;
3315 loff_t pos, devname_offset, tlen, rpos, old_pos;
3316 devfs_handle_t de;
3317 struct devfsd_buf_entry *entry;
3318 struct fs_info *fs_info = file->f_dentry->d_inode->i_sb->u.generic_sbp;
3319 struct devfsd_notify_struct *info = fs_info->devfsd_info;
3320 DECLARE_WAITQUEUE (wait, current);
3321
3322 /* Can't seek (pread) on this device */
3323 if (ppos != &file->f_pos) return -ESPIPE;
3324 /* Verify the task has grabbed the queue */
3325 if (fs_info->devfsd_task != current) return -EPERM;
3326 info->major = 0;
3327 info->minor = 0;
3328 /* Block for a new entry */
3329 set_current_state (TASK_INTERRUPTIBLE);
3330 add_wait_queue (&fs_info->devfsd_wait_queue, &wait);
3331 while ( devfsd_queue_empty (fs_info) )
3332 {
3333 fs_info->devfsd_sleeping = TRUE;
3334 wake_up (&fs_info->revalidate_wait_queue);
3335 schedule ();
3336 fs_info->devfsd_sleeping = FALSE;
3337 if ( signal_pending (current) )
3338 {
3339 remove_wait_queue (&fs_info->devfsd_wait_queue, &wait);
3340 __set_current_state (TASK_RUNNING);
3341 return -EINTR;
3342 }
3343 set_current_state (TASK_INTERRUPTIBLE);
3344 }
3345 remove_wait_queue (&fs_info->devfsd_wait_queue, &wait);
3346 __set_current_state (TASK_RUNNING);
3347 /* Now play with the data */
3348 ival = atomic_read (&fs_info->devfsd_overrun_count);
3349 info->overrun_count = ival;
3350 entry = fs_info->devfsd_first_event;
3351 info->type = entry->type;
3352 info->mode = entry->mode;
3353 info->uid = entry->uid;
3354 info->gid = entry->gid;
3355 de = entry->de;
3356 if ( S_ISCHR (de->mode) || S_ISBLK (de->mode) )
3357 {
3358 info->major = de->u.fcb.u.device.major;
3359 info->minor = de->u.fcb.u.device.minor;
3360 }
3361 pos = devfs_generate_path (de, info->devname, DEVFS_PATHLEN);
3362 if (pos < 0) return pos;
3363 info->namelen = DEVFS_PATHLEN - pos - 1;
3364 if (info->mode == 0) info->mode = de->mode;
3365 devname_offset = info->devname - (char *) info;
3366 old_pos = rpos = *ppos;
3367 if (rpos >= 0 && rpos < devname_offset)
3368 {
3369 /* Copy parts of the header */
3370 tlen = devname_offset - rpos;
3371 if (tlen > len) tlen = len;
3372 if ( copy_to_user (buf, (char *) info + rpos, tlen) )
3373 {
3374 return -EFAULT;
3375 }
3376 rpos += tlen;
3377 buf += tlen;
3378 len -= tlen;
3379 }
3380 if ( (rpos >= devname_offset) && (len > 0) )
3381 {
3382 /* Copy the name */
3383 tlen = info->namelen + 1;
3384 if (tlen > len) tlen = len;
3385 else done = TRUE;
3386 if ( copy_to_user (buf, info->devname + pos + rpos - devname_offset,
3387 tlen) )
3388 {
3389 return -EFAULT;
3390 }
3391 rpos += tlen;
3392 }
3393 tlen = rpos - old_pos;
3394 if (done)
3395 {
3396 devfs_handle_t parent;
3397
3398 spin_lock (&fs_info->devfsd_buffer_lock);
3399 fs_info->devfsd_first_event = entry->next;
3400 if (entry->next == NULL) fs_info->devfsd_last_event = NULL;
3401 spin_unlock (&fs_info->devfsd_buffer_lock);
3402 for (; de != NULL; de = parent)
3403 {
3404 parent = de->parent;
3405 devfs_put (de);
3406 }
3407 kmem_cache_free (devfsd_buf_cache, entry);
3408 if (ival > 0) atomic_sub (ival, &fs_info->devfsd_overrun_count);
3409 *ppos = 0;
3410 }
3411 else *ppos = rpos;
3412 return tlen;
3413 } /* End Function devfsd_read */
3414
devfsd_ioctl(struct inode * inode,struct file * file,unsigned int cmd,unsigned long arg)3415 static int devfsd_ioctl (struct inode *inode, struct file *file,
3416 unsigned int cmd, unsigned long arg)
3417 {
3418 int ival;
3419 struct fs_info *fs_info = inode->i_sb->u.generic_sbp;
3420
3421 switch (cmd)
3422 {
3423 case DEVFSDIOC_GET_PROTO_REV:
3424 ival = DEVFSD_PROTOCOL_REVISION_KERNEL;
3425 if ( copy_to_user ( (void *)arg, &ival, sizeof ival ) ) return -EFAULT;
3426 break;
3427 case DEVFSDIOC_SET_EVENT_MASK:
3428 /* Ensure only one reader has access to the queue. This scheme will
3429 work even if the global kernel lock were to be removed, because it
3430 doesn't matter who gets in first, as long as only one gets it */
3431 if (fs_info->devfsd_task == NULL)
3432 {
3433 static spinlock_t lock = SPIN_LOCK_UNLOCKED;
3434
3435 if ( !spin_trylock (&lock) ) return -EBUSY;
3436 if (fs_info->devfsd_task != NULL)
3437 { /* We lost the race... */
3438 spin_unlock (&lock);
3439 return -EBUSY;
3440 }
3441 fs_info->devfsd_task = current;
3442 spin_unlock (&lock);
3443 fs_info->devfsd_pgrp = (current->pgrp == current->pid) ?
3444 current->pgrp : 0;
3445 fs_info->devfsd_file = file;
3446 fs_info->devfsd_info = kmalloc (sizeof *fs_info->devfsd_info,
3447 GFP_KERNEL);
3448 if (!fs_info->devfsd_info)
3449 {
3450 devfsd_close (inode, file);
3451 return -ENOMEM;
3452 }
3453 }
3454 else if (fs_info->devfsd_task != current) return -EBUSY;
3455 fs_info->devfsd_event_mask = arg; /* Let the masses come forth */
3456 break;
3457 case DEVFSDIOC_RELEASE_EVENT_QUEUE:
3458 if (fs_info->devfsd_file != file) return -EPERM;
3459 return devfsd_close (inode, file);
3460 /*break;*/
3461 #ifdef CONFIG_DEVFS_DEBUG
3462 case DEVFSDIOC_SET_DEBUG_MASK:
3463 if ( copy_from_user (&ival, (void *) arg, sizeof ival) )return -EFAULT;
3464 devfs_debug = ival;
3465 break;
3466 #endif
3467 default:
3468 return -ENOIOCTLCMD;
3469 }
3470 return 0;
3471 } /* End Function devfsd_ioctl */
3472
devfsd_close(struct inode * inode,struct file * file)3473 static int devfsd_close (struct inode *inode, struct file *file)
3474 {
3475 struct devfsd_buf_entry *entry, *next;
3476 struct fs_info *fs_info = inode->i_sb->u.generic_sbp;
3477
3478 if (fs_info->devfsd_file != file) return 0;
3479 fs_info->devfsd_event_mask = 0;
3480 fs_info->devfsd_file = NULL;
3481 spin_lock (&fs_info->devfsd_buffer_lock);
3482 entry = fs_info->devfsd_first_event;
3483 fs_info->devfsd_first_event = NULL;
3484 fs_info->devfsd_last_event = NULL;
3485 if (fs_info->devfsd_info)
3486 {
3487 kfree (fs_info->devfsd_info);
3488 fs_info->devfsd_info = NULL;
3489 }
3490 spin_unlock (&fs_info->devfsd_buffer_lock);
3491 fs_info->devfsd_pgrp = 0;
3492 fs_info->devfsd_task = NULL;
3493 wake_up (&fs_info->revalidate_wait_queue);
3494 for (; entry; entry = next)
3495 {
3496 next = entry->next;
3497 kmem_cache_free (devfsd_buf_cache, entry);
3498 }
3499 return 0;
3500 } /* End Function devfsd_close */
3501
3502 #ifdef CONFIG_DEVFS_DEBUG
stat_read(struct file * file,char * buf,size_t len,loff_t * ppos)3503 static ssize_t stat_read (struct file *file, char *buf, size_t len,
3504 loff_t *ppos)
3505 {
3506 ssize_t num;
3507 loff_t n = *ppos;
3508 char txt[80];
3509
3510 num = sprintf (txt, "Number of entries: %u number of bytes: %u\n",
3511 stat_num_entries, stat_num_bytes) + 1;
3512 /* Can't seek (pread) on this device */
3513 if (ppos != &file->f_pos) return -ESPIPE;
3514 if (n != (unsigned)n || n >= num) return 0;
3515 if (len > num - n) len = num - n;
3516 if ( copy_to_user (buf, txt + n, len) ) return -EFAULT;
3517 *ppos = n + len;
3518 return len;
3519 } /* End Function stat_read */
3520 #endif
3521
3522
init_devfs_fs(void)3523 static int __init init_devfs_fs (void)
3524 {
3525 int err;
3526
3527 printk (KERN_INFO "%s: v%s Richard Gooch (rgooch@atnf.csiro.au)\n",
3528 DEVFS_NAME, DEVFS_VERSION);
3529 devfsd_buf_cache = kmem_cache_create ("devfsd_event",
3530 sizeof (struct devfsd_buf_entry),
3531 0, 0, NULL, NULL);
3532 if (!devfsd_buf_cache) OOPS ("(): unable to allocate event slab\n");
3533 #ifdef CONFIG_DEVFS_DEBUG
3534 devfs_debug = devfs_debug_init;
3535 printk (KERN_INFO "%s: devfs_debug: 0x%0x\n", DEVFS_NAME, devfs_debug);
3536 #endif
3537 printk (KERN_INFO "%s: boot_options: 0x%0x\n", DEVFS_NAME, boot_options);
3538 err = register_filesystem (&devfs_fs_type);
3539 if (!err)
3540 {
3541 struct vfsmount *devfs_mnt = kern_mount (&devfs_fs_type);
3542 err = PTR_ERR (devfs_mnt);
3543 if ( !IS_ERR (devfs_mnt) ) err = 0;
3544 }
3545 return err;
3546 } /* End Function init_devfs_fs */
3547
mount_devfs_fs(void)3548 void __init mount_devfs_fs (void)
3549 {
3550 int err;
3551
3552 if ( !(boot_options & OPTION_MOUNT) ) return;
3553 err = do_mount ("none", "/dev", "devfs", 0, NULL);
3554 if (err == 0) printk (KERN_INFO "Mounted devfs on /dev\n");
3555 else PRINTK ("(): unable to mount devfs, err: %d\n", err);
3556 } /* End Function mount_devfs_fs */
3557
3558 module_init(init_devfs_fs)
3559