busybox/examples/depmod.pl

#!/usr/bin/perl -w
# vi: set sw=4 ts=4:
# Copyright (c) 2001 David Schleef <ds@schleef.org>
# Copyright (c) 2001 Erik Andersen <andersen@codepoet.org>
# Copyright (c) 2001 Stuart Hughes <seh@zee2.com>
# Copyright (c) 2002 Steven J. Hill <shill@broadcom.com>
# Copyright (c) 2006 Freescale Semiconductor, Inc <stuarth@freescale.com>
#
# History:
# March 2006: Stuart Hughes <stuarth@freescale.com>.
#             Significant updates, including implementing the '-F' option
#             and adding support for 2.6 kernels.

# This program is free software; you can redistribute it and/or modify it
# under the same terms as Perl itself.
use Getopt::Long qw(:config no_auto_abbrev no_ignore_case);
use File::Find;
use strict;

# Set up some default values
my $kdir="";
my $basedir="";
my $kernel="";
my $kernelsyms="";
my $symprefix="";
my $all=0;
my $quick=0;
my $errsyms=0;
my $stdout=0;
my $verbose=0;
my $help=0;
my $nm = $ENV{'NM'} || "nm";

# more globals
my (@liblist) = ();
my $exp = {};
my $dep = {};
my $mod = {};

my $usage = <<TXT;
$0 -b basedir { -k <vmlinux> | -F <System.map> } [options]...
  Where:
   -h --help          : Show this help screen
   -b --basedir       : Modules base directory (e.g /lib/modules/<2.x.y>)
   -k --kernel        : Kernel binary for the target (e.g. vmlinux)
   -F --kernelsyms    : Kernel symbol file (e.g. System.map)
   -n --stdout        : Write to stdout instead of <basedir>/modules.dep
   -v --verbose       : Print out lots of debugging stuff
   -P --symbol-prefix : Symbol prefix
   -a --all           : Probe all modules (default/only thing supported)
   -e --errsyms       : Report any symbols not supplied by modules/kernel
TXT

# get command-line options
GetOptions(
	"help|h"            => \$help,
	"basedir|b=s"       => \$basedir,
	"kernel|k=s"        => \$kernel,
	"kernelsyms|F=s"    => \$kernelsyms,
	"stdout|n"          => \$stdout,
	"verbose|v"         => \$verbose,
	"symbol-prefix|P=s" => \$symprefix,
	"all|a"             => \$all,
	# unsupported options
	"quick|A"           => \$quick,
	# ignored options (for historical usage)
	"quiet|q",
	"root|r",
	"unresolved-error|u"
);

die $usage if $help;
die $usage unless $basedir && ( $kernel || $kernelsyms );
die "can't use both -k and -F\n\n$usage" if $kernel && $kernelsyms;
die "sorry, -A/--quick is not supported" if $quick;
die "--errsyms requires --kernelsyms" if $errsyms && !$kernelsyms;

# Strip any trailing or multiple slashes from basedir
$basedir =~ s-/+$--g;

# The base directory should contain /lib/modules somewhere
if($basedir !~ m-/lib/modules-) {
    warn "WARNING: base directory does not match ..../lib/modules\n";
}

# if no kernel version is contained in the basedir, try to find one
if($basedir !~ m-/lib/modules/\d\.\d-) {
    opendir(BD, $basedir) or die "can't open basedir $basedir : $!\n";
    foreach ( readdir(BD) ) {
        next if /^\.\.?$/;
        next unless -d "$basedir/$_";
        warn "dir = $_\n" if $verbose;
        if( /^\d\.\d/ ) {
            $kdir = $_;
            warn("Guessed module directory as $basedir/$kdir\n");
            last;
        }
    }
    closedir(BD);
    die "Cannot find a kernel version under $basedir\n" unless $kdir;
    $basedir = "$basedir/$kdir";
}

