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

Contents of /eclass/linux-mod.eclass

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.26 - (show annotations) (download)
Mon Jan 31 20:03:47 2005 UTC (9 years, 5 months ago) by johnm
Branch: MAIN
Changes since 1.25: +164 -88 lines
Multiple fixes.

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.17 2005/01/09 19:10:55 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 ECLASS=linux-mod
84 INHERITED="$INHERITED $ECLASS"
85 EXPORT_FUNCTIONS pkg_setup pkg_postinst src_install src_compile \
86 src_compile_userland src_install_userland
87
88 SLOT="0"
89 DESCRIPTION="Based on the $ECLASS eclass"
90 DEPEND="virtual/linux-sources
91 sys-apps/sed
92 virtual/modutils"
93
94
95 # eclass utilities
96 # ----------------------------------
97
98 use_m() {
99 # if we haven't determined the version yet, we need too.
100 get_version;
101
102 # if the kernel version is greater than 2.6.6 then we should use
103 # M= instead of SUBDIRS=
104 [ ${KV_MAJOR} -eq 2 -a ${KV_MINOR} -gt 5 -a ${KV_PATCH} -gt 5 ] && \
105 return 0 || return 1
106 }
107
108 convert_to_m() {
109 [ ! -f "${1}" ] && die "convert_to_m() requires a filename as an argument"
110 if use_m
111 then
112 ebegin "Converting ${1/${WORKDIR}\//} to use M= instead of SUBDIRS="
113 sed -i 's:SUBDIRS=:M=:g' ${1}
114 eend $?
115 fi
116 }
117
118 update_depmod() {
119 # if we haven't determined the version yet, we need too.
120 get_version;
121
122 ebegin "Updating module dependencies for ${KV_FULL}"
123 if [ -r ${KV_OUT_DIR}/System.map ]
124 then
125 depmod -ae -F ${KV_OUT_DIR}/System.map -b ${ROOT} -r ${KV_FULL}
126 eend $?
127 else
128 ewarn
129 ewarn "${KV_OUT_DIR}/System.map not found."
130 ewarn "You must manually update the kernel module dependencies using depmod."
131 eend 1
132 ewarn
133 fi
134 }
135
136 update_modules() {
137 if [ -x /sbin/modules-update -a \
138 -n "$(grep -v -e "^#" -e "^$" ${D}/etc/modules.d/*)" ] ; then
139 ebegin "Updating modules.conf"
140 /sbin/modules-update
141 eend $?
142 fi
143 }
144
145 set_kvobj() {
146 if kernel_is 2 6
147 then
148 KV_OBJ="ko"
149 else
150 KV_OBJ="o"
151 fi
152 # Do we really need to know this?
153 # Lets silence it.
154 # einfo "Using KV_OBJ=${KV_OBJ}"
155 }
156
157 generate_modulesd() {
158 # This function will generate the neccessary modules.d file from the
159 # information contained in the modules exported parms
160
161 local currm_path currm t myIFS myVAR
162 local module_docs module_enabled module_aliases \
163 module_additions module_examples module_modinfo module_opts
164
165 for currm_path in ${@}
166 do
167 currm=${currm_path//*\/}
168 currm=$(echo ${currm} | tr '[:lower:]' '[:upper:]')
169
170 module_docs="$(eval echo \${MODULESD_${currm}_DOCS})"
171 module_enabled="$(eval echo \${MODULESD_${currm}_ENABLED})"
172 module_aliases="$(eval echo \${#MODULESD_${currm}_ALIASES[*]})"
173 module_additions="$(eval echo \${#MODULESD_${currm}_ADDITIONS[*]})"
174 module_examples="$(eval echo \${#MODULESD_${currm}_EXAMPLES[*]})"
175
176 [ ${module_aliases} -eq 0 ] && unset module_aliases
177 [ ${module_additions} -eq 0 ] && unset module_additions
178 [ ${module_examples} -eq 0 ] && unset module_examples
179
180 # If we specify we dont want it, then lets exit, otherwise we assume
181 # that if its set, we do want it.
182 [[ ${module_enabled} == no ]] && return 0
183
184 # unset any unwanted variables.
185 for t in ${!module_*}
186 do
187 [[ -z ${!t} ]] && unset ${t}
188 done
189
190 [[ -z ${!module_*} ]] && return 0
191
192 # OK so now if we have got this far, then we know we want to continue
193 # and generate the modules.d file.
194 module_modinfo="$(modinfo -p ${currm_path}.${KV_OBJ})"
195 module_config="${T}/modulesd-${currm}"
196
197 ebegin "Preparing file for modules.d"
198 #-----------------------------------------------------------------------
199 echo "# modules.d configuration file for ${currm}" >> ${module_config}
200 #-----------------------------------------------------------------------
201 [[ -n ${module_docs} ]] && \
202 echo "# For more information please read:" >> ${module_config}
203 for t in ${module_docs}
204 do
205 echo "# ${t//*\/}" >> ${module_config}
206 done
207 echo >> ${module_config}
208
209 #-----------------------------------------------------------------------
210 if [ ${module_aliases} -gt 0 ]
211 then
212 echo "# Internal Aliases - Do not edit" >> ${module_config}
213 echo "# ------------------------------" >> ${module_config}
214
215 for((t=0; t<${module_aliases}; t++))
216 do
217 echo "alias $(eval echo \${MODULESD_${currm}_ALIASES[$t]})" \
218 >> ${module_config}
219 done
220 echo '' >> ${module_config}
221 fi
222
223 #-----------------------------------------------------------------------
224 if [[ -n ${module_modinfo} ]]
225 then
226 echo >> ${module_config}
227 echo "# Configurable module parameters" >> ${module_config}
228 echo "# ------------------------------" >> ${module_config}
229 myIFS="${IFS}"
230 IFS="$(echo -en "\n\b")"
231
232 for t in ${module_modinfo}
233 do
234 myVAR="$(echo ${t#*:} | grep -e " [0-9][ =]" | sed "s:.*\([01][= ]\).*:\1:")"
235 if [[ -n ${myVAR} ]]
236 then
237 module_opts="${module_opts} ${t%%:*}:${myVAR}"
238 fi
239 echo -e "# ${t%%:*}:\t${t#*:}" >> ${module_config}
240 done
241 IFS="${myIFS}"
242 echo '' >> ${module_config}
243 fi
244
245 #-----------------------------------------------------------------------
246 if [[ $(eval echo \${MODULESD_${currm}_ALIASES[0]}) == guess ]]
247 then
248 # So lets do some guesswork eh?
249 if [[ -n ${module_opts} ]]
250 then
251 echo "# For Example..." >> ${module_config}
252 echo "# --------------" >> ${module_config}
253 for t in ${module_opts}
254 do
255 echo "# options ${currm} ${t//:*}=${t//*:}" >> ${module_config}
256 done
257 echo '' >> ${module_config}
258 fi
259 elif [ ${module_examples} -gt 0 ]
260 then
261 echo "# For Example..." >> ${module_config}
262 echo "# --------------" >> ${module_config}
263 for((t=0; t<${module_examples}; t++))
264 do
265 echo "options $(eval echo \${MODULESD_${currm}_EXAMPLES[$t]})" \
266 >> ${module_config}
267 done
268 echo '' >> ${module_config}
269 fi
270
271 #-----------------------------------------------------------------------
272 if [ ${module_additions} -gt 0 ]
273 then
274 for((t=0; t<${module_additions}; t++))
275 do
276 echo "$(eval echo \${MODULESD_${currm}_ADDITIONS[$t]})" \
277 >> ${module_config}
278 done
279 echo '' >> ${module_config}
280 fi
281
282 #-----------------------------------------------------------------------
283
284 # then we install it
285 insinto /etc/modules.d
286 newins ${module_config} ${currm_path}
287
288 # and install any documentation we might have.
289 [[ -n ${module_docs} ]] && dodoc ${module_docs}
290 done
291 eend 0
292 return 0
293 }
294
295 display_postinst() {
296 # if we haven't determined the version yet, we need too.
297 get_version;
298
299 local modulename moduledir sourcedir moduletemp file i
300
301 file=${ROOT}/etc/modules.autoload.d/kernel-${KV_MAJOR}.${KV_MINOR}
302 file=${file/\/\///}
303
304 for i in ${MODULE_IGNORE}
305 do
306 MODULE_NAMES=${MODULE_NAMES//${i}(*}
307 done
308
309 if [[ -n ${MODULE_NAMES} ]]
310 then
311 einfo "If you would like to load this module automatically upon boot"
312 einfo "please type the following as root:"
313 for i in ${MODULE_NAMES}
314 do
315 unset libdir srcdir objdir
316 for n in $(find_module_params ${i})
317 do
318 eval ${n/:*}=${n/*:/}
319 done
320 einfo " # echo \"${modulename}\" >> ${file}"
321 done
322 einfo
323 fi
324 }
325
326 find_module_params() {
327 local matched_offset=0 matched_opts=0 test="${@}" temp_var result
328 local i=0 y=0 z=0
329
330 for((i=0; i<=${#test}; i++))
331 do
332 case ${test:${i}:1} in
333 \() matched_offset[0]=${i};;
334 \:) matched_opts=$((${matched_opts} + 1));
335 matched_offset[${matched_opts}]="${i}";;
336 \)) matched_opts=$((${matched_opts} + 1));
337 matched_offset[${matched_opts}]="${i}";;
338 esac
339 done
340
341 for((i=0; i<=${matched_opts}; i++))
342 do
343 # i = offset were working on
344 # y = last offset
345 # z = current offset - last offset
346 # temp_var = temporary name
347 case ${i} in
348 0) tempvar=${test:0:${matched_offset[0]}};;
349 *) y=$((${matched_offset[$((${i} - 1))]} + 1))
350 z=$((${matched_offset[${i}]} - ${matched_offset[$((${i} - 1))]}));
351 z=$((${z} - 1))
352 tempvar=${test:${y}:${z}};;
353 esac
354
355 case ${i} in
356 0) result="${result} modulename:${tempvar}";;
357 1) result="${result} libdir:${tempvar}";;
358 2) result="${result} srcdir:${tempvar}";;
359 3) result="${result} objdir:${tempvar}";;
360 esac
361 done
362
363 echo ${result}
364 }
365
366 # default ebuild functions
367 # --------------------------------
368
369 linux-mod_pkg_setup() {
370 linux-info_pkg_setup;
371 check_kernel_built;
372 check_modules_supported;
373 set_kvobj;
374 }
375
376 linux-mod_src_compile_userland() {
377 return 0
378 }
379
380 linux-mod_src_install_userland() {
381 return 0
382 }
383
384 linux-mod_src_compile() {
385 local modulename libdir srcdir objdir i n myARCH="${ARCH}"
386 unset ARCH
387
388 BUILD_TARGETS=${BUILD_TARGETS:-clean module}
389
390 for i in ${MODULE_IGNORE}
391 do
392 MODULE_NAMES=${MODULE_NAMES//${i}(*}
393 done
394
395 for i in ${MODULE_NAMES}
396 do
397 unset libdir srcdir objdir
398 for n in $(find_module_params ${i})
399 do
400 eval ${n/:*}=${n/*:/}
401 done
402 libdir=${libdir:-misc}
403 srcdir=${srcdir:-${S}}
404 objdir=${objdir:-${srcdir}}
405
406 if [ ! -f "${srcdir}/.built" ];
407 then
408 cd ${srcdir}
409 einfo "Preparing ${modulename} module"
410 if [[ -n ${ECONF_PARAMS} ]]
411 then
412 econf ${ECONF_PARAMS} || \
413 die "Unable to run econf ${ECONF_PARAMS}"
414 fi
415
416 emake ${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS} \
417 || die "Unable to make \
418 ${BUILD_FIXES} ${BUILD_PARAMS} ${BUILD_TARGETS}."
419 touch ${srcdir}/.built
420 cd ${OLDPWD}
421 fi
422 done
423
424 ARCH="${myARCH}"
425 }
426
427 linux-mod_src_install() {
428 local modulename libdir srcdir objdir i n
429
430 for i in ${MODULE_IGNORE}
431 do
432 MODULE_NAMES=${MODULE_NAMES//${i}(*}
433 done
434
435 for i in ${MODULE_NAMES}
436 do
437 unset libdir srcdir objdir
438 for n in $(find_module_params ${i})
439 do
440 eval ${n/:*}=${n/*:/}
441 done
442 libdir=${libdir:-misc}
443 srcdir=${srcdir:-${S}}
444 objdir=${objdir:-${srcdir}}
445
446 einfo "Installing ${modulename} module"
447 cd ${objdir}
448 insinto ${ROOT}lib/modules/${KV_FULL}/${libdir}
449 doins ${modulename}.${KV_OBJ}
450 cd ${OLDPWD}
451
452 generate_modulesd ${objdir}/${modulename}
453 done
454 }
455
456 linux-mod_pkg_postinst() {
457 update_depmod;
458 update_modules;
459 display_postinst;
460 }

  ViewVC Help
Powered by ViewVC 1.1.20