summaryrefslogtreecommitdiffstats
path: root/documentation/dev-manual/dev-manual-start.xml
blob: 4dc2cfca002aeeef1228dfee2c3e5a18022aa8d6 (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
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
<!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; ] >

<chapter id='dev-manual-start'>

<title>Getting Started with the Yocto Project</title>

<para>
    This chapter introduces the Yocto Project and gives you an idea of what you need to get started.  
    You can find enough information to set up your development host and build or use images for 
    hardware supported by the Yocto Project by reading  
    <ulink url='&YOCTO_DOCS_QS_URL;'>
    The Yocto Project Quick Start</ulink>.
</para>

<para>
    The remainder of this chapter summarizes what is in the Yocto Project Quick Start and provides 
    some higher-level concepts you might want to consider.
</para>

<section id='introducing-the-yocto-project'>
    <title>Introducing the Yocto Project</title>

    <para>
        The Yocto Project is an open-source collaboration project focused on embedded Linux development.  
        The project currently provides a build system, which is sometimes referred to as "Poky",
        and provides various ancillary tools suitable for the embedded developer.  
        The Yocto Project also features the Sato reference User Interface, which is optimized for 
        stylus driven, low-resolution screens.
    </para>

    <para>
        You can use the Yocto Project build system, which uses 
        <ulink url='http://bitbake.berlios.de/manual/'>BitBake</ulink>, to develop complete Linux 
        images and associated user-space applications for architectures based on ARM, MIPS, PowerPC, 
        x86 and x86-64.  
        While the Yocto Project does not provide a strict testing framework,
        it does provide or generate for you artifacts that let you perform target-level and 
        emulated testing and debugging.  
        Additionally, if you are an <trademark class='trade'>Eclipse</trademark>
        IDE user, you can install an Eclipse Yocto Plug-in to allow you to 
        develop within that familiar environment.
    </para>
</section>

