--- eclass/linux-info.eclass	2005/07/11 15:08:06	1.29
+++ eclass/linux-info.eclass	2009/09/06 22:54:58	1.62
@@ -1,58 +1,118 @@
-# Copyright 1999-2004 Gentoo Foundation
+# Copyright 1999-2006 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
-# $Header: /var/cvsroot/gentoo-x86/eclass/linux-info.eclass,v 1.29 2005/07/11 15:08:06 swegener Exp $
+# $Header: /var/cvsroot/gentoo-x86/eclass/linux-info.eclass,v 1.62 2009/09/06 22:54:58 robbat2 Exp $
 #
-# Description: This eclass is used as a central eclass for accessing kernel
-#			   related information for sources already installed.
-#			   It is vital for linux-mod to function correctly, and is split
-#			   out so that any ebuild behaviour "templates" are abstracted out
-#			   using additional eclasses.
-#
-# Maintainer: John Mylchreest <johnm@gentoo.org>
-# Copyright 2004 Gentoo Linux
+# Original author: John Mylchreest <johnm@gentoo.org>
+# Maintainer: kernel-misc@gentoo.org
 #
 # Please direct your bugs to the current eclass maintainer :)
 
+# @ECLASS: linux-info.eclass
+# @MAINTAINER:
+# kernel-misc@gentoo.org
+# @BLURB: eclass used for accessing kernel related information
+# @DESCRIPTION:
+# This eclass is used as a central eclass for accessing kernel
+# related information for source or binary already installed.
+# It is vital for linux-mod.eclass to function correctly, and is split
+# out so that any ebuild behaviour "templates" are abstracted out
+# using additional eclasses.
+#
+# "kernel config" in this file means:
+# The .config of the currently installed sources is used as the first
+# preference, with a fall-back to bundled config (/proc/config.gz) if available.
+
 # A Couple of env vars are available to effect usage of this eclass
 # These are as follows:
+
+# @ECLASS-VARIABLE: KERNEL_DIR
+# @DESCRIPTION:
+# A string containing the directory of the target kernel sources. The default value is
+# "/usr/src/linux"
+
+# @ECLASS-VARIABLE: CONFIG_CHECK
+# @DESCRIPTION:
+# A string containing a list of .config options to check for before
+# proceeding with the install.
+#
+#   e.g.: CONFIG_CHECK="MTRR"
+#
+# You can also check that an option doesn't exist by
+# prepending it with an exclamation mark (!).
+#
+#   e.g.: CONFIG_CHECK="!MTRR"
 #
-# Env Var	Option		Description
-# KERNEL_DIR	<string>	The directory containing kernel the target kernel
-#				sources.
-# CONFIG_CHECK	<string>	a list of .config options to check for before
-#				proceeding with the install. ie: CONFIG_CHECK="MTRR"
-#				You can also check that an option doesn't exist by
-#				prepending it with an exclamation mark (!).
-#				ie: CONFIG_CHECK="!MTRR"
-# ERROR_CFG		<string>	The error message to display when the above check
-#				fails. <CFG> should reference the appropriate option
-#				as above. ie: ERROR_MTRR="MTRR exists in the .config
-#				but shouldn't!!"
-# KBUILD_OUTPUT	<string>	This is passed on commandline, or can be set from
-#				the kernel makefile. This contains the directory
-#				which is to be used as the kernel object directory.
+# To simply warn about a missing option, prepend a '~'. 
+# It may be combined with '!'.
+#
+# In general, most checks should be non-fatal. The only time fatal checks should
+# be used is for building kernel modules or cases that a compile will fail
+# without the option.
+#
+# This is to allow usage of binary kernels, and minimal systems without kernel
+# sources.
+
+# @ECLASS-VARIABLE: ERROR_<CFG>
+# @DESCRIPTION:
+# A string containing the error message to display when the check against CONFIG_CHECK
+# fails. <CFG> should reference the appropriate option used in CONFIG_CHECK.
+#
+#   e.g.: ERROR_MTRR="MTRR exists in the .config but shouldn't!!"
+
+# @ECLASS-VARIABLE: KBUILD_OUTPUT
+# @DESCRIPTION:
+# A string passed on commandline, or set from the kernel makefile. It contains the directory
+# which is to be used as the kernel object directory.
 
 # There are also a couple of variables which are set by this, and shouldn't be
 # set by hand. These are as follows:
