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.64 2006/05/11 08:23:43 johnm 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.
#
# 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          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="" # don't put pcmcia here, rather in the ebuilds that actually support pcmcia
SLOT="0"
DESCRIPTION="Based on the $ECLASS eclass"
RDEPEND="kernel_linux? ( virtual/modutils
                pcmcia? ( virtual/pcmcia ) )"
DEPEND="${RDEPEND}
                sys-apps/sed"

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

check_vermagic() {
        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
}

unpack_pcmcia_sources() {
        # So while the two eclasses exist side-by-side and also the ebuilds inherit
        # both we need to check for PCMCIA_SOURCE_DIR, and if we find it, then we
        # bail out and assume pcmcia.eclass is working on it.
        [[ -n ${PCMCIA_SOURCE_DIR} ]] && return 1

        if [[ -f "${1}" ]]; then
                PCMCIA_SOURCE_DIR="${WORKDIR}/pcmcia-cs/"

                ebegin "Decompressing pcmcia-cs sources"
                mkdir -p ${PCMCIA_SOURCE_DIR}
                tar -xjf ${1} -C ${PCMCIA_SOURCE_DIR}
                eend $?

                if [[ -f ${PCMCIA_SOURCE_DIR}/pcmcia-cs-version ]]; then
                        PCMCIA_VERSION=$(cat ${PCMCIA_SOURCE_DIR}/pcmcia-cs-version)
                        einfo "Found pcmcia-cs-${PCMCIA_VERSION}"
                fi
        fi
}

# Dummy function for compatibility.
pcmcia_configure() { return 0; }

pcmcia_src_unpack() {
        local pcmcia_tbz="${ROOT}/usr/src/pcmcia-cs/pcmcia-cs-build-env.tbz2"

        # if the kernel has pcmcia support built in, then we just ignore all this.
        if linux_chkconfig_present PCMCIA; then
                einfo "Kernel based PCMCIA support has been detected."
        else
                if kernel_is 2 4; then
                        unpack_pcmcia_sources ${pcmcia_tbz};
                else
                        einfo "We have detected that you are running a 2.6 kernel"
                        einfo "but you are not using the built-in PCMCIA support."
                        einfo "We will assume you know what you are doing, but please"
                        einfo "consider using the built in PCMCIA support instead."
                        epause 10

                        unpack_pcmcia_sources ${pcmcia_tbz};
                fi
        fi
}

use_m() {
        # 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() {
        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() {
        # 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() {
        if [ -x /sbin/modules-update ] && \
                grep -v -e "^#" -e "^$" ${D}/etc/modules.d/* >/dev/null 2>&1; then
                ebegin "Updating modules.conf"
                /sbin/modules-update
                eend $?
        fi
}

move_old_moduledb() {
        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() {
        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 [[ -z $(grep ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb) ]]; then
                einfo "Adding module to moduledb."
                echo "a:1:${CATEGORY}/${PN}-${PVR}" >> ${MODULEDB_DIR}/moduledb
        fi
}

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

        if [[ -n $(grep ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb) ]]; then
                einfo "Removing ${CATEGORY}/${PN}-${PVR} from moduledb."
                sed -ie "/.*${CATEGORY}\/${PN}-${PVR}.*/d" ${MODULEDB_DIR}/moduledb
        fi
}

set_kvobj() {
        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}"
}

generate_modulesd() {
        # 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() {
        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() {
        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() {
        local i
        for i in ${MODULE_IGNORE}; do
                MODULE_NAMES=${MODULE_NAMES//${i}(*}
        done
}

linux-mod_src_compile() {
        local modulename libdir srcdir objdir i n myARCH="${ARCH}" myABI="${ABI}"
        ARCH="$(tc-arch-kernel)"
        ABI="${KERNEL_ABI}"
        CC_HOSTCC=$(tc-getBUILD_CC)
        CC_CC=$(tc-getCC)

        BUILD_TARGETS=${BUILD_TARGETS:-clean module}
        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}}

                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=${CC_HOSTCC} CC=${CC_CC}\
                                  ${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() {
        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() {
        [ -d ${IMAGE}/lib/modules ] && UPDATE_DEPMOD=true || UPDATE_DEPMOD=false
        [ -d ${IMAGE}/etc/modules.d ] && UPDATE_MODULES=true || UPDATE_MODULES=false
        [ -d ${IMAGE}/lib/modules ] && UPDATE_MODULEDB=true || UPDATE_MODULEDB=false
}

linux-mod_pkg_postinst() {
        ${UPDATE_DEPMOD} && update_depmod;
        ${UPDATE_MODULES} && update_modules;
        ${UPDATE_MODULEDB} && update_moduledb;
}

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