<section id='getting-setup'>
    <title>Getting Set Up</title>

    <para>
        Here is what you need to get set up to use the Yocto Project:
        <itemizedlist>
            <listitem><para><emphasis>Host System:</emphasis>  You should have a reasonably current 
                Linux-based host system.
                You will have the best results with a recent release of Fedora, 
                OpenSUSE, or Ubuntu as these releases are frequently tested against the Yocto Project
                and officially supported.  
                You should also have about 100 gigabytes of free disk space for building images.
                </para></listitem>
            <listitem><para><emphasis>Packages:</emphasis>  The Yocto Project requires certain packages
                exist on your development system (e.g. Python 2.6 or 2.7).  
                See "<ulink url='&YOCTO_DOCS_QS_URL;#packages'>The Packages</ulink>" 
                section in the Yocto Project Quick Start for the exact package
                requirements and the installation commands to install them 
                for the supported distributions.</para></listitem>
            <listitem id='local-yp-release'><para><emphasis>Yocto Project Release:</emphasis>  
                You need a release of the Yocto Project.  
                You can get set up with local 
                <link linkend='yocto-project-files'>Yocto Project Files</link> one of two ways 
                depending on whether you 
                are going to be contributing back into the Yocto Project source repository or not.
                <note>
                    Regardless of the method you use, this manual refers to the resulting 
                    hierarchical set of files as the "Yocto Project Files" or the "Yocto Project File
                    Structure."
                </note>
                <itemizedlist>
                    <listitem><para><emphasis>Tarball Extraction:</emphasis>  If you are not going to contribute 
                        back into the Yocto Project, you can simply download the Yocto Project release you want 
                        from the website’s <ulink url='&YOCTO_HOME_URL;/download'>download page</ulink>.
                        Once you have the tarball, just extract it into a directory of your choice.</para>
                        <para>For example, the following command extracts the Yocto Project &DISTRO; 
                        release tarball 
                        into the current working directory and sets up the Yocto Project file structure
                        with a top-level directory named <filename>&YOCTO_POKY;</filename>:
                        <literallayout class='monospaced'>
     $ tar xfj &YOCTO_POKY_TARBALL;
                        </literallayout></para>
                        <para>This method does not produce a Git repository. 
                        Instead, you simply end up with a local snapshot of the 
                        Yocto Project files that are based on the particular release in the 
                        tarball.</para></listitem>
                    <listitem><para><emphasis>Git Repository Method:</emphasis>  If you are going to be contributing
                        back into the Yocto Project or you simply want to keep up
                        with the latest developments, you should use Git commands to set up a local
                        Git repository of the Yocto Project Files.
                        Doing so creates a Git repository with a complete history of changes and allows 
                        you to easily submit your changes upstream to the project.
                        Because you cloned the repository, you have access to all the Yocto Project development
                        branches and tag names used in the upstream repository.</para>
                        <para>The following transcript shows how to clone the Yocto Project Files'  
                        Git repository into the current working directory.
                        <note>The name of the Yocto Project Files Git repository in the Yocto Project Files
                        Source Repositories is <filename>poky</filename>.
                        You can view the Yocto Project Source Repositories at
                        <ulink url='&YOCTO_GIT_URL;/cgit.cgi'></ulink></note>  
                        The command creates the local repository in a directory named <filename>poky</filename>.
                        For information on Git used within the Yocto Project, see the
                        "<link linkend='git'>Git</link>" section.
                        <literallayout class='monospaced'>
     $ git clone git://git.yoctoproject.org/poky
     Initialized empty Git repository in /home/scottrif/poky/.git/
     remote: Counting objects: 141863, done.
     remote: Compressing objects: 100% (38624/38624), done.
     remote: Total 141863 (delta 99661), reused 141816 (delta 99614)
     Receiving objects: 100% (141863/141863), 76.64 MiB | 126 KiB/s, done.
     Resolving deltas: 100% (99661/99661), done.
                        </literallayout></para>
                        <para>For another example of how to set up your own local Git repositories, see this
                        <ulink url='&YOCTO_WIKI_URL;/wiki/Transcript:_from_git_checkout_to_meta-intel_BSP'>
                        wiki page</ulink>, which describes how to create both <filename>poky</filename>
                        and <filename>meta-intel</filename> Git repositories.</para></listitem>
                </itemizedlist></para></listitem>
            <listitem id='local-kernel-files'><para><emphasis>Linux Yocto Kernel:</emphasis>  
                If you are going to be making modifications to a supported Linux Yocto kernel, you 
                need to establish local copies of the source.
                You can find Git repositories of supported Linux Yocto Kernels organized under
                "Yocto Linux Kernel" in the Yocto Project Source Repositories at
                <ulink url='&YOCTO_GIT_URL;/cgit.cgi'></ulink>.</para>
                <para>This setup involves creating a bare clone of the Linux Yocto kernel and then 
                copying that cloned repository.
                You can create the bare clone and the copy of the bare clone anywhere you like.
                For simplicity, it is recommended that you create these structures outside of the 
                Yocto Project Files Git repository.</para>
                <para>As an example, the following transcript shows how to create the bare clone
                of the <filename>linux-yocto-3.2</filename> kernel and then create a copy of 
                that clone.
                <note>When you have a local Linux Yocto kernel Git repository, you can 
                reference that repository rather than the upstream Git repository as 
                part of the <filename>clone</filename> command.
                Doing so can speed up the process.</note></para>
                <para>In the following example, the bare clone is named 
                <filename>linux-yocto-3.2.git</filename>, while the 
                copy is named <filename>my-linux-yocto-3.2-work</filename>: 
                <literallayout class='monospaced'>
     $ git clone --bare git://git.yoctoproject.org/linux-yocto-3.2 linux-yocto-3.2.git
     Initialized empty Git repository in /home/scottrif/linux-yocto-3.2.git/
     remote: Counting objects: 2468027, done.
     remote: Compressing objects: 100% (392255/392255), done.
     remote: Total 2468027 (delta 2071693), reused 2448773 (delta 2052498)
     Receiving objects: 100% (2468027/2468027), 530.46 MiB | 129 KiB/s, done.
     Resolving deltas: 100% (2071693/2071693), done.
                </literallayout></para>
                <para>Now create a clone of the bare clone just created:
                <literallayout class='monospaced'>
     $ git clone linux-yocto-3.2.git my-linux-yocto-3.2-work
     Initialized empty Git repository in /home/scottrif/my-linux-yocto-3.2-work/.git/
     Checking out files: 100% (37619/37619), done.
                </literallayout></para></listitem>
            <listitem id='poky-extras-repo'><para><emphasis>
                The <filename>poky-extras</filename> Git Repository</emphasis>:
                The <filename>poky-extras</filename> Git repository contains metadata needed 
                only if you are modifying and building the kernel image.
                In particular, it contains the kernel BitBake append (<filename>.bbappend</filename>)
                files that you 
                edit to point to your locally modified kernel source files and to build the kernel
                image. 
                Pointing to these local files is much more efficient than requiring a download of the 
                source files from upstream each time you make changes to the kernel.</para>
                <para>You can find the <filename>poky-extras</filename> Git Repository in the 
                "Yocto Metadata Layers" area of the Yocto Project Source Repositories at 
                <ulink url='&YOCTO_GIT_URL;/cgit.cgi'></ulink>.
                It is good practice to create this Git repository inside the Yocto Project
                files Git repository.</para>
                <para>Following is an example that creates the <filename>poky-extras</filename> Git 
                repository inside the Yocto Project files Git repository, which is named 
                <filename>poky</filename> in this case:
                <literallayout class='monospaced'>
     $ git clone git://git.yoctoproject.org/poky-extras poky-extras
     Initialized empty Git repository in /home/scottrif/poky/poky-extras/.git/
     remote: Counting objects: 618, done.
     remote: Compressing objects: 100% (558/558), done.
     remote: Total 618 (delta 192), reused 307 (delta 39)
     Receiving objects: 100% (618/618), 526.26 KiB | 111 KiB/s, done.
     Resolving deltas: 100% (192/192), done.
                </literallayout></para></listitem>
           <listitem><para id='supported-board-support-packages-(bsps)'><emphasis>Supported Board 
                Support Packages (BSPs):</emphasis>  
                The Yocto Project provides a layer called <filename>meta-intel</filename> and 
                it is maintained in its own separate Git repository.
                The <filename>meta-intel</filename> layer contains many supported 
                <ulink url='&YOCTO_DOCS_BSP_URL;#bsp-layers'>BSP Layers</ulink>.</para>
                <para>Similar considerations exist for setting up the <filename>meta-intel</filename>
                layer.  
                You can get set up for BSP development one of two ways: tarball extraction or
                with a local Git repository.
                It is a good idea to use the same method used to set up the Yocto Project Files.
                Regardless of the method you use, the Yocto Project uses the following BSP layer 
                naming scheme:
                <literallayout class='monospaced'> 
     meta-&lt;BSP_name&gt; 
                </literallayout>
                where &lt;BSP_name&gt; is the recognized BSP name.
                Here are some examples:
                <literallayout class='monospaced'>
     meta-crownbay
     meta-emenlow
     meta-n450
                </literallayout>
                See the
                "<ulink url='&YOCTO_DOCS_BSP_URL;#bsp-layers'>BSP Layers</ulink>"
                section in the Yocto Project Board Support Package (BSP) Developer's Guide for more
                information on BSP Layers.
                <itemizedlist>
                    <listitem><para><emphasis>Tarball Extraction:</emphasis>  You can download any released 
                        BSP tarball from the same 
                        <ulink url='&YOCTO_HOME_URL;/download'>download site</ulink> used 
                        to get the Yocto Project release.  
                        Once you have the tarball, just extract it into a directory of your choice.
                        Again, this method just produces a snapshot of the BSP layer in the form
                        of a hierarchical directory structure.</para></listitem>
                    <listitem><para><emphasis>Git Repository Method:</emphasis>  If you are working 
                        with a Yocto Project Files Git repository, you should also use this method 
                        to set up the <filename>meta-intel</filename> Git repository.
                        You can locate the <filename>meta-intel</filename> Git repository in the 
                        "Yocto Metadata Layers" area of the Yocto Project Source Repositories at
                        <ulink url='&YOCTO_GIT_URL;/cgit.cgi'></ulink>.</para>
                        <para>Typically, you set up the <filename>meta-intel</filename> Git repository inside
                        the Yocto Project Files Git repository.
                        For example, the following transcript shows the steps to clone the 
                        <filename>meta-intel</filename>
                        Git repository inside the <filename>poky</filename> Git repository.
                        <literallayout class='monospaced'>
     $ git clone git://git.yoctoproject.org/meta-intel.git
     Initialized empty Git repository in /home/scottrif/poky/meta-intel/.git/
     remote: Counting objects: 3380, done.
     remote: Compressing objects: 100% (2750/2750), done.
     remote: Total 3380 (delta 1689), reused 227 (delta 113)
     Receiving objects: 100% (3380/3380), 1.77 MiB | 128 KiB/s, done.
     Resolving deltas: 100% (1689/1689), done.
                        </literallayout></para>
                        <para>The same  
                        <ulink url='&YOCTO_WIKI_URL;/wiki/Transcript:_from_git_checkout_to_meta-intel_BSP'>
                        wiki page</ulink> referenced earlier covers how to 
                        set up the <filename>meta-intel</filename> Git repository.</para></listitem>
                </itemizedlist></para></listitem>
            <listitem><para><emphasis>Eclipse Yocto Plug-in:</emphasis>  If you are developing 
                applications using the Eclipse Integrated Development Environment (IDE),
                you will need this plug-in.  
                See the 
                "<ulink url='&YOCTO_DOCS_ADT_URL;#setting-up-the-eclipse-ide'>Setting up the Eclipse IDE</ulink>"
                section in the Yocto Application Development Toolkit (ADT) 
                User’s Guide for more information.</para></listitem>
        </itemizedlist>
    </para>