-#
-# Env Var		Option		Description
-# KV_FULL		<string>	The full kernel version. ie: 2.6.9-gentoo-johnm-r1
-# KV_MAJOR		<integer>	The kernel major version. ie: 2
-# KV_MINOR		<integer>	The kernel minor version. ie: 6
-# KV_PATCH		<integer>	The kernel patch version. ie: 9
-# KV_EXTRA		<string>	The kernel EXTRAVERSION. ie: -gentoo
-# KV_LOCAL		<string>	The kernel LOCALVERSION concatenation. ie: -johnm
-# KV_DIR		<string>	The kernel source directory, will be null if
-#					KERNEL_DIR is invalid.
-# KV_OUT_DIR		<string>	The kernel object directory. will be KV_DIR unless
-#					koutput is used. This should be used for referencing
-#					.config.
+
+# @ECLASS-VARIABLE: KV_FULL
+# @DESCRIPTION:
+# A read-only variable. It's a string containing the full kernel version. ie: 2.6.9-gentoo-johnm-r1
+
+# @ECLASS-VARIABLE: KV_MAJOR
+# @DESCRIPTION:
+# A read-only variable. It's an integer containing the kernel major version. ie: 2
+
+# @ECLASS-VARIABLE: KV_MINOR
+# @DESCRIPTION:
+# A read-only variable. It's an integer containing the kernel minor version. ie: 6
+
+# @ECLASS-VARIABLE: KV_PATCH
+# @DESCRIPTION:
+# A read-only variable. It's an integer containing the kernel patch version. ie: 9
+
+# @ECLASS-VARIABLE: KV_EXTRA
+# @DESCRIPTION:
+# A read-only variable. It's a string containing the kernel EXTRAVERSION. ie: -gentoo
+
+# @ECLASS-VARIABLE: KV_LOCAL
+# @DESCRIPTION:
+# A read-only variable. It's a string containing the kernel LOCALVERSION concatenation. ie: -johnm
+
+# @ECLASS-VARIABLE: KV_DIR
+# @DESCRIPTION:
+# A read-only variable. It's a string containing the kernel source directory, will be null if
+# KERNEL_DIR is invalid.
+
+# @ECLASS-VARIABLE: KV_OUT_DIR
+# @DESCRIPTION:
+# A read-only variable. It's a string containing the kernel object directory, will be KV_DIR unless
+# KBUILD_OUTPUT is used. This should be used for referencing .config.
+
+# @ECLASS-VARIABLE: I_KNOW_WHAT_I_AM_DOING
+# @DESCRIPTION:
+# Temporary variable for the migration to making linux-info non-fatal.
 
 # And to ensure all the weirdness with crosscompile
 inherit toolchain-funcs versionator
 
 EXPORT_FUNCTIONS pkg_setup
 
+DEPEND="kernel_linux? ( virtual/linux-sources )"
+RDEPEND=""
+
 # Overwritable environment Var's
 # ---------------------------------------
 KERNEL_DIR="${KERNEL_DIR:-${ROOT}usr/src/linux}"
@@ -65,10 +125,14 @@
 	ppc64)	BUILD_FIXES="${BUILD_FIXES} TOUT=${T}/.tmp_gas_check";;
 esac
 
-# These are legacy wrappers for toolchain-funcs.
-# I dont like them here, but oh well.
-set_arch_to_kernel() { export ARCH="$(tc-arch-kernel)"; }
-set_arch_to_portage() { export ARCH="$(tc-arch)"; }
+# @FUNCTION: set_arch_to_kernel
+# @DESCRIPTION:
+# Set the env ARCH to match what the kernel expects.
+set_arch_to_kernel() { export ARCH=$(tc-arch-kernel); }
+# @FUNCTION: set_arch_to_portage
+# @DESCRIPTION:
+# Set the env ARCH to match what portage expects.
+set_arch_to_portage() { export ARCH=$(tc-arch); }
 
 # qeinfo "Message"
 # -------------------
@@ -93,11 +157,15 @@
 # File Functions
 # ---------------------------------------
 
