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

Diff of /eclass/linux-mod.eclass

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

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

Legend:
Removed from v.1.6  
changed lines
  Added in v.1.102

  ViewVC Help
Powered by ViewVC 1.1.20