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;
use File::Find;
use strict;

# Set up some default values
my $kdir="";
my $basedir="";
my $kernel="";
my $kernelsyms="";
my $symprefix="";
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
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,
);

die $usage if $help;
die $usage unless $basedir && ( $kernel || $kernelsyms );
die "can't use both -k and -F\n\n$usage" if $kernel && $kernelsyms;

# Strip any trailing or multiple slashes from basedir
$basedir =~ s-(/)\1+-/-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";
        }
    }
}

# figure out where the output should go
if ($stdout == 0) {
    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 {
	    print "$module: ";
	    my @sorted = sort bydep keys %{$mod->{$module}};
	    print join(" ",@sorted);
	    print "\n";
    }
}


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

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

    # gather the exported symbols
	if($ksymtab){
        # explicitly exported
        foreach ( @$sym_ar ) {
            / __ksymtab_(.*)$/ and do {
                warn "sym = $1\n" if $verbose;
                $exp->{$1} = $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 ) {
        !/ __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;
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 $stdout=0;
27	my $verbose=0;
28	my $help=0;
29	my $nm = $ENV{'NM'} \|\| "nm";
30
31	# more globals
32	my (@liblist) = ();
33	my $exp = {};
34	my $dep = {};
35	my $mod = {};
36
37	my $usage = <<TXT;
38	$0 -b basedir { -k <vmlinux> \| -F <System.map> } [options]...
39	Where:
40	-h --help : Show this help screen
41	-b --basedir : Modules base directory (e.g /lib/modules/<2.x.y>)
42	-k --kernel : Kernel binary for the target (e.g. vmlinux)
43	-F --kernelsyms : Kernel symbol file (e.g. System.map)
44	-n --stdout : Write to stdout instead of <basedir>/modules.dep
45	-v --verbose : Print out lots of debugging stuff
46	-P --symbol-prefix : Symbol prefix
47	TXT
48
49	# get command-line options
50	GetOptions(
51	"help\|h" => \$help,
52	"basedir\|b=s" => \$basedir,
53	"kernel\|k=s" => \$kernel,
54	"kernelsyms\|F=s" => \$kernelsyms,
55	"stdout\|n" => \$stdout,
56	"verbose\|v" => \$verbose,
57	"symbol-prefix\|P=s" => \$symprefix,
58	);
59
60	die $usage if $help;
61	die $usage unless $basedir && ( $kernel \|\| $kernelsyms );
62	die "can't use both -k and -F\n\n$usage" if $kernel && $kernelsyms;
63
64	# Strip any trailing or multiple slashes from basedir
65	$basedir =~ s-(/)\1+-/-g;
66
67	# The base directory should contain /lib/modules somewhere
68	if($basedir !~ m-/lib/modules-) {
69	warn "WARNING: base directory does not match ..../lib/modules\n";
70	}
71
72	# if no kernel version is contained in the basedir, try to find one
73	if($basedir !~ m-/lib/modules/\d\.\d-) {
74	opendir(BD, $basedir) or die "can't open basedir $basedir : $!\n";
75	foreach ( readdir(BD) ) {
76	next if /^\.\.?$/;
77	next unless -d "$basedir/$_";
78	warn "dir = $_\n" if $verbose;
79	if( /^\d\.\d/ ) {
80	$kdir = $_;
81	warn("Guessed module directory as $basedir/$kdir\n");
82	last;
83	}
84	}
85	closedir(BD);
86	die "Cannot find a kernel version under $basedir\n" unless $kdir;
87	$basedir = "$basedir/$kdir";
88	}
89
90	# Find the list of .o or .ko files living under $basedir
91	warn "**** Locating all modules\n" if $verbose;
92	find sub {
93	my $file;
94	if ( -f $_ && ! -d $_ ) {
95	$file = $File::Find::name;
96	if ( $file =~ /\.k?o$/ ) {
97	push(@liblist, $file);
98	warn "$file\n" if $verbose;
99	}
100	}
101	}, $basedir;
102	warn "**** Finished locating modules\n" if $verbose;
103
104	foreach my $obj ( @liblist ){
105	# turn the input file name into a target tag name
106	my ($tgtname) = $obj =~ m-(/lib/modules/.*)$-;
107
108	warn "\nMODULE = $tgtname\n" if $verbose;
109
110	# get a list of symbols
111	my @output=`$nm $obj`;
112
113	build_ref_tables($tgtname, \@output, $exp, $dep);
114	}
115
116
117	# vmlinux is a special name that is only used to resolve symbols
118	my $tgtname = 'vmlinux';
119	my @output = $kernelsyms ? `cat $kernelsyms` : `$nm $kernel`;
120	warn "\nMODULE = $tgtname\n" if $verbose;
121	build_ref_tables($tgtname, \@output, $exp, $dep);
122
123	# resolve the dependencies for each module
124	# reduce dependencies: remove unresolvable and resolved from vmlinux/System.map
125	# remove duplicates
126	foreach my $module (keys %$dep) {
127	warn "reducing module: $module\n" if $verbose;
128	$mod->{$module} = {};
129	foreach (@{$dep->{$module}}) {
130	if( $exp->{$_} ) {
131	warn "resolved symbol $_ in file $exp->{$_}\n" if $verbose;
132	next if $exp->{$_} =~ /vmlinux/;
133	$mod->{$module}{$exp->{$_}} = 1;
134	} else {
135	warn "unresolved symbol $_ in file $module\n";
136	}
137	}
138	}
139
140	# figure out where the output should go
141	if ($stdout == 0) {
142	open(STDOUT, ">$basedir/modules.dep")
143	or die "cannot open $basedir/modules.dep: $!";
144	}
145	my $kseries = $basedir =~ m,/2\.6\.[^/]*, ? '2.6' : '2.4';
146
147	foreach my $module ( keys %$mod ) {
148	if($kseries eq '2.4') {
149	print "$module:\t";
150	my @sorted = sort bydep keys %{$mod->{$module}};
151	print join(" \\\n\t",@sorted);
152	print "\n\n";
153	} else {
154	print "$module: ";
155	my @sorted = sort bydep keys %{$mod->{$module}};
156	print join(" ",@sorted);
157	print "\n";
158	}
159	}
160
161
162	sub build_ref_tables
163	{
164	my ($name, $sym_ar, $exp, $dep) = @_;
165
166	my $ksymtab = grep m/ __ksymtab/, @$sym_ar;
167
168	# gather the exported symbols
169	if($ksymtab){
170	# explicitly exported
171	foreach ( @$sym_ar ) {
172	/ __ksymtab_(.*)$/ and do {
173	warn "sym = $1\n" if $verbose;
174	$exp->{$1} = $name;
175	};
176	}
177	} else {
178	# exporting all symbols
179	foreach ( @$sym_ar ) {
180	/ [ABCDGRSTW] (.*)$/ and do {
181	warn "syma = $1\n" if $verbose;
182	$exp->{$1} = $name;
183	};
184	}
185	}
186
187	# this takes makes sure modules with no dependencies get listed
188	push @{$dep->{$name}}, $symprefix . 'printk' unless $name eq 'vmlinux';
189
190	# gather the unresolved symbols
191	foreach ( @$sym_ar ) {
192	!/ __this_module/ && / U (.*)$/ and do {
193	warn "und = $1\n" if $verbose;
194	push @{$dep->{$name}}, $1;
195	};
196	}
197	}
198
199	sub bydep
200	{
201	foreach my $f ( keys %{$mod->{$b}} ) {
202	if($f eq $a) {
203	return 1;
204	}
205	}
206	return -1;
207	}
208
209
210
211	__END__
212
213	=head1 NAME
214
215	depmod.pl - a cross platform script to generate kernel module
216	dependency lists (modules.conf) which can then be used by modprobe
217	on the target platform.
218
219	It supports Linux 2.4 and 2.6 styles of modules.conf (auto-detected)
220
221	=head1 SYNOPSIS
222
223	depmod.pl [OPTION]... [basedir]...
224
225	Example:
226
227	depmod.pl -F linux/System.map -b target/lib/modules/2.6.11
228
229	=head1 DESCRIPTION
230
231	The purpose of this script is to automagically generate a list of of kernel
232	module dependencies. This script produces dependency lists that should be
233	identical to the depmod program from the modutils package. Unlike the depmod
234	binary, however, depmod.pl is designed to be run on your host system, not
235	on your target system.
236
237	This script was written by David Schleef <ds@schleef.org> to be used in
238	conjunction with the BusyBox modprobe applet.
239
240	=head1 OPTIONS
241
242	=over 4
243
244	=item B<-h --help>
245
246	This displays the help message.
247
248	=item B<-b --basedir>
249
250	The base directory uner which the target's modules will be found. This
251	defaults to the /lib/modules directory.
252
253	If you don't specify the kernel version, this script will search for
254	one under the specified based directory and use the first thing that
255	looks like a kernel version.
256
257	=item B<-k --kernel>
258
259	Kernel binary for the target (vmlinux). You must either supply a kernel binary
260	or a kernel symbol file (using the -F option).
261
262	=item B<-F --kernelsyms>
263
264	Kernel symbol file for the target (System.map).
265
266	=item B<-n --stdout>
267
268	Write to stdout instead of modules.dep
269	kernel binary for the target (using the -k option).
270
271	=item B<--verbose>
272
273	Verbose (debug) output
274
275	=back
276
277	=head1 COPYRIGHT AND LICENSE
278
279	Copyright (c) 2001 David Schleef <ds@schleef.org>
280	Copyright (c) 2001 Erik Andersen <andersen@codepoet.org>
281	Copyright (c) 2001 Stuart Hughes <seh@zee2.com>
282	Copyright (c) 2002 Steven J. Hill <shill@broadcom.com>
283	Copyright (c) 2006 Freescale Semiconductor, Inc <stuarth@freescale.com>
284
285	This program is free software; you can redistribute it and/or modify it
286	under the same terms as Perl itself.
287
288	=head1 AUTHOR
289
290	David Schleef <ds@schleef.org>
291
292	=cut