-# getfilevar accepts 2 vars as follows:
-# getfilevar <VARIABLE> <CONFIGFILE>
-
+# @FUNCTION: getfilevar
+# @USAGE: variable configfile
+# @RETURN: the value of the variable
+# @DESCRIPTION:
+# It detects the value of the variable defined in the file configfile. This is
+# done by including the configfile, and printing the variable with Make.
+# It WILL break if your makefile has missing dependencies!
 getfilevar() {
-local	ERROR workingdir basefname basedname myARCH="${ARCH}"
+local	ERROR basefname basedname myARCH="${ARCH}"
 	ERROR=0
 
 	[ -z "${1}" ] && ERROR=1
@@ -109,59 +177,181 @@
 		eerror "getfilevar requires 2 variables, with the second a valid file."
 		eerror "   getfilevar <VARIABLE> <CONFIGFILE>"
 	else
-		workingdir=${PWD}
-		basefname=$(basename ${2})
-		basedname=$(dirname ${2})
+		basefname="$(basename ${2})"
+		basedname="$(dirname ${2})"
 		unset ARCH
 
-		cd ${basedname}
-		echo -e "include ${basefname}\ne:\n\t@echo \$(${1})" | \
-			make ${BUILD_FIXES} -s -f - e 2>/dev/null
-		cd ${workingdir}
+		echo -e "e:\\n\\t@echo \$(${1})\\ninclude ${basefname}" | \
+			make -C "${basedname}" M="${S}" ${BUILD_FIXES} -s -f - 2>/dev/null
 
 		ARCH=${myARCH}
 	fi
 }
 
+# @FUNCTION: getfilevar_noexec
+# @USAGE: variable configfile
+# @RETURN: the value of the variable
+# @DESCRIPTION:
+# It detects the value of the variable defined in the file configfile.
+# This is done with sed matching an expression only. If the variable is defined,
+# you will run into problems. See getfilevar for those cases.
+getfilevar_noexec() {
+	local	ERROR basefname basedname mycat myARCH="${ARCH}"
+	ERROR=0
+	mycat='cat'
+
+	[ -z "${1}" ] && ERROR=1
+	[ ! -f "${2}" ] && ERROR=1
+	[ "${2#.gz}" != "${2}" ] && mycat='zcat'
+
+	if [ "${ERROR}" = 1 ]
+	then
+		echo -e "\n"
+		eerror "getfilevar_noexec requires 2 variables, with the second a valid file."
+		eerror "   getfilevar_noexec <VARIABLE> <CONFIGFILE>"
+	else
+		${mycat} "${2}" | \
+		sed -n \
+		-e "/^[[:space:]]*${1}[[:space:]]*=[[:space:]]*\(.*\)\$/{ 
+			s,^[^=]*[[:space:]]*=[[:space:]]*,,g ;
+			s,[[:space:]]*\$,,g ;
+			p
+		}"
+	fi
+}
+
+
+# @FUNCTION: linux_config_src_exists
+# @RETURN: true or false
+# @DESCRIPTION:
+# It returns true if .config exists in a build directory otherwise false
+linux_config_src_exists() {
+	[ -s "${KV_OUT_DIR}/.config" ]
+}
+
+# @FUNCTION: linux_config_bin_exists
+# @RETURN: true or false
+# @DESCRIPTION:
+# It returns true if .config exists in /proc, otherwise false
+linux_config_bin_exists() {
+	[ -s "/proc/config.gz" ]
+}
+
+# @FUNCTION: linux_config_exists
+# @RETURN: true or false
+# @DESCRIPTION:
+# It returns true if .config exists otherwise false
+#
+# This function MUST be checked before using any of the linux_chkconfig_*
+# functions.
+linux_config_exists() {
+	linux_config_src_exists || linux_config_bin_exists
+}
+
+# @FUNCTION: require_configured_kernel
+# @DESCRIPTION:
+# This function verifies that the current kernel is configured (it checks against the existence of .config)
+# otherwise it dies.
+require_configured_kernel() {
+	if ! linux_config_src_exists; then
+		qeerror "Could not find a usable .config in the kernel source directory."
+		qeerror "Please ensure that ${KERNEL_DIR} points to a configured set of Linux sources."
+		qeerror "If you are using KBUILD_OUTPUT, please set the environment var so that"
+		qeerror "it points to the necessary object directory so that it might find .config."
+		die "Kernel not configured; no .config found in ${KV_OUT_DIR}"
+	fi
+}
+
+# @FUNCTION: linux_chkconfig_present
+# @USAGE: option
+# @RETURN: true or false
+# @DESCRIPTION:
+# It checks that CONFIG_<option>=y or CONFIG_<option>=m is present in the current kernel .config
+# If linux_config_exists returns false, the results of this are UNDEFINED. You
+# MUST call linux_config_exists first.
 linux_chkconfig_present() {
 local	RESULT
-	RESULT="$(getfilevar CONFIG_${1} ${KV_OUT_DIR}/.config)"
+	[ -z "${I_KNOW_WHAT_I_AM_DOING}" ] && require_configured_kernel
+	local config
+	config="${KV_OUT_DIR}/.config"
+	[ ! -f "${config}" ] && config="/proc/config.gz"
+	RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")"
 	[ "${RESULT}" = "m" -o "${RESULT}" = "y" ] && return 0 || return 1
 }
 
