gentoo-x86/eclass/linux-mod.eclass

# Copyright 1999-2004 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/eclass/linux-mod.eclass,v 1.76 2007/10/03 12:55:18 phreak Exp $

# Description: This eclass is used to interface with linux-info in such a way
#              to provide the functionality required and initial functions
#                          required to install external modules against a kernel source
#                          tree.
#
# Author(s): John Mylchreest <johnm@gentoo.org>,
#            Stefan Schweizer <genstef@gentoo.org>
# Maintainer: kernel-misc@gentoo.org
#
# 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          Default         Description
# KERNEL_DIR            <string>        /usr/src/linux  The directory containing kernel
#                                                       the target kernel sources.
# ECONF_PARAMS          <string>                        The parameters to pass to econf.
#                                                       If this is not set, then econf
#                                                       isn't run.
# BUILD_PARAMS          <string>                        The parameters to pass to emake.
# BUILD_TARGETS         <string>        clean modules   The build targets to pass to
#                                                       make.
# MODULE_NAMES          <string>                        This is the modules which are
#                                                       to be built automatically using
#                                                       the default pkg_compile/install.
#                                                       They are explained properly
#                                                       below. It will only make
#                                                       BUILD_TARGETS once in any
#                                                       directory.

# MODULE_NAMES - Detailed Overview
#
# The structure of each MODULE_NAMES entry is as follows:
# modulename(libdir:srcdir:objdir)
# for example:
# MODULE_NAMES="module_pci(pci:${S}/pci:${S}) module_usb(usb:${S}/usb:${S})"
#
# what this would do is
#  cd ${S}/pci
#  make ${BUILD_PARAMS} ${BUILD_TARGETS}
#  cd ${S}
#  insinto /lib/modules/${KV_FULL}/pci
#  doins module_pci.${KV_OBJ}
#
#  cd ${S}/usb
#  make ${BUILD_PARAMS} ${BUILD_TARGETS}
#  cd ${S}
#  insinto /lib/modules/${KV_FULL}/usb
#  doins module_usb.${KV_OBJ}
#
# if the srcdir isnt specified, it assumes ${S}
# if the libdir isnt specified, it assumes misc.
# if the objdir isnt specified, it assumes srcdir

# There is also support for automatyed modules.d file generation.
# This can be explicitly enabled by setting any of the following variables.
#
#
# MODULESD_${modulename}_ENABLED                This enables the modules.d file
#                                               generation even if we dont
#                                               specify any additional info.
# MODULESD_${modulename}_EXAMPLES               This is a bash array containing
#                                               a list of examples which should
#                                               be used. If you want us to try and
#                                               take a guess. Set this to "guess"
# MODULESD_${modulename}_ALIASES                This is a bash array containing
#                                               a list of associated aliases.
# MODULESD_${modulename}_ADDITIONS              This is a bash array containing
#                                               A list of additional things to
#                                               add to the bottom of the file.
#                                               This can be absolutely anything.
#                                               Each entry is a new line.
# MODULES_${modulename}_DOCS                    This is a string list which contains
#                                               the full path to any associated
#                                               documents for $modulename

# The order of these is important as both of linux-info and eutils contain
# set_arch_to_kernel and set_arch_to_portage functions and the ones in eutils
# are deprecated in favor of the ones in linux-info.
# See http://bugs.gentoo.org/show_bug.cgi?id=127506

inherit eutils linux-info multilib
EXPORT_FUNCTIONS pkg_setup pkg_preinst pkg_postinst src_install src_compile pkg_postrm

IUSE="kernel_linux"
SLOT="0"
DESCRIPTION="Based on the $ECLASS eclass"
RDEPEND="kernel_linux? ( virtual/modutils )"
DEPEND="${RDEPEND}
        sys-apps/sed"

# eclass utilities
# ----------------------------------

