gentoo-x86/eclass/linux-info.eclass

# 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.40 2006/02/16 21:46:50 exg 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
#
# Please direct your bugs to the current eclass maintainer :)

# A Couple of env vars are available to effect usage of this eclass
# These are as follows:
#
# 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"
#                               To simply warn about a missing option, prepend a '~'.
# 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.

# 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.

# 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}"


# Bug fixes
# fix to bug #75034
case ${ARCH} in
        ppc)    BUILD_FIXES="${BUILD_FIXES} TOUT=${T}/.tmp_gas_check";;
        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)"; }

# qeinfo "Message"
# -------------------
# qeinfo is a quiet einfo call when EBUILD_PHASE
# should not have visible output.
qout() {
        local outputmsg type
        type=${1}
        shift
        outputmsg="${@}"
        case "${EBUILD_PHASE}" in
                depend)  unset outputmsg;;
                clean)   unset outputmsg;;
                preinst) unset outputmsg;;
        esac
        [ -n "${outputmsg}" ] && ${type} "${outputmsg}"
}

qeinfo() { qout einfo "${@}" ; }
qeerror() { qout eerror "${@}" ; }

# File Functions
# ---------------------------------------

# getfilevar accepts 2 vars as follows:
# getfilevar <VARIABLE> <CONFIGFILE>

getfilevar() {
local   ERROR workingdir basefname basedname myARCH="${ARCH}"
        ERROR=0

        [ -z "${1}" ] && ERROR=1
        [ ! -f "${2}" ] && ERROR=1

        if [ "${ERROR}" = 1 ]
        then
                echo -e "\n"
                eerror "getfilevar requires 2 variables, with the second a valid file."
                eerror "   getfilevar <VARIABLE> <CONFIGFILE>"
        else
                workingdir="${PWD}"
                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}"

                ARCH=${myARCH}
        fi
}

linux_chkconfig_present() {
local   RESULT
        RESULT="$(getfilevar CONFIG_${1} ${KV_OUT_DIR}/.config)"
        [ "${RESULT}" = "m" -o "${RESULT}" = "y" ] && return 0 || return 1
}

linux_chkconfig_module() {
local   RESULT
        RESULT="$(getfilevar CONFIG_${1} ${KV_OUT_DIR}/.config)"
        [ "${RESULT}" = "m" ] && return 0 || return 1
}

linux_chkconfig_builtin() {
local   RESULT
        RESULT="$(getfilevar CONFIG_${1} ${KV_OUT_DIR}/.config)"
        [ "${RESULT}" = "y" ] && return 0 || return 1
}

linux_chkconfig_string() {
        getfilevar "CONFIG_${1}" "${KV_OUT_DIR}/.config"
}

# Versioning Functions
# ---------------------------------------

# kernel_is returns true when the version is the same as the passed version
#
# 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
#
# got the jist yet?

