summaryrefslogtreecommitdiffstats
path: root/documentation/sdk-manual/sdk-appendix-obtain.xml
blob: 6ffc9586951ba158b9543a2dff90ff8939d7e4cb (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
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
"http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd"
[<!ENTITY % poky SYSTEM "../poky.ent"> %poky; ] >

<appendix id='sdk-appendix-obtain'>

<title>Obtaining the SDK</title>

<section id='sdk-locating-pre-built-sdk-installers'>
    <title>Locating Pre-Built SDK Installers</title>

    <para>
        You can use existing, pre-built toolchains by locating and running
        an SDK installer script that ships with the Yocto Project.
        Using this method, you select and download an architecture-specific
        toolchain installer and then run the script to hand-install the
        toolchain.
    </para>

    <para>
        You can find SDK installers here:
        <itemizedlist>
            <listitem><para><emphasis>Standard SDK Installers</emphasis>
                Go to <ulink url='&YOCTO_TOOLCHAIN_DL_URL;'></ulink>
                and find the folder that matches your host development system
                (i.e. <filename>i686</filename> for 32-bit machines or
                <filename>x86_64</filename> for 64-bit machines).</para>

                <para>Go into that folder and download the toolchain installer
                whose name includes the appropriate target architecture.
                The toolchains provided by the Yocto Project are based off of
                the <filename>core-image-sato</filename> image and contain
                libraries appropriate for developing against that image.
                For example, if your host development system is a 64-bit x86
                system and you are going to use your cross-toolchain for a
                32-bit x86 target, go into the <filename>x86_64</filename>
                folder and download the following installer:
                <literallayout class='monospaced'>
     poky-glibc-x86_64-core-image-sato-i586-toolchain-&DISTRO;.sh
                </literallayout>
                </para></listitem>
            <listitem><para><emphasis>Extensible SDK Installers</emphasis>
                Installers for the extensible SDK are in
                <ulink url='&YOCTO_TOOLCHAIN_DL_URL;'></ulink>.
                </para></listitem>
        </itemizedlist>
    </para>
</section>

<section id='sdk-building-an-sdk-installer'>
    <title>Building an SDK Installer</title>

    <para>
        As an alternative to locating and downloading a toolchain installer,
        you can build the toolchain installer if you have a
        <ulink url='&YOCTO_DOCS_DEV_URL;#build-directory'>Build Directory</ulink>.
        <note>
            Although not the preferred method, it is also possible to use
            <filename>bitbake meta-toolchain</filename> to build the toolchain
            installer.
            If you do use this method, you must separately install and extract
            the target sysroot.
            For information on how to install the sysroot, see the
            "<link linkend='sdk-extracting-the-root-filesystem'>Extracting the Root Filesystem</link>"
            section.
        </note>
    </para>

    <para>
        To build the toolchain installer for a standard SDK and populate
        the SDK image, use the following command:
        <literallayout class='monospaced'>
     $ bitbake <replaceable>image</replaceable> -c populate_sdk
        </literallayout>
        You can do the same for the extensible SDK using this command:
        <literallayout class='monospaced'>
     $ bitbake <replaceable>image</replaceable> -c populate_sdk_ext
        </literallayout>
        These commands result in a toolchain installer that contains the sysroot
        that matches your target root filesystem.
    </para>

    <para>
        Another powerful feature is that the toolchain is completely
        self-contained.
        The binaries are linked against their own copy of
        <filename>libc</filename>, which results in no dependencies
        on the target system.
        To achieve this, the pointer to the dynamic loader is
        configured at install time since that path cannot be dynamically
        altered.
        This is the reason for a wrapper around the
        <filename>populate_sdk</filename> and
        <filename>populate_sdk_ext</filename> archives.
    </para>

    <para>
        Another feature is that only one set of cross-canadian toolchain
        binaries are produced per architecture.
        This feature takes advantage of the fact that the target hardware can
        be passed to <filename>gcc</filename> as a set of compiler options.
        Those options are set up by the environment script and contained in
        variables such as
        <ulink url='&YOCTO_DOCS_REF_URL;#var-CC'><filename>CC</filename></ulink>
        and
        <ulink url='&YOCTO_DOCS_REF_URL;#var-LD'><filename>LD</filename></ulink>.
        This reduces the space needed for the tools.
        Understand, however, that a sysroot is still needed for every target
        since those binaries are target-specific.
    </para>

    <para>
         Remember, before using any BitBake command, you
         must source the build environment setup script
         (i.e.
         <ulink url='&YOCTO_DOCS_REF_URL;#structure-core-script'><filename>&OE_INIT_FILE;</filename></ulink>
         or
         <ulink url='&YOCTO_DOCS_REF_URL;#structure-memres-core-script'><filename>oe-init-build-env-memres</filename></ulink>)
         located in the Source Directory and you must make sure your
         <filename>conf/local.conf</filename> variables are correct.
         In particular, you need to be sure the
         <ulink url='&YOCTO_DOCS_REF_URL;#var-MACHINE'><filename>MACHINE</filename></ulink>
         variable matches the architecture for which you are building and that
         the
         <ulink url='&YOCTO_DOCS_REF_URL;#var-SDKMACHINE'><filename>SDKMACHINE</filename></ulink>
         variable is correctly set if you are building a toolchain designed to
         run on an architecture that differs from your current development host
         machine (i.e. the build machine).
    </para>

    <para>
        When the <filename>bitbake</filename> command completes, the toolchain
        installer will be in
        <filename>tmp/deploy/sdk</filename> in the Build Directory.
        <note>
            By default, this toolchain does not build static binaries.
            If you want to use the toolchain to build these types of libraries,
            you need to be sure your image has the appropriate static
            development libraries.
            Use the
            <ulink url='&YOCTO_DOCS_REF_URL;#var-IMAGE_INSTALL'><filename>IMAGE_INSTALL</filename></ulink>
            variable inside your <filename>local.conf</filename> file to
            install the appropriate library packages.
            Following is an example using <filename>glibc</filename> static
            development libraries:
            <literallayout class='monospaced'>
     IMAGE_INSTALL_append = " glibc-staticdev"
            </literallayout>
        </note>
    </para>
</section>

<section id='sdk-extracting-the-root-filesystem'>
    <title>Extracting the Root Filesystem</title>

    <para>
        After installing the toolchain or building it using BitBake,
        you need a root filesystem, which you need to separately extract.
    </para>

    <para>
        Here are some cases where you need to extract the root filesystem:
        <itemizedlist>
            <listitem><para>You want to boot the image using NFS.
                </para></listitem>
            <listitem><para>You want to use the root filesystem as the
                target sysroot.
                For example, the Eclipse IDE environment with the Eclipse
                Yocto Plug-in installed allows you to use QEMU to boot
                under NFS.</para></listitem>
            <listitem><para>You want to develop your target application
                using the root filesystem as the target sysroot.
                </para></listitem>
        </itemizedlist>
    </para>

    <para>
        To extract the root filesystem, first <filename>source</filename>
        the cross-development environment setup script to establish
        necessary environment variables.
        If you built the toolchain in the Build Directory, you will find
        the toolchain environment script in the
        <filename>tmp</filename> directory.
        If you installed the toolchain by hand, the environment setup
        script is located in <filename>/opt/poky/&DISTRO;</filename>.
    </para>

    <para>
        After sourcing the environment script, use the
        <filename>runqemu-extract-sdk</filename> command and provide the
        filesystem image.
    </para>

    <para>
        Following is an example.
        The second command sets up the environment.
        In this case, the setup script is located in the
        <filename>/opt/poky/&DISTRO;</filename> directory.
        The third command extracts the root filesystem from a previously
        built filesystem that is located in the
        <filename>~/Downloads</filename> directory.
        Furthermore, this command extracts the root filesystem into the
        <filename>qemux86-sato</filename> directory:
        <literallayout class='monospaced'>
     $ cd ~
     $ source /opt/poky/&DISTRO;/environment-setup-i586-poky-linux
     $ runqemu-extract-sdk \
        ~/Downloads/core-image-sato-sdk-qemux86-2011091411831.rootfs.tar.bz2 \
        $HOME/qemux86-sato
        </literallayout>
        You could now point to the target sysroot at
        <filename>qemux86-sato</filename>.
    </para>
</section>

<section id='sdk-installed-standard-sdk-directory-structure'>
    <title>Installed Standard SDK Directory Structure</title>

    <para>
        The following figure shows the resulting directory structure after
        you install the Standard SDK by running the <filename>.sh</filename>
        SDK installation script:
    </para>

    <para>
        <imagedata fileref="figures/sdk-installed-standard-sdk-directory.png" scale="60" align="center" />
    </para>

    <para>
        The installed SDK consists of an environment setup script for the SDK,
        a configuration file for the target, a version file for the target,
        and the root filesystem (<filename>sysroots</filename>) needed to
        develop objects for the target system.
    </para>

    <para>
        Within the figure, italicized text is used to indicate replaceable
        portions of the file or directory name.
        For example,
        <replaceable>install_dir</replaceable>/<replaceable>version</replaceable>
        is the directory where the SDK is installed.
        By default, this directory is <filename>/opt/poky/</filename>.
        And, <replaceable>version</replaceable> represents the specific
        snapshot of the SDK (e.g. <filename>&DISTRO;+snapshot</filename>).
        Furthermore, <replaceable>target</replaceable> represents the target
        architecture (e.g. <filename>i586</filename>) and
        <replaceable>host</replaceable> represents the development system's
        architecture (e.g. <filename>x86_64</filename>).
        Thus, the complete names of the two directories within the
        <filename>sysroots</filename> could be
        <filename>i586-poky-linux</filename> and
        <filename>x86_64-pokysdk-linux</filename> for the target and host,
        respectively.
    </para>
</section>

<section id='sdk-installed-extensible-sdk-directory-structure'>
    <title>Installed Extensible SDK Directory Structure</title>

    <para>
        The following figure shows the resulting directory structure after
        you install the Extensible SDK by running the <filename>.sh</filename>
        SDK installation script:
    </para>

    <para>
        <imagedata fileref="figures/sdk-installed-extensible-sdk-directory.png" scale="60" align="center" />
    </para>

    <para>
        The installed directory structure for the extensible SDK is quite
        different than the installed structure for the standard SDK.
        The extensible SDK does not separate host and target parts in the
        same manner as does the standard SDK.
        The extensible SDK uses an embedded copy of the build system, which
        has its own sysroots.
    </para>

    <para>
        Of note in the directory structure are an environment setup script
        for the SDK, a configuration file for the target, a version file for
        the target, and a log file for the build system preparation script run
        by the installer.
    </para>

    <para>
        Within the figure, italicized text is used to indicate replaceable
        portions of the file or directory name.
        For example,
        <replaceable>install_dir</replaceable> is the directory where the SDK
        is installed, which is <filename>poky_sdk</filename> by default.
        <replaceable>target</replaceable> represents the target
        architecture (e.g. <filename>i586</filename>) and
        <replaceable>host</replaceable> represents the development system's
        architecture (e.g. <filename>x86_64</filename>).
    </para>
</section>

</appendix>
<!--
vim: expandtab tw=80 ts=4
-->