crosstool-ng: scripts/build/kernel

     1 # This file declares functions to install the kernel headers for linux

     2 # Copyright 2007 Yann E. MORIN

     3 # Licensed under the GPL v2. See COPYING in the root of this package

     5 # Check kernel configuration

     6 do_kernel_check_config() {

     7     CT_DoStep INFO "Checking kernel configuration"

     9     if [    "${CT_KERNEL_LINUX_HEADERS_USE_CUSTOM_DIR}" != "y" \

    10          -a \( -z "${CT_KERNEL_LINUX_CONFIG_FILE}" -o ! -r "${CT_KERNEL_LINUX_CONFIG_FILE}" \) ]; then

    11         CT_DoLog WARN "You did not provide a kernel configuration file!"

    12         CT_DoLog WARN "I will try to generate one for you, but beware!"

    14         CT_DoStep INFO "Building a default configuration file for linux kernel"

    16         mkdir -p "${CT_BUILD_DIR}/build-kernel-defconfig"

    17         cd "${CT_BUILD_DIR}/build-kernel-defconfig"

    18         make -C "${CT_SRC_DIR}/${CT_KERNEL_FILE}" O=`pwd`   \

    19              ARCH=${CT_KERNEL_ARCH} defconfig               2>&1 |CT_DoLog DEBUG

    21         CT_KERNEL_LINUX_CONFIG_FILE="`pwd`/.config"

    23         CT_EndStep

    24     fi

    26     CT_EndStep

    27 }

    29 # Wrapper to the actual headers install method

    30 do_kernel_headers() {

    31     CT_DoStep INFO "Installing kernel headers"

    33     # Special case when using pre-installed headers

    34     if [ "${CT_KERNEL_LINUX_HEADERS_USE_CUSTOM_DIR}" = "y" ]; then

    35         do_kernel_preinstalled

    36     else

    37         # We need to enter this directory to find the kernel version strings

    38         cd "${CT_SRC_DIR}/${CT_KERNEL_FILE}"

    39         if [ "${CT_KERNEL_LINUX_HEADERS_SANITISED}" != "y" ]; then

    40             k_version=`awk '/^VERSION =/ { print $3 }' Makefile`

    41             k_patchlevel=`awk '/^PATCHLEVEL =/ { print $3 }' Makefile`

    42             k_sublevel=`awk '/^SUBLEVEL =/ { print $3 }' Makefile`

    43             k_extraversion=`awk '/^EXTRAVERSION =/ { print $3 }' Makefile`

    44         else

    45             k_version=`echo "${CT_KERNEL_VERSION}." |cut -d . -f 1`

    46             k_patchlevel=`echo "${CT_KERNEL_VERSION}." |cut -d . -f 2`

    47             k_sublevel=`echo "${CT_KERNEL_VERSION}." |cut -d . -f 3`

    48             k_extraversion=`echo "${CT_KERNEL_VERSION}." |cut -d . -f 4`

    49         fi

    51         case "${k_version}.${k_patchlevel}" in

    52             2.2|2.4|2.6) ;;

    53             *)  CT_Abort "Unsupported kernel version \"linux-${k_version}.${k_patchlevel}\".";;

    54         esac

    56         # Kernel version that support verbosity will use this, others will ignore it:

    57         V_OPT="V=${CT_KERNEL_LINUX_VERBOSE_LEVEL}"

    59         if [ "${CT_KERNEL_LINUX_HEADERS_INSTALL}" = "y" ]; then

    60             do_kernel_install

    61         elif [ "${CT_KERNEL_LINUX_HEADERS_SANITISED}" = "y" ]; then

    62             do_kernel_sanitised

    63         else [ "${CT_KERNEL_LINUX_HEADERS_COPY}" = "y" ];

    64             do_kernel_copy

    65         fi

    66     fi

    68     CT_EndStep

    69 }

    71 # Install kernel headers using headers_install from kernel sources.

    72 do_kernel_install() {

    73     CT_DoLog EXTRA "Using kernel's headers_install"

    75     mkdir -p "${CT_BUILD_DIR}/build-kernel-headers"

    76     cd "${CT_BUILD_DIR}/build-kernel-headers"

    78     case "${k_version}.${k_patchlevel}" in

    79         2.6) [ ${k_sublevel} -ge 18 ] || CT_Abort "Kernel version >= 2.6.18 is needed to install kernel headers.";;

    80         *)   CT_Abort "Kernel version >= 2.6.18 is needed to install kernel headers.";;

    81     esac

    83     CT_DoLog EXTRA "Configuring kernel headers"

    84     cp "${CT_KERNEL_LINUX_CONFIG_FILE}" .config

    85     CT_DoYes "" |make -C "${CT_SRC_DIR}/${CT_KERNEL_FILE}"      \

    86                       O="${CT_BUILD_DIR}/build-kernel-headers"  \

    87                       ${V_OPT}                                  \

    88                       ARCH=${CT_KERNEL_ARCH} oldconfig          2>&1 |CT_DoLog DEBUG

    90     CT_DoLog EXTRA "Installing kernel headers"

    91     make ARCH=${CT_KERNEL_ARCH}                     \

    92          INSTALL_HDR_PATH="${CT_SYSROOT_DIR}/usr"   \

    93          ${V_OPT}                                   \

    94          headers_install                            2>&1 |CT_DoLog DEBUG

    96     CT_DoLog EXTRA "Checking installed headers"

    97     make ARCH=${CT_KERNEL_ARCH}                     \

    98          INSTALL_HDR_PATH="${CT_SYSROOT_DIR}/usr"   \

    99          ${V_OPT}                                   \

   100          headers_check                              2>&1 |CT_DoLog DEBUG

   101 }

   103 # Install kernel headers from oldish Mazur's sanitised headers.

   104 do_kernel_sanitised() {

   105     CT_DoLog EXTRA "Copying sanitised headers"

   106     cd "${CT_SRC_DIR}/${CT_KERNEL_FILE}"

   107     cp -rv include/linux "${CT_HEADERS_DIR}" 2>&1 |CT_DoLog DEBUG

   108     cp -rv "include/asm-${CT_KERNEL_ARCH}" "${CT_HEADERS_DIR}/asm" 2>&1 |CT_DoLog DEBUG

   109 }

   111 # Install kernel headers by plain copy.

   112 do_kernel_copy() {

   113     CT_DoLog EXTRA "Copying plain kernel headers"

   114     CT_DoLog WARN "You are using plain kernel headers. You really shouldn't do that."

   115     CT_DoLog WARN "You'd be better off by using installed headers (or sanitised headers)."

   117     # 2.2 and 2.4 don't support building out-of-tree. 2.6 does.

   118     CT_DoLog EXTRA "Preparing kernel headers"

   119     case "${k_version}.${k_patchlevel}" in

   120         2.2|2.4) cd "${CT_SRC_DIR}/${CT_KERNEL_FILE}"

   121                  cp "${CT_KERNEL_LINUX_CONFIG_FILE}" .config

   122                  CT_DoYes "" |make ARCH=${CT_KERNEL_ARCH} oldconfig

   123                  # 2.4 doesn't follow V=# for verbosity... :-(

   124                  make ARCH=${CT_KERNEL_ARCH} symlinks include/linux/version.h

   125                  ;;

   126         2.6)     mkdir -p "${CT_BUILD_DIR}/build-kernel-headers"

   127                  cd "${CT_BUILD_DIR}/build-kernel-headers"

   128                  cp "${CT_KERNEL_LINUX_CONFIG_FILE}" .config

   129                  CT_DoYes "" |make -C "${CT_SRC_DIR}/${CT_KERNEL_FILE}"         \

   130                                    O="`pwd`" ${V_OPT} ARCH=${CT_KERNEL_ARCH}    \

   131                                    oldconfig

   132                  case "${CT_KERNEL_ARCH}" in

   133                      sh*)        # sh does secret stuff in 'make prepare' that can't be

   134                                  # triggered separately, but happily, it doesn't use

   135                                  # target gcc, so we can use it.

   136                                  # Update: this fails on 2.6.11, as it installs

   137                                  # elfconfig.h, which requires target compiler :-(

   138                                  make ${PARALLELMFLAGS}                 \

   139                                       ARCH=${CT_KERNEL_ARCH} ${V_OPT}   \

   140                                       prepare include/linux/version.h

   141                                  ;;

   142                      arm*|cris*) make ${PARALLELMFLAGS}                 \

   143                                       ARCH=${CT_KERNEL_ARCH} ${V_OPT}       \

   144                                       include/asm include/linux/version.h   \

   145                                       include/asm-${CT_KERNEL_ARCH}/.arch

   146                                  ;;

   147                      mips*)      # for linux-2.6, 'make prepare' for mips doesn't

   148                                  # actually create any symlinks.  Hope generic is ok.

   149                                  # Note that glibc ignores all -I flags passed in CFLAGS,

   150                                  # so you have to use -isystem.

   151                                  make ${PARALLELMFLAGS}                 \

   152                                       ARCH=${CT_KERNEL_ARCH} ${V_OPT}   \

   153                                       include/asm include/linux/version.h

   154                                  TARGET_CFLAGS="${TARGET_CFLAGS} -isystem ${LINUX_HEADER_DIR}/include/asm-mips/mach-generic"

   155                                  ;;

   156                      *)          make ${PARALLELMFLAGS}                 \

   157                                       ARCH=${CT_KERNEL_ARCH} ${V_OPT}   \

   158                                       include/asm include/linux/version.h

   159                                  ;;

   160                  esac

   161                  ;;

   162     esac 2>&1 |CT_DoLog DEBUG

   164     CT_DoLog EXTRA "Copying kernel headers"

   165     cp -rv include/asm-generic "${CT_HEADERS_DIR}/asm-generic" 2>&1 |CT_DoLog DEBUG

   166     cp -rv include/linux "${CT_HEADERS_DIR}" 2>&1 |CT_DoLog DEBUG

   167     cp -rv include/asm-${CT_KERNEL_ARCH} "${CT_HEADERS_DIR}/asm" 2>&1 |CT_DoLog DEBUG

   168 }

   170 # Use preinstalled headers (most probably by using make headers_install in a

   171 # modified (read: customised) kernel tree). In this case, simply copy

   172 # the headers in place

   173 do_kernel_preinstalled() {

   174     CT_DoLog EXTRA "Copying preinstalled kernel headers"

   176     mkdir -p "${CT_SYSROOT_DIR}/usr"

   177     cd "${CT_KERNEL_LINUX_HEADERS_CUSTOM_DIR}"

   178     cp -rv include "${CT_SYSROOT_DIR}/usr" 2>&1 |CT_DoLog DEBUG

   179 }

author	"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
	Mon Apr 23 21:06:09 2007 +0000 (2007-04-23)
changeset 49	f431118daec4
parent 37	21bcbfde8094
child 62	651912c5477c
permissions	-rw-r--r--