# Find the list of .o or .ko files living under $basedir
warn "**** Locating all modules\n" if $verbose;
find sub {
    my $file;
	if ( -f $_  && ! -d $_ ) {
		$file = $File::Find::name;
		if ( $file =~ /\.k?o$/ ) {
			push(@liblist, $file);
			warn "$file\n" if $verbose;
		}
	}
}, $basedir;
warn "**** Finished locating modules\n" if $verbose;

foreach my $obj ( @liblist ){
    # turn the input file name into a target tag name
    my ($tgtname) = $obj =~ m-(/lib/modules/.*)$-;

    warn "\nMODULE = $tgtname\n" if $verbose;

    # get a list of symbols
	my @output=`$nm $obj`;

    build_ref_tables($tgtname, \@output, $exp, $dep);
}


# vmlinux is a special name that is only used to resolve symbols
my $tgtname = 'vmlinux';
my @output = $kernelsyms ? `cat $kernelsyms` : `$nm $kernel`;
warn "\nMODULE = $tgtname\n" if $verbose;
build_ref_tables($tgtname, \@output, $exp, $dep);

# resolve the dependencies for each module
# reduce dependencies: remove unresolvable and resolved from vmlinux/System.map
# remove duplicates
foreach my $module (keys %$dep) {
    warn "reducing module: $module\n" if $verbose;
    $mod->{$module} = {};
    foreach (@{$dep->{$module}}) {
        if( $exp->{$_} ) {
            warn "resolved symbol $_ in file $exp->{$_}\n" if $verbose;
            next if $exp->{$_} =~ /vmlinux/;
            $mod->{$module}{$exp->{$_}} = 1;
        } else {
            warn "unresolved symbol $_ in file $module\n";
        }
    }
}

# build a complete dependency list for each module and make sure it
# is kept in order proper order
my $mod2 = {};
sub maybe_unshift
{
	my ($array, $ele) = @_;
	# chop off the leading path /lib/modules/<kver>/ as modprobe
	# will handle relative paths just fine
	$ele =~ s:^/lib/modules/[^/]*/::;
	foreach (@{$array}) {
		if ($_ eq $ele) {
			return;
		}
	}
	unshift (@{$array}, $ele);
}
sub add_mod_deps
{
	my ($depth, $mod, $mod2, $module, $this_module) = @_;

	$depth .= " ";
	warn "${depth}loading deps of module: $this_module\n" if $verbose;

	foreach my $md (keys %{$mod->{$this_module}}) {
		add_mod_deps ($depth, $mod, $mod2, $module, $md);
		warn "${depth} outputting $md\n" if $verbose;
		maybe_unshift (\@{$$mod2->{$module}}, $md);
	}

	if (!%{$mod->{$this_module}}) {
		warn "${depth} no deps\n" if $verbose;
	}
}
foreach my $module (keys %$mod) {
	warn "filling out module: $module\n" if $verbose;
	@{$mod2->{$module}} = ();
	add_mod_deps ("", $mod, \$mod2, $module, $module);
}

# figure out where the output should go
if ($stdout == 0) {
	warn "writing $basedir/modules.dep\n" if $verbose;
    open(STDOUT, ">$basedir/modules.dep")
                             or die "cannot open $basedir/modules.dep: $!";
}
my $kseries = $basedir =~ m,/2\.6\.[^/]*, ? '2.6' : '2.4';

foreach my $module ( keys %$mod ) {
    if($kseries eq '2.4') {
	    print "$module:\t";
	    my @sorted = sort bydep keys %{$mod->{$module}};
	    print join(" \\\n\t",@sorted);
	    print "\n\n";
    } else {
	    my $shortmod = $module;
	    $shortmod =~ s:^/lib/modules/[^/]*/::;
	    print "$shortmod:";
	    my @sorted = @{$mod2->{$module}};
	    printf " " if @sorted;
	    print join(" ",@sorted);
	    print "\n";
    }
}


