1 |
# Copyright 1999-2012 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.92 2012/06/26 00:06:14 robbat2 Exp $ |
4 |
|
5 |
# @ECLASS: linux-info.eclass |
6 |
# @MAINTAINER: |
7 |
# kernel-misc@gentoo.org |
8 |
# @AUTHOR: |
9 |
# Original author: John Mylchreest <johnm@gentoo.org> |
10 |
# @BLURB: eclass used for accessing kernel related information |
11 |
# @DESCRIPTION: |
12 |
# This eclass is used as a central eclass for accessing kernel |
13 |
# related information for source or binary already installed. |
14 |
# It is vital for linux-mod.eclass to function correctly, and is split |
15 |
# out so that any ebuild behaviour "templates" are abstracted out |
16 |
# using additional eclasses. |
17 |
# |
18 |
# "kernel config" in this file means: |
19 |
# The .config of the currently installed sources is used as the first |
20 |
# preference, with a fall-back to bundled config (/proc/config.gz) if available. |
21 |
# |
22 |
# Before using any of the config-handling functions in this eclass, you must |
23 |
# ensure that one of the following functions has been called (in order of |
24 |
# preference), otherwise you will get bugs like #364041): |
25 |
# linux-info_pkg_setup |
26 |
# linux-info_get_any_version |
27 |
# get_version |
28 |
# get_running_version |
29 |
|
30 |
# A Couple of env vars are available to effect usage of this eclass |
31 |
# These are as follows: |
32 |
|
33 |
# @ECLASS-VARIABLE: KERNEL_DIR |
34 |
# @DESCRIPTION: |
35 |
# A string containing the directory of the target kernel sources. The default value is |
36 |
# "/usr/src/linux" |
37 |
|
38 |
# @ECLASS-VARIABLE: CONFIG_CHECK |
39 |
# @DESCRIPTION: |
40 |
# A string containing a list of .config options to check for before |
41 |
# proceeding with the install. |
42 |
# |
43 |
# e.g.: CONFIG_CHECK="MTRR" |
44 |
# |
45 |
# You can also check that an option doesn't exist by |
46 |
# prepending it with an exclamation mark (!). |
47 |
# |
48 |
# e.g.: CONFIG_CHECK="!MTRR" |
49 |
# |
50 |
# To simply warn about a missing option, prepend a '~'. |
51 |
# It may be combined with '!'. |
52 |
# |
53 |
# In general, most checks should be non-fatal. The only time fatal checks should |
54 |
# be used is for building kernel modules or cases that a compile will fail |
55 |
# without the option. |
56 |
# |
57 |
# This is to allow usage of binary kernels, and minimal systems without kernel |
58 |
# sources. |
59 |
|
60 |
# @ECLASS-VARIABLE: ERROR_<CFG> |
61 |
# @DESCRIPTION: |
62 |
# A string containing the error message to display when the check against CONFIG_CHECK |
63 |
# fails. <CFG> should reference the appropriate option used in CONFIG_CHECK. |
64 |
# |
65 |
# e.g.: ERROR_MTRR="MTRR exists in the .config but shouldn't!!" |
66 |
|
67 |
# @ECLASS-VARIABLE: KBUILD_OUTPUT |
68 |
# @DESCRIPTION: |
69 |
# A string passed on commandline, or set from the kernel makefile. It contains the directory |
70 |
# which is to be used as the kernel object directory. |
71 |
|
72 |
# There are also a couple of variables which are set by this, and shouldn't be |
73 |
# set by hand. These are as follows: |
74 |
|
75 |
# @ECLASS-VARIABLE: KV_FULL |
76 |
# @DESCRIPTION: |
77 |
# A read-only variable. It's a string containing the full kernel version. ie: 2.6.9-gentoo-johnm-r1 |
78 |
|
79 |
# @ECLASS-VARIABLE: KV_MAJOR |
80 |
# @DESCRIPTION: |
81 |
# A read-only variable. It's an integer containing the kernel major version. ie: 2 |
82 |
|
83 |
# @ECLASS-VARIABLE: KV_MINOR |
84 |
# @DESCRIPTION: |
85 |
# A read-only variable. It's an integer containing the kernel minor version. ie: 6 |
86 |
|
87 |
# @ECLASS-VARIABLE: KV_PATCH |
88 |
# @DESCRIPTION: |
89 |
# A read-only variable. It's an integer containing the kernel patch version. ie: 9 |
90 |
|
91 |
# @ECLASS-VARIABLE: KV_EXTRA |
92 |
# @DESCRIPTION: |
93 |
# A read-only variable. It's a string containing the kernel EXTRAVERSION. ie: -gentoo |
94 |
|
95 |
# @ECLASS-VARIABLE: KV_LOCAL |
96 |
# @DESCRIPTION: |
97 |
# A read-only variable. It's a string containing the kernel LOCALVERSION concatenation. ie: -johnm |
98 |
|
99 |
# @ECLASS-VARIABLE: KV_DIR |
100 |
# @DESCRIPTION: |
101 |
# A read-only variable. It's a string containing the kernel source directory, will be null if |
102 |
# KERNEL_DIR is invalid. |
103 |
|
104 |
# @ECLASS-VARIABLE: KV_OUT_DIR |
105 |
# @DESCRIPTION: |
106 |
# A read-only variable. It's a string containing the kernel object directory, will be KV_DIR unless |
107 |
# KBUILD_OUTPUT is used. This should be used for referencing .config. |
108 |
|
109 |
# And to ensure all the weirdness with crosscompile |
110 |
inherit toolchain-funcs versionator |
111 |
|
112 |
EXPORT_FUNCTIONS pkg_setup |
113 |
|
114 |
DEPEND="" |
115 |
RDEPEND="" |
116 |
|
117 |
# Overwritable environment Var's |
118 |
# --------------------------------------- |
119 |
KERNEL_DIR="${KERNEL_DIR:-${ROOT}usr/src/linux}" |
120 |
|
121 |
|
122 |
# Bug fixes |
123 |
# fix to bug #75034 |
124 |
case ${ARCH} in |
125 |
ppc) BUILD_FIXES="${BUILD_FIXES} TOUT=${T}/.tmp_gas_check";; |
126 |
ppc64) BUILD_FIXES="${BUILD_FIXES} TOUT=${T}/.tmp_gas_check";; |
127 |
esac |
128 |
|
129 |
# @FUNCTION: set_arch_to_kernel |
130 |
# @DESCRIPTION: |
131 |
# Set the env ARCH to match what the kernel expects. |
132 |
set_arch_to_kernel() { export ARCH=$(tc-arch-kernel); } |
133 |
# @FUNCTION: set_arch_to_portage |
134 |
# @DESCRIPTION: |
135 |
# Set the env ARCH to match what portage expects. |
136 |
set_arch_to_portage() { export ARCH=$(tc-arch); } |
137 |
|
138 |
# qeinfo "Message" |
139 |
# ------------------- |
140 |
# qeinfo is a quiet einfo call when EBUILD_PHASE |
141 |
# should not have visible output. |
142 |
qout() { |
143 |
local outputmsg type |
144 |
type=${1} |
145 |
shift |
146 |
outputmsg="${@}" |
147 |
case "${EBUILD_PHASE}" in |
148 |
depend) unset outputmsg;; |
149 |
clean) unset outputmsg;; |
150 |
preinst) unset outputmsg;; |
151 |
esac |
152 |
[ -n "${outputmsg}" ] && ${type} "${outputmsg}" |
153 |
} |
154 |
|
155 |
qeinfo() { qout einfo "${@}" ; } |
156 |
qewarn() { qout ewarn "${@}" ; } |
157 |
qeerror() { qout eerror "${@}" ; } |
158 |
|
159 |
# File Functions |
160 |
# --------------------------------------- |
161 |
|
162 |
# @FUNCTION: getfilevar |
163 |
# @USAGE: variable configfile |
164 |
# @RETURN: the value of the variable |
165 |
# @DESCRIPTION: |
166 |
# It detects the value of the variable defined in the file configfile. This is |
167 |
# done by including the configfile, and printing the variable with Make. |
168 |
# It WILL break if your makefile has missing dependencies! |
169 |
getfilevar() { |
170 |
local ERROR basefname basedname myARCH="${ARCH}" |
171 |
ERROR=0 |
172 |
|
173 |
[ -z "${1}" ] && ERROR=1 |
174 |
[ ! -f "${2}" ] && ERROR=1 |
175 |
|
176 |
if [ "${ERROR}" = 1 ] |
177 |
then |
178 |
echo -e "\n" |
179 |
eerror "getfilevar requires 2 variables, with the second a valid file." |
180 |
eerror " getfilevar <VARIABLE> <CONFIGFILE>" |
181 |
else |
182 |
basefname="$(basename ${2})" |
183 |
basedname="$(dirname ${2})" |
184 |
unset ARCH |
185 |
|
186 |
echo -e "e:\\n\\t@echo \$(${1})\\ninclude ${basefname}" | \ |
187 |
make -C "${basedname}" M="${S}" ${BUILD_FIXES} -s -f - 2>/dev/null |
188 |
|
189 |
ARCH=${myARCH} |
190 |
fi |
191 |
} |
192 |
|
193 |
# @FUNCTION: getfilevar_noexec |
194 |
# @USAGE: variable configfile |
195 |
# @RETURN: the value of the variable |
196 |
# @DESCRIPTION: |
197 |
# It detects the value of the variable defined in the file configfile. |
198 |
# This is done with sed matching an expression only. If the variable is defined, |
199 |
# you will run into problems. See getfilevar for those cases. |
200 |
getfilevar_noexec() { |
201 |
local ERROR basefname basedname mycat myARCH="${ARCH}" |
202 |
ERROR=0 |
203 |
mycat='cat' |
204 |
|
205 |
[ -z "${1}" ] && ERROR=1 |
206 |
[ ! -f "${2}" ] && ERROR=1 |
207 |
[ "${2%.gz}" != "${2}" ] && mycat='zcat' |
208 |
|
209 |
if [ "${ERROR}" = 1 ] |
210 |
then |
211 |
echo -e "\n" |
212 |
eerror "getfilevar_noexec requires 2 variables, with the second a valid file." |
213 |
eerror " getfilevar_noexec <VARIABLE> <CONFIGFILE>" |
214 |
else |
215 |
${mycat} "${2}" | \ |
216 |
sed -n \ |
217 |
-e "/^[[:space:]]*${1}[[:space:]]*:\\?=[[:space:]]*\(.*\)\$/{ |
218 |
s,^[^=]*[[:space:]]*=[[:space:]]*,,g ; |
219 |
s,[[:space:]]*\$,,g ; |
220 |
p |
221 |
}" |
222 |
fi |
223 |
} |
224 |
|
225 |
# @ECLASS-VARIABLE: _LINUX_CONFIG_EXISTS_DONE |
226 |
# @INTERNAL |
227 |
# @DESCRIPTION: |
228 |
# This is only set if one of the linux_config_*exists functions has been called. |
229 |
# We use it for a QA warning that the check for a config has not been performed, |
230 |
# as linux_chkconfig* in non-legacy mode WILL return an undefined value if no |
231 |
# config is available at all. |
232 |
_LINUX_CONFIG_EXISTS_DONE= |
233 |
|
234 |
linux_config_qa_check() { |
235 |
local f="$1" |
236 |
if [ -z "${_LINUX_CONFIG_EXISTS_DONE}" ]; then |
237 |
ewarn "QA: You called $f before any linux_config_exists!" |
238 |
ewarn "QA: The return value of $f will NOT guaranteed later!" |
239 |
fi |
240 |
} |
241 |
|
242 |
# @FUNCTION: linux_config_src_exists |
243 |
# @RETURN: true or false |
244 |
# @DESCRIPTION: |
245 |
# It returns true if .config exists in a build directory otherwise false |
246 |
linux_config_src_exists() { |
247 |
export _LINUX_CONFIG_EXISTS_DONE=1 |
248 |
[ -s "${KV_OUT_DIR}/.config" ] |
249 |
} |
250 |
|
251 |
# @FUNCTION: linux_config_bin_exists |
252 |
# @RETURN: true or false |
253 |
# @DESCRIPTION: |
254 |
# It returns true if .config exists in /proc, otherwise false |
255 |
linux_config_bin_exists() { |
256 |
export _LINUX_CONFIG_EXISTS_DONE=1 |
257 |
[ -s "/proc/config.gz" ] |
258 |
} |
259 |
|
260 |
# @FUNCTION: linux_config_exists |
261 |
# @RETURN: true or false |
262 |
# @DESCRIPTION: |
263 |
# It returns true if .config exists otherwise false |
264 |
# |
265 |
# This function MUST be checked before using any of the linux_chkconfig_* |
266 |
# functions. |
267 |
linux_config_exists() { |
268 |
linux_config_src_exists || linux_config_bin_exists |
269 |
} |
270 |
|
271 |
# @FUNCTION: require_configured_kernel |
272 |
# @DESCRIPTION: |
273 |
# This function verifies that the current kernel is configured (it checks against the existence of .config) |
274 |
# otherwise it dies. |
275 |
require_configured_kernel() { |
276 |
if ! linux_config_src_exists; then |
277 |
qeerror "Could not find a usable .config in the kernel source directory." |
278 |
qeerror "Please ensure that ${KERNEL_DIR} points to a configured set of Linux sources." |
279 |
qeerror "If you are using KBUILD_OUTPUT, please set the environment var so that" |
280 |
qeerror "it points to the necessary object directory so that it might find .config." |
281 |
die "Kernel not configured; no .config found in ${KV_OUT_DIR}" |
282 |
fi |
283 |
} |
284 |
|
285 |
# @FUNCTION: linux_chkconfig_present |
286 |
# @USAGE: option |
287 |
# @RETURN: true or false |
288 |
# @DESCRIPTION: |
289 |
# It checks that CONFIG_<option>=y or CONFIG_<option>=m is present in the current kernel .config |
290 |
# If linux_config_exists returns false, the results of this are UNDEFINED. You |
291 |
# MUST call linux_config_exists first. |
292 |
linux_chkconfig_present() { |
293 |
linux_config_qa_check linux_chkconfig_present |
294 |
local RESULT |
295 |
local config |
296 |
config="${KV_OUT_DIR}/.config" |
297 |
[ ! -f "${config}" ] && config="/proc/config.gz" |
298 |
RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")" |
299 |
[ "${RESULT}" = "m" -o "${RESULT}" = "y" ] && return 0 || return 1 |
300 |
} |
301 |
|
302 |
# @FUNCTION: linux_chkconfig_module |
303 |
# @USAGE: option |
304 |
# @RETURN: true or false |
305 |
# @DESCRIPTION: |
306 |
# It checks that CONFIG_<option>=m is present in the current kernel .config |
307 |
# If linux_config_exists returns false, the results of this are UNDEFINED. You |
308 |
# MUST call linux_config_exists first. |
309 |
linux_chkconfig_module() { |
310 |
linux_config_qa_check linux_chkconfig_module |
311 |
local RESULT |
312 |
local config |
313 |
config="${KV_OUT_DIR}/.config" |
314 |
[ ! -f "${config}" ] && config="/proc/config.gz" |
315 |
RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")" |
316 |
[ "${RESULT}" = "m" ] && return 0 || return 1 |
317 |
} |
318 |
|
319 |
# @FUNCTION: linux_chkconfig_builtin |
320 |
# @USAGE: option |
321 |
# @RETURN: true or false |
322 |
# @DESCRIPTION: |
323 |
# It checks that CONFIG_<option>=y is present in the current kernel .config |
324 |
# If linux_config_exists returns false, the results of this are UNDEFINED. You |
325 |
# MUST call linux_config_exists first. |
326 |
linux_chkconfig_builtin() { |
327 |
linux_config_qa_check linux_chkconfig_builtin |
328 |
local RESULT |
329 |
local config |
330 |
config="${KV_OUT_DIR}/.config" |
331 |
[ ! -f "${config}" ] && config="/proc/config.gz" |
332 |
RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")" |
333 |
[ "${RESULT}" = "y" ] && return 0 || return 1 |
334 |
} |
335 |
|
336 |
# @FUNCTION: linux_chkconfig_string |
337 |
# @USAGE: option |
338 |
# @RETURN: CONFIG_<option> |
339 |
# @DESCRIPTION: |
340 |
# It prints the CONFIG_<option> value of the current kernel .config (it requires a configured kernel). |
341 |
# If linux_config_exists returns false, the results of this are UNDEFINED. You |
342 |
# MUST call linux_config_exists first. |
343 |
linux_chkconfig_string() { |
344 |
linux_config_qa_check linux_chkconfig_string |
345 |
local config |
346 |
config="${KV_OUT_DIR}/.config" |
347 |
[ ! -f "${config}" ] && config="/proc/config.gz" |
348 |
getfilevar_noexec "CONFIG_${1}" "${config}" |
349 |
} |
350 |
|
351 |
# Versioning Functions |
352 |
# --------------------------------------- |
353 |
|
354 |
# @FUNCTION: kernel_is |
355 |
# @USAGE: [-lt -gt -le -ge -eq] major_number [minor_number patch_number] |
356 |
# @RETURN: true or false |
357 |
# @DESCRIPTION: |
358 |
# It returns true when the current kernel version satisfies the comparison against the passed version. |
359 |
# -eq is the default comparison. |
360 |
# |
361 |
# @CODE |
362 |
# For Example where KV = 2.6.9 |
363 |
# kernel_is 2 4 returns false |
364 |
# kernel_is 2 returns true |
365 |
# kernel_is 2 6 returns true |
366 |
# kernel_is 2 6 8 returns false |
367 |
# kernel_is 2 6 9 returns true |
368 |
# @CODE |
369 |
|
370 |
# Note: duplicated in kernel-2.eclass |
371 |
kernel_is() { |
372 |
# if we haven't determined the version yet, we need to. |
373 |
linux-info_get_any_version |
374 |
|
375 |
# Now we can continue |
376 |
local operator test value |
377 |
|
378 |
case ${1#-} in |
379 |
lt) operator="-lt"; shift;; |
380 |
gt) operator="-gt"; shift;; |
381 |
le) operator="-le"; shift;; |
382 |
ge) operator="-ge"; shift;; |
383 |
eq) operator="-eq"; shift;; |
384 |
*) operator="-eq";; |
385 |
esac |
386 |
[[ $# -gt 3 ]] && die "Error in kernel-2_kernel_is(): too many parameters" |
387 |
|
388 |
: $(( test = (KV_MAJOR << 16) + (KV_MINOR << 8) + KV_PATCH )) |
389 |
: $(( value = (${1:-${KV_MAJOR}} << 16) + (${2:-${KV_MINOR}} << 8) + ${3:-${KV_PATCH}} )) |
390 |
[ ${test} ${operator} ${value} ] |
391 |
} |
392 |
|
393 |
get_localversion() { |
394 |
local lv_list i x |
395 |
|
396 |
# ignore files with ~ in it. |
397 |
for i in $(ls ${1}/localversion* 2>/dev/null); do |
398 |
[[ -n ${i//*~*} ]] && lv_list="${lv_list} ${i}" |
399 |
done |
400 |
|
401 |
for i in ${lv_list}; do |
402 |
x="${x}$(<${i})" |
403 |
done |
404 |
x=${x/ /} |
405 |
echo ${x} |
406 |
} |
407 |
|
408 |
# Check if the Makefile is valid for direct parsing. |
409 |
# Check status results: |
410 |
# - PASS, use 'getfilevar' to extract values |
411 |
# - FAIL, use 'getfilevar_noexec' to extract values |
412 |
# The check may fail if: |
413 |
# - make is not present |
414 |
# - corruption exists in the kernel makefile |
415 |
get_makefile_extract_function() { |
416 |
local a='' b='' mkfunc='getfilevar' |
417 |
a="$(getfilevar VERSION ${KERNEL_MAKEFILE})" |
418 |
b="$(getfilevar_noexec VERSION ${KERNEL_MAKEFILE})" |
419 |
[[ "${a}" != "${b}" ]] && mkfunc='getfilevar_noexec' |
420 |
echo "${mkfunc}" |
421 |
} |
422 |
|
423 |
# internal variable, so we know to only print the warning once |
424 |
get_version_warning_done= |
425 |
|
426 |
# @FUNCTION: get_version |
427 |
# @DESCRIPTION: |
428 |
# It gets the version of the kernel inside KERNEL_DIR and populates the KV_FULL variable |
429 |
# (if KV_FULL is already set it does nothing). |
430 |
# |
431 |
# The kernel version variables (KV_MAJOR, KV_MINOR, KV_PATCH, KV_EXTRA and KV_LOCAL) are also set. |
432 |
# |
433 |
# The KV_DIR is set using the KERNEL_DIR env var, the KV_DIR_OUT is set using a valid |
434 |
# KBUILD_OUTPUT (in a decreasing priority list, we look for the env var, makefile var or the |
435 |
# symlink /lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}/build). |
436 |
get_version() { |
437 |
local kbuild_output mkfunc tmplocal |
438 |
|
439 |
# no need to execute this twice assuming KV_FULL is populated. |
440 |
# we can force by unsetting KV_FULL |
441 |
[ -n "${KV_FULL}" ] && return 0 |
442 |
|
443 |
# if we dont know KV_FULL, then we need too. |
444 |
# make sure KV_DIR isnt set since we need to work it out via KERNEL_DIR |
445 |
unset KV_DIR |
446 |
|
447 |
# KV_DIR will contain the full path to the sources directory we should use |
448 |
[ -z "${get_version_warning_done}" ] && \ |
449 |
qeinfo "Determining the location of the kernel source code" |
450 |
[ -h "${KERNEL_DIR}" ] && KV_DIR="$(readlink -f ${KERNEL_DIR})" |
451 |
[ -d "${KERNEL_DIR}" ] && KV_DIR="${KERNEL_DIR}" |
452 |
|
453 |
if [ -z "${KV_DIR}" ] |
454 |
then |
455 |
if [ -z "${get_version_warning_done}" ]; then |
456 |
get_version_warning_done=1 |
457 |
qeerror "Unable to find kernel sources at ${KERNEL_DIR}" |
458 |
#qeinfo "This package requires Linux sources." |
459 |
if [ "${KERNEL_DIR}" == "/usr/src/linux" ] ; then |
460 |
qeinfo "Please make sure that ${KERNEL_DIR} points at your running kernel, " |
461 |
qeinfo "(or the kernel you wish to build against)." |
462 |
qeinfo "Alternatively, set the KERNEL_DIR environment variable to the kernel sources location" |
463 |
else |
464 |
qeinfo "Please ensure that the KERNEL_DIR environment variable points at full Linux sources of the kernel you wish to compile against." |
465 |
fi |
466 |
fi |
467 |
return 1 |
468 |
fi |
469 |
|
470 |
if [ -z "${get_version_warning_done}" ]; then |
471 |
qeinfo "Found kernel source directory:" |
472 |
qeinfo " ${KV_DIR}" |
473 |
fi |
474 |
|
475 |
if [ ! -s "${KV_DIR}/Makefile" ] |
476 |
then |
477 |
if [ -z "${get_version_warning_done}" ]; then |
478 |
get_version_warning_done=1 |
479 |
qeerror "Could not find a Makefile in the kernel source directory." |
480 |
qeerror "Please ensure that ${KERNEL_DIR} points to a complete set of Linux sources" |
481 |
fi |
482 |
return 1 |
483 |
fi |
484 |
|
485 |
# OK so now we know our sources directory, but they might be using |
486 |
# KBUILD_OUTPUT, and we need this for .config and localversions-* |
487 |
# so we better find it eh? |
488 |
# do we pass KBUILD_OUTPUT on the CLI? |
489 |
OUTPUT_DIR="${OUTPUT_DIR:-${KBUILD_OUTPUT}}" |
490 |
|
491 |
# keep track of it |
492 |
KERNEL_MAKEFILE="${KV_DIR}/Makefile" |
493 |
|
494 |
# Decide the function used to extract makefile variables. |
495 |
mkfunc="$(get_makefile_extract_function "${KERNEL_MAKEFILE}")" |
496 |
|
497 |
# And if we didn't pass it, we can take a nosey in the Makefile |
498 |
kbuild_output="$(${mkfunc} KBUILD_OUTPUT ${KERNEL_MAKEFILE})" |
499 |
OUTPUT_DIR="${OUTPUT_DIR:-${kbuild_output}}" |
500 |
|
501 |
# And contrary to existing functions I feel we shouldn't trust the |
502 |
# directory name to find version information as this seems insane. |
503 |
# so we parse ${KERNEL_MAKEFILE} |
504 |
KV_MAJOR="$(${mkfunc} VERSION ${KERNEL_MAKEFILE})" |
505 |
KV_MINOR="$(${mkfunc} PATCHLEVEL ${KERNEL_MAKEFILE})" |
506 |
KV_PATCH="$(${mkfunc} SUBLEVEL ${KERNEL_MAKEFILE})" |
507 |
KV_EXTRA="$(${mkfunc} EXTRAVERSION ${KERNEL_MAKEFILE})" |
508 |
|
509 |
if [ -z "${KV_MAJOR}" -o -z "${KV_MINOR}" -o -z "${KV_PATCH}" ] |
510 |
then |
511 |
if [ -z "${get_version_warning_done}" ]; then |
512 |
get_version_warning_done=1 |
513 |
qeerror "Could not detect kernel version." |
514 |
qeerror "Please ensure that ${KERNEL_DIR} points to a complete set of Linux sources." |
515 |
fi |
516 |
return 1 |
517 |
fi |
518 |
|
519 |
# and in newer versions we can also pull LOCALVERSION if it is set. |
520 |
# but before we do this, we need to find if we use a different object directory. |
521 |
# This *WILL* break if the user is using localversions, but we assume it was |
522 |
# caught before this if they are. |
523 |
OUTPUT_DIR="${OUTPUT_DIR:-/lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}/build}" |
524 |
|
525 |
[ -h "${OUTPUT_DIR}" ] && KV_OUT_DIR="$(readlink -f ${OUTPUT_DIR})" |
526 |
[ -d "${OUTPUT_DIR}" ] && KV_OUT_DIR="${OUTPUT_DIR}" |
527 |
if [ -n "${KV_OUT_DIR}" ]; |
528 |
then |
529 |
qeinfo "Found kernel object directory:" |
530 |
qeinfo " ${KV_OUT_DIR}" |
531 |
fi |
532 |
# and if we STILL have not got it, then we better just set it to KV_DIR |
533 |
KV_OUT_DIR="${KV_OUT_DIR:-${KV_DIR}}" |
534 |
|
535 |
# Grab the kernel release from the output directory. |
536 |
# TODO: we MUST detect kernel.release being out of date, and 'return 1' from |
537 |
# this function. |
538 |
if [ -s "${KV_OUT_DIR}"/include/config/kernel.release ]; then |
539 |
KV_LOCAL=$(<"${KV_OUT_DIR}"/include/config/kernel.release) |
540 |
elif [ -s "${KV_OUT_DIR}"/.kernelrelease ]; then |
541 |
KV_LOCAL=$(<"${KV_OUT_DIR}"/.kernelrelease) |
542 |
else |
543 |
KV_LOCAL= |
544 |
fi |
545 |
|
546 |
# KV_LOCAL currently contains the full release; discard the first bits. |
547 |
tmplocal=${KV_LOCAL#${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}} |
548 |
|
549 |
# If the updated local version was not changed, the tree is not prepared. |
550 |
# Clear out KV_LOCAL in that case. |
551 |
# TODO: this does not detect a change in the localversion part between |
552 |
# kernel.release and the value that would be generated. |
553 |
if [ "$KV_LOCAL" = "$tmplocal" ]; then |
554 |
KV_LOCAL= |
555 |
else |
556 |
KV_LOCAL=$tmplocal |
557 |
fi |
558 |
|
559 |
# And we should set KV_FULL to the full expanded version |
560 |
KV_FULL="${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}${KV_LOCAL}" |
561 |
|
562 |
qeinfo "Found sources for kernel version:" |
563 |
qeinfo " ${KV_FULL}" |
564 |
|
565 |
return 0 |
566 |
} |
567 |
|
568 |
# @FUNCTION: get_running_version |
569 |
# @DESCRIPTION: |
570 |
# It gets the version of the current running kernel and the result is the same as get_version() if the |
571 |
# function can find the sources. |
572 |
get_running_version() { |
573 |
KV_FULL=$(uname -r) |
574 |
|
575 |
if [[ -f ${ROOT}/lib/modules/${KV_FULL}/source/Makefile && -f ${ROOT}/lib/modules/${KV_FULL}/build/Makefile ]]; then |
576 |
KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/source) |
577 |
KBUILD_OUTPUT=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/build) |
578 |
unset KV_FULL |
579 |
get_version |
580 |
return $? |
581 |
elif [[ -f ${ROOT}/lib/modules/${KV_FULL}/source/Makefile ]]; then |
582 |
KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/source) |
583 |
unset KV_FULL |
584 |
get_version |
585 |
return $? |
586 |
elif [[ -f ${ROOT}/lib/modules/${KV_FULL}/build/Makefile ]]; then |
587 |
KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/build) |
588 |
unset KV_FULL |
589 |
get_version |
590 |
return $? |
591 |
else |
592 |
KV_MAJOR=$(get_version_component_range 1 ${KV_FULL}) |
593 |
KV_MINOR=$(get_version_component_range 2 ${KV_FULL}) |
594 |
KV_PATCH=$(get_version_component_range 3 ${KV_FULL}) |
595 |
KV_PATCH=${KV_PATCH//-*} |
596 |
KV_EXTRA="${KV_FULL#${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}}" |
597 |
fi |
598 |
return 0 |
599 |
} |
600 |
|
601 |
# This next function is named with the eclass prefix to avoid conflicts with |
602 |
# some old versionator-like eclass functions. |
603 |
|
604 |
# @FUNCTION: linux-info_get_any_version |
605 |
# @DESCRIPTION: |
606 |
# This attempts to find the version of the sources, and otherwise falls back to |
607 |
# the version of the running kernel. |
608 |
linux-info_get_any_version() { |
609 |
get_version |
610 |
if [[ $? -ne 0 ]]; then |
611 |
ewarn "Unable to calculate Linux Kernel version for build, attempting to use running version" |
612 |
get_running_version |
613 |
fi |
614 |
} |
615 |
|
616 |
|
617 |
# ebuild check functions |
618 |
# --------------------------------------- |
619 |
|
620 |
# @FUNCTION: check_kernel_built |
621 |
# @DESCRIPTION: |
622 |
# This function verifies that the current kernel sources have been already prepared otherwise it dies. |
623 |
check_kernel_built() { |
624 |
# if we haven't determined the version yet, we need to |
625 |
require_configured_kernel |
626 |
get_version |
627 |
|
628 |
local versionh_path |
629 |
if kernel_is -ge 3 7; then |
630 |
versionh_path="include/generated/uapi/linux/version.h" |
631 |
else |
632 |
versionh_path="include/linux/version.h" |
633 |
fi |
634 |
|
635 |
if [ ! -f "${KV_OUT_DIR}/${versionh_path}" ] |
636 |
then |
637 |
eerror "These sources have not yet been prepared." |
638 |
eerror "We cannot build against an unprepared tree." |
639 |
eerror "To resolve this, please type the following:" |
640 |
eerror |
641 |
eerror "# cd ${KV_DIR}" |
642 |
eerror "# make oldconfig" |
643 |
eerror "# make modules_prepare" |
644 |
eerror |
645 |
eerror "Then please try merging this module again." |
646 |
die "Kernel sources need compiling first" |
647 |
fi |
648 |
} |
649 |
|
650 |
# @FUNCTION: check_modules_supported |
651 |
# @DESCRIPTION: |
652 |
# This function verifies that the current kernel support modules (it checks CONFIG_MODULES=y) otherwise it dies. |
653 |
check_modules_supported() { |
654 |
# if we haven't determined the version yet, we need too. |
655 |
require_configured_kernel |
656 |
get_version |
657 |
|
658 |
if ! linux_chkconfig_builtin "MODULES" |
659 |
then |
660 |
eerror "These sources do not support loading external modules." |
661 |
eerror "to be able to use this module please enable \"Loadable modules support\"" |
662 |
eerror "in your kernel, recompile and then try merging this module again." |
663 |
die "No support for external modules in ${KV_FULL} config" |
664 |
fi |
665 |
} |
666 |
|
667 |
# @FUNCTION: check_extra_config |
668 |
# @DESCRIPTION: |
669 |
# It checks the kernel config options specified by CONFIG_CHECK. It dies only when a required config option (i.e. |
670 |
# the prefix ~ is not used) doesn't satisfy the directive. |
671 |
check_extra_config() { |
672 |
local config negate die error reworkmodulenames |
673 |
local soft_errors_count=0 hard_errors_count=0 config_required=0 |
674 |
# store the value of the QA check, because otherwise we won't catch usages |
675 |
# after if check_extra_config is called AND other direct calls are done |
676 |
# later. |
677 |
local old_LINUX_CONFIG_EXISTS_DONE="${_LINUX_CONFIG_EXISTS_DONE}" |
678 |
|
679 |
# if we haven't determined the version yet, we need to |
680 |
linux-info_get_any_version |
681 |
|
682 |
# Determine if we really need a .config. The only time when we don't need |
683 |
# one is when all of the CONFIG_CHECK options are prefixed with "~". |
684 |
for config in ${CONFIG_CHECK} |
685 |
do |
686 |
if [[ "${config:0:1}" != "~" ]]; then |
687 |
config_required=1 |
688 |
break |
689 |
fi |
690 |
done |
691 |
|
692 |
if [[ ${config_required} == 0 ]]; then |
693 |
# In the case where we don't require a .config, we can now bail out |
694 |
# if the user has no .config as there is nothing to do. Otherwise |
695 |
# code later will cause a failure due to missing .config. |
696 |
if ! linux_config_exists; then |
697 |
ewarn "Unable to check for the following kernel config options due" |
698 |
ewarn "to absence of any configured kernel sources or compiled" |
699 |
ewarn "config:" |
700 |
for config in ${CONFIG_CHECK}; do |
701 |
local_error="ERROR_${config#\~}" |
702 |
msg="${!local_error}" |
703 |
if [[ "x${msg}" == "x" ]]; then |
704 |
local_error="WARNING_${config#\~}" |
705 |
msg="${!local_error}" |
706 |
fi |
707 |
ewarn " - ${config#\~}${msg:+ - }${msg}" |
708 |
done |
709 |
ewarn "You're on your own to make sure they are set if needed." |
710 |
export LINUX_CONFIG_EXISTS_DONE="${old_LINUX_CONFIG_EXISTS_DONE}" |
711 |
return 0 |
712 |
fi |
713 |
else |
714 |
require_configured_kernel |
715 |
fi |
716 |
|
717 |
einfo "Checking for suitable kernel configuration options..." |
718 |
|
719 |
for config in ${CONFIG_CHECK} |
720 |
do |
721 |
# if we specify any fatal, ensure we honor them |
722 |
die=1 |
723 |
error=0 |
724 |
negate=0 |
725 |
reworkmodulenames=0 |
726 |
|
727 |
if [[ ${config:0:1} == "~" ]]; then |
728 |
die=0 |
729 |
config=${config:1} |
730 |
elif [[ ${config:0:1} == "@" ]]; then |
731 |
die=0 |
732 |
reworkmodulenames=1 |
733 |
config=${config:1} |
734 |
fi |
735 |
if [[ ${config:0:1} == "!" ]]; then |
736 |
negate=1 |
737 |
config=${config:1} |
738 |
fi |
739 |
|
740 |
if [[ ${negate} == 1 ]]; then |
741 |
linux_chkconfig_present ${config} && error=2 |
742 |
elif [[ ${reworkmodulenames} == 1 ]]; then |
743 |
local temp_config="${config//*:}" i n |
744 |
config="${config//:*}" |
745 |
if linux_chkconfig_present ${config}; then |
746 |
for i in ${MODULE_NAMES}; do |
747 |
n="${i//${temp_config}}" |
748 |
[[ -z ${n//\(*} ]] && \ |
749 |
MODULE_IGNORE="${MODULE_IGNORE} ${temp_config}" |
750 |
done |
751 |
error=2 |
752 |
fi |
753 |
else |
754 |
linux_chkconfig_present ${config} || error=1 |
755 |
fi |
756 |
|
757 |
if [[ ${error} > 0 ]]; then |
758 |
local report_func="eerror" local_error |
759 |
local_error="ERROR_${config}" |
760 |
local_error="${!local_error}" |
761 |
|
762 |
if [[ -z "${local_error}" ]]; then |
763 |
# using old, deprecated format. |
764 |
local_error="${config}_ERROR" |
765 |
local_error="${!local_error}" |
766 |
fi |
767 |
if [[ ${die} == 0 && -z "${local_error}" ]]; then |
768 |
#soft errors can be warnings |
769 |
local_error="WARNING_${config}" |
770 |
local_error="${!local_error}" |
771 |
if [[ -n "${local_error}" ]] ; then |
772 |
report_func="ewarn" |
773 |
fi |
774 |
fi |
775 |
|
776 |
if [[ -z "${local_error}" ]]; then |
777 |
[[ ${error} == 1 ]] \ |
778 |
&& local_error="is not set when it should be." \ |
779 |
|| local_error="should not be set. But it is." |
780 |
local_error="CONFIG_${config}:\t ${local_error}" |
781 |
fi |
782 |
if [[ ${die} == 0 ]]; then |
783 |
${report_func} " ${local_error}" |
784 |
soft_errors_count=$[soft_errors_count + 1] |
785 |
else |
786 |
${report_func} " ${local_error}" |
787 |
hard_errors_count=$[hard_errors_count + 1] |
788 |
fi |
789 |
fi |
790 |
done |
791 |
|
792 |
if [[ ${hard_errors_count} > 0 ]]; then |
793 |
eerror "Please check to make sure these options are set correctly." |
794 |
eerror "Failure to do so may cause unexpected problems." |
795 |
eerror "Once you have satisfied these options, please try merging" |
796 |
eerror "this package again." |
797 |
export LINUX_CONFIG_EXISTS_DONE="${old_LINUX_CONFIG_EXISTS_DONE}" |
798 |
die "Incorrect kernel configuration options" |
799 |
elif [[ ${soft_errors_count} > 0 ]]; then |
800 |
ewarn "Please check to make sure these options are set correctly." |
801 |
ewarn "Failure to do so may cause unexpected problems." |
802 |
else |
803 |
eend 0 |
804 |
fi |
805 |
export LINUX_CONFIG_EXISTS_DONE="${old_LINUX_CONFIG_EXISTS_DONE}" |
806 |
} |
807 |
|
808 |
check_zlibinflate() { |
809 |
# if we haven't determined the version yet, we need to |
810 |
require_configured_kernel |
811 |
get_version |
812 |
|
813 |
# although I restructured this code - I really really really dont support it! |
814 |
|
815 |
# bug #27882 - zlib routines are only linked into the kernel |
816 |
# if something compiled into the kernel calls them |
817 |
# |
818 |
# plus, for the cloop module, it appears that there's no way |
819 |
# to get cloop.o to include a static zlib if CONFIG_MODVERSIONS |
820 |
# is on |
821 |
|
822 |
local INFLATE |
823 |
local DEFLATE |
824 |
|
825 |
einfo "Determining the usability of ZLIB_INFLATE support in your kernel" |
826 |
|
827 |
ebegin "checking ZLIB_INFLATE" |
828 |
linux_chkconfig_builtin CONFIG_ZLIB_INFLATE |
829 |
eend $? |
830 |
[ "$?" != 0 ] && die |
831 |
|
832 |
ebegin "checking ZLIB_DEFLATE" |
833 |
linux_chkconfig_builtin CONFIG_ZLIB_DEFLATE |
834 |
eend $? |
835 |
[ "$?" != 0 ] && die |
836 |
|
837 |
local LINENO_START |
838 |
local LINENO_END |
839 |
local SYMBOLS |
840 |
local x |
841 |
|
842 |
LINENO_END="$(grep -n 'CONFIG_ZLIB_INFLATE y' ${KV_DIR}/lib/Config.in | cut -d : -f 1)" |
843 |
LINENO_START="$(head -n $LINENO_END ${KV_DIR}/lib/Config.in | grep -n 'if \[' | tail -n 1 | cut -d : -f 1)" |
844 |
(( LINENO_AMOUNT = $LINENO_END - $LINENO_START )) |
845 |
(( LINENO_END = $LINENO_END - 1 )) |
846 |
SYMBOLS="$(head -n $LINENO_END ${KV_DIR}/lib/Config.in | tail -n $LINENO_AMOUNT | sed -e 's/^.*\(CONFIG_[^\" ]*\).*/\1/g;')" |
847 |
|
848 |
# okay, now we have a list of symbols |
849 |
# we need to check each one in turn, to see whether it is set or not |
850 |
for x in $SYMBOLS ; do |
851 |
if [ "${!x}" = "y" ]; then |
852 |
# we have a winner! |
853 |
einfo "${x} ensures zlib is linked into your kernel - excellent" |
854 |
return 0 |
855 |
fi |
856 |
done |
857 |
|
858 |
eerror |
859 |
eerror "This kernel module requires ZLIB library support." |
860 |
eerror "You have enabled zlib support in your kernel, but haven't enabled" |
861 |
eerror "enabled any option that will ensure that zlib is linked into your" |
862 |
eerror "kernel." |
863 |
eerror |
864 |
eerror "Please ensure that you enable at least one of these options:" |
865 |
eerror |
866 |
|
867 |
for x in $SYMBOLS ; do |
868 |
eerror " * $x" |
869 |
done |
870 |
|
871 |
eerror |
872 |
eerror "Please remember to recompile and install your kernel, and reboot" |
873 |
eerror "into your new kernel before attempting to load this kernel module." |
874 |
|
875 |
die "Kernel doesn't include zlib support" |
876 |
} |
877 |
|
878 |
################################ |
879 |
# Default pkg_setup |
880 |
# Also used when inheriting linux-mod to force a get_version call |
881 |
# @FUNCTION: linux-info_pkg_setup |
882 |
# @DESCRIPTION: |
883 |
# Force a get_version() call when inherited from linux-mod.eclass and then check if the kernel is configured |
884 |
# to support the options specified in CONFIG_CHECK (if not null) |
885 |
linux-info_pkg_setup() { |
886 |
linux-info_get_any_version |
887 |
|
888 |
if kernel_is 2 4; then |
889 |
if [ "$( gcc-major-version )" -eq "4" ] ; then |
890 |
echo |
891 |
ewarn "Be warned !! >=sys-devel/gcc-4.0.0 isn't supported with" |
892 |
ewarn "linux-2.4 (or modules building against a linux-2.4 kernel)!" |
893 |
echo |
894 |
ewarn "Either switch to another gcc-version (via gcc-config) or use a" |
895 |
ewarn "newer kernel that supports gcc-4." |
896 |
echo |
897 |
ewarn "Also be aware that bugreports about gcc-4 not working" |
898 |
ewarn "with linux-2.4 based ebuilds will be closed as INVALID!" |
899 |
echo |
900 |
epause 10 |
901 |
fi |
902 |
fi |
903 |
|
904 |
[ -n "${CONFIG_CHECK}" ] && check_extra_config; |
905 |
} |