blob: 3152cf049fc99e72b2116815510b90a39cb45c90 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
|
#!/bin/bash
MODE_DIR="${ROOT_DIR}/remote"
MODULES_DIR="${MODE_DIR}/modules"
KERNEL_DIR="${MODE_DIR}/builds/kernel"
# Keep track of processed modules
PROCESSED_MODULES=""
initial_checks () {
# check for required tools
for BIN in git locate depmod
do
local TEST=$(which ${BIN})
[ -z "$TEST" ] && pinfo "Installing $BIN..." && apt-get install $BIN
done
}
read_config () {
# unset previous variables from other config files
for VARNAME in "${!REQUIRED_*}"; do
unset $VARNAME
done
local MODULE_CONFIG="${MODULE_DIR}/${MODULE}.conf"
# otherwise, use the generic one
[ ! -e "${MODULE_CONFIG}" ] && perror "Config for '$MODULE' not found."
. "${MODULE_CONFIG}" || perror "Sourcing '${MODULE_CONFIG}' failed."
if [ -e "${MODULE_CONFIG}.${PACKET_MANAGER}" ]; then
# a specific tool.conf seems to exist, use it to override certain vars
. "${MODULE_CONFIG}.${PACKET_MANAGER}" || perror "Sourcing '${MODULE_CONFIG}.${PACKET_MANAGER}' failed."
fi
}
read_build () {
local BUILD_SCRIPT="${MODULE_DIR}/${MODULE}.build"
[ ! -e "${BUILD_SCRIPT}" ] && perror "Build script for specified tool not found."
. "${BUILD_SCRIPT}" || perror "Sourcing '${BUILD_SCRIPT}' failed."
}
copy_files_with_deps () {
[ ! -d $MODULE_BUILD_DIR ] && pinfo "No build directory found, skipping dependency copying" && return 0
cd $MODULE_BUILD_DIR
COPYFILES_LIST="list_wanted_stage3.2"
[ -e ${COPYFILES_LIST} ] && rm ${COPYFILES_LIST}
[ ! -z "${REQUIRED_BINARIES}" ] && pinfo "Gathering required binaries from config file..."
for FILENAME in ${REQUIRED_BINARIES}
do
local FILE_CANDIDATES=$( find . -name "${FILENAME}" -a \( -type f -o -type l \) )
# only do if more than one candidate found
if [ $(echo $FILE_CANDIDATES | wc -w) -gt 1 ]; then
pdebug "Candidates for $FILENAME are: $(echo $FILE_CANDIDATES)"
local FINAL_LIST=""
for FILE in $FILE_CANDIDATES; do
local TESTFILE="$(readlink -f "$FILE")"
pdebug " $FILE leads to $TESTFILE"
[ -f "$TESTFILE" -a -x "$TESTFILE" ] && [ "x$(grep -l -E '^(.ELF|#!)' "$TESTFILE")" != "x" ] && FINAL_LIST="$FINAL_LIST $FILE"
done
FINAL_LIST=$(trim "$FINAL_LIST")
if [ -z "$FINAL_LIST" ]; then
pwarning "\tNo Binary found for ${FILENAME}. Skipping."
continue
fi
if [[ "$FINAL_LIST" == *" "* ]]; then
pwarning "Found more than one match for required file '$FILENAME': $FINAL_LIST"
else
pdebug "\tFound ${FILENAME} at ${FILE}"
fi
else
# one candidate
FINAL_LIST=${FILE_CANDIDATES}
fi
for FILE in $FINAL_LIST; do
pdebug "* $FILE"
strip $FILE || pwarning "Could not strip '${FILE}'"
get_link_chain "${MODULE_BUILD_DIR}/${FILE}" "${MODULE_BUILD_DIR}" >> "${COPYFILES_LIST}"
get_dynamic_dependencies -l "${MODULE_BUILD_DIR}" "${FILE}" >> "${COPYFILES_LIST}"
done
done
[ ! -z "${REQUIRED_LIBRARIES}" ] && pinfo "Gathering required libraries from config file..."
for LIB in ${REQUIRED_LIBRARIES}
do
for LOCATION in $(find . -name ${LIB}.so\*)
do
pdebug "* $LOCATION"
strip $LOCATION || pwarning "Could not strip '${LOCATION}'"
get_link_chain "${MODULE_BUILD_DIR}/${LOCATION}" "${MODULE_BUILD_DIR}" >> "${COPYFILES_LIST}"
get_dynamic_dependencies -l "${MODULE_BUILD_DIR}" "${LOCATION}" >> "${COPYFILES_LIST}"
done
done
[ ! -z "${REQUIRED_DIRECTORIES}" ] && pinfo "Gathering required directories from config file..."
local CURRENT_PWD=$(pwd) # Prevent calling pwd 50000 times inside the loop below
for ENTRY in ${REQUIRED_DIRECTORIES}
do
pdebug "* .$ENTRY"
echo "./${ENTRY}" >> "${COPYFILES_LIST}"
for BIN in $(find ".${ENTRY}" -type f -not -name '*.a' | xargs grep -l '^.ELF')
do
#pdebug "\tSearching libs for ${BIN}..."
get_link_chain "${MODULE_BUILD_DIR}/${BIN}" "${MODULE_BUILD_DIR}" >> "${COPYFILES_LIST}"
get_dynamic_dependencies -l "${MODULE_BUILD_DIR}" "${BIN}" >> "${COPYFILES_LIST}"
done
done
[ ! -z "${REQUIRED_FILES}" ] && pinfo "Gathering required files from config file..."
for ENTRY in ${REQUIRED_FILES}
do
get_link_chain "${MODULE_BUILD_DIR}/${ENTRY}" "${MODULE_BUILD_DIR}" >> "${COPYFILES_LIST}"
get_dynamic_dependencies -l "${MODULE_BUILD_DIR}" "${MODULE_BUILD_DIR}/.${ENTRY}" >> "${COPYFILES_LIST}"
done
#copy to initramfsdir
pdebug "File list generated at ${MODULE_BUILD_DIR}/${COPYFILES_LIST}."
if [ -s "$COPYFILES_LIST" ]; then
local CLISTCOUNT=$(cat "$COPYFILES_LIST" | wc -l)
pinfo "Copying $CLISTCOUNT files to '${TARGET_BUILD_DIR}'."
tarcopy "$(cat "$COPYFILES_LIST"|sort -u)" "${TARGET_BUILD_DIR}"
fi
}
generate_target() {
initial_checks
copy_kernel
TARGET=$1 && shift
TARGET_DIR="${MODE_DIR}/targets/${TARGET}"
TARGET_BUILD_DIR="${MODE_DIR}/builds/${TARGET}"
[ -e "${ROOT_DIR}/logs/${TARGET}.size" ] && . "${ROOT_DIR}/logs/${TARGET}.size" || echo "declare -A BUILD_SIZE" >> "${ROOT_DIR}/logs/${TARGET}.size"
[ -d $TARGET_DIR ] || perror "Given target directory does not exist: $TARGET_DIR"
[[ $TARGET == builds || $TARGET == modules ]] && \
perror "Target directory cannot be named 'builds' nor 'modules'."
pinfo "Generating '$TARGET_BUILD_DIR' for '$TARGET'"
# if no arguments assume all.
if [ "x$1" = "x" -o "x$1" = "xall" ]; then
MODULES=$(ls ${TARGET_DIR})
set -- $MODULES
else
# tools = arguments given
MODULES=$@
fi
pinfo "Activated modules in '${TARGET}':"
pinfo "\t$(echo ${MODULES})"
# copy basic libs
pinfo "Copying libc and ld-linux used by ${SHELL}"
tarcopy "$(list_basic_libs)" "${TARGET_BUILD_DIR}"
[ -d "$TARGET_BUILD_DIR" ] && TARGET_BUILD_SIZE=$(du -bc "${TARGET_BUILD_DIR}" | awk 'END {print $1}') || TARGET_BUILD_SIZE=0
# now iterate over given tools and copy them
while (( "$#" )); do
process_module "$1"
shift
done
post_process_target
pinfo "Target completed. Total size: $(du -bsh "${TARGET_BUILD_DIR}" | awk 'END {print $1}')"
TOOL_STR=""
}
process_module() {
[ "$#" -ne "1" ] && perror "process_module: want 1 param."
local MODULE="$1"
[[ "$PROCESSED_MODULES" == *"!${MODULE}!"* ]] && return # Already processed this module
PROCESSED_MODULES="${PROCESSED_MODULES}!${MODULE}!"
local MODULE_DIR="${TARGET_DIR}/${MODULE}"
local MODULE_BUILD_DIR="${MODULE_DIR}/build"
local TOOL_STR=""
pinfo ">>>>>>>>>>>>>>>>> Processing module [ $MODULE ]"
TOOL_STR="[${MODULE}]"
if [ -d "${MODULE_DIR}" ]; then
#[ "x$DEBUG" != "x1" ] \
# && echo "Logging to ${TOOL_DIR}/${TOOL}/stage32.log" \
# && exec 6>&1 > ${TOOL_DIR}/${TOOL}/stage32.log
# TODO: Make above work with the new logging system (add function to logging.inc to switch logfile)
cd "${MODULE_DIR}" || perror "Module dir '${MODULE_DIR}' seems to exist, but cd to it failed."
pinfo "## Reading config"
read_config
# Check if this module has a dependency that wasn't built yet:
if [ ! -z "$REQUIRED_MODULES" ]; then
pinfo "$MODULE depends on ${REQUIRED_MODULES}...."
for DEP in $REQUIRED_MODULES; do
process_module "$DEP"
done
# Read old config again, as it got overwritten by the deps
cd "${MODULE_DIR}" || perror "Tool dir '${MODULE_DIR}' seems to exist, but cd to it failed (after building deps)."
read_config
pinfo "<<<<<<<<<<<<<<<<< Dependency modules processed, back to module [ $MODULE ]"
fi
pinfo "## Reading build"
read_build
pinfo "## Installing dependencies"
install_dependencies
pinfo "## Fetching source"
[ -e "${MODULE_DIR}/.fetched_source" ] || { fetch_source && touch "${MODULE_DIR}/.fetched_source"; }
pinfo "## Building"
[ -e "${MODULE_DIR}/.built" ] || { build && touch "${MODULE_DIR}/.built"; }
# remove *.la files as they might confuse libtool/linker of other tool packages
find "${MODULE_BUILD_DIR}" -name '*.la' -exec rm -f {} \;
[ -d "$TARGET_BUILD_DIR" ] && TARGET_BUILD_SIZE=$(du -bc "${TARGET_BUILD_DIR}" | awk 'END {print $1}') || TARGET_BUILD_SIZE=0
pinfo "## Copying files with dependencies"
copy_files_with_deps
pinfo "## Copying static module files"
copy_static_data
pinfo "## Post copy"
post_copy
# reset pipes
#[ "x$DEBUG" != "x1" ] && exec 1>&6 6>&-
# TODO
calc_size #sets MODULE_BUILD_SIZE
pinfo "Module completed. Total size: ${MODULE_BUILD_SIZE}"
else
pwarning "Module directory for '$MODULE' not found."
fi
}
post_process_target() {
local TOOL_STR="$TOOL_STR post_process_target:"
#move systemd files from /lib to /etc/lib
pinfo "move systemd files from /lib/systemd to /etc/systemd"
if [ -d "${TARGET_BUILD_DIR}/lib" ]; then
cd "${TARGET_BUILD_DIR}/lib"
tarcopy "systemd" "${TARGET_BUILD_DIR}/etc"
cd - &> /dev/null
rm -r "${TARGET_BUILD_DIR}/lib/systemd"
fi
}
clean_modules() {
TARGET=$1
TARGET_DIR="${MODE_DIR}/targets/${TARGET}"
TARGET_BUILD_DIR="${MODE_DIR}/builds/${TARGET}"
[ -d $TARGET_DIR ] || perror "Given target directory does not exist: $TARGET_DIR"
if [ "x$2" = "x" -o "x$2" = "xall" ]; then
if [ -e ${ROOT_DIR}/logs/${TARGET}.size ]; then
rm "${ROOT_DIR}/logs/${TARGET}.size" || perror "Could not delete logs/${TARGET}.size"
fi
if [ -d ${TARGET_BUILD_DIR} ]; then
pinfo "Cleaning '${TARGET_BUILD_DIR}'" \
&& rm -rf "${TARGET_BUILD_DIR}"/* \
|| perror "Error deleting $TARGET_BUILD_DIR"
fi
set -- $(ls ${TARGET_DIR})
fi
cd ${TARGET_DIR}
while (( "$#" )); do
clean_module $(readlink -f $1)
shift
done
cd - &> /dev/null
}
clean_module() {
pinfo "Cleaning '$1'..."
local MODULE_DIR=$1
if [ -e ${MODULE_DIR}/.built ]; then
rm "${MODULE_DIR}/.built" || perror "Could not clear built flag"
fi
if [ -e ${MODULE_DIR}/.fetched_source ]; then
rm "${MODULE_DIR}/.fetched_source" || perror "Could not clear fetched_source flag"
fi
if [ -d ${MODULE_DIR}/build ]; then
rm -rf "${MODULE_DIR}/build" || perror "Could not delete build path"
fi
if [ -d ${MODULE_DIR}/src ]; then
rm -rf "${MODULE_DIR}/src" || perror "Could not delete src path"
fi
if [ -e ${MODULE_DIR}/list_dpkg_output ]; then
rm "${MODULE_DIR}/list_dpkg_output" || perror "Could not delete list_dpkg_output"
fi
if [ -e ${MODULE_DIR}/list_binaries_and_files ]; then
rm "${MODULE_DIR}/list_binaries_and_files" || perror "Could not delete list_binaries_and_files"
fi
}
|