check_vermagic() {
        debug-print-function ${FUNCNAME} $*

        local curr_gcc_ver=$(gcc -dumpversion)
        local tmpfile old_chost old_gcc_ver result=0

        tmpfile=`find ${KV_DIR}/ -iname "*.o.cmd" -exec grep usr/lib/gcc {} \; -quit`
        tmpfile=${tmpfile//*usr/lib}
        tmpfile=${tmpfile//\/include*}
        old_chost=${tmpfile//*gcc\/}
        old_chost=${old_chost//\/*}
        old_gcc_ver=${tmpfile//*\/}

        if [[ -z ${old_gcc_ver} || -z ${old_chost} ]]; then
                ewarn ""
                ewarn "Unable to detect what version of GCC was used to compile"
                ewarn "the kernel. Build will continue, but you may experience problems."
        elif [[ ${curr_gcc_ver} != ${old_gcc_ver} ]]; then
                ewarn ""
                ewarn "The version of GCC you are using (${curr_gcc_ver}) does"
                ewarn "not match the version of GCC used to compile the"
                ewarn "kernel (${old_gcc_ver})."
                result=1
        elif [[ ${CHOST} != ${old_chost} ]]; then
                ewarn ""
                ewarn "The current CHOST (${CHOST}) does not match the chost"
                ewarn "used when compiling the kernel (${old_chost})."
                result=1
        fi

        if [[ ${result} -gt 0 ]]; then
                ewarn ""
                ewarn "Build will not continue, because you will experience problems."
                ewarn "To fix this either change the version of GCC you wish to use"
                ewarn "to match the kernel, or recompile the kernel first."
                die "GCC Version Mismatch."
        fi
}

use_m() {
        debug-print-function ${FUNCNAME} $*

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

        # if the kernel version is greater than 2.6.6 then we should use
        # M= instead of SUBDIRS=
        [ ${KV_MAJOR} -eq 2 -a ${KV_MINOR} -gt 5 -a ${KV_PATCH} -gt 5 ] && \
                return 0 || return 1
}

convert_to_m() {
        debug-print-function ${FUNCNAME} $*

        if use_m
        then
                [ ! -f "${1}" ] && \
                        die "convert_to_m() requires a filename as an argument"
                ebegin "Converting ${1/${WORKDIR}\//} to use M= instead of SUBDIRS="
                sed -i 's:SUBDIRS=:M=:g' ${1}
                eend $?
        fi
}

update_depmod() {
        debug-print-function ${FUNCNAME} $*

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

        ebegin "Updating module dependencies for ${KV_FULL}"
        if [ -r ${KV_OUT_DIR}/System.map ]
        then
                depmod -ae -F ${KV_OUT_DIR}/System.map -b ${ROOT} -r ${KV_FULL}
                eend $?
        else
                ewarn
                ewarn "${KV_OUT_DIR}/System.map not found."
                ewarn "You must manually update the kernel module dependencies using depmod."
                eend 1
                ewarn
        fi
}

update_modules() {
        debug-print-function ${FUNCNAME} $*

        if [ -x /sbin/update-modules ] && \
                grep -v -e "^#" -e "^$" ${D}/etc/modules.d/* >/dev/null 2>&1; then
                ebegin "Updating modules.conf"
                /sbin/update-modules
                eend $?
        elif [ -x /sbin/update-modules ] && \
                grep -v -e "^#" -e "^$" ${D}/etc/modules.d/* >/dev/null 2>&1; then
                ebegin "Updating modules.conf"
                /sbin/update-modules
                eend $?
        fi
}

move_old_moduledb() {
        debug-print-function ${FUNCNAME} $*

        local OLDDIR=${ROOT}/usr/share/module-rebuild/
        local NEWDIR=${ROOT}/var/lib/module-rebuild/

        if [[ -f ${OLDDIR}/moduledb ]]; then
                [[ ! -d ${NEWDIR} ]] && mkdir -p ${NEWDIR}
                [[ ! -f ${NEWDIR}/moduledb ]] && \
                        mv ${OLDDIR}/moduledb ${NEWDIR}/moduledb
                rm -f ${OLDDIR}/*
                rmdir ${OLDDIR}
        fi
}

update_moduledb() {
        debug-print-function ${FUNCNAME} $*

        local MODULEDB_DIR=${ROOT}/var/lib/module-rebuild/
        move_old_moduledb

        if [[ ! -f ${MODULEDB_DIR}/moduledb ]]; then
                [[ ! -d ${MODULEDB_DIR} ]] && mkdir -p ${MODULEDB_DIR}
                touch ${MODULEDB_DIR}/moduledb
        fi

        if ! grep -qs ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb ; then
                einfo "Adding module to moduledb."
                echo "a:1:${CATEGORY}/${PN}-${PVR}" >> ${MODULEDB_DIR}/moduledb
        fi
}

remove_moduledb() {
        debug-print-function ${FUNCNAME} $*

        local MODULEDB_DIR=${ROOT}/var/lib/module-rebuild/
        move_old_moduledb

        if grep -qs ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb ; then
                einfo "Removing ${CATEGORY}/${PN}-${PVR} from moduledb."
                sed -i -e "/.*${CATEGORY}\/${PN}-${PVR}.*/d" ${MODULEDB_DIR}/moduledb
        fi
}

set_kvobj() {
        debug-print-function ${FUNCNAME} $*

        if kernel_is 2 6
        then
                KV_OBJ="ko"
        else
                KV_OBJ="o"
        fi
        # Do we really need to know this?
        # Lets silence it.
        # einfo "Using KV_OBJ=${KV_OBJ}"
}

get-KERNEL_CC() {
        debug-print-function ${FUNCNAME} $*

        local kernel_cc
        if [ -n "${KERNEL_ABI}" ]; then
                # In future, an arch might want to define CC_$ABI
                #kernel_cc="$(get_abi_CC)"
                #[ -z "${kernel_cc}" ] &&
                kernel_cc="$(tc-getCC $(ABI=${KERNEL_ABI} get_abi_CHOST))"
        else
                kernel_cc=$(tc-getCC)
        fi
        echo "${kernel_cc}"
}

generate_modulesd() {
        debug-print-function ${FUNCNAME} $*

        # This function will generate the neccessary modules.d file from the
        # information contained in the modules exported parms

        local   currm_path currm currm_t t myIFS myVAR
        local   module_docs module_enabled module_aliases \
                        module_additions module_examples module_modinfo module_opts

        for currm_path in ${@}
        do
                currm=${currm_path//*\/}
                currm=$(echo ${currm} | tr '[:lower:]' '[:upper:]')
                currm_t=${currm}
                while [[ -z ${currm_t//*-*} ]]; do
                        currm_t=${currm_t/-/_}
                done

                module_docs="$(eval echo \${MODULESD_${currm_t}_DOCS})"
                module_enabled="$(eval echo \${MODULESD_${currm_t}_ENABLED})"
                module_aliases="$(eval echo \${#MODULESD_${currm_t}_ALIASES[*]})"
                module_additions="$(eval echo \${#MODULESD_${currm_t}_ADDITIONS[*]})"
                module_examples="$(eval echo \${#MODULESD_${currm_t}_EXAMPLES[*]})"

                [[ ${module_aliases} -eq 0 ]]   && unset module_aliases
                [[ ${module_additions} -eq 0 ]] && unset module_additions
                [[ ${module_examples} -eq 0 ]]  && unset module_examples

                # If we specify we dont want it, then lets exit, otherwise we assume
                # that if its set, we do want it.
                [[ ${module_enabled} == no ]] && return 0

                # unset any unwanted variables.
                for t in ${!module_*}
                do
                        [[ -z ${!t} ]] && unset ${t}
                done

                [[ -z ${!module_*} ]] && return 0

                # OK so now if we have got this far, then we know we want to continue
                # and generate the modules.d file.
                module_modinfo="$(modinfo -p ${currm_path}.${KV_OBJ})"
                module_config="${T}/modulesd-${currm}"

                ebegin "Preparing file for modules.d"
                #-----------------------------------------------------------------------
                echo "# modules.d configuration file for ${currm}" >> ${module_config}
                #-----------------------------------------------------------------------
                [[ -n ${module_docs} ]] && \
                        echo "# For more information please read:" >> ${module_config}
                for t in ${module_docs}
                do
                        echo "#    ${t//*\/}" >> ${module_config}
                done
                echo >> ${module_config}

                #-----------------------------------------------------------------------
                if [[ ${module_aliases} -gt 0 ]]
                then
                        echo  "# Internal Aliases - Do not edit" >> ${module_config}
                        echo  "# ------------------------------" >> ${module_config}

                        for((t=0; t<${module_aliases}; t++))
                        do
                                echo "alias $(eval echo \${MODULESD_${currm}_ALIASES[$t]})" \
                                        >> ${module_config}
                        done
                        echo '' >> ${module_config}
                fi

                #-----------------------------------------------------------------------
                if [[ -n ${module_modinfo} ]]
                then
                        echo >> ${module_config}
                        echo  "# Configurable module parameters" >> ${module_config}
                        echo  "# ------------------------------" >> ${module_config}
                        myIFS="${IFS}"
                        IFS="$(echo -en "\n\b")"

                        for t in ${module_modinfo}
                        do
                                myVAR="$(echo ${t#*:} | grep -e " [0-9][ =]" | sed "s:.*\([01][= ]\).*:\1:")"
                                if [[ -n ${myVAR} ]]
                                then
                                        module_opts="${module_opts} ${t%%:*}:${myVAR}"
                                fi
                                echo -e "# ${t%%:*}:\t${t#*:}" >> ${module_config}
                        done
                        IFS="${myIFS}"
                        echo '' >> ${module_config}
                fi

                #-----------------------------------------------------------------------
                if [[ $(eval echo \${MODULESD_${currm}_ALIASES[0]}) == guess ]]
                then
                        # So lets do some guesswork eh?
                        if [[ -n ${module_opts} ]]
                        then
                                echo "# For Example..." >> ${module_config}
                                echo "# --------------" >> ${module_config}
                                for t in ${module_opts}
                                do
                                        echo "# options ${currm} ${t//:*}=${t//*:}" >> ${module_config}
                                done
                                echo '' >> ${module_config}
                        fi
                elif [[ ${module_examples} -gt 0 ]]
                then
                        echo "# For Example..." >> ${module_config}
                        echo "# --------------" >> ${module_config}
                        for((t=0; t<${module_examples}; t++))
                        do
                                echo "options $(eval echo \${MODULESD_${currm}_EXAMPLES[$t]})" \
                                        >> ${module_config}
                        done
                        echo '' >> ${module_config}
                fi

                #-----------------------------------------------------------------------
                if [[ ${module_additions} -gt 0 ]]
                then
                        for((t=0; t<${module_additions}; t++))
                        do
                                echo "$(eval echo \${MODULESD_${currm}_ADDITIONS[$t]})" \
                                        >> ${module_config}
                        done
                        echo '' >> ${module_config}
                fi

                #-----------------------------------------------------------------------

                # then we install it
                insinto /etc/modules.d
                newins ${module_config} ${currm_path//*\/}

                # and install any documentation we might have.
                [[ -n ${module_docs} ]] && dodoc ${module_docs}
        done
        eend 0
        return 0
}

find_module_params() {
        debug-print-function ${FUNCNAME} $*

        local matched_offset=0 matched_opts=0 test="${@}" temp_var result
        local i=0 y=0 z=0

        for((i=0; i<=${#test}; i++))
        do
                case ${test:${i}:1} in
                        \()             matched_offset[0]=${i};;
                        \:)             matched_opts=$((${matched_opts} + 1));
                                        matched_offset[${matched_opts}]="${i}";;
                        \))             matched_opts=$((${matched_opts} + 1));
                                        matched_offset[${matched_opts}]="${i}";;
                esac
        done

        for((i=0; i<=${matched_opts}; i++))
        do
                # i                     = offset were working on
                # y                     = last offset
                # z                     = current offset - last offset
                # temp_var      = temporary name
                case ${i} in
                        0)      tempvar=${test:0:${matched_offset[0]}};;
                        *)      y=$((${matched_offset[$((${i} - 1))]} + 1))
                                z=$((${matched_offset[${i}]} - ${matched_offset[$((${i} - 1))]}));
                                z=$((${z} - 1))
                                tempvar=${test:${y}:${z}};;
                esac

                case ${i} in
                        0)      result="${result} modulename:${tempvar}";;
                        1)      result="${result} libdir:${tempvar}";;
                        2)      result="${result} srcdir:${tempvar}";;
                        3)      result="${result} objdir:${tempvar}";;
                esac
        done

        echo ${result}
}

# default ebuild functions
# --------------------------------

linux-mod_pkg_setup() {
        debug-print-function ${FUNCNAME} $*

        linux-info_pkg_setup;
        check_kernel_built;
        strip_modulenames;
        [[ -n ${MODULE_NAMES} ]] && check_modules_supported
        set_kvobj;
        # Commented out with permission from johnm until a fixed version for arches
        # who intentionally use different kernel and userland compilers can be
        # introduced - Jason Wever <weeve@gentoo.org>, 23 Oct 2005
        #check_vermagic;
}

strip_modulenames() {
        debug-print-function ${FUNCNAME} $*

        local i
        for i in ${MODULE_IGNORE}; do
                MODULE_NAMES=${MODULE_NAMES//${i}(*}
        done
}

linux-mod_src_compile() {
        debug-print-function ${FUNCNAME} $*

        local modulename libdir srcdir objdir i n myARCH="${ARCH}" myABI="${ABI}"
        ARCH="$(tc-arch-kernel)"
        ABI="${KERNEL_ABI}"

        BUILD_TARGETS=${BUILD_TARGETS:-clean module}
        strip_modulenames;
        cd "${S}"
        for i in ${MODULE_NAMES}
        do
                unset libdir srcdir objdir
                for n in $(find_module_params ${i})
                do
                        eval ${n/:*}=${n/*:/}
                done
                libdir=${libdir:-misc}
                srcdir=${srcdir:-${S}}
                objdir=${objdir:-${srcdir}}

                if [ ! -f "${srcdir}/.built" ];
                then
                        cd ${srcdir}
                        einfo "Preparing ${modulename} module"
                        if [[ -n ${ECONF_PARAMS} ]]
                        then
                                econf ${ECONF_PARAMS} || \
                                die "Unable to run econf ${ECONF_PARAMS}"
                        fi

                        emake HOSTCC="$(tc-getBUILD_CC)" CC="$(get-KERNEL_CC)" LDFLAGS="$(get_abi_LDFLAGS)" \
                                  ${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS} \
                                || die "Unable to make ${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS}."
                        touch ${srcdir}/.built
                        cd ${OLDPWD}
                fi
        done

        ARCH="${myARCH}"
        ABI="${myABI}"
}

linux-mod_src_install() {
        debug-print-function ${FUNCNAME} $*

        local modulename libdir srcdir objdir i n

        strip_modulenames;
        for i in ${MODULE_NAMES}
        do
                unset libdir srcdir objdir
                for n in $(find_module_params ${i})
                do
                        eval ${n/:*}=${n/*:/}
                done
                libdir=${libdir:-misc}
                srcdir=${srcdir:-${S}}
                objdir=${objdir:-${srcdir}}

                einfo "Installing ${modulename} module"
                cd ${objdir} || die "${objdir} does not exist"
                insinto /lib/modules/${KV_FULL}/${libdir}
                doins ${modulename}.${KV_OBJ} || die "doins ${modulename}.${KV_OBJ} failed"
                cd ${OLDPWD}

                generate_modulesd ${objdir}/${modulename}
        done
}

linux-mod_pkg_preinst() {
        debug-print-function ${FUNCNAME} $*

        [ -d "${D}lib/modules" ] && UPDATE_DEPMOD=true || UPDATE_DEPMOD=false
        [ -d "${D}etc/modules.d" ] && UPDATE_MODULES=true || UPDATE_MODULES=false
        [ -d "${D}lib/modules" ] && UPDATE_MODULEDB=true || UPDATE_MODULEDB=false
}

linux-mod_pkg_postinst() {
        debug-print-function ${FUNCNAME} $*

        ${UPDATE_DEPMOD} && update_depmod;
        ${UPDATE_MODULES} && update_modules;
        ${UPDATE_MODULEDB} && update_moduledb;
}

linux-mod_pkg_postrm() {
        debug-print-function ${FUNCNAME} $*
        remove_moduledb;
}
1	johnm	1.1	# Copyright 1999-2004 Gentoo Foundation
2			# Distributed under the terms of the GNU General Public License v2
3	zmedico	1.77	# $Header: /var/cvsroot/gentoo-x86/eclass/linux-mod.eclass,v 1.76 2007/10/03 12:55:18 phreak Exp $
4	johnm	1.1
5	johnm	1.10	# Description: This eclass is used to interface with linux-info in such a way
6			# to provide the functionality required and initial functions
7			# required to install external modules against a kernel source
8			# tree.
9			#
10	phreak	1.75	# Author(s): John Mylchreest <johnm@gentoo.org>,
11			# Stefan Schweizer <genstef@gentoo.org>
12			# Maintainer: kernel-misc@gentoo.org
13	johnm	1.10	#
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.49	#
19	johnm	1.26	# Env Var Option Default Description
20			# KERNEL_DIR <string> /usr/src/linux The directory containing kernel
21			# the target kernel sources.
22			# ECONF_PARAMS <string> The parameters to pass to econf.
23			# If this is not set, then econf
24			# isn't run.
25			# BUILD_PARAMS <string> The parameters to pass to emake.
26			# BUILD_TARGETS <string> clean modules The build targets to pass to
27			# make.
28			# MODULE_NAMES <string> This is the modules which are
29	swegener	1.49	# to be built automatically using
30			# the default pkg_compile/install.
31			# They are explained properly
32			# below. It will only make
33	johnm	1.26	# BUILD_TARGETS once in any
34			# directory.
35	johnm	1.10
36			# MODULE_NAMES - Detailed Overview
37	swegener	1.49	#
38	johnm	1.10	# The structure of each MODULE_NAMES entry is as follows:
39	johnm	1.26	# modulename(libdir:srcdir:objdir)
40	johnm	1.10	# for example:
41	johnm	1.26	# MODULE_NAMES="module_pci(pci:${S}/pci:${S}) module_usb(usb:${S}/usb:${S})"
42	swegener	1.49	#
43	johnm	1.10	# what this would do is
44			# cd ${S}/pci
45			# make ${BUILD_PARAMS} ${BUILD_TARGETS}
46	johnm	1.26	# cd ${S}
47	johnm	1.10	# insinto /lib/modules/${KV_FULL}/pci
48			# doins module_pci.${KV_OBJ}
49			#
50			# cd ${S}/usb
51			# make ${BUILD_PARAMS} ${BUILD_TARGETS}
52	johnm	1.26	# cd ${S}
53	johnm	1.10	# insinto /lib/modules/${KV_FULL}/usb
54			# doins module_usb.${KV_OBJ}
55			#
56	johnm	1.26	# if the srcdir isnt specified, it assumes ${S}
57			# if the libdir isnt specified, it assumes misc.
58			# if the objdir isnt specified, it assumes srcdir
59
60			# There is also support for automatyed modules.d file generation.
61			# This can be explicitly enabled by setting any of the following variables.
62			#
63			#
64			# MODULESD_${modulename}_ENABLED This enables the modules.d file
65			# generation even if we dont
66			# specify any additional info.
67			# MODULESD_${modulename}_EXAMPLES This is a bash array containing
68			# a list of examples which should
69			# be used. If you want us to try and
70			# take a guess. Set this to "guess"
71			# MODULESD_${modulename}_ALIASES This is a bash array containing
72			# a list of associated aliases.
73			# MODULESD_${modulename}_ADDITIONS This is a bash array containing
74			# A list of additional things to
75			# add to the bottom of the file.
76			# This can be absolutely anything.
77			# Each entry is a new line.
78			# MODULES_${modulename}_DOCS This is a string list which contains
79			# the full path to any associated
80			# documents for $modulename
81
82	betelgeuse	1.61	# The order of these is important as both of linux-info and eutils contain
83			# set_arch_to_kernel and set_arch_to_portage functions and the ones in eutils
84			# are deprecated in favor of the ones in linux-info.
85			# See http://bugs.gentoo.org/show_bug.cgi?id=127506
86	johnm	1.1
87	blubb	1.62	inherit eutils linux-info multilib
88	genstef	1.65	EXPORT_FUNCTIONS pkg_setup pkg_preinst pkg_postinst src_install src_compile pkg_postrm
89	johnm	1.1
90	genstef	1.67	IUSE="kernel_linux"
91	johnm	1.26	SLOT="0"
92	johnm	1.1	DESCRIPTION="Based on the $ECLASS eclass"
93	genstef	1.67	RDEPEND="kernel_linux? ( virtual/modutils )"
94	genstef	1.65	DEPEND="${RDEPEND}
95	vapier	1.66	sys-apps/sed"
96	johnm	1.26
97	johnm	1.1	# eclass utilities
98			# ----------------------------------
99
100	johnm	1.53	check_vermagic() {
101	genstef	1.69	debug-print-function ${FUNCNAME} $*
102
103	johnm	1.53	local curr_gcc_ver=$(gcc -dumpversion)
104			local tmpfile old_chost old_gcc_ver result=0
105
106	johnm	1.54	tmpfile=`find ${KV_DIR}/ -iname "*.o.cmd" -exec grep usr/lib/gcc {} \; -quit`
107	johnm	1.53	tmpfile=${tmpfile//*usr/lib}
108			tmpfile=${tmpfile//\/include*}
109			old_chost=${tmpfile//*gcc\/}
110			old_chost=${old_chost//\/*}
111			old_gcc_ver=${tmpfile//*\/}
112
113	johnm	1.54	if [[ -z ${old_gcc_ver} \|\| -z ${old_chost} ]]; then
114			ewarn ""
115			ewarn "Unable to detect what version of GCC was used to compile"
116			ewarn "the kernel. Build will continue, but you may experience problems."
117			elif [[ ${curr_gcc_ver} != ${old_gcc_ver} ]]; then
118	johnm	1.53	ewarn ""
119			ewarn "The version of GCC you are using (${curr_gcc_ver}) does"
120			ewarn "not match the version of GCC used to compile the"
121			ewarn "kernel (${old_gcc_ver})."
122			result=1
123			elif [[ ${CHOST} != ${old_chost} ]]; then
124			ewarn ""
125			ewarn "The current CHOST (${CHOST}) does not match the chost"
126			ewarn "used when compiling the kernel (${old_chost})."
127			result=1
128			fi
129
130			if [[ ${result} -gt 0 ]]; then
131			ewarn ""
132			ewarn "Build will not continue, because you will experience problems."
133			ewarn "To fix this either change the version of GCC you wish to use"
134			ewarn "to match the kernel, or recompile the kernel first."
135			die "GCC Version Mismatch."
136			fi
137			}
138
139	johnm	1.1	use_m() {
140	genstef	1.69	debug-print-function ${FUNCNAME} $*
141
142	johnm	1.1	# if we haven't determined the version yet, we need too.
143			get_version;
144	swegener	1.49
145	johnm	1.1	# if the kernel version is greater than 2.6.6 then we should use
146	johnm	1.8	# M= instead of SUBDIRS=
147	johnm	1.1	[ ${KV_MAJOR} -eq 2 -a ${KV_MINOR} -gt 5 -a ${KV_PATCH} -gt 5 ] && \
148			return 0 \|\| return 1
149			}
150
151			convert_to_m() {
152	genstef	1.69	debug-print-function ${FUNCNAME} $*
153
154	johnm	1.1	if use_m
155			then
156	johnm	1.32	[ ! -f "${1}" ] && \
157			die "convert_to_m() requires a filename as an argument"
158	johnm	1.8	ebegin "Converting ${1/${WORKDIR}\//} to use M= instead of SUBDIRS="
159	johnm	1.1	sed -i 's:SUBDIRS=:M=:g' ${1}
160			eend $?
161			fi
162			}
163
164			update_depmod() {
165	genstef	1.69	debug-print-function ${FUNCNAME} $*
166
167	johnm	1.1	# if we haven't determined the version yet, we need too.
168			get_version;
169	swegener	1.49
170	johnm	1.1	ebegin "Updating module dependencies for ${KV_FULL}"
171	johnm	1.5	if [ -r ${KV_OUT_DIR}/System.map ]
172	johnm	1.1	then
173	johnm	1.5	depmod -ae -F ${KV_OUT_DIR}/System.map -b ${ROOT} -r ${KV_FULL}
174	johnm	1.18	eend $?
175	johnm	1.1	else
176			ewarn
177	johnm	1.5	ewarn "${KV_OUT_DIR}/System.map not found."
178	johnm	1.1	ewarn "You must manually update the kernel module dependencies using depmod."
179	johnm	1.18	eend 1
180	johnm	1.1	ewarn
181			fi
182			}
183
184	johnm	1.3	update_modules() {
185	genstef	1.69	debug-print-function ${FUNCNAME} $*
186
187	genstef	1.73	if [ -x /sbin/update-modules ] && \
188			grep -v -e "^#" -e "^$" ${D}/etc/modules.d/* >/dev/null 2>&1; then
189			ebegin "Updating modules.conf"
190			/sbin/update-modules
191			eend $?
192	vapier	1.74	elif [ -x /sbin/update-modules ] && \
193	kingtaco	1.31	grep -v -e "^#" -e "^$" ${D}/etc/modules.d/* >/dev/null 2>&1; then
194	johnm	1.3	ebegin "Updating modules.conf"
195	vapier	1.74	/sbin/update-modules
196	johnm	1.3	eend $?
197			fi
198			}
199
200	johnm	1.41	move_old_moduledb() {
201	genstef	1.69	debug-print-function ${FUNCNAME} $*
202
203	johnm	1.41	local OLDDIR=${ROOT}/usr/share/module-rebuild/
204			local NEWDIR=${ROOT}/var/lib/module-rebuild/
205	swegener	1.49
206	johnm	1.41	if [[ -f ${OLDDIR}/moduledb ]]; then
207			[[ ! -d ${NEWDIR} ]] && mkdir -p ${NEWDIR}
208	johnm	1.42	[[ ! -f ${NEWDIR}/moduledb ]] && \
209			mv ${OLDDIR}/moduledb ${NEWDIR}/moduledb
210			rm -f ${OLDDIR}/*
211	johnm	1.41	rmdir ${OLDDIR}
212			fi
213			}
214
215	johnm	1.37	update_moduledb() {
216	genstef	1.69	debug-print-function ${FUNCNAME} $*
217
218	johnm	1.40	local MODULEDB_DIR=${ROOT}/var/lib/module-rebuild/
219	johnm	1.41	move_old_moduledb
220	johnm	1.40
221			if [[ ! -f ${MODULEDB_DIR}/moduledb ]]; then
222			[[ ! -d ${MODULEDB_DIR} ]] && mkdir -p ${MODULEDB_DIR}
223			touch ${MODULEDB_DIR}/moduledb
224	johnm	1.37	fi
225	vapier	1.72
226			if ! grep -qs ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb ; then
227	johnm	1.37	einfo "Adding module to moduledb."
228	johnm	1.40	echo "a:1:${CATEGORY}/${PN}-${PVR}" >> ${MODULEDB_DIR}/moduledb
229	swegener	1.49	fi
230	johnm	1.37	}
231
232			remove_moduledb() {
233	genstef	1.69	debug-print-function ${FUNCNAME} $*
234
235	johnm	1.40	local MODULEDB_DIR=${ROOT}/var/lib/module-rebuild/
236	johnm	1.41	move_old_moduledb
237	johnm	1.40
238	vapier	1.72	if grep -qs ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb ; then
239	johnm	1.37	einfo "Removing ${CATEGORY}/${PN}-${PVR} from moduledb."
240	dsd	1.71	sed -i -e "/.${CATEGORY}\/${PN}-${PVR}./d" ${MODULEDB_DIR}/moduledb
241	johnm	1.37	fi
242			}
243
244	johnm	1.1	set_kvobj() {
245	genstef	1.69	debug-print-function ${FUNCNAME} $*
246
247	johnm	1.1	if kernel_is 2 6
248			then
249			KV_OBJ="ko"
250			else
251			KV_OBJ="o"
252			fi
253	johnm	1.26	# Do we really need to know this?
254			# Lets silence it.
255			# einfo "Using KV_OBJ=${KV_OBJ}"
256	johnm	1.1	}
257
258	genstef	1.68	get-KERNEL_CC() {
259	genstef	1.69	debug-print-function ${FUNCNAME} $*
260
261	genstef	1.68	local kernel_cc
262			if [ -n "${KERNEL_ABI}" ]; then
263			# In future, an arch might want to define CC_$ABI
264			#kernel_cc="$(get_abi_CC)"
265	swegener	1.70	#[ -z "${kernel_cc}" ] &&
266	genstef	1.68	kernel_cc="$(tc-getCC $(ABI=${KERNEL_ABI} get_abi_CHOST))"
267			else
268			kernel_cc=$(tc-getCC)
269			fi
270			echo "${kernel_cc}"
271			}
272
273	johnm	1.11	generate_modulesd() {
274	genstef	1.69	debug-print-function ${FUNCNAME} $*
275
276	johnm	1.11	# This function will generate the neccessary modules.d file from the
277			# information contained in the modules exported parms
278	johnm	1.26
279	johnm	1.54	local currm_path currm currm_t t myIFS myVAR
280	johnm	1.26	local module_docs module_enabled module_aliases \
281			module_additions module_examples module_modinfo module_opts
282
283			for currm_path in ${@}
284	johnm	1.11	do
285	johnm	1.26	currm=${currm_path//*\/}
286			currm=$(echo ${currm} \| tr '[:lower:]' '[:upper:]')
287	johnm	1.54	currm_t=${currm}
288			while [[ -z ${currm_t//-} ]]; do
289			currm_t=${currm_t/-/_}
290			done
291	johnm	1.26
292	johnm	1.54	module_docs="$(eval echo \${MODULESD_${currm_t}_DOCS})"
293			module_enabled="$(eval echo \${MODULESD_${currm_t}_ENABLED})"
294			module_aliases="$(eval echo \${#MODULESD_${currm_t}_ALIASES[*]})"
295			module_additions="$(eval echo \${#MODULESD_${currm_t}_ADDITIONS[*]})"
296			module_examples="$(eval echo \${#MODULESD_${currm_t}_EXAMPLES[*]})"
297	johnm	1.26
298	johnm	1.27	[[ ${module_aliases} -eq 0 ]] && unset module_aliases
299			[[ ${module_additions} -eq 0 ]] && unset module_additions
300			[[ ${module_examples} -eq 0 ]] && unset module_examples
301	johnm	1.26
302	swegener	1.49	# If we specify we dont want it, then lets exit, otherwise we assume
303	johnm	1.26	# that if its set, we do want it.
304			[[ ${module_enabled} == no ]] && return 0
305
306			# unset any unwanted variables.
307			for t in ${!module_*}
308	johnm	1.11	do
309	johnm	1.26	[[ -z ${!t} ]] && unset ${t}
310	johnm	1.11	done
311
312	johnm	1.26	[[ -z ${!module_*} ]] && return 0
313
314			# OK so now if we have got this far, then we know we want to continue
315			# and generate the modules.d file.
316			module_modinfo="$(modinfo -p ${currm_path}.${KV_OBJ})"
317			module_config="${T}/modulesd-${currm}"
318
319	johnm	1.11	ebegin "Preparing file for modules.d"
320	johnm	1.26	#-----------------------------------------------------------------------
321			echo "# modules.d configuration file for ${currm}" >> ${module_config}
322			#-----------------------------------------------------------------------
323			[[ -n ${module_docs} ]] && \
324			echo "# For more information please read:" >> ${module_config}
325			for t in ${module_docs}
326	johnm	1.11	do
327	johnm	1.26	echo "# ${t//*\/}" >> ${module_config}
328	johnm	1.11	done
329	johnm	1.26	echo >> ${module_config}
330	johnm	1.11
331	johnm	1.26	#-----------------------------------------------------------------------
332	johnm	1.27	if [[ ${module_aliases} -gt 0 ]]
333	johnm	1.11	then
334			echo "# Internal Aliases - Do not edit" >> ${module_config}
335			echo "# ------------------------------" >> ${module_config}
336	johnm	1.12
337	johnm	1.26	for((t=0; t<${module_aliases}; t++))
338	johnm	1.11	do
339	johnm	1.26	echo "alias $(eval echo \${MODULESD_${currm}_ALIASES[$t]})" \
340			>> ${module_config}
341	johnm	1.12	done
342	johnm	1.26	echo '' >> ${module_config}
343	johnm	1.11	fi
344
345	johnm	1.26	#-----------------------------------------------------------------------
346			if [[ -n ${module_modinfo} ]]
347	johnm	1.11	then
348			echo >> ${module_config}
349			echo "# Configurable module parameters" >> ${module_config}
350			echo "# ------------------------------" >> ${module_config}
351	johnm	1.26	myIFS="${IFS}"
352	johnm	1.11	IFS="$(echo -en "\n\b")"
353	swegener	1.49
354	johnm	1.26	for t in ${module_modinfo}
355	johnm	1.11	do
356	johnm	1.26	myVAR="$(echo ${t#:} \| grep -e " [0-9][ =]" \| sed "s:.\([01][= ]\).*:\1:")"
357			if [[ -n ${myVAR} ]]
358	johnm	1.11	then
359	johnm	1.26	module_opts="${module_opts} ${t%%:*}:${myVAR}"
360	johnm	1.11	fi
361	johnm	1.26	echo -e "# ${t%%:}:\t${t#:}" >> ${module_config}
362	swegener	1.49	done
363	johnm	1.26	IFS="${myIFS}"
364			echo '' >> ${module_config}
365			fi
366
367			#-----------------------------------------------------------------------
368			if [[ $(eval echo \${MODULESD_${currm}_ALIASES[0]}) == guess ]]
369			then
370			# So lets do some guesswork eh?
371			if [[ -n ${module_opts} ]]
372			then
373			echo "# For Example..." >> ${module_config}
374			echo "# --------------" >> ${module_config}
375			for t in ${module_opts}
376			do
377			echo "# options ${currm} ${t//:}=${t//:}" >> ${module_config}
378			done
379			echo '' >> ${module_config}
380			fi
381	johnm	1.27	elif [[ ${module_examples} -gt 0 ]]
382	johnm	1.26	then
383			echo "# For Example..." >> ${module_config}
384			echo "# --------------" >> ${module_config}
385			for((t=0; t<${module_examples}; t++))
386			do
387			echo "options $(eval echo \${MODULESD_${currm}_EXAMPLES[$t]})" \
388			>> ${module_config}
389	johnm	1.11	done
390	johnm	1.26	echo '' >> ${module_config}
391	johnm	1.11	fi
392	johnm	1.26
393			#-----------------------------------------------------------------------
394	johnm	1.27	if [[ ${module_additions} -gt 0 ]]
395	johnm	1.11	then
396	johnm	1.26	for((t=0; t<${module_additions}; t++))
397	johnm	1.11	do
398	johnm	1.26	echo "$(eval echo \${MODULESD_${currm}_ADDITIONS[$t]})" \
399			>> ${module_config}
400	johnm	1.11	done
401	johnm	1.26	echo '' >> ${module_config}
402	johnm	1.11	fi
403	swegener	1.49
404	johnm	1.26	#-----------------------------------------------------------------------
405
406	johnm	1.12	# then we install it
407	johnm	1.11	insinto /etc/modules.d
408	johnm	1.27	newins ${module_config} ${currm_path//*\/}
409
410	johnm	1.12	# and install any documentation we might have.
411	johnm	1.26	[[ -n ${module_docs} ]] && dodoc ${module_docs}
412	johnm	1.11	done
413			eend 0
414	johnm	1.26	return 0
415	johnm	1.11	}
416
417	johnm	1.18	find_module_params() {
418	genstef	1.69	debug-print-function ${FUNCNAME} $*
419
420	johnm	1.18	local matched_offset=0 matched_opts=0 test="${@}" temp_var result
421			local i=0 y=0 z=0
422	swegener	1.49
423	johnm	1.18	for((i=0; i<=${#test}; i++))
424			do
425			case ${test:${i}:1} in
426			\() matched_offset[0]=${i};;
427			\:) matched_opts=$((${matched_opts} + 1));
428			matched_offset[${matched_opts}]="${i}";;
429			\)) matched_opts=$((${matched_opts} + 1));
430			matched_offset[${matched_opts}]="${i}";;
431			esac
432			done
433	swegener	1.49
434	johnm	1.18	for((i=0; i<=${matched_opts}; i++))
435			do
436			# i = offset were working on
437			# y = last offset
438			# z = current offset - last offset
439			# temp_var = temporary name
440			case ${i} in
441			0) tempvar=${test:0:${matched_offset[0]}};;
442			*) y=$((${matched_offset[$((${i} - 1))]} + 1))
443			z=$((${matched_offset[${i}]} - ${matched_offset[$((${i} - 1))]}));
444			z=$((${z} - 1))
445			tempvar=${test:${y}:${z}};;
446			esac
447	swegener	1.49
448	johnm	1.18	case ${i} in
449			0) result="${result} modulename:${tempvar}";;
450			1) result="${result} libdir:${tempvar}";;
451			2) result="${result} srcdir:${tempvar}";;
452			3) result="${result} objdir:${tempvar}";;
453			esac
454			done
455	swegener	1.49
456	johnm	1.18	echo ${result}
457			}
458
459	johnm	1.1	# default ebuild functions
460			# --------------------------------
461
462			linux-mod_pkg_setup() {
463	genstef	1.69	debug-print-function ${FUNCNAME} $*
464
465	johnm	1.6	linux-info_pkg_setup;
466			check_kernel_built;
467	johnm	1.63	strip_modulenames;
468			[[ -n ${MODULE_NAMES} ]] && check_modules_supported
469	johnm	1.1	set_kvobj;
470	weeve	1.55	# Commented out with permission from johnm until a fixed version for arches
471			# who intentionally use different kernel and userland compilers can be
472			# introduced - Jason Wever <weeve@gentoo.org>, 23 Oct 2005
473			#check_vermagic;
474	johnm	1.1	}
475
476	johnm	1.63	strip_modulenames() {
477	genstef	1.69	debug-print-function ${FUNCNAME} $*
478
479	johnm	1.63	local i
480			for i in ${MODULE_IGNORE}; do
481			MODULE_NAMES=${MODULE_NAMES//${i}(*}
482			done
483			}
484
485	johnm	1.1	linux-mod_src_compile() {
486	genstef	1.69	debug-print-function ${FUNCNAME} $*
487
488	blubb	1.62	local modulename libdir srcdir objdir i n myARCH="${ARCH}" myABI="${ABI}"
489	johnm	1.52	ARCH="$(tc-arch-kernel)"
490	blubb	1.62	ABI="${KERNEL_ABI}"
491	johnm	1.26
492	johnm	1.16	BUILD_TARGETS=${BUILD_TARGETS:-clean module}
493	johnm	1.63	strip_modulenames;
494	phreak	1.76	cd "${S}"
495	johnm	1.9	for i in ${MODULE_NAMES}
496	johnm	1.1	do
497	johnm	1.23	unset libdir srcdir objdir
498	johnm	1.18	for n in $(find_module_params ${i})
499			do
500			eval ${n/:}=${n/:/}
501			done
502			libdir=${libdir:-misc}
503			srcdir=${srcdir:-${S}}
504			objdir=${objdir:-${srcdir}}
505	swegener	1.49
506	johnm	1.18	if [ ! -f "${srcdir}/.built" ];
507	johnm	1.16	then
508	johnm	1.18	cd ${srcdir}
509	johnm	1.16	einfo "Preparing ${modulename} module"
510	johnm	1.22	if [[ -n ${ECONF_PARAMS} ]]
511			then
512			econf ${ECONF_PARAMS} \|\| \
513			die "Unable to run econf ${ECONF_PARAMS}"
514			fi
515
516	genstef	1.69	emake HOSTCC="$(tc-getBUILD_CC)" CC="$(get-KERNEL_CC)" LDFLAGS="$(get_abi_LDFLAGS)" \
517	johnm	1.64	${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS} \
518	vapier	1.66	\|\| die "Unable to make ${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS}."
519	johnm	1.18	touch ${srcdir}/.built
520	johnm	1.16	cd ${OLDPWD}
521			fi
522	johnm	1.1	done
523	johnm	1.26
524			ARCH="${myARCH}"
525	blubb	1.62	ABI="${myABI}"
526	johnm	1.1	}
527
528			linux-mod_src_install() {
529	genstef	1.69	debug-print-function ${FUNCNAME} $*
530
531	johnm	1.18	local modulename libdir srcdir objdir i n
532	swegener	1.49
533	johnm	1.63	strip_modulenames;
534	johnm	1.9	for i in ${MODULE_NAMES}
535	johnm	1.1	do
536	johnm	1.23	unset libdir srcdir objdir
537	johnm	1.18	for n in $(find_module_params ${i})
538			do
539			eval ${n/:}=${n/:/}
540			done
541			libdir=${libdir:-misc}
542			srcdir=${srcdir:-${S}}
543			objdir=${objdir:-${srcdir}}
544	johnm	1.1
545			einfo "Installing ${modulename} module"
546	vapier	1.56	cd ${objdir} \|\| die "${objdir} does not exist"
547	brix	1.57	insinto /lib/modules/${KV_FULL}/${libdir}
548	vapier	1.56	doins ${modulename}.${KV_OBJ} \|\| die "doins ${modulename}.${KV_OBJ} failed"
549	johnm	1.16	cd ${OLDPWD}
550	swegener	1.49
551	johnm	1.26	generate_modulesd ${objdir}/${modulename}
552	johnm	1.1	done
553			}
554
555	genstef	1.65	linux-mod_pkg_preinst() {
556	genstef	1.69	debug-print-function ${FUNCNAME} $*
557
558	zmedico	1.77	[ -d "${D}lib/modules" ] && UPDATE_DEPMOD=true \|\| UPDATE_DEPMOD=false
559			[ -d "${D}etc/modules.d" ] && UPDATE_MODULES=true \|\| UPDATE_MODULES=false
560			[ -d "${D}lib/modules" ] && UPDATE_MODULEDB=true \|\| UPDATE_MODULEDB=false
561	genstef	1.65	}
562
563	johnm	1.1	linux-mod_pkg_postinst() {
564	genstef	1.69	debug-print-function ${FUNCNAME} $*
565
566	genstef	1.65	${UPDATE_DEPMOD} && update_depmod;
567			${UPDATE_MODULES} && update_modules;
568			${UPDATE_MODULEDB} && update_moduledb;
569	johnm	1.1	}
570	johnm	1.37
571			linux-mod_pkg_postrm() {
572	swegener	1.70	debug-print-function ${FUNCNAME} $*
573	johnm	1.37	remove_moduledb;
574			}