<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
"http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
<chapter id='usingpoky'>
<title>Using the Yocto Project</title>

    <para>
        This chapter describes common usage for the Yocto Project.
        The information is introductory in nature as other manuals in the Yocto Project
        provide more details on how to use the Yocto Project.
    </para>

<section id='usingpoky-build'>
    <title>Running a Build</title>

    <para>
        You can find general information on how to build an image using the 
        Yocto Project in the 
        "<ulink url='http://www.yoctoproject.org/docs/latest/yocto-project-qs/yocto-project-qs.html#building-image'>Building an Image</ulink>"
        section of The Yocto Project Quick Start.
        This section provides a summary of the build process and provides information
        for less obvious aspects of the build process.
    </para>

    <section id='build-overview'>
        <title>Build Overview</title>

        <para>
            The first thing you need to do is set up the Yocto Project build environment by sourcing
            the environment setup script as follows:
            <literallayout class='monospaced'>
     $ source oe-init-build-env [build_dir]
            </literallayout>
        </para>

        <para>
            The <filename>build_dir</filename> is optional and specifies the directory Yocto Project
            uses for the build.
            If you do not specify a build directory it defaults to <filename>build</filename>
            in your current working directory.
            A common practice is to use a different build directory for different targets. 
            For example, <filename>~/build/x86</filename> for a <filename>qemux86</filename>
            target, and <filename>~/build/arm</filename> for a <filename>qemuarm</filename> target.
            See <link linkend="structure-core-script">oe-init-build-env</link>
            for more information on this script.
        </para>

        <para>
            Once the Yocto Project build environment is set up, you can build a target using:
            <literallayout class='monospaced'>
     $ bitbake &lt;target&gt;
            </literallayout>
        </para>

        <para>
            The <filename>target</filename> is the name of the recipe you want to build. 
            Common targets are the images in <filename>meta/recipes-core/images</filename>,
            <filename>/meta/recipes-sato/images</filename>, etc. all found in the Yocto Project
            files.
            Or, the target can be the name of a recipe for a specific piece of software such as 
            <application>busybox</application>. 
            For more details about the images the Yocto Project supports, see the 
            "<link linkend="ref-images">Reference: Images</link>" appendix.
        </para>

        <note>
            Building an image without GNU Public License Version 3 (GPLv3) components is 
            only supported for minimal and base images.
            See the "<link linkend='ref-images'>Reference: Images</link>" appendix for more information.
        </note>
    </section>

    <section id='building-an-image-using-gpl-components'>
        <title>Building an Image Using GPL Components</title>

        <para>
            When building an image using GPL components, you need to maintain your original 
            settings and not switch back and forth applying different versions of the GNU
            Public License.  
            If you rebuild using different versions of GPL, dependency errors might occur
            due to some components not being rebuilt.
        </para>
    </section>
</section>

<section id='usingpoky-install'>
    <title>Installing and Using the Result</title>

    <para>
        Once an image has been built, it often needs to be installed. 
        The images and kernels built by the Yocto Project are placed in the build directory in 
        <filename class="directory">tmp/deploy/images</filename>. 
        For information on how to run pre-built images such as <filename>qemux86</filename> 
        and <filename>qemuarm</filename>, see the
        "<ulink url='http://www.yoctoproject.org/docs/latest/yocto-project-qs/yocto-project-qs.html#using-pre-built'>Using Pre-Built Binaries and QEMU</ulink>"
        section in The Yocto Project Quick Start.
        For information about how to install these images, see the documentation for your
        particular board/machine.
    </para>
</section>

