summaryrefslogtreecommitdiffstats
path: root/documentation/overview-manual/overview-concepts.xml
blob: a7d6d2f6fb2ad2ad108bcf10035a7a8322902639 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
<!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='overview-concepts'>
<title>Yocto Project Concepts</title>

    <para>
        This chapter describes concepts for various areas of the Yocto Project.
        Currently, topics include Yocto Project components, cross-development
        generation, shared state (sstate) cache, runtime dependencies,
        Pseudo and Fakeroot, x32 psABI, Wayland support, and Licenses.
    </para>

    <section id='yocto-project-components'>
        <title>Yocto Project Components</title>

        <para>
            The
            <ulink url='&YOCTO_DOCS_REF_URL;#bitbake-term'>BitBake</ulink>
            task executor together with various types of configuration files
            form the OpenEmbedded Core.
            This section overviews these components by describing their use and
            how they interact.
        </para>

        <para>
            BitBake handles the parsing and execution of the data files.
            The data itself is of various types:
            <itemizedlist>
                <listitem><para>
                    <emphasis>Recipes:</emphasis>
                    Provides details about particular pieces of software.
                    </para></listitem>
                <listitem><para>
                    <emphasis>Class Data:</emphasis>
                    Abstracts common build information (e.g. how to build a
                    Linux kernel).
                    </para></listitem>
                <listitem><para>
                    <emphasis>Configuration Data:</emphasis>
                    Defines machine-specific settings, policy decisions, and
                    so forth.
                    Configuration data acts as the glue to bind everything
                    together.
                    </para></listitem>
            </itemizedlist>
        </para>

        <para>
            BitBake knows how to combine multiple data sources together and
            refers to each data source as a layer.
            For information on layers, see the
            "<ulink url='&YOCTO_DOCS_DEV_URL;#understanding-and-creating-layers'>Understanding and Creating Layers</ulink>"
            section of the Yocto Project Development Tasks Manual.
        </para>

        <para>
            Following are some brief details on these core components.
            For additional information on how these components interact during
            a build, see the
            "<link linkend='development-concepts'>Development Concepts</link>"
            section.
        </para>

        <section id='usingpoky-components-bitbake'>
            <title>BitBake</title>

            <para>
                BitBake is the tool at the heart of the OpenEmbedded build
                system and is responsible for parsing the
                <ulink url='&YOCTO_DOCS_REF_URL;#metadata'>Metadata</ulink>,
                generating a list of tasks from it, and then executing those
                tasks.
            </para>

            <para>
                This section briefly introduces BitBake.
                If you want more information on BitBake, see the
                <ulink url='&YOCTO_DOCS_BB_URL;#bitbake-user-manual'>BitBake User Manual</ulink>.
            </para>

            <para>
                To see a list of the options BitBake supports, use either of
                the following commands:
                <literallayout class='monospaced'>
     $ bitbake -h
     $ bitbake --help
                </literallayout>
            </para>

            <para>
                The most common usage for BitBake is
                <filename>bitbake <replaceable>packagename</replaceable></filename>,
                where <filename>packagename</filename> is the name of the
                package you want to build (referred to as the "target" in this
                manual).
                The target often equates to the first part of a recipe's
                filename (e.g. "foo" for a recipe named
                <filename>foo_1.3.0-r0.bb</filename>).
                So, to process the
                <filename>matchbox-desktop_1.2.3.bb</filename> recipe file, you
                might type the following:
                <literallayout class='monospaced'>
     $ bitbake matchbox-desktop
                </literallayout>
                Several different versions of
                <filename>matchbox-desktop</filename> might exist.
                BitBake chooses the one selected by the distribution
                configuration.
                You can get more details about how BitBake chooses between
                different target versions and providers in the
                "<ulink url='&YOCTO_DOCS_BB_URL;#bb-bitbake-preferences'>Preferences</ulink>"
                section of the BitBake User Manual.
            </para>

            <para>
                BitBake also tries to execute any dependent tasks first.
                So for example, before building
                <filename>matchbox-desktop</filename>, BitBake would build a
                cross compiler and <filename>glibc</filename> if they had not
                already been built.
            </para>

            <para>
                A useful BitBake option to consider is the
                <filename>-k</filename> or <filename>--continue</filename>
                option.
                This option instructs BitBake to try and continue processing
                the job as long as possible even after encountering an error.
                When an error occurs, the target that failed and those that
                depend on it cannot be remade.
                However, when you use this option other dependencies can
                still be processed.
            </para>
        </section>

        <section id='usingpoky-components-metadata'>
            <title>Metadata (Recipes)</title>

            <para>
                Files that have the <filename>.bb</filename> suffix are
                "recipes" files.
                In general, a recipe contains information about a single piece
                of software.
                This information includes the location from which to download
                the unaltered source, any source patches to be applied to that
                source (if needed), which special configuration options to
                apply, how to compile the source files, and how to package the
                compiled output.
            </para>

            <para>
                The term "package" is sometimes used to refer to recipes.
                However, since the word "package" is used for the packaged
                output from the OpenEmbedded build system (i.e.
                <filename>.ipk</filename> or <filename>.deb</filename> files),
                this document avoids using the term "package" when referring
                to recipes.
            </para>
        </section>

        <section id='metadata-virtual-providers'>
            <title>Metadata (Virtual Providers)</title>

            <para>
                Prior to the build, if you know that several different recipes
                provide the same functionality, you can use a virtual provider
                (i.e. <filename>virtual/*</filename>) as a placeholder for the
                actual provider.
                The actual provider would be determined at build time.
                In this case, you should add <filename>virtual/*</filename>
                to
                <ulink url='&YOCTO_DOCS_REF_URL;#var-DEPENDS'><filename>DEPENDS</filename></ulink>,
                rather than listing the specified provider.
                You would select the actual provider by setting the
                <ulink url='&YOCTO_DOCS_REF_URL;#var-PREFERRED_PROVIDER'><filename>PREFERRED_PROVIDER</filename></ulink>
                variable (i.e.
                <filename>PREFERRED_PROVIDER_virtual/*</filename>)
                in the build's configuration file (e.g.
                <filename>poky/build/conf/local.conf</filename>).
                <note>
                    Any recipe that PROVIDES a <filename>virtual/*</filename>
                    item that is ultimately not selected through
                    <filename>PREFERRED_PROVIDER</filename> does not get built.
                    Preventing these recipes from building is usually the
                    desired behavior since this mechanism's purpose is to
                    select between mutually exclusive alternative providers.
                </note>
            </para>

            <para>
                The following lists specific examples of virtual providers:
                <itemizedlist>
                    <listitem><para>
                        <filename>virtual/mesa</filename>:
                        Provides <filename>gbm.pc</filename>.
                        </para></listitem>
                    <listitem><para>
                        <filename>virtual/egl</filename>:
                        Provides <filename>egl.pc</filename> and possibly
                        <filename>wayland-egl.pc</filename>.
                        </para></listitem>
                    <listitem><para>
                        <filename>virtual/libgl</filename>:
                        Provides <filename>gl.pc</filename> (i.e. libGL).
                        </para></listitem>
                    <listitem><para>
                        <filename>virtual/libgles1</filename>:
                        Provides <filename>glesv1_cm.pc</filename>
                        (i.e. libGLESv1_CM).
                        </para></listitem>
                    <listitem><para>
                        <filename>virtual/libgles2</filename>:
                        Provides <filename>glesv2.pc</filename>
                        (i.e. libGLESv2).
                        </para></listitem>
                </itemizedlist>
            </para>
        </section>

        <section id='usingpoky-components-classes'>
            <title>Classes</title>

            <para>
                Class files (<filename>.bbclass</filename>) contain information
                that is useful to share between
                <ulink url='&YOCTO_DOCS_REF_URL;#metadata'>Metadata</ulink>
                files.
                An example is the
                <ulink url='&YOCTO_DOCS_REF_URL;#ref-classes-autotools'><filename>autotools</filename></ulink>
                class, which contains common settings for any application that
                Autotools uses.
                The
                "<ulink url='&YOCTO_DOCS_REF_URL;#ref-classes'>Classes</ulink>"
                chapter in the Yocto Project Reference Manual provides
                details about classes and how to use them.
            </para>
        </section>

        <section id='usingpoky-components-configuration'>
            <title>Configuration</title>

            <para>
                The configuration files (<filename>.conf</filename>) define
                various configuration variables that govern the OpenEmbedded
                build process.
                These files fall into several areas that define machine
                configuration options, distribution configuration options,
                compiler tuning options, general common configuration options,
                and user configuration options in
                <filename>local.conf</filename>, which is found in the
                <ulink url='&YOCTO_DOCS_REF_URL;#build-directory'>Build Directory</ulink>.
            </para>
        </section>
    </section>

    <section id="cross-development-toolchain-generation">
        <title>Cross-Development Toolchain Generation</title>

        <para>
            The Yocto Project does most of the work for you when it comes to
            creating
            <ulink url='&YOCTO_DOCS_REF_URL;#cross-development-toolchain'>cross-development toolchains</ulink>.
            This section provides some technical background on how
            cross-development toolchains are created and used.
            For more information on toolchains, you can also see the
            <ulink url='&YOCTO_DOCS_SDK_URL;'>Yocto Project Application Development and the Extensible Software Development Kit (eSDK)</ulink>
            manual.
        </para>

        <para>
            In the Yocto Project development environment, cross-development
            toolchains are used to build the image and applications that run
            on the target hardware.
            With just a few commands, the OpenEmbedded build system creates
            these necessary toolchains for you.
        </para>

        <para>
            The following figure shows a high-level build environment regarding
            toolchain construction and use.
        </para>

        <para>
            <imagedata fileref="figures/cross-development-toolchains.png" width="8in" depth="6in" align="center" />
        </para>

        <para>
            Most of the work occurs on the Build Host.
            This is the machine used to build images and generally work within the
            the Yocto Project environment.
            When you run BitBake to create an image, the OpenEmbedded build system
            uses the host <filename>gcc</filename> compiler to bootstrap a
            cross-compiler named <filename>gcc-cross</filename>.
            The <filename>gcc-cross</filename> compiler is what BitBake uses to
            compile source files when creating the target image.
            You can think of <filename>gcc-cross</filename> simply as an
            automatically generated cross-compiler that is used internally within
            BitBake only.
            <note>
                The extensible SDK does not use
                <filename>gcc-cross-canadian</filename> since this SDK
                ships a copy of the OpenEmbedded build system and the sysroot
                within it contains <filename>gcc-cross</filename>.
            </note>
        </para>

        <para>
            The chain of events that occurs when <filename>gcc-cross</filename> is
            bootstrapped is as follows:
            <literallayout class='monospaced'>
     gcc -> binutils-cross -> gcc-cross-initial -> linux-libc-headers -> glibc-initial -> glibc -> gcc-cross -> gcc-runtime
            </literallayout>
            <itemizedlist>
                <listitem><para>
                    <filename>gcc</filename>:
                    The build host's GNU Compiler Collection (GCC).
                    </para></listitem>
                <listitem><para>
                    <filename>binutils-cross</filename>:
                    The bare minimum binary utilities needed in order to run
                    the <filename>gcc-cross-initial</filename> phase of the
                    bootstrap operation.
                    </para></listitem>
                <listitem><para>
                    <filename>gcc-cross-initial</filename>:
                    An early stage of the bootstrap process for creating
                    the cross-compiler.
                    This stage builds enough of the <filename>gcc-cross</filename>,
                    the C library, and other pieces needed to finish building the
                    final cross-compiler in later stages.
                    This tool is a "native" package (i.e. it is designed to run on
                    the build host).
                    </para></listitem>
                <listitem><para>
                    <filename>linux-libc-headers</filename>:
                    Headers needed for the cross-compiler.
                    </para></listitem>
                <listitem><para>
                    <filename>glibc-initial</filename>:
                    An initial version of the Embedded GLIBC needed to bootstrap
                    <filename>glibc</filename>.
                    </para></listitem>
                <listitem><para>
                    <filename>gcc-cross</filename>:
                    The final stage of the bootstrap process for the
                    cross-compiler.
                    This stage results in the actual cross-compiler that
                    BitBake uses when it builds an image for a targeted
                    device.
                    <note>
                        If you are replacing this cross compiler toolchain
                        with a custom version, you must replace
                        <filename>gcc-cross</filename>.
                    </note>
                    This tool is also a "native" package (i.e. it is
                    designed to run on the build host).
                    </para></listitem>
                <listitem><para>
                    <filename>gcc-runtime</filename>:
                    Runtime libraries resulting from the toolchain bootstrapping
                    process.
                    This tool produces a binary that consists of the
                    runtime libraries need for the targeted device.
                    </para></listitem>
            </itemizedlist>
        </para>

        <para>
            You can use the OpenEmbedded build system to build an installer for
            the relocatable SDK used to develop applications.
            When you run the installer, it installs the toolchain, which contains
            the development tools (e.g., the
            <filename>gcc-cross-canadian</filename>),
            <filename>binutils-cross-canadian</filename>, and other
            <filename>nativesdk-*</filename> tools,
            which are tools native to the SDK (i.e. native to
            <ulink url='&YOCTO_DOCS_REF_URL;#var-SDK_ARCH'><filename>SDK_ARCH</filename></ulink>),
            you need to cross-compile and test your software.
            The figure shows the commands you use to easily build out this
            toolchain.
            This cross-development toolchain is built to execute on the
            <ulink url='&YOCTO_DOCS_REF_URL;#var-SDKMACHINE'><filename>SDKMACHINE</filename></ulink>,
            which might or might not be the same
            machine as the Build Host.
            <note>
                If your target architecture is supported by the Yocto Project,
                you can take advantage of pre-built images that ship with the
                Yocto Project and already contain cross-development toolchain
                installers.
            </note>
        </para>

        <para>
            Here is the bootstrap process for the relocatable toolchain:
            <literallayout class='monospaced'>
     gcc -> binutils-crosssdk -> gcc-crosssdk-initial -> linux-libc-headers ->
        glibc-initial -> nativesdk-glibc -> gcc-crosssdk -> gcc-cross-canadian
            </literallayout>
            <itemizedlist>
                <listitem><para>
                    <filename>gcc</filename>:
                    The build host's GNU Compiler Collection (GCC).
                    </para></listitem>
                <listitem><para>
                    <filename>binutils-crosssdk</filename>:
                    The bare minimum binary utilities needed in order to run
                    the <filename>gcc-crosssdk-initial</filename> phase of the
                    bootstrap operation.
                    </para></listitem>
                <listitem><para>
                    <filename>gcc-crosssdk-initial</filename>:
                    An early stage of the bootstrap process for creating
                    the cross-compiler.
                    This stage builds enough of the
                    <filename>gcc-crosssdk</filename> and supporting pieces so that
                    the final stage of the bootstrap process can produce the
                    finished cross-compiler.
                    This tool is a "native" binary that runs on the build host.
                    </para></listitem>
                <listitem><para>
                    <filename>linux-libc-headers</filename>:
                    Headers needed for the cross-compiler.
                    </para></listitem>
                <listitem><para>
                    <filename>glibc-initial</filename>:
                    An initial version of the Embedded GLIBC needed to bootstrap
                    <filename>nativesdk-glibc</filename>.
                    </para></listitem>
                <listitem><para>
                    <filename>nativesdk-glibc</filename>:
                    The Embedded GLIBC needed to bootstrap the
                    <filename>gcc-crosssdk</filename>.
                    </para></listitem>
                <listitem><para>
                    <filename>gcc-crosssdk</filename>:
                    The final stage of the bootstrap process for the
                    relocatable cross-compiler.
                    The <filename>gcc-crosssdk</filename> is a transitory compiler
                    and never leaves the build host.
                    Its purpose is to help in the bootstrap process to create the
                    eventual relocatable <filename>gcc-cross-canadian</filename>
                    compiler, which is relocatable.
                    This tool is also a "native" package (i.e. it is
                    designed to run on the build host).
                    </para></listitem>
                <listitem><para>
                    <filename>gcc-cross-canadian</filename>:
                    The final relocatable cross-compiler.
                    When run on the
                    <ulink url='&YOCTO_DOCS_REF_URL;#var-SDKMACHINE'><filename>SDKMACHINE</filename></ulink>,
                    this tool
                    produces executable code that runs on the target device.
                    Only one cross-canadian compiler is produced per architecture
                    since they can be targeted at different processor optimizations
                    using configurations passed to the compiler through the
                    compile commands.
                    This circumvents the need for multiple compilers and thus
                    reduces the size of the toolchains.
                    </para></listitem>
            </itemizedlist>
        </para>

        <note>
            For information on advantages gained when building a
            cross-development toolchain installer, see the
            "<ulink url='&YOCTO_DOCS_SDK_URL;#sdk-building-an-sdk-installer'>Building an SDK Installer</ulink>"
            section in the Yocto Project Application Development and the
            Extensible Software Development Kit (eSDK) manual.
        </note>
    </section>




    <section id="shared-state-cache">
        <title>Shared State Cache</title>

        <para>
            By design, the OpenEmbedded build system builds everything from
            scratch unless BitBake can determine that parts do not need to be
            rebuilt.
            Fundamentally, building from scratch is attractive as it means all
            parts are built fresh and there is no possibility of stale data
            causing problems.
            When developers hit problems, they typically default back to
            building from scratch so they know the state of things from the
            start.
        </para>

        <para>
            Building an image from scratch is both an advantage and a
            disadvantage to the process.
            As mentioned in the previous paragraph, building from scratch
            ensures that everything is current and starts from a known state.
            However, building from scratch also takes much longer as it
            generally means rebuilding things that do not necessarily need
            to be rebuilt.
        </para>

        <para>
            The Yocto Project implements shared state code that supports
            incremental builds.
            The implementation of the shared state code answers the following
            questions that were fundamental roadblocks within the OpenEmbedded
            incremental build support system:
            <itemizedlist>
                <listitem><para>
                    What pieces of the system have changed and what pieces have
                    not changed?
                    </para></listitem>
                <listitem><para>
                    How are changed pieces of software removed and replaced?
                    </para></listitem>
                <listitem><para>
                    How are pre-built components that do not need to be rebuilt
                    from scratch used when they are available?
                    </para></listitem>
            </itemizedlist>
        </para>

        <para>
            For the first question, the build system detects changes in the
            "inputs" to a given task by creating a checksum (or signature) of
            the task's inputs.
            If the checksum changes, the system assumes the inputs have changed
            and the task needs to be rerun.
            For the second question, the shared state (sstate) code tracks
            which tasks add which output to the build process.
            This means the output from a given task can be removed, upgraded
            or otherwise manipulated.
            The third question is partly addressed by the solution for the
            second question assuming the build system can fetch the sstate
            objects from remote locations and install them if they are deemed
            to be valid.
            <note>
                The OpenEmbedded build system does not maintain
                <ulink url='&YOCTO_DOCS_REF_URL;#var-PR'><filename>PR</filename></ulink>
                information as part of the shared state packages.
                Consequently, considerations exist that affect maintaining
                shared state feeds.
                For information on how the OpenEmbedded build system
                works with packages and can track incrementing
                <filename>PR</filename> information, see the
                "<ulink url='&YOCTO_DOCS_DEV_URL;#automatically-incrementing-a-binary-package-revision-number'>Automatically Incrementing a Binary Package Revision Number</ulink>"
                section in the Yocto Project Development Tasks Manual.
            </note>
        </para>

        <para>
            The rest of this section goes into detail about the overall
            incremental build architecture, the checksums (signatures), shared
            state, and some tips and tricks.
        </para>

        <section id='overall-architecture'>
            <title>Overall Architecture</title>

            <para>
                When determining what parts of the system need to be built,
                BitBake works on a per-task basis rather than a per-recipe
                basis.
                You might wonder why using a per-task basis is preferred over
                a per-recipe basis.
                To help explain, consider having the IPK packaging backend
                enabled and then switching to DEB.
                In this case, the
                <ulink url='&YOCTO_DOCS_REF_URL;#ref-tasks-install'><filename>do_install</filename></ulink>
                and
                <ulink url='&YOCTO_DOCS_REF_URL;#ref-tasks-package'><filename>do_package</filename></ulink>
                task outputs are still valid.
                However, with a per-recipe approach, the build would not
                include the <filename>.deb</filename> files.
                Consequently, you would have to invalidate the whole build and
                rerun it.
                Rerunning everything is not the best solution.
                Also, in this case, the core must be "taught" much about
                specific tasks.
                This methodology does not scale well and does not allow users
                to easily add new tasks in layers or as external recipes
                without touching the packaged-staging core.
            </para>
        </section>

        <section id='overview-checksums'>
            <title>Checksums (Signatures)</title>

            <para>
                The shared state code uses a checksum, which is a unique
                signature of a task's inputs, to determine if a task needs to
                be run again.
                Because it is a change in a task's inputs that triggers a
                rerun, the process needs to detect all the inputs to a given
                task.
                For shell tasks, this turns out to be fairly easy because
                the build process generates a "run" shell script for each task
                and it is possible to create a checksum that gives you a good
                idea of when the task's data changes.
            </para>

            <para>
                To complicate the problem, there are things that should not be
                included in the checksum.
                First, there is the actual specific build path of a given
                task - the
                <ulink url='&YOCTO_DOCS_REF_URL;#var-WORKDIR'><filename>WORKDIR</filename></ulink>.
                It does not matter if the work directory changes because it
                should not affect the output for target packages.
                Also, the build process has the objective of making native
                or cross packages relocatable.
                <note>
                    Both native and cross packages run on the build host.
                    However, cross packages generate output for the target
                    architecture.
                </note>
                The checksum therefore needs to exclude
                <filename>WORKDIR</filename>.
                The simplistic approach for excluding the work directory is to
                set <filename>WORKDIR</filename> to some fixed value and
                create the checksum for the "run" script.
            </para>

            <para>
                Another problem results from the "run" scripts containing
                functions that might or might not get called.
                The incremental build solution contains code that figures out
                dependencies between shell functions.
                This code is used to prune the "run" scripts down to the
                minimum set, thereby alleviating this problem and making the
                "run" scripts much more readable as a bonus.
            </para>

            <para>
                So far we have solutions for shell scripts.
                What about Python tasks?
                The same approach applies even though these tasks are more
                difficult.
                The process needs to figure out what variables a Python
                function accesses and what functions it calls.
                Again, the incremental build solution contains code that first
                figures out the variable and function dependencies, and then
                creates a checksum for the data used as the input to the task.
            </para>

            <para>
                Like the <filename>WORKDIR</filename> case, situations exist
                where dependencies should be ignored.
                For these cases, you can instruct the build process to
                ignore a dependency by using a line like the following:
                <literallayout class='monospaced'>
     PACKAGE_ARCHS[vardepsexclude] = "MACHINE"
                </literallayout>
                This example ensures that the
                <ulink url='&YOCTO_DOCS_REF_URL;#var-PACKAGE_ARCHS'><filename>PACKAGE_ARCHS</filename></ulink>
                variable does not depend on the value of
                <ulink url='&YOCTO_DOCS_REF_URL;#var-MACHINE'><filename>MACHINE</filename></ulink>,
                even if it does reference it.
            </para>

            <para>
                Equally, there are cases where we need to add dependencies
                BitBake is not able to find.
                You can accomplish this by using a line like the following:
                <literallayout class='monospaced'>
      PACKAGE_ARCHS[vardeps] = "MACHINE"
                </literallayout>
                This example explicitly adds the <filename>MACHINE</filename>
                variable as a dependency for
                <filename>PACKAGE_ARCHS</filename>.
            </para>

            <para>
                Consider a case with in-line Python, for example, where
                BitBake is not able to figure out dependencies.
                When running in debug mode (i.e. using
                <filename>-DDD</filename>), BitBake produces output when it
                discovers something for which it cannot figure out dependencies.
                The Yocto Project team has currently not managed to cover
                those dependencies in detail and is aware of the need to fix
                this situation.
            </para>

            <para>
                Thus far, this section has limited discussion to the direct
                inputs into a task.
                Information based on direct inputs is referred to as the
                "basehash" in the code.
                However, there is still the question of a task's indirect
                inputs - the things that were already built and present in the
                <ulink url='&YOCTO_DOCS_REF_URL;#build-directory'>Build Directory</ulink>.
                The checksum (or signature) for a particular task needs to add
                the hashes of all the tasks on which the particular task
                depends.
                Choosing which dependencies to add is a policy decision.
                However, the effect is to generate a master checksum that
                combines the basehash and the hashes of the task's
                dependencies.
            </para>

            <para>
                At the code level, there are a variety of ways both the
                basehash and the dependent task hashes can be influenced.
                Within the BitBake configuration file, we can give BitBake
                some extra information to help it construct the basehash.
                The following statement effectively results in a list of
                global variable dependency excludes - variables never
                included in any checksum:
                <literallayout class='monospaced'>
     BB_HASHBASE_WHITELIST ?= "TMPDIR FILE PATH PWD BB_TASKHASH BBPATH DL_DIR \
         SSTATE_DIR THISDIR FILESEXTRAPATHS FILE_DIRNAME HOME LOGNAME SHELL TERM \
         USER FILESPATH STAGING_DIR_HOST STAGING_DIR_TARGET COREBASE PRSERV_HOST \
         PRSERV_DUMPDIR PRSERV_DUMPFILE PRSERV_LOCKDOWN PARALLEL_MAKE \
         CCACHE_DIR EXTERNAL_TOOLCHAIN CCACHE CCACHE_DISABLE LICENSE_PATH SDKPKGSUFFIX"
                </literallayout>
                The previous example excludes
                <ulink url='&YOCTO_DOCS_REF_URL;#var-WORKDIR'><filename>WORKDIR</filename></ulink>
                since that variable is actually constructed as a path within
                <ulink url='&YOCTO_DOCS_REF_URL;#var-TMPDIR'><filename>TMPDIR</filename></ulink>,
                which is on the whitelist.
            </para>

            <para>
                The rules for deciding which hashes of dependent tasks to
                include through dependency chains are more complex and are
                generally accomplished with a Python function.
                The code in <filename>meta/lib/oe/sstatesig.py</filename> shows
                two examples of this and also illustrates how you can insert
                your own policy into the system if so desired.
                This file defines the two basic signature generators
                <ulink url='&YOCTO_DOCS_REF_URL;#oe-core'>OE-Core</ulink>
                uses:  "OEBasic" and "OEBasicHash".
                By default, there is a dummy "noop" signature handler enabled
                in BitBake.
                This means that behavior is unchanged from previous versions.
                OE-Core uses the "OEBasicHash" signature handler by default
                through this setting in the <filename>bitbake.conf</filename>
                file:
                <literallayout class='monospaced'>
     BB_SIGNATURE_HANDLER ?= "OEBasicHash"
                </literallayout>
                The "OEBasicHash" <filename>BB_SIGNATURE_HANDLER</filename>
                is the same as the "OEBasic" version but adds the task hash to
                the stamp files.
                This results in any
                <ulink url='&YOCTO_DOCS_REF_URL;#metadata'>Metadata</ulink>
                change that changes the task hash, automatically
                causing the task to be run again.
                This removes the need to bump
                <ulink url='&YOCTO_DOCS_REF_URL;#var-PR'><filename>PR</filename></ulink>
                values, and changes to Metadata automatically ripple across
                the build.
            </para>

            <para>
                It is also worth noting that the end result of these
                signature generators is to make some dependency and hash
                information available to the build.
                This information includes:
                <itemizedlist>
                    <listitem><para>
                        <filename>BB_BASEHASH_task-</filename><replaceable>taskname</replaceable>:
                        The base hashes for each task in the recipe.
                        </para></listitem>
                    <listitem><para>
                        <filename>BB_BASEHASH_</filename><replaceable>filename</replaceable><filename>:</filename><replaceable>taskname</replaceable>:
                        The base hashes for each dependent task.
                        </para></listitem>
                    <listitem><para>
                        <filename>BBHASHDEPS_</filename><replaceable>filename</replaceable><filename>:</filename><replaceable>taskname</replaceable>:
                        The task dependencies for each task.
                        </para></listitem>
                    <listitem><para>
                        <filename>BB_TASKHASH</filename>:
                        The hash of the currently running task.
                        </para></listitem>
                </itemizedlist>
            </para>
        </section>

        <section id='shared-state'>
            <title>Shared State</title>

            <para>
                Checksums and dependencies, as discussed in the previous
                section, solve half the problem of supporting a shared state.
                The other part of the problem is being able to use checksum
                information during the build and being able to reuse or rebuild
                specific components.
            </para>

            <para>
                The
                <ulink url='&YOCTO_DOCS_REF_URL;#ref-classes-sstate'><filename>sstate</filename></ulink>
                class is a relatively generic implementation of how to
                "capture" a snapshot of a given task.
                The idea is that the build process does not care about the
                source of a task's output.
                Output could be freshly built or it could be downloaded and
                unpacked from somewhere - the build process does not need to
                worry about its origin.
            </para>

            <para>
                There are two types of output, one is just about creating a
                directory in
                <ulink url='&YOCTO_DOCS_REF_URL;#var-WORKDIR'><filename>WORKDIR</filename></ulink>.
                A good example is the output of either
                <ulink url='&YOCTO_DOCS_REF_URL;#ref-tasks-install'><filename>do_install</filename></ulink>
                or
                <ulink url='&YOCTO_DOCS_REF_URL;#ref-tasks-package'><filename>do_package</filename></ulink>.
                The other type of output occurs when a set of data is merged
                into a shared directory tree such as the sysroot.
            </para>

            <para>
                The Yocto Project team has tried to keep the details of the
                implementation hidden in <filename>sstate</filename> class.
                From a user's perspective, adding shared state wrapping to a task
                is as simple as this
                <ulink url='&YOCTO_DOCS_REF_URL;#ref-tasks-deploy'><filename>do_deploy</filename></ulink>
                example taken from the
                <ulink url='&YOCTO_DOCS_REF_URL;#ref-classes-deploy'><filename>deploy</filename></ulink>
                class:
                <literallayout class='monospaced'>
     DEPLOYDIR = "${WORKDIR}/deploy-${PN}"
     SSTATETASKS += "do_deploy"
     do_deploy[sstate-inputdirs] = "${DEPLOYDIR}"
     do_deploy[sstate-outputdirs] = "${DEPLOY_DIR_IMAGE}"

     python do_deploy_setscene () {
         sstate_setscene(d)
     }
     addtask do_deploy_setscene
     do_deploy[dirs] = "${DEPLOYDIR} ${B}"
                </literallayout>
                The following list explains the previous example:
                <itemizedlist>
                    <listitem><para>
                        Adding "do_deploy" to <filename>SSTATETASKS</filename>
                        adds some required sstate-related processing, which is
                        implemented in the
                        <ulink url='&YOCTO_DOCS_REF_URL;#ref-classes-sstate'><filename>sstate</filename></ulink>
                        class, to before and after the
                        <ulink url='&YOCTO_DOCS_REF_URL;#ref-tasks-deploy'><filename>do_deploy</filename></ulink>
                        task.
                        </para></listitem>
                    <listitem><para>
                        The
                        <filename>do_deploy[sstate-inputdirs] = "${DEPLOYDIR}"</filename>
                        declares that <filename>do_deploy</filename> places its
                        output in <filename>${DEPLOYDIR}</filename> when run
                        normally (i.e. when not using the sstate cache).
                        This output becomes the input to the shared state cache.
                        </para></listitem>
                    <listitem><para>
                        The
                        <filename>do_deploy[sstate-outputdirs] = "${DEPLOY_DIR_IMAGE}"</filename>
                        line causes the contents of the shared state cache to be
                        copied to <filename>${DEPLOY_DIR_IMAGE}</filename>.
                        <note>
                            If <filename>do_deploy</filename> is not already in
                            the shared state cache or if its input checksum
                            (signature) has changed from when the output was
                            cached, the task will be run to populate the shared
                            state cache, after which the contents of the shared
                            state cache is copied to
                            <filename>${DEPLOY_DIR_IMAGE}</filename>.
                            If <filename>do_deploy</filename> is in the shared
                            state cache and its signature indicates that the
                            cached output is still valid (i.e. if no
                            relevant task inputs have changed), then the
                            contents of the shared state cache will be copied
                            directly to
                            <filename>${DEPLOY_DIR_IMAGE}</filename> by the
                            <filename>do_deploy_setscene</filename> task
                            instead, skipping the
                            <filename>do_deploy</filename> task.
                        </note>
                        </para></listitem>
                    <listitem><para>
                        The following task definition is glue logic needed to
                        make the previous settings effective:
                        <literallayout class='monospaced'>
     python do_deploy_setscene () {
         sstate_setscene(d)
     }
     addtask do_deploy_setscene
                        </literallayout>
                        <filename>sstate_setscene()</filename> takes the flags
                        above as input and accelerates the
                        <filename>do_deploy</filename> task through the
                        shared state cache if possible.
                        If the task was accelerated,
                        <filename>sstate_setscene()</filename> returns True.
                        Otherwise, it returns False, and the normal
                        <filename>do_deploy</filename> task runs.
                        For more information, see the
                        "<ulink url='&YOCTO_DOCS_BB_URL;#setscene'>setscene</ulink>"
                        section in the BitBake User Manual.
                        </para></listitem>
                    <listitem><para>
                        The <filename>do_deploy[dirs] = "${DEPLOYDIR} ${B}"</filename>
                        line creates <filename>${DEPLOYDIR}</filename> and
                        <filename>${B}</filename> before the
                        <filename>do_deploy</filename> task runs, and also sets
                        the current working directory of
                        <filename>do_deploy</filename> to
                        <filename>${B}</filename>.
                        For more information, see the
                        "<ulink url='&YOCTO_DOCS_BB_URL;#variable-flags'>Variable Flags</ulink>"
                        section in the BitBake User Manual.
                        <note>
                            In cases where
                            <filename>sstate-inputdirs</filename> and
                            <filename>sstate-outputdirs</filename> would be the
                            same, you can use
                            <filename>sstate-plaindirs</filename>.
                            For example, to preserve the
                            <filename>${PKGD}</filename> and
                            <filename>${PKGDEST}</filename> output from the
                            <ulink url='&YOCTO_DOCS_REF_URL;#ref-tasks-package'><filename>do_package</filename></ulink>
                            task, use the following:
                            <literallayout class='monospaced'>
     do_package[sstate-plaindirs] = "${PKGD} ${PKGDEST}"
                            </literallayout>
                        </note>
                        </para></listitem>
                    <listitem><para>
                        <filename>sstate-inputdirs</filename> and
                        <filename>sstate-outputdirs</filename> can also be used
                        with multiple directories.
                        For example, the following declares
                        <filename>PKGDESTWORK</filename> and
                        <filename>SHLIBWORK</filename> as shared state
                        input directories, which populates the shared state
                        cache, and <filename>PKGDATA_DIR</filename> and
                        <filename>SHLIBSDIR</filename> as the corresponding
                        shared state output directories:
                        <literallayout class='monospaced'>
     do_package[sstate-inputdirs] = "${PKGDESTWORK} ${SHLIBSWORKDIR}"
     do_package[sstate-outputdirs] = "${PKGDATA_DIR} ${SHLIBSDIR}"
                        </literallayout>
                        </para></listitem>
                    <listitem><para>
                        These methods also include the ability to take a
                        lockfile when manipulating shared state directory
                        structures, for cases where file additions or removals
                        are sensitive:
                        <literallayout class='monospaced'>
     do_package[sstate-lockfile] = "${PACKAGELOCK}"
                        </literallayout>
                        </para></listitem>
                </itemizedlist>
            </para>

            <para>
                Behind the scenes, the shared state code works by looking in
                <ulink url='&YOCTO_DOCS_REF_URL;#var-SSTATE_DIR'><filename>SSTATE_DIR</filename></ulink>
                and
                <ulink url='&YOCTO_DOCS_REF_URL;#var-SSTATE_MIRRORS'><filename>SSTATE_MIRRORS</filename></ulink>
                for shared state files.
                Here is an example:
                <literallayout class='monospaced'>
     SSTATE_MIRRORS ?= "\
     file://.* http://someserver.tld/share/sstate/PATH;downloadfilename=PATH \n \
     file://.* file:///some/local/dir/sstate/PATH"
                </literallayout>
                <note>
                    The shared state directory
                    (<filename>SSTATE_DIR</filename>) is organized into
                    two-character subdirectories, where the subdirectory
                    names are based on the first two characters of the hash.
                    If the shared state directory structure for a mirror has the
                    same structure as <filename>SSTATE_DIR</filename>, you must
                    specify "PATH" as part of the URI to enable the build system
                    to map to the appropriate subdirectory.
                </note>
            </para>

            <para>
                The shared state package validity can be detected just by
                looking at the filename since the filename contains the task
                checksum (or signature) as described earlier in this section.
                If a valid shared state package is found, the build process
                downloads it and uses it to accelerate the task.
            </para>

            <para>
                The build processes use the <filename>*_setscene</filename>
                tasks for the task acceleration phase.
                BitBake goes through this phase before the main execution
                code and tries to accelerate any tasks for which it can find
                shared state packages.
                If a shared state package for a task is available, the
                shared state package is used.
                This means the task and any tasks on which it is dependent
                are not executed.
            </para>

            <para>
                As a real world example, the aim is when building an IPK-based
                image, only the
                <ulink url='&YOCTO_DOCS_REF_URL;#ref-tasks-package_write_ipk'><filename>do_package_write_ipk</filename></ulink>
                tasks would have their shared state packages fetched and
                extracted.
                Since the sysroot is not used, it would never get extracted.
                This is another reason why a task-based approach is preferred
                over a recipe-based approach, which would have to install the
                output from every task.
            </para>
        </section>

        <section id='tips-and-tricks'>
            <title>Tips and Tricks</title>

            <para>
                The code in the build system that supports incremental builds
                is not simple code.
                This section presents some tips and tricks that help you work
                around issues related to shared state code.
            </para>

            <section id='overview-debugging'>
                <title>Debugging</title>

                <para>
                    Seeing what metadata went into creating the input signature
                    of a shared state (sstate) task can be a useful debugging
                    aid.
                    This information is available in signature information
                    (<filename>siginfo</filename>) files in
                    <ulink url='&YOCTO_DOCS_REF_URL;#var-SSTATE_DIR'><filename>SSTATE_DIR</filename></ulink>.
                    For information on how to view and interpret information in
                    <filename>siginfo</filename> files, see the
                    "<ulink url='&YOCTO_DOCS_REF_URL;#usingpoky-viewing-task-variable-dependencies'>Viewing Task Variable Dependencies</ulink>"
                    section in the Yocto Project Reference Manual.
                </para>
            </section>

            <section id='invalidating-shared-state'>
                <title>Invalidating Shared State</title>

                <para>
                    The OpenEmbedded build system uses checksums and shared
                    state cache to avoid unnecessarily rebuilding tasks.
                    Collectively, this scheme is known as "shared state code."
                </para>

                <para>
                    As with all schemes, this one has some drawbacks.
                    It is possible that you could make implicit changes to your
                    code that the checksum calculations do not take into
                    account.
                    These implicit changes affect a task's output but do not
                    trigger the shared state code into rebuilding a recipe.
                    Consider an example during which a tool changes its output.
                    Assume that the output of <filename>rpmdeps</filename>
                    changes.
                    The result of the change should be that all the
                    <filename>package</filename> and
                    <filename>package_write_rpm</filename> shared state cache
                    items become invalid.
                    However, because the change to the output is
                    external to the code and therefore implicit,
                    the associated shared state cache items do not become
                    invalidated.
                    In this case, the build process uses the cached items
                    rather than running the task again.
                    Obviously, these types of implicit changes can cause
                    problems.
                </para>

                <para>
                    To avoid these problems during the build, you need to
                    understand the effects of any changes you make.
                    Realize that changes you make directly to a function
                    are automatically factored into the checksum calculation.
                    Thus, these explicit changes invalidate the associated
                    area of shared state cache.
                    However, you need to be aware of any implicit changes that
                    are not obvious changes to the code and could affect
                    the output of a given task.
                </para>

                <para>
                    When you identify an implicit change, you can easily
                    take steps to invalidate the cache and force the tasks
                    to run.
                    The steps you can take are as simple as changing a
                    function's comments in the source code.
                    For example, to invalidate package shared state files,
                    change the comment statements of
                    <ulink url='&YOCTO_DOCS_REF_URL;#ref-tasks-package'><filename>do_package</filename></ulink>
                    or the comments of one of the functions it calls.
                    Even though the change is purely cosmetic, it causes the
                    checksum to be recalculated and forces the OpenEmbedded
                    build system to run the task again.
                    <note>
                        For an example of a commit that makes a cosmetic
                        change to invalidate shared state, see this
                        <ulink url='&YOCTO_GIT_URL;/cgit.cgi/poky/commit/meta/classes/package.bbclass?id=737f8bbb4f27b4837047cb9b4fbfe01dfde36d54'>commit</ulink>.
                    </note>
                </para>
            </section>
        </section>
    </section>

    <section id='automatically-added-runtime-dependencies'>
        <title>Automatically Added Runtime Dependencies</title>

        <para>
            The OpenEmbedded build system automatically adds common types of
            runtime dependencies between packages, which means that you do not
            need to explicitly declare the packages using
            <ulink url='&YOCTO_DOCS_REF_URL;#var-RDEPENDS'><filename>RDEPENDS</filename></ulink>.
            Three automatic mechanisms exist (<filename>shlibdeps</filename>,
            <filename>pcdeps</filename>, and <filename>depchains</filename>)
            that handle shared libraries, package configuration (pkg-config)
            modules, and <filename>-dev</filename> and
            <filename>-dbg</filename> packages, respectively.
            For other types of runtime dependencies, you must manually declare
            the dependencies.
            <itemizedlist>
                <listitem><para>
                    <filename>shlibdeps</filename>:
                    During the
                    <ulink url='&YOCTO_DOCS_REF_URL;#ref-tasks-package'><filename>do_package</filename></ulink>
                    task of each recipe, all shared libraries installed by the
                    recipe are located.
                    For each shared library, the package that contains the
                    shared library is registered as providing the shared
                    library.
                    More specifically, the package is registered as providing
                    the
                    <ulink url='https://en.wikipedia.org/wiki/Soname'>soname</ulink>
                    of the library.
                    The resulting shared-library-to-package mapping
                    is saved globally in
                    <ulink url='&YOCTO_DOCS_REF_URL;#var-PKGDATA_DIR'><filename>PKGDATA_DIR</filename></ulink>
                    by the
                    <ulink url='&YOCTO_DOCS_REF_URL;#ref-tasks-packagedata'><filename>do_packagedata</filename></ulink>
                    task.</para>

                    <para>Simultaneously, all executables and shared libraries
                    installed by the recipe are inspected to see what shared
                    libraries they link against.
                    For each shared library dependency that is found,
                    <filename>PKGDATA_DIR</filename> is queried to
                    see if some package (likely from a different recipe)
                    contains the shared library.
                    If such a package is found, a runtime dependency is added
                    from the package that depends on the shared library to the
                    package that contains the library.</para>

                    <para>The automatically added runtime dependency also
                    includes a version restriction.
                    This version restriction specifies that at least the
                    current version of the package that provides the shared
                    library must be used, as if
                    "<replaceable>package</replaceable> (>= <replaceable>version</replaceable>)"
                    had been added to
                    <ulink url='&YOCTO_DOCS_REF_URL;#var-RDEPENDS'><filename>RDEPENDS</filename></ulink>.
                    This forces an upgrade of the package containing the shared
                    library when installing the package that depends on the
                    library, if needed.</para>

                    <para>If you want to avoid a package being registered as
                    providing a particular shared library (e.g. because the library
                    is for internal use only), then add the library to
                    <ulink url='&YOCTO_DOCS_REF_URL;#var-PRIVATE_LIBS'><filename>PRIVATE_LIBS</filename></ulink>
                    inside the package's recipe.
                    </para></listitem>
                <listitem><para>
                    <filename>pcdeps</filename>:
                    During the
                    <ulink url='&YOCTO_DOCS_REF_URL;#ref-tasks-package'><filename>do_package</filename></ulink>
                    task of each recipe, all pkg-config modules
                    (<filename>*.pc</filename> files) installed by the recipe
                    are located.
                    For each module, the package that contains the module is
                    registered as providing the module.
                    The resulting module-to-package mapping is saved globally in
                    <ulink url='&YOCTO_DOCS_REF_URL;#var-PKGDATA_DIR'><filename>PKGDATA_DIR</filename></ulink>
                    by the
                    <ulink url='&YOCTO_DOCS_REF_URL;#ref-tasks-packagedata'><filename>do_packagedata</filename></ulink>
                    task.</para>

                    <para>Simultaneously, all pkg-config modules installed by
                    the recipe are inspected to see what other pkg-config
                    modules they depend on.
                    A module is seen as depending on another module if it
                    contains a "Requires:" line that specifies the other module.
                    For each module dependency,
                    <filename>PKGDATA_DIR</filename> is queried to see if some
                    package contains the module.
                    If such a package is found, a runtime dependency is added
                    from the package that depends on the module to the package
                    that contains the module.
                    <note>
                        The <filename>pcdeps</filename> mechanism most often
                        infers dependencies between <filename>-dev</filename>
                        packages.
                    </note>
                    </para></listitem>
                <listitem><para>
                    <filename>depchains</filename>:
                    If a package <filename>foo</filename> depends on a package
                    <filename>bar</filename>, then <filename>foo-dev</filename>
                    and <filename>foo-dbg</filename> are also made to depend on
                    <filename>bar-dev</filename> and
                    <filename>bar-dbg</filename>, respectively.
                    Taking the <filename>-dev</filename> packages as an
                    example, the <filename>bar-dev</filename> package might
                    provide headers and shared library symlinks needed by
                    <filename>foo-dev</filename>, which shows the need
                    for a dependency between the packages.</para>

                    <para>The dependencies added by
                    <filename>depchains</filename> are in the form of
                    <ulink url='&YOCTO_DOCS_REF_URL;#var-RRECOMMENDS'><filename>RRECOMMENDS</filename></ulink>.
                    <note>
                        By default, <filename>foo-dev</filename> also has an
                        <filename>RDEPENDS</filename>-style dependency on
                        <filename>foo</filename>, because the default value of
                        <filename>RDEPENDS_${PN}-dev</filename> (set in
                        <filename>bitbake.conf</filename>) includes
                        "${PN}".
                    </note></para>

                    <para>To ensure that the dependency chain is never broken,
                    <filename>-dev</filename> and <filename>-dbg</filename>
                    packages are always generated by default, even if the
                    packages turn out to be empty.
                    See the
                    <ulink url='&YOCTO_DOCS_REF_URL;#var-ALLOW_EMPTY'><filename>ALLOW_EMPTY</filename></ulink>
                    variable for more information.
                    </para></listitem>
            </itemizedlist>
        </para>

        <para>
            The <filename>do_package</filename> task depends on the
            <ulink url='&YOCTO_DOCS_REF_URL;#ref-tasks-packagedata'><filename>do_packagedata</filename></ulink>
            task of each recipe in
            <ulink url='&YOCTO_DOCS_REF_URL;#var-DEPENDS'><filename>DEPENDS</filename></ulink>
            through use of a
            <filename>[</filename><ulink url='&YOCTO_DOCS_BB_URL;#variable-flags'><filename>deptask</filename></ulink><filename>]</filename>
            declaration, which guarantees that the required
            shared-library/module-to-package mapping information will be available
            when needed as long as <filename>DEPENDS</filename> has been
            correctly set.
        </para>
    </section>

    <section id='fakeroot-and-pseudo'>
        <title>Fakeroot and Pseudo</title>

        <para>
            Some tasks are easier to implement when allowed to perform certain
            operations that are normally reserved for the root user.
            For example, the
            <ulink url='&YOCTO_DOCS_REF_URL;#ref-tasks-install'><filename>do_install</filename></ulink>
            task benefits from being able to set the UID and GID of installed
            files to arbitrary values.
        </para>

        <para>
            One approach to allowing tasks to perform root-only operations
            would be to require BitBake to run as root.
            However, this method is cumbersome and has security issues.
            The approach that is actually used is to run tasks that benefit
            from root privileges in a "fake" root environment.
            Within this environment, the task and its child processes believe
            that they are running as the root user, and see an internally
            consistent view of the filesystem.
            As long as generating the final output (e.g. a package or an image)
            does not require root privileges, the fact that some earlier
            steps ran in a fake root environment does not cause problems.
        </para>

        <para>
            The capability to run tasks in a fake root environment is known as
            "fakeroot", which is derived from the BitBake keyword/variable
            flag that requests a fake root environment for a task.
            In current versions of the OpenEmbedded build system,
            the program that implements fakeroot is known as Pseudo.
        </para>

        <para>
            Pseudo overrides system calls through the
            <filename>LD_PRELOAD</filename> mechanism to give the
            illusion of running as root.
            To keep track of "fake" file ownership and permissions resulting
            from operations that require root permissions, an sqlite3
            database is used.
            This database is stored in
            <filename>${</filename><ulink url='&YOCTO_DOCS_REF_URL;#var-WORKDIR'><filename>WORKDIR</filename></ulink><filename>}/pseudo/files.db</filename>
            for individual recipes.
            Storing the database in a file as opposed to in memory
            gives persistence between tasks, and even between builds.
            <note><title>Caution</title>
                If you add your own task that manipulates the same files or
                directories as a fakeroot task, then that task should also run
                under fakeroot.
                Otherwise, the task will not be able to run root-only
                operations, and will not see the fake file ownership and
                permissions set by the other task.
                You should also add a dependency on
                <filename>virtual/fakeroot-native:do_populate_sysroot</filename>,
                giving the following:
                <literallayout class='monospaced'>
       fakeroot do_mytask () {
           ...
       }
       do_mytask[depends] += "virtual/fakeroot-native:do_populate_sysroot"
                </literallayout>
            </note>
            For more information, see the
            <ulink url='&YOCTO_DOCS_BB_URL;#var-FAKEROOT'><filename>FAKEROOT*</filename></ulink>
            variables in the BitBake User Manual.
            You can also reference this
            <ulink url='http://www.ibm.com/developerworks/opensource/library/os-aapseudo1/index.html'>Pseudo</ulink>
            article.
        </para>
    </section>

    <section id="wayland">
        <title>Wayland</title>

        <para>
            <ulink url='http://en.wikipedia.org/wiki/Wayland_(display_server_protocol)'>Wayland</ulink>
            is a computer display server protocol that
            provides a method for compositing window managers to communicate
            directly with applications and video hardware and expects them to
            communicate with input hardware using other libraries.
            Using Wayland with supporting targets can result in better control
            over graphics frame rendering than an application might otherwise
            achieve.
        </para>

        <para>
            The Yocto Project provides the Wayland protocol libraries and the
            reference
            <ulink url='http://en.wikipedia.org/wiki/Wayland_(display_server_protocol)#Weston'>Weston</ulink>
            compositor as part of its release.
            This section describes what you need to do to implement Wayland and
            use the compositor when building an image for a supporting target.
        </para>

        <section id="wayland-support">
            <title>Support</title>

            <para>
                The Wayland protocol libraries and the reference Weston
                compositor ship as integrated packages in the
                <filename>meta</filename> layer of the
                <ulink url='&YOCTO_DOCS_REF_URL;#source-directory'>Source Directory</ulink>.
                Specifically, you can find the recipes that build both Wayland
                and Weston at
                <filename>meta/recipes-graphics/wayland</filename>.
            </para>

            <para>
                You can build both the Wayland and Weston packages for use only
                with targets that accept the
                <ulink url='https://en.wikipedia.org/wiki/Mesa_(computer_graphics)'>Mesa 3D and Direct Rendering Infrastructure</ulink>,
                which is also known as Mesa DRI.
                This implies that you cannot build and use the packages if your
                target uses, for example, the
                <trademark class='registered'>Intel</trademark> Embedded Media
                and Graphics Driver
                (<trademark class='registered'>Intel</trademark> EMGD) that
                overrides Mesa DRI.
                <note>
                    Due to lack of EGL support, Weston 1.0.3 will not run
                    directly on the emulated QEMU hardware.
                    However, this version of Weston will run under X emulation
                    without issues.
                </note>
            </para>
        </section>

        <section id="enabling-wayland-in-an-image">
            <title>Enabling Wayland in an Image</title>

            <para>
                To enable Wayland, you need to enable it to be built and enable
                it to be included in the image.
            </para>

            <section id="enable-building">
                <title>Building</title>

                <para>
                    To cause Mesa to build the <filename>wayland-egl</filename>
                    platform and Weston to build Wayland with Kernel Mode
                    Setting
                    (<ulink url='https://wiki.archlinux.org/index.php/Kernel_Mode_Setting'>KMS</ulink>)
                    support, include the "wayland" flag in the
                    <ulink url="&YOCTO_DOCS_REF_URL;#var-DISTRO_FEATURES"><filename>DISTRO_FEATURES</filename></ulink>
                    statement in your <filename>local.conf</filename> file:
                    <literallayout class='monospaced'>
     DISTRO_FEATURES_append = " wayland"
                    </literallayout>
                    <note>
                        If X11 has been enabled elsewhere, Weston will build
                        Wayland with X11 support
                    </note>
                </para>
            </section>

            <section id="enable-installation-in-an-image">
                <title>Installing</title>

                <para>
                    To install the Wayland feature into an image, you must
                    include the following
                    <ulink url='&YOCTO_DOCS_REF_URL;#var-CORE_IMAGE_EXTRA_INSTALL'><filename>CORE_IMAGE_EXTRA_INSTALL</filename></ulink>
                    statement in your <filename>local.conf</filename> file:
                    <literallayout class='monospaced'>
     CORE_IMAGE_EXTRA_INSTALL += "wayland weston"
                    </literallayout>
                </para>
            </section>
        </section>

        <section id="running-weston">
            <title>Running Weston</title>

            <para>
                To run Weston inside X11, enabling it as described earlier and
                building a Sato image is sufficient.
                If you are running your image under Sato, a Weston Launcher
                appears in the "Utility" category.
            </para>

            <para>
                Alternatively, you can run Weston through the command-line
                interpretor (CLI), which is better suited for development work.
                To run Weston under the CLI, you need to do the following after
                your image is built:
                <orderedlist>
                    <listitem><para>
                        Run these commands to export
                        <filename>XDG_RUNTIME_DIR</filename>:
                        <literallayout class='monospaced'>
     mkdir -p /tmp/$USER-weston
     chmod 0700 /tmp/$USER-weston
     export XDG_RUNTIME_DIR=/tmp/$USER-weston
                        </literallayout>
                        </para></listitem>
                    <listitem><para>
                        Launch Weston in the shell:
                        <literallayout class='monospaced'>
     weston
                        </literallayout></para></listitem>
                </orderedlist>
            </para>
        </section>
    </section>

    <section id='x32'>
        <title>x32 psABI</title>

        <para>
            x32 processor-specific Application Binary Interface
            (<ulink url='https://software.intel.com/en-us/node/628948'>x32 psABI</ulink>)
            is a native 32-bit processor-specific ABI for
            <trademark class='registered'>Intel</trademark> 64 (x86-64)
            architectures.
            An ABI defines the calling conventions between functions in a
            processing environment.
            The interface determines what registers are used and what the sizes are
            for various C data types.
        </para>

        <para>
            Some processing environments prefer using 32-bit applications even
            when running on Intel 64-bit platforms.
            Consider the i386 psABI, which is a very old 32-bit ABI for Intel
            64-bit platforms.
            The i386 psABI does not provide efficient use and access of the
            Intel 64-bit processor resources, leaving the system underutilized.
            Now consider the x86_64 psABI.
            This ABI is newer and uses 64-bits for data sizes and program
            pointers.
            The extra bits increase the footprint size of the programs,
            libraries, and also increases the memory and file system size
            requirements.
            Executing under the x32 psABI enables user programs to utilize CPU
            and system resources more efficiently while keeping the memory
            footprint of the applications low.
            Extra bits are used for registers but not for addressing mechanisms.
        </para>

        <para>
            The Yocto Project supports the final specifications of x32 psABI
            as follows:
            <itemizedlist>
                <listitem><para>
                    You can create packages and images in x32 psABI format on
                    x86_64 architecture targets.
                    </para></listitem>
                <listitem><para>
                    You can successfully build recipes with the x32 toolchain.
                    </para></listitem>
                <listitem><para>
                    You can create and boot
                    <filename>core-image-minimal</filename> and
                    <filename>core-image-sato</filename> images.
                    </para></listitem>
                <listitem><para>
                    RPM Package Manager (RPM) support exists for x32 binaries.
                    </para></listitem>
                <listitem><para>
                    Support for large images exists.
                    </para></listitem>
            </itemizedlist>
        </para>

        <para>
            For steps on how to use x32 psABI, see the
            "<ulink url='&YOCTO_DOCS_DEV_URL;#using-x32-psabi'>Using x32 psABI</ulink>"
            section in the Yocto Project Development Tasks Manual.
        </para>
    </section>
</chapter>
<!--
vim: expandtab tw=80 ts=4
-->