1 |
# Copyright 1999-2004 Gentoo Foundation |
2 |
# Distributed under the terms of the GNU General Public License v2 |
3 |
# $Header: /var/cvsroot/gentoo-x86/eclass/linux-info.eclass,v 1.29 2005/07/11 15:08:06 swegener Exp $ |
4 |
# |
5 |
# Description: This eclass is used as a central eclass for accessing kernel |
6 |
# related information for sources already installed. |
7 |
# It is vital for linux-mod to function correctly, and is split |
8 |
# out so that any ebuild behaviour "templates" are abstracted out |
9 |
# using additional eclasses. |
10 |
# |
11 |
# Maintainer: John Mylchreest <johnm@gentoo.org> |
12 |
# Copyright 2004 Gentoo Linux |
13 |
# |
14 |
# Please direct your bugs to the current eclass maintainer :) |
15 |
|
16 |
# A Couple of env vars are available to effect usage of this eclass |
17 |
# These are as follows: |
18 |
# |
19 |
# Env Var Option Description |
20 |
# KERNEL_DIR <string> The directory containing kernel the target kernel |
21 |
# sources. |
22 |
# CONFIG_CHECK <string> a list of .config options to check for before |
23 |
# proceeding with the install. ie: CONFIG_CHECK="MTRR" |
24 |
# You can also check that an option doesn't exist by |
25 |
# prepending it with an exclamation mark (!). |
26 |
# ie: CONFIG_CHECK="!MTRR" |
27 |
# ERROR_CFG <string> The error message to display when the above check |
28 |
# fails. <CFG> should reference the appropriate option |
29 |
# as above. ie: ERROR_MTRR="MTRR exists in the .config |
30 |
# but shouldn't!!" |
31 |
# KBUILD_OUTPUT <string> This is passed on commandline, or can be set from |
32 |
# the kernel makefile. This contains the directory |
33 |
# which is to be used as the kernel object directory. |
34 |
|
35 |
# There are also a couple of variables which are set by this, and shouldn't be |
36 |
# set by hand. These are as follows: |
37 |
# |
38 |
# Env Var Option Description |
39 |
# KV_FULL <string> The full kernel version. ie: 2.6.9-gentoo-johnm-r1 |
40 |
# KV_MAJOR <integer> The kernel major version. ie: 2 |
41 |
# KV_MINOR <integer> The kernel minor version. ie: 6 |
42 |
# KV_PATCH <integer> The kernel patch version. ie: 9 |
43 |
# KV_EXTRA <string> The kernel EXTRAVERSION. ie: -gentoo |
44 |
# KV_LOCAL <string> The kernel LOCALVERSION concatenation. ie: -johnm |
45 |
# KV_DIR <string> The kernel source directory, will be null if |
46 |
# KERNEL_DIR is invalid. |
47 |
# KV_OUT_DIR <string> The kernel object directory. will be KV_DIR unless |
48 |
# koutput is used. This should be used for referencing |
49 |
# .config. |
50 |
|
51 |
# And to ensure all the weirdness with crosscompile |
52 |
inherit toolchain-funcs versionator |
53 |
|
54 |
EXPORT_FUNCTIONS pkg_setup |
55 |
|
56 |
# Overwritable environment Var's |
57 |
# --------------------------------------- |
58 |
KERNEL_DIR="${KERNEL_DIR:-${ROOT}usr/src/linux}" |
59 |
|
60 |
|
61 |
# Bug fixes |
62 |
# fix to bug #75034 |
63 |
case ${ARCH} in |
64 |
ppc) BUILD_FIXES="${BUILD_FIXES} TOUT=${T}/.tmp_gas_check";; |
65 |
ppc64) BUILD_FIXES="${BUILD_FIXES} TOUT=${T}/.tmp_gas_check";; |
66 |
esac |
67 |
|
68 |
# These are legacy wrappers for toolchain-funcs. |
69 |
# I dont like them here, but oh well. |
70 |
set_arch_to_kernel() { export ARCH="$(tc-arch-kernel)"; } |
71 |
set_arch_to_portage() { export ARCH="$(tc-arch)"; } |
72 |
|
73 |
# qeinfo "Message" |
74 |
# ------------------- |
75 |
# qeinfo is a quiet einfo call when EBUILD_PHASE |
76 |
# should not have visible output. |
77 |
qout() { |
78 |
local outputmsg type |
79 |
type=${1} |
80 |
shift |
81 |
outputmsg="${@}" |
82 |
case "${EBUILD_PHASE}" in |
83 |
depend) unset outputmsg;; |
84 |
clean) unset outputmsg;; |
85 |
preinst) unset outputmsg;; |
86 |
esac |
87 |
[ -n "${outputmsg}" ] && ${type} "${outputmsg}" |
88 |
} |
89 |
|
90 |
qeinfo() { qout einfo "${@}" ; } |
91 |
qeerror() { qout eerror "${@}" ; } |
92 |
|
93 |
# File Functions |
94 |
# --------------------------------------- |
95 |
|
96 |
# getfilevar accepts 2 vars as follows: |
97 |
# getfilevar <VARIABLE> <CONFIGFILE> |
98 |
|
99 |
getfilevar() { |
100 |
local ERROR workingdir basefname basedname myARCH="${ARCH}" |
101 |
ERROR=0 |
102 |
|
103 |
[ -z "${1}" ] && ERROR=1 |
104 |
[ ! -f "${2}" ] && ERROR=1 |
105 |
|
106 |
if [ "${ERROR}" = 1 ] |
107 |
then |
108 |
echo -e "\n" |
109 |
eerror "getfilevar requires 2 variables, with the second a valid file." |
110 |
eerror " getfilevar <VARIABLE> <CONFIGFILE>" |
111 |
else |
112 |
workingdir=${PWD} |
113 |
basefname=$(basename ${2}) |
114 |
basedname=$(dirname ${2}) |
115 |
unset ARCH |
116 |
|
117 |
cd ${basedname} |
118 |
echo -e "include ${basefname}\ne:\n\t@echo \$(${1})" | \ |
119 |
make ${BUILD_FIXES} -s -f - e 2>/dev/null |
120 |
cd ${workingdir} |
121 |
|
122 |
ARCH=${myARCH} |
123 |
fi |
124 |
} |
125 |
|
126 |
linux_chkconfig_present() { |
127 |
local RESULT |
128 |
RESULT="$(getfilevar CONFIG_${1} ${KV_OUT_DIR}/.config)" |
129 |
[ "${RESULT}" = "m" -o "${RESULT}" = "y" ] && return 0 || return 1 |
130 |
} |
131 |
|
132 |
linux_chkconfig_module() { |
133 |
local RESULT |
134 |
RESULT="$(getfilevar CONFIG_${1} ${KV_OUT_DIR}/.config)" |
135 |
[ "${RESULT}" = "m" ] && return 0 || return 1 |
136 |
} |
137 |
|
138 |
linux_chkconfig_builtin() { |
139 |
local RESULT |
140 |
RESULT="$(getfilevar CONFIG_${1} ${KV_OUT_DIR}/.config)" |
141 |
[ "${RESULT}" = "y" ] && return 0 || return 1 |
142 |
} |
143 |
|
144 |
linux_chkconfig_string() { |
145 |
getfilevar "CONFIG_${1}" "${KV_OUT_DIR}/.config" |
146 |
} |
147 |
|
148 |
# Versioning Functions |
149 |
# --------------------------------------- |
150 |
|
151 |
# kernel_is returns true when the version is the same as the passed version |
152 |
# |
153 |
# For Example where KV = 2.6.9 |
154 |
# kernel_is 2 4 returns false |
155 |
# kernel_is 2 returns true |
156 |
# kernel_is 2 6 returns true |
157 |
# kernel_is 2 6 8 returns false |
158 |
# kernel_is 2 6 9 returns true |
159 |
# |
160 |
# got the jist yet? |
161 |
|
162 |
kernel_is() { |
163 |
# if we haven't determined the version yet, we need too. |
164 |
get_version; |
165 |
local operator test value x=0 y=0 z=0 |
166 |
|
167 |
case ${1} in |
168 |
lt) operator="-lt"; shift;; |
169 |
gt) operator="-gt"; shift;; |
170 |
le) operator="-le"; shift;; |
171 |
ge) operator="-ge"; shift;; |
172 |
eq) operator="-eq"; shift;; |
173 |
*) operator="-eq";; |
174 |
esac |
175 |
|
176 |
for x in ${@}; do |
177 |
for((y=0; y<$((3 - ${#x})); y++)); do value="${value}0"; done |
178 |
value="${value}${x}" |
179 |
z=$((${z} + 1)) |
180 |
|
181 |
case ${z} in |
182 |
1) for((y=0; y<$((3 - ${#KV_MAJOR})); y++)); do test="${test}0"; done; |
183 |
test="${test}${KV_MAJOR}";; |
184 |
2) for((y=0; y<$((3 - ${#KV_MINOR})); y++)); do test="${test}0"; done; |
185 |
test="${test}${KV_MINOR}";; |
186 |
3) for((y=0; y<$((3 - ${#KV_PATCH})); y++)); do test="${test}0"; done; |
187 |
test="${test}${KV_PATCH}";; |
188 |
*) die "Error in kernel-2_kernel_is(): Too many parameters.";; |
189 |
esac |
190 |
done |
191 |
|
192 |
[ ${test} ${operator} ${value} ] && return 0 || return 1 |
193 |
} |
194 |
|
195 |
get_localversion() { |
196 |
local lv_list i x |
197 |
|
198 |
# ignore files with ~ in it. |
199 |
for i in $(ls ${1}/localversion* 2>/dev/null); do |
200 |
[[ -n ${i//*~*} ]] && lv_list="${lv_list} ${i}" |
201 |
done |
202 |
|
203 |
for i in ${lv_list}; do |
204 |
x="${x}$(<${i})" |
205 |
done |
206 |
x=${x/ /} |
207 |
echo ${x} |
208 |
} |
209 |
|
210 |
get_version() { |
211 |
local kbuild_output |
212 |
|
213 |
# no need to execute this twice assuming KV_FULL is populated. |
214 |
# we can force by unsetting KV_FULL |
215 |
[ -n "${KV_FULL}" ] && return 0 |
216 |
|
217 |
# if we dont know KV_FULL, then we need too. |
218 |
# make sure KV_DIR isnt set since we need to work it out via KERNEL_DIR |
219 |
unset KV_DIR |
220 |
|
221 |
# KV_DIR will contain the full path to the sources directory we should use |
222 |
qeinfo "Determining the location of the kernel source code" |
223 |
[ -h "${KERNEL_DIR}" ] && KV_DIR="$(readlink -f ${KERNEL_DIR})" |
224 |
[ -d "${KERNEL_DIR}" ] && KV_DIR="${KERNEL_DIR}" |
225 |
|
226 |
if [ -z "${KV_DIR}" ] |
227 |
then |
228 |
qeerror "Unable to find kernel sources at ${KERNEL_DIR}" |
229 |
qeinfo "This package requires Linux sources." |
230 |
if [ "${KERNEL_DIR}" == "/usr/src/linux" ] ; then |
231 |
qeinfo "Please make sure that ${KERNEL_DIR} points at your running kernel, " |
232 |
qeinfo "(or the kernel you wish to build against)." |
233 |
qeinfo "Alternatively, set the KERNEL_DIR environment variable to the kernel sources location" |
234 |
else |
235 |
qeinfo "Please ensure that the KERNEL_DIR environment variable points at full Linux sources of the kernel you wish to compile against." |
236 |
fi |
237 |
return 1 |
238 |
fi |
239 |
|
240 |
qeinfo "Found kernel source directory:" |
241 |
qeinfo " ${KV_DIR}" |
242 |
|
243 |
if [ ! -s "${KV_DIR}/Makefile" ] |
244 |
then |
245 |
qeerror "Could not find a Makefile in the kernel source directory." |
246 |
qeerror "Please ensure that ${KERNEL_DIR} points to a complete set of Linux sources" |
247 |
return 1 |
248 |
fi |
249 |
|
250 |
# OK so now we know our sources directory, but they might be using |
251 |
# KBUILD_OUTPUT, and we need this for .config and localversions-* |
252 |
# so we better find it eh? |
253 |
# do we pass KBUILD_OUTPUT on the CLI? |
254 |
OUTPUT_DIR="${OUTPUT_DIR:-${KBUILD_OUTPUT}}" |
255 |
|
256 |
# And if we didn't pass it, we can take a nosey in the Makefile |
257 |
kbuild_output="$(getfilevar KBUILD_OUTPUT ${KV_DIR}/Makefile)" |
258 |
OUTPUT_DIR="${OUTPUT_DIR:-${kbuild_output}}" |
259 |
|
260 |
# And contrary to existing functions I feel we shouldn't trust the |
261 |
# directory name to find version information as this seems insane. |
262 |
# so we parse ${KV_DIR}/Makefile |
263 |
KV_MAJOR="$(getfilevar VERSION ${KV_DIR}/Makefile)" |
264 |
KV_MINOR="$(getfilevar PATCHLEVEL ${KV_DIR}/Makefile)" |
265 |
KV_PATCH="$(getfilevar SUBLEVEL ${KV_DIR}/Makefile)" |
266 |
KV_EXTRA="$(getfilevar EXTRAVERSION ${KV_DIR}/Makefile)" |
267 |
|
268 |
if [ -z "${KV_MAJOR}" -o -z "${KV_MINOR}" -o -z "${KV_PATCH}" ] |
269 |
then |
270 |
qeerror "Could not detect kernel version." |
271 |
qeerror "Please ensure that ${KERNEL_DIR} points to a complete set of Linux sources." |
272 |
return 1 |
273 |
fi |
274 |
|
275 |
# and in newer versions we can also pull LOCALVERSION if it is set. |
276 |
# but before we do this, we need to find if we use a different object directory. |
277 |
# This *WILL* break if the user is using localversions, but we assume it was |
278 |
# caught before this if they are. |
279 |
[ "${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}.${KV_EXTRA}" == "$(uname -r)" ] && \ |
280 |
OUTPUT_DIR="${OUTPUT_DIR:-/lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}.${KV_EXTRA}/build}" |
281 |
|
282 |
[ -h "${OUTPUT_DIR}" ] && KV_OUT_DIR="$(readlink -f ${OUTPUT_DIR})" |
283 |
[ -d "${OUTPUT_DIR}" ] && KV_OUT_DIR="${OUTPUT_DIR}" |
284 |
if [ -n "${KV_OUT_DIR}" ]; |
285 |
then |
286 |
qeinfo "Found kernel object directory:" |
287 |
qeinfo " ${KV_OUT_DIR}" |
288 |
|
289 |
KV_LOCAL="$(get_localversion ${KV_OUT_DIR})" |
290 |
fi |
291 |
# and if we STILL haven't got it, then we better just set it to KV_DIR |
292 |
KV_OUT_DIR="${KV_OUT_DIR:-${KV_DIR}}" |
293 |
|
294 |
KV_LOCAL="${KV_LOCAL}$(get_localversion ${KV_OUT_DIR})" |
295 |
KV_LOCAL="${KV_LOCAL}$(linux_chkconfig_string LOCALVERSION)" |
296 |
KV_LOCAL="${KV_LOCAL//\"/}" |
297 |
|
298 |
# And we should set KV_FULL to the full expanded version |
299 |
KV_FULL="${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}${KV_LOCAL}" |
300 |
|
301 |
qeinfo "Found sources for kernel version:" |
302 |
qeinfo " ${KV_FULL}" |
303 |
|
304 |
if [ ! -s "${KV_OUT_DIR}/.config" ] |
305 |
then |
306 |
qeerror "Could not find a usable .config in the kernel source directory." |
307 |
qeerror "Please ensure that ${KERNEL_DIR} points to a configured set of Linux sources." |
308 |
qeerror "If you are using KBUILD_OUTPUT, please set the environment var so that" |
309 |
qeerror "it points to the necessary object directory so that it might find .config." |
310 |
return 1 |
311 |
fi |
312 |
|
313 |
return 0 |
314 |
} |
315 |
|
316 |
get_running_version() { |
317 |
KV_FULL=$(uname -r) |
318 |
|
319 |
if [[ -f ${ROOT}/lib/modules/${KV_FULL}/source/Makefile ]]; then |
320 |
KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/source) |
321 |
unset KV_FULL |
322 |
get_version |
323 |
return $? |
324 |
elif [[ -f ${ROOT}/lib/modules/${KV_FULL}/build/Makefile ]]; then |
325 |
KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/build) |
326 |
unset KV_FULL |
327 |
get_version |
328 |
return $? |
329 |
else |
330 |
KV_MAJOR=$(get_version_component_range 1 ${KV_FULL}) |
331 |
KV_MINOR=$(get_version_component_range 2 ${KV_FULL}) |
332 |
KV_PATCH=$(get_version_component_range 3- ${KV_FULL}) |
333 |
KV_PATCH=${KV_PATCH//-*} |
334 |
[[ -n ${KV_FULL#*-} ]] && [[ -n ${KV_FULL//${KV_FULL#*-}} ]] \ |
335 |
&& KV_EXTRA="-${KV_FULL#*-}" |
336 |
fi |
337 |
return 0 |
338 |
} |
339 |
|
340 |
|
341 |
# ebuild check functions |
342 |
# --------------------------------------- |
343 |
|
344 |
check_kernel_built() { |
345 |
# if we haven't determined the version yet, we need too. |
346 |
get_version; |
347 |
|
348 |
if [ ! -f "${KV_OUT_DIR}/include/linux/version.h" ] |
349 |
then |
350 |
eerror "These sources have not yet been prepared." |
351 |
eerror "We cannot build against an unprepared tree." |
352 |
eerror "To resolve this, please type the following:" |
353 |
eerror |
354 |
eerror "# cd ${KV_DIR}" |
355 |
eerror "# make oldconfig" |
356 |
eerror "# make modules_prepare" |
357 |
eerror |
358 |
eerror "Then please try merging this module again." |
359 |
die "Kernel sources need compiling first" |
360 |
fi |
361 |
} |
362 |
|
363 |
check_modules_supported() { |
364 |
# if we haven't determined the version yet, we need too. |
365 |
get_version; |
366 |
|
367 |
if ! linux_chkconfig_builtin "MODULES" |
368 |
then |
369 |
eerror "These sources do not support loading external modules." |
370 |
eerror "to be able to use this module please enable \"Loadable modules support\"" |
371 |
eerror "in your kernel, recompile and then try merging this module again." |
372 |
die "No support for external modules in ${KV_FULL} config" |
373 |
fi |
374 |
} |
375 |
|
376 |
check_extra_config() { |
377 |
local config negate error local_error i n temp_config |
378 |
|
379 |
# if we haven't determined the version yet, we need too. |
380 |
get_version; |
381 |
|
382 |
einfo "Checking for suitable kernel configuration options" |
383 |
for config in ${CONFIG_CHECK} |
384 |
do |
385 |
negate="${config:0:1}" |
386 |
if [ "${negate}" == "!" ]; |
387 |
then |
388 |
config="${config:1}" |
389 |
if linux_chkconfig_present ${config} |
390 |
then |
391 |
local_error="${config}_ERROR" |
392 |
local_error="${!local_error}" |
393 |
[ -n "${local_error}" ] && eerror " ${local_error}" || \ |
394 |
eerror " CONFIG_${config}:\tshould not be set in the kernel configuration, but it is." |
395 |
error=1 |
396 |
fi |
397 |
elif [ "${negate}" == "@" ]; |
398 |
then |
399 |
# we never call this unless we are using MODULE_NAMES |
400 |
|
401 |
config="${config:1}" |
402 |
temp_config="${config//*:}" |
403 |
config="${config//:*}" |
404 |
if linux_chkconfig_present ${config} |
405 |
then |
406 |
local_error="${config}_ERROR" |
407 |
local_error="${!local_error}" |
408 |
[ -n "${local_error}" ] && eerror " ${local_error}" || \ |
409 |
eerror " CONFIG_${config}:\tshould not be set in the kernel configuration, but it is." |
410 |
|
411 |
for i in ${MODULE_NAMES} |
412 |
do |
413 |
n="${i//${temp_config}}" |
414 |
[ -z "${n//(*}" ] && MODULE_IGNORE="${MODULE_IGNORE} ${temp_config}" |
415 |
done |
416 |
error=0 |
417 |
fi |
418 |
else |
419 |
if ! linux_chkconfig_present ${config} |
420 |
then |
421 |
# Support the new syntax first. |
422 |
local_error="ERROR_${config}" |
423 |
local_error="${!local_error}" |
424 |
|
425 |
# then fall back on the older syntax. |
426 |
if [[ -z ${local_error} ]] ; then |
427 |
local_error="${config}_ERROR" |
428 |
local_error="${!local_error}" |
429 |
fi |
430 |
|
431 |
[[ -n ${local_error} ]] && eerror " ${local_error}" || \ |
432 |
eerror " CONFIG_${config}:\tshould be set in the kernel configuration, but isn't" |
433 |
error=1 |
434 |
fi |
435 |
fi |
436 |
done |
437 |
|
438 |
if [ "${error}" == 1 ] ; |
439 |
then |
440 |
eerror "Please check to make sure these options are set correctly." |
441 |
eerror "Once you have satisfied these options, please try merging" |
442 |
eerror "this package again." |
443 |
die "Incorrect kernel configuration options" |
444 |
fi |
445 |
} |
446 |
|
447 |
check_zlibinflate() { |
448 |
# if we haven't determined the version yet, we need too. |
449 |
get_version; |
450 |
|
451 |
# although I restructured this code - I really really really dont support it! |
452 |
|
453 |
# bug #27882 - zlib routines are only linked into the kernel |
454 |
# if something compiled into the kernel calls them |
455 |
# |
456 |
# plus, for the cloop module, it appears that there's no way |
457 |
# to get cloop.o to include a static zlib if CONFIG_MODVERSIONS |
458 |
# is on |
459 |
|
460 |
local INFLATE |
461 |
local DEFLATE |
462 |
|
463 |
einfo "Determining the usability of ZLIB_INFLATE support in your kernel" |
464 |
|
465 |
ebegin "checking ZLIB_INFLATE" |
466 |
getfilevar_isbuiltin CONFIG_ZLIB_INFLATE ${KV_DIR}/.config |
467 |
eend $? |
468 |
[ "$?" != 0 ] && die |
469 |
|
470 |
ebegin "checking ZLIB_DEFLATE" |
471 |
getfilevar_isbuiltin CONFIG_ZLIB_DEFLATE ${KV_DIR}/.config |
472 |
eend $? |
473 |
[ "$?" != 0 ] && die |
474 |
|
475 |
local LINENO_START |
476 |
local LINENO_END |
477 |
local SYMBOLS |
478 |
local x |
479 |
|
480 |
LINENO_END="$(grep -n 'CONFIG_ZLIB_INFLATE y' ${KV_DIR}/lib/Config.in | cut -d : -f 1)" |
481 |
LINENO_START="$(head -n $LINENO_END ${KV_DIR}/lib/Config.in | grep -n 'if \[' | tail -n 1 | cut -d : -f 1)" |
482 |
(( LINENO_AMOUNT = $LINENO_END - $LINENO_START )) |
483 |
(( LINENO_END = $LINENO_END - 1 )) |
484 |
SYMBOLS="$(head -n $LINENO_END ${KV_DIR}/lib/Config.in | tail -n $LINENO_AMOUNT | sed -e 's/^.*\(CONFIG_[^\" ]*\).*/\1/g;')" |
485 |
|
486 |
# okay, now we have a list of symbols |
487 |
# we need to check each one in turn, to see whether it is set or not |
488 |
for x in $SYMBOLS ; do |
489 |
if [ "${!x}" = "y" ]; then |
490 |
# we have a winner! |
491 |
einfo "${x} ensures zlib is linked into your kernel - excellent" |
492 |
return 0 |
493 |
fi |
494 |
done |
495 |
|
496 |
eerror |
497 |
eerror "This kernel module requires ZLIB library support." |
498 |
eerror "You have enabled zlib support in your kernel, but haven't enabled" |
499 |
eerror "enabled any option that will ensure that zlib is linked into your" |
500 |
eerror "kernel." |
501 |
eerror |
502 |
eerror "Please ensure that you enable at least one of these options:" |
503 |
eerror |
504 |
|
505 |
for x in $SYMBOLS ; do |
506 |
eerror " * $x" |
507 |
done |
508 |
|
509 |
eerror |
510 |
eerror "Please remember to recompile and install your kernel, and reboot" |
511 |
eerror "into your new kernel before attempting to load this kernel module." |
512 |
|
513 |
die "Kernel doesn't include zlib support" |
514 |
} |
515 |
|
516 |
################################ |
517 |
# Default pkg_setup |
518 |
# Also used when inheriting linux-mod to force a get_version call |
519 |
|
520 |
linux-info_pkg_setup() { |
521 |
get_version || die "Unable to calculate Linux Kernel version" |
522 |
[ -n "${CONFIG_CHECK}" ] && check_extra_config; |
523 |
} |