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

Contents of /eclass/linux-mod.eclass

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.45 - (show annotations) (download)
Wed Jul 6 20:53:20 2005 UTC (9 years, 5 months ago) by agriffis
Branch: MAIN
Changes since 1.44: +2 -2 lines
add IUSE=pcmcia

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

  ViewVC Help
Powered by ViewVC 1.1.20