1 | # Copyright 1999-2004 Gentoo Foundation |
1 | # Copyright 1999-2006 Gentoo Foundation |
2 | # Distributed under the terms of the GNU General Public License v2 |
2 | # Distributed under the terms of the GNU General Public License v2 |
3 | # $Header: /var/cvsroot/gentoo-x86/eclass/linux-info.eclass,v 1.18 2005/01/15 21:46:00 johnm Exp $ |
3 | # $Header: /var/cvsroot/gentoo-x86/eclass/linux-info.eclass,v 1.83 2010/01/17 21:46:55 robbat2 Exp $ |
4 | # |
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> |
5 | # Original author: John Mylchreest <johnm@gentoo.org> |
12 | # Copyright 2004 Gentoo Linux |
6 | # Maintainer: kernel-misc@gentoo.org |
13 | # |
7 | # |
14 | # Please direct your bugs to the current eclass maintainer :) |
8 | # Please direct your bugs to the current eclass maintainer :) |
|
|
9 | |
|
|
10 | # @ECLASS: linux-info.eclass |
|
|
11 | # @MAINTAINER: |
|
|
12 | # kernel-misc@gentoo.org |
|
|
13 | # @BLURB: eclass used for accessing kernel related information |
|
|
14 | # @DESCRIPTION: |
|
|
15 | # This eclass is used as a central eclass for accessing kernel |
|
|
16 | # related information for source or binary already installed. |
|
|
17 | # It is vital for linux-mod.eclass to function correctly, and is split |
|
|
18 | # out so that any ebuild behaviour "templates" are abstracted out |
|
|
19 | # using additional eclasses. |
|
|
20 | # |
|
|
21 | # "kernel config" in this file means: |
|
|
22 | # The .config of the currently installed sources is used as the first |
|
|
23 | # preference, with a fall-back to bundled config (/proc/config.gz) if available. |
15 | |
24 | |
16 | # A Couple of env vars are available to effect usage of this eclass |
25 | # A Couple of env vars are available to effect usage of this eclass |
17 | # These are as follows: |
26 | # These are as follows: |
18 | # |
27 | |
19 | # Env Var Option Description |
28 | # @ECLASS-VARIABLE: KERNEL_DIR |
20 | # KERNEL_DIR <string> The directory containing kernel the target kernel |
29 | # @DESCRIPTION: |
21 | # sources. |
30 | # A string containing the directory of the target kernel sources. The default value is |
|
|
31 | # "/usr/src/linux" |
|
|
32 | |
|
|
33 | # @ECLASS-VARIABLE: CONFIG_CHECK |
|
|
34 | # @DESCRIPTION: |
22 | # CONFIG_CHECK <string> a list of .config options to check for before |
35 | # A string containing a list of .config options to check for before |
23 | # proceeding with the install. ie: CONFIG_CHECK="MTRR" |
36 | # proceeding with the install. |
|
|
37 | # |
|
|
38 | # e.g.: CONFIG_CHECK="MTRR" |
|
|
39 | # |
24 | # You can also check that an option doesn't exist by |
40 | # You can also check that an option doesn't exist by |
25 | # prepending it with an exclamation mark (!). |
41 | # prepending it with an exclamation mark (!). |
|
|
42 | # |
26 | # ie: CONFIG_CHECK="!MTRR" |
43 | # e.g.: CONFIG_CHECK="!MTRR" |
27 | # <CFG>_ERROR <string> The error message to display when the above check |
44 | # |
|
|
45 | # To simply warn about a missing option, prepend a '~'. |
|
|
46 | # It may be combined with '!'. |
|
|
47 | # |
|
|
48 | # In general, most checks should be non-fatal. The only time fatal checks should |
|
|
49 | # be used is for building kernel modules or cases that a compile will fail |
|
|
50 | # without the option. |
|
|
51 | # |
|
|
52 | # This is to allow usage of binary kernels, and minimal systems without kernel |
|
|
53 | # sources. |
|
|
54 | |
|
|
55 | # @ECLASS-VARIABLE: ERROR_<CFG> |
|
|
56 | # @DESCRIPTION: |
|
|
57 | # A string containing the error message to display when the check against CONFIG_CHECK |
28 | # fails. <CFG> should reference the appropriate option |
58 | # fails. <CFG> should reference the appropriate option used in CONFIG_CHECK. |
29 | # as above. ie: MTRR_ERROR="MTRR exists in the .config |
59 | # |
30 | # but shouldn't!!" |
60 | # e.g.: ERROR_MTRR="MTRR exists in the .config but shouldn't!!" |
31 | # KBUILD_OUTPUT <string> This is passed on commandline, or can be set from |
61 | |
32 | # the kernel makefile. This contains the directory |
62 | # @ECLASS-VARIABLE: KBUILD_OUTPUT |
|
|
63 | # @DESCRIPTION: |
|
|
64 | # A string passed on commandline, or set from the kernel makefile. It contains the directory |
33 | # which is to be used as the kernel object directory. |
65 | # which is to be used as the kernel object directory. |
34 | |
66 | |
35 | # There are also a couple of variables which are set by this, and shouldn't be |
67 | # There are also a couple of variables which are set by this, and shouldn't be |
36 | # set by hand. These are as follows: |
68 | # set by hand. These are as follows: |
37 | # |
69 | |
38 | # Env Var Option Description |
70 | # @ECLASS-VARIABLE: KV_FULL |
39 | # KV_FULL <string> The full kernel version. ie: 2.6.9-gentoo-johnm-r1 |
71 | # @DESCRIPTION: |
40 | # KV_MAJOR <integer> The kernel major version. ie: 2 |
72 | # A read-only variable. It's a string containing the full kernel version. ie: 2.6.9-gentoo-johnm-r1 |
41 | # KV_MINOR <integer> The kernel minor version. ie: 6 |
73 | |
42 | # KV_PATCH <integer> The kernel patch version. ie: 9 |
74 | # @ECLASS-VARIABLE: KV_MAJOR |
43 | # KV_EXTRA <string> The kernel EXTRAVERSION. ie: -gentoo |
75 | # @DESCRIPTION: |
44 | # KV_LOCAL <string> The kernel LOCALVERSION concatenation. ie: -johnm |
76 | # A read-only variable. It's an integer containing the kernel major version. ie: 2 |
45 | # KV_DIR <string> The kernel source directory, will be null if |
77 | |
|
|
78 | # @ECLASS-VARIABLE: KV_MINOR |
|
|
79 | # @DESCRIPTION: |
|
|
80 | # A read-only variable. It's an integer containing the kernel minor version. ie: 6 |
|
|
81 | |
|
|
82 | # @ECLASS-VARIABLE: KV_PATCH |
|
|
83 | # @DESCRIPTION: |
|
|
84 | # A read-only variable. It's an integer containing the kernel patch version. ie: 9 |
|
|
85 | |
|
|
86 | # @ECLASS-VARIABLE: KV_EXTRA |
|
|
87 | # @DESCRIPTION: |
|
|
88 | # A read-only variable. It's a string containing the kernel EXTRAVERSION. ie: -gentoo |
|
|
89 | |
|
|
90 | # @ECLASS-VARIABLE: KV_LOCAL |
|
|
91 | # @DESCRIPTION: |
|
|
92 | # A read-only variable. It's a string containing the kernel LOCALVERSION concatenation. ie: -johnm |
|
|
93 | |
|
|
94 | # @ECLASS-VARIABLE: KV_DIR |
|
|
95 | # @DESCRIPTION: |
|
|
96 | # A read-only variable. It's a string containing the kernel source directory, will be null if |
46 | # KERNEL_DIR is invalid. |
97 | # 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 | |
98 | |
|
|
99 | # @ECLASS-VARIABLE: KV_OUT_DIR |
|
|
100 | # @DESCRIPTION: |
|
|
101 | # A read-only variable. It's a string containing the kernel object directory, will be KV_DIR unless |
|
|
102 | # KBUILD_OUTPUT is used. This should be used for referencing .config. |
51 | |
103 | |
52 | ECLASS=linux-info |
104 | # And to ensure all the weirdness with crosscompile |
53 | INHERITED="$INHERITED $ECLASS" |
105 | inherit toolchain-funcs versionator |
|
|
106 | |
54 | EXPORT_FUNCTIONS pkg_setup |
107 | EXPORT_FUNCTIONS pkg_setup |
|
|
108 | |
|
|
109 | DEPEND="" |
|
|
110 | RDEPEND="" |
55 | |
111 | |
56 | # Overwritable environment Var's |
112 | # Overwritable environment Var's |
57 | # --------------------------------------- |
113 | # --------------------------------------- |
58 | KERNEL_DIR="${KERNEL_DIR:-/usr/src/linux}" |
114 | KERNEL_DIR="${KERNEL_DIR:-${ROOT}usr/src/linux}" |
59 | |
115 | |
60 | |
116 | |
61 | # Bug fixes |
117 | # Bug fixes |
62 | |
|
|
63 | # fix to bug #75034 |
118 | # fix to bug #75034 |
64 | case ${ARCH} in |
119 | case ${ARCH} in |
65 | ppc) BUILD_FIXES="${BUILD_FIXES} TOUT=${T}/.tmp_gas_check";; |
120 | ppc) BUILD_FIXES="${BUILD_FIXES} TOUT=${T}/.tmp_gas_check";; |
66 | ppc64) BUILD_FIXES="${BUILD_FIXES} TOUT=${T}/.tmp_gas_check";; |
121 | ppc64) BUILD_FIXES="${BUILD_FIXES} TOUT=${T}/.tmp_gas_check";; |
67 | esac |
122 | esac |
68 | |
123 | |
69 | # Pulled from eutils as it might be more useful only being here since |
124 | # @FUNCTION: set_arch_to_kernel |
70 | # very few ebuilds which dont use this eclass will ever ever use these functions |
125 | # @DESCRIPTION: |
71 | set_arch_to_kernel() { |
126 | # Set the env ARCH to match what the kernel expects. |
72 | export PORTAGE_ARCH="${ARCH}" |
127 | set_arch_to_kernel() { export ARCH=$(tc-arch-kernel); } |
73 | case ${ARCH} in |
128 | # @FUNCTION: set_arch_to_portage |
74 | x86) export ARCH="i386";; |
129 | # @DESCRIPTION: |
75 | amd64) export ARCH="x86_64";; |
130 | # Set the env ARCH to match what portage expects. |
76 | hppa) export ARCH="parisc";; |
131 | set_arch_to_portage() { export ARCH=$(tc-arch); } |
77 | mips) export ARCH="mips";; |
|
|
78 | *) export ARCH="${ARCH}";; |
|
|
79 | esac |
|
|
80 | } |
|
|
81 | |
132 | |
82 | # set's ARCH back to what portage expects |
|
|
83 | set_arch_to_portage() { |
|
|
84 | export ARCH="${PORTAGE_ARCH}" |
|
|
85 | } |
|
|
86 | |
|
|
87 | |
|
|
88 | # |
|
|
89 | # qeinfo "Message" |
133 | # qeinfo "Message" |
90 | # ------------------- |
134 | # ------------------- |
91 | # qeinfo is a queit einfo call when EBUILD_PHASE |
135 | # qeinfo is a quiet einfo call when EBUILD_PHASE |
92 | # should not have visible output. |
136 | # should not have visible output. |
93 | # |
137 | qout() { |
94 | qeinfo() { |
|
|
95 | local outputmsg |
138 | local outputmsg type |
|
|
139 | type=${1} |
|
|
140 | shift |
96 | outputmsg="${@}" |
141 | outputmsg="${@}" |
97 | case "${EBUILD_PHASE}" in |
142 | case "${EBUILD_PHASE}" in |
98 | depend) unset outputmsg;; |
143 | depend) unset outputmsg;; |
99 | clean) unset outputmsg;; |
144 | clean) unset outputmsg;; |
100 | preinst) unset outputmsg;; |
145 | preinst) unset outputmsg;; |
101 | esac |
146 | esac |
102 | [ -n "${outputmsg}" ] && einfo "${outputmsg}" |
147 | [ -n "${outputmsg}" ] && ${type} "${outputmsg}" |
103 | } |
148 | } |
104 | |
149 | |
105 | qeerror() { |
150 | qeinfo() { qout einfo "${@}" ; } |
106 | local outputmsg |
151 | qewarn() { qout ewarn "${@}" ; } |
107 | outputmsg="${@}" |
152 | qeerror() { qout eerror "${@}" ; } |
108 | case "${EBUILD_PHASE}" in |
|
|
109 | depend) unset outputmsg;; |
|
|
110 | clean) unset outputmsg;; |
|
|
111 | preinst) unset outputmsg;; |
|
|
112 | esac |
|
|
113 | [ -n "${outputmsg}" ] && einfo "${outputmsg}" |
|
|
114 | } |
|
|
115 | |
|
|
116 | |
|
|
117 | |
153 | |
118 | # File Functions |
154 | # File Functions |
119 | # --------------------------------------- |
155 | # --------------------------------------- |
120 | |
156 | |
121 | # getfilevar accepts 2 vars as follows: |
157 | # @FUNCTION: getfilevar |
122 | # getfilevar <VARIABLE> <CONFIGFILE> |
158 | # @USAGE: variable configfile |
123 | |
159 | # @RETURN: the value of the variable |
|
|
160 | # @DESCRIPTION: |
|
|
161 | # It detects the value of the variable defined in the file configfile. This is |
|
|
162 | # done by including the configfile, and printing the variable with Make. |
|
|
163 | # It WILL break if your makefile has missing dependencies! |
124 | getfilevar() { |
164 | getfilevar() { |
125 | local ERROR workingdir basefname basedname xarch |
165 | local ERROR basefname basedname myARCH="${ARCH}" |
126 | ERROR=0 |
166 | ERROR=0 |
127 | |
167 | |
128 | [ -z "${1}" ] && ERROR=1 |
168 | [ -z "${1}" ] && ERROR=1 |
129 | [ ! -f "${2}" ] && ERROR=1 |
169 | [ ! -f "${2}" ] && ERROR=1 |
130 | |
170 | |
131 | if [ "${ERROR}" = 1 ] |
171 | if [ "${ERROR}" = 1 ] |
132 | then |
172 | then |
133 | ebeep |
|
|
134 | echo -e "\n" |
173 | echo -e "\n" |
135 | eerror "getfilevar requires 2 variables, with the second a valid file." |
174 | eerror "getfilevar requires 2 variables, with the second a valid file." |
136 | eerror " getfilevar <VARIABLE> <CONFIGFILE>" |
175 | eerror " getfilevar <VARIABLE> <CONFIGFILE>" |
137 | else |
176 | else |
138 | workingdir=${PWD} |
|
|
139 | basefname=$(basename ${2}) |
177 | basefname="$(basename ${2})" |
140 | basedname=$(dirname ${2}) |
178 | basedname="$(dirname ${2})" |
141 | xarch=${ARCH} |
|
|
142 | unset ARCH |
179 | unset ARCH |
143 | |
|
|
144 | cd ${basedname} |
|
|
145 | echo -e "include ${basefname}\ne:\n\t@echo \$(${1})" | \ |
|
|
146 | make ${BUILD_FIXES} -f - e 2>/dev/null |
|
|
147 | cd ${workingdir} |
|
|
148 | |
|
|
149 | ARCH=${xarch} |
|
|
150 | fi |
|
|
151 | } |
|
|
152 | |
180 | |
|
|
181 | echo -e "e:\\n\\t@echo \$(${1})\\ninclude ${basefname}" | \ |
|
|
182 | make -C "${basedname}" M="${S}" ${BUILD_FIXES} -s -f - 2>/dev/null |
|
|
183 | |
|
|
184 | ARCH=${myARCH} |
|
|
185 | fi |
|
|
186 | } |
|
|
187 | |
|
|
188 | # @FUNCTION: getfilevar_noexec |
|
|
189 | # @USAGE: variable configfile |
|
|
190 | # @RETURN: the value of the variable |
|
|
191 | # @DESCRIPTION: |
|
|
192 | # It detects the value of the variable defined in the file configfile. |
|
|
193 | # This is done with sed matching an expression only. If the variable is defined, |
|
|
194 | # you will run into problems. See getfilevar for those cases. |
|
|
195 | getfilevar_noexec() { |
|
|
196 | local ERROR basefname basedname mycat myARCH="${ARCH}" |
|
|
197 | ERROR=0 |
|
|
198 | mycat='cat' |
|
|
199 | |
|
|
200 | [ -z "${1}" ] && ERROR=1 |
|
|
201 | [ ! -f "${2}" ] && ERROR=1 |
|
|
202 | [ "${2%.gz}" != "${2}" ] && mycat='zcat' |
|
|
203 | |
|
|
204 | if [ "${ERROR}" = 1 ] |
|
|
205 | then |
|
|
206 | echo -e "\n" |
|
|
207 | eerror "getfilevar_noexec requires 2 variables, with the second a valid file." |
|
|
208 | eerror " getfilevar_noexec <VARIABLE> <CONFIGFILE>" |
|
|
209 | else |
|
|
210 | ${mycat} "${2}" | \ |
|
|
211 | sed -n \ |
|
|
212 | -e "/^[[:space:]]*${1}[[:space:]]*:\\?=[[:space:]]*\(.*\)\$/{ |
|
|
213 | s,^[^=]*[[:space:]]*=[[:space:]]*,,g ; |
|
|
214 | s,[[:space:]]*\$,,g ; |
|
|
215 | p |
|
|
216 | }" |
|
|
217 | fi |
|
|
218 | } |
|
|
219 | |
|
|
220 | # @PRIVATE-VARIABLE: _LINUX_CONFIG_EXISTS_DONE |
|
|
221 | # @DESCRIPTION: |
|
|
222 | # This is only set if one of the linux_config_*exists functions has been called. |
|
|
223 | # We use it for a QA warning that the check for a config has not been performed, |
|
|
224 | # as linux_chkconfig* in non-legacy mode WILL return an undefined value if no |
|
|
225 | # config is available at all. |
|
|
226 | _LINUX_CONFIG_EXISTS_DONE= |
|
|
227 | |
|
|
228 | linux_config_qa_check() { |
|
|
229 | local f="$1" |
|
|
230 | if [ -z "${_LINUX_CONFIG_EXISTS_DONE}" ]; then |
|
|
231 | ewarn "QA: You called $f before any linux_config_exists!" |
|
|
232 | ewarn "QA: The return value of $f will NOT gaurenteed later!" |
|
|
233 | fi |
|
|
234 | } |
|
|
235 | |
|
|
236 | # @FUNCTION: linux_config_src_exists |
|
|
237 | # @RETURN: true or false |
|
|
238 | # @DESCRIPTION: |
|
|
239 | # It returns true if .config exists in a build directory otherwise false |
|
|
240 | linux_config_src_exists() { |
|
|
241 | export _LINUX_CONFIG_EXISTS_DONE=1 |
|
|
242 | [ -s "${KV_OUT_DIR}/.config" ] |
|
|
243 | } |
|
|
244 | |
|
|
245 | # @FUNCTION: linux_config_bin_exists |
|
|
246 | # @RETURN: true or false |
|
|
247 | # @DESCRIPTION: |
|
|
248 | # It returns true if .config exists in /proc, otherwise false |
|
|
249 | linux_config_bin_exists() { |
|
|
250 | export _LINUX_CONFIG_EXISTS_DONE=1 |
|
|
251 | [ -s "/proc/config.gz" ] |
|
|
252 | } |
|
|
253 | |
|
|
254 | # @FUNCTION: linux_config_exists |
|
|
255 | # @RETURN: true or false |
|
|
256 | # @DESCRIPTION: |
|
|
257 | # It returns true if .config exists otherwise false |
|
|
258 | # |
|
|
259 | # This function MUST be checked before using any of the linux_chkconfig_* |
|
|
260 | # functions. |
|
|
261 | linux_config_exists() { |
|
|
262 | linux_config_src_exists || linux_config_bin_exists |
|
|
263 | } |
|
|
264 | |
|
|
265 | # @FUNCTION: require_configured_kernel |
|
|
266 | # @DESCRIPTION: |
|
|
267 | # This function verifies that the current kernel is configured (it checks against the existence of .config) |
|
|
268 | # otherwise it dies. |
|
|
269 | require_configured_kernel() { |
|
|
270 | if ! linux_config_src_exists; then |
|
|
271 | qeerror "Could not find a usable .config in the kernel source directory." |
|
|
272 | qeerror "Please ensure that ${KERNEL_DIR} points to a configured set of Linux sources." |
|
|
273 | qeerror "If you are using KBUILD_OUTPUT, please set the environment var so that" |
|
|
274 | qeerror "it points to the necessary object directory so that it might find .config." |
|
|
275 | die "Kernel not configured; no .config found in ${KV_OUT_DIR}" |
|
|
276 | fi |
|
|
277 | } |
|
|
278 | |
|
|
279 | # @FUNCTION: linux_chkconfig_present |
|
|
280 | # @USAGE: option |
|
|
281 | # @RETURN: true or false |
|
|
282 | # @DESCRIPTION: |
|
|
283 | # It checks that CONFIG_<option>=y or CONFIG_<option>=m is present in the current kernel .config |
|
|
284 | # If linux_config_exists returns false, the results of this are UNDEFINED. You |
|
|
285 | # MUST call linux_config_exists first. |
153 | linux_chkconfig_present() { |
286 | linux_chkconfig_present() { |
|
|
287 | linux_config_qa_check linux_chkconfig_present |
154 | local RESULT |
288 | local RESULT |
|
|
289 | local config |
|
|
290 | config="${KV_OUT_DIR}/.config" |
|
|
291 | [ ! -f "${config}" ] && config="/proc/config.gz" |
155 | RESULT="$(getfilevar CONFIG_${1} ${KV_OUT_DIR}/.config)" |
292 | RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")" |
156 | [ "${RESULT}" = "m" -o "${RESULT}" = "y" ] && return 0 || return 1 |
293 | [ "${RESULT}" = "m" -o "${RESULT}" = "y" ] && return 0 || return 1 |
157 | } |
294 | } |
158 | |
295 | |
|
|
296 | # @FUNCTION: linux_chkconfig_module |
|
|
297 | # @USAGE: option |
|
|
298 | # @RETURN: true or false |
|
|
299 | # @DESCRIPTION: |
|
|
300 | # It checks that CONFIG_<option>=m is present in the current kernel .config |
|
|
301 | # If linux_config_exists returns false, the results of this are UNDEFINED. You |
|
|
302 | # MUST call linux_config_exists first. |
159 | linux_chkconfig_module() { |
303 | linux_chkconfig_module() { |
|
|
304 | linux_config_qa_check linux_chkconfig_module |
160 | local RESULT |
305 | local RESULT |
|
|
306 | local config |
|
|
307 | config="${KV_OUT_DIR}/.config" |
|
|
308 | [ ! -f "${config}" ] && config="/proc/config.gz" |
161 | RESULT="$(getfilevar CONFIG_${1} ${KV_OUT_DIR}/.config)" |
309 | RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")" |
162 | [ "${RESULT}" = "m" ] && return 0 || return 1 |
310 | [ "${RESULT}" = "m" ] && return 0 || return 1 |
163 | } |
311 | } |
164 | |
312 | |
|
|
313 | # @FUNCTION: linux_chkconfig_builtin |
|
|
314 | # @USAGE: option |
|
|
315 | # @RETURN: true or false |
|
|
316 | # @DESCRIPTION: |
|
|
317 | # It checks that CONFIG_<option>=y is present in the current kernel .config |
|
|
318 | # If linux_config_exists returns false, the results of this are UNDEFINED. You |
|
|
319 | # MUST call linux_config_exists first. |
165 | linux_chkconfig_builtin() { |
320 | linux_chkconfig_builtin() { |
|
|
321 | linux_config_qa_check linux_chkconfig_builtin |
166 | local RESULT |
322 | local RESULT |
|
|
323 | local config |
|
|
324 | config="${KV_OUT_DIR}/.config" |
|
|
325 | [ ! -f "${config}" ] && config="/proc/config.gz" |
167 | RESULT="$(getfilevar CONFIG_${1} ${KV_OUT_DIR}/.config)" |
326 | RESULT="$(getfilevar_noexec CONFIG_${1} "${config}")" |
168 | [ "${RESULT}" = "y" ] && return 0 || return 1 |
327 | [ "${RESULT}" = "y" ] && return 0 || return 1 |
169 | } |
328 | } |
170 | |
329 | |
|
|
330 | # @FUNCTION: linux_chkconfig_string |
|
|
331 | # @USAGE: option |
|
|
332 | # @RETURN: CONFIG_<option> |
|
|
333 | # @DESCRIPTION: |
|
|
334 | # It prints the CONFIG_<option> value of the current kernel .config (it requires a configured kernel). |
|
|
335 | # If linux_config_exists returns false, the results of this are UNDEFINED. You |
|
|
336 | # MUST call linux_config_exists first. |
171 | linux_chkconfig_string() { |
337 | linux_chkconfig_string() { |
|
|
338 | linux_config_qa_check linux_chkconfig_string |
|
|
339 | local config |
|
|
340 | config="${KV_OUT_DIR}/.config" |
|
|
341 | [ ! -f "${config}" ] && config="/proc/config.gz" |
172 | getfilevar "CONFIG_${1}" "${KV_OUT_DIR}/.config" |
342 | getfilevar_noexec "CONFIG_${1}" "${config}" |
173 | } |
343 | } |
174 | |
344 | |
175 | # Versioning Functions |
345 | # Versioning Functions |
176 | # --------------------------------------- |
346 | # --------------------------------------- |
177 | |
347 | |
178 | # kernel_is returns true when the version is the same as the passed version |
348 | # @FUNCTION: kernel_is |
|
|
349 | # @USAGE: [-lt -gt -le -ge -eq] major_number [minor_number patch_number] |
|
|
350 | # @RETURN: true or false |
|
|
351 | # @DESCRIPTION: |
|
|
352 | # It returns true when the current kernel version satisfies the comparison against the passed version. |
|
|
353 | # -eq is the default comparison. |
179 | # |
354 | # |
|
|
355 | # @CODE |
180 | # For Example where KV = 2.6.9 |
356 | # For Example where KV = 2.6.9 |
181 | # kernel_is 2 4 returns false |
357 | # kernel_is 2 4 returns false |
182 | # kernel_is 2 returns true |
358 | # kernel_is 2 returns true |
183 | # kernel_is 2 6 returns true |
359 | # kernel_is 2 6 returns true |
184 | # kernel_is 2 6 8 returns false |
360 | # kernel_is 2 6 8 returns false |
185 | # kernel_is 2 6 9 returns true |
361 | # kernel_is 2 6 9 returns true |
186 | # |
362 | # @CODE |
|
|
363 | |
187 | # got the jist yet? |
364 | # got the jist yet? |
188 | |
365 | |
189 | kernel_is() { |
366 | kernel_is() { |
190 | # if we haven't determined the version yet, we need too. |
367 | # if we haven't determined the version yet, we need to. |
191 | get_version; |
368 | linux-info_get_any_version |
192 | |
|
|
193 | local RESULT operator test value i len |
|
|
194 | RESULT=0 |
|
|
195 | |
|
|
196 | operator="=" |
|
|
197 | if [ "${1}" == "lt" ] |
|
|
198 | then |
|
|
199 | operator="-lt" |
|
|
200 | shift |
|
|
201 | elif [ "${1}" == "gt" ] |
|
|
202 | then |
|
|
203 | operator="-gt" |
|
|
204 | shift |
|
|
205 | elif [ "${1}" == "le" ] |
|
|
206 | then |
|
|
207 | operator="-le" |
|
|
208 | shift |
|
|
209 | elif [ "${1}" == "ge" ] |
|
|
210 | then |
|
|
211 | operator="-ge" |
|
|
212 | shift |
|
|
213 | fi |
|
|
214 | |
369 | |
215 | if [ -n "${1}" ] |
370 | local operator testagainst value x=0 y=0 z=0 |
216 | then |
371 | |
|
|
372 | case ${1} in |
|
|
373 | -lt|lt) operator="-lt"; shift;; |
|
|
374 | -gt|gt) operator="-gt"; shift;; |
|
|
375 | -le|le) operator="-le"; shift;; |
|
|
376 | -ge|ge) operator="-ge"; shift;; |
|
|
377 | -eq|eq) operator="-eq"; shift;; |
|
|
378 | *) operator="-eq";; |
|
|
379 | esac |
|
|
380 | |
|
|
381 | for x in ${@}; do |
|
|
382 | for((y=0; y<$((3 - ${#x})); y++)); do value="${value}0"; done |
217 | value="${value}${1}" |
383 | value="${value}${x}" |
218 | test="${test}${KV_MAJOR}" |
384 | z=$((${z} + 1)) |
219 | fi |
385 | |
220 | if [ -n "${2}" ] |
386 | case ${z} in |
221 | then |
387 | 1) for((y=0; y<$((3 - ${#KV_MAJOR})); y++)); do testagainst="${testagainst}0"; done; |
222 | len=$[ 3 - ${#2} ] |
388 | testagainst="${testagainst}${KV_MAJOR}";; |
223 | for((i=0; i<$len; i++)); do |
389 | 2) for((y=0; y<$((3 - ${#KV_MINOR})); y++)); do testagainst="${testagainst}0"; done; |
224 | value="${value}0" |
390 | testagainst="${testagainst}${KV_MINOR}";; |
|
|
391 | 3) for((y=0; y<$((3 - ${#KV_PATCH})); y++)); do testagainst="${testagainst}0"; done; |
|
|
392 | testagainst="${testagainst}${KV_PATCH}";; |
|
|
393 | *) die "Error in kernel-2_kernel_is(): Too many parameters.";; |
|
|
394 | esac |
225 | done |
395 | done |
226 | value="${value}${2}" |
|
|
227 | |
396 | |
228 | len=$[ 3 - ${#KV_MINOR} ] |
|
|
229 | for((i=0; i<$len; i++)); do |
|
|
230 | test="${test}0" |
|
|
231 | done |
|
|
232 | test="${test}${KV_MINOR}" |
|
|
233 | fi |
|
|
234 | if [ -n "${3}" ] |
|
|
235 | then |
|
|
236 | len=$[ 3 - ${#3} ] |
|
|
237 | for((i=0; i<$len; i++)); do |
|
|
238 | value="${value}0" |
|
|
239 | done |
|
|
240 | value="${value}${3}" |
|
|
241 | |
|
|
242 | len=$[ 3 - ${#KV_PATCH} ] |
|
|
243 | for((i=0; i<$len; i++)); do |
|
|
244 | test="${test}0" |
|
|
245 | done |
|
|
246 | test="${test}${KV_PATCH}" |
|
|
247 | fi |
|
|
248 | |
|
|
249 | [ ${test} ${operator} ${value} ] && return 0 || return 1 |
397 | [ "${testagainst}" ${operator} "${value}" ] && return 0 || return 1 |
250 | } |
398 | } |
251 | |
399 | |
|
|
400 | get_localversion() { |
|
|
401 | local lv_list i x |
|
|
402 | |
|
|
403 | # ignore files with ~ in it. |
|
|
404 | for i in $(ls ${1}/localversion* 2>/dev/null); do |
|
|
405 | [[ -n ${i//*~*} ]] && lv_list="${lv_list} ${i}" |
|
|
406 | done |
|
|
407 | |
|
|
408 | for i in ${lv_list}; do |
|
|
409 | x="${x}$(<${i})" |
|
|
410 | done |
|
|
411 | x=${x/ /} |
|
|
412 | echo ${x} |
|
|
413 | } |
|
|
414 | |
|
|
415 | # Check if the Makefile is valid for direct parsing. |
|
|
416 | # Check status results: |
|
|
417 | # - PASS, use 'getfilevar' to extract values |
|
|
418 | # - FAIL, use 'getfilevar_noexec' to extract values |
|
|
419 | # The check may fail if: |
|
|
420 | # - make is not present |
|
|
421 | # - corruption exists in the kernel makefile |
|
|
422 | get_makefile_extract_function() { |
|
|
423 | local a='' b='' mkfunc='getfilevar' |
|
|
424 | a="$(getfilevar VERSION ${KERNEL_MAKEFILE})" |
|
|
425 | b="$(getfilevar_noexec VERSION ${KERNEL_MAKEFILE})" |
|
|
426 | [[ "${a}" != "${b}" ]] && mkfunc='getfilevar_noexec' |
|
|
427 | echo "${mkfunc}" |
|
|
428 | } |
|
|
429 | |
|
|
430 | # internal variable, so we know to only print the warning once |
|
|
431 | get_version_warning_done= |
|
|
432 | |
|
|
433 | # @FUNCTION: get_version |
|
|
434 | # @DESCRIPTION: |
|
|
435 | # It gets the version of the kernel inside KERNEL_DIR and populates the KV_FULL variable |
|
|
436 | # (if KV_FULL is already set it does nothing). |
|
|
437 | # |
|
|
438 | # The kernel version variables (KV_MAJOR, KV_MINOR, KV_PATCH, KV_EXTRA and KV_LOCAL) are also set. |
|
|
439 | # |
|
|
440 | # The KV_DIR is set using the KERNEL_DIR env var, the KV_DIR_OUT is set using a valid |
|
|
441 | # KBUILD_OUTPUT (in a decreasing priority list, we look for the env var, makefile var or the |
|
|
442 | # symlink /lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}/build). |
252 | get_version() { |
443 | get_version() { |
253 | local kbuild_output |
444 | local kbuild_output mkfunc |
254 | |
445 | |
255 | # no need to execute this twice assuming KV_FULL is populated. |
446 | # no need to execute this twice assuming KV_FULL is populated. |
256 | # we can force by unsetting KV_FULL |
447 | # we can force by unsetting KV_FULL |
257 | [ -n "${KV_FULL}" ] && return |
448 | [ -n "${KV_FULL}" ] && return 0 |
258 | |
449 | |
259 | # if we dont know KV_FULL, then we need too. |
450 | # if we dont know KV_FULL, then we need too. |
260 | # make sure KV_DIR isnt set since we need to work it out via KERNEL_DIR |
451 | # make sure KV_DIR isnt set since we need to work it out via KERNEL_DIR |
261 | unset KV_DIR |
452 | unset KV_DIR |
262 | |
453 | |
263 | # KV_DIR will contain the full path to the sources directory we should use |
454 | # KV_DIR will contain the full path to the sources directory we should use |
|
|
455 | [ -z "${get_version_warning_done}" ] && \ |
264 | qeinfo "Determining the location of the kernel source code" |
456 | qeinfo "Determining the location of the kernel source code" |
265 | [ -h "${KERNEL_DIR}" ] && KV_DIR="$(readlink -f ${KERNEL_DIR})" |
457 | [ -h "${KERNEL_DIR}" ] && KV_DIR="$(readlink -f ${KERNEL_DIR})" |
266 | [ -d "${KERNEL_DIR}" ] && KV_DIR="${KERNEL_DIR}" |
458 | [ -d "${KERNEL_DIR}" ] && KV_DIR="${KERNEL_DIR}" |
267 | |
459 | |
268 | if [ -z "${KV_DIR}" ] |
460 | if [ -z "${KV_DIR}" ] |
269 | then |
461 | then |
|
|
462 | if [ -z "${get_version_warning_done}" ]; then |
|
|
463 | get_version_warning_done=1 |
270 | qeerror "Unable to find kernel sources at ${KERNEL_DIR}" |
464 | qeerror "Unable to find kernel sources at ${KERNEL_DIR}" |
271 | qeinfo "This package requires Linux sources." |
465 | #qeinfo "This package requires Linux sources." |
272 | if [ "${KERNEL_DIR}" == "/usr/src/linux" ] ; then |
466 | if [ "${KERNEL_DIR}" == "/usr/src/linux" ] ; then |
273 | qeinfo "Please make sure that ${KERNEL_DIR} points at your running kernel, " |
467 | qeinfo "Please make sure that ${KERNEL_DIR} points at your running kernel, " |
274 | qeinfo "(or the kernel you wish to build against)." |
468 | qeinfo "(or the kernel you wish to build against)." |
275 | qeinfo "Alternatively, set the KERNEL_DIR environment variable to the kernel sources location" |
469 | qeinfo "Alternatively, set the KERNEL_DIR environment variable to the kernel sources location" |
276 | else |
470 | else |
277 | qeinfo "Please ensure that the KERNEL_DIR environment variable points at full Linux sources of the kernel you wish to compile against." |
471 | qeinfo "Please ensure that the KERNEL_DIR environment variable points at full Linux sources of the kernel you wish to compile against." |
278 | fi |
472 | fi |
279 | die "Cannot locate Linux sources at ${KERNEL_DIR}" |
|
|
280 | fi |
473 | fi |
|
|
474 | return 1 |
|
|
475 | fi |
281 | |
476 | |
|
|
477 | if [ -z "${get_version_warning_done}" ]; then |
282 | qeinfo "Found kernel source directory:" |
478 | qeinfo "Found kernel source directory:" |
283 | qeinfo " ${KV_DIR}" |
479 | qeinfo " ${KV_DIR}" |
|
|
480 | fi |
284 | |
481 | |
285 | if [ ! -s "${KV_DIR}/Makefile" ] |
482 | if [ ! -s "${KV_DIR}/Makefile" ] |
286 | then |
483 | then |
|
|
484 | if [ -z "${get_version_warning_done}" ]; then |
|
|
485 | get_version_warning_done=1 |
287 | qeerror "Could not find a Makefile in the kernel source directory." |
486 | qeerror "Could not find a Makefile in the kernel source directory." |
288 | qeerror "Please ensure that ${KERNEL_DIR} points to a complete set of Linux sources" |
487 | qeerror "Please ensure that ${KERNEL_DIR} points to a complete set of Linux sources" |
289 | die "Makefile not found in ${KV_DIR}" |
|
|
290 | fi |
488 | fi |
291 | |
489 | return 1 |
|
|
490 | fi |
|
|
491 | |
292 | # OK so now we know our sources directory, but they might be using |
492 | # OK so now we know our sources directory, but they might be using |
293 | # KBUILD_OUTPUT, and we need this for .config and localversions-* |
493 | # KBUILD_OUTPUT, and we need this for .config and localversions-* |
294 | # so we better find it eh? |
494 | # so we better find it eh? |
295 | # do we pass KBUILD_OUTPUT on the CLI? |
495 | # do we pass KBUILD_OUTPUT on the CLI? |
296 | OUTPUT_DIR="${OUTPUT_DIR:-${KBUILD_OUTPUT}}" |
496 | OUTPUT_DIR="${OUTPUT_DIR:-${KBUILD_OUTPUT}}" |
|
|
497 | |
|
|
498 | # keep track of it |
|
|
499 | KERNEL_MAKEFILE="${KV_DIR}/Makefile" |
297 | |
500 | |
|
|
501 | # Decide the function used to extract makefile variables. |
|
|
502 | mkfunc="$(get_makefile_extract_function "${KERNEL_MAKEFILE}")" |
|
|
503 | |
298 | # And if we didn't pass it, we can take a nosey in the Makefile |
504 | # And if we didn't pass it, we can take a nosey in the Makefile |
299 | kbuild_output="$(getfilevar KBUILD_OUTPUT ${KV_DIR}/Makefile)" |
505 | kbuild_output="$(${mkfunc} KBUILD_OUTPUT ${KERNEL_MAKEFILE})" |
300 | OUTPUT_DIR="${OUTPUT_DIR:-${kbuild_output}}" |
506 | OUTPUT_DIR="${OUTPUT_DIR:-${kbuild_output}}" |
301 | |
507 | |
302 | # And contrary to existing functions I feel we shouldn't trust the |
508 | # And contrary to existing functions I feel we shouldn't trust the |
303 | # directory name to find version information as this seems insane. |
509 | # directory name to find version information as this seems insane. |
304 | # so we parse ${KV_DIR}/Makefile |
510 | # so we parse ${KERNEL_MAKEFILE} |
305 | KV_MAJOR="$(getfilevar VERSION ${KV_DIR}/Makefile)" |
511 | KV_MAJOR="$(${mkfunc} VERSION ${KERNEL_MAKEFILE})" |
306 | KV_MINOR="$(getfilevar PATCHLEVEL ${KV_DIR}/Makefile)" |
512 | KV_MINOR="$(${mkfunc} PATCHLEVEL ${KERNEL_MAKEFILE})" |
307 | KV_PATCH="$(getfilevar SUBLEVEL ${KV_DIR}/Makefile)" |
513 | KV_PATCH="$(${mkfunc} SUBLEVEL ${KERNEL_MAKEFILE})" |
308 | KV_EXTRA="$(getfilevar EXTRAVERSION ${KV_DIR}/Makefile)" |
514 | KV_EXTRA="$(${mkfunc} EXTRAVERSION ${KERNEL_MAKEFILE})" |
309 | |
515 | |
310 | if [ -z "${KV_MAJOR}" -o -z "${KV_MINOR}" -o -z "${KV_PATCH}" ] |
516 | if [ -z "${KV_MAJOR}" -o -z "${KV_MINOR}" -o -z "${KV_PATCH}" ] |
311 | then |
517 | then |
|
|
518 | if [ -z "${get_version_warning_done}" ]; then |
|
|
519 | get_version_warning_done=1 |
312 | qeerror "Could not detect kernel version." |
520 | qeerror "Could not detect kernel version." |
313 | qeerror "Please ensure that ${KERNEL_DIR} points to a complete set of Linux sources" |
521 | qeerror "Please ensure that ${KERNEL_DIR} points to a complete set of Linux sources." |
314 | die "Could not parse version info from ${KV_DIR}/Makefile" |
|
|
315 | fi |
522 | fi |
316 | |
523 | return 1 |
|
|
524 | fi |
|
|
525 | |
317 | # and in newer versions we can also pull LOCALVERSION if it is set. |
526 | # and in newer versions we can also pull LOCALVERSION if it is set. |
318 | # but before we do this, we need to find if we use a different object directory. |
527 | # but before we do this, we need to find if we use a different object directory. |
319 | # This *WILL* break if the user is using localversions, but we assume it was |
528 | # This *WILL* break if the user is using localversions, but we assume it was |
320 | # caught before this if they are. |
529 | # caught before this if they are. |
321 | [ "${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}.${KV_EXTRA}" == "$(uname -r)" ] && \ |
|
|
322 | OUTPUT_DIR="${OUTPUT_DIR:-/lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}.${KV_EXTRA}/build}" |
530 | OUTPUT_DIR="${OUTPUT_DIR:-/lib/modules/${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}/build}" |
323 | |
531 | |
324 | [ -h "${OUTPUT_DIR}" ] && KV_OUT_DIR="$(readlink -f ${OUTPUT_DIR})" |
532 | [ -h "${OUTPUT_DIR}" ] && KV_OUT_DIR="$(readlink -f ${OUTPUT_DIR})" |
325 | [ -d "${OUTPUT_DIR}" ] && KV_OUT_DIR="${OUTPUT_DIR}" |
533 | [ -d "${OUTPUT_DIR}" ] && KV_OUT_DIR="${OUTPUT_DIR}" |
326 | if [ -n "${KV_OUT_DIR}" ]; |
534 | if [ -n "${KV_OUT_DIR}" ]; |
327 | then |
535 | then |
328 | qeinfo "Found kernel object directory:" |
536 | qeinfo "Found kernel object directory:" |
329 | qeinfo " ${KV_OUT_DIR}" |
537 | qeinfo " ${KV_OUT_DIR}" |
330 | |
538 | |
331 | KV_LOCAL="$(cat ${KV_OUT_DIR}/localversion* 2>/dev/null)" |
539 | KV_LOCAL="$(get_localversion ${KV_OUT_DIR})" |
332 | fi |
540 | fi |
333 | # and if we STILL haven't got it, then we better just set it to KV_DIR |
541 | # and if we STILL have not got it, then we better just set it to KV_DIR |
334 | KV_OUT_DIR="${KV_OUT_DIR:-${KV_DIR}}" |
542 | KV_OUT_DIR="${KV_OUT_DIR:-${KV_DIR}}" |
335 | |
543 | |
336 | KV_LOCAL="${KV_LOCAL}$(cat ${KV_DIR}/localversion* 2>/dev/null)" |
544 | KV_LOCAL="${KV_LOCAL}$(get_localversion ${KV_DIR})" |
|
|
545 | if linux_config_src_exists; then |
337 | KV_LOCAL="${KV_LOCAL}$(linux_chkconfig_string LOCALVERSION)" |
546 | KV_LOCAL="${KV_LOCAL}$(linux_chkconfig_string LOCALVERSION)" |
338 | KV_LOCAL="${KV_LOCAL//\"/}" |
547 | KV_LOCAL="${KV_LOCAL//\"/}" |
339 | |
548 | |
|
|
549 | # For things like git that can append extra stuff: |
|
|
550 | [ -e ${KV_DIR}/scripts/setlocalversion ] && |
|
|
551 | linux_chkconfig_builtin LOCALVERSION_AUTO && |
|
|
552 | KV_LOCAL="${KV_LOCAL}$(sh ${KV_DIR}/scripts/setlocalversion ${KV_DIR})" |
|
|
553 | fi |
|
|
554 | |
340 | # And we should set KV_FULL to the full expanded version |
555 | # And we should set KV_FULL to the full expanded version |
341 | KV_FULL="${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}${KV_LOCAL}" |
556 | KV_FULL="${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}${KV_EXTRA}${KV_LOCAL}" |
342 | |
557 | |
343 | qeinfo "Found sources for kernel version:" |
558 | qeinfo "Found sources for kernel version:" |
344 | qeinfo " ${KV_FULL}" |
559 | qeinfo " ${KV_FULL}" |
345 | |
|
|
346 | if [ ! -s "${KV_OUT_DIR}/.config" ] |
|
|
347 | then |
|
|
348 | qeerror "Could not find a usable .config in the kernel source directory." |
|
|
349 | qeerror "Please ensure that ${KERNEL_DIR} points to a configured set of Linux sources." |
|
|
350 | qeerror "If you are using KBUILD_OUTPUT, please set the environment var so that" |
|
|
351 | qeerror "it points to the necessary object directory so that it might find .config." |
|
|
352 | die ".config not found in ${KV_OUT_DIR}" |
|
|
353 | fi |
|
|
354 | } |
|
|
355 | |
560 | |
|
|
561 | return 0 |
|
|
562 | } |
356 | |
563 | |
|
|
564 | # @FUNCTION: get_running_version |
|
|
565 | # @DESCRIPTION: |
|
|
566 | # It gets the version of the current running kernel and the result is the same as get_version() if the |
|
|
567 | # function can find the sources. |
|
|
568 | get_running_version() { |
|
|
569 | KV_FULL=$(uname -r) |
|
|
570 | |
|
|
571 | if [[ -f ${ROOT}/lib/modules/${KV_FULL}/source/Makefile ]]; then |
|
|
572 | KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/source) |
|
|
573 | unset KV_FULL |
|
|
574 | get_version |
|
|
575 | return $? |
|
|
576 | elif [[ -f ${ROOT}/lib/modules/${KV_FULL}/build/Makefile ]]; then |
|
|
577 | KERNEL_DIR=$(readlink -f ${ROOT}/lib/modules/${KV_FULL}/build) |
|
|
578 | unset KV_FULL |
|
|
579 | get_version |
|
|
580 | return $? |
|
|
581 | else |
|
|
582 | KV_MAJOR=$(get_version_component_range 1 ${KV_FULL}) |
|
|
583 | KV_MINOR=$(get_version_component_range 2 ${KV_FULL}) |
|
|
584 | KV_PATCH=$(get_version_component_range 3- ${KV_FULL}) |
|
|
585 | KV_PATCH=${KV_PATCH//-*} |
|
|
586 | [[ -n ${KV_FULL#*-} ]] && [[ -n ${KV_FULL//${KV_FULL#*-}} ]] \ |
|
|
587 | && KV_EXTRA="-${KV_FULL#*-}" |
|
|
588 | fi |
|
|
589 | return 0 |
|
|
590 | } |
|
|
591 | |
|
|
592 | # This next function is named with the eclass prefix to avoid conflicts with |
|
|
593 | # some old versionator-like eclass functions. |
|
|
594 | |
|
|
595 | # @FUNCTION: linux-info_get_any_version |
|
|
596 | # @DESCRIPTION: |
|
|
597 | # This attempts to find the version of the sources, and otherwise falls back to |
|
|
598 | # the version of the running kernel. |
|
|
599 | linux-info_get_any_version() { |
|
|
600 | get_version |
|
|
601 | if [[ $? -ne 0 ]]; then |
|
|
602 | ewarn "Unable to calculate Linux Kernel version for build, attempting to use running version" |
|
|
603 | get_running_version |
|
|
604 | fi |
|
|
605 | } |
357 | |
606 | |
358 | |
607 | |
359 | # ebuild check functions |
608 | # ebuild check functions |
360 | # --------------------------------------- |
609 | # --------------------------------------- |
361 | |
610 | |
|
|
611 | # @FUNCTION: check_kernel_built |
|
|
612 | # @DESCRIPTION: |
|
|
613 | # This function verifies that the current kernel sources have been already prepared otherwise it dies. |
362 | check_kernel_built() { |
614 | check_kernel_built() { |
363 | # if we haven't determined the version yet, we need too. |
615 | # if we haven't determined the version yet, we need to |
|
|
616 | require_configured_kernel |
364 | get_version; |
617 | get_version |
365 | |
618 | |
366 | if [ ! -f "${KV_OUT_DIR}/include/linux/version.h" ] |
619 | if [ ! -f "${KV_OUT_DIR}/include/linux/version.h" ] |
367 | then |
620 | then |
368 | eerror "These sources have not yet been prepared." |
621 | eerror "These sources have not yet been prepared." |
369 | eerror "We cannot build against an unprepared tree." |
622 | eerror "We cannot build against an unprepared tree." |
370 | eerror "To resolve this, please type the following:" |
623 | eerror "To resolve this, please type the following:" |
… | |
… | |
376 | eerror "Then please try merging this module again." |
629 | eerror "Then please try merging this module again." |
377 | die "Kernel sources need compiling first" |
630 | die "Kernel sources need compiling first" |
378 | fi |
631 | fi |
379 | } |
632 | } |
380 | |
633 | |
|
|
634 | # @FUNCTION: check_modules_supported |
|
|
635 | # @DESCRIPTION: |
|
|
636 | # This function verifies that the current kernel support modules (it checks CONFIG_MODULES=y) otherwise it dies. |
381 | check_modules_supported() { |
637 | check_modules_supported() { |
382 | # if we haven't determined the version yet, we need too. |
638 | # if we haven't determined the version yet, we need too. |
|
|
639 | require_configured_kernel |
383 | get_version; |
640 | get_version |
384 | |
641 | |
385 | if ! linux_chkconfig_builtin "MODULES" |
642 | if ! linux_chkconfig_builtin "MODULES" |
386 | then |
643 | then |
387 | eerror "These sources do not support loading external modules." |
644 | eerror "These sources do not support loading external modules." |
388 | eerror "to be able to use this module please enable \"Loadable modules support\"" |
645 | eerror "to be able to use this module please enable \"Loadable modules support\"" |
389 | eerror "in your kernel, recompile and then try merging this module again." |
646 | eerror "in your kernel, recompile and then try merging this module again." |
390 | die "No support for external modules in ${KV_FULL} config" |
647 | die "No support for external modules in ${KV_FULL} config" |
391 | fi |
648 | fi |
392 | } |
649 | } |
393 | |
650 | |
|
|
651 | # @FUNCTION: check_extra_config |
|
|
652 | # @DESCRIPTION: |
|
|
653 | # It checks the kernel config options specified by CONFIG_CHECK. It dies only when a required config option (i.e. |
|
|
654 | # the prefix ~ is not used) doesn't satisfy the directive. |
394 | check_extra_config() { |
655 | check_extra_config() { |
395 | local config negate error local_error i n temp_config |
656 | local config negate die error reworkmodulenames |
|
|
657 | local soft_errors_count=0 hard_errors_count=0 config_required=0 |
|
|
658 | # store the value of the QA check, because otherwise we won't catch usages |
|
|
659 | # after if check_extra_config is called AND other direct calls are done |
|
|
660 | # later. |
|
|
661 | local old_LINUX_CONFIG_EXISTS_DONE="${_LINUX_CONFIG_EXISTS_DONE}" |
396 | |
662 | |
397 | # if we haven't determined the version yet, we need too. |
663 | # if we haven't determined the version yet, we need to |
398 | get_version; |
664 | linux-info_get_any_version |
399 | |
665 | |
400 | einfo "Checking for suitable kernel configuration options" |
666 | # Determine if we really need a .config. The only time when we don't need |
|
|
667 | # one is when all of the CONFIG_CHECK options are prefixed with "~". |
401 | for config in ${CONFIG_CHECK} |
668 | for config in ${CONFIG_CHECK} |
402 | do |
669 | do |
403 | negate="${config:0:1}" |
670 | if [[ "${config:0:1}" != "~" ]]; then |
404 | if [ "${negate}" == "!" ]; |
671 | config_required=1 |
405 | then |
672 | break |
|
|
673 | fi |
|
|
674 | done |
|
|
675 | |
|
|
676 | if [[ ${config_required} == 0 ]]; then |
|
|
677 | # In the case where we don't require a .config, we can now bail out |
|
|
678 | # if the user has no .config as there is nothing to do. Otherwise |
|
|
679 | # code later will cause a failure due to missing .config. |
|
|
680 | if ! linux_config_exists; then |
|
|
681 | ewarn "Unable to check for the following kernel config options due" |
|
|
682 | ewarn "to absence of any configured kernel sources or compiled" |
|
|
683 | ewarn "config:" |
|
|
684 | for config in ${CONFIG_CHECK}; do |
|
|
685 | local_error="ERROR_${config#\~}" |
|
|
686 | msg="${!local_error}" |
|
|
687 | if [[ "x${msg}" == "x" ]]; then |
|
|
688 | local_error="WARNING_${config#\~}" |
|
|
689 | msg="${!local_error}" |
|
|
690 | fi |
|
|
691 | ewarn " - ${config#\~}${msg:+ - }${msg}" |
|
|
692 | done |
|
|
693 | ewarn "You're on your own to make sure they are set if needed." |
|
|
694 | export LINUX_CONFIG_EXISTS_DONE="${old_LINUX_CONFIG_EXISTS_DONE}" |
|
|
695 | return 0 |
|
|
696 | fi |
|
|
697 | else |
|
|
698 | require_configured_kernel |
|
|
699 | fi |
|
|
700 | |
|
|
701 | einfo "Checking for suitable kernel configuration options..." |
|
|
702 | |
|
|
703 | for config in ${CONFIG_CHECK} |
|
|
704 | do |
|
|
705 | # if we specify any fatal, ensure we honor them |
|
|
706 | die=1 |
|
|
707 | error=0 |
|
|
708 | negate=0 |
|
|
709 | reworkmodulenames=0 |
|
|
710 | |
|
|
711 | if [[ ${config:0:1} == "~" ]]; then |
|
|
712 | die=0 |
406 | config="${config:1}" |
713 | config=${config:1} |
|
|
714 | elif [[ ${config:0:1} == "@" ]]; then |
|
|
715 | die=0 |
|
|
716 | reworkmodulenames=1 |
|
|
717 | config=${config:1} |
|
|
718 | fi |
|
|
719 | if [[ ${config:0:1} == "!" ]]; then |
|
|
720 | negate=1 |
|
|
721 | config=${config:1} |
|
|
722 | fi |
|
|
723 | |
|
|
724 | if [[ ${negate} == 1 ]]; then |
|
|
725 | linux_chkconfig_present ${config} && error=2 |
|
|
726 | elif [[ ${reworkmodulenames} == 1 ]]; then |
|
|
727 | local temp_config="${config//*:}" i n |
|
|
728 | config="${config//:*}" |
407 | if linux_chkconfig_present ${config} |
729 | if linux_chkconfig_present ${config}; then |
408 | then |
730 | for i in ${MODULE_NAMES}; do |
|
|
731 | n="${i//${temp_config}}" |
|
|
732 | [[ -z ${n//\(*} ]] && \ |
|
|
733 | MODULE_IGNORE="${MODULE_IGNORE} ${temp_config}" |
|
|
734 | done |
|
|
735 | error=2 |
|
|
736 | fi |
|
|
737 | else |
|
|
738 | linux_chkconfig_present ${config} || error=1 |
|
|
739 | fi |
|
|
740 | |
|
|
741 | if [[ ${error} > 0 ]]; then |
|
|
742 | local report_func="eerror" local_error |
|
|
743 | local_error="ERROR_${config}" |
|
|
744 | local_error="${!local_error}" |
|
|
745 | |
|
|
746 | if [[ -z "${local_error}" ]]; then |
|
|
747 | # using old, deprecated format. |
409 | local_error="${config}_ERROR" |
748 | local_error="${config}_ERROR" |
410 | local_error="${!local_error}" |
749 | local_error="${!local_error}" |
411 | [ -n "${local_error}" ] && eerror " ${local_error}" || \ |
|
|
412 | eerror " CONFIG_${config}:\tshould not be set in the kernel configuration, but it is." |
|
|
413 | error=1 |
|
|
414 | fi |
750 | fi |
415 | elif [ "${negate}" == "@" ]; |
751 | if [[ ${die} == 0 && -z "${local_error}" ]]; then |
416 | then |
752 | #soft errors can be warnings |
417 | # we never call this unless we are using MODULE_NAMES |
|
|
418 | |
|
|
419 | config="${config:1}" |
|
|
420 | temp_config="${config//*:}" |
|
|
421 | config="${config//:*}" |
|
|
422 | if linux_chkconfig_present ${config} |
|
|
423 | then |
|
|
424 | local_error="${config}_ERROR" |
753 | local_error="WARNING_${config}" |
425 | local_error="${!local_error}" |
754 | local_error="${!local_error}" |
426 | [ -n "${local_error}" ] && eerror " ${local_error}" || \ |
755 | if [[ -n "${local_error}" ]] ; then |
427 | eerror " CONFIG_${config}:\tshould not be set in the kernel configuration, but it is." |
756 | report_func="ewarn" |
428 | |
757 | fi |
429 | for i in ${MODULE_NAMES} |
|
|
430 | do |
|
|
431 | n="${i//${temp_config}}" |
|
|
432 | [ -z "${n//(*}" ] && MODULE_IGNORE="${MODULE_IGNORE} ${temp_config}" |
|
|
433 | done |
|
|
434 | error=0 |
|
|
435 | fi |
758 | fi |
436 | else |
759 | |
437 | if ! linux_chkconfig_present ${config} |
760 | if [[ -z "${local_error}" ]]; then |
438 | then |
761 | [[ ${error} == 1 ]] \ |
439 | local_error="${config}_ERROR" |
762 | && local_error="is not set when it should be." \ |
|
|
763 | || local_error="should not be set. But it is." |
440 | local_error="${!local_error}" |
764 | local_error="CONFIG_${config}:\t ${local_error}" |
441 | [ -n "${local_error}" ] && eerror " ${local_error}" || \ |
|
|
442 | eerror " CONFIG_${config}:\tshould be set in the kernel configuration, but isn't" |
|
|
443 | error=1 |
|
|
444 | fi |
765 | fi |
|
|
766 | if [[ ${die} == 0 ]]; then |
|
|
767 | ${report_func} " ${local_error}" |
|
|
768 | soft_errors_count=$[soft_errors_count + 1] |
|
|
769 | else |
|
|
770 | ${report_func} " ${local_error}" |
|
|
771 | hard_errors_count=$[hard_errors_count + 1] |
|
|
772 | fi |
445 | fi |
773 | fi |
446 | done |
774 | done |
447 | |
775 | |
448 | if [ "${error}" == 1 ] ; |
776 | if [[ ${hard_errors_count} > 0 ]]; then |
449 | then |
|
|
450 | eerror "Please check to make sure these options are set correctly." |
777 | eerror "Please check to make sure these options are set correctly." |
|
|
778 | eerror "Failure to do so may cause unexpected problems." |
451 | eerror "Once you have satisfied these options, please try merging" |
779 | eerror "Once you have satisfied these options, please try merging" |
452 | eerror "this package again." |
780 | eerror "this package again." |
|
|
781 | export LINUX_CONFIG_EXISTS_DONE="${old_LINUX_CONFIG_EXISTS_DONE}" |
453 | die "Incorrect kernel configuration options" |
782 | die "Incorrect kernel configuration options" |
|
|
783 | elif [[ ${soft_errors_count} > 0 ]]; then |
|
|
784 | ewarn "Please check to make sure these options are set correctly." |
|
|
785 | ewarn "Failure to do so may cause unexpected problems." |
|
|
786 | else |
|
|
787 | eend 0 |
454 | fi |
788 | fi |
|
|
789 | export LINUX_CONFIG_EXISTS_DONE="${old_LINUX_CONFIG_EXISTS_DONE}" |
455 | } |
790 | } |
456 | |
791 | |
457 | check_zlibinflate() { |
792 | check_zlibinflate() { |
458 | # if we haven't determined the version yet, we need too. |
793 | # if we haven't determined the version yet, we need to |
|
|
794 | require_configured_kernel |
459 | get_version; |
795 | get_version |
460 | |
796 | |
461 | # although I restructured this code - I really really really dont support it! |
797 | # although I restructured this code - I really really really dont support it! |
462 | |
798 | |
463 | # bug #27882 - zlib routines are only linked into the kernel |
799 | # bug #27882 - zlib routines are only linked into the kernel |
464 | # if something compiled into the kernel calls them |
800 | # if something compiled into the kernel calls them |
465 | # |
801 | # |
466 | # plus, for the cloop module, it appears that there's no way |
802 | # plus, for the cloop module, it appears that there's no way |
467 | # to get cloop.o to include a static zlib if CONFIG_MODVERSIONS |
803 | # to get cloop.o to include a static zlib if CONFIG_MODVERSIONS |
468 | # is on |
804 | # is on |
469 | |
805 | |
470 | local INFLATE |
806 | local INFLATE |
471 | local DEFLATE |
807 | local DEFLATE |
472 | |
808 | |
473 | einfo "Determining the usability of ZLIB_INFLATE support in your kernel" |
809 | einfo "Determining the usability of ZLIB_INFLATE support in your kernel" |
474 | |
810 | |
475 | ebegin "checking ZLIB_INFLATE" |
811 | ebegin "checking ZLIB_INFLATE" |
476 | getfilevar_isbuiltin CONFIG_ZLIB_INFLATE ${KV_DIR}/.config |
812 | linux_chkconfig_builtin CONFIG_ZLIB_INFLATE |
477 | eend $? |
813 | eend $? |
478 | [ "$?" != 0 ] && die |
814 | [ "$?" != 0 ] && die |
479 | |
815 | |
480 | ebegin "checking ZLIB_DEFLATE" |
816 | ebegin "checking ZLIB_DEFLATE" |
481 | getfilevar_isbuiltin CONFIG_ZLIB_DEFLATE ${KV_DIR}/.config |
817 | linux_chkconfig_builtin CONFIG_ZLIB_DEFLATE |
482 | eend $? |
818 | eend $? |
483 | [ "$?" != 0 ] && die |
819 | [ "$?" != 0 ] && die |
484 | |
820 | |
485 | |
|
|
486 | local LINENO_START |
821 | local LINENO_START |
487 | local LINENO_END |
822 | local LINENO_END |
488 | local SYMBOLS |
823 | local SYMBOLS |
489 | local x |
824 | local x |
490 | |
825 | |
491 | LINENO_END="$(grep -n 'CONFIG_ZLIB_INFLATE y' ${KV_DIR}/lib/Config.in | cut -d : -f 1)" |
826 | LINENO_END="$(grep -n 'CONFIG_ZLIB_INFLATE y' ${KV_DIR}/lib/Config.in | cut -d : -f 1)" |
492 | LINENO_START="$(head -n $LINENO_END ${KV_DIR}/lib/Config.in | grep -n 'if \[' | tail -n 1 | cut -d : -f 1)" |
827 | LINENO_START="$(head -n $LINENO_END ${KV_DIR}/lib/Config.in | grep -n 'if \[' | tail -n 1 | cut -d : -f 1)" |
493 | (( LINENO_AMOUNT = $LINENO_END - $LINENO_START )) |
828 | (( LINENO_AMOUNT = $LINENO_END - $LINENO_START )) |
494 | (( LINENO_END = $LINENO_END - 1 )) |
829 | (( LINENO_END = $LINENO_END - 1 )) |
495 | SYMBOLS="$(head -n $LINENO_END ${KV_DIR}/lib/Config.in | tail -n $LINENO_AMOUNT | sed -e 's/^.*\(CONFIG_[^\" ]*\).*/\1/g;')" |
830 | SYMBOLS="$(head -n $LINENO_END ${KV_DIR}/lib/Config.in | tail -n $LINENO_AMOUNT | sed -e 's/^.*\(CONFIG_[^\" ]*\).*/\1/g;')" |
… | |
… | |
501 | # we have a winner! |
836 | # we have a winner! |
502 | einfo "${x} ensures zlib is linked into your kernel - excellent" |
837 | einfo "${x} ensures zlib is linked into your kernel - excellent" |
503 | return 0 |
838 | return 0 |
504 | fi |
839 | fi |
505 | done |
840 | done |
506 | |
841 | |
507 | eerror |
842 | eerror |
508 | eerror "This kernel module requires ZLIB library support." |
843 | eerror "This kernel module requires ZLIB library support." |
509 | eerror "You have enabled zlib support in your kernel, but haven't enabled" |
844 | eerror "You have enabled zlib support in your kernel, but haven't enabled" |
510 | eerror "enabled any option that will ensure that zlib is linked into your" |
845 | eerror "enabled any option that will ensure that zlib is linked into your" |
511 | eerror "kernel." |
846 | eerror "kernel." |
… | |
… | |
525 | } |
860 | } |
526 | |
861 | |
527 | ################################ |
862 | ################################ |
528 | # Default pkg_setup |
863 | # Default pkg_setup |
529 | # Also used when inheriting linux-mod to force a get_version call |
864 | # Also used when inheriting linux-mod to force a get_version call |
530 | |
865 | # @FUNCTION: linux-info_pkg_setup |
|
|
866 | # @DESCRIPTION: |
|
|
867 | # Force a get_version() call when inherited from linux-mod.eclass and then check if the kernel is configured |
|
|
868 | # to support the options specified in CONFIG_CHECK (if not null) |
531 | linux-info_pkg_setup() { |
869 | linux-info_pkg_setup() { |
532 | get_version; |
870 | linux-info_get_any_version |
|
|
871 | |
|
|
872 | if kernel_is 2 4; then |
|
|
873 | if [ "$( gcc-major-version )" -eq "4" ] ; then |
|
|
874 | echo |
|
|
875 | ewarn "Be warned !! >=sys-devel/gcc-4.0.0 isn't supported with" |
|
|
876 | ewarn "linux-2.4 (or modules building against a linux-2.4 kernel)!" |
|
|
877 | echo |
|
|
878 | ewarn "Either switch to another gcc-version (via gcc-config) or use a" |
|
|
879 | ewarn "newer kernel that supports gcc-4." |
|
|
880 | echo |
|
|
881 | ewarn "Also be aware that bugreports about gcc-4 not working" |
|
|
882 | ewarn "with linux-2.4 based ebuilds will be closed as INVALID!" |
|
|
883 | echo |
|
|
884 | epause 10 |
|
|
885 | fi |
|
|
886 | fi |
|
|
887 | |
533 | [ -n "${CONFIG_CHECK}" ] && check_extra_config; |
888 | [ -n "${CONFIG_CHECK}" ] && check_extra_config; |
534 | } |
889 | } |