sub build_ref_tables
{
    my ($name, $sym_ar, $exp, $dep) = @_;

	my $ksymtab = grep m/ ${symprefix}__ksymtab/, @$sym_ar;

    # gather the exported symbols
	if($ksymtab){
        # explicitly exported
        foreach ( @$sym_ar ) {
            / ${symprefix}__ksymtab_(.*)$/ and do {
                my $sym = ${symprefix} . $1;
                warn "sym = $sym\n" if $verbose;
                $exp->{$sym} = $name;
            };
        }
	} else {
        # exporting all symbols
        foreach ( @$sym_ar ) {
            / [ABCDGRSTW] (.*)$/ and do {
                warn "syma = $1\n" if $verbose;
                $exp->{$1} = $name;
            };
        }
	}

    # this takes makes sure modules with no dependencies get listed
    push @{$dep->{$name}}, $symprefix . 'printk' unless $name eq 'vmlinux';

    # gather the unresolved symbols
    foreach ( @$sym_ar ) {
        !/ ${symprefix}__this_module/ && / U (.*)$/ and do {
            warn "und = $1\n" if $verbose;
            push @{$dep->{$name}}, $1;
        };
    }
}

sub bydep
{
    foreach my $f ( keys %{$mod->{$b}} ) {
        if($f eq $a) {
            return 1;
        }
    }
    return -1;
}


__END__

=head1 NAME

depmod.pl - a cross platform script to generate kernel module
dependency lists (modules.conf) which can then be used by modprobe
on the target platform.

It supports Linux 2.4 and 2.6 styles of modules.conf (auto-detected)

=head1 SYNOPSIS

depmod.pl [OPTION]... [basedir]...

Example:

	depmod.pl -F linux/System.map -b target/lib/modules/2.6.11

=head1 DESCRIPTION

The purpose of this script is to automagically generate a list of of kernel
module dependencies.  This script produces dependency lists that should be
identical to the depmod program from the modutils package.  Unlike the depmod
binary, however, depmod.pl is designed to be run on your host system, not
on your target system.

This script was written by David Schleef <ds@schleef.org> to be used in
conjunction with the BusyBox modprobe applet.

=head1 OPTIONS

=over 4

=item B<-h --help>

This displays the help message.

=item B<-b --basedir>

The base directory uner which the target's modules will be found.  This
defaults to the /lib/modules directory.

If you don't specify the kernel version, this script will search for
one under the specified based directory and use the first thing that
looks like a kernel version.

=item B<-k --kernel>

Kernel binary for the target (vmlinux).  You must either supply a kernel binary
or a kernel symbol file (using the -F option).

=item B<-F --kernelsyms>

Kernel symbol file for the target (System.map).

=item B<-n --stdout>

Write to stdout instead of modules.dep
kernel binary for the target (using the -k option).

=item B<--verbose>

Verbose (debug) output

=back

=head1 COPYRIGHT AND LICENSE

 Copyright (c) 2001 David Schleef <ds@schleef.org>
 Copyright (c) 2001 Erik Andersen <andersen@codepoet.org>
 Copyright (c) 2001 Stuart Hughes <seh@zee2.com>
 Copyright (c) 2002 Steven J. Hill <shill@broadcom.com>
 Copyright (c) 2006 Freescale Semiconductor, Inc <stuarth@freescale.com>

This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.

=head1 AUTHOR

David Schleef <ds@schleef.org>

