diff options
| -rw-r--r-- | eclass/kmod.eclass | 322 |
1 files changed, 322 insertions, 0 deletions
diff --git a/eclass/kmod.eclass b/eclass/kmod.eclass new file mode 100644 index 000000000000..b51409ce0ff9 --- /dev/null +++ b/eclass/kmod.eclass @@ -0,0 +1,322 @@ +# Copyright 1999-2003 Gentoo Technologies, Inc. +# Distributed under the terms of the GNU General Public License v2 +# $Header: /var/cvsroot/gentoo-x86/eclass/kmod.eclass,v 1.11 2004/04/10 20:07:00 latexer Exp $ + +# This eclass provides help for compiling external kernel modules from +# source. +# +# BEWARE: This eclass is superceding the old kmod.eclass. It does *not* +# implement the same functionality as the old kmod.eclass! + +# DOCUMENTATION: Most documentation for this can be found at: +# http://www.gentoo.org/doc/en/2.6-koutput.xml +# +# More documentation comments will follow in the header of this soon! + +# Variables you can use to change behavior +# +# KMOD_SOURCES - space seperated list of source to unpack in +# src_unpack() if you don't want ${A} unpacked. +# +# KMOD_KOUTPUT_PATCH - Patch to apply in src_unpack() if a seperate output +# directory is detected. +# + +inherit eutils + +ECLASS=kmod +INHERITED="$INHERITED $ECLASS" +S=${WORKDIR}/${P} +DESCRIPTION="Based on the $ECLASS eclass" + +SRC_URI="${SRC_URI:-unknown - please fix me!!}" +KERNEL_DIR="${KERNEL_DIR:-${ROOT}/usr/src/linux}" + +EXPORT_FUNCTIONS src_unpack src_compile pkg_postinst + +kmod_get_make_var () +{ + grep "^${1}" ${2} | head -n 1 | grep -v ":=" | cut -d = -f 2- \ + | awk '{ print $1 }' +} + +# getconfigvar() - Prints the value of a certain config varaible from the +# current kernel's config file. Will return "n" for an unset +# option + +kmod_get_config_var() +{ + local configopt="CONFIG_${1}" + local configresult + + if [ -z ${KV_OUTPUT} ]; then + get_kernel_info + fi + + configresult="`grep ^$configopt ${KV_OUTPUT}/.config | cut -d= -f 2-`" + if [ -z "${configresult}" ]; then + echo "n" + else + echo ${configresult} | awk '{ print $1 }' + fi +} + +# get_kernel_info is used to get our build environment. It initializes several +# variables that can be used in ebuilds +# +# KV_MAJOR, KV_MINOR, KV_PATCH - the kernel major, minor, and pathlevel #'s +# KV_TYPE - the type, as found from EXTRAVERSION. +# +# KV_VERSION_FULL - full string for the kernel version +# +# KV_OUTPUT - the output direcotry if used with a 2.6 kernel +# +# KV_OBJ - extension for kernel objects, "o" for 2.4 kernels and "ko" for 2.6 +# +get_kernel_info() +{ + # yes, this is horrible, but it is effective + # + # KV_DIR contains the real directory name of the directory containing + # the Linux kernel that we are going to compile against + + if [ -h ${KERNEL_DIR} ] ; then + einfo "`echo ${KERNEL_DIR} | tr -s /` is a symbolic link" + einfo "Determining the real directory of the Linux kernel source code" + KV_DIR="`readlink ${KERNEL_DIR}`" + elif [ -d ${KERNEL_DIR} ] ; then + einfo "`echo ${KERNEL_DIR} | tr -s /` is a real directory" + KV_DIR="`ls -d ${KERNEL_DIR}`" + # KV_DIR="`ls -ld --full-time ${KERNEL_DIR} | awk '{ print $9 }'`" + else + eerror "Directory '${KERNEL_DIR}' cannot be found" + die + fi + KV_DIR="`basename ${KV_DIR}`" + + # now, we need to break that down into versions + + KV_DIR_VERSION_FULL="`echo $KV_DIR | cut -f 2- -d -`" + + KV_DIR_MAJOR="`echo ${KV_DIR_VERSION_FULL} | cut -f 1 -d .`" + KV_DIR_MINOR="`echo ${KV_DIR_VERSION_FULL} | cut -f 2 -d .`" + KV_DIR_PATCH="`echo ${KV_DIR_VERSION_FULL} | cut -f 3 -d . | cut -f 3 -d -`" + KV_DIR_TYPE="`echo ${KV_DIR_VERSION_FULL} | cut -f 2- -d -`" + + # sanity check - do the settings in the kernel's makefile match + # the directory that the kernel src is stored in? + + KV_MK_FILE="${KERNEL_DIR}/Makefile" + KV_MK_MAJOR="`kmod_get_make_var VERSION ${KV_MK_FILE}`" + KV_MK_MINOR="`kmod_get_make_var PATCHLEVEL ${KV_MK_FILE}`" + KV_MK_PATCH="`kmod_get_make_var SUBLEVEL ${KV_MK_FILE}`" + KV_MK_TYPE="`kmod_get_make_var EXTRAVERSION ${KV_MK_FILE}`" + + KV_MK_VERSION_FULL="${KV_MK_MAJOR}.${KV_MK_MINOR}.${KV_MK_PATCH}${KV_MK_TYPE}" + + KV_MK_OUTPUT="`kmod_get_make_var KBUILD_OUTPUT ${KV_MK_FILE}`" + + # May need to deal with a dynamically set KBUILD_OUTPUT variable + if [ "${KV_MK_OUTPUT/VERSION/}" != "${KV_MK_OUTPUT}" ]; then + KV_MK_OUTPUT="${KV_MK_OUTPUT/\$(VERSION)/${KV_MK_MAJOR}}" + KV_MK_OUTPUT="${KV_MK_OUTPUT/\$(PATCHLEVEL)/${KV_MK_MINOR}}" + KV_MK_OUTPUT="${KV_MK_OUTPUT/\$(SUBLEVEL)/${KV_MK_PATCH}}" + KV_MK_OUTPUT="${KV_MK_OUTPUT/\$(EXTRAVERSION)/${KV_MK_TYPE}}" + fi + + if [ "$KV_MK_VERSION_FULL" != "${KV_DIR_VERSION_FULL}" ]; then + ewarn + ewarn "The kernel Makefile says that this is a ${KV_MK_VERSION_FULL} kernel" + ewarn "but the source is in a directory for a ${KV_DIR_VERSION_FULL} kernel." + ewarn + ewarn "This goes against the recommended Gentoo naming convention." + ewarn "Please rename your source directory to 'linux-${KV_MK_VERSION_FULL}'" + ewarn + fi + + # these variables can be used by ebuilds to determine whether they + # will work with the targetted kernel or not + # + # do not rely on any of the variables above being available + + KV_VERSION_FULL="${KV_MK_VERSION_FULL}" + KV_MAJOR="${KV_MK_MAJOR}" + KV_MINOR="${KV_MK_MINOR}" + KV_PATCH="${KV_MK_PATCH}" + KV_TYPE="${KV_MK_TYPE}" + + # if we found an output location, use that. otherwise use KERNEL_DIR. + if [ ! -z "${KV_MK_OUTPUT}" ] + then + KV_OUTPUT="${ROOT}/${KV_MK_OUTPUT}" + else + KV_OUTPUT="${KERNEL_DIR}" + fi + + # KV_OBJ can be used when manually installing kernel modules + if [ "${KV_MINOR}" -gt "4" ] + then + KV_OBJ="ko" + else + KV_OBJ="o" + fi + + einfo "Building for Linux ${KV_VERSION_FULL} found in `echo ${KERNEL_DIR} | tr -s /`" + + if is_kernel 2 5 || is_kernel 2 6 + then + einfo "which outputs to `echo ${KV_OUTPUT} | tr -s /`" + + # Warn them if they aren't using a different output directory + if [ "${KV_OUTPUT}" = "${ROOT}/usr/src/linux" ]; then + ewarn "By not using the kernel's ability to output to an alternative" + ewarn "directory, some external module builds may fail." + ewarn "See <insert link to user doc here>" + fi + fi +} + +# kmod_make_linux_writeable() is used to allow portage to write to +# /usr/src/linux. This is a BIG no-no, but the "easiest" way for +# 2.6 module compilation. Since it's so horrible, we force users to accept +# doing it via a variable controlled by /etc/env.d/20kernel and kernel-config + +kmod_make_linux_writable() +{ + # LINUX_PORTAGE_WRITABLE is set in /etc/env.d/20kernel to "yes" + # if someone really wants to do that + [ -x ${ROOT}/usr/bin/config-kernel ] && LINUX_PORTAGE_WRITABLE="$(${ROOT}/usr/bin/config-kernel --is-writable)" + + if [ "${LINUX_PORTAGE_WRITABLE}" != "yes" ] + then + if [ "${FEATURES/sandbox/}" != "${FEATURES}" ] + then + eerror "Due to the 2.6 kernel build system, external module compilation" + eerror "with a normal setup requires write access to ${KERNEL_DIR}" + eerror "There are several ways to fix/prevent this." + eerror "Users can willingly let portage make this writable by doing" + eerror "# config-kernel --allow-writable yes" + eerror "However, this is considered a security risk!" + eerror "" + eerror "The prefered method is to enable Gentoo's new 'koutput' method" + eerror "for kernel modules. See the doc" + eerror "http://www.gentoo.org/doc/en/2.6-koutput-user.xml" + eerror "To enable this, you'll need to run" + eerror "# config-kernel --output-dir /var/tmp/kernel-output" + eerror "and then install a new kernel" + die "Incompatible kernel setup" + else + ewarn "Detected sandbox disabled for kernel module ebuild" + fi + fi + + eerror "Making ${ROOT}/usr/src/linux-${KV} writable by portage!!!" + addwrite ${ROOT}/usr/src/linux-${KV} +} + + +# kmod_do_buildpatches performs the needed koutput patches as needed +kmod_do_buildpatches() +{ + if [ -z ${KV_OUTPUT} ]; then + get_kernel_info + fi + + cd ${S} + if is_koutput && [ -n "${KMOD_KOUTPUT_PATCH}" ]; then + EPATCH_SINGLE_MESSAGE="Patching to enable koutput compatibility" \ + epatch ${KMOD_KOUTPUT_PATCH} + fi +} + +kmod_src_unpack () +{ + check_KV + kmod_universal_unpack +} + +kmod_universal_unpack() +{ + get_kernel_info + + # KMOD_SOURCES is used if you don't want to unpack just ${A} + # It can be set to "none" if you need to unpack things by hand + # (like the nvidia-kernel ebuild). If set to "none", you'll have + # to do any patching by hand as ${S} won't be around yet! + # You can just call kmod_do_buildpatches after unpacking ${S} + # if need be. + if [ -z "${KMOD_SOURCES}" ] + then + unpack ${A} + elif [ "${KMOD_SOURCES}" != "none" ] + then + unpack ${KMOD_SOURCES} + fi + + if is_kernel 2 5 || is_kernel 2 6 + then + # If we have sources we've unpacked, patch as needed + if [ "${KMOD_SOURCES}" != "none" ]; then + kmod_do_buildpatches + fi + fi +} + +kmod_src_compile () +{ + if is_kernel 2 5 || is_kernel 2 6 + then + # If we're on 2.5/2.6 and not koutputing, we need to make + # /usr/src/linux writable to succeed + if ! is_koutput + then + kmod_make_linux_writable + fi + + unset ARCH + fi + emake KERNEL_DIR=${KERNEL_DIR} || die +} + +kmod_pkg_postinst() +{ + einfo "Checking kernel module dependancies" + test -r "${ROOT}/${KV_OUTPUT}/System.map" && \ + depmod -ae -F "${ROOT}/${KV_OUTPUT}/System.map" -b "${ROOT}" -r ${KV} +} + +# is_kernel() takes two arguments. They should be the major and minor number +# of the kernel you'd like to check for. e.g. +# +# if is_kernel 2 6; then foo; fi +# +is_kernel() { + if [ -z "${KV_MAJOR}" ] + then + get_kernel_info + fi + + if [ "${KV_MAJOR}" -eq "${1}" -a "${KV_MINOR}" -eq "${2}" ] + then + return 0 + else + return 1 + fi +} + +# is_koutput() should be used to determing if we are using the koutput +# method of compilation for 2.6 kernels + +is_koutput() { + if [ -z ${KV_OUTPUT} ] + then + get_kernel_info + fi + + if [ "${KV_OUTPUT}" != "${ROOT}/usr/src/linux" ]; then + return 0 + else + return 1 + fi +} + |