/[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.8 Revision 1.73
1# Copyright 1999-2004 Gentoo Foundation 1# Copyright 1999-2004 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.8 2004/12/06 22:05:08 johnm Exp $ 3# $Header: /var/cvsroot/gentoo-x86/eclass/linux-mod.eclass,v 1.73 2007/04/16 08:13:40 genstef Exp $
4 4
5# This eclass provides functions for compiling external kernel modules 5# Description: This eclass is used to interface with linux-info in such a way
6# from source. 6# to provide the functionality required and initial functions
7# required to install external modules against a kernel source
8# tree.
9#
10# Maintainer: John Mylchreest <johnm@gentoo.org>, Stefan Schweizer <genstef@gentoo.org>
11# Copyright 2004 Gentoo Linux
12#
13# Please direct your bugs to the current eclass maintainer :)
7 14
8inherit linux-info 15# A Couple of env vars are available to effect usage of this eclass
9ECLASS=linux-mod 16# These are as follows:
10INHERITED="$INHERITED $ECLASS" 17#
11EXPORT_FUNCTIONS pkg_setup pkg_postinst src_compile 18# Env Var Option Default Description
19# KERNEL_DIR <string> /usr/src/linux The directory containing kernel
20# the target kernel sources.
21# ECONF_PARAMS <string> The parameters to pass to econf.
22# If this is not set, then econf
23# isn't run.
24# BUILD_PARAMS <string> The parameters to pass to emake.
25# BUILD_TARGETS <string> clean modules The build targets to pass to
26# make.
27# MODULE_NAMES <string> This is the modules which are
28# to be built automatically using
29# the default pkg_compile/install.
30# They are explained properly
31# below. It will only make
32# BUILD_TARGETS once in any
33# directory.
12 34
35# MODULE_NAMES - Detailed Overview
36#
37# The structure of each MODULE_NAMES entry is as follows:
38# modulename(libdir:srcdir:objdir)
39# for example:
40# MODULE_NAMES="module_pci(pci:${S}/pci:${S}) module_usb(usb:${S}/usb:${S})"
41#
42# what this would do is
43# cd ${S}/pci
44# make ${BUILD_PARAMS} ${BUILD_TARGETS}
45# cd ${S}
46# insinto /lib/modules/${KV_FULL}/pci
47# doins module_pci.${KV_OBJ}
48#
49# cd ${S}/usb
50# make ${BUILD_PARAMS} ${BUILD_TARGETS}
51# cd ${S}
52# insinto /lib/modules/${KV_FULL}/usb
53# doins module_usb.${KV_OBJ}
54#
55# if the srcdir isnt specified, it assumes ${S}
56# if the libdir isnt specified, it assumes misc.
57# if the objdir isnt specified, it assumes srcdir
58
59# There is also support for automatyed modules.d file generation.
60# This can be explicitly enabled by setting any of the following variables.
61#
62#
63# MODULESD_${modulename}_ENABLED This enables the modules.d file
64# generation even if we dont
65# specify any additional info.
66# MODULESD_${modulename}_EXAMPLES This is a bash array containing
67# a list of examples which should
68# be used. If you want us to try and
69# take a guess. Set this to "guess"
70# MODULESD_${modulename}_ALIASES This is a bash array containing
71# a list of associated aliases.
72# MODULESD_${modulename}_ADDITIONS This is a bash array containing
73# A list of additional things to
74# add to the bottom of the file.
75# This can be absolutely anything.
76# Each entry is a new line.
77# MODULES_${modulename}_DOCS This is a string list which contains
78# the full path to any associated
79# documents for $modulename
80
81# The order of these is important as both of linux-info and eutils contain
82# set_arch_to_kernel and set_arch_to_portage functions and the ones in eutils
83# are deprecated in favor of the ones in linux-info.
84# See http://bugs.gentoo.org/show_bug.cgi?id=127506
85
86inherit eutils linux-info multilib
87EXPORT_FUNCTIONS pkg_setup pkg_preinst pkg_postinst src_install src_compile pkg_postrm
88
89IUSE="kernel_linux"
90SLOT="0"
13DESCRIPTION="Based on the $ECLASS eclass" 91DESCRIPTION="Based on the $ECLASS eclass"
14SLOT=0 92RDEPEND="kernel_linux? ( virtual/modutils )"
15DEPEND="virtual/linux-sources 93DEPEND="${RDEPEND}
16 sys-apps/sed" 94 sys-apps/sed"
17
18
19# This eclass is designed to help ease the installation of external kernel
20# modules into the kernel tree.
21
22 95
23# eclass utilities 96# eclass utilities
24# ---------------------------------- 97# ----------------------------------
25 98
99check_vermagic() {
100 debug-print-function ${FUNCNAME} $*
101
102 local curr_gcc_ver=$(gcc -dumpversion)
103 local tmpfile old_chost old_gcc_ver result=0
104
105 tmpfile=`find ${KV_DIR}/ -iname "*.o.cmd" -exec grep usr/lib/gcc {} \; -quit`
106 tmpfile=${tmpfile//*usr/lib}
107 tmpfile=${tmpfile//\/include*}
108 old_chost=${tmpfile//*gcc\/}
109 old_chost=${old_chost//\/*}
110 old_gcc_ver=${tmpfile//*\/}
111
112 if [[ -z ${old_gcc_ver} || -z ${old_chost} ]]; then
113 ewarn ""
114 ewarn "Unable to detect what version of GCC was used to compile"
115 ewarn "the kernel. Build will continue, but you may experience problems."
116 elif [[ ${curr_gcc_ver} != ${old_gcc_ver} ]]; then
117 ewarn ""
118 ewarn "The version of GCC you are using (${curr_gcc_ver}) does"
119 ewarn "not match the version of GCC used to compile the"
120 ewarn "kernel (${old_gcc_ver})."
121 result=1
122 elif [[ ${CHOST} != ${old_chost} ]]; then
123 ewarn ""
124 ewarn "The current CHOST (${CHOST}) does not match the chost"
125 ewarn "used when compiling the kernel (${old_chost})."
126 result=1
127 fi
128
129 if [[ ${result} -gt 0 ]]; then
130 ewarn ""
131 ewarn "Build will not continue, because you will experience problems."
132 ewarn "To fix this either change the version of GCC you wish to use"
133 ewarn "to match the kernel, or recompile the kernel first."
134 die "GCC Version Mismatch."
135 fi
136}
137
26use_m() { 138use_m() {
139 debug-print-function ${FUNCNAME} $*
140
27 # if we haven't determined the version yet, we need too. 141 # if we haven't determined the version yet, we need too.
28 get_version; 142 get_version;
29 143
30 # if the kernel version is greater than 2.6.6 then we should use 144 # if the kernel version is greater than 2.6.6 then we should use
31 # M= instead of SUBDIRS= 145 # M= instead of SUBDIRS=
32 [ ${KV_MAJOR} -eq 2 -a ${KV_MINOR} -gt 5 -a ${KV_PATCH} -gt 5 ] && \ 146 [ ${KV_MAJOR} -eq 2 -a ${KV_MINOR} -gt 5 -a ${KV_PATCH} -gt 5 ] && \
33 return 0 || return 1 147 return 0 || return 1
34} 148}
35 149
36convert_to_m() { 150convert_to_m() {
37 [ ! -f "${1}" ] && die "convert_to_m() requires a filename as an argument" 151 debug-print-function ${FUNCNAME} $*
152
38 if use_m 153 if use_m
39 then 154 then
155 [ ! -f "${1}" ] && \
156 die "convert_to_m() requires a filename as an argument"
40 ebegin "Converting ${1/${WORKDIR}\//} to use M= instead of SUBDIRS=" 157 ebegin "Converting ${1/${WORKDIR}\//} to use M= instead of SUBDIRS="
41 sed -i 's:SUBDIRS=:M=:g' ${1} 158 sed -i 's:SUBDIRS=:M=:g' ${1}
42 eend $? 159 eend $?
43 fi 160 fi
44} 161}
45 162
46update_depmod() { 163update_depmod() {
164 debug-print-function ${FUNCNAME} $*
165
47 # if we haven't determined the version yet, we need too. 166 # if we haven't determined the version yet, we need too.
48 get_version; 167 get_version;
49 168
50 ebegin "Updating module dependencies for ${KV_FULL}" 169 ebegin "Updating module dependencies for ${KV_FULL}"
51 if [ -r ${KV_OUT_DIR}/System.map ] 170 if [ -r ${KV_OUT_DIR}/System.map ]
52 then 171 then
53 depmod -ae -F ${KV_OUT_DIR}/System.map -b ${ROOT} -r ${KV_FULL} 172 depmod -ae -F ${KV_OUT_DIR}/System.map -b ${ROOT} -r ${KV_FULL}
173 eend $?
54 else 174 else
55 ewarn 175 ewarn
56 ewarn "${KV_OUT_DIR}/System.map not found." 176 ewarn "${KV_OUT_DIR}/System.map not found."
57 ewarn "You must manually update the kernel module dependencies using depmod." 177 ewarn "You must manually update the kernel module dependencies using depmod."
178 eend 1
58 ewarn 179 ewarn
59 fi 180 fi
60 eend $?
61} 181}
62 182
63update_modules() { 183update_modules() {
184 debug-print-function ${FUNCNAME} $*
185
186 if [ -x /sbin/update-modules ] && \
187 grep -v -e "^#" -e "^$" ${D}/etc/modules.d/* >/dev/null 2>&1; then
188 ebegin "Updating modules.conf"
189 /sbin/update-modules
190 eend $?
64 if [ -x /sbin/modules-update ] ; 191 elif [ -x /sbin/modules-update ] && \
65 then 192 grep -v -e "^#" -e "^$" ${D}/etc/modules.d/* >/dev/null 2>&1; then
66 ebegin "Updating modules.conf" 193 ebegin "Updating modules.conf"
67 /sbin/modules-update 194 /sbin/modules-update
68 eend $? 195 eend $?
69 fi 196 fi
70} 197}
71 198
199move_old_moduledb() {
200 debug-print-function ${FUNCNAME} $*
201
202 local OLDDIR=${ROOT}/usr/share/module-rebuild/
203 local NEWDIR=${ROOT}/var/lib/module-rebuild/
204
205 if [[ -f ${OLDDIR}/moduledb ]]; then
206 [[ ! -d ${NEWDIR} ]] && mkdir -p ${NEWDIR}
207 [[ ! -f ${NEWDIR}/moduledb ]] && \
208 mv ${OLDDIR}/moduledb ${NEWDIR}/moduledb
209 rm -f ${OLDDIR}/*
210 rmdir ${OLDDIR}
211 fi
212}
213
214update_moduledb() {
215 debug-print-function ${FUNCNAME} $*
216
217 local MODULEDB_DIR=${ROOT}/var/lib/module-rebuild/
218 move_old_moduledb
219
220 if [[ ! -f ${MODULEDB_DIR}/moduledb ]]; then
221 [[ ! -d ${MODULEDB_DIR} ]] && mkdir -p ${MODULEDB_DIR}
222 touch ${MODULEDB_DIR}/moduledb
223 fi
224
225 if ! grep -qs ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb ; then
226 einfo "Adding module to moduledb."
227 echo "a:1:${CATEGORY}/${PN}-${PVR}" >> ${MODULEDB_DIR}/moduledb
228 fi
229}
230
231remove_moduledb() {
232 debug-print-function ${FUNCNAME} $*
233
234 local MODULEDB_DIR=${ROOT}/var/lib/module-rebuild/
235 move_old_moduledb
236
237 if grep -qs ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb ; then
238 einfo "Removing ${CATEGORY}/${PN}-${PVR} from moduledb."
239 sed -i -e "/.*${CATEGORY}\/${PN}-${PVR}.*/d" ${MODULEDB_DIR}/moduledb
240 fi
241}
242
72set_kvobj() { 243set_kvobj() {
244 debug-print-function ${FUNCNAME} $*
245
73 if kernel_is 2 6 246 if kernel_is 2 6
74 then 247 then
75 KV_OBJ="ko" 248 KV_OBJ="ko"
76 else 249 else
77 KV_OBJ="o" 250 KV_OBJ="o"
78 fi 251 fi
252 # Do we really need to know this?
253 # Lets silence it.
79 einfo "Using KV_OBJ=${KV_OBJ}" 254 # einfo "Using KV_OBJ=${KV_OBJ}"
80} 255}
81 256
82display_postinst() { 257get-KERNEL_CC() {
83 # if we haven't determined the version yet, we need too. 258 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 259
91 einfo "If you would like to load this module automatically upon boot" 260 local kernel_cc
92 einfo "please type the following as root:" 261 if [ -n "${KERNEL_ABI}" ]; then
262 # In future, an arch might want to define CC_$ABI
263 #kernel_cc="$(get_abi_CC)"
264 #[ -z "${kernel_cc}" ] &&
265 kernel_cc="$(tc-getCC $(ABI=${KERNEL_ABI} get_abi_CHOST))"
266 else
267 kernel_cc=$(tc-getCC)
268 fi
269 echo "${kernel_cc}"
270}
271
272generate_modulesd() {
273 debug-print-function ${FUNCNAME} $*
274
275 # This function will generate the neccessary modules.d file from the
276 # information contained in the modules exported parms
277
278 local currm_path currm currm_t t myIFS myVAR
279 local module_docs module_enabled module_aliases \
280 module_additions module_examples module_modinfo module_opts
281
282 for currm_path in ${@}
283 do
284 currm=${currm_path//*\/}
285 currm=$(echo ${currm} | tr '[:lower:]' '[:upper:]')
286 currm_t=${currm}
287 while [[ -z ${currm_t//*-*} ]]; do
288 currm_t=${currm_t/-/_}
289 done
290
291 module_docs="$(eval echo \${MODULESD_${currm_t}_DOCS})"
292 module_enabled="$(eval echo \${MODULESD_${currm_t}_ENABLED})"
293 module_aliases="$(eval echo \${#MODULESD_${currm_t}_ALIASES[*]})"
294 module_additions="$(eval echo \${#MODULESD_${currm_t}_ADDITIONS[*]})"
295 module_examples="$(eval echo \${#MODULESD_${currm_t}_EXAMPLES[*]})"
296
297 [[ ${module_aliases} -eq 0 ]] && unset module_aliases
298 [[ ${module_additions} -eq 0 ]] && unset module_additions
299 [[ ${module_examples} -eq 0 ]] && unset module_examples
300
301 # If we specify we dont want it, then lets exit, otherwise we assume
302 # that if its set, we do want it.
303 [[ ${module_enabled} == no ]] && return 0
304
305 # unset any unwanted variables.
306 for t in ${!module_*}
307 do
308 [[ -z ${!t} ]] && unset ${t}
309 done
310
311 [[ -z ${!module_*} ]] && return 0
312
313 # OK so now if we have got this far, then we know we want to continue
314 # and generate the modules.d file.
315 module_modinfo="$(modinfo -p ${currm_path}.${KV_OBJ})"
316 module_config="${T}/modulesd-${currm}"
317
318 ebegin "Preparing file for modules.d"
319 #-----------------------------------------------------------------------
320 echo "# modules.d configuration file for ${currm}" >> ${module_config}
321 #-----------------------------------------------------------------------
322 [[ -n ${module_docs} ]] && \
323 echo "# For more information please read:" >> ${module_config}
324 for t in ${module_docs}
325 do
326 echo "# ${t//*\/}" >> ${module_config}
327 done
328 echo >> ${module_config}
329
330 #-----------------------------------------------------------------------
331 if [[ ${module_aliases} -gt 0 ]]
332 then
333 echo "# Internal Aliases - Do not edit" >> ${module_config}
334 echo "# ------------------------------" >> ${module_config}
335
336 for((t=0; t<${module_aliases}; t++))
337 do
338 echo "alias $(eval echo \${MODULESD_${currm}_ALIASES[$t]})" \
339 >> ${module_config}
340 done
341 echo '' >> ${module_config}
342 fi
343
344 #-----------------------------------------------------------------------
345 if [[ -n ${module_modinfo} ]]
346 then
347 echo >> ${module_config}
348 echo "# Configurable module parameters" >> ${module_config}
349 echo "# ------------------------------" >> ${module_config}
350 myIFS="${IFS}"
351 IFS="$(echo -en "\n\b")"
352
353 for t in ${module_modinfo}
354 do
355 myVAR="$(echo ${t#*:} | grep -e " [0-9][ =]" | sed "s:.*\([01][= ]\).*:\1:")"
356 if [[ -n ${myVAR} ]]
357 then
358 module_opts="${module_opts} ${t%%:*}:${myVAR}"
359 fi
360 echo -e "# ${t%%:*}:\t${t#*:}" >> ${module_config}
361 done
362 IFS="${myIFS}"
363 echo '' >> ${module_config}
364 fi
365
366 #-----------------------------------------------------------------------
367 if [[ $(eval echo \${MODULESD_${currm}_ALIASES[0]}) == guess ]]
368 then
369 # So lets do some guesswork eh?
370 if [[ -n ${module_opts} ]]
371 then
372 echo "# For Example..." >> ${module_config}
373 echo "# --------------" >> ${module_config}
374 for t in ${module_opts}
375 do
376 echo "# options ${currm} ${t//:*}=${t//*:}" >> ${module_config}
377 done
378 echo '' >> ${module_config}
379 fi
380 elif [[ ${module_examples} -gt 0 ]]
381 then
382 echo "# For Example..." >> ${module_config}
383 echo "# --------------" >> ${module_config}
384 for((t=0; t<${module_examples}; t++))
385 do
386 echo "options $(eval echo \${MODULESD_${currm}_EXAMPLES[$t]})" \
387 >> ${module_config}
388 done
389 echo '' >> ${module_config}
390 fi
391
392 #-----------------------------------------------------------------------
393 if [[ ${module_additions} -gt 0 ]]
394 then
395 for((t=0; t<${module_additions}; t++))
396 do
397 echo "$(eval echo \${MODULESD_${currm}_ADDITIONS[$t]})" \
398 >> ${module_config}
399 done
400 echo '' >> ${module_config}
401 fi
402
403 #-----------------------------------------------------------------------
404
405 # then we install it
406 insinto /etc/modules.d
407 newins ${module_config} ${currm_path//*\/}
408
409 # and install any documentation we might have.
410 [[ -n ${module_docs} ]] && dodoc ${module_docs}
411 done
412 eend 0
413 return 0
414}
415
416find_module_params() {
417 debug-print-function ${FUNCNAME} $*
418
419 local matched_offset=0 matched_opts=0 test="${@}" temp_var result
420 local i=0 y=0 z=0
421
422 for((i=0; i<=${#test}; i++))
423 do
424 case ${test:${i}:1} in
425 \() matched_offset[0]=${i};;
426 \:) matched_opts=$((${matched_opts} + 1));
427 matched_offset[${matched_opts}]="${i}";;
428 \)) matched_opts=$((${matched_opts} + 1));
429 matched_offset[${matched_opts}]="${i}";;
430 esac
431 done
432
433 for((i=0; i<=${matched_opts}; i++))
434 do
435 # i = offset were working on
436 # y = last offset
437 # z = current offset - last offset
438 # temp_var = temporary name
439 case ${i} in
440 0) tempvar=${test:0:${matched_offset[0]}};;
441 *) y=$((${matched_offset[$((${i} - 1))]} + 1))
442 z=$((${matched_offset[${i}]} - ${matched_offset[$((${i} - 1))]}));
443 z=$((${z} - 1))
444 tempvar=${test:${y}:${z}};;
445 esac
446
447 case ${i} in
448 0) result="${result} modulename:${tempvar}";;
449 1) result="${result} libdir:${tempvar}";;
450 2) result="${result} srcdir:${tempvar}";;
451 3) result="${result} objdir:${tempvar}";;
452 esac
453 done
454
455 echo ${result}
456}
457
458# default ebuild functions
459# --------------------------------
460
461linux-mod_pkg_setup() {
462 debug-print-function ${FUNCNAME} $*
463
464 linux-info_pkg_setup;
465 check_kernel_built;
466 strip_modulenames;
467 [[ -n ${MODULE_NAMES} ]] && check_modules_supported
468 set_kvobj;
469 # Commented out with permission from johnm until a fixed version for arches
470 # who intentionally use different kernel and userland compilers can be
471 # introduced - Jason Wever <weeve@gentoo.org>, 23 Oct 2005
472 #check_vermagic;
473}
474
475strip_modulenames() {
476 debug-print-function ${FUNCNAME} $*
477
478 local i
479 for i in ${MODULE_IGNORE}; do
480 MODULE_NAMES=${MODULE_NAMES//${i}(*}
481 done
482}
483
484linux-mod_src_compile() {
485 debug-print-function ${FUNCNAME} $*
486
487 local modulename libdir srcdir objdir i n myARCH="${ARCH}" myABI="${ABI}"
488 ARCH="$(tc-arch-kernel)"
489 ABI="${KERNEL_ABI}"
490
491 BUILD_TARGETS=${BUILD_TARGETS:-clean module}
492 strip_modulenames;
93 for i in ${MODULE_NAMES} 493 for i in ${MODULE_NAMES}
94 do 494 do
95 module_temp="$(echo ${i} | sed -e "s:.*(\(.*\)):\1:")" 495 unset libdir srcdir objdir
96 modulename="${i/(*/}" 496 for n in $(find_module_params ${i})
97 moduledir="${module_temp/:*/}" 497 do
98 moduledir="${moduledir:-misc}" 498 eval ${n/:*}=${n/*:/}
99 sourcedir="${module_temp/*:/}" 499 done
500 libdir=${libdir:-misc}
100 sourcedir="${sourcedir:-${S}}" 501 srcdir=${srcdir:-${S}}
101 502 objdir=${objdir:-${srcdir}}
102 einfo " # echo \"${modulename}\" >> ${file}" 503
504 if [ ! -f "${srcdir}/.built" ];
505 then
506 cd ${srcdir}
507 einfo "Preparing ${modulename} module"
508 if [[ -n ${ECONF_PARAMS} ]]
509 then
510 econf ${ECONF_PARAMS} || \
511 die "Unable to run econf ${ECONF_PARAMS}"
512 fi
513
514 emake HOSTCC="$(tc-getBUILD_CC)" CC="$(get-KERNEL_CC)" LDFLAGS="$(get_abi_LDFLAGS)" \
515 ${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS} \
516 || die "Unable to make ${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS}."
517 touch ${srcdir}/.built
518 cd ${OLDPWD}
519 fi
103 done 520 done
104 echo
105}
106 521
107# default ebuild functions 522 ARCH="${myARCH}"
108# -------------------------------- 523 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} 524}
117 525
118linux-mod_src_compile() { 526linux-mod_src_install() {
119 local modulename moduledir sourcedir module_temp xarch i 527 debug-print-function ${FUNCNAME} $*
120 xarch="${ARCH}"
121 unset ARCH
122 528
529 local modulename libdir srcdir objdir i n
530
531 strip_modulenames;
123 for i in "${MODULE_NAMES}" 532 for i in ${MODULE_NAMES}
124 do 533 do
125 module_temp="$(echo ${i} | sed -e "s:.*(\(.*\)):\1:")" 534 unset libdir srcdir objdir
126 modulename="${i/(*/}" 535 for n in $(find_module_params ${i})
127 moduledir="${module_temp/:*/}" 536 do
128 moduledir="${moduledir:-misc}" 537 eval ${n/:*}=${n/*:/}
129 sourcedir="${module_temp/*:/}" 538 done
539 libdir=${libdir:-misc}
130 sourcedir="${sourcedir:-${S}}" 540 srcdir=${srcdir:-${S}}
131 541 objdir=${objdir:-${srcdir}}
542
132 einfo "Preparing ${modulename} module" 543 einfo "Installing ${modulename} module"
133 cd ${sourcedir} 544 cd ${objdir} || die "${objdir} does not exist"
134 emake ${BUILD_PARAMS} ${BUILD_TARGETS:-clean module} || die Unable to make ${BUILD_PARAMS} ${BUILD_TARGETS:-clean module}. 545 insinto /lib/modules/${KV_FULL}/${libdir}
546 doins ${modulename}.${KV_OBJ} || die "doins ${modulename}.${KV_OBJ} failed"
547 cd ${OLDPWD}
548
549 generate_modulesd ${objdir}/${modulename}
135 done 550 done
136 ARCH="${xarch}"
137} 551}
138 552
139linux-mod_src_install() { 553linux-mod_pkg_preinst() {
140 local modulename moduledir sourcedir module_temp i 554 debug-print-function ${FUNCNAME} $*
141 555
142 for i in "${MODULE_NAMES}" 556 [ -d ${IMAGE}/lib/modules ] && UPDATE_DEPMOD=true || UPDATE_DEPMOD=false
143 do 557 [ -d ${IMAGE}/etc/modules.d ] && UPDATE_MODULES=true || UPDATE_MODULES=false
144 module_temp="$(echo ${i} | sed -e "s:.*(\(.*\)):\1:")" 558 [ -d ${IMAGE}/lib/modules ] && UPDATE_MODULEDB=true || UPDATE_MODULEDB=false
145 modulename="${i/(*/}"
146 moduledir="${module_temp/:*/}"
147 moduledir="${moduledir:-misc}"
148 sourcedir="${module_temp/*:/}"
149 sourcedir="${sourcedir:-${S}}"
150
151 einfo "Installing ${modulename} module"
152 cd ${sourcedir}
153 insinto /lib/modules/${KV_FULL}/${moduledir}
154 doins ${modulename}.${KV_OBJ}
155 done
156} 559}
157 560
158linux-mod_pkg_postinst() { 561linux-mod_pkg_postinst() {
159 update_depmod; 562 debug-print-function ${FUNCNAME} $*
160 update_modules; 563
161 display_postinst; 564 ${UPDATE_DEPMOD} && update_depmod;
565 ${UPDATE_MODULES} && update_modules;
566 ${UPDATE_MODULEDB} && update_moduledb;
162} 567}
568
569linux-mod_pkg_postrm() {
570 debug-print-function ${FUNCNAME} $*
571 remove_moduledb;
572}

Legend:
Removed from v.1.8  
changed lines
  Added in v.1.73

  ViewVC Help
Powered by ViewVC 1.1.20