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

Contents of /eclass/linux-mod.eclass

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.109 - (show annotations) (download)
Sun Mar 24 09:54:12 2013 UTC (15 months, 2 weeks ago) by ssuominen
Branch: MAIN
Changes since 1.108: +14 -42 lines
Remove support for module-init-tools and Linux 2.4. Only works with kmod and 2.6 now.

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

  ViewVC Help
Powered by ViewVC 1.1.20