+# @FUNCTION: linux_chkconfig_module
+# @USAGE: option
+# @RETURN: true or false
+# @DESCRIPTION:
+# It checks that CONFIG_<option>=m is present in the current kernel .config
+# If linux_config_exists returns false, the results of this are UNDEFINED. You
+# MUST call linux_config_exists first.
 linux_chkconfig_module() {
 local	RESULT
-	RESULT="$(getfilevar CONFIG_${1} ${KV_OUT_DIR}/.config)"
+	[ -z "${I_KNOW_WHAT_I_AM_DOING}" ] && require_configured_kernel
+	local config
+	config="${KV_OUT_DIR}/.config"
+	[ ! -f "${config}" ] && config="/proc/config.gz"
+	RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")"
 	[ "${RESULT}" = "m" ] && return 0 || return 1
 }
 
+# @FUNCTION: linux_chkconfig_builtin
+# @USAGE: option
+# @RETURN: true or false
+# @DESCRIPTION:
+# It checks that CONFIG_<option>=y is present in the current kernel .config
+# If linux_config_exists returns false, the results of this are UNDEFINED. You
+# MUST call linux_config_exists first.
 linux_chkconfig_builtin() {
 local	RESULT
-	RESULT="$(getfilevar CONFIG_${1} ${KV_OUT_DIR}/.config)"
+	[ -z "${I_KNOW_WHAT_I_AM_DOING}" ] && require_configured_kernel
+	local config
+	config="${KV_OUT_DIR}/.config"
+	[ ! -f "${config}" ] && config="/proc/config.gz"
+	RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")"
 	[ "${RESULT}" = "y" ] && return 0 || return 1
 }
 
+# @FUNCTION: linux_chkconfig_string
+# @USAGE: option
+# @RETURN: CONFIG_<option>
+# @DESCRIPTION:
+# It prints the CONFIG_<option> value of the current kernel .config (it requires a configured kernel).
+# If linux_config_exists returns false, the results of this are UNDEFINED. You
+# MUST call linux_config_exists first.
 linux_chkconfig_string() {
-	getfilevar "CONFIG_${1}" "${KV_OUT_DIR}/.config"
+	[ -z "${I_KNOW_WHAT_I_AM_DOING}" ] && require_configured_kernel
+	local config
+	config="${KV_OUT_DIR}/.config"
+	[ ! -f "${config}" ] && config="/proc/config.gz"
+	getfilevar_noexec "CONFIG_${1}" "${config}"
 }
 
 # Versioning Functions
 # ---------------------------------------
 
-# kernel_is returns true when the version is the same as the passed version
+# @FUNCTION: kernel_is
+# @USAGE: [-lt -gt -le -ge -eq] major_number [minor_number patch_number]
+# @RETURN: true or false
+# @DESCRIPTION:
+# It returns true when the current kernel version satisfies the comparison against the passed version.
+# -eq is the default comparison.
 #
+# @CODE
 # For Example where KV = 2.6.9