</section>

<section id='building-images'>
    <title>Building Images</title>

    <para>
        The build process creates an entire Linux distribution, including the toolchain, from source.  
        For more information on this topic, see the 
        "<ulink url='&YOCTO_DOCS_QS_URL;#building-image'>Building an Image</ulink>"
        section in the Yocto Project Quick Start.
    </para>

    <para>
        The build process is as follows:
        <orderedlist>
            <listitem><para>Make sure you have the Yocto Project files as described in the 
                previous section.</para></listitem>
            <listitem><para>Initialize the build environment by sourcing a build environment 
                script.</para></listitem>
            <listitem><para>Optionally ensure the <filename>conf/local.conf</filename> configuration file,
                which is found in the 
                <link linkend='yocto-project-build-directory'>Yocto Project Build Directory</link>, 
                is set up how you want it.  
                This file defines many aspects of the build environment including 
                the target machine architecture through the 
                <filename><ulink url='&YOCTO_DOCS_REF_URL;#var-MACHINE'>MACHINE</ulink></filename> variable, 
                the development machine's processor use through the 
                <filename><ulink url='&YOCTO_DOCS_REF_URL;#var-BB_NUMBER_THREADS'>BB_NUMBER_THREADS</ulink></filename> and 
                <filename><ulink url='&YOCTO_DOCS_REF_URL;#var-PARALLEL_MAKE'>PARALLEL_MAKE</ulink></filename> variables, and
                a centralized tarball download directory through the  
                <filename><ulink url='&YOCTO_DOCS_REF_URL;#var-DL_DIR'>DL_DIR</ulink></filename> variable.</para></listitem>
            <listitem><para>Build the image using the <filename>bitbake</filename> command.
                If you want information on BitBake, see the user manual at
                <ulink url='&OE_DOCS_URL;/bitbake/html'></ulink>.</para></listitem>
            <listitem><para>Run the image either on the actual hardware or using the QEMU 
                emulator.</para></listitem>
        </orderedlist>
    </para>
