/[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.78 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.78 2010/01/10 08:47:01 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
233 227
234linux_config_qa_check() { 228linux_config_qa_check() {
235 local f="$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 $f before any linux_config_exists!" 231 ewarn "QA: You called $f before any linux_config_exists!"
238 ewarn "QA: The return value of $f 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:
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 linux_chkconfig_present 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
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 linux_chkconfig_module 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
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 linux_chkconfig_builtin 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
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 linux_chkconfig_string 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
491 OUTPUT_DIR="${OUTPUT_DIR:-${KBUILD_OUTPUT}}" 496 OUTPUT_DIR="${OUTPUT_DIR:-${KBUILD_OUTPUT}}"
492 497
493 # keep track of it 498 # keep track of it
494 KERNEL_MAKEFILE="${KV_DIR}/Makefile" 499 KERNEL_MAKEFILE="${KV_DIR}/Makefile"
495 500
496 # Check if the Makefile is valid for direct parsing. 501 # Decide the function used to extract makefile variables.
497 # Check status results: 502 mkfunc="$(get_makefile_extract_function "${KERNEL_MAKEFILE}")"
498 # - PASS, use 'getfilevar' to extract values
499 # - FAIL, use 'getfilevar_noexec' to extract values
500 # The check may fail if:
501 # - make is not present
502 # - corruption exists in the kernel makefile
503 local a='' b='' mkfunc='getfilevar'
504 a="$(getfilevar VERSION ${KERNEL_MAKEFILE})"
505 b="$(getfilevar_noexec VERSION ${KERNEL_MAKEFILE})"
506 [[ "${a}" != "${b}" ]] && mkfunc='getfilevar_noexec'
507 503
508 # 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
509 kbuild_output="$(${mkfunc} KBUILD_OUTPUT ${KERNEL_MAKEFILE})" 505 kbuild_output="$(${mkfunc} KBUILD_OUTPUT ${KERNEL_MAKEFILE})"
510 OUTPUT_DIR="${OUTPUT_DIR:-${kbuild_output}}" 506 OUTPUT_DIR="${OUTPUT_DIR:-${kbuild_output}}"
511 507
529 525
530 # 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.
531 # 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.
532 # 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
533 # caught before this if they are. 529 # caught before this if they are.
534 [ "${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}" == "$(uname -r)" ] && \
535 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}"
536 531
537 [ -h "${OUTPUT_DIR}" ] && KV_OUT_DIR="$(readlink -f ${OUTPUT_DIR})" 532 [ -h "${OUTPUT_DIR}" ] && KV_OUT_DIR="$(readlink -f ${OUTPUT_DIR})"
538 [ -d "${OUTPUT_DIR}" ] && KV_OUT_DIR="${OUTPUT_DIR}" 533 [ -d "${OUTPUT_DIR}" ] && KV_OUT_DIR="${OUTPUT_DIR}"
539 if [ -n "${KV_OUT_DIR}" ]; 534 if [ -n "${KV_OUT_DIR}" ];
540 then 535 then
541 qeinfo "Found kernel object directory:" 536 qeinfo "Found kernel object directory:"
542 qeinfo " ${KV_OUT_DIR}" 537 qeinfo " ${KV_OUT_DIR}"
543
544 KV_LOCAL="$(get_localversion ${KV_OUT_DIR})"
545 fi 538 fi
546 # 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
547 KV_OUT_DIR="${KV_OUT_DIR:-${KV_DIR}}" 540 KV_OUT_DIR="${KV_OUT_DIR:-${KV_DIR}}"
548 541
549 KV_LOCAL="${KV_LOCAL}$(get_localversion ${KV_DIR})" 542 # Grab the kernel release from the output directory.
550 if linux_config_src_exists; then 543 # TODO: we MUST detect kernel.release being out of date, and 'return 1' from
551 KV_LOCAL="${KV_LOCAL}$(linux_chkconfig_string LOCALVERSION)" 544 # this function.
552 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
553 552
554 # For things like git that can append extra stuff: 553 # KV_LOCAL currently contains the full release; discard the first bits.
555 [ -e ${KV_DIR}/scripts/setlocalversion ] && 554 tmplocal=${KV_LOCAL#${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}}
556 linux_chkconfig_builtin LOCALVERSION_AUTO && 555
557 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
558 fi 564 fi
559 565
560 # And we should set KV_FULL to the full expanded version 566 # And we should set KV_FULL to the full expanded version
561 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}"
562 568
571# 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
572# function can find the sources. 578# function can find the sources.
573get_running_version() { 579get_running_version() {
574 KV_FULL=$(uname -r) 580 KV_FULL=$(uname -r)
575 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 $?
576 if [[ -f ${ROOT}/lib/modules/${KV_FULL}/source/Makefile ]]; then 588 elif [[ -f ${ROOT}/lib/modules/${KV_FULL}/source/Makefile ]]; then
577 KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/source) 589 KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/source)
578 unset KV_FULL 590 unset KV_FULL
579 get_version 591 get_version
580 return $? 592 return $?
581 elif [[ -f ${ROOT}/lib/modules/${KV_FULL}/build/Makefile ]]; then 593 elif [[ -f ${ROOT}/lib/modules/${KV_FULL}/build/Makefile ]]; then
584 get_version 596 get_version
585 return $? 597 return $?
586 else 598 else
587 KV_MAJOR=$(get_version_component_range 1 ${KV_FULL}) 599 KV_MAJOR=$(get_version_component_range 1 ${KV_FULL})
588 KV_MINOR=$(get_version_component_range 2 ${KV_FULL}) 600 KV_MINOR=$(get_version_component_range 2 ${KV_FULL})
589 KV_PATCH=$(get_version_component_range 3- ${KV_FULL}) 601 KV_PATCH=$(get_version_component_range 3 ${KV_FULL})
590 KV_PATCH=${KV_PATCH//-*} 602 KV_PATCH=${KV_PATCH//-*}
591 [[ -n ${KV_FULL#*-} ]] && [[ -n ${KV_FULL//${KV_FULL#*-}} ]] \ 603 KV_EXTRA="${KV_FULL#${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}}"
592 && KV_EXTRA="-${KV_FULL#*-}"
593 fi 604 fi
594 return 0 605 return 0
595} 606}
596 607
597# 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
676 config_required=1 687 config_required=1
677 break 688 break
678 fi 689 fi
679 done 690 done
680 691
681 # TODO: After we enable the new code for /proc/config.gz, we need to
682 # change this back to linux_config_exists.
683 if [[ ${config_required} == 0 ]]; then 692 if [[ ${config_required} == 0 ]]; then
684 # 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
685 # 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
686 # code later will cause a failure due to missing .config. 695 # code later will cause a failure due to missing .config.
687 if ! linux_config_src_exists; then 696 if ! linux_config_exists; then
688 ewarn "Unable to check for the following kernel config options due" 697 ewarn "Unable to check for the following kernel config options due"
689 ewarn "to absence of any configured kernel sources or compiled" 698 ewarn "to absence of any configured kernel sources or compiled"
690 ewarn "config:" 699 ewarn "config:"
691 for config in ${CONFIG_CHECK}; do 700 for config in ${CONFIG_CHECK}; do
692 local_error="ERROR_${config#\~}" 701 local_error="ERROR_${config#\~}"
700 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."
701 export LINUX_CONFIG_EXISTS_DONE="${old_LINUX_CONFIG_EXISTS_DONE}" 710 export LINUX_CONFIG_EXISTS_DONE="${old_LINUX_CONFIG_EXISTS_DONE}"
702 return 0 711 return 0
703 fi 712 fi
704 else 713 else
705 [ -n "${I_KNOW_WHAT_I_AM_DOING}" ] && require_configured_kernel 714 require_configured_kernel
706 fi 715 fi
707 716
708 einfo "Checking for suitable kernel configuration options..." 717 einfo "Checking for suitable kernel configuration options..."
709 718
710 for config in ${CONFIG_CHECK} 719 for config in ${CONFIG_CHECK}

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

  ViewVC Help
Powered by ViewVC 1.1.20