-# kernel_is 2 4 	returns false
-# kernel_is 2		returns true
-# kernel_is 2 6		returns true
-# kernel_is 2 6 8	returns false
-# kernel_is 2 6 9	returns true
-#
+# kernel_is 2 4   returns false
+# kernel_is 2     returns true
+# kernel_is 2 6   returns true
+# kernel_is 2 6 8 returns false
+# kernel_is 2 6 9 returns true
+# @CODE
+
 # got the jist yet?
 
 kernel_is() {
-	# if we haven't determined the version yet, we need too.
-	get_version;
+	# if we haven't determined the version yet, we need to.
+	get_version
 	local operator test value x=0 y=0 z=0
 
 	case ${1} in
@@ -188,10 +378,35 @@
 		  *) die "Error in kernel-2_kernel_is(): Too many parameters.";;
 		esac
 	done
-
+	
 	[ ${test} ${operator} ${value} ] && return 0 || return 1
 }
 
+get_localversion() {
+	local lv_list i x
+
+	# ignore files with ~ in it.
+	for i in $(ls ${1}/localversion* 2>/dev/null); do
+		[[ -n ${i//*~*} ]] && lv_list="${lv_list} ${i}"
+	done
+
+	for i in ${lv_list}; do
+		x="${x}$(<${i})"
+	done
+	x=${x/ /}
+	echo ${x}
+}
+
+# @FUNCTION: get_version
+# @DESCRIPTION:
+# It gets the version of the kernel inside KERNEL_DIR and populates the KV_FULL variable
+# (if KV_FULL is already set it does nothing).
+#
+# The kernel version variables (KV_MAJOR, KV_MINOR, KV_PATCH, KV_EXTRA and KV_LOCAL) are also set.
+#
+# The KV_DIR is set using the KERNEL_DIR env var, the KV_DIR_OUT is set using a valid
+# KBUILD_OUTPUT (in a decreasing priority list, we look for the env var, makefile var or the
+# symlink /lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}/build).
 get_version() {
 	local kbuild_output
 
@@ -239,16 +454,16 @@
 	OUTPUT_DIR="${OUTPUT_DIR:-${KBUILD_OUTPUT}}"
 
 	# And if we didn't pass it, we can take a nosey in the Makefile
-	kbuild_output="$(getfilevar KBUILD_OUTPUT ${KV_DIR}/Makefile)"
+	kbuild_output="$(getfilevar_noexec KBUILD_OUTPUT ${KV_DIR}/Makefile)"
 	OUTPUT_DIR="${OUTPUT_DIR:-${kbuild_output}}"
 
 	# And contrary to existing functions I feel we shouldn't trust the
 	# directory name to find version information as this seems insane.
 	# so we parse ${KV_DIR}/Makefile
-	KV_MAJOR="$(getfilevar VERSION ${KV_DIR}/Makefile)"
-	KV_MINOR="$(getfilevar PATCHLEVEL ${KV_DIR}/Makefile)"
-	KV_PATCH="$(getfilevar SUBLEVEL ${KV_DIR}/Makefile)"
-	KV_EXTRA="$(getfilevar EXTRAVERSION ${KV_DIR}/Makefile)"
+	KV_MAJOR="$(getfilevar_noexec VERSION ${KV_DIR}/Makefile)"
+	KV_MINOR="$(getfilevar_noexec PATCHLEVEL ${KV_DIR}/Makefile)"
+	KV_PATCH="$(getfilevar_noexec SUBLEVEL ${KV_DIR}/Makefile)"
+	KV_EXTRA="$(getfilevar_noexec EXTRAVERSION ${KV_DIR}/Makefile)"
 
 	if [ -z "${KV_MAJOR}" -o -z "${KV_MINOR}" -o -z "${KV_PATCH}" ]
 	then
@@ -261,8 +476,8 @@
 	# but before we do this, we need to find if we use a different object directory.
 	# This *WILL* break if the user is using localversions, but we assume it was
 	# caught before this if they are.
-	[ "${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}.${KV_EXTRA}" == "$(uname -r)" ] && \
-		OUTPUT_DIR="${OUTPUT_DIR:-/lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}.${KV_EXTRA}/build}"
+	[ "${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}" == "$(uname -r)" ] && \
+		OUTPUT_DIR="${OUTPUT_DIR:-/lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}/build}"
 
 	[ -h "${OUTPUT_DIR}" ] && KV_OUT_DIR="$(readlink -f ${OUTPUT_DIR})"
 	[ -d "${OUTPUT_DIR}" ] && KV_OUT_DIR="${OUTPUT_DIR}"
@@ -271,14 +486,21 @@
 		qeinfo "Found kernel object directory:"
 		qeinfo "    ${KV_OUT_DIR}"
 
-		KV_LOCAL="$(cat ${KV_OUT_DIR}/localversion* 2>/dev/null)"
+		KV_LOCAL="$(get_localversion ${KV_OUT_DIR})"
 	fi
-	# and if we STILL haven't got it, then we better just set it to KV_DIR
+	# and if we STILL have not got it, then we better just set it to KV_DIR
 	KV_OUT_DIR="${KV_OUT_DIR:-${KV_DIR}}"
 
-	KV_LOCAL="${KV_LOCAL}$(cat ${KV_DIR}/localversion* 2>/dev/null)"
-	KV_LOCAL="${KV_LOCAL}$(linux_chkconfig_string LOCALVERSION)"
-	KV_LOCAL="${KV_LOCAL//\"/}"
+	KV_LOCAL="${KV_LOCAL}$(get_localversion ${KV_DIR})"
+	if linux_config_exists; then
+		KV_LOCAL="${KV_LOCAL}$(linux_chkconfig_string LOCALVERSION)"
+		KV_LOCAL="${KV_LOCAL//\"/}"
+
+		# For things like git that can append extra stuff:
+		[ -e ${KV_DIR}/scripts/setlocalversion ] &&
+			linux_chkconfig_builtin LOCALVERSION_AUTO &&
+			KV_LOCAL="${KV_LOCAL}$(sh ${KV_DIR}/scripts/setlocalversion ${KV_DIR})"
+	fi
 
 	# And we should set KV_FULL to the full expanded version
 	KV_FULL="${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}${KV_LOCAL}"
@@ -286,18 +508,13 @@
 	qeinfo "Found sources for kernel version:"
 	qeinfo "    ${KV_FULL}"
 
-	if [ ! -s "${KV_OUT_DIR}/.config" ]
-	then
-		qeerror "Could not find a usable .config in the kernel source directory."
-		qeerror "Please ensure that ${KERNEL_DIR} points to a configured set of Linux sources."
-		qeerror "If you are using KBUILD_OUTPUT, please set the environment var so that"
-		qeerror "it points to the necessary object directory so that it might find .config."
-		return 1
-	fi
-
 	return 0
 }
 
+# @FUNCTION: get_running_version
+# @DESCRIPTION:
+# It gets the version of the current running kernel and the result is the same as get_version() if the
+# function can find the sources.
 get_running_version() {
 	KV_FULL=$(uname -r)
 
@@ -326,9 +543,13 @@
 # ebuild check functions
 # ---------------------------------------
 
+# @FUNCTION: check_kernel_built
+# @DESCRIPTION:
+# This function verifies that the current kernel sources have been already prepared otherwise it dies.
 check_kernel_built() {
-	# if we haven't determined the version yet, we need too.
-	get_version;
+	# if we haven't determined the version yet, we need to
+	require_configured_kernel
+	get_version
 
 	if [ ! -f "${KV_OUT_DIR}/include/linux/version.h" ]
 	then
@@ -345,9 +566,13 @@
 	fi
 }
 
+# @FUNCTION: check_modules_supported
+# @DESCRIPTION:
+# This function verifies that the current kernel support modules (it checks CONFIG_MODULES=y) otherwise it dies.
 check_modules_supported() {
 	# if we haven't determined the version yet, we need too.
-	get_version;
+	require_configured_kernel
+	get_version
 
 	if ! linux_chkconfig_builtin "MODULES"
 	then
@@ -358,80 +583,137 @@
 	fi
 }
 
+# @FUNCTION: check_extra_config
+# @DESCRIPTION:
+# It checks the kernel config options specified by CONFIG_CHECK. It dies only when a required config option (i.e.
+# the prefix ~ is not used) doesn't satisfy the directive.
 check_extra_config() {
-	local	config negate error local_error i n temp_config
+	local	config negate die error reworkmodulenames
+	local	soft_errors_count=0 hard_errors_count=0 config_required=0
 
-	# if we haven't determined the version yet, we need too.
-	get_version;
+	# if we haven't determined the version yet, we need to
+	get_version
 
-	einfo "Checking for suitable kernel configuration options"
+	# Determine if we really need a .config. The only time when we don't need
+	# one is when all of the CONFIG_CHECK options are prefixed with "~".
 	for config in ${CONFIG_CHECK}
 	do
-		negate="${config:0:1}"
-		if [ "${negate}" == "!" ];
-		then
-			config="${config:1}"
-			if linux_chkconfig_present ${config}
-			then
-				local_error="${config}_ERROR"
-				local_error="${!local_error}"
-				[ -n "${local_error}" ] && eerror "  ${local_error}" || \
-					eerror "  CONFIG_${config}:\tshould not be set in the kernel configuration, but it is."
-				error=1
-			fi
-		elif [ "${negate}" == "@" ];
-		then
-			# we never call this unless we are using MODULE_NAMES
+		if [[ "${config:0:1}" != "~" ]]; then
+			config_required=1
+			break
+		fi
+	done
 
-			config="${config:1}"
-			temp_config="${config//*:}"
-			config="${config//:*}"
-			if linux_chkconfig_present ${config}
-			then
-				local_error="${config}_ERROR"
-				local_error="${!local_error}"
-				[ -n "${local_error}" ] && eerror "  ${local_error}" || \
-					eerror "  CONFIG_${config}:\tshould not be set in the kernel configuration, but it is."
+	if [[ ${config_required} == 0 ]]; then
+		# In the case where we don't require a .config, we can now bail out
+		# if the user has no .config as there is nothing to do. Otherwise
+		# code later will cause a failure due to missing .config.
+		if ! linux_config_exists; then
+			ewarn "Unable to check for the following kernel config options due"
+			ewarn "to absence of any configured kernel sources:"
+			for config in ${CONFIG_CHECK}; do
+				ewarn " - ${config#\~}"
+			done
+			ewarn "You're on your own to make sure they are set if needed."
+			return 0
+		fi
+	else
+		require_configured_kernel
+	fi
+
+	einfo "Checking for suitable kernel configuration options..."
 
-				for i in ${MODULE_NAMES}
-				do
+	for config in ${CONFIG_CHECK}
+	do
+		# if we specify any fatal, ensure we honor them
+		die=1
+		error=0
+		negate=0
+		reworkmodulenames=0
+
+		if [[ ${config:0:1} == "~" ]]; then
+			die=0
+			config=${config:1}
+		elif [[ ${config:0:1} == "@" ]]; then
+			die=0
+			reworkmodulenames=1
+			config=${config:1}
+		fi
+		if [[ ${config:0:1} == "!" ]]; then
+			negate=1
+			config=${config:1}
+		fi
+
+		if [[ ${negate} == 1 ]]; then
+			linux_chkconfig_present ${config} && error=2
+		elif [[ ${reworkmodulenames} == 1 ]]; then
+			local temp_config="${config//*:}" i n
+			config="${config//:*}"
+			if linux_chkconfig_present ${config}; then
+				for i in ${MODULE_NAMES}; do
 					n="${i//${temp_config}}"
-					[ -z "${n//(*}" ] && MODULE_IGNORE="${MODULE_IGNORE} ${temp_config}"
+					[[ -z ${n//\(*} ]] && \
+						MODULE_IGNORE="${MODULE_IGNORE} ${temp_config}"
 				done
-				error=0
+				error=2
 			fi
 		else
-			if ! linux_chkconfig_present ${config}
-			then
-				# Support the new syntax first.
-				local_error="ERROR_${config}"
-				local_error="${!local_error}"
+			linux_chkconfig_present ${config} || error=1
+		fi
+
+		if [[ ${error} > 0 ]]; then
+			local report_func="eerror" local_error
+			local_error="ERROR_${config}"
+			local_error="${!local_error}"
 
-				# then fall back on the older syntax.
-				if [[ -z ${local_error} ]] ; then
-					local_error="${config}_ERROR"
-					local_error="${!local_error}"
+			if [[ -z "${local_error}" ]]; then
+				# using old, deprecated format.
+				local_error="${config}_ERROR"
+				local_error="${!local_error}"
+			fi
+			if [[ ${die} == 0 && -z "${local_error}" ]]; then
+				#soft errors can be warnings
+				local_error="WARNING_${config}"
+				local_error="${!local_error}"
+				if [[ -n "${local_error}" ]] ; then
+					report_func="ewarn"
 				fi
+			fi
 
-				[[ -n ${local_error} ]] && eerror "  ${local_error}" || \
-					eerror "  CONFIG_${config}:\tshould be set in the kernel configuration, but isn't"
-				error=1
+			if [[ -z "${local_error}" ]]; then
+				[[ ${error} == 1 ]] \
+					&& local_error="is not set when it should be." \
+					|| local_error="should not be set. But it is."
+				local_error="CONFIG_${config}:\t ${local_error}"
+			fi
+			if [[ ${die} == 0 ]]; then
+				${report_func} "  ${local_error}"
+				soft_errors_count=$[soft_errors_count + 1]
+			else
+				${report_func} "  ${local_error}"
+				hard_errors_count=$[hard_errors_count + 1]
 			fi
 		fi
 	done
 
-	if [ "${error}" == 1 ] ;
-	then
+	if [[ ${hard_errors_count} > 0 ]]; then
 		eerror "Please check to make sure these options are set correctly."
+		eerror "Failure to do so may cause unexpected problems."
 		eerror "Once you have satisfied these options, please try merging"
 		eerror "this package again."
 		die "Incorrect kernel configuration options"
+	elif [[ ${soft_errors_count} > 0 ]]; then
+		ewarn "Please check to make sure these options are set correctly."
+		ewarn "Failure to do so may cause unexpected problems."
+	else
+		eend 0
 	fi
 }
 
 check_zlibinflate() {
-	# if we haven't determined the version yet, we need too.
-	get_version;
+	# if we haven't determined the version yet, we need to
+	require_configured_kernel
+	get_version
 
 	# although I restructured this code - I really really really dont support it!
 
@@ -448,12 +730,12 @@
 	einfo "Determining the usability of ZLIB_INFLATE support in your kernel"
 
 	ebegin "checking ZLIB_INFLATE"
-	getfilevar_isbuiltin CONFIG_ZLIB_INFLATE ${KV_DIR}/.config
+	linux_chkconfig_builtin CONFIG_ZLIB_INFLATE
 	eend $?
 	[ "$?" != 0 ] && die
 
 	ebegin "checking ZLIB_DEFLATE"
-	getfilevar_isbuiltin CONFIG_ZLIB_DEFLATE ${KV_DIR}/.config
+	linux_chkconfig_builtin CONFIG_ZLIB_DEFLATE
 	eend $?
 	[ "$?" != 0 ] && die
 
@@ -501,8 +783,32 @@
 ################################
 # Default pkg_setup
 # Also used when inheriting linux-mod to force a get_version call
-
+# @FUNCTION: linux-info_pkg_setup
+# @DESCRIPTION:
+# Force a get_version() call when inherited from linux-mod.eclass and then check if the kernel is configured
+# to support the options specified in CONFIG_CHECK (if not null)
 linux-info_pkg_setup() {
-	get_version || die "Unable to calculate Linux Kernel version"
+	get_version 
+	if [[ $rc -ne 0 ]]; then
+		ewarn "Unable to calculate Linux Kernel version for build, attempting to use running version"
+		get_running_version 
+	fi
+
+	if kernel_is 2 4; then
+		if [ "$( gcc-major-version )" -eq "4" ] ; then
+			echo
+			ewarn "Be warned !! >=sys-devel/gcc-4.0.0 isn't supported with"
+			ewarn "linux-2.4 (or modules building against a linux-2.4 kernel)!"
+			echo
+			ewarn "Either switch to another gcc-version (via gcc-config) or use a"
+			ewarn "newer kernel that supports gcc-4."
+			echo
+			ewarn "Also be aware that bugreports about gcc-4 not working"
+			ewarn "with linux-2.4 based ebuilds will be closed as INVALID!"
+			echo
+			epause 10
+		fi
+	fi
+
 	[ -n "${CONFIG_CHECK}" ] && check_extra_config;
 }