<section id='usingpoky-debugging'>
    <title>Debugging Build Failures</title>

    <para>
        The exact method for debugging Yocto Project build failures depends on the nature of the 
        problem and on the system's area from which the bug originates. 
        Standard debugging practices such as comparison against the last 
        known working version with examination of the changes and the re-application of steps 
        to identify the one causing the problem are
        valid for Yocto Project just as they are for any other system. 
        Even though it is impossible to detail every possible potential failure, 
        this section provides some general tips to aid in debugging.
    </para>

    <section id='usingpoky-debugging-taskfailures'>
        <title>Task Failures</title>

        <para>The log file for shell tasks is available in 
            <filename>${WORKDIR}/temp/log.do_taskname.pid</filename>. 
            For example, the <filename>compile</filename> task for the QEMU minimal image for the x86
            machine (<filename>qemux86</filename>) might be 
            <filename>tmp/work/qemux86-poky-linux/core-image-minimal-1.0-r0/temp/log.do_compile.20830</filename>.
            To see what BitBake runs to generate that log, look at the corresponding 
            <filename>run.do_taskname.pid</filename> file located in the same directory.
        </para>

        <para>
            Presently, the output from Python tasks is sent directly to the console.
        </para>
    </section>

    <section id='usingpoky-debugging-taskrunning'>
        <title>Running Specific Tasks</title>

        <para>
            Any given package consists of a set of tasks.  
            The standard BitBake behavior in most cases is: <filename>fetch</filename>, 
            <filename>unpack</filename>, 
            <filename>patch</filename>, <filename>configure</filename>,
            <filename>compile</filename>, <filename>install</filename>, <filename>package</filename>,
            <filename>package_write</filename>, and <filename>build</filename>. 
            The default task is <filename>build</filename> and any tasks on which it depends 
            build first.
            Some tasks exist, such as <filename>devshell</filename>, that are not part of the
            default build chain.  
            If you wish to run a task that is not part of the default build chain, you can use the 
            <filename>-c</filename> option in BitBake as follows:
            <literallayout class='monospaced'>
     $ bitbake matchbox-desktop -c devshell
            </literallayout>
        </para>

        <para>
            If you wish to rerun a task, use the <filename>-f</filename> force option. 
            For example, the following sequence forces recompilation after changing files in the 
            working directory.
            <literallayout class='monospaced'>
     $ bitbake matchbox-desktop
               .
               .
        [make some changes to the source code in the working directory]
               .
               .
     $ bitbake matchbox-desktop -c compile -f
     $ bitbake matchbox-desktop
            </literallayout>
        </para>

        <para>
            This sequence first builds <filename>matchbox-desktop</filename> and then recompiles it.
            The last command reruns all tasks (basically the packaging tasks) after the compile.
            BitBake recognizes that the <filename>compile</filename> task was rerun and therefore 
            understands that the other tasks also need to be run again.
        </para>

        <para>
            You can view a list of tasks in a given package by running the
            <filename>listtasks</filename> task as follows:
            <literallayout class='monospaced'>
     $ bitbake matchbox-desktop -c listtasks
            </literallayout>
            The results are in the file <filename>${WORKDIR}/temp/log.do_listtasks</filename>.
        </para>
    </section>

    <section id='usingpoky-debugging-dependencies'>
        <title>Dependency Graphs</title>

        <para>
            Sometimes it can be hard to see why BitBake wants to build some other packages before a given 
            package you have specified.
            The <filename>bitbake -g targetname</filename> command creates the 
            <filename>depends.dot</filename> and <filename>task-depends.dot</filename> files 
            in the current directory. 
            These files show the package and task dependencies and are useful for debugging problems.
            You can use the <filename>bitbake -g -u depexp targetname</filename> command to 
            display the results in a more human-readable form.
        </para>
    </section>

    <section id='usingpoky-debugging-bitbake'>
        <title>General BitBake Problems</title>

        <para>
            You can see debug output from BitBake by using the <filename>-D</filename> option.
            The debug output gives more information about what BitBake
            is doing and the reason behind it. 
            Each <filename>-D</filename> option you use increases the logging level.
            The most common usage is <filename>-DDD</filename>.
        </para>

        <para>
            The output from <filename>bitbake -DDD -v targetname</filename> can reveal why
            BitBake chose a certain version of a package or why BitBake
            picked a certain provider.
            This command could also help you in a situation where you think BitBake did something 
            unexpected.
        </para>
    </section>

    <section id='usingpoky-debugging-buildfile'>
        <title>Building with No Dependencies</title>
        <para>
            If you really want to build a specific <filename>.bb</filename> file, you can use
            the command form <filename>bitbake -b &lt;somepath/somefile.bb&gt;</filename>. 
            This command form does not check for dependencies so you should use it
            only when you know its dependencies already exist. 
            You can also specify fragments of the filename.
            In this case, BitBake checks for a unique match.
        </para>
    </section>

    <section id='usingpoky-debugging-variables'>
        <title>Variables</title>
        <para>
            The <filename>-e</filename> option dumps the resulting environment for
            either the configuration (no package specified) or for a
            specific package when specified; or <filename>-b recipename</filename>
            to show the environment from parsing a single recipe file only.
        </para>
    </section>
    
    <section id='recipe-logging-mechanisms'>
        <title>Recipe Logging Mechanisms</title>
        <para>
            Best practices exist while writing recipes that both log build progress and 
            act on build conditions such as warnings and errors. 
            Both Python and Bash language bindings exist for the logging mechanism:
            <itemizedlist>
                <listitem><para><emphasis>Python:</emphasis> For Python functions, BitBake
                    supports several loglevels: <filename>bb.fatal</filename>, 
                    <filename>bb.error</filename>, <filename>bb.warn</filename>,
                    <filename>bb.note</filename>, <filename>bb.plain</filename>,
                    and <filename>bb.debug</filename>.</para></listitem>
                <listitem><para><emphasis>Bash:</emphasis> For Bash functions, the same set 
                    of loglevels exist and are accessed with a similar syntax:
                    <filename>bbfatal</filename>, <filename>bberror</filename>, 
                    <filename>bbwarn</filename>, <filename>bbnote</filename>, 
                    <filename>bbplain</filename>, and <filename>bbdebug</filename>.</para></listitem>
            </itemizedlist>
        </para>

        <para>
            For guidance on how logging is handled 
            in both Python and Bash recipes, see the 
            <filename>logging.bbclass</filename> file in the 
            <filename>meta/classes</filename> directory of the Yocto Project files.
        </para>

        <section id='logging-with-python'>
            <title>Logging With Python</title>
            <para>
                When creating recipes using Python and inserting code that handles build logs
                keep in mind the goal is to have informative logs while keeping the console as 
                "silent" as possible. 
                Also, if you want status messages in the log use the "debug" loglevel.
            </para>

            <para>
                Following is an example written in Python.
                The code handles logging for a function that determines the number of tasks 
                needed to be run:
                <literallayout class='monospaced'>
     python do_listtasks() {
         bb.debug(2, "Starting to figure out the task list")
         if noteworthy_condition:
             bb.note("There are 47 tasks to run")
         bb.debug(2, "Got to point xyz")
         if warning_trigger:
             bb.warn("Detected warning_trigger, this might be a problem later.")
         if recoverable_error:
             bb.error("Hit recoverable_error, you really need to fix this!")
         if fatal_error:
             bb.fatal("fatal_error detected, unable to print the task list")
         bb.plain("The tasks present are abc")
         bb.debug(2, "Finished figureing out the tasklist")
     }
                </literallayout>
            </para>
        </section>

        <section id='logging-with-bash'>
            <title>Logging With Bash</title>
            <para>
                When creating recipes using Bash and inserting code that handles build
                logs you have the same goals - informative with minimal console output. 
                The syntax you use for recipes written in Bash is similar to that of 
                recipes written in Python described in the previous section.
            </para>

            <para>
                Following is an example written in Bash.
                The code logs the progress of the <filename>do_my_function</filename> function.
                <literallayout class='monospaced'>
     do_my_function() {
         bbdebug 2 "Running do_my_function"
         if [ exceptional_condition ]; then
             bbnote "Hit exceptional_condition"
         fi
         bbdebug 2  "Got to point xyz"
         if [ warning_trigger ]; then
             bbwarn "Detected warning_trigger, this might cause a problem later."
         fi
         if [ recoverable_error ]; then
             bberror "Hit recoverable_error, correcting"
         fi
         if [ fatal_error ]; then
             bbfatal "fatal_error detected"
         fi
         bbdebug 2 "Completed do_my_function"
     }
                </literallayout>
            </para>
        </section>
    </section>
    
    <section id='usingpoky-debugging-others'>
        <title>Other Tips</title>

        <para>
            Here are some other tips that you might find useful:
            <itemizedlist>
                <listitem><para>When adding new packages, it is worth watching for 
                    undesirable items making their way into compiler command lines.
                    For example, you do not want references to local system files like 
                    <filename>/usr/lib/</filename> or <filename>/usr/include/</filename>.
                    </para></listitem>
                <listitem><para>If you want to remove the psplash boot splashscreen, 
                    add <filename>psplash=false</filename> to  the kernel command line.
                    Doing so prevents psplash from loading and thus allows you to see the console.
                    It is also possible to switch out of the splashscreen by 
                    switching the virtual console (e.g. Fn+Left or Fn+Right on a Zaurus).
                    </para></listitem>
            </itemizedlist>
        </para>
    </section>
</section>

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