tree 3c1154a95c0a44a1015f3bfeb7e73d19024924cb
parent 7105458563213b6f6fb523065474cfe1d6c22a67
author Eric W. Biederman <ebiederm@xmission.com> 1195088348 -0800
committer Linus Torvalds <torvalds@woody.linux-foundation.org> 1195094738 -0800

proc: fix proc_kill_inodes to kill dentries on all proc superblocks

It appears we overlooked support for removing generic proc files
when we added support for multiple proc super blocks.  Handle
that now.

[akpm@linux-foundation.org: coding-style cleanups]
Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Acked-by: Pavel Emelyanov <xemul@openvz.org>
Cc: Alexey Dobriyan <adobriyan@sw.ru>
Acked-by: Sukadev Bhattiprolu <sukadev@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
