/[gentoo-x86]/eclass/linux-mod.eclass
Gentoo

Diff of /eclass/linux-mod.eclass

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

Revision 1.8 Revision 1.88
1# Copyright 1999-2004 Gentoo Foundation 1# Copyright 1999-2004 Gentoo Foundation
2# Distributed under the terms of the GNU General Public License v2 2# Distributed under the terms of the GNU General Public License v2
3# $Header: /var/cvsroot/gentoo-x86/eclass/linux-mod.eclass,v 1.8 2004/12/06 22:05:08 johnm Exp $ 3# $Header: /var/cvsroot/gentoo-x86/eclass/linux-mod.eclass,v 1.88 2008/10/31 23:37:06 gengor Exp $
4 4
5# This eclass provides functions for compiling external kernel modules 5# Author(s): John Mylchreest <johnm@gentoo.org>,
6# from source. 6# Stefan Schweizer <genstef@gentoo.org>
7# Maintainer: kernel-misc@gentoo.org
8#
9# Please direct your bugs to the current eclass maintainer :)
7 10
8inherit linux-info 11# @ECLASS: linux-mod.eclass
9ECLASS=linux-mod 12# @MAINTAINER:
10INHERITED="$INHERITED $ECLASS" 13# kernel-misc@gentoo.org
11EXPORT_FUNCTIONS pkg_setup pkg_postinst src_compile 14# @BLURB: It provides the functionality required to install external modules against a kernel source tree.
15# @DESCRIPTION:
16# This eclass is used to interface with linux-info.eclass in such a way
17# to provide the functionality and initial functions
18# required to install external modules against a kernel source
19# tree.
12 20
21# A Couple of env vars are available to effect usage of this eclass
22# These are as follows:
23
24# @ECLASS-VARIABLE: KERNEL_DIR
25# @DESCRIPTION:
26# A string containing the directory of the target kernel sources. The default value is
27# "/usr/src/linux"
28
29# @ECLASS-VARIABLE: ECONF_PARAMS
30# @DESCRIPTION:
31# It's a string containing the parameters to pass to econf.
32# If this is not set, then econf isn't run.
33
34# @ECLASS-VARIABLE: BUILD_PARAMS
35# @DESCRIPTION:
36# It's a string with the parameters to pass to emake.
37
38# @ECLASS-VARIABLE: BUILD_TARGETS
39# @DESCRIPTION:
40# It's a string with the build targets to pass to make. The default value is "clean modules"
41
42# @ECLASS-VARIABLE: MODULE_NAMES
43# @DESCRIPTION:
44# It's a string containing the modules to be built automatically using the default
45# src_compile/src_install. It will only make ${BUILD_TARGETS} once in any directory.
46
47#
48# The structure of each MODULE_NAMES entry is as follows:
49#
50# modulename(libdir:srcdir:objdir)
51#
52# where:
53#
54# modulename = name of the module file excluding the .ko
55# libdir = place in system modules directory where module is installed:
56# srcdir = place for ebuild to cd to before running make
57# objdir = place the .ko and objects are located after make runs
58#
59# To get an idea of how these variables are used, here's a few lines
60# of code from around line 540 in this eclass:
61#
62# einfo "Installing ${modulename} module"
63# cd ${objdir} || die "${objdir} does not exist"
64# insinto /lib/modules/${KV_FULL}/${libdir}
65# doins ${modulename}.${KV_OBJ} || die "doins ${modulename}.${KV_OBJ} failed"
66#
67# For example:
68# MODULE_NAMES="module_pci(pci:${S}/pci:${S}) module_usb(usb:${S}/usb:${S})"
69#
70# what this would do is
71#
72# cd "${S}"/pci
73# make ${BUILD_PARAMS} ${BUILD_TARGETS}
74# cd "${S}"
75# insinto /lib/modules/${KV_FULL}/pci
76# doins module_pci.${KV_OBJ}
77#
78# cd "${S}"/usb
79# make ${BUILD_PARAMS} ${BUILD_TARGETS}
80# cd "${S}"
81# insinto /lib/modules/${KV_FULL}/usb
82# doins module_usb.${KV_OBJ}
83
84# There is also support for automated modprobe.d/modules.d(2.4) file generation.
85# This can be explicitly enabled by setting any of the following variables.
86
87# @ECLASS-VARIABLE: MODULESD_<modulename>_ENABLED
88# @DESCRIPTION:
89# This is used to disable the modprobe.d/modules.d file generation otherwise the file will be
90# always generated (unless no MODULESD_<modulename>_* variable is provided). Set to "no" to disable
91# the generation of the file and the installation of the documentation.
92
93# @ECLASS-VARIABLE: MODULESD_<modulename>_EXAMPLES
94# @DESCRIPTION:
95# This is a bash array containing a list of examples which should
96# be used. If you want us to try and take a guess set this to "guess".
97#
98# For each array_component it's added an options line in the modprobe.d/modules.d file
99#
100# options array_component
101#
102# where array_component is "<modulename> options" (see modprobe.conf(5))
103
104# @ECLASS-VARIABLE: MODULESD_<modulename>_ALIASES
105# @DESCRIPTION:
106# This is a bash array containing a list of associated aliases.
107#
108# For each array_component it's added an alias line in the modprobe.d/modules.d file
109#
110# alias array_component
111#
112# where array_component is "wildcard <modulename>" (see modprobe.conf(5))
113
114# @ECLASS-VARIABLE: MODULESD_<modulename>_ADDITIONS
115# @DESCRIPTION:
116# This is a bash array containing a list of additional things to
117# add to the bottom of the file. This can be absolutely anything.
118# Each entry is a new line.
119
120# @ECLASS-VARIABLE: MODULESD_<modulename>_DOCS
121# @DESCRIPTION:
122# This is a string list which contains the full path to any associated
123# documents for <modulename>. These files are installed in the live tree.
124
125# @ECLASS-VARIABLE: KV_OBJ
126# @DESCRIPTION:
127# It's a read-only variable. It contains the extension of the kernel modules.
128
129# The order of these is important as both of linux-info and eutils contain
130# set_arch_to_kernel and set_arch_to_portage functions and the ones in eutils
131# are deprecated in favor of the ones in linux-info.
132# See http://bugs.gentoo.org/show_bug.cgi?id=127506
133
134inherit eutils linux-info multilib
135EXPORT_FUNCTIONS pkg_setup pkg_preinst pkg_postinst src_install src_compile pkg_postrm
136
137IUSE="kernel_linux"
138SLOT="0"
13DESCRIPTION="Based on the $ECLASS eclass" 139DESCRIPTION="Based on the $ECLASS eclass"
14SLOT=0 140RESTRICT="distcc"
15DEPEND="virtual/linux-sources 141RDEPEND="kernel_linux? ( virtual/modutils )"
142DEPEND="${RDEPEND}
16 sys-apps/sed" 143 sys-apps/sed"
17
18
19# This eclass is designed to help ease the installation of external kernel
20# modules into the kernel tree.
21
22 144
23# eclass utilities 145# eclass utilities
24# ---------------------------------- 146# ----------------------------------
25 147
148check_vermagic() {
149 debug-print-function ${FUNCNAME} $*
150
151 local curr_gcc_ver=$(gcc -dumpversion)
152 local tmpfile old_chost old_gcc_ver result=0
153
154 tmpfile=`find ${KV_DIR}/ -iname "*.o.cmd" -exec grep usr/lib/gcc {} \; -quit`
155 tmpfile=${tmpfile//*usr/lib}
156 tmpfile=${tmpfile//\/include*}
157 old_chost=${tmpfile//*gcc\/}
158 old_chost=${old_chost//\/*}
159 old_gcc_ver=${tmpfile//*\/}
160
161 if [[ -z ${old_gcc_ver} || -z ${old_chost} ]]; then
162 ewarn ""
163 ewarn "Unable to detect what version of GCC was used to compile"
164 ewarn "the kernel. Build will continue, but you may experience problems."
165 elif [[ ${curr_gcc_ver} != ${old_gcc_ver} ]]; then
166 ewarn ""
167 ewarn "The version of GCC you are using (${curr_gcc_ver}) does"
168 ewarn "not match the version of GCC used to compile the"
169 ewarn "kernel (${old_gcc_ver})."
170 result=1
171 elif [[ ${CHOST} != ${old_chost} ]]; then
172 ewarn ""
173 ewarn "The current CHOST (${CHOST}) does not match the chost"
174 ewarn "used when compiling the kernel (${old_chost})."
175 result=1
176 fi
177
178 if [[ ${result} -gt 0 ]]; then
179 ewarn ""
180 ewarn "Build will not continue, because you will experience problems."
181 ewarn "To fix this either change the version of GCC you wish to use"
182 ewarn "to match the kernel, or recompile the kernel first."
183 die "GCC Version Mismatch."
184 fi
185}
186
187# @FUNCTION: use_m
188# @RETURN: true or false
189# @DESCRIPTION:
190# It checks if the kernel version is greater than 2.6.5.
26use_m() { 191use_m() {
192 debug-print-function ${FUNCNAME} $*
193
27 # if we haven't determined the version yet, we need too. 194 # if we haven't determined the version yet, we need too.
28 get_version; 195 get_version;
29 196
30 # if the kernel version is greater than 2.6.6 then we should use 197 # if the kernel version is greater than 2.6.6 then we should use
31 # M= instead of SUBDIRS= 198 # M= instead of SUBDIRS=
32 [ ${KV_MAJOR} -eq 2 -a ${KV_MINOR} -gt 5 -a ${KV_PATCH} -gt 5 ] && \ 199 [ ${KV_MAJOR} -eq 2 -a ${KV_MINOR} -gt 5 -a ${KV_PATCH} -gt 5 ] && \
33 return 0 || return 1 200 return 0 || return 1
34} 201}
35 202
203# @FUNCTION: convert_to_m
204# @USAGE: /path/to/the/file
205# @DESCRIPTION:
206# It converts a file (e.g. a makefile) to use M= instead of SUBDIRS=
36convert_to_m() { 207convert_to_m() {
37 [ ! -f "${1}" ] && die "convert_to_m() requires a filename as an argument" 208 debug-print-function ${FUNCNAME} $*
209
38 if use_m 210 if use_m
39 then 211 then
212 [ ! -f "${1}" ] && \
213 die "convert_to_m() requires a filename as an argument"
40 ebegin "Converting ${1/${WORKDIR}\//} to use M= instead of SUBDIRS=" 214 ebegin "Converting ${1/${WORKDIR}\//} to use M= instead of SUBDIRS="
41 sed -i 's:SUBDIRS=:M=:g' ${1} 215 sed -i 's:SUBDIRS=:M=:g' ${1}
42 eend $? 216 eend $?
43 fi 217 fi
44} 218}
45 219
220# internal function
221#
222# FUNCTION: update_depmod
223# DESCRIPTION:
224# It updates the modules.dep file for the current kernel.
46update_depmod() { 225update_depmod() {
226 debug-print-function ${FUNCNAME} $*
227
47 # if we haven't determined the version yet, we need too. 228 # if we haven't determined the version yet, we need too.
48 get_version; 229 get_version;
49 230
50 ebegin "Updating module dependencies for ${KV_FULL}" 231 ebegin "Updating module dependencies for ${KV_FULL}"
51 if [ -r ${KV_OUT_DIR}/System.map ] 232 if [ -r ${KV_OUT_DIR}/System.map ]
52 then 233 then
53 depmod -ae -F ${KV_OUT_DIR}/System.map -b ${ROOT} -r ${KV_FULL} 234 depmod -ae -F ${KV_OUT_DIR}/System.map -b ${ROOT} -r ${KV_FULL}
235 eend $?
54 else 236 else
55 ewarn 237 ewarn
56 ewarn "${KV_OUT_DIR}/System.map not found." 238 ewarn "${KV_OUT_DIR}/System.map not found."
57 ewarn "You must manually update the kernel module dependencies using depmod." 239 ewarn "You must manually update the kernel module dependencies using depmod."
240 eend 1
58 ewarn 241 ewarn
59 fi 242 fi
60 eend $?
61} 243}
62 244
245# internal function
246#
247# FUNCTION: update_modules
248# DESCRIPTION:
249# It calls the update-modules utility.
63update_modules() { 250update_modules() {
64 if [ -x /sbin/modules-update ] ; 251 debug-print-function ${FUNCNAME} $*
65 then 252
253 if [ -x /sbin/update-modules ] && \
254 grep -v -e "^#" -e "^$" ${D}/etc/modules.d/* >/dev/null 2>&1; then
66 ebegin "Updating modules.conf" 255 ebegin "Updating modules.conf"
67 /sbin/modules-update 256 /sbin/update-modules
68 eend $? 257 eend $?
258 elif [ -x /sbin/update-modules ] && \
259 grep -v -e "^#" -e "^$" ${D}/etc/modules.d/* >/dev/null 2>&1; then
260 ebegin "Updating modules.conf"
261 /sbin/update-modules
262 eend $?
69 fi 263 fi
70} 264}
71 265
266# internal function
267#
268# FUNCTION: move_old_moduledb
269# DESCRIPTION:
270# It updates the location of the database used by the module-rebuild utility.
271move_old_moduledb() {
272 debug-print-function ${FUNCNAME} $*
273
274 local OLDDIR=${ROOT}/usr/share/module-rebuild/
275 local NEWDIR=${ROOT}/var/lib/module-rebuild/
276
277 if [[ -f ${OLDDIR}/moduledb ]]; then
278 [[ ! -d ${NEWDIR} ]] && mkdir -p ${NEWDIR}
279 [[ ! -f ${NEWDIR}/moduledb ]] && \
280 mv ${OLDDIR}/moduledb ${NEWDIR}/moduledb
281 rm -f ${OLDDIR}/*
282 rmdir ${OLDDIR}
283 fi
284}
285
286# internal function
287#
288# FUNCTION: update_moduledb
289# DESCRIPTION:
290# It adds the package to the /var/lib/module-rebuild/moduledb database used by the module-rebuild utility.
291update_moduledb() {
292 debug-print-function ${FUNCNAME} $*
293
294 local MODULEDB_DIR=${ROOT}/var/lib/module-rebuild/
295 move_old_moduledb
296
297 if [[ ! -f ${MODULEDB_DIR}/moduledb ]]; then
298 [[ ! -d ${MODULEDB_DIR} ]] && mkdir -p ${MODULEDB_DIR}
299 touch ${MODULEDB_DIR}/moduledb
300 fi
301
302 if ! grep -qs ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb ; then
303 einfo "Adding module to moduledb."
304 echo "a:1:${CATEGORY}/${PN}-${PVR}" >> ${MODULEDB_DIR}/moduledb
305 fi
306}
307
308# internal function
309#
310# FUNCTION: remove_moduledb
311# DESCRIPTION:
312# It removes the package from the /var/lib/module-rebuild/moduledb database used by
313# the module-rebuild utility.
314remove_moduledb() {
315 debug-print-function ${FUNCNAME} $*
316
317 local MODULEDB_DIR=${ROOT}/var/lib/module-rebuild/
318 move_old_moduledb
319
320 if grep -qs ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb ; then
321 einfo "Removing ${CATEGORY}/${PN}-${PVR} from moduledb."
322 sed -i -e "/.*${CATEGORY}\/${PN}-${PVR}.*/d" ${MODULEDB_DIR}/moduledb
323 fi
324}
325
326# @FUNCTION: set_kvobj
327# @DESCRIPTION:
328# It sets the KV_OBJ variable.
72set_kvobj() { 329set_kvobj() {
330 debug-print-function ${FUNCNAME} $*
331
73 if kernel_is 2 6 332 if kernel_is 2 6
74 then 333 then
75 KV_OBJ="ko" 334 KV_OBJ="ko"
76 else 335 else
77 KV_OBJ="o" 336 KV_OBJ="o"
78 fi 337 fi
338 # Do we really need to know this?
339 # Lets silence it.
79 einfo "Using KV_OBJ=${KV_OBJ}" 340 # einfo "Using KV_OBJ=${KV_OBJ}"
80} 341}
81 342
82display_postinst() { 343get-KERNEL_CC() {
83 # if we haven't determined the version yet, we need too. 344 debug-print-function ${FUNCNAME} $*
84 get_version;
85
86 local modulename moduledir sourcedir module_temp file i
87
88 file=${ROOT}/etc/modules.autoload.d/kernel-${KV_MAJOR}.${KV_MINOR}
89 file=${file/\/\///}
90 345
91 einfo "If you would like to load this module automatically upon boot" 346 if [[ -n ${KERNEL_CC} ]] ; then
92 einfo "please type the following as root:" 347 echo "${KERNEL_CC}"
348 return
349 fi
350
351 local kernel_cc
352 if [ -n "${KERNEL_ABI}" ]; then
353 # In future, an arch might want to define CC_$ABI
354 #kernel_cc="$(get_abi_CC)"
355 #[ -z "${kernel_cc}" ] &&
356 kernel_cc="$(tc-getCC $(ABI=${KERNEL_ABI} get_abi_CHOST))"
357 else
358 kernel_cc=$(tc-getCC)
359 fi
360 echo "${kernel_cc}"
361}
362
363# internal function
364#
365# FUNCTION:
366# USAGE: /path/to/the/modulename_without_extension
367# RETURN: A file in /etc/modules.d/ (kernel < 2.6) or /etc/modprobe.d/ (kernel >= 2.6)
368# DESCRIPTION:
369# This function will generate and install the neccessary modprobe.d/modules.d file from the
370# information contained in the modules exported parms.
371# (see the variables MODULESD_<modulename>_ENABLED, MODULESD_<modulename>_EXAMPLES,
372# MODULESD_<modulename>_ALIASES, MODULESD_<modulename>_ADDITION and MODULESD_<modulename>_DOCS).
373#
374# At the end the documentation specified with MODULESD_<modulename>_DOCS is installed.
375generate_modulesd() {
376 debug-print-function ${FUNCNAME} $*
377
378 local currm_path currm currm_t t myIFS myVAR
379 local module_docs module_enabled module_aliases \
380 module_additions module_examples module_modinfo module_opts
381
382 for currm_path in ${@}
383 do
384 currm=${currm_path//*\/}
385 currm=$(echo ${currm} | tr '[:lower:]' '[:upper:]')
386 currm_t=${currm}
387 while [[ -z ${currm_t//*-*} ]]; do
388 currm_t=${currm_t/-/_}
389 done
390
391 module_docs="$(eval echo \${MODULESD_${currm_t}_DOCS})"
392 module_enabled="$(eval echo \${MODULESD_${currm_t}_ENABLED})"
393 module_aliases="$(eval echo \${#MODULESD_${currm_t}_ALIASES[*]})"
394 module_additions="$(eval echo \${#MODULESD_${currm_t}_ADDITIONS[*]})"
395 module_examples="$(eval echo \${#MODULESD_${currm_t}_EXAMPLES[*]})"
396
397 [[ ${module_aliases} -eq 0 ]] && unset module_aliases
398 [[ ${module_additions} -eq 0 ]] && unset module_additions
399 [[ ${module_examples} -eq 0 ]] && unset module_examples
400
401 # If we specify we dont want it, then lets exit, otherwise we assume
402 # that if its set, we do want it.
403 [[ ${module_enabled} == no ]] && return 0
404
405 # unset any unwanted variables.
406 for t in ${!module_*}
407 do
408 [[ -z ${!t} ]] && unset ${t}
409 done
410
411 [[ -z ${!module_*} ]] && return 0
412
413 # OK so now if we have got this far, then we know we want to continue
414 # and generate the modules.d file.
415 module_modinfo="$(modinfo -p ${currm_path}.${KV_OBJ})"
416 module_config="${T}/modulesd-${currm}"
417
418 ebegin "Preparing file for modules.d"
419 #-----------------------------------------------------------------------
420 echo "# modules.d configuration file for ${currm}" >> ${module_config}
421 #-----------------------------------------------------------------------
422 [[ -n ${module_docs} ]] && \
423 echo "# For more information please read:" >> ${module_config}
424 for t in ${module_docs}
425 do
426 echo "# ${t//*\/}" >> ${module_config}
427 done
428 echo >> ${module_config}
429
430 #-----------------------------------------------------------------------
431 if [[ ${module_aliases} -gt 0 ]]
432 then
433 echo "# Internal Aliases - Do not edit" >> ${module_config}
434 echo "# ------------------------------" >> ${module_config}
435
436 for((t=0; t<${module_aliases}; t++))
437 do
438 echo "alias $(eval echo \${MODULESD_${currm}_ALIASES[$t]})" \
439 >> ${module_config}
440 done
441 echo '' >> ${module_config}
442 fi
443
444 #-----------------------------------------------------------------------
445 if [[ -n ${module_modinfo} ]]
446 then
447 echo >> ${module_config}
448 echo "# Configurable module parameters" >> ${module_config}
449 echo "# ------------------------------" >> ${module_config}
450 myIFS="${IFS}"
451 IFS="$(echo -en "\n\b")"
452
453 for t in ${module_modinfo}
454 do
455 myVAR="$(echo ${t#*:} | grep -e " [0-9][ =]" | sed "s:.*\([01][= ]\).*:\1:")"
456 if [[ -n ${myVAR} ]]
457 then
458 module_opts="${module_opts} ${t%%:*}:${myVAR}"
459 fi
460 echo -e "# ${t%%:*}:\t${t#*:}" >> ${module_config}
461 done
462 IFS="${myIFS}"
463 echo '' >> ${module_config}
464 fi
465
466 #-----------------------------------------------------------------------
467 if [[ $(eval echo \${MODULESD_${currm}_ALIASES[0]}) == guess ]]
468 then
469 # So lets do some guesswork eh?
470 if [[ -n ${module_opts} ]]
471 then
472 echo "# For Example..." >> ${module_config}
473 echo "# --------------" >> ${module_config}
474 for t in ${module_opts}
475 do
476 echo "# options ${currm} ${t//:*}=${t//*:}" >> ${module_config}
477 done
478 echo '' >> ${module_config}
479 fi
480 elif [[ ${module_examples} -gt 0 ]]
481 then
482 echo "# For Example..." >> ${module_config}
483 echo "# --------------" >> ${module_config}
484 for((t=0; t<${module_examples}; t++))
485 do
486 echo "options $(eval echo \${MODULESD_${currm}_EXAMPLES[$t]})" \
487 >> ${module_config}
488 done
489 echo '' >> ${module_config}
490 fi
491
492 #-----------------------------------------------------------------------
493 if [[ ${module_additions} -gt 0 ]]
494 then
495 for((t=0; t<${module_additions}; t++))
496 do
497 echo "$(eval echo \${MODULESD_${currm}_ADDITIONS[$t]})" \
498 >> ${module_config}
499 done
500 echo '' >> ${module_config}
501 fi
502
503 #-----------------------------------------------------------------------
504
505 # then we install it
506 if kernel_is ge 2 6; then
507 insinto /etc/modprobe.d
508 else
509 insinto /etc/modules.d
510 fi
511 newins ${module_config} ${currm_path//*\/}
512
513 # and install any documentation we might have.
514 [[ -n ${module_docs} ]] && dodoc ${module_docs}
515 done
516 eend 0
517 return 0
518}
519
520# internal function
521#
522# FUNCTION: find_module_params
523# USAGE: A string "NAME(LIBDIR:SRCDIR:OBJDIR)"
524# RETURN: The string "modulename:NAME libdir:LIBDIR srcdir:SRCDIR objdir:OBJDIR"
525# DESCRIPTION:
526# Analyze the specification NAME(LIBDIR:SRCDIR:OBJDIR) of one module as described in MODULE_NAMES.
527find_module_params() {
528 debug-print-function ${FUNCNAME} $*
529
530 local matched_offset=0 matched_opts=0 test="${@}" temp_var result
531 local i=0 y=0 z=0
532
533 for((i=0; i<=${#test}; i++))
534 do
535 case ${test:${i}:1} in
536 \() matched_offset[0]=${i};;
537 \:) matched_opts=$((${matched_opts} + 1));
538 matched_offset[${matched_opts}]="${i}";;
539 \)) matched_opts=$((${matched_opts} + 1));
540 matched_offset[${matched_opts}]="${i}";;
541 esac
542 done
543
544 for((i=0; i<=${matched_opts}; i++))
545 do
546 # i = offset were working on
547 # y = last offset
548 # z = current offset - last offset
549 # temp_var = temporary name
550 case ${i} in
551 0) tempvar=${test:0:${matched_offset[0]}};;
552 *) y=$((${matched_offset[$((${i} - 1))]} + 1))
553 z=$((${matched_offset[${i}]} - ${matched_offset[$((${i} - 1))]}));
554 z=$((${z} - 1))
555 tempvar=${test:${y}:${z}};;
556 esac
557
558 case ${i} in
559 0) result="${result} modulename:${tempvar}";;
560 1) result="${result} libdir:${tempvar}";;
561 2) result="${result} srcdir:${tempvar}";;
562 3) result="${result} objdir:${tempvar}";;
563 esac
564 done
565
566 echo ${result}
567}
568
569# default ebuild functions
570# --------------------------------
571
572# @FUNCTION: linux-mod_pkg_setup
573# @DESCRIPTION:
574# It checks the CONFIG_CHECK options (see linux-info.eclass(5)), verifies that the kernel is
575# configured, verifies that the sources are prepared, verifies that the modules support is builtin
576# in the kernel and sets the object extension KV_OBJ.
577linux-mod_pkg_setup() {
578 debug-print-function ${FUNCNAME} $*
579
580 linux-info_pkg_setup;
581 require_configured_kernel
582 check_kernel_built;
583 strip_modulenames;
584 [[ -n ${MODULE_NAMES} ]] && check_modules_supported
585 set_kvobj;
586 # Commented out with permission from johnm until a fixed version for arches
587 # who intentionally use different kernel and userland compilers can be
588 # introduced - Jason Wever <weeve@gentoo.org>, 23 Oct 2005
589 #check_vermagic;
590}
591
592strip_modulenames() {
593 debug-print-function ${FUNCNAME} $*
594
595 local i
596 for i in ${MODULE_IGNORE}; do
597 MODULE_NAMES=${MODULE_NAMES//${i}(*}
598 done
599}
600
601# @FUNCTION: linux-mod_src_compile
602# @DESCRIPTION:
603# It compiles all the modules specified in MODULE_NAMES. For each module the econf command is
604# executed only if ECONF_PARAMS is defined, the name of the target is specified by BUILD_TARGETS
605# while the options are in BUILD_PARAMS (all the modules share these variables). The compilation
606# happens inside ${srcdir}.
607#
608# Look at the description of these variables for more details.
609linux-mod_src_compile() {
610 debug-print-function ${FUNCNAME} $*
611
612 local modulename libdir srcdir objdir i n myABI="${ABI}"
613 set_arch_to_kernel
614 ABI="${KERNEL_ABI}"
615
616 BUILD_TARGETS=${BUILD_TARGETS:-clean module}
617 strip_modulenames;
618 cd "${S}"
93 for i in ${MODULE_NAMES} 619 for i in ${MODULE_NAMES}
94 do 620 do
95 module_temp="$(echo ${i} | sed -e "s:.*(\(.*\)):\1:")" 621 unset libdir srcdir objdir
96 modulename="${i/(*/}" 622 for n in $(find_module_params ${i})
97 moduledir="${module_temp/:*/}" 623 do
98 moduledir="${moduledir:-misc}" 624 eval ${n/:*}=${n/*:/}
99 sourcedir="${module_temp/*:/}" 625 done
626 libdir=${libdir:-misc}
100 sourcedir="${sourcedir:-${S}}" 627 srcdir=${srcdir:-${S}}
101 628 objdir=${objdir:-${srcdir}}
102 einfo " # echo \"${modulename}\" >> ${file}" 629
630 if [ ! -f "${srcdir}/.built" ];
631 then
632 cd ${srcdir}
633 einfo "Preparing ${modulename} module"
634 if [[ -n ${ECONF_PARAMS} ]]
635 then
636 econf ${ECONF_PARAMS} || \
637 die "Unable to run econf ${ECONF_PARAMS}"
638 fi
639
640 # This looks messy, but it is needed to handle multiple variables
641 # being passed in the BUILD_* stuff where the variables also have
642 # spaces that must be preserved. If don't do this, then the stuff
643 # inside the variables gets used as targets for Make, which then
644 # fails.
645 eval "emake HOSTCC=\"$(tc-getBUILD_CC)\" \
646 CROSS_COMPILE=${CHOST}- \
647 LDFLAGS=\"$(get_abi_LDFLAGS)\" \
648 ${BUILD_FIXES} \
649 ${BUILD_PARAMS} \
650 ${BUILD_TARGETS} " \
651 || die "Unable to emake HOSTCC="$(tc-getBUILD_CC)" CROSS_COMPILE=${CHOST}- LDFLAGS="$(get_abi_LDFLAGS)" ${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS}"
652 cd ${OLDPWD}
653 touch ${srcdir}/.built
654 fi
103 done 655 done
104 echo
105}
106 656
107# default ebuild functions 657 set_arch_to_portage
108# -------------------------------- 658 ABI="${myABI}"
109
110linux-mod_pkg_setup() {
111 linux-info_pkg_setup;
112 check_kernel_built;
113 check_modules_supported;
114 check_extra_config;
115 set_kvobj;
116} 659}
117 660
661# @FUNCTION: linux-mod_src_install
662# @DESCRIPTION:
663# It install the modules specified in MODULES_NAME. The modules should be inside the ${objdir}
664# directory and they are installed inside /lib/modules/${KV_FULL}/${libdir}.
665#
666# The modprobe.d/modules.d configuration file is automatically generated if the
667# MODULESD_<modulename>_* variables are defined. The only way to stop this process is by
668# setting MODULESD_<modulename>_ENABLED=no. At the end the documentation specified via
669# MODULESD_<modulename>_DOCS is also installed.
670#
671# Look at the description of these variables for more details.
118linux-mod_src_compile() { 672linux-mod_src_install() {
119 local modulename moduledir sourcedir module_temp xarch i 673 debug-print-function ${FUNCNAME} $*
120 xarch="${ARCH}"
121 unset ARCH
122 674
675 local modulename libdir srcdir objdir i n
676
677 strip_modulenames;
123 for i in "${MODULE_NAMES}" 678 for i in ${MODULE_NAMES}
124 do 679 do
125 module_temp="$(echo ${i} | sed -e "s:.*(\(.*\)):\1:")" 680 unset libdir srcdir objdir
126 modulename="${i/(*/}" 681 for n in $(find_module_params ${i})
127 moduledir="${module_temp/:*/}" 682 do
128 moduledir="${moduledir:-misc}" 683 eval ${n/:*}=${n/*:/}
129 sourcedir="${module_temp/*:/}" 684 done
685 libdir=${libdir:-misc}
130 sourcedir="${sourcedir:-${S}}" 686 srcdir=${srcdir:-${S}}
131 687 objdir=${objdir:-${srcdir}}
688
132 einfo "Preparing ${modulename} module" 689 einfo "Installing ${modulename} module"
133 cd ${sourcedir} 690 cd ${objdir} || die "${objdir} does not exist"
134 emake ${BUILD_PARAMS} ${BUILD_TARGETS:-clean module} || die Unable to make ${BUILD_PARAMS} ${BUILD_TARGETS:-clean module}. 691 insinto /lib/modules/${KV_FULL}/${libdir}
692 doins ${modulename}.${KV_OBJ} || die "doins ${modulename}.${KV_OBJ} failed"
693 cd ${OLDPWD}
694
695 generate_modulesd ${objdir}/${modulename}
135 done 696 done
136 ARCH="${xarch}"
137} 697}
138 698
699# @FUNCTION: linux-mod_pkg_preinst
700# @DESCRIPTION:
701# It checks what to do after having merged the package.
139linux-mod_src_install() { 702linux-mod_pkg_preinst() {
140 local modulename moduledir sourcedir module_temp i 703 debug-print-function ${FUNCNAME} $*
141 704
142 for i in "${MODULE_NAMES}" 705 [ -d "${D}lib/modules" ] && UPDATE_DEPMOD=true || UPDATE_DEPMOD=false
143 do 706 [ -d "${D}etc/modules.d" ] && UPDATE_MODULES=true || UPDATE_MODULES=false
144 module_temp="$(echo ${i} | sed -e "s:.*(\(.*\)):\1:")" 707 [ -d "${D}lib/modules" ] && UPDATE_MODULEDB=true || UPDATE_MODULEDB=false
145 modulename="${i/(*/}"
146 moduledir="${module_temp/:*/}"
147 moduledir="${moduledir:-misc}"
148 sourcedir="${module_temp/*:/}"
149 sourcedir="${sourcedir:-${S}}"
150
151 einfo "Installing ${modulename} module"
152 cd ${sourcedir}
153 insinto /lib/modules/${KV_FULL}/${moduledir}
154 doins ${modulename}.${KV_OBJ}
155 done
156} 708}
157 709
710# @FUNCTION: linux-mod_pkg_postinst
711# @DESCRIPTION:
712# It executes /sbin/depmod and adds the package to the /var/lib/module-rebuild/moduledb
713# database (if ${D}/lib/modules is created) and it runs /sbin/update-modules
714# (if ${D}/etc/modules.d is created).
158linux-mod_pkg_postinst() { 715linux-mod_pkg_postinst() {
159 update_depmod; 716 debug-print-function ${FUNCNAME} $*
160 update_modules; 717
161 display_postinst; 718 ${UPDATE_DEPMOD} && update_depmod;
719 ${UPDATE_MODULES} && update_modules;
720 ${UPDATE_MODULEDB} && update_moduledb;
162} 721}
722
723# @FUNCTION: linux-mod_pkg_postrm
724# @DESCRIPTION:
725# It removes the package from the /var/lib/module-rebuild/moduledb database but it doens't
726# call /sbin/depmod and /sbin/update-modules because the modules are still installed.
727linux-mod_pkg_postrm() {
728 debug-print-function ${FUNCNAME} $*
729 remove_moduledb;
730}

Legend:
Removed from v.1.8  
changed lines
  Added in v.1.88

  ViewVC Help
Powered by ViewVC 1.1.20