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

Contents of /eclass/linux-mod.eclass

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.74 - (show annotations) (download)
Mon Apr 16 19:20:28 2007 UTC (7 years, 4 months ago) by vapier
Branch: MAIN
Changes since 1.73: +3 -3 lines
modules-update -> update-modules

1 # Copyright 1999-2004 Gentoo Foundation
2 # Distributed under the terms of the GNU General Public License v2
3 # $Header: /var/cvsroot/gentoo-x86/eclass/linux-mod.eclass,v 1.73 2007/04/16 08:13:40 genstef Exp $
4
5 # Description: This eclass is used to interface with linux-info in such a way
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 :)
14
15 # A Couple of env vars are available to effect usage of this eclass
16 # These are as follows:
17 #
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.
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
86 inherit eutils linux-info multilib
87 EXPORT_FUNCTIONS pkg_setup pkg_preinst pkg_postinst src_install src_compile pkg_postrm
88
89 IUSE="kernel_linux"
90 SLOT="0"
91 DESCRIPTION="Based on the $ECLASS eclass"
92 RDEPEND="kernel_linux? ( virtual/modutils )"
93 DEPEND="${RDEPEND}
94 sys-apps/sed"
95
96 # eclass utilities
97 # ----------------------------------
98
99 check_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
138 use_m() {
139 debug-print-function ${FUNCNAME} $*
140
141 # if we haven't determined the version yet, we need too.
142 get_version;
143
144 # if the kernel version is greater than 2.6.6 then we should use
145 # M= instead of SUBDIRS=
146 [ ${KV_MAJOR} -eq 2 -a ${KV_MINOR} -gt 5 -a ${KV_PATCH} -gt 5 ] && \
147 return 0 || return 1
148 }
149
150 convert_to_m() {
151 debug-print-function ${FUNCNAME} $*
152
153 if use_m
154 then
155 [ ! -f "${1}" ] && \
156 die "convert_to_m() requires a filename as an argument"
157 ebegin "Converting ${1/${WORKDIR}\//} to use M= instead of SUBDIRS="
158 sed -i 's:SUBDIRS=:M=:g' ${1}
159 eend $?
160 fi
161 }
162
163 update_depmod() {
164 debug-print-function ${FUNCNAME} $*
165
166 # if we haven't determined the version yet, we need too.
167 get_version;
168
169 ebegin "Updating module dependencies for ${KV_FULL}"
170 if [ -r ${KV_OUT_DIR}/System.map ]
171 then
172 depmod -ae -F ${KV_OUT_DIR}/System.map -b ${ROOT} -r ${KV_FULL}
173 eend $?
174 else
175 ewarn
176 ewarn "${KV_OUT_DIR}/System.map not found."
177 ewarn "You must manually update the kernel module dependencies using depmod."
178 eend 1
179 ewarn
180 fi
181 }
182
183 update_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 $?
191 elif [ -x /sbin/update-modules ] && \
192 grep -v -e "^#" -e "^$" ${D}/etc/modules.d/* >/dev/null 2>&1; then
193 ebegin "Updating modules.conf"
194 /sbin/update-modules
195 eend $?
196 fi
197 }
198
199 move_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
214 update_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
231 remove_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
243 set_kvobj() {
244 debug-print-function ${FUNCNAME} $*
245
246 if kernel_is 2 6
247 then
248 KV_OBJ="ko"
249 else
250 KV_OBJ="o"
251 fi
252 # Do we really need to know this?
253 # Lets silence it.
254 # einfo "Using KV_OBJ=${KV_OBJ}"
255 }
256
257 get-KERNEL_CC() {
258 debug-print-function ${FUNCNAME} $*
259
260 local kernel_cc
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
272 generate_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
416 find_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
461 linux-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
475 strip_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
484 linux-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;
493 for i in ${MODULE_NAMES}
494 do
495 unset libdir srcdir objdir
496 for n in $(find_module_params ${i})
497 do
498 eval ${n/:*}=${n/*:/}
499 done
500 libdir=${libdir:-misc}
501 srcdir=${srcdir:-${S}}
502 objdir=${objdir:-${srcdir}}
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
520 done
521
522 ARCH="${myARCH}"
523 ABI="${myABI}"
524 }
525
526 linux-mod_src_install() {
527 debug-print-function ${FUNCNAME} $*
528
529 local modulename libdir srcdir objdir i n
530
531 strip_modulenames;
532 for i in ${MODULE_NAMES}
533 do
534 unset libdir srcdir objdir
535 for n in $(find_module_params ${i})
536 do
537 eval ${n/:*}=${n/*:/}
538 done
539 libdir=${libdir:-misc}
540 srcdir=${srcdir:-${S}}
541 objdir=${objdir:-${srcdir}}
542
543 einfo "Installing ${modulename} module"
544 cd ${objdir} || die "${objdir} does not exist"
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}
550 done
551 }
552
553 linux-mod_pkg_preinst() {
554 debug-print-function ${FUNCNAME} $*
555
556 [ -d ${IMAGE}/lib/modules ] && UPDATE_DEPMOD=true || UPDATE_DEPMOD=false
557 [ -d ${IMAGE}/etc/modules.d ] && UPDATE_MODULES=true || UPDATE_MODULES=false
558 [ -d ${IMAGE}/lib/modules ] && UPDATE_MODULEDB=true || UPDATE_MODULEDB=false
559 }
560
561 linux-mod_pkg_postinst() {
562 debug-print-function ${FUNCNAME} $*
563
564 ${UPDATE_DEPMOD} && update_depmod;
565 ${UPDATE_MODULES} && update_modules;
566 ${UPDATE_MODULEDB} && update_moduledb;
567 }
568
569 linux-mod_pkg_postrm() {
570 debug-print-function ${FUNCNAME} $*
571 remove_moduledb;
572 }

  ViewVC Help
Powered by ViewVC 1.1.20