/[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.111
1# Copyright 1999-2004 Gentoo Foundation 1# Copyright 1999-2012 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.111 2013/03/26 07:36:11 ssuominen Exp $
4 4
5# This eclass provides functions for compiling external kernel modules 5# @ECLASS: linux-mod.eclass
6# from source. 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.
7 17
8inherit linux-info 18# A Couple of env vars are available to effect usage of this eclass
9ECLASS=linux-mod 19# These are as follows:
10INHERITED="$INHERITED $ECLASS"
11EXPORT_FUNCTIONS pkg_setup pkg_postinst src_compile
12 20
13DESCRIPTION="Based on the $ECLASS eclass" 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
125inherit eutils linux-info multilib
126EXPORT_FUNCTIONS pkg_setup pkg_preinst pkg_postinst src_install src_compile pkg_postrm
127
128IUSE="kernel_linux"
14SLOT=0 129SLOT="0"
15DEPEND="virtual/linux-sources 130if ! [[ ${PN} == kmod ]]; then
131 RDEPEND="kernel_linux? ( virtual/modutils )"
132 DEPEND="${RDEPEND}
16 sys-apps/sed" 133 sys-apps/sed
17 134 kernel_linux? ( virtual/linux-sources )"
18 135fi
19# This eclass is designed to help ease the installation of external kernel
20# modules into the kernel tree.
21
22 136
23# eclass utilities 137# eclass utilities
24# ---------------------------------- 138# ----------------------------------
25 139
140check_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.
26use_m() { 183use_m() {
184 debug-print-function ${FUNCNAME} $*
185
27 # if we haven't determined the version yet, we need too. 186 # if we haven't determined the version yet, we need too.
28 get_version; 187 get_version;
29 188
30 # if the kernel version is greater than 2.6.6 then we should use 189 # if the kernel version is greater than 2.6.6 then we should use
31 # M= instead of SUBDIR= 190 # M= instead of SUBDIRS=
191 [ ${KV_MAJOR} -eq 3 ] && return 0
32 [ ${KV_MAJOR} -eq 2 -a ${KV_MINOR} -gt 5 -a ${KV_PATCH} -gt 5 ] && \ 192 [ ${KV_MAJOR} -eq 2 -a ${KV_MINOR} -gt 5 -a ${KV_PATCH} -gt 5 ] && \
33 return 0 || return 1 193 return 0 || return 1
34} 194}
35 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=
36convert_to_m() { 200convert_to_m() {
37 [ ! -f "${1}" ] && die "convert_to_m() requires a filename as an argument" 201 debug-print-function ${FUNCNAME} $*
202
38 if use_m 203 if use_m
39 then 204 then
205 [ ! -f "${1}" ] && \
206 die "convert_to_m() requires a filename as an argument"
40 ebegin "Converting ${1/${WORKDIR}\//} to use M= instead of SUBDIR=" 207 ebegin "Converting ${1/${WORKDIR}\//} to use M= instead of SUBDIRS="
41 sed -i 's:SUBDIRS=:M=:g' ${1} 208 sed -i 's:SUBDIRS=:M=:g' "${1}"
42 eend $? 209 eend $?
43 fi 210 fi
44} 211}
45 212
213# internal function
214#
215# FUNCTION: update_depmod
216# DESCRIPTION:
217# It updates the modules.dep file for the current kernel.
46update_depmod() { 218update_depmod() {
219 debug-print-function ${FUNCNAME} $*
220
47 # if we haven't determined the version yet, we need too. 221 # if we haven't determined the version yet, we need too.
48 get_version; 222 get_version;
49 223
50 ebegin "Updating module dependencies for ${KV_FULL}" 224 ebegin "Updating module dependencies for ${KV_FULL}"
51 if [ -r ${KV_OUT_DIR}/System.map ] 225 if [ -r "${KV_OUT_DIR}"/System.map ]
52 then 226 then
53 depmod -ae -F ${KV_OUT_DIR}/System.map -b ${ROOT} -r ${KV_FULL} 227 depmod -ae -F "${KV_OUT_DIR}"/System.map -b "${ROOT}" ${KV_FULL}
228 eend $?
54 else 229 else
55 ewarn 230 ewarn
56 ewarn "${KV_OUT_DIR}/System.map not found." 231 ewarn "${KV_OUT_DIR}/System.map not found."
57 ewarn "You must manually update the kernel module dependencies using depmod." 232 ewarn "You must manually update the kernel module dependencies using depmod."
233 eend 1
58 ewarn 234 ewarn
59 fi 235 fi
60 eend $?
61} 236}
62 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.
243move_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.
63update_modules() { 263update_moduledb() {
64 if [ -x /sbin/modules-update ] ; 264 debug-print-function ${FUNCNAME} $*
65 then
66 ebegin "Updating modules.conf"
67 /sbin/modules-update
68 eend $?
69 fi
70}
71 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.
286remove_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.
72set_kvobj() { 301set_kvobj() {
302 debug-print-function ${FUNCNAME} $*
303
73 if kernel_is 2 6 304 if kernel_is ge 2 6
74 then 305 then
75 KV_OBJ="ko" 306 KV_OBJ="ko"
76 else 307 else
77 KV_OBJ="o" 308 KV_OBJ="o"
78 fi 309 fi
310 # Do we really need to know this?
311 # Lets silence it.
79 einfo "Using KV_OBJ=${KV_OBJ}" 312 # einfo "Using KV_OBJ=${KV_OBJ}"
80} 313}
81 314
82display_postinst() { 315get-KERNEL_CC() {
83 # if we haven't determined the version yet, we need too. 316 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 317
91 einfo "If you would like to load this module automatically upon boot" 318 if [[ -n ${KERNEL_CC} ]] ; then
92 einfo "please type the following as root:" 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.
347generate_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.
495find_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.
545linux-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.
578linux-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
591strip_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.
608linux-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
93 for i in ${MODULE_NAMES} 619 for i in ${MODULE_NAMES}
94 do 620 do
95 module_temp="$(echo ${i} | sed -e "s:.*(\(.*\)):\1:")" 621 unset libdir srcdir objdir
96 modulename="${i/(*/}" 622 for n in $(find_module_params ${i})
97 moduledir="${module_temp/:*/}" 623 do
98 moduledir="${moduledir:-misc}" 624 eval ${n/:*}=${n/*:/}
99 sourcedir="${module_temp/*:/}" 625 done
626 libdir=${libdir:-misc}
100 sourcedir="${sourcedir:-${S}}" 627 srcdir=${srcdir:-${S}}
101 628 objdir=${objdir:-${srcdir}}
102 einfo " # echo \"${modulename}\" >> ${file}" 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
103 done 656 done
104 echo
105}
106 657
107# default ebuild functions 658 set_arch_to_portage
108# -------------------------------- 659 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} 660}
117 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.
118linux-mod_src_compile() { 673linux-mod_src_install() {
119 local modulename moduledir sourcedir module_temp xarch i 674 debug-print-function ${FUNCNAME} $*
120 xarch="${ARCH}"
121 unset ARCH
122 675
676 local modulename libdir srcdir objdir i n
677
678 strip_modulenames;
123 for i in "${MODULE_NAMES}" 679 for i in ${MODULE_NAMES}
124 do 680 do
125 module_temp="$(echo ${i} | sed -e "s:.*(\(.*\)):\1:")" 681 unset libdir srcdir objdir
126 modulename="${i/(*/}" 682 for n in $(find_module_params ${i})
127 moduledir="${module_temp/:*/}" 683 do
128 moduledir="${moduledir:-misc}" 684 eval ${n/:*}=${n/*:/}
129 sourcedir="${module_temp/*:/}" 685 done
686 libdir=${libdir:-misc}
130 sourcedir="${sourcedir:-${S}}" 687 srcdir=${srcdir:-${S}}
131 688 objdir=${objdir:-${srcdir}}
689
132 einfo "Preparing ${modulename} module" 690 einfo "Installing ${modulename} module"
133 cd ${sourcedir} 691 cd "${objdir}" || die "${objdir} does not exist"
134 emake clean || die Unable to make clean. 692 insinto /lib/modules/${KV_FULL}/${libdir}
135 emake ${BUILD_PARAMS} module || die Unable to make ${BUILD_PARAMS} module. 693 doins ${modulename}.${KV_OBJ} || die "doins ${modulename}.${KV_OBJ} failed"
694 cd "${OLDPWD}"
695
696 generate_modulesd "${objdir}/${modulename}"
136 done 697 done
137 ARCH="${xarch}"
138} 698}
139 699
700# @FUNCTION: linux-mod_pkg_preinst
701# @DESCRIPTION:
702# It checks what to do after having merged the package.
140linux-mod_src_install() { 703linux-mod_pkg_preinst() {
141 local modulename moduledir sourcedir module_temp i 704 debug-print-function ${FUNCNAME} $*
142 705
143 for i in "${MODULE_NAMES}" 706 [ -d "${D}lib/modules" ] && UPDATE_DEPMOD=true || UPDATE_DEPMOD=false
144 do 707 [ -d "${D}lib/modules" ] && UPDATE_MODULEDB=true || UPDATE_MODULEDB=false
145 module_temp="$(echo ${i} | sed -e "s:.*(\(.*\)):\1:")"
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} 708}
158 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)"
159linux-mod_pkg_postinst() { 714linux-mod_pkg_postinst() {
160 update_depmod; 715 debug-print-function ${FUNCNAME} $*
161 update_modules; 716
162 display_postinst; 717 ${UPDATE_DEPMOD} && update_depmod;
718 ${UPDATE_MODULEDB} && update_moduledb;
163} 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.
725linux-mod_pkg_postrm() {
726 debug-print-function ${FUNCNAME} $*
727 remove_moduledb;
728}

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

  ViewVC Help
Powered by ViewVC 1.1.20