The Yocto Project creates a custom embedded Linux distribution for a device by building recipes that define how to obtain, patch, compile and package software, rather than using an existing Linux distribution. It provides a common build environment and tools to configure, build and test embedded systems across different processor architectures.
AI Fame Rush Review – Virtual Influencer Creation In Just Minutes
Yocto Project Open Source Build System and Collaboration Initiative
1. It’s not an embedded Linux distribution –
It creates a custom one for you.
Creating a Custom Embedded Linux* OS for
Any Embedded Device using the Yocto Project*
marcelo.lorenzati@intel.com
2. Risk Factors
The above statements and any others in this document that refer to plans and expectations for the second quarter, the year and the future are forward-
looking statements that involve a number of risks and uncertainties. Words such as “anticipates,” “expects,” “intends,” “plans,” “believes,” “seeks,”
“estimates,” “may,” “will,” “should,” and their variations identify forward-looking statements. Statements that refer to or are based on projections, uncertain
events or assumptions also identify forward-looking statements. Many factors could affect Intel‟s actual results, and variances from Intel‟s current
expectations regarding such factors could cause actual results to differ materially from those expressed in these forward-looking statements. Intel
presently considers the following to be the important factors that could cause actual results to differ materially from the company‟s expectations. Demand
could be different from Intel's expectations due to factors including changes in business and economic conditions, including supply constraints and other
disruptions affecting customers; customer acceptance of Intel‟s and competitors‟ products; changes in customer order patterns including order
cancellations; and changes in the level of inventory at customers. Potential disruptions in the high technology supply chain resulting from the recent
disaster in Japan could cause customer demand to be different from Intel‟s expectations. Intel operates in intensely competitive industries that are
characterized by a high percentage of costs that are fixed or difficult to reduce in the short term and product demand that is highly variable and difficult to
forecast. Revenue and the gross margin percentage are affected by the timing of Intel product introductions and the demand for and market acceptance of
Intel's products; actions taken by Intel's competitors, including product offerings and introductions, marketing programs and pricing pressures and Intel‟s
response to such actions; and Intel‟s ability to respond quickly to technological developments and to incorporate new features into its products. The gross
margin percentage could vary significantly from expectations based on capacity utilization; variations in inventory valuation, including variations related to
the timing of qualifying products for sale; changes in revenue levels; product mix and pricing; the timing and execution of the manufacturing ramp and
associated costs; start-up costs; excess or obsolete inventory; changes in unit costs; defects or disruptions in the supply of materials or resources; product
manufacturing quality/yields; and impairments of long-lived assets, including manufacturing, assembly/test and intangible assets. Expenses, particularly
certain marketing and compensation expenses, as well as restructuring and asset impairment charges, vary depending on the level of demand for Intel's
products and the level of revenue and profits. The majority of Intel‟s non-marketable equity investment portfolio balance is concentrated in companies in
the flash memory market segment, and declines in this market segment or changes in management‟s plans with respect to Intel‟s investments in this
market segment could result in significant impairment charges, impacting restructuring charges as well as gains/losses on equity investments and interest
and other. Intel's results could be affected by adverse economic, social, political and physical/infrastructure conditions in countries where Intel, its
customers or its suppliers operate, including military conflict and other security risks, natural disasters, infrastructure disruptions, health concerns and
fluctuations in currency exchange rates. Intel‟s results could be affected by the timing of closing of acquisitions and divestitures. Intel's results could be
affected by adverse effects associated with product defects and errata (deviations from published specifications), and by litigation or regulatory matters
involving intellectual property, stockholder, consumer, antitrust and other issues, such as the litigation and regulatory matters described in Intel's SEC
reports. An unfavorable ruling could include monetary damages or an injunction prohibiting us from manufacturing or selling one or more products,
precluding particular business practices, impacting Intel‟s ability to design its products, or requiring other remedies such as compulsory licensing of
intellectual property. A detailed discussion of these and other factors that could affect Intel‟s results is included in Intel‟s SEC filings, including the report on
Form 10-Q for the quarter ended April 2, 2011.
Rev. 5/9/11
2
4. Agenda
• Day 1
• Preparation: Set and run Virtual Machine
• Meet the Yocto Project
• Build system, Recipes, configurations and workflow
• Application Development Tools, emulation
• Eclipse and HOB
• Test drive!
• Day 2
• Bake your own Linux distribution! Eat your own
cake!
5. Meet the Yocto Project*
The Yocto Project* is an open source
collaboration project that provides templates,
tools and methods to help you create custom
Linux-based systems for embedded products
regardless of hardware architecture.
• Focused resources for system application ™
developers who need to customize a Linux
distribution for a device
• Validated and tested BSPs in a common format
• Automatically creates an application development It’s not an embedded Linux distribution –
SDK customized for each specific device It creates a custom one for you.
• Supported by embedded industry leaders across
multiple architectures (IA, ARM, PowerPC, MIPS,
etc)
• Is a great starting point for “roll your own”
embedded developers and commercial distribution
vendors.
Simple M2M Point of of
Point Sale Networking & Industrial
• Enables easy transition from Proof of Concept Electronics Sale Storage & Medical
(POC) to supported Commercial Linux with no loss
of optimizations, code or design
• Proprietary code can be included in build structure www.yoctoproject.org
within a separate layer, which can be kept private.
(security)
• Project hosted by the Linux* Foundation
55
5
7. Where to Get Things
WHAT WHO WHERE HOW TO GET
SUPPORTS DISTRIBUTED
BSPs in common Community YOCTO PROJECT www.yoctoproject.org
Yocto Project format WEBSITE
Complete platform Community YOCTO PROJECT www.yoctoproject.org
configuration, WEBSITE
environment,
Embedded Media Yocto Project will YOCTO PROJECT www.yoctoproject.org
and Graphics Driver - test specific WEBSITE or ECG Integrated Image
EMGD (Atom) configurations - EDC WEBSITE Or
provided on www.edc.intel.com
website. Driver
Commercial OS OSV OSV Thru OSV
Commercial Support
7
8. Intel® Embedded Software Development
Tool Suite for Intel® Atom™ Processor
Identify
Performance optimization
optimize your opportunities Thread Specific Run
code for IA Control & Thread Kernel debug;
Grouping On-Chip trace &
SMP run control
Intel®
Intel® Intel® Intel®
Intel® C++
Compiler
Integrated
Performance
VTune™ Application JTAG Support
Amplifier XE Debugger Debugger
Primitives for the
Yocto
Linux* Operating System Support Project
JTAG I/F
Intel® Atom™ Processor
Broad Processor coverage
CE4xxx, Z6xx, E6xx, Nxx
Target OS: Linux*; series
Tizen*
A comprehensive Suite of Tools for Embedded
Development, Analysis
and System Debugging
http://software.intel.com/en-us/articles/intel-tools-for-intel-atom-processors/ 8
9. Intel Academic Community
Share educational resources to take advantage of next-generation technologies.
http://software.intel.com/en-us/academic
There are tool licenses with special prices for Universities:
http://software.intel.com/en-us/articles/intel-education-offerings
and 30-day evaluation licenses:
http://software.intel.com/en-us/articles/intel-software-evaluation-center/
10. A Few Benefits of The Yocto Project*
• One common Linux* OS for all major architectures
• Just change one line in a config file and rebuild
• Easy transition to a commercial embedded Linux
• Build a complete Linux system in about an hour from pre-compiled
sources (about 90 minutes with X) – quick start
• Start with a validated collection of packages
• Access to a great collection of app developer tools (performance,
debug, power analysis, Eclipse*)
• Use Kernel development tools to manage patches
• Access to interaction with the Embedded Open Community
10
11. Developing in Linux is easy*
Warning!
Things beyond this point might get difficult!
http://en.wikipedia.org/wiki/Apollo_Command/Service_Module
12. Yocto Project* Build System Overview
Poky = BitBake + metadata
Poky – build system used by the Yocto Project*
BitBake – a task executor and scheduler
Metadata – task definitions
• Configuration (.conf) – global definitions of variables
• Classes (.bbclass) – encapsulation and inheritance of build logic,
packaging, etc.
• Recipes (.bb) – the logical units of software/images to build
12
13. YP = Poky + Upstreams + Tools
Poky
OpenEmbedded-Core
Bitbake Build system upstream
components
Yocto Documentation
Poky
Meta-Yocto
Reference Images
Reference BSP
Upstream Metadata (one per arch) Prebuilt Build State Yocto Project
Software Software Releases components
Projects ADT Tools (Eclipse
Plugin) ADT Components
Yocto Project
Pseudo
Swabber
Yocto Project Output
Embedded Kernel Tools
YP provides best of upstream for a stable base
14. Key Concepts
• The Yocto Project* provides tools and metadata
for creating custom Linux* images
• These images are created from a repository of
„baked‟ recipes
• A recipe is a set of instructions for building
packages, including:
• Where to obtain the upstream sources and which patches to apply
• Dependencies (on libraries or other recipes)
• Configuration/compilation options
• Define what files go into what output packages
14
16. Quick Start Guide in a Slide
Obtain our sources:
Download poky-danny-8.0.tar.bz2
$tar xjf poky-danny-8.0.tar.bz2
$cd poky-danny-8.0
Build a Linux* image:
$source oe-init-build-env
$MACHINE=qemux86 bitbake core-image-minimal
some time passes
Run the image under emulation:
$runqemu qemux86
http://downloads.yoctoproject.org/releases/yocto/yocto-1.3/poky-danny-8.0.tar.bz2
16
17. Poky Directory Tree Map
• bitbake: the BitBake utility itself
• documentation: documentation sources
• scripts: various support scripts (e.g, runqemu)
• meta/conf: important configuration files, bitbake.conf,
reference distro config, machine configs for qemu
architectures
• meta/classes: BitBake classes
• meta/recipes-<xyz>: recipes
17
19. User Configuration
• User configuration:
• conf/local.conf – some things to set:
• Set BB_NUMBER_THREADS and PARALLEL_MAKE, based on the
number of threads in the machine
• Set MACHINE=“foo” for the CPU architecture
• EXTRA_IMAGE_FEATURES adds features (groups of packages)
• INCOMPATIBLE_LICENSE = “GPLv3” eliminates packages using
this license (for example)
20. Recipes & Metadata
• Metadata and patches:
• Recipes for building packages
• Eg, meta/recipes-
core/coreutils/coreutils_6.9.bb builds the core
utilities (version 6.9) and installs them
• meta-recipes-core/coreutils/coreutils-6.9/
includes patches, also could include extra files to
install
22. Example Recipe – ethtool_2.6.36.bb
SUMMARY = "Display or change ethernet card settings"
DESCRIPTION = "A small utility for examining and
tuning the settings of your ethernet-based network
interfaces."
HOMEPAGE = "http://sourceforge.net/projects/gkernel/"
LICENSE = "GPLv2+"
SRC_URI = "${SOURCEFORGE_MIRROR}/gkernel/ethtool-
${PV}.tar.gz"
inherit autotools
22
23. Standard Recipe Build Steps
• Building recipes involves executing the following functions,
which can be overridden when needed for customizations
• do_fetch
• do_unpack
• do_patch
• do_configure
• do_compile
• do_install
• do_package
23
24. Examining Recipes
meta/recipes-extended/bc/
• Uses LIC_FILES_CHKSUM and SRC_URI checksums
• Note the DEPENDS declaration
meta/recipes-core/psplash/
• Uses SVN for sources
• Sets up an init service
meta/recipes-multimedia/flac/
• Includes custom source patches
• Customizes autoconf configure options
• Breaks up output into multiple binary packages
24
25. Source Fetching
• Recipes call out location of all sources, whether on the internet or local
(Look for SRC_URI in *.bb files)
• Bitbake can get sources from git, svn, bzr, from tarballs, and many, many
more*
• Versions of packages can be fixed or updated automatically (Add
SRCREV_pn- PN = "${AUTOREV}” to local.conf)
• Yocto Project sources mirror available as a fallback, if the sources move on
the internet
* Complete list includes: http, ftp, https, git, svn, perforce, mercurial, bzr, cvs, osc, repo, ssh, and
svk and the unpacker can cope with tarballs, zip, rar, xz, gz, bz2, and so on.
26. Patching
• Once sources are obtained, the patches are applied
• This is a good place place to patch the software yourself
• However, we encourage you to contribute development
upstream whenever possible (we try to)
27. Packaging
• Once configure/compile/install is completed,
packaging commences
• The most popular package formats are
supported: RPM, Debian, and ipk
• Set PACKAGE_CLASSES in conf/local.conf
• You can split into multiple packages using
PACKAGES and FILES in a *.bb file:
PACKAGES =+ "sxpm cxpm"
FILES_cxpm = "${bindir}/cxpm"
FILES_sxpm = "${bindir}/sxpm"
28. Image Generation
• Images are constructed using the
packages built earlier in the process
• Uses for these images:
• Live Image to boot a device
• Root filesystem for QEMU emulator
• Sysroot for App development
YP lets you customize your embedded Linux OS
29. Layers Agenda
• Introduction to Layers
• Stacking Customizations
• Adding Layers
• Board Support Packages
• Example machine configuration
• Kernel configuration
29
30. Layers
• The Yocto Project* build system is composed of
layers
• A layer is a logical collection of recipes
representing the core, a Board Support Package
(BSP), or an application stack
• All layers have a priority and can override policy
and config settings of the layers beneath it
30
32. Using Layers
• Layers are added to your build by editing the
build/conf/bblayers.conf file:
BBLAYERS = "
/data/poky/meta # core system
/data/poky/meta-yocto # yocto config and recipes
/data/meta-skynet # my customization layer
"
32
34. Board Support Packages
• BSPs are layers to enable support for specific
hardware platforms
• Defines machine configuration for the “board”
• Adds machine-specific recipes and
customizations
– Kernel config
– Graphics drivers (e.g, Xorg)
– Additional recipes to support hardware features
34
36. Kernel Customization
• You can define a full kernel configuration set
(defconfig) or use kernel configuration
“fragments”
• Add a kernel configuration fragment (.cfg) to
your layer
• These include standard Linux* Kconfig values and are
inserted into the generated defconfig
• Add a linux-yocto.bbappend recipe to your
layer which includes your config file(s)
36
39. Images
• Specify which packages to install
– List individual package names and/or:
– Set the IMAGE_FEATURES variable, which maps collections of
packages (defined in task recipes) to named functionality, e.g,
“apps-console-core package-management”
• Define commands to be run on the generated rootfs (e.g,
installing configuration files into /etc)
• Built images are saved to
build/tmp/deploy/images/
39
40. Example Image – my-nas-image.bb
IMAGE_FEATURES += "nfs-server apps-console-core package-management"
inherit poky-image
SRC_URI = "file://fstab # These files will be installed after the
file://exports” # rootfs is generated, see below
ROOTFS_POSTPROCESS_COMMAND += "setup_target_image ; "
setup_target_image() {
# install configuration files
install -m 0644 ${WORKDIR}/fstab ${IMAGE_ROOTFS}/etc/fstab
install -m 0644 ${WORKDIR}/exports ${IMAGE_ROOTFS}/etc/exports
# etc etc
}
40
41. Yocto Project* ADT
• Yocto Project* Application Development Toolkit
• Setup target system development environment on the
host machine based on sysroot concept
• GNU cross-development toolchain of build, packaging, and debug
• Development headers and libraries
• Sysroot represents target device root file system
• Optimized for use with Autotools
• For autotool-enabled packages just pass host options to configure
• For other projects should ensure the cross tools are used
41
42. Yocto Project* ADT (Cont.)
• Yocto Application Development Toolkit
• Use hardware as development targets - Qemu
with GL pass-through
• User mode NFS support
• Allow emulator and host access the file system at same time
• Update packages on running systems and
sysroot
• ADT installer, Eclipse plug-in and user space
tool suite
Allow software and hardware development to happen in parallel
42
43. ADT Generation
• Cross toolchain and installation script
generated.
• This can be used to set up an application
developer‟s cross development
environment to create apps
• MACHINE=qemuarm bitbake poky-
image-sato-sdk meta-toolchain
package-index
• QEMU built for target architecture
emulation
44. Using Emulation
• Yocto uses QEMU, which supports all major
architectures: x86(-64), arm, mips, ppc
• Simply set MACHINE=qemux86 in local.conf and
build your image
• runqemu script is used to boot the image with
QEMU – it auto-detects as much as possible:
runqemu qemux86
44
45. Embedded Software Development
• Embedded products are highly customized to
provide special functions
• Quickly roll out new applications that utilize
unique hardware features
• Embedded platforms needs
• Run time supporting system
• Application development
• Product-focused toolchain and development
platform are essential for embedded software
development
45
46. Eclipse Plugin
The Eclipse IDE Plug-in integrates the functionality of the Yocto Project
Application Development Toolkit (ADT) and toolchain into the
Eclipse IDE, allowing its users direct access to their capabilities:
• Crosscompiling
• Deploying
• Debugging
• Emulation
• Profiling
• Tracing
• Collection of Power, Latency and Performance data
http://www.yoctoproject.org/docs/current/adt-manual/adt-manual.html
48. HOB
Hob is a graphical user interface for BitBake. Its primary goal
is to enable a user to perform common tasks more easily.
• Modify existing images
• Create custom images
• Save customized images as templates
• Build images
• Run images in the QEMU emulator
• Deploy images to a USB disk for live-booting on a target device
48
59. Project Resources
• The Yocto Project* is an open source project, and aims to
deliver an open standard for the embedded Linux*
community and industry
• Development is done in the open through public mailing
lists: openembedded-core@lists.openembedded.org,
poky@yoctoproject.org and yocto@yoctoproject.org
• And public code repositories:
http://git.yoctoproject.org and
http://git.openembedded.net
• Bug reports and feature requests:
http://bugzilla.yoctoproject.org
59
Manually adjust the transparent blue boxes once the headline has been entered
I’m sure you’re asking what is the Yocto Project and if you already Google’d “Yocto” you found out that it’s “a is a prefix in the metric system denoting a factor of 10−24” In this context, however, Yocto Project is a Linux Open Source build environment especially tailored for embedded distributions. The Yocto Project delivers a set of tools, services, and information which can be used to create a CUSTOMIZED Linux for any embedded device. The Yocto Project consists of a website with full documentation catering to the “new user”, the Poky build system at its core based on the OpenEmbedded architecture, provides cross build tools, an agnostic packaging system (rpm, deb, ipk), and an app developer SDK generator + Eclipse There are three main components the Yocto Project provides: x-Architecture: The Yocto Project extends Poky’s capabilities by providing extensively tested and up-to-date metadata for the Yocto Project kernel and for three build profiles: minimal, sato and LSB builds. Each of these includes tested and validated metadata for libraries, tools, and applications for building on multiple architectures, including x86 (32 and 64), ARM, PPC, and MIPS. BSP: Additionally, some tested board support packages (in a de facto standard format) are included with the source recipes and their resulting Yocto Project reference runtime images. SDK : Finally, the Yocto Project tools automatically create an Software or Application Developer Kit (SDK with Eclipse and Anjuta Plug-ins available), which can be used to develop applications suitable for use with that particular custom runtime image. And of major importance, partner discussions and meetings underway for wide range industry support for the project, it’s formats, code base and tools to reduce the Linux fragmentation in the embedded industry. Commercial OS’s can be based on the Yocto Project Kernel.Silicon vendors would supply HW BSP’s
Kernel1.1: 3.0.1Stable: 2.6.37
A tool suite for application and system development. This provides a lot of processor-specific features, that need updates with every new processor. JTAG I/F is required to use it, currently available form Macraigor.Features of v2.2 update 2: New GUI for the application and JTAG debugger Additional support for new platforms and flash types in IDB-JTAG Intel® VTune™ Amplifier XE Update 2 which includes SEP v3.4 EBS (data sampling) on ATOM™ targets Analysis of data sampled with SEP on target (remotely) - no sampling on development host Hotspot/Concurreny/L&W analysis on the host work as no HW counters are involved
Universities can have our Software for educational purposes by accessing to our grants at the Intel Academic Community.We offer “grants” that allow the professors to “buy” our software tools. We also have big discounts for multiple-seats licenses to be used in Universities.You can also download our tools for a 30-day trial period.The Intel Academic Community not only allows access to the software tools, but also gives you a community to share knowledge about teaching/learning parallel programming: you can download/upload course material, access to a Many-Core Test Lab, participate in contests, publish/read blogs, get help to create/update parallel programming courses.
Using Poky, essentially, one command can generate both a toolchain and matching rootfs imageRun “bitbake qemux86 poky-image-sato-sdk meta-toolchainpackageindex”These are generated by Poky build system based on the target metadata configuration
Allows board vendor to bundle product-focused toolchain, tools and development platform in the bundle with Board Support Package (BSP)s.