| <!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='sdk-extensible'> |
| |
| <title>Using the Extensible SDK</title> |
| |
| <para> |
| This chapter describes the extensible SDK and how to use it. |
| The extensible SDK makes it easy to add new applications and libraries |
| to an image, modify the source for an existing component, test |
| changes on the target hardware, and ease integration into the rest of the |
| <ulink url='&YOCTO_DOCS_DEV_URL;#build-system-term'>OpenEmbedded build system</ulink>. |
| </para> |
| |
| <para> |
| Information in this chapter covers features that are not part of the |
| standard SDK. |
| In other words, the chapter presents information unique to the |
| extensible SDK only. |
| For information on how to use the standard SDK, see the |
| "<link linkend='sdk-using-the-standard-sdk'>Using the Standard SDK</link>" |
| chapter. |
| </para> |
| |
| <section id='sdk-setting-up-to-use-the-extensible-sdk'> |
| <title>Setting Up to Use the Extensible SDK</title> |
| |
| <para> |
| Getting set up to use the extensible SDK is identical to getting set |
| up to use the standard SDK. |
| You still need to locate and run the installer and then run the |
| environment setup script. |
| See the |
| "<link linkend='sdk-installing-the-sdk'>Installing the SDK</link>" |
| and the |
| "<link linkend='sdk-running-the-sdk-environment-setup-script'>Running the SDK Environment Setup Script</link>" |
| sections for general information. |
| The following items highlight the only differences between getting |
| set up to use the extensible SDK as compared to the standard SDK: |
| <itemizedlist> |
| <listitem><para><emphasis>Default Installation Directory:</emphasis> |
| By default, the extensible SDK installs into the |
| <filename>poky_sdk</filename> folder of your home directory. |
| As with the standard SDK, you can choose to install the |
| extensible SDK in any location when you run the installer. |
| However, unlike the standard SDK, the location you choose needs |
| to be writable for whichever users need to use the SDK, |
| since files will need to be written under that directory during |
| the normal course of operation. |
| </para></listitem> |
| <listitem><para><emphasis>Build Tools and Build System:</emphasis> |
| The extensible SDK installer performs additional tasks as |
| compared to the standard SDK installer. |
| The extensible SDK installer extracts build tools specific |
| to the SDK and the installer also prepares the internal build |
| system within the SDK. |
| Here is example output for running the extensible SDK |
| installer: |
| <literallayout class='monospaced'> |
| $ ./poky-glibc-x86_64-core-image-minimal-core2-64-toolchain-ext-2.1+snapshot.sh |
| Poky (Yocto Project Reference Distro) Extensible SDK installer version 2.1+snapshot |
| =================================================================================== |
| Enter target directory for SDK (default: ~/poky_sdk): |
| You are about to install the SDK to "/home/scottrif/poky_sdk". Proceed[Y/n]? Y |
| Extracting SDK......................................................................done |
| Setting it up... |
| Extracting buildtools... |
| Preparing build system... |
| done |
| SDK has been successfully set up and is ready to be used. |
| Each time you wish to use the SDK in a new shell session, you need to source the environment setup script e.g. |
| $ . /home/scottrif/poky_sdk/environment-setup-core2-64-poky-linux |
| </literallayout> |
| </para></listitem> |
| </itemizedlist> |
| </para> |
| |
| <para> |
| After installing the SDK, you need to run the SDK environment setup |
| script. |
| Here is the output: |
| <literallayout class='monospaced'> |
| $ source environment-setup-core2-64-poky-linux |
| SDK environment now set up; additionally you may now run devtool to perform development tasks. |
| Run devtool --help for further details. |
| </literallayout> |
| Once you run the environment setup script, you have |
| <filename>devtool</filename> available. |
| </para> |
| </section> |
| |
| <section id='using-devtool-in-your-sdk-workflow'> |
| <title>Using <filename>devtool</filename> in Your SDK Workflow</title> |
| |
| <para> |
| The cornerstone of the extensible SDK is a command-line tool |
| called <filename>devtool</filename>. |
| This tool provides a number of features that help |
| you build, test and package software within the extensible SDK, and |
| optionally integrate it into an image built by the OpenEmbedded build |
| system. |
| </para> |
| |
| <para> |
| The <filename>devtool</filename> command line is organized similarly |
| to |
| <ulink url='&YOCTO_DOCS_DEV_URL;#git'>Git</ulink> in that it has a |
| number of sub-commands for each function. |
| You can run <filename>devtool --help</filename> to see all the |
| commands. |
| </para> |
| |
| <para> |
| Two <filename>devtool</filename> subcommands that provide |
| entry-points into development are: |
| <itemizedlist> |
| <listitem><para><emphasis><filename>devtool add</filename></emphasis>: |
| Assists in adding new software to be built. |
| </para></listitem> |
| <listitem><para><emphasis><filename>devtool modify</filename></emphasis>: |
| Sets up an environment to enable you to modify the source of |
| an existing component. |
| </para></listitem> |
| </itemizedlist> |
| As with the OpenEmbedded build system, "recipes" represent software |
| packages within <filename>devtool</filename>. |
| When you use <filename>devtool add</filename>, a recipe is |
| automatically created. |
| When you use <filename>devtool modify</filename>, the specified |
| existing recipe is used in order to determine where to get the source |
| code and how to patch it. |
| In both cases, an environment is set up so that when you build the |
| recipe a source tree that is under your control is used in order to |
| allow you to make changes to the source as desired. |
| By default, both new recipes and the source go into a "workspace" |
| directory under the SDK. |
| </para> |
| |
| <para> |
| The remainder of this section presents the |
| <filename>devtool add</filename> and |
| <filename>devtool modify</filename> workflows. |
| </para> |
| |
| <section id='sdk-use-devtool-to-add-an-application'> |
| <title>Use <filename>devtool add</filename> to Add an Application</title> |
| |
| <para> |
| The <filename>devtool add</filename> command generates |
| a new recipe based on existing source code. |
| This command takes advantage of the |
| <ulink url='&YOCTO_DOCS_DEV_URL;#devtool-the-workspace-layer-structure'>workspace</ulink> |
| layer that many <filename>devtool</filename> commands |
| use. |
| The command is flexible enough to allow you to extract source |
| code into both the workspace or a separate local Git repository |
| and to use existing code that does not need to be extracted. |
| </para> |
| |
| <para> |
| Depending on your particular scenario, the arguments and options |
| you use with <filename>devtool add</filename> form different |
| combinations. |
| The following diagram shows common development flows |
| you would use with the <filename>devtool add</filename> |
| command: |
| </para> |
| |
| <para> |
| <imagedata fileref="figures/sdk-devtool-add-flow.png" align="center" /> |
| </para> |
| |
| <para> |
| <orderedlist> |
| <listitem><para><emphasis>Generating the New Recipe</emphasis>: |
| The top part of the flow shows three scenarios by which |
| you could use <filename>devtool add</filename> to |
| generate a recipe based on existing source code.</para> |
| |
| <para>In a shared development environment, it is |
| typical where other developers are responsible for |
| various areas of source code. |
| As a developer, you are probably interested in using |
| that source code as part of your development using |
| the Yocto Project. |
| All you need is access to the code, a recipe, and a |
| controlled area in which to do your work.</para> |
| |
| <para>Within the diagram, three possible scenarios |
| feed into the <filename>devtool add</filename> workflow: |
| <itemizedlist> |
| <listitem><para><emphasis>Left</emphasis>: |
| The left scenario represents a common situation |
| where the source code does not exist locally |
| and needs to be extracted. |
| In this situation, you just let it get |
| extracted to the default workspace - you do not |
| want it in some specific location outside of the |
| workspace. |
| Thus, everything you need will be located in the |
| workspace: |
| <literallayout class='monospaced'> |
| $ devtool add <replaceable>recipe fetchuri</replaceable> |
| </literallayout> |
| With this command, <filename>devtool</filename> |
| creates a recipe and an append file in the |
| workspace as well as extracts the upstream |
| source files into a local Git repository also |
| within the <filename>sources</filename> folder. |
| </para></listitem> |
| <listitem><para><emphasis>Middle</emphasis>: |
| The middle scenario also represents a situation where |
| the source code does not exist locally. |
| In this case, the code is again upstream |
| and needs to be extracted to some |
| local area - this time outside of the default |
| workspace. |
| As always, if required <filename>devtool</filename> creates |
| a Git repository locally during the extraction. |
| Furthermore, the first positional argument |
| <replaceable>srctree</replaceable> in this case |
| identifies where the |
| <filename>devtool add</filename> command |
| will locate the extracted code outside of the |
| workspace: |
| <literallayout class='monospaced'> |
| $ devtool add <replaceable>recipe srctree fetchuri</replaceable> |
| </literallayout> |
| In summary, the source code is pulled from |
| <replaceable>fetchuri</replaceable> and extracted |
| into the location defined by |
| <replaceable>srctree</replaceable> as a local |
| Git repository.</para> |
| |
| <para>Within workspace, <filename>devtool</filename> |
| creates both the recipe and an append file |
| for the recipe. |
| </para></listitem> |
| <listitem><para><emphasis>Right</emphasis>: |
| The right scenario represents a situation |
| where the source tree (srctree) has been |
| previously prepared outside of the |
| <filename>devtool</filename> workspace. |
| </para> |
| |
| <para>The following command names the recipe |
| and identifies where the existing source tree |
| is located: |
| <literallayout class='monospaced'> |
| $ devtool add <replaceable>recipe srctree</replaceable> |
| </literallayout> |
| The command examines the source code and creates |
| a recipe for it placing the recipe into the |
| workspace.</para> |
| |
| <para>Because the extracted source code already exists, |
| <filename>devtool</filename> does not try to |
| relocate it into the workspace - just the new |
| the recipe is placed in the workspace.</para> |
| |
| <para>Aside from a recipe folder, the command |
| also creates an append folder and places an initial |
| <filename>*.bbappend</filename> within. |
| </para></listitem> |
| </itemizedlist> |
| </para></listitem> |
| <listitem><para><emphasis>Edit the Recipe</emphasis>: |
| At this point, you can use <filename>devtool edit-recipe</filename> |
| to open up the editor as defined by the |
| <filename>$EDITOR</filename> environment variable |
| and modify the file: |
| <literallayout class='monospaced'> |
| $ devtool edit-recipe <replaceable>recipe</replaceable> |
| </literallayout> |
| From within the editor, you can make modifications to the |
| recipe that take affect when you build it later. |
| </para></listitem> |
| <listitem><para><emphasis>Build the Recipe or Rebuild the Image</emphasis>: |
| At this point in the flow, the next step you |
| take depends on what you are going to do with |
| the new code.</para> |
| <para>If you need to take the build output and eventually |
| move it to the target hardware, you would use |
| <filename>devtool build</filename>: |
| <literallayout class='monospaced'> |
| $ devtool build <replaceable>recipe</replaceable> |
| </literallayout></para> |
| <para>On the other hand, if you want an image to |
| contain the recipe's packages for immediate deployment |
| onto a device (e.g. for testing purposes), you can use |
| the <filename>devtool build-image</filename> command: |
| <literallayout class='monospaced'> |
| $ devtool build-image <replaceable>image</replaceable> |
| </literallayout> |
| </para></listitem> |
| <listitem><para><emphasis>Deploy the Build Output</emphasis>: |
| When you use the <filename>devtool build</filename> |
| command to build out your recipe, you probably want to |
| see if the resulting build output works as expected on target |
| hardware. |
| <note> |
| This step assumes you have a previously built |
| image that is already either running in QEMU or |
| running on actual hardware. |
| Also, it is assumed that for deployment of the image |
| to the target, SSH is installed in the image and if |
| the image is running on real hardware that you have |
| network access to and from your development machine. |
| </note> |
| You can deploy your build output to that target hardware by |
| using the <filename>devtool deploy-target</filename> command: |
| <literallayout class='monospaced'> |
| $ devtool deploy-target <replaceable>recipe target</replaceable> |
| </literallayout> |
| The <replaceable>target</replaceable> is a live target machine |
| running as an SSH server.</para> |
| |
| <para>You can, of course, also deploy the image you build |
| using the <filename>devtool build-image</filename> command |
| to actual hardware. |
| However, <filename>devtool</filename> does not provide a |
| specific command that allows you to do this. |
| </para></listitem> |
| <listitem><para><emphasis>Optionally Update the Recipe With Patch Files</emphasis>: |
| Once you are satisfied with the recipe, if you have made |
| any changes to the source tree that you want to have |
| applied by the recipe, you need to generate patches |
| from those changes. |
| You do this before moving the recipe |
| to its final layer and cleaning up the workspace area |
| <filename>devtool</filename> uses. |
| This optional step is especially relevant if you are |
| using or adding third-party software.</para> |
| <para>To convert commits created using Git to patch files, |
| use the <filename>devtool update-recipe</filename> command. |
| <note> |
| Any changes you want to turn into patches must be |
| committed to the Git repository in the source tree. |
| </note> |
| <literallayout class='monospaced'> |
| $ devtool update-recipe <replaceable>recipe</replaceable> |
| </literallayout> |
| </para></listitem> |
| <listitem><para><emphasis>Move the Recipe to its Permanent Layer</emphasis>: |
| Before cleaning up the workspace, you need to move the |
| final recipe to its permanent layer. |
| You must do this before using the |
| <filename>devtool reset</filename> command if you want to |
| retain the recipe. |
| </para></listitem> |
| <listitem><para><emphasis>Reset the Recipe</emphasis>: |
| As a final step, you can restore the state such that |
| standard layers and the upstream source is used to build |
| the recipe rather than data in the workspace. |
| To reset the recipe, use the <filename>devtool reset</filename> |
| command: |
| <literallayout class='monospaced'> |
| $ devtool reset <replaceable>recipe</replaceable> |
| </literallayout> |
| </para></listitem> |
| </orderedlist> |
| </para> |
| </section> |
| |
| <section id='sdk-devtool-use-devtool-modify-to-modify-the-source-of-an-existing-component'> |
| <title>Use <filename>devtool modify</filename> to Modify the Source of an Existing Component</title> |
| |
| <para> |
| The <filename>devtool modify</filename> command prepares the |
| way to work on existing code that already has a recipe in |
| place. |
| The command is flexible enough to allow you to extract code, |
| specify the existing recipe, and keep track of and gather any |
| patch files from other developers that are |
| associated with the code. |
| </para> |
| |
| <para> |
| Depending on your particular scenario, the arguments and options |
| you use with <filename>devtool modify</filename> form different |
| combinations. |
| The following diagram shows common development flows |
| you would use with the <filename>devtool modify</filename> |
| command: |
| </para> |
| |
| <para> |
| <imagedata fileref="figures/sdk-devtool-modify-flow.png" align="center" /> |
| </para> |
| |
| <para> |
| <orderedlist> |
| <listitem><para><emphasis>Preparing to Modify the Code</emphasis>: |
| The top part of the flow shows three scenarios by which |
| you could use <filename>devtool modify</filename> to |
| prepare to work on source files. |
| Each scenario assumes the following: |
| <itemizedlist> |
| <listitem><para>The recipe exists in some layer external |
| to the <filename>devtool</filename> workspace. |
| </para></listitem> |
| <listitem><para>The source files exist upstream in an |
| un-extracted state or locally in a previously |
| extracted state. |
| </para></listitem> |
| </itemizedlist> |
| The typical situation is where another developer has |
| created some layer for use with the Yocto Project and |
| their recipe already resides in that layer. |
| Furthermore, their source code is readily available |
| either upstream or locally. |
| <itemizedlist> |
| <listitem><para><emphasis>Left</emphasis>: |
| The left scenario represents a common situation |
| where the source code does not exist locally |
| and needs to be extracted. |
| In this situation, the source is extracted |
| into the default workspace location. |
| The recipe, in this scenario, is in its own |
| layer outside the workspace |
| (i.e. |
| <filename>meta-</filename><replaceable>layername</replaceable>). |
| </para> |
| |
| <para>The following command identifies the recipe |
| and by default extracts the source files: |
| <literallayout class='monospaced'> |
| $ devtool modify <replaceable>recipe</replaceable> |
| </literallayout> |
| Once <filename>devtool</filename>locates the recipe, |
| it uses the |
| <ulink url='&YOCTO_DOCS_REF_URL;#var-SRC_URI'><filename>SRC_URI</filename></ulink> |
| variable to locate the source code and |
| any local patch files from other developers are |
| located. |
| <note> |
| You cannot provide an URL for |
| <replaceable>srctree</replaceable> when using the |
| <filename>devtool modify</filename> command. |
| </note> |
| With this scenario, however, since no |
| <replaceable>srctree</replaceable> argument exists, the |
| <filename>devtool modify</filename> command by default |
| extracts the source files to a Git structure. |
| Furthermore, the location for the extracted source is the |
| default area within the workspace. |
| The result is that the command sets up both the source |
| code and an append file within the workspace with the |
| recipe remaining in its original location. |
| </para></listitem> |
| <listitem><para><emphasis>Middle</emphasis>: |
| The middle scenario represents a situation where |
| the source code also does not exist locally. |
| In this case, the code is again upstream |
| and needs to be extracted to some |
| local area as a Git repository. |
| The recipe, in this scenario, is again in its own |
| layer outside the workspace.</para> |
| |
| <para>The following command tells |
| <filename>devtool</filename> what recipe with |
| which to work and, in this case, identifies a local |
| area for the extracted source files that is outside |
| of the default workspace: |
| <literallayout class='monospaced'> |
| $ devtool modify <replaceable>recipe srctree</replaceable> |
| </literallayout> |
| As with all extractions, the command uses |
| the recipe's <filename>SRC_URI</filename> to locate the |
| source files. |
| Once the files are located, the command by default |
| extracts them. |
| Providing the <replaceable>srctree</replaceable> |
| argument instructs <filename>devtool</filename> where |
| place the extracted source.</para> |
| |
| <para>Within workspace, <filename>devtool</filename> |
| creates an append file for the recipe. |
| The recipe remains in its original location but |
| the source files are extracted to the location you |
| provided with <replaceable>srctree</replaceable>. |
| </para></listitem> |
| <listitem><para><emphasis>Right</emphasis>: |
| The right scenario represents a situation |
| where the source tree |
| (<replaceable>srctree</replaceable>) exists as a |
| previously extracted Git structure outside of |
| the <filename>devtool</filename> workspace. |
| In this example, the recipe also exists |
| elsewhere in its own layer. |
| </para> |
| |
| <para>The following command tells |
| <filename>devtool</filename> the recipe |
| with which to work, uses the "-n" option to indicate |
| source does not need to be extracted, and uses |
| <replaceable>srctree</replaceable> to point to the |
| previously extracted source files: |
| <literallayout class='monospaced'> |
| $ devtool modify -n <replaceable>recipe srctree</replaceable> |
| </literallayout> |
| </para> |
| |
| <para>Once the command finishes, it creates only |
| an append file for the recipe in the workspace. |
| The recipe and the source code remain in their |
| original locations. |
| </para></listitem> |
| </itemizedlist> |
| </para></listitem> |
| <listitem><para><emphasis>Edit the Source</emphasis>: |
| Once you have used the <filename>devtool modify</filename> |
| command, you are free to make changes to the source |
| files. |
| You can use any editor you like to make and save |
| your source code modifications. |
| </para></listitem> |
| <listitem><para><emphasis>Build the Recipe</emphasis>: |
| Once you have updated the source files, you can build |
| the recipe. |
| </para></listitem> |
| <listitem><para><emphasis>Deploy the Build Output</emphasis>: |
| When you use the <filename>devtool build</filename> |
| command to build out your recipe, you probably want to see |
| if the resulting build output works as expected on target |
| hardware. |
| <note> |
| This step assumes you have a previously built |
| image that is already either running in QEMU or |
| running on actual hardware. |
| Also, it is assumed that for deployment of the image |
| to the target, SSH is installed in the image and if |
| the image is running on real hardware that you have |
| network access to and from your development machine. |
| </note> |
| You can deploy your build output to that target hardware by |
| using the <filename>devtool deploy-target</filename> command: |
| <literallayout class='monospaced'> |
| $ devtool deploy-target <replaceable>recipe target</replaceable> |
| </literallayout> |
| The <replaceable>target</replaceable> is a live target machine |
| running as an SSH server.</para> |
| |
| <para>You can, of course, also deploy the image you build |
| using the <filename>devtool build-image</filename> command |
| to actual hardware. |
| However, <filename>devtool</filename> does not provide a |
| specific command that allows you to do this. |
| </para></listitem> |
| <listitem><para><emphasis>Optionally Create Patch Files for Your Changes</emphasis>: |
| After you have debugged your changes, you can |
| use <filename>devtool update-recipe</filename> to |
| generate patch files for all the commits you have |
| made. |
| <note> |
| Patch files are generated only for changes |
| you have committed. |
| </note> |
| <literallayout class='monospaced'> |
| $ devtool update-recipe <replaceable>recipe</replaceable> |
| </literallayout> |
| By default, the |
| <filename>devtool update-recipe</filename> command |
| creates the patch files in a folder named the same |
| as the recipe beneath the folder in which the recipe |
| resides, and updates the recipe's |
| <ulink url='&YOCTO_DOCS_REF_URL;#var-SRC_URI'><filename>SRC_URI</filename></ulink> |
| statement to point to the generated patch files. |
| <note> |
| You can use the |
| "--append <replaceable>LAYERDIR</replaceable>" |
| option to cause the command to create append files |
| in a specific layer rather than the default |
| recipe layer. |
| </note> |
| </para></listitem> |
| <listitem><para><emphasis>Restore the Workspace</emphasis>: |
| The <filename>devtool reset</filename> restores the |
| state so that standard layers and upstream sources are |
| used to build the recipe rather than what is in the |
| workspace. |
| <literallayout class='monospaced'> |
| $ devtool reset <replaceable>recipe</replaceable> |
| </literallayout> |
| </para></listitem> |
| </orderedlist> |
| </para> |
| </section> |
| </section> |
| |
| <section id='sdk-a-closer-look-at-devtool-add'> |
| <title>A Closer Look at <filename>devtool add</filename></title> |
| |
| <para> |
| The <filename>devtool add</filename> command automatically creates a |
| recipe based on the source tree with which you provide it. |
| Currently, the command has support for the following: |
| <itemizedlist> |
| <listitem><para> |
| Autotools (<filename>autoconf</filename> and |
| <filename>automake</filename>) |
| </para></listitem> |
| <listitem><para> |
| CMake |
| </para></listitem> |
| <listitem><para> |
| Scons |
| </para></listitem> |
| <listitem><para> |
| <filename>qmake</filename> |
| </para></listitem> |
| <listitem><para> |
| Plain <filename>Makefile</filename> |
| </para></listitem> |
| <listitem><para> |
| Out-of-tree kernel module |
| </para></listitem> |
| <listitem><para> |
| Binary package (i.e. "-b" option) |
| </para></listitem> |
| <listitem><para> |
| Node.js module through |
| <filename>npm</filename> |
| </para></listitem> |
| <listitem><para> |
| Python modules that use <filename>setuptools</filename> |
| or <filename>distutils</filename> |
| </para></listitem> |
| </itemizedlist> |
| </para> |
| |
| <para> |
| Apart from binary packages, the determination of how a source tree |
| should be treated is automatic based on the files present within |
| that source tree. |
| For example, if a <filename>CMakeLists.txt</filename> file is found, |
| then the source tree is assumed to be using |
| CMake and is treated accordingly. |
| <note> |
| In most cases, you need to edit the automatically generated |
| recipe in order to make it build properly. |
| Typically, you would go through several edit and build cycles |
| until you can build the recipe. |
| Once the recipe can be built, you could use possible further |
| iterations to test the recipe on the target device. |
| </note> |
| </para> |
| |
| <para> |
| The remainder of this section covers specifics regarding how parts |
| of the recipe are generated. |
| </para> |
| |
| <section id='sdk-name-and-version'> |
| <title>Name and Version</title> |
| |
| <para> |
| If you do not specify a name and version on the command |
| line, <filename>devtool add</filename> attempts to determine |
| the name and version of the software being built from |
| various metadata within the source tree. |
| Furthermore, the command sets the name of the created recipe |
| file accordingly. |
| If the name or version cannot be determined, the |
| <filename>devtool add</filename> command prints an error and |
| you must re-run the command with both the name and version |
| or just the name or version specified. |
| </para> |
| |
| <para> |
| Sometimes the name or version determined from the source tree |
| might be incorrect. |
| For such a case, you must reset the recipe: |
| <literallayout class='monospaced'> |
| $ devtool reset -n <replaceable>recipename</replaceable> |
| </literallayout> |
| After running the <filename>devtool reset</filename> command, |
| you need to run <filename>devtool add</filename> again and |
| provide the name or the version. |
| </para> |
| </section> |
| |
| <section id='sdk-dependency-detection-and-mapping'> |
| <title>Dependency Detection and Mapping</title> |
| |
| <para> |
| The <filename>devtool add</filename> command attempts to |
| detect build-time dependencies and map them to other recipes |
| in the system. |
| During this mapping, the command fills in the names of those |
| recipes in the |
| <ulink url='&YOCTO_DOCS_REF_URL;#var-DEPENDS'><filename>DEPENDS</filename></ulink> |
| value within the recipe. |
| If a dependency cannot be mapped, then a comment is placed in |
| the recipe indicating such. |
| The inability to map a dependency might be caused because the |
| naming is not recognized or because the dependency simply is |
| not available. |
| For cases where the dependency is not available, you must use |
| the <filename>devtool add</filename> command to add an |
| additional recipe to satisfy the dependency and then come |
| back to the first recipe and add its name to |
| <filename>DEPENDS</filename>. |
| </para> |
| |
| <para> |
| If you need to add runtime dependencies, you can do so by |
| adding the following to your recipe: |
| <literallayout class='monospaced'> |
| RDEPENDS_${PN} += "dependency1 dependency2 ..." |
| </literallayout> |
| <note> |
| The <filename>devtool add</filename> command often cannot |
| distinguish between mandatory and optional dependencies. |
| Consequently, some of the detected dependencies might |
| in fact be optional. |
| When in doubt, consult the documentation or the configure |
| script for the software the recipe is building for further |
| details. |
| In some cases, you might find you can substitute the |
| dependency for an option to disable the associated |
| functionality passed to the configure script. |
| </note> |
| </para> |
| </section> |
| |
| <section id='sdk-license-detection'> |
| <title>License Detection</title> |
| |
| <para> |
| The <filename>devtool add</filename> command attempts to |
| determine if the software you are adding is able to be |
| distributed under a common open-source license and sets the |
| <ulink url='&YOCTO_DOCS_REF_URL;#var-LICENSE'><filename>LICENSE</filename></ulink> |
| value accordingly. |
| You should double-check this value against the documentation |
| or source files for the software you are building and update |
| that <filename>LICENSE</filename> value if necessary. |
| </para> |
| |
| <para> |
| The <filename>devtool add</filename> command also sets the |
| <ulink url='&YOCTO_DOCS_REF_URL;#var-LIC_FILES_CHKSUM'><filename>LIC_FILES_CHKSUM</filename></ulink> |
| value to point to all files that appear to be license-related. |
| However, license statements often appear in comments at the top |
| of source files or within documentation. |
| Consequently, you might need to amend the |
| <filename>LIC_FILES_CHKSUM</filename> variable to point to one |
| or more of those comments if present. |
| Setting <filename>LIC_FILES_CHKSUM</filename> is particularly |
| important for third-party software. |
| The mechanism attempts to ensure correct licensing should you |
| upgrade the recipe to a newer upstream version in future. |
| Any change in licensing is detected and you receive an error |
| prompting you to check the license text again. |
| </para> |
| |
| <para> |
| If the <filename>devtool add</filename> command cannot |
| determine licensing information, the |
| <filename>LICENSE</filename> value is set to "CLOSED" and the |
| <filename>LIC_FILES_CHKSUM</filename> vaule remains unset. |
| This behavior allows you to continue with development but is |
| unlikely to be correct in all cases. |
| Consequently, you should check the documentation or source |
| files for the software you are building to determine the actual |
| license. |
| </para> |
| </section> |
| |
| <section id='sdk-adding-makefile-only-software'> |
| <title>Adding Makefile-Only Software</title> |
| |
| <para> |
| The use of <filename>make</filename> by itself is very common |
| in both proprietary and open source software. |
| Unfortunately, Makefiles are often not written with |
| cross-compilation in mind. |
| Thus, <filename>devtool add</filename> often cannot do very |
| much to ensure that these Makefiles build correctly. |
| It is very common, for example, to explicitly call |
| <filename>gcc</filename> instead of using the |
| <filename>CC</filename> variable. |
| Usually, in a cross-compilation environment, |
| <filename>gcc</filename> is the compiler for the build host |
| and the cross-compiler is named something similar to |
| <filename>arm-poky-linux-gnueabi-gcc</filename> and might |
| require some arguments (e.g. to point to the associated sysroot |
| for the target machine). |
| </para> |
| |
| <para> |
| When writing a recipe for Makefile-only software, keep the |
| following in mind: |
| <itemizedlist> |
| <listitem><para> |
| You probably need to patch the Makefile to use |
| variables instead of hardcoding tools within the |
| toolchain such as <filename>gcc</filename> and |
| <filename>g++</filename>. |
| </para></listitem> |
| <listitem><para> |
| The environment in which <filename>make</filename> runs |
| is set up with various standard variables for |
| compilation (e.g. <filename>CC</filename>, |
| <filename>CXX</filename>, and so forth) in a similar |
| manner to the environment set up by the SDK's |
| environment setup script. |
| One easy way to see these variables is to run the |
| <filename>devtool build</filename> command on the |
| recipe and then look in |
| <filename>oe-logs/run.do_compile</filename>. |
| Towards the top of this file you will see a list of |
| environment variables that are being set. |
| You can take advantage of these variables within the |
| Makefile. |
| </para></listitem> |
| <listitem><para> |
| If the Makefile sets a default for a variable using "=", |
| that default overrides the value set in the environment, |
| which is usually not desirable. |
| In this situation, you can either patch the Makefile |
| so it sets the default using the "?=" operator, or |
| you can alternatively force the value on the |
| <filename>make</filename> command line. |
| To force the value on the command line, add the |
| variable setting to |
| <ulink url='&YOCTO_DOCS_REF_URL;#var-EXTRA_OEMAKE'><filename>EXTRA_OEMAKE</filename></ulink> |
| within the recipe as follows: |
| <literallayout class='monospaced'> |
| EXTRA_OEMAKE += "'CC=${CC}' 'CXX=${CXX}'" |
| </literallayout> |
| In the above example, single quotes are used around the |
| variable settings as the values are likely to contain |
| spaces because required default options are passed to |
| the compiler. |
| </para></listitem> |
| <listitem><para> |
| Hardcoding paths inside Makefiles is often problematic |
| in a cross-compilation environment. |
| This is particularly true because those hardcoded paths |
| often point to locations on the build host and thus |
| will either be read-only or will introduce |
| contamination into the cross-compilation by virtue of |
| being specific to the build host rather than the target. |
| Patching the Makefile to use prefix variables or other |
| path variables is usually the way to handle this. |
| </para></listitem> |
| <listitem><para> |
| Sometimes a Makefile runs target-specific commands such |
| as <filename>ldconfig</filename>. |
| For such cases, you might be able to simply apply |
| patches that remove these commands from the Makefile. |
| </para></listitem> |
| </itemizedlist> |
| </para> |
| </section> |
| |
| <section id='sdk-adding-native-tools'> |
| <title>Adding Native Tools</title> |
| |
| <para> |
| Often, you need to build additional tools that run on the |
| build host system as opposed to the target. |
| You should indicate this using one of the following methods |
| when you run <filename>devtool add</filename>: |
| <itemizedlist> |
| <listitem><para> |
| Specify the name of the recipe such that it ends |
| with "-native". |
| Specifying the name like this produces a recipe that |
| only builds for the build host. |
| </para></listitem> |
| <listitem><para> |
| Specify the "‐‐also-native" option with the |
| <filename>devtool add</filename> command. |
| Specifying this option creates a recipe file that still |
| builds for the target but also creates a variant with |
| a "-native" suffix that builds for the build host. |
| </para></listitem> |
| </itemizedlist> |
| <note> |
| If you need to add a tool that is shipped as part of a |
| source tree that builds code for the target, you can |
| typically accomplish this by building the native and target |
| parts separately rather than within the same compilation |
| process. |
| Realize though that with the "‐‐also-native" option, you |
| can add the tool using just one recipe file. |
| </note> |
| </para> |
| </section> |
| |
| <section id='sdk-adding-node-js-modules'> |
| <title>Adding Node.js Modules</title> |
| |
| <para> |
| You can use the <filename>devtool add</filename> command in the |
| following form to add Node.js modules: |
| <literallayout class='monospaced'> |
| $ devtool add "npm://registry.npmjs.org;name=forever;version=0.15.1" |
| </literallayout> |
| The name and version parameters are mandatory. |
| Lockdown and shrinkwrap files are generated and pointed to by |
| the recipe in order to freeze the version that is fetched for |
| the dependencies according to the first time. |
| This also saves checksums that are verified on future fetches. |
| Together, these behaviors ensure the reproducibility and |
| integrity of the build. |
| <note><title>Notes</title> |
| <itemizedlist> |
| <listitem><para> |
| You must use quotes around the URL. |
| The <filename>devtool add</filename> does not require |
| the quotes, but the shell considers ";" as a splitter |
| between multiple commands. |
| Thus, without the quotes, |
| <filename>devtool add</filename> does not receive the |
| other parts, which results in several "command not |
| found" errors. |
| </para></listitem> |
| <listitem><para> |
| In order to support adding |
| Node.js modules, a |
| <filename>nodejs</filename> recipe must be part of your |
| SDK in order to provide Node.js |
| itself. |
| </para></listitem> |
| </itemizedlist> |
| </note> |
| </para> |
| </section> |
| </section> |
| |
| <section id='sdk-working-with-recipes'> |
| <title>Working With Recipes</title> |
| |
| <para> |
| When building a recipe with <filename>devtool build</filename> the |
| typical build progression is as follows: |
| <orderedlist> |
| <listitem><para> |
| Fetch the source |
| </para></listitem> |
| <listitem><para> |
| Unpack the source |
| </para></listitem> |
| <listitem><para> |
| Configure the source |
| </para></listitem> |
| <listitem><para> |
| Compiling the source |
| </para></listitem> |
| <listitem><para> |
| Install the build output |
| </para></listitem> |
| <listitem><para> |
| Package the installed output |
| </para></listitem> |
| </orderedlist> |
| For recipes in the workspace, fetching and unpacking is disabled |
| as the source tree has already been prepared and is persistent. |
| Each of these build steps is defined as a function, usually with a |
| "do_" prefix. |
| These functions are typically shell scripts but can instead be written |
| in Python. |
| </para> |
| |
| <para> |
| If you look at the contents of a recipe, you will see that the |
| recipe does not include complete instructions for building the |
| software. |
| Instead, common functionality is encapsulated in classes inherited |
| with the <filename>inherit</filename> directive, leaving the recipe |
| to describe just the things that are specific to the software to be |
| built. |
| A <ulink url='ref-classes-base'><filename>base</filename></ulink> |
| class exists that is implicitly inherited by all recipes and provides |
| the functionality that most typical recipes need. |
| </para> |
| |
| <para> |
| The remainder of this section presents information useful when |
| working with recipes. |
| </para> |
| |
| <section id='sdk-finding-logs-and-work-files'> |
| <title>Finding Logs and Work Files</title> |
| |
| <para> |
| When you are debugging a recipe that you previously created using |
| <filename>devtool add</filename> or whose source you are modifying |
| by using the <filename>devtool modify</filename> command, after |
| the first run of <filename>devtool build</filename>, you will |
| find some symbolic links created within the source tree: |
| <filename>oe-logs</filename>, which points to the directory in |
| which log files and run scripts for each build step are created |
| and <filename>oe-workdir</filename>, which points to the temporary |
| work area for the recipe. |
| You can use these links to get more information on what is |
| happening at each build step. |
| </para> |
| |
| <para> |
| These locations under <filename>oe-workdir</filename> are |
| particularly useful: |
| <itemizedlist> |
| <listitem><para><filename>image/</filename>: |
| Contains all of the files installed at the |
| <ulink url='&YOCTO_DOCS_REF_URL;ref-tasks-install'><filename>do_install</filename></ulink> |
| stage. |
| Within a recipe, this directory is referred to by the |
| expression |
| <filename>${</filename><ulink url='&YOCTO_DOCS_REF_URL;#var-D'><filename>D</filename></ulink><filename>}</filename>. |
| </para></listitem> |
| <listitem><para><filename>sysroot-destdir/</filename>: |
| Contains a subset of files installed within |
| <filename>do_install</filename> that have been put into the |
| shared sysroot. |
| For more information, see the |
| "<link linkend='sdk-sharing-files-between-recipes'>Sharing Files Between Recipes</link>" |
| section. |
| </para></listitem> |
| <listitem><para><filename>packages-split/</filename>: |
| Contains subdirectories for each package produced by the |
| recipe. |
| For more information, see the |
| "<link linkend='sdk-packaging'>Packaging</link>" section. |
| </para></listitem> |
| </itemizedlist> |
| </para> |
| </section> |
| |
| <section id='sdk-setting-configure-arguments'> |
| <title>Setting Configure Arguments</title> |
| |
| <para> |
| If the software your recipe is building uses GNU autoconf, |
| then a fixed set of arguments is passed to it to enable |
| cross-compilation plus any extras specified by |
| <ulink url='&YOCTO_DOCS_REF_URL;#var-EXTRA_OECONF'><filename>EXTRA_OECONF</filename></ulink> |
| set within the recipe. |
| If you wish to pass additional options, add them to |
| <filename>EXTRA_OECONF</filename>. |
| Other supported build tools have similar variables |
| (e.g. |
| <ulink url='&YOCTO_DOCS_REF_URL;#var-EXTRA_OECMAKE'><filename>EXTRA_OECMAKE</filename></ulink> |
| for CMake, |
| <ulink url='&YOCTO_DOCS_REF_URL;#var-EXTRA_OESCONS'><filename>EXTRA_OESCONS</filename></ulink> |
| for Scons, and so forth). |
| If you need to pass anything on the <filename>make</filename> |
| command line, you can use <filename>EXTRA_OEMAKE</filename> to do |
| so. |
| </para> |
| |
| <para> |
| You can use the <filename>devtool configure-help</filename> command |
| to help you set the arguments listed in the previous paragraph. |
| The command determines the exact options being passed, and shows |
| them to you along with any custom arguments specified through |
| <filename>EXTRA_OECONF</filename>. |
| If applicable, the command also shows you the output of the |
| configure script's "‐‐help" option as a reference. |
| </para> |
| </section> |
| |
| <section id='sdk-sharing-files-between-recipes'> |
| <title>Sharing Files Between Recipes</title> |
| |
| <para> |
| Recipes often need to use files provided by other recipes on |
| the build host. |
| For example, an application linking to a common library needs |
| access to the library itself and its associated headers. |
| The way this access is accomplished within the extensible SDK is |
| through the sysroot. |
| One sysroot exists per "machine" for which the SDK is being built. |
| In practical terms, this means a sysroot exists for the target |
| machine, and a sysroot exists for the build host. |
| </para> |
| |
| <para> |
| Recipes should never write files directly into the sysroot. |
| Instead, files should be installed into standard locations |
| during the |
| <ulink url='&YOCTO_DOCS_REF_URL;#ref-tasks-install'><filename>do_install</filename></ulink> |
| task within the |
| <filename>${</filename><ulink url='&YOCTO_DOCS_REF_URL;#var-D'><filename>D</filename></ulink><filename>}</filename> |
| directory. |
| A subset of these files automatically go into the sysroot. |
| The reason for this limitation is that almost all files that go |
| into the sysroot are cataloged in manifests in order to ensure |
| they can be removed later when a recipe is modified or removed. |
| Thus, the sysroot is able to remain free from stale files. |
| </para> |
| </section> |
| |
| <section id='sdk-packaging'> |
| <title>Packaging</title> |
| |
| <para> |
| Packaging is not always particularly relevant within the |
| extensible SDK. |
| However, if you examine how build output gets into the final image |
| on the target device, it is important to understand packaging |
| because the contents of the image are expressed in terms of |
| packages and not recipes. |
| </para> |
| |
| <para> |
| During the |
| <ulink url='&YOCTO_DOCS_REF_URL;#ref-tasks-package'><filename>do_package</filename></ulink> |
| task, files installed during the |
| <ulink url='&YOCTO_DOCS_REF_URL;#ref-tasks-install'><filename>do_install</filename></ulink> |
| task are split into one main package, which is almost always named |
| the same as the recipe, and several other packages. |
| This separation is done because not all of those installed files |
| are always useful in every image. |
| For example, you probably do not need any of the documentation |
| installed in a production image. |
| Consequently, for each recipe the documentation files are separated |
| into a <filename>-doc</filename> package. |
| Recipes that package software that has optional modules or |
| plugins might do additional package splitting as well. |
| </para> |
| |
| <para> |
| After building a recipe you can see where files have gone by |
| looking in the <filename>oe-workdir/packages-split</filename> |
| directory, which contains a subdirectory for each package. |
| Apart from some advanced cases, the |
| <ulink url='&YOCTO_DOCS_REF_URL;#var-PACKAGES'><filename>PACKAGES</filename></ulink> |
| and |
| <ulink url='&YOCTO_DOCS_REF_URL;#var-FILES'><filename>FILES</filename></ulink> |
| variables controls splitting. |
| The <filename>PACKAGES</filename> variable lists all of the |
| packages to be produced, while the <filename>FILES</filename> |
| variable specifies which files to include in each package, |
| using an override to specify the package. |
| For example, <filename>FILES_${PN}</filename> specifies the files |
| to go into the main package (i.e. the main package is named the |
| same as the recipe and |
| <filename>${</filename><ulink url='&YOCTO_DOCS_REF_URL;#var-PN'><filename>PN</filename></ulink><filename>}</filename> |
| evaluates to the recipe name). |
| The order of the <filename>PACKAGES</filename> value is significant. |
| For each installed file, the first package whose |
| <filename>FILES</filename> value matches the file is the package |
| into which the file goes. |
| Defaults exist for both the <filename>PACKAGES</filename> and |
| <filename>FILES</filename> variables. |
| Consequently, you might find you do not even need to set these |
| variables in your recipe unless the software the recipe is |
| building installs files into non-standard locations. |
| </para> |
| </section> |
| </section> |
| |
| <section id='sdk-restoring-the-target-device-to-its-original-state'> |
| <title>Restoring the Target Device to its Original State</title> |
| |
| <para> |
| If you use the <filename>devtool deploy-target</filename> |
| command to write a recipe's build output to the target, and |
| you are working on an existing component of the system, then you |
| might find yourself in a situation where you need to restore the |
| original files that existed prior to running the |
| <filename>devtool deploy-target</filename> command. |
| Because the <filename>devtool deploy-target</filename> command |
| backs up any files it overwrites, you can use the |
| <filename>devtool undeploy-target</filename> to restore those files |
| and remove any other files the recipe deployed. |
| Consider the following example: |
| <literallayout class='monospaced'> |
| $ devtool undeploy-target lighttpd root@192.168.7.2 |
| </literallayout> |
| If you have deployed multiple applications, you can remove them |
| all at once thus restoring the target device back to its |
| original state: |
| <literallayout class='monospaced'> |
| $ devtool undeploy-target -a root@192.168.7.2 |
| </literallayout> |
| Information about files deployed to the target as well as any |
| backed up files are stored on the target itself. |
| This storage of course requires some additional space |
| on the target machine. |
| <note> |
| The <filename>devtool deploy-target</filename> and |
| <filename>devtool undeploy-target</filename> command do not |
| currently interact with any package management system on the |
| target device (e.g. RPM or OPKG). |
| Consequently, you should not intermingle operations |
| <filename>devtool deploy-target</filename> and the package |
| manager operations on the target device. |
| Doing so could result in a conflicting set of files. |
| </note> |
| </para> |
| </section> |
| |
| <section id='sdk-installing-additional-items-into-the-extensible-sdk'> |
| <title>Installing Additional Items Into the Extensible SDK</title> |
| |
| <para> |
| The extensible SDK typically only comes with a small number of tools |
| and libraries out of the box. |
| If you have a minimal SDK, then it starts mostly empty and is |
| populated on-demand. |
| However, sometimes you will need to explicitly install extra items |
| into the SDK. |
| If you need these extra items, you can first search for the items |
| using the <filename>devtool search</filename> command. |
| For example, suppose you need to link to libGL but you are not sure |
| which recipe provides it. |
| You can use the following command to find out: |
| <literallayout class='monospaced'> |
| $ devtool search libGL |
| mesa A free implementation of the OpenGL API |
| </literallayout> |
| Once you know the recipe (i.e. <filename>mesa</filename> in this |
| example), you can install it: |
| <literallayout class='monospaced'> |
| $ devtool sdk-install mesa |
| </literallayout> |
| By default, the <filename>devtool sdk-install</filename> assumes the |
| item is available in pre-built form from your SDK provider. |
| If the item is not available and it is acceptable to build the item |
| from source, you can add the "-s" option as follows: |
| <literallayout class='monospaced'> |
| $ devtool sdk-install -s mesa |
| </literallayout> |
| It is important to remember that building the item from source takes |
| significantly longer than installing the pre-built artifact. |
| Also, if no recipe exists for the item you want to add to the SDK, you |
| must instead add it using the <filename>devtool add</filename> command. |
| </para> |
| </section> |
| |
| <section id='sdk-updating-the-extensible-sdk'> |
| <title>Updating the Extensible SDK</title> |
| |
| <para> |
| If you are working with an extensible SDK that gets occasionally |
| updated (e.g. typically when that SDK has been provided to you by |
| another party), then you will need to manually pull down those |
| updates to your installed SDK. |
| </para> |
| |
| <para> |
| To update your installed SDK, run the following: |
| <literallayout class='monospaced'> |
| $ devtool sdk-update |
| </literallayout> |
| The previous command assumes your SDK provider has set the default |
| update URL for you. |
| If that URL has not been set, you need to specify it yourself as |
| follows: |
| <literallayout class='monospaced'> |
| $ devtool sdk-update <replaceable>path_to_update_directory</replaceable> |
| </literallayout> |
| <note> |
| The URL needs to point specifically to a published SDK and not an |
| SDK installer that you would download and install. |
| </note> |
| </para> |
| </section> |
| |
| <section id='sdk-creating-a-derivative-sdk-with-additional-components'> |
| <title>Creating a Derivative SDK With Additional Components</title> |
| |
| <para> |
| You might need to produce an SDK that contains your own custom |
| libraries for sending to a third party (e.g., if you are a vendor with |
| customers needing to build their own software for the target platform). |
| If that is the case, then you can produce a derivative SDK based on |
| the currently installed SDK fairly easily. |
| Use these steps: |
| <orderedlist> |
| <listitem><para>If necessary, install an extensible SDK that |
| you want to use as a base for your derivative SDK. |
| </para></listitem> |
| <listitem><para>Source the environment script for the SDK. |
| </para></listitem> |
| <listitem><para>Add the extra libraries or other components |
| you want by using the <filename>devtool add</filename> |
| command. |
| </para></listitem> |
| <listitem><para>Run the <filename>devtool build-sdk</filename> |
| command. |
| </para></listitem> |
| </orderedlist> |
| The above procedure takes the recipes added to the workspace and |
| constructs a new SDK installer containing those recipes and the |
| resulting binary artifacts. |
| The recipes go into their own separate layer in the constructed |
| derivative SDK, leaving the workspace clean and ready for users |
| to add their own recipes. |
| </para> |
| </section> |
| |
| </chapter> |
| <!-- |
| vim: expandtab tw=80 ts=4 |
| --> |