kernel_is() {
        # if we haven't determined the version yet, we need too.
        get_version;
        local operator test value x=0 y=0 z=0

        case ${1} in
          lt) operator="-lt"; shift;;
          gt) operator="-gt"; shift;;
          le) operator="-le"; shift;;
          ge) operator="-ge"; shift;;
          eq) operator="-eq"; shift;;
           *) operator="-eq";;
        esac

        for x in ${@}; do
                for((y=0; y<$((3 - ${#x})); y++)); do value="${value}0"; done
                value="${value}${x}"
                z=$((${z} + 1))

                case ${z} in
                  1) for((y=0; y<$((3 - ${#KV_MAJOR})); y++)); do test="${test}0"; done;
                     test="${test}${KV_MAJOR}";;
                  2) for((y=0; y<$((3 - ${#KV_MINOR})); y++)); do test="${test}0"; done;
                     test="${test}${KV_MINOR}";;
                  3) for((y=0; y<$((3 - ${#KV_PATCH})); y++)); do test="${test}0"; done;
                     test="${test}${KV_PATCH}";;
                  *) 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}
}

get_version() {
        local kbuild_output

        # no need to execute this twice assuming KV_FULL is populated.
        # we can force by unsetting KV_FULL
        [ -n "${KV_FULL}" ] && return 0

        # if we dont know KV_FULL, then we need too.
        # make sure KV_DIR isnt set since we need to work it out via KERNEL_DIR
        unset KV_DIR

        # KV_DIR will contain the full path to the sources directory we should use
        qeinfo "Determining the location of the kernel source code"
        [ -h "${KERNEL_DIR}" ] && KV_DIR="$(readlink -f ${KERNEL_DIR})"
        [ -d "${KERNEL_DIR}" ] && KV_DIR="${KERNEL_DIR}"

        if [ -z "${KV_DIR}" ]
        then
                qeerror "Unable to find kernel sources at ${KERNEL_DIR}"
                qeinfo "This package requires Linux sources."
                if [ "${KERNEL_DIR}" == "/usr/src/linux" ] ; then
                        qeinfo "Please make sure that ${KERNEL_DIR} points at your running kernel, "
                        qeinfo "(or the kernel you wish to build against)."
                        qeinfo "Alternatively, set the KERNEL_DIR environment variable to the kernel sources location"
                else
                        qeinfo "Please ensure that the KERNEL_DIR environment variable points at full Linux sources of the kernel you wish to compile against."
                fi
                return 1
        fi

        qeinfo "Found kernel source directory:"
        qeinfo "    ${KV_DIR}"

        if [ ! -s "${KV_DIR}/Makefile" ]
        then
                qeerror "Could not find a Makefile in the kernel source directory."
                qeerror "Please ensure that ${KERNEL_DIR} points to a complete set of Linux sources"
                return 1
        fi

        # OK so now we know our sources directory, but they might be using
        # KBUILD_OUTPUT, and we need this for .config and localversions-*
        # so we better find it eh?
        # do we pass KBUILD_OUTPUT on the CLI?
        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)"
        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)"

        if [ -z "${KV_MAJOR}" -o -z "${KV_MINOR}" -o -z "${KV_PATCH}" ]
        then
                qeerror "Could not detect kernel version."
                qeerror "Please ensure that ${KERNEL_DIR} points to a complete set of Linux sources."
                return 1
        fi

        # and in newer versions we can also pull LOCALVERSION if it is set.
        # 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}"

        [ -h "${OUTPUT_DIR}" ] && KV_OUT_DIR="$(readlink -f ${OUTPUT_DIR})"
        [ -d "${OUTPUT_DIR}" ] && KV_OUT_DIR="${OUTPUT_DIR}"
        if [ -n "${KV_OUT_DIR}" ];
        then
                qeinfo "Found kernel object directory:"
                qeinfo "    ${KV_OUT_DIR}"

                KV_LOCAL="$(get_localversion ${KV_OUT_DIR})"
        fi
        # 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}}"

        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

        KV_LOCAL="${KV_LOCAL}$(get_localversion ${KV_DIR})"
        KV_LOCAL="${KV_LOCAL}$(linux_chkconfig_string LOCALVERSION)"
        KV_LOCAL="${KV_LOCAL//\"/}"

        # And we should set KV_FULL to the full expanded version
        KV_FULL="${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}${KV_LOCAL}"

        qeinfo "Found sources for kernel version:"
        qeinfo "    ${KV_FULL}"

        return 0
}

get_running_version() {
        KV_FULL=$(uname -r)

        if [[ -f ${ROOT}/lib/modules/${KV_FULL}/source/Makefile ]]; then
                KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/source)
                unset KV_FULL
                get_version
                return $?
        elif [[ -f ${ROOT}/lib/modules/${KV_FULL}/build/Makefile ]]; then
                KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/build)
                unset KV_FULL
                get_version
                return $?
        else
                KV_MAJOR=$(get_version_component_range 1 ${KV_FULL})
                KV_MINOR=$(get_version_component_range 2 ${KV_FULL})
                KV_PATCH=$(get_version_component_range 3- ${KV_FULL})
                KV_PATCH=${KV_PATCH//-*}
                [[ -n ${KV_FULL#*-} ]] && [[ -n ${KV_FULL//${KV_FULL#*-}} ]] \
                        && KV_EXTRA="-${KV_FULL#*-}"
        fi
        return 0
}


# ebuild check functions
# ---------------------------------------

check_kernel_built() {
        # if we haven't determined the version yet, we need too.
        get_version;

        if [ ! -f "${KV_OUT_DIR}/include/linux/version.h" ]
        then
                eerror "These sources have not yet been prepared."
                eerror "We cannot build against an unprepared tree."
                eerror "To resolve this, please type the following:"
                eerror
                eerror "# cd ${KV_DIR}"
                eerror "# make oldconfig"
                eerror "# make modules_prepare"
                eerror
                eerror "Then please try merging this module again."
                die "Kernel sources need compiling first"
        fi
}

check_modules_supported() {
        # if we haven't determined the version yet, we need too.
        get_version;

        if ! linux_chkconfig_builtin "MODULES"
        then
                eerror "These sources do not support loading external modules."
                eerror "to be able to use this module please enable \"Loadable modules support\""
                eerror "in your kernel, recompile and then try merging this module again."
                die "No support for external modules in ${KV_FULL} config"
        fi
}

check_extra_config() {
        local   config negate error local_error i n
        local   temp_config die reworkmodulenames

        # if we haven't determined the version yet, we need too.
        get_version;

        einfo "Checking for suitable kernel configuration options:"
        for config in ${CONFIG_CHECK}
        do
                # if we specify any fatal, ensure we honor them
                die=1
                error=0
                negate=0
                reworkmodulenames=0

                if [[ -z ${config//\!*} ]]; then
                        negate=1
                        config=${config:1}
                fi
                if [[ -z ${config/\@*} ]]; then
                        die=2
                        reworkmodulenames=1
                        config=${config:1}
                fi
                if [[ -z ${config/\~*} ]]; then
                        die=0
                        config=${config:1}
                fi

                if [[ ${negate} == 1 ]]; then
                        linux_chkconfig_present ${config} && error=2
                elif [[ ${reworkmodulenames} == 1 ]]; then
                        temp_config="${config//*:}"
                        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}"
                                done
                                error=2
                        fi
                else
                        linux_chkconfig_present ${config} || error=1
                fi

                if [[ ${die} == 0 ]]; then
                        ebegin "CONFIG_${config}"
                        eend ${error}
                else
                        if [[ ${error} > 0 ]]; then
                                local_error="ERROR_${config}"
                                local_error="${!local_error}"

                                if [[ -z "${local_error}" ]]; then
                                        # using old, deprecated format.
                                        local_error="${config}_ERROR"
                                        local_error="${!local_error}"
                                fi

                                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
                                eerror "  ${local_error}"
                        fi
                fi
        done

        if [[ ${error} > 0 ]]; then
                eerror "Please check to make sure these options are set correctly."
                eerror "Failure to do so may cause unexpected problems."
                if [[ ${die} == 1 ]]; then
                        eerror "Once you have satisfied these options, please try merging"
                        eerror "this package again."
                        die "Incorrect kernel configuration options"
                fi
        fi
}

check_zlibinflate() {
        # if we haven't determined the version yet, we need too.
        get_version;

        # although I restructured this code - I really really really dont support it!

        # bug #27882 - zlib routines are only linked into the kernel
        # if something compiled into the kernel calls them
        #
        # plus, for the cloop module, it appears that there's no way
        # to get cloop.o to include a static zlib if CONFIG_MODVERSIONS
        # is on

        local INFLATE
        local DEFLATE

        einfo "Determining the usability of ZLIB_INFLATE support in your kernel"

        ebegin "checking ZLIB_INFLATE"
        getfilevar_isbuiltin CONFIG_ZLIB_INFLATE ${KV_DIR}/.config
        eend $?
        [ "$?" != 0 ] && die

        ebegin "checking ZLIB_DEFLATE"
        getfilevar_isbuiltin CONFIG_ZLIB_DEFLATE ${KV_DIR}/.config
        eend $?
        [ "$?" != 0 ] && die

        local LINENO_START
        local LINENO_END
        local SYMBOLS
        local x

        LINENO_END="$(grep -n 'CONFIG_ZLIB_INFLATE y' ${KV_DIR}/lib/Config.in | cut -d : -f 1)"
        LINENO_START="$(head -n $LINENO_END ${KV_DIR}/lib/Config.in | grep -n 'if \[' | tail -n 1 | cut -d : -f 1)"
        (( LINENO_AMOUNT = $LINENO_END - $LINENO_START ))
        (( LINENO_END = $LINENO_END - 1 ))
        SYMBOLS="$(head -n $LINENO_END ${KV_DIR}/lib/Config.in | tail -n $LINENO_AMOUNT | sed -e 's/^.*\(CONFIG_[^\" ]*\).*/\1/g;')"

        # okay, now we have a list of symbols
        # we need to check each one in turn, to see whether it is set or not
        for x in $SYMBOLS ; do
                if [ "${!x}" = "y" ]; then
                        # we have a winner!
                        einfo "${x} ensures zlib is linked into your kernel - excellent"
                        return 0
                fi
        done

        eerror
        eerror "This kernel module requires ZLIB library support."
        eerror "You have enabled zlib support in your kernel, but haven't enabled"
        eerror "enabled any option that will ensure that zlib is linked into your"
        eerror "kernel."
        eerror
        eerror "Please ensure that you enable at least one of these options:"
        eerror

        for x in $SYMBOLS ; do
                eerror "  * $x"
        done

        eerror
        eerror "Please remember to recompile and install your kernel, and reboot"
        eerror "into your new kernel before attempting to load this kernel module."

        die "Kernel doesn't include zlib support"
}

################################
# Default pkg_setup
# Also used when inheriting linux-mod to force a get_version call

linux-info_pkg_setup() {
        get_version || die "Unable to calculate Linux Kernel version"
        [ -n "${CONFIG_CHECK}" ] && check_extra_config;
}
1	vapier	1.37	# Copyright 1999-2006 Gentoo Foundation
2	johnm	1.1	# Distributed under the terms of the GNU General Public License v2
3	johnm	1.41	# $Header: /var/cvsroot/gentoo-x86/eclass/linux-info.eclass,v 1.40 2006/02/16 21:46:50 exg Exp $
4	johnm	1.1	#
5	johnm	1.10	# Description: This eclass is used as a central eclass for accessing kernel
6			# related information for sources already installed.
7			# It is vital for linux-mod to function correctly, and is split
8			# out so that any ebuild behaviour "templates" are abstracted out
9			# using additional eclasses.
10	johnm	1.1	#
11	johnm	1.10	# Maintainer: John Mylchreest <johnm@gentoo.org>
12			# Copyright 2004 Gentoo Linux
13			#
14			# Please direct your bugs to the current eclass maintainer :)
15
16			# A Couple of env vars are available to effect usage of this eclass
17			# These are as follows:
18	swegener	1.29	#
19	johnm	1.21	# Env Var Option Description
20	johnm	1.10	# KERNEL_DIR <string> The directory containing kernel the target kernel
21	johnm	1.21	# sources.
22	johnm	1.10	# CONFIG_CHECK <string> a list of .config options to check for before
23	johnm	1.21	# proceeding with the install. ie: CONFIG_CHECK="MTRR"
24	swegener	1.29	# You can also check that an option doesn't exist by
25	johnm	1.21	# prepending it with an exclamation mark (!).
26			# ie: CONFIG_CHECK="!MTRR"
27	vapier	1.37	# To simply warn about a missing option, prepend a '~'.
28	johnm	1.21	# ERROR_CFG <string> The error message to display when the above check
29			# fails. <CFG> should reference the appropriate option
30	johnm	1.25	# as above. ie: ERROR_MTRR="MTRR exists in the .config
31	johnm	1.21	# but shouldn't!!"
32	johnm	1.10	# KBUILD_OUTPUT <string> This is passed on commandline, or can be set from
33	johnm	1.21	# the kernel makefile. This contains the directory
34			# which is to be used as the kernel object directory.
35	johnm	1.10
36			# There are also a couple of variables which are set by this, and shouldn't be
37			# set by hand. These are as follows:
38	swegener	1.29	#
39	johnm	1.10	# Env Var Option Description
40			# KV_FULL <string> The full kernel version. ie: 2.6.9-gentoo-johnm-r1
41			# KV_MAJOR <integer> The kernel major version. ie: 2
42			# KV_MINOR <integer> The kernel minor version. ie: 6
43			# KV_PATCH <integer> The kernel patch version. ie: 9
44			# KV_EXTRA <string> The kernel EXTRAVERSION. ie: -gentoo
45			# KV_LOCAL <string> The kernel LOCALVERSION concatenation. ie: -johnm
46			# KV_DIR <string> The kernel source directory, will be null if
47	johnm	1.21	# KERNEL_DIR is invalid.
48			# KV_OUT_DIR <string> The kernel object directory. will be KV_DIR unless
49			# koutput is used. This should be used for referencing
50			# .config.
51	johnm	1.10
52	johnm	1.21	# And to ensure all the weirdness with crosscompile
53	johnm	1.23	inherit toolchain-funcs versionator
54	johnm	1.1
55	johnm	1.8	EXPORT_FUNCTIONS pkg_setup
56	johnm	1.1
57	exg	1.40	DEPEND="kernel_linux? ( virtual/linux-sources )"
58	brix	1.39	RDEPEND=""
59
60	johnm	1.1	# Overwritable environment Var's
61			# ---------------------------------------
62	johnm	1.21	KERNEL_DIR="${KERNEL_DIR:-${ROOT}usr/src/linux}"
63	johnm	1.1
64	johnm	1.7
65	johnm	1.16	# Bug fixes
66			# fix to bug #75034
67			case ${ARCH} in
68	swegener	1.29	ppc) BUILD_FIXES="${BUILD_FIXES} TOUT=${T}/.tmp_gas_check";;
69			ppc64) BUILD_FIXES="${BUILD_FIXES} TOUT=${T}/.tmp_gas_check";;
70	johnm	1.16	esac
71
72	johnm	1.21	# These are legacy wrappers for toolchain-funcs.
73			# I dont like them here, but oh well.
74	johnm	1.22	set_arch_to_kernel() { export ARCH="$(tc-arch-kernel)"; }
75			set_arch_to_portage() { export ARCH="$(tc-arch)"; }
76	johnm	1.11
77			# qeinfo "Message"
78			# -------------------
79	johnm	1.21	# qeinfo is a quiet einfo call when EBUILD_PHASE
80	johnm	1.11	# should not have visible output.
81	johnm	1.21	qout() {
82			local outputmsg type
83			type=${1}
84			shift
85			outputmsg="${@}"
86	wolf31o2	1.26	case "${EBUILD_PHASE}" in
87			depend) unset outputmsg;;
88			clean) unset outputmsg;;
89			preinst) unset outputmsg;;
90			esac
91			[ -n "${outputmsg}" ] && ${type} "${outputmsg}"
92	johnm	1.11	}
93
94	johnm	1.21	qeinfo() { qout einfo "${@}" ; }
95			qeerror() { qout eerror "${@}" ; }
96	johnm	1.11
97	johnm	1.1	# File Functions
98			# ---------------------------------------
99
100			# getfilevar accepts 2 vars as follows:
101			# getfilevar <VARIABLE> <CONFIGFILE>
102
103			getfilevar() {
104	johnm	1.21	local ERROR workingdir basefname basedname myARCH="${ARCH}"
105	johnm	1.1	ERROR=0
106	johnm	1.16
107	johnm	1.1	[ -z "${1}" ] && ERROR=1
108			[ ! -f "${2}" ] && ERROR=1
109
110			if [ "${ERROR}" = 1 ]
111			then
112	johnm	1.6	echo -e "\n"
113	johnm	1.1	eerror "getfilevar requires 2 variables, with the second a valid file."
114			eerror " getfilevar <VARIABLE> <CONFIGFILE>"
115			else
116	johnm	1.34	workingdir="${PWD}"
117			basefname="$(basename ${2})"
118			basedname="$(dirname ${2})"
119	johnm	1.6	unset ARCH
120	johnm	1.21
121	johnm	1.34	cd "${basedname}"
122	johnm	1.7	echo -e "include ${basefname}\ne:\n\t@echo \$(${1})" \| \
123	johnm	1.24	make ${BUILD_FIXES} -s -f - e 2>/dev/null
124	johnm	1.34	cd "${workingdir}"
125	johnm	1.21
126			ARCH=${myARCH}
127	johnm	1.1	fi
128			}
129
130	johnm	1.7	linux_chkconfig_present() {
131	johnm	1.1	local RESULT
132	johnm	1.7	RESULT="$(getfilevar CONFIG_${1} ${KV_OUT_DIR}/.config)"
133	johnm	1.1	[ "${RESULT}" = "m" -o "${RESULT}" = "y" ] && return 0 \|\| return 1
134			}
135
136	johnm	1.7	linux_chkconfig_module() {
137	johnm	1.1	local RESULT
138	johnm	1.7	RESULT="$(getfilevar CONFIG_${1} ${KV_OUT_DIR}/.config)"
139	johnm	1.1	[ "${RESULT}" = "m" ] && return 0 \|\| return 1
140			}
141
142	johnm	1.7	linux_chkconfig_builtin() {
143	johnm	1.1	local RESULT
144	johnm	1.7	RESULT="$(getfilevar CONFIG_${1} ${KV_OUT_DIR}/.config)"
145	johnm	1.1	[ "${RESULT}" = "y" ] && return 0 \|\| return 1
146			}
147
148	johnm	1.7	linux_chkconfig_string() {
149			getfilevar "CONFIG_${1}" "${KV_OUT_DIR}/.config"
150			}
151
152	johnm	1.1	# Versioning Functions
153			# ---------------------------------------
154
155			# kernel_is returns true when the version is the same as the passed version
156			#
157			# For Example where KV = 2.6.9
158			# kernel_is 2 4 returns false
159			# kernel_is 2 returns true
160			# kernel_is 2 6 returns true
161			# kernel_is 2 6 8 returns false
162			# kernel_is 2 6 9 returns true
163	johnm	1.3	#
164	johnm	1.1	# got the jist yet?
165
166			kernel_is() {
167			# if we haven't determined the version yet, we need too.
168			get_version;
169	johnm	1.23	local operator test value x=0 y=0 z=0
170
171			case ${1} in
172			lt) operator="-lt"; shift;;
173			gt) operator="-gt"; shift;;
174			le) operator="-le"; shift;;
175			ge) operator="-ge"; shift;;
176			eq) operator="-eq"; shift;;
177			*) operator="-eq";;
178			esac
179
180			for x in ${@}; do
181			for((y=0; y<$((3 - ${#x})); y++)); do value="${value}0"; done
182			value="${value}${x}"
183			z=$((${z} + 1))
184
185			case ${z} in
186			1) for((y=0; y<$((3 - ${#KV_MAJOR})); y++)); do test="${test}0"; done;
187			test="${test}${KV_MAJOR}";;
188			2) for((y=0; y<$((3 - ${#KV_MINOR})); y++)); do test="${test}0"; done;
189			test="${test}${KV_MINOR}";;
190			3) for((y=0; y<$((3 - ${#KV_PATCH})); y++)); do test="${test}0"; done;
191			test="${test}${KV_PATCH}";;
192			*) die "Error in kernel-2_kernel_is(): Too many parameters.";;
193			esac
194			done
195	johnm	1.12
196	swegener	1.29	[ ${test} ${operator} ${value} ] && return 0 \|\| return 1
197	johnm	1.1	}
198
199	johnm	1.30	get_localversion() {
200			local lv_list i x
201
202			# ignore files with ~ in it.
203			for i in $(ls ${1}/localversion* 2>/dev/null); do
204			[[ -n ${i//~} ]] && lv_list="${lv_list} ${i}"
205			done
206
207			for i in ${lv_list}; do
208			x="${x}$(<${i})"
209			done
210			x=${x/ /}
211			echo ${x}
212			}
213
214	johnm	1.1	get_version() {
215	johnm	1.4	local kbuild_output
216	swegener	1.29
217	johnm	1.1	# no need to execute this twice assuming KV_FULL is populated.
218			# we can force by unsetting KV_FULL
219	johnm	1.19	[ -n "${KV_FULL}" ] && return 0
220	johnm	1.1
221			# if we dont know KV_FULL, then we need too.
222			# make sure KV_DIR isnt set since we need to work it out via KERNEL_DIR
223			unset KV_DIR
224
225			# KV_DIR will contain the full path to the sources directory we should use
226	johnm	1.11	qeinfo "Determining the location of the kernel source code"
227	johnm	1.1	[ -h "${KERNEL_DIR}" ] && KV_DIR="$(readlink -f ${KERNEL_DIR})"
228			[ -d "${KERNEL_DIR}" ] && KV_DIR="${KERNEL_DIR}"
229	swegener	1.29
230	johnm	1.1	if [ -z "${KV_DIR}" ]
231			then
232	johnm	1.11	qeerror "Unable to find kernel sources at ${KERNEL_DIR}"
233			qeinfo "This package requires Linux sources."
234	johnm	1.7	if [ "${KERNEL_DIR}" == "/usr/src/linux" ] ; then
235	johnm	1.11	qeinfo "Please make sure that ${KERNEL_DIR} points at your running kernel, "
236			qeinfo "(or the kernel you wish to build against)."
237			qeinfo "Alternatively, set the KERNEL_DIR environment variable to the kernel sources location"
238	johnm	1.7	else
239	johnm	1.11	qeinfo "Please ensure that the KERNEL_DIR environment variable points at full Linux sources of the kernel you wish to compile against."
240	johnm	1.7	fi
241	johnm	1.19	return 1
242	johnm	1.7	fi
243
244	johnm	1.11	qeinfo "Found kernel source directory:"
245			qeinfo " ${KV_DIR}"
246	johnm	1.7
247			if [ ! -s "${KV_DIR}/Makefile" ]
248			then
249	johnm	1.11	qeerror "Could not find a Makefile in the kernel source directory."
250			qeerror "Please ensure that ${KERNEL_DIR} points to a complete set of Linux sources"
251	johnm	1.19	return 1
252	johnm	1.7	fi
253	swegener	1.29
254	johnm	1.4	# OK so now we know our sources directory, but they might be using
255			# KBUILD_OUTPUT, and we need this for .config and localversions-*
256			# so we better find it eh?
257			# do we pass KBUILD_OUTPUT on the CLI?
258			OUTPUT_DIR="${OUTPUT_DIR:-${KBUILD_OUTPUT}}"
259	swegener	1.29
260	johnm	1.6	# And if we didn't pass it, we can take a nosey in the Makefile
261	johnm	1.4	kbuild_output="$(getfilevar KBUILD_OUTPUT ${KV_DIR}/Makefile)"
262			OUTPUT_DIR="${OUTPUT_DIR:-${kbuild_output}}"
263	swegener	1.29
264	johnm	1.1	# And contrary to existing functions I feel we shouldn't trust the
265			# directory name to find version information as this seems insane.
266			# so we parse ${KV_DIR}/Makefile
267			KV_MAJOR="$(getfilevar VERSION ${KV_DIR}/Makefile)"
268			KV_MINOR="$(getfilevar PATCHLEVEL ${KV_DIR}/Makefile)"
269			KV_PATCH="$(getfilevar SUBLEVEL ${KV_DIR}/Makefile)"
270			KV_EXTRA="$(getfilevar EXTRAVERSION ${KV_DIR}/Makefile)"
271	swegener	1.29
272	johnm	1.7	if [ -z "${KV_MAJOR}" -o -z "${KV_MINOR}" -o -z "${KV_PATCH}" ]
273			then
274	johnm	1.11	qeerror "Could not detect kernel version."
275	johnm	1.19	qeerror "Please ensure that ${KERNEL_DIR} points to a complete set of Linux sources."
276			return 1
277	johnm	1.7	fi
278	swegener	1.29
279	johnm	1.1	# and in newer versions we can also pull LOCALVERSION if it is set.
280	johnm	1.4	# but before we do this, we need to find if we use a different object directory.
281			# This WILL break if the user is using localversions, but we assume it was
282			# caught before this if they are.
283			[ "${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}.${KV_EXTRA}" == "$(uname -r)" ] && \
284	johnm	1.7	OUTPUT_DIR="${OUTPUT_DIR:-/lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}.${KV_EXTRA}/build}"
285	johnm	1.4
286			[ -h "${OUTPUT_DIR}" ] && KV_OUT_DIR="$(readlink -f ${OUTPUT_DIR})"
287			[ -d "${OUTPUT_DIR}" ] && KV_OUT_DIR="${OUTPUT_DIR}"
288			if [ -n "${KV_OUT_DIR}" ];
289			then
290	johnm	1.11	qeinfo "Found kernel object directory:"
291			qeinfo " ${KV_OUT_DIR}"
292	swegener	1.29
293	johnm	1.30	KV_LOCAL="$(get_localversion ${KV_OUT_DIR})"
294	johnm	1.4	fi
295	johnm	1.41	# and if we STILL have not got it, then we better just set it to KV_DIR
296	johnm	1.4	KV_OUT_DIR="${KV_OUT_DIR:-${KV_DIR}}"
297	johnm	1.21
298	johnm	1.41	if [ ! -s "${KV_OUT_DIR}/.config" ]
299			then
300			qeerror "Could not find a usable .config in the kernel source directory."
301			qeerror "Please ensure that ${KERNEL_DIR} points to a configured set of Linux sources."
302			qeerror "If you are using KBUILD_OUTPUT, please set the environment var so that"
303			qeerror "it points to the necessary object directory so that it might find .config."
304			return 1
305			fi
306
307	johnm	1.33	KV_LOCAL="${KV_LOCAL}$(get_localversion ${KV_DIR})"
308	johnm	1.7	KV_LOCAL="${KV_LOCAL}$(linux_chkconfig_string LOCALVERSION)"
309			KV_LOCAL="${KV_LOCAL//\"/}"
310	johnm	1.21
311	johnm	1.1	# And we should set KV_FULL to the full expanded version
312			KV_FULL="${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}${KV_LOCAL}"
313	johnm	1.21
314	johnm	1.11	qeinfo "Found sources for kernel version:"
315			qeinfo " ${KV_FULL}"
316	johnm	1.21
317	johnm	1.19	return 0
318	johnm	1.1	}
319
320	johnm	1.23	get_running_version() {
321			KV_FULL=$(uname -r)
322	johnm	1.1
323	johnm	1.23	if [[ -f ${ROOT}/lib/modules/${KV_FULL}/source/Makefile ]]; then
324			KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/source)
325			unset KV_FULL
326			get_version
327			return $?
328			elif [[ -f ${ROOT}/lib/modules/${KV_FULL}/build/Makefile ]]; then
329			KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/build)
330			unset KV_FULL
331			get_version
332			return $?
333			else
334			KV_MAJOR=$(get_version_component_range 1 ${KV_FULL})
335			KV_MINOR=$(get_version_component_range 2 ${KV_FULL})
336			KV_PATCH=$(get_version_component_range 3- ${KV_FULL})
337			KV_PATCH=${KV_PATCH//-*}
338			[[ -n ${KV_FULL#-} ]] && [[ -n ${KV_FULL//${KV_FULL#-}} ]] \
339			&& KV_EXTRA="-${KV_FULL#*-}"
340			fi
341			return 0
342			}
343	johnm	1.1
344
345			# ebuild check functions
346			# ---------------------------------------
347
348			check_kernel_built() {
349			# if we haven't determined the version yet, we need too.
350			get_version;
351	swegener	1.29
352	johnm	1.16	if [ ! -f "${KV_OUT_DIR}/include/linux/version.h" ]
353	johnm	1.1	then
354	johnm	1.16	eerror "These sources have not yet been prepared."
355			eerror "We cannot build against an unprepared tree."
356	johnm	1.1	eerror "To resolve this, please type the following:"
357			eerror
358			eerror "# cd ${KV_DIR}"
359			eerror "# make oldconfig"
360	johnm	1.16	eerror "# make modules_prepare"
361	johnm	1.1	eerror
362			eerror "Then please try merging this module again."
363			die "Kernel sources need compiling first"
364			fi
365			}
366
367			check_modules_supported() {
368			# if we haven't determined the version yet, we need too.
369			get_version;
370	swegener	1.29
371	johnm	1.7	if ! linux_chkconfig_builtin "MODULES"
372	johnm	1.1	then
373			eerror "These sources do not support loading external modules."
374			eerror "to be able to use this module please enable \"Loadable modules support\""
375			eerror "in your kernel, recompile and then try merging this module again."
376	johnm	1.7	die "No support for external modules in ${KV_FULL} config"
377	johnm	1.3	fi
378			}
379
380			check_extra_config() {
381	swegener	1.32	local config negate error local_error i n
382	johnm	1.31	local temp_config die reworkmodulenames
383	johnm	1.3
384			# if we haven't determined the version yet, we need too.
385			get_version;
386
387	johnm	1.31	einfo "Checking for suitable kernel configuration options:"
388	johnm	1.3	for config in ${CONFIG_CHECK}
389			do
390	johnm	1.31	# if we specify any fatal, ensure we honor them
391			die=1
392			error=0
393			negate=0
394			reworkmodulenames=0
395
396			if [[ -z ${config//\!*} ]]; then
397			negate=1
398			config=${config:1}
399			fi
400			if [[ -z ${config/\@*} ]]; then
401			die=2
402			reworkmodulenames=1
403			config=${config:1}
404			fi
405			if [[ -z ${config/\~*} ]]; then
406			die=0
407			config=${config:1}
408			fi
409	johnm	1.17
410	johnm	1.31	if [[ ${negate} == 1 ]]; then
411			linux_chkconfig_present ${config} && error=2
412			elif [[ ${reworkmodulenames} == 1 ]]; then
413	johnm	1.17	temp_config="${config//*:}"
414			config="${config//:*}"
415	johnm	1.31	if linux_chkconfig_present ${config}; then
416			for i in ${MODULE_NAMES}; do
417	johnm	1.17	n="${i//${temp_config}}"
418	dsd	1.38	[[ -z ${n//\(*} ]] && \
419	johnm	1.31	MODULE_IGNORE="${MODULE_IGNORE} ${temp_config}"
420	johnm	1.17	done
421	johnm	1.31	error=2
422	johnm	1.17	fi
423	johnm	1.3	else
424	johnm	1.31	linux_chkconfig_present ${config} \|\| error=1
425			fi
426
427			if [[ ${die} == 0 ]]; then
428			ebegin "CONFIG_${config}"
429			eend ${error}
430			else
431			if [[ ${error} > 0 ]]; then
432	johnm	1.35	local_error="ERROR_${config}"
433	johnm	1.7	local_error="${!local_error}"
434	swegener	1.36
435	johnm	1.35	if [[ -z "${local_error}" ]]; then
436			# using old, deprecated format.
437			local_error="${config}_ERROR"
438			local_error="${!local_error}"
439			fi
440	swegener	1.36
441	johnm	1.31	if [[ -z "${local_error}" ]]; then
442			[[ ${error} == 1 ]] \
443			&& local_error="is not set when it should be." \
444			\|\| local_error="should not be set. But it is."
445			local_error="CONFIG_${config}:\t ${local_error}"
446	johnm	1.21	fi
447	johnm	1.31	eerror " ${local_error}"
448	johnm	1.3	fi
449			fi
450			done
451
452	johnm	1.31	if [[ ${error} > 0 ]]; then
453	johnm	1.3	eerror "Please check to make sure these options are set correctly."
454	johnm	1.31	eerror "Failure to do so may cause unexpected problems."
455			if [[ ${die} == 1 ]]; then
456			eerror "Once you have satisfied these options, please try merging"
457			eerror "this package again."
458			die "Incorrect kernel configuration options"
459			fi
460	johnm	1.1	fi
461			}
462
463			check_zlibinflate() {
464			# if we haven't determined the version yet, we need too.
465			get_version;
466	swegener	1.29
467	johnm	1.1	# although I restructured this code - I really really really dont support it!
468
469			# bug #27882 - zlib routines are only linked into the kernel
470			# if something compiled into the kernel calls them
471			#
472			# plus, for the cloop module, it appears that there's no way
473			# to get cloop.o to include a static zlib if CONFIG_MODVERSIONS
474			# is on
475	swegener	1.29
476			local INFLATE
477			local DEFLATE
478	johnm	1.1
479			einfo "Determining the usability of ZLIB_INFLATE support in your kernel"
480	swegener	1.29
481	johnm	1.1	ebegin "checking ZLIB_INFLATE"
482			getfilevar_isbuiltin CONFIG_ZLIB_INFLATE ${KV_DIR}/.config
483			eend $?
484			[ "$?" != 0 ] && die
485	swegener	1.29
486	johnm	1.1	ebegin "checking ZLIB_DEFLATE"
487			getfilevar_isbuiltin CONFIG_ZLIB_DEFLATE ${KV_DIR}/.config
488			eend $?
489			[ "$?" != 0 ] && die
490	swegener	1.29
491	johnm	1.1	local LINENO_START
492			local LINENO_END
493			local SYMBOLS
494			local x
495	swegener	1.29
496	johnm	1.1	LINENO_END="$(grep -n 'CONFIG_ZLIB_INFLATE y' ${KV_DIR}/lib/Config.in \| cut -d : -f 1)"
497			LINENO_START="$(head -n $LINENO_END ${KV_DIR}/lib/Config.in \| grep -n 'if \[' \| tail -n 1 \| cut -d : -f 1)"
498			(( LINENO_AMOUNT = $LINENO_END - $LINENO_START ))
499			(( LINENO_END = $LINENO_END - 1 ))
500	johnm	1.4	SYMBOLS="$(head -n $LINENO_END ${KV_DIR}/lib/Config.in \| tail -n $LINENO_AMOUNT \| sed -e 's/^.\(CONFIG_[^\" ]\).*/\1/g;')"
501	johnm	1.1
502			# okay, now we have a list of symbols
503			# we need to check each one in turn, to see whether it is set or not
504			for x in $SYMBOLS ; do
505			if [ "${!x}" = "y" ]; then
506			# we have a winner!
507			einfo "${x} ensures zlib is linked into your kernel - excellent"
508			return 0
509			fi
510			done
511	swegener	1.29
512	johnm	1.1	eerror
513			eerror "This kernel module requires ZLIB library support."
514			eerror "You have enabled zlib support in your kernel, but haven't enabled"
515			eerror "enabled any option that will ensure that zlib is linked into your"
516			eerror "kernel."
517			eerror
518			eerror "Please ensure that you enable at least one of these options:"
519			eerror
520
521			for x in $SYMBOLS ; do
522			eerror " * $x"
523			done
524
525			eerror
526			eerror "Please remember to recompile and install your kernel, and reboot"
527			eerror "into your new kernel before attempting to load this kernel module."
528
529			die "Kernel doesn't include zlib support"
530			}
531	johnm	1.8
532			################################
533			# Default pkg_setup
534			# Also used when inheriting linux-mod to force a get_version call
535
536			linux-info_pkg_setup() {
537	johnm	1.19	get_version \|\| die "Unable to calculate Linux Kernel version"
538	johnm	1.10	[ -n "${CONFIG_CHECK}" ] && check_extra_config;
539	johnm	1.8	}