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

Contents of /eclass/linux-mod.eclass

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.53 - (show annotations) (download)
Sat Oct 22 16:55:17 2005 UTC (9 years, 2 months ago) by johnm
Branch: MAIN
Changes since 1.52: +39 -1 lines
Adding in vermagic check. This is a little crude, but picks up on the most common problem

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.52 2005/09/22 14:13:36 johnm 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>
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
82 inherit linux-info
83 EXPORT_FUNCTIONS pkg_setup pkg_postinst src_install src_compile pkg_postrm
84
85 IUSE="" # don't put pcmcia here, rather in the ebuilds that actually support pcmcia
86 SLOT="0"
87 DESCRIPTION="Based on the $ECLASS eclass"
88 RDEPEND="virtual/modutils
89 pcmcia? ( virtual/pcmcia )"
90 DEPEND="virtual/linux-sources
91 sys-apps/sed
92 pcmcia? ( virtual/pcmcia )"
93
94 # eclass utilities
95 # ----------------------------------
96
97 check_vermagic() {
98 local curr_gcc_ver=$(gcc -dumpversion)
99 local tmpfile old_chost old_gcc_ver result=0
100
101 tmpfile=`find ${KV_DIR} -iname "*.o.cmd" -exec grep usr/lib/gcc {} \; -quit`
102 tmpfile=${tmpfile//*usr/lib}
103 tmpfile=${tmpfile//\/include*}
104 old_chost=${tmpfile//*gcc\/}
105 old_chost=${old_chost//\/*}
106 old_gcc_ver=${tmpfile//*\/}
107
108 if [[ ${curr_gcc_ver} != ${old_gcc_ver} ]]; then
109 ewarn ""
110 ewarn "The version of GCC you are using (${curr_gcc_ver}) does"
111 ewarn "not match the version of GCC used to compile the"
112 ewarn "kernel (${old_gcc_ver})."
113 result=1
114 elif [[ ${CHOST} != ${old_chost} ]]; then
115 ewarn ""
116 ewarn "The current CHOST (${CHOST}) does not match the chost"
117 ewarn "used when compiling the kernel (${old_chost})."
118 result=1
119 elif [[ -z ${old_gcc_ver} || -z ${old_chost} ]]; then
120 ewarn ""
121 ewarn "Unable to detect what version of GCC was used to compile"
122 ewarn "the kernel. Build will continue, but you may experience problems."
123 fi
124
125 if [[ ${result} -gt 0 ]]; then
126 ewarn ""
127 ewarn "Build will not continue, because you will experience problems."
128 ewarn "To fix this either change the version of GCC you wish to use"
129 ewarn "to match the kernel, or recompile the kernel first."
130 die "GCC Version Mismatch."
131 fi
132 }
133
134 unpack_pcmcia_sources() {
135 # So while the two eclasses exist side-by-side and also the ebuilds inherit
136 # both we need to check for PCMCIA_SOURCE_DIR, and if we find it, then we
137 # bail out and assume pcmcia.eclass is working on it.
138 [[ -n ${PCMCIA_SOURCE_DIR} ]] && return 1
139
140 if [[ -f "${1}" ]]; then
141 PCMCIA_SOURCE_DIR="${WORKDIR}/pcmcia-cs/"
142
143 ebegin "Decompressing pcmcia-cs sources"
144 mkdir -p ${PCMCIA_SOURCE_DIR}
145 tar -xjf ${1} -C ${PCMCIA_SOURCE_DIR}
146 eend $?
147
148 if [[ -f ${PCMCIA_SOURCE_DIR}/pcmcia-cs-version ]]; then
149 PCMCIA_VERSION=$(cat ${PCMCIA_SOURCE_DIR}/pcmcia-cs-version)
150 einfo "Found pcmcia-cs-${PCMCIA_VERSION}"
151 fi
152 fi
153 }
154
155 # Dummy function for compatibility.
156 pcmcia_configure() { return 0; }
157
158 pcmcia_src_unpack() {
159 local pcmcia_tbz="${ROOT}/usr/src/pcmcia-cs/pcmcia-cs-build-env.tbz2"
160
161 # if the kernel has pcmcia support built in, then we just ignore all this.
162 if linux_chkconfig_present PCMCIA; then
163 einfo "Kernel based PCMCIA support has been detected."
164 else
165 if kernel_is 2 4; then
166 unpack_pcmcia_sources ${pcmcia_tbz};
167 else
168 einfo "We have detected that you are running a 2.6 kernel"
169 einfo "but you are not using the built-in PCMCIA support."
170 einfo "We will assume you know what you are doing, but please"
171 einfo "consider using the built in PCMCIA support instead."
172 sleep 10
173
174 unpack_pcmcia_sources ${pcmcia_tbz};
175 fi
176 fi
177 }
178
179 use_m() {
180 # if we haven't determined the version yet, we need too.
181 get_version;
182
183 # if the kernel version is greater than 2.6.6 then we should use
184 # M= instead of SUBDIRS=
185 [ ${KV_MAJOR} -eq 2 -a ${KV_MINOR} -gt 5 -a ${KV_PATCH} -gt 5 ] && \
186 return 0 || return 1
187 }
188
189 convert_to_m() {
190 if use_m
191 then
192 [ ! -f "${1}" ] && \
193 die "convert_to_m() requires a filename as an argument"
194 ebegin "Converting ${1/${WORKDIR}\//} to use M= instead of SUBDIRS="
195 sed -i 's:SUBDIRS=:M=:g' ${1}
196 eend $?
197 fi
198 }
199
200 update_depmod() {
201 # if we haven't determined the version yet, we need too.
202 get_version;
203
204 ebegin "Updating module dependencies for ${KV_FULL}"
205 if [ -r ${KV_OUT_DIR}/System.map ]
206 then
207 depmod -ae -F ${KV_OUT_DIR}/System.map -b ${ROOT} -r ${KV_FULL}
208 eend $?
209 else
210 ewarn
211 ewarn "${KV_OUT_DIR}/System.map not found."
212 ewarn "You must manually update the kernel module dependencies using depmod."
213 eend 1
214 ewarn
215 fi
216 }
217
218 update_modules() {
219 if [ -x /sbin/modules-update ] && \
220 grep -v -e "^#" -e "^$" ${D}/etc/modules.d/* >/dev/null 2>&1; then
221 ebegin "Updating modules.conf"
222 /sbin/modules-update
223 eend $?
224 fi
225 }
226
227 move_old_moduledb() {
228 local OLDDIR=${ROOT}/usr/share/module-rebuild/
229 local NEWDIR=${ROOT}/var/lib/module-rebuild/
230
231 if [[ -f ${OLDDIR}/moduledb ]]; then
232 [[ ! -d ${NEWDIR} ]] && mkdir -p ${NEWDIR}
233 [[ ! -f ${NEWDIR}/moduledb ]] && \
234 mv ${OLDDIR}/moduledb ${NEWDIR}/moduledb
235 rm -f ${OLDDIR}/*
236 rmdir ${OLDDIR}
237 fi
238 }
239
240 update_moduledb() {
241 local MODULEDB_DIR=${ROOT}/var/lib/module-rebuild/
242 move_old_moduledb
243
244 if [[ ! -f ${MODULEDB_DIR}/moduledb ]]; then
245 [[ ! -d ${MODULEDB_DIR} ]] && mkdir -p ${MODULEDB_DIR}
246 touch ${MODULEDB_DIR}/moduledb
247 fi
248 if [[ -z $(grep ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb) ]]; then
249 einfo "Adding module to moduledb."
250 echo "a:1:${CATEGORY}/${PN}-${PVR}" >> ${MODULEDB_DIR}/moduledb
251 fi
252 }
253
254 remove_moduledb() {
255 local MODULEDB_DIR=${ROOT}/var/lib/module-rebuild/
256 move_old_moduledb
257
258 if [[ -n $(grep ${CATEGORY}/${PN}-${PVR} ${MODULEDB_DIR}/moduledb) ]]; then
259 einfo "Removing ${CATEGORY}/${PN}-${PVR} from moduledb."
260 sed -ie "/.*${CATEGORY}\/${P}.*/d" ${MODULEDB_DIR}/moduledb
261 fi
262 }
263
264 set_kvobj() {
265 if kernel_is 2 6
266 then
267 KV_OBJ="ko"
268 else
269 KV_OBJ="o"
270 fi
271 # Do we really need to know this?
272 # Lets silence it.
273 # einfo "Using KV_OBJ=${KV_OBJ}"
274 }
275
276 generate_modulesd() {
277 # This function will generate the neccessary modules.d file from the
278 # information contained in the modules exported parms
279
280 local currm_path currm t myIFS myVAR
281 local module_docs module_enabled module_aliases \
282 module_additions module_examples module_modinfo module_opts
283
284 for currm_path in ${@}
285 do
286 currm=${currm_path//*\/}
287 currm=$(echo ${currm} | tr '[:lower:]' '[:upper:]')
288
289 module_docs="$(eval echo \${MODULESD_${currm}_DOCS})"
290 module_enabled="$(eval echo \${MODULESD_${currm}_ENABLED})"
291 module_aliases="$(eval echo \${#MODULESD_${currm/-/_}_ALIASES[*]})"
292 module_additions="$(eval echo \${#MODULESD_${currm/-/_}_ADDITIONS[*]})"
293 module_examples="$(eval echo \${#MODULESD_${currm/-/_}_EXAMPLES[*]})"
294
295 [[ ${module_aliases} -eq 0 ]] && unset module_aliases
296 [[ ${module_additions} -eq 0 ]] && unset module_additions
297 [[ ${module_examples} -eq 0 ]] && unset module_examples
298
299 # If we specify we dont want it, then lets exit, otherwise we assume
300 # that if its set, we do want it.
301 [[ ${module_enabled} == no ]] && return 0
302
303 # unset any unwanted variables.
304 for t in ${!module_*}
305 do
306 [[ -z ${!t} ]] && unset ${t}
307 done
308
309 [[ -z ${!module_*} ]] && return 0
310
311 # OK so now if we have got this far, then we know we want to continue
312 # and generate the modules.d file.
313 module_modinfo="$(modinfo -p ${currm_path}.${KV_OBJ})"
314 module_config="${T}/modulesd-${currm}"
315
316 ebegin "Preparing file for modules.d"
317 #-----------------------------------------------------------------------
318 echo "# modules.d configuration file for ${currm}" >> ${module_config}
319 #-----------------------------------------------------------------------
320 [[ -n ${module_docs} ]] && \
321 echo "# For more information please read:" >> ${module_config}
322 for t in ${module_docs}
323 do
324 echo "# ${t//*\/}" >> ${module_config}
325 done
326 echo >> ${module_config}
327
328 #-----------------------------------------------------------------------
329 if [[ ${module_aliases} -gt 0 ]]
330 then
331 echo "# Internal Aliases - Do not edit" >> ${module_config}
332 echo "# ------------------------------" >> ${module_config}
333
334 for((t=0; t<${module_aliases}; t++))
335 do
336 echo "alias $(eval echo \${MODULESD_${currm}_ALIASES[$t]})" \
337 >> ${module_config}
338 done
339 echo '' >> ${module_config}
340 fi
341
342 #-----------------------------------------------------------------------
343 if [[ -n ${module_modinfo} ]]
344 then
345 echo >> ${module_config}
346 echo "# Configurable module parameters" >> ${module_config}
347 echo "# ------------------------------" >> ${module_config}
348 myIFS="${IFS}"
349 IFS="$(echo -en "\n\b")"
350
351 for t in ${module_modinfo}
352 do
353 myVAR="$(echo ${t#*:} | grep -e " [0-9][ =]" | sed "s:.*\([01][= ]\).*:\1:")"
354 if [[ -n ${myVAR} ]]
355 then
356 module_opts="${module_opts} ${t%%:*}:${myVAR}"
357 fi
358 echo -e "# ${t%%:*}:\t${t#*:}" >> ${module_config}
359 done
360 IFS="${myIFS}"
361 echo '' >> ${module_config}
362 fi
363
364 #-----------------------------------------------------------------------
365 if [[ $(eval echo \${MODULESD_${currm}_ALIASES[0]}) == guess ]]
366 then
367 # So lets do some guesswork eh?
368 if [[ -n ${module_opts} ]]
369 then
370 echo "# For Example..." >> ${module_config}
371 echo "# --------------" >> ${module_config}
372 for t in ${module_opts}
373 do
374 echo "# options ${currm} ${t//:*}=${t//*:}" >> ${module_config}
375 done
376 echo '' >> ${module_config}
377 fi
378 elif [[ ${module_examples} -gt 0 ]]
379 then
380 echo "# For Example..." >> ${module_config}
381 echo "# --------------" >> ${module_config}
382 for((t=0; t<${module_examples}; t++))
383 do
384 echo "options $(eval echo \${MODULESD_${currm}_EXAMPLES[$t]})" \
385 >> ${module_config}
386 done
387 echo '' >> ${module_config}
388 fi
389
390 #-----------------------------------------------------------------------
391 if [[ ${module_additions} -gt 0 ]]
392 then
393 for((t=0; t<${module_additions}; t++))
394 do
395 echo "$(eval echo \${MODULESD_${currm}_ADDITIONS[$t]})" \
396 >> ${module_config}
397 done
398 echo '' >> ${module_config}
399 fi
400
401 #-----------------------------------------------------------------------
402
403 # then we install it
404 insinto /etc/modules.d
405 newins ${module_config} ${currm_path//*\/}
406
407 # and install any documentation we might have.
408 [[ -n ${module_docs} ]] && dodoc ${module_docs}
409 done
410 eend 0
411 return 0
412 }
413
414 find_module_params() {
415 local matched_offset=0 matched_opts=0 test="${@}" temp_var result
416 local i=0 y=0 z=0
417
418 for((i=0; i<=${#test}; i++))
419 do
420 case ${test:${i}:1} in
421 \() matched_offset[0]=${i};;
422 \:) matched_opts=$((${matched_opts} + 1));
423 matched_offset[${matched_opts}]="${i}";;
424 \)) matched_opts=$((${matched_opts} + 1));
425 matched_offset[${matched_opts}]="${i}";;
426 esac
427 done
428
429 for((i=0; i<=${matched_opts}; i++))
430 do
431 # i = offset were working on
432 # y = last offset
433 # z = current offset - last offset
434 # temp_var = temporary name
435 case ${i} in
436 0) tempvar=${test:0:${matched_offset[0]}};;
437 *) y=$((${matched_offset[$((${i} - 1))]} + 1))
438 z=$((${matched_offset[${i}]} - ${matched_offset[$((${i} - 1))]}));
439 z=$((${z} - 1))
440 tempvar=${test:${y}:${z}};;
441 esac
442
443 case ${i} in
444 0) result="${result} modulename:${tempvar}";;
445 1) result="${result} libdir:${tempvar}";;
446 2) result="${result} srcdir:${tempvar}";;
447 3) result="${result} objdir:${tempvar}";;
448 esac
449 done
450
451 echo ${result}
452 }
453
454 # default ebuild functions
455 # --------------------------------
456
457 linux-mod_pkg_setup() {
458 linux-info_pkg_setup;
459 check_kernel_built;
460 check_modules_supported;
461 set_kvobj;
462 check_vermagic;
463 }
464
465 linux-mod_src_compile() {
466 local modulename libdir srcdir objdir i n myARCH="${ARCH}"
467 ARCH="$(tc-arch-kernel)"
468
469 BUILD_TARGETS=${BUILD_TARGETS:-clean module}
470
471 for i in ${MODULE_IGNORE}
472 do
473 MODULE_NAMES=${MODULE_NAMES//${i}(*}
474 done
475
476 for i in ${MODULE_NAMES}
477 do
478 unset libdir srcdir objdir
479 for n in $(find_module_params ${i})
480 do
481 eval ${n/:*}=${n/*:/}
482 done
483 libdir=${libdir:-misc}
484 srcdir=${srcdir:-${S}}
485 objdir=${objdir:-${srcdir}}
486
487 if [ ! -f "${srcdir}/.built" ];
488 then
489 cd ${srcdir}
490 einfo "Preparing ${modulename} module"
491 if [[ -n ${ECONF_PARAMS} ]]
492 then
493 econf ${ECONF_PARAMS} || \
494 die "Unable to run econf ${ECONF_PARAMS}"
495 fi
496
497 emake ${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS} \
498 || die "Unable to make \
499 ${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS}."
500 touch ${srcdir}/.built
501 cd ${OLDPWD}
502 fi
503 done
504
505 ARCH="${myARCH}"
506 }
507
508 linux-mod_src_install() {
509 local modulename libdir srcdir objdir i n
510
511 for i in ${MODULE_IGNORE}
512 do
513 MODULE_NAMES=${MODULE_NAMES//${i}(*}
514 done
515
516 for i in ${MODULE_NAMES}
517 do
518 unset libdir srcdir objdir
519 for n in $(find_module_params ${i})
520 do
521 eval ${n/:*}=${n/*:/}
522 done
523 libdir=${libdir:-misc}
524 srcdir=${srcdir:-${S}}
525 objdir=${objdir:-${srcdir}}
526
527 einfo "Installing ${modulename} module"
528 cd ${objdir}
529 insinto ${ROOT}lib/modules/${KV_FULL}/${libdir}
530 doins ${modulename}.${KV_OBJ}
531 cd ${OLDPWD}
532
533 generate_modulesd ${objdir}/${modulename}
534 done
535 }
536
537 linux-mod_pkg_postinst() {
538 update_depmod;
539 update_modules;
540 update_moduledb;
541 }
542
543 linux-mod_pkg_postrm() {
544 remove_moduledb;
545 }

  ViewVC Help
Powered by ViewVC 1.1.20