summaryrefslogtreecommitdiff
path: root/scripts/build/kernel/linux.sh
blob: 32ba269cb8504fcf20d6ff25029237251a08e887 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
# This file declares functions to install the kernel headers for linux
# Copyright 2007 Yann E. MORIN
# Licensed under the GPL v2. See COPYING in the root of this package

CT_DoKernelTupleValues() {
    if [ "${CT_ARCH_USE_MMU}" = "y" ]; then
        CT_TARGET_KERNEL="linux"
    else
    # Sometime, noMMU linux targets have a -uclinux tuple, while
    # sometime it's -linux. We currently have only one noMMU linux
    # target, and it uses -linux, so let's just use that. Time
    # to fix that later...
    #    CT_TARGET_KERNEL="uclinux"
        CT_TARGET_KERNEL="linux"
    fi
}

# Download the kernel
do_kernel_get() {
    local k_ver
    if [    "${CT_KERNEL_LINUX_INSTALL}" = "y"  \
         -a "${CT_KERNEL_LINUX_CUSTOM}" != "y"  \
       ]; then
        case "${CT_KERNEL_VERSION}" in
            2.6.*.*|3.*.*)
                # 4-part versions (for 2.6 stables and long-terms), and
                # 3-part versions (for 3.x.y stables and long-terms),
                # we need to trash the last digit
                k_ver="${CT_KERNEL_VERSION%.*}"
                ;;
            2.6.*|3.*)
                # 3-part version (for 2.6.x initial releases), and 2-part
                # versions (for 3.x initial releases), use all of it
                k_ver="${CT_KERNEL_VERSION}"
                ;;
        esac
        CT_GetFile "linux-${CT_KERNEL_VERSION}"                                             \
                   http://ftp.{de.,eu.,}kernel.org/pub/linux/kernel/v2.6                    \
                   http://ftp.{de.,eu.,}kernel.org/pub/linux/kernel/v3.0                    \
                   http://ftp.{de.,eu.,}kernel.org/pub/linux/kernel/v2.6/longterm/v${k_ver} \
                   http://ftp.{de.,eu.,}kernel.org/pub/linux/kernel/v3.0/longterm/v${k_ver} \
                   http://ftp.free.fr/mirrors/ftp.kernel.org//linux/kernel/v2.6             \
                   http://ftp.free.fr/mirrors/ftp.kernel.org//linux/kernel/v3.0             \
                   http://ftp.free.fr/mirrors/ftp.kernel.org//linux/kernel/v2.6/longterm/v${k_ver}  \
                   http://ftp.free.fr/mirrors/ftp.kernel.org//linux/kernel/v3.0/longterm/v${k_ver}
    fi
}

# Extract kernel
do_kernel_extract() {
    local tar_opt
    if [ "${CT_KERNEL_LINUX_INSTALL}" = "y" ]; then
        if [ "${CT_KERNEL_LINUX_CUSTOM}" = "y" ]; then
            # We extract the custom linux tree into a directory with a
            # well-known name, and strip the leading directory component
            # of the extracted pathes. This is needed because we do not
            # know the value for this first component, because it is a
            # _custom_ tree.
            # Also, we have to protect from partial extraction using the
            # .extracting and .extracted locks (not using .patching and
            # .patched as we are *not* patching that kernel).

            if [ -e "${CT_SRC_DIR}/.linux-custom.extracted" ]; then
                CT_DoLog DEBUG "Custom linux kernel tree already extracted"
                return 0
            fi

            CT_TestAndAbort "Custom kernel tree partially extracted. Remove before resuming" -f "${CT_SRC_DIR}/.linux-custom.extracting"
            CT_DoExecLog DEBUG touch "${CT_SRC_DIR}/.linux-custom.extracting"
            CT_DoExecLog DEBUG mkdir "${CT_SRC_DIR}/linux-custom"

            case "${CT_KERNEL_LINUX_CUSTOM_TARBALL}" in
                *.tar.bz2)      tar_opt=-j;;
                *.tar.gz|*.tgz) tar_opt=-z;;
                *.tar)          ;;
                *)              CT_Abort "Don't know how to handle '${CT_KERNEL_LINUX_CUSTOM_TARBALL}': unknown extension";;
            esac
            CT_DoLog EXTRA "Extracting custom linux kernel"
            CT_DoExecLog ALL tar x -C "${CT_SRC_DIR}/linux-custom"      \
                                 --strip-components 1 -v ${tar_opt}     \
                                 -f "${CT_KERNEL_LINUX_CUSTOM_TARBALL}"

            CT_DoExecLog ALL mv -v "${CT_SRC_DIR}/.linux-custom.extracting" "${CT_SRC_DIR}/.linux-custom.extracted"
        else
            CT_Extract "linux-${CT_KERNEL_VERSION}"
            CT_Patch "linux" "${CT_KERNEL_VERSION}"
        fi
    fi
}