=cut
1	#!/usr/bin/perl -w
2	# vi: set sw=4 ts=4:
3	# Copyright (c) 2001 David Schleef <ds@schleef.org>
4	# Copyright (c) 2001 Erik Andersen <andersen@codepoet.org>
5	# Copyright (c) 2001 Stuart Hughes <seh@zee2.com>
6	# Copyright (c) 2002 Steven J. Hill <shill@broadcom.com>
7	# Copyright (c) 2006 Freescale Semiconductor, Inc <stuarth@freescale.com>
8	#
9	# History:
10	# March 2006: Stuart Hughes <stuarth@freescale.com>.
11	# Significant updates, including implementing the '-F' option
12	# and adding support for 2.6 kernels.
13
14	# This program is free software; you can redistribute it and/or modify it
15	# under the same terms as Perl itself.
16	use Getopt::Long qw(:config no_auto_abbrev no_ignore_case);
17	use File::Find;
18	use strict;
19
20	# Set up some default values
21	my $kdir="";
22	my $basedir="";
23	my $kernel="";
24	my $kernelsyms="";
25	my $symprefix="";
26	my $all=0;
27	my $quick=0;
28	my $errsyms=0;
29	my $stdout=0;
30	my $verbose=0;
31	my $help=0;
32	my $nm = $ENV{'NM'} \|\| "nm";
33
34	# more globals
35	my (@liblist) = ();
36	my $exp = {};
37	my $dep = {};
38	my $mod = {};
39
40	my $usage = <<TXT;
41	$0 -b basedir { -k <vmlinux> \| -F <System.map> } [options]...
42	Where:
43	-h --help : Show this help screen
44	-b --basedir : Modules base directory (e.g /lib/modules/<2.x.y>)
45	-k --kernel : Kernel binary for the target (e.g. vmlinux)
46	-F --kernelsyms : Kernel symbol file (e.g. System.map)
47	-n --stdout : Write to stdout instead of <basedir>/modules.dep
48	-v --verbose : Print out lots of debugging stuff
49	-P --symbol-prefix : Symbol prefix
50	-a --all : Probe all modules (default/only thing supported)
51	-e --errsyms : Report any symbols not supplied by modules/kernel
52	TXT
53
54	# get command-line options
55	GetOptions(
56	"help\|h" => \$help,
57	"basedir\|b=s" => \$basedir,
58	"kernel\|k=s" => \$kernel,
59	"kernelsyms\|F=s" => \$kernelsyms,
60	"stdout\|n" => \$stdout,
61	"verbose\|v" => \$verbose,
62	"symbol-prefix\|P=s" => \$symprefix,
63	"all\|a" => \$all,
64	# unsupported options
65	"quick\|A" => \$quick,
66	# ignored options (for historical usage)
67	"quiet\|q",
68	"root\|r",
69	"unresolved-error\|u"
70	);
71
72	die $usage if $help;
73	die $usage unless $basedir && ( $kernel \|\| $kernelsyms );
74	die "can't use both -k and -F\n\n$usage" if $kernel && $kernelsyms;
75	die "sorry, -A/--quick is not supported" if $quick;
76	die "--errsyms requires --kernelsyms" if $errsyms && !$kernelsyms;
77
78	# Strip any trailing or multiple slashes from basedir
79	$basedir =~ s-/+$--g;
80
81	# The base directory should contain /lib/modules somewhere
82	if($basedir !~ m-/lib/modules-) {
83	warn "WARNING: base directory does not match ..../lib/modules\n";
84	}
85
86	# if no kernel version is contained in the basedir, try to find one
87	if($basedir !~ m-/lib/modules/\d\.\d-) {
88	opendir(BD, $basedir) or die "can't open basedir $basedir : $!\n";
89	foreach ( readdir(BD) ) {
90	next if /^\.\.?$/;
91	next unless -d "$basedir/$_";
92	warn "dir = $_\n" if $verbose;
93	if( /^\d\.\d/ ) {
94	$kdir = $_;
95	warn("Guessed module directory as $basedir/$kdir\n");
96	last;
97	}
98	}
99	closedir(BD);
100	die "Cannot find a kernel version under $basedir\n" unless $kdir;
101	$basedir = "$basedir/$kdir";
102	}
103
104	# Find the list of .o or .ko files living under $basedir
105	warn "**** Locating all modules\n" if $verbose;
106	find sub {
107	my $file;
108	if ( -f $_ && ! -d $_ ) {
109	$file = $File::Find::name;
110	if ( $file =~ /\.k?o$/ ) {
111	push(@liblist, $file);
112	warn "$file\n" if $verbose;
113	}
114	}
115	}, $basedir;
116	warn "**** Finished locating modules\n" if $verbose;
117
118	foreach my $obj ( @liblist ){
119	# turn the input file name into a target tag name
120	my ($tgtname) = $obj =~ m-(/lib/modules/.*)$-;
121
122	warn "\nMODULE = $tgtname\n" if $verbose;
123
124	# get a list of symbols
125	my @output=`$nm $obj`;
126
127	build_ref_tables($tgtname, \@output, $exp, $dep);
128	}
129
130
131	# vmlinux is a special name that is only used to resolve symbols
132	my $tgtname = 'vmlinux';
133	my @output = $kernelsyms ? `cat $kernelsyms` : `$nm $kernel`;
134	warn "\nMODULE = $tgtname\n" if $verbose;
135	build_ref_tables($tgtname, \@output, $exp, $dep);
136
137	# resolve the dependencies for each module
138	# reduce dependencies: remove unresolvable and resolved from vmlinux/System.map
139	# remove duplicates
140	foreach my $module (keys %$dep) {
141	warn "reducing module: $module\n" if $verbose;
142	$mod->{$module} = {};
143	foreach (@{$dep->{$module}}) {
144	if( $exp->{$_} ) {
145	warn "resolved symbol $_ in file $exp->{$_}\n" if $verbose;
146	next if $exp->{$_} =~ /vmlinux/;
147	$mod->{$module}{$exp->{$_}} = 1;
148	} else {
149	warn "unresolved symbol $_ in file $module\n";
150	}
151	}
152	}
153
154	# build a complete dependency list for each module and make sure it
155	# is kept in order proper order
156	my $mod2 = {};
157	sub maybe_unshift
158	{
159	my ($array, $ele) = @_;
160	# chop off the leading path /lib/modules/<kver>/ as modprobe
161	# will handle relative paths just fine
162	$ele =~ s:^/lib/modules/[^/]*/::;
163	foreach (@{$array}) {
164	if ($_ eq $ele) {
165	return;
166	}
167	}
168	unshift (@{$array}, $ele);
169	}
170	sub add_mod_deps
171	{
172	my ($depth, $mod, $mod2, $module, $this_module) = @_;
173
174	$depth .= " ";
175	warn "${depth}loading deps of module: $this_module\n" if $verbose;
176
177	foreach my $md (keys %{$mod->{$this_module}}) {
178	add_mod_deps ($depth, $mod, $mod2, $module, $md);
179	warn "${depth} outputting $md\n" if $verbose;
180	maybe_unshift (\@{$$mod2->{$module}}, $md);
181	}
182
183	if (!%{$mod->{$this_module}}) {
184	warn "${depth} no deps\n" if $verbose;
185	}
186	}
187	foreach my $module (keys %$mod) {
188	warn "filling out module: $module\n" if $verbose;
189	@{$mod2->{$module}} = ();
190	add_mod_deps ("", $mod, \$mod2, $module, $module);
191	}
192
193	# figure out where the output should go
194	if ($stdout == 0) {
195	warn "writing $basedir/modules.dep\n" if $verbose;
196	open(STDOUT, ">$basedir/modules.dep")
197	or die "cannot open $basedir/modules.dep: $!";
198	}
199	my $kseries = $basedir =~ m,/2\.6\.[^/]*, ? '2.6' : '2.4';
200
201	foreach my $module ( keys %$mod ) {
202	if($kseries eq '2.4') {
203	print "$module:\t";
204	my @sorted = sort bydep keys %{$mod->{$module}};
205	print join(" \\\n\t",@sorted);
206	print "\n\n";
207	} else {
208	my $shortmod = $module;
209	$shortmod =~ s:^/lib/modules/[^/]*/::;
210	print "$shortmod:";
211	my @sorted = @{$mod2->{$module}};
212	printf " " if @sorted;
213	print join(" ",@sorted);
214	print "\n";
215	}
216	}
217
218
219	sub build_ref_tables
220	{
221	my ($name, $sym_ar, $exp, $dep) = @_;
222
223	my $ksymtab = grep m/ ${symprefix}__ksymtab/, @$sym_ar;
224
225	# gather the exported symbols
226	if($ksymtab){
227	# explicitly exported
228	foreach ( @$sym_ar ) {
229	/ ${symprefix}__ksymtab_(.*)$/ and do {
230	my $sym = ${symprefix} . $1;
231	warn "sym = $sym\n" if $verbose;
232	$exp->{$sym} = $name;
233	};
234	}
235	} else {
236	# exporting all symbols
237	foreach ( @$sym_ar ) {
238	/ [ABCDGRSTW] (.*)$/ and do {
239	warn "syma = $1\n" if $verbose;
240	$exp->{$1} = $name;
241	};
242	}
243	}
244
245	# this takes makes sure modules with no dependencies get listed
246	push @{$dep->{$name}}, $symprefix . 'printk' unless $name eq 'vmlinux';
247
248	# gather the unresolved symbols
249	foreach ( @$sym_ar ) {
250	!/ ${symprefix}__this_module/ && / U (.*)$/ and do {
251	warn "und = $1\n" if $verbose;
252	push @{$dep->{$name}}, $1;
253	};
254	}
255	}
256
257	sub bydep
258	{
259	foreach my $f ( keys %{$mod->{$b}} ) {
260	if($f eq $a) {
261	return 1;
262	}
263	}
264	return -1;
265	}
266
267
268
269	__END__
270
271	=head1 NAME
272
273	depmod.pl - a cross platform script to generate kernel module
274	dependency lists (modules.conf) which can then be used by modprobe
275	on the target platform.
276
277	It supports Linux 2.4 and 2.6 styles of modules.conf (auto-detected)
278
279	=head1 SYNOPSIS
280
281	depmod.pl [OPTION]... [basedir]...
282
283	Example:
284
285	depmod.pl -F linux/System.map -b target/lib/modules/2.6.11
286
287	=head1 DESCRIPTION
288
289	The purpose of this script is to automagically generate a list of of kernel
290	module dependencies. This script produces dependency lists that should be
291	identical to the depmod program from the modutils package. Unlike the depmod
292	binary, however, depmod.pl is designed to be run on your host system, not
293	on your target system.
294
295	This script was written by David Schleef <ds@schleef.org> to be used in
296	conjunction with the BusyBox modprobe applet.
297
298	=head1 OPTIONS
299
300	=over 4
301
302	=item B<-h --help>
303
304	This displays the help message.
305
306	=item B<-b --basedir>
307
308	The base directory uner which the target's modules will be found. This
309	defaults to the /lib/modules directory.
310
311	If you don't specify the kernel version, this script will search for
312	one under the specified based directory and use the first thing that
313	looks like a kernel version.
314
315	=item B<-k --kernel>
316
317	Kernel binary for the target (vmlinux). You must either supply a kernel binary
318	or a kernel symbol file (using the -F option).
319
320	=item B<-F --kernelsyms>
321
322	Kernel symbol file for the target (System.map).
323
324	=item B<-n --stdout>
325
326	Write to stdout instead of modules.dep
327	kernel binary for the target (using the -k option).
328
329	=item B<--verbose>
330
331	Verbose (debug) output
332
333	=back
334
335	=head1 COPYRIGHT AND LICENSE
336
337	Copyright (c) 2001 David Schleef <ds@schleef.org>
338	Copyright (c) 2001 Erik Andersen <andersen@codepoet.org>
339	Copyright (c) 2001 Stuart Hughes <seh@zee2.com>
340	Copyright (c) 2002 Steven J. Hill <shill@broadcom.com>
341	Copyright (c) 2006 Freescale Semiconductor, Inc <stuarth@freescale.com>
342
343	This program is free software; you can redistribute it and/or modify it
344	under the same terms as Perl itself.
345
346	=head1 AUTHOR
347
348	David Schleef <ds@schleef.org>
349
350	=cut