/[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.71 Revision 1.90
1# Copyright 1999-2006 Gentoo Foundation 1# Copyright 1999-2011 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.71 2009/09/08 12:34:21 robbat2 Exp $ 3# $Header: /var/cvsroot/gentoo-x86/eclass/linux-info.eclass,v 1.90 2011/08/22 04:46:32 vapier Exp $
4#
5# Original author: John Mylchreest <johnm@gentoo.org>
6# Maintainer: kernel-misc@gentoo.org
7#
8# Please direct your bugs to the current eclass maintainer :)
9 4
10# @ECLASS: linux-info.eclass 5# @ECLASS: linux-info.eclass
11# @MAINTAINER: 6# @MAINTAINER:
12# kernel-misc@gentoo.org 7# kernel-misc@gentoo.org
8# @AUTHOR:
9# Original author: John Mylchreest <johnm@gentoo.org>
13# @BLURB: eclass used for accessing kernel related information 10# @BLURB: eclass used for accessing kernel related information
14# @DESCRIPTION: 11# @DESCRIPTION:
15# This eclass is used as a central eclass for accessing kernel 12# This eclass is used as a central eclass for accessing kernel
16# related information for source or binary already installed. 13# related information for source or binary already installed.
17# It is vital for linux-mod.eclass to function correctly, and is split 14# It is vital for linux-mod.eclass to function correctly, and is split
40# You can also check that an option doesn't exist by 37# You can also check that an option doesn't exist by
41# prepending it with an exclamation mark (!). 38# prepending it with an exclamation mark (!).
42# 39#
43# e.g.: CONFIG_CHECK="!MTRR" 40# e.g.: CONFIG_CHECK="!MTRR"
44# 41#
45# To simply warn about a missing option, prepend a '~'. 42# To simply warn about a missing option, prepend a '~'.
46# It may be combined with '!'. 43# It may be combined with '!'.
47# 44#
48# In general, most checks should be non-fatal. The only time fatal checks should 45# In general, most checks should be non-fatal. The only time fatal checks should
49# be used is for building kernel modules or cases that a compile will fail 46# be used is for building kernel modules or cases that a compile will fail
50# without the option. 47# without the option.
99# @ECLASS-VARIABLE: KV_OUT_DIR 96# @ECLASS-VARIABLE: KV_OUT_DIR
100# @DESCRIPTION: 97# @DESCRIPTION:
101# A read-only variable. It's a string containing the kernel object directory, will be KV_DIR unless 98# A read-only variable. It's a string containing the kernel object directory, will be KV_DIR unless
102# KBUILD_OUTPUT is used. This should be used for referencing .config. 99# KBUILD_OUTPUT is used. This should be used for referencing .config.
103 100
104# @ECLASS-VARIABLE: I_KNOW_WHAT_I_AM_DOING
105# @DESCRIPTION:
106# Temporary variable for the migration to making linux-info non-fatal.
107
108# And to ensure all the weirdness with crosscompile 101# And to ensure all the weirdness with crosscompile
109inherit toolchain-funcs versionator 102inherit toolchain-funcs versionator
110 103
111EXPORT_FUNCTIONS pkg_setup 104EXPORT_FUNCTIONS pkg_setup
112 105
113DEPEND="" 106DEPEND=""
114RDEPEND="" 107RDEPEND=""
115
116[ -z "${I_KNOW_WHAT_I_AM_DOING}" ] && \
117DEPEND="kernel_linux? ( virtual/linux-sources )"
118 108
119# Overwritable environment Var's 109# Overwritable environment Var's
120# --------------------------------------- 110# ---------------------------------------
121KERNEL_DIR="${KERNEL_DIR:-${ROOT}usr/src/linux}" 111KERNEL_DIR="${KERNEL_DIR:-${ROOT}usr/src/linux}"
122 112
153 esac 143 esac
154 [ -n "${outputmsg}" ] && ${type} "${outputmsg}" 144 [ -n "${outputmsg}" ] && ${type} "${outputmsg}"
155} 145}
156 146
157qeinfo() { qout einfo "${@}" ; } 147qeinfo() { qout einfo "${@}" ; }
148qewarn() { qout ewarn "${@}" ; }
158qeerror() { qout eerror "${@}" ; } 149qeerror() { qout eerror "${@}" ; }
159 150
160# File Functions 151# File Functions
161# --------------------------------------- 152# ---------------------------------------
162 153
213 eerror "getfilevar_noexec requires 2 variables, with the second a valid file." 204 eerror "getfilevar_noexec requires 2 variables, with the second a valid file."
214 eerror " getfilevar_noexec <VARIABLE> <CONFIGFILE>" 205 eerror " getfilevar_noexec <VARIABLE> <CONFIGFILE>"
215 else 206 else
216 ${mycat} "${2}" | \ 207 ${mycat} "${2}" | \
217 sed -n \ 208 sed -n \
218 -e "/^[[:space:]]*${1}[[:space:]]*=[[:space:]]*\(.*\)\$/{ 209 -e "/^[[:space:]]*${1}[[:space:]]*:\\?=[[:space:]]*\(.*\)\$/{
219 s,^[^=]*[[:space:]]*=[[:space:]]*,,g ; 210 s,^[^=]*[[:space:]]*=[[:space:]]*,,g ;
220 s,[[:space:]]*\$,,g ; 211 s,[[:space:]]*\$,,g ;
221 p 212 p
222 }" 213 }"
223 fi 214 fi
224} 215}
225 216
217# @ECLASS-VARIABLE: _LINUX_CONFIG_EXISTS_DONE
218# @INTERNAL
219# @DESCRIPTION:
220# This is only set if one of the linux_config_*exists functions has been called.
221# We use it for a QA warning that the check for a config has not been performed,
222# as linux_chkconfig* in non-legacy mode WILL return an undefined value if no
223# config is available at all.
224_LINUX_CONFIG_EXISTS_DONE=
225
226linux_config_qa_check() {
227 local f="$1"
228 if [ -z "${_LINUX_CONFIG_EXISTS_DONE}" ]; then
229 ewarn "QA: You called $f before any linux_config_exists!"
230 ewarn "QA: The return value of $f will NOT guaranteed later!"
231 fi
232}
226 233
227# @FUNCTION: linux_config_src_exists 234# @FUNCTION: linux_config_src_exists
228# @RETURN: true or false 235# @RETURN: true or false
229# @DESCRIPTION: 236# @DESCRIPTION:
230# It returns true if .config exists in a build directory otherwise false 237# It returns true if .config exists in a build directory otherwise false
231linux_config_src_exists() { 238linux_config_src_exists() {
239 export _LINUX_CONFIG_EXISTS_DONE=1
232 [ -s "${KV_OUT_DIR}/.config" ] 240 [ -s "${KV_OUT_DIR}/.config" ]
233} 241}
234 242
235# @FUNCTION: linux_config_bin_exists 243# @FUNCTION: linux_config_bin_exists
236# @RETURN: true or false 244# @RETURN: true or false
237# @DESCRIPTION: 245# @DESCRIPTION:
238# It returns true if .config exists in /proc, otherwise false 246# It returns true if .config exists in /proc, otherwise false
239linux_config_bin_exists() { 247linux_config_bin_exists() {
248 export _LINUX_CONFIG_EXISTS_DONE=1
240 [ -s "/proc/config.gz" ] 249 [ -s "/proc/config.gz" ]
241} 250}
242 251
243# @FUNCTION: linux_config_exists 252# @FUNCTION: linux_config_exists
244# @RETURN: true or false 253# @RETURN: true or false
271# @DESCRIPTION: 280# @DESCRIPTION:
272# It checks that CONFIG_<option>=y or CONFIG_<option>=m is present in the current kernel .config 281# It checks that CONFIG_<option>=y or CONFIG_<option>=m is present in the current kernel .config
273# If linux_config_exists returns false, the results of this are UNDEFINED. You 282# If linux_config_exists returns false, the results of this are UNDEFINED. You
274# MUST call linux_config_exists first. 283# MUST call linux_config_exists first.
275linux_chkconfig_present() { 284linux_chkconfig_present() {
285 linux_config_qa_check linux_chkconfig_present
276local RESULT 286 local RESULT
277 [ -z "${I_KNOW_WHAT_I_AM_DOING}" ] && require_configured_kernel
278 local config 287 local config
279 config="${KV_OUT_DIR}/.config" 288 config="${KV_OUT_DIR}/.config"
280 [ ! -f "${config}" ] && config="/proc/config.gz" 289 [ ! -f "${config}" ] && config="/proc/config.gz"
281 RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")" 290 RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")"
282 [ "${RESULT}" = "m" -o "${RESULT}" = "y" ] && return 0 || return 1 291 [ "${RESULT}" = "m" -o "${RESULT}" = "y" ] && return 0 || return 1
288# @DESCRIPTION: 297# @DESCRIPTION:
289# It checks that CONFIG_<option>=m is present in the current kernel .config 298# It checks that CONFIG_<option>=m is present in the current kernel .config
290# If linux_config_exists returns false, the results of this are UNDEFINED. You 299# If linux_config_exists returns false, the results of this are UNDEFINED. You
291# MUST call linux_config_exists first. 300# MUST call linux_config_exists first.
292linux_chkconfig_module() { 301linux_chkconfig_module() {
302 linux_config_qa_check linux_chkconfig_module
293local RESULT 303 local RESULT
294 [ -z "${I_KNOW_WHAT_I_AM_DOING}" ] && require_configured_kernel
295 local config 304 local config
296 config="${KV_OUT_DIR}/.config" 305 config="${KV_OUT_DIR}/.config"
297 [ ! -f "${config}" ] && config="/proc/config.gz" 306 [ ! -f "${config}" ] && config="/proc/config.gz"
298 RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")" 307 RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")"
299 [ "${RESULT}" = "m" ] && return 0 || return 1 308 [ "${RESULT}" = "m" ] && return 0 || return 1
305# @DESCRIPTION: 314# @DESCRIPTION:
306# It checks that CONFIG_<option>=y is present in the current kernel .config 315# It checks that CONFIG_<option>=y is present in the current kernel .config
307# If linux_config_exists returns false, the results of this are UNDEFINED. You 316# If linux_config_exists returns false, the results of this are UNDEFINED. You
308# MUST call linux_config_exists first. 317# MUST call linux_config_exists first.
309linux_chkconfig_builtin() { 318linux_chkconfig_builtin() {
319 linux_config_qa_check linux_chkconfig_builtin
310local RESULT 320 local RESULT
311 [ -z "${I_KNOW_WHAT_I_AM_DOING}" ] && require_configured_kernel
312 local config 321 local config
313 config="${KV_OUT_DIR}/.config" 322 config="${KV_OUT_DIR}/.config"
314 [ ! -f "${config}" ] && config="/proc/config.gz" 323 [ ! -f "${config}" ] && config="/proc/config.gz"
315 RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")" 324 RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")"
316 [ "${RESULT}" = "y" ] && return 0 || return 1 325 [ "${RESULT}" = "y" ] && return 0 || return 1
322# @DESCRIPTION: 331# @DESCRIPTION:
323# It prints the CONFIG_<option> value of the current kernel .config (it requires a configured kernel). 332# It prints the CONFIG_<option> value of the current kernel .config (it requires a configured kernel).
324# If linux_config_exists returns false, the results of this are UNDEFINED. You 333# If linux_config_exists returns false, the results of this are UNDEFINED. You
325# MUST call linux_config_exists first. 334# MUST call linux_config_exists first.
326linux_chkconfig_string() { 335linux_chkconfig_string() {
327 [ -z "${I_KNOW_WHAT_I_AM_DOING}" ] && require_configured_kernel 336 linux_config_qa_check linux_chkconfig_string
328 local config 337 local config
329 config="${KV_OUT_DIR}/.config" 338 config="${KV_OUT_DIR}/.config"
330 [ ! -f "${config}" ] && config="/proc/config.gz" 339 [ ! -f "${config}" ] && config="/proc/config.gz"
331 getfilevar_noexec "CONFIG_${1}" "${config}" 340 getfilevar_noexec "CONFIG_${1}" "${config}"
332} 341}
354 363
355kernel_is() { 364kernel_is() {
356 # if we haven't determined the version yet, we need to. 365 # if we haven't determined the version yet, we need to.
357 linux-info_get_any_version 366 linux-info_get_any_version
358 367
359 local operator test value x=0 y=0 z=0 368 local operator testagainst value x=0 y=0 z=0
360 369
361 case ${1} in 370 case ${1} in
362 -lt|lt) operator="-lt"; shift;; 371 -lt|lt) operator="-lt"; shift;;
363 -gt|gt) operator="-gt"; shift;; 372 -gt|gt) operator="-gt"; shift;;
364 -le|le) operator="-le"; shift;; 373 -le|le) operator="-le"; shift;;
371 for((y=0; y<$((3 - ${#x})); y++)); do value="${value}0"; done 380 for((y=0; y<$((3 - ${#x})); y++)); do value="${value}0"; done
372 value="${value}${x}" 381 value="${value}${x}"
373 z=$((${z} + 1)) 382 z=$((${z} + 1))
374 383
375 case ${z} in 384 case ${z} in
376 1) for((y=0; y<$((3 - ${#KV_MAJOR})); y++)); do test="${test}0"; done; 385 1) for((y=0; y<$((3 - ${#KV_MAJOR})); y++)); do testagainst="${testagainst}0"; done;
377 test="${test}${KV_MAJOR}";; 386 testagainst="${testagainst}${KV_MAJOR}";;
378 2) for((y=0; y<$((3 - ${#KV_MINOR})); y++)); do test="${test}0"; done; 387 2) for((y=0; y<$((3 - ${#KV_MINOR})); y++)); do testagainst="${testagainst}0"; done;
379 test="${test}${KV_MINOR}";; 388 testagainst="${testagainst}${KV_MINOR}";;
380 3) for((y=0; y<$((3 - ${#KV_PATCH})); y++)); do test="${test}0"; done; 389 3) for((y=0; y<$((3 - ${#KV_PATCH})); y++)); do testagainst="${testagainst}0"; done;
381 test="${test}${KV_PATCH}";; 390 testagainst="${testagainst}${KV_PATCH}";;
382 *) die "Error in kernel-2_kernel_is(): Too many parameters.";; 391 *) die "Error in kernel-2_kernel_is(): Too many parameters.";;
383 esac 392 esac
384 done 393 done
385 394
386 [ ${test} ${operator} ${value} ] && return 0 || return 1 395 [ "${testagainst}" ${operator} "${value}" ] && return 0 || return 1
387} 396}
388 397
389get_localversion() { 398get_localversion() {
390 local lv_list i x 399 local lv_list i x
391 400
399 done 408 done
400 x=${x/ /} 409 x=${x/ /}
401 echo ${x} 410 echo ${x}
402} 411}
403 412
413# Check if the Makefile is valid for direct parsing.
414# Check status results:
415# - PASS, use 'getfilevar' to extract values
416# - FAIL, use 'getfilevar_noexec' to extract values
417# The check may fail if:
418# - make is not present
419# - corruption exists in the kernel makefile
420get_makefile_extract_function() {
421 local a='' b='' mkfunc='getfilevar'
422 a="$(getfilevar VERSION ${KERNEL_MAKEFILE})"
423 b="$(getfilevar_noexec VERSION ${KERNEL_MAKEFILE})"
424 [[ "${a}" != "${b}" ]] && mkfunc='getfilevar_noexec'
425 echo "${mkfunc}"
426}
427
404# internal variable, so we know to only print the warning once 428# internal variable, so we know to only print the warning once
405get_version_warning_done= 429get_version_warning_done=
406 430
407# @FUNCTION: get_version 431# @FUNCTION: get_version
408# @DESCRIPTION: 432# @DESCRIPTION:
413# 437#
414# The KV_DIR is set using the KERNEL_DIR env var, the KV_DIR_OUT is set using a valid 438# The KV_DIR is set using the KERNEL_DIR env var, the KV_DIR_OUT is set using a valid
415# KBUILD_OUTPUT (in a decreasing priority list, we look for the env var, makefile var or the 439# KBUILD_OUTPUT (in a decreasing priority list, we look for the env var, makefile var or the
416# symlink /lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}/build). 440# symlink /lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}/build).
417get_version() { 441get_version() {
418 local kbuild_output 442 local kbuild_output mkfunc tmplocal
419 443
420 # no need to execute this twice assuming KV_FULL is populated. 444 # no need to execute this twice assuming KV_FULL is populated.
421 # we can force by unsetting KV_FULL 445 # we can force by unsetting KV_FULL
422 [ -n "${KV_FULL}" ] && return 0 446 [ -n "${KV_FULL}" ] && return 0
423 447
467 # KBUILD_OUTPUT, and we need this for .config and localversions-* 491 # KBUILD_OUTPUT, and we need this for .config and localversions-*
468 # so we better find it eh? 492 # so we better find it eh?
469 # do we pass KBUILD_OUTPUT on the CLI? 493 # do we pass KBUILD_OUTPUT on the CLI?
470 OUTPUT_DIR="${OUTPUT_DIR:-${KBUILD_OUTPUT}}" 494 OUTPUT_DIR="${OUTPUT_DIR:-${KBUILD_OUTPUT}}"
471 495
496 # keep track of it
497 KERNEL_MAKEFILE="${KV_DIR}/Makefile"
498
499 # Decide the function used to extract makefile variables.
500 mkfunc="$(get_makefile_extract_function "${KERNEL_MAKEFILE}")"
501
472 # And if we didn't pass it, we can take a nosey in the Makefile 502 # And if we didn't pass it, we can take a nosey in the Makefile
473 kbuild_output="$(getfilevar_noexec KBUILD_OUTPUT ${KV_DIR}/Makefile)" 503 kbuild_output="$(${mkfunc} KBUILD_OUTPUT ${KERNEL_MAKEFILE})"
474 OUTPUT_DIR="${OUTPUT_DIR:-${kbuild_output}}" 504 OUTPUT_DIR="${OUTPUT_DIR:-${kbuild_output}}"
475 505
476 # And contrary to existing functions I feel we shouldn't trust the 506 # And contrary to existing functions I feel we shouldn't trust the
477 # directory name to find version information as this seems insane. 507 # directory name to find version information as this seems insane.
478 # so we parse ${KV_DIR}/Makefile 508 # so we parse ${KERNEL_MAKEFILE}
479 KV_MAJOR="$(getfilevar_noexec VERSION ${KV_DIR}/Makefile)" 509 KV_MAJOR="$(${mkfunc} VERSION ${KERNEL_MAKEFILE})"
480 KV_MINOR="$(getfilevar_noexec PATCHLEVEL ${KV_DIR}/Makefile)" 510 KV_MINOR="$(${mkfunc} PATCHLEVEL ${KERNEL_MAKEFILE})"
481 KV_PATCH="$(getfilevar_noexec SUBLEVEL ${KV_DIR}/Makefile)" 511 KV_PATCH="$(${mkfunc} SUBLEVEL ${KERNEL_MAKEFILE})"
482 KV_EXTRA="$(getfilevar_noexec EXTRAVERSION ${KV_DIR}/Makefile)" 512 KV_EXTRA="$(${mkfunc} EXTRAVERSION ${KERNEL_MAKEFILE})"
483 513
484 if [ -z "${KV_MAJOR}" -o -z "${KV_MINOR}" -o -z "${KV_PATCH}" ] 514 if [ -z "${KV_MAJOR}" -o -z "${KV_MINOR}" -o -z "${KV_PATCH}" ]
485 then 515 then
486 if [ -z "${get_version_warning_done}" ]; then 516 if [ -z "${get_version_warning_done}" ]; then
487 get_version_warning_done=1 517 get_version_warning_done=1
493 523
494 # and in newer versions we can also pull LOCALVERSION if it is set. 524 # and in newer versions we can also pull LOCALVERSION if it is set.
495 # but before we do this, we need to find if we use a different object directory. 525 # but before we do this, we need to find if we use a different object directory.
496 # This *WILL* break if the user is using localversions, but we assume it was 526 # This *WILL* break if the user is using localversions, but we assume it was
497 # caught before this if they are. 527 # caught before this if they are.
498 [ "${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}" == "$(uname -r)" ] && \
499 OUTPUT_DIR="${OUTPUT_DIR:-/lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}/build}" 528 OUTPUT_DIR="${OUTPUT_DIR:-/lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}/build}"
500 529
501 [ -h "${OUTPUT_DIR}" ] && KV_OUT_DIR="$(readlink -f ${OUTPUT_DIR})" 530 [ -h "${OUTPUT_DIR}" ] && KV_OUT_DIR="$(readlink -f ${OUTPUT_DIR})"
502 [ -d "${OUTPUT_DIR}" ] && KV_OUT_DIR="${OUTPUT_DIR}" 531 [ -d "${OUTPUT_DIR}" ] && KV_OUT_DIR="${OUTPUT_DIR}"
503 if [ -n "${KV_OUT_DIR}" ]; 532 if [ -n "${KV_OUT_DIR}" ];
504 then 533 then
505 qeinfo "Found kernel object directory:" 534 qeinfo "Found kernel object directory:"
506 qeinfo " ${KV_OUT_DIR}" 535 qeinfo " ${KV_OUT_DIR}"
507
508 KV_LOCAL="$(get_localversion ${KV_OUT_DIR})"
509 fi 536 fi
510 # and if we STILL have not got it, then we better just set it to KV_DIR 537 # and if we STILL have not got it, then we better just set it to KV_DIR
511 KV_OUT_DIR="${KV_OUT_DIR:-${KV_DIR}}" 538 KV_OUT_DIR="${KV_OUT_DIR:-${KV_DIR}}"
512 539
513 KV_LOCAL="${KV_LOCAL}$(get_localversion ${KV_DIR})" 540 # Grab the kernel release from the output directory.
514 if linux_config_src_exists; then 541 # TODO: we MUST detect kernel.release being out of date, and 'return 1' from
515 KV_LOCAL="${KV_LOCAL}$(linux_chkconfig_string LOCALVERSION)" 542 # this function.
516 KV_LOCAL="${KV_LOCAL//\"/}" 543 if [ -s "${KV_OUT_DIR}"/include/config/kernel.release ]; then
544 KV_LOCAL=$(<"${KV_OUT_DIR}"/include/config/kernel.release)
545 elif [ -s "${KV_OUT_DIR}"/.kernelrelease ]; then
546 KV_LOCAL=$(<"${KV_OUT_DIR}"/.kernelrelease)
547 else
548 KV_LOCAL=
549 fi
517 550
518 # For things like git that can append extra stuff: 551 # KV_LOCAL currently contains the full release; discard the first bits.
519 [ -e ${KV_DIR}/scripts/setlocalversion ] && 552 tmplocal=${KV_LOCAL#${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}}
520 linux_chkconfig_builtin LOCALVERSION_AUTO && 553
521 KV_LOCAL="${KV_LOCAL}$(sh ${KV_DIR}/scripts/setlocalversion ${KV_DIR})" 554 # If the updated local version was not changed, the tree is not prepared.
555 # Clear out KV_LOCAL in that case.
556 # TODO: this does not detect a change in the localversion part between
557 # kernel.release and the value that would be generated.
558 if [ "$KV_LOCAL" = "$tmplocal" ]; then
559 KV_LOCAL=
560 else
561 KV_LOCAL=$tmplocal
522 fi 562 fi
523 563
524 # And we should set KV_FULL to the full expanded version 564 # And we should set KV_FULL to the full expanded version
525 KV_FULL="${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}${KV_LOCAL}" 565 KV_FULL="${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}${KV_LOCAL}"
526 566
535# It gets the version of the current running kernel and the result is the same as get_version() if the 575# It gets the version of the current running kernel and the result is the same as get_version() if the
536# function can find the sources. 576# function can find the sources.
537get_running_version() { 577get_running_version() {
538 KV_FULL=$(uname -r) 578 KV_FULL=$(uname -r)
539 579
580 if [[ -f ${ROOT}/lib/modules/${KV_FULL}/source/Makefile && -f ${ROOT}/lib/modules/${KV_FULL}/build/Makefile ]]; then
581 KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/source)
582 KBUILD_OUTPUT=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/build)
583 unset KV_FULL
584 get_version
585 return $?
540 if [[ -f ${ROOT}/lib/modules/${KV_FULL}/source/Makefile ]]; then 586 elif [[ -f ${ROOT}/lib/modules/${KV_FULL}/source/Makefile ]]; then
541 KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/source) 587 KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/source)
542 unset KV_FULL 588 unset KV_FULL
543 get_version 589 get_version
544 return $? 590 return $?
545 elif [[ -f ${ROOT}/lib/modules/${KV_FULL}/build/Makefile ]]; then 591 elif [[ -f ${ROOT}/lib/modules/${KV_FULL}/build/Makefile ]]; then
548 get_version 594 get_version
549 return $? 595 return $?
550 else 596 else
551 KV_MAJOR=$(get_version_component_range 1 ${KV_FULL}) 597 KV_MAJOR=$(get_version_component_range 1 ${KV_FULL})
552 KV_MINOR=$(get_version_component_range 2 ${KV_FULL}) 598 KV_MINOR=$(get_version_component_range 2 ${KV_FULL})
553 KV_PATCH=$(get_version_component_range 3- ${KV_FULL}) 599 KV_PATCH=$(get_version_component_range 3 ${KV_FULL})
554 KV_PATCH=${KV_PATCH//-*} 600 KV_PATCH=${KV_PATCH//-*}
555 [[ -n ${KV_FULL#*-} ]] && [[ -n ${KV_FULL//${KV_FULL#*-}} ]] \ 601 KV_EXTRA="${KV_FULL#${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}}"
556 && KV_EXTRA="-${KV_FULL#*-}"
557 fi 602 fi
558 return 0 603 return 0
559} 604}
560 605
561# This next function is named with the eclass prefix to avoid conflicts with 606# This next function is named with the eclass prefix to avoid conflicts with
564# @FUNCTION: linux-info_get_any_version 609# @FUNCTION: linux-info_get_any_version
565# @DESCRIPTION: 610# @DESCRIPTION:
566# This attempts to find the version of the sources, and otherwise falls back to 611# This attempts to find the version of the sources, and otherwise falls back to
567# the version of the running kernel. 612# the version of the running kernel.
568linux-info_get_any_version() { 613linux-info_get_any_version() {
569 get_version 614 get_version
570 if [[ $? -ne 0 ]]; then 615 if [[ $? -ne 0 ]]; then
571 ewarn "Unable to calculate Linux Kernel version for build, attempting to use running version" 616 ewarn "Unable to calculate Linux Kernel version for build, attempting to use running version"
572 get_running_version 617 get_running_version
573 fi 618 fi
574} 619}
575 620
576 621
577# ebuild check functions 622# ebuild check functions
622# It checks the kernel config options specified by CONFIG_CHECK. It dies only when a required config option (i.e. 667# It checks the kernel config options specified by CONFIG_CHECK. It dies only when a required config option (i.e.
623# the prefix ~ is not used) doesn't satisfy the directive. 668# the prefix ~ is not used) doesn't satisfy the directive.
624check_extra_config() { 669check_extra_config() {
625 local config negate die error reworkmodulenames 670 local config negate die error reworkmodulenames
626 local soft_errors_count=0 hard_errors_count=0 config_required=0 671 local soft_errors_count=0 hard_errors_count=0 config_required=0
672 # store the value of the QA check, because otherwise we won't catch usages
673 # after if check_extra_config is called AND other direct calls are done
674 # later.
675 local old_LINUX_CONFIG_EXISTS_DONE="${_LINUX_CONFIG_EXISTS_DONE}"
627 676
628 # if we haven't determined the version yet, we need to 677 # if we haven't determined the version yet, we need to
629 linux-info_get_any_version 678 linux-info_get_any_version
630 679
631 # Determine if we really need a .config. The only time when we don't need 680 # Determine if we really need a .config. The only time when we don't need
645 if ! linux_config_exists; then 694 if ! linux_config_exists; then
646 ewarn "Unable to check for the following kernel config options due" 695 ewarn "Unable to check for the following kernel config options due"
647 ewarn "to absence of any configured kernel sources or compiled" 696 ewarn "to absence of any configured kernel sources or compiled"
648 ewarn "config:" 697 ewarn "config:"
649 for config in ${CONFIG_CHECK}; do 698 for config in ${CONFIG_CHECK}; do
699 local_error="ERROR_${config#\~}"
700 msg="${!local_error}"
701 if [[ "x${msg}" == "x" ]]; then
702 local_error="WARNING_${config#\~}"
703 msg="${!local_error}"
704 fi
650 ewarn " - ${config#\~}" 705 ewarn " - ${config#\~}${msg:+ - }${msg}"
651 done 706 done
652 ewarn "You're on your own to make sure they are set if needed." 707 ewarn "You're on your own to make sure they are set if needed."
708 export LINUX_CONFIG_EXISTS_DONE="${old_LINUX_CONFIG_EXISTS_DONE}"
653 return 0 709 return 0
654 fi 710 fi
655 else 711 else
656 [ -n "${I_KNOW_WHAT_I_AM_DOING}" ] && require_configured_kernel 712 require_configured_kernel
657 fi 713 fi
658 714
659 einfo "Checking for suitable kernel configuration options..." 715 einfo "Checking for suitable kernel configuration options..."
660 716
661 for config in ${CONFIG_CHECK} 717 for config in ${CONFIG_CHECK}
734 if [[ ${hard_errors_count} > 0 ]]; then 790 if [[ ${hard_errors_count} > 0 ]]; then
735 eerror "Please check to make sure these options are set correctly." 791 eerror "Please check to make sure these options are set correctly."
736 eerror "Failure to do so may cause unexpected problems." 792 eerror "Failure to do so may cause unexpected problems."
737 eerror "Once you have satisfied these options, please try merging" 793 eerror "Once you have satisfied these options, please try merging"
738 eerror "this package again." 794 eerror "this package again."
795 export LINUX_CONFIG_EXISTS_DONE="${old_LINUX_CONFIG_EXISTS_DONE}"
739 die "Incorrect kernel configuration options" 796 die "Incorrect kernel configuration options"
740 elif [[ ${soft_errors_count} > 0 ]]; then 797 elif [[ ${soft_errors_count} > 0 ]]; then
741 ewarn "Please check to make sure these options are set correctly." 798 ewarn "Please check to make sure these options are set correctly."
742 ewarn "Failure to do so may cause unexpected problems." 799 ewarn "Failure to do so may cause unexpected problems."
743 else 800 else
744 eend 0 801 eend 0
745 fi 802 fi
803 export LINUX_CONFIG_EXISTS_DONE="${old_LINUX_CONFIG_EXISTS_DONE}"
746} 804}
747 805
748check_zlibinflate() { 806check_zlibinflate() {
749 # if we haven't determined the version yet, we need to 807 # if we haven't determined the version yet, we need to
750 require_configured_kernel 808 require_configured_kernel

Legend:
Removed from v.1.71  
changed lines
  Added in v.1.90

  ViewVC Help
Powered by ViewVC 1.1.20