tree 3704d95e3049290c2efaff829d7ac2c77c97a681
parent 88f66ea98d7ae6a8b6a34e38b1b4fa51abc1c9ca
author Steven Rostedt <srostedt@redhat.com> 1265165487 -0500
committer Steven Rostedt <rostedt@goodmis.org> 1265165880 -0500

kconfig: Add LSMOD=file to override the lsmod for localmodconfig

Doing the following:

	make LSMOD=file localmodconfig

Will make the streamline-config code use the given file instead of
lsmod. If the file is an executable, it will execute it, otherwise
it will read it as text.

	make LSMOD=/my/local/path/lsmod localmodconfig

The above will execute the lsmod in /my/local/path instead of the
lsmods that may be located elsewhere.

	make LSMOD=embedded_board_lsmod localmodconfig

The above will read the "embedded_board_lsmod" as a text file. This
is useful if you are doing a cross compile and need to run the
config against modules that exist on an embedded device.

Note, if the LSMOD= file does is not a path, it will add the
path to the object directory. That is, the above example will look
for "embedded_board_lsmod" in the directory that the binary will
be built in (the O=dir directory).

Signed-off-by: Steven Rostedt <rostedt@goodmis.org>

 On branch config/linus
