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 "Installing kernel headers"

    84     make ARCH=${CT_KERNEL_ARCH}                     \

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

    86          ${V_OPT}                                   \

    87          headers_install                            2>&1 |CT_DoLog DEBUG

    89     CT_DoLog EXTRA "Checking installed headers"

    90     make ARCH=${CT_KERNEL_ARCH}                     \

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

    92          ${V_OPT}                                   \

    93          headers_check                              2>&1 |CT_DoLog DEBUG

    94 }

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

    97 do_kernel_sanitised() {

    98     CT_DoLog EXTRA "Copying sanitised headers"

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

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

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

   102 }

   104 # Install kernel headers by plain copy.

   105 do_kernel_copy() {

   106     CT_DoLog EXTRA "Copying plain kernel headers"

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

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

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

   111     CT_DoLog EXTRA "Preparing kernel headers"

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

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

   114                  cp "${CT_KERNEL_LINUX_CONFIG_FILE}" .config

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

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

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

   118                  ;;

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

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

   121                  cp "${CT_KERNEL_LINUX_CONFIG_FILE}" .config

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

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

   124                                    oldconfig

   125                  case "${CT_KERNEL_ARCH}" in

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

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

   128                                  # target gcc, so we can use it.

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

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

   131                                  make ${PARALLELMFLAGS}                 \

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

   133                                       prepare include/linux/version.h

   134                                  ;;

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

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

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

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

   139                                  ;;

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

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

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

   143                                  # so you have to use -isystem.

   144                                  make ${PARALLELMFLAGS}                 \

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

   146                                       include/asm include/linux/version.h

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

   148                                  ;;

   149                      *)          make ${PARALLELMFLAGS}                 \

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

   151                                       include/asm include/linux/version.h

   152                                  ;;

   153                  esac

   154                  ;;

   155     esac 2>&1 |CT_DoLog DEBUG

   157     CT_DoLog EXTRA "Copying kernel headers"

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

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

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

   161 }

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

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

   165 # the headers in place

   166 do_kernel_preinstalled() {

   167     CT_DoLog EXTRA "Copying preinstalled kernel headers"

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

   170     cd "${CT_KERNEL_LINUX_HEADERS_CUSTOM_DIR}"

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

   172 }

author	"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
	Sun May 06 21:47:29 2007 +0000 (2007-05-06)
changeset 62	651912c5477c
parent 49	f431118daec4
child 63	89b41dbffe8d
permissions	-rw-r--r--