</section>

<section id='using-pre-built-binaries-and-qemu'>
    <title>Using Pre-Built Binaries and QEMU</title>

    <para>
        Another option you have to get started is to use pre-built binaries. 
        The Yocto Project provides many types of binaries with each release. 
        See the <ulink url='&YOCTO_DOCS_REF_URL;#ref-images'>Reference: Images</ulink>
        section for descriptions of the types of binaries that ship with a Yocto Project
        release.
    </para>

    <para>
        Using a pre-built binary is ideal for developing software applications to run on your 
        target hardware.  
        To do this, you need to be able to access the appropriate cross-toolchain tarball for 
        the architecture on which you are developing.  
        If you are using an SDK type image, the image ships with the complete toolchain native to 
        the architecture. 
        If you are not using an SDK type image, you need to separately download and 
        install the stand-alone Yocto Project cross-toolchain tarball.
    </para>

    <para>
        Regardless of the type of image you are using, you need to download the pre-built kernel 
        that you will boot in the QEMU emulator and then download and extract the target root 
        filesystem for your target machine’s architecture.
        You can get architecture-specific binaries and filesystem from
        <ulink url='&YOCTO_MACHINES_DL_URL;'>machines</ulink>.
        You can get stand-alone toolchains from
        <ulink url='&YOCTO_TOOLCHAIN_DL_URL;'>toolchains</ulink>.
        Once you have all your files, you set up the environment to emulate the hardware 
        by sourcing an environment setup script. 
        Finally, you start the QEMU emulator.
        You can find details on all these steps in the 
        "<ulink url='&YOCTO_DOCS_QS_URL;#using-pre-built'>Using Pre-Built Binaries and QEMU</ulink>"
        section of the Yocto Project Quick Start. 
    </para>

    <para> 
        Using QEMU to emulate your hardware can result in speed issues
        depending on the target and host architecture mix.
        For example, using the <filename>qemux86</filename> image in the emulator 
        on an Intel-based 32-bit (x86) host machine is fast because the target and 
        host architectures match.
        On the other hand, using the <filename>qemuarm</filename> image on the same Intel-based
        host can be slower.
        But, you still achieve faithful emulation of ARM-specific issues. 
    </para>

    <para>
        To speed things up, the QEMU images support using <filename>distcc</filename>
        to call a cross-compiler outside the emulated system. 
        If you used <filename>runqemu</filename> to start QEMU, and the
        <filename>distccd</filename> application is present on the host system, any 
        BitBake cross-compiling toolchain available from the build system is automatically
        used from within QEMU simply by calling <filename>distcc</filename>.
        You can accomplish this by defining the cross-compiler variable 
        (e.g. <filename>export CC="distcc"</filename>).
        Alternatively, if you are using a suitable SDK image or the appropriate
        stand-alone toolchain is present in <filename>/opt/poky</filename>,
        the toolchain is also automatically used.
    </para>

    <note>
        Several mechanisms exist that let you connect to the system running on the 
        QEMU emulator:
        <itemizedlist>
            <listitem><para>QEMU provides a framebuffer interface that makes standard 
                consoles available.</para></listitem>
            <listitem><para>Generally, headless embedded devices have a serial port.
                If so, you can configure the operating system of the running image
                to use that port to run a console. 
                The connection uses standard IP networking.</para></listitem>
            <listitem><para>The QEMU images have a Dropbear secure shell (ssh) server 
                that runs with the root password disabled.
                This allows you to use standard <filename>ssh</filename> and 
                <filename>scp</filename> commands.</para></listitem>
            <listitem><para>The QEMU images also contain an embedded Network File
                System (NFS) server that exports the image's root filesystem.
                This allows you to make the filesystem available to the 
                host.</para></listitem>
        </itemizedlist>
    </note>
</section>
</chapter>
<!--
vim: expandtab tw=80 ts=4
-->