# Wrapper to the actual headers install method
do_kernel_headers() {
    CT_DoStep INFO "Installing kernel headers"

    if [ "${CT_KERNEL_LINUX_INSTALL}" = "y" ]; then
        do_kernel_install
    else
        do_kernel_custom
    fi

    CT_EndStep
}

# Install kernel headers using headers_install from kernel sources.
do_kernel_install() {
    local kernel_path

    CT_DoLog DEBUG "Using kernel's headers_install"

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

    kernel_path="${CT_SRC_DIR}/linux-${CT_KERNEL_VERSION}"
    if [ "${CT_KERNEL_LINUX_CUSTOM}" = "y" ]; then
        kernel_path="${CT_SRC_DIR}/linux-custom"
    fi
    V_OPT="V=${CT_KERNEL_LINUX_VERBOSE_LEVEL}"

    CT_DoLog EXTRA "Installing kernel headers"
    CT_DoExecLog ALL                                    \
    make -C "${kernel_path}"                            \
         O="${CT_BUILD_DIR}/build-kernel-headers"       \
         ARCH=${CT_ARCH}                                \
         INSTALL_HDR_PATH="${CT_SYSROOT_DIR}/usr"       \
         ${V_OPT}                                       \
         headers_install

    if [ "${CT_KERNEL_LINUX_INSTALL_CHECK}" = "y" ]; then
        CT_DoLog EXTRA "Checking installed headers"
        CT_DoExecLog ALL                                    \
        make -C "${kernel_path}"                            \
             O="${CT_BUILD_DIR}/build-kernel-headers"       \
             ARCH=${CT_ARCH}                                \
             INSTALL_HDR_PATH="${CT_SYSROOT_DIR}/usr"       \
             ${V_OPT}                                       \
             headers_check
    fi

    # Cleanup
    find "${CT_SYSROOT_DIR}" -type f                        \
                             \(    -name '.install'         \
                                -o -name '..install.cmd'    \
                                -o -name '.check'           \
                                -o -name '..check.cmd'      \
                             \)                             \
                             -exec rm {} \;
}

# Use custom headers (most probably by using make headers_install in a
# modified (read: customised) kernel tree, or using pre-2.6.18 headers, such
# as 2.4). In this case, simply copy the headers in place
do_kernel_custom() {
    local tar_opt

    CT_DoLog EXTRA "Installing custom kernel headers"

    mkdir -p "${CT_SYSROOT_DIR}/usr"
    cd "${CT_SYSROOT_DIR}/usr"
    if [ "${CT_KERNEL_LINUX_CUSTOM_IS_TARBALL}" = "y" ]; then
        case "${CT_KERNEL_LINUX_CUSTOM_PATH}" in
            *.tar)      ;;
            *.tgz)      tar_opt=--gzip;;
            *.tar.gz)   tar_opt=--gzip;;
            *.tar.bz2)  tar_opt=--bzip2;;
            *.tar.lzma) tar_opt=--lzma;;
        esac
        CT_DoExecLog ALL tar x ${tar_opt} -vf ${CT_KERNEL_LINUX_CUSTOM_PATH}
    else
        CT_DoExecLog ALL cp -rv "${CT_KERNEL_LINUX_CUSTOM_PATH}/include" .
    fi
}