/[gentoo-x86]/eclass/linux-info.eclass
Gentoo

Diff of /eclass/linux-info.eclass

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.94

  ViewVC Help
Powered by ViewVC 1.1.20