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

Contents of /eclass/linux-mod.eclass

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.112 - (show annotations) (download)
Tue Mar 26 08:17:26 2013 UTC (16 months ago) by ssuominen
Branch: MAIN
Changes since 1.111: +2 -2 lines
Control pulling in linux-mod dependencies based on VIRTUAL_MODUTILS variable, set in eg. sys-apps/kmod

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.111 2013/03/26 07:36:11 ssuominen 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 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 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 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 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 if [[ -z ${VIRTUAL_MODUTILS} ]]; then
131 RDEPEND="kernel_linux? ( virtual/modutils )"
132 DEPEND="${RDEPEND}
133 sys-apps/sed
134 kernel_linux? ( virtual/linux-sources )"
135 fi
136
137 # eclass utilities
138 # ----------------------------------
139
140 check_vermagic() {
141 debug-print-function ${FUNCNAME} $*
142
143 local curr_gcc_ver=$(gcc -dumpversion)
144 local tmpfile old_chost old_gcc_ver result=0
145
146 tmpfile=`find "${KV_DIR}/" -iname "*.o.cmd" -exec grep usr/lib/gcc {} \; -quit`
147 tmpfile=${tmpfile//*usr/lib}
148 tmpfile=${tmpfile//\/include*}
149 old_chost=${tmpfile//*gcc\/}
150 old_chost=${old_chost//\/*}
151 old_gcc_ver=${tmpfile//*\/}
152
153 if [[ -z ${old_gcc_ver} || -z ${old_chost} ]]; then
154 ewarn ""
155 ewarn "Unable to detect what version of GCC was used to compile"
156 ewarn "the kernel. Build will continue, but you may experience problems."
157 elif [[ ${curr_gcc_ver} != ${old_gcc_ver} ]]; then
158 ewarn ""
159 ewarn "The version of GCC you are using (${curr_gcc_ver}) does"
160 ewarn "not match the version of GCC used to compile the"
161 ewarn "kernel (${old_gcc_ver})."
162 result=1
163 elif [[ ${CHOST} != ${old_chost} ]]; then
164 ewarn ""
165 ewarn "The current CHOST (${CHOST}) does not match the chost"
166 ewarn "used when compiling the kernel (${old_chost})."
167 result=1
168 fi
169
170 if [[ ${result} -gt 0 ]]; then
171 ewarn ""
172 ewarn "Build will not continue, because you will experience problems."
173 ewarn "To fix this either change the version of GCC you wish to use"
174 ewarn "to match the kernel, or recompile the kernel first."
175 die "GCC Version Mismatch."
176 fi
177 }
178
179 # @FUNCTION: use_m
180 # @RETURN: true or false
181 # @DESCRIPTION:
182 # It checks if the kernel version is greater than 2.6.5.
183 use_m() {
184 debug-print-function ${FUNCNAME} $*
185
186 # if we haven't determined the version yet, we need too.
187 get_version;
188
189 # if the kernel version is greater than 2.6.6 then we should use
190 # M= instead of SUBDIRS=
191 [ ${KV_MAJOR} -eq 3 ] && return 0
192 [ ${KV_MAJOR} -eq 2 -a ${KV_MINOR} -gt 5 -a ${KV_PATCH} -gt 5 ] && \
193 return 0 || return 1
194 }
195
196 # @FUNCTION: convert_to_m
197 # @USAGE: /path/to/the/file
198 # @DESCRIPTION:
199 # It converts a file (e.g. a makefile) to use M= instead of SUBDIRS=
200 convert_to_m() {
201 debug-print-function ${FUNCNAME} $*
202
203 if use_m
204 then
205 [ ! -f "${1}" ] && \
206 die "convert_to_m() requires a filename as an argument"
207 ebegin "Converting ${1/${WORKDIR}\//} to use M= instead of SUBDIRS="
208 sed -i 's:SUBDIRS=:M=:g' "${1}"
209 eend $?
210 fi
211 }
212
213 # internal function
214 #
215 # FUNCTION: update_depmod
216 # DESCRIPTION:
217 # It updates the modules.dep file for the current kernel.
218 update_depmod() {
219 debug-print-function ${FUNCNAME} $*
220
221 # if we haven't determined the version yet, we need too.
222 get_version;
223
224 ebegin "Updating module dependencies for ${KV_FULL}"
225 if [ -r "${KV_OUT_DIR}"/System.map ]
226 then
227 depmod -ae -F "${KV_OUT_DIR}"/System.map -b "${ROOT}" ${KV_FULL}
228 eend $?
229 else
230 ewarn
231 ewarn "${KV_OUT_DIR}/System.map not found."
232 ewarn "You must manually update the kernel module dependencies using depmod."
233 eend 1
234 ewarn
235 fi
236 }
237
238 # internal function
239 #
240 # FUNCTION: move_old_moduledb
241 # DESCRIPTION:
242 # It updates the location of the database used by the module-rebuild utility.
243 move_old_moduledb() {
244 debug-print-function ${FUNCNAME} $*
245
246 local OLDDIR="${ROOT}"/usr/share/module-rebuild/
247 local NEWDIR="${ROOT}"/var/lib/module-rebuild/
248
249 if [[ -f "${OLDDIR}"/moduledb ]]; then
250 [[ ! -d "${NEWDIR}" ]] && mkdir -p "${NEWDIR}"
251 [[ ! -f "${NEWDIR}"/moduledb ]] && \
252 mv "${OLDDIR}"/moduledb "${NEWDIR}"/moduledb
253 rm -f "${OLDDIR}"/*
254 rmdir "${OLDDIR}"
255 fi
256 }
257
258 # internal function
259 #
260 # FUNCTION: update_moduledb
261 # DESCRIPTION:
262 # It adds the package to the /var/lib/module-rebuild/moduledb database used by the module-rebuild utility.
263 update_moduledb() {
264 debug-print-function ${FUNCNAME} $*
265
266 local MODULEDB_DIR="${ROOT}"/var/lib/module-rebuild/
267 move_old_moduledb
268
269 if [[ ! -f "${MODULEDB_DIR}"/moduledb ]]; then
270 [[ ! -d "${MODULEDB_DIR}" ]] && mkdir -p "${MODULEDB_DIR}"
271 touch "${MODULEDB_DIR}"/moduledb
272 fi
273
274 if ! grep -qs ${CATEGORY}/${PN}-${PVR} "${MODULEDB_DIR}"/moduledb ; then
275 einfo "Adding module to moduledb."
276 echo "a:1:${CATEGORY}/${PN}-${PVR}" >> "${MODULEDB_DIR}"/moduledb
277 fi
278 }
279
280 # internal function
281 #
282 # FUNCTION: remove_moduledb
283 # DESCRIPTION:
284 # It removes the package from the /var/lib/module-rebuild/moduledb database used by
285 # the module-rebuild utility.
286 remove_moduledb() {
287 debug-print-function ${FUNCNAME} $*
288
289 local MODULEDB_DIR="${ROOT}"/var/lib/module-rebuild/
290 move_old_moduledb
291
292 if grep -qs ${CATEGORY}/${PN}-${PVR} "${MODULEDB_DIR}"/moduledb ; then
293 einfo "Removing ${CATEGORY}/${PN}-${PVR} from moduledb."
294 sed -i -e "/.*${CATEGORY}\/${PN}-${PVR}.*/d" "${MODULEDB_DIR}"/moduledb
295 fi
296 }
297
298 # @FUNCTION: set_kvobj
299 # @DESCRIPTION:
300 # It sets the KV_OBJ variable.
301 set_kvobj() {
302 debug-print-function ${FUNCNAME} $*
303
304 if kernel_is ge 2 6
305 then
306 KV_OBJ="ko"
307 else
308 KV_OBJ="o"
309 fi
310 # Do we really need to know this?
311 # Lets silence it.
312 # einfo "Using KV_OBJ=${KV_OBJ}"
313 }
314
315 get-KERNEL_CC() {
316 debug-print-function ${FUNCNAME} $*
317
318 if [[ -n ${KERNEL_CC} ]] ; then
319 echo "${KERNEL_CC}"
320 return
321 fi
322
323 local kernel_cc
324 if [ -n "${KERNEL_ABI}" ]; then
325 # In future, an arch might want to define CC_$ABI
326 #kernel_cc="$(get_abi_CC)"
327 #[ -z "${kernel_cc}" ] &&
328 kernel_cc="$(tc-getCC $(ABI=${KERNEL_ABI} get_abi_CHOST))"
329 else
330 kernel_cc=$(tc-getCC)
331 fi
332 echo "${kernel_cc}"
333 }
334
335 # internal function
336 #
337 # FUNCTION:
338 # USAGE: /path/to/the/modulename_without_extension
339 # RETURN: A file in /etc/modprobe.d
340 # DESCRIPTION:
341 # This function will generate and install the neccessary modprobe.d file from the
342 # information contained in the modules exported parms.
343 # (see the variables MODULESD_<modulename>_ENABLED, MODULESD_<modulename>_EXAMPLES,
344 # MODULESD_<modulename>_ALIASES, MODULESD_<modulename>_ADDITION and MODULESD_<modulename>_DOCS).
345 #
346 # At the end the documentation specified with MODULESD_<modulename>_DOCS is installed.
347 generate_modulesd() {
348 debug-print-function ${FUNCNAME} $*
349
350 local currm_path currm currm_t t myIFS myVAR
351 local module_docs module_enabled module_aliases \
352 module_additions module_examples module_modinfo module_opts
353
354 for currm_path in ${@}
355 do
356 currm=${currm_path//*\/}
357 currm=$(echo ${currm} | tr '[:lower:]' '[:upper:]')
358 currm_t=${currm}
359 while [[ -z ${currm_t//*-*} ]]; do
360 currm_t=${currm_t/-/_}
361 done
362
363 module_docs="$(eval echo \${MODULESD_${currm_t}_DOCS})"
364 module_enabled="$(eval echo \${MODULESD_${currm_t}_ENABLED})"
365 module_aliases="$(eval echo \${#MODULESD_${currm_t}_ALIASES[*]})"
366 module_additions="$(eval echo \${#MODULESD_${currm_t}_ADDITIONS[*]})"
367 module_examples="$(eval echo \${#MODULESD_${currm_t}_EXAMPLES[*]})"
368
369 [[ ${module_aliases} -eq 0 ]] && unset module_aliases
370 [[ ${module_additions} -eq 0 ]] && unset module_additions
371 [[ ${module_examples} -eq 0 ]] && unset module_examples
372
373 # If we specify we dont want it, then lets exit, otherwise we assume
374 # that if its set, we do want it.
375 [[ ${module_enabled} == no ]] && return 0
376
377 # unset any unwanted variables.
378 for t in ${!module_*}
379 do
380 [[ -z ${!t} ]] && unset ${t}
381 done
382
383 [[ -z ${!module_*} ]] && return 0
384
385 # OK so now if we have got this far, then we know we want to continue
386 # and generate the modprobe.d file.
387 module_modinfo="$(modinfo -p ${currm_path}.${KV_OBJ})"
388 module_config="${T}/modulesd-${currm}"
389
390 ebegin "Preparing file for modprobe.d"
391 #-----------------------------------------------------------------------
392 echo "# modprobe.d configuration file for ${currm}" >> "${module_config}"
393 #-----------------------------------------------------------------------
394 [[ -n ${module_docs} ]] && \
395 echo "# For more information please read:" >> "${module_config}"
396 for t in ${module_docs}
397 do
398 echo "# ${t//*\/}" >> "${module_config}"
399 done
400 echo >> "${module_config}"
401
402 #-----------------------------------------------------------------------
403 if [[ ${module_aliases} -gt 0 ]]
404 then
405 echo "# Internal Aliases - Do not edit" >> "${module_config}"
406 echo "# ------------------------------" >> "${module_config}"
407
408 for((t=0; t<${module_aliases}; t++))
409 do
410 echo "alias $(eval echo \${MODULESD_${currm}_ALIASES[$t]})" \
411 >> "${module_config}"
412 done
413 echo '' >> "${module_config}"
414 fi
415
416 #-----------------------------------------------------------------------
417 if [[ -n ${module_modinfo} ]]
418 then
419 echo >> "${module_config}"
420 echo "# Configurable module parameters" >> "${module_config}"
421 echo "# ------------------------------" >> "${module_config}"
422 myIFS="${IFS}"
423 IFS="$(echo -en "\n\b")"
424
425 for t in ${module_modinfo}
426 do
427 myVAR="$(echo ${t#*:} | grep -e " [0-9][ =]" | sed "s:.*\([01][= ]\).*:\1:")"
428 if [[ -n ${myVAR} ]]
429 then
430 module_opts="${module_opts} ${t%%:*}:${myVAR}"
431 fi
432 echo -e "# ${t%%:*}:\t${t#*:}" >> "${module_config}"
433 done
434 IFS="${myIFS}"
435 echo '' >> "${module_config}"
436 fi
437
438 #-----------------------------------------------------------------------
439 if [[ $(eval echo \${MODULESD_${currm}_ALIASES[0]}) == guess ]]
440 then
441 # So lets do some guesswork eh?
442 if [[ -n ${module_opts} ]]
443 then
444 echo "# For Example..." >> "${module_config}"
445 echo "# --------------" >> "${module_config}"
446 for t in ${module_opts}
447 do
448 echo "# options ${currm} ${t//:*}=${t//*:}" >> "${module_config}"
449 done
450 echo '' >> "${module_config}"
451 fi
452 elif [[ ${module_examples} -gt 0 ]]
453 then
454 echo "# For Example..." >> "${module_config}"
455 echo "# --------------" >> "${module_config}"
456 for((t=0; t<${module_examples}; t++))
457 do
458 echo "options $(eval echo \${MODULESD_${currm}_EXAMPLES[$t]})" \
459 >> "${module_config}"
460 done
461 echo '' >> "${module_config}"
462 fi
463
464 #-----------------------------------------------------------------------
465 if [[ ${module_additions} -gt 0 ]]
466 then
467 for((t=0; t<${module_additions}; t++))
468 do
469 echo "$(eval echo \${MODULESD_${currm}_ADDITIONS[$t]})" \
470 >> "${module_config}"
471 done
472 echo '' >> "${module_config}"
473 fi
474
475 #-----------------------------------------------------------------------
476
477 # then we install it
478 insinto /etc/modprobe.d
479 newins "${module_config}" "${currm_path//*\/}.conf"
480
481 # and install any documentation we might have.
482 [[ -n ${module_docs} ]] && dodoc ${module_docs}
483 done
484 eend 0
485 return 0
486 }
487
488 # internal function
489 #
490 # FUNCTION: find_module_params
491 # USAGE: A string "NAME(LIBDIR:SRCDIR:OBJDIR)"
492 # RETURN: The string "modulename:NAME libdir:LIBDIR srcdir:SRCDIR objdir:OBJDIR"
493 # DESCRIPTION:
494 # Analyze the specification NAME(LIBDIR:SRCDIR:OBJDIR) of one module as described in MODULE_NAMES.
495 find_module_params() {
496 debug-print-function ${FUNCNAME} $*
497
498 local matched_offset=0 matched_opts=0 test="${@}" temp_var result
499 local i=0 y=0 z=0
500
501 for((i=0; i<=${#test}; i++))
502 do
503 case ${test:${i}:1} in
504 \() matched_offset[0]=${i};;
505 \:) matched_opts=$((${matched_opts} + 1));
506 matched_offset[${matched_opts}]="${i}";;
507 \)) matched_opts=$((${matched_opts} + 1));
508 matched_offset[${matched_opts}]="${i}";;
509 esac
510 done
511
512 for((i=0; i<=${matched_opts}; i++))
513 do
514 # i = offset were working on
515 # y = last offset
516 # z = current offset - last offset
517 # temp_var = temporary name
518 case ${i} in
519 0) tempvar=${test:0:${matched_offset[0]}};;
520 *) y=$((${matched_offset[$((${i} - 1))]} + 1))
521 z=$((${matched_offset[${i}]} - ${matched_offset[$((${i} - 1))]}));
522 z=$((${z} - 1))
523 tempvar=${test:${y}:${z}};;
524 esac
525
526 case ${i} in
527 0) result="${result} modulename:${tempvar}";;
528 1) result="${result} libdir:${tempvar}";;
529 2) result="${result} srcdir:${tempvar}";;
530 3) result="${result} objdir:${tempvar}";;
531 esac
532 done
533
534 echo ${result}
535 }
536
537 # default ebuild functions
538 # --------------------------------
539
540 # @FUNCTION: linux-mod_pkg_setup
541 # @DESCRIPTION:
542 # It checks the CONFIG_CHECK options (see linux-info.eclass(5)), verifies that the kernel is
543 # configured, verifies that the sources are prepared, verifies that the modules support is builtin
544 # in the kernel and sets the object extension KV_OBJ.
545 linux-mod_pkg_setup() {
546 debug-print-function ${FUNCNAME} $*
547
548 local is_bin="${MERGE_TYPE}"
549
550 # If we are installing a binpkg, take a different path.
551 # use MERGE_TYPE if available (eapi>=4); else use non-PMS EMERGE_FROM (eapi<4)
552 if has ${EAPI} 0 1 2 3; then
553 is_bin=${EMERGE_FROM}
554 fi
555
556 if [[ ${is_bin} == binary ]]; then
557 linux-mod_pkg_setup_binary
558 return
559 fi
560
561 linux-info_pkg_setup;
562 require_configured_kernel
563 check_kernel_built;
564 strip_modulenames;
565 [[ -n ${MODULE_NAMES} ]] && check_modules_supported
566 set_kvobj;
567 # Commented out with permission from johnm until a fixed version for arches
568 # who intentionally use different kernel and userland compilers can be
569 # introduced - Jason Wever <weeve@gentoo.org>, 23 Oct 2005
570 #check_vermagic;
571 }
572
573 # @FUNCTION: linux-mod_pkg_setup_binary
574 # @DESCRIPTION:
575 # Perform all kernel option checks non-fatally, as the .config and
576 # /proc/config.gz might not be present. Do not do anything that requires kernel
577 # sources.
578 linux-mod_pkg_setup_binary() {
579 debug-print-function ${FUNCNAME} $*
580 local new_CONFIG_CHECK
581 # ~ needs always to be quoted, else bash expands it.
582 for config in $CONFIG_CHECK ; do
583 optional='~'
584 [[ ${config:0:1} == "~" ]] && optional=''
585 new_CONFIG_CHECK="${new_CONFIG_CHECK} ${optional}${config}"
586 done
587 export CONFIG_CHECK="${new_CONFIG_CHECK}"
588 linux-info_pkg_setup;
589 }
590
591 strip_modulenames() {
592 debug-print-function ${FUNCNAME} $*
593
594 local i
595 for i in ${MODULE_IGNORE}; do
596 MODULE_NAMES=${MODULE_NAMES//${i}(*}
597 done
598 }
599
600 # @FUNCTION: linux-mod_src_compile
601 # @DESCRIPTION:
602 # It compiles all the modules specified in MODULE_NAMES. For each module the econf command is
603 # executed only if ECONF_PARAMS is defined, the name of the target is specified by BUILD_TARGETS
604 # while the options are in BUILD_PARAMS (all the modules share these variables). The compilation
605 # happens inside ${srcdir}.
606 #
607 # Look at the description of these variables for more details.
608 linux-mod_src_compile() {
609 debug-print-function ${FUNCNAME} $*
610
611 local modulename libdir srcdir objdir i n myABI="${ABI}"
612 set_arch_to_kernel
613 ABI="${KERNEL_ABI}"
614
615 BUILD_TARGETS=${BUILD_TARGETS:-clean module}
616 strip_modulenames;
617 cd "${S}"
618 touch Module.symvers
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 ln -s "${S}"/Module.symvers Module.symvers
634 einfo "Preparing ${modulename} module"
635 if [[ -n ${ECONF_PARAMS} ]]
636 then
637 econf ${ECONF_PARAMS} || \
638 die "Unable to run econf ${ECONF_PARAMS}"
639 fi
640
641 # This looks messy, but it is needed to handle multiple variables
642 # being passed in the BUILD_* stuff where the variables also have
643 # spaces that must be preserved. If don't do this, then the stuff
644 # inside the variables gets used as targets for Make, which then
645 # fails.
646 eval "emake HOSTCC=\"$(tc-getBUILD_CC)\" \
647 CROSS_COMPILE=${CHOST}- \
648 LDFLAGS=\"$(get_abi_LDFLAGS)\" \
649 ${BUILD_FIXES} \
650 ${BUILD_PARAMS} \
651 ${BUILD_TARGETS} " \
652 || die "Unable to emake HOSTCC="$(tc-getBUILD_CC)" CROSS_COMPILE=${CHOST}- LDFLAGS="$(get_abi_LDFLAGS)" ${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS}"
653 cd "${OLDPWD}"
654 touch "${srcdir}"/.built
655 fi
656 done
657
658 set_arch_to_portage
659 ABI="${myABI}"
660 }
661
662 # @FUNCTION: linux-mod_src_install
663 # @DESCRIPTION:
664 # It install the modules specified in MODULES_NAME. The modules should be inside the ${objdir}
665 # directory and they are installed inside /lib/modules/${KV_FULL}/${libdir}.
666 #
667 # The modprobe.d configuration file is automatically generated if the
668 # MODULESD_<modulename>_* variables are defined. The only way to stop this process is by
669 # setting MODULESD_<modulename>_ENABLED=no. At the end the documentation specified via
670 # MODULESD_<modulename>_DOCS is also installed.
671 #
672 # Look at the description of these variables for more details.
673 linux-mod_src_install() {
674 debug-print-function ${FUNCNAME} $*
675
676 local modulename libdir srcdir objdir i n
677
678 strip_modulenames;
679 for i in ${MODULE_NAMES}
680 do
681 unset libdir srcdir objdir
682 for n in $(find_module_params ${i})
683 do
684 eval ${n/:*}=${n/*:/}
685 done
686 libdir=${libdir:-misc}
687 srcdir=${srcdir:-${S}}
688 objdir=${objdir:-${srcdir}}
689
690 einfo "Installing ${modulename} module"
691 cd "${objdir}" || die "${objdir} does not exist"
692 insinto /lib/modules/${KV_FULL}/${libdir}
693 doins ${modulename}.${KV_OBJ} || die "doins ${modulename}.${KV_OBJ} failed"
694 cd "${OLDPWD}"
695
696 generate_modulesd "${objdir}/${modulename}"
697 done
698 }
699
700 # @FUNCTION: linux-mod_pkg_preinst
701 # @DESCRIPTION:
702 # It checks what to do after having merged the package.
703 linux-mod_pkg_preinst() {
704 debug-print-function ${FUNCNAME} $*
705
706 [ -d "${D}lib/modules" ] && UPDATE_DEPMOD=true || UPDATE_DEPMOD=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)"
714 linux-mod_pkg_postinst() {
715 debug-print-function ${FUNCNAME} $*
716
717 ${UPDATE_DEPMOD} && update_depmod;
718 ${UPDATE_MODULEDB} && update_moduledb;
719 }
720
721 # @FUNCTION: linux-mod_pkg_postrm
722 # @DESCRIPTION:
723 # It removes the package from the /var/lib/module-rebuild/moduledb database but it doens't
724 # call /sbin/depmod because the modules are still installed.
725 linux-mod_pkg_postrm() {
726 debug-print-function ${FUNCNAME} $*
727 remove_moduledb;
728 }

  ViewVC Help
Powered by ViewVC 1.1.20