/[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.75 Revision 1.89
1# Copyright 1999-2006 Gentoo Foundation 1# Copyright 1999-2006 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.75 2009/12/11 20:54:06 robbat2 Exp $ 3# $Header: /var/cvsroot/gentoo-x86/eclass/linux-info.eclass,v 1.89 2011/08/18 14:58:57 vapier Exp $
4# 4#
5# Original author: John Mylchreest <johnm@gentoo.org> 5# Original author: John Mylchreest <johnm@gentoo.org>
6# Maintainer: kernel-misc@gentoo.org 6# Maintainer: kernel-misc@gentoo.org
7# 7#
8# Please direct your bugs to the current eclass maintainer :) 8# Please direct your bugs to the current eclass maintainer :)
40# You can also check that an option doesn't exist by 40# You can also check that an option doesn't exist by
41# prepending it with an exclamation mark (!). 41# prepending it with an exclamation mark (!).
42# 42#
43# e.g.: CONFIG_CHECK="!MTRR" 43# e.g.: CONFIG_CHECK="!MTRR"
44# 44#
45# To simply warn about a missing option, prepend a '~'. 45# To simply warn about a missing option, prepend a '~'.
46# It may be combined with '!'. 46# It may be combined with '!'.
47# 47#
48# In general, most checks should be non-fatal. The only time fatal checks should 48# 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 49# be used is for building kernel modules or cases that a compile will fail
50# without the option. 50# without the option.
99# @ECLASS-VARIABLE: KV_OUT_DIR 99# @ECLASS-VARIABLE: KV_OUT_DIR
100# @DESCRIPTION: 100# @DESCRIPTION:
101# A read-only variable. It's a string containing the kernel object directory, will be KV_DIR unless 101# 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. 102# KBUILD_OUTPUT is used. This should be used for referencing .config.
103 103
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 104# And to ensure all the weirdness with crosscompile
109inherit toolchain-funcs versionator 105inherit toolchain-funcs versionator
110 106
111EXPORT_FUNCTIONS pkg_setup 107EXPORT_FUNCTIONS pkg_setup
112 108
113DEPEND="" 109DEPEND=""
114RDEPEND="" 110RDEPEND=""
115
116[ -z "${I_KNOW_WHAT_I_AM_DOING}" ] && \
117DEPEND="kernel_linux? ( virtual/linux-sources )"
118 111
119# Overwritable environment Var's 112# Overwritable environment Var's
120# --------------------------------------- 113# ---------------------------------------
121KERNEL_DIR="${KERNEL_DIR:-${ROOT}usr/src/linux}" 114KERNEL_DIR="${KERNEL_DIR:-${ROOT}usr/src/linux}"
122 115
153 esac 146 esac
154 [ -n "${outputmsg}" ] && ${type} "${outputmsg}" 147 [ -n "${outputmsg}" ] && ${type} "${outputmsg}"
155} 148}
156 149
157qeinfo() { qout einfo "${@}" ; } 150qeinfo() { qout einfo "${@}" ; }
151qewarn() { qout ewarn "${@}" ; }
158qeerror() { qout eerror "${@}" ; } 152qeerror() { qout eerror "${@}" ; }
159 153
160# File Functions 154# File Functions
161# --------------------------------------- 155# ---------------------------------------
162 156
213 eerror "getfilevar_noexec requires 2 variables, with the second a valid file." 207 eerror "getfilevar_noexec requires 2 variables, with the second a valid file."
214 eerror " getfilevar_noexec <VARIABLE> <CONFIGFILE>" 208 eerror " getfilevar_noexec <VARIABLE> <CONFIGFILE>"
215 else 209 else
216 ${mycat} "${2}" | \ 210 ${mycat} "${2}" | \
217 sed -n \ 211 sed -n \
218 -e "/^[[:space:]]*${1}[[:space:]]*=[[:space:]]*\(.*\)\$/{ 212 -e "/^[[:space:]]*${1}[[:space:]]*:\\?=[[:space:]]*\(.*\)\$/{
219 s,^[^=]*[[:space:]]*=[[:space:]]*,,g ; 213 s,^[^=]*[[:space:]]*=[[:space:]]*,,g ;
220 s,[[:space:]]*\$,,g ; 214 s,[[:space:]]*\$,,g ;
221 p 215 p
222 }" 216 }"
223 fi 217 fi
230# as linux_chkconfig* in non-legacy mode WILL return an undefined value if no 224# as linux_chkconfig* in non-legacy mode WILL return an undefined value if no
231# config is available at all. 225# config is available at all.
232_LINUX_CONFIG_EXISTS_DONE= 226_LINUX_CONFIG_EXISTS_DONE=
233 227
234linux_config_qa_check() { 228linux_config_qa_check() {
235 local funcname="$1" 229 local f="$1"
236 if [ -z "${_LINUX_CONFIG_EXISTS_DONE}" ]; then 230 if [ -z "${_LINUX_CONFIG_EXISTS_DONE}" ]; then
237 ewarn "QA: You called $1 before any linux_config_exists!" 231 ewarn "QA: You called $f before any linux_config_exists!"
238 ewarn "QA: The return value of $1 will NOT gaurenteed later!" 232 ewarn "QA: The return value of $f will NOT guaranteed later!"
239 fi 233 fi
240} 234}
241 235
242# @FUNCTION: linux_config_src_exists 236# @FUNCTION: linux_config_src_exists
243# @RETURN: true or false 237# @RETURN: true or false
252# @RETURN: true or false 246# @RETURN: true or false
253# @DESCRIPTION: 247# @DESCRIPTION:
254# It returns true if .config exists in /proc, otherwise false 248# It returns true if .config exists in /proc, otherwise false
255linux_config_bin_exists() { 249linux_config_bin_exists() {
256 export _LINUX_CONFIG_EXISTS_DONE=1 250 export _LINUX_CONFIG_EXISTS_DONE=1
257 [ -n "${I_KNOW_WHAT_I_AM_DOING}" -a -s "/proc/config.gz" ] 251 [ -s "/proc/config.gz" ]
258} 252}
259 253
260# @FUNCTION: linux_config_exists 254# @FUNCTION: linux_config_exists
261# @RETURN: true or false 255# @RETURN: true or false
262# @DESCRIPTION: 256# @DESCRIPTION:
288# @DESCRIPTION: 282# @DESCRIPTION:
289# It checks that CONFIG_<option>=y or CONFIG_<option>=m is present in the current kernel .config 283# 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 284# If linux_config_exists returns false, the results of this are UNDEFINED. You
291# MUST call linux_config_exists first. 285# MUST call linux_config_exists first.
292linux_chkconfig_present() { 286linux_chkconfig_present() {
293 linux_config_qa_check 287 linux_config_qa_check linux_chkconfig_present
294 local RESULT 288 local RESULT
295 [ -z "${I_KNOW_WHAT_I_AM_DOING}" ] && require_configured_kernel
296 local config 289 local config
297 config="${KV_OUT_DIR}/.config" 290 config="${KV_OUT_DIR}/.config"
298 [ ! -f "${config}" ] && config="/proc/config.gz" 291 [ ! -f "${config}" ] && config="/proc/config.gz"
299 RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")" 292 RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")"
300 [ "${RESULT}" = "m" -o "${RESULT}" = "y" ] && return 0 || return 1 293 [ "${RESULT}" = "m" -o "${RESULT}" = "y" ] && return 0 || return 1
306# @DESCRIPTION: 299# @DESCRIPTION:
307# It checks that CONFIG_<option>=m is present in the current kernel .config 300# It checks that CONFIG_<option>=m is present in the current kernel .config
308# If linux_config_exists returns false, the results of this are UNDEFINED. You 301# If linux_config_exists returns false, the results of this are UNDEFINED. You
309# MUST call linux_config_exists first. 302# MUST call linux_config_exists first.
310linux_chkconfig_module() { 303linux_chkconfig_module() {
311 linux_config_qa_check 304 linux_config_qa_check linux_chkconfig_module
312 local RESULT 305 local RESULT
313 [ -z "${I_KNOW_WHAT_I_AM_DOING}" ] && require_configured_kernel
314 local config 306 local config
315 config="${KV_OUT_DIR}/.config" 307 config="${KV_OUT_DIR}/.config"
316 [ ! -f "${config}" ] && config="/proc/config.gz" 308 [ ! -f "${config}" ] && config="/proc/config.gz"
317 RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")" 309 RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")"
318 [ "${RESULT}" = "m" ] && return 0 || return 1 310 [ "${RESULT}" = "m" ] && return 0 || return 1
324# @DESCRIPTION: 316# @DESCRIPTION:
325# It checks that CONFIG_<option>=y is present in the current kernel .config 317# It checks that CONFIG_<option>=y is present in the current kernel .config
326# If linux_config_exists returns false, the results of this are UNDEFINED. You 318# If linux_config_exists returns false, the results of this are UNDEFINED. You
327# MUST call linux_config_exists first. 319# MUST call linux_config_exists first.
328linux_chkconfig_builtin() { 320linux_chkconfig_builtin() {
329 linux_config_qa_check 321 linux_config_qa_check linux_chkconfig_builtin
330 local RESULT 322 local RESULT
331 [ -z "${I_KNOW_WHAT_I_AM_DOING}" ] && require_configured_kernel
332 local config 323 local config
333 config="${KV_OUT_DIR}/.config" 324 config="${KV_OUT_DIR}/.config"
334 [ ! -f "${config}" ] && config="/proc/config.gz" 325 [ ! -f "${config}" ] && config="/proc/config.gz"
335 RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")" 326 RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")"
336 [ "${RESULT}" = "y" ] && return 0 || return 1 327 [ "${RESULT}" = "y" ] && return 0 || return 1
342# @DESCRIPTION: 333# @DESCRIPTION:
343# It prints the CONFIG_<option> value of the current kernel .config (it requires a configured kernel). 334# It prints the CONFIG_<option> value of the current kernel .config (it requires a configured kernel).
344# If linux_config_exists returns false, the results of this are UNDEFINED. You 335# If linux_config_exists returns false, the results of this are UNDEFINED. You
345# MUST call linux_config_exists first. 336# MUST call linux_config_exists first.
346linux_chkconfig_string() { 337linux_chkconfig_string() {
347 linux_config_qa_check 338 linux_config_qa_check linux_chkconfig_string
348 [ -z "${I_KNOW_WHAT_I_AM_DOING}" ] && require_configured_kernel
349 local config 339 local config
350 config="${KV_OUT_DIR}/.config" 340 config="${KV_OUT_DIR}/.config"
351 [ ! -f "${config}" ] && config="/proc/config.gz" 341 [ ! -f "${config}" ] && config="/proc/config.gz"
352 getfilevar_noexec "CONFIG_${1}" "${config}" 342 getfilevar_noexec "CONFIG_${1}" "${config}"
353} 343}
375 365
376kernel_is() { 366kernel_is() {
377 # if we haven't determined the version yet, we need to. 367 # if we haven't determined the version yet, we need to.
378 linux-info_get_any_version 368 linux-info_get_any_version
379 369
380 local operator test value x=0 y=0 z=0 370 local operator testagainst value x=0 y=0 z=0
381 371
382 case ${1} in 372 case ${1} in
383 -lt|lt) operator="-lt"; shift;; 373 -lt|lt) operator="-lt"; shift;;
384 -gt|gt) operator="-gt"; shift;; 374 -gt|gt) operator="-gt"; shift;;
385 -le|le) operator="-le"; shift;; 375 -le|le) operator="-le"; shift;;
392 for((y=0; y<$((3 - ${#x})); y++)); do value="${value}0"; done 382 for((y=0; y<$((3 - ${#x})); y++)); do value="${value}0"; done
393 value="${value}${x}" 383 value="${value}${x}"
394 z=$((${z} + 1)) 384 z=$((${z} + 1))
395 385
396 case ${z} in 386 case ${z} in
397 1) for((y=0; y<$((3 - ${#KV_MAJOR})); y++)); do test="${test}0"; done; 387 1) for((y=0; y<$((3 - ${#KV_MAJOR})); y++)); do testagainst="${testagainst}0"; done;
398 test="${test}${KV_MAJOR}";; 388 testagainst="${testagainst}${KV_MAJOR}";;
399 2) for((y=0; y<$((3 - ${#KV_MINOR})); y++)); do test="${test}0"; done; 389 2) for((y=0; y<$((3 - ${#KV_MINOR})); y++)); do testagainst="${testagainst}0"; done;
400 test="${test}${KV_MINOR}";; 390 testagainst="${testagainst}${KV_MINOR}";;
401 3) for((y=0; y<$((3 - ${#KV_PATCH})); y++)); do test="${test}0"; done; 391 3) for((y=0; y<$((3 - ${#KV_PATCH})); y++)); do testagainst="${testagainst}0"; done;
402 test="${test}${KV_PATCH}";; 392 testagainst="${testagainst}${KV_PATCH}";;
403 *) die "Error in kernel-2_kernel_is(): Too many parameters.";; 393 *) die "Error in kernel-2_kernel_is(): Too many parameters.";;
404 esac 394 esac
405 done 395 done
406 396
407 [ ${test} ${operator} ${value} ] && return 0 || return 1 397 [ "${testagainst}" ${operator} "${value}" ] && return 0 || return 1
408} 398}
409 399
410get_localversion() { 400get_localversion() {
411 local lv_list i x 401 local lv_list i x
412 402
420 done 410 done
421 x=${x/ /} 411 x=${x/ /}
422 echo ${x} 412 echo ${x}
423} 413}
424 414
415# Check if the Makefile is valid for direct parsing.
416# Check status results:
417# - PASS, use 'getfilevar' to extract values
418# - FAIL, use 'getfilevar_noexec' to extract values
419# The check may fail if:
420# - make is not present
421# - corruption exists in the kernel makefile
422get_makefile_extract_function() {
423 local a='' b='' mkfunc='getfilevar'
424 a="$(getfilevar VERSION ${KERNEL_MAKEFILE})"
425 b="$(getfilevar_noexec VERSION ${KERNEL_MAKEFILE})"
426 [[ "${a}" != "${b}" ]] && mkfunc='getfilevar_noexec'
427 echo "${mkfunc}"
428}
429
425# internal variable, so we know to only print the warning once 430# internal variable, so we know to only print the warning once
426get_version_warning_done= 431get_version_warning_done=
427 432
428# @FUNCTION: get_version 433# @FUNCTION: get_version
429# @DESCRIPTION: 434# @DESCRIPTION:
434# 439#
435# The KV_DIR is set using the KERNEL_DIR env var, the KV_DIR_OUT is set using a valid 440# The KV_DIR is set using the KERNEL_DIR env var, the KV_DIR_OUT is set using a valid
436# KBUILD_OUTPUT (in a decreasing priority list, we look for the env var, makefile var or the 441# KBUILD_OUTPUT (in a decreasing priority list, we look for the env var, makefile var or the
437# symlink /lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}/build). 442# symlink /lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}/build).
438get_version() { 443get_version() {
439 local kbuild_output 444 local kbuild_output mkfunc tmplocal
440 445
441 # no need to execute this twice assuming KV_FULL is populated. 446 # no need to execute this twice assuming KV_FULL is populated.
442 # we can force by unsetting KV_FULL 447 # we can force by unsetting KV_FULL
443 [ -n "${KV_FULL}" ] && return 0 448 [ -n "${KV_FULL}" ] && return 0
444 449
488 # KBUILD_OUTPUT, and we need this for .config and localversions-* 493 # KBUILD_OUTPUT, and we need this for .config and localversions-*
489 # so we better find it eh? 494 # so we better find it eh?
490 # do we pass KBUILD_OUTPUT on the CLI? 495 # do we pass KBUILD_OUTPUT on the CLI?
491 OUTPUT_DIR="${OUTPUT_DIR:-${KBUILD_OUTPUT}}" 496 OUTPUT_DIR="${OUTPUT_DIR:-${KBUILD_OUTPUT}}"
492 497
498 # keep track of it
499 KERNEL_MAKEFILE="${KV_DIR}/Makefile"
500
501 # Decide the function used to extract makefile variables.
502 mkfunc="$(get_makefile_extract_function "${KERNEL_MAKEFILE}")"
503
493 # And if we didn't pass it, we can take a nosey in the Makefile 504 # And if we didn't pass it, we can take a nosey in the Makefile
494 kbuild_output="$(getfilevar_noexec KBUILD_OUTPUT ${KV_DIR}/Makefile)" 505 kbuild_output="$(${mkfunc} KBUILD_OUTPUT ${KERNEL_MAKEFILE})"
495 OUTPUT_DIR="${OUTPUT_DIR:-${kbuild_output}}" 506 OUTPUT_DIR="${OUTPUT_DIR:-${kbuild_output}}"
496 507
497 # And contrary to existing functions I feel we shouldn't trust the 508 # And contrary to existing functions I feel we shouldn't trust the
498 # directory name to find version information as this seems insane. 509 # directory name to find version information as this seems insane.
499 # so we parse ${KV_DIR}/Makefile 510 # so we parse ${KERNEL_MAKEFILE}
500 KV_MAJOR="$(getfilevar_noexec VERSION ${KV_DIR}/Makefile)" 511 KV_MAJOR="$(${mkfunc} VERSION ${KERNEL_MAKEFILE})"
501 KV_MINOR="$(getfilevar_noexec PATCHLEVEL ${KV_DIR}/Makefile)" 512 KV_MINOR="$(${mkfunc} PATCHLEVEL ${KERNEL_MAKEFILE})"
502 KV_PATCH="$(getfilevar_noexec SUBLEVEL ${KV_DIR}/Makefile)" 513 KV_PATCH="$(${mkfunc} SUBLEVEL ${KERNEL_MAKEFILE})"
503 KV_EXTRA="$(getfilevar_noexec EXTRAVERSION ${KV_DIR}/Makefile)" 514 KV_EXTRA="$(${mkfunc} EXTRAVERSION ${KERNEL_MAKEFILE})"
504 515
505 if [ -z "${KV_MAJOR}" -o -z "${KV_MINOR}" -o -z "${KV_PATCH}" ] 516 if [ -z "${KV_MAJOR}" -o -z "${KV_MINOR}" -o -z "${KV_PATCH}" ]
506 then 517 then
507 if [ -z "${get_version_warning_done}" ]; then 518 if [ -z "${get_version_warning_done}" ]; then
508 get_version_warning_done=1 519 get_version_warning_done=1
514 525
515 # and in newer versions we can also pull LOCALVERSION if it is set. 526 # and in newer versions we can also pull LOCALVERSION if it is set.
516 # but before we do this, we need to find if we use a different object directory. 527 # but before we do this, we need to find if we use a different object directory.
517 # This *WILL* break if the user is using localversions, but we assume it was 528 # This *WILL* break if the user is using localversions, but we assume it was
518 # caught before this if they are. 529 # caught before this if they are.
519 [ "${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}" == "$(uname -r)" ] && \
520 OUTPUT_DIR="${OUTPUT_DIR:-/lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}/build}" 530 OUTPUT_DIR="${OUTPUT_DIR:-/lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}/build}"
521 531
522 [ -h "${OUTPUT_DIR}" ] && KV_OUT_DIR="$(readlink -f ${OUTPUT_DIR})" 532 [ -h "${OUTPUT_DIR}" ] && KV_OUT_DIR="$(readlink -f ${OUTPUT_DIR})"
523 [ -d "${OUTPUT_DIR}" ] && KV_OUT_DIR="${OUTPUT_DIR}" 533 [ -d "${OUTPUT_DIR}" ] && KV_OUT_DIR="${OUTPUT_DIR}"
524 if [ -n "${KV_OUT_DIR}" ]; 534 if [ -n "${KV_OUT_DIR}" ];
525 then 535 then
526 qeinfo "Found kernel object directory:" 536 qeinfo "Found kernel object directory:"
527 qeinfo " ${KV_OUT_DIR}" 537 qeinfo " ${KV_OUT_DIR}"
528
529 KV_LOCAL="$(get_localversion ${KV_OUT_DIR})"
530 fi 538 fi
531 # and if we STILL have not got it, then we better just set it to KV_DIR 539 # and if we STILL have not got it, then we better just set it to KV_DIR
532 KV_OUT_DIR="${KV_OUT_DIR:-${KV_DIR}}" 540 KV_OUT_DIR="${KV_OUT_DIR:-${KV_DIR}}"
533 541
534 KV_LOCAL="${KV_LOCAL}$(get_localversion ${KV_DIR})" 542 # Grab the kernel release from the output directory.
535 if linux_config_src_exists; then 543 # TODO: we MUST detect kernel.release being out of date, and 'return 1' from
536 KV_LOCAL="${KV_LOCAL}$(linux_chkconfig_string LOCALVERSION)" 544 # this function.
537 KV_LOCAL="${KV_LOCAL//\"/}" 545 if [ -s "${KV_OUT_DIR}"/include/config/kernel.release ]; then
546 KV_LOCAL=$(<"${KV_OUT_DIR}"/include/config/kernel.release)
547 elif [ -s "${KV_OUT_DIR}"/.kernelrelease ]; then
548 KV_LOCAL=$(<"${KV_OUT_DIR}"/.kernelrelease)
549 else
550 KV_LOCAL=
551 fi
538 552
539 # For things like git that can append extra stuff: 553 # KV_LOCAL currently contains the full release; discard the first bits.
540 [ -e ${KV_DIR}/scripts/setlocalversion ] && 554 tmplocal=${KV_LOCAL#${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}}
541 linux_chkconfig_builtin LOCALVERSION_AUTO && 555
542 KV_LOCAL="${KV_LOCAL}$(sh ${KV_DIR}/scripts/setlocalversion ${KV_DIR})" 556 # If the updated local version was not changed, the tree is not prepared.
557 # Clear out KV_LOCAL in that case.
558 # TODO: this does not detect a change in the localversion part between
559 # kernel.release and the value that would be generated.
560 if [ "$KV_LOCAL" = "$tmplocal" ]; then
561 KV_LOCAL=
562 else
563 KV_LOCAL=$tmplocal
543 fi 564 fi
544 565
545 # And we should set KV_FULL to the full expanded version 566 # And we should set KV_FULL to the full expanded version
546 KV_FULL="${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}${KV_LOCAL}" 567 KV_FULL="${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}${KV_LOCAL}"
547 568
556# It gets the version of the current running kernel and the result is the same as get_version() if the 577# It gets the version of the current running kernel and the result is the same as get_version() if the
557# function can find the sources. 578# function can find the sources.
558get_running_version() { 579get_running_version() {
559 KV_FULL=$(uname -r) 580 KV_FULL=$(uname -r)
560 581
582 if [[ -f ${ROOT}/lib/modules/${KV_FULL}/source/Makefile && -f ${ROOT}/lib/modules/${KV_FULL}/build/Makefile ]]; then
583 KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/source)
584 KBUILD_OUTPUT=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/build)
585 unset KV_FULL
586 get_version
587 return $?
561 if [[ -f ${ROOT}/lib/modules/${KV_FULL}/source/Makefile ]]; then 588 elif [[ -f ${ROOT}/lib/modules/${KV_FULL}/source/Makefile ]]; then
562 KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/source) 589 KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/source)
563 unset KV_FULL 590 unset KV_FULL
564 get_version 591 get_version
565 return $? 592 return $?
566 elif [[ -f ${ROOT}/lib/modules/${KV_FULL}/build/Makefile ]]; then 593 elif [[ -f ${ROOT}/lib/modules/${KV_FULL}/build/Makefile ]]; then
569 get_version 596 get_version
570 return $? 597 return $?
571 else 598 else
572 KV_MAJOR=$(get_version_component_range 1 ${KV_FULL}) 599 KV_MAJOR=$(get_version_component_range 1 ${KV_FULL})
573 KV_MINOR=$(get_version_component_range 2 ${KV_FULL}) 600 KV_MINOR=$(get_version_component_range 2 ${KV_FULL})
574 KV_PATCH=$(get_version_component_range 3- ${KV_FULL}) 601 KV_PATCH=$(get_version_component_range 3 ${KV_FULL})
575 KV_PATCH=${KV_PATCH//-*} 602 KV_PATCH=${KV_PATCH//-*}
576 [[ -n ${KV_FULL#*-} ]] && [[ -n ${KV_FULL//${KV_FULL#*-}} ]] \ 603 KV_EXTRA="${KV_FULL#${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}}"
577 && KV_EXTRA="-${KV_FULL#*-}"
578 fi 604 fi
579 return 0 605 return 0
580} 606}
581 607
582# This next function is named with the eclass prefix to avoid conflicts with 608# This next function is named with the eclass prefix to avoid conflicts with
661 config_required=1 687 config_required=1
662 break 688 break
663 fi 689 fi
664 done 690 done
665 691
666 # TODO: After we enable the new code for /proc/config.gz, we need to
667 # change this back to linux_config_exists.
668 if [[ ${config_required} == 0 ]]; then 692 if [[ ${config_required} == 0 ]]; then
669 # In the case where we don't require a .config, we can now bail out 693 # In the case where we don't require a .config, we can now bail out
670 # if the user has no .config as there is nothing to do. Otherwise 694 # if the user has no .config as there is nothing to do. Otherwise
671 # code later will cause a failure due to missing .config. 695 # code later will cause a failure due to missing .config.
672 if ! linux_config_src_exists; then 696 if ! linux_config_exists; then
673 ewarn "Unable to check for the following kernel config options due" 697 ewarn "Unable to check for the following kernel config options due"
674 ewarn "to absence of any configured kernel sources or compiled" 698 ewarn "to absence of any configured kernel sources or compiled"
675 ewarn "config:" 699 ewarn "config:"
676 for config in ${CONFIG_CHECK}; do 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
677 ewarn " - ${config#\~}" 707 ewarn " - ${config#\~}${msg:+ - }${msg}"
678 done 708 done
679 ewarn "You're on your own to make sure they are set if needed." 709 ewarn "You're on your own to make sure they are set if needed."
680 export LINUX_CONFIG_EXISTS_DONE="${old_LINUX_CONFIG_EXISTS_DONE}" 710 export LINUX_CONFIG_EXISTS_DONE="${old_LINUX_CONFIG_EXISTS_DONE}"
681 return 0 711 return 0
682 fi 712 fi
683 else 713 else
684 [ -n "${I_KNOW_WHAT_I_AM_DOING}" ] && require_configured_kernel 714 require_configured_kernel
685 fi 715 fi
686 716
687 einfo "Checking for suitable kernel configuration options..." 717 einfo "Checking for suitable kernel configuration options..."
688 718
689 for config in ${CONFIG_CHECK} 719 for config in ${CONFIG_CHECK}

Legend:
Removed from v.1.75  
changed lines
  Added in v.1.89

  ViewVC Help
Powered by ViewVC 1.1.20