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.37 2005/05/03 22:55:03 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
ECLASS=linux-mod
INHERITED="$INHERITED $ECLASS"
EXPORT_FUNCTIONS pkg_setup pkg_postinst src_install src_compile pkg_postrm

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

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

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
}

update_moduledb() {
        if [[ ! -f ${ROOT}/usr/share/module-rebuild/moduledb ]]; then
                [[ ! -d ${ROOT}/usr/share/module-rebuild/ ]] && mkdir ${ROOT}/usr/share/module-rebuild/
                touch ${ROOT}/usr/share/module-rebuild/moduledb
        fi
        if [[ -z $(grep ${CATEGORY}/${PN}-${PVR} ${ROOT}/usr/share/module-rebuild/moduledb) ]]; then
                einfo "Adding module to moduledb."
                echo "a:1:${CATEGORY}/${PN}-${PVR}" >> ${ROOT}/usr/share/module-rebuild/moduledb
        fi      
}

remove_moduledb() {
        if [[ -n $(grep ${CATEGORY}/${PN}-${PVR} ${ROOT}/usr/share/module-rebuild/moduledb) ]]; then
                einfo "Removing ${CATEGORY}/${PN}-${PVR} from moduledb."
                sed -ie "/.*${CATEGORY}\/${P}.*/d" ${ROOT}/usr/share/module-rebuild/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 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:]')

                module_docs="$(eval echo \${MODULESD_${currm}_DOCS})"
                module_enabled="$(eval echo \${MODULESD_${currm}_ENABLED})"
                module_aliases="$(eval echo \${#MODULESD_${currm/-/_}_ALIASES[*]})"
                module_additions="$(eval echo \${#MODULESD_${currm/-/_}_ADDITIONS[*]})"
                module_examples="$(eval echo \${#MODULESD_${currm/-/_}_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
}

display_postinst() {
        # if we haven't determined the version yet, we need too.
        get_version;
        
        local modulename moduledir sourcedir moduletemp file i
        
        file=${ROOT}/etc/modules.autoload.d/kernel-${KV_MAJOR}.${KV_MINOR}
        file=${file/\/\///}

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

        if [[ -n ${MODULE_NAMES} ]]
        then
                einfo "If you would like to load this module automatically upon boot"
                einfo "please type the following as root:"
                for i in ${MODULE_NAMES}
                do
                        unset libdir srcdir objdir
                        for n in $(find_module_params ${i})
                        do
                                eval ${n/:*}=${n/*:/}
                        done
                        einfo "    # echo \"${modulename}\" >> ${file}"
                done
                einfo
        fi
}

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;
}

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

        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;
        display_postinst;
}

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