blob: 3acb1810632676be19b25ff0a7e55e7b1018e4a6 (
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
|
#
# Common functions to copy kernel related files
#
############################################################
#
#
# copies kernel modules as given in the module config file
# * depends on 'depmod'
# * requires REQUIRED_KERNEL_MODULES to be set.
# (entries must be a relative path to /lib/modules/<KERNEL_CURRENT_VERSION>)
#
# ex: for /lib/modules/3.2.0/kernel/fs/nfs/nfs.ko
# must be given as kernel/fs/nfs/nfs.ko
#
# set global KERNEL_TARGET_NAME
KERNEL_TARGET_NAME="kernel"
# set global KERNEL_BASE_DIR as in the directory containing lib/modules and lib/firmware
# for system kernel, that is "/" and for an openslx kernel KERNEL_BUILD_DIR
KERNEL_BASE_DIR=""
get_kernel_version () {
# determine kernel version currently running on this machine
[ -z "$KERNEL_CURRENT_VERSION" ] && declare -rg KERNEL_CURRENT_VERSION="$(uname -r)"
[ -z "$KERNEL_CURRENT_VERSION" ] && pwarning "Could not determine kernel version."
# set empty SYS_UTS_RELEASE and SYS_KERNEL
SYS_UTS_RELEASE="(unknown)"
SYS_KERNEL="$(echo "$SYS_UTS_RELEASE" | grep -o -E '^[0-9\.]+')"
# System kernel version
SYSTEM_KERNEL_LONG=$(uname -r)
SYSTEM_KERNEL_SHORT=$(grep -o -E '^[0-9\.]+' <<<$SYSTEM_KERNEL_LONG)
}
check_kernel_base_dir () {
# check if KERNEL_BASE_DIR was set, if not we don't know
# whether kernel-openslx or kernel-system has been built
# and therefore not were to look for kernel modules,
# firmware and the kernel itself
if [ -z "${KERNEL_BASE_DIR}" ]; then
# this is bad, abort
perror "KERNEL_BASE_DIR is not set. The kernel module did not run properly"
else
pinfo "KERNEL_BASE_DIR is '$KERNEL_BASE_DIR'"
fi
}
copy_kernel_modules () {
pinfo "Copying kernel modules for kernel ${KERNEL_CURRENT_VERSION}..."
[ -z "${REQUIRED_KERNEL_MODULES}" ] && perror "REQUIRED_KERNEL_MODULES is empty. Check your config file."
[ -z "${KERNEL_HEADERS_PATH}" ] && perror "KERNEL_HEADERS_PATH is empty. Kernel headers appears to be missing."
check_kernel_base_dir
local OLD_DIR="$(pwd)"
#
# process modules list
#
# search for modules in KERNEL_BASE_DIR
cd "${KERNEL_BASE_DIR}" || perror "Could not cd to ${KERNEL_BASE_DIR}"
local KERNEL_MODULES_DIR="lib/modules/${KERNEL_NEW_VERSION}"
local KERNEL_MODULES_LIST=""
local REQUIRED_KERNEL_MODULES_EXPANDED=""
local KERNEL_MODULE=""
local KERNEL_MODULE_PATH=""
local ELEM=""
# Do some fancy stuff to allow wildcards etc. in required kernel modules.
cd "${KERNEL_MODULES_DIR}"
for KERNEL_MODULE in ${REQUIRED_KERNEL_MODULES}; do
for ELEM in $KERNEL_MODULE; do
echo $ELEM | grep '\*' && pwarning "Could not expand '$ELEM'." && continue
REQUIRED_KERNEL_MODULES_EXPANDED+=" $ELEM"
done
done
cd - 2>/dev/null
pinfo "Expanded the list of $(echo "$REQUIRED_KERNEL_MODULES" | wc -w) required kernel modules to $(echo "$REQUIRED_KERNEL_MODULES_EXPANDED" | wc -w)"
#
# now loop over given modules and locate them
#
for KERNEL_MODULE in ${REQUIRED_KERNEL_MODULES_EXPANDED}; do
local KERNEL_MODULE_PATH="${KERNEL_MODULES_DIR}/${KERNEL_MODULE}"
if grep "^${KERNEL_MODULE}$" "${KERNEL_BASE_DIR}/${KERNEL_MODULES_DIR}/modules.builtin" >/dev/null; then
pdebug "Already built-in ${KERNEL_MODULE}."
elif [ -e "${KERNEL_MODULE_PATH}" ]; then
pdebug "Copying '${KERNEL_MODULE_PATH}'"
KERNEL_MODULES_LIST+=" ${KERNEL_MODULE_PATH}"
else
pwarning "Module ${KERNEL_MODULE} not found. Skipping. (might cause problems on certain clients!)"
continue
fi
# check for dependencies
local DEPS=$(grep "${KERNEL_MODULE}:" "${KERNEL_BASE_DIR}/${KERNEL_MODULES_DIR}/modules.dep" | cut -d ":" -f2-)
if [ ! -z "$DEPS" ]; then
for DEP in $DEPS; do
pdebug "Adding dep: ${KERNEL_MODULES_DIR}/$DEP"
KERNEL_MODULES_LIST+=" ${KERNEL_MODULES_DIR}/$DEP"
done
else
pdebug "${KERNEL_MODULE} has no dependencies."
fi
done
if [ ! -z "${KERNEL_MODULES_LIST}" ]; then
local COUNT=$(echo "${KERNEL_MODULES_LIST}" | wc -w)
pinfo "Copying $COUNT modules to target directory."
tarcopy "${KERNEL_MODULES_LIST}" "${TARGET_BUILD_DIR}"
fi
#
# generate modules map files
#
# first strip modules.order of all the modules we don't use
cat "${KERNEL_MODULES_DIR}/modules.order" | grep -E "$(echo ${REQUIRED_KERNEL_MODULES} | tr '\ ' '|' | tr '_' '.' | tr '-' '.')" \
>> "${TARGET_BUILD_DIR}/${KERNEL_MODULES_DIR}/modules.order"
# copy list of builtin kernel modules
cp "${KERNEL_MODULES_DIR}/modules.builtin" "${TARGET_BUILD_DIR}/${KERNEL_MODULES_DIR}"
# with modules.order and modules.builtin, we can run depmod for the rest of the files
depmod -b "${TARGET_BUILD_DIR}" -a "${KERNEL_NEW_VERSION}"
# go back to wherever we were
cd "${OLD_DIR}" || perror "Could not cd back to ${OLD_DIR}."
}
copy_firmware () {
pinfo "Copying firmware for kernel ${KERNEL_CURRENT_VERSION}..."
[ -z "${REQUIRED_FIRMWARE}" ] && perror "REQUIRED_FIRMWARE is empty. Check your config file."
check_kernel_base_dir
local OLD_DIR=$(pwd)
#
# process firmware list
#
cd "${KERNEL_BASE_DIR}" || perror "Could not cd to ${KERNEL_BASE_DIR}"
local FIRMWARE_DIR="lib/firmware"
local FIRMWARE_LIST=""
for FIRMWARE in ${REQUIRED_FIRMWARE}; do
local FOUND=0
# check for firmware in the build directory of the kernel
for CANDIDATE in "${FIRMWARE_DIR}/${FIRMWARE}" "${FIRMWARE_DIR}/${KERNEL_NEW_VERSION}/${FIRMWARE}"; do
if [ -e "${CANDIDATE}" ]; then
pdebug "Copying from kernel base dir ('$KERNEL_BASE_DIR'): '${CANDIDATE}'"
FIRMWARE_LIST+=" ${CANDIDATE}"
FOUND=1
fi
done
# dont look under / if KERNEL_BASE_DIR is already /
if [ "x${KERNEL_BASE_DIR}" == "x/" ]; then
[ $FOUND -ne 1 ] && pwarning "Neither '${FIRMWARE_DIR}/${FIRMWARE}' nor '${FIRMWARE_DIR}/${KERNEL_NEW_VERSION}/${FIRMWARE}' found on the system"
continue
fi
# if we didn't found it in the kernel build directory, check for firmware in the system firmware directory
if [ $FOUND -ne 1 ]; then
pdebug "Did not found '$FIRMWARE' in kernel base dir. Searching system..."
for CANDIDATE in "/${FIRMWARE_DIR}/${FIRMWARE}" "/${FIRMWARE_DIR}/${KERNEL_CURRENT_VERSION}/${FIRMWARE}"; do
if [ -e "${CANDIDATE}" ]; then
if [ $(echo "${CANDIDATE}" | grep -c "${KERNEL_CURRENT_VERSION}") -eq 0 ]; then
pdebug "Copying from system: '${CANDIDATE}'"
FIRMWARE_LIST+=" ${CANDIDATE}"
else
pdebug "Copying from system: '${CANDIDATE}' to ${FIRMWARE_DIR}/${KERNEL_NEW_VERSION}/${FIRMWARE}"
FIRMWARE_LIST+=" /${FIRMWARE_DIR}/${KERNEL_CURRENT_VERSION}/${FIRMWARE}"
fi
FOUND=1
fi
done
fi
[ $FOUND -ne 1 ] && pwarning "Neither '${FIRMWARE_DIR}/${FIRMWARE}' nor '${FIRMWARE_DIR}/${KERNEL_NEW_VERSION}/${FIRMWARE}' "\
" was found on the system. Skipping. (might cause problems on certain clients!)"
done
if [ ! -z "${FIRMWARE_LIST}" ]; then
echo "$FIRMWARE_LIST" > /fwlist
local COUNT=$(echo "${FIRMWARE_LIST}" | wc -w)
pinfo "Copying $COUNT firmware to target directory."
tarcopy "${FIRMWARE_LIST}" "${TARGET_BUILD_DIR}"
fi
# only for kernel-openslx
# post-process to fix the path of the firmwares found on the system unter /lib/firmware/$(uname -r)
# which have to be copied to /lib/firmware/${KERNEL_NEW_VERSION}
if [ "x${KERNEL_BASE_DIR}" != "x/" ]; then
if [ -d "${TARGET_BUILD_DIR}/lib/firmware/${KERNEL_CURRENT_VERSION}" ]; then
mkdir -p "${TARGET_BUILD_DIR}/lib/firmware/${KERNEL_NEW_VERSION}/"
cd "${TARGET_BUILD_DIR}/lib/firmware/${KERNEL_CURRENT_VERSION}" || perror "old kernel but no old kernel"
tarcopy "$(ls)" "${TARGET_BUILD_DIR}/lib/firmware/${KERNEL_NEW_VERSION}/"
cd -
rm -r "${TARGET_BUILD_DIR}/lib/firmware/${KERNEL_CURRENT_VERSION}" || perror "something went very wrong..."
else
pdebug "No ${TARGET_BUILD_DIR}/lib/firmware/${KERNEL_CURRENT_VERSION} directory, skipping the merge."
fi
fi
cd "${OLD_DIR}" || perror "Could not cd back to ${OLD_DIR}."
}
copy_kernel () {
check_kernel_base_dir
local TOOL_STR="$TOOL_STR copy_kernel:"
local KERNEL_DIR="${MODE_DIR}/builds/kernel"
[ -d "${KERNEL_DIR}" ] || mkdir -p "${KERNEL_DIR}"
# here we need special logic for the 2 different kind of kernels
# if KERNEL_BASE_DIR is '/' then we are using the kernel-system module
# else if it is '*tm-scripts/remote/modules/*" then we use the openslx-module
# TODO til the configuration interface is done, it is ugly...
if [ "${KERNEL_BASE_DIR}" = "/" ]; then
# remote/modules/kernel-system/build/kernel
cp "${MODULES_DIR}/kernel-system/build/kernel" "${KERNEL_DIR}" \
|| perror "Could not copy '${MODULES_DIR}/kernel-system/build/kernel' to '${KERNEL_DIR}'"
pinfo "Copied '${MODULES_DIR}/kernel-system/build/kernel' to '${KERNEL_DIR}'"
elif [[ "${KERNEL_BASE_DIR}" = *tm-scripts/remote/modules/kernel* ]]; then
# kernel-openslx
cp "${MODULES_DIR}/kernel/build/kernel" "${KERNEL_DIR}" \
|| perror "Could not copy '${MODULES_DIR}/kernel/build/kernel' to '${KERNEL_DIR}'"
pinfo "Copied '${MODULES_DIR}/kernel/build/kernel' to '${KERNEL_DIR}'"
fi
# kernel has 0600 perms since ubuntu 14.04, change that once we copied it
chmod +r "${KERNEL_DIR}/kernel"
pinfo "You may want to update your systems firmware/modules to match the current kernel."
}
|