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

Contents of /eclass/linux-mod.eclass

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.108 - (show annotations) (download)
Sat Sep 15 16:16:53 2012 UTC (23 months ago) by zmedico
Branch: MAIN
Changes since 1.107: +1 -2 lines
Remove redundant DESCRIPTION variable settings.

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

  ViewVC Help
Powered by ViewVC 1.1.20