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.53 2005/10/22 16:55:17 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


inherit linux-info
EXPORT_FUNCTIONS pkg_setup 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="virtual/modutils
                pcmcia? ( virtual/pcmcia )"
DEPEND="virtual/linux-sources
                sys-apps/sed
                pcmcia? ( virtual/pcmcia )"

# 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."
                        sleep 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}\/${P}.*/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;
        check_modules_supported;
        set_kvobj;
        check_vermagic;
}

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

        BUILD_TARGETS=${BUILD_TARGETS:-clean module}

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

        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 ${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}"
}

linux-mod_src_install() {
        local modulename libdir srcdir objdir i n

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

        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}
                insinto ${ROOT}lib/modules/${KV_FULL}/${libdir}
                doins ${modulename}.${KV_OBJ}
                cd ${OLDPWD}

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

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