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.66 2006/06/20 19:47:37 vapier 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="kernel_linux"
SLOT="0"
DESCRIPTION="Based on the $ECLASS eclass"
RDEPEND="kernel_linux? ( virtual/modutils )"
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
}

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.67	# $Header: /var/cvsroot/gentoo-x86/eclass/linux-mod.eclass,v 1.66 2006/06/20 19:47:37 vapier 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	genstef	1.67	IUSE="kernel_linux"
90	johnm	1.26	SLOT="0"
91	johnm	1.1	DESCRIPTION="Based on the $ECLASS eclass"
92	genstef	1.67	RDEPEND="kernel_linux? ( virtual/modutils )"
93	genstef	1.65	DEPEND="${RDEPEND}
94	vapier	1.66	sys-apps/sed"
95	johnm	1.26
96	johnm	1.1	# eclass utilities
97			# ----------------------------------
98
99	johnm	1.53	check_vermagic() {
100			local curr_gcc_ver=$(gcc -dumpversion)
101			local tmpfile old_chost old_gcc_ver result=0
102
103	johnm	1.54	tmpfile=`find ${KV_DIR}/ -iname "*.o.cmd" -exec grep usr/lib/gcc {} \; -quit`
104	johnm	1.53	tmpfile=${tmpfile//*usr/lib}
105			tmpfile=${tmpfile//\/include*}
106			old_chost=${tmpfile//*gcc\/}
107			old_chost=${old_chost//\/*}
108			old_gcc_ver=${tmpfile//*\/}
109
110	johnm	1.54	if [[ -z ${old_gcc_ver} \|\| -z ${old_chost} ]]; then
111			ewarn ""
112			ewarn "Unable to detect what version of GCC was used to compile"
113			ewarn "the kernel. Build will continue, but you may experience problems."
114			elif [[ ${curr_gcc_ver} != ${old_gcc_ver} ]]; then
115	johnm	1.53	ewarn ""
116			ewarn "The version of GCC you are using (${curr_gcc_ver}) does"
117			ewarn "not match the version of GCC used to compile the"
118			ewarn "kernel (${old_gcc_ver})."
119			result=1
120			elif [[ ${CHOST} != ${old_chost} ]]; then
121			ewarn ""
122			ewarn "The current CHOST (${CHOST}) does not match the chost"
123			ewarn "used when compiling the kernel (${old_chost})."
124			result=1
125			fi
126
127			if [[ ${result} -gt 0 ]]; then
128			ewarn ""
129			ewarn "Build will not continue, because you will experience problems."
130			ewarn "To fix this either change the version of GCC you wish to use"
131			ewarn "to match the kernel, or recompile the kernel first."
132			die "GCC Version Mismatch."
133			fi
134			}
135
136	johnm	1.1	use_m() {
137			# if we haven't determined the version yet, we need too.
138			get_version;
139	swegener	1.49
140	johnm	1.1	# if the kernel version is greater than 2.6.6 then we should use
141	johnm	1.8	# M= instead of SUBDIRS=
142	johnm	1.1	[ ${KV_MAJOR} -eq 2 -a ${KV_MINOR} -gt 5 -a ${KV_PATCH} -gt 5 ] && \
143			return 0 \|\| return 1
144			}
145
146			convert_to_m() {
147			if use_m
148			then
149	johnm	1.32	[ ! -f "${1}" ] && \
150			die "convert_to_m() requires a filename as an argument"
151	johnm	1.8	ebegin "Converting ${1/${WORKDIR}\//} to use M= instead of SUBDIRS="
152	johnm	1.1	sed -i 's:SUBDIRS=:M=:g' ${1}
153			eend $?
154			fi
155			}
156
157			update_depmod() {
158			# if we haven't determined the version yet, we need too.
159			get_version;
160	swegener	1.49
161	johnm	1.1	ebegin "Updating module dependencies for ${KV_FULL}"
162	johnm	1.5	if [ -r ${KV_OUT_DIR}/System.map ]
163	johnm	1.1	then
164	johnm	1.5	depmod -ae -F ${KV_OUT_DIR}/System.map -b ${ROOT} -r ${KV_FULL}
165	johnm	1.18	eend $?
166	johnm	1.1	else
167			ewarn
168	johnm	1.5	ewarn "${KV_OUT_DIR}/System.map not found."
169	johnm	1.1	ewarn "You must manually update the kernel module dependencies using depmod."
170	johnm	1.18	eend 1
171	johnm	1.1	ewarn
172			fi
173			}
174
175	johnm	1.3	update_modules() {
176	kingtaco	1.31	if [ -x /sbin/modules-update ] && \
177			grep -v -e "^#" -e "^$" ${D}/etc/modules.d/* >/dev/null 2>&1; then
178	johnm	1.3	ebegin "Updating modules.conf"
179			/sbin/modules-update
180			eend $?
181			fi
182			}
183
184	johnm	1.41	move_old_moduledb() {
185			local OLDDIR=${ROOT}/usr/share/module-rebuild/
186			local NEWDIR=${ROOT}/var/lib/module-rebuild/
187	swegener	1.49
188	johnm	1.41	if [[ -f ${OLDDIR}/moduledb ]]; then
189			[[ ! -d ${NEWDIR} ]] && mkdir -p ${NEWDIR}
190	johnm	1.42	[[ ! -f ${NEWDIR}/moduledb ]] && \
191			mv ${OLDDIR}/moduledb ${NEWDIR}/moduledb
192			rm -f ${OLDDIR}/*
193	johnm	1.41	rmdir ${OLDDIR}
194			fi
195			}
196
197	johnm	1.37	update_moduledb() {
198	johnm	1.40	local MODULEDB_DIR=${ROOT}/var/lib/module-rebuild/
199	johnm	1.41	move_old_moduledb
200	johnm	1.40
201			if [[ ! -f ${MODULEDB_DIR}/moduledb ]]; then
202			[[ ! -d ${MODULEDB_DIR} ]] && mkdir -p ${MODULEDB_DIR}
203			touch ${MODULEDB_DIR}/moduledb
204	johnm	1.37	fi
205	johnm	1.40	if [[ -z $(grep ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb) ]]; then
206	johnm	1.37	einfo "Adding module to moduledb."
207	johnm	1.40	echo "a:1:${CATEGORY}/${PN}-${PVR}" >> ${MODULEDB_DIR}/moduledb
208	swegener	1.49	fi
209	johnm	1.37	}
210
211			remove_moduledb() {
212	johnm	1.40	local MODULEDB_DIR=${ROOT}/var/lib/module-rebuild/
213	johnm	1.41	move_old_moduledb
214	johnm	1.40
215			if [[ -n $(grep ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb) ]]; then
216	johnm	1.37	einfo "Removing ${CATEGORY}/${PN}-${PVR} from moduledb."
217	johnm	1.59	sed -ie "/.${CATEGORY}\/${PN}-${PVR}./d" ${MODULEDB_DIR}/moduledb
218	johnm	1.37	fi
219			}
220
221	johnm	1.1	set_kvobj() {
222			if kernel_is 2 6
223			then
224			KV_OBJ="ko"
225			else
226			KV_OBJ="o"
227			fi
228	johnm	1.26	# Do we really need to know this?
229			# Lets silence it.
230			# einfo "Using KV_OBJ=${KV_OBJ}"
231	johnm	1.1	}
232
233	johnm	1.11	generate_modulesd() {
234			# This function will generate the neccessary modules.d file from the
235			# information contained in the modules exported parms
236	johnm	1.26
237	johnm	1.54	local currm_path currm currm_t t myIFS myVAR
238	johnm	1.26	local module_docs module_enabled module_aliases \
239			module_additions module_examples module_modinfo module_opts
240
241			for currm_path in ${@}
242	johnm	1.11	do
243	johnm	1.26	currm=${currm_path//*\/}
244			currm=$(echo ${currm} \| tr '[:lower:]' '[:upper:]')
245	johnm	1.54	currm_t=${currm}
246			while [[ -z ${currm_t//-} ]]; do
247			currm_t=${currm_t/-/_}
248			done
249	johnm	1.26
250	johnm	1.54	module_docs="$(eval echo \${MODULESD_${currm_t}_DOCS})"
251			module_enabled="$(eval echo \${MODULESD_${currm_t}_ENABLED})"
252			module_aliases="$(eval echo \${#MODULESD_${currm_t}_ALIASES[*]})"
253			module_additions="$(eval echo \${#MODULESD_${currm_t}_ADDITIONS[*]})"
254			module_examples="$(eval echo \${#MODULESD_${currm_t}_EXAMPLES[*]})"
255	johnm	1.26
256	johnm	1.27	[[ ${module_aliases} -eq 0 ]] && unset module_aliases
257			[[ ${module_additions} -eq 0 ]] && unset module_additions
258			[[ ${module_examples} -eq 0 ]] && unset module_examples
259	johnm	1.26
260	swegener	1.49	# If we specify we dont want it, then lets exit, otherwise we assume
261	johnm	1.26	# that if its set, we do want it.
262			[[ ${module_enabled} == no ]] && return 0
263
264			# unset any unwanted variables.
265			for t in ${!module_*}
266	johnm	1.11	do
267	johnm	1.26	[[ -z ${!t} ]] && unset ${t}
268	johnm	1.11	done
269
270	johnm	1.26	[[ -z ${!module_*} ]] && return 0
271
272			# OK so now if we have got this far, then we know we want to continue
273			# and generate the modules.d file.
274			module_modinfo="$(modinfo -p ${currm_path}.${KV_OBJ})"
275			module_config="${T}/modulesd-${currm}"
276
277	johnm	1.11	ebegin "Preparing file for modules.d"
278	johnm	1.26	#-----------------------------------------------------------------------
279			echo "# modules.d configuration file for ${currm}" >> ${module_config}
280			#-----------------------------------------------------------------------
281			[[ -n ${module_docs} ]] && \
282			echo "# For more information please read:" >> ${module_config}
283			for t in ${module_docs}
284	johnm	1.11	do
285	johnm	1.26	echo "# ${t//*\/}" >> ${module_config}
286	johnm	1.11	done
287	johnm	1.26	echo >> ${module_config}
288	johnm	1.11
289	johnm	1.26	#-----------------------------------------------------------------------
290	johnm	1.27	if [[ ${module_aliases} -gt 0 ]]
291	johnm	1.11	then
292			echo "# Internal Aliases - Do not edit" >> ${module_config}
293			echo "# ------------------------------" >> ${module_config}
294	johnm	1.12
295	johnm	1.26	for((t=0; t<${module_aliases}; t++))
296	johnm	1.11	do
297	johnm	1.26	echo "alias $(eval echo \${MODULESD_${currm}_ALIASES[$t]})" \
298			>> ${module_config}
299	johnm	1.12	done
300	johnm	1.26	echo '' >> ${module_config}
301	johnm	1.11	fi
302
303	johnm	1.26	#-----------------------------------------------------------------------
304			if [[ -n ${module_modinfo} ]]
305	johnm	1.11	then
306			echo >> ${module_config}
307			echo "# Configurable module parameters" >> ${module_config}
308			echo "# ------------------------------" >> ${module_config}
309	johnm	1.26	myIFS="${IFS}"
310	johnm	1.11	IFS="$(echo -en "\n\b")"
311	swegener	1.49
312	johnm	1.26	for t in ${module_modinfo}
313	johnm	1.11	do
314	johnm	1.26	myVAR="$(echo ${t#:} \| grep -e " [0-9][ =]" \| sed "s:.\([01][= ]\).*:\1:")"
315			if [[ -n ${myVAR} ]]
316	johnm	1.11	then
317	johnm	1.26	module_opts="${module_opts} ${t%%:*}:${myVAR}"
318	johnm	1.11	fi
319	johnm	1.26	echo -e "# ${t%%:}:\t${t#:}" >> ${module_config}
320	swegener	1.49	done
321	johnm	1.26	IFS="${myIFS}"
322			echo '' >> ${module_config}
323			fi
324
325			#-----------------------------------------------------------------------
326			if [[ $(eval echo \${MODULESD_${currm}_ALIASES[0]}) == guess ]]
327			then
328			# So lets do some guesswork eh?
329			if [[ -n ${module_opts} ]]
330			then
331			echo "# For Example..." >> ${module_config}
332			echo "# --------------" >> ${module_config}
333			for t in ${module_opts}
334			do
335			echo "# options ${currm} ${t//:}=${t//:}" >> ${module_config}
336			done
337			echo '' >> ${module_config}
338			fi
339	johnm	1.27	elif [[ ${module_examples} -gt 0 ]]
340	johnm	1.26	then
341			echo "# For Example..." >> ${module_config}
342			echo "# --------------" >> ${module_config}
343			for((t=0; t<${module_examples}; t++))
344			do
345			echo "options $(eval echo \${MODULESD_${currm}_EXAMPLES[$t]})" \
346			>> ${module_config}
347	johnm	1.11	done
348	johnm	1.26	echo '' >> ${module_config}
349	johnm	1.11	fi
350	johnm	1.26
351			#-----------------------------------------------------------------------
352	johnm	1.27	if [[ ${module_additions} -gt 0 ]]
353	johnm	1.11	then
354	johnm	1.26	for((t=0; t<${module_additions}; t++))
355	johnm	1.11	do
356	johnm	1.26	echo "$(eval echo \${MODULESD_${currm}_ADDITIONS[$t]})" \
357			>> ${module_config}
358	johnm	1.11	done
359	johnm	1.26	echo '' >> ${module_config}
360	johnm	1.11	fi
361	swegener	1.49
362	johnm	1.26	#-----------------------------------------------------------------------
363
364	johnm	1.12	# then we install it
365	johnm	1.11	insinto /etc/modules.d
366	johnm	1.27	newins ${module_config} ${currm_path//*\/}
367
368	johnm	1.12	# and install any documentation we might have.
369	johnm	1.26	[[ -n ${module_docs} ]] && dodoc ${module_docs}
370	johnm	1.11	done
371			eend 0
372	johnm	1.26	return 0
373	johnm	1.11	}
374
375	johnm	1.18	find_module_params() {
376			local matched_offset=0 matched_opts=0 test="${@}" temp_var result
377			local i=0 y=0 z=0
378	swegener	1.49
379	johnm	1.18	for((i=0; i<=${#test}; i++))
380			do
381			case ${test:${i}:1} in
382			\() matched_offset[0]=${i};;
383			\:) matched_opts=$((${matched_opts} + 1));
384			matched_offset[${matched_opts}]="${i}";;
385			\)) matched_opts=$((${matched_opts} + 1));
386			matched_offset[${matched_opts}]="${i}";;
387			esac
388			done
389	swegener	1.49
390	johnm	1.18	for((i=0; i<=${matched_opts}; i++))
391			do
392			# i = offset were working on
393			# y = last offset
394			# z = current offset - last offset
395			# temp_var = temporary name
396			case ${i} in
397			0) tempvar=${test:0:${matched_offset[0]}};;
398			*) y=$((${matched_offset[$((${i} - 1))]} + 1))
399			z=$((${matched_offset[${i}]} - ${matched_offset[$((${i} - 1))]}));
400			z=$((${z} - 1))
401			tempvar=${test:${y}:${z}};;
402			esac
403	swegener	1.49
404	johnm	1.18	case ${i} in
405			0) result="${result} modulename:${tempvar}";;
406			1) result="${result} libdir:${tempvar}";;
407			2) result="${result} srcdir:${tempvar}";;
408			3) result="${result} objdir:${tempvar}";;
409			esac
410			done
411	swegener	1.49
412	johnm	1.18	echo ${result}
413			}
414
415	johnm	1.1	# default ebuild functions
416			# --------------------------------
417
418			linux-mod_pkg_setup() {
419	johnm	1.6	linux-info_pkg_setup;
420			check_kernel_built;
421	johnm	1.63	strip_modulenames;
422			[[ -n ${MODULE_NAMES} ]] && check_modules_supported
423	johnm	1.1	set_kvobj;
424	weeve	1.55	# Commented out with permission from johnm until a fixed version for arches
425			# who intentionally use different kernel and userland compilers can be
426			# introduced - Jason Wever <weeve@gentoo.org>, 23 Oct 2005
427			#check_vermagic;
428	johnm	1.1	}
429
430	johnm	1.63	strip_modulenames() {
431			local i
432			for i in ${MODULE_IGNORE}; do
433			MODULE_NAMES=${MODULE_NAMES//${i}(*}
434			done
435			}
436
437	johnm	1.1	linux-mod_src_compile() {
438	blubb	1.62	local modulename libdir srcdir objdir i n myARCH="${ARCH}" myABI="${ABI}"
439	johnm	1.52	ARCH="$(tc-arch-kernel)"
440	blubb	1.62	ABI="${KERNEL_ABI}"
441	johnm	1.64	CC_HOSTCC=$(tc-getBUILD_CC)
442			CC_CC=$(tc-getCC)
443	johnm	1.26
444	johnm	1.16	BUILD_TARGETS=${BUILD_TARGETS:-clean module}
445	johnm	1.63	strip_modulenames;
446	johnm	1.9	for i in ${MODULE_NAMES}
447	johnm	1.1	do
448	johnm	1.23	unset libdir srcdir objdir
449	johnm	1.18	for n in $(find_module_params ${i})
450			do
451			eval ${n/:}=${n/:/}
452			done
453			libdir=${libdir:-misc}
454			srcdir=${srcdir:-${S}}
455			objdir=${objdir:-${srcdir}}
456	swegener	1.49
457	johnm	1.18	if [ ! -f "${srcdir}/.built" ];
458	johnm	1.16	then
459	johnm	1.18	cd ${srcdir}
460	johnm	1.16	einfo "Preparing ${modulename} module"
461	johnm	1.22	if [[ -n ${ECONF_PARAMS} ]]
462			then
463			econf ${ECONF_PARAMS} \|\| \
464			die "Unable to run econf ${ECONF_PARAMS}"
465			fi
466
467	johnm	1.64	emake HOSTCC=${CC_HOSTCC} CC=${CC_CC}\
468			${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS} \
469	vapier	1.66	\|\| die "Unable to make ${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS}."
470	johnm	1.18	touch ${srcdir}/.built
471	johnm	1.16	cd ${OLDPWD}
472			fi
473	johnm	1.1	done
474	johnm	1.26
475			ARCH="${myARCH}"
476	blubb	1.62	ABI="${myABI}"
477	johnm	1.1	}
478
479			linux-mod_src_install() {
480	johnm	1.18	local modulename libdir srcdir objdir i n
481	swegener	1.49
482	johnm	1.63	strip_modulenames;
483	johnm	1.9	for i in ${MODULE_NAMES}
484	johnm	1.1	do
485	johnm	1.23	unset libdir srcdir objdir
486	johnm	1.18	for n in $(find_module_params ${i})
487			do
488			eval ${n/:}=${n/:/}
489			done
490			libdir=${libdir:-misc}
491			srcdir=${srcdir:-${S}}
492			objdir=${objdir:-${srcdir}}
493	johnm	1.1
494			einfo "Installing ${modulename} module"
495	vapier	1.56	cd ${objdir} \|\| die "${objdir} does not exist"
496	brix	1.57	insinto /lib/modules/${KV_FULL}/${libdir}
497	vapier	1.56	doins ${modulename}.${KV_OBJ} \|\| die "doins ${modulename}.${KV_OBJ} failed"
498	johnm	1.16	cd ${OLDPWD}
499	swegener	1.49
500	johnm	1.26	generate_modulesd ${objdir}/${modulename}
501	johnm	1.1	done
502			}
503
504	genstef	1.65	linux-mod_pkg_preinst() {
505			[ -d ${IMAGE}/lib/modules ] && UPDATE_DEPMOD=true \|\| UPDATE_DEPMOD=false
506			[ -d ${IMAGE}/etc/modules.d ] && UPDATE_MODULES=true \|\| UPDATE_MODULES=false
507			[ -d ${IMAGE}/lib/modules ] && UPDATE_MODULEDB=true \|\| UPDATE_MODULEDB=false
508			}
509
510	johnm	1.1	linux-mod_pkg_postinst() {
511	genstef	1.65	${UPDATE_DEPMOD} && update_depmod;
512			${UPDATE_MODULES} && update_modules;
513			${UPDATE_MODULEDB} && update_moduledb;
514	johnm	1.1	}
515	johnm	1.37
516			linux-mod_pkg_postrm() {
517			remove_moduledb;
518			}