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

Contents of /eclass/linux-info.eclass

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.15 - (show annotations) (download)
Fri Dec 31 09:23:43 2004 UTC (9 years, 9 months ago) by mrness
Branch: MAIN
Changes since 1.14: +20 -2 lines
correct kernel_is; format kernel versions as %d%03d%03d and test them as integers

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-info.eclass,v 1.14 2004/12/29 11:22:41 johnm Exp $
4 #
5 # Description: This eclass is used as a central eclass for accessing kernel
6 # related information for sources already installed.
7 # It is vital for linux-mod to function correctly, and is split
8 # out so that any ebuild behaviour "templates" are abstracted out
9 # using additional eclasses.
10 #
11 # Maintainer: John Mylchreest <johnm@gentoo.org>
12 # Copyright 2004 Gentoo Linux
13 #
14 # Please direct your bugs to the current eclass maintainer :)
15
16 # A Couple of env vars are available to effect usage of this eclass
17 # These are as follows:
18 #
19 # Env Var Option Description
20 # KERNEL_DIR <string> The directory containing kernel the target kernel
21 # sources.
22 # CONFIG_CHECK <string> a list of .config options to check for before
23 # proceeding with the install. ie: CONFIG_CHECK="MTRR"
24 # You can also check that an option doesn't exist by
25 # prepending it with an exclamation mark (!).
26 # ie: CONFIG_CHECK="!MTRR"
27 # <CFG>_ERROR <string> The error message to display when the above check
28 # fails. <CFG> should reference the appropriate option
29 # as above. ie: MTRR_ERROR="MTRR exists in the .config
30 # but shouldn't!!"
31 # KBUILD_OUTPUT <string> This is passed on commandline, or can be set from
32 # the kernel makefile. This contains the directory
33 # which is to be used as the kernel object directory.
34
35 # There are also a couple of variables which are set by this, and shouldn't be
36 # set by hand. These are as follows:
37 #
38 # Env Var Option Description
39 # KV_FULL <string> The full kernel version. ie: 2.6.9-gentoo-johnm-r1
40 # KV_MAJOR <integer> The kernel major version. ie: 2
41 # KV_MINOR <integer> The kernel minor version. ie: 6
42 # KV_PATCH <integer> The kernel patch version. ie: 9
43 # KV_EXTRA <string> The kernel EXTRAVERSION. ie: -gentoo
44 # KV_LOCAL <string> The kernel LOCALVERSION concatenation. ie: -johnm
45 # KV_DIR <string> The kernel source directory, will be null if
46 # KERNEL_DIR is invalid.
47 # KV_OUT_DIR <string> The kernel object directory. will be KV_DIR unless
48 # koutput is used. This should be used for referencing
49 # .config.
50
51
52 ECLASS=linux-info
53 INHERITED="$INHERITED $ECLASS"
54 EXPORT_FUNCTIONS pkg_setup
55
56 # Overwritable environment Var's
57 # ---------------------------------------
58 KERNEL_DIR="${KERNEL_DIR:-/usr/src/linux}"
59
60
61 # Pulled from eutils as it might be more useful only being here since
62 # very few ebuilds which dont use this eclass will ever ever use these functions
63 set_arch_to_kernel() {
64 export PORTAGE_ARCH="${ARCH}"
65 case ${ARCH} in
66 x86) export ARCH="i386";;
67 amd64) export ARCH="x86_64";;
68 hppa) export ARCH="parisc";;
69 mips) export ARCH="mips";;
70 *) export ARCH="${ARCH}";;
71 esac
72 }
73
74 # set's ARCH back to what portage expects
75 set_arch_to_portage() {
76 export ARCH="${PORTAGE_ARCH}"
77 }
78
79
80 #
81 # qeinfo "Message"
82 # -------------------
83 # qeinfo is a queit einfo call when EBUILD_PHASE
84 # should not have visible output.
85 #
86 qeinfo() {
87 local outputmsg
88 outputmsg="${@}"
89 case "${EBUILD_PHASE}" in
90 depend) unset outputmsg;;
91 clean) unset outputmsg;;
92 preinst) unset outputmsg;;
93 esac
94 [ -n "${outputmsg}" ] && einfo "${outputmsg}"
95 }
96
97 qeerror() {
98 local outputmsg
99 outputmsg="${@}"
100 case "${EBUILD_PHASE}" in
101 depend) unset outputmsg;;
102 clean) unset outputmsg;;
103 preinst) unset outputmsg;;
104 esac
105 [ -n "${outputmsg}" ] && einfo "${outputmsg}"
106 }
107
108
109
110 # File Functions
111 # ---------------------------------------
112
113 # getfilevar accepts 2 vars as follows:
114 # getfilevar <VARIABLE> <CONFIGFILE>
115
116 getfilevar() {
117 local ERROR workingdir basefname basedname xarch
118 ERROR=0
119
120 [ -z "${1}" ] && ERROR=1
121 [ ! -f "${2}" ] && ERROR=1
122
123 if [ "${ERROR}" = 1 ]
124 then
125 ebeep
126 echo -e "\n"
127 eerror "getfilevar requires 2 variables, with the second a valid file."
128 eerror " getfilevar <VARIABLE> <CONFIGFILE>"
129 else
130 workingdir=${PWD}
131 basefname=$(basename ${2})
132 basedname=$(dirname ${2})
133 xarch=${ARCH}
134 unset ARCH
135
136 cd ${basedname}
137 echo -e "include ${basefname}\ne:\n\t@echo \$(${1})" | \
138 make -f - e 2>/dev/null
139 cd ${workingdir}
140
141 ARCH=${xarch}
142 fi
143 }
144
145 linux_chkconfig_present() {
146 local RESULT
147 RESULT="$(getfilevar CONFIG_${1} ${KV_OUT_DIR}/.config)"
148 [ "${RESULT}" = "m" -o "${RESULT}" = "y" ] && return 0 || return 1
149 }
150
151 linux_chkconfig_module() {
152 local RESULT
153 RESULT="$(getfilevar CONFIG_${1} ${KV_OUT_DIR}/.config)"
154 [ "${RESULT}" = "m" ] && return 0 || return 1
155 }
156
157 linux_chkconfig_builtin() {
158 local RESULT
159 RESULT="$(getfilevar CONFIG_${1} ${KV_OUT_DIR}/.config)"
160 [ "${RESULT}" = "y" ] && return 0 || return 1
161 }
162
163 linux_chkconfig_string() {
164 getfilevar "CONFIG_${1}" "${KV_OUT_DIR}/.config"
165 }
166
167 # Versioning Functions
168 # ---------------------------------------
169
170 # kernel_is returns true when the version is the same as the passed version
171 #
172 # For Example where KV = 2.6.9
173 # kernel_is 2 4 returns false
174 # kernel_is 2 returns true
175 # kernel_is 2 6 returns true
176 # kernel_is 2 6 8 returns false
177 # kernel_is 2 6 9 returns true
178 #
179 # got the jist yet?
180
181 kernel_is() {
182 # if we haven't determined the version yet, we need too.
183 get_version;
184
185 local RESULT operator test value i len
186 RESULT=0
187
188 operator="="
189 if [ "${1}" == "lt" ]
190 then
191 operator="-lt"
192 shift
193 elif [ "${1}" == "gt" ]
194 then
195 operator="-gt"
196 shift
197 elif [ "${1}" == "le" ]
198 then
199 operator="-le"
200 shift
201 elif [ "${1}" == "ge" ]
202 then
203 operator="-ge"
204 shift
205 fi
206
207 if [ -n "${1}" ]
208 then
209 value="${value}${1}"
210 test="${test}${KV_MAJOR}"
211 fi
212 if [ -n "${2}" ]
213 then
214 len=$[ 3 - ${#2} ]
215 for((i=0; i<$len; i++)); do
216 value="${value}0"
217 done
218 value="${value}${2}"
219
220 len=$[ 3 - ${#KV_MINOR} ]
221 for((i=0; i<$len; i++)); do
222 test="${test}0"
223 done
224 test="${test}${KV_MINOR}"
225 fi
226 if [ -n "${3}" ]
227 then
228 len=$[ 3 - ${#3} ]
229 for((i=0; i<$len; i++)); do
230 value="${value}0"
231 done
232 value="${value}${3}"
233
234 len=$[ 3 - ${#KV_PATCH} ]
235 for((i=0; i<$len; i++)); do
236 test="${test}0"
237 done
238 test="${test}${KV_PATCH}"
239 fi
240
241 [ ${test} ${operator} ${value} ] && return 0 || return 1
242 }
243
244 get_version() {
245 local kbuild_output
246
247 # no need to execute this twice assuming KV_FULL is populated.
248 # we can force by unsetting KV_FULL
249 [ -n "${KV_FULL}" ] && return
250
251 # if we dont know KV_FULL, then we need too.
252 # make sure KV_DIR isnt set since we need to work it out via KERNEL_DIR
253 unset KV_DIR
254
255 # KV_DIR will contain the full path to the sources directory we should use
256 qeinfo "Determining the location of the kernel source code"
257 [ -h "${KERNEL_DIR}" ] && KV_DIR="$(readlink -f ${KERNEL_DIR})"
258 [ -d "${KERNEL_DIR}" ] && KV_DIR="${KERNEL_DIR}"
259
260 if [ -z "${KV_DIR}" ]
261 then
262 qeerror "Unable to find kernel sources at ${KERNEL_DIR}"
263 qeinfo "This package requires Linux sources."
264 if [ "${KERNEL_DIR}" == "/usr/src/linux" ] ; then
265 qeinfo "Please make sure that ${KERNEL_DIR} points at your running kernel, "
266 qeinfo "(or the kernel you wish to build against)."
267 qeinfo "Alternatively, set the KERNEL_DIR environment variable to the kernel sources location"
268 else
269 qeinfo "Please ensure that the KERNEL_DIR environment variable points at full Linux sources of the kernel you wish to compile against."
270 fi
271 die "Cannot locate Linux sources at ${KERNEL_DIR}"
272 fi
273
274 qeinfo "Found kernel source directory:"
275 qeinfo " ${KV_DIR}"
276
277 if [ ! -s "${KV_DIR}/Makefile" ]
278 then
279 qeerror "Could not find a Makefile in the kernel source directory."
280 qeerror "Please ensure that ${KERNEL_DIR} points to a complete set of Linux sources"
281 die "Makefile not found in ${KV_DIR}"
282 fi
283
284 # OK so now we know our sources directory, but they might be using
285 # KBUILD_OUTPUT, and we need this for .config and localversions-*
286 # so we better find it eh?
287 # do we pass KBUILD_OUTPUT on the CLI?
288 OUTPUT_DIR="${OUTPUT_DIR:-${KBUILD_OUTPUT}}"
289
290 # And if we didn't pass it, we can take a nosey in the Makefile
291 kbuild_output="$(getfilevar KBUILD_OUTPUT ${KV_DIR}/Makefile)"
292 OUTPUT_DIR="${OUTPUT_DIR:-${kbuild_output}}"
293
294 # And contrary to existing functions I feel we shouldn't trust the
295 # directory name to find version information as this seems insane.
296 # so we parse ${KV_DIR}/Makefile
297 KV_MAJOR="$(getfilevar VERSION ${KV_DIR}/Makefile)"
298 KV_MINOR="$(getfilevar PATCHLEVEL ${KV_DIR}/Makefile)"
299 KV_PATCH="$(getfilevar SUBLEVEL ${KV_DIR}/Makefile)"
300 KV_EXTRA="$(getfilevar EXTRAVERSION ${KV_DIR}/Makefile)"
301
302 if [ -z "${KV_MAJOR}" -o -z "${KV_MINOR}" -o -z "${KV_PATCH}" ]
303 then
304 qeerror "Could not detect kernel version."
305 qeerror "Please ensure that ${KERNEL_DIR} points to a complete set of Linux sources"
306 die "Could not parse version info from ${KV_DIR}/Makefile"
307 fi
308
309 # and in newer versions we can also pull LOCALVERSION if it is set.
310 # but before we do this, we need to find if we use a different object directory.
311 # This *WILL* break if the user is using localversions, but we assume it was
312 # caught before this if they are.
313 [ "${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}.${KV_EXTRA}" == "$(uname -r)" ] && \
314 OUTPUT_DIR="${OUTPUT_DIR:-/lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}.${KV_EXTRA}/build}"
315
316 [ -h "${OUTPUT_DIR}" ] && KV_OUT_DIR="$(readlink -f ${OUTPUT_DIR})"
317 [ -d "${OUTPUT_DIR}" ] && KV_OUT_DIR="${OUTPUT_DIR}"
318 if [ -n "${KV_OUT_DIR}" ];
319 then
320 qeinfo "Found kernel object directory:"
321 qeinfo " ${KV_OUT_DIR}"
322
323 KV_LOCAL="$(cat ${KV_OUT_DIR}/localversion* 2>/dev/null)"
324 fi
325 # and if we STILL haven't got it, then we better just set it to KV_DIR
326 KV_OUT_DIR="${KV_OUT_DIR:-${KV_DIR}}"
327
328 KV_LOCAL="${KV_LOCAL}$(cat ${KV_DIR}/localversion* 2>/dev/null)"
329 KV_LOCAL="${KV_LOCAL}$(linux_chkconfig_string LOCALVERSION)"
330 KV_LOCAL="${KV_LOCAL//\"/}"
331
332 # And we should set KV_FULL to the full expanded version
333 KV_FULL="${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}${KV_LOCAL}"
334
335 qeinfo "Found sources for kernel version:"
336 qeinfo " ${KV_FULL}"
337
338 if [ ! -s "${KV_OUT_DIR}/.config" ]
339 then
340 qeerror "Could not find a usable .config in the kernel source directory."
341 qeerror "Please ensure that ${KERNEL_DIR} points to a configured set of Linux sources."
342 qeerror "If you are using KBUILD_OUTPUT, please set the environment var so that"
343 qeerror "it points to the necessary object directory so that it might find .config."
344 die ".config not found in ${KV_OUT_DIR}"
345 fi
346 }
347
348
349
350
351 # ebuild check functions
352 # ---------------------------------------
353
354 check_kernel_built() {
355 # if we haven't determined the version yet, we need too.
356 get_version;
357
358 if [ ! -f "${KV_OUT_DIR}/System.map" ]
359 then
360 eerror "These sources have not yet been compiled."
361 eerror "We cannot build against an uncompiled tree."
362 eerror "To resolve this, please type the following:"
363 eerror
364 eerror "# cd ${KV_DIR}"
365 eerror "# make oldconfig"
366 eerror "# make bzImage modules modules_install"
367 eerror
368 eerror "Then please try merging this module again."
369 die "Kernel sources need compiling first"
370 fi
371 }
372
373 check_modules_supported() {
374 # if we haven't determined the version yet, we need too.
375 get_version;
376
377 if ! linux_chkconfig_builtin "MODULES"
378 then
379 eerror "These sources do not support loading external modules."
380 eerror "to be able to use this module please enable \"Loadable modules support\""
381 eerror "in your kernel, recompile and then try merging this module again."
382 die "No support for external modules in ${KV_FULL} config"
383 fi
384 }
385
386 check_extra_config() {
387 local config negate error local_error
388
389 # if we haven't determined the version yet, we need too.
390 get_version;
391
392 einfo "Checking for suitable kernel configuration options"
393 for config in ${CONFIG_CHECK}
394 do
395 negate="${config:0:1}"
396 if [ "${negate}" == "!" ];
397 then
398 config="${config:1}"
399 if linux_chkconfig_present ${config}
400 then
401 local_error="${config}_ERROR"
402 local_error="${!local_error}"
403 [ -n "${local_error}" ] && eerror " ${local_error}" || \
404 eerror " CONFIG_${config}:\tshould not be set in the kernel configuration, but it is."
405 error=1
406 fi
407 else
408 if ! linux_chkconfig_present ${config}
409 then
410 local_error="${config}_ERROR"
411 local_error="${!local_error}"
412 [ -n "${local_error}" ] && eerror " ${local_error}" || \
413 eerror " CONFIG_${config}:\tshould be set in the kernel configuration, but isn't"
414 error=1
415 fi
416 fi
417 done
418
419 if [ -n "${error}" ] ;
420 then
421 eerror "Please check to make sure these options are set correctly."
422 eerror "Once you have satisfied these options, please try merging"
423 eerror "this package again."
424 die "Incorrect kernel configuration options"
425 fi
426 }
427
428 check_zlibinflate() {
429 # if we haven't determined the version yet, we need too.
430 get_version;
431
432 # although I restructured this code - I really really really dont support it!
433
434 # bug #27882 - zlib routines are only linked into the kernel
435 # if something compiled into the kernel calls them
436 #
437 # plus, for the cloop module, it appears that there's no way
438 # to get cloop.o to include a static zlib if CONFIG_MODVERSIONS
439 # is on
440
441 local INFLATE
442 local DEFLATE
443
444 einfo "Determining the usability of ZLIB_INFLATE support in your kernel"
445
446 ebegin "checking ZLIB_INFLATE"
447 getfilevar_isbuiltin CONFIG_ZLIB_INFLATE ${KV_DIR}/.config
448 eend $?
449 [ "$?" != 0 ] && die
450
451 ebegin "checking ZLIB_DEFLATE"
452 getfilevar_isbuiltin CONFIG_ZLIB_DEFLATE ${KV_DIR}/.config
453 eend $?
454 [ "$?" != 0 ] && die
455
456
457 local LINENO_START
458 local LINENO_END
459 local SYMBOLS
460 local x
461
462 LINENO_END="$(grep -n 'CONFIG_ZLIB_INFLATE y' ${KV_DIR}/lib/Config.in | cut -d : -f 1)"
463 LINENO_START="$(head -n $LINENO_END ${KV_DIR}/lib/Config.in | grep -n 'if \[' | tail -n 1 | cut -d : -f 1)"
464 (( LINENO_AMOUNT = $LINENO_END - $LINENO_START ))
465 (( LINENO_END = $LINENO_END - 1 ))
466 SYMBOLS="$(head -n $LINENO_END ${KV_DIR}/lib/Config.in | tail -n $LINENO_AMOUNT | sed -e 's/^.*\(CONFIG_[^\" ]*\).*/\1/g;')"
467
468 # okay, now we have a list of symbols
469 # we need to check each one in turn, to see whether it is set or not
470 for x in $SYMBOLS ; do
471 if [ "${!x}" = "y" ]; then
472 # we have a winner!
473 einfo "${x} ensures zlib is linked into your kernel - excellent"
474 return 0
475 fi
476 done
477
478 eerror
479 eerror "This kernel module requires ZLIB library support."
480 eerror "You have enabled zlib support in your kernel, but haven't enabled"
481 eerror "enabled any option that will ensure that zlib is linked into your"
482 eerror "kernel."
483 eerror
484 eerror "Please ensure that you enable at least one of these options:"
485 eerror
486
487 for x in $SYMBOLS ; do
488 eerror " * $x"
489 done
490
491 eerror
492 eerror "Please remember to recompile and install your kernel, and reboot"
493 eerror "into your new kernel before attempting to load this kernel module."
494
495 die "Kernel doesn't include zlib support"
496 }
497
498 ################################
499 # Default pkg_setup
500 # Also used when inheriting linux-mod to force a get_version call
501
502 linux-info_pkg_setup() {
503 get_version;
504 [ -n "${CONFIG_CHECK}" ] && check_extra_config;
505 }

  ViewVC Help
Powered by ViewVC 1.1.20