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
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
|
#!/bin/bash
# -----------------------------------------------------------------------------
#
# Copyright (c) 2011..2018 bwLehrpool-Projektteam
#
# This program/file is free software distributed under the GPL version 2.
# See https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
#
# If you have any feedback please consult https://bwlehrpool.de and
# send your feedback to support@bwlehrpool.de.
#
# General information about bwLehrpool can be found at https://bwlehrpool.de
#
# -----------------------------------------------------------------------------
#
# This file contains the functions needed to setup a target.
# The main function is 'generate_target' which will go over all
# activated modules (symlinks found under core/targets/<target> or
# overlay/targets/<target>) and run the module-specific 'fetch_source',
# 'build' and 'post_copy' functions of the modules.
#
# The functions defined here are module-independent, meaning they
# can process any module, as long as following requirements are met:
#
# - Modules need to have a build-script and a config file,
# i.e. core/module/kernel/module.build
# and core/module/kernel/module.conf
# as these will be read by 'process_module'.
#
# - Modules do not change anything inside the module dirs anymore,
# everything (triggerfiles, source download, build) is done in
# tmp/work/<MODULE>
#
# - Several information have to be set in the config file of
# a module:
# * REQUIRED_BINARIES - list of binaries
# * REQUIRED_FILES - list of regular files
# * REQUIRED_DIRECTORIES - list of directories
# * REQUIRED_SYSTEM_FILES - files to be copied directly from the system
# * REQUIRED_INSTALLED_PACKAGES - list of packages needed at build-time
# * REQUIRED_CONTENT_PACKAGES - list of packages where the contents are to be copied
# * (optional variables needed by the module-build-script)
#
# NOTE: REQUIRED_BINARIES, REQUIRED_FILES, REQUIRED_FILES will be ONLY looked
# for in the module's own build directory!
#
# Optionally, a module can have a static data directory under
# core/modules/<module>/data which will be copied as is to the target build directory.
#
# Moreover modules do not need to specify the dynamic dependencies of given binaries
# as these will be determined automaticly by the helper function 'get_dynamic_dependencies'
# -----------------------------------------------------------------------------
#
# Map modules from their names to path - contains all modules of current target
declare -Ag MODULE_PATHS=()
declare -g PACKAGES_INSTALLED_FLAG=
declare -rg CORE_DIR="${ROOT_DIR}/core"
declare -rg TARGETS_BASEDIR="$( readlink -f "${CORE_DIR}/targets" )"
declare -rg EXPORT_DIR="/export/build"
[ -z "$REMOTE_EXPORT_DIR" ] || EXPORT_DIR=$REMOTE_EXPORT_DIR
initial_checks () {
get_kernel_version
detect_distribution
}
unset_required_vars () {
for VARNAME in ${!REQUIRED_*}; do
unset $VARNAME
done
}
# Install all the packages from all selected modules in current target
install_all_packages () {
[ -n "$PACKAGES_INSTALLED_FLAG" ] && return 0
PACKAGES_INSTALLED_FLAG=1
local module file config
declare -a missing
declare -A packages dupcheck
packages=()
for module in "${!MODULE_PATHS[@]}"; do
unset_required_vars
config="${MODULE_PATHS["$module"]}/module.conf"
for file in $SYS_VERSIONS; do
if [ -e "${config}.${file}" ]; then
validate_config "${config}.${file}"
. "${config}.${file}"
break
fi
done
dupcheck=()
for file in $REQUIRED_INSTALLED_PACKAGES; do
[ -n "${dupcheck["$file"]}" ] && continue
packages["$file"]+=" $module"
dupcheck["$file"]=1
done
for file in $REQUIRED_CONTENT_PACKAGES; do
[ "${file:0:1}" = "@" ] && continue
[ -n "${dupcheck["$file"]}" ] && continue
packages["$file"]+=" $module"
dupcheck["$file"]=1
done
done
missing=( $( filter_installed_packages "${!packages[@]}" ) )
if [ "${#missing[@]}" -gt 0 ]; then
pinfo "Making sure required packages are installed..."
pinfo "Potentially missing: ${missing[*]}"
install_packages "${missing[@]}"
fi
unset_required_vars
}
#
# generic function to read the config file of the current $MODULE
#
read_config () {
# unset previous variables from other config files
unset_required_vars
local MODULE_CONFIG="${MODULE_DIR}/module.conf"
# sanity checks
[ ! -e "${MODULE_CONFIG}" ] && perror "Config for '$MODULE' not found."
validate_config "$MODULE_CONFIG"
# source the config file
. "${MODULE_CONFIG}" || perror "Sourcing '${MODULE_CONFIG}' failed."
# sanity checks - no distribution specific things in the global config
local CHECK
for CHECK in REQUIRED_CONTENT_PACKAGES REQUIRED_INSTALLED_PACKAGES; do
[ -n "${!CHECK}" ] && perror "$CHECK is set in ${MODULE}.conf, but distribution specific config has to go to one of these files:\n$PRINT_SYS_VERSIONS"
done
local FILE
for FILE in $SYS_VERSIONS; do
if [ -e "${MODULE_CONFIG}.${FILE}" ]; then
# a specific tool.conf seems to exist, use it to override/extend certain vars
validate_config "${MODULE_CONFIG}.${FILE}"
. "${MODULE_CONFIG}.${FILE}" || perror "Sourcing '${MODULE_CONFIG}.${FILE}' failed."
pinfo "Sourced distribution specific config (${MODULE_CONFIG##*/}.${FILE})"
return # end function
fi
done
# reaching here means no specific config
pinfo "Sourced general module config only (${MODULE_CONFIG##*/})"
}
validate_config () {
local INVALID=$(grep -h -E -o '^\s*\w+=' "$1" | grep -v -E '^\s*REQUIRED_')
[ -z "$INVALID" ] && return 0
local i
for i in $INVALID; do
pwarning "Invalid variable $i"
done
perror "$1 contains invalid variables. All variables must start with REQUIRED_"
}
#
# generic function to read the build script of the current $MODULE
#
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."
}
export_builds() {
[ ! -d "${ROOT_DIR}/var/builds" ] && perror "No ${ROOT_DIR}/var/builds, nothing to export."
if mount|grep -q ${ROOT_DIR}/var/builds; then
pwarning "${ROOT_DIR}/var/builds already exported! Ignoring..."
return 1;
fi
pinfo "Mounting ${ROOT_DIR}/var/builds to ${EXPORT_DIR}."
pinfo "This will make the local var/builds syncable from another machine."
[ ! -d "${EXPORT_DIR}" ] && mkdir -p "${EXPORT_DIR}"
mount --bind ${ROOT_DIR}/var/builds ${EXPORT_DIR} || perror "Failed to bind mount ${ROOT_DIR}/var/builds to ${EXPORT_DIR}"
}
#
# main function which copies all files, directories, binaries and external libraries to TARGET_BUILD_DIR
# called after building the module
#
copy_files_with_deps () {
[ ! -d "$MODULE_BUILD_DIR" ] && pinfo "No build directory found, skipping dependency copying" && return 0
cde "$MODULE_BUILD_DIR"
local COPYFILES_LIST="${TARGET_BUILD_DIR}/opt/openslx/.mltk/${MODULE}.copy_files_with_deps"
rm -f -- "${COPYFILES_LIST}"
# from REQUIRED_BINARIES - follow symlinks and ldd the file
[ ! -z "${REQUIRED_BINARIES}" ] && pinfo "Gathering required binaries from config file..."
local OPTIONAL FILENAME
for FILENAME in ${REQUIRED_BINARIES}; do
if [[ "${FILENAME:0:1}" == "@" ]]; then
OPTIONAL="yes"
FILENAME="${FILENAME:1}"
else
OPTIONAL="no"
fi
local FILE_CANDIDATES="$( find . -name "${FILENAME}" -a \( -type f -o -type l \) )"
local FINAL_LIST=""
# Check result of find
if [ "$(echo "$FILE_CANDIDATES" | wc -l)" -gt 1 ]; then
# More than one match for binary
pdebug "Candidates for $FILENAME are: $(echo $FILE_CANDIDATES)"
for FILE in $FILE_CANDIDATES; do
local TESTFILE="$(readlink -f "$FILE")"
pdebug " $FILE leads to $TESTFILE"
[ -f "$TESTFILE" -a -x "$TESTFILE" ] && FINAL_LIST="$FINAL_LIST $FILE"
done
FINAL_LIST=$(trim "$FINAL_LIST")
if [ -z "$FINAL_LIST" ]; then
# Not found in build dir; if install mode, check if it's in the PKG_CONTENT_FILE
if [ -n "$MLTK_INSTALL" ]; then
# TODO: Might want to iterate over all the matches and check if at least one of them
# is +x
grep -q "/${FILENAME}\$" "$PKG_CONTENT_FILE" && continue
fi
perror "\tNo binary found for ${FILENAME}. None of the candidates ($FILE_CANDIDATES) is executable."
fi
if [[ "$FINAL_LIST" == *" "* ]]; then
pdebug "Found more than one match for required file '$FILENAME': $FINAL_LIST"
else
pdebug "\tFound ${FILENAME} at ${FILE}"
fi
elif [ "$OPTIONAL" == "no" -a -z "$FILE_CANDIDATES" ]; then
# No candidate
# Same as above: accept existing file in /
if [ -n "$MLTK_INSTALL" ]; then
grep -q "/${FILENAME}\$" "$PKG_CONTENT_FILE" && continue
fi
perror "Could not find required binary $FILENAME"
else
# One candidate
local TESTFILE="$( readlink -f "$FILE_CANDIDATES" )"
if [ -f "$TESTFILE" ] && [ -x "$TESTFILE" ]; then
FINAL_LIST="${FILE_CANDIDATES}"
elif [ "$OPTIONAL" = "no" ]; then
perror "No executable regular file found for '$FILENAME' (potential match was $(echo $FILE_CANDIDATES))"
fi
fi
for FILE in $FINAL_LIST; do
pdebug "* $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
# from REQUIRED_LIBRARIES - like binaries, follow symlinks and ldd, but also expand the lib-name
# by looking for files named <libname>.so*
[ -n "$REQUIRED_LIBRARIES" ] && pinfo "Gathering required libraries from config file..."
for LIB in $REQUIRED_LIBRARIES; do
FILE_CANDIDATES=$(find . -name "${LIB}.so*")
if [ -z "$FILE_CANDIDATES" ]; then
if [ -n "$MLTK_INSTALL" ]; then
# TODO: Escape LIB and use a proper regex with -P
grep -qF "/${LIB}.so" "$PKG_CONTENT_FILE" && continue
fi
perror "Cannot find required library $LIB"
fi
for LOCATION in $FILE_CANDIDATES; do
pdebug "* $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
# from REQUIRED_DIRECTORIES - recursively copy given dirs, look for files that seem to be an elf
# binary and do the symlink+ldd trick on them
[ ! -z "${REQUIRED_DIRECTORIES}" ] && pinfo "Gathering required directories from config file..."
local ENTRY=""
for ENTRY in ${REQUIRED_DIRECTORIES}; do
[[ "$ENTRY" == /* ]] || perror "All entries in REQUIRED_DIRECTORIES have to start with a slash '/', but $ENTRY does not!"
[ -e "$ENTRY" -a ! -d "$ENTRY" ] && perror "$ENTRY is not a directory in base system"
pdebug "* $ENTRY"
if [ -d ".${ENTRY}" ]; then
ENTRY=".${ENTRY}"
echo "${ENTRY}" >> "${COPYFILES_LIST}"
for BIN in $(find "${ENTRY}" -type f -a \( -executable -o -name '*.so*' \) -a -not -name '*.a'); do
[ -f "$BIN" ] || continue
#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
elif [ -z "$MLTK_INSTALL" ] || ! [ -d "$ENTRY" ]; then
perror "Required directory $ENTRY not found"
fi
done
# from REQUIRED_FILES - these are assumed to be simple files, so only follow symlinks
[ ! -z "${REQUIRED_FILES}" ] && pinfo "Gathering required files from config file..."
for ENTRY in ${REQUIRED_FILES}; do
if [ "${ENTRY:0:1}" = "@" ]; then
ENTRY="${ENTRY:1}"
if [ ! -e "${MODULE_BUILD_DIR}/${ENTRY}" ]; then
pinfo "Skipping missing optional file: ${MODULE_BUILD_DIR}/${ENTRY}"
continue
fi
fi
if [ -n "$MLTK_INSTALL" ] && ! [ -e "${MODULE_BUILD_DIR}/${ENTRY}" ]; then
[ -e "/${ENTRY}" ] && continue # OK for install mode... I think
fi
get_link_chain "${MODULE_BUILD_DIR}/${ENTRY}" "${MODULE_BUILD_DIR}" >> "${COPYFILES_LIST}"
done
#copy to initramfsdir
pdebug "File list generated at ${COPYFILES_LIST}."
# empty?
if [ ! -s "$COPYFILES_LIST" ]; then
return
fi
# unchanged?
local OLD="${COPYFILES_LIST}.old"
if [ -s "$OLD" ] && cmp "$OLD" "$COPYFILES_LIST"; then
return
fi
local CLISTCOUNT=$(cat "$COPYFILES_LIST" | wc -l)
pinfo "Copying $CLISTCOUNT files to '${TARGET_BUILD_DIR}'."
tarcopy "$(sort -u "$COPYFILES_LIST")" "${TARGET_BUILD_DIR}"
mv -f "$COPYFILES_LIST" "$OLD"
}
#
#
# If the system has no usr split, recreate the structure in the given
# directory, otherwise, do nothing
#
#
prepare_usr_split () {
local DIR DEST
local BASE=$1
[ -z "$BASE" ] && perror "prepare_usr_split called with empty base dir"
if [ "$USR_SPLIT" == "no" ]; then # no usr split, /bin /lib etc are symlinks
for DIR in lib lib32 lib64 bin sbin; do
[ -L "/${DIR}" ] || continue
DEST=$(readlink "/${DIR}")
if [ ! -L "/${DEST}" ]; then
mkdir -p "${BASE}/${DEST}" || perror "Could not create '${BASE}/${DEST}'"
fi
[ -L "${BASE}/${DIR}" ] || ln -s "${DEST}" "${BASE}/${DIR}" || perror "Could not symlink '${BASE}/${DIR}' to '${DEST}'"
done
fi
}
# Recursively get all modules in the current target
scan_target() {
local dir item base real
dir="$1"
[ -d "$1" ] || perror "scan_target: $dir is not a directory"
for item in "$dir/"*; do
[ -L "$item" ] || continue
base="$( basename "$item" )"
real="$( readlink -f "$item" )"
if [ -s "$item/module.conf" ]; then
if [ -n "${MODULE_PATHS["$base"]}" ] \
&& [ "${MODULE_PATHS["$base"]}" != "$real" ]; then
perror "$base exists in multiple sub-targets and links to different modules\n1: $real\n2: ${MODULE_PATHS["$base"]}"
fi
MODULE_PATHS["$base"]="$real"
elif [ "${real#$TARGETS_BASEDIR}" != "$real" ]; then
scan_target "$real"
else
perror "Unknown link in target '$dir': '$base' is '$real', neither target nor module"
fi
done
}
#
#
# main public function. Requires the TARGET to be given as argument.
# this will simply go over all the modules as found in the core/target/<TARGET>
# and run following functions:
#
#
generate_target() {
initial_checks
TARGET="$1"
shift
TARGET_DIR="$( readlink -f "${TARGETS_BASEDIR}/${TARGET}" )"
scan_target "$TARGET_DIR"
if [[ "$TARGET" == *@* ]]; then
VARNAME="${TARGET#*@}"
TARGET="${TARGET%@*}"
for VERSION in ${!VARNAME}; do
TARGET_BUILD_DIR="${ROOT_DIR}/var/builds/${TARGET}@${VERSION}"
generate_target_real "$@"
done
else
TARGET_BUILD_DIR="${ROOT_DIR}/var/builds/${TARGET}"
generate_target_real "$@"
fi
}
generate_target_real() {
# Keep track of processed modules so we don't
# build a module multiple times when following dependencies
local item
local PROCESSED_MODULES=
[ -d "$TARGET_DIR" ] || perror "Given target directory does not exist: $TARGET_DIR"
[[ "$TARGET" == "builds" || "$TARGET" == "modules" ]] && \
perror "Target directory cannot be named 'builds' or 'modules'."
pdebug "Generating '$TARGET_BUILD_DIR' for '$TARGET'"
mkdir -p "$TARGET_BUILD_DIR" || perror "Failed to create $TARGET_BUILD_DIR"
prepare_usr_split "${TARGET_BUILD_DIR}"
# if no arguments assume all.
if [ "x$1" = "x" -o "x$1" = "xall" ]; then
MODULES="${!MODULE_PATHS[@]}"
else
# tools = arguments given
MODULES="$@"
fi
pinfo "Activated modules in '${TARGET}':"
pinfo "\t$(echo ${MODULES})"
# Make sure all selected modules seem valid
for item in $MODULES; do
[ -n "${MODULE_PATHS["$item"]}" ] || perror "Module $item not found in target"
done
# Run load hook
for item in $MODULES; do
. "${CORE_DIR}/includes/clean_module_funcs.inc" # Clean all hooks, in case the module doesn't define them all
. "${MODULE_PATHS["$item"]}/module.build"
module_init
done
install_all_packages
# copy basic libs
pinfo "Copying libc and ld-linux used by ${SHELL}"
tarcopy "$(list_basic_libs)" "${TARGET_BUILD_DIR}"
# now iterate over given tools and copy them
for item in $MODULES; do
process_module "$item"
done
post_process_target
pinfo "Target completed. Total size: $(du -bsh "${TARGET_BUILD_DIR}" | awk 'END {print $1}')"
TOOL_STR=""
}
process_module() {
# Parse arguments
[ "$#" -lt "1" ] && perror "process_module: want >= 1 param."
if [ "x$1" = "x--dep-of" ]; then
shift
local DEPOF=" $1"
shift
else
local DEPOF=""
fi
local MODULE="$1"
[ -z "$MODULE" ] && perror "No module given when calling process_module"
[[ "$PROCESSED_MODULES" == *"!${MODULE}!"* ]] && return # Already processed this module
# Set up dirs ans variables
PROCESSED_MODULES="${PROCESSED_MODULES}!${MODULE}!"
local MODULE_DIR="${MODULE_PATHS["${MODULE}"]}"
local MODULE_WORK_DIR="${ROOT_DIR}/tmp/work/${MODULE}"
local MODULE_BUILD_DIR="${MODULE_WORK_DIR}/build"
local TOOL_STR="[${MODULE}]"
local SOURCE_FLAG="${MODULE_WORK_DIR}/meta/fetched_source.flag"
local BUILD_FLAG="${MODULE_WORK_DIR}/meta/build_complete.flag"
local AUTOCLONE_FILE="${MODULE_WORK_DIR}/meta/repos"
local MD5FILE="${TARGET_BUILD_DIR}/opt/openslx/.mltk/${MODULE}.md5"
local PKG_CONTENT_FILE="${MODULE_WORK_DIR}/meta/list_package_contents"
mkdir -p "${TARGET_BUILD_DIR}/opt/openslx/.mltk" "${MODULE_WORK_DIR}/meta"
if [ ! -d "${MODULE_DIR}" ]; then
if [ -z "$DEPOF" ]; then
perror "Module directory for '$MODULE' not found in ${TARGET_DIR}"
fi
perror "Module directory for '$MODULE' not found in ${TARGET_DIR} (is a dependency of${DEPOF})"
return
fi
cde "${MODULE_DIR}"
# Simple check for modified .build / .config, in which case we'll run a module clean first
if [ -f "$MD5FILE" ]; then
if ! md5sum --check "$MD5FILE"; then
# Mismatch
if [ "x$MODULE" = "xkernel" ]; then
pwarning " ** Kernel .build/.config changed, but won't autoclean."
pwarning " ** Check if cleaning should be done and use '-c kernel'"
else
pwarning "Module's .build/.config has changed, rebuilding!"
clean_module "${TARGET}:${MODULE}"
fi
elif [ ! -e "$SOURCE_FLAG" ] || [ ! -e "$BUILD_FLAG" ]; then
# One of the flags is missing, in this case delete the .md5 file
# which would prevent dependency copying etc. below
rm -f -- "$MD5FILE"
fi
fi
# Process module
pdebug "## Reading config of $MODULE"
read_config
# Prepare build directory
mkdir -p "${MODULE_BUILD_DIR}" || perror "Could not create build dir"
prepare_usr_split "${MODULE_BUILD_DIR}"
# Check if this module has a dependency that wasn't built yet:
if [ ! -z "$REQUIRED_MODULES" ]; then
pdebug "$MODULE depends on ${REQUIRED_MODULES}...."
for DEP in $REQUIRED_MODULES; do
process_module --dep-of "${MODULE}${DEPOF}" "$DEP"
done
# Read old config again, as it got overwritten by the deps
cde "${MODULE_WORK_DIR}"
read_config
fi
[ -n "$DEPOF" ] && local DEPOF_STR="(dependency of${DEPOF})"
pinfo ">>>>>>>>>>>>>>>>> Processing module [ $MODULE ] $DEPOF_STR"
# Source .build script of module
pdebug "## Reading .build of $MODULE"
. "${CORE_DIR}/includes/clean_module_funcs.inc" # Clean all hooks, in case the module doesn't define them all
read_build # Read all the hooks from the module
cde "${MODULE_DIR}"
# update kernel version variables before running a module, as the last one might have been the kernel...
get_kernel_version
# Execute pre_exec before anything else
pre_exec
cde "${MODULE_WORK_DIR}"
# Fetch source code
if [ ! -e "$SOURCE_FLAG" ]; then
pinfo "## Fetching source"
rm -f -- "$AUTOCLONE_FILE"
fetch_source
touch "$SOURCE_FLAG" || pwarning "Error setting source-flag"
fi
# Build
if [ ! -e "$BUILD_FLAG" ]; then
list_packet_files > "$PKG_CONTENT_FILE" || perror "Could not write packet content list to $PKG_CONTENT_FILE"
# Copy all required packages' contents to build dir, but not in install mode
if [ -z "$MLTK_INSTALL" ]; then
pinfo "## Copying required packages to build dir"
tarcopy "$( sort -u "$PKG_CONTENT_FILE" )" "${MODULE_BUILD_DIR}"
fi
cde "${MODULE_WORK_DIR}"
pinfo "## Building"
build # calls perror if something fails, no need to do that here
strip_recursive "$MODULE_BUILD_DIR"
touch "$BUILD_FLAG" || pwarning "Error setting built-flag"
fi
# Remove *.la files as they might confuse libtool/linker of other tool packages
[ -d "${MODULE_BUILD_DIR}" ] && find "${MODULE_BUILD_DIR}" -name '*.la' -exec rm -f {} \;
# Only copy stuff from system or build dir if md5s didn't change
if [ ! -f "$MD5FILE" ]; then
pinfo "## Copying files with dependencies"
cde "${MODULE_DIR}"
copy_files_with_deps
if [ -n "$REQUIRED_SYSTEM_FILES" ]; then
pinfo "## Copying required system files" # REQUIRED_SYSTEM_FILES
cde "${MODULE_DIR}"
copy_system_files
fi
fi
# Always copy static data
if [ -d "${MODULE_DIR}/data" ]; then
pinfo "## Copying static module files"
copy_static_data
fi
# TODO: automatic copy of REQUIRED_CONTENT_PACKAGES
pinfo "## Post copy"
cde "${MODULE_DIR}"
post_copy
# Write new md5 file if not existent yet
if [ ! -f "$MD5FILE" ]; then
md5sum "$MODULE_DIR/module".* > "$MD5FILE" || perror "Could not create $MD5FILE"
fi
[ -s "$AUTOCLONE_FILE" ] && cp "$AUTOCLONE_FILE" "${TARGET_BUILD_DIR}/opt/openslx/.mltk/${MODULE}.git"
# Sanity checks
[ -e "$TARGET_BUILD_DIR/var/run" -a ! -L "$TARGET_BUILD_DIR/var/run" ] && perror "Messup datected: $TARGET_BUILD_DIR/var/run exists and is not a symlink!"
[ -e "$TARGET_BUILD_DIR/var/lock" -a ! -L "$TARGET_BUILD_DIR/var/lock" ] && perror "Messup datected: $TARGET_BUILD_DIR/var/lock exists and is not a symlink!"
[ -n "$(ls -A "$TARGET_BUILD_DIR/run" 2>> /dev/null)" ] && perror "Messup detected: $TARGET_BUILD_DIR/run is not empty. You cannot place static files there, use /etc/tmpfiles.d instead!"
}
post_process_target() {
local TOOL_STR="$TOOL_STR post_process_target:"
if [ -z "$MLTK_INSTALL" ]; then
# traditional minilinux approach
# figure out all relevant ld-paths
pinfo "Running ldconfig"
cp -r -L /etc/ld.so.conf* "${TARGET_BUILD_DIR}/etc/"
ldconfig -v -r "${TARGET_BUILD_DIR}"
# run depmod to generate the final modules.* files
depmod -b "${TARGET_BUILD_DIR}" -a "${TARGET_KERNEL_LONG}"
return 0
fi
# Installer mode
local RSYNC_DEST RSYNC_EXCLUDE_LIST entry filelist target_file system_file
# default dest and exclude list for non-addons
RSYNC_DEST='/'
RSYNC_EXCLUDE_LIST="$( mktemp )"
# always exclude ld.so.cache, we handle that separately
echo 'etc/ld.so*' > "$RSYNC_EXCLUDE_LIST"
echo 'autoexec.bat' >> "$RSYNC_EXCLUDE_LIST"
if [ -e "${TARGET_DIR}/.addon" ]; then
# This is an addon, don't sync to / but to dedicated directory
RSYNC_DEST="/opt/openslx/addons/${TARGET_BUILD_DIR##*/}"
pinfo "Target is an addon, preparing install to '${RSYNC_DEST}'."
mkdir -p "${RSYNC_DEST}" || perror "Failed to mkdir '${RSYNC_DEST}'."
RSYNC_OPTS+=( "--delete" "--delete-excluded" )
cde "$TARGET_BUILD_DIR"
readarray -t -d '' filelist < <( find . -not -type d -print0 )
for entry in "${filelist[@]}"; do
# diff them to be sure they are the same?
system_file="${entry:1}"
target_file="${entry:2}"
if [ -e "$system_file" ] && cmp "$system_file" "$target_file"; then
echo "$target_file" >> "$RSYNC_EXCLUDE_LIST"
fi
done
pinfo "Calling ldconfig on overlay'ed ${TARGET_BUILD_DIR##*/}..."
chroot_run "${TARGET_BUILD_DIR}" <<< "ldconfig"
if [ -f "${TARGET_BUILD_DIR}/etc/ld.so.cache" ]; then
mkdir -p "${TARGET_BUILD_DIR}/opt/openslx/etc"
mv -f -- "${TARGET_BUILD_DIR}/etc/ld.so.cache" \
"${TARGET_BUILD_DIR}/opt/openslx/etc/${TARGET_BUILD_DIR##*/}.ld.so.cache"
pinfo "... generated cache at '${TARGET_BUILD_DIR}/opt/openslx/etc/${TARGET_BUILD_DIR##*/}.ld.so.cache'."
fi
fi
pinfo "Rsyncing local build of '${TARGET_BUILD_DIR}' to '${RSYNC_DEST}'..."
rsync -aAXv "${RSYNC_OPTS[@]}" \
--exclude-from="${RSYNC_EXCLUDE_LIST}" \
"${TARGET_BUILD_DIR}/" "${RSYNC_DEST}" || \
perror "Failed to rsync, your system is probably trashed ;-("
[ -z "$MLTK_DEBUG" ] && rm -f -- "$RSYNC_EXCLUDE_LIST"
# finish by running ldconfig for the running system (when processing non-addons).
if [ ! -e "${TARGET_DIR}/.addon" ]; then
ldconfig -v
depmod -a "${TARGET_KERNEL_LONG}"
fi
}
clean_modules() {
local module
TARGET=$1
shift
TARGET_DIR="$( readlink -f "${TARGETS_BASEDIR}/${TARGET}" )"
scan_target "$TARGET_DIR"
TARGET_BUILD_DIR="${ROOT_DIR}/var/builds/${TARGET}"
[ -d $TARGET_DIR ] || perror "Given target directory does not exist: $TARGET_DIR"
if [ "x$1" = "x" -o "x$1" = "xall" ]; then
if [[ "$TARGET" == *@* ]]; then
rm -rf -- "${TARGET_BUILD_DIR%@*}"@* || perror "Could not delete target build dirs for $TARGET"
else
rm -rf -- "${TARGET_BUILD_DIR}" || perror "Could not delete target build dir for $TARGET"
fi
# exclude kernel on "all"
unset 'MODULE_PATHS[kernel]'
set -- "${!MODULE_PATHS[@]}"
fi
for module in "$@"; do
[ -n "${MODULE_PATHS["$module"]}" ] || perror "Target does not contain module '$module'"
done
cde "$TARGET_DIR"
for module in "$@"; do
clean_module "${TARGET}:${module}"
done
}
clean_module() {
[ -z "$1" ] && perror "No module given on clean_module()"
pinfo "## clean_module $1"
local TARGET=${1%%:*}
local MODULE=${1#*:}
local MODULE_DIR="${MODULE_PATHS["${MODULE}"]}"
local MODULE_WORK_DIR="${ROOT_DIR}/tmp/work/${MODULE}"
if ! [ -d "$MODULE_DIR" ]; then
pwarning "No such module '$MODULE' in current target '$TARGET'"
pwarning "Check your spelling"
if [ -d "$MODULE_WORK_DIR" ]; then
pwarning "Continuing anyways since the according work dir exists..."
else
return 1
fi
fi
pinfo "Cleaning '$1'..."
rm -rf -- "${MODULE_WORK_DIR}" || perror "Could not delete work dir"
rm -f -- "${TARGET_BUILD_DIR}/opt/openslx/.mltk/${MODULE}."* # no space here!
return 1
}
# Recursively strip binaries and libraries in the given directory
strip_recursive() {
local DIR="$1"
[ -n "$DIR" -a -d "$DIR" ] || perror "strip_recursive(): No such directory: '$DIR'"
# Will try to strip shell scripts too but shouldn't do any harm
# Ignore anything we compile ourselves so we have usable core dumps
find "$DIR" -type f \! -path "*openslx*bin*" -a \( -executable -o -name "*.so*" \) -exec strip {} \; 2> /dev/null
}
# copies static data files from <MODULE>/data/ to <TARGET_BUILD_DIR>
copy_static_data() {
[ ! -d "${MODULE_DIR}/data" ] && pinfo "${MODULE} has no static 'data' directory." && return
cde "${MODULE_DIR}/data/"
pinfo "tarcopy ${MODULE_DIR}/data/"
tarcopy "$(find . -type f -o -type l)" "${TARGET_BUILD_DIR}"
}
# Copies files with their absolute paths in $REQUIRED_SYSTEM_FILES to $TARGET_BUILD_DIR
copy_system_files() {
[ -z "$REQUIRED_SYSTEM_FILES" ] && return
local file list
list=
for file in $REQUIRED_SYSTEM_FILES; do
list+=" $(get_link_chain "$file")"
done
tarcopy "$list" "$TARGET_BUILD_DIR"
}
|