/[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.109
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.109 2013/03/24 09:54:12 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 130RDEPEND="kernel_linux? ( virtual/modutils )"
131DEPEND="${RDEPEND}
16 sys-apps/sed" 132 sys-apps/sed
17 133 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 134
23# eclass utilities 135# eclass utilities
24# ---------------------------------- 136# ----------------------------------
25 137
138check_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.
26use_m() { 181use_m() {
182 debug-print-function ${FUNCNAME} $*
183
27 # if we haven't determined the version yet, we need too. 184 # if we haven't determined the version yet, we need too.
28 get_version; 185 get_version;
29 186
30 # if the kernel version is greater than 2.6.6 then we should use 187 # if the kernel version is greater than 2.6.6 then we should use
31 # M= instead of SUBDIR= 188 # M= instead of SUBDIRS=
189 [ ${KV_MAJOR} -eq 3 ] && return 0
32 [ ${KV_MAJOR} -eq 2 -a ${KV_MINOR} -gt 5 -a ${KV_PATCH} -gt 5 ] && \ 190 [ ${KV_MAJOR} -eq 2 -a ${KV_MINOR} -gt 5 -a ${KV_PATCH} -gt 5 ] && \
33 return 0 || return 1 191 return 0 || return 1
34} 192}
35 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=
36convert_to_m() { 198convert_to_m() {
37 [ ! -f "${1}" ] && die "convert_to_m() requires a filename as an argument" 199 debug-print-function ${FUNCNAME} $*
200
38 if use_m 201 if use_m
39 then 202 then
203 [ ! -f "${1}" ] && \
204 die "convert_to_m() requires a filename as an argument"
40 ebegin "Converting ${1/${WORKDIR}\//} to use M= instead of SUBDIR=" 205 ebegin "Converting ${1/${WORKDIR}\//} to use M= instead of SUBDIRS="
41 sed -i 's:SUBDIRS=:M=:g' ${1} 206 sed -i 's:SUBDIRS=:M=:g' "${1}"
42 eend $? 207 eend $?
43 fi 208 fi
44} 209}
45 210
211# internal function
212#
213# FUNCTION: update_depmod
214# DESCRIPTION:
215# It updates the modules.dep file for the current kernel.
46update_depmod() { 216update_depmod() {
217 debug-print-function ${FUNCNAME} $*
218
47 # if we haven't determined the version yet, we need too. 219 # if we haven't determined the version yet, we need too.
48 get_version; 220 get_version;
49 221
50 ebegin "Updating module dependencies for ${KV_FULL}" 222 ebegin "Updating module dependencies for ${KV_FULL}"
51 if [ -r ${KV_OUT_DIR}/System.map ] 223 if [ -r "${KV_OUT_DIR}"/System.map ]
52 then 224 then
53 depmod -ae -F ${KV_OUT_DIR}/System.map -b ${ROOT} -r ${KV_FULL} 225 depmod -ae -F "${KV_OUT_DIR}"/System.map -b "${ROOT}" ${KV_FULL}
226 eend $?
54 else 227 else
55 ewarn 228 ewarn
56 ewarn "${KV_OUT_DIR}/System.map not found." 229 ewarn "${KV_OUT_DIR}/System.map not found."
57 ewarn "You must manually update the kernel module dependencies using depmod." 230 ewarn "You must manually update the kernel module dependencies using depmod."
231 eend 1
58 ewarn 232 ewarn
59 fi 233 fi
60 eend $?
61} 234}
62 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.
241move_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.
63update_modules() { 261update_moduledb() {
64 if [ -x /sbin/modules-update ] ; 262 debug-print-function ${FUNCNAME} $*
65 then
66 ebegin "Updating modules.conf"
67 /sbin/modules-update
68 eend $?
69 fi
70}
71 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.
284remove_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.
72set_kvobj() { 299set_kvobj() {
300 debug-print-function ${FUNCNAME} $*
301
73 if kernel_is 2 6 302 if kernel_is ge 2 6
74 then 303 then
75 KV_OBJ="ko" 304 KV_OBJ="ko"
76 else 305 else
77 KV_OBJ="o" 306 KV_OBJ="o"
78 fi 307 fi
308 # Do we really need to know this?
309 # Lets silence it.
79 einfo "Using KV_OBJ=${KV_OBJ}" 310 # einfo "Using KV_OBJ=${KV_OBJ}"
80} 311}
81 312
82display_postinst() { 313get-KERNEL_CC() {
83 # if we haven't determined the version yet, we need too. 314 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 315
91 einfo "If you would like to load this module automatically upon boot" 316 if [[ -n ${KERNEL_CC} ]] ; then
92 einfo "please type the following as root:" 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.
345generate_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.
493find_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.
543linux-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.
576linux-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
589strip_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.
606linux-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
93 for i in ${MODULE_NAMES} 617 for i in ${MODULE_NAMES}
94 do 618 do
95 module_temp="$(echo ${i} | sed -e "s:.*(\(.*\)):\1:")" 619 unset libdir srcdir objdir
96 modulename="${i/(*/}" 620 for n in $(find_module_params ${i})
97 moduledir="${module_temp/:*/}" 621 do
98 moduledir="${moduledir:-misc}" 622 eval ${n/:*}=${n/*:/}
99 sourcedir="${module_temp/*:/}" 623 done
624 libdir=${libdir:-misc}
100 sourcedir="${sourcedir:-${S}}" 625 srcdir=${srcdir:-${S}}
101 626 objdir=${objdir:-${srcdir}}
102 einfo " # echo \"${modulename}\" >> ${file}" 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
103 done 654 done
104 echo
105}
106 655
107# default ebuild functions 656 set_arch_to_portage
108# -------------------------------- 657 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} 658}
117 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.
118linux-mod_src_compile() { 671linux-mod_src_install() {
119 local modulename moduledir sourcedir module_temp xarch i 672 debug-print-function ${FUNCNAME} $*
120 xarch="${ARCH}"
121 unset ARCH
122 673
674 local modulename libdir srcdir objdir i n
675
676 strip_modulenames;
123 for i in "${MODULE_NAMES}" 677 for i in ${MODULE_NAMES}
124 do 678 do
125 module_temp="$(echo ${i} | sed -e "s:.*(\(.*\)):\1:")" 679 unset libdir srcdir objdir
126 modulename="${i/(*/}" 680 for n in $(find_module_params ${i})
127 moduledir="${module_temp/:*/}" 681 do
128 moduledir="${moduledir:-misc}" 682 eval ${n/:*}=${n/*:/}
129 sourcedir="${module_temp/*:/}" 683 done
684 libdir=${libdir:-misc}
130 sourcedir="${sourcedir:-${S}}" 685 srcdir=${srcdir:-${S}}
131 686 objdir=${objdir:-${srcdir}}
687
132 einfo "Preparing ${modulename} module" 688 einfo "Installing ${modulename} module"
133 cd ${sourcedir} 689 cd "${objdir}" || die "${objdir} does not exist"
134 emake clean || die Unable to make clean. 690 insinto /lib/modules/${KV_FULL}/${libdir}
135 emake ${BUILD_PARAMS} module || die Unable to make ${BUILD_PARAMS} module. 691 doins ${modulename}.${KV_OBJ} || die "doins ${modulename}.${KV_OBJ} failed"
692 cd "${OLDPWD}"
693
694 generate_modulesd "${objdir}/${modulename}"
136 done 695 done
137 ARCH="${xarch}"
138} 696}
139 697
698# @FUNCTION: linux-mod_pkg_preinst
699# @DESCRIPTION:
700# It checks what to do after having merged the package.
140linux-mod_src_install() { 701linux-mod_pkg_preinst() {
141 local modulename moduledir sourcedir module_temp i 702 debug-print-function ${FUNCNAME} $*
142 703
143 for i in "${MODULE_NAMES}" 704 [ -d "${D}lib/modules" ] && UPDATE_DEPMOD=true || UPDATE_DEPMOD=false
144 do 705 [ -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} 706}
158 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)"
159linux-mod_pkg_postinst() { 712linux-mod_pkg_postinst() {
160 update_depmod; 713 debug-print-function ${FUNCNAME} $*
161 update_modules; 714
162 display_postinst; 715 ${UPDATE_DEPMOD} && update_depmod;
716 ${UPDATE_MODULEDB} && update_moduledb;
163} 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.
723linux-mod_pkg_postrm() {
724 debug-print-function ${FUNCNAME} $*
725 remove_moduledb;
726}

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

  ViewVC Help
Powered by ViewVC 1.1.20