1 # Copyright 1999-2018 Gentoo Foundation
2 # Distributed under the terms of the GNU General Public License v2
4 # @ECLASS: linux-info.eclass
8 # Original author: John Mylchreest <johnm@gentoo.org>
9 # @BLURB: eclass used for accessing kernel related information
11 # This eclass is used as a central eclass for accessing kernel
12 # related information for source or binary already installed.
13 # It is vital for linux-mod.eclass to function correctly, and is split
14 # out so that any ebuild behaviour "templates" are abstracted out
15 # using additional eclasses.
17 # "kernel config" in this file means:
18 # The .config of the currently installed sources is used as the first
19 # preference, with a fall-back to bundled config (/proc/config.gz) if available.
21 # Before using any of the config-handling functions in this eclass, you must
22 # ensure that one of the following functions has been called (in order of
23 # preference), otherwise you will get bugs like #364041):
24 # linux-info_pkg_setup
25 # linux-info_get_any_version
29 # A Couple of env vars are available to effect usage of this eclass
30 # These are as follows:
32 # @ECLASS-VARIABLE: KERNEL_DIR
34 # A string containing the directory of the target kernel sources. The default value is
37 # @ECLASS-VARIABLE: CONFIG_CHECK
39 # A string containing a list of .config options to check for before
40 # proceeding with the install.
42 # e.g.: CONFIG_CHECK="MTRR"
44 # You can also check that an option doesn't exist by
45 # prepending it with an exclamation mark (!).
47 # e.g.: CONFIG_CHECK="!MTRR"
49 # To simply warn about a missing option, prepend a '~'.
50 # It may be combined with '!'.
52 # In general, most checks should be non-fatal. The only time fatal checks should
53 # be used is for building kernel modules or cases that a compile will fail
56 # This is to allow usage of binary kernels, and minimal systems without kernel
59 # @ECLASS-VARIABLE: ERROR_<CFG>
61 # A string containing the error message to display when the check against CONFIG_CHECK
62 # fails. <CFG> should reference the appropriate option used in CONFIG_CHECK.
64 # e.g.: ERROR_MTRR="MTRR exists in the .config but shouldn't!!"
66 # @ECLASS-VARIABLE: KBUILD_OUTPUT
68 # A string passed on commandline, or set from the kernel makefile. It contains the directory
69 # which is to be used as the kernel object directory.
71 # There are also a couple of variables which are set by this, and shouldn't be
72 # set by hand. These are as follows:
74 # @ECLASS-VARIABLE: KV_FULL
76 # A read-only variable. It's a string containing the full kernel version. ie: 2.6.9-gentoo-johnm-r1
78 # @ECLASS-VARIABLE: KV_MAJOR
80 # A read-only variable. It's an integer containing the kernel major version. ie: 2
82 # @ECLASS-VARIABLE: KV_MINOR
84 # A read-only variable. It's an integer containing the kernel minor version. ie: 6
86 # @ECLASS-VARIABLE: KV_PATCH
88 # A read-only variable. It's an integer containing the kernel patch version. ie: 9
90 # @ECLASS-VARIABLE: KV_EXTRA
92 # A read-only variable. It's a string containing the kernel EXTRAVERSION. ie: -gentoo
94 # @ECLASS-VARIABLE: KV_LOCAL
96 # A read-only variable. It's a string containing the kernel LOCALVERSION concatenation. ie: -johnm
98 # @ECLASS-VARIABLE: KV_DIR
100 # A read-only variable. It's a string containing the kernel source directory, will be null if
101 # KERNEL_DIR is invalid.
103 # @ECLASS-VARIABLE: KV_OUT_DIR
105 # A read-only variable. It's a string containing the kernel object directory, will be KV_DIR unless
106 # KBUILD_OUTPUT is used. This should be used for referencing .config.
108 # And to ensure all the weirdness with crosscompile
109 inherit toolchain-funcs
110 [[ ${EAPI:-0} == [0123456] ]] && inherit eapi7-ver
112 EXPORT_FUNCTIONS pkg_setup
116 # Overwritable environment Var's
117 # ---------------------------------------
118 KERNEL_DIR="${KERNEL_DIR:-${ROOT%/}/usr/src/linux}"
124 ppc) BUILD_FIXES="${BUILD_FIXES} TOUT=${T}/.tmp_gas_check";;
125 ppc64) BUILD_FIXES="${BUILD_FIXES} TOUT=${T}/.tmp_gas_check";;
128 # @FUNCTION: set_arch_to_kernel
130 # Set the env ARCH to match what the kernel expects.
131 set_arch_to_kernel() { export ARCH=$(tc-arch-kernel); }
132 # @FUNCTION: set_arch_to_portage
134 # Set the env ARCH to match what portage expects.
135 set_arch_to_portage() { export ARCH=$(tc-arch); }
138 # -------------------
139 # qeinfo is a quiet einfo call when EBUILD_PHASE
140 # should not have visible output.
146 case "${EBUILD_PHASE}" in
147 depend) unset outputmsg;;
148 clean) unset outputmsg;;
149 preinst) unset outputmsg;;
151 [ -n "${outputmsg}" ] && ${type} "${outputmsg}"
154 qeinfo() { qout einfo "${@}" ; }
155 qewarn() { qout ewarn "${@}" ; }
156 qeerror() { qout eerror "${@}" ; }
159 # ---------------------------------------
161 # @FUNCTION: getfilevar
162 # @USAGE: <variable> <configfile>
163 # @RETURN: the value of the variable
165 # It detects the value of the variable defined in the file configfile. This is
166 # done by including the configfile, and printing the variable with Make.
167 # It WILL break if your makefile has missing dependencies!
169 local ERROR basefname basedname myARCH="${ARCH}" M="${S}"
172 [ -z "${1}" ] && ERROR=1
173 [ ! -f "${2}" ] && ERROR=1
175 if [ "${ERROR}" = 1 ]
178 eerror "getfilevar requires 2 variables, with the second a valid file."
179 eerror " getfilevar <VARIABLE> <CONFIGFILE>"
181 basefname="$(basename ${2})"
182 basedname="$(dirname ${2})"
185 # We use nonfatal because we want the caller to take care of things #373151
186 [[ ${EAPI:-0} == [0123] ]] && nonfatal() { "$@"; }
187 case ${EBUILD_PHASE_FUNC} in
188 pkg_info|pkg_nofetch|pkg_pretend) M="${T}" ;;
190 echo -e "e:\\n\\t@echo \$(${1})\\ninclude ${basefname}" | \
191 nonfatal emake -C "${basedname}" M="${M}" ${BUILD_FIXES} -s -f - 2>/dev/null
197 # @FUNCTION: getfilevar_noexec
198 # @USAGE: <variable> <configfile>
199 # @RETURN: the value of the variable
201 # It detects the value of the variable defined in the file configfile.
202 # This is done with sed matching an expression only. If the variable is defined,
203 # you will run into problems. See getfilevar for those cases.
204 getfilevar_noexec() {
205 local ERROR basefname basedname mycat myARCH="${ARCH}"
209 [ -z "${1}" ] && ERROR=1
210 [ ! -f "${2}" ] && ERROR=1
211 [ "${2%.gz}" != "${2}" ] && mycat='zcat'
213 if [ "${ERROR}" = 1 ]
216 eerror "getfilevar_noexec requires 2 variables, with the second a valid file."
217 eerror " getfilevar_noexec <VARIABLE> <CONFIGFILE>"
221 -e "/^[[:space:]]*${1}[[:space:]]*:\\?=[[:space:]]*\(.*\)\$/{
222 s,^[^=]*[[:space:]]*=[[:space:]]*,,g ;
223 s,[[:space:]]*\$,,g ;
229 # @ECLASS-VARIABLE: _LINUX_CONFIG_EXISTS_DONE
232 # This is only set if one of the linux_config_*exists functions has been called.
233 # We use it for a QA warning that the check for a config has not been performed,
234 # as linux_chkconfig* in non-legacy mode WILL return an undefined value if no
235 # config is available at all.
236 _LINUX_CONFIG_EXISTS_DONE=
238 linux_config_qa_check() {
240 if [ -z "${_LINUX_CONFIG_EXISTS_DONE}" ]; then
241 ewarn "QA: You called $f before any linux_config_exists!"
242 ewarn "QA: The return value of $f will NOT guaranteed later!"
245 if ! use kernel_linux; then
246 die "$f called on non-Linux system, please fix the ebuild"
250 # @FUNCTION: linux_config_src_exists
251 # @RETURN: true or false
253 # It returns true if .config exists in a build directory otherwise false
254 linux_config_src_exists() {
255 export _LINUX_CONFIG_EXISTS_DONE=1
256 use kernel_linux && [[ -n ${KV_OUT_DIR} && -s ${KV_OUT_DIR}/.config ]]
259 # @FUNCTION: linux_config_bin_exists
260 # @RETURN: true or false
262 # It returns true if .config exists in /proc, otherwise false
263 linux_config_bin_exists() {
264 export _LINUX_CONFIG_EXISTS_DONE=1
265 use kernel_linux && [[ -s /proc/config.gz ]]
268 # @FUNCTION: linux_config_exists
269 # @RETURN: true or false
271 # It returns true if .config exists otherwise false
273 # This function MUST be checked before using any of the linux_chkconfig_*
275 linux_config_exists() {
276 linux_config_src_exists || linux_config_bin_exists
279 # @FUNCTION: linux_config_path
281 # Echo the name of the config file to use. If none are found,
283 linux_config_path() {
284 if linux_config_src_exists; then
285 echo "${KV_OUT_DIR}/.config"
286 elif linux_config_bin_exists; then
287 echo "/proc/config.gz"
293 # @FUNCTION: require_configured_kernel
295 # This function verifies that the current kernel is configured (it checks against the existence of .config)
297 require_configured_kernel() {
298 if ! use kernel_linux; then
299 die "${FUNCNAME}() called on non-Linux system, please fix the ebuild"
302 if ! linux_config_src_exists; then
303 qeerror "Could not find a usable .config in the kernel source directory."
304 qeerror "Please ensure that ${KERNEL_DIR} points to a configured set of Linux sources."
305 qeerror "If you are using KBUILD_OUTPUT, please set the environment var so that"
306 qeerror "it points to the necessary object directory so that it might find .config."
307 die "Kernel not configured; no .config found in ${KV_OUT_DIR}"
309 get_version || die "Unable to determine configured kernel version"
312 # @FUNCTION: linux_chkconfig_present
314 # @RETURN: true or false
316 # It checks that CONFIG_<option>=y or CONFIG_<option>=m is present in the current kernel .config
317 # If linux_config_exists returns false, the results of this are UNDEFINED. You
318 # MUST call linux_config_exists first.
319 linux_chkconfig_present() {
320 linux_config_qa_check linux_chkconfig_present
321 [[ $(getfilevar_noexec "CONFIG_$1" "$(linux_config_path)") == [my] ]]
324 # @FUNCTION: linux_chkconfig_module
326 # @RETURN: true or false
328 # It checks that CONFIG_<option>=m is present in the current kernel .config
329 # If linux_config_exists returns false, the results of this are UNDEFINED. You
330 # MUST call linux_config_exists first.
331 linux_chkconfig_module() {
332 linux_config_qa_check linux_chkconfig_module
333 [[ $(getfilevar_noexec "CONFIG_$1" "$(linux_config_path)") == m ]]
336 # @FUNCTION: linux_chkconfig_builtin
338 # @RETURN: true or false
340 # It checks that CONFIG_<option>=y is present in the current kernel .config
341 # If linux_config_exists returns false, the results of this are UNDEFINED. You
342 # MUST call linux_config_exists first.
343 linux_chkconfig_builtin() {
344 linux_config_qa_check linux_chkconfig_builtin
345 [[ $(getfilevar_noexec "CONFIG_$1" "$(linux_config_path)") == y ]]
348 # @FUNCTION: linux_chkconfig_string
350 # @RETURN: CONFIG_<option>
352 # It prints the CONFIG_<option> value of the current kernel .config (it requires a configured kernel).
353 # If linux_config_exists returns false, the results of this are UNDEFINED. You
354 # MUST call linux_config_exists first.
355 linux_chkconfig_string() {
356 linux_config_qa_check linux_chkconfig_string
357 getfilevar_noexec "CONFIG_$1" "$(linux_config_path)"
360 # Versioning Functions
361 # ---------------------------------------
363 # @FUNCTION: kernel_is
364 # @USAGE: [-lt -gt -le -ge -eq] <major_number> [minor_number patch_number]
365 # @RETURN: true or false
367 # It returns true when the current kernel version satisfies the comparison against the passed version.
368 # -eq is the default comparison.
371 # For Example where KV = 2.6.9
372 # kernel_is 2 4 returns false
373 # kernel_is 2 returns true
374 # kernel_is 2 6 returns true
375 # kernel_is 2 6 8 returns false
376 # kernel_is 2 6 9 returns true
379 # Note: duplicated in kernel-2.eclass
381 if ! use kernel_linux; then
382 die "${FUNCNAME}() called on non-Linux system, please fix the ebuild"
385 # if we haven't determined the version yet, we need to.
386 linux-info_get_any_version
388 # Now we can continue
389 local operator test value
392 lt) operator="-lt"; shift;;
393 gt) operator="-gt"; shift;;
394 le) operator="-le"; shift;;
395 ge) operator="-ge"; shift;;
396 eq) operator="-eq"; shift;;
399 [[ $# -gt 3 ]] && die "Error in kernel-2_kernel_is(): too many parameters"
401 : $(( test = (KV_MAJOR << 16) + (KV_MINOR << 8) + KV_PATCH ))
402 : $(( value = (${1:-${KV_MAJOR}} << 16) + (${2:-${KV_MINOR}} << 8) + ${3:-${KV_PATCH}} ))
403 [ ${test} ${operator} ${value} ]
409 local shopt_save=$(shopt -p nullglob)
411 local files=( ${1}/localversion* )
414 # ignore files with ~ in it.
415 for i in "${files[@]}"; do
416 [[ -n ${i//*~*} ]] && lv_list="${lv_list} ${i}"
419 for i in ${lv_list}; do
426 # Check if the Makefile is valid for direct parsing.
427 # Check status results:
428 # - PASS, use 'getfilevar' to extract values
429 # - FAIL, use 'getfilevar_noexec' to extract values
430 # The check may fail if:
431 # - make is not present
432 # - corruption exists in the kernel makefile
433 get_makefile_extract_function() {
434 local a='' b='' mkfunc='getfilevar'
435 a="$(getfilevar VERSION ${KERNEL_MAKEFILE})"
436 b="$(getfilevar_noexec VERSION ${KERNEL_MAKEFILE})"
437 [[ "${a}" != "${b}" ]] && mkfunc='getfilevar_noexec'
441 # internal variable, so we know to only print the warning once
442 get_version_warning_done=
444 # @FUNCTION: get_version
446 # It gets the version of the kernel inside KERNEL_DIR and populates the KV_FULL variable
447 # (if KV_FULL is already set it does nothing).
449 # The kernel version variables (KV_MAJOR, KV_MINOR, KV_PATCH, KV_EXTRA and KV_LOCAL) are also set.
451 # The KV_DIR is set using the KERNEL_DIR env var, the KV_DIR_OUT is set using a valid
452 # KBUILD_OUTPUT (in a decreasing priority list, we look for the env var, makefile var or the
453 # symlink /lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}/build).
455 if ! use kernel_linux; then
456 die "${FUNCNAME}() called on non-Linux system, please fix the ebuild"
461 # no need to execute this twice assuming KV_FULL is populated.
462 # we can force by unsetting KV_FULL
463 [ -n "${KV_FULL}" ] && return 0
465 # if we dont know KV_FULL, then we need too.
466 # make sure KV_DIR isnt set since we need to work it out via KERNEL_DIR
469 # KV_DIR will contain the full path to the sources directory we should use
470 [ -z "${get_version_warning_done}" ] && \
471 qeinfo "Determining the location of the kernel source code"
472 [ -d "${KERNEL_DIR}" ] && KV_DIR="${KERNEL_DIR}"
474 if [ -z "${KV_DIR}" ]
476 if [ -z "${get_version_warning_done}" ]; then
477 get_version_warning_done=1
478 qewarn "Unable to find kernel sources at ${KERNEL_DIR}"
479 #qeinfo "This package requires Linux sources."
480 if [ "${KERNEL_DIR}" == "/usr/src/linux" ] ; then
481 qeinfo "Please make sure that ${KERNEL_DIR} points at your running kernel, "
482 qeinfo "(or the kernel you wish to build against)."
483 qeinfo "Alternatively, set the KERNEL_DIR environment variable to the kernel sources location"
485 qeinfo "Please ensure that the KERNEL_DIR environment variable points at full Linux sources of the kernel you wish to compile against."
491 # See if the kernel dir is actually an output dir. #454294
492 if [ -z "${KBUILD_OUTPUT}" -a -L "${KERNEL_DIR}/source" ]; then
493 KBUILD_OUTPUT=${KERNEL_DIR}
494 KERNEL_DIR=$(readlink -f "${KERNEL_DIR}/source")
498 if [ -z "${get_version_warning_done}" ]; then
499 qeinfo "Found kernel source directory:"
503 if [ ! -s "${KV_DIR}/Makefile" ]
505 if [ -z "${get_version_warning_done}" ]; then
506 get_version_warning_done=1
507 qeerror "Could not find a Makefile in the kernel source directory."
508 qeerror "Please ensure that ${KERNEL_DIR} points to a complete set of Linux sources"
513 # OK so now we know our sources directory, but they might be using
514 # KBUILD_OUTPUT, and we need this for .config and localversions-*
515 # so we better find it eh?
516 # do we pass KBUILD_OUTPUT on the CLI?
517 local OUTPUT_DIR=${KBUILD_OUTPUT}
520 KERNEL_MAKEFILE="${KV_DIR}/Makefile"
522 if [[ -z ${OUTPUT_DIR} ]]; then
523 # Decide the function used to extract makefile variables.
524 local mkfunc=$(get_makefile_extract_function "${KERNEL_MAKEFILE}")
526 # And if we didn't pass it, we can take a nosey in the Makefile.
527 OUTPUT_DIR=$(${mkfunc} KBUILD_OUTPUT "${KERNEL_MAKEFILE}")
530 # And contrary to existing functions I feel we shouldn't trust the
531 # directory name to find version information as this seems insane.
532 # So we parse ${KERNEL_MAKEFILE}. We should be able to trust that
533 # the Makefile is simple enough to use the noexec extract function.
534 # This has been true for every release thus far, and it's faster
535 # than using make to evaluate the Makefile every time.
536 KV_MAJOR=$(getfilevar_noexec VERSION "${KERNEL_MAKEFILE}")
537 KV_MINOR=$(getfilevar_noexec PATCHLEVEL "${KERNEL_MAKEFILE}")
538 KV_PATCH=$(getfilevar_noexec SUBLEVEL "${KERNEL_MAKEFILE}")
539 KV_EXTRA=$(getfilevar_noexec EXTRAVERSION "${KERNEL_MAKEFILE}")
541 if [ -z "${KV_MAJOR}" -o -z "${KV_MINOR}" -o -z "${KV_PATCH}" ]
543 if [ -z "${get_version_warning_done}" ]; then
544 get_version_warning_done=1
545 qeerror "Could not detect kernel version."
546 qeerror "Please ensure that ${KERNEL_DIR} points to a complete set of Linux sources."
551 [ -d "${OUTPUT_DIR}" ] && KV_OUT_DIR="${OUTPUT_DIR}"
552 if [ -n "${KV_OUT_DIR}" ];
554 qeinfo "Found kernel object directory:"
555 qeinfo " ${KV_OUT_DIR}"
557 # and if we STILL have not got it, then we better just set it to KV_DIR
558 KV_OUT_DIR="${KV_OUT_DIR:-${KV_DIR}}"
560 # Grab the kernel release from the output directory.
561 # TODO: we MUST detect kernel.release being out of date, and 'return 1' from
563 if [ -s "${KV_OUT_DIR}"/include/config/kernel.release ]; then
564 KV_LOCAL=$(<"${KV_OUT_DIR}"/include/config/kernel.release)
565 elif [ -s "${KV_OUT_DIR}"/.kernelrelease ]; then
566 KV_LOCAL=$(<"${KV_OUT_DIR}"/.kernelrelease)
571 # KV_LOCAL currently contains the full release; discard the first bits.
572 tmplocal=${KV_LOCAL#${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}}
574 # If the updated local version was not changed, the tree is not prepared.
575 # Clear out KV_LOCAL in that case.
576 # TODO: this does not detect a change in the localversion part between
577 # kernel.release and the value that would be generated.
578 if [ "$KV_LOCAL" = "$tmplocal" ]; then
584 # and in newer versions we can also pull LOCALVERSION if it is set.
585 # but before we do this, we need to find if we use a different object directory.
586 # This *WILL* break if the user is using localversions, but we assume it was
587 # caught before this if they are.
588 if [[ -z ${OUTPUT_DIR} ]] ; then
589 # Try to locate a kernel that is most relevant for us.
590 for OUTPUT_DIR in "${SYSROOT}" "${ROOT%/}" "" ; do
591 OUTPUT_DIR+="/lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}${KV_LOCAL}/build"
592 if [[ -e ${OUTPUT_DIR} ]] ; then
598 # And we should set KV_FULL to the full expanded version
599 KV_FULL="${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}${KV_LOCAL}"
601 qeinfo "Found sources for kernel version:"
607 # @FUNCTION: get_running_version
609 # It gets the version of the current running kernel and the result is the same as get_version() if the
610 # function can find the sources.
611 get_running_version() {
612 if ! use kernel_linux; then
613 die "${FUNCNAME}() called on non-Linux system, please fix the ebuild"
618 if [[ -f ${ROOT%/}/lib/modules/${KV_FULL}/source/Makefile && -f ${ROOT%/}/lib/modules/${KV_FULL}/build/Makefile ]]; then
619 KERNEL_DIR=$(readlink -f ${ROOT%/}/lib/modules/${KV_FULL}/source)
620 KBUILD_OUTPUT=$(readlink -f ${ROOT%/}/lib/modules/${KV_FULL}/build)
624 elif [[ -f ${ROOT%/}/lib/modules/${KV_FULL}/source/Makefile ]]; then
625 KERNEL_DIR=$(readlink -f ${ROOT%/}/lib/modules/${KV_FULL}/source)
629 elif [[ -f ${ROOT%/}/lib/modules/${KV_FULL}/build/Makefile ]]; then
630 KERNEL_DIR=$(readlink -f ${ROOT%/}/lib/modules/${KV_FULL}/build)
635 # This handles a variety of weird kernel versions. Make sure to update
636 # tests/linux-info_get_running_version.sh if you want to change this.
637 local kv_full=${KV_FULL//[-+_]*}
638 KV_MAJOR=$(ver_cut 1 ${kv_full})
639 KV_MINOR=$(ver_cut 2 ${kv_full})
640 KV_PATCH=$(ver_cut 3 ${kv_full})
641 KV_EXTRA="${KV_FULL#${KV_MAJOR}.${KV_MINOR}${KV_PATCH:+.${KV_PATCH}}}"
647 # This next function is named with the eclass prefix to avoid conflicts with
648 # some old versionator-like eclass functions.
650 # @FUNCTION: linux-info_get_any_version
652 # This attempts to find the version of the sources, and otherwise falls back to
653 # the version of the running kernel.
654 linux-info_get_any_version() {
655 if ! use kernel_linux; then
656 die "${FUNCNAME}() called on non-Linux system, please fix the ebuild"
659 if ! get_version; then
660 ewarn "Unable to calculate Linux Kernel version for build, attempting to use running version"
661 if ! get_running_version; then
662 die "Unable to determine any Linux Kernel version, please report a bug"
668 # ebuild check functions
669 # ---------------------------------------
671 # @FUNCTION: check_kernel_built
673 # This function verifies that the current kernel sources have been already prepared otherwise it dies.
674 check_kernel_built() {
675 if ! use kernel_linux; then
676 die "${FUNCNAME}() called on non-Linux system, please fix the ebuild"
679 # if we haven't determined the version yet, we need to
680 require_configured_kernel
683 if kernel_is -ge 3 7; then
684 versionh_path="include/generated/uapi/linux/version.h"
686 versionh_path="include/linux/version.h"
689 if [ ! -f "${KV_OUT_DIR}/${versionh_path}" ]
691 eerror "These sources have not yet been prepared."
692 eerror "We cannot build against an unprepared tree."
693 eerror "To resolve this, please type the following:"
695 eerror "# cd ${KV_DIR}"
696 eerror "# make oldconfig"
697 eerror "# make modules_prepare"
699 eerror "Then please try merging this module again."
700 die "Kernel sources need compiling first"
704 # @FUNCTION: check_modules_supported
706 # This function verifies that the current kernel support modules (it checks CONFIG_MODULES=y) otherwise it dies.
707 check_modules_supported() {
708 if ! use kernel_linux; then
709 die "${FUNCNAME}() called on non-Linux system, please fix the ebuild"
712 # if we haven't determined the version yet, we need too.
713 require_configured_kernel
715 if ! linux_chkconfig_builtin "MODULES"; then
716 eerror "These sources do not support loading external modules."
717 eerror "to be able to use this module please enable \"Loadable modules support\""
718 eerror "in your kernel, recompile and then try merging this module again."
719 die "No support for external modules in ${KV_FULL} config"
723 # @FUNCTION: check_extra_config
725 # It checks the kernel config options specified by CONFIG_CHECK. It dies only when a required config option (i.e.
726 # the prefix ~ is not used) doesn't satisfy the directive. Ignored on non-Linux systems.
727 check_extra_config() {
728 use kernel_linux || return
730 local config negate die error reworkmodulenames
731 local soft_errors_count=0 hard_errors_count=0 config_required=0
732 # store the value of the QA check, because otherwise we won't catch usages
733 # after if check_extra_config is called AND other direct calls are done
735 local old_LINUX_CONFIG_EXISTS_DONE="${_LINUX_CONFIG_EXISTS_DONE}"
737 # if we haven't determined the version yet, we need to
738 linux-info_get_any_version
740 # Determine if we really need a .config. The only time when we don't need
741 # one is when all of the CONFIG_CHECK options are prefixed with "~".
742 for config in ${CONFIG_CHECK}; do
743 if [[ "${config:0:1}" != "~" ]]; then
749 if [[ ${config_required} == 0 ]]; then
750 # In the case where we don't require a .config, we can now bail out
751 # if the user has no .config as there is nothing to do. Otherwise
752 # code later will cause a failure due to missing .config.
753 if ! linux_config_exists; then
754 ewarn "Unable to check for the following kernel config options due"
755 ewarn "to absence of any configured kernel sources or compiled"
757 for config in ${CONFIG_CHECK}; do
760 local_error="ERROR_${config}"
761 msg="${!local_error}"
762 if [[ -z ${msg} ]]; then
763 local_error="WARNING_${config}"
764 msg="${!local_error}"
766 ewarn " - ${config}${msg:+ - }${msg}"
768 ewarn "You're on your own to make sure they are set if needed."
769 export LINUX_CONFIG_EXISTS_DONE="${old_LINUX_CONFIG_EXISTS_DONE}"
773 require_configured_kernel
776 einfo "Checking for suitable kernel configuration options..."
778 for config in ${CONFIG_CHECK}
780 # if we specify any fatal, ensure we honor them
786 if [[ ${config:0:1} == "~" ]]; then
789 elif [[ ${config:0:1} == "@" ]]; then
794 if [[ ${config:0:1} == "!" ]]; then
799 if [[ ${negate} == 1 ]]; then
800 linux_chkconfig_present ${config} && error=2
801 elif [[ ${reworkmodulenames} == 1 ]]; then
802 local temp_config="${config//*:}" i n
803 config="${config//:*}"
804 if linux_chkconfig_present ${config}; then
805 for i in ${MODULE_NAMES}; do
806 n="${i//${temp_config}}"
807 [[ -z ${n//\(*} ]] && \
808 MODULE_IGNORE="${MODULE_IGNORE} ${temp_config}"
813 linux_chkconfig_present ${config} || error=1
816 if [[ ${error} -gt 0 ]]; then
817 local report_func="eerror" local_error
818 local_error="ERROR_${config}"
819 local_error="${!local_error}"
821 if [[ -z "${local_error}" ]]; then
822 # using old, deprecated format.
823 local_error="${config}_ERROR"
824 local_error="${!local_error}"
826 if [[ ${die} == 0 && -z "${local_error}" ]]; then
827 #soft errors can be warnings
828 local_error="WARNING_${config}"
829 local_error="${!local_error}"
830 if [[ -n "${local_error}" ]] ; then
835 if [[ -z "${local_error}" ]]; then
836 [[ ${error} == 1 ]] \
837 && local_error="is not set when it should be." \
838 || local_error="should not be set. But it is."
839 local_error="CONFIG_${config}:\t ${local_error}"
841 if [[ ${die} == 0 ]]; then
842 ${report_func} " ${local_error}"
843 soft_errors_count=$[soft_errors_count + 1]
845 ${report_func} " ${local_error}"
846 hard_errors_count=$[hard_errors_count + 1]
851 if [[ ${hard_errors_count} -gt 0 ]]; then
852 eerror "Please check to make sure these options are set correctly."
853 eerror "Failure to do so may cause unexpected problems."
854 eerror "Once you have satisfied these options, please try merging"
855 eerror "this package again."
856 export LINUX_CONFIG_EXISTS_DONE="${old_LINUX_CONFIG_EXISTS_DONE}"
857 die "Incorrect kernel configuration options"
858 elif [[ ${soft_errors_count} -gt 0 ]]; then
859 ewarn "Please check to make sure these options are set correctly."
860 ewarn "Failure to do so may cause unexpected problems."
864 export LINUX_CONFIG_EXISTS_DONE="${old_LINUX_CONFIG_EXISTS_DONE}"
867 check_zlibinflate() {
868 if ! use kernel_linux; then
869 die "${FUNCNAME}() called on non-Linux system, please fix the ebuild"
872 # if we haven't determined the version yet, we need to
873 require_configured_kernel
875 # although I restructured this code - I really really really dont support it!
877 # bug #27882 - zlib routines are only linked into the kernel
878 # if something compiled into the kernel calls them
880 # plus, for the cloop module, it appears that there's no way
881 # to get cloop.o to include a static zlib if CONFIG_MODVERSIONS
887 einfo "Determining the usability of ZLIB_INFLATE support in your kernel"
889 ebegin "checking ZLIB_INFLATE"
890 linux_chkconfig_builtin CONFIG_ZLIB_INFLATE
893 ebegin "checking ZLIB_DEFLATE"
894 linux_chkconfig_builtin CONFIG_ZLIB_DEFLATE
902 LINENO_END="$(grep -n 'CONFIG_ZLIB_INFLATE y' ${KV_DIR}/lib/Config.in | cut -d : -f 1)"
903 LINENO_START="$(head -n $LINENO_END ${KV_DIR}/lib/Config.in | grep -n 'if \[' | tail -n 1 | cut -d : -f 1)"
904 (( LINENO_AMOUNT = $LINENO_END - $LINENO_START ))
905 (( LINENO_END = $LINENO_END - 1 ))
906 SYMBOLS="$(head -n $LINENO_END ${KV_DIR}/lib/Config.in | tail -n $LINENO_AMOUNT | sed -e 's/^.*\(CONFIG_[^\" ]*\).*/\1/g;')"
908 # okay, now we have a list of symbols
909 # we need to check each one in turn, to see whether it is set or not
910 for x in $SYMBOLS ; do
911 if [ "${!x}" = "y" ]; then
913 einfo "${x} ensures zlib is linked into your kernel - excellent"
919 eerror "This kernel module requires ZLIB library support."
920 eerror "You have enabled zlib support in your kernel, but haven't enabled"
921 eerror "enabled any option that will ensure that zlib is linked into your"
924 eerror "Please ensure that you enable at least one of these options:"
927 for x in $SYMBOLS ; do
932 eerror "Please remember to recompile and install your kernel, and reboot"
933 eerror "into your new kernel before attempting to load this kernel module."
935 die "Kernel doesn't include zlib support"
938 ################################
940 # Also used when inheriting linux-mod to force a get_version call
941 # @FUNCTION: linux-info_pkg_setup
943 # Force a get_version() call when inherited from linux-mod.eclass and then check if the kernel is configured
944 # to support the options specified in CONFIG_CHECK (if not null)
945 linux-info_pkg_setup() {
946 use kernel_linux || return
948 linux-info_get_any_version
950 if kernel_is 2 4; then
951 if [ "$( gcc-major-version )" -eq "4" ] ; then
953 ewarn "Be warned !! >=sys-devel/gcc-4.0.0 isn't supported with"
954 ewarn "linux-2.4 (or modules building against a linux-2.4 kernel)!"
956 ewarn "Either switch to another gcc-version (via gcc-config) or use a"
957 ewarn "newer kernel that supports gcc-4."
959 ewarn "Also be aware that bugreports about gcc-4 not working"
960 ewarn "with linux-2.4 based ebuilds will be closed as INVALID!"
965 [ -n "${CONFIG_CHECK}" ] && check_extra_config;