mirror of
https://github.com/crosstool-ng/crosstool-ng.git
synced 2024-12-19 04:47:52 +00:00
1913d355b3
If a list-file is used, then each library in the file will be handled twice (not a real issue, as the second iteration will find the library already present, just avoid doing the job twice).
271 lines
9.3 KiB
Plaintext
271 lines
9.3 KiB
Plaintext
#!@@CT_bash@@
|
|
# This script will populate the root directory with libs from the sysroot.
|
|
# (C) 2007 Yann E. MORIN
|
|
# Licensed under the GPL v2
|
|
set -e
|
|
|
|
# Use the tools discovered by crosstool-NG's ./configure:
|
|
install="@@CT_install@@"
|
|
grep="@@CT_grep@@"
|
|
sed="@@CT_sed@@"
|
|
|
|
# Detect where the toolchain is:
|
|
CT_PREFIX_DIR="$(cd "$(dirname "$0")/.."; pwd)"
|
|
CT_GCC="${0%-populate}-gcc"
|
|
CT_READELF="${0%-populate}-readelf"
|
|
CT_CFG_PREFIX_DIR="$("${CT_GCC}" -v 2>&1 \
|
|
|tr ' ' '\n' \
|
|
|"${grep}" -E -- '--prefix=' \
|
|
|cut -d = -f 2-
|
|
)"
|
|
CT_CFG_SYSROOT_DIR="$("${CT_GCC}" -v 2>&1 \
|
|
|tr ' ' '\n' \
|
|
|"${grep}" -E -- '--with-sysroot=' \
|
|
|cut -d = -f 2-
|
|
)"
|
|
CT_SYSROOT_DIR="$(echo "${CT_CFG_SYSROOT_DIR}" \
|
|
|"${sed}" -r -e "s:^${CT_CFG_PREFIX_DIR}:${CT_PREFIX_DIR}:;" \
|
|
|"${sed}" -r -e 's,/+,/,g;' \
|
|
)"
|
|
|
|
myname=$(basename "$0")
|
|
|
|
doHelp() {
|
|
cat <<_EOF_
|
|
NAME
|
|
$myname - populate the target root file system
|
|
|
|
SYNOPSIS
|
|
$myname OPTIONS -s source_root -d destination_root
|
|
|
|
DESCRIPTION
|
|
$myname will 'populate' your target root file system ('src_dir') with
|
|
libraries from the toolchain (eg. libc.so...), storing the result into
|
|
'dst_dir'.
|
|
|
|
OPTIONS
|
|
-s src_dir
|
|
use 'src_dir' as the un-populated (source) root directory
|
|
|
|
-d dst_dir
|
|
use 'dst_dir' as the place to put the populated root directory
|
|
|
|
-r sysroot_dir
|
|
use 'sysroot_dir' as the sysroot instead of the toolchain default
|
|
|
|
-l name1[:name2[...]]
|
|
Always add the specified shared library/ies name1, name2... from the
|
|
toolchain (in the sys-root). Actual library names are searched as
|
|
follows (where 'name' is replaced with the given name) in the
|
|
sys-root directory:
|
|
- libname.so
|
|
- name.so
|
|
- name
|
|
If the file is found, then the SONAME of the library is used, and the
|
|
library is copied with that name. If the library was not found, this
|
|
yields an error (unless -f was given).
|
|
|
|
-L file
|
|
Read 'file' for a list of shared libraries to always add from the
|
|
toolchain. The file should contain one library name per line; text
|
|
after a # is ignored until the end of the line; spaces are ignored;
|
|
empty lines are ignored. Libraries are searched for as with -l.
|
|
|
|
-f force execution: if destination directory already exists, it will be
|
|
removed first; if a specified library (above) was not found, continue.
|
|
Note: if using -m and the destination directory already exists, it
|
|
is *not* removed, see below.
|
|
|
|
-m Merge the source root directory with the destination root directory.
|
|
If the latter does not exist, it is created, and -m is ignored.
|
|
If the destination droot directory exists, then the content of the
|
|
source root directory is copied in there, and the result is populated
|
|
as usual.
|
|
It can be usefull if constructing a rootfs incrementally from many
|
|
smaller source root directories, or if your destination root directory
|
|
is an NFS export that your target mounts as / (and you don't want to
|
|
re-run exportfs -av everytime). USE WITH CARE!
|
|
|
|
-v Be verbose. By default, populate is absolutely silent.
|
|
|
|
_EOF_
|
|
}
|
|
|
|
CT_ROOT_SRC_DIR=
|
|
CT_ROOT_DST_DIR=
|
|
CT_LIB_LIST=
|
|
CT_LIB_FILE=
|
|
CT_MERGE=
|
|
CT_FORCE=
|
|
CT_PRINTF=:
|
|
OPTIND=1
|
|
while getopts ":s:d:r:l:L:fmvh" CT_OPT; do
|
|
case "${CT_OPT}" in
|
|
s) CT_ROOT_SRC_DIR="${OPTARG}";;
|
|
d) CT_ROOT_DST_DIR="${OPTARG}";;
|
|
r) CT_SYSROOT_DIR="${OPTARG}";;
|
|
l) CT_LIB_LIST="${CT_LIB_LIST}:${OPTARG}";;
|
|
L) CT_LIB_FILE="${OPTARG}";;
|
|
f) CT_FORCE=y;;
|
|
m) CT_MERGE=y;;
|
|
v) CT_PRINTF=printf;;
|
|
h) doHelp
|
|
exit 0
|
|
;;
|
|
:) echo "$myname: '-${OPTARG}' takes exactly one argument."
|
|
exit 1
|
|
;;
|
|
?) echo "$myname: unknown option '-${OPTARG}'."
|
|
exit 1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
# Sanity checks
|
|
if [ -z "${CT_ROOT_SRC_DIR}" -o -z "${CT_ROOT_DST_DIR}" ]; then
|
|
doHelp
|
|
exit 1
|
|
fi
|
|
if [ ! -d "${CT_ROOT_SRC_DIR}" ]; then
|
|
echo "$myname: '${CT_ROOT_SRC_DIR}': no such file or directory"
|
|
exit 1
|
|
fi
|
|
if [ ! -d "${CT_SYSROOT_DIR}" ]; then
|
|
echo "$myname: '${CT_SYSROOT_DIR}': no such file or directory"
|
|
exit 1
|
|
fi
|
|
# If the dest dir does not exist, all is well
|
|
# If merging, we accept an existing dest directory
|
|
# If forcing and not merging, we remove an exiting dest directory
|
|
# If not forcing and not merging, we do not accept an exiting dest directory
|
|
if [ -d "${CT_ROOT_DST_DIR}" ]; then
|
|
case "${CT_FORCE}:${CT_MERGE}" in
|
|
*:y) ;;
|
|
y:) rm -rf "${CT_ROOT_DST_DIR}";;
|
|
:) echo "$myname: '${CT_ROOT_DST_DIR}': already exists" && exit 1 ;;
|
|
esac
|
|
fi
|
|
src_inode=$(stat -c '%i' "${CT_ROOT_SRC_DIR}/.")
|
|
dst_inode=$(stat -c '%i' "${CT_ROOT_DST_DIR}/." 2>/dev/null || true)
|
|
if [ "${src_inode}" -eq "$((dst_inode+0))" ]; then
|
|
echo "$myname: source and destination are the same!"
|
|
exit 1
|
|
fi
|
|
|
|
# Check existence of the forced libraries file
|
|
if [ -n "${CT_LIB_FILE}" -a ! \( -f "${CT_LIB_FILE}" -a -r "${CT_LIB_FILE}" \) ]; then
|
|
echo "$myname: forced libraries file '${CT_LIB_FILE}' not found!"
|
|
exit 1
|
|
fi
|
|
|
|
# Create the working copy, no issue if already existing
|
|
mkdir -p "${CT_ROOT_DST_DIR}"
|
|
|
|
# Make all path absolute
|
|
CT_ROOT_SRC_DIR=$(cd "${CT_ROOT_SRC_DIR}"; pwd)
|
|
CT_ROOT_DST_DIR=$(cd "${CT_ROOT_DST_DIR}"; pwd)
|
|
|
|
# Populate the destination directory with files from the source directory
|
|
pushd "${CT_ROOT_SRC_DIR}" >/dev/null
|
|
cp -a . "${CT_ROOT_DST_DIR}"
|
|
popd >/dev/null
|
|
|
|
# A function do search for a library
|
|
# Usage: do_add_lib libname
|
|
# returns: 0 if library was found and added, !0 otherwise
|
|
do_add_lib() {
|
|
local libname="$1"
|
|
local true_libname
|
|
local dir
|
|
local mode
|
|
|
|
for dir in lib usr/lib; do
|
|
${CT_PRINTF} " trying in '%s'" "${dir}"
|
|
libfile="${CT_SYSROOT_DIR}/${dir}/${libname}"
|
|
${CT_PRINTF} ": '%s'\n" "${libfile}"
|
|
if [ -e "${libfile}" ]; then
|
|
mkdir -p "${dir}"
|
|
true_libname=$("${CT_READELF}" -d "${libfile}" \
|
|
|"${grep}" "Library soname:" \
|
|
|"${sed}" -r -e 's,.+\[(.+)\] *$,\1,;' \
|
|
)
|
|
case "${libfile}" in
|
|
*/ld*) mode=0755;;
|
|
*) mode=0644;;
|
|
esac
|
|
${CT_PRINTF} " installing as '%s/%s', mode='%s'\n" "${dir}" "${true_libname}" "${mode}"
|
|
"${install}" -m "${mode}" "${libfile}" "${dir}/${true_libname}"
|
|
return 0
|
|
break
|
|
fi
|
|
done
|
|
return 1
|
|
}
|
|
|
|
# We'll work in the copied rootfs
|
|
pushd "${CT_ROOT_DST_DIR}" >/dev/null
|
|
|
|
# First of, copy the forced libraries into the working copy
|
|
lib_list=
|
|
if [ -n "${CT_LIB_FILE}" ]; then
|
|
lib_list=$("${sed}" -r -e ':loop; s/#.*//;' \
|
|
-e 's/[[:space:]]+//g;' \
|
|
-e 's/([^:])$/\1:/;' \
|
|
-e '/$/N; s/\n//; tloop;' \
|
|
"${CT_LIB_FILE}"
|
|
)
|
|
fi
|
|
CT_LIB_LIST=$(echo "${CT_LIB_LIST}:${lib_list}" \
|
|
|"${sed}" -r -e 's/^:+//; s/:+$//; s/:+/ /g;' \
|
|
)
|
|
if [ -n "${CT_LIB_LIST}" ]; then
|
|
${CT_PRINTF} "Installing forced libraries...\n"
|
|
for name in ${CT_LIB_LIST}; do
|
|
[ -z "${name}" ] && continue
|
|
found=0
|
|
for libname in "lib${name}.so" "${name}.so" "${name}"; do
|
|
${CT_PRINTF} " searching for '%s'\n" "${libname}"
|
|
if do_add_lib "${libname}"; then
|
|
found=1
|
|
break
|
|
fi
|
|
done
|
|
if [ ${found} -eq 0 ]; then
|
|
echo "$myname: library '${libname}' not found!"
|
|
[ "${CT_FORCE}" = y ] || exit 1
|
|
fi
|
|
done
|
|
fi
|
|
|
|
# Parse the working copy for executables and libraries
|
|
still_needed=1
|
|
while [ ${still_needed} -eq 1 ]; do
|
|
${CT_PRINTF} "Looping...\n"
|
|
still_needed=0
|
|
for f in $(find . -type f -exec file {} \; \
|
|
|"${grep}" -E ': ELF [[:digit:]]+-bit (L|M)SB (executable|shared object),' \
|
|
|cut -d ":" -f 1 \
|
|
); do
|
|
${CT_PRINTF} "Scanning '%s'\n" "${f}"
|
|
for libname in $("${CT_READELF}" -d "${f}" \
|
|
|"${grep}" -E '\(NEEDED\)[[:space:]]+Shared library:' \
|
|
|"${sed}" -r -e 's,.+\[(.+)\] *$,\1,;' \
|
|
); do
|
|
${CT_PRINTF} " searching for '%s'\n" "${libname}"
|
|
if [ -e "lib/${libname}" \
|
|
-o -e "usr/lib/${libname}" ]; then
|
|
${CT_PRINTF} " already present\n"
|
|
continue
|
|
fi
|
|
if do_add_lib "${libname}"; then
|
|
still_needed=1
|
|
else
|
|
echo "$myname: library '${libname}' not found!"
|
|
fi
|
|
done
|
|
done
|
|
done
|
|
|
|
# OK, we're done. Back off.
|
|
popd >/dev/null
|