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

Contents of /eclass/linux-mod.eclass

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.91 - (show annotations) (download)
Sat Nov 1 23:19:15 2008 UTC (5 years, 9 months ago) by dsd
Branch: MAIN
Changes since 1.90: +4 -5 lines
documentation tweaks from Fabio Rossi

1 # Copyright 1999-2004 Gentoo Foundation
2 # Distributed under the terms of the GNU General Public License v2
3 # $Header: /var/cvsroot/gentoo-x86/eclass/linux-mod.eclass,v 1.90 2008/11/01 14:56:59 gengor Exp $
4
5 # Author(s): John Mylchreest <johnm@gentoo.org>,
6 # Stefan Schweizer <genstef@gentoo.org>
7 # Maintainer: kernel-misc@gentoo.org
8 #
9 # Please direct your bugs to the current eclass maintainer :)
10
11 # @ECLASS: linux-mod.eclass
12 # @MAINTAINER:
13 # kernel-misc@gentoo.org
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.
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 # The structure of each MODULE_NAMES entry is as follows:
48 #
49 # modulename(libdir:srcdir:objdir)
50 #
51 # where:
52 #
53 # modulename = name of the module file excluding the .ko
54 # libdir = place in system modules directory where module is installed (by default it's misc)
55 # srcdir = place for ebuild to cd to before running make (by default it's ${S})
56 # objdir = place the .ko and objects are located after make runs (by default it's set to srcdir)
57 #
58 # To get an idea of how these variables are used, here's a few lines
59 # of code from around line 540 in this eclass:
60 #
61 # einfo "Installing ${modulename} module"
62 # cd ${objdir} || die "${objdir} does not exist"
63 # insinto /lib/modules/${KV_FULL}/${libdir}
64 # doins ${modulename}.${KV_OBJ} || die "doins ${modulename}.${KV_OBJ} failed"
65 #
66 # For example:
67 # MODULE_NAMES="module_pci(pci:${S}/pci:${S}) module_usb(usb:${S}/usb:${S})"
68 #
69 # what this would do is
70 #
71 # cd "${S}"/pci
72 # make ${BUILD_PARAMS} ${BUILD_TARGETS}
73 # cd "${S}"
74 # insinto /lib/modules/${KV_FULL}/pci
75 # doins module_pci.${KV_OBJ}
76 #
77 # cd "${S}"/usb
78 # make ${BUILD_PARAMS} ${BUILD_TARGETS}
79 # cd "${S}"
80 # insinto /lib/modules/${KV_FULL}/usb
81 # doins module_usb.${KV_OBJ}
82
83 # There is also support for automated modprobe.d/modules.d(2.4) file generation.
84 # This can be explicitly enabled by setting any of the following variables.
85
86 # @ECLASS-VARIABLE: MODULESD_<modulename>_ENABLED
87 # @DESCRIPTION:
88 # This is used to disable the modprobe.d/modules.d file generation otherwise the file will be
89 # always generated (unless no MODULESD_<modulename>_* variable is provided). Set to "no" to disable
90 # the generation of the file and the installation of the documentation.
91
92 # @ECLASS-VARIABLE: MODULESD_<modulename>_EXAMPLES
93 # @DESCRIPTION:
94 # This is a bash array containing a list of examples which should
95 # be used. If you want us to try and take a guess set this to "guess".
96 #
97 # For each array_component it's added an options line in the modprobe.d/modules.d file
98 #
99 # options array_component
100 #
101 # where array_component is "<modulename> options" (see modprobe.conf(5))
102
103 # @ECLASS-VARIABLE: MODULESD_<modulename>_ALIASES
104 # @DESCRIPTION:
105 # This is a bash array containing a list of associated aliases.
106 #
107 # For each array_component it's added an alias line in the modprobe.d/modules.d file
108 #
109 # alias array_component
110 #
111 # where array_component is "wildcard <modulename>" (see modprobe.conf(5))
112
113 # @ECLASS-VARIABLE: MODULESD_<modulename>_ADDITIONS
114 # @DESCRIPTION:
115 # This is a bash array containing a list of additional things to
116 # add to the bottom of the file. This can be absolutely anything.
117 # Each entry is a new line.
118
119 # @ECLASS-VARIABLE: MODULESD_<modulename>_DOCS
120 # @DESCRIPTION:
121 # This is a string list which contains the full path to any associated
122 # documents for <modulename>. These files are installed in the live tree.
123
124 # @ECLASS-VARIABLE: KV_OBJ
125 # @DESCRIPTION:
126 # It's a read-only variable. It contains the extension of the kernel modules.
127
128 # The order of these is important as both of linux-info and eutils contain
129 # set_arch_to_kernel and set_arch_to_portage functions and the ones in eutils
130 # are deprecated in favor of the ones in linux-info.
131 # See http://bugs.gentoo.org/show_bug.cgi?id=127506
132
133 inherit eutils linux-info multilib
134 EXPORT_FUNCTIONS pkg_setup pkg_preinst pkg_postinst src_install src_compile pkg_postrm
135
136 IUSE="kernel_linux"
137 SLOT="0"
138 DESCRIPTION="Based on the $ECLASS eclass"
139 # Restrict distributed compile of kernel modules bugs #120001, #167844
140 RESTRICT="distcc"
141 RDEPEND="kernel_linux? ( virtual/modutils )"
142 DEPEND="${RDEPEND}
143 sys-apps/sed"
144
145 # eclass utilities
146 # ----------------------------------
147
148 check_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.
191 use_m() {
192 debug-print-function ${FUNCNAME} $*
193
194 # if we haven't determined the version yet, we need too.
195 get_version;
196
197 # if the kernel version is greater than 2.6.6 then we should use
198 # M= instead of SUBDIRS=
199 [ ${KV_MAJOR} -eq 2 -a ${KV_MINOR} -gt 5 -a ${KV_PATCH} -gt 5 ] && \
200 return 0 || return 1
201 }
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=
207 convert_to_m() {
208 debug-print-function ${FUNCNAME} $*
209
210 if use_m
211 then
212 [ ! -f "${1}" ] && \
213 die "convert_to_m() requires a filename as an argument"
214 ebegin "Converting ${1/${WORKDIR}\//} to use M= instead of SUBDIRS="
215 sed -i 's:SUBDIRS=:M=:g' ${1}
216 eend $?
217 fi
218 }
219
220 # internal function
221 #
222 # FUNCTION: update_depmod
223 # DESCRIPTION:
224 # It updates the modules.dep file for the current kernel.
225 update_depmod() {
226 debug-print-function ${FUNCNAME} $*
227
228 # if we haven't determined the version yet, we need too.
229 get_version;
230
231 ebegin "Updating module dependencies for ${KV_FULL}"
232 if [ -r ${KV_OUT_DIR}/System.map ]
233 then
234 depmod -ae -F ${KV_OUT_DIR}/System.map -b ${ROOT} -r ${KV_FULL}
235 eend $?
236 else
237 ewarn
238 ewarn "${KV_OUT_DIR}/System.map not found."
239 ewarn "You must manually update the kernel module dependencies using depmod."
240 eend 1
241 ewarn
242 fi
243 }
244
245 # internal function
246 #
247 # FUNCTION: update_modules
248 # DESCRIPTION:
249 # It calls the update-modules utility.
250 update_modules() {
251 debug-print-function ${FUNCNAME} $*
252
253 if [ -x /sbin/update-modules ] && \
254 grep -v -e "^#" -e "^$" ${D}/etc/modules.d/* >/dev/null 2>&1; then
255 ebegin "Updating modules.conf"
256 /sbin/update-modules
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 $?
263 fi
264 }
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.
271 move_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.
291 update_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.
314 remove_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.
329 set_kvobj() {
330 debug-print-function ${FUNCNAME} $*
331
332 if kernel_is 2 6
333 then
334 KV_OBJ="ko"
335 else
336 KV_OBJ="o"
337 fi
338 # Do we really need to know this?
339 # Lets silence it.
340 # einfo "Using KV_OBJ=${KV_OBJ}"
341 }
342
343 get-KERNEL_CC() {
344 debug-print-function ${FUNCNAME} $*
345
346 if [[ -n ${KERNEL_CC} ]] ; then
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.
375 generate_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.
527 find_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.
577 linux-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
592 strip_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.
609 linux-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}"
619 for i in ${MODULE_NAMES}
620 do
621 unset libdir srcdir objdir
622 for n in $(find_module_params ${i})
623 do
624 eval ${n/:*}=${n/*:/}
625 done
626 libdir=${libdir:-misc}
627 srcdir=${srcdir:-${S}}
628 objdir=${objdir:-${srcdir}}
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
655 done
656
657 set_arch_to_portage
658 ABI="${myABI}"
659 }
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.
672 linux-mod_src_install() {
673 debug-print-function ${FUNCNAME} $*
674
675 local modulename libdir srcdir objdir i n
676
677 strip_modulenames;
678 for i in ${MODULE_NAMES}
679 do
680 unset libdir srcdir objdir
681 for n in $(find_module_params ${i})
682 do
683 eval ${n/:*}=${n/*:/}
684 done
685 libdir=${libdir:-misc}
686 srcdir=${srcdir:-${S}}
687 objdir=${objdir:-${srcdir}}
688
689 einfo "Installing ${modulename} module"
690 cd ${objdir} || die "${objdir} does not exist"
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}
696 done
697 }
698
699 # @FUNCTION: linux-mod_pkg_preinst
700 # @DESCRIPTION:
701 # It checks what to do after having merged the package.
702 linux-mod_pkg_preinst() {
703 debug-print-function ${FUNCNAME} $*
704
705 [ -d "${D}lib/modules" ] && UPDATE_DEPMOD=true || UPDATE_DEPMOD=false
706 [ -d "${D}etc/modules.d" ] && UPDATE_MODULES=true || UPDATE_MODULES=false
707 [ -d "${D}lib/modules" ] && UPDATE_MODULEDB=true || UPDATE_MODULEDB=false
708 }
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).
715 linux-mod_pkg_postinst() {
716 debug-print-function ${FUNCNAME} $*
717
718 ${UPDATE_DEPMOD} && update_depmod;
719 ${UPDATE_MODULES} && update_modules;
720 ${UPDATE_MODULEDB} && update_moduledb;
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.
727 linux-mod_pkg_postrm() {
728 debug-print-function ${FUNCNAME} $*
729 remove_moduledb;
730 }

  ViewVC Help
Powered by ViewVC 1.1.20